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

webrtc/modules/audio_coding/codecs/ilbc/cb_search.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 22 matching lines @@
  *  Search routine for codebook encoding and gain quantization.
  *----------------------------------------------------------------*/
 
 void WebRtcIlbcfix_CbSearch(
     IlbcEncoder *iLBCenc_inst,
     /* (i) the encoder state structure */
     int16_t *index,  /* (o) Codebook indices */
     int16_t *gain_index, /* (o) Gain quantization indices */
     int16_t *intarget, /* (i) Target vector for encoding */
     int16_t *decResidual,/* (i) Decoded residual for codebook construction */
-    int16_t lMem,  /* (i) Length of buffer */
-    int16_t lTarget,  /* (i) Length of vector */
+    size_t lMem,  /* (i) Length of buffer */
+    size_t lTarget,  /* (i) Length of vector */
     int16_t *weightDenum,/* (i) weighting filter coefficients in Q12 */
-    int16_t block  /* (i) the subblock number */
+    size_t block  /* (i) the subblock number */
                             ) {
-  int16_t i, j, stage, range;
+  size_t i, range;
+  int16_t ii, j, stage;
   int16_t *pp;
   int16_t tmp;
   int scale;
   int16_t bits, temp1, temp2;
-  int16_t base_size;
+  size_t base_size;
   int32_t codedEner, targetEner;
   int16_t gains[CB_NSTAGES+1];
   int16_t *cb_vecPtr;
-  int16_t indexOffset, sInd, eInd;
+  size_t indexOffset, sInd, eInd;
   int32_t CritMax=0;
   int16_t shTotMax=WEBRTC_SPL_WORD16_MIN;
-  int16_t bestIndex=0;
+  size_t bestIndex=0;
   int16_t bestGain=0;
-  int16_t indexNew, CritNewSh;
+  size_t indexNew;
+  int16_t CritNewSh;
   int32_t CritNew;
   int32_t *cDotPtr;
-  int16_t noOfZeros;
+  size_t noOfZeros;
   int16_t *gainPtr;
   int32_t t32, tmpW32;
   int16_t *WebRtcIlbcfix_kGainSq5_ptr;
   /* Stack based */
   int16_t CBbuf[CB_MEML+LPC_FILTERORDER+CB_HALFFILTERLEN];
   int32_t cDot[128];
   int32_t Crit[128];
   int16_t targetVec[SUBL+LPC_FILTERORDER];
   int16_t cbvectors[CB_MEML + 1];  /* Adding one extra position for
                                             Coverity warnings. */
@@ skipping 65 matching lines @@
     WebRtcIlbcfix_InterpolateSamples(interpSamples, buf, lMem);
 
     /* Second section, filtered half of the cb */
     WebRtcIlbcfix_InterpolateSamples(interpSamplesFilt, cbvectors, lMem);
 
     /* Compute the CB vectors' energies for the first cb section (non-filtered) */
     WebRtcIlbcfix_CbMemEnergyAugmentation(interpSamples, buf,
                                           scale, 20, energyW16, energyShifts);
 
     /* Compute the CB vectors' energies for the second cb section (filtered cb) */
-    WebRtcIlbcfix_CbMemEnergyAugmentation(interpSamplesFilt, cbvectors,
-                                          scale, (int16_t)(base_size + 20),
-                                          energyW16, energyShifts);
+    WebRtcIlbcfix_CbMemEnergyAugmentation(interpSamplesFilt, cbvectors, scale,
+                                          base_size + 20, energyW16,
+                                          energyShifts);
 
     /* Compute the CB vectors' energies and store them in the vector
      * energyW16. Also the corresponding shift values are stored. The
      * energy values are used in all three stages. */
     WebRtcIlbcfix_CbMemEnergy(range, buf, cbvectors, lMem,
                               lTarget, energyW16+20, energyShifts+20, scale, base_size);
 
   } else {
     /* Compute the CB vectors' energies and store them in the vector
      * energyW16. Also the corresponding shift values are stored. The
@@ skipping 53 matching lines @@
     indexOffset=0;
 
     /* Search for best index in this part of the vector */
     WebRtcIlbcfix_CbSearchCore(
         cDot, range, stage, inverseEnergy,
         inverseEnergyShifts, Crit,
         &indexNew, &CritNew, &CritNewSh);
 
     /* Update the global best index and the corresponding gain */
     WebRtcIlbcfix_CbUpdateBestIndex(
-        CritNew, CritNewSh, (int16_t)(indexNew+indexOffset), cDot[indexNew+indexOffset],
+        CritNew, CritNewSh, indexNew+indexOffset, cDot[indexNew+indexOffset],
         inverseEnergy[indexNew+indexOffset], inverseEnergyShifts[indexNew+indexOffset],
         &CritMax, &shTotMax, &bestIndex, &bestGain);
 
     sInd = ((CB_RESRANGE >> 1) > bestIndex) ?
         0 : (bestIndex - (CB_RESRANGE >> 1));
     eInd=sInd+CB_RESRANGE;
     if (eInd>=range) {
       eInd=range-1;
       sInd=eInd-CB_RESRANGE;
     }
 
     range = WebRtcIlbcfix_kSearchRange[block][stage];
 
     if (lTarget==SUBL) {
       i=sInd;
       if (sInd<20) {
         WebRtcIlbcfix_AugmentedCbCorr(target, cbvectors + lMem,
-                                      interpSamplesFilt, cDot,
-                                      (int16_t)(sInd + 20),
-                                      (int16_t)(WEBRTC_SPL_MIN(39,
-                                                               (eInd + 20))),
-                                      scale);
+                                      interpSamplesFilt, cDot, sInd + 20,
+                                      WEBRTC_SPL_MIN(39, (eInd + 20)), scale);
         i=20;
         cDotPtr = &cDot[20 - sInd];
       } else {
         cDotPtr = cDot;
       }
 
       cb_vecPtr = cbvectors+lMem-20-i;
 
       /* Calculate the cross correlations (main part of the filtered CB) */
       WebRtcSpl_CrossCorrelation(cDotPtr, target, cb_vecPtr, lTarget,
-                                 (int16_t)(eInd - i + 1), scale, -1);
+                                 eInd - i + 1, scale, -1);
 
     } else {
       cDotPtr = cDot;
       cb_vecPtr = cbvectors+lMem-lTarget-sInd;
 
       /* Calculate the cross correlations (main part of the filtered CB) */
       WebRtcSpl_CrossCorrelation(cDotPtr, target, cb_vecPtr, lTarget,
-                                 (int16_t)(eInd - sInd + 1), scale, -1);
+                                 eInd - sInd + 1, scale, -1);
 
     }
 
     /* Adjust the search range for the augmented vectors */
     indexOffset=base_size+sInd;
 
     /* Search for best index in this part of the vector */
     WebRtcIlbcfix_CbSearchCore(
-        cDot, (int16_t)(eInd-sInd+1), stage, inverseEnergy+indexOffset,
+        cDot, eInd-sInd+1, stage, inverseEnergy+indexOffset,
         inverseEnergyShifts+indexOffset, Crit,
         &indexNew, &CritNew, &CritNewSh);
 
     /* Update the global best index and the corresponding gain */
     WebRtcIlbcfix_CbUpdateBestIndex(
-        CritNew, CritNewSh, (int16_t)(indexNew+indexOffset), cDot[indexNew],
+        CritNew, CritNewSh, indexNew+indexOffset, cDot[indexNew],
         inverseEnergy[indexNew+indexOffset], inverseEnergyShifts[indexNew+indexOffset],
         &CritMax, &shTotMax, &bestIndex, &bestGain);
 
