Corrected the delay agnostic AEC behavior during periods of silent farend signal.

webrtc/modules/audio_processing/utility/delay_estimator.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.
  */
 
 #include "webrtc/modules/audio_processing/utility/delay_estimator.h"
 
+#include <algorithm>

[hlundin-webrtc, 2016/05/11 13:06:19]

C system files go before C++ system files.

[peah-webrtc, 2016/05/11 13:16:08]

Good catch!
Done.

 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 // Number of right shifts for scaling is linearly depending on number of bits in
 // the far-end binary spectrum.
 static const int kShiftsAtZero = 13;  // Right shifts at zero binary spectrum.
 static const int kShiftsLinearSlope = 3;
 
 static const int32_t kProbabilityOffset = 1024;  // 2 in Q9.
@@ skipping 588 matching lines @@
   //  1) The valley is distinct enough (|valley_depth| > |kProbabilityOffset|)
   // and
   //  2) The depth of the valley is deep enough
   //      (|value_best_candidate| < |minimum_probability|)
   //     and deeper than the best estimate so far
   //      (|value_best_candidate| < |last_delay_probability|)
   valid_candidate = ((valley_depth > kProbabilityOffset) &&
       ((value_best_candidate < self->minimum_probability) ||
           (value_best_candidate < self->last_delay_probability)));
 
-  UpdateRobustValidationStatistics(self, candidate_delay, valley_depth,
-                                   value_best_candidate);
+  // Check for nonstationary farend signal.
+  const bool non_stationary_farend =
+      std::any_of(self->farend->far_bit_counts,
+                  self->farend->far_bit_counts + self->history_size,
+                  [](int a) { return a > 0; });
+
+  if (non_stationary_farend) {
+    // Only update the validation statistics when the farend is nonstationary
+    // as the underlying estimates are otherwise frozen.
+    UpdateRobustValidationStatistics(self, candidate_delay, valley_depth,
+                                     value_best_candidate);
+  }
+
   if (self->robust_validation_enabled) {
     int is_histogram_valid = HistogramBasedValidation(self, candidate_delay);
     valid_candidate = RobustValidation(self, candidate_delay, valid_candidate,
                                        is_histogram_valid);
 
   }
-  if (valid_candidate) {
+
+  // Only update the delay estimate when the farend is nonstationary and when
+  // a valid delay candidate is available.
+  if (non_stationary_farend && valid_candidate) {
     if (candidate_delay != self->last_delay) {
       self->last_delay_histogram =
           (self->histogram[candidate_delay] > kLastHistogramMax ?
               kLastHistogramMax : self->histogram[candidate_delay]);
       // Adjust the histogram if we made a change to |last_delay|, though it was
       // not the most likely one according to the histogram.
       if (self->histogram[candidate_delay] <
           self->histogram[self->compare_delay]) {
         self->histogram[self->compare_delay] = self->histogram[candidate_delay];
       }
@@ skipping 38 matching lines @@
   int32_t diff = new_value - *mean_value;
 
   // mean_new = mean_value + ((new_value - mean_value) >> factor);
   if (diff < 0) {
     diff = -((-diff) >> factor);
   } else {
     diff = (diff >> factor);
   }
   *mean_value += diff;
 }