Utilizing the AEC3 config struct for constants.

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.
  */
 
@@ skipping 91 matching lines @@
     RTC_DCHECK_NE(0.f, high_band_energy);
     anti_howling_gain = 0.01f * sqrtf(low_band_energy / high_band_energy);
   }
 
   // Choose the gain as the minimum of the lower and upper gains.
   return std::min(gain_below_8_khz, anti_howling_gain);
 }
 
 // Limits the gain increase.
 void UpdateMaxGainIncrease(
+    const AudioProcessing::Config::EchoCanceller3& config,
     size_t no_saturation_counter,
     bool low_noise_render,
     const std::array<float, kFftLengthBy2Plus1>& last_echo,
     const std::array<float, kFftLengthBy2Plus1>& echo,
     const std::array<float, kFftLengthBy2Plus1>& last_gain,
     const std::array<float, kFftLengthBy2Plus1>& new_gain,
     std::array<float, kFftLengthBy2Plus1>* gain_increase) {
   float max_increasing;
   float max_decreasing;
   float rate_increasing;
   float rate_decreasing;
   float min_increasing;
   float min_decreasing;
 
+  auto& param = config.param.gain_updates;
   if (low_noise_render) {
-    max_increasing = 8.f;
-    max_decreasing = 8.f;
-    rate_increasing = 2.f;
-    rate_decreasing = 2.f;
-    min_increasing = 4.f;
-    min_decreasing = 4.f;
+    max_increasing = param.low_noise.max_inc;
+    max_decreasing = param.low_noise.max_dec;
+    rate_increasing = param.low_noise.rate_inc;
+    rate_decreasing = param.low_noise.rate_dec;
+    min_increasing = param.low_noise.min_inc;
+    min_decreasing = param.low_noise.min_dec;
   } else if (no_saturation_counter > 10) {
-    max_increasing = 4.f;
-    max_decreasing = 4.f;
-    rate_increasing = 2.f;
-    rate_decreasing = 2.f;
-    min_increasing = 1.2f;
-    min_decreasing = 2.f;
+    max_increasing = param.normal.max_inc;
+    max_decreasing = param.normal.max_dec;
+    rate_increasing = param.normal.rate_inc;
+    rate_decreasing = param.normal.rate_dec;
+    min_increasing = param.normal.min_inc;
+    min_decreasing = param.normal.min_dec;
   } else {
-    max_increasing = 1.2f;
-    max_decreasing = 1.2f;
-    rate_increasing = 1.5f;
-    rate_decreasing = 1.5f;
-    min_increasing = 1.f;
-    min_decreasing = 1.f;
+    max_increasing = param.saturation.max_inc;
+    max_decreasing = param.saturation.max_dec;
+    rate_increasing = param.saturation.rate_inc;
+    rate_decreasing = param.saturation.rate_dec;
+    min_increasing = param.saturation.min_inc;
+    min_decreasing = param.saturation.min_dec;
   }
 
   for (size_t k = 0; k < new_gain.size(); ++k) {
     if (echo[k] > last_echo[k]) {
       (*gain_increase)[k] =
           new_gain[k] > last_gain[k]
               ? std::min(max_increasing, (*gain_increase)[k] * rate_increasing)
               : min_increasing;
     } else {
       (*gain_increase)[k] =
           new_gain[k] > last_gain[k]
               ? std::min(max_decreasing, (*gain_increase)[k] * rate_decreasing)
               : min_decreasing;
     }
   }
 }
 
 // Computes the gain to reduce the echo to a non audible level.
 void GainToNoAudibleEcho(
+    const AudioProcessing::Config::EchoCanceller3& config,
     bool low_noise_render,
     bool saturated_echo,
     const std::array<float, kFftLengthBy2Plus1>& nearend,
     const std::array<float, kFftLengthBy2Plus1>& echo,
     const std::array<float, kFftLengthBy2Plus1>& masker,
     const std::array<float, kFftLengthBy2Plus1>& min_gain,
     const std::array<float, kFftLengthBy2Plus1>& max_gain,
     const std::array<float, kFftLengthBy2Plus1>& one_by_echo,
     std::array<float, kFftLengthBy2Plus1>* gain) {
-  constexpr float kEchoMaskingMargin = 1.f / 100.f;
   const float nearend_masking_margin =
-      low_noise_render ? 0.1f : (saturated_echo ? 0.001f : 0.01f);
+      low_noise_render ? 0.1f
+                       : (saturated_echo ? config.param.gain_mask.m2
+                                         : config.param.gain_mask.m3);
 
   for (size_t k = 0; k < gain->size(); ++k) {
     RTC_DCHECK_LE(0.f, nearend_masking_margin * nearend[k]);
     if (echo[k] <= nearend_masking_margin * nearend[k]) {
       (*gain)[k] = 1.f;
     } else {
-      (*gain)[k] = kEchoMaskingMargin * masker[k] * one_by_echo[k];
+      (*gain)[k] = config.param.gain_mask.m1 * masker[k] * one_by_echo[k];
     }
 
     (*gain)[k] = std::min(std::max((*gain)[k], min_gain[k]), max_gain[k]);
   }
 }
 
 // Computes the signal output power that masks the echo signal.
