Pull out the PostFilter to its own NonlinearBeamformer API

webrtc/modules/audio_processing/beamformer/nonlinear_beamformer_unittest.cc

 /*
  *  Copyright (c) 2015 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 39 matching lines @@
 void AimAndVerify(NonlinearBeamformer* bf, float target_azimuth_radians) {
   bf->AimAt(AzimuthToSphericalPoint(target_azimuth_radians));
   Verify(bf, target_azimuth_radians);
 }
 
 // Bitexactness test code.
 const size_t kNumFramesToProcess = 1000;
 
 void ProcessOneFrame(int sample_rate_hz,
                      AudioBuffer* capture_audio_buffer,
-                     Beamformer<float>* beamformer) {
+                     NonlinearBeamformer* beamformer) {
   if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
     capture_audio_buffer->SplitIntoFrequencyBands();
   }
 
-  beamformer->ProcessChunk(*capture_audio_buffer->split_data_f(),
-                           capture_audio_buffer->split_data_f());
+  beamformer->AnalyzeChunk(*capture_audio_buffer->split_data_f());
   capture_audio_buffer->set_num_channels(1);
+  beamformer->PostFilter(capture_audio_buffer->split_data_f());
 
   if (sample_rate_hz > AudioProcessing::kSampleRate16kHz) {
     capture_audio_buffer->MergeFrequencyBands();
   }
 }
 
 int BeamformerSampleRate(int sample_rate_hz) {
   return (sample_rate_hz > AudioProcessing::kSampleRate16kHz
               ? AudioProcessing::kSampleRate16kHz
               : sample_rate_hz);
 }
 
 void RunBitExactnessTest(int sample_rate_hz,
                          const std::vector<Point>& array_geometry,
                          const SphericalPointf& target_direction,
                          rtc::ArrayView<const float> output_reference) {
-  NonlinearBeamformer beamformer(array_geometry, target_direction);
+  NonlinearBeamformer beamformer(array_geometry, 1u, target_direction);
   beamformer.Initialize(AudioProcessing::kChunkSizeMs,
                         BeamformerSampleRate(sample_rate_hz));
 
   const StreamConfig capture_config(sample_rate_hz, array_geometry.size(),
                                     false);
   AudioBuffer capture_buffer(
       capture_config.num_frames(), capture_config.num_channels(),
       capture_config.num_frames(), capture_config.num_channels(),
       capture_config.num_frames());
   test::InputAudioFile capture_file(
@@ skipping 57 matching lines @@
 const SphericalPointf TargetDirection2(static_cast<float>(M_PI) / 2.f,
                                        1.f,
                                        2.f);
 
 }  // namespace
 
 TEST(NonlinearBeamformerTest, AimingModifiesBeam) {
   std::vector<Point> array_geometry;
   array_geometry.push_back(Point(-0.025f, 0.f, 0.f));
   array_geometry.push_back(Point(0.025f, 0.f, 0.f));
-  NonlinearBeamformer bf(array_geometry);
+  NonlinearBeamformer bf(array_geometry, 1u);
   bf.Initialize(kChunkSizeMs, kSampleRateHz);
   // The default constructor parameter sets the target angle to PI / 2.
   Verify(&bf, static_cast<float>(M_PI) / 2.f);
   AimAndVerify(&bf, static_cast<float>(M_PI) / 3.f);
   AimAndVerify(&bf, 3.f * static_cast<float>(M_PI) / 4.f);
   AimAndVerify(&bf, static_cast<float>(M_PI) / 6.f);
   AimAndVerify(&bf, static_cast<float>(M_PI));
 }
 
 TEST(NonlinearBeamformerTest, InterfAnglesTakeAmbiguityIntoAccount) {
   {
     // For linear arrays there is ambiguity.
     std::vector<Point> array_geometry;
     array_geometry.push_back(Point(-0.1f, 0.f, 0.f));
     array_geometry.push_back(Point(0.f, 0.f, 0.f));
     array_geometry.push_back(Point(0.2f, 0.f, 0.f));
-    NonlinearBeamformer bf(array_geometry);
+    NonlinearBeamformer bf(array_geometry, 1u);
     bf.Initialize(kChunkSizeMs, kSampleRateHz);
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
                     bf.interf_angles_radians_[1]);
     bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
   }
   {
     // For planar arrays with normal in the xy-plane there is ambiguity.
     std::vector<Point> array_geometry;
     array_geometry.push_back(Point(-0.1f, 0.f, 0.f));
     array_geometry.push_back(Point(0.f, 0.f, 0.f));
     array_geometry.push_back(Point(0.2f, 0.f, 0.f));
     array_geometry.push_back(Point(0.1f, 0.f, 0.2f));
     array_geometry.push_back(Point(0.f, 0.f, -0.1f));
-    NonlinearBeamformer bf(array_geometry);
+    NonlinearBeamformer bf(array_geometry, 1u);
     bf.Initialize(kChunkSizeMs, kSampleRateHz);
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
                     bf.interf_angles_radians_[1]);
     bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI - bf.away_radians_ / 2.f,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
   }
   {
     // For planar arrays with normal not in the xy-plane there is no ambiguity.
     std::vector<Point> array_geometry;
     array_geometry.push_back(Point(0.f, 0.f, 0.f));
     array_geometry.push_back(Point(0.2f, 0.f, 0.f));
     array_geometry.push_back(Point(0.f, 0.1f, -0.2f));
-    NonlinearBeamformer bf(array_geometry);
+    NonlinearBeamformer bf(array_geometry, 1u);
     bf.Initialize(kChunkSizeMs, kSampleRateHz);
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
                     bf.interf_angles_radians_[1]);
     bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
   }
   {
     // For arrays which are not linear or planar there is no ambiguity.
     std::vector<Point> array_geometry;
     array_geometry.push_back(Point(0.f, 0.f, 0.f));
     array_geometry.push_back(Point(0.1f, 0.f, 0.f));
     array_geometry.push_back(Point(0.f, 0.2f, 0.f));
     array_geometry.push_back(Point(0.f, 0.f, 0.3f));
-    NonlinearBeamformer bf(array_geometry);
+    NonlinearBeamformer bf(array_geometry, 1u);
     bf.Initialize(kChunkSizeMs, kSampleRateHz);
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(M_PI / 2.f - bf.away_radians_,
                     bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(M_PI / 2.f + bf.away_radians_,
                     bf.interf_angles_radians_[1]);
     bf.AimAt(AzimuthToSphericalPoint(bf.away_radians_ / 2.f));
     EXPECT_EQ(2u, bf.interf_angles_radians_.size());
     EXPECT_FLOAT_EQ(-bf.away_radians_ / 2.f, bf.interf_angles_radians_[0]);
     EXPECT_FLOAT_EQ(3.f * bf.away_radians_ / 2.f, bf.interf_angles_radians_[1]);
   }
 }
 
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection1) {
   const float kOutputReference[] = {0.001318f, -0.001091f, 0.000990f,
                                     0.001318f, -0.001091f, 0.000990f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo16kHz_ArrayGeometry1_TargetDirection1) {
-  const float kOutputReference[] = {0.000064f, 0.000211f, 0.000075f,
-                                    0.000064f, 0.000211f, 0.000075f};
+  const float kOutputReference[] = {-0.000077f, -0.000147f, -0.000138f,
+                                    -0.000077f, -0.000147f, -0.000138f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo32kHz_ArrayGeometry1_TargetDirection1) {
-  const float kOutputReference[] = {0.000183f, 0.000183f, 0.000183f,
-                                    0.000183f, 0.000183f, 0.000183f};
+  const float kOutputReference[] = {-0.000061f, -0.000061f, -0.000061f,
+                                    -0.000061f, -0.000061f, -0.000061f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo48kHz_ArrayGeometry1_TargetDirection1) {
-  const float kOutputReference[] = {0.000155f, 0.000152f, 0.000159f,
-                                    0.000155f, 0.000152f, 0.000159f};
+  const float kOutputReference[] = {0.000450f, 0.000436f, 0.000433f,
+                                    0.000450f, 0.000436f, 0.000433f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1),
                       TargetDirection1, kOutputReference);
 }
 
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo8kHz_ArrayGeometry1_TargetDirection2) {
   const float kOutputReference[] = {0.001144f,  -0.001026f, 0.001074f,
                                     -0.016205f, -0.007324f, -0.015656f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo16kHz_ArrayGeometry1_TargetDirection2) {
-  const float kOutputReference[] = {0.001144f, -0.001026f, 0.001074f,
-                                    0.001144f, -0.001026f, 0.001074f};
+  const float kOutputReference[] = {0.000221f, -0.000249f, 0.000140f,
+                                    0.000221f, -0.000249f, 0.000140f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo32kHz_ArrayGeometry1_TargetDirection2) {
-  const float kOutputReference[] = {0.000732f, -0.000397f, 0.000610f,
-                                    0.000732f, -0.000397f, 0.000610f};
+  const float kOutputReference[] = {0.000763f, -0.000336f, 0.000549f,
+                                    0.000763f, -0.000336f, 0.000549f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo48kHz_ArrayGeometry1_TargetDirection2) {
-  const float kOutputReference[] = {0.000106f, -0.000464f, 0.000188f,
-                                    0.000106f, -0.000464f, 0.000188f};
+  const float kOutputReference[] = {-0.000004f, -0.000494f, 0.000255f,
+                                    -0.000004f, -0.000494f, 0.000255f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(1),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo8kHz_ArrayGeometry2_TargetDirection2) {
-  const float kOutputReference[] = {-0.000649f, 0.000576f, -0.000148f,
-                                    -0.000649f, 0.000576f, -0.000148f};
+  const float kOutputReference[] = {-0.000914f, 0.002170f, -0.002382f,
+                                    -0.000914f, 0.002170f, -0.002382f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate8kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo16kHz_ArrayGeometry2_TargetDirection2) {
-  const float kOutputReference[] = {0.000808f, -0.000695f, 0.000739f,
-                                    0.000808f, -0.000695f, 0.000739f};
+  const float kOutputReference[] = {0.000179f, -0.000179f, 0.000081f,
+                                    0.000179f, -0.000179f, 0.000081f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo32kHz_ArrayGeometry2_TargetDirection2) {
-  const float kOutputReference[] = {0.000580f, -0.000183f, 0.000458f,
-                                    0.000580f, -0.000183f, 0.000458f};
+  const float kOutputReference[] = {0.000549f, -0.000214f, 0.000366f,
+                                    0.000549f, -0.000214f, 0.000366f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate32kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 TEST(BeamformerBitExactnessTest,
      Stereo48kHz_ArrayGeometry2_TargetDirection2) {
-  const float kOutputReference[] = {0.000075f, -0.000288f, 0.000156f,
-                                    0.000075f, -0.000288f, 0.000156f};
+  const float kOutputReference[] = {0.000019f, -0.000310f, 0.000182f,
+                                    0.000019f, -0.000310f, 0.000182f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate48kHz, CreateArrayGeometry(2),
                       TargetDirection2, kOutputReference);
 }
 
 // TODO(peah): Investigate why the nonlinear_beamformer.cc causes a DCHECK in
 // this setup.
 TEST(BeamformerBitExactnessTest,
      DISABLED_Stereo16kHz_ArrayGeometry3_TargetDirection1) {
   const float kOutputReference[] = {-0.000161f, 0.000171f, -0.000096f,
                                     0.001007f,  0.000427f, 0.000977f};
 
   RunBitExactnessTest(AudioProcessing::kSampleRate16kHz, CreateArrayGeometry(3),
                       TargetDirection1, kOutputReference);
 }
 
 }  // namespace webrtc