Add RTC_ prefix to (D)CHECKs and related macros.

webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.cc

 /*
  *  Copyright (c) 2014 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 40 matching lines @@
     IntelligibilityEnhancer::AudioSource source)
     : parent_(parent), source_(source) {
 }
 
 void IntelligibilityEnhancer::TransformCallback::ProcessAudioBlock(
     const complex<float>* const* in_block,
     int in_channels,
     size_t frames,
     int /* out_channels */,
     complex<float>* const* out_block) {
-  DCHECK_EQ(parent_->freqs_, frames);
+  RTC_DCHECK_EQ(parent_->freqs_, frames);
   for (int i = 0; i < in_channels; ++i) {
     parent_->DispatchAudio(source_, in_block[i], out_block[i]);
   }
 }
 
 IntelligibilityEnhancer::IntelligibilityEnhancer()
     : IntelligibilityEnhancer(IntelligibilityEnhancer::Config()) {
 }
 
 IntelligibilityEnhancer::IntelligibilityEnhancer(const Config& config)
@@ skipping 24 matching lines @@
       rho_(new float[bank_size_]),
       gains_eq_(new float[bank_size_]),
       gain_applier_(freqs_, config.gain_change_limit),
       temp_render_out_buffer_(chunk_length_, num_render_channels_),
       temp_capture_out_buffer_(chunk_length_, num_capture_channels_),
       kbd_window_(new float[window_size_]),
       render_callback_(this, AudioSource::kRenderStream),
       capture_callback_(this, AudioSource::kCaptureStream),
       block_count_(0),
       analysis_step_(0) {
-  DCHECK_LE(config.rho, 1.0f);
+  RTC_DCHECK_LE(config.rho, 1.0f);
 
   CreateErbBank();
 
   // Assumes all rho equal.
   for (size_t i = 0; i < bank_size_; ++i) {
     rho_[i] = config.rho * config.rho;
   }
 
   float freqs_khz = kClipFreq / 1000.0f;
   size_t erb_index = static_cast<size_t>(ceilf(
       11.17f * logf((freqs_khz + 0.312f) / (freqs_khz + 14.6575f)) + 43.0f));
   start_freq_ = std::max(static_cast<size_t>(1), erb_index * erb_resolution_);
 
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, window_size_,
                                        kbd_window_.get());
   render_mangler_.reset(new LappedTransform(
       num_render_channels_, num_render_channels_, chunk_length_,
       kbd_window_.get(), window_size_, window_size_ / 2, &render_callback_));
   capture_mangler_.reset(new LappedTransform(
       num_capture_channels_, num_capture_channels_, chunk_length_,
       kbd_window_.get(), window_size_, window_size_ / 2, &capture_callback_));
 }
 
 void IntelligibilityEnhancer::ProcessRenderAudio(float* const* audio,
                                                  int sample_rate_hz,
                                                  int num_channels) {
-  CHECK_EQ(sample_rate_hz_, sample_rate_hz);
-  CHECK_EQ(num_render_channels_, num_channels);
+  RTC_CHECK_EQ(sample_rate_hz_, sample_rate_hz);
+  RTC_CHECK_EQ(num_render_channels_, num_channels);
 
   if (active_) {
     render_mangler_->ProcessChunk(audio, temp_render_out_buffer_.channels());
   }
 
   if (active_) {
     for (int i = 0; i < num_render_channels_; ++i) {
       memcpy(audio[i], temp_render_out_buffer_.channels()[i],
              chunk_length_ * sizeof(**audio));
     }
   }
 }
 
 void IntelligibilityEnhancer::AnalyzeCaptureAudio(float* const* audio,
                                                   int sample_rate_hz,
                                                   int num_channels) {
-  CHECK_EQ(sample_rate_hz_, sample_rate_hz);
-  CHECK_EQ(num_capture_channels_, num_channels);
+  RTC_CHECK_EQ(sample_rate_hz_, sample_rate_hz);
+  RTC_CHECK_EQ(num_capture_channels_, num_channels);
 
   capture_mangler_->ProcessChunk(audio, temp_capture_out_buffer_.channels());
 }
 
 void IntelligibilityEnhancer::DispatchAudio(
     IntelligibilityEnhancer::AudioSource source,
     const complex<float>* in_block,
     complex<float>* out_block) {
   switch (source) {
     case kRenderStream:
@@ skipping 187 matching lines @@
       sols[n] =
           (-beta0 - sqrtf(beta0 * beta0 - 4 * alpha0 * gamma0)) / (2 * alpha0);
     } else {
       sols[n] = -gamma0 / beta0;
     }
     sols[n] = fmax(0, sols[n]);
   }
 }
 
 void IntelligibilityEnhancer::FilterVariance(const float* var, float* result) {
-  DCHECK_GT(freqs_, 0u);
+  RTC_DCHECK_GT(freqs_, 0u);
   for (size_t i = 0; i < bank_size_; ++i) {
     result[i] = DotProduct(&filter_bank_[i][0], var, freqs_);
   }
 }
 
 float IntelligibilityEnhancer::DotProduct(const float* a,
                                           const float* b,
                                           size_t length) {
   float ret = 0.0f;
 
   for (size_t i = 0; i < length; ++i) {
     ret = fmaf(a[i], b[i], ret);
   }
   return ret;
 }
 
 bool IntelligibilityEnhancer::active() const {
   return active_;
 }
 
 }  // namespace webrtc