Added the ability to adjust the AEC3 performance for large rooms

webrtc/modules/audio_processing/aec3/aec_state_unittest.cc

 /*
  *  Copyright (c) 2017 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.
  */
 
 #include "webrtc/modules/audio_processing/aec3/aec_state.h"
 
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 
 // Verify the general functionality of AecState
 TEST(AecState, NormalUsage) {
   ApmDataDumper data_dumper(42);
-  AecState state;
+  AecState state(0.f);
   RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
                              std::vector<size_t>(1, 30));
   std::array<float, kFftLengthBy2Plus1> E2_main = {};
   std::array<float, kFftLengthBy2Plus1> Y2 = {};
   std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
   EchoPathVariability echo_path_variability(false, false);
 
   std::vector<std::array<float, kFftLengthBy2Plus1>>
       converged_filter_frequency_response(10);
   for (auto& v : converged_filter_frequency_response) {
@@ skipping 109 matching lines @@
     }
     for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; ++k) {
       EXPECT_NEAR(k % 2 == 0 ? 1.5f : 1.f, erle[k], 0.1);
     }
     EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]);
   }
 }
 
 // Verifies the a non-significant delay is correctly identified.
 TEST(AecState, NonSignificantDelay) {
-  AecState state;
+  AecState state(0.f);
   RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
                              std::vector<size_t>(1, 30));
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kBlockSize> x;
   EchoPathVariability echo_path_variability(false, false);
   x.fill(0.f);
 
   std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30);
   for (auto& v : frequency_response) {
     v.fill(0.01f);
   }
 
   // Verify that a non-significant filter delay is identified correctly.
   state.HandleEchoPathChange(echo_path_variability);
   state.Update(frequency_response, rtc::Optional<size_t>(), render_buffer,
                E2_main, Y2, x, false);
   EXPECT_FALSE(state.FilterDelay());
 }
 
 // Verifies the delay for a converged filter is correctly identified.
 TEST(AecState, ConvergedFilterDelay) {
   constexpr int kFilterLength = 10;
-  AecState state;
+  AecState state(0.f);
   RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
                              std::vector<size_t>(1, 30));
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kBlockSize> x;
   EchoPathVariability echo_path_variability(false, false);
   x.fill(0.f);
 
   std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(
       kFilterLength);
@@ skipping 10 matching lines @@
                  E2_main, Y2, x, false);
     EXPECT_TRUE(k == (kFilterLength - 1) || state.FilterDelay());
     if (k != (kFilterLength - 1)) {
       EXPECT_EQ(k, state.FilterDelay());
     }
   }
 }
 
 // Verify that the externally reported delay is properly reported and converted.
 TEST(AecState, ExternalDelay) {
-  AecState state;
+  AecState state(0.f);
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> E2_shadow;
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kBlockSize> x;
   E2_main.fill(0.f);
   E2_shadow.fill(0.f);
   Y2.fill(0.f);
   x.fill(0.f);
   RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
                              std::vector<size_t>(1, 30));
@@ skipping 12 matching lines @@
 
   // Verify that the externally reported delay is properly unset when it is no
   // longer present.
   state.HandleEchoPathChange(EchoPathVariability(false, false));
   state.Update(frequency_response, rtc::Optional<size_t>(), render_buffer,
                E2_main, Y2, x, false);
   EXPECT_FALSE(state.ExternalDelay());
 }
 
 }  // namespace webrtc