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#include "testing/gtest/include/gtest/gtest.h" 12 13extern "C" { 14#include "webrtc/modules/audio_processing/utility/delay_estimator.h" 15#include "webrtc/modules/audio_processing/utility/delay_estimator_internal.h" 16#include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h" 17} 18#include "webrtc/typedefs.h" 19 20namespace { 21 22enum { kSpectrumSize = 65 }; 23// Delay history sizes. 24enum { kMaxDelay = 100 }; 25enum { kLookahead = 10 }; 26// Length of binary spectrum sequence. 27enum { kSequenceLength = 400 }; 28 29const int kEnable[] = { 0, 1 }; 30const size_t kSizeEnable = sizeof(kEnable) / sizeof(*kEnable); 31 32class DelayEstimatorTest : public ::testing::Test { 33 protected: 34 DelayEstimatorTest(); 35 virtual void SetUp(); 36 virtual void TearDown(); 37 38 void Init(); 39 void InitBinary(); 40 void VerifyDelay(BinaryDelayEstimator* binary_handle, int offset, int delay); 41 void RunBinarySpectra(BinaryDelayEstimator* binary1, 42 BinaryDelayEstimator* binary2, 43 int near_offset, int lookahead_offset, int far_offset); 44 void RunBinarySpectraTest(int near_offset, int lookahead_offset, 45 int ref_robust_validation, int robust_validation); 46 47 void* handle_; 48 DelayEstimator* self_; 49 void* farend_handle_; 50 DelayEstimatorFarend* farend_self_; 51 BinaryDelayEstimator* binary_; 52 BinaryDelayEstimatorFarend* binary_farend_; 53 int spectrum_size_; 54 // Dummy input spectra. 55 float far_f_[kSpectrumSize]; 56 float near_f_[kSpectrumSize]; 57 uint16_t far_u16_[kSpectrumSize]; 58 uint16_t near_u16_[kSpectrumSize]; 59 uint32_t binary_spectrum_[kSequenceLength + kMaxDelay + kLookahead]; 60}; 61 62DelayEstimatorTest::DelayEstimatorTest() 63 : handle_(NULL), 64 self_(NULL), 65 farend_handle_(NULL), 66 farend_self_(NULL), 67 binary_(NULL), 68 binary_farend_(NULL), 69 spectrum_size_(kSpectrumSize) { 70 // Dummy input data are set with more or less arbitrary non-zero values. 71 memset(far_f_, 1, sizeof(far_f_)); 72 memset(near_f_, 2, sizeof(near_f_)); 73 memset(far_u16_, 1, sizeof(far_u16_)); 74 memset(near_u16_, 2, sizeof(near_u16_)); 75 // Construct a sequence of binary spectra used to verify delay estimate. The 76 // |kSequenceLength| has to be long enough for the delay estimation to leave 77 // the initialized state. 78 binary_spectrum_[0] = 1; 79 for (int i = 1; i < (kSequenceLength + kMaxDelay + kLookahead); i++) { 80 binary_spectrum_[i] = 3 * binary_spectrum_[i - 1]; 81 } 82} 83 84void DelayEstimatorTest::SetUp() { 85 farend_handle_ = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize, 86 kMaxDelay + kLookahead); 87 ASSERT_TRUE(farend_handle_ != NULL); 88 farend_self_ = reinterpret_cast<DelayEstimatorFarend*>(farend_handle_); 89 handle_ = WebRtc_CreateDelayEstimator(farend_handle_, kLookahead); 90 ASSERT_TRUE(handle_ != NULL); 91 self_ = reinterpret_cast<DelayEstimator*>(handle_); 92 binary_farend_ = WebRtc_CreateBinaryDelayEstimatorFarend(kMaxDelay + 93 kLookahead); 94 ASSERT_TRUE(binary_farend_ != NULL); 95 binary_ = WebRtc_CreateBinaryDelayEstimator(binary_farend_, kLookahead); 96 ASSERT_TRUE(binary_ != NULL); 97} 98 99void DelayEstimatorTest::TearDown() { 100 WebRtc_FreeDelayEstimator(handle_); 101 handle_ = NULL; 102 self_ = NULL; 103 WebRtc_FreeDelayEstimatorFarend(farend_handle_); 104 farend_handle_ = NULL; 105 farend_self_ = NULL; 106 WebRtc_FreeBinaryDelayEstimator(binary_); 107 binary_ = NULL; 108 WebRtc_FreeBinaryDelayEstimatorFarend(binary_farend_); 109 binary_farend_ = NULL; 110} 111 112void DelayEstimatorTest::Init() { 113 // Initialize Delay Estimator 114 EXPECT_EQ(0, WebRtc_InitDelayEstimatorFarend(farend_handle_)); 115 EXPECT_EQ(0, WebRtc_InitDelayEstimator(handle_)); 116 // Verify initialization. 117 EXPECT_EQ(0, farend_self_->far_spectrum_initialized); 118 EXPECT_EQ(0, self_->near_spectrum_initialized); 119 EXPECT_EQ(-2, WebRtc_last_delay(handle_)); // Delay in initial state. 120 EXPECT_FLOAT_EQ(0, WebRtc_last_delay_quality(handle_)); // Zero quality. 121} 122 123void DelayEstimatorTest::InitBinary() { 124 // Initialize Binary Delay Estimator (far-end part). 125 WebRtc_InitBinaryDelayEstimatorFarend(binary_farend_); 126 // Initialize Binary Delay Estimator 127 WebRtc_InitBinaryDelayEstimator(binary_); 128 // Verify initialization. This does not guarantee a complete check, since 129 // |last_delay| may be equal to -2 before initialization if done on the fly. 130 EXPECT_EQ(-2, binary_->last_delay); 131} 132 133void DelayEstimatorTest::VerifyDelay(BinaryDelayEstimator* binary_handle, 134 int offset, int delay) { 135 // Verify that we WebRtc_binary_last_delay() returns correct delay. 136 EXPECT_EQ(delay, WebRtc_binary_last_delay(binary_handle)); 137 138 if (delay != -2) { 139 // Verify correct delay estimate. In the non-causal case the true delay 140 // is equivalent with the |offset|. 141 EXPECT_EQ(offset, delay); 142 } 143} 144 145void DelayEstimatorTest::RunBinarySpectra(BinaryDelayEstimator* binary1, 146 BinaryDelayEstimator* binary2, 147 int near_offset, 148 int lookahead_offset, 149 int far_offset) { 150 int different_validations = binary1->robust_validation_enabled ^ 151 binary2->robust_validation_enabled; 152 WebRtc_InitBinaryDelayEstimatorFarend(binary_farend_); 153 WebRtc_InitBinaryDelayEstimator(binary1); 154 WebRtc_InitBinaryDelayEstimator(binary2); 155 // Verify initialization. This does not guarantee a complete check, since 156 // |last_delay| may be equal to -2 before initialization if done on the fly. 157 EXPECT_EQ(-2, binary1->last_delay); 158 EXPECT_EQ(-2, binary2->last_delay); 159 for (int i = kLookahead; i < (kSequenceLength + kLookahead); i++) { 160 WebRtc_AddBinaryFarSpectrum(binary_farend_, 161 binary_spectrum_[i + far_offset]); 162 int delay_1 = WebRtc_ProcessBinarySpectrum(binary1, binary_spectrum_[i]); 163 int delay_2 = 164 WebRtc_ProcessBinarySpectrum(binary2, 165 binary_spectrum_[i - near_offset]); 166 167 VerifyDelay(binary1, far_offset + kLookahead, delay_1); 168 VerifyDelay(binary2, 169 far_offset + kLookahead + lookahead_offset + near_offset, 170 delay_2); 171 // Expect the two delay estimates to be offset by |lookahead_offset| + 172 // |near_offset| when we have left the initial state. 173 if ((delay_1 != -2) && (delay_2 != -2)) { 174 EXPECT_EQ(delay_1, delay_2 - lookahead_offset - near_offset); 175 } 176 // For the case of identical signals |delay_1| and |delay_2| should match 177 // all the time, unless one of them has robust validation turned on. In 178 // that case the robust validation leaves the initial state faster. 179 if ((near_offset == 0) && (lookahead_offset == 0)) { 180 if (!different_validations) { 181 EXPECT_EQ(delay_1, delay_2); 182 } else { 183 if (binary1->robust_validation_enabled) { 184 EXPECT_GE(delay_1, delay_2); 185 } else { 186 EXPECT_GE(delay_2, delay_1); 187 } 188 } 189 } 190 } 191 // Verify that we have left the initialized state. 192 EXPECT_NE(-2, WebRtc_binary_last_delay(binary1)); 193 EXPECT_LT(0, WebRtc_binary_last_delay_quality(binary1)); 194 EXPECT_NE(-2, WebRtc_binary_last_delay(binary2)); 195 EXPECT_LT(0, WebRtc_binary_last_delay_quality(binary2)); 196} 197 198void DelayEstimatorTest::RunBinarySpectraTest(int near_offset, 199 int lookahead_offset, 200 int ref_robust_validation, 201 int robust_validation) { 202 BinaryDelayEstimator* binary2 = 203 WebRtc_CreateBinaryDelayEstimator(binary_farend_, 204 kLookahead + lookahead_offset); 205 // Verify the delay for both causal and non-causal systems. For causal systems 206 // the delay is equivalent with a positive |offset| of the far-end sequence. 207 // For non-causal systems the delay is equivalent with a negative |offset| of 208 // the far-end sequence. 209 binary_->robust_validation_enabled = ref_robust_validation; 210 binary2->robust_validation_enabled = robust_validation; 211 for (int offset = -kLookahead; 212 offset < kMaxDelay - lookahead_offset - near_offset; 213 offset++) { 214 RunBinarySpectra(binary_, binary2, near_offset, lookahead_offset, offset); 215 } 216 WebRtc_FreeBinaryDelayEstimator(binary2); 217 binary2 = NULL; 218 binary_->robust_validation_enabled = 0; // Reset reference. 219} 220 221TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfWrapper) { 222 // In this test we verify correct error returns on invalid API calls. 223 224 // WebRtc_CreateDelayEstimatorFarend() and WebRtc_CreateDelayEstimator() 225 // should return a NULL pointer on invalid input values. 226 // Make sure we have a non-NULL value at start, so we can detect NULL after 227 // create failure. 228 void* handle = farend_handle_; 229 handle = WebRtc_CreateDelayEstimatorFarend(33, kMaxDelay + kLookahead); 230 EXPECT_TRUE(handle == NULL); 231 handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize, 1); 232 EXPECT_TRUE(handle == NULL); 233 234 handle = handle_; 235 handle = WebRtc_CreateDelayEstimator(NULL, kLookahead); 236 EXPECT_TRUE(handle == NULL); 237 handle = WebRtc_CreateDelayEstimator(farend_handle_, -1); 238 EXPECT_TRUE(handle == NULL); 239 240 // WebRtc_InitDelayEstimatorFarend() and WebRtc_InitDelayEstimator() should 241 // return -1 if we have a NULL pointer as |handle|. 242 EXPECT_EQ(-1, WebRtc_InitDelayEstimatorFarend(NULL)); 243 EXPECT_EQ(-1, WebRtc_InitDelayEstimator(NULL)); 244 245 // WebRtc_AddFarSpectrumFloat() should return -1 if we have: 246 // 1) NULL pointer as |handle|. 247 // 2) NULL pointer as far-end spectrum. 248 // 3) Incorrect spectrum size. 249 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(NULL, far_f_, spectrum_size_)); 250 // Use |farend_handle_| which is properly created at SetUp(). 251 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, NULL, 252 spectrum_size_)); 253 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_, 254 spectrum_size_ + 1)); 255 256 // WebRtc_AddFarSpectrumFix() should return -1 if we have: 257 // 1) NULL pointer as |handle|. 258 // 2) NULL pointer as far-end spectrum. 259 // 3) Incorrect spectrum size. 260 // 4) Too high precision in far-end spectrum (Q-domain > 15). 261 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(NULL, far_u16_, spectrum_size_, 0)); 262 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, NULL, spectrum_size_, 263 0)); 264 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_, 265 spectrum_size_ + 1, 0)); 266 EXPECT_EQ(-1, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_, 267 spectrum_size_, 16)); 268 269 // WebRtc_set_allowed_offset() should return -1 if we have: 270 // 1) NULL pointer as |handle|. 271 // 2) |allowed_offset| < 0. 272 EXPECT_EQ(-1, WebRtc_set_allowed_offset(NULL, 0)); 273 EXPECT_EQ(-1, WebRtc_set_allowed_offset(handle_, -1)); 274 275 EXPECT_EQ(-1, WebRtc_get_allowed_offset(NULL)); 276 277 // WebRtc_enable_robust_validation() should return -1 if we have: 278 // 1) NULL pointer as |handle|. 279 // 2) Incorrect |enable| value (not 0 or 1). 280 EXPECT_EQ(-1, WebRtc_enable_robust_validation(NULL, kEnable[0])); 281 EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, -1)); 282 EXPECT_EQ(-1, WebRtc_enable_robust_validation(handle_, 2)); 283 284 // WebRtc_is_robust_validation_enabled() should return -1 if we have NULL 285 // pointer as |handle|. 286 EXPECT_EQ(-1, WebRtc_is_robust_validation_enabled(NULL)); 287 288 // WebRtc_DelayEstimatorProcessFloat() should return -1 if we have: 289 // 1) NULL pointer as |handle|. 290 // 2) NULL pointer as near-end spectrum. 291 // 3) Incorrect spectrum size. 292 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(NULL, near_f_, 293 spectrum_size_)); 294 // Use |handle_| which is properly created at SetUp(). 295 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, NULL, 296 spectrum_size_)); 297 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFloat(handle_, near_f_, 298 spectrum_size_ + 1)); 299 300 // WebRtc_DelayEstimatorProcessFix() should return -1 if we have: 301 // 1) NULL pointer as |handle|. 302 // 3) NULL pointer as near-end spectrum. 303 // 4) Incorrect spectrum size. 304 // 6) Too high precision in near-end spectrum (Q-domain > 15). 305 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(NULL, near_u16_, spectrum_size_, 306 0)); 307 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, NULL, spectrum_size_, 308 0)); 309 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_, 310 spectrum_size_ + 1, 0)); 311 EXPECT_EQ(-1, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_, 312 spectrum_size_, 16)); 313 314 // WebRtc_last_delay() should return -1 if we have a NULL pointer as |handle|. 315 EXPECT_EQ(-1, WebRtc_last_delay(NULL)); 316 317 // Free any local memory if needed. 318 WebRtc_FreeDelayEstimator(handle); 319} 320 321TEST_F(DelayEstimatorTest, VerifyAllowedOffset) { 322 // Is set to zero by default. 323 EXPECT_EQ(0, WebRtc_get_allowed_offset(handle_)); 324 for (int i = 1; i >= 0; i--) { 325 EXPECT_EQ(0, WebRtc_set_allowed_offset(handle_, i)); 326 EXPECT_EQ(i, WebRtc_get_allowed_offset(handle_)); 327 Init(); 328 // Unaffected over a reset. 329 EXPECT_EQ(i, WebRtc_get_allowed_offset(handle_)); 330 } 331} 332 333TEST_F(DelayEstimatorTest, VerifyEnableRobustValidation) { 334 // Disabled by default. 335 EXPECT_EQ(0, WebRtc_is_robust_validation_enabled(handle_)); 336 for (size_t i = 0; i < kSizeEnable; ++i) { 337 EXPECT_EQ(0, WebRtc_enable_robust_validation(handle_, kEnable[i])); 338 EXPECT_EQ(kEnable[i], WebRtc_is_robust_validation_enabled(handle_)); 339 Init(); 340 // Unaffected over a reset. 341 EXPECT_EQ(kEnable[i], WebRtc_is_robust_validation_enabled(handle_)); 342 } 343} 344 345TEST_F(DelayEstimatorTest, InitializedSpectrumAfterProcess) { 346 // In this test we verify that the mean spectra are initialized after first 347 // time we call WebRtc_AddFarSpectrum() and Process() respectively. 348 349 // For floating point operations, process one frame and verify initialization 350 // flag. 351 Init(); 352 EXPECT_EQ(0, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_, 353 spectrum_size_)); 354 EXPECT_EQ(1, farend_self_->far_spectrum_initialized); 355 EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFloat(handle_, near_f_, 356 spectrum_size_)); 357 EXPECT_EQ(1, self_->near_spectrum_initialized); 358 359 // For fixed point operations, process one frame and verify initialization 360 // flag. 361 Init(); 362 EXPECT_EQ(0, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_, 363 spectrum_size_, 0)); 364 EXPECT_EQ(1, farend_self_->far_spectrum_initialized); 365 EXPECT_EQ(-2, WebRtc_DelayEstimatorProcessFix(handle_, near_u16_, 366 spectrum_size_, 0)); 367 EXPECT_EQ(1, self_->near_spectrum_initialized); 368} 369 370TEST_F(DelayEstimatorTest, CorrectLastDelay) { 371 // In this test we verify that we get the correct last delay upon valid call. 372 // We simply process the same data until we leave the initialized state 373 // (|last_delay| = -2). Then we compare the Process() output with the 374 // last_delay() call. 375 376 // TODO(bjornv): Update quality values for robust validation. 377 int last_delay = 0; 378 // Floating point operations. 379 Init(); 380 for (int i = 0; i < 200; i++) { 381 EXPECT_EQ(0, WebRtc_AddFarSpectrumFloat(farend_handle_, far_f_, 382 spectrum_size_)); 383 last_delay = WebRtc_DelayEstimatorProcessFloat(handle_, near_f_, 384 spectrum_size_); 385 if (last_delay != -2) { 386 EXPECT_EQ(last_delay, WebRtc_last_delay(handle_)); 387 if (!WebRtc_is_robust_validation_enabled(handle_)) { 388 EXPECT_FLOAT_EQ(7203.f / kMaxBitCountsQ9, 389 WebRtc_last_delay_quality(handle_)); 390 } 391 break; 392 } 393 } 394 // Verify that we have left the initialized state. 395 EXPECT_NE(-2, WebRtc_last_delay(handle_)); 396 EXPECT_LT(0, WebRtc_last_delay_quality(handle_)); 397 398 // Fixed point operations. 399 Init(); 400 for (int i = 0; i < 200; i++) { 401 EXPECT_EQ(0, WebRtc_AddFarSpectrumFix(farend_handle_, far_u16_, 402 spectrum_size_, 0)); 403 last_delay = WebRtc_DelayEstimatorProcessFix(handle_, near_u16_, 404 spectrum_size_, 0); 405 if (last_delay != -2) { 406 EXPECT_EQ(last_delay, WebRtc_last_delay(handle_)); 407 if (!WebRtc_is_robust_validation_enabled(handle_)) { 408 EXPECT_FLOAT_EQ(7203.f / kMaxBitCountsQ9, 409 WebRtc_last_delay_quality(handle_)); 410 } 411 break; 412 } 413 } 414 // Verify that we have left the initialized state. 415 EXPECT_NE(-2, WebRtc_last_delay(handle_)); 416 EXPECT_LT(0, WebRtc_last_delay_quality(handle_)); 417} 418 419TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimatorFarend) { 420 // In this test we verify correct output on invalid API calls to the Binary 421 // Delay Estimator (far-end part). 422 423 BinaryDelayEstimatorFarend* binary = binary_farend_; 424 // WebRtc_CreateBinaryDelayEstimatorFarend() should return -1 if the input 425 // history size is less than 2. This is to make sure the buffer shifting 426 // applies properly. 427 // Make sure we have a non-NULL value at start, so we can detect NULL after 428 // create failure. 429 binary = WebRtc_CreateBinaryDelayEstimatorFarend(1); 430 EXPECT_TRUE(binary == NULL); 431} 432 433TEST_F(DelayEstimatorTest, CorrectErrorReturnsOfBinaryEstimator) { 434 // In this test we verify correct output on invalid API calls to the Binary 435 // Delay Estimator. 436 437 BinaryDelayEstimator* binary_handle = binary_; 438 // WebRtc_CreateBinaryDelayEstimator() should return -1 if we have a NULL 439 // pointer as |binary_farend| or invalid input values. Upon failure, the 440 // |binary_handle| should be NULL. 441 // Make sure we have a non-NULL value at start, so we can detect NULL after 442 // create failure. 443 binary_handle = WebRtc_CreateBinaryDelayEstimator(NULL, kLookahead); 444 EXPECT_TRUE(binary_handle == NULL); 445 binary_handle = WebRtc_CreateBinaryDelayEstimator(binary_farend_, -1); 446 EXPECT_TRUE(binary_handle == NULL); 447} 448 449TEST_F(DelayEstimatorTest, MeanEstimatorFix) { 450 // In this test we verify that we update the mean value in correct direction 451 // only. With "direction" we mean increase or decrease. 452 453 int32_t mean_value = 4000; 454 int32_t mean_value_before = mean_value; 455 int32_t new_mean_value = mean_value * 2; 456 457 // Increasing |mean_value|. 458 WebRtc_MeanEstimatorFix(new_mean_value, 10, &mean_value); 459 EXPECT_LT(mean_value_before, mean_value); 460 EXPECT_GT(new_mean_value, mean_value); 461 462 // Decreasing |mean_value|. 463 new_mean_value = mean_value / 2; 464 mean_value_before = mean_value; 465 WebRtc_MeanEstimatorFix(new_mean_value, 10, &mean_value); 466 EXPECT_GT(mean_value_before, mean_value); 467 EXPECT_LT(new_mean_value, mean_value); 468} 469 470TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearSameSpectrum) { 471 // In this test we verify that we get the correct delay estimates if we shift 472 // the signal accordingly. We create two Binary Delay Estimators and feed them 473 // with the same signals, so they should output the same results. 474 // We verify both causal and non-causal delays. 475 // For these noise free signals, the robust validation should not have an 476 // impact, hence we turn robust validation on/off for both reference and 477 // delayed near end. 478 479 for (size_t i = 0; i < kSizeEnable; ++i) { 480 for (size_t j = 0; j < kSizeEnable; ++j) { 481 RunBinarySpectraTest(0, 0, kEnable[i], kEnable[j]); 482 } 483 } 484} 485 486TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearDifferentSpectrum) { 487 // In this test we use the same setup as above, but we now feed the two Binary 488 // Delay Estimators with different signals, so they should output different 489 // results. 490 // For these noise free signals, the robust validation should not have an 491 // impact, hence we turn robust validation on/off for both reference and 492 // delayed near end. 493 494 const int kNearOffset = 1; 495 for (size_t i = 0; i < kSizeEnable; ++i) { 496 for (size_t j = 0; j < kSizeEnable; ++j) { 497 RunBinarySpectraTest(kNearOffset, 0, kEnable[i], kEnable[j]); 498 } 499 } 500} 501 502TEST_F(DelayEstimatorTest, ExactDelayEstimateMultipleNearDifferentLookahead) { 503 // In this test we use the same setup as above, feeding the two Binary 504 // Delay Estimators with the same signals. The difference is that we create 505 // them with different lookahead. 506 // For these noise free signals, the robust validation should not have an 507 // impact, hence we turn robust validation on/off for both reference and 508 // delayed near end. 509 510 const int kLookaheadOffset = 1; 511 for (size_t i = 0; i < kSizeEnable; ++i) { 512 for (size_t j = 0; j < kSizeEnable; ++j) { 513 RunBinarySpectraTest(0, kLookaheadOffset, kEnable[i], kEnable[j]); 514 } 515 } 516} 517 518TEST_F(DelayEstimatorTest, AllowedOffsetNoImpactWhenRobustValidationDisabled) { 519 // The same setup as in ExactDelayEstimateMultipleNearSameSpectrum with the 520 // difference that |allowed_offset| is set for the reference binary delay 521 // estimator. 522 523 binary_->allowed_offset = 10; 524 RunBinarySpectraTest(0, 0, 0, 0); 525 binary_->allowed_offset = 0; // Reset reference. 526} 527 528TEST_F(DelayEstimatorTest, VerifyLookaheadAtCreate) { 529 void* farend_handle = WebRtc_CreateDelayEstimatorFarend(kSpectrumSize, 530 kMaxDelay); 531 ASSERT_TRUE(farend_handle != NULL); 532 void* handle = WebRtc_CreateDelayEstimator(farend_handle, kLookahead); 533 ASSERT_TRUE(handle != NULL); 534 EXPECT_EQ(kLookahead, WebRtc_lookahead(handle)); 535 WebRtc_FreeDelayEstimator(handle); 536 WebRtc_FreeDelayEstimatorFarend(farend_handle); 537} 538 539// TODO(bjornv): Add tests for SoftReset...(...). 540 541} // namespace 542