Convert some more things to size_t.

webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c

Index: webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c
diff --git a/webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c b/webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c
index b6cc2406831952e7395b1cdb8d102318a2963da9..f1294d8d80e243c99e680cc3d71fe65bf5209fc6 100644
--- a/webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c
+++ b/webrtc/modules/audio_coding/codecs/ilbc/nearest_neighbor.c
@@ -18,29 +18,16 @@
 
 #include "defines.h"
 
-/*----------------------------------------------------------------*
- * Find index in array such that the array element with said
- * index is the element of said array closest to "value"
- * according to the squared-error criterion
- *---------------------------------------------------------------*/
-
-void WebRtcIlbcfix_NearestNeighbor(
-    int16_t *index, /* (o) index of array element closest to value */
-    int16_t *array, /* (i) data array (Q2) */
-    int16_t value, /* (i) value (Q2) */
-    size_t arlength /* (i) dimension of data array (==8) */
-                                   ){
-  size_t i;
-  int16_t diff;
-  /* Stack based */
-  int32_t crit[8];
-
-  /* Calculate square distance */
-  for(i=0;i<arlength;i++){
-    diff=array[i]-value;
-    crit[i] = diff * diff;
+void WebRtcIlbcfix_NearestNeighbor(size_t* index,
+                                   const size_t* array,
+                                   size_t value,
+                                   size_t arlength) {
+  size_t min_diff = static_cast<size_t>(-1);

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

I changed this implementation for a couple of reasons.

First, the old implementation was based on doing signed subtractions and then
squaring to get a positive value.  That doesn't really work with size_ts, so I
would have had to insert a lot of different casts, and it still would only work
if the input values happened to be close enough to the desired value for the
result to fit in an int32_t.  (They always are, but why make this function
depend on that external condition?)

Second, and more importantly, the code assumed (arlength == ENH_NBLOCKS_TOT (==
8)), and would potentially buffer-overflow otherwise.  This seems very unsafe,
and if it's really desirable, why pass in |arlength| at all?  Why not just
hardcode this -- and the calling code, in similar places -- to use this
constant?

Third, the old code seemed needlessly convoluted.  Why calculate the squared
error just to be able to use WebRtcSpl_MinIndexW32() to do the index selection?

The new code is simpler, safer, and more like what a reader would expect.  It
seems at a glance like it might be slower -- all those branches inside the loop!
-- but I'm not convinced it is; after all, MinIndexW32 has to do something very
similar, so things aren't as dissimilar as they appear, and we're losing a
multiplication besides.  In any case, since there are only 8 elements in the
array, I doubt the resulting speed difference is going to be important anywhere.

+  for (size_t i = 0; i < arlength; i++) {
+    size_t diff = (array[i] < value) ? (value - array[i]) : (array[i] - value);

[hlundin-webrtc, 2015/08/28 06:48:18]

Nit: const size_t diff

+    if (diff < min_diff) {
+      *index = i;
+      min_diff = diff;
+    }
   }
-
-  /* Find the minimum square distance */
-  *index=WebRtcSpl_MinIndexW32(crit, arlength);
 }