Update audio code to use size_t more correctly, webrtc/modules/audio_processing/

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 101 matching lines @@
 
   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;
 }
 
 // Works for positive numbers only.
-int Round(float x) {
-  return static_cast<int>(std::floor(x + 0.5f));
+size_t Round(float x) {
+  return static_cast<size_t>(std::floor(x + 0.5f));
 }
 
 // Calculates the sum of absolute values of a complex matrix.
 float SumAbs(const ComplexMatrix<float>& mat) {
   float sum_abs = 0.f;
   const complex<float>* const* mat_els = mat.elements();
   for (int i = 0; i < mat.num_rows(); ++i) {
     for (int j = 0; j < mat.num_columns(); ++j) {
       sum_abs += std::abs(mat_els[i][j]);
     }
@@ skipping 38 matching lines @@
     center /= array_geometry.size();
     for (size_t i = 0; i < array_geometry.size(); ++i) {
       array_geometry[i].c[dim] -= center;
     }
   }
   return array_geometry;
 }
 
 }  // namespace
 
+// static
+const size_t NonlinearBeamformer::kNumFreqBins;
+
 NonlinearBeamformer::NonlinearBeamformer(
     const std::vector<Point>& array_geometry)
   : num_input_channels_(array_geometry.size()),
       array_geometry_(GetCenteredArray(array_geometry)) {
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, kFftSize, window_);
 }
 
 void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
-  chunk_length_ = sample_rate_hz / (1000.f / chunk_size_ms);
+  chunk_length_ =
+      static_cast<size_t>(sample_rate_hz / (1000.f / chunk_size_ms));
   sample_rate_hz_ = sample_rate_hz;
   low_mean_start_bin_ = Round(kLowMeanStartHz * kFftSize / sample_rate_hz_);
   low_mean_end_bin_ = Round(kLowMeanEndHz * kFftSize / sample_rate_hz_);
   high_mean_start_bin_ = Round(kHighMeanStartHz * kFftSize / sample_rate_hz_);
   high_mean_end_bin_ = Round(kHighMeanEndHz * kFftSize / sample_rate_hz_);
   // 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_, 0);
+  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);
 
   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_,
                                               window_,
                                               kFftSize,
                                               kFftSize / 2,
                                               this));
