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/neteq/delay_manager.h" 14 15#include <math.h> 16 17#include "testing/gmock/include/gmock/gmock.h" 18#include "testing/gtest/include/gtest/gtest.h" 19#include "webrtc/modules/audio_coding/neteq/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 298