Finalization of the first version of EchoCanceller 3

webrtc/modules/audio_processing/aec3/render_delay_controller_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/render_delay_controller.h"
 
 #include <algorithm>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "webrtc/base/random.h"
-#include "webrtc/modules/audio_processing/aec3/aec3_constants.h"
+#include "webrtc/modules/audio_processing/aec3/aec3_common.h"
 #include "webrtc/modules/audio_processing/aec3/render_delay_buffer.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, size_t delay) {
-  std::ostringstream ss(ProduceDebugText(sample_rate_hz));
-  ss << ", Delay: " << delay;
+  std::ostringstream ss;
+  ss << ProduceDebugText(sample_rate_hz) << ", Delay: " << delay;
   return ss.str();
 }
 
 std::string ProduceDebugText(int sample_rate_hz,
                              size_t delay,
                              size_t max_jitter) {
-  std::ostringstream ss(ProduceDebugText(sample_rate_hz, delay));
-  ss << ", Max Api call jitter: " << max_jitter;
+  std::ostringstream ss;
+  ss << ProduceDebugText(sample_rate_hz, delay)
+     << ", Max Api call jitter: " << max_jitter;
   return ss.str();
 }
 
 constexpr size_t kMaxApiCallJitter = 30;
 
 }  // namespace
 
 // Verifies the output of GetDelay when there are no AnalyzeRender calls.
 TEST(RenderDelayController, NoRenderSignal) {
   std::vector<float> block(kBlockSize, 0.f);
@@ skipping 48 matching lines @@
 }
 
 // Verifies that the RenderDelayController is able to align the signals for
 // simple timeshifts between the signals.
 TEST(RenderDelayController, Alignment) {
   Random random_generator(42U);
   std::vector<float> render_block(kBlockSize, 0.f);
   std::vector<float> capture_block(kBlockSize, 0.f);
   size_t delay_blocks = 0;
   for (auto rate : {8000, 16000, 32000, 48000}) {
-    for (size_t delay_samples : {0, 50, 150, 200, 800, 4000}) {
+    for (size_t delay_samples : {15, 50, 150, 200, 800, 4000}) {
       SCOPED_TRACE(ProduceDebugText(rate, delay_samples));
       std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
           RenderDelayBuffer::Create(250, NumBandsForRate(rate),
                                     kMaxApiCallJitter));
       std::unique_ptr<RenderDelayController> delay_controller(
           RenderDelayController::Create(rate, *render_delay_buffer));
       DelayBuffer<float> signal_delay_buffer(delay_samples);
-      for (size_t k = 0; k < (300 + delay_samples / kBlockSize); ++k) {
+      for (size_t k = 0; k < (400 + delay_samples / kBlockSize); ++k) {
         RandomizeSampleVector(&random_generator, render_block);
         signal_delay_buffer.Delay(render_block, capture_block);
         EXPECT_TRUE(delay_controller->AnalyzeRender(render_block));
         delay_blocks = delay_controller->GetDelay(capture_block);
       }
 
       constexpr int kDelayHeadroomBlocks = 1;
       size_t expected_delay_blocks =
           std::max(0, static_cast<int>(delay_samples / kBlockSize) -
                           kDelayHeadroomBlocks);
@@ skipping 12 matching lines @@
   }
 }
 
 // Verifies that the RenderDelayController is able to align the signals for
 // simple timeshifts between the signals when there is jitter in the API calls.
 TEST(RenderDelayController, AlignmentWithJitter) {
   Random random_generator(42U);
   std::vector<float> render_block(kBlockSize, 0.f);
   std::vector<float> capture_block(kBlockSize, 0.f);
   for (auto rate : {8000, 16000, 32000, 48000}) {
-    for (size_t delay_samples : {0, 50, 800}) {
+    for (size_t delay_samples : {15, 50, 800}) {
       for (size_t max_jitter : {1, 9, 20}) {
         size_t delay_blocks = 0;
         SCOPED_TRACE(ProduceDebugText(rate, delay_samples, max_jitter));
         std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
             RenderDelayBuffer::Create(250, NumBandsForRate(rate), max_jitter));
         std::unique_ptr<RenderDelayController> delay_controller(
             RenderDelayController::Create(rate, *render_delay_buffer));
         DelayBuffer<float> signal_delay_buffer(delay_samples);
         for (size_t j = 0;
              j < (300 + delay_samples / kBlockSize) / max_jitter + 1; ++j) {
@@ skipping 87 matching lines @@
                                   kMaxApiCallJitter));
     EXPECT_DEATH(std::unique_ptr<RenderDelayController>(
                      RenderDelayController::Create(rate, *render_delay_buffer)),
                  "");
   }
 }
 
 #endif
 
 }  // namespace webrtc