Update a ton of audio code to use size_t more correctly and in general reduce

webrtc/modules/audio_processing/ns/ns_core.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 199 matching lines @@
   WebRtcNs_set_policy_core(self, 0);
 
   self->initFlag = 1;
   return 0;
 }
 
 // Estimate noise.
 static void NoiseEstimation(NoiseSuppressionC* self,
                             float* magn,
                             float* noise) {
-  int i, s, offset;
+  size_t i, s, offset;
   float lmagn[HALF_ANAL_BLOCKL], delta;
 
   if (self->updates < END_STARTUP_LONG) {
     self->updates++;
   }
 
   for (i = 0; i < self->magnLen; i++) {
     lmagn[i] = (float)log(magn[i]);
   }
 
@@ skipping 284 matching lines @@
       }
     }
   }  // End of flag == 1.
 }
 
 // Compute spectral flatness on input spectrum.
 // |magnIn| is the magnitude spectrum.
 // Spectral flatness is returned in self->featureData[0].
 static void ComputeSpectralFlatness(NoiseSuppressionC* self,
                                     const float* magnIn) {
-  int i;
-  int shiftLP = 1;  // Option to remove first bin(s) from spectral measures.
+  size_t i;
+  size_t shiftLP = 1;  // Option to remove first bin(s) from spectral measures.
   float avgSpectralFlatnessNum, avgSpectralFlatnessDen, spectralTmp;
 
   // Compute spectral measures.
   // For flatness.
   avgSpectralFlatnessNum = 0.0;
   avgSpectralFlatnessDen = self->sumMagn;
   for (i = 0; i < shiftLP; i++) {
     avgSpectralFlatnessDen -= magnIn[i];
   }
   // Compute log of ratio of the geometric to arithmetic mean: check for log(0)
@@ skipping 24 matching lines @@
 //   * |magn| is the signal magnitude spectrum estimate.
 //   * |noise| is the magnitude noise spectrum estimate.
 // Outputs:
 //   * |snrLocPrior| is the computed prior SNR.
 //   * |snrLocPost| is the computed post SNR.
 static void ComputeSnr(const NoiseSuppressionC* self,
                        const float* magn,
                        const float* noise,
                        float* snrLocPrior,
                        float* snrLocPost) {
-  int i;
+  size_t i;
 
   for (i = 0; i < self->magnLen; i++) {
     // Previous post SNR.
     // Previous estimate: based on previous frame with gain filter.
     float previousEstimateStsa = self->magnPrevAnalyze[i] /
         (self->noisePrev[i] + 0.0001f) * self->smooth[i];
     // Post SNR.
     snrLocPost[i] = 0.f;
     if (magn[i] > noise[i]) {
       snrLocPost[i] = magn[i] / (noise[i] + 0.0001f) - 1.f;
     }
     // DD estimate is sum of two terms: current estimate and previous estimate.
     // Directed decision update of snrPrior.
     snrLocPrior[i] =
         DD_PR_SNR * previousEstimateStsa + (1.f - DD_PR_SNR) * snrLocPost[i];
   }  // End of loop over frequencies.
 }
 
 // Compute the difference measure between input spectrum and a template/learned
 // noise spectrum.
 // |magnIn| is the input spectrum.
 // The reference/template spectrum is self->magnAvgPause[i].
 // Returns (normalized) spectral difference in self->featureData[4].
 static void ComputeSpectralDifference(NoiseSuppressionC* self,
                                       const float* magnIn) {
   // avgDiffNormMagn = var(magnIn) - cov(magnIn, magnAvgPause)^2 /
   // var(magnAvgPause)
-  int i;
+  size_t i;
   float avgPause, avgMagn, covMagnPause, varPause, varMagn, avgDiffNormMagn;
 
   avgPause = 0.0;
   avgMagn = self->sumMagn;
   // Compute average quantities.
   for (i = 0; i < self->magnLen; i++) {
     // Conservative smooth noise spectrum from pause frames.
     avgPause += self->magnAvgPause[i];
   }
   avgPause /= self->magnLen;
@@ skipping 26 matching lines @@
 // Compute speech/noise probability.
 // Speech/noise probability is returned in |probSpeechFinal|.
 // |magn| is the input magnitude spectrum.
 // |noise| is the noise spectrum.
 // |snrLocPrior| is the prior SNR for each frequency.
 // |snrLocPost| is the post SNR for each frequency.
 static void SpeechNoiseProb(NoiseSuppressionC* self,
                             float* probSpeechFinal,
                             const float* snrLocPrior,
                             const float* snrLocPost) {
-  int i, sgnMap;
+  size_t i;
+  int sgnMap;
   float invLrt, gainPrior, indPrior;
   float logLrtTimeAvgKsum, besselTmp;
   float indicator0, indicator1, indicator2;
   float tmpFloat1, tmpFloat2;
   float weightIndPrior0, weightIndPrior1, weightIndPrior2;
   float threshPrior0, threshPrior1, threshPrior2;
   float widthPrior, widthPrior0, widthPrior1, widthPrior2;
 
   widthPrior0 = WIDTH_PR_MAP;
   // Width for pause region: lower range, so increase width in tanh map.
@@ skipping 138 matching lines @@
 //   * |magn| is the signal magnitude spectrum estimate.
 //   * |snrLocPrior| is the prior SNR.
 //   * |snrLocPost| is the post SNR.
 // Output:
 //   * |noise| is the updated noise magnitude spectrum estimate.
 static void UpdateNoiseEstimate(NoiseSuppressionC* self,
                                 const float* magn,
                                 const float* snrLocPrior,
                                 const float* snrLocPost,
                                 float* noise) {
-  int i;
+  size_t i;
   float probSpeech, probNonSpeech;
   // Time-avg parameter for noise update.
   float gammaNoiseTmp = NOISE_UPDATE;
   float gammaNoiseOld;
   float noiseUpdateTmp;
 
   for (i = 0; i < self->magnLen; i++) {
     probSpeech = self->speechProb[i];
     probNonSpeech = 1.f - probSpeech;
     // Temporary noise update:
@@ skipping 30 matching lines @@
 }
 
 // Updates |buffer| with a new |frame|.
 // Inputs:
 //   * |frame| is a new speech frame or NULL for setting to zero.
 //   * |frame_length| is the length of the new frame.
 //   * |buffer_length| is the length of the buffer.
 // Output:
 //   * |buffer| is the updated buffer.
 static void UpdateBuffer(const float* frame,
-                         int frame_length,
-                         int buffer_length,
+                         size_t frame_length,
+                         size_t buffer_length,
                          float* buffer) {
   assert(buffer_length < 2 * frame_length);
 
   memcpy(buffer,
          buffer + frame_length,
          sizeof(*buffer) * (buffer_length - frame_length));
   if (frame) {
     memcpy(buffer + buffer_length - frame_length,
            frame,
            sizeof(*buffer) * frame_length);
@@ skipping 10 matching lines @@
 //   * |time_data_length| is the length of the analysis buffer.
 //   * |magnitude_length| is the length of the spectrum magnitude, which equals
 //     the length of both |real| and |imag| (time_data_length / 2 + 1).
 // Outputs:
 //   * |time_data| is the signal in the frequency domain.
 //   * |real| is the real part of the frequency domain.
 //   * |imag| is the imaginary part of the frequency domain.
 //   * |magn| is the calculated signal magnitude in the frequency domain.
 static void FFT(NoiseSuppressionC* self,
                 float* time_data,
-                int time_data_length,
-                int magnitude_length,
+                size_t time_data_length,
+                size_t magnitude_length,
                 float* real,
                 float* imag,
                 float* magn) {
-  int i;
+  size_t i;
 
   assert(magnitude_length == time_data_length / 2 + 1);
 
   WebRtc_rdft(time_data_length, 1, time_data, self->ip, self->wfft);
 
   imag[0] = 0;
   real[0] = time_data[0];
   magn[0] = fabsf(real[0]) + 1.f;
   imag[magnitude_length - 1] = 0;
   real[magnitude_length - 1] = time_data[1];
@@ skipping 12 matching lines @@
 //   * |imag| is the imaginary part of the frequency domain.
 //   * |magnitude_length| is the length of the spectrum magnitude, which equals
 //     the length of both |real| and |imag|.
 //   * |time_data_length| is the length of the analysis buffer
 //     (2 * (magnitude_length - 1)).
 // Output:
 //   * |time_data| is the signal in the time domain.
 static void IFFT(NoiseSuppressionC* self,
                  const float* real,
                  const float* imag,
-                 int magnitude_length,
-                 int time_data_length,
+                 size_t magnitude_length,
+                 size_t time_data_length,
                  float* time_data) {
-  int i;
+  size_t i;
 
   assert(time_data_length == 2 * (magnitude_length - 1));
 
   time_data[0] = real[0];
   time_data[1] = real[magnitude_length - 1];
   for (i = 1; i < magnitude_length - 1; ++i) {
     time_data[2 * i] = real[i];
     time_data[2 * i + 1] = imag[i];
   }
   WebRtc_rdft(time_data_length, -1, time_data, self->ip, self->wfft);
 
   for (i = 0; i < time_data_length; ++i) {
     time_data[i] *= 2.f / time_data_length;  // FFT scaling.
   }
 }
 
 // Calculates the energy of a buffer.
 // Inputs:
 //   * |buffer| is the buffer over which the energy is calculated.
 //   * |length| is the length of the buffer.
 // Returns the calculated energy.
-static float Energy(const float* buffer, int length) {
-  int i;
+static float Energy(const float* buffer, size_t length) {
+  size_t i;
   float energy = 0.f;
 
   for (i = 0; i < length; ++i) {
     energy += buffer[i] * buffer[i];
   }
 
   return energy;
 }
 
 // Windows a buffer.
 // Inputs:
 //   * |window| is the window by which to multiply.
 //   * |data| is the data without windowing.
 //   * |length| is the length of the window and data.
 // Output:
 //   * |data_windowed| is the windowed data.
 static void Windowing(const float* window,
                       const float* data,
-                      int length,
+                      size_t length,
                       float* data_windowed) {
-  int i;
+  size_t i;
 
   for (i = 0; i < length; ++i) {
     data_windowed[i] = window[i] * data[i];
   }
 }
 
 // Estimate prior SNR decision-directed and compute DD based Wiener Filter.
 // Input:
 //   * |magn| is the signal magnitude spectrum estimate.
 // Output:
 //   * |theFilter| is the frequency response of the computed Wiener filter.
 static void ComputeDdBasedWienerFilter(const NoiseSuppressionC* self,
                                        const float* magn,
                                        float* theFilter) {
-  int i;
+  size_t i;
   float snrPrior, previousEstimateStsa, currentEstimateStsa;
 
   for (i = 0; i < self->magnLen; i++) {
     // Previous estimate: based on previous frame with gain filter.
     previousEstimateStsa = self->magnPrevProcess[i] /
                            (self->noisePrev[i] + 0.0001f) * self->smooth[i];
     // Post and prior SNR.
     currentEstimateStsa = 0.f;
     if (magn[i] > self->noise[i]) {
       currentEstimateStsa = magn[i] / (self->noise[i] + 0.0001f) - 1.f;
@@ skipping 35 matching lines @@
   } else if (mode == 3) {
     // self->overdrive = 1.3f;
     self->overdrive = 1.25f;
     self->denoiseBound = 0.09f;
     self->gainmap = 1;
   }
   return 0;
 }
 
 void WebRtcNs_AnalyzeCore(NoiseSuppressionC* self, const float* speechFrame) {
-  int i;
-  const int kStartBand = 5;  // Skip first frequency bins during estimation.
+  size_t i;
+  const size_t kStartBand = 5;  // Skip first frequency bins during estimation.
   int updateParsFlag;
   float energy;
   float signalEnergy = 0.f;
   float sumMagn = 0.f;
   float tmpFloat1, tmpFloat2, tmpFloat3;
   float winData[ANAL_BLOCKL_MAX];
   float magn[HALF_ANAL_BLOCKL], noise[HALF_ANAL_BLOCKL];
   float snrLocPost[HALF_ANAL_BLOCKL], snrLocPrior[HALF_ANAL_BLOCKL];
   float real[ANAL_BLOCKL_MAX], imag[HALF_ANAL_BLOCKL];
   // Variables during startup.
@@ skipping 119 matching lines @@
   SpeechNoiseProb(self, self->speechProb, snrLocPrior, snrLocPost);
   UpdateNoiseEstimate(self, magn, snrLocPrior, snrLocPost, noise);
 
   // Keep track of noise spectrum for next frame.
   memcpy(self->noise, noise, sizeof(*noise) * self->magnLen);
   memcpy(self->magnPrevAnalyze, magn, sizeof(*magn) * self->magnLen);
 }
 
 void WebRtcNs_ProcessCore(NoiseSuppressionC* self,
                           const float* const* speechFrame,
-                          int num_bands,
+                          size_t num_bands,
                           float* const* outFrame) {
   // Main routine for noise reduction.
   int flagHB = 0;
-  int i, j;
+  size_t i, j;
 
   float energy1, energy2, gain, factor, factor1, factor2;
   float fout[BLOCKL_MAX];
   float winData[ANAL_BLOCKL_MAX];
   float magn[HALF_ANAL_BLOCKL];
   float theFilter[HALF_ANAL_BLOCKL], theFilterTmp[HALF_ANAL_BLOCKL];
   float real[ANAL_BLOCKL_MAX], imag[HALF_ANAL_BLOCKL];
 
   // SWB variables.
   int deltaBweHB = 1;
   int deltaGainHB = 1;
   float decayBweHB = 1.0;
   float gainMapParHB = 1.0;
   float gainTimeDomainHB = 1.0;
   float avgProbSpeechHB, avgProbSpeechHBTmp, avgFilterGainHB, gainModHB;
   float sumMagnAnalyze, sumMagnProcess;
 
   // Check that initiation has been done.
   assert(self->initFlag == 1);
   assert((num_bands - 1) <= NUM_HIGH_BANDS_MAX);
 
   const float* const* speechFrameHB = NULL;
   float* const* outFrameHB = NULL;
-  int num_high_bands = 0;
+  size_t num_high_bands = 0;
   if (num_bands > 1) {
     speechFrameHB = &speechFrame[1];
     outFrameHB = &outFrame[1];
     num_high_bands = num_bands - 1;
     flagHB = 1;
     // Range for averaging low band quantities for H band gain.
     deltaBweHB = (int)self->magnLen / 4;
     deltaGainHB = deltaBweHB;
   }
 
@@ skipping 182 matching lines @@
     for (i = 0; i < num_high_bands; ++i) {
       for (j = 0; j < self->blockLen; j++) {
         outFrameHB[i][j] =
             WEBRTC_SPL_SAT(WEBRTC_SPL_WORD16_MAX,
                            gainTimeDomainHB * self->dataBufHB[i][j],
                            WEBRTC_SPL_WORD16_MIN);
       }
     }
   }  // End of H band gain computation.
 }