Misc. small cleanups

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 145 matching lines @@
   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) {
-  for (int dim = 0; dim < 3; ++dim) {
+  for (size_t dim = 0; dim < 3; ++dim) {
     float center = 0.f;
     for (size_t i = 0; i < array_geometry.size(); ++i) {
       center += array_geometry[i].c[dim];
     }
     center /= array_geometry.size();
     for (size_t i = 0; i < array_geometry.size(); ++i) {
       array_geometry[i].c[dim] -= center;
     }
   }
   return array_geometry;
@@ skipping 195 matching lines @@
   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 the smoothed high-pass mask to the first channel of each band.
-  // This can be done because the effct of the linear beamformer is negligible
+  // This can be done because the effect of the linear beamformer is negligible
   // compared to the post-filter.
   for (size_t i = 1; i < input.num_bands(); ++i) {
     float smoothed_mask = old_high_pass_mask;
     for (size_t j = 0; j < input.num_frames_per_band(); ++j) {
       smoothed_mask += ramp_increment;
       output->channels(i)[0][j] = input.channels(i)[0][j] * smoothed_mask;
     }
   }
 }
 
@@ skipping 12 matching lines @@
   // you are out of the beam.
   return fabs(spherical_point.azimuth() - target_angle_radians_) <
          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) {
-  RTC_CHECK_EQ(num_freq_bins, kNumFreqBins);
-  RTC_CHECK_EQ(num_input_channels, num_input_channels_);
-  RTC_CHECK_EQ(num_output_channels, 1);
+  RTC_CHECK_EQ(kNumFreqBins, num_freq_bins);
+  RTC_CHECK_EQ(num_input_channels_, num_input_channels);
+  RTC_CHECK_EQ(1, num_output_channels);
 
   // 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 133 matching lines @@
                    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