-  for (int i = 0; i < kNumFreqBins; ++i) {
+  for (size_t i = 0; i < kNumFreqBins; ++i) {
     time_smooth_mask_[i] = 1.f;
     final_mask_[i] = 1.f;
     float freq_hz = (static_cast<float>(i) / kFftSize) * sample_rate_hz_;
     wave_numbers_[i] = 2 * M_PI * freq_hz / kSpeedOfSoundMeterSeconds;
     mask_thresholds_[i] = num_input_channels_ * num_input_channels_ *
                           kBeamwidthConstant * wave_numbers_[i] *
                           wave_numbers_[i];
   }
 
   // Initialize all nonadaptive values before looping through the frames.
   InitDelaySumMasks();
   InitTargetCovMats();
   InitInterfCovMats();
 
-  for (int i = 0; i < kNumFreqBins; ++i) {
+  for (size_t i = 0; i < kNumFreqBins; ++i) {
     rxiws_[i] = Norm(target_cov_mats_[i], delay_sum_masks_[i]);
     rpsiws_[i] = Norm(interf_cov_mats_[i], delay_sum_masks_[i]);
     reflected_rpsiws_[i] =
         Norm(reflected_interf_cov_mats_[i], delay_sum_masks_[i]);
   }
 }
 
 void NonlinearBeamformer::InitDelaySumMasks() {
-  for (int f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
+  for (size_t f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
     delay_sum_masks_[f_ix].Resize(1, num_input_channels_);
     CovarianceMatrixGenerator::PhaseAlignmentMasks(f_ix,
                                                    kFftSize,
                                                    sample_rate_hz_,
                                                    kSpeedOfSoundMeterSeconds,
                                                    array_geometry_,
                                                    kTargetAngleRadians,
                                                    &delay_sum_masks_[f_ix]);
 
     complex_f norm_factor = sqrt(
         ConjugateDotProduct(delay_sum_masks_[f_ix], delay_sum_masks_[f_ix]));
     delay_sum_masks_[f_ix].Scale(1.f / norm_factor);
     normalized_delay_sum_masks_[f_ix].CopyFrom(delay_sum_masks_[f_ix]);
     normalized_delay_sum_masks_[f_ix].Scale(1.f / SumAbs(
         normalized_delay_sum_masks_[f_ix]));
   }
 }
 
 void NonlinearBeamformer::InitTargetCovMats() {
-  for (int i = 0; i < kNumFreqBins; ++i) {
+  for (size_t i = 0; i < kNumFreqBins; ++i) {
     target_cov_mats_[i].Resize(num_input_channels_, num_input_channels_);
     TransposedConjugatedProduct(delay_sum_masks_[i], &target_cov_mats_[i]);
     complex_f normalization_factor = target_cov_mats_[i].Trace();
     target_cov_mats_[i].Scale(1.f / normalization_factor);
   }
 }
 
 void NonlinearBeamformer::InitInterfCovMats() {
-  for (int i = 0; i < kNumFreqBins; ++i) {
+  for (size_t i = 0; i < kNumFreqBins; ++i) {
     interf_cov_mats_[i].Resize(num_input_channels_, num_input_channels_);
     ComplexMatrixF uniform_cov_mat(num_input_channels_, num_input_channels_);
     ComplexMatrixF angled_cov_mat(num_input_channels_, num_input_channels_);
 
     CovarianceMatrixGenerator::UniformCovarianceMatrix(wave_numbers_[i],
                                                        array_geometry_,
                                                        &uniform_cov_mat);
 
     CovarianceMatrixGenerator::AngledCovarianceMatrix(kSpeedOfSoundMeterSeconds,
                                                       kInterfAngleRadians,
@@ skipping 24 matching lines @@
 
   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.
-  for (int i = 1; i < input.num_bands(); ++i) {
+  for (size_t i = 1; i < input.num_bands(); ++i) {
     float smoothed_mask = old_high_pass_mask;
-    for (int j = 0; j < input.num_frames_per_band(); ++j) {
+    for (size_t j = 0; j < input.num_frames_per_band(); ++j) {
       smoothed_mask += ramp_increment;
 
       // Applying the delay and sum (at zero degrees, this is equivalent to
       // averaging).
       float sum = 0.f;
       for (int k = 0; k < input.num_channels(); ++k) {
         sum += input.channels(i)[k][j];
       }
       output->channels(i)[0][j] = sum / input.num_channels() * smoothed_mask;
     }
   }
 }
 
 bool NonlinearBeamformer::IsInBeam(const SphericalPointf& spherical_point) {
   // If more than half-beamwidth degrees away from the beam's center,
   // 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,

[Andrew MacDonald, 2015/07/24 04:01:43]

and here

-                                            int num_freq_bins,
+                                            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);
 
   // Calculating the post-filter masks. Note that we need two for each
   // frequency bin to account for the positive and negative interferer
   // angle.
-  for (int i = low_mean_start_bin_; i <= high_mean_end_bin_; ++i) {
+  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);
     }
 
     float rxim = Norm(target_cov_mats_[i], eig_m_);
     float ratio_rxiw_rxim = 0.f;
     if (rxim > 0.f) {
       ratio_rxiw_rxim = rxiws_[i] / rxim;
@@ skipping 44 matching lines @@
   if (denominator > mask_threshold) {
     float lambda = numerator / denominator;
     mask = std::max(lambda * ratio_rxiw_rxim / rmw_r, kMaskMinimum);
   }
   return mask;
 }
 
 void NonlinearBeamformer::ApplyMasks(const complex_f* const* input,
                                      complex_f* const* output) {
   complex_f* output_channel = output[0];
-  for (int f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
+  for (size_t f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
     output_channel[f_ix] = complex_f(0.f, 0.f);
 
     const complex_f* delay_sum_mask_els =
         normalized_delay_sum_masks_[f_ix].elements()[0];
     for (int c_ix = 0; c_ix < num_input_channels_; ++c_ix) {
       output_channel[f_ix] += input[c_ix][f_ix] * delay_sum_mask_els[c_ix];
     }
 
     output_channel[f_ix] *= final_mask_[f_ix];
   }
 }
 
 // Smooth new_mask_ into time_smooth_mask_.
 void NonlinearBeamformer::ApplyMaskTimeSmoothing() {
-  for (int i = low_mean_start_bin_; i <= high_mean_end_bin_; ++i) {
+  for (size_t i = low_mean_start_bin_; i <= high_mean_end_bin_; ++i) {
     time_smooth_mask_[i] = kMaskTimeSmoothAlpha * new_mask_[i] +
                            (1 - kMaskTimeSmoothAlpha) * time_smooth_mask_[i];
   }
 }
 
 // Copy time_smooth_mask_ to final_mask_ and smooth over frequency.
 void NonlinearBeamformer::ApplyMaskFrequencySmoothing() {
   // Smooth over frequency in both directions. The "frequency correction"
   // regions have constant value, but we enter them to smooth over the jump
   // that exists at the boundary. However, this does mean when smoothing "away"
   // from the region that we only need to use the last element.
   //
   // Upward smoothing:
   //   low_mean_start_bin_
   //         v
   // |------|------------|------|
   //       ^------------------>^
   //
   // Downward smoothing:
   //         high_mean_end_bin_
   //                    v
   // |------|------------|------|
   //  ^<------------------^
   std::copy(time_smooth_mask_, time_smooth_mask_ + kNumFreqBins, final_mask_);
-  for (int i = low_mean_start_bin_; i < kNumFreqBins; ++i) {
+  for (size_t i = low_mean_start_bin_; i < kNumFreqBins; ++i) {
     final_mask_[i] = kMaskFrequencySmoothAlpha * final_mask_[i] +
                      (1 - kMaskFrequencySmoothAlpha) * final_mask_[i - 1];
   }
-  for (int i = high_mean_end_bin_ + 1; i > 0; --i) {
+  for (size_t i = high_mean_end_bin_ + 1; i > 0; --i) {
     final_mask_[i - 1] = kMaskFrequencySmoothAlpha * final_mask_[i - 1] +
                          (1 - kMaskFrequencySmoothAlpha) * final_mask_[i];
   }
 }
 
 // Apply low frequency correction to time_smooth_mask_.
 void NonlinearBeamformer::ApplyLowFrequencyCorrection() {
   const float low_frequency_mask =
       MaskRangeMean(low_mean_start_bin_, low_mean_end_bin_ + 1);
   std::fill(time_smooth_mask_, time_smooth_mask_ + low_mean_start_bin_,
             low_frequency_mask);
 }
 
 // Apply high frequency correction to time_smooth_mask_. Update
 // 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(int first, int last) {
+float NonlinearBeamformer::MaskRangeMean(size_t first, size_t last) {
   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 int quantile =
+  const size_t quantile = static_cast<size_t>(
       (high_mean_end_bin_ - low_mean_start_bin_) * kMaskQuantile +
-      low_mean_start_bin_;
+      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