Update audio code to use size_t more correctly, webrtc/modules/audio_processing/

webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc

Index: webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
diff --git a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
index 145cc0872866db4effc4715000b979e54d5e723e..dedfb2bc4b80db9ff157db2583800580c2b2118c 100644
--- a/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
+++ b/webrtc/modules/audio_processing/intelligibility/intelligibility_utils.cc
@@ -63,11 +63,11 @@ inline complex<float> zerofudge(complex<float> c) {
 // mean |mean| with added |data|.
 inline complex<float> NewMean(complex<float> mean,
                               complex<float> data,
-                              int count) {
+                              size_t count) {
   return mean + (data - mean) / static_cast<float>(count);
 }
 
-inline void AddToMean(complex<float> data, int count, complex<float>* mean) {
+inline void AddToMean(complex<float> data, size_t count, complex<float>* mean) {
   (*mean) = NewMean(*mean, data, count);
 }
 
@@ -79,11 +79,11 @@ namespace webrtc {
 
 namespace intelligibility {
 
-static const int kWindowBlockSize = 10;
+static const size_t kWindowBlockSize = 10;
 
-VarianceArray::VarianceArray(int freqs,
+VarianceArray::VarianceArray(size_t freqs,
                              StepType type,
-                             int window_size,
+                             size_t window_size,
                              float decay)
     : running_mean_(new complex<float>[freqs]()),
       running_mean_sq_(new complex<float>[freqs]()),
@@ -98,15 +98,15 @@ VarianceArray::VarianceArray(int freqs,
       count_(0),
       array_mean_(0.0f) {
   history_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     history_[i].reset(new complex<float>[window_size_]());
   }
   subhistory_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     subhistory_[i].reset(new complex<float>[window_size_]());
   }
   subhistory_sq_.reset(new rtc::scoped_ptr<complex<float>[]>[freqs_]());
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     subhistory_sq_[i].reset(new complex<float>[window_size_]());
   }
   switch (type) {
@@ -130,7 +130,7 @@ VarianceArray::VarianceArray(int freqs,
 void VarianceArray::InfiniteStep(const complex<float>* data, bool skip_fudge) {
   array_mean_ = 0.0f;
   ++count_;
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     complex<float> sample = data[i];
     if (!skip_fudge) {
       sample = zerofudge(sample);
@@ -148,9 +148,9 @@ void VarianceArray::InfiniteStep(const complex<float>* data, bool skip_fudge) {
               .real();
       variance_[i] =
           conj_sum_[i] / (count_ - 1);  // + fudge[fudge_index].real();
-      if (skip_fudge && false) {
-        // variance_[i] -= fudge[fudge_index].real();
-      }
+      // if (skip_fudge) {
+      //   variance_[i] -= fudge[fudge_index].real();
+      // }
     }
     array_mean_ += (variance_[i] - array_mean_) / (i + 1);
   }
@@ -161,7 +161,7 @@ void VarianceArray::InfiniteStep(const complex<float>* data, bool skip_fudge) {
 void VarianceArray::DecayStep(const complex<float>* data, bool /*dummy*/) {
   array_mean_ = 0.0f;
   ++count_;
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     complex<float> sample = data[i];
     sample = zerofudge(sample);
 
@@ -189,9 +189,9 @@ void VarianceArray::DecayStep(const complex<float>* data, bool /*dummy*/) {
 // Windowed variance computation. On each step, the variances for the
 // window are recomputed from scratch, using Welford's algorithm.
 void VarianceArray::WindowedStep(const complex<float>* data, bool /*dummy*/) {
-  int num = min(count_ + 1, window_size_);
+  size_t num = min(count_ + 1, window_size_);
   array_mean_ = 0.0f;
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     complex<float> mean;
     float conj_sum = 0.0f;
 
@@ -199,7 +199,7 @@ void VarianceArray::WindowedStep(const complex<float>* data, bool /*dummy*/) {
 
     mean = history_[i][history_cursor_];
     variance_[i] = 0.0f;
-    for (int j = 1; j < num; ++j) {
+    for (size_t j = 1; j < num; ++j) {
       complex<float> sample =
           zerofudge(history_[i][(history_cursor_ + j) % window_size_]);
       sample = history_[i][(history_cursor_ + j) % window_size_];
@@ -223,8 +223,8 @@ void VarianceArray::WindowedStep(const complex<float>* data, bool /*dummy*/) {
 // history window and a new block is started. The variances for the window
 // are recomputed from scratch at each of these transitions.
 void VarianceArray::BlockedStep(const complex<float>* data, bool /*dummy*/) {
-  int blocks = min(window_size_, history_cursor_);
-  for (int i = 0; i < freqs_; ++i) {
+  size_t blocks = min(window_size_, history_cursor_);
+  for (size_t i = 0; i < freqs_; ++i) {
     AddToMean(data[i], count_ + 1, &sub_running_mean_[i]);
     AddToMean(data[i] * std::conj(data[i]), count_ + 1,
               &sub_running_mean_sq_[i]);
@@ -241,7 +241,7 @@ void VarianceArray::BlockedStep(const complex<float>* data, bool /*dummy*/) {
       sub_running_mean_sq_[i] = complex<float>(0.0f, 0.0f);
       running_mean_[i] = complex<float>(0.0f, 0.0f);
       running_mean_sq_[i] = complex<float>(0.0f, 0.0f);
-      for (int j = 0; j < min(window_size_, history_cursor_); ++j) {
+      for (size_t j = 0; j < min(window_size_, history_cursor_); ++j) {
         AddToMean(subhistory_[i][j], j, &running_mean_[i]);
         AddToMean(subhistory_sq_[i][j], j, &running_mean_sq_[i]);
       }
@@ -266,18 +266,18 @@ void VarianceArray::Clear() {
 
 void VarianceArray::ApplyScale(float scale) {
   array_mean_ = 0.0f;
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     variance_[i] *= scale * scale;
     array_mean_ += (variance_[i] - array_mean_) / (i + 1);
   }
 }
 
-GainApplier::GainApplier(int freqs, float change_limit)
+GainApplier::GainApplier(size_t freqs, float change_limit)
     : freqs_(freqs),
       change_limit_(change_limit),
       target_(new float[freqs]()),
       current_(new float[freqs]()) {
-  for (int i = 0; i < freqs; ++i) {
+  for (size_t i = 0; i < freqs; ++i) {
     target_[i] = 1.0f;
     current_[i] = 1.0f;
   }
@@ -285,7 +285,7 @@ GainApplier::GainApplier(int freqs, float change_limit)
 
 void GainApplier::Apply(const complex<float>* in_block,
                         complex<float>* out_block) {
-  for (int i = 0; i < freqs_; ++i) {
+  for (size_t i = 0; i < freqs_; ++i) {
     float factor = sqrtf(fabsf(current_[i]));
     if (!std::isnormal(factor)) {
       factor = 1.0f;