Convert some more things to size_t.

webrtc/modules/audio_coding/codecs/ilbc/enhancer_interface.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 17 matching lines @@
 
 /*----------------------------------------------------------------*
  * interface for enhancer
  *---------------------------------------------------------------*/
 
 size_t WebRtcIlbcfix_EnhancerInterface( /* (o) Estimated lag in end of in[] */
     int16_t *out,     /* (o) enhanced signal */
     int16_t *in,      /* (i) unenhanced signal */
     IlbcDecoder *iLBCdec_inst /* (i) buffers etc */
                                         ){
-  int iblock;
+  size_t iblock;
   size_t lag=20, tlag=20;
   size_t inLen=iLBCdec_inst->blockl+120;
   int16_t scale, scale1;
   size_t plc_blockl;
-  int16_t *enh_buf, *enh_period;
-  int32_t tmp1, tmp2, max, new_blocks;
+  int16_t *enh_buf;
+  size_t *enh_period;
+  int32_t tmp1, tmp2, max;
+  size_t new_blocks;
   int16_t *enh_bufPtr1;
   size_t i;
-  int k;
+  size_t k;
   int16_t EnChange;
   int16_t SqrtEnChange;
   int16_t inc;
   int16_t win;
   int16_t *tmpW16ptr;
-  int16_t startPos;
+  size_t startPos;
   int16_t *plc_pred;
   int16_t *target, *regressor;
   int16_t max16;
   int shifts;
   int32_t ener;
   int16_t enerSh;
   int16_t corrSh;
   size_t ind;
   int16_t sh;
-  int16_t start, stop;
+  size_t start, stop;
   /* Stack based */
   int16_t totsh[3];
   int16_t downsampled[(BLOCKL_MAX+120)>>1]; /* length 180 */
   int32_t corr32[50];
   int32_t corrmax[3];
   int16_t corr16[3];
   int16_t en16[3];
-  int16_t lagmax[3];
+  size_t lagmax[3];
 
   plc_pred = downsampled; /* Reuse memory since plc_pred[ENH_BLOCKL] and
                               downsampled are non overlapping */
   enh_buf=iLBCdec_inst->enh_buf;
   enh_period=iLBCdec_inst->enh_period;
 
   /* Copy in the new data into the enhancer buffer */
   memmove(enh_buf, &enh_buf[iLBCdec_inst->blockl],
           (ENH_BUFL - iLBCdec_inst->blockl) * sizeof(*enh_buf));
 
@@ skipping 10 matching lines @@
     plc_blockl=40;
     new_blocks=2;
     startPos=440;  /* Start position for enhancement
                     (640-new_blocks*ENH_BLOCKL-40) */
   }
 
   /* Update the pitch prediction for each enhancer block, move the old ones */
   memmove(enh_period, &enh_period[new_blocks],
           (ENH_NBLOCKS_TOT - new_blocks) * sizeof(*enh_period));
 
-  k = WebRtcSpl_DownsampleFast(
+  WebRtcSpl_DownsampleFast(
       enh_buf+ENH_BUFL-inLen,    /* Input samples */
       inLen + ENH_BUFL_FILTEROVERHEAD,
       downsampled,
       inLen / 2,
       (int16_t*)WebRtcIlbcfix_kLpFiltCoefs,  /* Coefficients in Q12 */
       FILTERORDER_DS_PLUS1,    /* Length of filter (order-1) */
       FACTOR_DS,
       DELAY_DS);
 
   /* Estimate the pitch in the down sampled domain. */
@@ skipping 11 matching lines @@
     /* compute cross correlation */
     WebRtcSpl_CrossCorrelation(corr32, target, regressor, ENH_BLOCKL_HALF, 50,
                                shifts, -1);
 
     /* Find 3 highest correlations that should be compared for the
        highest (corr*corr)/ener */
 
     for (i=0;i<2;i++) {
       lagmax[i] = WebRtcSpl_MaxIndexW32(corr32, 50);
       corrmax[i] = corr32[lagmax[i]];
-      start = lagmax[i] - 2;
-      stop = lagmax[i] + 2;
-      start = WEBRTC_SPL_MAX(0,  start);
-      stop  = WEBRTC_SPL_MIN(49, stop);
-      for (k=start; k<=stop; k++) {
+      start = WEBRTC_SPL_MAX(2, lagmax[i]) - 2;
+      stop = WEBRTC_SPL_MIN(47, lagmax[i]) + 2;
+      for (k = start; k <= stop; k++) {
         corr32[k] = 0;
       }
     }
     lagmax[2] = WebRtcSpl_MaxIndexW32(corr32, 50);
     corrmax[2] = corr32[lagmax[2]];
 
     /* Calculate normalized corr^2 and ener */
     for (i=0;i<3;i++) {
       corrSh = 15-WebRtcSpl_GetSizeInBits(corrmax[i]);
-      ener = WebRtcSpl_DotProductWithScale(&regressor[-lagmax[i]],
-                                           &regressor[-lagmax[i]],
+      ener = WebRtcSpl_DotProductWithScale(regressor - lagmax[i],
+                                           regressor - lagmax[i],
                                            ENH_BLOCKL_HALF, shifts);
       enerSh = 15-WebRtcSpl_GetSizeInBits(ener);
       corr16[i] = (int16_t)WEBRTC_SPL_SHIFT_W32(corrmax[i], corrSh);
       corr16[i] = (int16_t)((corr16[i] * corr16[i]) >> 16);
       en16[i] = (int16_t)WEBRTC_SPL_SHIFT_W32(ener, enerSh);
       totsh[i] = enerSh - (corrSh << 1);
     }
 
     /* Compare lagmax[0..3] for the (corr^2)/ener criteria */
     ind = 0;
     for (i=1; i<3; i++) {
       if (totsh[ind] > totsh[i]) {
         sh = WEBRTC_SPL_MIN(31, totsh[ind]-totsh[i]);
         if (corr16[ind] * en16[i] < (corr16[i] * en16[ind]) >> sh) {
           ind = i;
         }
       } else {
         sh = WEBRTC_SPL_MIN(31, totsh[i]-totsh[ind]);
         if ((corr16[ind] * en16[i]) >> sh < corr16[i] * en16[ind]) {
           ind = i;
         }
       }
     }
 
-    lag = (size_t)(lagmax[ind] + 10);
+    lag = lagmax[ind] + 10;
 
     /* Store the estimated lag in the non-downsampled domain */
-    enh_period[ENH_NBLOCKS_TOT - new_blocks + iblock] = (int16_t)(lag * 8);
+    enh_period[ENH_NBLOCKS_TOT - new_blocks + iblock] = lag * 8;
 
     /* Store the estimated lag for backward PLC */
     if (iLBCdec_inst->prev_enh_pl==1) {
       if (!iblock) {
         tlag = lag * 2;
       }
     } else {
       if (iblock==1) {
         tlag = lag * 2;
       }
@@ skipping 173 matching lines @@
     }
   }
 
 
   /* Perform enhancement block by block */
 
   for (iblock = 0; iblock<new_blocks; iblock++) {
     WebRtcIlbcfix_Enhancer(out + iblock * ENH_BLOCKL,
                            enh_buf,
                            ENH_BUFL,
-                           (int16_t)(iblock * ENH_BLOCKL + startPos),
+                           iblock * ENH_BLOCKL + startPos,
                            enh_period,
-                           (int16_t*)WebRtcIlbcfix_kEnhPlocs, ENH_NBLOCKS_TOT);
+                           WebRtcIlbcfix_kEnhPlocs, ENH_NBLOCKS_TOT);
   }
 
   return (lag);
 }