src/third_party/webrtc/modules/audio_processing/utility/delay_estimator_unittest.cc

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