Add new variance update option and unittests for intelligibility

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h

 /*
  *  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 @@
   // Construct a new instance with the given filter bank resolution,
   // sampling rate, number of channels and analysis rates.
   // |analysis_rate| sets the number of input blocks (containing speech!)
   // to elapse before a new gain computation is made. |variance_rate| specifies
   // the number of gain recomputations after which the variances are reset.
   // |cv_*| are parameters for the VarianceArray constructor for the
   // clear speech stream.
   // TODO(bercic): the |cv_*|, |*_rate| and |gain_limit| parameters should
   // probably go away once fine tuning is done. They override the internal
   // constants in the class (kGainChangeLimit, kAnalyzeRate, kVarianceRate).
   IntelligibilityEnhancer(int erb_resolution,

[hlundin-webrtc, 2015/06/30 14:00:52]

This is a very complicated constructor call. Consider using a config struct
instead. See for instance NetEq::Config in neteq.h. The config struct should
typically have a constructor which populates the config with default values. A
user will then only have to modify the values if they differ from the default.
You can also add convenience method to the struct, for instance 
std::string ToString() const
for logging and
bool IsOk() const
for validating a configuration before sending it to the class constructor. (An
extra benefit of including an IsOk() method to the Config struct is that the
class constructor can simply CHECK(config.IsOk()) and go down in a ball of fire
if that fails.)

[ekm, 2015/07/01 23:48:25]

You're right. To stay uniform with the other APM components, how about using
Constructor + Intialize for creation and SetExtraOptions to modify defaults?
Might this change be better to include in the next cl, which integrates into the
apm pipeline?

[Andrew MacDonald, 2015/07/02 02:24:49]

Don't worry too much about uniformity with other components; some of the older
ones may be less than ideal :)

I think initializing everything in the constructor is fine, but is it really
useful to expose all of these parameters? Do you intend to use them in a tool
for optimizing them? If so, or if you want to keep some of them, an alternative
is to use default arguments, which is recently permitted by the style guide in
constructors. (Henrik's Config is a slick workaround for the ban on default
arguments :)

I'll send you an example off-review. But I'd make anything you're not intending
to modify externally an internal const.

[hlundin-webrtc, 2015/07/02 10:53:13]

I still think that a Config struct is a better option. Don't worry about the
legacy code. Config structs are on the rise in the WebRTC code base, e.g., the
new Call API and friends, new AudioEncoder classes.

But, I'm fine with you doing that in a follow-up.

[ekm, 2015/07/07 21:57:02]

Acknowledged. Some of these params should not be exposed at all; a few I'd like
to keep for optimizing in a tool. I'll go for the Config in the next cl.

                           int sample_rate_hz,
                           int channels,
                           int cv_type,
                           float cv_alpha,
                           int cv_win,
                           int analysis_rate,
                           int variance_rate,
                           float gain_limit);
   ~IntelligibilityEnhancer();
 
@@ skipping 20 matching lines @@
                                    int in_channels,
                                    int frames,
                                    int out_channels,
                                    std::complex<float>* const* out_block);
 
    private:
     IntelligibilityEnhancer* parent_;
     AudioSource source_;
   };
   friend class TransformCallback;
+  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest, TestErbCreation);
+  FRIEND_TEST_ALL_PREFIXES(IntelligibilityEnhancerTest, TestSolveForGains);
 
   // Sends streams to ProcessClearBlock or ProcessNoiseBlock based on source.
   void DispatchAudio(AudioSource source,
                      const std::complex<float>* in_block,
                      std::complex<float>* out_block);
 
   // Updates variance computation and analysis with |in_block_|,
   // and writes modified speech to |out_block|.
   void ProcessClearBlock(const std::complex<float>* in_block,
                          std::complex<float>* out_block);
 
   // Computes and sets modified gains.
   void AnalyzeClearBlock(float power_target);
 
+  // Bisection search for optimal |lambda|.
+  void SolveForLambda(float power_target, float power_bot, float power_top);
+
+  // Transforms freq gains to ERB gains.
+  void UpdateErbGains();
+
   // Updates variance calculation for noise input with |in_block|.
   void ProcessNoiseBlock(const std::complex<float>* in_block,
                          std::complex<float>* out_block);
 
   // Returns number of ERB filters.
   static int GetBankSize(int sample_rate, int erb_resolution);
 
   // Initializes ERB filterbank.
   void CreateErbBank();
 
   // Analytically solves quadratic for optimal gains given |lambda|.
   // Negative gains are set to 0. Stores the results in |sols|.
   void SolveForGainsGivenLambda(float lambda, int start_freq, float* sols);
 
   // Computes variance across ERB filters from freq variance |var|.
   // Stores in |result|.
   void FilterVariance(const float* var, float* result);
 
   // Returns dot product of vectors specified by size |length| arrays |a|,|b|.
   static float DotProduct(const float* a, const float* b, int length);
 
   static const int kErbResolution;

[hlundin-webrtc, 2015/06/30 14:00:52]

Static const data members should go before methods.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Declaration_O...

[ekm, 2015/07/01 23:48:25]

Done.

   static const int kWindowSizeMs;
   static const int kChunkSizeMs;
   static const int kAnalyzeRate;   // Default for |analysis_rate_|.
   static const int kVarianceRate;  // Default for |variance_rate_|.
   static const float kClipFreq;
   static const float kConfigRho;  // Default production and interpretation SNR.
   static const float kKbdAlpha;
   static const float kGainChangeLimit;
+  static const float kLambdaBot;  // Extreme values in bisection
+  static const float kLambdaTop;  // search for lambda.
 
   const int freqs_;         // Num frequencies in frequency domain.
   const int window_size_;   // Window size in samples; also the block size.
   const int chunk_length_;  // Chunk size in samples.
   const int bank_size_;     // Num ERB filters.
   const int sample_rate_hz_;
   const int erb_resolution_;
   const int channels_;       // Num channels.
   const int analysis_rate_;  // Num blocks before gains recalculated.
   const int variance_rate_;  // Num recalculations before history is cleared.
@@ skipping 29 matching lines @@
   // Note: VAD currently does not affect anything in IntelligibilityEnhancer.
   VadInst* vad_high_;
   VadInst* vad_low_;
   rtc::scoped_ptr<int16_t[]> vad_tmp_buffer_;
   bool has_voice_low_;  // Whether voice detected in speech stream.
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_ENHANCER_H_