Update audio code to use size_t more correctly, webrtc/common_audio/ portion.

webrtc/common_audio/vad/vad_filterbank.c

 /*
  *  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 20 matching lines @@
 static const int16_t kOffsetVector[6] = { 368, 368, 272, 176, 176, 176 };
 
 // High pass filtering, with a cut-off frequency at 80 Hz, if the |data_in| is
 // sampled at 500 Hz.
 //
 // - data_in      [i]   : Input audio data sampled at 500 Hz.
 // - data_length  [i]   : Length of input and output data.
 // - filter_state [i/o] : State of the filter.
 // - data_out     [o]   : Output audio data in the frequency interval
 //                        80 - 250 Hz.
-static void HighPassFilter(const int16_t* data_in, int data_length,
+static void HighPassFilter(const int16_t* data_in, size_t data_length,
                            int16_t* filter_state, int16_t* data_out) {
-  int i;
+  size_t i;
   const int16_t* in_ptr = data_in;
   int16_t* out_ptr = data_out;
   int32_t tmp32 = 0;
 
 
   // The sum of the absolute values of the impulse response:
   // The zero/pole-filter has a max amplification of a single sample of: 1.4546
   // Impulse response: 0.4047 -0.6179 -0.0266  0.1993  0.1035  -0.0194
   // The all-zero section has a max amplification of a single sample of: 1.6189
   // Impulse response: 0.4047 -0.8094  0.4047  0       0        0
@@ skipping 19 matching lines @@
 
 // All pass filtering of |data_in|, used before splitting the signal into two
 // frequency bands (low pass vs high pass).
 // Note that |data_in| and |data_out| can NOT correspond to the same address.
 //
 // - data_in            [i]   : Input audio signal given in Q0.
 // - data_length        [i]   : Length of input and output data.
 // - filter_coefficient [i]   : Given in Q15.
 // - filter_state       [i/o] : State of the filter given in Q(-1).
 // - data_out           [o]   : Output audio signal given in Q(-1).
-static void AllPassFilter(const int16_t* data_in, int data_length,
+static void AllPassFilter(const int16_t* data_in, size_t data_length,
                           int16_t filter_coefficient, int16_t* filter_state,
                           int16_t* data_out) {
   // The filter can only cause overflow (in the w16 output variable)
   // if more than 4 consecutive input numbers are of maximum value and
   // has the the same sign as the impulse responses first taps.
   // First 6 taps of the impulse response:
   // 0.6399 0.5905 -0.3779 0.2418 -0.1547 0.0990
 
-  int i;
+  size_t i;
   int16_t tmp16 = 0;
   int32_t tmp32 = 0;
   int32_t state32 = ((int32_t) (*filter_state) << 16);  // Q15
 
   for (i = 0; i < data_length; i++) {
     tmp32 = state32 + filter_coefficient * *data_in;
     tmp16 = (int16_t) (tmp32 >> 16);  // Q(-1)
     *data_out++ = tmp16;
     state32 = (*data_in << 14) - filter_coefficient * tmp16;  // Q14
     state32 <<= 1;  // Q15.
     data_in += 2;
   }
 
   *filter_state = (int16_t) (state32 >> 16);  // Q(-1)
 }
 
 // Splits |data_in| into |hp_data_out| and |lp_data_out| corresponding to
 // an upper (high pass) part and a lower (low pass) part respectively.
 //
 // - data_in      [i]   : Input audio data to be split into two frequency bands.
 // - data_length  [i]   : Length of |data_in|.
 // - upper_state  [i/o] : State of the upper filter, given in Q(-1).
 // - lower_state  [i/o] : State of the lower filter, given in Q(-1).
 // - hp_data_out  [o]   : Output audio data of the upper half of the spectrum.
 //                        The length is |data_length| / 2.
 // - lp_data_out  [o]   : Output audio data of the lower half of the spectrum.
 //                        The length is |data_length| / 2.
-static void SplitFilter(const int16_t* data_in, int data_length,
+static void SplitFilter(const int16_t* data_in, size_t data_length,
                         int16_t* upper_state, int16_t* lower_state,
                         int16_t* hp_data_out, int16_t* lp_data_out) {
-  int i;
-  int half_length = data_length >> 1;  // Downsampling by 2.
+  size_t i;
+  size_t half_length = data_length >> 1;  // Downsampling by 2.
   int16_t tmp_out;
 
   // All-pass filtering upper branch.
   AllPassFilter(&data_in[0], half_length, kAllPassCoefsQ15[0], upper_state,
                 hp_data_out);
 
   // All-pass filtering lower branch.
   AllPassFilter(&data_in[1], half_length, kAllPassCoefsQ15[1], lower_state,
                 lp_data_out);
 
   // Make LP and HP signals.
   for (i = 0; i < half_length; i++) {
     tmp_out = *hp_data_out;
     *hp_data_out++ -= *lp_data_out;
     *lp_data_out++ += tmp_out;
   }
 }
 
 // Calculates the energy of |data_in| in dB, and also updates an overall
 // |total_energy| if necessary.
 //
 // - data_in      [i]   : Input audio data for energy calculation.
 // - data_length  [i]   : Length of input data.
 // - offset       [i]   : Offset value added to |log_energy|.
 // - total_energy [i/o] : An external energy updated with the energy of
 //                        |data_in|.
 //                        NOTE: |total_energy| is only updated if
 //                        |total_energy| <= |kMinEnergy|.
 // - log_energy   [o]   : 10 * log10("energy of |data_in|") given in Q4.
-static void LogOfEnergy(const int16_t* data_in, int data_length,
+static void LogOfEnergy(const int16_t* data_in, size_t data_length,
                         int16_t offset, int16_t* total_energy,
                         int16_t* log_energy) {
   // |tot_rshifts| accumulates the number of right shifts performed on |energy|.
   int tot_rshifts = 0;
   // The |energy| will be normalized to 15 bits. We use unsigned integer because
   // we eventually will mask out the fractional part.
   uint32_t energy = 0;
 
   assert(data_in != NULL);
   assert(data_length > 0);
@@ skipping 71 matching lines @@
       // By construction |energy| is represented by 15 bits, hence any number of
       // right shifted |energy| will fit in an int16_t. In addition, adding the
       // value to |total_energy| is wrap around safe as long as
       // |kMinEnergy| < 8192.
       *total_energy += (int16_t) (energy >> -tot_rshifts);  // Q0.
     }
   }
 }
 
 int16_t WebRtcVad_CalculateFeatures(VadInstT* self, const int16_t* data_in,
-                                    int data_length, int16_t* features) {
+                                    size_t data_length, int16_t* features) {
   int16_t total_energy = 0;
   // We expect |data_length| to be 80, 160 or 240 samples, which corresponds to
   // 10, 20 or 30 ms in 8 kHz. Therefore, the intermediate downsampled data will
   // have at most 120 samples after the first split and at most 60 samples after
   // the second split.
   int16_t hp_120[120], lp_120[120];
   int16_t hp_60[60], lp_60[60];
-  const int half_data_length = data_length >> 1;
-  int length = half_data_length;  // |data_length| / 2, corresponds to
-                                  // bandwidth = 2000 Hz after downsampling.
+  const size_t half_data_length = data_length >> 1;
+  size_t length = half_data_length;  // |data_length| / 2, corresponds to
+                                     // bandwidth = 2000 Hz after downsampling.
 
   // Initialize variables for the first SplitFilter().
   int frequency_band = 0;
   const int16_t* in_ptr = data_in;  // [0 - 4000] Hz.
   int16_t* hp_out_ptr = hp_120;  // [2000 - 4000] Hz.
   int16_t* lp_out_ptr = lp_120;  // [0 - 2000] Hz.
 
-  assert(data_length >= 0);
   assert(data_length <= 240);
   assert(4 < kNumChannels - 1);  // Checking maximum |frequency_band|.
 
   // Split at 2000 Hz and downsample.
   SplitFilter(in_ptr, data_length, &self->upper_state[frequency_band],
               &self->lower_state[frequency_band], hp_out_ptr, lp_out_ptr);
 
   // For the upper band (2000 Hz - 4000 Hz) split at 3000 Hz and downsample.
   frequency_band = 1;
   in_ptr = hp_120;  // [2000 - 4000] Hz.
@@ skipping 48 matching lines @@
   LogOfEnergy(hp_60, length, kOffsetVector[1], &total_energy, &features[1]);
 
   // Remove 0 Hz - 80 Hz, by high pass filtering the lower band.
   HighPassFilter(lp_60, length, self->hp_filter_state, hp_120);
 
   // Energy in 80 Hz - 250 Hz.
   LogOfEnergy(hp_120, length, kOffsetVector[0], &total_energy, &features[0]);
 
   return total_energy;
 }