peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/audio_processing/aec3/aec_state.h" |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 12 | |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 13 | #include "modules/audio_processing/aec3/aec3_fft.h" |
| 14 | #include "modules/audio_processing/aec3/render_delay_buffer.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "modules/audio_processing/logging/apm_data_dumper.h" |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 16 | #include "rtc_base/strings/string_builder.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 17 | #include "test/gtest.h" |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 18 | |
| 19 | namespace webrtc { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 20 | namespace { |
| 21 | std::string ProduceDebugText(size_t num_render_channels, |
| 22 | size_t num_capture_channels) { |
| 23 | rtc::StringBuilder ss; |
| 24 | ss << "Render channels: " << num_render_channels; |
| 25 | ss << ", Capture channels: " << num_capture_channels; |
| 26 | return ss.Release(); |
| 27 | } |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 28 | |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 29 | void RunNormalUsageTest(size_t num_render_channels, |
| 30 | size_t num_capture_channels) { |
| 31 | // TODO(bugs.webrtc.org/10913): Test with different content in different |
| 32 | // channels. |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 33 | constexpr int kSampleRateHz = 48000; |
| 34 | constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 35 | ApmDataDumper data_dumper(42); |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 36 | EchoCanceller3Config config; |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 37 | AecState state(config, num_capture_channels); |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 38 | absl::optional<DelayEstimate> delay_estimate = |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 39 | DelayEstimate(DelayEstimate::Quality::kRefined, 10); |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 40 | std::unique_ptr<RenderDelayBuffer> render_delay_buffer( |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 41 | RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels)); |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 42 | std::vector<std::array<float, kFftLengthBy2Plus1>> E2_main( |
| 43 | num_capture_channels); |
| 44 | std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(num_capture_channels); |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 45 | std::vector<std::vector<std::vector<float>>> x( |
| 46 | kNumBands, std::vector<std::vector<float>>( |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 47 | num_render_channels, std::vector<float>(kBlockSize, 0.f))); |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 48 | EchoPathVariability echo_path_variability( |
| 49 | false, EchoPathVariability::DelayAdjustment::kNone, false); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 50 | std::vector<std::array<float, kBlockSize>> y(num_capture_channels); |
| 51 | std::vector<SubtractorOutput> subtractor_output(num_capture_channels); |
| 52 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 53 | subtractor_output[ch].Reset(); |
| 54 | subtractor_output[ch].s_main.fill(100.f); |
| 55 | subtractor_output[ch].e_main.fill(100.f); |
| 56 | y[ch].fill(1000.f); |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 57 | E2_main[ch].fill(0.f); |
| 58 | Y2[ch].fill(0.f); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 59 | } |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 60 | Aec3Fft fft; |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 61 | std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>> |
| 62 | converged_filter_frequency_response( |
| 63 | num_capture_channels, |
| 64 | std::vector<std::array<float, kFftLengthBy2Plus1>>(10)); |
| 65 | for (auto& v_ch : converged_filter_frequency_response) { |
| 66 | for (auto& v : v_ch) { |
| 67 | v.fill(0.01f); |
| 68 | } |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 69 | } |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 70 | std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>> |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 71 | diverged_filter_frequency_response = converged_filter_frequency_response; |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 72 | converged_filter_frequency_response[0][2].fill(100.f); |
| 73 | converged_filter_frequency_response[0][2][0] = 1.f; |
| 74 | std::vector<std::vector<float>> impulse_response( |
| 75 | num_capture_channels, |
| 76 | std::vector<float>(GetTimeDomainLength(config.filter.main.length_blocks), |
| 77 | 0.f)); |
peah | 2910357 | 2017-07-11 02:54:02 -0700 | [diff] [blame] | 78 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 79 | // Verify that linear AEC usability is true when the filter is converged |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 80 | for (size_t band = 0; band < kNumBands; ++band) { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 81 | for (size_t ch = 0; ch < num_render_channels; ++ch) { |
| 82 | std::fill(x[band][ch].begin(), x[band][ch].end(), 101.f); |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 83 | } |
| 84 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 85 | for (int k = 0; k < 3000; ++k) { |
Per Åhgren | 0e6d2f5 | 2017-12-20 22:19:56 +0100 | [diff] [blame] | 86 | render_delay_buffer->Insert(x); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 87 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 88 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 89 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 90 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 91 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 92 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 93 | } |
| 94 | EXPECT_TRUE(state.UsableLinearEstimate()); |
| 95 | |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 96 | // Verify that linear AEC usability becomes false after an echo path |
| 97 | // change is reported |
| 98 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 99 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 100 | } |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 101 | state.HandleEchoPathChange(EchoPathVariability( |
Per Åhgren | 88cf050 | 2018-07-16 17:08:41 +0200 | [diff] [blame] | 102 | false, EchoPathVariability::DelayAdjustment::kBufferReadjustment, false)); |
Per Åhgren | 3ab308f | 2018-02-21 08:46:03 +0100 | [diff] [blame] | 103 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 104 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 105 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 106 | EXPECT_FALSE(state.UsableLinearEstimate()); |
| 107 | |
| 108 | // Verify that the active render detection works as intended. |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 109 | std::fill(x[0][0].begin(), x[0][0].end(), 101.f); |
Per Åhgren | 0e6d2f5 | 2017-12-20 22:19:56 +0100 | [diff] [blame] | 110 | render_delay_buffer->Insert(x); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 111 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 112 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 113 | } |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 114 | state.HandleEchoPathChange(EchoPathVariability( |
| 115 | true, EchoPathVariability::DelayAdjustment::kNewDetectedDelay, false)); |
Per Åhgren | 3ab308f | 2018-02-21 08:46:03 +0100 | [diff] [blame] | 116 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 117 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 118 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 119 | EXPECT_FALSE(state.ActiveRender()); |
| 120 | |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 121 | for (int k = 0; k < 1000; ++k) { |
Per Åhgren | 0e6d2f5 | 2017-12-20 22:19:56 +0100 | [diff] [blame] | 122 | render_delay_buffer->Insert(x); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 123 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 124 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 125 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 126 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 127 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 128 | E2_main, Y2, subtractor_output); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 129 | } |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 130 | EXPECT_TRUE(state.ActiveRender()); |
| 131 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 132 | // Verify that the ERL is properly estimated |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 133 | for (auto& band : x) { |
| 134 | for (auto& channel : band) { |
| 135 | channel = std::vector<float>(kBlockSize, 0.f); |
| 136 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 137 | } |
| 138 | |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 139 | x[0][0][0] = 5000.f; |
Per Åhgren | c59a576 | 2017-12-11 21:34:19 +0100 | [diff] [blame] | 140 | for (size_t k = 0; |
Per Åhgren | ec22e3f | 2017-12-20 15:20:37 +0100 | [diff] [blame] | 141 | k < render_delay_buffer->GetRenderBuffer()->GetFftBuffer().size(); ++k) { |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 142 | render_delay_buffer->Insert(x); |
| 143 | if (k == 0) { |
| 144 | render_delay_buffer->Reset(); |
| 145 | } |
Per Åhgren | c59a576 | 2017-12-11 21:34:19 +0100 | [diff] [blame] | 146 | render_delay_buffer->PrepareCaptureProcessing(); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 149 | for (auto& Y2_ch : Y2) { |
| 150 | Y2_ch.fill(10.f * 10000.f * 10000.f); |
| 151 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 152 | for (size_t k = 0; k < 1000; ++k) { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 153 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 154 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 155 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 156 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 157 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 158 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | ASSERT_TRUE(state.UsableLinearEstimate()); |
| 162 | const std::array<float, kFftLengthBy2Plus1>& erl = state.Erl(); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 163 | EXPECT_EQ(erl[0], erl[1]); |
| 164 | for (size_t k = 1; k < erl.size() - 1; ++k) { |
| 165 | EXPECT_NEAR(k % 2 == 0 ? 10.f : 1000.f, erl[k], 0.1); |
| 166 | } |
| 167 | EXPECT_EQ(erl[erl.size() - 2], erl[erl.size() - 1]); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 168 | |
| 169 | // Verify that the ERLE is properly estimated |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 170 | for (auto& E2_main_ch : E2_main) { |
| 171 | E2_main_ch.fill(1.f * 10000.f * 10000.f); |
| 172 | } |
| 173 | for (auto& Y2_ch : Y2) { |
| 174 | Y2_ch.fill(10.f * E2_main[0][0]); |
| 175 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 176 | for (size_t k = 0; k < 1000; ++k) { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 177 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 178 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 179 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 180 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 181 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 182 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 183 | } |
| 184 | ASSERT_TRUE(state.UsableLinearEstimate()); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 185 | { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 186 | // Note that the render spectrum is built so it does not have energy in |
| 187 | // the odd bands but just in the even bands. |
Per Åhgren | b4161d3 | 2019-10-08 12:35:47 +0200 | [diff] [blame] | 188 | const auto& erle = state.Erle()[0]; |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 189 | EXPECT_EQ(erle[0], erle[1]); |
peah | 1d68089 | 2017-05-23 04:07:10 -0700 | [diff] [blame] | 190 | constexpr size_t kLowFrequencyLimit = 32; |
Jesús de Vicente Peña | e9a7e90 | 2018-09-27 11:49:39 +0200 | [diff] [blame] | 191 | for (size_t k = 2; k < kLowFrequencyLimit; k = k + 2) { |
| 192 | EXPECT_NEAR(4.f, erle[k], 0.1); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 193 | } |
Jesús de Vicente Peña | e9a7e90 | 2018-09-27 11:49:39 +0200 | [diff] [blame] | 194 | for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; k = k + 2) { |
| 195 | EXPECT_NEAR(1.5f, erle[k], 0.1); |
peah | 1d68089 | 2017-05-23 04:07:10 -0700 | [diff] [blame] | 196 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 197 | EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]); |
| 198 | } |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 199 | for (auto& E2_main_ch : E2_main) { |
| 200 | E2_main_ch.fill(1.f * 10000.f * 10000.f); |
| 201 | } |
| 202 | for (auto& Y2_ch : Y2) { |
| 203 | Y2_ch.fill(5.f * E2_main[0][0]); |
| 204 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 205 | for (size_t k = 0; k < 1000; ++k) { |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 206 | for (size_t ch = 0; ch < num_capture_channels; ++ch) { |
| 207 | subtractor_output[ch].ComputeMetrics(y[ch]); |
| 208 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 209 | state.Update(delay_estimate, converged_filter_frequency_response, |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 210 | impulse_response, *render_delay_buffer->GetRenderBuffer(), |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 211 | E2_main, Y2, subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 212 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 213 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 214 | ASSERT_TRUE(state.UsableLinearEstimate()); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 215 | { |
Per Åhgren | b4161d3 | 2019-10-08 12:35:47 +0200 | [diff] [blame] | 216 | const auto& erle = state.Erle()[0]; |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 217 | EXPECT_EQ(erle[0], erle[1]); |
peah | 1d68089 | 2017-05-23 04:07:10 -0700 | [diff] [blame] | 218 | constexpr size_t kLowFrequencyLimit = 32; |
| 219 | for (size_t k = 1; k < kLowFrequencyLimit; ++k) { |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 220 | EXPECT_NEAR(k % 2 == 0 ? 4.f : 1.f, erle[k], 0.1); |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 221 | } |
peah | 1d68089 | 2017-05-23 04:07:10 -0700 | [diff] [blame] | 222 | for (size_t k = kLowFrequencyLimit; k < erle.size() - 1; ++k) { |
| 223 | EXPECT_NEAR(k % 2 == 0 ? 1.5f : 1.f, erle[k], 0.1); |
| 224 | } |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 225 | EXPECT_EQ(erle[erle.size() - 2], erle[erle.size() - 1]); |
| 226 | } |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 227 | } |
| 228 | |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 229 | } // namespace |
| 230 | |
| 231 | // Verify the general functionality of AecState |
| 232 | TEST(AecState, NormalUsage) { |
| 233 | for (size_t num_render_channels : {1, 2, 8}) { |
| 234 | for (size_t num_capture_channels : {1, 2, 8}) { |
| 235 | SCOPED_TRACE(ProduceDebugText(num_render_channels, num_capture_channels)); |
| 236 | RunNormalUsageTest(num_render_channels, num_capture_channels); |
| 237 | } |
| 238 | } |
| 239 | } |
| 240 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 241 | // Verifies the delay for a converged filter is correctly identified. |
| 242 | TEST(AecState, ConvergedFilterDelay) { |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 243 | constexpr int kFilterLengthBlocks = 10; |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 244 | constexpr size_t kNumCaptureChannels = 1; |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 245 | EchoCanceller3Config config; |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 246 | AecState state(config, kNumCaptureChannels); |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 247 | std::unique_ptr<RenderDelayBuffer> render_delay_buffer( |
Per Åhgren | ce202a0 | 2019-09-02 17:01:19 +0200 | [diff] [blame] | 248 | RenderDelayBuffer::Create(config, 48000, 1)); |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 249 | absl::optional<DelayEstimate> delay_estimate; |
Per Åhgren | f980725 | 2019-10-09 13:57:07 +0200 | [diff] [blame^] | 250 | std::vector<std::array<float, kFftLengthBy2Plus1>> E2_main( |
| 251 | kNumCaptureChannels); |
| 252 | std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(kNumCaptureChannels); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 253 | std::array<float, kBlockSize> x; |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 254 | EchoPathVariability echo_path_variability( |
| 255 | false, EchoPathVariability::DelayAdjustment::kNone, false); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 256 | std::vector<SubtractorOutput> subtractor_output(kNumCaptureChannels); |
| 257 | for (auto& output : subtractor_output) { |
| 258 | output.Reset(); |
| 259 | output.s_main.fill(100.f); |
| 260 | } |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 261 | std::array<float, kBlockSize> y; |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 262 | x.fill(0.f); |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 263 | y.fill(0.f); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 264 | |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 265 | std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>> |
| 266 | frequency_response( |
| 267 | kNumCaptureChannels, |
| 268 | std::vector<std::array<float, kFftLengthBy2Plus1>>(kFilterLengthBlocks)); |
| 269 | for (auto& v_ch : frequency_response) { |
| 270 | for (auto& v : v_ch) { |
| 271 | v.fill(0.01f); |
| 272 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 273 | } |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 274 | |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 275 | std::vector<std::vector<float>> impulse_response( |
| 276 | kNumCaptureChannels, |
| 277 | std::vector<float>(GetTimeDomainLength(config.filter.main.length_blocks), |
| 278 | 0.f)); |
peah | 2910357 | 2017-07-11 02:54:02 -0700 | [diff] [blame] | 279 | |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 280 | // Verify that the filter delay for a converged filter is properly |
| 281 | // identified. |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 282 | for (int k = 0; k < kFilterLengthBlocks; ++k) { |
Sam Zackrisson | 46b0140 | 2019-10-08 16:17:48 +0200 | [diff] [blame] | 283 | for (auto& ir : impulse_response) { |
| 284 | std::fill(ir.begin(), ir.end(), 0.f); |
| 285 | ir[k * kBlockSize + 1] = 1.f; |
| 286 | } |
Per Åhgren | 5c532d3 | 2018-03-22 00:29:25 +0100 | [diff] [blame] | 287 | |
peah | 86afe9d | 2017-04-06 15:45:32 -0700 | [diff] [blame] | 288 | state.HandleEchoPathChange(echo_path_variability); |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 289 | subtractor_output[0].ComputeMetrics(y); |
Per Åhgren | b20b937 | 2018-07-13 00:22:54 +0200 | [diff] [blame] | 290 | state.Update(delay_estimate, frequency_response, impulse_response, |
Sam Zackrisson | 8f736c0 | 2019-10-01 12:47:53 +0200 | [diff] [blame] | 291 | *render_delay_buffer->GetRenderBuffer(), E2_main, Y2, |
| 292 | subtractor_output); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 293 | } |
| 294 | } |
| 295 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 296 | } // namespace webrtc |