webrtc/modules/audio_processing: Use RTC_DCHECK() instead of assert()

webrtc/modules/audio_processing/aec/aec_core.cc

 /*
  *  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.
  */
 
 /*
  * The core AEC algorithm, which is presented with time-aligned signals.
  */
 
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
 
 #include <algorithm>
-#include <assert.h>
 #include <math.h>
 #include <stddef.h>  // size_t
 #include <stdlib.h>
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 extern "C" {
 #include "webrtc/common_audio/ring_buffer.h"
 }
 #include "webrtc/base/checks.h"
@@ skipping 784 matching lines @@
   freq_data[0][PART_LEN] = time_data[1];
   for (i = 1; i < PART_LEN; i++) {
     freq_data[0][i] = time_data[2 * i];
     freq_data[1][i] = time_data[2 * i + 1];
   }
 }
 
 static int SignalBasedDelayCorrection(AecCore* self) {
   int delay_correction = 0;
   int last_delay = -2;
-  assert(self != NULL);
+  RTC_DCHECK(self);
 #if !defined(WEBRTC_ANDROID)
   // On desktops, turn on correction after |kDelayCorrectionStart| frames.  This
   // is to let the delay estimation get a chance to converge.  Also, if the
   // playout audio volume is low (or even muted) the delay estimation can return
   // a very large delay, which will break the AEC if it is applied.
   if (self->frame_count < kDelayCorrectionStart) {
     self->data_dumper->DumpRaw("aec_da_reported_delay", 1, &last_delay);
     return 0;
   }
 #endif
@@ skipping 434 matching lines @@
   float output[PART_LEN];
   float outputH[NUM_HIGH_BANDS_MAX][PART_LEN];
   float* outputH_ptr[NUM_HIGH_BANDS_MAX];
   float* x_fft_ptr = NULL;
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     outputH_ptr[i] = outputH[i];
   }
 
   // We should always have at least one element stored in |far_buf|.
-  assert(WebRtc_available_read(aec->far_time_buf) > 0);
+  RTC_DCHECK_GT(WebRtc_available_read(aec->far_time_buf), 0u);
   WebRtc_ReadBuffer(aec->far_time_buf, reinterpret_cast<void**>(&farend_ptr),
                     farend, 1);
 
   aec->data_dumper->DumpWav("aec_far", PART_LEN, &farend_ptr[PART_LEN],
                             std::min(aec->sampFreq, 16000), 1);
   aec->data_dumper->DumpWav("aec_near", PART_LEN, &nearend_block[0][0],
                             std::min(aec->sampFreq, 16000), 1);
 
   if (aec->metricsMode == 1) {
     // Update power levels
@@ skipping 482 matching lines @@
   // first relies on delay input values from the user and the amount of
   // shifted buffer elements is controlled by |knownDelay|.  This delay will
   // give a guess on how much we need to shift far-end buffers to align with
   // the near-end signal.  The other delay estimation algorithm uses the
   // far- and near-end signals to find the offset between them.  This one
   // (called "signal delay") is then used to fine tune the alignment, or
   // simply compensate for errors in the system based one.
   // Note that the two algorithms operate independently.  Currently, we only
   // allow one algorithm to be turned on.
 
-  assert(aec->num_bands == num_bands);
+  RTC_DCHECK_EQ(aec->num_bands, num_bands);
 
   for (size_t j = 0; j < num_samples; j += FRAME_LEN) {
     // 1) At most we process |aec->mult|+1 partitions in 10 ms. Make sure we
     // have enough far-end data for that by stuffing the buffer if the
     // |system_delay| indicates others.
     if (aec->system_delay < FRAME_LEN) {
       // We don't have enough data so we rewind 10 ms.
       WebRtcAec_MoveFarReadPtr(aec, -(aec->mult + 1));
     }
 
@@ skipping 85 matching lines @@
     for (size_t i = 1; i < num_bands; ++i) {
       WebRtc_ReadBuffer(aec->outFrBufH[i - 1], NULL, &out[i][j], FRAME_LEN);
     }
   }
 }
 
 int WebRtcAec_GetDelayMetricsCore(AecCore* self,
                                   int* median,
                                   int* std,
                                   float* fraction_poor_delays) {
-  assert(self != NULL);
-  assert(median != NULL);
-  assert(std != NULL);
+  RTC_DCHECK(self);
+  RTC_DCHECK(median);
+  RTC_DCHECK(std);
 
   if (self->delay_logging_enabled == 0) {
     // Logging disabled.
     return -1;
   }
 
   if (self->delay_metrics_delivered == 0) {
     UpdateDelayMetrics(self);
     self->delay_metrics_delivered = 1;
   }
   *median = self->delay_median;
   *std = self->delay_std;
   *fraction_poor_delays = self->fraction_poor_delays;
 
   return 0;
 }
 
 int WebRtcAec_echo_state(AecCore* self) {
   return self->echoState;
 }
 
 void WebRtcAec_GetEchoStats(AecCore* self,
                             Stats* erl,
                             Stats* erle,
                             Stats* a_nlp,
                             float* divergent_filter_fraction) {
-  assert(erl != NULL);
-  assert(erle != NULL);
-  assert(a_nlp != NULL);
+  RTC_DCHECK(erl);
+  RTC_DCHECK(erle);
+  RTC_DCHECK(a_nlp);
   *erl = self->erl;
   *erle = self->erle;
   *a_nlp = self->aNlp;
   *divergent_filter_fraction =
       self->divergent_filter_fraction.GetLatestFraction();
 }
 
 void WebRtcAec_SetConfigCore(AecCore* self,
                              int nlp_mode,
                              int metrics_mode,
                              int delay_logging) {
-  assert(nlp_mode >= 0 && nlp_mode < 3);
+  RTC_DCHECK_GE(nlp_mode, 0);
+  RTC_DCHECK_LT(nlp_mode, 3);
   self->nlp_mode = nlp_mode;
   self->metricsMode = metrics_mode;
   if (self->metricsMode) {
     InitMetrics(self);
   }
   // Turn on delay logging if it is either set explicitly or if delay agnostic
   // AEC is enabled (which requires delay estimates).
   self->delay_logging_enabled = delay_logging || self->delay_agnostic_enabled;
   if (self->delay_logging_enabled) {
     memset(self->delay_histogram, 0, sizeof(self->delay_histogram));
   }
 }
 
 void WebRtcAec_enable_delay_agnostic(AecCore* self, int enable) {
   self->delay_agnostic_enabled = enable;
 }
 
 int WebRtcAec_delay_agnostic_enabled(AecCore* self) {
   return self->delay_agnostic_enabled;
 }
 
 void WebRtcAec_enable_aec3(AecCore* self, int enable) {
   self->aec3_enabled = (enable != 0);
 }
 
 int WebRtcAec_aec3_enabled(AecCore* self) {
-  assert(self->aec3_enabled == 0 || self->aec3_enabled == 1);
+  RTC_DCHECK(self->aec3_enabled == 0 || self->aec3_enabled == 1);
   return self->aec3_enabled;
 }
 
 void WebRtcAec_enable_refined_adaptive_filter(AecCore* self, bool enable) {
   self->refined_adaptive_filter_enabled = enable;
   SetAdaptiveFilterStepSize(self);
   SetErrorThreshold(self);
 }
 
 bool WebRtcAec_refined_adaptive_filter_enabled(const AecCore* self) {
@@ skipping 11 matching lines @@
 
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
-  assert(delay >= 0);
+  RTC_DCHECK_GE(delay, 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc