Remove C++11 calls from intelligibility_utils

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.
  */
 
 //
 //  Implements helper functions and classes for intelligibility enhancement.
 //
 
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_utils.h"
 
 #include <math.h>
+#include <stdlib.h>
 #include <string.h>
 #include <algorithm>
 
 using std::complex;
 using std::min;
 
 namespace webrtc {
 
 namespace intelligibility {
 
 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);
 }
 
-bool cplxfinite(complex<float> c) {
-  return std::isfinite(c.real()) && std::isfinite(c.imag());
-}
-
-bool cplxnormal(complex<float> c) {
-  return std::isnormal(c.real()) && std::isnormal(c.imag());
+float AddDitherIfZero(float value) {
+  return value == 0.f ? std::rand() * 0.01f / RAND_MAX : value;
 }
 
 complex<float> zerofudge(complex<float> c) {
-  const static complex<float> fudge[7] = {{0.001f, 0.002f},
-                                          {0.008f, 0.001f},
-                                          {0.003f, 0.008f},
-                                          {0.0006f, 0.0009f},
-                                          {0.001f, 0.004f},
-                                          {0.003f, 0.004f},
-                                          {0.002f, 0.009f}};
-  static int fudge_index = 0;
-  if (cplxfinite(c) && !cplxnormal(c)) {
-    fudge_index = (fudge_index + 1) % 7;
-    return c + fudge[fudge_index];
-  }
-  return c;
+  return complex<float>(AddDitherIfZero(c.real()), AddDitherIfZero(c.imag()));
 }
 
 complex<float> NewMean(complex<float> mean, complex<float> data, int count) {
   return mean + (data - mean) / static_cast<float>(count);
 }
 
 void AddToMean(complex<float> data, int count, complex<float>* mean) {
   (*mean) = NewMean(*mean, data, count);
 }
 
@@ skipping 63 matching lines @@
       variance_[i] = 0.0f;
     } else {
       float old_sum = conj_sum_[i];
       complex<float> old_mean = running_mean_[i];
       running_mean_[i] =
           old_mean + (sample - old_mean) / static_cast<float>(count_);
       conj_sum_[i] =
           (old_sum + std::conj(sample - old_mean) * (sample - running_mean_[i]))
               .real();
       variance_[i] =
-          conj_sum_[i] / (count_ - 1);  // + fudge[fudge_index].real();
-      // if (skip_fudge) {
-      //   variance_[i] -= fudge[fudge_index].real();
-      // }
+          conj_sum_[i] / (count_ - 1);
     }
     array_mean_ += (variance_[i] - array_mean_) / (i + 1);
   }
 }
 
 // Compute the variance from the beginning, with exponential decaying of the
 // series data.
 void VarianceArray::DecayStep(const complex<float>* data, bool /*dummy*/) {
   array_mean_ = 0.0f;
   ++count_;
   for (int i = 0; i < freqs_; ++i) {
     complex<float> sample = data[i];
     sample = zerofudge(sample);
 
     if (count_ == 1) {
       running_mean_[i] = sample;
       running_mean_sq_[i] = sample * std::conj(sample);
       variance_[i] = 0.0f;
     } else {
       complex<float> prev = running_mean_[i];
       complex<float> prev2 = running_mean_sq_[i];
       running_mean_[i] = decay_ * prev + (1.0f - decay_) * sample;
       running_mean_sq_[i] =
           decay_ * prev2 + (1.0f - decay_) * sample * std::conj(sample);
-      // variance_[i] = decay_ * variance_[i] + (1.0f - decay_) * (
-      //  (sample - running_mean_[i]) * std::conj(sample -
-      //  running_mean_[i])).real();
       variance_[i] = (running_mean_sq_[i] -
                       running_mean_[i] * std::conj(running_mean_[i])).real();
     }
 
     array_mean_ += (variance_[i] - array_mean_) / (i + 1);
   }
 }
 
 // Windowed variance computation. On each step, the variances for the
 // window are recomputed from scratch, using Welford's algorithm.
@@ skipping 145 matching lines @@
       factor = 1.0f;
     }
     out_block[i] = factor * in_block[i];
     current_[i] = UpdateFactor(target_[i], current_[i], change_limit_);
   }
 }
 
 }  // namespace intelligibility
 
 }  // namespace webrtc