-void MaskingPower(const std::array<float, kFftLengthBy2Plus1>& nearend,
+void MaskingPower(const AudioProcessing::Config::EchoCanceller3& config,
+                  const std::array<float, kFftLengthBy2Plus1>& nearend,
                   const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
                   const std::array<float, kFftLengthBy2Plus1>& last_masker,
                   const std::array<float, kFftLengthBy2Plus1>& gain,
                   std::array<float, kFftLengthBy2Plus1>* masker) {
   std::array<float, kFftLengthBy2Plus1> side_band_masker;
   for (size_t k = 0; k < gain.size(); ++k) {
     side_band_masker[k] = nearend[k] * gain[k] + comfort_noise[k];
-    (*masker)[k] = comfort_noise[k] + 0.1f * last_masker[k];
+    (*masker)[k] =
+        comfort_noise[k] + config.param.gain_mask.m4 * last_masker[k];
   }
   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).
   std::array<float, kFftLengthBy2Plus1> one_by_echo;
   std::transform(echo.begin(), echo.end(), one_by_echo.begin(),
                  [](float a) { return a > 0.f ? 1.f / a : 1.f; });
 
   // Compute the minimum gain as the attenuating gain to put the signal just
   // above the zero sample values.
   std::array<float, kFftLengthBy2Plus1> min_gain;
-  const float min_echo_power = low_noise_render ? 192.f : 64.f;
+  const float min_echo_power =
+      low_noise_render ? config_.param.echo_audibility.low_render_limit
+                       : config_.param.echo_audibility.normal_render_limit;
   if (no_saturation_counter_ > 10) {
     for (size_t k = 0; k < nearend.size(); ++k) {
       const float denom = std::min(nearend[k], echo[k]);
       min_gain[k] = denom > 0.f ? min_echo_power / denom : 1.f;
       min_gain[k] = std::min(min_gain[k], 1.f);
     }
   } else {
     min_gain.fill(0.f);
   }
 
   // Compute the maximum gain by limiting the gain increase from the previous
   // gain.
   std::array<float, kFftLengthBy2Plus1> max_gain;
   for (size_t k = 0; k < gain->size(); ++k) {
     max_gain[k] =
-        std::min(std::max(last_gain_[k] * gain_increase_[k], 0.001f), 1.f);
+        std::min(std::max(last_gain_[k] * gain_increase_[k],
+                          config_.param.gain_updates.floor_first_increase),
+                 1.f);
   }
 
   // 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);
+    MaskingPower(config_, nearend, comfort_noise, last_masker_, *gain, &masker);
+    GainToNoAudibleEcho(config_, 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_);
+  UpdateMaxGainIncrease(config_, 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_);
+  MaskingPower(config_, nearend, comfort_noise, last_masker_, *gain,
+               &last_masker_);
   aec3::VectorMath(optimization_).Sqrt(*gain);
 }
 
-SuppressionGain::SuppressionGain(Aec3Optimization optimization)
-    : optimization_(optimization) {
+SuppressionGain::SuppressionGain(
+    const AudioProcessing::Config::EchoCanceller3& config,
+    Aec3Optimization optimization)
+    : optimization_(optimization), config_(config) {
   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,
@@ skipping 41 matching lines @@
   }
 
   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