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

webrtc/common_audio/vad/vad_core.c

 /*
  *  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 104 matching lines @@
 // type of signal is most probable.
 //
 // - self           [i/o] : Pointer to VAD instance
 // - features       [i]   : Feature vector of length |kNumChannels|
 //                          = log10(energy in frequency band)
 // - total_power    [i]   : Total power in audio frame.
 // - frame_length   [i]   : Number of input samples
 //
 // - returns              : the VAD decision (0 - noise, 1 - speech).
 static int16_t GmmProbability(VadInstT* self, int16_t* features,
-                              int16_t total_power, int frame_length) {
+                              int16_t total_power, size_t frame_length) {
   int channel, k;
   int16_t feature_minimum;
   int16_t h0, h1;
   int16_t log_likelihood_ratio;
   int16_t vadflag = 0;
   int16_t shifts_h0, shifts_h1;
   int16_t tmp_s16, tmp1_s16, tmp2_s16;
   int16_t diff;
   int gaussian;
   int16_t nmk, nmk2, nmk3, smk, smk2, nsk, ssk;
@@ skipping 453 matching lines @@
       break;
   }
 
   return return_value;
 }
 
 // Calculate VAD decision by first extracting feature values and then calculate
 // probability for both speech and background noise.
 
 int WebRtcVad_CalcVad48khz(VadInstT* inst, const int16_t* speech_frame,
-                           int frame_length) {
+                           size_t frame_length) {
   int vad;
-  int i;
+  size_t i;
   int16_t speech_nb[240];  // 30 ms in 8 kHz.
   // |tmp_mem| is a temporary memory used by resample function, length is
   // frame length in 10 ms (480 samples) + 256 extra.
   int32_t tmp_mem[480 + 256] = { 0 };
-  const int kFrameLen10ms48khz = 480;
-  const int kFrameLen10ms8khz = 80;
-  int num_10ms_frames = frame_length / kFrameLen10ms48khz;
+  const size_t kFrameLen10ms48khz = 480;
+  const size_t kFrameLen10ms8khz = 80;
+  size_t num_10ms_frames = frame_length / kFrameLen10ms48khz;
 
   for (i = 0; i < num_10ms_frames; i++) {
     WebRtcSpl_Resample48khzTo8khz(speech_frame,
                                   &speech_nb[i * kFrameLen10ms8khz],
                                   &inst->state_48_to_8,
                                   tmp_mem);
   }
 
   // Do VAD on an 8 kHz signal
   vad = WebRtcVad_CalcVad8khz(inst, speech_nb, frame_length / 6);
 
   return vad;
 }
 
 int WebRtcVad_CalcVad32khz(VadInstT* inst, const int16_t* speech_frame,
-                           int frame_length)
+                           size_t frame_length)
 {
-    int len, vad;
+    size_t len;
+    int vad;
     int16_t speechWB[480]; // Downsampled speech frame: 960 samples (30ms in SWB)
     int16_t speechNB[240]; // Downsampled speech frame: 480 samples (30ms in WB)
 
 
     // Downsample signal 32->16->8 before doing VAD
     WebRtcVad_Downsampling(speech_frame, speechWB, &(inst->downsampling_filter_states[2]),
                            frame_length);
     len = frame_length / 2;
 
     WebRtcVad_Downsampling(speechWB, speechNB, inst->downsampling_filter_states, len);
     len /= 2;
 
     // Do VAD on an 8 kHz signal
     vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);
 
     return vad;
 }
 
 int WebRtcVad_CalcVad16khz(VadInstT* inst, const int16_t* speech_frame,
-                           int frame_length)
+                           size_t frame_length)
 {
-    int len, vad;
+    size_t len;
+    int vad;
     int16_t speechNB[240]; // Downsampled speech frame: 480 samples (30ms in WB)
 
     // Wideband: Downsample signal before doing VAD
     WebRtcVad_Downsampling(speech_frame, speechNB, inst->downsampling_filter_states,
                            frame_length);
 
     len = frame_length / 2;
     vad = WebRtcVad_CalcVad8khz(inst, speechNB, len);
 
     return vad;
 }
 
 int WebRtcVad_CalcVad8khz(VadInstT* inst, const int16_t* speech_frame,
-                          int frame_length)
+                          size_t frame_length)
 {
     int16_t feature_vector[kNumChannels], total_power;
 
     // Get power in the bands
     total_power = WebRtcVad_CalculateFeatures(inst, speech_frame, frame_length,
                                               feature_vector);
 
     // Make a VAD
     inst->vad = GmmProbability(inst, feature_vector, total_power, frame_length);
 
     return inst->vad;
 }