-    index[stage] = bestIndex;
+    index[stage] = (int16_t)bestIndex;
 
 
     bestGain = WebRtcIlbcfix_GainQuant(bestGain,
                                        (int16_t)WEBRTC_SPL_ABS_W16(gains[stage]), stage, &gain_index[stage]);
 
     /* Extract the best (according to measure) codebook vector
        Also adjust the index, so that the augmented vectors are last.
        Above these vectors were first...
     */
 
     if(lTarget==(STATE_LEN-iLBCenc_inst->state_short_len)) {
 
-      if(index[stage]<base_size) {
+      if((size_t)index[stage]<base_size) {
         pp=buf+lMem-lTarget-index[stage];
       } else {
         pp=cbvectors+lMem-lTarget-
             index[stage]+base_size;
       }
 
     } else {
 
-      if (index[stage]<base_size) {
+      if ((size_t)index[stage]<base_size) {
         if (index[stage]>=20) {
           /* Adjust index and extract vector */
           index[stage]-=20;
           pp=buf+lMem-lTarget-index[stage];
         } else {
           /* Adjust index and extract vector */
-          index[stage]+=(base_size-20);
+          index[stage]+=(int16_t)(base_size-20);
 
-          WebRtcIlbcfix_CreateAugmentedVec((int16_t)(index[stage]-base_size+40),
+          WebRtcIlbcfix_CreateAugmentedVec(index[stage]-base_size+40,
                                            buf+lMem, aug_vec);
           pp = aug_vec;
 
         }
       } else {
 
         if ((index[stage] - base_size) >= 20) {
           /* Adjust index and extract vector */
           index[stage]-=20;
           pp=cbvectors+lMem-lTarget-
               index[stage]+base_size;
         } else {
           /* Adjust index and extract vector */
-          index[stage]+=(base_size-20);
-          WebRtcIlbcfix_CreateAugmentedVec((int16_t)(index[stage]-2*base_size+40),
+          index[stage]+=(int16_t)(base_size-20);
+          WebRtcIlbcfix_CreateAugmentedVec(index[stage]-2*base_size+40,
                                            cbvectors+lMem, aug_vec);
           pp = aug_vec;
         }
       }
     }
 
     /* Subtract the best codebook vector, according
        to measure, from the target vector */
 
     WebRtcSpl_AddAffineVectorToVector(target, pp, (int16_t)(-bestGain),
@@ skipping 30 matching lines @@
   tmpW32 = ((int32_t)(gains[1]-1))<<1;
 
   /* Pointer to the table that contains
      gain_sq5TblFIX * gain_sq5TblFIX in Q14 */
   gainPtr=(int16_t*)WebRtcIlbcfix_kGainSq5Sq+gain_index[0];
   temp1 = (int16_t)WEBRTC_SPL_SHIFT_W32(codedEner, -bits);
 
   WebRtcIlbcfix_kGainSq5_ptr = (int16_t*)&WebRtcIlbcfix_kGainSq5[j];
 
   /* targetEner and codedEner are in Q(-2*scale) */
-  for (i=gain_index[0];i<32;i++) {
+  for (ii=gain_index[0];ii<32;ii++) {
 
     /* Change the index if
        (codedEnergy*gainTbl[i]*gainTbl[i])<(targetEn*gain[0]*gain[0]) AND
        gainTbl[i] < 2*gain[0]
     */
 
     t32 = temp1 * *gainPtr;
     t32 = t32 - targetEner;
     if (t32 < 0) {
       if ((*WebRtcIlbcfix_kGainSq5_ptr) < tmpW32) {
-        j=i;
-        WebRtcIlbcfix_kGainSq5_ptr = (int16_t*)&WebRtcIlbcfix_kGainSq5[i];
+        j=ii;
+        WebRtcIlbcfix_kGainSq5_ptr = (int16_t*)&WebRtcIlbcfix_kGainSq5[ii];
       }
     }
     gainPtr++;
   }
   gain_index[0]=j;
 
   return;
 }