Use VAD to get a better speech power estimation in the IntelligibilityEnhancer

webrtc/modules/audio_processing/intelligibility/intelligibility_utils.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 13 matching lines @@
 float UpdateFactor(float target, float current, float limit) {
   float delta = fabsf(target - current);
   float sign = copysign(1.0f, target - current);
   return current + sign * fminf(delta, limit);
 }
 
 }  // namespace
 
 PowerEstimator::PowerEstimator(size_t num_freqs,
                                float decay)
-    : magnitude_(new float[num_freqs]()),
-      power_(new float[num_freqs]()),
-      num_freqs_(num_freqs),
-      decay_(decay) {
-  memset(magnitude_.get(), 0, sizeof(*magnitude_.get()) * num_freqs_);
-  memset(power_.get(), 0, sizeof(*power_.get()) * num_freqs_);
-}
+    : power_(num_freqs, 0.f),
+      decay_(decay) {}
 
-// Compute the magnitude from the beginning, with exponential decaying of the
-// series data.
-void PowerEstimator::Step(const std::complex<float>* data) {
-  for (size_t i = 0; i < num_freqs_; ++i) {
-    magnitude_[i] = decay_ * magnitude_[i] +
-                (1.0f - decay_) * std::abs(data[i]);
+// Compute the power from the beginning, with exponential decaying of the series
+// data.
+void PowerEstimator::Step(const float* data) {

[turaj, 2016/02/13 00:09:43]

This is a utility class so I guess it is fine to be implemented like this. But
this is a bit dangerous implementation in the sense that one might call both
Step() methods and mess up with averaging. I guess what you need here is a
template class.

[hlundin-webrtc, 2016/02/15 13:05:12]

Acknowledged.

[aluebs-webrtc, 2016/02/19 03:56:31]

Done.

+  for (size_t i = 0; i < power_.size(); ++i) {

[turaj, 2016/02/13 00:09:43]

maybe a DCHECK that power_ and data are of the same size.

[hlundin-webrtc, 2016/02/15 13:05:12]

You don't know the size of |data|.

[aluebs-webrtc, 2016/02/19 03:56:31]

As Henrik points out, the size of data is unknown. If you think it is worth it I
can pass in the size as another parameter and DCHECK.

[turaj, 2016/02/19 16:48:47]

Sorry, my mistake, no I don't think it is necessary to pass the size.

+    power_[i] = decay_ * power_[i] + (1.f - decay_) * data[i] * data[i];
   }
 }
 
-const float* PowerEstimator::Power() {
-  for (size_t i = 0; i < num_freqs_; ++i) {
-    power_[i] = magnitude_[i] * magnitude_[i];
+void PowerEstimator::Step(const std::complex<float>* data) {
+  for (size_t i = 0; i < power_.size(); ++i) {

[turaj, 2016/02/13 00:09:43]

same comment as line 40.

+    power_[i] = decay_ * power_[i] +
+                (1.f - decay_) * std::abs(data[i]) * std::abs(data[i]);
   }
-  return &power_[0];
 }
 
 GainApplier::GainApplier(size_t freqs, float change_limit)
     : num_freqs_(freqs),
       change_limit_(change_limit),
       target_(new float[freqs]()),
       current_(new float[freqs]()) {
   for (size_t i = 0; i < freqs; ++i) {
     target_[i] = 1.0f;
     current_[i] = 1.0f;
   }
 }
 
 void GainApplier::Apply(const std::complex<float>* in_block,
                         std::complex<float>* out_block) {
   for (size_t i = 0; i < num_freqs_; ++i) {
     float factor = sqrtf(fabsf(current_[i]));
     if (!std::isnormal(factor)) {
       factor = 1.f;
     }
     out_block[i] = factor * in_block[i];
     current_[i] = UpdateFactor(target_[i], current_[i], change_limit_);
   }
 }
 
 }  // namespace webrtc