admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Corrected the detection of narrowband render signals

Browse Source 
This CL corrects the bug that only looked at narrowband
render signals above 900 Hz and only assumed that the
influence of such lasted for 6 blocks, which resulted
in filter divergence and echo leakage.


Bug: webrtc:9008,chromium:821670
Change-Id: I9b2635d24b260e9d9a8c5c088ab663e03fb93c42
Reviewed-on: https://webrtc-review.googlesource.com/61800
Commit-Queue: Per Åhgren <peah@webrtc.org>
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22434}
This commit is contained in:
Per Åhgren 2018-03-14 23:23:47 +01:00 committed by Commit Bot
parent ee205f5bba
commit 971de07713
9 changed files with 35 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/audio_processing/aec3/adaptive_fir_filter_unittest.cc
View File

@ -320,7 +320,7 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
std::vector<float> n(kBlockSize, 0.f); std::vector<float> n(kBlockSize, 0.f);
std::vector<float> y(kBlockSize, 0.f); std::vector<float> y(kBlockSize, 0.f);
AecState aec_state(EchoCanceller3Config{}); AecState aec_state(EchoCanceller3Config{});
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
rtc::Optional<DelayEstimate> delay_estimate; rtc::Optional<DelayEstimate> delay_estimate;
std::vector<float> e(kBlockSize, 0.f); std::vector<float> e(kBlockSize, 0.f);
std::array<float, kFftLength> s_scratch; std::array<float, kFftLength> s_scratch;

1
modules/audio_processing/aec3/echo_remover.cc
View File

