blob: a6a38b692ebfd147bf9226f6d3e511a0ee3e92a1 [file] [log] [blame]
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +00001/*
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 Bonadei92ea95e2017-09-15 06:47:31 +020013#include "modules/audio_coding/neteq/delay_manager.h"
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000014
15#include <math.h>
16
Mirko Bonadei317a1f02019-09-17 17:06:18 +020017#include <memory>
18
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010019#include "modules/audio_coding/neteq/histogram.h"
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010020#include "modules/audio_coding/neteq/mock/mock_histogram.h"
Jakob Ivarsson44507082019-03-05 16:59:03 +010021#include "modules/audio_coding/neteq/mock/mock_statistics_calculator.h"
Ruslan Burakov4a68fb92019-02-13 14:25:39 +010022#include "rtc_base/checks.h"
Minyue Li002fbb82018-10-04 11:31:03 +020023#include "test/field_trial.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020024#include "test/gmock.h"
25#include "test/gtest.h"
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000026
27namespace webrtc {
28
Jakob Ivarssondb42ed22019-02-27 10:08:09 +010029namespace {
30constexpr int kMaxNumberOfPackets = 240;
31constexpr int kMinDelayMs = 0;
32constexpr int kTimeStepMs = 10;
33constexpr int kFs = 8000;
34constexpr int kFrameSizeMs = 20;
35constexpr int kTsIncrement = kFrameSizeMs * kFs / 1000;
36constexpr int kMaxBufferSizeMs = kMaxNumberOfPackets * kFrameSizeMs;
37constexpr int kDefaultHistogramQuantile = 1020054733;
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020038constexpr int kNumBuckets = 100;
Jakob Ivarssondb42ed22019-02-27 10:08:09 +010039constexpr int kForgetFactor = 32745;
40} // namespace
41
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000042class DelayManagerTest : public ::testing::Test {
43 protected:
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000044 DelayManagerTest();
45 virtual void SetUp();
Minyue Li002fbb82018-10-04 11:31:03 +020046 void RecreateDelayManager();
Ivo Creusen53a31f72019-10-24 15:20:39 +020047 absl::optional<int> InsertNextPacket();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000048 void IncreaseTime(int inc_ms);
49
Minyue Li002fbb82018-10-04 11:31:03 +020050 std::unique_ptr<DelayManager> dm_;
henrik.lundinf3933702016-04-28 01:53:52 -070051 TickTimer tick_timer_;
Jakob Ivarsson44507082019-03-05 16:59:03 +010052 MockStatisticsCalculator stats_;
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010053 MockHistogram* mock_histogram_;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000054 uint32_t ts_;
Jakob Ivarssondb42ed22019-02-27 10:08:09 +010055 bool use_mock_histogram_ = false;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000056};
57
58DelayManagerTest::DelayManagerTest()
Jakob Ivarsson39b934b2019-01-10 10:28:23 +010059 : dm_(nullptr),
Jakob Ivarsson39b934b2019-01-10 10:28:23 +010060 ts_(0x12345678) {}
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000061
62void DelayManagerTest::SetUp() {
Minyue Li002fbb82018-10-04 11:31:03 +020063 RecreateDelayManager();
64}
65
66void DelayManagerTest::RecreateDelayManager() {
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010067 if (use_mock_histogram_) {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020068 mock_histogram_ = new MockHistogram(kNumBuckets, kForgetFactor);
Jakob Ivarssondb42ed22019-02-27 10:08:09 +010069 std::unique_ptr<Histogram> histogram(mock_histogram_);
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020070 dm_ = std::make_unique<DelayManager>(kMaxNumberOfPackets, kMinDelayMs,
71 kDefaultHistogramQuantile,
72 &tick_timer_, std::move(histogram));
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010073 } else {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020074 dm_ = DelayManager::Create(kMaxNumberOfPackets, kMinDelayMs, &tick_timer_);
Jakob Ivarsson1eb3d7e2019-02-21 15:42:31 +010075 }
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020076 dm_->SetPacketAudioLength(kFrameSizeMs);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000077}
78
Ivo Creusen53a31f72019-10-24 15:20:39 +020079absl::optional<int> DelayManagerTest::InsertNextPacket() {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +020080 auto relative_delay = dm_->Update(ts_, kFs);
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000081 ts_ += kTsIncrement;
Ivo Creusen53a31f72019-10-24 15:20:39 +020082 return relative_delay;
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000083}
84
85void DelayManagerTest::IncreaseTime(int inc_ms) {
86 for (int t = 0; t < inc_ms; t += kTimeStepMs) {
henrik.lundinf3933702016-04-28 01:53:52 -070087 tick_timer_.Increment();
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000088 }
89}
Ruslan Burakov1e193fa2019-05-15 14:31:22 +020090
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000091TEST_F(DelayManagerTest, CreateAndDestroy) {
92 // Nothing to do here. The test fixture creates and destroys the DelayManager
93 // object.
94}
95
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000096TEST_F(DelayManagerTest, UpdateNormal) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +000097 // First packet arrival.
98 InsertNextPacket();
99 // Advance time by one frame size.
100 IncreaseTime(kFrameSizeMs);
101 // Second packet arrival.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000102 InsertNextPacket();
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200103 EXPECT_EQ(20, dm_->TargetDelayMs());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000104}
105
106TEST_F(DelayManagerTest, UpdateLongInterArrivalTime) {
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000107 // First packet arrival.
108 InsertNextPacket();
109 // Advance time by two frame size.
110 IncreaseTime(2 * kFrameSizeMs);
111 // Second packet arrival.
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000112 InsertNextPacket();
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200113 EXPECT_EQ(40, dm_->TargetDelayMs());
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000114}
115
Niels Möller18f1adc2018-08-23 08:40:41 +0200116TEST_F(DelayManagerTest, MaxDelay) {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200117 const int kExpectedTarget = 5 * kFrameSizeMs;
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000118 // First packet arrival.
119 InsertNextPacket();
120 // Second packet arrival.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200121 IncreaseTime(kExpectedTarget);
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000122 InsertNextPacket();
123
124 // No limit is set.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200125 EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs());
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000126
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200127 const int kMaxDelayMs = 3 * kFrameSizeMs;
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000128 EXPECT_TRUE(dm_->SetMaximumDelay(kMaxDelayMs));
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200129 IncreaseTime(kFrameSizeMs);
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000130 InsertNextPacket();
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200131 EXPECT_EQ(kMaxDelayMs, dm_->TargetDelayMs());
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000132
133 // Target level at least should be one packet.
134 EXPECT_FALSE(dm_->SetMaximumDelay(kFrameSizeMs - 1));
135}
136
Niels Möller18f1adc2018-08-23 08:40:41 +0200137TEST_F(DelayManagerTest, MinDelay) {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200138 const int kExpectedTarget = 5 * kFrameSizeMs;
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000139 // First packet arrival.
140 InsertNextPacket();
141 // Second packet arrival.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200142 IncreaseTime(kExpectedTarget);
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000143 InsertNextPacket();
144
145 // No limit is applied.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200146 EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs());
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000147
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200148 int kMinDelayMs = 7 * kFrameSizeMs;
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000149 dm_->SetMinimumDelay(kMinDelayMs);
Jakob Ivarsson507f4342019-09-03 13:04:41 +0200150 IncreaseTime(kFrameSizeMs);
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000151 InsertNextPacket();
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200152 EXPECT_EQ(kMinDelayMs, dm_->TargetDelayMs());
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000153}
154
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100155TEST_F(DelayManagerTest, BaseMinimumDelayCheckValidRange) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100156 // 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
165TEST_F(DelayManagerTest, BaseMinimumDelayLowerThanMinimumDelay) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100166 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
178TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanMinimumDelay) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100179 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
191TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanBufferSize) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100192 constexpr int kBaseMinimumDelayMs = kMaxBufferSizeMs + 1;
193 constexpr int kMinimumDelayMs = 12;
Ruslan Burakovb35bacc2019-02-20 13:41:59 +0100194 constexpr int kMaximumDelayMs = 20;
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100195 constexpr int kMaxBufferSizeMsQ75 = 3 * kMaxBufferSizeMs / 4;
196
Ruslan Burakovb35bacc2019-02-20 13:41:59 +0100197 EXPECT_TRUE(dm_->SetMaximumDelay(kMaximumDelayMs));
198
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100199 // 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 Burakovb35bacc2019-02-20 13:41:59 +0100203 RTC_DCHECK_GT(kBaseMinimumDelayMs, kMaximumDelayMs);
204 RTC_DCHECK_LT(kMaximumDelayMs, kMaxBufferSizeMsQ75);
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100205
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
217TEST_F(DelayManagerTest, BaseMinimumDelayGreaterThanMaximumDelay) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100218 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
234TEST_F(DelayManagerTest, BaseMinimumDelayLowerThanMaxSize) {
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100235 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
250TEST_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 Burakov4a68fb92019-02-13 14:25:39 +0100255 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
274TEST_F(DelayManagerTest, BaseMinimumDelay) {
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200275 const int kExpectedTarget = 5 * kFrameSizeMs;
Jakob Ivarssonb1ae5cc2020-10-06 15:37:28 +0000276 // First packet arrival.
277 InsertNextPacket();
278 // Second packet arrival.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200279 IncreaseTime(kExpectedTarget);
Jakob Ivarssonb1ae5cc2020-10-06 15:37:28 +0000280 InsertNextPacket();
281
282 // No limit is applied.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200283 EXPECT_EQ(kExpectedTarget, dm_->TargetDelayMs());
Jakob Ivarssonff9f6462020-10-07 12:46:42 +0000284
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200285 constexpr int kBaseMinimumDelayMs = 7 * kFrameSizeMs;
Jakob Ivarssonff9f6462020-10-07 12:46:42 +0000286 EXPECT_TRUE(dm_->SetBaseMinimumDelay(kBaseMinimumDelayMs));
287 EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs);
288
289 IncreaseTime(kFrameSizeMs);
290 InsertNextPacket();
291 EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs);
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200292 EXPECT_EQ(kBaseMinimumDelayMs, dm_->TargetDelayMs());
Jakob Ivarssonff9f6462020-10-07 12:46:42 +0000293}
294
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200295TEST_F(DelayManagerTest, BaseMinimumDelayAffectsTargetDelay) {
Jakob Ivarssonff9f6462020-10-07 12:46:42 +0000296 const int kExpectedTarget = 5;
297 const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
Jakob Ivarssonff9f6462020-10-07 12:46:42 +0000298 // First packet arrival.
299 InsertNextPacket();
300 // Second packet arrival.
301 IncreaseTime(kTimeIncrement);
302 InsertNextPacket();
303
304 // No limit is applied.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200305 EXPECT_EQ(kTimeIncrement, dm_->TargetDelayMs());
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100306
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 Ivarsson507f4342019-09-03 13:04:41 +0200320 IncreaseTime(kFrameSizeMs);
Ruslan Burakov4a68fb92019-02-13 14:25:39 +0100321 InsertNextPacket();
322 EXPECT_EQ(dm_->GetBaseMinimumDelay(), kBaseMinimumDelayMs);
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200323 EXPECT_EQ(kBaseMinimumDelayMs, dm_->TargetDelayMs());
henrik.lundinb8c55b12017-05-10 07:38:01 -0700324}
325
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000326TEST_F(DelayManagerTest, Failures) {
327 // Wrong sample rate.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200328 EXPECT_EQ(absl::nullopt, dm_->Update(0, -1));
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000329 // Wrong packet size.
330 EXPECT_EQ(-1, dm_->SetPacketAudioLength(0));
331 EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1));
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000332
333 // Minimum delay higher than a maximum delay is not accepted.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200334 EXPECT_TRUE(dm_->SetMaximumDelay(20));
335 EXPECT_FALSE(dm_->SetMinimumDelay(40));
turaj@webrtc.orgf1efc572013-08-16 23:44:24 +0000336
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.orgd94659d2013-01-29 12:09:21 +0000341}
342
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100343TEST_F(DelayManagerTest, DelayHistogramFieldTrial) {
344 {
345 test::ScopedFieldTrials field_trial(
346 "WebRTC-Audio-NetEqDelayHistogram/Enabled-96-0.998/");
347 RecreateDelayManager();
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100348 EXPECT_EQ(1030792151, dm_->histogram_quantile()); // 0.96 in Q30.
Jakob Ivarssone9a2ee22019-05-22 16:54:09 +0200349 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 Ivarssondb42ed22019-02-27 10:08:09 +0100353 }
354 {
355 test::ScopedFieldTrials field_trial(
356 "WebRTC-Audio-NetEqDelayHistogram/Enabled-97.5-0.998/");
357 RecreateDelayManager();
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100358 EXPECT_EQ(1046898278, dm_->histogram_quantile()); // 0.975 in Q30.
Jakob Ivarssone9a2ee22019-05-22 16:54:09 +0200359 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 Ivarssondb42ed22019-02-27 10:08:09 +0100363 }
Jakob Ivarssone9a2ee22019-05-22 16:54:09 +0200364 // 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 Ivarssondb42ed22019-02-27 10:08:09 +0100382 }
383}
384
Jakob Ivarssonbd5874a2020-01-07 17:07:40 +0100385TEST_F(DelayManagerTest, RelativeArrivalDelay) {
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100386 use_mock_histogram_ = true;
387 RecreateDelayManager();
388
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100389 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 Ivarsson80fb9782020-10-09 13:41:06 +0200397 dm_->Update(ts_, kFs);
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100398
399 IncreaseTime(2 * kFrameSizeMs);
400 EXPECT_CALL(*mock_histogram_, Add(2)); // 40ms delayed.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200401 dm_->Update(ts_ + kTsIncrement, kFs);
Jakob Ivarssondb42ed22019-02-27 10:08:09 +0100402
403 EXPECT_CALL(*mock_histogram_, Add(1)); // Reordered, 20ms delayed.
Jakob Ivarsson80fb9782020-10-09 13:41:06 +0200404 dm_->Update(ts_, kFs);
405}
406
407TEST_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 Ivarssondb42ed22019-02-27 10:08:09 +0100427}
428
Jakob Ivarsson74154e62019-08-22 15:00:16 +0200429TEST_F(DelayManagerTest, MaxDelayHistory) {
Jakob Ivarsson74154e62019-08-22 15:00:16 +0200430 use_mock_histogram_ = true;
431 RecreateDelayManager();
432
Jakob Ivarsson74154e62019-08-22 15:00:16 +0200433 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 Ivarsson80fb9782020-10-09 13:41:06 +0200446 dm_->Update(ts_, kFs);
Jakob Ivarsson74154e62019-08-22 15:00:16 +0200447}
448
Jakob Ivarsson44507082019-03-05 16:59:03 +0100449TEST_F(DelayManagerTest, RelativeArrivalDelayStatistic) {
Ivo Creusen53a31f72019-10-24 15:20:39 +0200450 EXPECT_EQ(absl::nullopt, InsertNextPacket());
Jakob Ivarsson44507082019-03-05 16:59:03 +0100451 IncreaseTime(kFrameSizeMs);
Ivo Creusen53a31f72019-10-24 15:20:39 +0200452 EXPECT_EQ(0, InsertNextPacket());
Jakob Ivarsson44507082019-03-05 16:59:03 +0100453 IncreaseTime(2 * kFrameSizeMs);
Ivo Creusen53a31f72019-10-24 15:20:39 +0200454
455 EXPECT_EQ(20, InsertNextPacket());
Jakob Ivarsson44507082019-03-05 16:59:03 +0100456}
457
henrik.lundin@webrtc.orgd94659d2013-01-29 12:09:21 +0000458} // namespace webrtc