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

webrtc/modules/audio_processing/ns/nsx_core_neon.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/nsx_core.h"
 
 #include <arm_neon.h>
-#include <assert.h>
+
+#include "webrtc/base/checks.h"
 
 // Constants to compensate for shifting signal log(2^shifts).
 const int16_t WebRtcNsx_kLogTable[9] = {
   0, 177, 355, 532, 710, 887, 1065, 1242, 1420
 };
 
 const int16_t WebRtcNsx_kCounterDiv[201] = {
   32767, 16384, 10923, 8192, 6554, 5461, 4681, 4096, 3641, 3277, 2979, 2731,
   2521, 2341, 2185, 2048, 1928, 1820, 1725, 1638, 1560, 1489, 1425, 1365, 1311,
   1260, 1214, 1170, 1130, 1092, 1057, 1024, 993, 964, 936, 910, 886, 862, 840,
@@ skipping 112 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;
   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];
   }
 
   int16x8_t logval_16x8 = vdupq_n_s16(logval);
 
   // 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);
-      assert(frac < 256);
+      RTC_DCHECK_LT(frac, 256);
       // log2(magn(i))
       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;
     }
   }
 
   int16x4_t Q3_16x4  = vdup_n_s16(3);
   int16x8_t WIDTHQ8_16x8 = vdupq_n_s16(WIDTH_Q8);
   int16x8_t WIDTHFACTOR_16x8 = vdupq_n_s16(width_factor);
 
   int16_t factor = FACTOR_Q7;
   if (inst->blockIndex < END_STARTUP_LONG)
     factor = FACTOR_Q7_STARTUP;
 
   // 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(...)
     int16_t deltaBuff[8];
     int16x4_t tmp16x4_0;
     int16x4_t tmp16x4_1;
     int16x4_t countDiv_16x4 = vdup_n_s16(countDiv);
     int16x8_t countProd_16x8 = vdupq_n_s16(countProd);
     int16x8_t tmp16x8_0 = vdupq_n_s16(countDiv);
@@ skipping 143 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.
 void WebRtcNsx_PrepareSpectrumNeon(NoiseSuppressionFixedC* inst,
                                    int16_t* freq_buf) {
-  assert(inst->magnLen % 8 == 1);
-  assert(inst->anaLen2 % 16 == 0);
+  RTC_DCHECK_EQ(1, inst->magnLen % 8);
+  RTC_DCHECK_EQ(0, inst->anaLen2 % 16);
 
   // (1) Filtering.
 
   // Fixed point C code for the next block is as follows:
   // 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)
   // }
@@ skipping 69 matching lines @@
   }
   freq_buf[inst->anaLen] = inst->real[inst->anaLen2];
   freq_buf[inst->anaLen + 1] = -inst->imag[inst->anaLen2];
 }
 
 // For the noise supress process, synthesis, read out fully processed segment,
 // and update synthesis buffer.
 void WebRtcNsx_SynthesisUpdateNeon(NoiseSuppressionFixedC* inst,
                                    int16_t* out_frame,
                                    int16_t gain_factor) {
-  assert(inst->anaLen % 16 == 0);
-  assert(inst->blockLen10ms % 16 == 0);
+  RTC_DCHECK_EQ(0, inst->anaLen % 16);
+  RTC_DCHECK_EQ(0, inst->blockLen10ms % 16);
 
   int16_t* preal_start = inst->real;
   const int16_t* pwindow = inst->window;
   int16_t* preal_end = preal_start + inst->anaLen;
   int16_t* psynthesis_buffer = inst->synthesisBuffer;
 
   while (preal_start < preal_end) {
     // Loop unroll.
     int16x8_t window_0 = vld1q_s16(pwindow);
     int16x8_t real_0 = vld1q_s16(preal_start);
@@ skipping 70 matching lines @@
   int16x8_t zero = vdupq_n_s16(0);
   for (;p_start < p_end; p_start += 8) {
     vst1q_s16(p_start, zero);
   }
 }
 
 // Update analysis buffer for lower band, and window data before FFT.
 void WebRtcNsx_AnalysisUpdateNeon(NoiseSuppressionFixedC* inst,
                                   int16_t* out,
                                   int16_t* new_speech) {
-  assert(inst->blockLen10ms % 16 == 0);
-  assert(inst->anaLen % 16 == 0);
+  RTC_DCHECK_EQ(0, inst->blockLen10ms % 16);
+  RTC_DCHECK_EQ(0, inst->anaLen % 16);
 
   // For lower band update analysis buffer.
   // memcpy(inst->analysisBuffer, inst->analysisBuffer + inst->blockLen10ms,
   //     (inst->anaLen - inst->blockLen10ms) * sizeof(*inst->analysisBuffer));
   int16_t* p_start_src = inst->analysisBuffer + inst->blockLen10ms;
   int16_t* p_end_src = inst->analysisBuffer + inst->anaLen;
   int16_t* p_start_dst = inst->analysisBuffer;
   while (p_start_src < p_end_src) {
     int16x8_t frame = vld1q_s16(p_start_src);
     vst1q_s16(p_start_dst, frame);
@@ skipping 44 matching lines @@
     p_start_out += 8;
   }
   int32x4_t tmp32_low = vmull_s16(vget_low_s16(window), vget_low_s16(buffer));
   int32x4_t tmp32_high = vmull_s16(vget_high_s16(window),
                                    vget_high_s16(buffer));
 
   int16x4_t result_low = vrshrn_n_s32(tmp32_low, 14);
   int16x4_t result_high = vrshrn_n_s32(tmp32_high, 14);
   vst1q_s16(p_start_out, vcombine_s16(result_low, result_high));
 }