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

webrtc/modules/audio_processing/ns/nsx_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 50 matching lines @@
   188, 189, 190, 191, 192, 192, 193, 194, 195, 196, 197, 198, 198, 199, 200,
   201, 202, 203, 203, 204, 205, 206, 207, 208, 208, 209, 210, 211, 212, 212,
   213, 214, 215, 216, 216, 217, 218, 219, 220, 220, 221, 222, 223, 224, 224,
   225, 226, 227, 228, 228, 229, 230, 231, 231, 232, 233, 234, 234, 235, 236,
   237, 238, 238, 239, 240, 241, 241, 242, 243, 244, 244, 245, 246, 247, 247,
   248, 249, 249, 250, 251, 252, 252, 253, 254, 255, 255
 };
 #endif  // WEBRTC_DETECT_NEON || WEBRTC_HAS_NEON
 
 // Skip first frequency bins during estimation. (0 <= value < 64)
-static const int kStartBand = 5;
+static const size_t kStartBand = 5;
 
 // hybrib Hanning & flat window
 static const int16_t kBlocks80w128x[128] = {
   0,    536,   1072,   1606,   2139,   2669,   3196,   3720,   4240,   4756,   5266,
   5771,   6270,   6762,   7246,   7723,   8192,   8652,   9102,   9543,   9974,  10394,
   10803,  11200,  11585,  11958,  12318,  12665,  12998,  13318,  13623,  13913,  14189,
   14449,  14694,  14924,  15137,  15334,  15515,  15679,  15826,  15956,  16069,  16165,
   16244,  16305,  16349,  16375,  16384,  16384,  16384,  16384,  16384,  16384,  16384,
   16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,
   16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,  16384,
@@ skipping 217 matching lines @@
   355,    330
 };
 
 // Update the noise estimation information.
 static void UpdateNoiseEstimate(NoiseSuppressionFixedC* inst, int offset) {
   int32_t tmp32no1 = 0;
   int32_t tmp32no2 = 0;
   int16_t tmp16 = 0;
   const int16_t kExp2Const = 11819; // Q13
 
-  int i = 0;
+  size_t i = 0;
 
   tmp16 = WebRtcSpl_MaxValueW16(inst->noiseEstLogQuantile + offset,
                                    inst->magnLen);
   // Guarantee a Q-domain as high as possible and still fit in int16
   inst->qNoise = 14 - (int) WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(
                    kExp2Const, tmp16, 21);
   for (i = 0; i < inst->magnLen; i++) {
     // inst->quantile[i]=exp(inst->lquantile[offset+i]);
     // in Q21
     tmp32no2 = kExp2Const * inst->noiseEstLogQuantile[offset + i];
@@ skipping 14 matching lines @@
 static void NoiseEstimationC(NoiseSuppressionFixedC* inst,
                              uint16_t* magn,
                              uint32_t* noise,
                              int16_t* q_noise) {
   int16_t lmagn[HALF_ANAL_BLOCKL], counter, countDiv;
   int16_t countProd, delta, zeros, frac;
   int16_t log2, tabind, logval, tmp16, tmp16no1, tmp16no2;
   const int16_t log2_const = 22713; // Q15
   const int16_t width_factor = 21845;
 
-  int i, s, offset;
+  size_t i, s, offset;
 
   tabind = inst->stages - inst->normData;
   assert(tabind < 9);
   assert(tabind > -9);
   if (tabind < 0) {
     logval = -WebRtcNsx_kLogTable[-tabind];
   } else {
     logval = WebRtcNsx_kLogTable[tabind];
   }
 
@@ skipping 92 matching lines @@
   }
 
   for (i = 0; i < inst->magnLen; i++) {
     noise[i] = (uint32_t)(inst->noiseEstQuantile[i]); // Q(qNoise)
   }
   (*q_noise) = (int16_t)inst->qNoise;
 }
 
 // Filter the data in the frequency domain, and create spectrum.
 static void PrepareSpectrumC(NoiseSuppressionFixedC* inst, int16_t* freq_buf) {
-  int i = 0, j = 0;
+  size_t i = 0, j = 0;
 
   for (i = 0; i < inst->magnLen; i++) {
     inst->real[i] = (int16_t)((inst->real[i] *
         (int16_t)(inst->noiseSupFilter[i])) >> 14);  // Q(normData-stages)
     inst->imag[i] = (int16_t)((inst->imag[i] *
         (int16_t)(inst->noiseSupFilter[i])) >> 14);  // Q(normData-stages)
   }
 
   freq_buf[0] = inst->real[0];
   freq_buf[1] = -inst->imag[0];
   for (i = 1, j = 2; i < inst->anaLen2; i += 1, j += 2) {
     freq_buf[j] = inst->real[i];
     freq_buf[j + 1] = -inst->imag[i];
   }
   freq_buf[inst->anaLen] = inst->real[inst->anaLen2];
   freq_buf[inst->anaLen + 1] = -inst->imag[inst->anaLen2];
 }
 
 // Denormalize the real-valued signal |in|, the output from inverse FFT.
 static void DenormalizeC(NoiseSuppressionFixedC* inst,
                          int16_t* in,
                          int factor) {
-  int i = 0;
+  size_t i = 0;
   int32_t tmp32 = 0;
   for (i = 0; i < inst->anaLen; i += 1) {
     tmp32 = WEBRTC_SPL_SHIFT_W32((int32_t)in[i],
                                  factor - inst->normData);
     inst->real[i] = WebRtcSpl_SatW32ToW16(tmp32); // Q0
   }
 }
 
 // For the noise supression process, synthesis, read out fully processed
 // segment, and update synthesis buffer.
 static void SynthesisUpdateC(NoiseSuppressionFixedC* inst,
                              int16_t* out_frame,
                              int16_t gain_factor) {
-  int i = 0;
+  size_t i = 0;
   int16_t tmp16a = 0;
   int16_t tmp16b = 0;
   int32_t tmp32 = 0;
 
   // synthesis
   for (i = 0; i < inst->anaLen; i++) {
     tmp16a = (int16_t)WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(
                  inst->window[i], inst->real[i], 14); // Q0, window in Q14
     tmp32 = WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(tmp16a, gain_factor, 13); // Q0
     // Down shift with rounding
@@ skipping 11 matching lines @@
   memcpy(inst->synthesisBuffer, inst->synthesisBuffer + inst->blockLen10ms,
       (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->synthesisBuffer));
   WebRtcSpl_ZerosArrayW16(inst->synthesisBuffer
       + inst->anaLen - inst->blockLen10ms, inst->blockLen10ms);
 }
 
 // Update analysis buffer for lower band, and window data before FFT.
 static void AnalysisUpdateC(NoiseSuppressionFixedC* inst,
                             int16_t* out,
                             int16_t* new_speech) {
-  int i = 0;
+  size_t i = 0;
 
   // For lower band update analysis buffer.
   memcpy(inst->analysisBuffer, inst->analysisBuffer + inst->blockLen10ms,
       (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->analysisBuffer));
   memcpy(inst->analysisBuffer + inst->anaLen - inst->blockLen10ms, new_speech,
       inst->blockLen10ms * sizeof(*inst->analysisBuffer));
 
   // Window data before FFT.
   for (i = 0; i < inst->anaLen; i++) {
     out[i] = (int16_t)WEBRTC_SPL_MUL_16_16_RSFT_WITH_ROUND(
                inst->window[i], inst->analysisBuffer[i], 14); // Q0
   }
 }
 
 // Normalize the real-valued signal |in|, the input to forward FFT.
 static void NormalizeRealBufferC(NoiseSuppressionFixedC* inst,
                                  const int16_t* in,
                                  int16_t* out) {
-  int i = 0;
+  size_t i = 0;
   assert(inst->normData >= 0);
   for (i = 0; i < inst->anaLen; ++i) {
     out[i] = in[i] << inst->normData;  // Q(normData)
   }
 }
 
 // Declare function pointers.
 NoiseEstimation WebRtcNsx_NoiseEstimation;
 PrepareSpectrum WebRtcNsx_PrepareSpectrum;
 SynthesisUpdate WebRtcNsx_SynthesisUpdate;
@@ skipping 463 matching lines @@
 void WebRtcNsx_ComputeSpectralFlatness(NoiseSuppressionFixedC* inst,
                                        uint16_t* magn) {
   uint32_t tmpU32;
   uint32_t avgSpectralFlatnessNum, avgSpectralFlatnessDen;
 
   int32_t tmp32;
   int32_t currentSpectralFlatness, logCurSpectralFlatness;
 
   int16_t zeros, frac, intPart;
 
-  int i;
+  size_t i;
 
   // for flatness
   avgSpectralFlatnessNum = 0;
   avgSpectralFlatnessDen = inst->sumMagn - (uint32_t)magn[0]; // Q(normData-stages)
 
   // compute log of ratio of the geometric to arithmetic mean: check for log(0) case
   // flatness = exp( sum(log(magn[i]))/N - log(sum(magn[i])/N) )
   //          = exp( sum(log(magn[i]))/N ) * N / sum(magn[i])
   //          = 2^( sum(log2(magn[i]))/N - (log2(sum(magn[i])) - log2(N)) ) [This is used]
   for (i = 1; i < inst->magnLen; i++) {
@@ skipping 52 matching lines @@
 
   uint32_t tmpU32no1, tmpU32no2;
   uint32_t varMagnUFX, varPauseUFX, avgDiffNormMagnUFX;
 
   int32_t tmp32no1, tmp32no2;
   int32_t avgPauseFX, avgMagnFX, covMagnPauseFX;
   int32_t maxPause, minPause;
 
   int16_t tmp16no1;
 
-  int i, norm32, nShifts;
+  size_t i;
+  int norm32, nShifts;
 
   avgPauseFX = 0;
   maxPause = 0;
   minPause = inst->avgMagnPause[0]; // Q(prevQMagn)
   // compute average quantities
   for (i = 0; i < inst->magnLen; i++) {
     // Compute mean of magn_pause
     avgPauseFX += inst->avgMagnPause[i]; // in Q(prevQMagn)
     maxPause = WEBRTC_SPL_MAX(maxPause, inst->avgMagnPause[i]);
     minPause = WEBRTC_SPL_MIN(minPause, inst->avgMagnPause[i]);
@@ skipping 78 matching lines @@
   uint16_t  sum_log_magn_u16 = 0;
   uint16_t  tmp_u16 = 0;
 
   int16_t   sum_log_i = 0;
   int16_t   sum_log_i_square = 0;
   int16_t   frac = 0;
   int16_t   log2 = 0;
   int16_t   matrix_determinant = 0;
   int16_t   maxWinData;
 
-  int i, j;
+  size_t i, j;
   int zeros;
   int net_norm = 0;
   int right_shifts_in_magnU16 = 0;
   int right_shifts_in_initMagnEst = 0;
 
   int16_t winData_buff[ANAL_BLOCKL_MAX * 2 + 16];
   int16_t realImag_buff[ANAL_BLOCKL_MAX * 2 + 16];
 
   // Align the structures to 32-byte boundary for the FFT function.
   int16_t* winData = (int16_t*) (((uintptr_t)winData_buff + 31) & ~31);
@@ skipping 211 matching lines @@
   int16_t rfft_out_buff[ANAL_BLOCKL_MAX * 2 + 16];
 
   // Align the structures to 32-byte boundary for the FFT function.
   int16_t* realImag = (int16_t*) (((uintptr_t)realImag_buff + 31) & ~31);
   int16_t* rfft_out = (int16_t*) (((uintptr_t) rfft_out_buff + 31) & ~31);
 
   int16_t tmp16no1, tmp16no2;
   int16_t energyRatio;
   int16_t gainFactor, gainFactor1, gainFactor2;
 
-  int i;
+  size_t i;
   int outCIFFT;
   int scaleEnergyOut = 0;
 
   if (inst->zeroInputSignal) {
     // synthesize the special case of zero input
     // read out fully processed segment
     for (i = 0; i < inst->blockLen10ms; i++) {
       outFrame[i] = inst->synthesisBuffer[i]; // Q0
     }
     // update synthesis buffer
@@ skipping 80 matching lines @@
   uint16_t magnU16[HALF_ANAL_BLOCKL];
   uint16_t prevNoiseU16[HALF_ANAL_BLOCKL];
   uint16_t nonSpeechProbFinal[HALF_ANAL_BLOCKL];
   uint16_t gammaNoise, prevGammaNoise;
   uint16_t noiseSupFilterTmp[HALF_ANAL_BLOCKL];
 
   int16_t qMagn, qNoise;
   int16_t avgProbSpeechHB, gainModHB, avgFilterGainHB, gainTimeDomainHB;
   int16_t pink_noise_exp_avg = 0;
 
-  int i, j;
+  size_t i, j;
   int nShifts, postShifts;
   int norm32no1, norm32no2;
   int flag, sign;
   int q_domain_to_use = 0;
 
   // Code for ARMv7-Neon platform assumes the following:
   assert(inst->anaLen > 0);
   assert(inst->anaLen2 > 0);
   assert(inst->anaLen % 16 == 0);
   assert(inst->anaLen2 % 8 == 0);
   assert(inst->blockLen10ms > 0);
   assert(inst->blockLen10ms % 16 == 0);
   assert(inst->magnLen == inst->anaLen2 + 1);
 
 #ifdef NS_FILEDEBUG
   if (fwrite(spframe, sizeof(short),
              inst->blockLen10ms, inst->infile) != inst->blockLen10ms) {
     assert(false);
   }
 #endif
 
   // Check that initialization has been done
   assert(inst->initFlag == 1);
   assert((num_bands - 1) <= NUM_HIGH_BANDS_MAX);
 
   const short* const* speechFrameHB = NULL;
   short* 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;
+    num_high_bands = (size_t)(num_bands - 1);
   }
 
   // Store speechFrame and transform to frequency domain
   WebRtcNsx_DataAnalysis(inst, (short*)speechFrame[0], magnU16);
 
   if (inst->zeroInputSignal) {
     WebRtcNsx_DataSynthesis(inst, outFrame[0]);
 
     if (num_bands > 1) {
       // update analysis buffer for H band
@@ skipping 525 matching lines @@
 
     //apply gain
     for (i = 0; i < num_high_bands; ++i) {
       for (j = 0; j < inst->blockLen10ms; j++) {
         outFrameHB[i][j] = (int16_t)((gainTimeDomainHB *
             inst->dataBufHBFX[i][j]) >> 14);  // Q0
       }
     }
   }  // end of H band gain computation
 }