Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/dsp_helper.cc

 /*
  *  Copyright (c) 2012 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 81 matching lines @@
   }
   int end_factor = 0;
   // Loop over the channels, starting at the same |factor| each time.
   for (size_t channel = 0; channel < signal->Channels(); ++channel) {
     end_factor =
         RampSignal(&(*signal)[channel][start_index], length, factor, increment);
   }
   return end_factor;
 }
 
-void DspHelper::PeakDetection(int16_t* data, int data_length,
-                              int num_peaks, int fs_mult,
-                              int* peak_index, int16_t* peak_value) {
-  int16_t min_index = 0;
-  int16_t max_index = 0;
+void DspHelper::PeakDetection(int16_t* data, size_t data_length,
+                              size_t num_peaks, int fs_mult,
+                              size_t* peak_index, int16_t* peak_value) {
+  size_t min_index = 0;
+  size_t max_index = 0;
 
-  for (int i = 0; i <= num_peaks - 1; i++) {
+  for (size_t i = 0; i <= num_peaks - 1; i++) {
     if (num_peaks == 1) {
       // Single peak.  The parabola fit assumes that an extra point is
       // available; worst case it gets a zero on the high end of the signal.
       // TODO(hlundin): This can potentially get much worse. It breaks the
       // API contract, that the length of |data| is |data_length|.
       data_length++;
     }
 
     peak_index[i] = WebRtcSpl_MaxIndexW16(data, data_length - 1);
 
@@ skipping 22 matching lines @@
     }
 
     if (i != num_peaks - 1) {
       memset(&data[min_index], 0,
              sizeof(data[0]) * (max_index - min_index + 1));
     }
   }
 }
 
 void DspHelper::ParabolicFit(int16_t* signal_points, int fs_mult,
-                             int* peak_index, int16_t* peak_value) {
+                             size_t* peak_index, int16_t* peak_value) {
   uint16_t fit_index[13];
   if (fs_mult == 1) {
     fit_index[0] = 0;
     fit_index[1] = 8;
     fit_index[2] = 16;
   } else if (fs_mult == 2) {
     fit_index[0] = 0;
     fit_index[1] = 4;
     fit_index[2] = 8;
     fit_index[3] = 12;
@@ skipping 66 matching lines @@
         flag++;
         lmt += stp;
       }
     }
   } else {
     *peak_value = signal_points[1];
     *peak_index = *peak_index * 2 * fs_mult;
   }
 }
 
-int DspHelper::MinDistortion(const int16_t* signal, int min_lag,
-                             int max_lag, int length,
-                             int32_t* distortion_value) {
-  int best_index = 0;
+size_t DspHelper::MinDistortion(const int16_t* signal, size_t min_lag,
+                                size_t max_lag, size_t length,
+                                int32_t* distortion_value) {
+  size_t best_index = 0;
   int32_t min_distortion = WEBRTC_SPL_WORD32_MAX;
-  for (int i = min_lag; i <= max_lag; i++) {
+  for (size_t i = min_lag; i <= max_lag; i++) {
     int32_t sum_diff = 0;
     const int16_t* data1 = signal;
     const int16_t* data2 = signal - i;
-    for (int j = 0; j < length; j++) {
+    for (size_t j = 0; j < length; j++) {
       sum_diff += WEBRTC_SPL_ABS_W32(data1[j] - data2[j]);
     }
     // Compare with previous minimum.
     if (sum_diff < min_distortion) {
       min_distortion = sum_diff;
       best_index = i;
     }
   }
   *distortion_value = min_distortion;
   return best_index;
@@ skipping 28 matching lines @@
 
 void DspHelper::MuteSignal(int16_t* signal, int mute_slope, size_t length) {
   int32_t factor = (16384 << 6) + 32;
   for (size_t i = 0; i < length; i++) {
     signal[i] = ((factor >> 6) * signal[i] + 8192) >> 14;
     factor -= mute_slope;
   }
 }
 
 int DspHelper::DownsampleTo4kHz(const int16_t* input, size_t input_length,
-                                int output_length, int input_rate_hz,
+                                size_t output_length, int input_rate_hz,
                                 bool compensate_delay, int16_t* output) {
   // Set filter parameters depending on input frequency.
   // NOTE: The phase delay values are wrong compared to the true phase delay
   // of the filters. However, the error is preserved (through the +1 term) for
   // consistency.
   const int16_t* filter_coefficients;  // Filter coefficients.
-  int16_t filter_length;  // Number of coefficients.
-  int16_t filter_delay;  // Phase delay in samples.
+  size_t filter_length;  // Number of coefficients.
+  size_t filter_delay;  // Phase delay in samples.
   int16_t factor;  // Conversion rate (inFsHz / 8000).
   switch (input_rate_hz) {
     case 8000: {
       filter_length = 3;
       factor = 2;
       filter_coefficients = kDownsample8kHzTbl;
       filter_delay = 1 + 1;
       break;
     }
     case 16000: {
@@ skipping 23 matching lines @@
     }
   }
 
   if (!compensate_delay) {
     // Disregard delay compensation.
     filter_delay = 0;
   }
 
   // Returns -1 if input signal is too short; 0 otherwise.
   return WebRtcSpl_DownsampleFast(
-      &input[filter_length - 1], static_cast<int>(input_length) -
-      (filter_length - 1), output, output_length, filter_coefficients,
-      filter_length, factor, filter_delay);
+      &input[filter_length - 1], input_length - filter_length + 1, output,
+      output_length, filter_coefficients, filter_length, factor, filter_delay);
 }
 
 }  // namespace webrtc