Replace calls to assert() with RTC_DCHECK_*() in .c code

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.
  */
 
 #include "webrtc/modules/audio_processing/ns/noise_suppression_x.h"
 
-#include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/common_audio/signal_processing/include/real_fft.h"
 #include "webrtc/modules/audio_processing/ns/nsx_core.h"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 
 #if defined(WEBRTC_HAS_NEON)
 /* Tables are defined in ARM assembly files. */
 extern const int16_t WebRtcNsx_kLogTable[9];
 extern const int16_t WebRtcNsx_kCounterDiv[201];
 extern const int16_t WebRtcNsx_kLogTableFrac[256];
 #else
@@ skipping 309 matching lines @@
                              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;
 
   size_t i, s, offset;
 
   tabind = inst->stages - inst->normData;
-  assert(tabind < 9);
-  assert(tabind > -9);
+  RTC_DCHECK_LT(tabind, 9);
+  RTC_DCHECK_GT(tabind, -9);
   if (tabind < 0) {
     logval = -WebRtcNsx_kLogTable[-tabind];
   } else {
     logval = WebRtcNsx_kLogTable[tabind];
   }
 
   // lmagn(i)=log(magn(i))=log(2)*log2(magn(i))
   // magn is in Q(-stages), and the real lmagn values are:
   // real_lmagn(i)=log(magn(i)*2^stages)=log(magn(i))+log(2^stages)
   // lmagn in Q8
   for (i = 0; i < inst->magnLen; i++) {
     if (magn[i]) {
       zeros = WebRtcSpl_NormU32((uint32_t)magn[i]);
       frac = (int16_t)((((uint32_t)magn[i] << zeros)
                               & 0x7FFFFFFF) >> 23);
       // log2(magn(i))
-      assert(frac < 256);
+      RTC_DCHECK_LT(frac, 256);
       log2 = (int16_t)(((31 - zeros) << 8)
                              + WebRtcNsx_kLogTableFrac[frac]);
       // log2(magn(i))*log(2)
       lmagn[i] = (int16_t)((log2 * log2_const) >> 15);
       // + log(2^stages)
       lmagn[i] += logval;
     } else {
       lmagn[i] = logval;//0;
     }
   }
 
   // loop over simultaneous estimates
   for (s = 0; s < SIMULT; s++) {
     offset = s * inst->magnLen;
 
     // Get counter values from state
     counter = inst->noiseEstCounter[s];
-    assert(counter < 201);
+    RTC_DCHECK_LT(counter, 201);
     countDiv = WebRtcNsx_kCounterDiv[counter];
     countProd = (int16_t)(counter * countDiv);
 
     // quant_est(...)
     for (i = 0; i < inst->magnLen; i++) {
       // compute delta
       if (inst->noiseEstDensity[offset + i] > 512) {
         // Get the value for delta by shifting intead of dividing.
         int factor = WebRtcSpl_NormW16(inst->noiseEstDensity[offset + i]);
         delta = (int16_t)(FACTOR_Q16 >> (14 - factor));
@@ skipping 142 matching lines @@
     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) {
   size_t i = 0;
-  assert(inst->normData >= 0);
+  RTC_DCHECK_GE(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;
 AnalysisUpdate WebRtcNsx_AnalysisUpdate;
@@ skipping 30 matching lines @@
                                            uint32_t* noise_estimate,
                                            uint32_t* noise_estimate_avg) {
   int32_t tmp32no1 = 0;
   int32_t tmp32no2 = 0;
 
   int16_t int_part = 0;
   int16_t frac_part = 0;
 
   // Use pink noise estimate
   // noise_estimate = 2^(pinkNoiseNumerator + pinkNoiseExp * log2(j))
-  assert(freq_index >= 0);
-  assert(freq_index < 129);
+  RTC_DCHECK_GE(freq_index, 0);
+  RTC_DCHECK_LT(freq_index, 129);
   tmp32no2 = (pink_noise_exp_avg * kLogIndex[freq_index]) >> 15;  // Q11
   tmp32no1 = pink_noise_num_avg - tmp32no2; // Q11
 
   // Calculate output: 2^tmp32no1
   // Output in Q(minNorm-stages)
   tmp32no1 += (inst->minNorm - inst->stages) << 11;
   if (tmp32no1 > 0) {
     int_part = (int16_t)(tmp32no1 >> 11);
     frac_part = (int16_t)(tmp32no1 & 0x000007ff); // Q11
     // Piecewise linear approximation of 'b' in
@@ skipping 422 matching lines @@
   // 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++) {
     // First bin is excluded from spectrum measures. Number of bins is now a power of 2
     if (magn[i]) {
       zeros = WebRtcSpl_NormU32((uint32_t)magn[i]);
       frac = (int16_t)(((uint32_t)((uint32_t)(magn[i]) << zeros)
                               & 0x7FFFFFFF) >> 23);
       // log2(magn(i))
-      assert(frac < 256);
+      RTC_DCHECK_LT(frac, 256);
       tmpU32 = (uint32_t)(((31 - zeros) << 8)
                                 + WebRtcNsx_kLogTableFrac[frac]); // Q8
       avgSpectralFlatnessNum += tmpU32; // Q8
     } else {
       //if at least one frequency component is zero, treat separately
       tmpU32 = WEBRTC_SPL_UMUL_32_16(inst->featureSpecFlat, SPECT_FLAT_TAVG_Q14); // Q24
       inst->featureSpecFlat -= tmpU32 >> 14;  // Q10
       return;
     }
   }
   //ratio and inverse log: check for case of log(0)
   zeros = WebRtcSpl_NormU32(avgSpectralFlatnessDen);
   frac = (int16_t)(((avgSpectralFlatnessDen << zeros) & 0x7FFFFFFF) >> 23);
   // log2(avgSpectralFlatnessDen)
-  assert(frac < 256);
+  RTC_DCHECK_LT(frac, 256);
   tmp32 = (int32_t)(((31 - zeros) << 8) + WebRtcNsx_kLogTableFrac[frac]); // Q8
   logCurSpectralFlatness = (int32_t)avgSpectralFlatnessNum;
   logCurSpectralFlatness += ((int32_t)(inst->stages - 1) << (inst->stages + 7)); // Q(8+stages-1)
   logCurSpectralFlatness -= (tmp32 << (inst->stages - 1));
   logCurSpectralFlatness <<= (10 - inst->stages);  // Q17
   tmp32 = (int32_t)(0x00020000 | (WEBRTC_SPL_ABS_W32(logCurSpectralFlatness)
                                         & 0x0001FFFF)); //Q17
   intPart = 7 - (logCurSpectralFlatness >> 17);  // Add 7 for output in Q10.
   if (intPart > 0) {
     currentSpectralFlatness = tmp32 >> intPart;
@@ skipping 212 matching lines @@
     inst->initMagnEst[inst->anaLen2] +=
         magnU16[inst->anaLen2] >> right_shifts_in_magnU16;
 
     log2 = 0;
     if (magnU16[inst->anaLen2]) {
       // Calculate log2(magnU16[inst->anaLen2])
       zeros = WebRtcSpl_NormU32((uint32_t)magnU16[inst->anaLen2]);
       frac = (int16_t)((((uint32_t)magnU16[inst->anaLen2] << zeros) &
                               0x7FFFFFFF) >> 23); // Q8
       // log2(magnU16(i)) in Q8
-      assert(frac < 256);
+      RTC_DCHECK_LT(frac, 256);
       log2 = (int16_t)(((31 - zeros) << 8) + WebRtcNsx_kLogTableFrac[frac]);
     }
 
     sum_log_magn = (int32_t)log2; // Q8
     // sum_log_i_log_magn in Q17
     sum_log_i_log_magn = (kLogIndex[inst->anaLen2] * log2) >> 3;
 
     for (i = 1, j = 2; i < inst->anaLen2; i += 1, j += 2) {
       inst->real[i] = winData[j];
       inst->imag[i] = -winData[j + 1];
@@ skipping 13 matching lines @@
       inst->initMagnEst[i] += magnU16[i] >> right_shifts_in_magnU16;
 
       if (i >= kStartBand) {
         // For pink noise estimation. Collect data neglecting lower frequency band
         log2 = 0;
         if (magnU16[i]) {
           zeros = WebRtcSpl_NormU32((uint32_t)magnU16[i]);
           frac = (int16_t)((((uint32_t)magnU16[i] << zeros) &
                                   0x7FFFFFFF) >> 23);
           // log2(magnU16(i)) in Q8
-          assert(frac < 256);
+          RTC_DCHECK_LT(frac, 256);
           log2 = (int16_t)(((31 - zeros) << 8)
                                  + WebRtcNsx_kLogTableFrac[frac]);
         }
         sum_log_magn += (int32_t)log2; // Q8
         // sum_log_i_log_magn in Q17
         sum_log_i_log_magn += (kLogIndex[i] * log2) >> 3;
       }
     }
 
     //
     //compute simplified noise model during startup
     //
 
     // Estimate White noise
 
     // Switch whiteNoiseLevel to Q(minNorm-stages)
     inst->whiteNoiseLevel >>= right_shifts_in_initMagnEst;
 
     // Update the average magnitude spectrum, used as noise estimate.
     tmpU32no1 = WEBRTC_SPL_UMUL_32_16(inst->sumMagn, inst->overdrive);
     tmpU32no1 >>= inst->stages + 8;
 
     // Replacing division above with 'stages' shifts
     // Shift to same Q-domain as whiteNoiseLevel
     tmpU32no1 >>= right_shifts_in_magnU16;
     // This operation is safe from wrap around as long as END_STARTUP_SHORT < 128
-    assert(END_STARTUP_SHORT < 128);
+    RTC_DCHECK_LT(END_STARTUP_SHORT, 128);
     inst->whiteNoiseLevel += tmpU32no1; // Q(minNorm-stages)
 
     // Estimate Pink noise parameters
     // Denominator used in both parameter estimates.
     // The value is only dependent on the size of the frequency band (kStartBand)
     // and to reduce computational complexity stored in a table (kDeterminantEstMatrix[])
-    assert(kStartBand < 66);
+    RTC_DCHECK_LT(kStartBand, 66);
     matrix_determinant = kDeterminantEstMatrix[kStartBand]; // Q0
     sum_log_i = kSumLogIndex[kStartBand]; // Q5
     sum_log_i_square = kSumSquareLogIndex[kStartBand]; // Q2
     if (inst->fs == 8000) {
       // Adjust values to shorter blocks in narrow band.
       tmp_1_w32 = (int32_t)matrix_determinant;
       tmp_1_w32 += (kSumLogIndex[65] * sum_log_i) >> 9;
       tmp_1_w32 -= (kSumLogIndex[65] * kSumLogIndex[65]) >> 10;
       tmp_1_w32 -= (int32_t)sum_log_i_square << 4;
       tmp_1_w32 -= ((inst->magnLen - kStartBand) * kSumSquareLogIndex[65]) >> 2;
@@ skipping 94 matching lines @@
     if (scaleEnergyOut == 0 && !(energyOut & 0x7f800000)) {
       energyOut = WEBRTC_SPL_SHIFT_W32(energyOut, 8 + scaleEnergyOut
                                        - inst->scaleEnergyIn);
     } else {
       // |energyIn| is currently in Q(|scaleEnergyIn|), but to later on end up
       // with an |energyRatio| in Q8 we need to change the Q-domain to
       // Q(-8-scaleEnergyOut).
       inst->energyIn >>= 8 + scaleEnergyOut - inst->scaleEnergyIn;
     }
 
-    assert(inst->energyIn > 0);
+    RTC_DCHECK_GT(inst->energyIn, 0);
     energyRatio = (energyOut + inst->energyIn / 2) / inst->energyIn;  // Q8
     // Limit the ratio to [0, 1] in Q8, i.e., [0, 256]
     energyRatio = WEBRTC_SPL_SAT(256, energyRatio, 0);
 
     // all done in lookup tables now
-    assert(energyRatio < 257);
+    RTC_DCHECK_LT(energyRatio, 257);
     gainFactor1 = kFactor1Table[energyRatio]; // Q8
     gainFactor2 = inst->factor2Table[energyRatio]; // Q8
 
     //combine both scales with speech/noise prob: note prior (priorSpeechProb) is not frequency dependent
 
     // factor = inst->priorSpeechProb*factor1 + (1.0-inst->priorSpeechProb)*factor2; // original code
     tmp16no1 = (int16_t)(((16384 - inst->priorNonSpeechProb) * gainFactor1) >>
         14);  // in Q13, where 16384 = Q14(1.0)
     tmp16no2 = (int16_t)((inst->priorNonSpeechProb * gainFactor2) >> 14);
     gainFactor = tmp16no1 + tmp16no2; // Q13
@@ skipping 38 matching lines @@
   int16_t avgProbSpeechHB, gainModHB, avgFilterGainHB, gainTimeDomainHB;
   int16_t pink_noise_exp_avg = 0;
 
   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);
+  RTC_DCHECK_GT(inst->anaLen, 0);
+  RTC_DCHECK_GT(inst->anaLen2, 0);
+  RTC_DCHECK_EQ(0, inst->anaLen % 16);
+  RTC_DCHECK_EQ(0, inst->anaLen2 % 8);
+  RTC_DCHECK_GT(inst->blockLen10ms, 0);
+  RTC_DCHECK_EQ(0, inst->blockLen10ms % 16);
+  RTC_DCHECK_EQ(inst->magnLen, inst->anaLen2 + 1);
 
 #ifdef NS_FILEDEBUG
   if (fwrite(spframe, sizeof(short),
              inst->blockLen10ms, inst->infile) != inst->blockLen10ms) {
-    assert(false);
+    RTC_DCHECK(false);
   }
 #endif
 
   // Check that initialization has been done
-  assert(inst->initFlag == 1);
-  assert((num_bands - 1) <= NUM_HIGH_BANDS_MAX);
+  RTC_DCHECK_EQ(1, inst->initFlag);
+  RTC_DCHECK_LE(num_bands - 1, NUM_HIGH_BANDS_MAX);
 
   const short* const* speechFrameHB = NULL;
   short* const* outFrameHB = NULL;
   size_t num_high_bands = 0;
   if (num_bands > 1) {
     speechFrameHB = &speechFrame[1];
     outFrameHB = &outFrame[1];
     num_high_bands = (size_t)(num_bands - 1);
   }
 
@@ skipping 417 matching lines @@
     //directed decision update of priorSnr
     // FLOAT
     // priorSnr = DD_PR_SNR * prevNearSnr + (1.0-DD_PR_SNR) * curNearSnr;
 
     tmpU32no1 = WEBRTC_SPL_UMUL_32_16(prevNearSnr[i], DD_PR_SNR_Q11); // Q22
     tmpU32no2 = WEBRTC_SPL_UMUL_32_16(curNearSnr, ONE_MINUS_DD_PR_SNR_Q11); // Q22
     priorSnr = tmpU32no1 + tmpU32no2; // Q22
 
     //gain filter
     tmpU32no1 = inst->overdrive + ((priorSnr + 8192) >> 14);  // Q8
-    assert(inst->overdrive > 0);
+    RTC_DCHECK_GT(inst->overdrive, 0);
     tmpU16no1 = (priorSnr + tmpU32no1 / 2) / tmpU32no1;  // Q14
     inst->noiseSupFilter[i] = WEBRTC_SPL_SAT(16384, tmpU16no1, inst->denoiseBound); // 16384 = Q14(1.0) // Q14
 
     // Weight in the parametric Wiener filter during startup
     if (inst->blockIndex < END_STARTUP_SHORT) {
       // Weight the two suppression filters
       tmpU32no1 = inst->noiseSupFilter[i] * inst->blockIndex;
       tmpU32no2 = noiseSupFilterTmp[i] *
           (END_STARTUP_SHORT - inst->blockIndex);
       tmpU32no1 += tmpU32no2;
@@ skipping 15 matching lines @@
     for (i = 0; i < inst->magnLen; i++) {
       inst->prevNoiseU32[i] = noiseU32[i] >> (5 - norm32no1);  // Q(qNoise+11)
       inst->prevMagnU16[i] = magnU16[i]; // Q(qMagn)
     }
   }
 
   WebRtcNsx_DataSynthesis(inst, outFrame[0]);
 #ifdef NS_FILEDEBUG
   if (fwrite(outframe, sizeof(short),
              inst->blockLen10ms, inst->outfile) != inst->blockLen10ms) {
-    assert(false);
+    RTC_DCHECK(false);
   }
 #endif
 
   //for H band:
   // only update data buffer, then apply time-domain gain is applied derived from L band
   if (num_bands > 1) {
     // update analysis buffer for H band
     // append new data to buffer FX
     for (i = 0; i < num_high_bands; ++i) {
       memcpy(inst->dataBufHBFX[i], inst->dataBufHBFX[i] + inst->blockLen10ms,
           (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->dataBufHBFX[i]));
       memcpy(inst->dataBufHBFX[i] + inst->anaLen - inst->blockLen10ms,
           speechFrameHB[i], inst->blockLen10ms * sizeof(*inst->dataBufHBFX[i]));
     }
     // range for averaging low band quantities for H band gain
 
     gainTimeDomainHB = 16384; // 16384 = Q14(1.0)
     //average speech prob from low band
     //average filter gain from low band
     //avg over second half (i.e., 4->8kHz) of freq. spectrum
     tmpU32no1 = 0; // Q12
     tmpU16no1 = 0; // Q8
     for (i = inst->anaLen2 - (inst->anaLen2 >> 2); i < inst->anaLen2; i++) {
       tmpU16no1 += nonSpeechProbFinal[i]; // Q8
       tmpU32no1 += (uint32_t)(inst->noiseSupFilter[i]); // Q14
     }
-    assert(inst->stages >= 7);
+    RTC_DCHECK_GE(inst->stages, 7);
     avgProbSpeechHB = (4096 - (tmpU16no1 >> (inst->stages - 7)));  // Q12
     avgFilterGainHB = (int16_t)(tmpU32no1 >> (inst->stages - 3));  // Q14
 
     // // original FLOAT code
     // // gain based on speech probability:
     // avg_prob_speech_tt=(float)2.0*avg_prob_speech-(float)1.0;
     // gain_mod=(float)0.5*((float)1.0+(float)tanh(avg_prob_speech_tt)); // between 0 and 1
 
     // gain based on speech probability:
     // original expression: "0.5 * (1 + tanh(2x-1))"
@@ skipping 32 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
 }