admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

StreamSynchronizationTest: rename and make some variables const.

Browse Source 
Bug: none
Change-Id: I5c452b0d2f58b2821db31b19506de2ba73480748
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/168125
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Commit-Queue: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#30537}
This commit is contained in:
Åsa Persson 2020-02-03 11:13:20 +01:00 committed by Commit Bot
parent 6baceb9b18
commit 0e57858fa9
1 changed files with 216 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

455
video/stream_synchronization_unittest.cc
View File

@ -18,7 +18,7 @@
namespace webrtc {
namespace {
constexpr int kMaxAudioDiffMs = 80; // From stream_synchronization.cc
constexpr int kMaxChangeMs = 80; // From stream_synchronization.cc
constexpr int kDefaultAudioFrequency = 8000;
constexpr int kDefaultVideoFrequency = 90000;
constexpr int kSmoothingFilter = 4 * 2;
@ -33,13 +33,13 @@ class StreamSynchronizationTest : public ::testing::Test {
// Generates the necessary RTCP measurements and RTP timestamps and computes
// the audio and video delays needed to get the two streams in sync.
// |audio_delay_ms| and |video_delay_ms| are the number of milliseconds after
// capture which the frames are rendered.
// capture which the frames are received.
// |current_audio_delay_ms| is the number of milliseconds which audio is
// currently being delayed by the receiver.
bool DelayedStreams(int audio_delay_ms,
int video_delay_ms,
int current_audio_delay_ms,
int* extra_audio_delay_ms,
int* total_audio_delay_ms,
int* total_video_delay_ms) {
int audio_frequency =
static_cast<int>(kDefaultAudioFrequency * audio_clock_drift_ + 0.5);
@ -95,186 +95,175 @@ class StreamSynchronizationTest : public ::testing::Test {
clock_receiver_.AdvanceTimeMilliseconds(video_delay_ms - audio_delay_ms);
video.latest_receive_time_ms = clock_receiver_.CurrentTime().ms();
}
int relative_delay_ms;
StreamSynchronization::ComputeRelativeDelay(audio, video,
&relative_delay_ms);
EXPECT_TRUE(StreamSynchronization::ComputeRelativeDelay(
audio, video, &relative_delay_ms));
EXPECT_EQ(video_delay_ms - audio_delay_ms, relative_delay_ms);
return sync_.ComputeDelays(relative_delay_ms, current_audio_delay_ms,
extra_audio_delay_ms, total_video_delay_ms);
total_audio_delay_ms, total_video_delay_ms);
}
// Simulate audio playback 300 ms after capture and video rendering 100 ms
// after capture. Verify that the correct extra delays are calculated for
// audio and video, and that they change correctly when we simulate that
// NetEQ or the VCM adds more delay to the streams.
// TODO(holmer): This is currently wrong! We should simply change
// audio_delay_ms or video_delay_ms since those now include VCM and NetEQ
// delays.
void BothDelayedAudioLaterTest(int base_target_delay) {
int current_audio_delay_ms = base_target_delay;
int audio_delay_ms = base_target_delay + 300;
int video_delay_ms = base_target_delay + 100;
int extra_audio_delay_ms = 0;
int total_video_delay_ms = base_target_delay;
int filtered_move = (audio_delay_ms - video_delay_ms) / kSmoothingFilter;
const int kNeteqDelayIncrease = 50;
const int kNeteqDelayDecrease = 10;
void BothDelayedAudioLaterTest(int base_target_delay_ms) {
const int kAudioDelayMs = base_target_delay_ms + 300;
const int kVideoDelayMs = base_target_delay_ms + 100;
int current_audio_delay_ms = base_target_delay_ms;
int total_audio_delay_ms = 0;
int total_video_delay_ms = base_target_delay_ms;
int filtered_move = (kAudioDelayMs - kVideoDelayMs) / kSmoothingFilter;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay, extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
// Set new current delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(
1000 - std::max(audio_delay_ms, video_delay_ms));
// Simulate base_target_delay minimum delay in the VCM.
total_video_delay_ms = base_target_delay;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
1000 - std::max(kAudioDelayMs, kVideoDelayMs));
// Simulate base_target_delay_ms minimum delay in the VCM.
total_video_delay_ms = base_target_delay_ms;
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay + 2 * filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay, extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(base_target_delay_ms + 2 * filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
// Set new current delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(
1000 - std::max(audio_delay_ms, video_delay_ms));
// Simulate base_target_delay minimum delay in the VCM.
total_video_delay_ms = base_target_delay;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
1000 - std::max(kAudioDelayMs, kVideoDelayMs));
// Simulate base_target_delay_ms minimum delay in the VCM.
total_video_delay_ms = base_target_delay_ms;
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay + 3 * filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay, extra_audio_delay_ms);
EXPECT_EQ(base_target_delay_ms + 3 * filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
// Simulate that NetEQ introduces some audio delay.
current_audio_delay_ms = base_target_delay + kNeteqDelayIncrease;
const int kNeteqDelayIncrease = 50;
current_audio_delay_ms = base_target_delay_ms + kNeteqDelayIncrease;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(
1000 - std::max(audio_delay_ms, video_delay_ms));
// Simulate base_target_delay minimum delay in the VCM.
total_video_delay_ms = base_target_delay;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
1000 - std::max(kAudioDelayMs, kVideoDelayMs));
// Simulate base_target_delay_ms minimum delay in the VCM.
total_video_delay_ms = base_target_delay_ms;
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
filtered_move = 3 * filtered_move +
(kNeteqDelayIncrease + audio_delay_ms - video_delay_ms) /
(kNeteqDelayIncrease + kAudioDelayMs - kVideoDelayMs) /
kSmoothingFilter;
EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay, extra_audio_delay_ms);
EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
// Simulate that NetEQ reduces its delay.
current_audio_delay_ms = base_target_delay + kNeteqDelayDecrease;
const int kNeteqDelayDecrease = 10;
current_audio_delay_ms = base_target_delay_ms + kNeteqDelayDecrease;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(
1000 - std::max(audio_delay_ms, video_delay_ms));
// Simulate base_target_delay minimum delay in the VCM.
total_video_delay_ms = base_target_delay;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
1000 - std::max(kAudioDelayMs, kVideoDelayMs));
// Simulate base_target_delay_ms minimum delay in the VCM.
total_video_delay_ms = base_target_delay_ms;
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
filtered_move = filtered_move +
(kNeteqDelayDecrease + audio_delay_ms - video_delay_ms) /
kSmoothingFilter;
EXPECT_EQ(base_target_delay + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay, extra_audio_delay_ms);
filtered_move =
filtered_move + (kNeteqDelayDecrease + kAudioDelayMs - kVideoDelayMs) /
kSmoothingFilter;
EXPECT_EQ(base_target_delay_ms + filtered_move, total_video_delay_ms);
EXPECT_EQ(base_target_delay_ms, total_audio_delay_ms);
}
void BothDelayedVideoLaterTest(int base_target_delay) {
int current_audio_delay_ms = base_target_delay;
int audio_delay_ms = base_target_delay + 100;
int video_delay_ms = base_target_delay + 300;
int extra_audio_delay_ms = 0;
int total_video_delay_ms = base_target_delay;
void BothDelayedVideoLaterTest(int base_target_delay_ms) {
const int kAudioDelayMs = base_target_delay_ms + 100;
const int kVideoDelayMs = base_target_delay_ms + 300;
int current_audio_delay_ms = base_target_delay_ms;
int total_audio_delay_ms = 0;
int total_video_delay_ms = base_target_delay_ms;
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay, total_video_delay_ms);
// The audio delay is not allowed to change more than this in 1 second.
EXPECT_GE(base_target_delay + kMaxAudioDiffMs, extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
int current_extra_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
// The audio delay is not allowed to change more than this.
EXPECT_GE(base_target_delay_ms + kMaxChangeMs, total_audio_delay_ms);
int last_total_audio_delay_ms = total_audio_delay_ms;
// Set new current audio delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the
// required change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(
EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(
current_audio_delay_ms,
base_target_delay + video_delay_ms - audio_delay_ms),
extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
current_extra_delay_ms = extra_audio_delay_ms;
base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Set new current audio delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the
// required change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(
EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(
current_audio_delay_ms,
base_target_delay + video_delay_ms - audio_delay_ms),
extra_audio_delay_ms);
current_extra_delay_ms = extra_audio_delay_ms;
base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Simulate that NetEQ for some reason reduced the delay.
current_audio_delay_ms = base_target_delay + 10;
current_audio_delay_ms = base_target_delay_ms + 10;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay, total_video_delay_ms);
// Since we only can ask NetEQ for a certain amount of extra delay, and
// we only measure the total NetEQ delay, we will ask for additional delay
// here to try to stay in sync.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(
EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(
current_audio_delay_ms,
base_target_delay + video_delay_ms - audio_delay_ms),
extra_audio_delay_ms);
current_extra_delay_ms = extra_audio_delay_ms;
base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Simulate that NetEQ for some reason significantly increased the delay.
current_audio_delay_ms = base_target_delay + 350;
current_audio_delay_ms = base_target_delay_ms + 350;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(audio_delay_ms, video_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(base_target_delay, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the
// required change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(
EXPECT_EQ(base_target_delay_ms, total_video_delay_ms);
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(
current_audio_delay_ms,
base_target_delay + video_delay_ms - audio_delay_ms),
extra_audio_delay_ms);
base_target_delay_ms + kVideoDelayMs - kAudioDelayMs),
total_audio_delay_ms);
}
int MaxAudioDelayIncrease(int current_audio_delay_ms, int delay_ms) {
return std::min((delay_ms - current_audio_delay_ms) / kSmoothingFilter,
kMaxAudioDiffMs);
}
int MaxAudioDelayDecrease(int current_audio_delay_ms, int delay_ms) {
return std::max((delay_ms - current_audio_delay_ms) / kSmoothingFilter,
-kMaxAudioDiffMs);
int MaxAudioDelayChangeMs(int current_audio_delay_ms, int delay_ms) const {
int diff_ms = (delay_ms - current_audio_delay_ms) / kSmoothingFilter;
diff_ms = std::min(diff_ms, kMaxChangeMs);
diff_ms = std::max(diff_ms, -kMaxChangeMs);
return diff_ms;
}
StreamSynchronization sync_;
@ -285,114 +274,113 @@ class StreamSynchronizationTest : public ::testing::Test {
};
TEST_F(StreamSynchronizationTest, NoDelay) {
uint32_t current_audio_delay_ms = 0;
int extra_audio_delay_ms = 0;
int total_audio_delay_ms = 0;
int total_video_delay_ms = 0;
EXPECT_FALSE(DelayedStreams(0, 0, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, extra_audio_delay_ms);
EXPECT_FALSE(DelayedStreams(/*audio_delay_ms=*/0, /*video_delay_ms=*/0,
/*current_audio_delay_ms=*/0,
&total_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, total_audio_delay_ms);
EXPECT_EQ(0, total_video_delay_ms);
}
TEST_F(StreamSynchronizationTest, VideoDelay) {
uint32_t current_audio_delay_ms = 0;
int delay_ms = 200;
int extra_audio_delay_ms = 0;
TEST_F(StreamSynchronizationTest, VideoDelayed) {
const int kAudioDelayMs = 200;
int total_audio_delay_ms = 0;
int total_video_delay_ms = 0;
EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, extra_audio_delay_ms);
// The video delay is not allowed to change more than this in 1 second.
EXPECT_EQ(delay_ms / kSmoothingFilter, total_video_delay_ms);
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
/*current_audio_delay_ms=*/0,
&total_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, total_audio_delay_ms);
// The delay is not allowed to change more than this.
EXPECT_EQ(kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
// Simulate 0 minimum delay in the VCM.
total_video_delay_ms = 0;
EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, extra_audio_delay_ms);
// The video delay is not allowed to change more than this in 1 second.
EXPECT_EQ(2 * delay_ms / kSmoothingFilter, total_video_delay_ms);
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
/*current_audio_delay_ms=*/0,
&total_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, total_audio_delay_ms);
EXPECT_EQ(2 * kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
// Simulate 0 minimum delay in the VCM.
total_video_delay_ms = 0;
EXPECT_TRUE(DelayedStreams(delay_ms, 0, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, extra_audio_delay_ms);
EXPECT_EQ(3 * delay_ms / kSmoothingFilter, total_video_delay_ms);
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(kAudioDelayMs, /*video_delay_ms=*/0,
/*current_audio_delay_ms=*/0,
&total_audio_delay_ms, &total_video_delay_ms));
EXPECT_EQ(0, total_audio_delay_ms);
EXPECT_EQ(3 * kAudioDelayMs / kSmoothingFilter, total_video_delay_ms);
}
TEST_F(StreamSynchronizationTest, AudioDelay) {
TEST_F(StreamSynchronizationTest, AudioDelayed) {
const int kVideoDelayMs = 200;
int current_audio_delay_ms = 0;
int delay_ms = 200;
int extra_audio_delay_ms = 0;
int total_audio_delay_ms = 0;
int total_video_delay_ms = 0;
EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(0, total_video_delay_ms);
// The audio delay is not allowed to change more than this in 1 second.
EXPECT_EQ(delay_ms / kSmoothingFilter, extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
int current_extra_delay_ms = extra_audio_delay_ms;
// The delay is not allowed to change more than this.
EXPECT_EQ(kVideoDelayMs / kSmoothingFilter, total_audio_delay_ms);
int last_total_audio_delay_ms = total_audio_delay_ms;
// Set new current audio delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(0, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the required
// change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms),
extra_audio_delay_ms);
current_audio_delay_ms = extra_audio_delay_ms;
current_extra_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Set new current audio delay.
current_audio_delay_ms = total_audio_delay_ms;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(0, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the required
// change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms),
extra_audio_delay_ms);
current_extra_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Simulate that NetEQ for some reason reduced the delay.
current_audio_delay_ms = 10;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(0, total_video_delay_ms);
// Since we only can ask NetEQ for a certain amount of extra delay, and
// we only measure the total NetEQ delay, we will ask for additional delay
// here to try to
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayIncrease(current_audio_delay_ms, delay_ms),
extra_audio_delay_ms);
current_extra_delay_ms = extra_audio_delay_ms;
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
total_audio_delay_ms);
last_total_audio_delay_ms = total_audio_delay_ms;
// Simulate that NetEQ for some reason significantly increased the delay.
current_audio_delay_ms = 350;
clock_sender_.AdvanceTimeMilliseconds(1000);
clock_receiver_.AdvanceTimeMilliseconds(800);
EXPECT_TRUE(DelayedStreams(0, delay_ms, current_audio_delay_ms,
&extra_audio_delay_ms, &total_video_delay_ms));
EXPECT_TRUE(DelayedStreams(/*audio_delay_ms=*/0, kVideoDelayMs,
current_audio_delay_ms, &total_audio_delay_ms,
&total_video_delay_ms));
EXPECT_EQ(0, total_video_delay_ms);
// The audio delay is not allowed to change more than the half of the required
// change in delay.
EXPECT_EQ(current_extra_delay_ms +
MaxAudioDelayDecrease(current_audio_delay_ms, delay_ms),
extra_audio_delay_ms);
EXPECT_EQ(last_total_audio_delay_ms +
MaxAudioDelayChangeMs(current_audio_delay_ms, kVideoDelayMs),
total_audio_delay_ms);
}
TEST_F(StreamSynchronizationTest, BothDelayedVideoLater) {
@ -423,77 +411,66 @@ TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDrift) {
BothDelayedAudioLaterTest(0);
}
TEST_F(StreamSynchronizationTest, BaseDelay) {
int base_target_delay_ms = 2000;
int current_audio_delay_ms = 2000;
int extra_audio_delay_ms = 0;
int total_video_delay_ms = base_target_delay_ms;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
// We are in sync don't change.
EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
&total_video_delay_ms));
// Triggering another call with the same values. Delay should not be modified.
base_target_delay_ms = 2000;
current_audio_delay_ms = base_target_delay_ms;
total_video_delay_ms = base_target_delay_ms;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
// We are in sync don't change.
EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
&total_video_delay_ms));
// Changing delay value - intended to test this module only. In practice it
// would take VoE time to adapt.
base_target_delay_ms = 5000;
current_audio_delay_ms = base_target_delay_ms;
total_video_delay_ms = base_target_delay_ms;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
// We are in sync don't change.
EXPECT_FALSE(DelayedStreams(base_target_delay_ms, base_target_delay_ms,
current_audio_delay_ms, &extra_audio_delay_ms,
&total_video_delay_ms));
TEST_F(StreamSynchronizationTest, BothEquallyDelayed) {
const int kDelayMs = 2000;
int current_audio_delay_ms = kDelayMs;
int total_audio_delay_ms = 0;
int total_video_delay_ms = kDelayMs;
// In sync, expect no change.
EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
&total_audio_delay_ms, &total_video_delay_ms));
// Trigger another call with the same values, delay should not be modified.
total_video_delay_ms = kDelayMs;
EXPECT_FALSE(DelayedStreams(kDelayMs, kDelayMs, current_audio_delay_ms,
&total_audio_delay_ms, &total_video_delay_ms));
// Change delay value, delay should not be modified.
const int kDelayMs2 = 5000;
current_audio_delay_ms = kDelayMs2;
total_video_delay_ms = kDelayMs2;
EXPECT_FALSE(DelayedStreams(kDelayMs2, kDelayMs2, current_audio_delay_ms,
&total_audio_delay_ms, &total_video_delay_ms));
}
TEST_F(StreamSynchronizationTest, BothDelayedAudioLaterWithBaseDelay) {
int base_target_delay_ms = 3000;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
BothDelayedAudioLaterTest(base_target_delay_ms);
const int kBaseTargetDelayMs = 3000;
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
BothDelayedAudioLaterTest(kBaseTargetDelayMs);
}
TEST_F(StreamSynchronizationTest, BothDelayedAudioClockDriftWithBaseDelay) {
int base_target_delay_ms = 3000;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
const int kBaseTargetDelayMs = 3000;
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
audio_clock_drift_ = 1.05;
BothDelayedAudioLaterTest(base_target_delay_ms);
BothDelayedAudioLaterTest(kBaseTargetDelayMs);
}
TEST_F(StreamSynchronizationTest, BothDelayedVideoClockDriftWithBaseDelay) {
int base_target_delay_ms = 3000;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
const int kBaseTargetDelayMs = 3000;
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
video_clock_drift_ = 1.05;
BothDelayedAudioLaterTest(base_target_delay_ms);
BothDelayedAudioLaterTest(kBaseTargetDelayMs);
}
TEST_F(StreamSynchronizationTest, BothDelayedVideoLaterWithBaseDelay) {
int base_target_delay_ms = 2000;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
BothDelayedVideoLaterTest(base_target_delay_ms);
const int kBaseTargetDelayMs = 2000;
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
BothDelayedVideoLaterTest(kBaseTargetDelayMs);
}
TEST_F(StreamSynchronizationTest,
BothDelayedVideoLaterAudioClockDriftWithBaseDelay) {
int base_target_delay_ms = 2000;
const int kBaseTargetDelayMs = 2000;
audio_clock_drift_ = 1.05;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
BothDelayedVideoLaterTest(base_target_delay_ms);
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
BothDelayedVideoLaterTest(kBaseTargetDelayMs);
}
TEST_F(StreamSynchronizationTest,
BothDelayedVideoLaterVideoClockDriftWithBaseDelay) {
int base_target_delay_ms = 2000;
const int kBaseTargetDelayMs = 2000;
video_clock_drift_ = 1.05;
sync_.SetTargetBufferingDelay(base_target_delay_ms);
BothDelayedVideoLaterTest(base_target_delay_ms);
sync_.SetTargetBufferingDelay(kBaseTargetDelayMs);
BothDelayedVideoLaterTest(kBaseTargetDelayMs);
}
} // namespace webrtc