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,BothDelayedVideoLater)386 TEST_F(StreamSynchronizationTest, BothDelayedVideoLater) {
387 BothDelayedVideoLaterTest(0);
388 }
389
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterAudioClockDrift)390 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterAudioClockDrift) {
391 audio_clock_drift_ = 1.05;
392 BothDelayedVideoLaterTest(0);
393 }
394
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterVideoClockDrift)395 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterVideoClockDrift) {
396 video_clock_drift_ = 1.05;
397 BothDelayedVideoLaterTest(0);
398 }
399
TEST_F(StreamSynchronizationTest,BothDelayedAudioLater)400 TEST_F(StreamSynchronizationTest, BothDelayedAudioLater) {
401 BothDelayedAudioLaterTest(0);
402 }
403
TEST_F(StreamSynchronizationTest,BothDelayedAudioClockDrift)404 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDrift) {
405 audio_clock_drift_ = 1.05;
406 BothDelayedAudioLaterTest(0);
407 }
408
TEST_F(StreamSynchronizationTest,BothDelayedVideoClockDrift)409 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDrift) {
410 video_clock_drift_ = 1.05;
411 BothDelayedAudioLaterTest(0);
412 }
413
TEST_F(StreamSynchronizationTest,BothEquallyDelayed)414 TEST_F(StreamSynchronizationTest, BothEquallyDelayed) {
415 const int kDelayMs = 2000;
416 int current_audio_delay_ms = kDelayMs;
417 int total_audio_delay_ms = 0;
418 int total_video_delay_ms = kDelayMs;
419 // In sync, expect no change.
420 EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
421 &total_audio_delay_ms, &total_video_delay_ms));
422 // Trigger another call with the same values, delay should not be modified.
423 total_video_delay_ms = kDelayMs;
424 EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
425 &total_audio_delay_ms, &total_video_delay_ms));
426 // Change delay value, delay should not be modified.
427 const int kDelayMs2 = 5000;
428 current_audio_delay_ms = kDelayMs2;
429 total_video_delay_ms = kDelayMs2;
430 EXPECT_FALSE(DelayedStreams(kDelayMs2, kDelayMs2, current_audio_delay_ms,
431 &total_audio_delay_ms, &total_video_delay_ms));
432 }
433
TEST_F(StreamSynchronizationTest,BothDelayedAudioLaterWithBaseDelay)434 TEST_F(StreamSynchronizationTest, BothDelayedAudioLaterWithBaseDelay) {
435 const int kBaseTargetDelayMs = 3000;
436 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
437 BothDelayedAudioLaterTest(kBaseTargetDelayMs);
438 }
439
TEST_F(StreamSynchronizationTest,BothDelayedAudioClockDriftWithBaseDelay)440 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDriftWithBaseDelay) {
441 const int kBaseTargetDelayMs = 3000;
442 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
443 audio_clock_drift_ = 1.05;
444 BothDelayedAudioLaterTest(kBaseTargetDelayMs);
445 }
446
TEST_F(StreamSynchronizationTest,BothDelayedVideoClockDriftWithBaseDelay)447 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDriftWithBaseDelay) {
448 const int kBaseTargetDelayMs = 3000;
449 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
450 video_clock_drift_ = 1.05;
451 BothDelayedAudioLaterTest(kBaseTargetDelayMs);
452 }
453
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterWithBaseDelay)454 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterWithBaseDelay) {
455 const int kBaseTargetDelayMs = 2000;
456 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
457 BothDelayedVideoLaterTest(kBaseTargetDelayMs);
458 }
459
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterAudioClockDriftWithBaseDelay)460 TEST_F(StreamSynchronizationTest,
461 BothDelayedVideoLaterAudioClockDriftWithBaseDelay) {
462 const int kBaseTargetDelayMs = 2000;
463 audio_clock_drift_ = 1.05;
464 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
465 BothDelayedVideoLaterTest(kBaseTargetDelayMs);
466 }
467
TEST_F(StreamSynchronizationTest,BothDelayedVideoLaterVideoClockDriftWithBaseDelay)468 TEST_F(StreamSynchronizationTest,
469 BothDelayedVideoLaterVideoClockDriftWithBaseDelay) {
470 const int kBaseTargetDelayMs = 2000;
471 video_clock_drift_ = 1.05;
472 sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
473 BothDelayedVideoLaterTest(kBaseTargetDelayMs);
474 }
475
476 } // namespace webrtc
477