@ -106,6 +106,7 @@ EchoRemoverImpl::EchoRemoverImpl(const EchoCanceller3Config& config,
suppression_gain_(config_, optimization_), suppression_gain_(config_, optimization_),
cng_(optimization_), cng_(optimization_),
suppression_filter_(sample_rate_hz_), suppression_filter_(sample_rate_hz_),
render_signal_analyzer_(config_),
residual_echo_estimator_(config_), residual_echo_estimator_(config_),
aec_state_(config_) { aec_state_(config_) {
RTC_DCHECK(ValidFullBandRate(sample_rate_hz)); RTC_DCHECK(ValidFullBandRate(sample_rate_hz));

4
modules/audio_processing/aec3/main_filter_update_gain_unittest.cc
View File

@ -61,7 +61,7 @@ void RunFilterUpdateTest(int num_blocks_to_process,
std::unique_ptr<RenderDelayBuffer> render_delay_buffer( std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
RenderDelayBuffer::Create(config, 3)); RenderDelayBuffer::Create(config, 3));
AecState aec_state(config); AecState aec_state(config);
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
rtc::Optional<DelayEstimate> delay_estimate; rtc::Optional<DelayEstimate> delay_estimate;
std::array<float, kFftLength> s_scratch; std::array<float, kFftLength> s_scratch;
std::array<float, kBlockSize> s; std::array<float, kBlockSize> s;
@ -190,7 +190,7 @@ TEST(MainFilterUpdateGain, NullDataOutputGain) {
EchoCanceller3Config config; EchoCanceller3Config config;
AdaptiveFirFilter filter(config.filter.main.length_blocks, AdaptiveFirFilter filter(config.filter.main.length_blocks,
DetectOptimization(), &data_dumper); DetectOptimization(), &data_dumper);
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
SubtractorOutput output; SubtractorOutput output;
MainFilterUpdateGain gain(config.filter.main); MainFilterUpdateGain gain(config.filter.main);
std::array<float, kFftLengthBy2Plus1> render_power; std::array<float, kFftLengthBy2Plus1> render_power;

18
modules/audio_processing/aec3/render_signal_analyzer.cc
View File

@ -42,6 +42,7 @@ void IdentifySmallNarrowBandRegions(
// Identifies whether the signal has a single strong narrow-band component. // Identifies whether the signal has a single strong narrow-band component.
void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer, void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
int strong_peak_freeze_duration,
rtc::Optional<int>* narrow_peak_band, rtc::Optional<int>* narrow_peak_band,
size_t* narrow_peak_counter) { size_t* narrow_peak_counter) {
const auto X2_latest = render_buffer.Spectrum(0); const auto X2_latest = render_buffer.Spectrum(0);
@ -52,7 +53,7 @@ void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
// Compute the level around the peak. // Compute the level around the peak.
float non_peak_power = 0.f; float non_peak_power = 0.f;
for (int k = std::max(5, peak_bin - 14); k < peak_bin - 4; ++k) { for (int k = std::max(0, peak_bin - 14); k < peak_bin - 4; ++k) {
non_peak_power = std::max(X2_latest[k], non_peak_power); non_peak_power = std::max(X2_latest[k], non_peak_power);
} }
for (int k = peak_bin + 5; for (int k = peak_bin + 5;
@ -60,7 +61,7 @@ void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
non_peak_power = std::max(X2_latest[k], non_peak_power); non_peak_power = std::max(X2_latest[k], non_peak_power);
} }
// Assess the render signal strength // Assess the render signal strength.
const std::vector<std::vector<float>>& x_latest = render_buffer.Block(0); const std::vector<std::vector<float>>& x_latest = render_buffer.Block(0);
auto result0 = std::minmax_element(x_latest[0].begin(), x_latest[0].end()); auto result0 = std::minmax_element(x_latest[0].begin(), x_latest[0].end());
float max_abs = std::max(fabs(*result0.first), fabs(*result0.second)); float max_abs = std::max(fabs(*result0.first), fabs(*result0.second));
@ -74,12 +75,14 @@ void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
} }
// Detect whether the spectal peak has as strong narrowband nature. // Detect whether the spectal peak has as strong narrowband nature.
if (peak_bin > 6 && max_abs > 100 && if (peak_bin > 0 && max_abs > 100 &&
X2_latest[peak_bin] > 100 * non_peak_power) { X2_latest[peak_bin] > 100 * non_peak_power) {
*narrow_peak_band = peak_bin; *narrow_peak_band = peak_bin;
*narrow_peak_counter = 0; *narrow_peak_counter = 0;
} else { } else {
if (*narrow_peak_band && ++(*narrow_peak_counter) > 7) { if (*narrow_peak_band &&
++(*narrow_peak_counter) >
static_cast<size_t>(strong_peak_freeze_duration)) {
*narrow_peak_band = rtc::nullopt; *narrow_peak_band = rtc::nullopt;
} }
} }
@ -87,7 +90,8 @@ void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
} // namespace } // namespace
RenderSignalAnalyzer::RenderSignalAnalyzer() { RenderSignalAnalyzer::RenderSignalAnalyzer(const EchoCanceller3Config& config)
: strong_peak_freeze_duration_(config.filter.main.length_blocks) {
narrow_band_counters_.fill(0); narrow_band_counters_.fill(0);
} }
RenderSignalAnalyzer::~RenderSignalAnalyzer() = default; RenderSignalAnalyzer::~RenderSignalAnalyzer() = default;
@ -100,8 +104,8 @@ void RenderSignalAnalyzer::Update(
&narrow_band_counters_); &narrow_band_counters_);
// Identify the presence of a strong narrow band. // Identify the presence of a strong narrow band.
IdentifyStrongNarrowBandComponent(render_buffer, &narrow_peak_band_, IdentifyStrongNarrowBandComponent(render_buffer, strong_peak_freeze_duration_,
&narrow_peak_counter_); &narrow_peak_band_, &narrow_peak_counter_);
} }
void RenderSignalAnalyzer::MaskRegionsAroundNarrowBands( void RenderSignalAnalyzer::MaskRegionsAroundNarrowBands(

4
modules/audio_processing/aec3/render_signal_analyzer.h
View File

@ -14,6 +14,7 @@
#include <array> #include <array>
#include <memory> #include <memory>
#include "api/audio/echo_canceller3_config.h"
#include "api/optional.h" #include "api/optional.h"
#include "modules/audio_processing/aec3/aec3_common.h" #include "modules/audio_processing/aec3/aec3_common.h"
#include "modules/audio_processing/aec3/render_buffer.h" #include "modules/audio_processing/aec3/render_buffer.h"
@ -24,7 +25,7 @@ namespace webrtc {
// Provides functionality for analyzing the properties of the render signal. // Provides functionality for analyzing the properties of the render signal.
class RenderSignalAnalyzer { class RenderSignalAnalyzer {
public: public:
RenderSignalAnalyzer(); explicit RenderSignalAnalyzer(const EchoCanceller3Config& config);
~RenderSignalAnalyzer(); ~RenderSignalAnalyzer();
// Updates the render signal analysis with the most recent render signal. // Updates the render signal analysis with the most recent render signal.
@ -46,6 +47,7 @@ class RenderSignalAnalyzer {
rtc::Optional<int> NarrowPeakBand() const { return narrow_peak_band_; } rtc::Optional<int> NarrowPeakBand() const { return narrow_peak_band_; }
private: private:
const int strong_peak_freeze_duration_;
std::array<size_t, kFftLengthBy2 - 1> narrow_band_counters_; std::array<size_t, kFftLengthBy2 - 1> narrow_band_counters_;
rtc::Optional<int> narrow_peak_band_; rtc::Optional<int> narrow_peak_band_;
size_t narrow_peak_counter_; size_t narrow_peak_counter_;

6
modules/audio_processing/aec3/render_signal_analyzer_unittest.cc
View File

@ -46,7 +46,7 @@ void ProduceSinusoid(int sample_rate_hz,
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
// Verifies that the check for non-null output parameter works. // Verifies that the check for non-null output parameter works.
TEST(RenderSignalAnalyzer, NullMaskOutput) { TEST(RenderSignalAnalyzer, NullMaskOutput) {
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
EXPECT_DEATH(analyzer.MaskRegionsAroundNarrowBands(nullptr), ""); EXPECT_DEATH(analyzer.MaskRegionsAroundNarrowBands(nullptr), "");
} }
@ -54,7 +54,7 @@ TEST(RenderSignalAnalyzer, NullMaskOutput) {
// Verify that no narrow bands are detected in a Gaussian noise signal. // Verify that no narrow bands are detected in a Gaussian noise signal.
TEST(RenderSignalAnalyzer, NoFalseDetectionOfNarrowBands) { TEST(RenderSignalAnalyzer, NoFalseDetectionOfNarrowBands) {
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
Random random_generator(42U); Random random_generator(42U);
std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f)); std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
std::array<float, kBlockSize> x_old; std::array<float, kBlockSize> x_old;
@ -85,7 +85,7 @@ TEST(RenderSignalAnalyzer, NoFalseDetectionOfNarrowBands) {
// Verify that a sinusiod signal is detected as narrow bands. // Verify that a sinusiod signal is detected as narrow bands.
TEST(RenderSignalAnalyzer, NarrowBandDetection) { TEST(RenderSignalAnalyzer, NarrowBandDetection) {
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
Random random_generator(42U); Random random_generator(42U);
std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f)); std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
std::array<float, kBlockSize> x_old; std::array<float, kBlockSize> x_old;

4
modules/audio_processing/aec3/shadow_filter_update_gain_unittest.cc
View File

@ -57,7 +57,7 @@ void RunFilterUpdateTest(int num_blocks_to_process,
std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f)); std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
std::vector<float> y(kBlockSize, 0.f); std::vector<float> y(kBlockSize, 0.f);
AecState aec_state(config); AecState aec_state(config);
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
std::array<float, kFftLength> s; std::array<float, kFftLength> s;
FftData S; FftData S;
FftData G; FftData G;
@ -130,7 +130,7 @@ std::string ProduceDebugText(size_t delay, int filter_length_blocks) {
TEST(ShadowFilterUpdateGain, NullDataOutputGain) { TEST(ShadowFilterUpdateGain, NullDataOutputGain) {
ApmDataDumper data_dumper(42); ApmDataDumper data_dumper(42);
FftBuffer fft_buffer(1); FftBuffer fft_buffer(1);
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
FftData E; FftData E;
const EchoCanceller3Config::Filter::ShadowConfiguration& config = { const EchoCanceller3Config::Filter::ShadowConfiguration& config = {
12, 0.5f, 220075344.f}; 12, 0.5f, 220075344.f};

6
modules/audio_processing/aec3/subtractor_unittest.cc
View File

@ -42,7 +42,7 @@ float RunSubtractorTest(int num_blocks_to_process,
config.delay.default_delay = 1; config.delay.default_delay = 1;
std::unique_ptr<RenderDelayBuffer> render_delay_buffer( std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
RenderDelayBuffer::Create(config, 3)); RenderDelayBuffer::Create(config, 3));
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
Random random_generator(42U); Random random_generator(42U);
Aec3Fft fft; Aec3Fft fft;
std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kFftLengthBy2Plus1> Y2;
@ -126,7 +126,7 @@ TEST(Subtractor, DISABLED_NullOutput) {
Subtractor subtractor(config, &data_dumper, DetectOptimization()); Subtractor subtractor(config, &data_dumper, DetectOptimization());
std::unique_ptr<RenderDelayBuffer> render_delay_buffer( std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
RenderDelayBuffer::Create(config, 3)); RenderDelayBuffer::Create(config, 3));
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
std::vector<float> y(kBlockSize, 0.f); std::vector<float> y(kBlockSize, 0.f);
EXPECT_DEATH( EXPECT_DEATH(
@ -142,7 +142,7 @@ TEST(Subtractor, WrongCaptureSize) {
Subtractor subtractor(config, &data_dumper, DetectOptimization()); Subtractor subtractor(config, &data_dumper, DetectOptimization());
std::unique_ptr<RenderDelayBuffer> render_delay_buffer( std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
RenderDelayBuffer::Create(config, 3)); RenderDelayBuffer::Create(config, 3));
RenderSignalAnalyzer render_signal_analyzer; RenderSignalAnalyzer render_signal_analyzer(config);
std::vector<float> y(kBlockSize - 1, 0.f); std::vector<float> y(kBlockSize - 1, 0.f);
SubtractorOutput output; SubtractorOutput output;

16
modules/audio_processing/aec3/suppression_gain_unittest.cc
View File

@ -34,12 +34,14 @@ TEST(SuppressionGain, NullOutputGains) {
N2.fill(0.f); N2.fill(0.f);
float high_bands_gain; float high_bands_gain;
AecState aec_state(EchoCanceller3Config{}); AecState aec_state(EchoCanceller3Config{});
EXPECT_DEATH(SuppressionGain(EchoCanceller3Config{}, DetectOptimization()) EXPECT_DEATH(
.GetGain(E2, R2, N2, RenderSignalAnalyzer(), aec_state, SuppressionGain(EchoCanceller3Config{}, DetectOptimization())
std::vector<std::vector<float>>( .GetGain(E2, R2, N2, RenderSignalAnalyzer((EchoCanceller3Config{})),
3, std::vector<float>(kBlockSize, 0.f)), aec_state,
&high_bands_gain, nullptr), std::vector<std::vector<float>>(
""); 3, std::vector<float>(kBlockSize, 0.f)),
&high_bands_gain, nullptr),
"");
} }
#endif #endif
@ -48,7 +50,7 @@ TEST(SuppressionGain, NullOutputGains) {
TEST(SuppressionGain, BasicGainComputation) { TEST(SuppressionGain, BasicGainComputation) {
SuppressionGain suppression_gain(EchoCanceller3Config(), SuppressionGain suppression_gain(EchoCanceller3Config(),
DetectOptimization()); DetectOptimization());
RenderSignalAnalyzer analyzer; RenderSignalAnalyzer analyzer(EchoCanceller3Config{});
float high_bands_gain; float high_bands_gain;
std::array<float, kFftLengthBy2Plus1> E2; std::array<float, kFftLengthBy2Plus1> E2;
std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kFftLengthBy2Plus1> Y2;