Major updates to the echo removal functionality in AEC3

webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc

Index: webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
diff --git a/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc b/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
index c9dd864ee9d6c01db7f38008c85a634ed19f5f28..85d9769bf33773adfef6286a70991a2f8e2b4f48 100644
--- a/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
+++ b/webrtc/modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
@@ -10,9 +10,6 @@
 
 #include "webrtc/modules/audio_processing/aec3/adaptive_fir_filter.h"
 
-// TODO(peah): Reactivate once the next CL has landed.
-#if 0
-
 #include <algorithm>
 #include <numeric>
 #include <string>
@@ -22,8 +19,9 @@
 #endif
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/random.h"
-#include "webrtc/modules/audio_processing/aec3/aec_state.h"
 #include "webrtc/modules/audio_processing/aec3/aec3_fft.h"
+#include "webrtc/modules/audio_processing/aec3/aec_state.h"
+#include "webrtc/modules/audio_processing/aec3/cascaded_biquad_filter.h"
 #include "webrtc/modules/audio_processing/aec3/render_signal_analyzer.h"
 #include "webrtc/modules/audio_processing/aec3/shadow_filter_update_gain.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
@@ -49,12 +47,10 @@ std::string ProduceDebugText(size_t delay) {
 TEST(AdaptiveFirFilter, TestOptimizations) {
   bool use_sse2 = (WebRtc_GetCPUInfo(kSSE2) != 0);
   if (use_sse2) {
-    FftBuffer X_buffer(Aec3Optimization::kNone, 12, std::vector<size_t>(1, 12));
-    std::array<float, kBlockSize> x_old;
-    x_old.fill(0.f);
+    RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 12,
+                               std::vector<size_t>(1, 12));
     Random random_generator(42U);
-    std::vector<float> x(kBlockSize, 0.f);
-    FftData X;
+    std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
     FftData S_C;
     FftData S_SSE2;
     FftData G;
@@ -69,12 +65,11 @@ TEST(AdaptiveFirFilter, TestOptimizations) {
     }
 
     for (size_t k = 0; k < 500; ++k) {
-      RandomizeSampleVector(&random_generator, x);
-      fft.PaddedFft(x, x_old, &X);
-      X_buffer.Insert(X);
+      RandomizeSampleVector(&random_generator, x[0]);
+      render_buffer.Insert(x);
 
-      ApplyFilter_SSE2(X_buffer, H_SSE2, &S_SSE2);
-      ApplyFilter(X_buffer, H_C, &S_C);
+      ApplyFilter_SSE2(render_buffer, H_SSE2, &S_SSE2);
+      ApplyFilter(render_buffer, H_C, &S_C);
       for (size_t j = 0; j < S_C.re.size(); ++j) {
         EXPECT_FLOAT_EQ(S_C.re[j], S_SSE2.re[j]);
         EXPECT_FLOAT_EQ(S_C.im[j], S_SSE2.im[j]);
@@ -85,8 +80,8 @@ TEST(AdaptiveFirFilter, TestOptimizations) {
       std::for_each(G.im.begin(), G.im.end(),
                     [&](float& a) { a = random_generator.Rand<float>(); });
 
-      AdaptPartitions_SSE2(X_buffer, G, H_SSE2);
-      AdaptPartitions(X_buffer, G, H_C);
+      AdaptPartitions_SSE2(render_buffer, G, H_SSE2);
+      AdaptPartitions(render_buffer, G, H_C);
 
       for (size_t k = 0; k < H_C.size(); ++k) {
         for (size_t j = 0; j < H_C[k].re.size(); ++j) {
@@ -103,32 +98,17 @@ TEST(AdaptiveFirFilter, TestOptimizations) {
 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 // Verifies that the check for non-null data dumper works.
 TEST(AdaptiveFirFilter, NullDataDumper) {
-  EXPECT_DEATH(AdaptiveFirFilter(9, true, DetectOptimization(), nullptr), "");
+  EXPECT_DEATH(AdaptiveFirFilter(9, DetectOptimization(), nullptr), "");
 }
 
 // Verifies that the check for non-null filter output works.
 TEST(AdaptiveFirFilter, NullFilterOutput) {
   ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, true, DetectOptimization(), &data_dumper);
-  FftBuffer X_buffer(Aec3Optimization::kNone, filter.SizePartitions(),
-                     std::vector<size_t>(1, filter.SizePartitions()));
-  EXPECT_DEATH(filter.Filter(X_buffer, nullptr), "");
-}
-
-// Verifies that the check for whether filter statistics are being generated
-// works when retrieving the ERL.
-TEST(AdaptiveFirFilter, ErlAccessWhenNoFilterStatistics) {
-  ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, false, DetectOptimization(), &data_dumper);
-  EXPECT_DEATH(filter.Erl(), "");
-}
-
-// Verifies that the check for whether filter statistics are being generated
-// works when retrieving the filter frequencyResponse.
-TEST(AdaptiveFirFilter, FilterFrequencyResponseAccessWhenNoFilterStatistics) {
-  ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, false, DetectOptimization(), &data_dumper);
-  EXPECT_DEATH(filter.FilterFrequencyResponse(), "");
+  AdaptiveFirFilter filter(9, DetectOptimization(), &data_dumper);
+  RenderBuffer render_buffer(Aec3Optimization::kNone, 3,
+                             filter.SizePartitions(),
+                             std::vector<size_t>(1, filter.SizePartitions()));
+  EXPECT_DEATH(filter.Filter(render_buffer, nullptr), "");
 }
 
 #endif
@@ -137,7 +117,7 @@ TEST(AdaptiveFirFilter, FilterFrequencyResponseAccessWhenNoFilterStatistics) {
 // are turned on.
 TEST(AdaptiveFirFilter, FilterStatisticsAccess) {
   ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, true, DetectOptimization(), &data_dumper);
+  AdaptiveFirFilter filter(9, DetectOptimization(), &data_dumper);
   filter.Erl();
   filter.FilterFrequencyResponse();
 }
@@ -146,8 +126,7 @@ TEST(AdaptiveFirFilter, FilterStatisticsAccess) {
 TEST(AdaptiveFirFilter, FilterSize) {
   ApmDataDumper data_dumper(42);
   for (size_t filter_size = 1; filter_size < 5; ++filter_size) {
-    AdaptiveFirFilter filter(filter_size, false, DetectOptimization(),
-                             &data_dumper);
+    AdaptiveFirFilter filter(filter_size, DetectOptimization(), &data_dumper);
     EXPECT_EQ(filter_size, filter.SizePartitions());
   }
 }
@@ -157,19 +136,18 @@ TEST(AdaptiveFirFilter, FilterSize) {
 TEST(AdaptiveFirFilter, FilterAndAdapt) {
   constexpr size_t kNumBlocksToProcess = 500;
   ApmDataDumper data_dumper(42);
-  AdaptiveFirFilter filter(9, true, DetectOptimization(), &data_dumper);
+  AdaptiveFirFilter filter(9, DetectOptimization(), &data_dumper);
   Aec3Fft fft;
-  FftBuffer X_buffer(Aec3Optimization::kNone, filter.SizePartitions(),
-                     std::vector<size_t>(1, filter.SizePartitions()));
-  std::array<float, kBlockSize> x_old;
-  x_old.fill(0.f);
+  RenderBuffer render_buffer(Aec3Optimization::kNone, 3,
+                             filter.SizePartitions(),
+                             std::vector<size_t>(1, filter.SizePartitions()));
   ShadowFilterUpdateGain gain;
   Random random_generator(42U);
-  std::vector<float> x(kBlockSize, 0.f);
+  std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
+  std::vector<float> n(kBlockSize, 0.f);
   std::vector<float> y(kBlockSize, 0.f);
   AecState aec_state;
   RenderSignalAnalyzer render_signal_analyzer;
-  FftData X;
   std::vector<float> e(kBlockSize, 0.f);
   std::array<float, kFftLength> s;
   FftData S;
@@ -178,6 +156,10 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
   std::array<float, kFftLengthBy2Plus1> Y2;
   std::array<float, kFftLengthBy2Plus1> E2_main;
   std::array<float, kFftLengthBy2Plus1> E2_shadow;
+  // [B,A] = butter(2,100/8000,'high')
+  constexpr CascadedBiQuadFilter::BiQuadCoefficients
+      kHighPassFilterCoefficients = {{0.97261f, -1.94523f, 0.97261f},
+                                     {-1.94448f, 0.94598f}};
   Y2.fill(0.f);
   E2_main.fill(0.f);
   E2_shadow.fill(0.f);
@@ -186,16 +168,27 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
 
   for (size_t delay_samples : {0, 64, 150, 200, 301}) {
     DelayBuffer<float> delay_buffer(delay_samples);
+    CascadedBiQuadFilter x_hp_filter(kHighPassFilterCoefficients, 1);
+    CascadedBiQuadFilter y_hp_filter(kHighPassFilterCoefficients, 1);
+
     SCOPED_TRACE(ProduceDebugText(delay_samples));
     for (size_t k = 0; k < kNumBlocksToProcess; ++k) {
-      RandomizeSampleVector(&random_generator, x);
-      delay_buffer.Delay(x, y);
+      RandomizeSampleVector(&random_generator, x[0]);
+      delay_buffer.Delay(x[0], y);
+
+      RandomizeSampleVector(&random_generator, n);
+      constexpr float kNoiseScaling = 1.f / 100.f;
+      std::transform(
+          y.begin(), y.end(), n.begin(), y.begin(),
+          [kNoiseScaling](float a, float b) { return a + b * kNoiseScaling; });
 
-      fft.PaddedFft(x, x_old, &X);
-      X_buffer.Insert(X);
-      render_signal_analyzer.Update(X_buffer, aec_state.FilterDelay());
+      x_hp_filter.Process(x[0]);
+      y_hp_filter.Process(y);
 
-      filter.Filter(X_buffer, &S);
+      render_buffer.Insert(x);
+      render_signal_analyzer.Update(render_buffer, aec_state.FilterDelay());
+
+      filter.Filter(render_buffer, &S);
       fft.Ifft(S, &s);
       std::transform(y.begin(), y.end(), s.begin() + kFftLengthBy2, e.begin(),
                      [&](float a, float b) { return a - b * kScale; });
@@ -204,12 +197,13 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
       });
       fft.ZeroPaddedFft(e, &E);
 
-      gain.Compute(X_buffer, render_signal_analyzer, E, filter.SizePartitions(),
-                   false, &G);
-      filter.Adapt(X_buffer, G);
+      gain.Compute(render_buffer, render_signal_analyzer, E,
+                   filter.SizePartitions(), false, &G);
+      filter.Adapt(render_buffer, G);
+      aec_state.HandleEchoPathChange(EchoPathVariability(false, false));
       aec_state.Update(filter.FilterFrequencyResponse(),
-                       rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow,
-                       Y2, x, EchoPathVariability(false, false), false);
+                       rtc::Optional<size_t>(), render_buffer, E2_main, Y2,
+                       x[0], false);
     }
     // Verify that the filter is able to perform well.
     EXPECT_LT(1000 * std::inner_product(e.begin(), e.end(), e.begin(), 0.f),
@@ -220,5 +214,3 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
 }
 }  // namespace aec3
 }  // namespace webrtc
-
-#endif