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

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer.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 62 matching lines @@
 const float kMaskTargetThreshold = 0.3f;
 // Time in seconds after which the data is considered interference if the mask
 // does not pass |kMaskTargetThreshold|.
 const float kHoldTargetSeconds = 0.25f;
 
 // Does conjugate(|norm_mat|) * |mat| * transpose(|norm_mat|). No extra space is
 // used; to accomplish this, we compute both multiplications in the same loop.
 // The returned norm is clamped to be non-negative.
 float Norm(const ComplexMatrix<float>& mat,
            const ComplexMatrix<float>& norm_mat) {
-  CHECK_EQ(norm_mat.num_rows(), 1);
-  CHECK_EQ(norm_mat.num_columns(), mat.num_rows());
-  CHECK_EQ(norm_mat.num_columns(), mat.num_columns());
+  RTC_CHECK_EQ(norm_mat.num_rows(), 1);
+  RTC_CHECK_EQ(norm_mat.num_columns(), mat.num_rows());
+  RTC_CHECK_EQ(norm_mat.num_columns(), mat.num_columns());
 
   complex<float> first_product = complex<float>(0.f, 0.f);
   complex<float> second_product = complex<float>(0.f, 0.f);
 
   const complex<float>* const* mat_els = mat.elements();
   const complex<float>* const* norm_mat_els = norm_mat.elements();
 
   for (int i = 0; i < norm_mat.num_columns(); ++i) {
     for (int j = 0; j < norm_mat.num_columns(); ++j) {
       first_product += conj(norm_mat_els[0][j]) * mat_els[j][i];
     }
     second_product += first_product * norm_mat_els[0][i];
     first_product = 0.f;
   }
   return std::max(second_product.real(), 0.f);
 }
 
 // Does conjugate(|lhs|) * |rhs| for row vectors |lhs| and |rhs|.
 complex<float> ConjugateDotProduct(const ComplexMatrix<float>& lhs,
                                    const ComplexMatrix<float>& rhs) {
-  CHECK_EQ(lhs.num_rows(), 1);
-  CHECK_EQ(rhs.num_rows(), 1);
-  CHECK_EQ(lhs.num_columns(), rhs.num_columns());
+  RTC_CHECK_EQ(lhs.num_rows(), 1);
+  RTC_CHECK_EQ(rhs.num_rows(), 1);
+  RTC_CHECK_EQ(lhs.num_columns(), rhs.num_columns());
 
   const complex<float>* const* lhs_elements = lhs.elements();
   const complex<float>* const* rhs_elements = rhs.elements();
 
   complex<float> result = complex<float>(0.f, 0.f);
   for (int i = 0; i < lhs.num_columns(); ++i) {
     result += conj(lhs_elements[0][i]) * rhs_elements[0][i];
   }
 
   return result;
@@ skipping 25 matching lines @@
       float abs_value = std::abs(mat_els[i][j]);
       sum_squares += abs_value * abs_value;
     }
   }
   return sum_squares;
 }
 
 // Does |out| = |in|.' * conj(|in|) for row vector |in|.
 void TransposedConjugatedProduct(const ComplexMatrix<float>& in,
                                  ComplexMatrix<float>* out) {
-  CHECK_EQ(in.num_rows(), 1);
-  CHECK_EQ(out->num_rows(), in.num_columns());
-  CHECK_EQ(out->num_columns(), in.num_columns());
+  RTC_CHECK_EQ(in.num_rows(), 1);
+  RTC_CHECK_EQ(out->num_rows(), in.num_columns());
+  RTC_CHECK_EQ(out->num_columns(), in.num_columns());
   const complex<float>* in_elements = in.elements()[0];
   complex<float>* const* out_elements = out->elements();
   for (int i = 0; i < out->num_rows(); ++i) {
     for (int j = 0; j < out->num_columns(); ++j) {
       out_elements[i][j] = in_elements[i] * conj(in_elements[j]);
     }
   }
 }
 
 std::vector<Point> GetCenteredArray(std::vector<Point> array_geometry) {
@@ skipping 33 matching lines @@
   // These bin indexes determine the regions over which a mean is taken. This
   // is applied as a constant value over the adjacent end "frequency correction"
   // regions.
   //
   //             low_mean_start_bin_     high_mean_start_bin_
   //                   v                         v              constant
   // |----------------|--------|----------------|-------|----------------|
   //   constant               ^                        ^
   //             low_mean_end_bin_       high_mean_end_bin_
   //
-  DCHECK_GT(low_mean_start_bin_, 0U);
-  DCHECK_LT(low_mean_start_bin_, low_mean_end_bin_);
-  DCHECK_LT(low_mean_end_bin_, high_mean_end_bin_);
-  DCHECK_LT(high_mean_start_bin_, high_mean_end_bin_);
-  DCHECK_LT(high_mean_end_bin_, kNumFreqBins - 1);
+  RTC_DCHECK_GT(low_mean_start_bin_, 0U);
+  RTC_DCHECK_LT(low_mean_start_bin_, low_mean_end_bin_);
+  RTC_DCHECK_LT(low_mean_end_bin_, high_mean_end_bin_);
+  RTC_DCHECK_LT(high_mean_start_bin_, high_mean_end_bin_);
+  RTC_DCHECK_LT(high_mean_end_bin_, kNumFreqBins - 1);
 
   high_pass_postfilter_mask_ = 1.f;
   is_target_present_ = false;
   hold_target_blocks_ = kHoldTargetSeconds * 2 * sample_rate_hz / kFftSize;
   interference_blocks_count_ = hold_target_blocks_;
 
 
   lapped_transform_.reset(new LappedTransform(num_input_channels_,
                                               1,
                                               chunk_length_,
@@ skipping 80 matching lines @@
     // Average matrices.
     uniform_cov_mat.Scale(1 - kBalance);
     angled_cov_mat.Scale(kBalance);
     interf_cov_mats_[i].Add(uniform_cov_mat, angled_cov_mat);
     reflected_interf_cov_mats_[i].PointwiseConjugate(interf_cov_mats_[i]);
   }
 }
 
 void NonlinearBeamformer::ProcessChunk(const ChannelBuffer<float>& input,
                                        ChannelBuffer<float>* output) {
-  DCHECK_EQ(input.num_channels(), num_input_channels_);
-  DCHECK_EQ(input.num_frames_per_band(), chunk_length_);
+  RTC_DCHECK_EQ(input.num_channels(), num_input_channels_);
+  RTC_DCHECK_EQ(input.num_frames_per_band(), chunk_length_);
 
   float old_high_pass_mask = high_pass_postfilter_mask_;
   lapped_transform_->ProcessChunk(input.channels(0), output->channels(0));
   // Ramp up/down for smoothing. 1 mask per 10ms results in audible
   // discontinuities.
   const float ramp_increment =
       (high_pass_postfilter_mask_ - old_high_pass_mask) /
       input.num_frames_per_band();
   // Apply delay and sum and post-filter in the time domain. WARNING: only works
   // because delay-and-sum is not frequency dependent.
@@ skipping 18 matching lines @@
   // you are out of the beam.
   return fabs(spherical_point.azimuth() - kTargetAngleRadians) <
          kHalfBeamWidthRadians;
 }
 
 void NonlinearBeamformer::ProcessAudioBlock(const complex_f* const* input,
                                             int num_input_channels,
                                             size_t num_freq_bins,
                                             int num_output_channels,
                                             complex_f* const* output) {
-  CHECK_EQ(num_freq_bins, kNumFreqBins);
-  CHECK_EQ(num_input_channels, num_input_channels_);
-  CHECK_EQ(num_output_channels, 1);
+  RTC_CHECK_EQ(num_freq_bins, kNumFreqBins);
+  RTC_CHECK_EQ(num_input_channels, num_input_channels_);
+  RTC_CHECK_EQ(num_output_channels, 1);
 
   // Calculating the post-filter masks. Note that we need two for each
   // frequency bin to account for the positive and negative interferer
   // angle.
   for (size_t i = low_mean_start_bin_; i <= high_mean_end_bin_; ++i) {
     eig_m_.CopyFromColumn(input, i, num_input_channels_);
     float eig_m_norm_factor = std::sqrt(SumSquares(eig_m_));
     if (eig_m_norm_factor != 0.f) {
       eig_m_.Scale(1.f / eig_m_norm_factor);
     }
@@ skipping 118 matching lines @@
 // high_pass_postfilter_mask_ to use for the high frequency time-domain bands.
 void NonlinearBeamformer::ApplyHighFrequencyCorrection() {
   high_pass_postfilter_mask_ =
       MaskRangeMean(high_mean_start_bin_, high_mean_end_bin_ + 1);
   std::fill(time_smooth_mask_ + high_mean_end_bin_ + 1,
             time_smooth_mask_ + kNumFreqBins, high_pass_postfilter_mask_);
 }
 
 // Compute mean over the given range of time_smooth_mask_, [first, last).
 float NonlinearBeamformer::MaskRangeMean(size_t first, size_t last) {
-  DCHECK_GT(last, first);
+  RTC_DCHECK_GT(last, first);
   const float sum = std::accumulate(time_smooth_mask_ + first,
                                     time_smooth_mask_ + last, 0.f);
   return sum / (last - first);
 }
 
 void NonlinearBeamformer::EstimateTargetPresence() {
   const size_t quantile = static_cast<size_t>(
       (high_mean_end_bin_ - low_mean_start_bin_) * kMaskQuantile +
       low_mean_start_bin_);
   std::nth_element(new_mask_ + low_mean_start_bin_, new_mask_ + quantile,
                    new_mask_ + high_mean_end_bin_ + 1);
   if (new_mask_[quantile] > kMaskTargetThreshold) {
     is_target_present_ = true;
     interference_blocks_count_ = 0;
   } else {
     is_target_present_ = interference_blocks_count_++ < hold_target_blocks_;
   }
 }
 
 }  // namespace webrtc