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

webrtc/modules/audio_processing/utility/delay_estimator.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.h"
 
-#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <algorithm>
 
+#include "webrtc/base/checks.h"
+
 // Number of right shifts for scaling is linearly depending on number of bits in
 // the far-end binary spectrum.
 static const int kShiftsAtZero = 13;  // Right shifts at zero binary spectrum.
 static const int kShiftsLinearSlope = 3;
 
 static const int32_t kProbabilityOffset = 1024;  // 2 in Q9.
 static const int32_t kProbabilityLowerLimit = 8704;  // 17 in Q9.
 static const int32_t kProbabilityMinSpread = 2816;  // 5.5 in Q9.
 
 // Robust validation settings
@@ skipping 64 matching lines @@
 static void UpdateRobustValidationStatistics(BinaryDelayEstimator* self,
                                              int candidate_delay,
                                              int32_t valley_depth_q14,
                                              int32_t valley_level_q14) {
   const float valley_depth = valley_depth_q14 * kQ14Scaling;
   float decrease_in_last_set = valley_depth;
   const int max_hits_for_slow_change = (candidate_delay < self->last_delay) ?
       kMaxHitsWhenPossiblyNonCausal : kMaxHitsWhenPossiblyCausal;
   int i = 0;
 
-  assert(self->history_size == self->farend->history_size);
+  RTC_DCHECK_EQ(self->history_size, self->farend->history_size);
   // Reset |candidate_hits| if we have a new candidate.
   if (candidate_delay != self->last_candidate_delay) {
     self->candidate_hits = 0;
     self->last_candidate_delay = candidate_delay;
   }
   self->candidate_hits++;
 
   // The |histogram| is updated differently across the bins.
   // 1. The |candidate_delay| histogram bin is increased with the
   //    |valley_depth|, which is a simple measure of how reliable the
@@ skipping 176 matching lines @@
   self->far_bit_counts = NULL;
   if (WebRtc_AllocateFarendBufferMemory(self, history_size) == 0) {
     WebRtc_FreeBinaryDelayEstimatorFarend(self);
     self = NULL;
   }
   return self;
 }
 
 int WebRtc_AllocateFarendBufferMemory(BinaryDelayEstimatorFarend* self,
                                       int history_size) {
-  assert(self != NULL);
+  RTC_DCHECK(self);
   // (Re-)Allocate memory for history buffers.
   self->binary_far_history = static_cast<uint32_t*>(
       realloc(self->binary_far_history,
               history_size * sizeof(*self->binary_far_history)));
   self->far_bit_counts = static_cast<int*>(
       realloc(self->far_bit_counts,
               history_size * sizeof(*self->far_bit_counts)));
   if ((self->binary_far_history == NULL) || (self->far_bit_counts == NULL)) {
     history_size = 0;
   }
   // Fill with zeros if we have expanded the buffers.
   if (history_size > self->history_size) {
     int size_diff = history_size - self->history_size;
     memset(&self->binary_far_history[self->history_size],
            0,
            sizeof(*self->binary_far_history) * size_diff);
     memset(&self->far_bit_counts[self->history_size],
            0,
            sizeof(*self->far_bit_counts) * size_diff);
   }
   self->history_size = history_size;
 
   return self->history_size;
 }
 
 void WebRtc_InitBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self) {
-  assert(self != NULL);
+  RTC_DCHECK(self);
   memset(self->binary_far_history, 0, sizeof(uint32_t) * self->history_size);
   memset(self->far_bit_counts, 0, sizeof(int) * self->history_size);
 }
 
 void WebRtc_SoftResetBinaryDelayEstimatorFarend(
     BinaryDelayEstimatorFarend* self, int delay_shift) {
   int abs_shift = abs(delay_shift);
   int shift_size = 0;
   int dest_index = 0;
   int src_index = 0;
   int padding_index = 0;
 
-  assert(self != NULL);
+  RTC_DCHECK(self);
   shift_size = self->history_size - abs_shift;
-  assert(shift_size > 0);
+  RTC_DCHECK_GT(shift_size, 0);
   if (delay_shift == 0) {
     return;
   } else if (delay_shift > 0) {
     dest_index = abs_shift;
   } else if (delay_shift < 0) {
     src_index = abs_shift;
     padding_index = shift_size;
   }
 
   // Shift and zero pad buffers.
   memmove(&self->binary_far_history[dest_index],
           &self->binary_far_history[src_index],
           sizeof(*self->binary_far_history) * shift_size);
   memset(&self->binary_far_history[padding_index], 0,
          sizeof(*self->binary_far_history) * abs_shift);
   memmove(&self->far_bit_counts[dest_index],
           &self->far_bit_counts[src_index],
           sizeof(*self->far_bit_counts) * shift_size);
   memset(&self->far_bit_counts[padding_index], 0,
          sizeof(*self->far_bit_counts) * abs_shift);
 }
 
 void WebRtc_AddBinaryFarSpectrum(BinaryDelayEstimatorFarend* handle,
                                  uint32_t binary_far_spectrum) {
-  assert(handle != NULL);
+  RTC_DCHECK(handle);
   // Shift binary spectrum history and insert current |binary_far_spectrum|.
   memmove(&(handle->binary_far_history[1]), &(handle->binary_far_history[0]),
           (handle->history_size - 1) * sizeof(uint32_t));
   handle->binary_far_history[0] = binary_far_spectrum;
 
   // Shift history of far-end binary spectrum bit counts and insert bit count
   // of current |binary_far_spectrum|.
   memmove(&(handle->far_bit_counts[1]), &(handle->far_bit_counts[0]),
           (handle->history_size - 1) * sizeof(int));
   handle->far_bit_counts[0] = BitCount(binary_far_spectrum);
@@ skipping 97 matching lines @@
            0,
            sizeof(*self->histogram) * size_diff);
   }
   self->history_size = history_size;
 
   return self->history_size;
 }
 
 void WebRtc_InitBinaryDelayEstimator(BinaryDelayEstimator* self) {
   int i = 0;
-  assert(self != NULL);
+  RTC_DCHECK(self);
 
   memset(self->bit_counts, 0, sizeof(int32_t) * self->history_size);
   memset(self->binary_near_history,
          0,
          sizeof(uint32_t) * self->near_history_size);
   for (i = 0; i <= self->history_size; ++i) {
     self->mean_bit_counts[i] = (20 << 9);  // 20 in Q9.
     self->histogram[i] = 0.f;
   }
   self->minimum_probability = kMaxBitCountsQ9;  // 32 in Q9.
   self->last_delay_probability = (int) kMaxBitCountsQ9;  // 32 in Q9.
 
   // Default return value if we're unable to estimate. -1 is used for errors.
   self->last_delay = -2;
 
   self->last_candidate_delay = -2;
   self->compare_delay = self->history_size;
   self->candidate_hits = 0;
   self->last_delay_histogram = 0.f;
 }
 
 int WebRtc_SoftResetBinaryDelayEstimator(BinaryDelayEstimator* self,
                                          int delay_shift) {
   int lookahead = 0;
-  assert(self != NULL);
+  RTC_DCHECK(self);
   lookahead = self->lookahead;
   self->lookahead -= delay_shift;
   if (self->lookahead < 0) {
     self->lookahead = 0;
   }
   if (self->lookahead > self->near_history_size - 1) {
     self->lookahead = self->near_history_size - 1;
   }
   return lookahead - self->lookahead;
 }
 
 int WebRtc_ProcessBinarySpectrum(BinaryDelayEstimator* self,
                                  uint32_t binary_near_spectrum) {
   int i = 0;
   int candidate_delay = -1;
   int valid_candidate = 0;
 
   int32_t value_best_candidate = kMaxBitCountsQ9;
   int32_t value_worst_candidate = 0;
   int32_t valley_depth = 0;
 
-  assert(self != NULL);
+  RTC_DCHECK(self);
   if (self->farend->history_size != self->history_size) {
     // Non matching history sizes.
     return -1;
   }
   if (self->near_history_size > 1) {
     // If we apply lookahead, shift near-end binary spectrum history. Insert
     // current |binary_near_spectrum| and pull out the delayed one.
     memmove(&(self->binary_near_history[1]), &(self->binary_near_history[0]),
             (self->near_history_size - 1) * sizeof(uint32_t));
     self->binary_near_history[0] = binary_near_spectrum;
@@ skipping 115 matching lines @@
     if (value_best_candidate < self->last_delay_probability) {
       self->last_delay_probability = value_best_candidate;
     }
     self->compare_delay = self->last_delay;
   }
 
   return self->last_delay;
 }
 
 int WebRtc_binary_last_delay(BinaryDelayEstimator* self) {
-  assert(self != NULL);
+  RTC_DCHECK(self);
   return self->last_delay;
 }
 
 float WebRtc_binary_last_delay_quality(BinaryDelayEstimator* self) {
   float quality = 0;
-  assert(self != NULL);
+  RTC_DCHECK(self);
 
   if (self->robust_validation_enabled) {
     // Simply a linear function of the histogram height at delay estimate.
     quality = self->histogram[self->compare_delay] / kHistogramMax;
   } else {
     // Note that |last_delay_probability| states how deep the minimum of the
     // cost function is, so it is rather an error probability.
     quality = (float) (kMaxBitCountsQ9 - self->last_delay_probability) /
         kMaxBitCountsQ9;
     if (quality < 0) {
       quality = 0;
     }
   }
   return quality;
 }
 
 void WebRtc_MeanEstimatorFix(int32_t new_value,
                              int factor,
                              int32_t* mean_value) {
   int32_t diff = new_value - *mean_value;
 
   // mean_new = mean_value + ((new_value - mean_value) >> factor);
   if (diff < 0) {
     diff = -((-diff) >> factor);
   } else {
     diff = (diff >> factor);
   }
   *mean_value += diff;
 }