Note: We no longer publish the latest version of our code here. We primarily use a kumc-bmi github organization. The heron ETL repository, in particular, is not public. Peers in the informatics community should see MultiSiteDev for details on requesting access.

source: webrtc/webrtc/modules/audio_coding/neteq4/delay_manager_unittest.cc @ 0:4bda6873e34c

pub_scrub_3792 tip
Last change on this file since 0:4bda6873e34c was 0:4bda6873e34c, checked in by Michael Prittie <mprittie@…>, 6 years ago

Scrubbed password for publication.

File size: 9.9 KB
Line 
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
13#include "webrtc/modules/audio_coding/neteq4/delay_manager.h"
14
15#include <math.h>
16
17#include "gmock/gmock.h"
18#include "gtest/gtest.h"
19#include "webrtc/modules/audio_coding/neteq4/mock/mock_delay_peak_detector.h"
20
21namespace webrtc {
22
23using ::testing::Return;
24using ::testing::_;
25
26class DelayManagerTest : public ::testing::Test {
27 protected:
28  static const int kMaxNumberOfPackets = 240;
29  static const int kTimeStepMs = 10;
30  static const int kFs = 8000;
31  static const int kFrameSizeMs = 20;
32  static const int kTsIncrement = kFrameSizeMs * kFs / 1000;
33
34  DelayManagerTest();
35  virtual void SetUp();
36  virtual void TearDown();
37  void SetPacketAudioLength(int lengt_ms);
38  void InsertNextPacket();
39  void IncreaseTime(int inc_ms);
40
41  DelayManager* dm_;
42  MockDelayPeakDetector detector_;
43  uint16_t seq_no_;
44  uint32_t ts_;
45};
46
47DelayManagerTest::DelayManagerTest()
48    : dm_(NULL),
49      seq_no_(0x1234),
50      ts_(0x12345678) {
51}
52
53void DelayManagerTest::SetUp() {
54  EXPECT_CALL(detector_, Reset())
55            .Times(1);
56  dm_ = new DelayManager(kMaxNumberOfPackets, &detector_);
57}
58
59void DelayManagerTest::SetPacketAudioLength(int lengt_ms) {
60  EXPECT_CALL(detector_, SetPacketAudioLength(lengt_ms));
61  dm_->SetPacketAudioLength(lengt_ms);
62}
63
64void DelayManagerTest::InsertNextPacket() {
65  EXPECT_EQ(0, dm_->Update(seq_no_, ts_, kFs));
66  seq_no_ += 1;
67  ts_ += kTsIncrement;
68}
69
70void DelayManagerTest::IncreaseTime(int inc_ms) {
71  for (int t = 0; t < inc_ms; t += kTimeStepMs) {
72    EXPECT_CALL(detector_, IncrementCounter(kTimeStepMs))
73        .Times(1);
74    dm_->UpdateCounters(kTimeStepMs);
75  }
76}
77void DelayManagerTest::TearDown() {
78  EXPECT_CALL(detector_, Die());
79  delete dm_;
80}
81
82TEST_F(DelayManagerTest, CreateAndDestroy) {
83  // Nothing to do here. The test fixture creates and destroys the DelayManager
84  // object.
85}
86
87TEST_F(DelayManagerTest, VectorInitialization) {
88  const DelayManager::IATVector& vec = dm_->iat_vector();
89  double sum = 0.0;
90  for (size_t i = 0; i < vec.size(); i++) {
91    EXPECT_NEAR(ldexp(pow(0.5, static_cast<int>(i + 1)), 30), vec[i], 65536);
92    // Tolerance 65536 in Q30 corresponds to a delta of approximately 0.00006.
93    sum += vec[i];
94  }
95  EXPECT_EQ(1 << 30, static_cast<int>(sum));  // Should be 1 in Q30.
96}
97
98TEST_F(DelayManagerTest, SetPacketAudioLength) {
99  const int kLengthMs = 30;
100  // Expect DelayManager to pass on the new length to the detector object.
101  EXPECT_CALL(detector_, SetPacketAudioLength(kLengthMs))
102      .Times(1);
103  EXPECT_EQ(0, dm_->SetPacketAudioLength(kLengthMs));
104  EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1));  // Illegal parameter value.
105}
106
107TEST_F(DelayManagerTest, PeakFound) {
108  // Expect DelayManager to pass on the question to the detector.
109  // Call twice, and let the detector return true the first time and false the
110  // second time.
111  EXPECT_CALL(detector_, peak_found())
112      .WillOnce(Return(true))
113      .WillOnce(Return(false));
114  EXPECT_TRUE(dm_->PeakFound());
115  EXPECT_FALSE(dm_->PeakFound());
116}
117
118TEST_F(DelayManagerTest, UpdateCounters) {
119  // Expect DelayManager to pass on the counter update to the detector.
120  EXPECT_CALL(detector_, IncrementCounter(kTimeStepMs))
121      .Times(1);
122  dm_->UpdateCounters(kTimeStepMs);
123}
124
125TEST_F(DelayManagerTest, UpdateNormal) {
126  SetPacketAudioLength(kFrameSizeMs);
127  // First packet arrival.
128  InsertNextPacket();
129  // Advance time by one frame size.
130  IncreaseTime(kFrameSizeMs);
131  // Second packet arrival.
132  // Expect detector update method to be called once with inter-arrival time
133  // equal to 1 packet, and (base) target level equal to 1 as well.
134  // Return false to indicate no peaks found.
135  EXPECT_CALL(detector_, Update(1, 1))
136      .WillOnce(Return(false));
137  InsertNextPacket();
138  EXPECT_EQ(1 << 8, dm_->TargetLevel());  // In Q8.
139  EXPECT_EQ(1, dm_->base_target_level());
140  int lower, higher;
141  dm_->BufferLimits(&lower, &higher);
142  // Expect |lower| to be 75% of target level, and |higher| to be target level,
143  // but also at least 20 ms higher than |lower|, which is the limiting case
144  // here.
145  EXPECT_EQ((1 << 8) * 3 / 4, lower);
146  EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
147}
148
149TEST_F(DelayManagerTest, UpdateLongInterArrivalTime) {
150  SetPacketAudioLength(kFrameSizeMs);
151  // First packet arrival.
152  InsertNextPacket();
153  // Advance time by two frame size.
154  IncreaseTime(2 * kFrameSizeMs);
155  // Second packet arrival.
156  // Expect detector update method to be called once with inter-arrival time
157  // equal to 1 packet, and (base) target level equal to 1 as well.
158  // Return false to indicate no peaks found.
159  EXPECT_CALL(detector_, Update(2, 2))
160      .WillOnce(Return(false));
161  InsertNextPacket();
162  EXPECT_EQ(2 << 8, dm_->TargetLevel());  // In Q8.
163  EXPECT_EQ(2, dm_->base_target_level());
164  int lower, higher;
165  dm_->BufferLimits(&lower, &higher);
166  // Expect |lower| to be 75% of target level, and |higher| to be target level,
167  // but also at least 20 ms higher than |lower|, which is the limiting case
168  // here.
169  EXPECT_EQ((2 << 8) * 3 / 4, lower);
170  EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
171}
172
173TEST_F(DelayManagerTest, UpdatePeakFound) {
174  SetPacketAudioLength(kFrameSizeMs);
175  // First packet arrival.
176  InsertNextPacket();
177  // Advance time by one frame size.
178  IncreaseTime(kFrameSizeMs);
179  // Second packet arrival.
180  // Expect detector update method to be called once with inter-arrival time
181  // equal to 1 packet, and (base) target level equal to 1 as well.
182  // Return true to indicate that peaks are found. Let the peak height be 5.
183  EXPECT_CALL(detector_, Update(1, 1))
184      .WillOnce(Return(true));
185  EXPECT_CALL(detector_, MaxPeakHeight())
186      .WillOnce(Return(5));
187  InsertNextPacket();
188  EXPECT_EQ(5 << 8, dm_->TargetLevel());
189  EXPECT_EQ(1, dm_->base_target_level());  // Base target level is w/o peaks.
190  int lower, higher;
191  dm_->BufferLimits(&lower, &higher);
192  // Expect |lower| to be 75% of target level, and |higher| to be target level.
193  EXPECT_EQ((5 << 8) * 3 / 4, lower);
194  EXPECT_EQ(5 << 8, higher);
195}
196
197TEST_F(DelayManagerTest, TargetDelay) {
198  SetPacketAudioLength(kFrameSizeMs);
199  // First packet arrival.
200  InsertNextPacket();
201  // Advance time by one frame size.
202  IncreaseTime(kFrameSizeMs);
203  // Second packet arrival.
204  // Expect detector update method to be called once with inter-arrival time
205  // equal to 1 packet, and (base) target level equal to 1 as well.
206  // Return false to indicate no peaks found.
207  EXPECT_CALL(detector_, Update(1, 1))
208      .WillOnce(Return(false));
209  InsertNextPacket();
210  const int kExpectedTarget = 1;
211  EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());  // In Q8.
212  EXPECT_EQ(1, dm_->base_target_level());
213  int lower, higher;
214  dm_->BufferLimits(&lower, &higher);
215  // Expect |lower| to be 75% of base target level, and |higher| to be
216  // lower + 20 ms headroom.
217  EXPECT_EQ((1 << 8) * 3 / 4, lower);
218  EXPECT_EQ(lower + (20 << 8) / kFrameSizeMs, higher);
219}
220
221TEST_F(DelayManagerTest, MaxAndRequiredDelay) {
222  const int kExpectedTarget = 5;
223  const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
224  SetPacketAudioLength(kFrameSizeMs);
225  // First packet arrival.
226  InsertNextPacket();
227  // Second packet arrival.
228  // Expect detector update method to be called once with inter-arrival time
229  // equal to |kExpectedTarget| packet. Return true to indicate peaks found.
230  EXPECT_CALL(detector_, Update(kExpectedTarget, _))
231      .WillRepeatedly(Return(true));
232  EXPECT_CALL(detector_, MaxPeakHeight())
233      .WillRepeatedly(Return(kExpectedTarget));
234  IncreaseTime(kTimeIncrement);
235  InsertNextPacket();
236
237  // No limit is set.
238  EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());
239
240  int kMaxDelayPackets = kExpectedTarget - 2;
241  int kMaxDelayMs = kMaxDelayPackets * kFrameSizeMs;
242  EXPECT_TRUE(dm_->SetMaximumDelay(kMaxDelayMs));
243  IncreaseTime(kTimeIncrement);
244  InsertNextPacket();
245  EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
246  EXPECT_EQ(kMaxDelayPackets << 8, dm_->TargetLevel());
247
248  // Target level at least should be one packet.
249  EXPECT_FALSE(dm_->SetMaximumDelay(kFrameSizeMs - 1));
250}
251
252TEST_F(DelayManagerTest, MinAndRequiredDelay) {
253  const int kExpectedTarget = 5;
254  const int kTimeIncrement = kExpectedTarget * kFrameSizeMs;
255  SetPacketAudioLength(kFrameSizeMs);
256  // First packet arrival.
257  InsertNextPacket();
258  // Second packet arrival.
259  // Expect detector update method to be called once with inter-arrival time
260  // equal to |kExpectedTarget| packet. Return true to indicate peaks found.
261  EXPECT_CALL(detector_, Update(kExpectedTarget, _))
262      .WillRepeatedly(Return(true));
263  EXPECT_CALL(detector_, MaxPeakHeight())
264      .WillRepeatedly(Return(kExpectedTarget));
265  IncreaseTime(kTimeIncrement);
266  InsertNextPacket();
267
268  // No limit is applied.
269  EXPECT_EQ(kExpectedTarget << 8, dm_->TargetLevel());
270
271  int kMinDelayPackets = kExpectedTarget + 2;
272  int kMinDelayMs = kMinDelayPackets * kFrameSizeMs;
273  dm_->SetMinimumDelay(kMinDelayMs);
274  IncreaseTime(kTimeIncrement);
275  InsertNextPacket();
276  EXPECT_EQ(kExpectedTarget * kFrameSizeMs, dm_->least_required_delay_ms());
277  EXPECT_EQ(kMinDelayPackets << 8, dm_->TargetLevel());
278}
279
280TEST_F(DelayManagerTest, Failures) {
281  // Wrong sample rate.
282  EXPECT_EQ(-1, dm_->Update(0, 0, -1));
283  // Wrong packet size.
284  EXPECT_EQ(-1, dm_->SetPacketAudioLength(0));
285  EXPECT_EQ(-1, dm_->SetPacketAudioLength(-1));
286
287  // Minimum delay higher than a maximum delay is not accepted.
288  EXPECT_TRUE(dm_->SetMaximumDelay(10));
289  EXPECT_FALSE(dm_->SetMinimumDelay(20));
290
291  // Maximum delay less than minimum delay is not accepted.
292  EXPECT_TRUE(dm_->SetMaximumDelay(100));
293  EXPECT_TRUE(dm_->SetMinimumDelay(80));
294  EXPECT_FALSE(dm_->SetMaximumDelay(60));
295}
296
297}  // namespace webrtc
Note: See TracBrowser for help on using the repository browser.