Initial SIE commit: migrating existing code

webrtc/modules/audio_processing/intelligibility/intelligibility_utils.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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
+#define WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
+
+#include <complex>
+
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+
+namespace webrtc {
+
+namespace intelligibility {
+
+// 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 {
+ public:
+  enum StepType {
+    kStepInfinite = 0,
+    kStepDecaying,
+    kStepWindowed,
+    kStepBlocked
+  };
+
+  // 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(int freqs, StepType type, int 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_;
+  }
+
+ 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);
+
+  // The current average X and X^2.
+  scoped_ptr<std::complex<float>[]> running_mean_;
+  scoped_ptr<std::complex<float>[]> running_mean_sq_;
+
+  // Average X and X^2 for the current block in kStepBlocked.
+  scoped_ptr<std::complex<float>[]> sub_running_mean_;
+  scoped_ptr<std::complex<float>[]> sub_running_mean_sq_;
+
+  // Sample history for the rolling window in kStepWindowed and block-wise
+  // histories for kStepBlocked.
+  scoped_ptr<scoped_ptr<std::complex<float>[]>[]> history_;
+  scoped_ptr<scoped_ptr<std::complex<float>[]>[]> subhistory_;
+  scoped_ptr<scoped_ptr<std::complex<float>[]>[]> subhistory_sq_;
+
+  // The current set of variances and sums for Welford's algorithm.
+  scoped_ptr<float[]> variance_;
+  scoped_ptr<float[]> conj_sum_;
+
+  const int freqs_;
+  const int window_size_;
+  const float decay_;
+  int history_cursor_;
+  int count_;
+  float array_mean_;
+  void (VarianceArray::*step_func_)(const std::complex<float>*, bool);
+};
+
+// Helper class for smoothing gain changes. On each applicatiion 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 {
+ public:
+  GainApplier(int freqs, float change_limit);
+
+  // Copy |in_block| to |out_block|, multiplied by the current set of gains,
+  // and step the current set of gains towards the target set.
+  void Apply(const std::complex<float>* in_block,
+             std::complex<float>* out_block);
+
+  // Return the current target gain set. Modify this array to set the targets.
+  float* target() const {
+    return target_.get();
+  }
+
+ private:
+  const int freqs_;
+  const float change_limit_;
+  scoped_ptr<float[]> target_;
+  scoped_ptr<float[]> current_;
+};
+
+}  // namespace intelligibility
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INTELLIGIBILITY_INTELLIGIBILITY_UTILS_H_
+