Finalization of the first version of EchoCanceller 3

webrtc/modules/audio_processing/aec3/power_echo_model_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/power_echo_model.h"
+
+#include <array>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/random.h"
+#include "webrtc/modules/audio_processing/aec3/aec_state.h"
+#include "webrtc/modules/audio_processing/aec3/aec3_common.h"
+#include "webrtc/modules/audio_processing/aec3/aec3_fft.h"
+#include "webrtc/modules/audio_processing/aec3/echo_path_variability.h"
+#include "webrtc/modules/audio_processing/test/echo_canceller_test_tools.h"
+
+#include "webrtc/test/gtest.h"
+
+namespace webrtc {
+namespace {
+
+std::string ProduceDebugText(size_t delay, bool known_delay) {
+  std::ostringstream ss;
+  ss << "True delay: " << delay;
+  ss << ", Delay known: " << (known_delay ? "true" : "false");
+  return ss.str();
+}
+
+}  // namespace
+
+#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
+
+// Verifies that the check for non-null output parameter works.
+TEST(PowerEchoModel, NullEstimateEchoOutput) {
+  PowerEchoModel model;
+  std::array<float, kFftLengthBy2Plus1> Y2;
+  AecState aec_state;
+  FftBuffer X_buffer(Aec3Optimization::kNone, model.MinFarendBufferLength(),
+                     std::vector<size_t>(1, model.MinFarendBufferLength()));
+
+  EXPECT_DEATH(model.EstimateEcho(X_buffer, Y2, aec_state, nullptr), "");
+}
+
+#endif
+
+TEST(PowerEchoModel, BasicSetup) {
+  PowerEchoModel model;
+  Random random_generator(42U);
+  AecState aec_state;
+  Aec3Fft fft;
+  std::array<float, kFftLengthBy2Plus1> Y2;
+  std::array<float, kFftLengthBy2Plus1> S2;
+  std::array<float, kFftLengthBy2Plus1> E2_main;
+  std::array<float, kFftLengthBy2Plus1> E2_shadow;
+  std::array<float, kBlockSize> x_old;
+  std::array<float, kBlockSize> y;
+  std::vector<float> x(kBlockSize, 0.f);
+  FftData X;
+  FftData Y;
+  x_old.fill(0.f);
+
+  FftBuffer X_buffer(Aec3Optimization::kNone, model.MinFarendBufferLength(),
+                     std::vector<size_t>(1, model.MinFarendBufferLength()));
+
+  for (size_t delay_samples : {0, 64, 301}) {
+    DelayBuffer<float> delay_buffer(delay_samples);
+    auto model_applier = [&](int num_iterations, float y_scale,
+                             bool known_delay) {
+      for (int k = 0; k < num_iterations; ++k) {
+        RandomizeSampleVector(&random_generator, x);
+        delay_buffer.Delay(x, y);
+        std::for_each(y.begin(), y.end(), [&](float& a) { a *= y_scale; });
+
+        fft.PaddedFft(x, x_old, &X);
+        X_buffer.Insert(X);
+
+        fft.ZeroPaddedFft(y, &Y);
+        Y.Spectrum(Aec3Optimization::kNone, &Y2);
+
+        aec_state.Update(std::vector<std::array<float, kFftLengthBy2Plus1>>(
+                             10, std::array<float, kFftLengthBy2Plus1>()),
+                         known_delay ? rtc::Optional<size_t>(delay_samples)
+                                     : rtc::Optional<size_t>(),
+                         X_buffer, E2_main, E2_shadow, Y2, x,
+                         EchoPathVariability(false, false), false);
+
+        model.EstimateEcho(X_buffer, Y2, aec_state, &S2);
+      }
+    };
+
+    for (int j = 0; j < 2; ++j) {
+      bool known_delay = j == 0;
+      SCOPED_TRACE(ProduceDebugText(delay_samples, known_delay));
+      // Verify that the echo path estimates converges downwards to a fairly
+      // tight bound estimate.
+      model_applier(600, 1.f, known_delay);
+      for (size_t k = 1; k < S2.size() - 1; ++k) {
+        EXPECT_LE(Y2[k], 2.f * S2[k]);
+      }
+
+      // Verify that stronger echo paths are detected immediately.
+      model_applier(100, 10.f, known_delay);
+      for (size_t k = 1; k < S2.size() - 1; ++k) {
+        EXPECT_LE(Y2[k], 5.f * S2[k]);
+      }
+
+      // Verify that there is a delay until a weaker echo path is detected.
+      model_applier(50, 100.f, known_delay);
+      model_applier(50, 1.f, known_delay);
+      for (size_t k = 1; k < S2.size() - 1; ++k) {
+        EXPECT_LE(100.f * Y2[k], S2[k]);
+      }
+
+      // Verify that an echo path change causes the echo path estimate to be
+      // reset.
+      model_applier(600, 0.1f, known_delay);
+      model.HandleEchoPathChange(EchoPathVariability(true, false));
+      model_applier(50, 0.1f, known_delay);
+      for (size_t k = 1; k < S2.size() - 1; ++k) {
+        EXPECT_LE(10.f * Y2[k], S2[k]);
+      }
+    }
+  }
+}
+
+}  // namespace webrtc