henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 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 | // Unit tests for DelayManager class. |
| 12 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 13 | #include "modules/audio_coding/neteq/delay_manager.h" |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 14 | |
| 15 | #include <math.h> |
| 16 | |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 17 | #include <memory> |
| 18 | |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 19 | #include "modules/audio_coding/neteq/histogram.h" |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 20 | #include "modules/audio_coding/neteq/mock/mock_histogram.h" |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 21 | #include "modules/audio_coding/neteq/mock/mock_statistics_calculator.h" |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 22 | #include "rtc_base/checks.h" |
Minyue Li | 002fbb8 | 2018-10-04 11:31:03 +0200 | [diff] [blame] | 23 | #include "test/field_trial.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "test/gmock.h" |
| 25 | #include "test/gtest.h" |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 26 | |
| 27 | namespace webrtc { |
| 28 | |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 29 | namespace { |
| 30 | constexpr int kMaxNumberOfPackets = 240; |
| 31 | constexpr int kMinDelayMs = 0; |
| 32 | constexpr int kTimeStepMs = 10; |
| 33 | constexpr int kFs = 8000; |
| 34 | constexpr int kFrameSizeMs = 20; |
| 35 | constexpr int kTsIncrement = kFrameSizeMs * kFs / 1000; |
| 36 | constexpr int kMaxBufferSizeMs = kMaxNumberOfPackets * kFrameSizeMs; |
| 37 | constexpr int kDefaultHistogramQuantile = 1020054733; |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 38 | constexpr int kNumBuckets = 100; |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 39 | constexpr int kForgetFactor = 32745; |
| 40 | } // namespace |
| 41 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 42 | class DelayManagerTest : public ::testing::Test { |
| 43 | protected: |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 44 | DelayManagerTest(); |
| 45 | virtual void SetUp(); |
Minyue Li | 002fbb8 | 2018-10-04 11:31:03 +0200 | [diff] [blame] | 46 | void RecreateDelayManager(); |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 47 | absl::optional<int> InsertNextPacket(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 48 | void IncreaseTime(int inc_ms); |
| 49 | |
Minyue Li | 002fbb8 | 2018-10-04 11:31:03 +0200 | [diff] [blame] | 50 | std::unique_ptr<DelayManager> dm_; |
henrik.lundin | f393370 | 2016-04-28 01:53:52 -0700 | [diff] [blame] | 51 | TickTimer tick_timer_; |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 52 | MockStatisticsCalculator stats_; |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 53 | MockHistogram* mock_histogram_; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 54 | uint32_t ts_; |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 55 | bool use_mock_histogram_ = false; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 56 | }; |
| 57 | |
| 58 | DelayManagerTest::DelayManagerTest() |
Jakob Ivarsson | 39b934b | 2019-01-10 10:28:23 +0100 | [diff] [blame] | 59 | : dm_(nullptr), |
Jakob Ivarsson | 39b934b | 2019-01-10 10:28:23 +0100 | [diff] [blame] | 60 | ts_(0x12345678) {} |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 61 | |
| 62 | void DelayManagerTest::SetUp() { |
Minyue Li | 002fbb8 | 2018-10-04 11:31:03 +0200 | [diff] [blame] | 63 | RecreateDelayManager(); |
| 64 | } |
| 65 | |
| 66 | void DelayManagerTest::RecreateDelayManager() { |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 67 | if (use_mock_histogram_) { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 68 | mock_histogram_ = new MockHistogram(kNumBuckets, kForgetFactor); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 69 | std::unique_ptr<Histogram> histogram(mock_histogram_); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 70 | dm_ = std::make_unique<DelayManager>(kMaxNumberOfPackets, kMinDelayMs, |
| 71 | kDefaultHistogramQuantile, |
| 72 | &tick_timer_, std::move(histogram)); |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 73 | } else { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 74 | dm_ = DelayManager::Create(kMaxNumberOfPackets, kMinDelayMs, &tick_timer_); |
Jakob Ivarsson | 1eb3d7e | 2019-02-21 15:42:31 +0100 | [diff] [blame] | 75 | } |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 76 | dm_->SetPacketAudioLength(kFrameSizeMs); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 77 | } |
| 78 | |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 79 | absl::optional<int> DelayManagerTest::InsertNextPacket() { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 80 | auto relative_delay = dm_->Update(ts_, kFs); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 81 | ts_ += kTsIncrement; |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 82 | return relative_delay; |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | void DelayManagerTest::IncreaseTime(int inc_ms) { |
| 86 | for (int t = 0; t < inc_ms; t += kTimeStepMs) { |
henrik.lundin | f393370 | 2016-04-28 01:53:52 -0700 | [diff] [blame] | 87 | tick_timer_.Increment(); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 88 | } |
| 89 | } |
Ruslan Burakov | 1e193fa | 2019-05-15 14:31:22 +0200 | [diff] [blame] | 90 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 91 | TEST_F(DelayManagerTest, CreateAndDestroy) { |
| 92 | // Nothing to do here. The test fixture creates and destroys the DelayManager |
| 93 | // object. |
| 94 | } |
| 95 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 96 | TEST_F(DelayManagerTest, UpdateNormal) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 97 | // First packet arrival. |
| 98 | InsertNextPacket(); |
| 99 | // Advance time by one frame size. |
| 100 | IncreaseTime(kFrameSizeMs); |
| 101 | // Second packet arrival. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 102 | InsertNextPacket(); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 103 | EXPECT_EQ(20, dm_->TargetDelayMs()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | TEST_F(DelayManagerTest, UpdateLongInterArrivalTime) { |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 107 | // First packet arrival. |
| 108 | InsertNextPacket(); |
| 109 | // Advance time by two frame size. |
| 110 | IncreaseTime(2 * kFrameSizeMs); |
| 111 | // Second packet arrival. |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 112 | InsertNextPacket(); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 113 | EXPECT_EQ(40, dm_->TargetDelayMs()); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 114 | } |
| 115 | |
Niels Möller | 18f1adc | 2018-08-23 08:40:41 +0200 | [diff] [blame] | 116 | TEST_F(DelayManagerTest, MaxDelay) { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 117 | const int kExpectedTarget = 5 * kFrameSizeMs; |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 118 | // First packet arrival. |
| 119 | InsertNextPacket(); |
| 120 | // Second packet arrival. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 121 | IncreaseTime(kExpectedTarget); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 122 | InsertNextPacket(); |
| 123 | |
| 124 | // No limit is set. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 125 | EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs()); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 126 | |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 127 | const int kMaxDelayMs = 3 * kFrameSizeMs; |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 128 | EXPECT_TRUE(dm_->SetMaximumDelay(kMaxDelayMs)); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 129 | IncreaseTime(kFrameSizeMs); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 130 | InsertNextPacket(); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 131 | EXPECT_EQ(kMaxDelayMs, dm_->TargetDelayMs()); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 132 | |
| 133 | // Target level at least should be one packet. |
| 134 | EXPECT_FALSE(dm_->SetMaximumDelay(kFrameSizeMs - 1)); |
| 135 | } |
| 136 | |
Niels Möller | 18f1adc | 2018-08-23 08:40:41 +0200 | [diff] [blame] | 137 | TEST_F(DelayManagerTest, MinDelay) { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 138 | const int kExpectedTarget = 5 * kFrameSizeMs; |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 139 | // First packet arrival. |
| 140 | InsertNextPacket(); |
| 141 | // Second packet arrival. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 142 | IncreaseTime(kExpectedTarget); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 143 | InsertNextPacket(); |
| 144 | |
| 145 | // No limit is applied. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 146 | EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs()); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 147 | |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 148 | int kMinDelayMs = 7 * kFrameSizeMs; |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 149 | dm_->SetMinimumDelay(kMinDelayMs); |
Jakob Ivarsson | 507f434 | 2019-09-03 13:04:41 +0200 | [diff] [blame] | 150 | IncreaseTime(kFrameSizeMs); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 151 | InsertNextPacket(); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 152 | EXPECT_EQ(kMinDelayMs, dm_->TargetDelayMs()); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 153 | } |
| 154 | |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 155 | TEST_F(DelayManagerTest, BaseMinimumDelayCheckValidRange) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 156 | // Base minimum delay should be between [0, 10000] milliseconds. |
| 157 | EXPECT_FALSE(dm_->SetBaseMinimumDelay(-1)); |
| 158 | EXPECT_FALSE(dm_->SetBaseMinimumDelay(10001)); |
| 159 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), 0); |
| 160 | |
| 161 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(7999)); |
| 162 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), 7999); |
| 163 | } |
| 164 | |
| 165 | TEST_F(DelayManagerTest, BaseMinimumDelayLowerThanMinimumDelay) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 166 | constexpr int kBaseMinimumDelayMs = 100; |
| 167 | constexpr int kMinimumDelayMs = 200; |
| 168 | |
| 169 | // Base minimum delay sets lower bound on minimum. That is why when base |
| 170 | // minimum delay is lower than minimum delay we use minimum delay. |
| 171 | RTC_DCHECK_LT(kBaseMinimumDelayMs, kMinimumDelayMs); |
| 172 | |
| 173 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 174 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 175 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kMinimumDelayMs); |
| 176 | } |
| 177 | |
| 178 | TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanMinimumDelay) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 179 | constexpr int kBaseMinimumDelayMs = 70; |
| 180 | constexpr int kMinimumDelayMs = 30; |
| 181 | |
| 182 | // Base minimum delay sets lower bound on minimum. That is why when base |
| 183 | // minimum delay is greater than minimum delay we use base minimum delay. |
| 184 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMinimumDelayMs); |
| 185 | |
| 186 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 187 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 188 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kBaseMinimumDelayMs); |
| 189 | } |
| 190 | |
| 191 | TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanBufferSize) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 192 | constexpr int kBaseMinimumDelayMs = kMaxBufferSizeMs + 1; |
| 193 | constexpr int kMinimumDelayMs = 12; |
Ruslan Burakov | b35bacc | 2019-02-20 13:41:59 +0100 | [diff] [blame] | 194 | constexpr int kMaximumDelayMs = 20; |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 195 | constexpr int kMaxBufferSizeMsQ75 = 3 * kMaxBufferSizeMs / 4; |
| 196 | |
Ruslan Burakov | b35bacc | 2019-02-20 13:41:59 +0100 | [diff] [blame] | 197 | EXPECT_TRUE(dm_->SetMaximumDelay(kMaximumDelayMs)); |
| 198 | |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 199 | // Base minimum delay is greater than minimum delay, that is why we clamp |
| 200 | // it to current the highest possible value which is maximum delay. |
| 201 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMinimumDelayMs); |
| 202 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMaxBufferSizeMs); |
Ruslan Burakov | b35bacc | 2019-02-20 13:41:59 +0100 | [diff] [blame] | 203 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMaximumDelayMs); |
| 204 | RTC_DCHECK_LT(kMaximumDelayMs, kMaxBufferSizeMsQ75); |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 205 | |
| 206 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 207 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 208 | |
| 209 | // Unset maximum value. |
| 210 | EXPECT_TRUE(dm_->SetMaximumDelay(0)); |
| 211 | |
| 212 | // With maximum value unset, the highest possible value now is 75% of |
| 213 | // currently possible maximum buffer size. |
| 214 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kMaxBufferSizeMsQ75); |
| 215 | } |
| 216 | |
| 217 | TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanMaximumDelay) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 218 | constexpr int kMaximumDelayMs = 400; |
| 219 | constexpr int kBaseMinimumDelayMs = kMaximumDelayMs + 1; |
| 220 | constexpr int kMinimumDelayMs = 20; |
| 221 | |
| 222 | // Base minimum delay is greater than minimum delay, that is why we clamp |
| 223 | // it to current the highest possible value which is kMaximumDelayMs. |
| 224 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMinimumDelayMs); |
| 225 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMaximumDelayMs); |
| 226 | RTC_DCHECK_LT(kMaximumDelayMs, kMaxBufferSizeMs); |
| 227 | |
| 228 | EXPECT_TRUE(dm_->SetMaximumDelay(kMaximumDelayMs)); |
| 229 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 230 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 231 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kMaximumDelayMs); |
| 232 | } |
| 233 | |
| 234 | TEST_F(DelayManagerTest, BaseMinimumDelayLowerThanMaxSize) { |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 235 | constexpr int kMaximumDelayMs = 400; |
| 236 | constexpr int kBaseMinimumDelayMs = kMaximumDelayMs - 1; |
| 237 | constexpr int kMinimumDelayMs = 20; |
| 238 | |
| 239 | // Base minimum delay is greater than minimum delay, and lower than maximum |
| 240 | // delays that is why it is used. |
| 241 | RTC_DCHECK_GT(kBaseMinimumDelayMs, kMinimumDelayMs); |
| 242 | RTC_DCHECK_LT(kBaseMinimumDelayMs, kMaximumDelayMs); |
| 243 | |
| 244 | EXPECT_TRUE(dm_->SetMaximumDelay(kMaximumDelayMs)); |
| 245 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 246 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 247 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kBaseMinimumDelayMs); |
| 248 | } |
| 249 | |
| 250 | TEST_F(DelayManagerTest, MinimumDelayMemorization) { |
| 251 | // Check that when we increase base minimum delay to value higher than |
| 252 | // minimum delay then minimum delay is still memorized. This allows to |
| 253 | // restore effective minimum delay to memorized minimum delay value when we |
| 254 | // decrease base minimum delay. |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 255 | constexpr int kBaseMinimumDelayMsLow = 10; |
| 256 | constexpr int kMinimumDelayMs = 20; |
| 257 | constexpr int kBaseMinimumDelayMsHigh = 30; |
| 258 | |
| 259 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMsLow)); |
| 260 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 261 | // Minimum delay is used as it is higher than base minimum delay. |
| 262 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kMinimumDelayMs); |
| 263 | |
| 264 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMsHigh)); |
| 265 | // Base minimum delay is used as it is now higher than minimum delay. |
| 266 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), |
| 267 | kBaseMinimumDelayMsHigh); |
| 268 | |
| 269 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMsLow)); |
| 270 | // Check that minimum delay is memorized and is used again. |
| 271 | EXPECT_EQ(dm_->effective_minimum_delay_ms_for_test(), kMinimumDelayMs); |
| 272 | } |
| 273 | |
| 274 | TEST_F(DelayManagerTest, BaseMinimumDelay) { |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 275 | const int kExpectedTarget = 5 * kFrameSizeMs; |
Jakob Ivarsson | b1ae5cc | 2020-10-06 15:37:28 +0000 | [diff] [blame] | 276 | // First packet arrival. |
| 277 | InsertNextPacket(); |
| 278 | // Second packet arrival. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 279 | IncreaseTime(kExpectedTarget); |
Jakob Ivarsson | b1ae5cc | 2020-10-06 15:37:28 +0000 | [diff] [blame] | 280 | InsertNextPacket(); |
| 281 | |
| 282 | // No limit is applied. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 283 | EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs()); |
Jakob Ivarsson | ff9f646 | 2020-10-07 12:46:42 +0000 | [diff] [blame] | 284 | |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 285 | constexpr int kBaseMinimumDelayMs = 7 * kFrameSizeMs; |
Jakob Ivarsson | ff9f646 | 2020-10-07 12:46:42 +0000 | [diff] [blame] | 286 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 287 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs); |
| 288 | |
| 289 | IncreaseTime(kFrameSizeMs); |
| 290 | InsertNextPacket(); |
| 291 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 292 | EXPECT_EQ(kBaseMinimumDelayMs, dm_->TargetDelayMs()); |
Jakob Ivarsson | ff9f646 | 2020-10-07 12:46:42 +0000 | [diff] [blame] | 293 | } |
| 294 | |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 295 | TEST_F(DelayManagerTest, BaseMinimumDelayAffectsTargetDelay) { |
Jakob Ivarsson | ff9f646 | 2020-10-07 12:46:42 +0000 | [diff] [blame] | 296 | const int kExpectedTarget = 5; |
| 297 | const int kTimeIncrement = kExpectedTarget * kFrameSizeMs; |
Jakob Ivarsson | ff9f646 | 2020-10-07 12:46:42 +0000 | [diff] [blame] | 298 | // First packet arrival. |
| 299 | InsertNextPacket(); |
| 300 | // Second packet arrival. |
| 301 | IncreaseTime(kTimeIncrement); |
| 302 | InsertNextPacket(); |
| 303 | |
| 304 | // No limit is applied. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 305 | EXPECT_EQ(kTimeIncrement, dm_->TargetDelayMs()); |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 306 | |
| 307 | // Minimum delay is lower than base minimum delay, that is why base minimum |
| 308 | // delay is used to calculate target level. |
| 309 | constexpr int kMinimumDelayPackets = kExpectedTarget + 1; |
| 310 | constexpr int kBaseMinimumDelayPackets = kExpectedTarget + 2; |
| 311 | |
| 312 | constexpr int kMinimumDelayMs = kMinimumDelayPackets * kFrameSizeMs; |
| 313 | constexpr int kBaseMinimumDelayMs = kBaseMinimumDelayPackets * kFrameSizeMs; |
| 314 | |
| 315 | EXPECT_TRUE(kMinimumDelayMs < kBaseMinimumDelayMs); |
| 316 | EXPECT_TRUE(dm_->SetMinimumDelay(kMinimumDelayMs)); |
| 317 | EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs)); |
| 318 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs); |
| 319 | |
Jakob Ivarsson | 507f434 | 2019-09-03 13:04:41 +0200 | [diff] [blame] | 320 | IncreaseTime(kFrameSizeMs); |
Ruslan Burakov | 4a68fb9 | 2019-02-13 14:25:39 +0100 | [diff] [blame] | 321 | InsertNextPacket(); |
| 322 | EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs); |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 323 | EXPECT_EQ(kBaseMinimumDelayMs, dm_->TargetDelayMs()); |
henrik.lundin | b8c55b1 | 2017-05-10 07:38:01 -0700 | [diff] [blame] | 324 | } |
| 325 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 326 | TEST_F(DelayManagerTest, Failures) { |
| 327 | // Wrong sample rate. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 328 | EXPECT_EQ(absl::nullopt, dm_->Update(0, -1)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 329 | // Wrong packet size. |
| 330 | EXPECT_EQ(-1, dm_->SetPacketAudioLength(0)); |
| 331 | EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1)); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 332 | |
| 333 | // Minimum delay higher than a maximum delay is not accepted. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 334 | EXPECT_TRUE(dm_->SetMaximumDelay(20)); |
| 335 | EXPECT_FALSE(dm_->SetMinimumDelay(40)); |
turaj@webrtc.org | f1efc57 | 2013-08-16 23:44:24 +0000 | [diff] [blame] | 336 | |
| 337 | // Maximum delay less than minimum delay is not accepted. |
| 338 | EXPECT_TRUE(dm_->SetMaximumDelay(100)); |
| 339 | EXPECT_TRUE(dm_->SetMinimumDelay(80)); |
| 340 | EXPECT_FALSE(dm_->SetMaximumDelay(60)); |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 341 | } |
| 342 | |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 343 | TEST_F(DelayManagerTest, DelayHistogramFieldTrial) { |
| 344 | { |
| 345 | test::ScopedFieldTrials field_trial( |
| 346 | "WebRTC-Audio-NetEqDelayHistogram/Enabled-96-0.998/"); |
| 347 | RecreateDelayManager(); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 348 | EXPECT_EQ(1030792151, dm_->histogram_quantile()); // 0.96 in Q30. |
Jakob Ivarsson | e9a2ee2 | 2019-05-22 16:54:09 +0200 | [diff] [blame] | 349 | EXPECT_EQ( |
| 350 | 32702, |
| 351 | dm_->histogram()->base_forget_factor_for_testing()); // 0.998 in Q15. |
| 352 | EXPECT_FALSE(dm_->histogram()->start_forget_weight_for_testing()); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 353 | } |
| 354 | { |
| 355 | test::ScopedFieldTrials field_trial( |
| 356 | "WebRTC-Audio-NetEqDelayHistogram/Enabled-97.5-0.998/"); |
| 357 | RecreateDelayManager(); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 358 | EXPECT_EQ(1046898278, dm_->histogram_quantile()); // 0.975 in Q30. |
Jakob Ivarsson | e9a2ee2 | 2019-05-22 16:54:09 +0200 | [diff] [blame] | 359 | EXPECT_EQ( |
| 360 | 32702, |
| 361 | dm_->histogram()->base_forget_factor_for_testing()); // 0.998 in Q15. |
| 362 | EXPECT_FALSE(dm_->histogram()->start_forget_weight_for_testing()); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 363 | } |
Jakob Ivarsson | e9a2ee2 | 2019-05-22 16:54:09 +0200 | [diff] [blame] | 364 | // Test parameter for new call start adaptation. |
| 365 | { |
| 366 | test::ScopedFieldTrials field_trial( |
| 367 | "WebRTC-Audio-NetEqDelayHistogram/Enabled-96-0.998-1/"); |
| 368 | RecreateDelayManager(); |
| 369 | EXPECT_EQ(dm_->histogram()->start_forget_weight_for_testing().value(), 1.0); |
| 370 | } |
| 371 | { |
| 372 | test::ScopedFieldTrials field_trial( |
| 373 | "WebRTC-Audio-NetEqDelayHistogram/Enabled-96-0.998-1.5/"); |
| 374 | RecreateDelayManager(); |
| 375 | EXPECT_EQ(dm_->histogram()->start_forget_weight_for_testing().value(), 1.5); |
| 376 | } |
| 377 | { |
| 378 | test::ScopedFieldTrials field_trial( |
| 379 | "WebRTC-Audio-NetEqDelayHistogram/Enabled-96-0.998-0.5/"); |
| 380 | RecreateDelayManager(); |
| 381 | EXPECT_FALSE(dm_->histogram()->start_forget_weight_for_testing()); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 382 | } |
| 383 | } |
| 384 | |
Jakob Ivarsson | bd5874a | 2020-01-07 17:07:40 +0100 | [diff] [blame] | 385 | TEST_F(DelayManagerTest, RelativeArrivalDelay) { |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 386 | use_mock_histogram_ = true; |
| 387 | RecreateDelayManager(); |
| 388 | |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 389 | InsertNextPacket(); |
| 390 | |
| 391 | IncreaseTime(kFrameSizeMs); |
| 392 | EXPECT_CALL(*mock_histogram_, Add(0)); // Not delayed. |
| 393 | InsertNextPacket(); |
| 394 | |
| 395 | IncreaseTime(2 * kFrameSizeMs); |
| 396 | EXPECT_CALL(*mock_histogram_, Add(1)); // 20ms delayed. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 397 | dm_->Update(ts_, kFs); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 398 | |
| 399 | IncreaseTime(2 * kFrameSizeMs); |
| 400 | EXPECT_CALL(*mock_histogram_, Add(2)); // 40ms delayed. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 401 | dm_->Update(ts_ + kTsIncrement, kFs); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 402 | |
| 403 | EXPECT_CALL(*mock_histogram_, Add(1)); // Reordered, 20ms delayed. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 404 | dm_->Update(ts_, kFs); |
| 405 | } |
| 406 | |
| 407 | TEST_F(DelayManagerTest, ReorderedPackets) { |
| 408 | use_mock_histogram_ = true; |
| 409 | RecreateDelayManager(); |
| 410 | |
| 411 | // Insert first packet. |
| 412 | InsertNextPacket(); |
| 413 | |
| 414 | // Insert reordered packet. |
| 415 | EXPECT_CALL(*mock_histogram_, Add(4)); |
| 416 | dm_->Update(ts_ - 5 * kTsIncrement, kFs); |
| 417 | |
| 418 | // Insert another reordered packet. |
| 419 | EXPECT_CALL(*mock_histogram_, Add(1)); |
| 420 | dm_->Update(ts_ - 2 * kTsIncrement, kFs); |
| 421 | |
| 422 | // Insert the next packet in order and verify that the relative delay is |
| 423 | // estimated based on the first inserted packet. |
| 424 | IncreaseTime(4 * kFrameSizeMs); |
| 425 | EXPECT_CALL(*mock_histogram_, Add(3)); |
| 426 | InsertNextPacket(); |
Jakob Ivarsson | db42ed2 | 2019-02-27 10:08:09 +0100 | [diff] [blame] | 427 | } |
| 428 | |
Jakob Ivarsson | 74154e6 | 2019-08-22 15:00:16 +0200 | [diff] [blame] | 429 | TEST_F(DelayManagerTest, MaxDelayHistory) { |
Jakob Ivarsson | 74154e6 | 2019-08-22 15:00:16 +0200 | [diff] [blame] | 430 | use_mock_histogram_ = true; |
| 431 | RecreateDelayManager(); |
| 432 | |
Jakob Ivarsson | 74154e6 | 2019-08-22 15:00:16 +0200 | [diff] [blame] | 433 | InsertNextPacket(); |
| 434 | |
| 435 | // Insert 20 ms iat delay in the delay history. |
| 436 | IncreaseTime(2 * kFrameSizeMs); |
| 437 | EXPECT_CALL(*mock_histogram_, Add(1)); // 20ms delayed. |
| 438 | InsertNextPacket(); |
| 439 | |
| 440 | // Insert next packet with a timestamp difference larger than maximum history |
| 441 | // size. This removes the previously inserted iat delay from the history. |
| 442 | constexpr int kMaxHistoryMs = 2000; |
| 443 | IncreaseTime(kMaxHistoryMs + kFrameSizeMs); |
| 444 | ts_ += kFs * kMaxHistoryMs / 1000; |
| 445 | EXPECT_CALL(*mock_histogram_, Add(0)); // Not delayed. |
Jakob Ivarsson | 80fb978 | 2020-10-09 13:41:06 +0200 | [diff] [blame^] | 446 | dm_->Update(ts_, kFs); |
Jakob Ivarsson | 74154e6 | 2019-08-22 15:00:16 +0200 | [diff] [blame] | 447 | } |
| 448 | |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 449 | TEST_F(DelayManagerTest, RelativeArrivalDelayStatistic) { |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 450 | EXPECT_EQ(absl::nullopt, InsertNextPacket()); |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 451 | IncreaseTime(kFrameSizeMs); |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 452 | EXPECT_EQ(0, InsertNextPacket()); |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 453 | IncreaseTime(2 * kFrameSizeMs); |
Ivo Creusen | 53a31f7 | 2019-10-24 15:20:39 +0200 | [diff] [blame] | 454 | |
| 455 | EXPECT_EQ(20, InsertNextPacket()); |
Jakob Ivarsson | 4450708 | 2019-03-05 16:59:03 +0100 | [diff] [blame] | 456 | } |
| 457 | |
henrik.lundin@webrtc.org | d94659d | 2013-01-29 12:09:21 +0000 | [diff] [blame] | 458 | } // namespace webrtc |