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.
  */
 
@@ skipping 13 matching lines @@
 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());
-}
-
 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;

[Andrew MacDonald, 2015/07/22 22:17:07]

Ahh, non-const static!

Do we really need this zerofudge thing at all? There's a comment here:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

that says "Can probably be removed."

[ekm, 2015/07/22 22:45:25]

I think that's saying the |skip_fudge| flag can be removed. zerofudge does catch
some div by 0 errors in other places (e.g.,
IntelligibilityEnhancer::SolverForGainsGivenLambda). There's surely a better way
to deal with this, but we need to do something. I've changed it to use rand().

[Andrew MacDonald, 2015/07/22 23:34:59]

Got it. Is there any benefit to adding this dither, or can we just ensure the
components never fall below some small value? Something like this:

float ClampToMinAbs(float value, float min_abs_value) {
  return std::abs(value) < min_abs_value ? min_abs_value : value;
}

complex<float> ZeroFudge(complex<float> c) {
  const float kMinValue = 0.001f;
  return complex<float>(ClampToMinAbs(c.real(), kMinValue),
ClampToMinAbs(c.imag(), kMinValue));
}

[ekm, 2015/07/23 00:06:26]

That's a good question. I think we want the dither, otherwise we could still end
up with 0 variance if all samples are equal.

-  if (cplxfinite(c) && !cplxnormal(c)) {
+  if (c.real() == 0.f || c.imag() == 0.f) {
     fudge_index = (fudge_index + 1) % 7;
     return c + fudge[fudge_index];
   }
   return c;
 }
 
 complex<float> NewMean(complex<float> mean, complex<float> data, int count) {
   return mean + (data - mean) / static_cast<float>(count);
 }
 
@@ skipping 68 matching lines @@
     } 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 && false) {

[Andrew MacDonald, 2015/07/22 22:17:07]

Can you remove these three lines?

[ekm, 2015/07/22 22:45:25]

Done.

         // variance_[i] -= fudge[fudge_index].real();
       }
     }
     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*/) {
@@ skipping 174 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