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

Simplified the usage of the render buffer in AEC3

Browse Source 
Bug: webrtc:8671
Change-Id: I4af397e9f208685e4ffec2a5f92501e0d2605c42
Reviewed-on: https://webrtc-review.googlesource.com/35060
Commit-Queue: Per Åhgren <peah@webrtc.org>
Reviewed-by: Per Åhgren <peah@webrtc.org>
Reviewed-by: Gustaf Ullberg <gustaf@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21386}
This commit is contained in:
Per Åhgren 2017-12-20 15:20:37 +01:00 committed by Commit Bot
parent 2ceb646f0d
commit ec22e3f503
20 changed files with 93 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -134,7 +134,8 @@ void UpdateErlEstimator_SSE2(
void AdaptPartitions(const RenderBuffer& render_buffer,
const FftData& G,
rtc::ArrayView<FftData> H) {
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
size_t index = render_buffer.Position();
for (auto& H_j : H) {
const FftData& X = render_buffer_data[index];
@ -152,7 +153,8 @@ void AdaptPartitions(const RenderBuffer& render_buffer,
void AdaptPartitions_NEON(const RenderBuffer& render_buffer,
const FftData& G,
rtc::ArrayView<FftData> H) {
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
const int lim1 =
std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
const int lim2 = H.size();
@ -209,7 +211,8 @@ void AdaptPartitions_NEON(const RenderBuffer& render_buffer,
void AdaptPartitions_SSE2(const RenderBuffer& render_buffer,
const FftData& G,
rtc::ArrayView<FftData> H) {
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
const int lim1 =
std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
const int lim2 = H.size();
@ -274,7 +277,8 @@ void ApplyFilter(const RenderBuffer& render_buffer,
S->re.fill(0.f);
S->im.fill(0.f);
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
size_t index = render_buffer.Position();
for (auto& H_j : H) {
const FftData& X = render_buffer_data[index];
@ -295,7 +299,8 @@ void ApplyFilter_NEON(const RenderBuffer& render_buffer,
S->re.fill(0.f);
S->im.fill(0.f);
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
const int lim1 =
std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
const int lim2 = H.size();
@ -354,7 +359,8 @@ void ApplyFilter_SSE2(const RenderBuffer& render_buffer,
S->re.fill(0.f);
S->im.fill(0.f);
rtc::ArrayView<const FftData> render_buffer_data = render_buffer.Buffer();
rtc::ArrayView<const FftData> render_buffer_data =
render_buffer.GetFftBuffer();
const int lim1 =
std::min(render_buffer_data.size() - render_buffer.Position(), H.size());
const int lim2 = H.size();

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

@ -72,7 +72,6 @@ TEST(AdaptiveFirFilter, FilterAdaptationNeonOptimizations) {
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
}
const auto& render_buffer = render_delay_buffer->GetRenderBuffer();
@ -184,7 +183,6 @@ TEST(AdaptiveFirFilter, FilterAdaptationSse2Optimizations) {
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
const auto& render_buffer = render_delay_buffer->GetRenderBuffer();
ApplyFilter_SSE2(*render_buffer, H_SSE2, &S_SSE2);
@ -367,7 +365,6 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
const auto& render_buffer = render_delay_buffer->GetRenderBuffer();
render_signal_analyzer.Update(*render_buffer, aec_state.FilterDelay());
@ -384,7 +381,9 @@ TEST(AdaptiveFirFilter, FilterAndAdapt) {
s[k] = kScale * s_scratch[k + kFftLengthBy2];
}
gain.Compute(*render_buffer, render_signal_analyzer, E,
std::array<float, kFftLengthBy2Plus1> render_power;
render_buffer->SpectralSum(filter.SizePartitions(), &render_power);
gain.Compute(render_power, render_signal_analyzer, E,
filter.SizePartitions(), false, &G);
filter.Adapt(*render_buffer, G);
aec_state.HandleEchoPathChange(EchoPathVariability(

3
modules/audio_processing/aec3/aec_state_unittest.cc
View File

@ -105,13 +105,12 @@ TEST(AecState, NormalUsage) {
x[0][0] = 5000.f;
for (size_t k = 0;
k < render_delay_buffer->GetRenderBuffer()->Buffer().size(); ++k) {
k < render_delay_buffer->GetRenderBuffer()->GetFftBuffer().size(); ++k) {
render_delay_buffer->Insert(x);
if (k == 0) {
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
}
Y2.fill(10.f * 10000.f * 10000.f);

3
modules/audio_processing/aec3/echo_path_delay_estimator_unittest.cc
View File

@ -84,7 +84,6 @@ TEST(EchoPathDelayEstimator, DelayEstimation) {
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
estimated_delay_samples = estimator.EstimateDelay(
render_delay_buffer->GetDownsampledRenderBuffer(), capture);
}
@ -120,7 +119,6 @@ TEST(EchoPathDelayEstimator, NoInitialDelayestimates) {
std::copy(render[0].begin(), render[0].end(), capture.begin());
render_delay_buffer->Insert(render);
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
EXPECT_FALSE(estimator.EstimateDelay(
render_delay_buffer->GetDownsampledRenderBuffer(), capture));
}
@ -145,7 +143,6 @@ TEST(EchoPathDelayEstimator, NoDelayEstimatesForLowLevelRenderSignals) {
std::copy(render[0].begin(), render[0].end(), capture.begin());
render_delay_buffer->Insert(render);
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
EXPECT_FALSE(estimator.EstimateDelay(
render_delay_buffer->GetDownsampledRenderBuffer(), capture));
}

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

@ -125,7 +125,7 @@ void EchoRemoverImpl::ProcessCapture(
bool capture_signal_saturation,
RenderBuffer* render_buffer,
std::vector<std::vector<float>>* capture) {
const std::vector<std::vector<float>>& x = render_buffer->MostRecentBlock();
const std::vector<std::vector<float>>& x = render_buffer->Block(0);
std::vector<std::vector<float>>* y = capture;
RTC_DCHECK(render_buffer);
RTC_DCHECK(y);
@ -143,8 +143,6 @@ void EchoRemoverImpl::ProcessCapture(
data_dumper_->DumpRaw("aec3_echo_remover_capture_input", y0);
data_dumper_->DumpRaw("aec3_echo_remover_render_input", x0);
render_buffer->UpdateSpectralSum();
aec_state_.UpdateCaptureSaturation(capture_signal_saturation);
if (echo_path_variability.AudioPathChanged()) {

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

@ -53,7 +53,7 @@ void MainFilterUpdateGain::HandleEchoPathChange(
}
void MainFilterUpdateGain::Compute(
const RenderBuffer& render_buffer,
const std::array<float, kFftLengthBy2Plus1>& render_power,
const RenderSignalAnalyzer& render_signal_analyzer,
const SubtractorOutput& subtractor_output,
const AdaptiveFirFilter& filter,
@ -66,7 +66,7 @@ void MainFilterUpdateGain::Compute(
const auto& E2_shadow = subtractor_output.E2_shadow;
FftData* G = gain_fft;
const size_t size_partitions = filter.SizePartitions();
auto X2 = render_buffer.SpectralSum(size_partitions);
auto X2 = render_power;
const auto& erl = filter.Erl();
++call_counter_;

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

@ -1,6 +1,6 @@
/*
* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
*
spect *
* 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
@ -38,7 +38,7 @@ class MainFilterUpdateGain {
void HandleEchoPathChange(const EchoPathVariability& echo_path_variability);
// Computes the gain.
void Compute(const RenderBuffer& render_buffer,
void Compute(const std::array<float, kFftLengthBy2Plus1>& render_power,
const RenderSignalAnalyzer& render_signal_analyzer,
const SubtractorOutput& subtractor_output,
const AdaptiveFirFilter& filter,

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

@ -107,7 +107,6 @@ void RunFilterUpdateTest(int num_blocks_to_process,
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
render_signal_analyzer.Update(*render_delay_buffer->GetRenderBuffer(),
aec_state.FilterDelay());
@ -140,15 +139,18 @@ void RunFilterUpdateTest(int num_blocks_to_process,
E_shadow.Spectrum(Aec3Optimization::kNone, output.E2_shadow);
// Adapt the shadow filter.
shadow_gain.Compute(*render_delay_buffer->GetRenderBuffer(),
render_signal_analyzer, E_shadow,
std::array<float, kFftLengthBy2Plus1> render_power;
render_delay_buffer->GetRenderBuffer()->SpectralSum(
shadow_filter.SizePartitions(), &render_power);
shadow_gain.Compute(render_power, render_signal_analyzer, E_shadow,
shadow_filter.SizePartitions(), saturation, &G);
shadow_filter.Adapt(*render_delay_buffer->GetRenderBuffer(), G);
// Adapt the main filter
main_gain.Compute(*render_delay_buffer->GetRenderBuffer(),
render_signal_analyzer, output, main_filter, saturation,
&G);
render_delay_buffer->GetRenderBuffer()->SpectralSum(
main_filter.SizePartitions(), &render_power);
main_gain.Compute(render_power, render_signal_analyzer, output, main_filter,
saturation, &G);
main_filter.Adapt(*render_delay_buffer->GetRenderBuffer(), G);
// Update the delay.
@ -189,16 +191,15 @@ TEST(MainFilterUpdateGain, NullDataOutputGain) {
EchoCanceller3Config config;
AdaptiveFirFilter filter(config.filter.length_blocks, DetectOptimization(),
&data_dumper);
std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
RenderDelayBuffer::Create(config, 3));
RenderSignalAnalyzer analyzer;
SubtractorOutput output;
MainFilterUpdateGain gain(
config.filter.leakage_converged, config.filter.leakage_diverged,
config.filter.main_noise_gate, config.filter.error_floor);
EXPECT_DEATH(gain.Compute(*render_delay_buffer->GetRenderBuffer(), analyzer,
output, filter, false, nullptr),
"");
std::array<float, kFftLengthBy2Plus1> render_power;
render_power.fill(0.f);
EXPECT_DEATH(
gain.Compute(render_power, analyzer, output, filter, false, nullptr), "");
}
#endif

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

@ -171,7 +171,6 @@ TEST(MatchedFilter, LagEstimation) {
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
std::array<float, kBlockSize> downsampled_capture_data;
rtc::ArrayView<float> downsampled_capture(
downsampled_capture_data.data(), sub_block_size);

2
modules/audio_processing/aec3/mock/mock_render_delay_buffer.h
View File

@ -30,7 +30,7 @@ class MockRenderDelayBuffer : public RenderDelayBuffer {
kBlockSize),
spectrum_buffer_(block_buffer_.buffer.size(), kFftLengthBy2Plus1),
fft_buffer_(block_buffer_.buffer.size()),
render_buffer_(12, &block_buffer_, &spectrum_buffer_, &fft_buffer_),
render_buffer_(&block_buffer_, &spectrum_buffer_, &fft_buffer_),
downsampled_render_buffer_(GetDownSampledBufferSize(4, 4)) {
ON_CALL(*this, GetRenderBuffer())
.WillByDefault(

33
modules/audio_processing/aec3/render_buffer.cc
View File

@ -17,35 +17,32 @@
namespace webrtc {
RenderBuffer::RenderBuffer(size_t num_ffts_for_spectral_sums,
MatrixBuffer* block_buffer,
RenderBuffer::RenderBuffer(MatrixBuffer* block_buffer,
VectorBuffer* spectrum_buffer,
FftBuffer* fft_buffer)
: block_buffer_(block_buffer),
spectrum_buffer_(spectrum_buffer),
fft_buffer_(fft_buffer),
spectral_sums_length_(num_ffts_for_spectral_sums) {
fft_buffer_(fft_buffer) {
RTC_DCHECK(block_buffer_);
RTC_DCHECK(spectrum_buffer_);
RTC_DCHECK(fft_buffer_);
RTC_DCHECK_GE(fft_buffer_->buffer.size(), spectral_sums_length_);
Clear();
RTC_DCHECK_EQ(block_buffer_->buffer.size(), fft_buffer_->buffer.size());
RTC_DCHECK_EQ(spectrum_buffer_->buffer.size(), fft_buffer_->buffer.size());
RTC_DCHECK_EQ(spectrum_buffer_->read, fft_buffer_->read);
RTC_DCHECK_EQ(spectrum_buffer_->write, fft_buffer_->write);
}
RenderBuffer::~RenderBuffer() = default;
void RenderBuffer::Clear() {
spectral_sums_.fill(0.f);
}
void RenderBuffer::UpdateSpectralSum() {
std::fill(spectral_sums_.begin(), spectral_sums_.end(), 0.f);
size_t position = spectrum_buffer_->read;
for (size_t j = 0; j < spectral_sums_length_; ++j) {
for (size_t k = 0; k < spectral_sums_.size(); ++k) {
spectral_sums_[k] += spectrum_buffer_->buffer[position][k];
}
void RenderBuffer::SpectralSum(
size_t num_spectra,
std::array<float, kFftLengthBy2Plus1>* X2) const {
X2->fill(0.f);
int position = spectrum_buffer_->read;
for (size_t j = 0; j < num_spectra; ++j) {
std::transform(X2->begin(), X2->end(),
spectrum_buffer_->buffer[position].begin(), X2->begin(),
std::plus<float>());
position = spectrum_buffer_->IncIndex(position);
}
}

45
modules/audio_processing/aec3/render_buffer.h
View File

@ -26,48 +26,45 @@ namespace webrtc {
// Provides a buffer of the render data for the echo remover.
class RenderBuffer {
public:
RenderBuffer(size_t num_ffts_for_spectral_sums,
MatrixBuffer* block_buffer,
RenderBuffer(MatrixBuffer* block_buffer,
VectorBuffer* spectrum_buffer,
FftBuffer* fft_buffer);
~RenderBuffer();
// Clears the buffer.
void Clear();
// Insert a block into the buffer.
void UpdateSpectralSum();
// Gets the last inserted block.
const std::vector<std::vector<float>>& MostRecentBlock() const {
return block_buffer_->buffer[block_buffer_->read];
// Get a block.
const std::vector<std::vector<float>>& Block(int buffer_offset_blocks) const {
int position =
block_buffer_->OffsetIndex(block_buffer_->read, buffer_offset_blocks);
return block_buffer_->buffer[position];
}
// Get the spectrum from one of the FFTs in the buffer.
rtc::ArrayView<const float> Spectrum(size_t buffer_offset_ffts) const {
size_t position = spectrum_buffer_->OffsetIndex(spectrum_buffer_->read,
buffer_offset_ffts);
rtc::ArrayView<const float> Spectrum(int buffer_offset_ffts) const {
int position = spectrum_buffer_->OffsetIndex(spectrum_buffer_->read,
buffer_offset_ffts);
return spectrum_buffer_->buffer[position];
}
// Returns the sum of the spectrums for a certain number of FFTs.
rtc::ArrayView<const float> SpectralSum(size_t num_ffts) const {
RTC_DCHECK_EQ(spectral_sums_length_, num_ffts);
return spectral_sums_;
// Returns the circular fft buffer.
rtc::ArrayView<const FftData> GetFftBuffer() const {
return fft_buffer_->buffer;
}
// Returns the circular buffer.
rtc::ArrayView<const FftData> Buffer() const { return fft_buffer_->buffer; }
// Returns the current position in the circular buffer.
size_t Position() const { return fft_buffer_->read; }
size_t Position() const {
RTC_DCHECK_EQ(spectrum_buffer_->read, fft_buffer_->read);
RTC_DCHECK_EQ(spectrum_buffer_->write, fft_buffer_->write);
return fft_buffer_->read;
}
// Returns the sum of the spectrums for a certain number of FFTs.
void SpectralSum(size_t num_spectra,
std::array<float, kFftLengthBy2Plus1>* X2) const;
private:
const MatrixBuffer* const block_buffer_;
const VectorBuffer* const spectrum_buffer_;
const FftBuffer* const fft_buffer_;
const size_t spectral_sums_length_;
std::array<float, kFftLengthBy2Plus1> spectral_sums_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RenderBuffer);
};

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

@ -24,21 +24,21 @@ namespace webrtc {
TEST(RenderBuffer, NullExternalFftBuffer) {
MatrixBuffer block_buffer(10, 3, kBlockSize);
VectorBuffer spectrum_buffer(10, kFftLengthBy2Plus1);
EXPECT_DEATH(RenderBuffer(1, &block_buffer, &spectrum_buffer, nullptr), "");
EXPECT_DEATH(RenderBuffer(&block_buffer, &spectrum_buffer, nullptr), "");
}
// Verifies the check for non-null spectrum buffer.
TEST(RenderBuffer, NullExternalSpectrumBuffer) {
FftBuffer fft_buffer(10);
MatrixBuffer block_buffer(10, 3, kBlockSize);
EXPECT_DEATH(RenderBuffer(1, &block_buffer, nullptr, &fft_buffer), "");
EXPECT_DEATH(RenderBuffer(&block_buffer, nullptr, &fft_buffer), "");
}
// Verifies the check for non-null block buffer.
TEST(RenderBuffer, NullExternalBlockBuffer) {
FftBuffer fft_buffer(10);
VectorBuffer spectrum_buffer(10, kFftLengthBy2Plus1);
EXPECT_DEATH(RenderBuffer(1, nullptr, &spectrum_buffer, &fft_buffer), "");
EXPECT_DEATH(RenderBuffer(nullptr, &spectrum_buffer, &fft_buffer), "");
}
#endif

5
modules/audio_processing/aec3/render_delay_buffer.cc
View File

@ -159,10 +159,7 @@ RenderDelayBufferImpl::RenderDelayBufferImpl(const EchoCanceller3Config& config,
spectra_(blocks_.buffer.size(), kFftLengthBy2Plus1),
ffts_(blocks_.buffer.size()),
delay_(config_.delay.min_echo_path_delay_blocks),
echo_remover_buffer_(config.filter.length_blocks,
&blocks_,
&spectra_,
&ffts_),
echo_remover_buffer_(&blocks_, &spectra_, &ffts_),
low_rate_(GetDownSampledBufferSize(config.delay.down_sampling_factor,
config.delay.num_filters)),
render_decimator_(config.delay.down_sampling_factor),

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

@ -61,8 +61,7 @@ void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
}
// Assess the render signal strength
const std::vector<std::vector<float>>& x_latest =
render_buffer.MostRecentBlock();
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());
float max_abs = std::max(fabs(*result0.first), fabs(*result0.second));

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

@ -29,7 +29,7 @@ void ShadowFilterUpdateGain::HandleEchoPathChange() {
}
void ShadowFilterUpdateGain::Compute(
const RenderBuffer& render_buffer,
const std::array<float, kFftLengthBy2Plus1>& render_power,
const RenderSignalAnalyzer& render_signal_analyzer,
const FftData& E_shadow,
size_t size_partitions,
@ -52,7 +52,7 @@ void ShadowFilterUpdateGain::Compute(
// Compute mu.
std::array<float, kFftLengthBy2Plus1> mu;
auto X2 = render_buffer.SpectralSum(size_partitions);
auto X2 = render_power;
std::transform(X2.begin(), X2.end(), mu.begin(), [&](float a) {
return a > noise_gate_power_ ? rate_ / a : 0.f;
});

2
modules/audio_processing/aec3/shadow_filter_update_gain.h
View File

@ -27,7 +27,7 @@ class ShadowFilterUpdateGain {
void HandleEchoPathChange();
// Computes the gain.
void Compute(const RenderBuffer& render_buffer,
void Compute(const std::array<float, kFftLengthBy2Plus1>& render_power,
const RenderSignalAnalyzer& render_signal_analyzer,
const FftData& E_shadow,
size_t size_partitions,

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

@ -83,7 +83,6 @@ void RunFilterUpdateTest(int num_blocks_to_process,
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
render_signal_analyzer.Update(*render_delay_buffer->GetRenderBuffer(),
delay_samples / kBlockSize);
@ -97,8 +96,10 @@ void RunFilterUpdateTest(int num_blocks_to_process,
[](float& a) { a = rtc::SafeClamp(a, -32768.f, 32767.f); });
fft.ZeroPaddedFft(e_shadow, &E_shadow);
shadow_gain.Compute(*render_delay_buffer->GetRenderBuffer(),
render_signal_analyzer, E_shadow,
std::array<float, kFftLengthBy2Plus1> render_power;
render_delay_buffer->GetRenderBuffer()->SpectralSum(
shadow_filter.SizePartitions(), &render_power);
shadow_gain.Compute(render_power, render_signal_analyzer, E_shadow,
shadow_filter.SizePartitions(), saturation, &G);
shadow_filter.Adapt(*render_delay_buffer->GetRenderBuffer(), G);
}
@ -130,13 +131,12 @@ std::string ProduceDebugText(size_t delay, int filter_length_blocks) {
TEST(ShadowFilterUpdateGain, NullDataOutputGain) {
ApmDataDumper data_dumper(42);
FftBuffer fft_buffer(1);
MatrixBuffer block_buffer(fft_buffer.buffer.size(), 3, kBlockSize);
VectorBuffer spectrum_buffer(fft_buffer.buffer.size(), kFftLengthBy2Plus1);
RenderBuffer render_buffer(1, &block_buffer, &spectrum_buffer, &fft_buffer);
RenderSignalAnalyzer analyzer;
FftData E;
ShadowFilterUpdateGain gain(0.5f, 220075344.f);
EXPECT_DEATH(gain.Compute(render_buffer, analyzer, E, 1, false, nullptr), "");
std::array<float, kFftLengthBy2Plus1> render_power;
render_power.fill(0.f);
EXPECT_DEATH(gain.Compute(render_power, analyzer, E, 1, false, nullptr), "");
}
#endif

10
modules/audio_processing/aec3/subtractor.cc
View File

@ -65,6 +65,7 @@ void PredictionError(const Aec3Fft& fft,
fft.ZeroPaddedFft(rtc::ArrayView<const float>(tmp.data(), 64), E);
}
} // namespace
Subtractor::Subtractor(const EchoCanceller3Config& config,
@ -151,14 +152,19 @@ void Subtractor::Process(const RenderBuffer& render_buffer,
E_shadow.Spectrum(optimization_, output->E2_shadow);
// Update the main filter.
G_main_.Compute(render_buffer, render_signal_analyzer, *output, main_filter_,
std::array<float, kFftLengthBy2Plus1> X2;
render_buffer.SpectralSum(main_filter_.SizePartitions(), &X2);
G_main_.Compute(X2, render_signal_analyzer, *output, main_filter_,
aec_state.SaturatedCapture(), &G);
main_filter_.Adapt(render_buffer, G);
data_dumper_->DumpRaw("aec3_subtractor_G_main", G.re);
data_dumper_->DumpRaw("aec3_subtractor_G_main", G.im);
// Update the shadow filter.
G_shadow_.Compute(render_buffer, render_signal_analyzer, E_shadow,
if (shadow_filter_.SizePartitions() != main_filter_.SizePartitions()) {
render_buffer.SpectralSum(shadow_filter_.SizePartitions(), &X2);
}
G_shadow_.Compute(X2, render_signal_analyzer, E_shadow,
shadow_filter_.SizePartitions(),
aec_state.SaturatedCapture(), &G);
shadow_filter_.Adapt(render_buffer, G);

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

@ -65,7 +65,6 @@ float RunSubtractorTest(int num_blocks_to_process,
render_delay_buffer->Reset();
}
render_delay_buffer->PrepareCaptureProcessing();
render_delay_buffer->GetRenderBuffer()->UpdateSpectralSum();
render_signal_analyzer.Update(*render_delay_buffer->GetRenderBuffer(),
aec_state.FilterDelay());