Added the ability to adjust the AEC3 performance for large rooms

webrtc/modules/audio_processing/aec3/echo_canceller3_unittest.cc

 /*
  *  Copyright (c) 2016 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 139 matching lines @@
                        1,
                        fullband_frame_length_,
                        1,
                        fullband_frame_length_) {}
 
   // Verifies that the capture data is properly received by the block processor
   // and that the processor data is properly passed to the EchoCanceller3
   // output.
   void RunCaptureTransportVerificationTest() {
     EchoCanceller3 aec3(
-        sample_rate_hz_, false,
+        AudioProcessing::Config::EchoCanceller3(), sample_rate_hz_, false,
         std::unique_ptr<BlockProcessor>(
             new CaptureTransportVerificationProcessor(num_bands_)));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 0);
       PopulateInputFrame(frame_length_, frame_index,
                          &render_buffer_.channels_f()[0][0], 0);
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
           &capture_buffer_.split_bands_f(0)[0], -64));
     }
   }
 
   // Test method for testing that the render data is properly received by the
   // block processor.
   void RunRenderTransportVerificationTest() {
     EchoCanceller3 aec3(
-        sample_rate_hz_, false,
+        AudioProcessing::Config::EchoCanceller3(), sample_rate_hz_, false,
         std::unique_ptr<BlockProcessor>(
             new RenderTransportVerificationProcessor(num_bands_)));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       aec3.AnalyzeCapture(&capture_buffer_);
       OptionalBandSplit();
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &capture_buffer_.split_bands_f(0)[0], 100);
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
@@ skipping 43 matching lines @@
             .Times(expected_num_block_to_process);
         break;
       case EchoPathChangeTestVariant::kOneNonSticky:
         EXPECT_CALL(*block_processor_mock, ProcessCapture(true, _, _))
             .Times(num_full_blocks_per_frame);
         EXPECT_CALL(*block_processor_mock, ProcessCapture(false, _, _))
             .Times(expected_num_block_to_process - num_full_blocks_per_frame);
         break;
     }
 
-    EchoCanceller3 aec3(sample_rate_hz_, false,
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        sample_rate_hz_, false,
                         std::move(block_processor_mock));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       bool echo_path_change = false;
       switch (echo_path_change_test_variant) {
         case EchoPathChangeTestVariant::kNone:
           break;
         case EchoPathChangeTestVariant::kOneSticky:
           echo_path_change = true;
@@ skipping 61 matching lines @@
         break;
       case EchoLeakageTestVariant::kTrueNonSticky: {
         testing::InSequence s;
         EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(true))
             .Times(1);
         EXPECT_CALL(*block_processor_mock, UpdateEchoLeakageStatus(false))
             .Times(kNumFramesToProcess - 1);
       } break;
     }
 
-    EchoCanceller3 aec3(sample_rate_hz_, false,
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        sample_rate_hz_, false,
                         std::move(block_processor_mock));
 
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       switch (leakage_report_variant) {
         case EchoLeakageTestVariant::kNone:
           break;
         case EchoLeakageTestVariant::kFalseSticky:
           if (frame_index == 0) {
             aec3.UpdateEchoLeakageStatus(false);
@@ skipping 68 matching lines @@
       } break;
       case SaturationTestVariant::kOnePositive: {
         testing::InSequence s;
         EXPECT_CALL(*block_processor_mock, ProcessCapture(_, true, _))
             .Times(num_full_blocks_per_frame);
         EXPECT_CALL(*block_processor_mock, ProcessCapture(_, false, _))
             .Times(expected_num_block_to_process - num_full_blocks_per_frame);
       } break;
     }
 
-    EchoCanceller3 aec3(sample_rate_hz_, false,
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        sample_rate_hz_, false,
                         std::move(block_processor_mock));
     for (size_t frame_index = 0; frame_index < kNumFramesToProcess;
          ++frame_index) {
       for (int k = 0; k < fullband_frame_length_; ++k) {
         capture_buffer_.channels_f()[0][k] = 0.f;
       }
       switch (saturation_variant) {
         case SaturationTestVariant::kNone:
           break;
         case SaturationTestVariant::kOneNegative:
@@ skipping 18 matching lines @@
 
       aec3.AnalyzeRender(&render_buffer_);
       aec3.ProcessCapture(&capture_buffer_, false);
     }
   }
 
   // This test verifies that the swapqueue is able to handle jitter in the
   // capture and render API calls.
   void RunRenderSwapQueueVerificationTest() {
     EchoCanceller3 aec3(
-        sample_rate_hz_, false,
+        AudioProcessing::Config::EchoCanceller3(), sample_rate_hz_, false,
         std::unique_ptr<BlockProcessor>(
             new RenderTransportVerificationProcessor(num_bands_)));
 
     for (size_t frame_index = 0; frame_index < kRenderTransferQueueSize;
          ++frame_index) {
       if (sample_rate_hz_ > 16000) {
         render_buffer_.SplitIntoFrequencyBands();
       }
       PopulateInputFrame(frame_length_, num_bands_, frame_index,
                          &render_buffer_.split_bands_f(0)[0], 0);
@@ skipping 18 matching lines @@
       aec3.ProcessCapture(&capture_buffer_, false);
       EXPECT_TRUE(VerifyOutputFrameBitexactness(
           frame_length_, num_bands_, frame_index,
           &capture_buffer_.split_bands_f(0)[0], -64));
     }
   }
 
   // This test verifies that a buffer overrun in the render swapqueue is
   // properly reported.
   void RunRenderPipelineSwapQueueOverrunReturnValueTest() {
-    EchoCanceller3 aec3(sample_rate_hz_, false);
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        sample_rate_hz_, false);
 
     constexpr size_t kRenderTransferQueueSize = 30;
     for (size_t k = 0; k < 2; ++k) {
       for (size_t frame_index = 0; frame_index < kRenderTransferQueueSize;
            ++frame_index) {
         if (sample_rate_hz_ > 16000) {
           render_buffer_.SplitIntoFrequencyBands();
         }
         PopulateInputFrame(frame_length_, frame_index,
                            &render_buffer_.channels_f()[0][0], 0);
 
         if (k == 0) {
           aec3.AnalyzeRender(&render_buffer_);
         } else {
           aec3.AnalyzeRender(&render_buffer_);
         }
       }
     }
   }
 
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
   // Verifies the that the check for the number of bands in the AnalyzeRender
   // input is correct by adjusting the sample rates of EchoCanceller3 and the
   // input AudioBuffer to have a different number of bands.
   void RunAnalyzeRenderNumBandsCheckVerification() {
     // Set aec3_sample_rate_hz to be different from sample_rate_hz_ in such a
     // way that the number of bands for the rates are different.
     const int aec3_sample_rate_hz = sample_rate_hz_ == 48000 ? 32000 : 48000;
-    EchoCanceller3 aec3(aec3_sample_rate_hz, false);
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        aec3_sample_rate_hz, false);
     PopulateInputFrame(frame_length_, 0, &render_buffer_.channels_f()[0][0], 0);
 
     EXPECT_DEATH(aec3.AnalyzeRender(&render_buffer_), "");
   }
 
   // Verifies the that the check for the number of bands in the ProcessCapture
   // input is correct by adjusting the sample rates of EchoCanceller3 and the
   // input AudioBuffer to have a different number of bands.
   void RunProcessCaptureNumBandsCheckVerification() {
     // Set aec3_sample_rate_hz to be different from sample_rate_hz_ in such a
     // way that the number of bands for the rates are different.
     const int aec3_sample_rate_hz = sample_rate_hz_ == 48000 ? 32000 : 48000;
-    EchoCanceller3 aec3(aec3_sample_rate_hz, false);
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        aec3_sample_rate_hz, false);
     PopulateInputFrame(frame_length_, num_bands_, 0,
                        &capture_buffer_.split_bands_f(0)[0], 100);
     EXPECT_DEATH(aec3.ProcessCapture(&capture_buffer_, false), "");
   }
 
   // Verifies the that the check for the frame length in the AnalyzeRender input
   // is correct by adjusting the sample rates of EchoCanceller3 and the input
   // AudioBuffer to have a different frame lengths.
   void RunAnalyzeRenderFrameLengthCheckVerification() {
     // Set aec3_sample_rate_hz to be different from sample_rate_hz_ in such a
     // way that the band frame lengths are different.
     const int aec3_sample_rate_hz = sample_rate_hz_ == 8000 ? 16000 : 8000;
-    EchoCanceller3 aec3(aec3_sample_rate_hz, false);
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        aec3_sample_rate_hz, false);
 
     OptionalBandSplit();
     PopulateInputFrame(frame_length_, 0, &render_buffer_.channels_f()[0][0], 0);
 
     EXPECT_DEATH(aec3.AnalyzeRender(&render_buffer_), "");
   }
 
   // Verifies the that the check for the frame length in the AnalyzeRender input
   // is correct by adjusting the sample rates of EchoCanceller3 and the input
   // AudioBuffer to have a different frame lengths.
   void RunProcessCaptureFrameLengthCheckVerification() {
     // Set aec3_sample_rate_hz to be different from sample_rate_hz_ in such a
     // way that the band frame lengths are different.
     const int aec3_sample_rate_hz = sample_rate_hz_ == 8000 ? 16000 : 8000;
-    EchoCanceller3 aec3(aec3_sample_rate_hz, false);
+    EchoCanceller3 aec3(AudioProcessing::Config::EchoCanceller3(),
+                        aec3_sample_rate_hz, false);
 
     OptionalBandSplit();
     PopulateInputFrame(frame_length_, num_bands_, 0,
                        &capture_buffer_.split_bands_f(0)[0], 100);
 
     EXPECT_DEATH(aec3.ProcessCapture(&capture_buffer_, false), "");
   }
 
 #endif
 
@@ skipping 91 matching lines @@
       EchoCanceller3Tester::EchoLeakageTestVariant::kTrueSticky,
       EchoCanceller3Tester::EchoLeakageTestVariant::kTrueNonSticky};
   for (auto rate : {8000, 16000, 32000, 48000}) {
     for (auto variant : variants) {
       SCOPED_TRACE(ProduceDebugText(rate, static_cast<int>(variant)));
       EchoCanceller3Tester(rate).RunEchoLeakageVerificationTest(variant);
     }
   }
 }
 
+TEST(EchoCanceller3, ConfigValidation) {
+  AudioProcessing::Config::EchoCanceller3 config;
+
+  config.echo_decay = 0.f;
+  EXPECT_TRUE(EchoCanceller3::Validate(config));
+  config.echo_decay = 0.9f;
+  EXPECT_TRUE(EchoCanceller3::Validate(config));
+  config.echo_decay = -0.1f;
+  EXPECT_FALSE(EchoCanceller3::Validate(config));
+  config.echo_decay = 1.0f;
+  EXPECT_FALSE(EchoCanceller3::Validate(config));
+  config.echo_decay = 1.1f;
+  EXPECT_FALSE(EchoCanceller3::Validate(config));
+}
+
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 TEST(EchoCanceller3InputCheck, WrongCaptureNumBandsCheckVerification) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate).RunProcessCaptureNumBandsCheckVerification();
   }
 }
 
 // TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
 // tests on test bots has been fixed.
 TEST(EchoCanceller3InputCheck,
      DISABLED_WrongRenderFrameLengthCheckVerification) {
   for (auto rate : {8000, 16000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate).RunAnalyzeRenderFrameLengthCheckVerification();
   }
 }
 
 TEST(EchoCanceller3InputCheck, WrongCaptureFrameLengthCheckVerification) {
   for (auto rate : {8000, 16000}) {
     SCOPED_TRACE(ProduceDebugText(rate));
     EchoCanceller3Tester(rate).RunProcessCaptureFrameLengthCheckVerification();
   }
 }
 
 // Verifiers that the verification for null input to the render analysis api
 // call works.
 TEST(EchoCanceller3InputCheck, NullRenderAnalysisParameter) {
-  EXPECT_DEATH(EchoCanceller3(8000, false).AnalyzeRender(nullptr), "");
+  EXPECT_DEATH(
+      EchoCanceller3(AudioProcessing::Config::EchoCanceller3(), 8000, false)
+          .AnalyzeRender(nullptr),
+      "");
 }
 
 // Verifiers that the verification for null input to the capture analysis api
 // call works.
 TEST(EchoCanceller3InputCheck, NullCaptureAnalysisParameter) {
-  EXPECT_DEATH(EchoCanceller3(8000, false).AnalyzeCapture(nullptr), "");
+  EXPECT_DEATH(
+      EchoCanceller3(AudioProcessing::Config::EchoCanceller3(), 8000, false)
+          .AnalyzeCapture(nullptr),
+      "");
 }
 
 // Verifiers that the verification for null input to the capture processing api
 // call works.
 TEST(EchoCanceller3InputCheck, NullCaptureProcessingParameter) {
-  EXPECT_DEATH(EchoCanceller3(8000, false).ProcessCapture(nullptr, false), "");
+  EXPECT_DEATH(
+      EchoCanceller3(AudioProcessing::Config::EchoCanceller3(), 8000, false)
+          .ProcessCapture(nullptr, false),
+      "");
 }
 
 // Verifies the check for correct sample rate.
 // TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
 // tests on test bots has been fixed.
 TEST(EchoCanceller3InputCheck, DISABLED_WrongSampleRate) {
   ApmDataDumper data_dumper(0);
-  EXPECT_DEATH(EchoCanceller3(8001, false), "");
+  EXPECT_DEATH(
+      EchoCanceller3(AudioProcessing::Config::EchoCanceller3(), 8001, false),
+      "");
 }
 
 #endif
 
 }  // namespace webrtc