Rename APM Config ReportedDelay to DelayAgnostic

webrtc/modules/audio_processing/aec/aec_core.c

 /*
  *  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 1434 matching lines @@
   }
   // We create the delay_estimator with the same amount of maximum lookahead as
   // the delay history size (kHistorySizeBlocks) for symmetry reasons.
   aec->delay_estimator = WebRtc_CreateDelayEstimator(
       aec->delay_estimator_farend, kHistorySizeBlocks);
   if (aec->delay_estimator == NULL) {
     WebRtcAec_FreeAec(aec);
     return NULL;
   }
 #ifdef WEBRTC_ANDROID
-  aec->reported_delay_enabled = 0;  // DA-AEC enabled by default.
+  aec->delay_agnostic_enabled = 0;  // DA-AEC enabled by default.

[bjornv1, 2015/07/01 18:13:34]

You should change 0 to 1. Otherwise it will break on Androids, where the Config
isn't set.

[hlundin-webrtc, 2015/07/02 06:36:30]

Good. You found the error I planted there. I already had a patch prepared for
that. :)

   // DA-AEC assumes the system is causal from the beginning and will self adjust
   // the lookahead when shifting is required.
   WebRtc_set_lookahead(aec->delay_estimator, 0);
 #else
-  aec->reported_delay_enabled = 1;
+  aec->delay_agnostic_enabled = 0;
   WebRtc_set_lookahead(aec->delay_estimator, kLookaheadBlocks);
 #endif
   aec->extended_filter_enabled = 0;
 
   // Assembly optimization
   WebRtcAec_FilterFar = FilterFar;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignal;
   WebRtcAec_FilterAdaptation = FilterAdaptation;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppress;
   WebRtcAec_ComfortNoise = ComfortNoise;
@@ skipping 308 matching lines @@
     }
 
     // 1) At most we process |aec->mult|+1 partitions in 10 ms. Make sure we
     // have enough far-end data for that by stuffing the buffer if the
     // |system_delay| indicates others.
     if (aec->system_delay < FRAME_LEN) {
       // We don't have enough data so we rewind 10 ms.
       WebRtcAec_MoveFarReadPtr(aec, -(aec->mult + 1));
     }
 
-    if (aec->reported_delay_enabled) {
+    if (!aec->delay_agnostic_enabled) {
       // 2 a) Compensate for a possible change in the system delay.
 
       // TODO(bjornv): Investigate how we should round the delay difference;
       // right now we know that incoming |knownDelay| is underestimated when
       // it's less than |aec->knownDelay|. We therefore, round (-32) in that
       // direction. In the other direction, we don't have this situation, but
       // might flush one partition too little. This can cause non-causality,
       // which should be investigated. Maybe, allow for a non-symmetric
       // rounding, like -16.
       int move_elements = (aec->knownDelay - knownDelay - 32) / PART_LEN;
@@ skipping 93 matching lines @@
                              int metrics_mode,
                              int delay_logging) {
   assert(nlp_mode >= 0 && nlp_mode < 3);
   self->nlp_mode = nlp_mode;
   self->metricsMode = metrics_mode;
   if (self->metricsMode) {
     InitMetrics(self);
   }
   // Turn on delay logging if it is either set explicitly or if delay agnostic
   // AEC is enabled (which requires delay estimates).
-  self->delay_logging_enabled = delay_logging || !self->reported_delay_enabled;
+  self->delay_logging_enabled = delay_logging || self->delay_agnostic_enabled;
   if (self->delay_logging_enabled) {
     memset(self->delay_histogram, 0, sizeof(self->delay_histogram));
   }
 }
 
-void WebRtcAec_enable_reported_delay(AecCore* self, int enable) {
-  self->reported_delay_enabled = enable;
+void WebRtcAec_enable_delay_agnostic(AecCore* self, int enable) {
+  self->delay_agnostic_enabled = enable;
 }
 
-int WebRtcAec_reported_delay_enabled(AecCore* self) {
-  return self->reported_delay_enabled;
+int WebRtcAec_delay_agnostic_enabled(AecCore* self) {
+  return self->delay_agnostic_enabled;
 }
 
 void WebRtcAec_enable_extended_filter(AecCore* self, int enable) {
   self->extended_filter_enabled = enable;
   self->num_partitions = enable ? kExtendedNumPartitions : kNormalNumPartitions;
   // Update the delay estimator with filter length.  See InitAEC() for details.
   WebRtc_set_allowed_offset(self->delay_estimator, self->num_partitions / 2);
 }
 
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }