blob: 9a84ef6136007a4bc63f34e3b5b62add26f971d0 [file] [log] [blame]
peah522d71b2017-02-23 05:16:26 -08001/*
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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/audio_processing/aec3/aec_state.h"
peah522d71b2017-02-23 05:16:26 -080012
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020013#include "modules/audio_processing/logging/apm_data_dumper.h"
14#include "test/gtest.h"
peah522d71b2017-02-23 05:16:26 -080015
16namespace webrtc {
17
18// Verify the general functionality of AecState
19TEST(AecState, NormalUsage) {
20 ApmDataDumper data_dumper(42);
peah8cee56f2017-08-24 22:36:53 -070021 AecState state(AudioProcessing::Config::EchoCanceller3{});
peah86afe9d2017-04-06 15:45:32 -070022 RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
23 std::vector<size_t>(1, 30));
24 std::array<float, kFftLengthBy2Plus1> E2_main = {};
25 std::array<float, kFftLengthBy2Plus1> Y2 = {};
26 std::vector<std::vector<float>> x(3, std::vector<float>(kBlockSize, 0.f));
peah522d71b2017-02-23 05:16:26 -080027 EchoPathVariability echo_path_variability(false, false);
peah29103572017-07-11 02:54:02 -070028 std::array<float, kBlockSize> s;
29 s.fill(100.f);
peah522d71b2017-02-23 05:16:26 -080030
31 std::vector<std::array<float, kFftLengthBy2Plus1>>
32 converged_filter_frequency_response(10);
33 for (auto& v : converged_filter_frequency_response) {
34 v.fill(0.01f);
35 }
36 std::vector<std::array<float, kFftLengthBy2Plus1>>
37 diverged_filter_frequency_response = converged_filter_frequency_response;
38 converged_filter_frequency_response[2].fill(100.f);
peah86afe9d2017-04-06 15:45:32 -070039 converged_filter_frequency_response[2][0] = 1.f;
peah522d71b2017-02-23 05:16:26 -080040
peah29103572017-07-11 02:54:02 -070041 std::array<float, kAdaptiveFilterTimeDomainLength> impulse_response;
42 impulse_response.fill(0.f);
43
peah86afe9d2017-04-06 15:45:32 -070044 // Verify that linear AEC usability is false when the filter is diverged and
45 // there is no external delay reported.
Per Åhgren1b4059e2017-10-15 20:19:21 +020046 state.Update(diverged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070047 rtc::Optional<size_t>(), render_buffer, E2_main, Y2, x[0], s,
48 false);
peah522d71b2017-02-23 05:16:26 -080049 EXPECT_FALSE(state.UsableLinearEstimate());
50
51 // Verify that linear AEC usability is true when the filter is converged
peah86afe9d2017-04-06 15:45:32 -070052 std::fill(x[0].begin(), x[0].end(), 101.f);
53 for (int k = 0; k < 3000; ++k) {
Per Åhgren1b4059e2017-10-15 20:19:21 +020054 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070055 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
56 false);
peah522d71b2017-02-23 05:16:26 -080057 }
58 EXPECT_TRUE(state.UsableLinearEstimate());
59
60 // Verify that linear AEC usability becomes false after an echo path change is
61 // reported
peah86afe9d2017-04-06 15:45:32 -070062 state.HandleEchoPathChange(EchoPathVariability(true, false));
Per Åhgren1b4059e2017-10-15 20:19:21 +020063 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070064 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
65 false);
peah522d71b2017-02-23 05:16:26 -080066 EXPECT_FALSE(state.UsableLinearEstimate());
67
68 // Verify that the active render detection works as intended.
peah86afe9d2017-04-06 15:45:32 -070069 std::fill(x[0].begin(), x[0].end(), 101.f);
70 state.HandleEchoPathChange(EchoPathVariability(true, true));
Per Åhgren1b4059e2017-10-15 20:19:21 +020071 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070072 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
73 false);
peah522d71b2017-02-23 05:16:26 -080074 EXPECT_FALSE(state.ActiveRender());
75
peah86afe9d2017-04-06 15:45:32 -070076 for (int k = 0; k < 1000; ++k) {
Per Åhgren1b4059e2017-10-15 20:19:21 +020077 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070078 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
79 false);
peah86afe9d2017-04-06 15:45:32 -070080 }
peah522d71b2017-02-23 05:16:26 -080081 EXPECT_TRUE(state.ActiveRender());
82
83 // Verify that echo leakage is properly reported.
Per Åhgren1b4059e2017-10-15 20:19:21 +020084 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070085 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
86 false);
peah522d71b2017-02-23 05:16:26 -080087 EXPECT_FALSE(state.EchoLeakageDetected());
88
Per Åhgren1b4059e2017-10-15 20:19:21 +020089 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -070090 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
91 true);
peah522d71b2017-02-23 05:16:26 -080092 EXPECT_TRUE(state.EchoLeakageDetected());
93
peah522d71b2017-02-23 05:16:26 -080094 // Verify that the ERL is properly estimated
peah86afe9d2017-04-06 15:45:32 -070095 for (auto& x_k : x) {
96 x_k = std::vector<float>(kBlockSize, 0.f);
97 }
98
99 x[0][0] = 5000.f;
100 for (size_t k = 0; k < render_buffer.Buffer().size(); ++k) {
101 render_buffer.Insert(x);
102 }
103
104 Y2.fill(10.f * 10000.f * 10000.f);
105 for (size_t k = 0; k < 1000; ++k) {
Per Åhgren1b4059e2017-10-15 20:19:21 +0200106 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -0700107 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
108 false);
peah522d71b2017-02-23 05:16:26 -0800109 }
110
111 ASSERT_TRUE(state.UsableLinearEstimate());
112 const std::array<float, kFftLengthBy2Plus1>& erl = state.Erl();
peah86afe9d2017-04-06 15:45:32 -0700113 EXPECT_EQ(erl[0], erl[1]);
114 for (size_t k = 1; k < erl.size() - 1; ++k) {
115 EXPECT_NEAR(k % 2 == 0 ? 10.f : 1000.f, erl[k], 0.1);
116 }
117 EXPECT_EQ(erl[erl.size() - 2], erl[erl.size() - 1]);
peah522d71b2017-02-23 05:16:26 -0800118
119 // Verify that the ERLE is properly estimated
peah86afe9d2017-04-06 15:45:32 -0700120 E2_main.fill(1.f * 10000.f * 10000.f);
peah522d71b2017-02-23 05:16:26 -0800121 Y2.fill(10.f * E2_main[0]);
peah86afe9d2017-04-06 15:45:32 -0700122 for (size_t k = 0; k < 1000; ++k) {
Per Åhgren1b4059e2017-10-15 20:19:21 +0200123 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -0700124 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
125 false);
peah522d71b2017-02-23 05:16:26 -0800126 }
127 ASSERT_TRUE(state.UsableLinearEstimate());
peah86afe9d2017-04-06 15:45:32 -0700128 {
129 const auto& erle = state.Erle();
130 EXPECT_EQ(erle[0], erle[1]);
peah1d680892017-05-23 04:07:10 -0700131 constexpr size_t kLowFrequencyLimit = 32;
132 for (size_t k = 1; k < kLowFrequencyLimit; ++k) {
peah86afe9d2017-04-06 15:45:32 -0700133 EXPECT_NEAR(k % 2 == 0 ? 8.f : 1.f, erle[k], 0.1);
134 }
peah1d680892017-05-23 04:07:10 -0700135 for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; ++k) {
136 EXPECT_NEAR(k % 2 == 0 ? 1.5f : 1.f, erle[k], 0.1);
137 }
peah86afe9d2017-04-06 15:45:32 -0700138 EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]);
139 }
peah522d71b2017-02-23 05:16:26 -0800140
peah86afe9d2017-04-06 15:45:32 -0700141 E2_main.fill(1.f * 10000.f * 10000.f);
peah522d71b2017-02-23 05:16:26 -0800142 Y2.fill(5.f * E2_main[0]);
peah86afe9d2017-04-06 15:45:32 -0700143 for (size_t k = 0; k < 1000; ++k) {
Per Åhgren1b4059e2017-10-15 20:19:21 +0200144 state.Update(converged_filter_frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -0700145 rtc::Optional<size_t>(2), render_buffer, E2_main, Y2, x[0], s,
146 false);
peah522d71b2017-02-23 05:16:26 -0800147 }
peah86afe9d2017-04-06 15:45:32 -0700148
peah522d71b2017-02-23 05:16:26 -0800149 ASSERT_TRUE(state.UsableLinearEstimate());
peah86afe9d2017-04-06 15:45:32 -0700150 {
151 const auto& erle = state.Erle();
152 EXPECT_EQ(erle[0], erle[1]);
peah1d680892017-05-23 04:07:10 -0700153 constexpr size_t kLowFrequencyLimit = 32;
154 for (size_t k = 1; k < kLowFrequencyLimit; ++k) {
peah86afe9d2017-04-06 15:45:32 -0700155 EXPECT_NEAR(k % 2 == 0 ? 5.f : 1.f, erle[k], 0.1);
156 }
peah1d680892017-05-23 04:07:10 -0700157 for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; ++k) {
158 EXPECT_NEAR(k % 2 == 0 ? 1.5f : 1.f, erle[k], 0.1);
159 }
peah86afe9d2017-04-06 15:45:32 -0700160 EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]);
161 }
peah522d71b2017-02-23 05:16:26 -0800162}
163
164// Verifies the a non-significant delay is correctly identified.
165TEST(AecState, NonSignificantDelay) {
peah8cee56f2017-08-24 22:36:53 -0700166 AecState state(AudioProcessing::Config::EchoCanceller3{});
peah86afe9d2017-04-06 15:45:32 -0700167 RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
168 std::vector<size_t>(1, 30));
peah522d71b2017-02-23 05:16:26 -0800169 std::array<float, kFftLengthBy2Plus1> E2_main;
peah522d71b2017-02-23 05:16:26 -0800170 std::array<float, kFftLengthBy2Plus1> Y2;
171 std::array<float, kBlockSize> x;
172 EchoPathVariability echo_path_variability(false, false);
peah29103572017-07-11 02:54:02 -0700173 std::array<float, kBlockSize> s;
174 s.fill(100.f);
peah522d71b2017-02-23 05:16:26 -0800175 x.fill(0.f);
176
177 std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30);
178 for (auto& v : frequency_response) {
179 v.fill(0.01f);
180 }
181
peah29103572017-07-11 02:54:02 -0700182 std::array<float, kAdaptiveFilterTimeDomainLength> impulse_response;
183 impulse_response.fill(0.f);
184
peah522d71b2017-02-23 05:16:26 -0800185 // Verify that a non-significant filter delay is identified correctly.
peah86afe9d2017-04-06 15:45:32 -0700186 state.HandleEchoPathChange(echo_path_variability);
Per Åhgren1b4059e2017-10-15 20:19:21 +0200187 state.Update(frequency_response, impulse_response, true,
188 rtc::Optional<size_t>(), render_buffer, E2_main, Y2, x, s,
189 false);
peah522d71b2017-02-23 05:16:26 -0800190 EXPECT_FALSE(state.FilterDelay());
191}
192
193// Verifies the delay for a converged filter is correctly identified.
194TEST(AecState, ConvergedFilterDelay) {
195 constexpr int kFilterLength = 10;
peah8cee56f2017-08-24 22:36:53 -0700196 AecState state(AudioProcessing::Config::EchoCanceller3{});
peah86afe9d2017-04-06 15:45:32 -0700197 RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
198 std::vector<size_t>(1, 30));
peah522d71b2017-02-23 05:16:26 -0800199 std::array<float, kFftLengthBy2Plus1> E2_main;
peah522d71b2017-02-23 05:16:26 -0800200 std::array<float, kFftLengthBy2Plus1> Y2;
201 std::array<float, kBlockSize> x;
202 EchoPathVariability echo_path_variability(false, false);
peah29103572017-07-11 02:54:02 -0700203 std::array<float, kBlockSize> s;
204 s.fill(100.f);
peah522d71b2017-02-23 05:16:26 -0800205 x.fill(0.f);
206
207 std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(
208 kFilterLength);
209
peah29103572017-07-11 02:54:02 -0700210 std::array<float, kAdaptiveFilterTimeDomainLength> impulse_response;
211 impulse_response.fill(0.f);
212
peah522d71b2017-02-23 05:16:26 -0800213 // Verify that the filter delay for a converged filter is properly identified.
214 for (int k = 0; k < kFilterLength; ++k) {
215 for (auto& v : frequency_response) {
216 v.fill(0.01f);
217 }
218 frequency_response[k].fill(100.f);
peah86afe9d2017-04-06 15:45:32 -0700219 frequency_response[k][0] = 0.f;
220 state.HandleEchoPathChange(echo_path_variability);
Per Åhgren1b4059e2017-10-15 20:19:21 +0200221 state.Update(frequency_response, impulse_response, true,
222 rtc::Optional<size_t>(), render_buffer, E2_main, Y2, x, s,
223 false);
peah522d71b2017-02-23 05:16:26 -0800224 EXPECT_TRUE(k == (kFilterLength - 1) || state.FilterDelay());
225 if (k != (kFilterLength - 1)) {
226 EXPECT_EQ(k, state.FilterDelay());
227 }
228 }
229}
230
231// Verify that the externally reported delay is properly reported and converted.
232TEST(AecState, ExternalDelay) {
peah8cee56f2017-08-24 22:36:53 -0700233 AecState state(AudioProcessing::Config::EchoCanceller3{});
peah522d71b2017-02-23 05:16:26 -0800234 std::array<float, kFftLengthBy2Plus1> E2_main;
235 std::array<float, kFftLengthBy2Plus1> E2_shadow;
236 std::array<float, kFftLengthBy2Plus1> Y2;
237 std::array<float, kBlockSize> x;
peah29103572017-07-11 02:54:02 -0700238 std::array<float, kBlockSize> s;
239 s.fill(100.f);
peah522d71b2017-02-23 05:16:26 -0800240 E2_main.fill(0.f);
241 E2_shadow.fill(0.f);
242 Y2.fill(0.f);
243 x.fill(0.f);
peah86afe9d2017-04-06 15:45:32 -0700244 RenderBuffer render_buffer(Aec3Optimization::kNone, 3, 30,
245 std::vector<size_t>(1, 30));
peah522d71b2017-02-23 05:16:26 -0800246 std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30);
247 for (auto& v : frequency_response) {
248 v.fill(0.01f);
249 }
250
peah29103572017-07-11 02:54:02 -0700251 std::array<float, kAdaptiveFilterTimeDomainLength> impulse_response;
252 impulse_response.fill(0.f);
253
peah522d71b2017-02-23 05:16:26 -0800254 for (size_t k = 0; k < frequency_response.size() - 1; ++k) {
peah86afe9d2017-04-06 15:45:32 -0700255 state.HandleEchoPathChange(EchoPathVariability(false, false));
Per Åhgren1b4059e2017-10-15 20:19:21 +0200256 state.Update(frequency_response, impulse_response, true,
peah29103572017-07-11 02:54:02 -0700257 rtc::Optional<size_t>(k * kBlockSize + 5), render_buffer,
258 E2_main, Y2, x, s, false);
peah522d71b2017-02-23 05:16:26 -0800259 EXPECT_TRUE(state.ExternalDelay());
260 EXPECT_EQ(k, state.ExternalDelay());
261 }
262
263 // Verify that the externally reported delay is properly unset when it is no
264 // longer present.
peah86afe9d2017-04-06 15:45:32 -0700265 state.HandleEchoPathChange(EchoPathVariability(false, false));
Per Åhgren1b4059e2017-10-15 20:19:21 +0200266 state.Update(frequency_response, impulse_response, true,
267 rtc::Optional<size_t>(), render_buffer, E2_main, Y2, x, s,
268 false);
peah522d71b2017-02-23 05:16:26 -0800269 EXPECT_FALSE(state.ExternalDelay());
270}
271
272} // namespace webrtc