Rename APM Config ReportedDelay to DelayAgnostic

webrtc/modules/audio_processing/aec/system_delay_unittest.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 118 matching lines @@
   }
   return buffer_size;
 }
 
 void SystemDelayTest::RunStableStartup() {
   // To make sure we have a full buffer when we verify stability we first fill
   // up the far-end buffer with the same amount as we will report in through
   // Process().
   int buffer_size = BufferFillUp();
 
-  if (WebRtcAec_reported_delay_enabled(self_->aec) == 0) {
+  if (WebRtcAec_delay_agnostic_enabled(self_->aec) == 1) {
     // In extended_filter mode we set the buffer size after the first processed
     // 10 ms chunk. Hence, we don't need to wait for the reported system delay
     // values to become stable.
     RenderAndCapture(kDeviceBufMs);
     buffer_size += samples_per_frame_;
     EXPECT_EQ(0, self_->startup_phase);
   } else {
     // A stable device should be accepted and put in a regular process mode
     // within |kStableConvergenceMs|.
     int process_time_ms = 0;
@@ skipping 41 matching lines @@
 // 8) The system delay should never become negative.
 
 TEST_F(SystemDelayTest, CorrectIncreaseWhenBufferFarend) {
   // When we add data to the AEC buffer the internal system delay should be
   // incremented with the same amount as the size of data.
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         // Loop through a couple of calls to make sure the system delay
         // increments correctly.
         for (int j = 1; j <= 5; j++) {
           EXPECT_EQ(0,
                     WebRtcAec_BufferFarend(handle_, far_, samples_per_frame_));
           EXPECT_EQ(j * samples_per_frame_, WebRtcAec_system_delay(self_->aec));
         }
       }
     }
   }
 }
 
 // TODO(bjornv): Add a test to verify behavior if the far-end buffer is full
 // when adding new data.
 
 TEST_F(SystemDelayTest, CorrectDelayAfterStableStartup) {
   // We run the system in a stable startup. After that we verify that the system
   // delay meets the requirements.
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
 
         // Verify system delay with respect to requirements, i.e., the
         // |system_delay| is in the interval [75%, 100%] of what's reported on
         // the average.
         // In extended_filter mode we target 50% and measure after one processed
         // 10 ms chunk.
         int average_reported_delay = kDeviceBufMs * samples_per_frame_ / 10;
         EXPECT_GE(average_reported_delay, WebRtcAec_system_delay(self_->aec));
         int lower_bound = WebRtcAec_extended_filter_enabled(self_->aec)
                               ? average_reported_delay / 2 - samples_per_frame_
                               : average_reported_delay * 3 / 4;
         EXPECT_LE(lower_bound, WebRtcAec_system_delay(self_->aec));
       }
     }
   }
 }
 
 TEST_F(SystemDelayTest, CorrectDelayAfterUnstableStartup) {
   // This test does not apply in extended_filter mode, since we only use the
   // the first 10 ms chunk to determine a reasonable buffer size. Neither does
   // it apply if DA-AEC is on because that overrides the startup procedure.
   WebRtcAec_enable_extended_filter(self_->aec, 0);
   EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(self_->aec));
