1 /*
2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/audio_processing/aec3/aec_state.h"
12
13 #include "modules/audio_processing/aec3/aec3_fft.h"
14 #include "modules/audio_processing/aec3/render_delay_buffer.h"
15 #include "modules/audio_processing/logging/apm_data_dumper.h"
16 #include "rtc_base/strings/string_builder.h"
17 #include "test/gtest.h"
18
19 namespace webrtc {
20 namespace {
21
RunNormalUsageTest(size_t num_render_channels,size_t num_capture_channels)22 void RunNormalUsageTest(size_t num_render_channels,
23 size_t num_capture_channels) {
24 // TODO(bugs.webrtc.org/10913): Test with different content in different
25 // channels.
26 constexpr int kSampleRateHz = 48000;
27 constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz);
28 ApmDataDumper data_dumper(42);
29 EchoCanceller3Config config;
30 AecState state(config, num_capture_channels);
31 absl::optional<DelayEstimate> delay_estimate =
32 DelayEstimate(DelayEstimate::Quality::kRefined, 10);
33 std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
34 RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels));
35 std::vector<std::array<float, kFftLengthBy2Plus1>> E2_refined(
36 num_capture_channels);
37 std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(num_capture_channels);
38 Block x(kNumBands, num_render_channels);
39 EchoPathVariability echo_path_variability(
40 false, EchoPathVariability::DelayAdjustment::kNone, false);
41 std::vector<std::array<float, kBlockSize>> y(num_capture_channels);
42 std::vector<SubtractorOutput> subtractor_output(num_capture_channels);
43 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
44 subtractor_output[ch].Reset();
45 subtractor_output[ch].s_refined.fill(100.f);
46 subtractor_output[ch].e_refined.fill(100.f);
47 y[ch].fill(1000.f);
48 E2_refined[ch].fill(0.f);
49 Y2[ch].fill(0.f);
50 }
51 Aec3Fft fft;
52 std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>>
53 converged_filter_frequency_response(
54 num_capture_channels,
55 std::vector<std::array<float, kFftLengthBy2Plus1>>(10));
56 for (auto& v_ch : converged_filter_frequency_response) {
57 for (auto& v : v_ch) {
58 v.fill(0.01f);
59 }
60 }
61 std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>>
62 diverged_filter_frequency_response = converged_filter_frequency_response;
63 converged_filter_frequency_response[0][2].fill(100.f);
64 converged_filter_frequency_response[0][2][0] = 1.f;
65 std::vector<std::vector<float>> impulse_response(
66 num_capture_channels,
67 std::vector<float>(
68 GetTimeDomainLength(config.filter.refined.length_blocks), 0.f));
69
70 // Verify that linear AEC usability is true when the filter is converged
71 for (size_t band = 0; band < kNumBands; ++band) {
72 for (size_t ch = 0; ch < num_render_channels; ++ch) {
73 std::fill(x.begin(band, ch), x.end(band, ch), 101.f);
74 }
75 }
76 for (int k = 0; k < 3000; ++k) {
77 render_delay_buffer->Insert(x);
78 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
79 subtractor_output[ch].ComputeMetrics(y[ch]);
80 }
81 state.Update(delay_estimate, converged_filter_frequency_response,
82 impulse_response, *render_delay_buffer->GetRenderBuffer(),
83 E2_refined, Y2, subtractor_output);
84 }
85 EXPECT_TRUE(state.UsableLinearEstimate());
86
87 // Verify that linear AEC usability becomes false after an echo path
88 // change is reported
89 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
90 subtractor_output[ch].ComputeMetrics(y[ch]);
91 }
92 state.HandleEchoPathChange(EchoPathVariability(
93 false, EchoPathVariability::DelayAdjustment::kNewDetectedDelay, false));
94 state.Update(delay_estimate, converged_filter_frequency_response,
95 impulse_response, *render_delay_buffer->GetRenderBuffer(),
96 E2_refined, Y2, subtractor_output);
97 EXPECT_FALSE(state.UsableLinearEstimate());
98
99 // Verify that the active render detection works as intended.
100 for (size_t ch = 0; ch < num_render_channels; ++ch) {
101 std::fill(x.begin(0, ch), x.end(0, ch), 101.f);
102 }
103 render_delay_buffer->Insert(x);
104 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
105 subtractor_output[ch].ComputeMetrics(y[ch]);
106 }
107 state.HandleEchoPathChange(EchoPathVariability(
108 true, EchoPathVariability::DelayAdjustment::kNewDetectedDelay, false));
109 state.Update(delay_estimate, converged_filter_frequency_response,
110 impulse_response, *render_delay_buffer->GetRenderBuffer(),
111 E2_refined, Y2, subtractor_output);
112 EXPECT_FALSE(state.ActiveRender());
113
114 for (int k = 0; k < 1000; ++k) {
115 render_delay_buffer->Insert(x);
116 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
117 subtractor_output[ch].ComputeMetrics(y[ch]);
118 }
119 state.Update(delay_estimate, converged_filter_frequency_response,
120 impulse_response, *render_delay_buffer->GetRenderBuffer(),
121 E2_refined, Y2, subtractor_output);
122 }
123 EXPECT_TRUE(state.ActiveRender());
124
125 // Verify that the ERL is properly estimated
126 for (int band = 0; band < x.NumBands(); ++band) {
127 for (int channel = 0; channel < x.NumChannels(); ++channel) {
128 std::fill(x.begin(band, channel), x.end(band, channel), 0.0f);
129 }
130 }
131
132 for (size_t ch = 0; ch < num_render_channels; ++ch) {
133 x.View(/*band=*/0, ch)[0] = 5000.f;
134 }
135 for (size_t k = 0;
136 k < render_delay_buffer->GetRenderBuffer()->GetFftBuffer().size(); ++k) {
137 render_delay_buffer->Insert(x);
138 if (k == 0) {
139 render_delay_buffer->Reset();
140 }
141 render_delay_buffer->PrepareCaptureProcessing();
142 }
143
144 for (auto& Y2_ch : Y2) {
145 Y2_ch.fill(10.f * 10000.f * 10000.f);
146 }
147 for (size_t k = 0; k < 1000; ++k) {
148 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
149 subtractor_output[ch].ComputeMetrics(y[ch]);
150 }
151 state.Update(delay_estimate, converged_filter_frequency_response,
152 impulse_response, *render_delay_buffer->GetRenderBuffer(),
153 E2_refined, Y2, subtractor_output);
154 }
155
156 ASSERT_TRUE(state.UsableLinearEstimate());
157 const std::array<float, kFftLengthBy2Plus1>& erl = state.Erl();
158 EXPECT_EQ(erl[0], erl[1]);
159 for (size_t k = 1; k < erl.size() - 1; ++k) {
160 EXPECT_NEAR(k % 2 == 0 ? 10.f : 1000.f, erl[k], 0.1);
161 }
162 EXPECT_EQ(erl[erl.size() - 2], erl[erl.size() - 1]);
163
164 // Verify that the ERLE is properly estimated
165 for (auto& E2_refined_ch : E2_refined) {
166 E2_refined_ch.fill(1.f * 10000.f * 10000.f);
167 }
168 for (auto& Y2_ch : Y2) {
169 Y2_ch.fill(10.f * E2_refined[0][0]);
170 }
171 for (size_t k = 0; k < 1000; ++k) {
172 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
173 subtractor_output[ch].ComputeMetrics(y[ch]);
174 }
175 state.Update(delay_estimate, converged_filter_frequency_response,
176 impulse_response, *render_delay_buffer->GetRenderBuffer(),
177 E2_refined, Y2, subtractor_output);
178 }
179 ASSERT_TRUE(state.UsableLinearEstimate());
180 {
181 // Note that the render spectrum is built so it does not have energy in
182 // the odd bands but just in the even bands.
183 const auto& erle = state.Erle(/*onset_compensated=*/true)[0];
184 EXPECT_EQ(erle[0], erle[1]);
185 constexpr size_t kLowFrequencyLimit = 32;
186 for (size_t k = 2; k < kLowFrequencyLimit; k = k + 2) {
187 EXPECT_NEAR(4.f, erle[k], 0.1);
188 }
189 for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; k = k + 2) {
190 EXPECT_NEAR(1.5f, erle[k], 0.1);
191 }
192 EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]);
193 }
194 for (auto& E2_refined_ch : E2_refined) {
195 E2_refined_ch.fill(1.f * 10000.f * 10000.f);
196 }
197 for (auto& Y2_ch : Y2) {
198 Y2_ch.fill(5.f * E2_refined[0][0]);
199 }
200 for (size_t k = 0; k < 1000; ++k) {
201 for (size_t ch = 0; ch < num_capture_channels; ++ch) {
202 subtractor_output[ch].ComputeMetrics(y[ch]);
203 }
204 state.Update(delay_estimate, converged_filter_frequency_response,
205 impulse_response, *render_delay_buffer->GetRenderBuffer(),
206 E2_refined, Y2, subtractor_output);
207 }
208
209 ASSERT_TRUE(state.UsableLinearEstimate());
210 {
211 const auto& erle = state.Erle(/*onset_compensated=*/true)[0];
212 EXPECT_EQ(erle[0], erle[1]);
213 constexpr size_t kLowFrequencyLimit = 32;
214 for (size_t k = 1; k < kLowFrequencyLimit; ++k) {
215 EXPECT_NEAR(k % 2 == 0 ? 4.f : 1.f, erle[k], 0.1);
216 }
217 for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; ++k) {
218 EXPECT_NEAR(k % 2 == 0 ? 1.5f : 1.f, erle[k], 0.1);
219 }
220 EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]);
221 }
222 }
223
224 } // namespace
225
226 class AecStateMultiChannel
227 : public ::testing::Test,
228 public ::testing::WithParamInterface<std::tuple<size_t, size_t>> {};
229
230 INSTANTIATE_TEST_SUITE_P(MultiChannel,
231 AecStateMultiChannel,
232 ::testing::Combine(::testing::Values(1, 2, 8),
233 ::testing::Values(1, 2, 8)));
234
235 // Verify the general functionality of AecState
TEST_P(AecStateMultiChannel,NormalUsage)236 TEST_P(AecStateMultiChannel, NormalUsage) {
237 const size_t num_render_channels = std::get<0>(GetParam());
238 const size_t num_capture_channels = std::get<1>(GetParam());
239 RunNormalUsageTest(num_render_channels, num_capture_channels);
240 }
241
242 // Verifies the delay for a converged filter is correctly identified.
TEST(AecState,ConvergedFilterDelay)243 TEST(AecState, ConvergedFilterDelay) {
244 constexpr int kFilterLengthBlocks = 10;
245 constexpr size_t kNumCaptureChannels = 1;
246 EchoCanceller3Config config;
247 AecState state(config, kNumCaptureChannels);
248 std::unique_ptr<RenderDelayBuffer> render_delay_buffer(
249 RenderDelayBuffer::Create(config, 48000, 1));
250 absl::optional<DelayEstimate> delay_estimate;
251 std::vector<std::array<float, kFftLengthBy2Plus1>> E2_refined(
252 kNumCaptureChannels);
253 std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(kNumCaptureChannels);
254 std::array<float, kBlockSize> x;
255 EchoPathVariability echo_path_variability(
256 false, EchoPathVariability::DelayAdjustment::kNone, false);
257 std::vector<SubtractorOutput> subtractor_output(kNumCaptureChannels);
258 for (auto& output : subtractor_output) {
259 output.Reset();
260 output.s_refined.fill(100.f);
261 }
262 std::array<float, kBlockSize> y;
263 x.fill(0.f);
264 y.fill(0.f);
265
266 std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>>
267 frequency_response(kNumCaptureChannels,
268 std::vector<std::array<float, kFftLengthBy2Plus1>>(
269 kFilterLengthBlocks));
270 for (auto& v_ch : frequency_response) {
271 for (auto& v : v_ch) {
272 v.fill(0.01f);
273 }
274 }
275
276 std::vector<std::vector<float>> impulse_response(
277 kNumCaptureChannels,
278 std::vector<float>(
279 GetTimeDomainLength(config.filter.refined.length_blocks), 0.f));
280
281 // Verify that the filter delay for a converged filter is properly
282 // identified.
283 for (int k = 0; k < kFilterLengthBlocks; ++k) {
284 for (auto& ir : impulse_response) {
285 std::fill(ir.begin(), ir.end(), 0.f);
286 ir[k * kBlockSize + 1] = 1.f;
287 }
288
289 state.HandleEchoPathChange(echo_path_variability);
290 subtractor_output[0].ComputeMetrics(y);
291 state.Update(delay_estimate, frequency_response, impulse_response,
292 *render_delay_buffer->GetRenderBuffer(), E2_refined, Y2,
293 subtractor_output);
294 }
295 }
296
297 } // namespace webrtc
298