Finalization of the first version of EchoCanceller 3

webrtc/modules/audio_processing/aec3/echo_remover_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/echo_remover.h"
 
+#include <algorithm>
 #include <memory>
+#include <numeric>
 #include <sstream>
 #include <string>
 
-#include "webrtc/modules/audio_processing/aec3/aec3_constants.h"
+#include "webrtc/base/random.h"
+#include "webrtc/modules/audio_processing/aec3/aec3_common.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
+#include "webrtc/modules/audio_processing/test/echo_canceller_test_tools.h"
 #include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace {
 
 std::string ProduceDebugText(int sample_rate_hz) {
   std::ostringstream ss;
   ss << "Sample rate: " << sample_rate_hz;
   return ss.str();
 }
 
+std::string ProduceDebugText(int sample_rate_hz, int delay) {
+  std::ostringstream ss(ProduceDebugText(sample_rate_hz));
+  ss << ", Delay: " << delay;
+  return ss.str();
+}
+
 }  // namespace
 
 // Verifies the basic API call sequence
 TEST(EchoRemover, BasicApiCalls) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
-    ProduceDebugText(rate);
+    SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
 
     std::vector<std::vector<float>> render(NumBandsForRate(rate),
                                            std::vector<float>(kBlockSize, 0.f));
     std::vector<std::vector<float>> capture(
         NumBandsForRate(rate), std::vector<float>(kBlockSize, 0.f));
     for (size_t k = 0; k < 100; ++k) {
       EchoPathVariability echo_path_variability(k % 3 == 0 ? true : false,
                                                 k % 5 == 0 ? true : false);
       rtc::Optional<size_t> echo_path_delay_samples =
@@ skipping 11 matching lines @@
 // Verifies the check for the samplerate.
 // TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
 // tests on test bots has been fixed.
 TEST(EchoRemover, DISABLED_WrongSampleRate) {
   EXPECT_DEATH(std::unique_ptr<EchoRemover>(EchoRemover::Create(8001)), "");
 }
 
 // Verifies the check for the render block size.
 TEST(EchoRemover, WrongRenderBlockSize) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
-    ProduceDebugText(rate);
+    SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
 
     std::vector<std::vector<float>> render(
         NumBandsForRate(rate), std::vector<float>(kBlockSize - 1, 0.f));
     std::vector<std::vector<float>> capture(
         NumBandsForRate(rate), std::vector<float>(kBlockSize, 0.f));
     EchoPathVariability echo_path_variability(false, false);
     rtc::Optional<size_t> echo_path_delay_samples;
     EXPECT_DEATH(
         remover->ProcessBlock(echo_path_delay_samples, echo_path_variability,
                               false, render, &capture),
         "");
   }
 }
 
 // Verifies the check for the capture block size.
 TEST(EchoRemover, WrongCaptureBlockSize) {
   for (auto rate : {8000, 16000, 32000, 48000}) {
-    ProduceDebugText(rate);
+    SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
 
     std::vector<std::vector<float>> render(NumBandsForRate(rate),
                                            std::vector<float>(kBlockSize, 0.f));
     std::vector<std::vector<float>> capture(
         NumBandsForRate(rate), std::vector<float>(kBlockSize - 1, 0.f));
     EchoPathVariability echo_path_variability(false, false);
     rtc::Optional<size_t> echo_path_delay_samples;
     EXPECT_DEATH(
         remover->ProcessBlock(echo_path_delay_samples, echo_path_variability,
                               false, render, &capture),
         "");
   }
 }
 
 // Verifies the check for the number of render bands.
 TEST(EchoRemover, WrongRenderNumBands) {
   for (auto rate : {16000, 32000, 48000}) {
-    ProduceDebugText(rate);
+    SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
 
     std::vector<std::vector<float>> render(
         NumBandsForRate(rate == 48000 ? 16000 : rate + 16000),
         std::vector<float>(kBlockSize, 0.f));
     std::vector<std::vector<float>> capture(
         NumBandsForRate(rate), std::vector<float>(kBlockSize, 0.f));
     EchoPathVariability echo_path_variability(false, false);
     rtc::Optional<size_t> echo_path_delay_samples;
     EXPECT_DEATH(
         remover->ProcessBlock(echo_path_delay_samples, echo_path_variability,
                               false, render, &capture),
         "");
   }
 }
 
 // Verifies the check for the number of capture bands.
