Convert channel counts to size_t.

webrtc/modules/audio_processing/audio_buffer.cc

 /*
  *  Copyright (c) 2012 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 26 matching lines @@
   if (num_frames == kSamplesPer32kHzChannel ||
       num_frames == kSamplesPer48kHzChannel) {
     num_bands = rtc::CheckedDivExact(num_frames, kSamplesPer16kHzChannel);
   }
   return num_bands;
 }
 
 }  // namespace
 
 AudioBuffer::AudioBuffer(size_t input_num_frames,
-                         int num_input_channels,
+                         size_t num_input_channels,
                          size_t process_num_frames,
-                         int num_process_channels,
+                         size_t num_process_channels,
                          size_t output_num_frames)
   : input_num_frames_(input_num_frames),
     num_input_channels_(num_input_channels),
     proc_num_frames_(process_num_frames),
     num_proc_channels_(num_process_channels),
     output_num_frames_(output_num_frames),
     num_channels_(num_process_channels),
     num_bands_(NumBandsFromSamplesPerChannel(proc_num_frames_)),
     num_split_frames_(rtc::CheckedDivExact(proc_num_frames_, num_bands_)),
     mixed_low_pass_valid_(false),
     reference_copied_(false),
     activity_(AudioFrame::kVadUnknown),
     keyboard_data_(NULL),
     data_(new IFChannelBuffer(proc_num_frames_, num_proc_channels_)) {
   assert(input_num_frames_ > 0);
   assert(proc_num_frames_ > 0);
   assert(output_num_frames_ > 0);
   assert(num_input_channels_ > 0);
   assert(num_proc_channels_ > 0 && num_proc_channels_ <= num_input_channels_);
 
   if (input_num_frames_ != proc_num_frames_ ||
       output_num_frames_ != proc_num_frames_) {
     // Create an intermediate buffer for resampling.
     process_buffer_.reset(new ChannelBuffer<float>(proc_num_frames_,
                                                    num_proc_channels_));
 
     if (input_num_frames_ != proc_num_frames_) {
-      for (int i = 0; i < num_proc_channels_; ++i) {
+      for (size_t i = 0; i < num_proc_channels_; ++i) {
         input_resamplers_.push_back(
             new PushSincResampler(input_num_frames_,
                                   proc_num_frames_));
       }
     }
 
     if (output_num_frames_ != proc_num_frames_) {
-      for (int i = 0; i < num_proc_channels_; ++i) {
+      for (size_t i = 0; i < num_proc_channels_; ++i) {
         output_resamplers_.push_back(
             new PushSincResampler(proc_num_frames_,
                                   output_num_frames_));
       }
     }
   }
 
   if (num_bands_ > 1) {
     split_data_.reset(new IFChannelBuffer(proc_num_frames_,
                                           num_proc_channels_,
@@ skipping 27 matching lines @@
   // Downmix.
   const float* const* data_ptr = data;
   if (need_to_downmix) {
     DownmixToMono<float, float>(data, input_num_frames_, num_input_channels_,
                                 input_buffer_->fbuf()->channels()[0]);
     data_ptr = input_buffer_->fbuf_const()->channels();
   }
 
   // Resample.
   if (input_num_frames_ != proc_num_frames_) {
-    for (int i = 0; i < num_proc_channels_; ++i) {
+    for (size_t i = 0; i < num_proc_channels_; ++i) {
       input_resamplers_[i]->Resample(data_ptr[i],
                                      input_num_frames_,
                                      process_buffer_->channels()[i],
                                      proc_num_frames_);
     }
     data_ptr = process_buffer_->channels();
   }
 
   // Convert to the S16 range.
-  for (int i = 0; i < num_proc_channels_; ++i) {
+  for (size_t i = 0; i < num_proc_channels_; ++i) {
     FloatToFloatS16(data_ptr[i],
                     proc_num_frames_,
                     data_->fbuf()->channels()[i]);
   }
 }
 
 void AudioBuffer::CopyTo(const StreamConfig& stream_config,
                          float* const* data) {
   assert(stream_config.num_frames() == output_num_frames_);
   assert(stream_config.num_channels() == num_channels_ || num_channels_ == 1);
 
   // Convert to the float range.
   float* const* data_ptr = data;
   if (output_num_frames_ != proc_num_frames_) {
     // Convert to an intermediate buffer for subsequent resampling.
     data_ptr = process_buffer_->channels();
   }
-  for (int i = 0; i < num_channels_; ++i) {
+  for (size_t i = 0; i < num_channels_; ++i) {
     FloatS16ToFloat(data_->fbuf()->channels()[i],
                     proc_num_frames_,
                     data_ptr[i]);
   }
 
   // Resample.
   if (output_num_frames_ != proc_num_frames_) {
-    for (int i = 0; i < num_channels_; ++i) {
+    for (size_t i = 0; i < num_channels_; ++i) {
       output_resamplers_[i]->Resample(data_ptr[i],
                                       proc_num_frames_,
                                       data[i],
                                       output_num_frames_);
     }
   }
 
   // Upmix.
-  for (int i = num_channels_; i < stream_config.num_channels(); ++i) {
+  for (size_t i = num_channels_; i < stream_config.num_channels(); ++i) {
     memcpy(data[i], data[0], output_num_frames_ * sizeof(**data));
   }
 }
 
 void AudioBuffer::InitForNewData() {
   keyboard_data_ = NULL;
   mixed_low_pass_valid_ = false;
   reference_copied_ = false;
   activity_ = AudioFrame::kVadUnknown;
   num_channels_ = num_proc_channels_;
 }
 
 const int16_t* const* AudioBuffer::channels_const() const {
   return data_->ibuf_const()->channels();
 }
 
 int16_t* const* AudioBuffer::channels() {
   mixed_low_pass_valid_ = false;
   return data_->ibuf()->channels();
 }
 
-const int16_t* const* AudioBuffer::split_bands_const(int channel) const {
+const int16_t* const* AudioBuffer::split_bands_const(size_t channel) const {
   return split_data_.get() ?
          split_data_->ibuf_const()->bands(channel) :
          data_->ibuf_const()->bands(channel);
 }
 
-int16_t* const* AudioBuffer::split_bands(int channel) {
+int16_t* const* AudioBuffer::split_bands(size_t channel) {
   mixed_low_pass_valid_ = false;
   return split_data_.get() ?
          split_data_->ibuf()->bands(channel) :
          data_->ibuf()->bands(channel);
 }
 
 const int16_t* const* AudioBuffer::split_channels_const(Band band) const {
   if (split_data_.get()) {
     return split_data_->ibuf_const()->channels(band);
   } else {
@@ skipping 30 matching lines @@
 
 const float* const* AudioBuffer::channels_const_f() const {
   return data_->fbuf_const()->channels();
 }
 
 float* const* AudioBuffer::channels_f() {
   mixed_low_pass_valid_ = false;
   return data_->fbuf()->channels();
 }
 
-const float* const* AudioBuffer::split_bands_const_f(int channel) const {
+const float* const* AudioBuffer::split_bands_const_f(size_t channel) const {
   return split_data_.get() ?
          split_data_->fbuf_const()->bands(channel) :
          data_->fbuf_const()->bands(channel);
 }
 
-float* const* AudioBuffer::split_bands_f(int channel) {
+float* const* AudioBuffer::split_bands_f(size_t channel) {
   mixed_low_pass_valid_ = false;
   return split_data_.get() ?
          split_data_->fbuf()->bands(channel) :
          data_->fbuf()->bands(channel);
 }
 
 const float* const* AudioBuffer::split_channels_const_f(Band band) const {
   if (split_data_.get()) {
     return split_data_->fbuf_const()->channels(band);
   } else {
@@ skipping 60 matching lines @@
 }
 
 void AudioBuffer::set_activity(AudioFrame::VADActivity activity) {
   activity_ = activity;
 }
 
 AudioFrame::VADActivity AudioBuffer::activity() const {
   return activity_;
 }
 
-int AudioBuffer::num_channels() const {
+size_t AudioBuffer::num_channels() const {
   return num_channels_;
 }
 
-void AudioBuffer::set_num_channels(int num_channels) {
+void AudioBuffer::set_num_channels(size_t num_channels) {
   num_channels_ = num_channels;
 }
 
 size_t AudioBuffer::num_frames() const {
   return proc_num_frames_;
 }
 
 size_t AudioBuffer::num_frames_per_band() const {
   return num_split_frames_;
 }
@@ skipping 32 matching lines @@
   } else {
     assert(num_proc_channels_ == num_input_channels_);
     Deinterleave(frame->data_,
                  input_num_frames_,
                  num_proc_channels_,
                  deinterleaved);
   }
 
   // Resample.
   if (input_num_frames_ != proc_num_frames_) {
-    for (int i = 0; i < num_proc_channels_; ++i) {
+    for (size_t i = 0; i < num_proc_channels_; ++i) {
       input_resamplers_[i]->Resample(input_buffer_->fbuf_const()->channels()[i],
                                      input_num_frames_,
                                      data_->fbuf()->channels()[i],
                                      proc_num_frames_);
     }
   }
 }
 
 void AudioBuffer::InterleaveTo(AudioFrame* frame, bool data_changed) {
   frame->vad_activity_ = activity_;
   if (!data_changed) {
     return;
   }
 
   assert(frame->num_channels_ == num_channels_ || num_channels_ == 1);
   assert(frame->samples_per_channel_ == output_num_frames_);
 
   // Resample if necessary.
   IFChannelBuffer* data_ptr = data_.get();
   if (proc_num_frames_ != output_num_frames_) {
     if (!output_buffer_) {
       output_buffer_.reset(
           new IFChannelBuffer(output_num_frames_, num_channels_));
     }
-    for (int i = 0; i < num_channels_; ++i) {
+    for (size_t i = 0; i < num_channels_; ++i) {
       output_resamplers_[i]->Resample(
           data_->fbuf()->channels()[i], proc_num_frames_,
           output_buffer_->fbuf()->channels()[i], output_num_frames_);
     }
     data_ptr = output_buffer_.get();
   }
 
   if (frame->num_channels_ == num_channels_) {
     Interleave(data_ptr->ibuf()->channels(), proc_num_frames_, num_channels_,
                frame->data_);
   } else {
     UpmixMonoToInterleaved(data_ptr->ibuf()->channels()[0], proc_num_frames_,
                            frame->num_channels_, frame->data_);
   }
 }
 
 void AudioBuffer::CopyLowPassToReference() {
   reference_copied_ = true;
   if (!low_pass_reference_channels_.get() ||
       low_pass_reference_channels_->num_channels() != num_channels_) {
     low_pass_reference_channels_.reset(
         new ChannelBuffer<int16_t>(num_split_frames_,
                                    num_proc_channels_));
   }
-  for (int i = 0; i < num_proc_channels_; i++) {
+  for (size_t i = 0; i < num_proc_channels_; i++) {
     memcpy(low_pass_reference_channels_->channels()[i],
            split_bands_const(i)[kBand0To8kHz],
            low_pass_reference_channels_->num_frames_per_band() *
                sizeof(split_bands_const(i)[kBand0To8kHz][0]));
   }
 }
 
 void AudioBuffer::SplitIntoFrequencyBands() {
   splitting_filter_->Analysis(data_.get(), split_data_.get());
 }
 
 void AudioBuffer::MergeFrequencyBands() {
   splitting_filter_->Synthesis(split_data_.get(), data_.get());
 }
 
 }  // namespace webrtc