Add new variance update option and unittests for intelligibility

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 24 matching lines @@
 
 const int IntelligibilityEnhancer::kErbResolution = 2;
 const int IntelligibilityEnhancer::kWindowSizeMs = 2;
 const int IntelligibilityEnhancer::kChunkSizeMs = 10;  // Size provided by APM.
 const int IntelligibilityEnhancer::kAnalyzeRate = 800;
 const int IntelligibilityEnhancer::kVarianceRate = 2;
 const float IntelligibilityEnhancer::kClipFreq = 200.0f;
 const float IntelligibilityEnhancer::kConfigRho = 0.02f;
 const float IntelligibilityEnhancer::kKbdAlpha = 1.5f;
 
+const float IntelligibilityEnhancer::kLambdaBot = -1.0;
+const float IntelligibilityEnhancer::kLambdaTop = -10e-18f;
+
 // To disable gain update smoothing, set gain limit to be VERY high.
 // TODO(ekmeyerson): Add option to disable gain smoothing altogether
 // to avoid the extra computation.
 const float IntelligibilityEnhancer::kGainChangeLimit = 0.0125f;
 
 using VarianceType = intelligibility::VarianceArray::StepType;
 
 IntelligibilityEnhancer::TransformCallback::TransformCallback(
     IntelligibilityEnhancer* parent,
     IntelligibilityEnhancer::AudioSource source)
@@ skipping 177 matching lines @@
   }
 
   /* efidata(n,:) = sqrt(b(n)) * fidata(n,:) */
   gain_applier_.Apply(in_block, out_block);
 }
 
 void IntelligibilityEnhancer::AnalyzeClearBlock(float power_target) {
   FilterVariance(clear_variance_.variance(), filtered_clear_var_.get());
   FilterVariance(noise_variance_.variance(), filtered_noise_var_.get());
 
-  // Bisection search for optimal |lambda|
-
-  float lambda_bot = -1.0f, lambda_top = -10e-18f, lambda;
-  float power_bot, power_top, power;
-  SolveForGainsGivenLambda(lambda_top, start_freq_, gains_eq_.get());
+  float power_bot, power_top;
+  SolveForGainsGivenLambda(kLambdaTop, start_freq_, gains_eq_.get());
   power_top =
       DotProduct(gains_eq_.get(), filtered_clear_var_.get(), bank_size_);
-  SolveForGainsGivenLambda(lambda_bot, start_freq_, gains_eq_.get());
+  SolveForGainsGivenLambda(kLambdaBot, start_freq_, gains_eq_.get());
   power_bot =
       DotProduct(gains_eq_.get(), filtered_clear_var_.get(), bank_size_);
-  DCHECK(power_target >= power_bot && power_target <= power_top);
+  if(power_target >= power_bot && power_target <= power_top) {
+    SolveForLambda(power_target, power_bot, power_top);
+  } else {
+    // Experiencing underflow; no speech; does not modify gains.
+    for (int i = 0; i < freqs_; ++i) {
+      gains_eq_[i] = 1.0f;

[turaj, 2015/06/26 00:32:57]

Does this really mean that are not changing gains? What if we do nothing, then
we will have same |gains_eq_| from the past and UpdateErbGains() will result in
the same gains. It that is correct we even don't need to run UpdateErbGains()
either. 

[ekm, 2015/06/26 19:07:09]

Done. You're right. I was thinking that if the previous |gains_eq_| were high
then it would be strange to boost a ~0 variance signal, but it results in ~0
signal either way, and this saves computation. When speech eventually comes back
on, the previous |gains_eq_| will still apply for a window, but that should be
ok.

+    }
+  }
+  UpdateErbGains();
+}
 
+void IntelligibilityEnhancer::SolveForLambda(float power_target,
+                                             float power_bot,
+                                             float power_top) {
+  float lambda_bot = kLambdaBot;
+  float lambda_top = kLambdaTop;
+  float lambda, power;
   float power_ratio = 2.0f;  // Ratio of achieved power to target power.
   const float kConvergeThresh = 0.001f;  // TODO(ekmeyerson): Find best values
   const int kMaxIters = 100;             // for these, based on experiments.
   int iters = 0;
   while (fabs(power_ratio - 1.0f) > kConvergeThresh && iters <= kMaxIters) {
     lambda = lambda_bot + (lambda_top - lambda_bot) / 2.0f;
     SolveForGainsGivenLambda(lambda, start_freq_, gains_eq_.get());
     power = DotProduct(gains_eq_.get(), filtered_clear_var_.get(), bank_size_);
     if (power < power_target) {
       lambda_bot = lambda;
     } else {
       lambda_top = lambda;
     }
     power_ratio = fabs(power / power_target);
     ++iters;
   }
+}
 
+void IntelligibilityEnhancer::UpdateErbGains() {
   // (ERB gain) = filterbank' * (freq gain)
   float* gains = gain_applier_.target();
   for (int i = 0; i < freqs_; ++i) {
     gains[i] = 0.0f;
     for (int j = 0; j < bank_size_; ++j) {
       gains[i] = fmaf(filter_bank_[j][i], gains_eq_[j], gains[i]);
     }
   }
 }
 
@@ skipping 116 matching lines @@
                                           int length) {
   float ret = 0.0f;
 
   for (int i = 0; i < length; ++i) {
     ret = fmaf(a[i], b[i], ret);
   }
   return ret;
 }
 
 }  // namespace webrtc