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

webrtc/modules/audio_processing/utility/delay_estimator_wrapper.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.
  */
 
 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
 
-#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/modules/audio_processing/utility/delay_estimator.h"
 #include "webrtc/modules/audio_processing/utility/delay_estimator_internal.h"
 
 // Only bit |kBandFirst| through bit |kBandLast| are processed and
 // |kBandFirst| - |kBandLast| must be < 32.
 enum { kBandFirst = 12 };
 enum { kBandLast = 43 };
 
 static __inline uint32_t SetBit(uint32_t in, int pos) {
   uint32_t mask = (1 << pos);
   uint32_t out = (in | mask);
 
   return out;
 }
 
 // Calculates the mean recursively. Same version as WebRtc_MeanEstimatorFix(),
 // but for float.
 //
 // Inputs:
 //    - new_value             : New additional value.
 //    - scale                 : Scale for smoothing (should be less than 1.0).
 //
 // Input/Output:
 //    - mean_value            : Pointer to the mean value for updating.
 //
 static void MeanEstimatorFloat(float new_value,
                                float scale,
                                float* mean_value) {
-  assert(scale < 1.0f);
+  RTC_DCHECK_LT(scale, 1.0f);
   *mean_value += (new_value - *mean_value) * scale;
 }
 
 // Computes the binary spectrum by comparing the input |spectrum| with a
 // |threshold_spectrum|. Float and fixed point versions.
 //
 // Inputs:
 //      - spectrum            : Spectrum of which the binary spectrum should be
 //                              calculated.
 //      - threshold_spectrum  : Threshold spectrum with which the input
 //                              spectrum is compared.
 // Return:
 //      - out                 : Binary spectrum.
 //
 static uint32_t BinarySpectrumFix(const uint16_t* spectrum,
                                   SpectrumType* threshold_spectrum,
                                   int q_domain,
                                   int* threshold_initialized) {
   int i = kBandFirst;
   uint32_t out = 0;
 
-  assert(q_domain < 16);
+  RTC_DCHECK_LT(q_domain, 16);
 
   if (!(*threshold_initialized)) {
     // Set the |threshold_spectrum| to half the input |spectrum| as starting
     // value. This speeds up the convergence.
     for (i = kBandFirst; i <= kBandLast; i++) {
       if (spectrum[i] > 0) {
         // Convert input spectrum from Q(|q_domain|) to Q15.
         int32_t spectrum_q15 = ((int32_t) spectrum[i]) << (15 - q_domain);
         threshold_spectrum[i].int32_ = (spectrum_q15 >> 1);
         *threshold_initialized = 1;
@@ skipping 109 matching lines @@
   memset(self->mean_far_spectrum, 0,
          sizeof(SpectrumType) * self->spectrum_size);
   // Reset initialization indicators.
   self->far_spectrum_initialized = 0;
 
   return 0;
 }
 
 void WebRtc_SoftResetDelayEstimatorFarend(void* handle, int delay_shift) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
-  assert(self != NULL);
+  RTC_DCHECK(self);
   WebRtc_SoftResetBinaryDelayEstimatorFarend(self->binary_farend, delay_shift);
 }
 
 int WebRtc_AddFarSpectrumFix(void* handle,
                              const uint16_t* far_spectrum,
                              int spectrum_size,
                              int far_q) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
   uint32_t binary_spectrum = 0;
 
@@ skipping 109 matching lines @@
   memset(self->mean_near_spectrum, 0,
          sizeof(SpectrumType) * self->spectrum_size);
   // Reset initialization indicators.
   self->near_spectrum_initialized = 0;
 
   return 0;
 }
 
 int WebRtc_SoftResetDelayEstimator(void* handle, int delay_shift) {
   DelayEstimator* self = (DelayEstimator*) handle;
-  assert(self != NULL);
+  RTC_DCHECK(self);
   return WebRtc_SoftResetBinaryDelayEstimator(self->binary_handle, delay_shift);
 }
 
 int WebRtc_set_history_size(void* handle, int history_size) {
   DelayEstimator* self = static_cast<DelayEstimator*>(handle);
 
   if ((self == NULL) || (history_size <= 1)) {
     return -1;
   }
   return WebRtc_AllocateHistoryBufferMemory(self->binary_handle, history_size);
 }
 
 int WebRtc_history_size(const void* handle) {
   const DelayEstimator* self = static_cast<const DelayEstimator*>(handle);
 
   if (self == NULL) {
     return -1;
   }
   if (self->binary_handle->farend->history_size !=
       self->binary_handle->history_size) {
     // Non matching history sizes.
     return -1;
   }
   return self->binary_handle->history_size;
 }
 
 int WebRtc_set_lookahead(void* handle, int lookahead) {
   DelayEstimator* self = (DelayEstimator*) handle;
-  assert(self != NULL);
-  assert(self->binary_handle != NULL);
+  RTC_DCHECK(self);
+  RTC_DCHECK(self->binary_handle);
   if ((lookahead > self->binary_handle->near_history_size - 1) ||
       (lookahead < 0)) {
     return -1;
   }
   self->binary_handle->lookahead = lookahead;
   return self->binary_handle->lookahead;
 }
 
 int WebRtc_lookahead(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
-  assert(self != NULL);
-  assert(self->binary_handle != NULL);
+  RTC_DCHECK(self);
+  RTC_DCHECK(self->binary_handle);
   return self->binary_handle->lookahead;
 }
 
 int WebRtc_set_allowed_offset(void* handle, int allowed_offset) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
   if ((self == NULL) || (allowed_offset < 0)) {
     return -1;
   }
   self->binary_handle->allowed_offset = allowed_offset;
@@ skipping 11 matching lines @@
 
 int WebRtc_enable_robust_validation(void* handle, int enable) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
   if (self == NULL) {
     return -1;
   }
   if ((enable < 0) || (enable > 1)) {
     return -1;
   }
-  assert(self->binary_handle != NULL);
+  RTC_DCHECK(self->binary_handle);
   self->binary_handle->robust_validation_enabled = enable;
   return 0;
 }
 
 int WebRtc_is_robust_validation_enabled(const void* handle) {
   const DelayEstimator* self = (const DelayEstimator*) handle;
 
   if (self == NULL) {
     return -1;
   }
@@ skipping 62 matching lines @@
 
   if (self == NULL) {
     return -1;
   }
 
   return WebRtc_binary_last_delay(self->binary_handle);
 }
 
 float WebRtc_last_delay_quality(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
-  assert(self != NULL);
+  RTC_DCHECK(self);
   return WebRtc_binary_last_delay_quality(self->binary_handle);
 }