Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_processing/include/audio_processing.h

 /*
  *  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 293 matching lines @@
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element
   // of |src| points to a channel buffer, arranged according to
   // |input_layout|. At output, the channels will be arranged according to
   // |output_layout| at |output_sample_rate_hz| in |dest|.
   //
   // The output layout must have one channel or as many channels as the input.
   // |src| and |dest| may use the same memory, if desired.
   //
   // TODO(mgraczyk): Remove once clients are updated to use the new interface.
   virtual int ProcessStream(const float* const* src,
-                            int samples_per_channel,
+                            size_t samples_per_channel,
                             int input_sample_rate_hz,
                             ChannelLayout input_layout,
                             int output_sample_rate_hz,
                             ChannelLayout output_layout,
                             float* const* dest) = 0;
 
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element of
   // |src| points to a channel buffer, arranged according to |input_stream|. At
   // output, the channels will be arranged according to |output_stream| in
   // |dest|.
@@ skipping 25 matching lines @@
   virtual int AnalyzeReverseStream(AudioFrame* frame) = 0;
 
   // Same as |AnalyzeReverseStream|, but may modify |frame| if intelligibility
   // is enabled.
   virtual int ProcessReverseStream(AudioFrame* frame) = 0;
 
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element
   // of |data| points to a channel buffer, arranged according to |layout|.
   // TODO(mgraczyk): Remove once clients are updated to use the new interface.
   virtual int AnalyzeReverseStream(const float* const* data,
-                                   int samples_per_channel,
+                                   size_t samples_per_channel,
                                    int rev_sample_rate_hz,
                                    ChannelLayout layout) = 0;
 
   // Accepts deinterleaved float audio with the range [-1, 1]. Each element of
   // |data| points to a channel buffer, arranged according to |reverse_config|.
   virtual int ProcessReverseStream(const float* const* src,
                                    const StreamConfig& reverse_input_config,
                                    const StreamConfig& reverse_output_config,
                                    float* const* dest) = 0;
 
@@ skipping 132 matching lines @@
   void set_num_channels(int value) { num_channels_ = value; }
   void set_has_keyboard(bool value) { has_keyboard_ = value; }
 
   int sample_rate_hz() const { return sample_rate_hz_; }
 
   // The number of channels in the stream, not including the keyboard channel if
   // present.
   int num_channels() const { return num_channels_; }
 
   bool has_keyboard() const { return has_keyboard_; }
-  int num_frames() const { return num_frames_; }
-  int num_samples() const { return num_channels_ * num_frames_; }
+  size_t num_frames() const { return num_frames_; }
+  size_t num_samples() const { return num_channels_ * num_frames_; }
 
   bool operator==(const StreamConfig& other) const {
     return sample_rate_hz_ == other.sample_rate_hz_ &&
            num_channels_ == other.num_channels_ &&
            has_keyboard_ == other.has_keyboard_;
   }
 
   bool operator!=(const StreamConfig& other) const { return !(*this == other); }
 
  private:
-  static int calculate_frames(int sample_rate_hz) {
-    return AudioProcessing::kChunkSizeMs * sample_rate_hz / 1000;
+  static size_t calculate_frames(int sample_rate_hz) {
+    return static_cast<size_t>(
+        AudioProcessing::kChunkSizeMs * sample_rate_hz / 1000);
   }
 
   int sample_rate_hz_;
   int num_channels_;
   bool has_keyboard_;
-  int num_frames_;
+  size_t num_frames_;
 };
 
 class ProcessingConfig {
  public:
   enum StreamName {
     kInputStream,
     kOutputStream,
     kReverseInputStream,
     kReverseOutputStream,
     kNumStreamNames,
@@ skipping 392 matching lines @@
   // This does not impact the size of frames passed to |ProcessStream()|.
   virtual int set_frame_size_ms(int size) = 0;
   virtual int frame_size_ms() const = 0;
 
  protected:
   virtual ~VoiceDetection() {}
 };
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_INCLUDE_AUDIO_PROCESSING_H_