cf02cf13a7
This CL adds major render pipeline changes to the AEC3 code. The reason for these are that 1) It allows the echo removal unit to receive information about the content in bands beyond band 0, thereby allowing removal of high-frequency echoes 2) It allows more controlled handling of the render buffers, allowing proper buffer behaviour during capture glitches and clock-drift. Unfortunately, the render pipeline caused a lot of related changes in much of the rest of the AEC3 files. Most of these are, however, caused by a change of class name. Another unfortunate effect of this CL, is that a number of unittest cease to compile. I chose to temporarily solve that by removing them from the build using #if/#endif. The reason for that is that those will anyway again need to be changed in the next review, and doing like this avoids them having to be reviewed twice. BUG=webrtc:6018 Review-Url: https://codereview.webrtc.org/2784023002 Cr-Commit-Position: refs/heads/master@{#17547}
196 lines
7.6 KiB
C++
196 lines
7.6 KiB
C++
/*
|
|
* 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/base/random.h"
|
|
#include "webrtc/modules/audio_processing/aec3/aec3_common.h"
|
|
#include "webrtc/modules/audio_processing/aec3/render_buffer.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, 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}) {
|
|
SCOPED_TRACE(ProduceDebugText(rate));
|
|
std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
|
|
std::unique_ptr<RenderDelayBuffer> render_buffer(
|
|
RenderDelayBuffer::Create(NumBandsForRate(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 =
|
|
(k % 6 == 0 ? rtc::Optional<size_t>(k * 10)
|
|
: rtc::Optional<size_t>());
|
|
render_buffer->Insert(render);
|
|
render_buffer->UpdateBuffers();
|
|
remover->ProcessCapture(echo_path_delay_samples, echo_path_variability,
|
|
k % 2 == 0 ? true : false,
|
|
render_buffer->GetRenderBuffer(), &capture);
|
|
}
|
|
}
|
|
}
|
|
|
|
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
|
|
|
|
// 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 capture block size.
|
|
TEST(EchoRemover, WrongCaptureBlockSize) {
|
|
for (auto rate : {8000, 16000, 32000, 48000}) {
|
|
SCOPED_TRACE(ProduceDebugText(rate));
|
|
std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
|
|
std::unique_ptr<RenderDelayBuffer> render_buffer(
|
|
RenderDelayBuffer::Create(NumBandsForRate(rate)));
|
|
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->ProcessCapture(
|
|
echo_path_delay_samples, echo_path_variability, false,
|
|
render_buffer->GetRenderBuffer(), &capture),
|
|
"");
|
|
}
|
|
}
|
|
|
|
// Verifies the check for the number of capture bands.
|
|
// 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}) {
|
|
SCOPED_TRACE(ProduceDebugText(rate));
|
|
std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
|
|
std::unique_ptr<RenderDelayBuffer> render_buffer(
|
|
RenderDelayBuffer::Create(NumBandsForRate(rate)));
|
|
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(remover->ProcessCapture(
|
|
echo_path_delay_samples, echo_path_variability, false,
|
|
render_buffer->GetRenderBuffer(), &capture),
|
|
"");
|
|
}
|
|
}
|
|
|
|
// Verifies the check for non-null capture block.
|
|
TEST(EchoRemover, NullCapture) {
|
|
std::unique_ptr<EchoRemover> remover(EchoRemover::Create(8000));
|
|
std::unique_ptr<RenderDelayBuffer> render_buffer(
|
|
RenderDelayBuffer::Create(3));
|
|
EchoPathVariability echo_path_variability(false, false);
|
|
rtc::Optional<size_t> echo_path_delay_samples;
|
|
EXPECT_DEATH(
|
|
remover->ProcessCapture(echo_path_delay_samples, echo_path_variability,
|
|
false, render_buffer->GetRenderBuffer(), nullptr),
|
|
"");
|
|
}
|
|
|
|
#endif
|
|
|
|
// Performs a sanity check that the echo_remover is able to properly
|
|
// 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}) {
|
|
SCOPED_TRACE(ProduceDebugText(rate, delay_samples));
|
|
std::unique_ptr<EchoRemover> remover(EchoRemover::Create(rate));
|
|
std::unique_ptr<RenderDelayBuffer> render_buffer(
|
|
RenderDelayBuffer::Create(NumBandsForRate(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);
|
|
}
|
|
}
|
|
|
|
render_buffer->Insert(x);
|
|
render_buffer->UpdateBuffers();
|
|
|
|
remover->ProcessCapture(rtc::Optional<size_t>(delay_samples),
|
|
echo_path_variability, false,
|
|
render_buffer->GetRenderBuffer(), &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
|