Fix normalization of noise estimate in NoiseSuppressor

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc

 /*
  *  Copyright (c) 2014 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 11 matching lines @@
 
 namespace webrtc {
 
 namespace {
 
 const size_t kErbResolution = 2;
 const int kWindowSizeMs = 16;
 const int kChunkSizeMs = 10;  // Size provided by APM.
 const float kClipFreqKhz = 0.2f;
 const float kKbdAlpha = 1.5f;
-const float kLambdaBot = -1.0f;      // Extreme values in bisection
+const float kLambdaBot = -1.f;      // Extreme values in bisection
 const float kLambdaTop = -1e-5f;      // search for lamda.
 const float kVoiceProbabilityThreshold = 0.02f;
 // Number of chunks after voice activity which is still considered speech.
 const size_t kSpeechOffsetDelay = 80;
 const float kDecayRate = 0.98f;              // Power estimation decay rate.
 const float kMaxRelativeGainChange = 0.04f;  // Maximum relative change in gain.
 const float kRho = 0.0004f;  // Default production and interpretation SNR.
+const float kPowerNormalizationFactor = 1.f / (1 << 30);
 
 // Returns dot product of vectors |a| and |b| with size |length|.
 float DotProduct(const float* a, const float* b, size_t length) {
   float ret = 0.f;
   for (size_t i = 0; i < length; ++i) {
     ret += a[i] * b[i];
   }
   return ret;
 }
 
 // Computes the power across ERB bands from the power spectral density |pow|.
 // Stores it in |result|.
 void MapToErbBands(const float* pow,
                    const std::vector<std::vector<float>>& filter_bank,
                    float* result) {
   for (size_t i = 0; i < filter_bank.size(); ++i) {
     RTC_DCHECK_GT(filter_bank[i].size(), 0u);
-    result[i] = DotProduct(filter_bank[i].data(), pow, filter_bank[i].size());
+    result[i] = kPowerNormalizationFactor *
+                DotProduct(filter_bank[i].data(), pow, filter_bank[i].size());
   }
 }
 
 }  // namespace
 
 IntelligibilityEnhancer::IntelligibilityEnhancer(int sample_rate_hz,
                                                  size_t num_render_channels,
                                                  size_t num_noise_bins)
     : freqs_(RealFourier::ComplexLength(
           RealFourier::FftOrder(sample_rate_hz * kWindowSizeMs / 1000))),
@@ skipping 65 matching lines @@
   if (is_speech_) {
     clear_power_estimator_.Step(in_block[0]);
   }
   const std::vector<float>& clear_power = clear_power_estimator_.power();
   const std::vector<float>& noise_power = noise_power_estimator_.power();
   MapToErbBands(clear_power.data(), render_filter_bank_,
                 filtered_clear_pow_.data());
   MapToErbBands(noise_power.data(), capture_filter_bank_,
                 filtered_noise_pow_.data());
   SolveForGainsGivenLambda(kLambdaTop, start_freq_, gains_eq_.data());
-  const float power_target =
-      std::accumulate(clear_power.data(), clear_power.data() + freqs_, 0.f);
+  const float power_target = std::accumulate(
+      filtered_clear_pow_.data(), filtered_clear_pow_.data() + bank_size_, 0.f);
   const float power_top =
       DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
   SolveForGainsGivenLambda(kLambdaBot, start_freq_, gains_eq_.data());
   const float power_bot =
       DotProduct(gains_eq_.data(), filtered_clear_pow_.data(), bank_size_);
   if (power_target >= power_bot && power_target <= power_top) {
     SolveForLambda(power_target);
     UpdateErbGains();
   }  // Else experiencing power underflow, so do nothing.
   for (size_t i = 0; i < in_channels; ++i) {
@@ skipping 151 matching lines @@
   vad_.ProcessChunk(audio_s16_.data(), chunk_length_, sample_rate_hz_);
   if (vad_.last_voice_probability() > kVoiceProbabilityThreshold) {
     chunks_since_voice_ = 0;
   } else if (chunks_since_voice_ < kSpeechOffsetDelay) {
     ++chunks_since_voice_;
   }
   return chunks_since_voice_ < kSpeechOffsetDelay;
 }
 
 }  // namespace webrtc