[NOT FOR REVIEW] Convert channel counts to size_t.

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.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 36 matching lines @@
 using VarianceType = intelligibility::VarianceArray::StepType;
 
 IntelligibilityEnhancer::TransformCallback::TransformCallback(
     IntelligibilityEnhancer* parent,
     IntelligibilityEnhancer::AudioSource source)
     : parent_(parent), source_(source) {
 }
 
 void IntelligibilityEnhancer::TransformCallback::ProcessAudioBlock(
     const complex<float>* const* in_block,
-    int in_channels,
+    size_t in_channels,
     size_t frames,
-    int /* out_channels */,
+    size_t /* out_channels */,
     complex<float>* const* out_block) {
   DCHECK_EQ(parent_->freqs_, frames);
-  for (int i = 0; i < in_channels; ++i) {
+  for (size_t i = 0; i < in_channels; ++i) {
     parent_->DispatchAudio(source_, in_block[i], out_block[i]);
   }
 }
 
 IntelligibilityEnhancer::IntelligibilityEnhancer(size_t erb_resolution,
                                                  int sample_rate_hz,
-                                                 int channels,
+                                                 size_t channels,
                                                  int cv_type,
                                                  float cv_alpha,
                                                  size_t cv_win,
                                                  int analysis_rate,
                                                  int variance_rate,
                                                  float gain_limit)
     : freqs_(RealFourier::ComplexLength(
           RealFourier::FftOrder(sample_rate_hz * kWindowSizeMs / 1000))),
       window_size_(static_cast<size_t>(1 << RealFourier::FftOrder(freqs_))),
       chunk_length_(static_cast<size_t>(sample_rate_hz * kChunkSizeMs / 1000)),
@@ skipping 30 matching lines @@
   CreateErbBank();
 
   WebRtcVad_Init(vad_high_);
   WebRtcVad_set_mode(vad_high_, 0);  // High likelihood of speech.
   WebRtcVad_Init(vad_low_);
   WebRtcVad_set_mode(vad_low_, 3);  // Low likelihood of speech.
 
   temp_out_buffer_ = static_cast<float**>(
       malloc(sizeof(*temp_out_buffer_) * channels_ +
              sizeof(**temp_out_buffer_) * chunk_length_ * channels_));
-  for (int i = 0; i < channels_; ++i) {
+  for (size_t i = 0; i < channels_; ++i) {
     temp_out_buffer_[i] =
         reinterpret_cast<float*>(temp_out_buffer_ + channels_) +
         chunk_length_ * i;
   }
 
   // Assumes all rho equal.
   for (size_t i = 0; i < bank_size_; ++i) {
     rho_[i] = kConfigRho * kConfigRho;
   }
 
@@ skipping 21 matching lines @@
 void IntelligibilityEnhancer::ProcessRenderAudio(float* const* audio) {
   for (size_t i = 0; i < chunk_length_; ++i) {
     vad_tmp_buffer_[i] = (int16_t)audio[0][i];
   }
   has_voice_low_ = WebRtcVad_Process(vad_low_, sample_rate_hz_,
                                      vad_tmp_buffer_.get(), chunk_length_) == 1;
 
   // Process and enhance chunk of |audio|
   render_mangler_->ProcessChunk(audio, temp_out_buffer_);
 
-  for (int i = 0; i < channels_; ++i) {
+  for (size_t i = 0; i < channels_; ++i) {
     memcpy(audio[i], temp_out_buffer_[i],
            chunk_length_ * sizeof(**temp_out_buffer_));
   }
 }
 
 void IntelligibilityEnhancer::ProcessCaptureAudio(float* const* audio) {
   for (size_t i = 0; i < chunk_length_; ++i) {
     vad_tmp_buffer_[i] = (int16_t)audio[0][i];
   }
   // TODO(bercic): The VAD was always detecting voice in the noise stream,
@@ skipping 232 matching lines @@
                                           size_t length) {
   float ret = 0.0f;
 
   for (size_t i = 0; i < length; ++i) {
     ret = fmaf(a[i], b[i], ret);
   }
   return ret;
 }
 
 }  // namespace webrtc