-  WebRtcAec_enable_reported_delay(self_->aec, 1);
-  EXPECT_EQ(1, WebRtcAec_reported_delay_enabled(self_->aec));
+  WebRtcAec_enable_delay_agnostic(self_->aec, 0);
+  EXPECT_EQ(0, WebRtcAec_delay_agnostic_enabled(self_->aec));
 
   // In an unstable system we would start processing after |kMaxConvergenceMs|.
   // On the last frame the AEC buffer is adjusted to 60% of the last reported
   // device buffer size.
   // We construct an unstable system by altering the device buffer size between
   // two values |kDeviceBufMs| +- 25 ms.
   for (size_t i = 0; i < kNumSampleRates; i++) {
     Init(kSampleRateHz[i]);
 
     // To make sure we have a full buffer when we verify stability we first fill
@@ skipping 27 matching lines @@
               WebRtcAec_system_delay(self_->aec));
   }
 }
 
 TEST_F(SystemDelayTest, CorrectDelayAfterStableBufferBuildUp) {
   // This test does not apply in extended_filter mode, since we only use the
   // the first 10 ms chunk to determine a reasonable buffer size. Neither does
   // it apply if DA-AEC is on because that overrides the startup procedure.
   WebRtcAec_enable_extended_filter(self_->aec, 0);
   EXPECT_EQ(0, WebRtcAec_extended_filter_enabled(self_->aec));
-  WebRtcAec_enable_reported_delay(self_->aec, 1);
-  EXPECT_EQ(1, WebRtcAec_reported_delay_enabled(self_->aec));
+  WebRtcAec_enable_delay_agnostic(self_->aec, 0);
+  EXPECT_EQ(0, WebRtcAec_delay_agnostic_enabled(self_->aec));
 
   // In this test we start by establishing the device buffer size during stable
   // conditions, but with an empty internal far-end buffer. Once that is done we
   // verify that the system delay is increased correctly until we have reach an
   // internal buffer size of 75% of what's been reported.
   for (size_t i = 0; i < kNumSampleRates; i++) {
     Init(kSampleRateHz[i]);
 
     // We assume that running |kStableConvergenceMs| calls will put the
     // algorithm in a state where the device buffer size has been determined. We
@@ skipping 43 matching lines @@
 TEST_F(SystemDelayTest, CorrectDelayWhenBufferUnderrun) {
   // Here we test a buffer under run scenario. If we keep on calling
   // WebRtcAec_Process() we will finally run out of data, but should
   // automatically stuff the buffer. We verify this behavior by checking if the
   // system delay goes negative.
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
 
         // The AEC has now left the Startup phase. We now have at most
         // |kStableConvergenceMs| in the buffer. Keep on calling Process() until
         // we run out of data and verify that the system delay is non-negative.
         for (int j = 0; j <= kStableConvergenceMs; j += 10) {
           EXPECT_EQ(0, WebRtcAec_Process(handle_, &near_ptr_, 1, &out_ptr_,
                                          samples_per_frame_, kDeviceBufMs, 0));
           EXPECT_LE(0, WebRtcAec_system_delay(self_->aec));
         }
       }
     }
   }
 }
 
 TEST_F(SystemDelayTest, CorrectDelayDuringDrift) {
   // This drift test should verify that the system delay is never exceeding the
   // device buffer. The drift is simulated by decreasing the reported device
   // buffer size by 1 ms every 100 ms. If the device buffer size goes below 30
   // ms we jump (add) 10 ms to give a repeated pattern.
 
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
 
         // We have left the startup phase and proceed with normal processing.
         int jump = 0;
         for (int j = 0; j < 1000; j++) {
           // Drift = -1 ms per 100 ms of data.
           int device_buf_ms = kDeviceBufMs - (j / 10) + jump;
           int device_buf = MapBufferSizeToSamples(device_buf_ms,
@@ skipping 22 matching lines @@
   // after which the stable procedure continues. The glitch is never reported by
   // the device.
   // The system is said to be in a non-causal state if the difference between
   // the device buffer and system delay is less than a block (64 samples).
 
   // This process should be independent of DA-AEC and extended_filter mode.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
         int device_buf = MapBufferSizeToSamples(kDeviceBufMs,
                                                 extended_filter == 1);
         // Glitch state.
         for (int j = 0; j < 20; j++) {
           EXPECT_EQ(0,
                     WebRtcAec_BufferFarend(handle_, far_, samples_per_frame_));
           // No need to verify system delay, since that is done in a separate
@@ skipping 35 matching lines @@
 
 TEST_F(SystemDelayTest, UnaffectedWhenSpuriousDeviceBufferValues) {
   // This test does not apply in extended_filter mode, since we only use the
   // the first 10 ms chunk to determine a reasonable buffer size.
   const int extended_filter = 0;
   WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
   EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
 
   // Should be DA-AEC independent.
   for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-    WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-    EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+    WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+    EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
     // This spurious device buffer data test aims at verifying that the system
     // delay is unaffected by large outliers.
     // The system is said to be in a non-causal state if the difference between
     // the device buffer and system delay is less than a block (64 samples).
     for (size_t i = 0; i < kNumSampleRates; i++) {
       Init(kSampleRateHz[i]);
       RunStableStartup();
       int device_buf = MapBufferSizeToSamples(kDeviceBufMs,
                                               extended_filter == 1);
 
@@ skipping 32 matching lines @@
   // TODO(bjornv): This test will have a better impact if we verified that the
   // delay estimate goes up when the system delay goes down to meet the average
   // device buffer size.
 
   // This test does not apply if DA-AEC is enabled and extended_filter mode
   // disabled.
   for (int extended_filter = 0; extended_filter <= 1; ++extended_filter) {
     WebRtcAec_enable_extended_filter(self_->aec, extended_filter);
     EXPECT_EQ(extended_filter, WebRtcAec_extended_filter_enabled(self_->aec));
     for (int da_aec = 0; da_aec <= 1; ++da_aec) {
-      WebRtcAec_enable_reported_delay(self_->aec, 1 - da_aec);
-      EXPECT_EQ(1 - da_aec, WebRtcAec_reported_delay_enabled(self_->aec));
+      WebRtcAec_enable_delay_agnostic(self_->aec, da_aec);
+      EXPECT_EQ(da_aec, WebRtcAec_delay_agnostic_enabled(self_->aec));
       if (extended_filter == 0 && da_aec == 1) {
         continue;
       }
       for (size_t i = 0; i < kNumSampleRates; i++) {
         Init(kSampleRateHz[i]);
         RunStableStartup();
         const int device_buf = MapBufferSizeToSamples(kDeviceBufMs,
                                                       extended_filter == 1);
 
         // Normal state. We are currently not in a non-causal state.
@@ skipping 18 matching lines @@
           EXPECT_LE(0, WebRtcAec_system_delay(self_->aec));
         }
         // Verify we are not in a non-causal state.
         EXPECT_FALSE(non_causal);
       }
     }
   }
 }
 
 }  // namespace