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.
  */
 
@@ skipping 600 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.
+  bool non_stationary_farend = false;

[hlundin-webrtc, 2016/05/11 12:39:48]

You are traversing the array from end to beginning. If this is not important, I
suggest a one-liner instead:

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; });

I don't think it works to use any_of to backwards-traverse a raw array. One
option is to wrap the array (just locally) in an ArrayView and get iterators out
of it, but ArrayView currently has no reverse-iterators implemented.

[peah-webrtc, 2016/05/11 12:53:33]

Wow! That was great!! And works splendidly. Thanks!
Done.

+  for (i = self->history_size - 1; i >= 0; --i) {
+    if (self->farend->far_bit_counts[i] > 0) {
+      non_stationary_farend = true;
+      break;
+    }
+  }
+
+  if (non_stationary_farend) {
+    // Only update the validation statistics when the farend is nonstationary
+    // as the underlying estimates are otherwise freezed.

[hlundin-webrtc, 2016/05/11 12:39:48]

frozen

[peah-webrtc, 2016/05/11 12:53:33]

Done.

+    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;
 }