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

webrtc/common_audio/signal_processing/resample_fractional.c

 /*
  *  Copyright (c) 2011 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 23 matching lines @@
         {-101, 612, -2283, 8532, 29790, -5138, 1789, -524, 91},
         {50, -292, 1016, -3064, 32010, 3933, -1147, 315, -53},
         {-156, 974, -3863, 18603, 21691, -6246, 2353, -712, 126}
 };
 
 //   Resampling ratio: 2/3
 // input:  int32_t (normalized, not saturated) :: size 3 * K
 // output: int32_t (shifted 15 positions to the left, + offset 16384) :: size 2 * K
 //      K: number of blocks
 
-void WebRtcSpl_Resample48khzTo32khz(const int32_t *In, int32_t *Out, int32_t K)
+void WebRtcSpl_Resample48khzTo32khz(const int32_t *In, int32_t *Out, size_t K)
 {
     /////////////////////////////////////////////////////////////
     // Filter operation:
     //
     // Perform resampling (3 input samples -> 2 output samples);
     // process in sub blocks of size 3 samples.
     int32_t tmp;
-    int32_t m;
+    size_t m;
 
     for (m = 0; m < K; m++)
     {
         tmp = 1 << 14;
         tmp += kCoefficients48To32[0][0] * In[0];
         tmp += kCoefficients48To32[0][1] * In[1];
         tmp += kCoefficients48To32[0][2] * In[2];
         tmp += kCoefficients48To32[0][3] * In[3];
         tmp += kCoefficients48To32[0][4] * In[4];
         tmp += kCoefficients48To32[0][5] * In[5];
@@ skipping 16 matching lines @@
         In += 3;
         Out += 2;
     }
 }
 
 //   Resampling ratio: 3/4
 // input:  int32_t (normalized, not saturated) :: size 4 * K
 // output: int32_t (shifted 15 positions to the left, + offset 16384) :: size 3 * K
 //      K: number of blocks
 
-void WebRtcSpl_Resample32khzTo24khz(const int32_t *In, int32_t *Out, int32_t K)
+void WebRtcSpl_Resample32khzTo24khz(const int32_t *In, int32_t *Out, size_t K)
 {
     /////////////////////////////////////////////////////////////
     // Filter operation:
     //
     // Perform resampling (4 input samples -> 3 output samples);
     // process in sub blocks of size 4 samples.
-    int32_t m;
+    size_t m;
     int32_t tmp;
 
     for (m = 0; m < K; m++)
     {
         tmp = 1 << 14;
         tmp += kCoefficients32To24[0][0] * In[0];
         tmp += kCoefficients32To24[0][1] * In[1];
         tmp += kCoefficients32To24[0][2] * In[2];
         tmp += kCoefficients32To24[0][3] * In[3];
         tmp += kCoefficients32To24[0][4] * In[4];
@@ skipping 80 matching lines @@
     coef = coef_ptr[8];
     *out1 = tmp1 + coef * in1[8];
     *out2 = tmp2 + coef * in2[-8];
 }
 
 //   Resampling ratio: 8/11
 // input:  int32_t (normalized, not saturated) :: size 11 * K
 // output: int32_t (shifted 15 positions to the left, + offset 16384) :: size  8 * K
 //      K: number of blocks
 
-void WebRtcSpl_Resample44khzTo32khz(const int32_t *In, int32_t *Out, int32_t K)
+void WebRtcSpl_Resample44khzTo32khz(const int32_t *In, int32_t *Out, size_t K)
 {
     /////////////////////////////////////////////////////////////
     // Filter operation:
     //
     // Perform resampling (11 input samples -> 8 output samples);
     // process in sub blocks of size 11 samples.
     int32_t tmp;
-    int32_t m;
+    size_t m;
 
     for (m = 0; m < K; m++)
     {
         tmp = 1 << 14;
 
         // first output sample
         Out[0] = ((int32_t)In[3] << 15) + tmp;
 
         // sum and accumulate filter coefficients and input samples
         tmp += kCoefficients44To32[3][0] * In[5];
@@ skipping 14 matching lines @@
         WebRtcSpl_ResampDotProduct(&In[2], &In[15], kCoefficients44To32[1], &Out[2], &Out[6]);
 
         // sum and accumulate filter coefficients and input samples
         WebRtcSpl_ResampDotProduct(&In[3], &In[14], kCoefficients44To32[2], &Out[3], &Out[5]);
 
         // update pointers
         In += 11;
         Out += 8;
     }
 }