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

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.
  */
 
 #include "webrtc/modules/audio_processing/audio_buffer.h"
 
 #include "webrtc/common_audio/include/audio_util.h"
 #include "webrtc/common_audio/resampler/push_sinc_resampler.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/common_audio/channel_buffer.h"
 #include "webrtc/modules/audio_processing/common.h"
 
 namespace webrtc {
 namespace {
 
-const int kSamplesPer16kHzChannel = 160;
-const int kSamplesPer32kHzChannel = 320;
-const int kSamplesPer48kHzChannel = 480;
+const size_t kSamplesPer16kHzChannel = 160;
+const size_t kSamplesPer32kHzChannel = 320;
+const size_t kSamplesPer48kHzChannel = 480;
 
 bool HasKeyboardChannel(AudioProcessing::ChannelLayout layout) {
   switch (layout) {
     case AudioProcessing::kMono:
     case AudioProcessing::kStereo:
       return false;
     case AudioProcessing::kMonoAndKeyboard:
     case AudioProcessing::kStereoAndKeyboard:
       return true;
   }
@@ skipping 11 matching lines @@
       return 1;
     case AudioProcessing::kStereoAndKeyboard:
       return 2;
   }
   assert(false);
   return -1;
 }
 
 template <typename T>
 void StereoToMono(const T* left, const T* right, T* out,
-                  int num_frames) {
-  for (int i = 0; i < num_frames; ++i)
+                  size_t num_frames) {
+  for (size_t i = 0; i < num_frames; ++i)
     out[i] = (left[i] + right[i]) / 2;
 }
 
-int NumBandsFromSamplesPerChannel(int num_frames) {
-  int num_bands = 1;
+size_t NumBandsFromSamplesPerChannel(size_t num_frames) {
+  size_t num_bands = 1;
   if (num_frames == kSamplesPer32kHzChannel ||
       num_frames == kSamplesPer48kHzChannel) {
-    num_bands = rtc::CheckedDivExact(num_frames,
-                                     static_cast<int>(kSamplesPer16kHzChannel));
+    num_bands = rtc::CheckedDivExact(num_frames, kSamplesPer16kHzChannel);
   }
   return num_bands;
 }
 
 }  // namespace
 
-AudioBuffer::AudioBuffer(int input_num_frames,
+AudioBuffer::AudioBuffer(size_t input_num_frames,
                          int num_input_channels,
-                         int process_num_frames,
+                         size_t process_num_frames,
                          int num_process_channels,
-                         int output_num_frames)
+                         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),
@@ skipping 35 matching lines @@
                                           num_bands_));
     splitting_filter_.reset(new SplittingFilter(num_proc_channels_,
                                                 num_bands_,
                                                 proc_num_frames_));
   }
 }
 
 AudioBuffer::~AudioBuffer() {}
 
 void AudioBuffer::CopyFrom(const float* const* data,
-                           int num_frames,
+                           size_t num_frames,
                            AudioProcessing::ChannelLayout layout) {
   assert(num_frames == input_num_frames_);
   assert(ChannelsFromLayout(layout) == num_input_channels_);
   InitForNewData();
   // Initialized lazily because there's a different condition in
   // DeinterleaveFrom.
   if ((num_input_channels_ == 2 && num_proc_channels_ == 1) && !input_buffer_) {
     input_buffer_.reset(
         new IFChannelBuffer(input_num_frames_, num_proc_channels_));
   }
@@ skipping 24 matching lines @@
   }
 
   // Convert to the S16 range.
   for (int i = 0; i < num_proc_channels_; ++i) {
     FloatToFloatS16(data_ptr[i],
                     proc_num_frames_,
                     data_->fbuf()->channels()[i]);
   }
 }
 
-void AudioBuffer::CopyTo(int num_frames,
+void AudioBuffer::CopyTo(size_t num_frames,
                          AudioProcessing::ChannelLayout layout,
                          float* const* data) {
   assert(num_frames == output_num_frames_);
   assert(ChannelsFromLayout(layout) == num_channels_);
 
   // 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();
@@ skipping 180 matching lines @@
 }
 
 int AudioBuffer::num_channels() const {
   return num_channels_;
 }
 
 void AudioBuffer::set_num_channels(int num_channels) {
   num_channels_ = num_channels;
 }
 
-int AudioBuffer::num_frames() const {
+size_t AudioBuffer::num_frames() const {
   return proc_num_frames_;
 }
 
-int AudioBuffer::num_frames_per_band() const {
+size_t AudioBuffer::num_frames_per_band() const {
   return num_split_frames_;
 }
 
-int AudioBuffer::num_keyboard_frames() const {
+size_t AudioBuffer::num_keyboard_frames() const {
   // We don't resample the keyboard channel.
   return input_num_frames_;
 }
 
-int AudioBuffer::num_bands() const {
+size_t AudioBuffer::num_bands() const {
   return num_bands_;
 }
 
 // The resampler is only for supporting 48kHz to 16kHz in the reverse stream.
 void AudioBuffer::DeinterleaveFrom(AudioFrame* frame) {
   assert(frame->num_channels_ == num_input_channels_);
   assert(frame->samples_per_channel_ == input_num_frames_);
   InitForNewData();
   // Initialized lazily because there's a different condition in CopyFrom.
   if ((input_num_frames_ != proc_num_frames_) && !input_buffer_) {
     input_buffer_.reset(
         new IFChannelBuffer(input_num_frames_, num_proc_channels_));
   }
   activity_ = frame->vad_activity_;
 
   int16_t* const* deinterleaved;
   if (input_num_frames_ == proc_num_frames_) {
     deinterleaved = data_->ibuf()->channels();
   } else {
     deinterleaved = input_buffer_->ibuf()->channels();
   }
   if (num_input_channels_ == 2 && num_proc_channels_ == 1) {
     // Downmix directly; no explicit deinterleaving needed.
-    for (int i = 0; i < input_num_frames_; ++i) {
+    for (size_t i = 0; i < input_num_frames_; ++i) {
       deinterleaved[0][i] = (frame->data_[i * 2] + frame->data_[i * 2 + 1]) / 2;
     }
   } else {
     assert(num_proc_channels_ == num_input_channels_);
     Deinterleave(frame->data_,
                  input_num_frames_,
                  num_proc_channels_,
                  deinterleaved);
   }
 
@@ skipping 43 matching lines @@
 
 void AudioBuffer::SplitIntoFrequencyBands() {
   splitting_filter_->Analysis(data_.get(), split_data_.get());
 }
 
 void AudioBuffer::MergeFrequencyBands() {
   splitting_filter_->Synthesis(split_data_.get(), data_.get());
 }
 
 }  // namespace webrtc