Convert some more things to size_t.

webrtc/modules/audio_coding/codecs/ilbc/get_sync_seq.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.
  */
 
 /******************************************************************
 
  iLBC Speech Coder ANSI-C Source Code
 
  WebRtcIlbcfix_GetSyncSeq.c
 
 ******************************************************************/
 
 #include "defines.h"
 #include "constants.h"
 #include "refiner.h"
 #include "nearest_neighbor.h"
 
 /*----------------------------------------------------------------*
  * get the pitch-synchronous sample sequence
  *---------------------------------------------------------------*/
 
 void WebRtcIlbcfix_GetSyncSeq(
     int16_t *idata,   /* (i) original data */
-    int16_t idatal,   /* (i) dimension of data */
-    int16_t centerStartPos, /* (i) where current block starts */
-    int16_t *period,   /* (i) rough-pitch-period array       (Q-2) */
-    int16_t *plocs,   /* (i) where periods of period array are taken (Q-2) */
+    size_t idatal,   /* (i) dimension of data */
+    size_t centerStartPos, /* (i) where current block starts */
+    size_t *period,   /* (i) rough-pitch-period array       (Q-2) */
+    const size_t *plocs, /* (i) where periods of period array are taken (Q-2) */
     size_t periodl,   /* (i) dimension period array */
-    int16_t hl,    /* (i) 2*hl+1 is the number of sequences */
+    size_t hl,    /* (i) 2*hl+1 is the number of sequences */
     int16_t *surround  /* (i/o) The contribution from this sequence
                                 summed with earlier contributions */
                               ){
-  size_t i;
-  int16_t centerEndPos,q;
+  size_t i, centerEndPos, q;
   /* Stack based */
-  int16_t lagBlock[2*ENH_HL+1];
-  int16_t blockStartPos[2*ENH_HL+1]; /* Defines the position to search around (Q2) */
-  int16_t plocs2[ENH_PLOCSL];
+  size_t lagBlock[2 * ENH_HL + 1];
+  size_t blockStartPos[2 * ENH_HL + 1]; /* The position to search around (Q2) */
+  size_t plocs2[ENH_PLOCSL];
 
-  centerEndPos=centerStartPos+ENH_BLOCKL-1;
+  centerEndPos = centerStartPos + ENH_BLOCKL - 1;
 
   /* present (find predicted lag from this position) */
 
   WebRtcIlbcfix_NearestNeighbor(lagBlock + hl,
                                 plocs,
-                                (int16_t)(2 * (centerStartPos + centerEndPos)),
+                                2 * (centerStartPos + centerEndPos),
                                 periodl);
 
-  blockStartPos[hl] = (int16_t)(4 * centerStartPos);
+  blockStartPos[hl] = 4 * centerStartPos;
 
   /* past (find predicted position and perform a refined
      search to find the best sequence) */
 
-  for(q=hl-1;q>=0;q--) {
-    blockStartPos[q]=blockStartPos[q+1]-period[lagBlock[q+1]];
+  for (q = hl; q > 0; q--) {
+    size_t qq = q - 1;
+    size_t period_q = period[lagBlock[q]];
+    /* Stop if this sequence would be outside the buffer; that means all
+       further-past sequences would also be outside the buffer. */

[Peter Kasting, 2015/08/27 00:39:02]

Because |period| contains only non-negative numbers, |blockStartPos|' elements
will only ever decrease in value as we iterate more times.  Since the call to
WebRtcIlbcfix_Refiner() is the only thing in this loop body with side effects
that affect anything (we would also update the elements of |blockStartPos| and
|lagBlock|, but nothing below this loop would read the particular elements we
updated), once the conditional guarding the call to WebRtcIlbcfix_Refiner()
fails, it's safe to just bail out of the loop entirely.

Not only is this faster, it avoids the case that otherwise could occur where
|blockStartPos|' elements could actually be set to negative values, which
wouldn't be compatible with using size_ts for some of these objects.

+    if (blockStartPos[q] < period_q + (4 * ENH_OVERHANG))
+      break;
+    blockStartPos[qq] = blockStartPos[q] - period_q;
 
-    WebRtcIlbcfix_NearestNeighbor(
-        lagBlock + q,
-        plocs,
-        (int16_t)(blockStartPos[q] + 4 * ENH_BLOCKL_HALF -
-            period[lagBlock[q + 1]]),
-        periodl);
+    size_t value = blockStartPos[qq] + 4 * ENH_BLOCKL_HALF;
+    value = (value > period_q) ? (value - period_q) : 0;

[Peter Kasting, 2015/08/27 00:39:02]

Previously |value| was just inlined directly into the
WebRtcIlbcfix_NearestNeighbor() call, and could result in a negative value; but
since the elements of |plocs| are all non-negative, we know that would have the
same effect as passing in zero, so this code change won't result in a functional
difference.

+    WebRtcIlbcfix_NearestNeighbor(lagBlock + qq, plocs, value, periodl);
 
-    if (blockStartPos[q] - 4 * ENH_OVERHANG >= 0) {
-
-      /* Find the best possible sequence in the 4 times upsampled
-         domain around blockStartPos+q */
-      WebRtcIlbcfix_Refiner(blockStartPos+q,idata,idatal,
-                            centerStartPos,blockStartPos[q],surround,WebRtcIlbcfix_kEnhWt[q]);
-
-    } else {
-      /* Don't add anything since this sequence would
-         be outside the buffer */
-    }
+    /* Find the best possible sequence in the 4 times upsampled
+        domain around blockStartPos+q */
+    WebRtcIlbcfix_Refiner(blockStartPos + qq, idata, idatal, centerStartPos,
+                          blockStartPos[qq], surround,
+                          WebRtcIlbcfix_kEnhWt[qq]);
   }
 
   /* future (find predicted position and perform a refined
      search to find the best sequence) */
 
-  for(i=0;i<periodl;i++) {
-    plocs2[i]=(plocs[i]-period[i]);
+  for (i = 0; i < periodl; i++) {
+    plocs2[i] = plocs[i] - period[i];
   }
 
-  for (q = hl + 1; q <= (int16_t)(2 * hl); q++) {
+  for (q = hl + 1; q <= (2 * hl); q++) {
 
     WebRtcIlbcfix_NearestNeighbor(
         lagBlock + q,
         plocs2,
-        (int16_t)(blockStartPos[q - 1] + 4 * ENH_BLOCKL_HALF),
+        blockStartPos[q - 1] + 4 * ENH_BLOCKL_HALF,
         periodl);
 
     blockStartPos[q]=blockStartPos[q-1]+period[lagBlock[q]];
 
     if (blockStartPos[q] + 4 * (ENH_BLOCKL + ENH_OVERHANG) < 4 * idatal) {
 
       /* Find the best possible sequence in the 4 times upsampled
          domain around blockStartPos+q */
-      WebRtcIlbcfix_Refiner(blockStartPos+q, idata, idatal,
-                            centerStartPos,blockStartPos[q],surround,WebRtcIlbcfix_kEnhWt[2*hl-q]);
+      WebRtcIlbcfix_Refiner(blockStartPos + q, idata, idatal, centerStartPos,
+                            blockStartPos[q], surround,
+                            WebRtcIlbcfix_kEnhWt[2 * hl - q]);
 
-    }
-    else {
+    } else {
       /* Don't add anything since this sequence would
          be outside the buffer */
     }
   }
 }