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_interpolator.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(AbsoluteCaptureTimeInterpolatorTest,GetSourceWithoutCsrcs)19 TEST(AbsoluteCaptureTimeInterpolatorTest, GetSourceWithoutCsrcs) {
20   constexpr uint32_t kSsrc = 12;
21 
22   EXPECT_EQ(AbsoluteCaptureTimeInterpolator::GetSource(kSsrc, nullptr), kSsrc);
23 }
24 
TEST(AbsoluteCaptureTimeInterpolatorTest,GetSourceWithCsrcs)25 TEST(AbsoluteCaptureTimeInterpolatorTest, GetSourceWithCsrcs) {
26   constexpr uint32_t kSsrc = 12;
27   constexpr uint32_t kCsrcs[] = {34, 56, 78, 90};
28 
29   EXPECT_EQ(AbsoluteCaptureTimeInterpolator::GetSource(kSsrc, kCsrcs),
30             kCsrcs[0]);
31 }
32 
TEST(AbsoluteCaptureTimeInterpolatorTest,ReceiveExtensionReturnsExtension)33 TEST(AbsoluteCaptureTimeInterpolatorTest, ReceiveExtensionReturnsExtension) {
34   constexpr uint32_t kSource = 1337;
35   constexpr uint32_t kRtpClockFrequency = 64000;
36   constexpr uint32_t kRtpTimestamp0 = 1020300000;
37   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
38   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
39       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
40   static const absl::optional<AbsoluteCaptureTime> kExtension1 =
41       AbsoluteCaptureTime{Int64MsToUQ32x32(9020), absl::nullopt};
42 
43   SimulatedClock clock(0);
44   AbsoluteCaptureTimeInterpolator interpolator(&clock);
45 
46   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
47                                          kRtpClockFrequency, kExtension0),
48             kExtension0);
49 
50   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp1,
51                                          kRtpClockFrequency, kExtension1),
52             kExtension1);
53 }
54 
TEST(AbsoluteCaptureTimeInterpolatorTest,ReceiveNoExtensionReturnsNoExtension)55 TEST(AbsoluteCaptureTimeInterpolatorTest,
56      ReceiveNoExtensionReturnsNoExtension) {
57   constexpr uint32_t kSource = 1337;
58   constexpr uint32_t kRtpClockFrequency = 64000;
59   constexpr uint32_t kRtpTimestamp0 = 1020300000;
60   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
61   static const absl::optional<AbsoluteCaptureTime> kExtension0 = absl::nullopt;
62   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
63 
64   SimulatedClock clock(0);
65   AbsoluteCaptureTimeInterpolator interpolator(&clock);
66 
67   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
68                                          kRtpClockFrequency, kExtension0),
69             absl::nullopt);
70 
71   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp1,
72                                          kRtpClockFrequency, kExtension1),
73             absl::nullopt);
74 }
75 
TEST(AbsoluteCaptureTimeInterpolatorTest,InterpolateLaterPacketArrivingLater)76 TEST(AbsoluteCaptureTimeInterpolatorTest, InterpolateLaterPacketArrivingLater) {
77   constexpr uint32_t kSource = 1337;
78   constexpr uint32_t kRtpClockFrequency = 64000;
79   constexpr uint32_t kRtpTimestamp0 = 1020300000;
80   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
81   constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 + 2560;
82   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
83       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
84   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
85   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
86 
87   SimulatedClock clock(0);
88   AbsoluteCaptureTimeInterpolator interpolator(&clock);
89 
90   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
91                                          kRtpClockFrequency, kExtension0),
92             kExtension0);
93 
94   absl::optional<AbsoluteCaptureTime> extension = interpolator.OnReceivePacket(
95       kSource, kRtpTimestamp1, kRtpClockFrequency, kExtension1);
96   EXPECT_TRUE(extension.has_value());
97   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
98             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) + 20);
99   EXPECT_EQ(extension->estimated_capture_clock_offset,
100             kExtension0->estimated_capture_clock_offset);
101 
102   extension = interpolator.OnReceivePacket(kSource, kRtpTimestamp2,
103                                            kRtpClockFrequency, kExtension2);
104   EXPECT_TRUE(extension.has_value());
105   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
106             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) + 40);
107   EXPECT_EQ(extension->estimated_capture_clock_offset,
108             kExtension0->estimated_capture_clock_offset);
109 }
110 
TEST(AbsoluteCaptureTimeInterpolatorTest,InterpolateEarlierPacketArrivingLater)111 TEST(AbsoluteCaptureTimeInterpolatorTest,
112      InterpolateEarlierPacketArrivingLater) {
113   constexpr uint32_t kSource = 1337;
114   constexpr uint32_t kRtpClockFrequency = 64000;
115   constexpr uint32_t kRtpTimestamp0 = 1020300000;
116   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 - 1280;
117   constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 - 2560;
118   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
119       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
120   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
121   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
122 
123   SimulatedClock clock(0);
124   AbsoluteCaptureTimeInterpolator interpolator(&clock);
125 
126   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
127                                          kRtpClockFrequency, kExtension0),
128             kExtension0);
129 
130   absl::optional<AbsoluteCaptureTime> extension = interpolator.OnReceivePacket(
131       kSource, kRtpTimestamp1, kRtpClockFrequency, kExtension1);
132   EXPECT_TRUE(extension.has_value());
133   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
134             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) - 20);
135   EXPECT_EQ(extension->estimated_capture_clock_offset,
136             kExtension0->estimated_capture_clock_offset);
137 
138   extension = interpolator.OnReceivePacket(kSource, kRtpTimestamp2,
139                                            kRtpClockFrequency, kExtension2);
140   EXPECT_TRUE(extension.has_value());
141   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
142             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) - 40);
143   EXPECT_EQ(extension->estimated_capture_clock_offset,
144             kExtension0->estimated_capture_clock_offset);
145 }
146 
TEST(AbsoluteCaptureTimeInterpolatorTest,InterpolateLaterPacketArrivingLaterWithRtpTimestampWrapAround)147 TEST(AbsoluteCaptureTimeInterpolatorTest,
148      InterpolateLaterPacketArrivingLaterWithRtpTimestampWrapAround) {
149   constexpr uint32_t kSource = 1337;
150   constexpr uint32_t kRtpClockFrequency = 64000;
151   constexpr uint32_t kRtpTimestamp0 = ~uint32_t{0} - 79;
152   constexpr uint32_t kRtpTimestamp1 = 1280 - 80;
153   constexpr uint32_t kRtpTimestamp2 = 2560 - 80;
154   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
155       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
156   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
157   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
158 
159   SimulatedClock clock(0);
160   AbsoluteCaptureTimeInterpolator interpolator(&clock);
161 
162   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
163                                          kRtpClockFrequency, kExtension0),
164             kExtension0);
165 
166   absl::optional<AbsoluteCaptureTime> extension = interpolator.OnReceivePacket(
167       kSource, kRtpTimestamp1, kRtpClockFrequency, kExtension1);
168   EXPECT_TRUE(extension.has_value());
169   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
170             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) + 20);
171   EXPECT_EQ(extension->estimated_capture_clock_offset,
172             kExtension0->estimated_capture_clock_offset);
173 
174   extension = interpolator.OnReceivePacket(kSource, kRtpTimestamp2,
175                                            kRtpClockFrequency, kExtension2);
176   EXPECT_TRUE(extension.has_value());
177   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
178             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) + 40);
179   EXPECT_EQ(extension->estimated_capture_clock_offset,
180             kExtension0->estimated_capture_clock_offset);
181 }
182 
TEST(AbsoluteCaptureTimeInterpolatorTest,InterpolateEarlierPacketArrivingLaterWithRtpTimestampWrapAround)183 TEST(AbsoluteCaptureTimeInterpolatorTest,
184      InterpolateEarlierPacketArrivingLaterWithRtpTimestampWrapAround) {
185   constexpr uint32_t kSource = 1337;
186   constexpr uint32_t kRtpClockFrequency = 64000;
187   constexpr uint32_t kRtpTimestamp0 = 799;
188   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 - 1280;
189   constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp0 - 2560;
190   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
191       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
192   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
193   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
194 
195   SimulatedClock clock(0);
196   AbsoluteCaptureTimeInterpolator interpolator(&clock);
197 
198   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
199                                          kRtpClockFrequency, kExtension0),
200             kExtension0);
201 
202   absl::optional<AbsoluteCaptureTime> extension = interpolator.OnReceivePacket(
203       kSource, kRtpTimestamp1, kRtpClockFrequency, kExtension1);
204   EXPECT_TRUE(extension.has_value());
205   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
206             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) - 20);
207   EXPECT_EQ(extension->estimated_capture_clock_offset,
208             kExtension0->estimated_capture_clock_offset);
209 
210   extension = interpolator.OnReceivePacket(kSource, kRtpTimestamp2,
211                                            kRtpClockFrequency, kExtension2);
212   EXPECT_TRUE(extension.has_value());
213   EXPECT_EQ(UQ32x32ToInt64Ms(extension->absolute_capture_timestamp),
214             UQ32x32ToInt64Ms(kExtension0->absolute_capture_timestamp) - 40);
215   EXPECT_EQ(extension->estimated_capture_clock_offset,
216             kExtension0->estimated_capture_clock_offset);
217 }
218 
TEST(AbsoluteCaptureTimeInterpolatorTest,SkipInterpolateIfTooLate)219 TEST(AbsoluteCaptureTimeInterpolatorTest, SkipInterpolateIfTooLate) {
220   constexpr uint32_t kSource = 1337;
221   constexpr uint32_t kRtpClockFrequency = 64000;
222   constexpr uint32_t kRtpTimestamp0 = 1020300000;
223   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
224   constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp1 + 1280;
225   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
226       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
227   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
228   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
229 
230   SimulatedClock clock(0);
231   AbsoluteCaptureTimeInterpolator interpolator(&clock);
232 
233   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
234                                          kRtpClockFrequency, kExtension0),
235             kExtension0);
236 
237   clock.AdvanceTime(AbsoluteCaptureTimeInterpolator::kInterpolationMaxInterval);
238 
239   EXPECT_TRUE(interpolator
240                   .OnReceivePacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
241                                    kExtension1)
242                   .has_value());
243 
244   clock.AdvanceTimeMilliseconds(1);
245 
246   EXPECT_FALSE(interpolator
247                    .OnReceivePacket(kSource, kRtpTimestamp2, kRtpClockFrequency,
248                                     kExtension2)
249                    .has_value());
250 }
251 
TEST(AbsoluteCaptureTimeInterpolatorTest,SkipInterpolateIfSourceChanged)252 TEST(AbsoluteCaptureTimeInterpolatorTest, SkipInterpolateIfSourceChanged) {
253   constexpr uint32_t kSource0 = 1337;
254   constexpr uint32_t kSource1 = 1338;
255   constexpr uint32_t kRtpClockFrequency = 64000;
256   constexpr uint32_t kRtpTimestamp0 = 1020300000;
257   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
258   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
259       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
260   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
261 
262   SimulatedClock clock(0);
263   AbsoluteCaptureTimeInterpolator interpolator(&clock);
264 
265   EXPECT_EQ(interpolator.OnReceivePacket(kSource0, kRtpTimestamp0,
266                                          kRtpClockFrequency, kExtension0),
267             kExtension0);
268 
269   EXPECT_FALSE(interpolator
270                    .OnReceivePacket(kSource1, kRtpTimestamp1,
271                                     kRtpClockFrequency, kExtension1)
272                    .has_value());
273 }
274 
TEST(AbsoluteCaptureTimeInterpolatorTest,SkipInterpolateIfRtpClockFrequencyChanged)275 TEST(AbsoluteCaptureTimeInterpolatorTest,
276      SkipInterpolateIfRtpClockFrequencyChanged) {
277   constexpr uint32_t kSource = 1337;
278   constexpr uint32_t kRtpClockFrequency0 = 64000;
279   constexpr uint32_t kRtpClockFrequency1 = 32000;
280   constexpr uint32_t kRtpTimestamp0 = 1020300000;
281   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 640;
282   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
283       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
284   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
285 
286   SimulatedClock clock(0);
287   AbsoluteCaptureTimeInterpolator interpolator(&clock);
288 
289   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
290                                          kRtpClockFrequency0, kExtension0),
291             kExtension0);
292 
293   EXPECT_FALSE(interpolator
294                    .OnReceivePacket(kSource, kRtpTimestamp1,
295                                     kRtpClockFrequency1, kExtension1)
296                    .has_value());
297 }
298 
TEST(AbsoluteCaptureTimeInterpolatorTest,SkipInterpolateIfRtpClockFrequencyIsInvalid)299 TEST(AbsoluteCaptureTimeInterpolatorTest,
300      SkipInterpolateIfRtpClockFrequencyIsInvalid) {
301   constexpr uint32_t kSource = 1337;
302   constexpr uint32_t kRtpClockFrequency = 0;
303   constexpr uint32_t kRtpTimestamp0 = 1020300000;
304   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 640;
305   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
306       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
307   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
308 
309   SimulatedClock clock(0);
310   AbsoluteCaptureTimeInterpolator interpolator(&clock);
311 
312   EXPECT_EQ(interpolator.OnReceivePacket(kSource, kRtpTimestamp0,
313                                          kRtpClockFrequency, kExtension0),
314             kExtension0);
315 
316   EXPECT_FALSE(interpolator
317                    .OnReceivePacket(kSource, kRtpTimestamp1, kRtpClockFrequency,
318                                     kExtension1)
319                    .has_value());
320 }
321 
TEST(AbsoluteCaptureTimeInterpolatorTest,SkipInterpolateIsSticky)322 TEST(AbsoluteCaptureTimeInterpolatorTest, SkipInterpolateIsSticky) {
323   constexpr uint32_t kSource0 = 1337;
324   constexpr uint32_t kSource1 = 1338;
325   constexpr uint32_t kSource2 = 1337;
326   constexpr uint32_t kRtpClockFrequency = 64000;
327   constexpr uint32_t kRtpTimestamp0 = 1020300000;
328   constexpr uint32_t kRtpTimestamp1 = kRtpTimestamp0 + 1280;
329   constexpr uint32_t kRtpTimestamp2 = kRtpTimestamp1 + 1280;
330   static const absl::optional<AbsoluteCaptureTime> kExtension0 =
331       AbsoluteCaptureTime{Int64MsToUQ32x32(9000), Int64MsToQ32x32(-350)};
332   static const absl::optional<AbsoluteCaptureTime> kExtension1 = absl::nullopt;
333   static const absl::optional<AbsoluteCaptureTime> kExtension2 = absl::nullopt;
334 
335   SimulatedClock clock(0);
336   AbsoluteCaptureTimeInterpolator interpolator(&clock);
337 
338   EXPECT_EQ(interpolator.OnReceivePacket(kSource0, kRtpTimestamp0,
339                                          kRtpClockFrequency, kExtension0),
340             kExtension0);
341 
342   EXPECT_FALSE(interpolator
343                    .OnReceivePacket(kSource1, kRtpTimestamp1,
344                                     kRtpClockFrequency, kExtension1)
345                    .has_value());
346 
347   EXPECT_FALSE(interpolator
348                    .OnReceivePacket(kSource2, kRtpTimestamp2,
349                                     kRtpClockFrequency, kExtension2)
350                    .has_value());
351 }
352 
353 }  // namespace webrtc
354