Robustification of the AEC3 echo removal in the first part of the call

webrtc/modules/audio_processing/aec3/aec_state.cc

 /*
  *  Copyright (c) 2017 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/aec3/aec_state.h"
 
 #include <math.h>
 #include <numeric>
 #include <vector>
 
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
 #include "webrtc/rtc_base/array_view.h"
 #include "webrtc/rtc_base/atomicops.h"
 #include "webrtc/rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
 
-constexpr size_t kEchoPathChangeConvergenceBlocks = 2 * kNumBlocksPerSecond;
-constexpr size_t kSaturationLeakageBlocks = 20;
-
 // Computes delay of the adaptive filter.
 rtc::Optional<size_t> EstimateFilterDelay(
     const std::vector<std::array<float, kFftLengthBy2Plus1>>&
         adaptive_filter_frequency_response) {
   const auto& H2 = adaptive_filter_frequency_response;
 
   size_t reliable_delays_sum = 0;
   size_t num_reliable_delays = 0;
 
   constexpr size_t kUpperBin = kFftLengthBy2 - 5;
@@ skipping 118 matching lines @@
     erl_estimator_.Update(X2, Y2);
   }
 
   // Detect and flag echo saturation.
   // TODO(peah): Add the delay in this computation to ensure that the render and
   // capture signals are properly aligned.
   RTC_DCHECK_LT(0, x.size());
   const float max_sample = fabs(*std::max_element(
       x.begin(), x.end(), [](float a, float b) { return a * a < b * b; }));
   const bool saturated_echo =
-      previous_max_sample_ * kFixedEchoPathGain > 1600 && SaturatedCapture();
+      previous_max_sample_ * 100 > 1600 && SaturatedCapture();
   previous_max_sample_ = max_sample;
 
   // Counts the blocks since saturation.
+  constexpr size_t kSaturationLeakageBlocks = 20;
   blocks_since_last_saturation_ =
       saturated_echo ? 0 : blocks_since_last_saturation_ + 1;
   echo_saturation_ = blocks_since_last_saturation_ < kSaturationLeakageBlocks;
 
   // Flag whether the linear filter estimate is usable.
+  constexpr size_t kEchoPathChangeConvergenceBlocks = 2 * kNumBlocksPerSecond;
   usable_linear_estimate_ =
       (!echo_saturation_) &&
       (!render_received_ ||
        blocks_with_filter_adaptation_ > kEchoPathChangeConvergenceBlocks) &&
       filter_delay_ && echo_path_change_counter_ <= 0;
 
   // After an amount of active render samples for which an echo should have been
   // detected in the capture signal if the ERL was not infinite, flag that a
   // headset is used.
-  headset_detected_ =
-      !external_delay_ && !filter_delay_ &&
-      (!render_received_ ||
-       blocks_with_filter_adaptation_ >= kEchoPathChangeConvergenceBlocks);
+  constexpr size_t kHeadSetDetectionBlocks = 5 * kNumBlocksPerSecond;
+  headset_detected_ = !external_delay_ && !filter_delay_ &&
+                      (!render_received_ || blocks_with_filter_adaptation_ >=
+                                                kHeadSetDetectionBlocks);
 
   // Update the room reverb estimate.
   UpdateReverb(adaptive_filter_impulse_response);
 }
 
 void AecState::UpdateReverb(
     const std::array<float, kAdaptiveFilterTimeDomainLength>&
         impulse_response) {
   if ((!(filter_delay_ && usable_linear_estimate_)) ||
       (*filter_delay_ > kAdaptiveFilterLength - 4)) {
@@ skipping 103 matching lines @@
     max_nearend_ = e_abs;
     max_nearend_counter_ = 0;
   } else {
     if (++max_nearend_counter_ > 5 * kNumBlocksPerSecond) {
       max_nearend_ *= 0.995f;
     }
   }
 }
 
 }  // namespace webrtc