Replace some asserts with DCHECKs

webrtc/common_audio/resampler/sinc_resampler.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
@@ skipping 69 matching lines @@
 // 8) Else, if we're not on the second load, goto (4).
 //
 // Note: we're glossing over how the sub-sample handling works with
 // |virtual_source_idx_|, etc.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "webrtc/common_audio/resampler/sinc_resampler.h"
 
-#include <assert.h>
 #include <math.h>
 #include <string.h>
 
 #include <limits>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 
 namespace {
 
 double SincScaleFactor(double io_ratio) {
   // |sinc_scale_factor| is basically the normalized cutoff frequency of the
   // low-pass filter.
@@ skipping 52 matching lines @@
           AlignedMalloc(sizeof(float) * kKernelStorageSize, 16))),
       input_buffer_(static_cast<float*>(
           AlignedMalloc(sizeof(float) * input_buffer_size_, 16))),
 #if defined(WEBRTC_CPU_DETECTION)
       convolve_proc_(NULL),
 #endif
       r1_(input_buffer_.get()),
       r2_(input_buffer_.get() + kKernelSize / 2) {
 #if defined(WEBRTC_CPU_DETECTION)
   InitializeCPUSpecificFeatures();
-  assert(convolve_proc_);
+  RTC_DCHECK(convolve_proc_);
 #endif
-  assert(request_frames_ > 0);
+  RTC_DCHECK_GT(request_frames_, 0);
   Flush();
-  assert(block_size_ > kKernelSize);
+  RTC_DCHECK_GT(block_size_, kKernelSize);
 
   memset(kernel_storage_.get(), 0,
          sizeof(*kernel_storage_.get()) * kKernelStorageSize);
   memset(kernel_pre_sinc_storage_.get(), 0,
          sizeof(*kernel_pre_sinc_storage_.get()) * kKernelStorageSize);
   memset(kernel_window_storage_.get(), 0,
          sizeof(*kernel_window_storage_.get()) * kKernelStorageSize);
 
   InitializeKernel();
 }
 
 SincResampler::~SincResampler() {}
 
 void SincResampler::UpdateRegions(bool second_load) {
   // Setup various region pointers in the buffer (see diagram above).  If we're
   // on the second load we need to slide r0_ to the right by kKernelSize / 2.
   r0_ = input_buffer_.get() + (second_load ? kKernelSize : kKernelSize / 2);
   r3_ = r0_ + request_frames_ - kKernelSize;
   r4_ = r0_ + request_frames_ - kKernelSize / 2;
   block_size_ = r4_ - r2_;
 
   // r1_ at the beginning of the buffer.
-  assert(r1_ == input_buffer_.get());
+  RTC_DCHECK_EQ(r1_, input_buffer_.get());
   // r1_ left of r2_, r4_ left of r3_ and size correct.
-  assert(r2_ - r1_ == r4_ - r3_);
+  RTC_DCHECK_EQ(r2_ - r1_, r4_ - r3_);
   // r2_ left of r3.
-  assert(r2_ < r3_);
+  RTC_DCHECK_LT(r2_, r3_);
 }
 
 void SincResampler::InitializeKernel() {
   // Blackman window parameters.
   static const double kAlpha = 0.16;
   static const double kA0 = 0.5 * (1.0 - kAlpha);
   static const double kA1 = 0.5;
   static const double kA2 = 0.5 * kAlpha;
 
   // Generates a set of windowed sinc() kernels.
@@ skipping 66 matching lines @@
   const float* const kernel_ptr = kernel_storage_.get();
   while (remaining_frames) {
     // |i| may be negative if the last Resample() call ended on an iteration
     // that put |virtual_source_idx_| over the limit.
     //
     // Note: The loop construct here can severely impact performance on ARM
     // or when built with clang.  See https://codereview.chromium.org/18566009/
     for (int i = static_cast<int>(
              ceil((block_size_ - virtual_source_idx_) / current_io_ratio));
          i > 0; --i) {
-      assert(virtual_source_idx_ < block_size_);
+      RTC_DCHECK_LT(virtual_source_idx_, block_size_);
 
       // |virtual_source_idx_| lies in between two kernel offsets so figure out
       // what they are.
       const int source_idx = static_cast<int>(virtual_source_idx_);
       const double subsample_remainder = virtual_source_idx_ - source_idx;
 
       const double virtual_offset_idx =
           subsample_remainder * kKernelOffsetCount;
       const int offset_idx = static_cast<int>(virtual_offset_idx);
 
       // We'll compute "convolutions" for the two kernels which straddle
       // |virtual_source_idx_|.
       const float* const k1 = kernel_ptr + offset_idx * kKernelSize;
       const float* const k2 = k1 + kKernelSize;
 
       // Ensure |k1|, |k2| are 16-byte aligned for SIMD usage.  Should always be
       // true so long as kKernelSize is a multiple of 16.
-      assert(0u == (reinterpret_cast<uintptr_t>(k1) & 0x0F));
-      assert(0u == (reinterpret_cast<uintptr_t>(k2) & 0x0F));
+      RTC_DCHECK_EQ(0, reinterpret_cast<uintptr_t>(k1) % 16);
+      RTC_DCHECK_EQ(0, reinterpret_cast<uintptr_t>(k2) % 16);
 
       // Initialize input pointer based on quantized |virtual_source_idx_|.
       const float* const input_ptr = r1_ + source_idx;
 
       // Figure out how much to weight each kernel's "convolution".
       const double kernel_interpolation_factor =
           virtual_offset_idx - offset_idx;
       *destination++ = CONVOLVE_FUNC(
           input_ptr, k1, k2, kernel_interpolation_factor);
 
@@ skipping 47 matching lines @@
     sum1 += *input_ptr * *k1++;
     sum2 += *input_ptr++ * *k2++;
   }
 
   // Linearly interpolate the two "convolutions".
   return static_cast<float>((1.0 - kernel_interpolation_factor) * sum1 +
       kernel_interpolation_factor * sum2);
 }
 
 }  // namespace webrtc