Fix and simplify the power estimation in the IntelligibilityEnhancer

webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h

Index: webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
index 4ac11671474dcde823379be25990532684a499ea..7d5de7d92a54b2fed4065ccee72a7990ce03d4a2 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h
@@ -8,10 +8,6 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-//
-//  Specifies helper classes for intelligibility enhancement.
-//
-
 #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
 #define WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
 
@@ -21,117 +17,36 @@
 
 namespace webrtc {
 
-namespace intelligibility {

[turaj, 2016/02/12 23:12:35]

Do you think it was a bad idea to protect this utility in a namespace? 

[aluebs-webrtc, 2016/02/13 01:47:50]

I think it adds too much verbosity, but if you think it helps I am happy to add
the namespace back.

[turaj, 2016/02/17 16:36:30]

I thought, in general, limiting the scope is recommended, obviously one should
not over do it, otherwise we will end up with many layers of namespace. In this
case, I thought maybe it makes sense to have utility namespace, especially that
the class names are so generic. That said, really don't have strong opinion,
just curious why to change something that is potentially good.

[aluebs-webrtc, 2016/02/17 23:37:59]

I completely agree that in general limiting the scope is good, but I felt in
this case it was overly verbose with not much gain, but you are right, the names
of the utility classes are really generic. Added the namespace back.

-
-// Return |current| changed towards |target|, with the change being at most
-// |limit|.
-float UpdateFactor(float target, float current, float limit);
-
-// Apply a small fudge to degenerate complex values. The numbers in the array
-// were chosen randomly, so that even a series of all zeroes has some small
-// variability.
-std::complex<float> zerofudge(std::complex<float> c);
-
-// Incremental mean computation. Return the mean of the series with the
-// mean |mean| with added |data|.
-std::complex<float> NewMean(std::complex<float> mean,
-                            std::complex<float> data,
-                            size_t count);
-
-// Updates |mean| with added |data|;
-void AddToMean(std::complex<float> data,
-               size_t count,
-               std::complex<float>* mean);
-
-// Internal helper for computing the variances of a stream of arrays.
-// The result is an array of variances per position: the i-th variance
-// is the variance of the stream of data on the i-th positions in the
-// input arrays.
-// There are four methods of computation:
-//  * kStepInfinite computes variances from the beginning onwards
-//  * kStepDecaying uses a recursive exponential decay formula with a
-//    settable forgetting factor
-//  * kStepWindowed computes variances within a moving window
-//  * kStepBlocked is similar to kStepWindowed, but history is kept
-//    as a rolling window of blocks: multiple input elements are used for
-//    one block and the history then consists of the variances of these blocks
-//    with the same effect as kStepWindowed, but less storage, so the window
-//    can be longer
-class VarianceArray {
+// Internal helper for computing the power of a stream of arrays.
+// The result is an array of power per position: the i-th power is the power of
+// the stream of data on the i-th positions in the input arrays.
+class PowerEstimator {
  public:
-  enum StepType {
-    kStepInfinite = 0,
-    kStepDecaying,
-    kStepWindowed,
-    kStepBlocked,
-    kStepBlockBasedMovingAverage
-  };
-
-  // Construct an instance for the given input array length (|freqs|) and
-  // computation algorithm (|type|), with the appropriate parameters.
-  // |window_size| is the number of samples for kStepWindowed and
-  // the number of blocks for kStepBlocked. |decay| is the forgetting factor
-  // for kStepDecaying.
-  VarianceArray(size_t freqs, StepType type, size_t window_size, float decay);
-
-  // Add a new data point to the series and compute the new variances.
-  // TODO(bercic) |skip_fudge| is a flag for kStepWindowed and kStepDecaying,
-  // whether they should skip adding some small dummy values to the input
-  // to prevent problems with all-zero inputs. Can probably be removed.
-  void Step(const std::complex<float>* data, bool skip_fudge = false) {
-    (this->*step_func_)(data, skip_fudge);
-  }
-  // Reset variances to zero and forget all history.
-  void Clear();
-  // Scale the input data by |scale|. Effectively multiply variances
-  // by |scale^2|.
-  void ApplyScale(float scale);
-
-  // The current set of variances.
-  const float* variance() const { return variance_.get(); }
-
-  // The mean value of the current set of variances.
-  float array_mean() const { return array_mean_; }
+  // Construct an instance for the given input array length (|freqs|), with the
+  // appropriate parameters. |decay| is the forgetting factor.
+  PowerEstimator(size_t freqs, float decay);
 
- private:
-  void InfiniteStep(const std::complex<float>* data, bool dummy);
-  void DecayStep(const std::complex<float>* data, bool dummy);
-  void WindowedStep(const std::complex<float>* data, bool dummy);
-  void BlockedStep(const std::complex<float>* data, bool dummy);
-  void BlockBasedMovingAverage(const std::complex<float>* data, bool dummy);
+  // Add a new data point to the series.
+  void Step(const std::complex<float>* data);
 
+  // The current power array.
+  const float* Power();
+
+ private:
   // TODO(ekmeyerson): Switch the following running means
   // and histories from rtc::scoped_ptr to std::vector.
-
-  // The current average X and X^2.
-  rtc::scoped_ptr<std::complex<float>[]> running_mean_;
   rtc::scoped_ptr<std::complex<float>[]> running_mean_sq_;
 
-  // Average X and X^2 for the current block in kStepBlocked.
-  rtc::scoped_ptr<std::complex<float>[]> sub_running_mean_;
-  rtc::scoped_ptr<std::complex<float>[]> sub_running_mean_sq_;
-
-  // Sample history for the rolling window in kStepWindowed and block-wise
-  // histories for kStepBlocked.
-  rtc::scoped_ptr<rtc::scoped_ptr<std::complex<float>[]>[]> history_;
-  rtc::scoped_ptr<rtc::scoped_ptr<std::complex<float>[]>[]> subhistory_;
-  rtc::scoped_ptr<rtc::scoped_ptr<std::complex<float>[]>[]> subhistory_sq_;
-
-  // The current set of variances and sums for Welford's algorithm.
-  rtc::scoped_ptr<float[]> variance_;
-  rtc::scoped_ptr<float[]> conj_sum_;
+  // The current magnitude array.
+  rtc::scoped_ptr<float[]> magnitude_;
+  // The current power array.
+  rtc::scoped_ptr<float[]> power_;
 
   const size_t num_freqs_;
-  const size_t window_size_;
   const float decay_;
-  size_t history_cursor_;
-  size_t count_;
-  float array_mean_;
-  bool buffer_full_;
-  void (VarianceArray::*step_func_)(const std::complex<float>*, bool);
 };
 
-// Helper class for smoothing gain changes. On each applicatiion step, the
+// Helper class for smoothing gain changes. On each application step, the
 // currently used gains are changed towards a set of settable target gains,
 // constrained by a limit on the magnitude of the changes.
 class GainApplier {
@@ -153,8 +68,6 @@ class GainApplier {
   rtc::scoped_ptr<float[]> current_;
 };
 
-}  // namespace intelligibility
-
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_