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