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

webrtc/common_audio/resampler/resampler.cc

 /*
  *  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 383 matching lines @@
             state1_ = malloc(sizeof(WebRtcSpl_State22khzTo16khz));
             WebRtcSpl_ResetResample22khzTo16khz((WebRtcSpl_State22khzTo16khz *)state1_);
             break;
 
     }
 
     return 0;
 }
 
 // Synchronous resampling, all output samples are written to samplesOut
-int Resampler::Push(const int16_t * samplesIn, int lengthIn,
-                    int16_t* samplesOut, int maxLen, int &outLen)
+int Resampler::Push(const int16_t * samplesIn, size_t lengthIn,
+                    int16_t* samplesOut, size_t maxLen, size_t &outLen)
 {
     if (num_channels_ == 2)
     {
         // Split up the signal and call the slave object for each channel
         int16_t* left = (int16_t*)malloc(lengthIn * sizeof(int16_t) / 2);
         int16_t* right = (int16_t*)malloc(lengthIn * sizeof(int16_t) / 2);
         int16_t* out_left = (int16_t*)malloc(maxLen / 2 * sizeof(int16_t));
         int16_t* out_right =
                 (int16_t*)malloc(maxLen / 2 * sizeof(int16_t));
         int res = 0;
-        for (int i = 0; i < lengthIn; i += 2)
+        for (size_t i = 0; i < lengthIn; i += 2)
         {
             left[i >> 1] = samplesIn[i];
             right[i >> 1] = samplesIn[i + 1];
         }
 
         // It's OK to overwrite the local parameter, since it's just a copy
         lengthIn = lengthIn / 2;
 
-        int actualOutLen_left = 0;
-        int actualOutLen_right = 0;
+        size_t actualOutLen_left = 0;
+        size_t actualOutLen_right = 0;
         // Do resampling for right channel
         res |= slave_left_->Push(left, lengthIn, out_left, maxLen / 2, actualOutLen_left);
         res |= slave_right_->Push(right, lengthIn, out_right, maxLen / 2, actualOutLen_right);
         if (res || (actualOutLen_left != actualOutLen_right))
         {
             free(left);
             free(right);
             free(out_left);
             free(out_right);
             return -1;
         }
 
         // Reassemble the signal
-        for (int i = 0; i < actualOutLen_left; i++)
+        for (size_t i = 0; i < actualOutLen_left; i++)
         {
             samplesOut[i * 2] = out_left[i];
             samplesOut[i * 2 + 1] = out_right[i];
         }
         outLen = 2 * actualOutLen_left;
 
         free(left);
         free(right);
         free(out_left);
         free(out_right);
@@ skipping 28 matching lines @@
             if ((lengthIn % 160) != 0)
             {
                 return -1;
             }
             if (maxLen < (lengthIn * 3))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(336 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 160)
+            for (size_t i = 0; i < lengthIn; i += 160)
             {
                 WebRtcSpl_Resample16khzTo48khz(samplesIn + i, samplesOut + i * 3,
                                                (WebRtcSpl_State16khzTo48khz *)state1_,
                                                tmp_mem);
             }
             outLen = lengthIn * 3;
             free(tmp_mem);
             return 0;
         case kResamplerMode1To4:
             if (maxLen < (lengthIn * 4))
@@ skipping 22 matching lines @@
             }
 
             //1:2
 
             tmp_mem = (int32_t*)malloc(336 * sizeof(int32_t));
             tmp = (int16_t*)malloc(sizeof(int16_t) * 2 * lengthIn);
 
             WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, (int32_t*)state1_);
             outLen = lengthIn * 2;
 
-            for (int i = 0; i < outLen; i += 160)
+            for (size_t i = 0; i < outLen; i += 160)
             {
                 WebRtcSpl_Resample16khzTo48khz(tmp + i, samplesOut + i * 3,
                                                (WebRtcSpl_State16khzTo48khz *)state2_,
                                                tmp_mem);
             }
             outLen = outLen * 3;
             free(tmp_mem);
             free(tmp);
 
             return 0;
@@ skipping 10 matching lines @@
             tmp_mem = (int32_t*) malloc(336 * sizeof(int32_t));
             tmp = (int16_t*) malloc(sizeof(int16_t) * 4 * lengthIn);
             //1:2
             WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut,
                                   (int32_t*) state1_);
             outLen = lengthIn * 2;
             //2:4
             WebRtcSpl_UpsampleBy2(samplesOut, outLen, tmp, (int32_t*) state2_);
             outLen = outLen * 2;
             // 4:12
-            for (int i = 0; i < outLen; i += 160) {
+            for (size_t i = 0; i < outLen; i += 160) {
               // WebRtcSpl_Resample16khzTo48khz() takes a block of 160 samples
               // as input and outputs a resampled block of 480 samples. The
               // data is now actually in 32 kHz sampling rate, despite the
               // function name, and with a resampling factor of three becomes
               // 96 kHz.
               WebRtcSpl_Resample16khzTo48khz(tmp + i, samplesOut + i * 3,
                                              (WebRtcSpl_State16khzTo48khz*) state3_,
                                              tmp_mem);
             }
             outLen = outLen * 3;
             free(tmp_mem);
             free(tmp);
 
             return 0;
         case kResamplerMode2To3:
             if (maxLen < (lengthIn * 3 / 2))
             {
                 return -1;
             }
             // 2:6
             // We can only handle blocks of 160 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 160) != 0)
             {
                 return -1;
             }
             tmp = static_cast<int16_t*> (malloc(sizeof(int16_t) * lengthIn * 3));
             tmp_mem = (int32_t*)malloc(336 * sizeof(int32_t));
-            for (int i = 0; i < lengthIn; i += 160)
+            for (size_t i = 0; i < lengthIn; i += 160)
             {
                 WebRtcSpl_Resample16khzTo48khz(samplesIn + i, tmp + i * 3,
                                                (WebRtcSpl_State16khzTo48khz *)state1_,
                                                tmp_mem);
             }
             lengthIn = lengthIn * 3;
             // 6:3
             WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut, (int32_t*)state2_);
             outLen = lengthIn / 2;
             free(tmp);
@@ skipping 11 matching lines @@
             {
                 return -1;
             }
             tmp = (int16_t*)malloc(sizeof(int16_t) * 2 * lengthIn);
             // 1:2
             WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, (int32_t*)state1_);
             lengthIn *= 2;
 
             tmp_mem = (int32_t*)malloc(98 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 80)
+            for (size_t i = 0; i < lengthIn; i += 80)
             {
                 WebRtcSpl_Resample8khzTo22khz(tmp + i, samplesOut + (i * 11) / 4,
                                               (WebRtcSpl_State8khzTo22khz *)state2_,
                                               tmp_mem);
             }
             outLen = (lengthIn * 11) / 4;
             free(tmp_mem);
             free(tmp);
             return 0;
         case kResamplerMode4To11:
 
             // We can only handle blocks of 80 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 80) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 11) / 4))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(98 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 80)
+            for (size_t i = 0; i < lengthIn; i += 80)
             {
                 WebRtcSpl_Resample8khzTo22khz(samplesIn + i, samplesOut + (i * 11) / 4,
                                               (WebRtcSpl_State8khzTo22khz *)state1_,
                                               tmp_mem);
             }
             outLen = (lengthIn * 11) / 4;
             free(tmp_mem);
             return 0;
         case kResamplerMode8To11:
             // We can only handle blocks of 160 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 160) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 11) / 8))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(88 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 160)
+            for (size_t i = 0; i < lengthIn; i += 160)
             {
                 WebRtcSpl_Resample16khzTo22khz(samplesIn + i, samplesOut + (i * 11) / 8,
                                                (WebRtcSpl_State16khzTo22khz *)state1_,
                                                tmp_mem);
             }
             outLen = (lengthIn * 11) / 8;
             free(tmp_mem);
             return 0;
 
         case kResamplerMode11To16:
             // We can only handle blocks of 110 samples
             if ((lengthIn % 110) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 16) / 11))
             {
                 return -1;
             }
 
             tmp_mem = (int32_t*)malloc(104 * sizeof(int32_t));
             tmp = (int16_t*)malloc((sizeof(int16_t) * lengthIn * 2));
 
             WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, tmp, (int32_t*)state1_);
 
-            for (int i = 0; i < (lengthIn * 2); i += 220)
+            for (size_t i = 0; i < (lengthIn * 2); i += 220)
             {
                 WebRtcSpl_Resample22khzTo16khz(tmp + i, samplesOut + (i / 220) * 160,
                                                (WebRtcSpl_State22khzTo16khz *)state2_,
                                                tmp_mem);
             }
 
             outLen = (lengthIn * 16) / 11;
 
             free(tmp_mem);
             free(tmp);
@@ skipping 11 matching lines @@
                 return -1;
             }
 
             tmp_mem = (int32_t*)malloc(104 * sizeof(int32_t));
             tmp = (int16_t*)malloc((sizeof(int16_t) * lengthIn * 2));
 
             // 11 -> 22 kHz in samplesOut
             WebRtcSpl_UpsampleBy2(samplesIn, lengthIn, samplesOut, (int32_t*)state1_);
 
             // 22 -> 16 in tmp
-            for (int i = 0; i < (lengthIn * 2); i += 220)
+            for (size_t i = 0; i < (lengthIn * 2); i += 220)
             {
                 WebRtcSpl_Resample22khzTo16khz(samplesOut + i, tmp + (i / 220) * 160,
                                                (WebRtcSpl_State22khzTo16khz *)state2_,
                                                tmp_mem);
             }
 
             // 16 -> 32 in samplesOut
             WebRtcSpl_UpsampleBy2(tmp, (lengthIn * 16) / 11, samplesOut,
                                   (int32_t*)state3_);
 
@@ skipping 17 matching lines @@
             if ((lengthIn % 480) != 0)
             {
                 return -1;
             }
             if (maxLen < (lengthIn / 3))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(496 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 480)
+            for (size_t i = 0; i < lengthIn; i += 480)
             {
                 WebRtcSpl_Resample48khzTo16khz(samplesIn + i, samplesOut + i / 3,
                                                (WebRtcSpl_State48khzTo16khz *)state1_,
                                                tmp_mem);
             }
             outLen = lengthIn / 3;
             free(tmp_mem);
             return 0;
         case kResamplerMode4To1:
             if (maxLen < (lengthIn / 4))
@@ skipping 17 matching lines @@
                 return -1;
             }
             if (maxLen < (lengthIn / 6))
             {
                 return -1;
             }
 
             tmp_mem = (int32_t*)malloc(496 * sizeof(int32_t));
             tmp = (int16_t*)malloc((sizeof(int16_t) * lengthIn) / 3);
 
-            for (int i = 0; i < lengthIn; i += 480)
+            for (size_t i = 0; i < lengthIn; i += 480)
             {
                 WebRtcSpl_Resample48khzTo16khz(samplesIn + i, tmp + i / 3,
                                                (WebRtcSpl_State48khzTo16khz *)state1_,
                                                tmp_mem);
             }
             outLen = lengthIn / 3;
             free(tmp_mem);
             WebRtcSpl_DownsampleBy2(tmp, outLen, samplesOut, (int32_t*)state2_);
             free(tmp);
             outLen = outLen / 2;
             return 0;
         case kResamplerMode12To1:
             // We can only handle blocks of 480 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 480) != 0) {
               return -1;
             }
             if (maxLen < (lengthIn / 12)) {
               return -1;
             }
 
             tmp_mem = (int32_t*) malloc(496 * sizeof(int32_t));
             tmp = (int16_t*) malloc((sizeof(int16_t) * lengthIn) / 3);
             tmp_2 = (int16_t*) malloc((sizeof(int16_t) * lengthIn) / 6);
             // 12:4
-            for (int i = 0; i < lengthIn; i += 480) {
+            for (size_t i = 0; i < lengthIn; i += 480) {
               // WebRtcSpl_Resample48khzTo16khz() takes a block of 480 samples
               // as input and outputs a resampled block of 160 samples. The
               // data is now actually in 96 kHz sampling rate, despite the
               // function name, and with a resampling factor of 1/3 becomes
               // 32 kHz.
               WebRtcSpl_Resample48khzTo16khz(samplesIn + i, tmp + i / 3,
                                              (WebRtcSpl_State48khzTo16khz*) state1_,
                                              tmp_mem);
             }
             outLen = lengthIn / 3;
@@ skipping 19 matching lines @@
             lengthIn *= 2;
             // 6:2
             // We can only handle blocks of 480 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 480) != 0)
             {
                 free(tmp);
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(496 * sizeof(int32_t));
-            for (int i = 0; i < lengthIn; i += 480)
+            for (size_t i = 0; i < lengthIn; i += 480)
             {
                 WebRtcSpl_Resample48khzTo16khz(tmp + i, samplesOut + i / 3,
                                                (WebRtcSpl_State48khzTo16khz *)state2_,
                                                tmp_mem);
             }
             outLen = lengthIn / 3;
             free(tmp);
             free(tmp_mem);
             return 0;
         case kResamplerMode11To2:
             // We can only handle blocks of 220 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 220) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 2) / 11))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(126 * sizeof(int32_t));
             tmp = (int16_t*)malloc((lengthIn * 4) / 11 * sizeof(int16_t));
 
-            for (int i = 0; i < lengthIn; i += 220)
+            for (size_t i = 0; i < lengthIn; i += 220)
             {
                 WebRtcSpl_Resample22khzTo8khz(samplesIn + i, tmp + (i * 4) / 11,
                                               (WebRtcSpl_State22khzTo8khz *)state1_,
                                               tmp_mem);
             }
             lengthIn = (lengthIn * 4) / 11;
 
             WebRtcSpl_DownsampleBy2(tmp, lengthIn, samplesOut,
                                     (int32_t*)state2_);
             outLen = lengthIn / 2;
 
             free(tmp_mem);
             free(tmp);
             return 0;
         case kResamplerMode11To4:
             // We can only handle blocks of 220 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 220) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 4) / 11))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(126 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 220)
+            for (size_t i = 0; i < lengthIn; i += 220)
             {
                 WebRtcSpl_Resample22khzTo8khz(samplesIn + i, samplesOut + (i * 4) / 11,
                                               (WebRtcSpl_State22khzTo8khz *)state1_,
                                               tmp_mem);
             }
             outLen = (lengthIn * 4) / 11;
             free(tmp_mem);
             return 0;
         case kResamplerMode11To8:
             // We can only handle blocks of 160 samples
             // Can be fixed, but I don't think it's needed
             if ((lengthIn % 220) != 0)
             {
                 return -1;
             }
             if (maxLen < ((lengthIn * 8) / 11))
             {
                 return -1;
             }
             tmp_mem = (int32_t*)malloc(104 * sizeof(int32_t));
 
-            for (int i = 0; i < lengthIn; i += 220)
+            for (size_t i = 0; i < lengthIn; i += 220)
             {
                 WebRtcSpl_Resample22khzTo16khz(samplesIn + i, samplesOut + (i * 8) / 11,
                                                (WebRtcSpl_State22khzTo16khz *)state1_,
                                                tmp_mem);
             }
             outLen = (lengthIn * 8) / 11;
             free(tmp_mem);
             return 0;
             break;
 
     }
     return 0;
 }
 
 }  // namespace webrtc