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

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.
  */
 
-#include <assert.h>
 #include <math.h>
 #include <string.h>
 #include <stdlib.h>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/common_audio/fft4g.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/ns/noise_suppression.h"
 #include "webrtc/modules/audio_processing/ns/ns_core.h"
 #include "webrtc/modules/audio_processing/ns/windows_private.h"
 
 // Set Feature Extraction Parameters.
 static void set_feature_extraction_parameters(NoiseSuppressionC* self) {
   // Bin size of histogram.
   self->featureExtractionParams.binSizeLrt = 0.1f;
@@ skipping 824 matching lines @@
 // 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,
                          size_t frame_length,
                          size_t buffer_length,
                          float* buffer) {
-  assert(buffer_length < 2 * frame_length);
+  RTC_DCHECK_LT(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);
   } else {
     memset(buffer + buffer_length - frame_length,
@@ skipping 15 matching lines @@
 //   * |magn| is the calculated signal magnitude in the frequency domain.
 static void FFT(NoiseSuppressionC* self,
                 float* time_data,
                 size_t time_data_length,
                 size_t magnitude_length,
                 float* real,
                 float* imag,
                 float* magn) {
   size_t i;
 
-  assert(magnitude_length == time_data_length / 2 + 1);
+  RTC_DCHECK_EQ(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];
   magn[magnitude_length - 1] = fabsf(real[magnitude_length - 1]) + 1.f;
   for (i = 1; i < magnitude_length - 1; ++i) {
@@ skipping 15 matching lines @@
 // Output:
 //   * |time_data| is the signal in the time domain.
 static void IFFT(NoiseSuppressionC* self,
                  const float* real,
                  const float* imag,
                  size_t magnitude_length,
                  size_t time_data_length,
                  float* time_data) {
   size_t i;
 
-  assert(time_data_length == 2 * (magnitude_length - 1));
+  RTC_DCHECK_EQ(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) {
@@ skipping 112 matching lines @@
   float real[ANAL_BLOCKL_MAX], imag[HALF_ANAL_BLOCKL];
   // Variables during startup.
   float sum_log_i = 0.0;
   float sum_log_i_square = 0.0;
   float sum_log_magn = 0.0;
   float sum_log_i_log_magn = 0.0;
   float parametric_exp = 0.0;
   float parametric_num = 0.0;
 
   // Check that initiation has been done.
-  assert(self->initFlag == 1);
+  RTC_DCHECK_EQ(1, self->initFlag);
   updateParsFlag = self->modelUpdatePars[0];
 
   // Update analysis buffer for L band.
   UpdateBuffer(speechFrame, self->blockLen, self->anaLen, self->analyzeBuf);
 
   Windowing(self->window, self->analyzeBuf, self->anaLen, winData);
   energy = Energy(winData, self->anaLen);
   if (energy == 0.0) {
     // We want to avoid updating statistics in this case:
     // Updating feature statistics when we have zeros only will cause
@@ skipping 123 matching lines @@
   // 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);
+  RTC_DCHECK_EQ(1, self->initFlag);
+  RTC_DCHECK_LE(num_bands - 1, NUM_HIGH_BANDS_MAX);
 
   const float* const* speechFrameHB = NULL;
   float* const* outFrameHB = NULL;
   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.
@@ skipping 186 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.
 }