Make the separation between target and interferer scenario depend on microphone spacing in Nonlinea…

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 18 matching lines @@
 
 const float kSpeedOfSoundMeterSeconds = 343;
 
 // For both target and interference angles, PI / 2 is perpendicular to the
 // microphone array, facing forwards. The positive direction goes
 // counterclockwise.
 // The angle at which we amplify sound.
 // TODO(aluebs): Make the target angle dynamically settable.
 const float kTargetAngleRadians = static_cast<float>(M_PI) / 2.f;
 
+// The minimum separation in radians between the target direction and an
+// interferer scenario.
+const float kMinAwayRadians = 0.2f;
+
+// The separation between the target direction and the closest interferer
+// scenario is proportional to this constant.
+const float kAwaySlope = 0.008f;
+
 // When calculating the interference covariance matrix, this is the weight for
 // the weighted average between the uniform covariance matrix and the angled
 // covariance matrix.
 // Rpsi = Rpsi_angled * kBalance + Rpsi_uniform * (1 - kBalance)
 const float kBalance = 0.95f;
 
 const float kHalfBeamWidthRadians = static_cast<float>(M_PI) * 20.f / 180.f;
 
 // Alpha coefficients for mask smoothing.
 const float kMaskTimeSmoothAlpha = 0.2f;
@@ skipping 133 matching lines @@
   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)) {
+    : num_input_channels_(array_geometry.size()),
+      array_geometry_(GetCenteredArray(array_geometry)),
+      min_mic_spacing_(GetMinimumSpacing(array_geometry)) {
   WindowGenerator::KaiserBesselDerived(kKbdAlpha, kFftSize, window_);
 }
 
 void NonlinearBeamformer::Initialize(int chunk_size_ms, int sample_rate_hz) {
   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_);
@@ skipping 42 matching lines @@
   for (size_t i = 0; i < kNumFreqBins; ++i) {
     rxiws_[i] = Norm(target_cov_mats_[i], delay_sum_masks_[i]);
     rpsiws_[i].clear();
     for (size_t j = 0; j < interf_angles_radians_.size(); ++j) {
       rpsiws_[i].push_back(Norm(*interf_cov_mats_[i][j], delay_sum_masks_[i]));
     }
   }
 }
 
 void NonlinearBeamformer::InitInterfAngles() {
-  // TODO(aluebs): Make kAwayRadians dependent on the mic spacing.
-  const float kAwayRadians = 0.5;
+  const float kAwayRadians =
+      std::min(static_cast<float>(M_PI),
+               std::max(kMinAwayRadians, kAwaySlope * static_cast<float>(M_PI) /
+                                             min_mic_spacing_));
 
   interf_angles_radians_.clear();
   // TODO(aluebs): When the target angle is settable, make sure the interferer
   // scenarios aren't reflected over the target one for linear geometries.
   interf_angles_radians_.push_back(kTargetAngleRadians - kAwayRadians);
   interf_angles_radians_.push_back(kTargetAngleRadians + kAwayRadians);
 }
 
 void NonlinearBeamformer::InitDelaySumMasks() {
   for (size_t f_ix = 0; f_ix < kNumFreqBins; ++f_ix) {
@@ skipping 246 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