1 /*
2 * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/absolute_capture_time_sender.h"
12
13 #include "system_wrappers/include/ntp_time.h"
14 #include "test/gmock.h"
15 #include "test/gtest.h"
16
17 namespace webrtc {
18
TEST(AbsoluteCaptureTimeSenderTest,GetSourceWithoutCsrcs)19 TEST(AbsoluteCaptureTimeSenderTest, GetSourceWithoutCsrcs) {
20 constexpr uint32_t kSsrc = 12;
21
22 EXPECT_EQ(AbsoluteCaptureTimeSender::GetSource(kSsrc, nullptr), kSsrc);
23 }
24
TEST(AbsoluteCaptureTimeSenderTest,GetSourceWithCsrcs)25 TEST(AbsoluteCaptureTimeSenderTest, GetSourceWithCsrcs) {
26 constexpr uint32_t kSsrc = 12;
27 constexpr uint32_t kCsrcs[] = {34, 56, 78, 90};
28
29 EXPECT_EQ(AbsoluteCaptureTimeSender::GetSource(kSsrc, kCsrcs), kCsrcs[0]);
30 }
31
TEST(AbsoluteCaptureTimeSenderTest,InterpolateLaterPacketSentLater)32 TEST(AbsoluteCaptureTimeSenderTest, InterpolateLaterPacketSentLater) {
33 constexpr uint32_t kSource = 1337;
34 constexpr uint32_t kRtpClockFrequency = 64000;
35 constexpr uint32_t kRtpTimestamp0 = 1020300000;
36 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
37 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
38 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
39 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
40 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
41 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
42 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
43 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
44 SimulatedClock clock(0);
45 AbsoluteCaptureTimeSender sender(&clock);
46
47 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
48 kExtension0->absolute_capture_timestamp,
49 kExtension0->estimated_capture_clock_offset),
50 kExtension0);
51
52 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
53 kExtension1->absolute_capture_timestamp,
54 kExtension1->estimated_capture_clock_offset),
55 absl::nullopt);
56
57 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
58 kExtension2->absolute_capture_timestamp,
59 kExtension2->estimated_capture_clock_offset),
60 absl::nullopt);
61 }
62
TEST(AbsoluteCaptureTimeSenderTest,InterpolateEarlierPacketSentLater)63 TEST(AbsoluteCaptureTimeSenderTest, InterpolateEarlierPacketSentLater) {
64 constexpr uint32_t kSource = 1337;
65 constexpr uint32_t kRtpClockFrequency = 64000;
66 constexpr uint32_t kRtpTimestamp0 = 1020300000;
67 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 - 1280;
68 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 - 2560;
69 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
70 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
71 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
72 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 - 20), Int64MsToQ32x32(-350)};
73 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
74 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 - 40), Int64MsToQ32x32(-350)};
75
76 SimulatedClock clock(0);
77 AbsoluteCaptureTimeSender sender(&clock);
78
79 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
80 kExtension0->absolute_capture_timestamp,
81 kExtension0->estimated_capture_clock_offset),
82 kExtension0);
83
84 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
85 kExtension1->absolute_capture_timestamp,
86 kExtension1->estimated_capture_clock_offset),
87 absl::nullopt);
88
89 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
90 kExtension2->absolute_capture_timestamp,
91 kExtension2->estimated_capture_clock_offset),
92 absl::nullopt);
93 }
94
TEST(AbsoluteCaptureTimeSenderTest,InterpolateLaterPacketSentLaterWithRtpTimestampWrapAround)95 TEST(AbsoluteCaptureTimeSenderTest,
96 InterpolateLaterPacketSentLaterWithRtpTimestampWrapAround) {
97 constexpr uint32_t kSource = 1337;
98 constexpr uint32_t kRtpClockFrequency = 64000;
99 constexpr uint32_t kRtpTimestamp0 = ~uint32_t{0} - 79;
100 constexpr uint32_t kRtpTimestamp1 = 1280 - 80;
101 constexpr uint32_t kRtpTimestamp2 = 2560 - 80;
102 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
103 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
104 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
105 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
106 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
107 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
108
109 SimulatedClock clock(0);
110 AbsoluteCaptureTimeSender sender(&clock);
111
112 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
113 kExtension0->absolute_capture_timestamp,
114 kExtension0->estimated_capture_clock_offset),
115 kExtension0);
116
117 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
118 kExtension1->absolute_capture_timestamp,
119 kExtension1->estimated_capture_clock_offset),
120 absl::nullopt);
121
122 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
123 kExtension2->absolute_capture_timestamp,
124 kExtension2->estimated_capture_clock_offset),
125 absl::nullopt);
126 }
127
TEST(AbsoluteCaptureTimeSenderTest,InterpolateEarlierPacketSentLaterWithRtpTimestampWrapAround)128 TEST(AbsoluteCaptureTimeSenderTest,
129 InterpolateEarlierPacketSentLaterWithRtpTimestampWrapAround) {
130 constexpr uint32_t kSource = 1337;
131 constexpr uint32_t kRtpClockFrequency = 64000;
132 constexpr uint32_t kRtpTimestamp0 = 799;
133 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 - 1280;
134 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 - 2560;
135 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
136 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
137 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
138 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 - 20), Int64MsToQ32x32(-350)};
139 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
140 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 - 40), Int64MsToQ32x32(-350)};
141
142 SimulatedClock clock(0);
143 AbsoluteCaptureTimeSender sender(&clock);
144
145 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
146 kExtension0->absolute_capture_timestamp,
147 kExtension0->estimated_capture_clock_offset),
148 kExtension0);
149
150 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
151 kExtension1->absolute_capture_timestamp,
152 kExtension1->estimated_capture_clock_offset),
153 absl::nullopt);
154
155 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
156 kExtension2->absolute_capture_timestamp,
157 kExtension2->estimated_capture_clock_offset),
158 absl::nullopt);
159 }
160
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfTooLate)161 TEST(AbsoluteCaptureTimeSenderTest, SkipInterpolateIfTooLate) {
162 constexpr uint32_t kSource = 1337;
163 constexpr uint32_t kRtpClockFrequency = 64000;
164 constexpr uint32_t kRtpTimestamp0 = 1020300000;
165 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
166 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
167 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
168 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
169 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
170 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
171 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
172 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
173
174 SimulatedClock clock(0);
175 AbsoluteCaptureTimeSender sender(&clock);
176
177 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
178 kExtension0->absolute_capture_timestamp,
179 kExtension0->estimated_capture_clock_offset),
180 kExtension0);
181
182 clock.AdvanceTime(AbsoluteCaptureTimeSender::kInterpolationMaxInterval);
183
184 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
185 kExtension1->absolute_capture_timestamp,
186 kExtension1->estimated_capture_clock_offset),
187 absl::nullopt);
188
189 clock.AdvanceTimeMicroseconds(1);
190
191 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
192 kExtension2->absolute_capture_timestamp,
193 kExtension2->estimated_capture_clock_offset),
194 kExtension2);
195 }
196
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfSourceChanged)197 TEST(AbsoluteCaptureTimeSenderTest, SkipInterpolateIfSourceChanged) {
198 constexpr uint32_t kSource0 = 1337;
199 constexpr uint32_t kSource1 = 1338;
200 constexpr uint32_t kSource2 = 1338;
201 constexpr uint32_t kRtpClockFrequency = 64000;
202 constexpr uint32_t kRtpTimestamp0 = 1020300000;
203 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
204 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
205 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
206 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
207 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
208 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
209 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
210 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
211
212 SimulatedClock clock(0);
213 AbsoluteCaptureTimeSender sender(&clock);
214
215 EXPECT_EQ(sender.OnSendPacket(kSource0, kRtpTimestamp0, kRtpClockFrequency,
216 kExtension0->absolute_capture_timestamp,
217 kExtension0->estimated_capture_clock_offset),
218 kExtension0);
219
220 EXPECT_EQ(sender.OnSendPacket(kSource1, kRtpTimestamp1, kRtpClockFrequency,
221 kExtension1->absolute_capture_timestamp,
222 kExtension1->estimated_capture_clock_offset),
223 kExtension1);
224
225 EXPECT_EQ(sender.OnSendPacket(kSource2, kRtpTimestamp2, kRtpClockFrequency,
226 kExtension2->absolute_capture_timestamp,
227 kExtension2->estimated_capture_clock_offset),
228 absl::nullopt);
229 }
230
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfRtpClockFrequencyChanged)231 TEST(AbsoluteCaptureTimeSenderTest, SkipInterpolateIfRtpClockFrequencyChanged) {
232 constexpr uint32_t kSource = 1337;
233 constexpr uint32_t kRtpClockFrequency0 = 64000;
234 constexpr uint32_t kRtpClockFrequency1 = 32000;
235 constexpr uint32_t kRtpClockFrequency2 = 32000;
236 constexpr uint32_t kRtpTimestamp0 = 1020300000;
237 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 640;
238 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 1280;
239 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
240 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
241 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
242 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
243 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
244 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
245
246 SimulatedClock clock(0);
247 AbsoluteCaptureTimeSender sender(&clock);
248
249 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency0,
250 kExtension0->absolute_capture_timestamp,
251 kExtension0->estimated_capture_clock_offset),
252 kExtension0);
253
254 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency1,
255 kExtension1->absolute_capture_timestamp,
256 kExtension1->estimated_capture_clock_offset),
257 kExtension1);
258
259 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency2,
260 kExtension2->absolute_capture_timestamp,
261 kExtension2->estimated_capture_clock_offset),
262 absl::nullopt);
263 }
264
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfRtpClockFrequencyIsInvalid)265 TEST(AbsoluteCaptureTimeSenderTest,
266 SkipInterpolateIfRtpClockFrequencyIsInvalid) {
267 constexpr uint32_t kSource = 1337;
268 constexpr uint32_t kRtpClockFrequency0 = 0;
269 constexpr uint32_t kRtpClockFrequency1 = 0;
270 constexpr uint32_t kRtpClockFrequency2 = 0;
271 constexpr uint32_t kRtpTimestamp0 = 1020300000;
272 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0;
273 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0;
274 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
275 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
276 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
277 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(-350)};
278 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
279 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), Int64MsToQ32x32(-350)};
280
281 SimulatedClock clock(0);
282 AbsoluteCaptureTimeSender sender(&clock);
283
284 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency0,
285 kExtension0->absolute_capture_timestamp,
286 kExtension0->estimated_capture_clock_offset),
287 kExtension0);
288
289 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency1,
290 kExtension1->absolute_capture_timestamp,
291 kExtension1->estimated_capture_clock_offset),
292 kExtension1);
293
294 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency2,
295 kExtension2->absolute_capture_timestamp,
296 kExtension2->estimated_capture_clock_offset),
297 kExtension2);
298 }
299
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfEstimatedCaptureClockOffsetChanged)300 TEST(AbsoluteCaptureTimeSenderTest,
301 SkipInterpolateIfEstimatedCaptureClockOffsetChanged) {
302 constexpr uint32_t kSource = 1337;
303 constexpr uint32_t kRtpClockFrequency = 64000;
304 constexpr uint32_t kRtpTimestamp0 = 1020300000;
305 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
306 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
307 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
308 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
309 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
310 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 20), Int64MsToQ32x32(370)};
311 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
312 AbsoluteCaptureTime{Int64MsToUQ32x32(9000 + 40), absl::nullopt};
313
314 SimulatedClock clock(0);
315 AbsoluteCaptureTimeSender sender(&clock);
316
317 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
318 kExtension0->absolute_capture_timestamp,
319 kExtension0->estimated_capture_clock_offset),
320 kExtension0);
321
322 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
323 kExtension1->absolute_capture_timestamp,
324 kExtension1->estimated_capture_clock_offset),
325 kExtension1);
326
327 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
328 kExtension2->absolute_capture_timestamp,
329 kExtension2->estimated_capture_clock_offset),
330 kExtension2);
331 }
332
TEST(AbsoluteCaptureTimeSenderTest,SkipInterpolateIfTooMuchInterpolationError)333 TEST(AbsoluteCaptureTimeSenderTest,
334 SkipInterpolateIfTooMuchInterpolationError) {
335 constexpr uint32_t kSource = 1337;
336 constexpr uint32_t kRtpClockFrequency = 64000;
337 constexpr uint32_t kRtpTimestamp0 = 1020300000;
338 constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
339 constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
340 static const absl::optional<AbsoluteCaptureTime> kExtension0 =
341 AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
342 static const absl::optional<AbsoluteCaptureTime> kExtension1 =
343 AbsoluteCaptureTime{
344 Int64MsToUQ32x32(
345 9000 + 20 +
346 AbsoluteCaptureTimeSender::kInterpolationMaxError.ms()),
347 Int64MsToQ32x32(-350)};
348 static const absl::optional<AbsoluteCaptureTime> kExtension2 =
349 AbsoluteCaptureTime{
350 Int64MsToUQ32x32(
351 9000 + 40 +
352 AbsoluteCaptureTimeSender::kInterpolationMaxError.ms() + 1),
353 Int64MsToQ32x32(-350)};
354
355 SimulatedClock clock(0);
356 AbsoluteCaptureTimeSender sender(&clock);
357
358 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp0, kRtpClockFrequency,
359 kExtension0->absolute_capture_timestamp,
360 kExtension0->estimated_capture_clock_offset),
361 kExtension0);
362
363 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
364 kExtension1->absolute_capture_timestamp,
365 kExtension1->estimated_capture_clock_offset),
366 absl::nullopt);
367
368 EXPECT_EQ(sender.OnSendPacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
369 kExtension2->absolute_capture_timestamp,
370 kExtension2->estimated_capture_clock_offset),
371 kExtension2);
372 }
373
374 } // namespace webrtc
375