-TEST(EchoRemover, WrongCaptureNumBands) {
+// TODO(peah): Re-enable the test once the issue with memory leaks during DEATH
+// tests on test bots has been fixed.c
+TEST(EchoRemover, DISABLED_WrongCaptureNumBands) {
   for (auto rate : {16000, 32000, 48000}) {
-    ProduceDebugText(rate);
+    SCOPED_TRACE(ProduceDebugText(rate));
     std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
 
     std::vector<std::vector<float>> render(NumBandsForRate(rate),
                                            std::vector<float>(kBlockSize, 0.f));
     std::vector<std::vector<float>> capture(
         NumBandsForRate(rate == 48000 ? 16000 : rate + 16000),
         std::vector<float>(kBlockSize, 0.f));
     EchoPathVariability echo_path_variability(false, false);
     rtc::Optional<size_t> echo_path_delay_samples;
     EXPECT_DEATH(
@@ skipping 12 matching lines @@
   EchoPathVariability echo_path_variability(false, false);
   rtc::Optional<size_t> echo_path_delay_samples;
   EXPECT_DEATH(
       remover->ProcessBlock(echo_path_delay_samples, echo_path_variability,
                             false, render, nullptr),
       "");
 }
 
 #endif
 
+// Performs a sanity check that the echo_remover is being able to properly

[ivoc, 2017/02/22 17:08:13]

"being" can be safely removed, in my opinion.

[peah-webrtc, 2017/02/22 23:51:38]

Done.

+// remove echoes.
+TEST(EchoRemover, BasicEchoRemoval) {
+  constexpr int kNumBlocksToProcess = 500;
+  Random random_generator(42U);
+  for (auto rate : {8000, 16000, 32000, 48000}) {
+    std::vector<std::vector<float>> x(NumBandsForRate(rate),
+                                      std::vector<float>(kBlockSize, 0.f));
+    std::vector<std::vector<float>> y(NumBandsForRate(rate),
+                                      std::vector<float>(kBlockSize, 0.f));
+    EchoPathVariability echo_path_variability(false, false);
+    for (size_t delay_samples : {0, 64, 150, 200, 301}) {
+      ProduceDebugText(rate, delay_samples);

[ivoc, 2017/02/22 17:08:12]

scoped trace?

[peah-webrtc, 2017/02/22 23:51:37]

Done.

+      std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
+      std::vector<std::unique_ptr<DelayBuffer<float>>> delay_buffers(x.size());
+      for (size_t j = 0; j < x.size(); ++j) {
+        delay_buffers[j].reset(new DelayBuffer<float>(delay_samples));
+      }
+
+      float input_energy = 0.f;
+      float output_energy = 0.f;
+      for (int k = 0; k < kNumBlocksToProcess; ++k) {
+        const bool silence = k < 100 || (k % 100 >= 10);
+
+        for (size_t j = 0; j < x.size(); ++j) {
+          if (silence) {
+            std::fill(x[j].begin(), x[j].end(), 0.f);
+          } else {
+            RandomizeSampleVector(&random_generator, x[j]);
+          }
+          delay_buffers[j]->Delay(x[j], y[j]);
+        }
+
+        if (k > kNumBlocksToProcess / 2) {
+          for (size_t j = 0; j < x.size(); ++j) {
+            input_energy = std::inner_product(y[j].begin(), y[j].end(),
+                                              y[j].begin(), input_energy);
+          }
+        }
+
+        remover->ProcessBlock(rtc::Optional<size_t>(delay_samples),
+                              echo_path_variability, false, x, &y);
+
+        if (k > kNumBlocksToProcess / 2) {
+          for (size_t j = 0; j < x.size(); ++j) {
+            output_energy = std::inner_product(y[j].begin(), y[j].end(),
+                                               y[j].begin(), output_energy);
+          }
+        }
+      }
+      EXPECT_GT(input_energy, 10.f * output_energy);
+    }
+  }
+}
+
 }  // namespace webrtc