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

webrtc/modules/audio_processing/aec3/residual_echo_estimator.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.
  */
 
@@ skipping 118 matching lines @@
       EchoGeneratingPower(render_buffer, 0,
                           kResidualEchoPowerRenderWindowSize - 1, &X2);
     }
 
     // Subtract the stationary noise power to avoid stationary noise causing
     // excessive echo suppression.
     std::transform(
         X2.begin(), X2.end(), X2_noise_floor_.begin(), X2.begin(),
         [](float a, float b) { return std::max(0.f, a - 10.f * b); });
 
-    NonLinearEstimate(
-        aec_state.HeadsetDetected() ? kHeadsetEchoPathGain : kFixedEchoPathGain,
-        X2, Y2, R2);
+    NonLinearEstimate(aec_state, X2, Y2, R2);
     AddEchoReverb(*R2, aec_state.SaturatedEcho(),
                   std::min(static_cast<size_t>(kAdaptiveFilterLength),
                            delay.value_or(kAdaptiveFilterLength)),
                   aec_state.ReverbDecayFactor(), R2);
   }
 
   // If the echo is saturated, estimate the echo power as the maximum echo power
   // with a leakage factor.
   if (aec_state.SaturatedEcho()) {
     R2->fill((*std::max_element(R2->begin(), R2->end())) * 100.f);
@@ skipping 20 matching lines @@
     std::array<float, kFftLengthBy2Plus1>* R2) {
   std::fill(R2_hold_counter_.begin(), R2_hold_counter_.end(), 10.f);
   std::transform(erle.begin(), erle.end(), S2_linear.begin(), R2->begin(),
                  [](float a, float b) {
                    RTC_DCHECK_LT(0.f, a);
                    return b / a;
                  });
 }
 
 void ResidualEchoEstimator::NonLinearEstimate(
-    float echo_path_gain,
+    const AecState& aec_state,

[ivoc, 2017/07/11 08:46:04]

Since the function only uses aec_state.HeadsetDetected(), how about passing that
in as an argument as a bool instead of the aec_state? 

[peah-webrtc, 2017/07/11 08:53:01]

Good point!

Done.

     const std::array<float, kFftLengthBy2Plus1>& X2,
     const std::array<float, kFftLengthBy2Plus1>& Y2,
     std::array<float, kFftLengthBy2Plus1>* R2) {
+  // Choose gains.
+  const float echo_path_gain_lf =
+      aec_state.HeadsetDetected() ? kHeadsetEchoPathGain : 100;
+  const float echo_path_gain_mf =
+      aec_state.HeadsetDetected() ? kHeadsetEchoPathGain : 1000;
+  const float echo_path_gain_hf =
+      aec_state.HeadsetDetected() ? kHeadsetEchoPathGain : 5000;
+
   // Compute preliminary residual echo.
-  std::transform(X2.begin(), X2.end(), R2->begin(),
-                 [echo_path_gain](float a) { return a * echo_path_gain; });
+  std::transform(
+      X2.begin(), X2.begin() + 12, R2->begin(),
+      [echo_path_gain_lf](float a) { return a * echo_path_gain_lf; });
+  std::transform(
+      X2.begin() + 12, X2.begin() + 25, R2->begin() + 12,
+      [echo_path_gain_mf](float a) { return a * echo_path_gain_mf; });
+  std::transform(
+      X2.begin() + 25, X2.end(), R2->begin() + 25,
+      [echo_path_gain_hf](float a) { return a * echo_path_gain_hf; });
 
   for (size_t k = 0; k < R2->size(); ++k) {
     // Update hold counter.
     R2_hold_counter_[k] = R2_old_[k] < (*R2)[k] ? 0 : R2_hold_counter_[k] + 1;
 
     // Compute the residual echo by holding a maximum echo powers and an echo
     // fading corresponding to a room with an RT60 value of about 50 ms.
     (*R2)[k] = R2_hold_counter_[k] < 2
                    ? std::max((*R2)[k], R2_old_[k])
                    : std::min((*R2)[k] + R2_old_[k] * 0.1f, Y2[k]);
@@ skipping 35 matching lines @@
   } else {
     std::copy(S2.begin(), S2.end(), S2_old_[S2_old_index_].begin());
   }
 
   // Add the power of the echo reverb to the residual echo power.
   std::transform(R2->begin(), R2->end(), R2_reverb_.begin(), R2->begin(),
                  std::plus<float>());
 }
 
 }  // namespace webrtc