Add adaptive notch filter to remove narrowband echo components in AEC3

webrtc/modules/audio_processing/aec3/suppression_gain.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/suppression_gain.h"
 
 #include "webrtc/typedefs.h"
 #if defined(WEBRTC_ARCH_X86_FAMILY)
 #include <emmintrin.h>
 #endif
 #include <math.h>
 #include <algorithm>
 #include <functional>
 #include <numeric>
 
 #include "webrtc/modules/audio_processing/aec3/vector_math.h"
 #include "webrtc/rtc_base/checks.h"
 
 namespace webrtc {
 namespace {
 
+// Reduce gain to avoid narrow band echo leakage.
+void NarrowBandAttenuation(int narrow_bin,
+                           std::array<float, kFftLengthBy2Plus1>* gain) {
+  const int upper_bin =
+      std::min(narrow_bin + 6, static_cast<int>(kFftLengthBy2Plus1 - 1));
+  for (int k = std::max(0, narrow_bin - 6); k <= upper_bin; ++k) {
+    (*gain)[k] = std::min((*gain)[k], 0.001f);
+  }
+}
+
 // Adjust the gains according to the presence of known external filters.
 void AdjustForExternalFilters(std::array<float, kFftLengthBy2Plus1>* gain) {
   // Limit the low frequency gains to avoid the impact of the high-pass filter
   // on the lower-frequency gain influencing the overall achieved gain.
   (*gain)[0] = (*gain)[1] = std::min((*gain)[1], (*gain)[2]);
 
   // Limit the high frequency gains to avoid the impact of the anti-aliasing
   // filter on the upper-frequency gains influencing the overall achieved
   // gain. TODO(peah): Update this when new anti-aliasing filters are
   // implemented.
   constexpr size_t kAntiAliasingImpactLimit = (64 * 2000) / 8000;
   const float min_upper_gain = (*gain)[kAntiAliasingImpactLimit];
   std::for_each(
       gain->begin() + kAntiAliasingImpactLimit, gain->end() - 1,
       [min_upper_gain](float& a) { a = std::min(a, min_upper_gain); });
   (*gain)[kFftLengthBy2] = (*gain)[kFftLengthBy2Minus1];
 }
 
 // Computes the gain to apply for the bands beyond the first band.
 float UpperBandsGain(
+    const rtc::Optional<int>& narrow_peak_band,
     bool saturated_echo,
     const std::vector<std::vector<float>>& render,
     const std::array<float, kFftLengthBy2Plus1>& low_band_gain) {
   RTC_DCHECK_LT(0, render.size());
   if (render.size() == 1) {
     return 1.f;
   }
 
+  if (narrow_peak_band &&
+      (*narrow_peak_band > static_cast<int>(kFftLengthBy2Plus1 - 10))) {
+    return 0.001f;
+  }
+
   constexpr size_t kLowBandGainLimit = kFftLengthBy2 / 2;
   const float gain_below_8_khz = *std::min_element(
       low_band_gain.begin() + kLowBandGainLimit, low_band_gain.end());
 
   // Always attenuate the upper bands when there is saturated echo.
   if (saturated_echo) {
     return std::min(0.001f, gain_below_8_khz);
   }
 
   // Compute the upper and lower band energies.
@@ skipping 120 matching lines @@
   for (size_t k = 1; k < gain.size() - 1; ++k) {
     (*masker)[k] += 0.1f * (side_band_masker[k - 1] + side_band_masker[k + 1]);
   }
 }
 
 }  // namespace
 
 // TODO(peah): Add further optimizations, in particular for the divisions.
 void SuppressionGain::LowerBandGain(
     bool low_noise_render,
+    const rtc::Optional<int>& narrow_peak_band,
     bool saturated_echo,
     const std::array<float, kFftLengthBy2Plus1>& nearend,
     const std::array<float, kFftLengthBy2Plus1>& echo,
     const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
     std::array<float, kFftLengthBy2Plus1>* gain) {
   // Count the number of blocks since saturation.
   no_saturation_counter_ = saturated_echo ? 0 : no_saturation_counter_ + 1;
 
   // Precompute 1/echo (note that when the echo is zero, the precomputed value
   // is never used).
@@ skipping 25 matching lines @@
 
   // Iteratively compute the gain required to attenuate the echo to a non
   // noticeable level.
   gain->fill(0.f);
   for (int k = 0; k < 2; ++k) {
     std::array<float, kFftLengthBy2Plus1> masker;
     MaskingPower(nearend, comfort_noise, last_masker_, *gain, &masker);
     GainToNoAudibleEcho(low_noise_render, saturated_echo, nearend, echo, masker,
                         min_gain, max_gain, one_by_echo, gain);
     AdjustForExternalFilters(gain);
+    if (narrow_peak_band) {
+      NarrowBandAttenuation(*narrow_peak_band, gain);
+    }
   }
 
   // Update the allowed maximum gain increase.
   UpdateMaxGainIncrease(no_saturation_counter_, low_noise_render, last_echo_,
                         echo, last_gain_, *gain, &gain_increase_);
 
   // Store data required for the gain computation of the next block.
   std::copy(echo.begin(), echo.end(), last_echo_.begin());
   std::copy(gain->begin(), gain->end(), last_gain_.begin());
   MaskingPower(nearend, comfort_noise, last_masker_, *gain, &last_masker_);
   aec3::VectorMath(optimization_).Sqrt(*gain);
 }
 
 SuppressionGain::SuppressionGain(Aec3Optimization optimization)
     : optimization_(optimization) {
   last_gain_.fill(1.f);
   last_masker_.fill(0.f);
   gain_increase_.fill(1.f);
   last_echo_.fill(0.f);
 }
 
 void SuppressionGain::GetGain(
     const std::array<float, kFftLengthBy2Plus1>& nearend,
     const std::array<float, kFftLengthBy2Plus1>& echo,
     const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
+    const RenderSignalAnalyzer& render_signal_analyzer,
     bool saturated_echo,
     const std::vector<std::vector<float>>& render,
     bool force_zero_gain,
     float* high_bands_gain,
     std::array<float, kFftLengthBy2Plus1>* low_band_gain) {
   RTC_DCHECK(high_bands_gain);
   RTC_DCHECK(low_band_gain);
 
   if (force_zero_gain) {
     last_gain_.fill(0.f);
     std::copy(comfort_noise.begin(), comfort_noise.end(), last_masker_.begin());
     low_band_gain->fill(0.f);
     gain_increase_.fill(1.f);
     *high_bands_gain = 0.f;
     return;
   }
 
   bool low_noise_render = low_render_detector_.Detect(render);
 
   // Compute gain for the lower band.
-  LowerBandGain(low_noise_render, saturated_echo, nearend, echo, comfort_noise,
-                low_band_gain);
+  const rtc::Optional<int> narrow_peak_band =
+      render_signal_analyzer.NarrowPeakBand();
+  LowerBandGain(low_noise_render, narrow_peak_band, saturated_echo, nearend,
+                echo, comfort_noise, low_band_gain);
 
   // Compute the gain for the upper bands.
-  *high_bands_gain = UpperBandsGain(saturated_echo, render, *low_band_gain);
+  *high_bands_gain =
+      UpperBandsGain(narrow_peak_band, saturated_echo, render, *low_band_gain);
 }
 
 // Detects when the render signal can be considered to have low power and
 // consist of stationary noise.
 bool SuppressionGain::LowNoiseRenderDetector::Detect(
     const std::vector<std::vector<float>>& render) {
   float x2_sum = 0.f;
   float x2_max = 0.f;
   for (auto x_k : render[0]) {
     const float x2 = x_k * x_k;
     x2_sum += x2;
     x2_max = std::max(x2_max, x2);
   }
 
   constexpr float kThreshold = 50.f * 50.f * 64.f;
   const bool low_noise_render =
       average_power_ < kThreshold && x2_max < 3 * average_power_;
   average_power_ = average_power_ * 0.9f + x2_sum * 0.1f;
   return low_noise_render;
 }
 
 }  // namespace webrtc