1 /*
2  *  Copyright (c) 2012 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 "video/stream_synchronization.h"
12 
13 #include <algorithm>
14 
15 #include "system_wrappers/include/clock.h"
16 #include "system_wrappers/include/ntp_time.h"
17 #include "test/gtest.h"
18 
19 namespace webrtc {
20 namespace {
21 constexpr int kMaxChangeMs = 80;  // From stream_synchronization.cc
22 constexpr int kDefaultAudioFrequency = 8000;
23 constexpr int kDefaultVideoFrequency = 90000;
24 constexpr int kSmoothingFilter = 4 * 2;
25 }  // namespace
26 
27 class StreamSynchronizationTest : public ::testing::Test {
28  public:
StreamSynchronizationTest()29   StreamSynchronizationTest()
30       : sync_(0, 0), clock_sender_(98765000), clock_receiver_(43210000) {}
31 
32  protected:
33   // Generates the necessary RTCP measurements and RTP timestamps and computes
34   // the audio and video delays needed to get the two streams in sync.
35   // |audio_delay_ms| and |video_delay_ms| are the number of milliseconds after
36   // capture which the frames are received.
37   // |current_audio_delay_ms| is the number of milliseconds which audio is
38   // currently being delayed by the receiver.
DelayedStreams(int audio_delay_ms,int video_delay_ms,int current_audio_delay_ms,int * total_audio_delay_ms,int * total_video_delay_ms)39   bool DelayedStreams(int audio_delay_ms,
40                       int video_delay_ms,
41                       int current_audio_delay_ms,
42                       int* total_audio_delay_ms,
43                       int* total_video_delay_ms) {
44     int audio_frequency =
45         static_cast<int>(kDefaultAudioFrequency * audio_clock_drift_ + 0.5);
46     int video_frequency =
47         static_cast<int>(kDefaultVideoFrequency * video_clock_drift_ + 0.5);
48 
49     // Generate NTP/RTP timestamp pair for both streams corresponding to RTCP.
50     bool new_sr;
51     StreamSynchronization::Measurements audio;
52     StreamSynchronization::Measurements video;
53     NtpTime ntp_time = clock_sender_.CurrentNtpTime();
54     uint32_t rtp_timestamp =
55         clock_sender_.CurrentTime().ms() * audio_frequency / 1000;
56     EXPECT_TRUE(audio.rtp_to_ntp.UpdateMeasurements(
57         ntp_time.seconds(), ntp_time.fractions(), rtp_timestamp, &new_sr));
58     clock_sender_.AdvanceTimeMilliseconds(100);
59     clock_receiver_.AdvanceTimeMilliseconds(100);
60     ntp_time = clock_sender_.CurrentNtpTime();
61     rtp_timestamp = clock_sender_.CurrentTime().ms() * video_frequency / 1000;
62     EXPECT_TRUE(video.rtp_to_ntp.UpdateMeasurements(
63         ntp_time.seconds(), ntp_time.fractions(), rtp_timestamp, &new_sr));
64     clock_sender_.AdvanceTimeMilliseconds(900);
65     clock_receiver_.AdvanceTimeMilliseconds(900);
66     ntp_time = clock_sender_.CurrentNtpTime();
67     rtp_timestamp = clock_sender_.CurrentTime().ms() * audio_frequency / 1000;
68     EXPECT_TRUE(audio.rtp_to_ntp.UpdateMeasurements(
69         ntp_time.seconds(), ntp_time.fractions(), rtp_timestamp, &new_sr));
70     clock_sender_.AdvanceTimeMilliseconds(100);
71     clock_receiver_.AdvanceTimeMilliseconds(100);
72     ntp_time = clock_sender_.CurrentNtpTime();
73     rtp_timestamp = clock_sender_.CurrentTime().ms() * video_frequency / 1000;
74     EXPECT_TRUE(video.rtp_to_ntp.UpdateMeasurements(
75         ntp_time.seconds(), ntp_time.fractions(), rtp_timestamp, &new_sr));
76     clock_sender_.AdvanceTimeMilliseconds(900);
77     clock_receiver_.AdvanceTimeMilliseconds(900);
78 
79     // Capture an audio and a video frame at the same time.
80     audio.latest_timestamp =
81         clock_sender_.CurrentTime().ms() * audio_frequency / 1000;
82     video.latest_timestamp =
83         clock_sender_.CurrentTime().ms() * video_frequency / 1000;
84 
85     if (audio_delay_ms > video_delay_ms) {
86       // Audio later than video.
87       clock_receiver_.AdvanceTimeMilliseconds(video_delay_ms);
88       video.latest_receive_time_ms = clock_receiver_.CurrentTime().ms();
89       clock_receiver_.AdvanceTimeMilliseconds(audio_delay_ms - video_delay_ms);
90       audio.latest_receive_time_ms = clock_receiver_.CurrentTime().ms();
91     } else {
92       // Video later than audio.
93       clock_receiver_.AdvanceTimeMilliseconds(audio_delay_ms);
94       audio.latest_receive_time_ms = clock_receiver_.CurrentTime().ms();
95       clock_receiver_.AdvanceTimeMilliseconds(video_delay_ms - audio_delay_ms);
96       video.latest_receive_time_ms = clock_receiver_.CurrentTime().ms();
97     }
98 
99     int relative_delay_ms;
100     EXPECT_TRUE(StreamSynchronization::ComputeRelativeDelay(
101         audio, video, &relative_delay_ms));
102     EXPECT_EQ(video_delay_ms - audio_delay_ms, relative_delay_ms);
103 
104     return sync_.ComputeDelays(relative_delay_ms, current_audio_delay_ms,
105                                total_audio_delay_ms, total_video_delay_ms);
106   }
107 
108   // Simulate audio playback 300 ms after capture and video rendering 100 ms
109   // after capture. Verify that the correct extra delays are calculated for
110   // audio and video, and that they change correctly when we simulate that
111   // NetEQ or the VCM adds more delay to the streams.
BothDelayedAudioLaterTest(int base_target_delay_ms)112   void BothDelayedAudioLaterTest(int base_target_delay_ms) {
113     const int kAudioDelayMs = base_target_delay_ms + 300;
114     const int kVideoDelayMs = base_target_delay_ms + 100;
115     int current_audio_delay_ms = base_target_delay_ms;
116     int total_audio_delay_ms = 0;
117     int total_video_delay_ms = base_target_delay_ms;
118     int filtered_move = (kAudioDelayMs - kVideoDelayMs) / kSmoothingFilter;
119 
120     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
121                                current_audio_delay_ms, &total_audio_delay_ms,
122                                &total_video_delay_ms));
123     EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
124     EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
125 
126     // Set new current delay.
127     current_audio_delay_ms = total_audio_delay_ms;
128     clock_sender_.AdvanceTimeMilliseconds(1000);
129     clock_receiver_.AdvanceTimeMilliseconds(
130         1000 - std::max(kAudioDelayMs, kVideoDelayMs));
131     // Simulate base_target_delay_ms minimum delay in the VCM.
132     total_video_delay_ms = base_target_delay_ms;
133     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
134                                current_audio_delay_ms, &total_audio_delay_ms,
135                                &total_video_delay_ms));
136     EXPECT_EQ(base_target_delay_ms + 2 * filtered_move, total_video_delay_ms);
137     EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
138 
139     // Set new current delay.
140     current_audio_delay_ms = total_audio_delay_ms;
141     clock_sender_.AdvanceTimeMilliseconds(1000);
142     clock_receiver_.AdvanceTimeMilliseconds(
143         1000 - std::max(kAudioDelayMs, kVideoDelayMs));
144     // Simulate base_target_delay_ms minimum delay in the VCM.
145     total_video_delay_ms = base_target_delay_ms;
146     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
147                                current_audio_delay_ms, &total_audio_delay_ms,
148                                &total_video_delay_ms));
149     EXPECT_EQ(base_target_delay_ms + 3 * filtered_move, total_video_delay_ms);
150     EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
151 
152     // Simulate that NetEQ introduces some audio delay.
153     const int kNeteqDelayIncrease = 50;
154     current_audio_delay_ms = base_target_delay_ms + kNeteqDelayIncrease;
155     clock_sender_.AdvanceTimeMilliseconds(1000);
156     clock_receiver_.AdvanceTimeMilliseconds(
157         1000 - std::max(kAudioDelayMs, kVideoDelayMs));
158     // Simulate base_target_delay_ms minimum delay in the VCM.
159     total_video_delay_ms = base_target_delay_ms;
160     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
161                                current_audio_delay_ms, &total_audio_delay_ms,
162                                &total_video_delay_ms));
163     filtered_move = 3 * filtered_move +
164                     (kNeteqDelayIncrease + kAudioDelayMs - kVideoDelayMs) /
165                         kSmoothingFilter;
166     EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
167     EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
168 
169     // Simulate that NetEQ reduces its delay.
170     const int kNeteqDelayDecrease = 10;
171     current_audio_delay_ms = base_target_delay_ms + kNeteqDelayDecrease;
172     clock_sender_.AdvanceTimeMilliseconds(1000);
173     clock_receiver_.AdvanceTimeMilliseconds(
174         1000 - std::max(kAudioDelayMs, kVideoDelayMs));
175     // Simulate base_target_delay_ms minimum delay in the VCM.
176     total_video_delay_ms = base_target_delay_ms;
177     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
178                                current_audio_delay_ms, &total_audio_delay_ms,
179                                &total_video_delay_ms));
180     filtered_move =
181         filtered_move + (kNeteqDelayDecrease + kAudioDelayMs - kVideoDelayMs) /
182                             kSmoothingFilter;
183     EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
184     EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
185   }
186 
BothDelayedVideoLaterTest(int base_target_delay_ms)187   void BothDelayedVideoLaterTest(int base_target_delay_ms) {
188     const int kAudioDelayMs = base_target_delay_ms + 100;
189     const int kVideoDelayMs = base_target_delay_ms + 300;
190     int current_audio_delay_ms = base_target_delay_ms;
191     int total_audio_delay_ms = 0;
192     int total_video_delay_ms = base_target_delay_ms;
193 
194     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
195                                current_audio_delay_ms, &total_audio_delay_ms,
196                                &total_video_delay_ms));
197     EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
198     // The audio delay is not allowed to change more than this.
199     EXPECT_GE(base_target_delay_ms + kMaxChangeMs, total_audio_delay_ms);
200     int last_total_audio_delay_ms = total_audio_delay_ms;
201 
202     // Set new current audio delay.
203     current_audio_delay_ms = total_audio_delay_ms;
204     clock_sender_.AdvanceTimeMilliseconds(1000);
205     clock_receiver_.AdvanceTimeMilliseconds(800);
206     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
207                                current_audio_delay_ms, &total_audio_delay_ms,
208                                &total_video_delay_ms));
209     EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
210     EXPECT_EQ(last_total_audio_delay_ms +
211                   MaxAudioDelayChangeMs(
212                       current_audio_delay_ms,
213                       base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
214               total_audio_delay_ms);
215     last_total_audio_delay_ms = total_audio_delay_ms;
216 
217     // Set new current audio delay.
218     current_audio_delay_ms = total_audio_delay_ms;
219     clock_sender_.AdvanceTimeMilliseconds(1000);
220     clock_receiver_.AdvanceTimeMilliseconds(800);
221     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
222                                current_audio_delay_ms, &total_audio_delay_ms,
223                                &total_video_delay_ms));
224     EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
225     EXPECT_EQ(last_total_audio_delay_ms +
226                   MaxAudioDelayChangeMs(
227                       current_audio_delay_ms,
228                       base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
229               total_audio_delay_ms);
230     last_total_audio_delay_ms = total_audio_delay_ms;
231 
232     // Simulate that NetEQ for some reason reduced the delay.
233     current_audio_delay_ms = base_target_delay_ms + 10;
234     clock_sender_.AdvanceTimeMilliseconds(1000);
235     clock_receiver_.AdvanceTimeMilliseconds(800);
236     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
237                                current_audio_delay_ms, &total_audio_delay_ms,
238                                &total_video_delay_ms));
239     EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
240     EXPECT_EQ(last_total_audio_delay_ms +
241                   MaxAudioDelayChangeMs(
242                       current_audio_delay_ms,
243                       base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
244               total_audio_delay_ms);
245     last_total_audio_delay_ms = total_audio_delay_ms;
246 
247     // Simulate that NetEQ for some reason significantly increased the delay.
248     current_audio_delay_ms = base_target_delay_ms + 350;
249     clock_sender_.AdvanceTimeMilliseconds(1000);
250     clock_receiver_.AdvanceTimeMilliseconds(800);
251     EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
252                                current_audio_delay_ms, &total_audio_delay_ms,
253                                &total_video_delay_ms));
254     EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
255     EXPECT_EQ(last_total_audio_delay_ms +
256                   MaxAudioDelayChangeMs(
257                       current_audio_delay_ms,
258                       base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
259               total_audio_delay_ms);
260   }
261 
MaxAudioDelayChangeMs(int current_audio_delay_ms,int delay_ms) const262   int MaxAudioDelayChangeMs(int current_audio_delay_ms, int delay_ms) const {
263     int diff_ms = (delay_ms - current_audio_delay_ms) / kSmoothingFilter;
264     diff_ms = std::min(diff_ms, kMaxChangeMs);
265     diff_ms = std::max(diff_ms, -kMaxChangeMs);
266     return diff_ms;
267   }
268 
269   StreamSynchronization sync_;
270   SimulatedClock clock_sender_;
271   SimulatedClock clock_receiver_;
272   double audio_clock_drift_ = 1.0;
273   double video_clock_drift_ = 1.0;
274 };
275 
TEST_F(StreamSynchronizationTest,NoDelay)276 TEST_F(StreamSynchronizationTest, NoDelay) {
277   int total_audio_delay_ms = 0;
278   int total_video_delay_ms = 0;
279 
280   EXPECT_FALSE(DelayedStreams(/*audio_delay_ms=*/0, /*video_delay_ms=*/0,
281                               /*current_audio_delay_ms=*/0,
282                               &total_audio_delay_ms, &total_video_delay_ms));
283   EXPECT_EQ(0, total_audio_delay_ms);
284   EXPECT_EQ(0, total_video_delay_ms);
285 }
286 
TEST_F(StreamSynchronizationTest,VideoDelayed)287 TEST_F(StreamSynchronizationTest, VideoDelayed) {
288   const int kAudioDelayMs = 200;
289   int total_audio_delay_ms = 0;
290   int total_video_delay_ms = 0;
291 
292   EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
293                              /*current_audio_delay_ms=*/0,
294                              &total_audio_delay_ms, &total_video_delay_ms));
295   EXPECT_EQ(0, total_audio_delay_ms);
296   // The delay is not allowed to change more than this.
297   EXPECT_EQ(kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
298 
299   // Simulate 0 minimum delay in the VCM.
300   total_video_delay_ms = 0;
301   clock_sender_.AdvanceTimeMilliseconds(1000);
302   clock_receiver_.AdvanceTimeMilliseconds(800);
303   EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
304                              /*current_audio_delay_ms=*/0,
305                              &total_audio_delay_ms, &total_video_delay_ms));
306   EXPECT_EQ(0, total_audio_delay_ms);
307   EXPECT_EQ(2 * kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
308 
309   // Simulate 0 minimum delay in the VCM.
310   total_video_delay_ms = 0;
311   clock_sender_.AdvanceTimeMilliseconds(1000);
312   clock_receiver_.AdvanceTimeMilliseconds(800);
313   EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
314                              /*current_audio_delay_ms=*/0,
315                              &total_audio_delay_ms, &total_video_delay_ms));
316   EXPECT_EQ(0, total_audio_delay_ms);
317   EXPECT_EQ(3 * kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
318 }
319 
TEST_F(StreamSynchronizationTest,AudioDelayed)320 TEST_F(StreamSynchronizationTest, AudioDelayed) {
321   const int kVideoDelayMs = 200;
322   int current_audio_delay_ms = 0;
323   int total_audio_delay_ms = 0;
324   int total_video_delay_ms = 0;
325 
326   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
327                              current_audio_delay_ms, &total_audio_delay_ms,
328                              &total_video_delay_ms));
329   EXPECT_EQ(0, total_video_delay_ms);
330   // The delay is not allowed to change more than this.
331   EXPECT_EQ(kVideoDelayMs / kSmoothingFilter, total_audio_delay_ms);
332   int last_total_audio_delay_ms = total_audio_delay_ms;
333 
334   // Set new current audio delay.
335   current_audio_delay_ms = total_audio_delay_ms;
336   clock_sender_.AdvanceTimeMilliseconds(1000);
337   clock_receiver_.AdvanceTimeMilliseconds(800);
338   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
339                              current_audio_delay_ms, &total_audio_delay_ms,
340                              &total_video_delay_ms));
341   EXPECT_EQ(0, total_video_delay_ms);
342   EXPECT_EQ(last_total_audio_delay_ms +
343                 MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
344             total_audio_delay_ms);
345   last_total_audio_delay_ms = total_audio_delay_ms;
346 
347   // Set new current audio delay.
348   current_audio_delay_ms = total_audio_delay_ms;
349   clock_sender_.AdvanceTimeMilliseconds(1000);
350   clock_receiver_.AdvanceTimeMilliseconds(800);
351   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
352                              current_audio_delay_ms, &total_audio_delay_ms,
353                              &total_video_delay_ms));
354   EXPECT_EQ(0, total_video_delay_ms);
355   EXPECT_EQ(last_total_audio_delay_ms +
356                 MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
357             total_audio_delay_ms);
358   last_total_audio_delay_ms = total_audio_delay_ms;
359 
360   // Simulate that NetEQ for some reason reduced the delay.
361   current_audio_delay_ms = 10;
362   clock_sender_.AdvanceTimeMilliseconds(1000);
363   clock_receiver_.AdvanceTimeMilliseconds(800);
364   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
365                              current_audio_delay_ms, &total_audio_delay_ms,
366                              &total_video_delay_ms));
367   EXPECT_EQ(0, total_video_delay_ms);
368   EXPECT_EQ(last_total_audio_delay_ms +
369                 MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
370             total_audio_delay_ms);
371   last_total_audio_delay_ms = total_audio_delay_ms;
372 
373   // Simulate that NetEQ for some reason significantly increased the delay.
374   current_audio_delay_ms = 350;
375   clock_sender_.AdvanceTimeMilliseconds(1000);
376   clock_receiver_.AdvanceTimeMilliseconds(800);
377   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
378                              current_audio_delay_ms, &total_audio_delay_ms,
379                              &total_video_delay_ms));
380   EXPECT_EQ(0, total_video_delay_ms);
381   EXPECT_EQ(last_total_audio_delay_ms +
382                 MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
383             total_audio_delay_ms);
384 }
385 
TEST_F(StreamSynchronizationTest,NoAudioIncomingUnboundedIncrease)386 TEST_F(StreamSynchronizationTest, NoAudioIncomingUnboundedIncrease) {
387   // Test how audio delay can grow unbounded when audio stops coming in.
388   // This is handled in caller of RtpStreamsSynchronizer, for example in
389   // RtpStreamsSynchronizer by not updating delays when audio samples stop
390   // coming in.
391   const int kVideoDelayMs = 300;
392   const int kAudioDelayMs = 100;
393   int current_audio_delay_ms = kAudioDelayMs;
394   int total_audio_delay_ms = 0;
395   int total_video_delay_ms = 0;
396 
397   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
398                              current_audio_delay_ms, &total_audio_delay_ms,
399                              &total_video_delay_ms));
400   EXPECT_EQ(0, total_video_delay_ms);
401   // The delay is not allowed to change more than this.
402   EXPECT_EQ((kVideoDelayMs - kAudioDelayMs) / kSmoothingFilter,
403             total_audio_delay_ms);
404   int last_total_audio_delay_ms = total_audio_delay_ms;
405 
406   // Set new current audio delay: simulate audio samples are flowing in.
407   current_audio_delay_ms = total_audio_delay_ms;
408 
409   clock_sender_.AdvanceTimeMilliseconds(1000);
410   clock_receiver_.AdvanceTimeMilliseconds(1000);
411   EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
412                              current_audio_delay_ms, &total_audio_delay_ms,
413                              &total_video_delay_ms));
414   EXPECT_EQ(0, total_video_delay_ms);
415   EXPECT_EQ(last_total_audio_delay_ms +
416                 MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
417             total_audio_delay_ms);
418   last_total_audio_delay_ms = total_audio_delay_ms;
419 
420   // Simulate no incoming audio by not update audio delay.
421   const int kSimulationSecs = 300;     // 5min
422   const int kMaxDeltaDelayMs = 10000;  // max delay for audio in webrtc
423   for (auto time_secs = 0; time_secs < kSimulationSecs; time_secs++) {
424     clock_sender_.AdvanceTimeMilliseconds(1000);
425     clock_receiver_.AdvanceTimeMilliseconds(1000);
426     EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
427                                current_audio_delay_ms, &total_audio_delay_ms,
428                                &total_video_delay_ms));
429     EXPECT_EQ(0, total_video_delay_ms);
430 
431     // Audio delay does not go above kMaxDeltaDelayMs.
432     EXPECT_EQ(std::min(kMaxDeltaDelayMs,
433                        last_total_audio_delay_ms +
434                            MaxAudioDelayChangeMs(current_audio_delay_ms,
435                                                  kVideoDelayMs)),
436               total_audio_delay_ms);
437     last_total_audio_delay_ms = total_audio_delay_ms;
438   }
439   // By now the audio delay has grown unbounded to kMaxDeltaDelayMs.
440   EXPECT_EQ(kMaxDeltaDelayMs, last_total_audio_delay_ms);
441 }
442 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLater)443 TEST_F(StreamSynchronizationTest, BothDelayedVideoLater) {
444   BothDelayedVideoLaterTest(0);
445 }
446 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterAudioClockDrift)447 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterAudioClockDrift) {
448   audio_clock_drift_ = 1.05;
449   BothDelayedVideoLaterTest(0);
450 }
451 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterVideoClockDrift)452 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterVideoClockDrift) {
453   video_clock_drift_ = 1.05;
454   BothDelayedVideoLaterTest(0);
455 }
456 
TEST_F(StreamSynchronizationTest,BothDelayedAudioLater)457 TEST_F(StreamSynchronizationTest, BothDelayedAudioLater) {
458   BothDelayedAudioLaterTest(0);
459 }
460 
TEST_F(StreamSynchronizationTest,BothDelayedAudioClockDrift)461 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDrift) {
462   audio_clock_drift_ = 1.05;
463   BothDelayedAudioLaterTest(0);
464 }
465 
TEST_F(StreamSynchronizationTest,BothDelayedVideoClockDrift)466 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDrift) {
467   video_clock_drift_ = 1.05;
468   BothDelayedAudioLaterTest(0);
469 }
470 
TEST_F(StreamSynchronizationTest,BothEquallyDelayed)471 TEST_F(StreamSynchronizationTest, BothEquallyDelayed) {
472   const int kDelayMs = 2000;
473   int current_audio_delay_ms = kDelayMs;
474   int total_audio_delay_ms = 0;
475   int total_video_delay_ms = kDelayMs;
476   // In sync, expect no change.
477   EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
478                               &total_audio_delay_ms, &total_video_delay_ms));
479   // Trigger another call with the same values, delay should not be modified.
480   total_video_delay_ms = kDelayMs;
481   EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
482                               &total_audio_delay_ms, &total_video_delay_ms));
483   // Change delay value, delay should not be modified.
484   const int kDelayMs2 = 5000;
485   current_audio_delay_ms = kDelayMs2;
486   total_video_delay_ms = kDelayMs2;
487   EXPECT_FALSE(DelayedStreams(kDelayMs2, kDelayMs2, current_audio_delay_ms,
488                               &total_audio_delay_ms, &total_video_delay_ms));
489 }
490 
TEST_F(StreamSynchronizationTest,BothDelayedAudioLaterWithBaseDelay)491 TEST_F(StreamSynchronizationTest, BothDelayedAudioLaterWithBaseDelay) {
492   const int kBaseTargetDelayMs = 3000;
493   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
494   BothDelayedAudioLaterTest(kBaseTargetDelayMs);
495 }
496 
TEST_F(StreamSynchronizationTest,BothDelayedAudioClockDriftWithBaseDelay)497 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDriftWithBaseDelay) {
498   const int kBaseTargetDelayMs = 3000;
499   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
500   audio_clock_drift_ = 1.05;
501   BothDelayedAudioLaterTest(kBaseTargetDelayMs);
502 }
503 
TEST_F(StreamSynchronizationTest,BothDelayedVideoClockDriftWithBaseDelay)504 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDriftWithBaseDelay) {
505   const int kBaseTargetDelayMs = 3000;
506   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
507   video_clock_drift_ = 1.05;
508   BothDelayedAudioLaterTest(kBaseTargetDelayMs);
509 }
510 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterWithBaseDelay)511 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterWithBaseDelay) {
512   const int kBaseTargetDelayMs = 2000;
513   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
514   BothDelayedVideoLaterTest(kBaseTargetDelayMs);
515 }
516 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterAudioClockDriftWithBaseDelay)517 TEST_F(StreamSynchronizationTest,
518        BothDelayedVideoLaterAudioClockDriftWithBaseDelay) {
519   const int kBaseTargetDelayMs = 2000;
520   audio_clock_drift_ = 1.05;
521   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
522   BothDelayedVideoLaterTest(kBaseTargetDelayMs);
523 }
524 
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterVideoClockDriftWithBaseDelay)525 TEST_F(StreamSynchronizationTest,
526        BothDelayedVideoLaterVideoClockDriftWithBaseDelay) {
527   const int kBaseTargetDelayMs = 2000;
528   video_clock_drift_ = 1.05;
529   sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
530   BothDelayedVideoLaterTest(kBaseTargetDelayMs);
531 }
532 
533 }  // namespace webrtc
534