| OLD | NEW |
|---|
| (Empty) |
| 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 <math.h> | |
| 12 | |
| 13 #include <algorithm> | |
| 14 | |
| 15 #include "testing/gtest/include/gtest/gtest.h" | |
| 16 #include "webrtc/video/stream_synchronization.h" | |
| 17 | |
| 18 namespace webrtc { | |
| 19 | |
| 20 // These correspond to the same constants defined in vie_sync_module.cc. | |
| 21 enum { kMaxVideoDiffMs = 80 }; | |
| 22 enum { kMaxAudioDiffMs = 80 }; | |
| 23 enum { kMaxDelay = 1500 }; | |
| 24 | |
| 25 // Test constants. | |
| 26 enum { kDefaultAudioFrequency = 8000 }; | |
| 27 enum { kDefaultVideoFrequency = 90000 }; | |
| 28 const double kNtpFracPerMs = 4.294967296E6; | |
| 29 static const int kSmoothingFilter = 4 * 2; | |
| 30 | |
| 31 class Time { | |
| 32 public: | |
| 33 explicit Time(int64_t offset) | |
| 34 : kNtpJan1970(2208988800UL), | |
| 35 time_now_ms_(offset) {} | |
| 36 | |
| 37 RtcpMeasurement GenerateRtcp(int frequency, uint32_t offset) const { | |
| 38 RtcpMeasurement rtcp; | |
| 39 NowNtp(&rtcp.ntp_secs, &rtcp.ntp_frac); | |
| 40 rtcp.rtp_timestamp = NowRtp(frequency, offset); | |
| 41 return rtcp; | |
| 42 } | |
| 43 | |
| 44 void NowNtp(uint32_t* ntp_secs, uint32_t* ntp_frac) const { | |
| 45 *ntp_secs = time_now_ms_ / 1000 + kNtpJan1970; | |
| 46 int64_t remainder_ms = time_now_ms_ % 1000; | |
| 47 *ntp_frac = static_cast<uint32_t>( | |
| 48 static_cast<double>(remainder_ms) * kNtpFracPerMs + 0.5); | |
| 49 } | |
| 50 | |
| 51 uint32_t NowRtp(int frequency, uint32_t offset) const { | |
| 52 return frequency * time_now_ms_ / 1000 + offset; | |
| 53 } | |
| 54 | |
| 55 void IncreaseTimeMs(int64_t inc) { | |
| 56 time_now_ms_ += inc; | |
| 57 } | |
| 58 | |
| 59 int64_t time_now_ms() const { | |
| 60 return time_now_ms_; | |
| 61 } | |
| 62 | |
| 63 private: | |
| 64 // January 1970, in NTP seconds. | |
| 65 const uint32_t kNtpJan1970; | |
| 66 int64_t time_now_ms_; | |
| 67 }; | |
| 68 | |
| 69 class StreamSynchronizationTest : public ::testing::Test { | |
| 70 protected: | |
| 71 virtual void SetUp() { | |
| 72 sync_ = new StreamSynchronization(0, 0); | |
| 73 send_time_ = new Time(kSendTimeOffsetMs); | |
| 74 receive_time_ = new Time(kReceiveTimeOffsetMs); | |
| 75 audio_clock_drift_ = 1.0; | |
| 76 video_clock_drift_ = 1.0; | |
| 77 } | |
| 78 | |
| 79 virtual void TearDown() { | |
| 80 delete sync_; | |
| 81 delete send_time_; | |
| 82 delete receive_time_; | |
| 83 } | |
| 84 | |
| 85 // Generates the necessary RTCP measurements and RTP timestamps and computes | |
| 86 // the audio and video delays needed to get the two streams in sync. | |
| 87 // |audio_delay_ms| and |video_delay_ms| are the number of milliseconds after | |
| 88 // capture which the frames are rendered. | |
| 89 // |current_audio_delay_ms| is the number of milliseconds which audio is | |
| 90 // currently being delayed by the receiver. | |
| 91 bool DelayedStreams(int audio_delay_ms, | |
| 92 int video_delay_ms, | |
| 93 int current_audio_delay_ms, | |
| 94 int* extra_audio_delay_ms, | |
| 95 int* total_video_delay_ms) { | |
| 96 int audio_frequency = static_cast<int>(kDefaultAudioFrequency * | |
| 97 audio_clock_drift_ + 0.5); | |
| 98 int audio_offset = 0; | |
| 99 int video_frequency = static_cast<int>(kDefaultVideoFrequency * | |
| 100 video_clock_drift_ + 0.5); | |
| 101 int video_offset = 0; | |
| 102 StreamSynchronization::Measurements audio; | |
| 103 StreamSynchronization::Measurements video; | |
| 104 // Generate NTP/RTP timestamp pair for both streams corresponding to RTCP. | |
| 105 audio.rtcp.push_front(send_time_->GenerateRtcp(audio_frequency, | |
| 106 audio_offset)); | |
| 107 send_time_->IncreaseTimeMs(100); | |
| 108 receive_time_->IncreaseTimeMs(100); | |
| 109 video.rtcp.push_front(send_time_->GenerateRtcp(video_frequency, | |
| 110 video_offset)); | |
| 111 send_time_->IncreaseTimeMs(900); | |
| 112 receive_time_->IncreaseTimeMs(900); | |
| 113 audio.rtcp.push_front(send_time_->GenerateRtcp(audio_frequency, | |
| 114 audio_offset)); | |
| 115 send_time_->IncreaseTimeMs(100); | |
| 116 receive_time_->IncreaseTimeMs(100); | |
| 117 video.rtcp.push_front(send_time_->GenerateRtcp(video_frequency, | |
| 118 video_offset)); | |
| 119 send_time_->IncreaseTimeMs(900); | |
| 120 receive_time_->IncreaseTimeMs(900); | |
| 121 | |
| 122 // Capture an audio and a video frame at the same time. | |
| 123 audio.latest_timestamp = send_time_->NowRtp(audio_frequency, | |
| 124 audio_offset); | |
| 125 video.latest_timestamp = send_time_->NowRtp(video_frequency, | |
| 126 video_offset); | |
| 127 | |
| 128 if (audio_delay_ms > video_delay_ms) { | |
| 129 // Audio later than video. | |
| 130 receive_time_->IncreaseTimeMs(video_delay_ms); | |
| 131 video.latest_receive_time_ms = receive_time_->time_now_ms(); | |
| 132 receive_time_->IncreaseTimeMs(audio_delay_ms - video_delay_ms); | |
| 133 audio.latest_receive_time_ms = receive_time_->time_now_ms(); | |
| 134 } else { | |
| 135 // Video later than audio. | |
| 136 receive_time_->IncreaseTimeMs(audio_delay_ms); | |
| 137 audio.latest_receive_time_ms = receive_time_->time_now_ms(); | |
| 138 receive_time_->IncreaseTimeMs(video_delay_ms - audio_delay_ms); | |
| 139 video.latest_receive_time_ms = receive_time_->time_now_ms(); | |
| 140 } | |
| 141 int relative_delay_ms; | |
| 142 StreamSynchronization::ComputeRelativeDelay(audio, video, | |
| 143 &relative_delay_ms); | |
| 144 EXPECT_EQ(video_delay_ms - audio_delay_ms, relative_delay_ms); | |
| 145 return sync_->ComputeDelays(relative_delay_ms, | |
| 146 current_audio_delay_ms, | |
| 147 extra_audio_delay_ms, | |
| 148 total_video_delay_ms); | |
| 149 } | |
| 150 | |
| 151 // Simulate audio playback 300 ms after capture and video rendering 100 ms | |
| 152 // after capture. Verify that the correct extra delays are calculated for | |
| 153 // audio and video, and that they change correctly when we simulate that | |
| 154 // NetEQ or the VCM adds more delay to the streams. | |
| 155 // TODO(holmer): This is currently wrong! We should simply change | |
| 156 // audio_delay_ms or video_delay_ms since those now include VCM and NetEQ | |
| 157 // delays. | |
| 158 void BothDelayedAudioLaterTest(int base_target_delay) { | |
| 159 int current_audio_delay_ms = base_target_delay; | |
| 160 int audio_delay_ms = base_target_delay + 300; | |
| 161 int video_delay_ms = base_target_delay + 100; | |
| 162 int extra_audio_delay_ms = 0; | |
| 163 int total_video_delay_ms = base_target_delay; | |
| 164 int filtered_move = (audio_delay_ms - video_delay_ms) / kSmoothingFilter; | |
| 165 const int kNeteqDelayIncrease = 50; | |
| 166 const int kNeteqDelayDecrease = 10; | |
| 167 | |
| 168 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 169 video_delay_ms, | |
| 170 current_audio_delay_ms, | |
| 171 &extra_audio_delay_ms, | |
| 172 &total_video_delay_ms)); | |
| 173 EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms); | |
| 174 EXPECT_EQ(base_target_delay, extra_audio_delay_ms); | |
| 175 current_audio_delay_ms = extra_audio_delay_ms; | |
| 176 | |
| 177 send_time_->IncreaseTimeMs(1000); | |
| 178 receive_time_->IncreaseTimeMs(1000 - std::max(audio_delay_ms, | |
| 179 video_delay_ms)); | |
| 180 // Simulate base_target_delay minimum delay in the VCM. | |
| 181 total_video_delay_ms = base_target_delay; | |
| 182 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 183 video_delay_ms, | |
| 184 current_audio_delay_ms, | |
| 185 &extra_audio_delay_ms, | |
| 186 &total_video_delay_ms)); | |
| 187 EXPECT_EQ(base_target_delay + 2 * filtered_move, total_video_delay_ms); | |
| 188 EXPECT_EQ(base_target_delay, extra_audio_delay_ms); | |
| 189 current_audio_delay_ms = extra_audio_delay_ms; | |
| 190 | |
| 191 send_time_->IncreaseTimeMs(1000); | |
| 192 receive_time_->IncreaseTimeMs(1000 - std::max(audio_delay_ms, | |
| 193 video_delay_ms)); | |
| 194 // Simulate base_target_delay minimum delay in the VCM. | |
| 195 total_video_delay_ms = base_target_delay; | |
| 196 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 197 video_delay_ms, | |
| 198 current_audio_delay_ms, | |
| 199 &extra_audio_delay_ms, | |
| 200 &total_video_delay_ms)); | |
| 201 EXPECT_EQ(base_target_delay + 3 * filtered_move, total_video_delay_ms); | |
| 202 EXPECT_EQ(base_target_delay, extra_audio_delay_ms); | |
| 203 | |
| 204 // Simulate that NetEQ introduces some audio delay. | |
| 205 current_audio_delay_ms = base_target_delay + kNeteqDelayIncrease; | |
| 206 send_time_->IncreaseTimeMs(1000); | |
| 207 receive_time_->IncreaseTimeMs(1000 - std::max(audio_delay_ms, | |
| 208 video_delay_ms)); | |
| 209 // Simulate base_target_delay minimum delay in the VCM. | |
| 210 total_video_delay_ms = base_target_delay; | |
| 211 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 212 video_delay_ms, | |
| 213 current_audio_delay_ms, | |
| 214 &extra_audio_delay_ms, | |
| 215 &total_video_delay_ms)); | |
| 216 filtered_move = 3 * filtered_move + | |
| 217 (kNeteqDelayIncrease + audio_delay_ms - video_delay_ms) / | |
| 218 kSmoothingFilter; | |
| 219 EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms); | |
| 220 EXPECT_EQ(base_target_delay, extra_audio_delay_ms); | |
| 221 | |
| 222 // Simulate that NetEQ reduces its delay. | |
| 223 current_audio_delay_ms = base_target_delay + kNeteqDelayDecrease; | |
| 224 send_time_->IncreaseTimeMs(1000); | |
| 225 receive_time_->IncreaseTimeMs(1000 - std::max(audio_delay_ms, | |
| 226 video_delay_ms)); | |
| 227 // Simulate base_target_delay minimum delay in the VCM. | |
| 228 total_video_delay_ms = base_target_delay; | |
| 229 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 230 video_delay_ms, | |
| 231 current_audio_delay_ms, | |
| 232 &extra_audio_delay_ms, | |
| 233 &total_video_delay_ms)); | |
| 234 | |
| 235 filtered_move = filtered_move + | |
| 236 (kNeteqDelayDecrease + audio_delay_ms - video_delay_ms) / | |
| 237 kSmoothingFilter; | |
| 238 | |
| 239 EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms); | |
| 240 EXPECT_EQ(base_target_delay, extra_audio_delay_ms); | |
| 241 } | |
| 242 | |
| 243 void BothDelayedVideoLaterTest(int base_target_delay) { | |
| 244 int current_audio_delay_ms = base_target_delay; | |
| 245 int audio_delay_ms = base_target_delay + 100; | |
| 246 int video_delay_ms = base_target_delay + 300; | |
| 247 int extra_audio_delay_ms = 0; | |
| 248 int total_video_delay_ms = base_target_delay; | |
| 249 | |
| 250 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 251 video_delay_ms, | |
| 252 current_audio_delay_ms, | |
| 253 &extra_audio_delay_ms, | |
| 254 &total_video_delay_ms)); | |
| 255 EXPECT_EQ(base_target_delay, total_video_delay_ms); | |
| 256 // The audio delay is not allowed to change more than this in 1 second. | |
| 257 EXPECT_GE(base_target_delay + kMaxAudioDiffMs, extra_audio_delay_ms); | |
| 258 current_audio_delay_ms = extra_audio_delay_ms; | |
| 259 int current_extra_delay_ms = extra_audio_delay_ms; | |
| 260 | |
| 261 send_time_->IncreaseTimeMs(1000); | |
| 262 receive_time_->IncreaseTimeMs(800); | |
| 263 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 264 video_delay_ms, | |
| 265 current_audio_delay_ms, | |
| 266 &extra_audio_delay_ms, | |
| 267 &total_video_delay_ms)); | |
| 268 EXPECT_EQ(base_target_delay, total_video_delay_ms); | |
| 269 // The audio delay is not allowed to change more than the half of the | |
| 270 // required change in delay. | |
| 271 EXPECT_EQ(current_extra_delay_ms + MaxAudioDelayIncrease( | |
| 272 current_audio_delay_ms, | |
| 273 base_target_delay + video_delay_ms - audio_delay_ms), | |
| 274 extra_audio_delay_ms); | |
| 275 current_audio_delay_ms = extra_audio_delay_ms; | |
| 276 current_extra_delay_ms = extra_audio_delay_ms; | |
| 277 | |
| 278 send_time_->IncreaseTimeMs(1000); | |
| 279 receive_time_->IncreaseTimeMs(800); | |
| 280 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 281 video_delay_ms, | |
| 282 current_audio_delay_ms, | |
| 283 &extra_audio_delay_ms, | |
| 284 &total_video_delay_ms)); | |
| 285 EXPECT_EQ(base_target_delay, total_video_delay_ms); | |
| 286 // The audio delay is not allowed to change more than the half of the | |
| 287 // required change in delay. | |
| 288 EXPECT_EQ(current_extra_delay_ms + MaxAudioDelayIncrease( | |
| 289 current_audio_delay_ms, | |
| 290 base_target_delay + video_delay_ms - audio_delay_ms), | |
| 291 extra_audio_delay_ms); | |
| 292 current_extra_delay_ms = extra_audio_delay_ms; | |
| 293 | |
| 294 // Simulate that NetEQ for some reason reduced the delay. | |
| 295 current_audio_delay_ms = base_target_delay + 10; | |
| 296 send_time_->IncreaseTimeMs(1000); | |
| 297 receive_time_->IncreaseTimeMs(800); | |
| 298 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 299 video_delay_ms, | |
| 300 current_audio_delay_ms, | |
| 301 &extra_audio_delay_ms, | |
| 302 &total_video_delay_ms)); | |
| 303 EXPECT_EQ(base_target_delay, total_video_delay_ms); | |
| 304 // Since we only can ask NetEQ for a certain amount of extra delay, and | |
| 305 // we only measure the total NetEQ delay, we will ask for additional delay | |
| 306 // here to try to stay in sync. | |
| 307 EXPECT_EQ(current_extra_delay_ms + MaxAudioDelayIncrease( | |
| 308 current_audio_delay_ms, | |
| 309 base_target_delay + video_delay_ms - audio_delay_ms), | |
| 310 extra_audio_delay_ms); | |
| 311 current_extra_delay_ms = extra_audio_delay_ms; | |
| 312 | |
| 313 // Simulate that NetEQ for some reason significantly increased the delay. | |
| 314 current_audio_delay_ms = base_target_delay + 350; | |
| 315 send_time_->IncreaseTimeMs(1000); | |
| 316 receive_time_->IncreaseTimeMs(800); | |
| 317 EXPECT_TRUE(DelayedStreams(audio_delay_ms, | |
| 318 video_delay_ms, | |
| 319 current_audio_delay_ms, | |
| 320 &extra_audio_delay_ms, | |
| 321 &total_video_delay_ms)); | |
| 322 EXPECT_EQ(base_target_delay, total_video_delay_ms); | |
| 323 // The audio delay is not allowed to change more than the half of the | |
| 324 // required change in delay. | |
| 325 EXPECT_EQ(current_extra_delay_ms + MaxAudioDelayIncrease( | |
| 326 current_audio_delay_ms, | |
| 327 base_target_delay + video_delay_ms - audio_delay_ms), | |
| 328 extra_audio_delay_ms); | |
| 329 } | |
| 330 | |
| 331 int MaxAudioDelayIncrease(int current_audio_delay_ms, int delay_ms) { | |
| 332 return std::min((delay_ms - current_audio_delay_ms) / kSmoothingFilter, | |
| 333 static_cast<int>(kMaxAudioDiffMs)); | |
| 334 } | |
| 335 | |
| 336 int MaxAudioDelayDecrease(int current_audio_delay_ms, int delay_ms) { | |
| 337 return std::max((delay_ms - current_audio_delay_ms) / kSmoothingFilter, | |
| 338 -kMaxAudioDiffMs); | |
| 339 } | |
| 340 | |
| 341 enum { kSendTimeOffsetMs = 98765 }; | |
| 342 enum { kReceiveTimeOffsetMs = 43210 }; | |
| 343 | |
| 344 StreamSynchronization* sync_; | |
| 345 Time* send_time_; // The simulated clock at the sender. | |
| 346 Time* receive_time_; // The simulated clock at the receiver. | |
| 347 double audio_clock_drift_; | |
| 348 double video_clock_drift_; | |
| 349 }; | |
| 350 | |
| 351 TEST_F(StreamSynchronizationTest, NoDelay) { | |
| 352 uint32_t current_audio_delay_ms = 0; | |
| 353 int extra_audio_delay_ms = 0; | |
| 354 int total_video_delay_ms = 0; | |
| 355 | |
| 356 EXPECT_FALSE(DelayedStreams(0, 0, current_audio_delay_ms, | |
| 357 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 358 EXPECT_EQ(0, extra_audio_delay_ms); | |
| 359 EXPECT_EQ(0, total_video_delay_ms); | |
| 360 } | |
| 361 | |
| 362 TEST_F(StreamSynchronizationTest, VideoDelay) { | |
| 363 uint32_t current_audio_delay_ms = 0; | |
| 364 int delay_ms = 200; | |
| 365 int extra_audio_delay_ms = 0; | |
| 366 int total_video_delay_ms = 0; | |
| 367 | |
| 368 EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms, | |
| 369 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 370 EXPECT_EQ(0, extra_audio_delay_ms); | |
| 371 // The video delay is not allowed to change more than this in 1 second. | |
| 372 EXPECT_EQ(delay_ms / kSmoothingFilter, total_video_delay_ms); | |
| 373 | |
| 374 send_time_->IncreaseTimeMs(1000); | |
| 375 receive_time_->IncreaseTimeMs(800); | |
| 376 // Simulate 0 minimum delay in the VCM. | |
| 377 total_video_delay_ms = 0; | |
| 378 EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms, | |
| 379 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 380 EXPECT_EQ(0, extra_audio_delay_ms); | |
| 381 // The video delay is not allowed to change more than this in 1 second. | |
| 382 EXPECT_EQ(2 * delay_ms / kSmoothingFilter, total_video_delay_ms); | |
| 383 | |
| 384 send_time_->IncreaseTimeMs(1000); | |
| 385 receive_time_->IncreaseTimeMs(800); | |
| 386 // Simulate 0 minimum delay in the VCM. | |
| 387 total_video_delay_ms = 0; | |
| 388 EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms, | |
| 389 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 390 EXPECT_EQ(0, extra_audio_delay_ms); | |
| 391 EXPECT_EQ(3 * delay_ms / kSmoothingFilter, total_video_delay_ms); | |
| 392 } | |
| 393 | |
| 394 TEST_F(StreamSynchronizationTest, AudioDelay) { | |
| 395 int current_audio_delay_ms = 0; | |
| 396 int delay_ms = 200; | |
| 397 int extra_audio_delay_ms = 0; | |
| 398 int total_video_delay_ms = 0; | |
| 399 | |
| 400 EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms, | |
| 401 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 402 EXPECT_EQ(0, total_video_delay_ms); | |
| 403 // The audio delay is not allowed to change more than this in 1 second. | |
| 404 EXPECT_EQ(delay_ms / kSmoothingFilter, extra_audio_delay_ms); | |
| 405 current_audio_delay_ms = extra_audio_delay_ms; | |
| 406 int current_extra_delay_ms = extra_audio_delay_ms; | |
| 407 | |
| 408 send_time_->IncreaseTimeMs(1000); | |
| 409 receive_time_->IncreaseTimeMs(800); | |
| 410 EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms, | |
| 411 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 412 EXPECT_EQ(0, total_video_delay_ms); | |
| 413 // The audio delay is not allowed to change more than the half of the required | |
| 414 // change in delay. | |
| 415 EXPECT_EQ(current_extra_delay_ms + | |
| 416 MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms), | |
| 417 extra_audio_delay_ms); | |
| 418 current_audio_delay_ms = extra_audio_delay_ms; | |
| 419 current_extra_delay_ms = extra_audio_delay_ms; | |
| 420 | |
| 421 send_time_->IncreaseTimeMs(1000); | |
| 422 receive_time_->IncreaseTimeMs(800); | |
| 423 EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms, | |
| 424 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 425 EXPECT_EQ(0, total_video_delay_ms); | |
| 426 // The audio delay is not allowed to change more than the half of the required | |
| 427 // change in delay. | |
| 428 EXPECT_EQ(current_extra_delay_ms + | |
| 429 MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms), | |
| 430 extra_audio_delay_ms); | |
| 431 current_extra_delay_ms = extra_audio_delay_ms; | |
| 432 | |
| 433 // Simulate that NetEQ for some reason reduced the delay. | |
| 434 current_audio_delay_ms = 10; | |
| 435 send_time_->IncreaseTimeMs(1000); | |
| 436 receive_time_->IncreaseTimeMs(800); | |
| 437 EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms, | |
| 438 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 439 EXPECT_EQ(0, total_video_delay_ms); | |
| 440 // Since we only can ask NetEQ for a certain amount of extra delay, and | |
| 441 // we only measure the total NetEQ delay, we will ask for additional delay | |
| 442 // here to try to | |
| 443 EXPECT_EQ(current_extra_delay_ms + | |
| 444 MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms), | |
| 445 extra_audio_delay_ms); | |
| 446 current_extra_delay_ms = extra_audio_delay_ms; | |
| 447 | |
| 448 // Simulate that NetEQ for some reason significantly increased the delay. | |
| 449 current_audio_delay_ms = 350; | |
| 450 send_time_->IncreaseTimeMs(1000); | |
| 451 receive_time_->IncreaseTimeMs(800); | |
| 452 EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms, | |
| 453 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 454 EXPECT_EQ(0, total_video_delay_ms); | |
| 455 // The audio delay is not allowed to change more than the half of the required | |
| 456 // change in delay. | |
| 457 EXPECT_EQ(current_extra_delay_ms + | |
| 458 MaxAudioDelayDecrease(current_audio_delay_ms, delay_ms), | |
| 459 extra_audio_delay_ms); | |
| 460 } | |
| 461 | |
| 462 TEST_F(StreamSynchronizationTest, BothDelayedVideoLater) { | |
| 463 BothDelayedVideoLaterTest(0); | |
| 464 } | |
| 465 | |
| 466 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterAudioClockDrift) { | |
| 467 audio_clock_drift_ = 1.05; | |
| 468 BothDelayedVideoLaterTest(0); | |
| 469 } | |
| 470 | |
| 471 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterVideoClockDrift) { | |
| 472 video_clock_drift_ = 1.05; | |
| 473 BothDelayedVideoLaterTest(0); | |
| 474 } | |
| 475 | |
| 476 TEST_F(StreamSynchronizationTest, BothDelayedAudioLater) { | |
| 477 BothDelayedAudioLaterTest(0); | |
| 478 } | |
| 479 | |
| 480 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDrift) { | |
| 481 audio_clock_drift_ = 1.05; | |
| 482 BothDelayedAudioLaterTest(0); | |
| 483 } | |
| 484 | |
| 485 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDrift) { | |
| 486 video_clock_drift_ = 1.05; | |
| 487 BothDelayedAudioLaterTest(0); | |
| 488 } | |
| 489 | |
| 490 TEST_F(StreamSynchronizationTest, BaseDelay) { | |
| 491 int base_target_delay_ms = 2000; | |
| 492 int current_audio_delay_ms = 2000; | |
| 493 int extra_audio_delay_ms = 0; | |
| 494 int total_video_delay_ms = base_target_delay_ms; | |
| 495 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 496 // We are in sync don't change. | |
| 497 EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms, | |
| 498 current_audio_delay_ms, | |
| 499 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 500 // Triggering another call with the same values. Delay should not be modified. | |
| 501 base_target_delay_ms = 2000; | |
| 502 current_audio_delay_ms = base_target_delay_ms; | |
| 503 total_video_delay_ms = base_target_delay_ms; | |
| 504 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 505 // We are in sync don't change. | |
| 506 EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms, | |
| 507 current_audio_delay_ms, | |
| 508 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 509 // Changing delay value - intended to test this module only. In practice it | |
| 510 // would take VoE time to adapt. | |
| 511 base_target_delay_ms = 5000; | |
| 512 current_audio_delay_ms = base_target_delay_ms; | |
| 513 total_video_delay_ms = base_target_delay_ms; | |
| 514 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 515 // We are in sync don't change. | |
| 516 EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms, | |
| 517 current_audio_delay_ms, | |
| 518 &extra_audio_delay_ms, &total_video_delay_ms)); | |
| 519 } | |
| 520 | |
| 521 TEST_F(StreamSynchronizationTest, BothDelayedAudioLaterWithBaseDelay) { | |
| 522 int base_target_delay_ms = 3000; | |
| 523 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 524 BothDelayedAudioLaterTest(base_target_delay_ms); | |
| 525 } | |
| 526 | |
| 527 TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDriftWithBaseDelay) { | |
| 528 int base_target_delay_ms = 3000; | |
| 529 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 530 audio_clock_drift_ = 1.05; | |
| 531 BothDelayedAudioLaterTest(base_target_delay_ms); | |
| 532 } | |
| 533 | |
| 534 TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDriftWithBaseDelay) { | |
| 535 int base_target_delay_ms = 3000; | |
| 536 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 537 video_clock_drift_ = 1.05; | |
| 538 BothDelayedAudioLaterTest(base_target_delay_ms); | |
| 539 } | |
| 540 | |
| 541 TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterWithBaseDelay) { | |
| 542 int base_target_delay_ms = 2000; | |
| 543 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 544 BothDelayedVideoLaterTest(base_target_delay_ms); | |
| 545 } | |
| 546 | |
| 547 TEST_F(StreamSynchronizationTest, | |
| 548 BothDelayedVideoLaterAudioClockDriftWithBaseDelay) { | |
| 549 int base_target_delay_ms = 2000; | |
| 550 audio_clock_drift_ = 1.05; | |
| 551 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 552 BothDelayedVideoLaterTest(base_target_delay_ms); | |
| 553 } | |
| 554 | |
| 555 TEST_F(StreamSynchronizationTest, | |
| 556 BothDelayedVideoLaterVideoClockDriftWithBaseDelay) { | |
| 557 int base_target_delay_ms = 2000; | |
| 558 video_clock_drift_ = 1.05; | |
| 559 sync_->SetTargetBufferingDelay(base_target_delay_ms); | |
| 560 BothDelayedVideoLaterTest(base_target_delay_ms); | |
| 561 } | |
| 562 | |
| 563 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1507903005:
Revert of Merge webrtc/video_engine/ into webrtc/video/ (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master