erle_estimator_unittest.cc (12248B)
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/erle_estimator.h" 12 13 #include <algorithm> 14 #include <array> 15 #include <cmath> 16 #include <cstddef> 17 #include <memory> 18 #include <tuple> 19 #include <vector> 20 21 #include "api/array_view.h" 22 #include "api/audio/echo_canceller3_config.h" 23 #include "api/environment/environment_factory.h" 24 #include "modules/audio_processing/aec3/aec3_common.h" 25 #include "modules/audio_processing/aec3/block.h" 26 #include "modules/audio_processing/aec3/render_buffer.h" 27 #include "modules/audio_processing/aec3/render_delay_buffer.h" 28 #include "modules/audio_processing/aec3/spectrum_buffer.h" 29 #include "rtc_base/checks.h" 30 #include "test/gtest.h" 31 32 namespace webrtc { 33 34 namespace { 35 constexpr int kLowFrequencyLimit = kFftLengthBy2 / 2; 36 constexpr float kTrueErle = 10.f; 37 constexpr float kTrueErleOnsets = 1.0f; 38 constexpr float kEchoPathGain = 3.f; 39 40 void VerifyErleBands( 41 ArrayView<const std::array<float, kFftLengthBy2Plus1>> erle, 42 float reference_lf, 43 float reference_hf) { 44 for (size_t ch = 0; ch < erle.size(); ++ch) { 45 std::for_each( 46 erle[ch].begin(), erle[ch].begin() + kLowFrequencyLimit, 47 [reference_lf](float a) { EXPECT_NEAR(reference_lf, a, 0.001); }); 48 std::for_each( 49 erle[ch].begin() + kLowFrequencyLimit, erle[ch].end(), 50 [reference_hf](float a) { EXPECT_NEAR(reference_hf, a, 0.001); }); 51 } 52 } 53 54 void VerifyErle(ArrayView<const std::array<float, kFftLengthBy2Plus1>> erle, 55 float erle_time_domain, 56 float reference_lf, 57 float reference_hf) { 58 VerifyErleBands(erle, reference_lf, reference_hf); 59 EXPECT_NEAR(kTrueErle, erle_time_domain, 0.5); 60 } 61 62 void VerifyErleGreaterOrEqual( 63 ArrayView<const std::array<float, kFftLengthBy2Plus1>> erle1, 64 ArrayView<const std::array<float, kFftLengthBy2Plus1>> erle2) { 65 for (size_t ch = 0; ch < erle1.size(); ++ch) { 66 for (size_t i = 0; i < kFftLengthBy2Plus1; ++i) { 67 EXPECT_GE(erle1[ch][i], erle2[ch][i]); 68 } 69 } 70 } 71 72 void FormFarendTimeFrame(Block* x) { 73 const std::array<float, kBlockSize> frame = { 74 7459.88, 17209.6, 17383, 20768.9, 16816.7, 18386.3, 4492.83, 9675.85, 75 6665.52, 14808.6, 9342.3, 7483.28, 19261.7, 4145.98, 1622.18, 13475.2, 76 7166.32, 6856.61, 21937, 7263.14, 9569.07, 14919, 8413.32, 7551.89, 77 7848.65, 6011.27, 13080.6, 15865.2, 12656, 17459.6, 4263.93, 4503.03, 78 9311.79, 21095.8, 12657.9, 13906.6, 19267.2, 11338.1, 16828.9, 11501.6, 79 11405, 15031.4, 14541.6, 19765.5, 18346.3, 19350.2, 3157.47, 18095.8, 80 1743.68, 21328.2, 19727.5, 7295.16, 10332.4, 11055.5, 20107.4, 14708.4, 81 12416.2, 16434, 2454.69, 9840.8, 6867.23, 1615.75, 6059.9, 8394.19}; 82 for (int band = 0; band < x->NumBands(); ++band) { 83 for (int channel = 0; channel < x->NumChannels(); ++channel) { 84 RTC_DCHECK_GE(kBlockSize, frame.size()); 85 std::copy(frame.begin(), frame.end(), x->begin(band, channel)); 86 } 87 } 88 } 89 90 void FormFarendFrame(const RenderBuffer& render_buffer, 91 float erle, 92 std::array<float, kFftLengthBy2Plus1>* X2, 93 ArrayView<std::array<float, kFftLengthBy2Plus1>> E2, 94 ArrayView<std::array<float, kFftLengthBy2Plus1>> Y2) { 95 const auto& spectrum_buffer = render_buffer.GetSpectrumBuffer(); 96 const int num_render_channels = spectrum_buffer.buffer[0].size(); 97 const int num_capture_channels = Y2.size(); 98 99 X2->fill(0.f); 100 for (int ch = 0; ch < num_render_channels; ++ch) { 101 for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) { 102 (*X2)[k] += spectrum_buffer.buffer[spectrum_buffer.write][ch][k] / 103 num_render_channels; 104 } 105 } 106 107 for (int ch = 0; ch < num_capture_channels; ++ch) { 108 std::transform(X2->begin(), X2->end(), Y2[ch].begin(), 109 [](float a) { return a * kEchoPathGain * kEchoPathGain; }); 110 std::transform(Y2[ch].begin(), Y2[ch].end(), E2[ch].begin(), 111 [erle](float a) { return a / erle; }); 112 } 113 } 114 115 void FormNearendFrame(Block* x, 116 std::array<float, kFftLengthBy2Plus1>* X2, 117 ArrayView<std::array<float, kFftLengthBy2Plus1>> E2, 118 ArrayView<std::array<float, kFftLengthBy2Plus1>> Y2) { 119 for (int band = 0; band < x->NumBands(); ++band) { 120 for (int ch = 0; ch < x->NumChannels(); ++ch) { 121 std::fill(x->begin(band, ch), x->end(band, ch), 0.f); 122 } 123 } 124 125 X2->fill(0.f); 126 for (size_t ch = 0; ch < Y2.size(); ++ch) { 127 Y2[ch].fill(500.f * 1000.f * 1000.f); 128 E2[ch].fill(Y2[ch][0]); 129 } 130 } 131 132 void GetFilterFreq(size_t delay_headroom_samples, 133 ArrayView<std::vector<std::array<float, kFftLengthBy2Plus1>>> 134 filter_frequency_response) { 135 const size_t delay_headroom_blocks = delay_headroom_samples / kBlockSize; 136 for (size_t ch = 0; ch < filter_frequency_response[0].size(); ++ch) { 137 for (auto& block_freq_resp : filter_frequency_response) { 138 block_freq_resp[ch].fill(0.f); 139 } 140 141 for (size_t k = 0; k < kFftLengthBy2Plus1; ++k) { 142 filter_frequency_response[delay_headroom_blocks][ch][k] = kEchoPathGain; 143 } 144 } 145 } 146 147 } // namespace 148 149 class ErleEstimatorMultiChannel 150 : public ::testing::Test, 151 public ::testing::WithParamInterface<std::tuple<size_t, size_t>> {}; 152 153 INSTANTIATE_TEST_SUITE_P(MultiChannel, 154 ErleEstimatorMultiChannel, 155 ::testing::Combine(::testing::Values(1, 2, 4, 8), 156 ::testing::Values(1, 2, 8))); 157 158 TEST_P(ErleEstimatorMultiChannel, VerifyErleIncreaseAndHold) { 159 const size_t num_render_channels = std::get<0>(GetParam()); 160 const size_t num_capture_channels = std::get<1>(GetParam()); 161 constexpr int kSampleRateHz = 48000; 162 constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz); 163 164 std::array<float, kFftLengthBy2Plus1> X2; 165 std::vector<std::array<float, kFftLengthBy2Plus1>> E2(num_capture_channels); 166 std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(num_capture_channels); 167 std::vector<bool> converged_filters(num_capture_channels, true); 168 169 EchoCanceller3Config config; 170 config.erle.onset_detection = true; 171 172 Block x(kNumBands, num_render_channels); 173 std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>> 174 filter_frequency_response( 175 config.filter.refined.length_blocks, 176 std::vector<std::array<float, kFftLengthBy2Plus1>>( 177 num_capture_channels)); 178 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( 179 RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels)); 180 181 GetFilterFreq(config.delay.delay_headroom_samples, filter_frequency_response); 182 183 ErleEstimator estimator(CreateEnvironment(), 0, config, num_capture_channels); 184 185 FormFarendTimeFrame(&x); 186 render_delay_buffer->Insert(x); 187 render_delay_buffer->PrepareCaptureProcessing(); 188 // Verifies that the ERLE estimate is properly increased to higher values. 189 FormFarendFrame(*render_delay_buffer->GetRenderBuffer(), kTrueErle, &X2, E2, 190 Y2); 191 for (size_t k = 0; k < 1000; ++k) { 192 render_delay_buffer->Insert(x); 193 render_delay_buffer->PrepareCaptureProcessing(); 194 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 195 filter_frequency_response, X2, Y2, E2, converged_filters); 196 } 197 VerifyErle(estimator.Erle(/*onset_compensated=*/true), 198 std::pow(2.f, estimator.FullbandErleLog2()), config.erle.max_l, 199 config.erle.max_h); 200 VerifyErleGreaterOrEqual(estimator.Erle(/*onset_compensated=*/false), 201 estimator.Erle(/*onset_compensated=*/true)); 202 VerifyErleGreaterOrEqual(estimator.ErleUnbounded(), 203 estimator.Erle(/*onset_compensated=*/false)); 204 205 FormNearendFrame(&x, &X2, E2, Y2); 206 // Verifies that the ERLE is not immediately decreased during nearend 207 // activity. 208 for (size_t k = 0; k < 50; ++k) { 209 render_delay_buffer->Insert(x); 210 render_delay_buffer->PrepareCaptureProcessing(); 211 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 212 filter_frequency_response, X2, Y2, E2, converged_filters); 213 } 214 VerifyErle(estimator.Erle(/*onset_compensated=*/true), 215 std::pow(2.f, estimator.FullbandErleLog2()), config.erle.max_l, 216 config.erle.max_h); 217 VerifyErleGreaterOrEqual(estimator.Erle(/*onset_compensated=*/false), 218 estimator.Erle(/*onset_compensated=*/true)); 219 VerifyErleGreaterOrEqual(estimator.ErleUnbounded(), 220 estimator.Erle(/*onset_compensated=*/false)); 221 } 222 223 TEST_P(ErleEstimatorMultiChannel, VerifyErleTrackingOnOnsets) { 224 const size_t num_render_channels = std::get<0>(GetParam()); 225 const size_t num_capture_channels = std::get<1>(GetParam()); 226 constexpr int kSampleRateHz = 48000; 227 constexpr size_t kNumBands = NumBandsForRate(kSampleRateHz); 228 229 std::array<float, kFftLengthBy2Plus1> X2; 230 std::vector<std::array<float, kFftLengthBy2Plus1>> E2(num_capture_channels); 231 std::vector<std::array<float, kFftLengthBy2Plus1>> Y2(num_capture_channels); 232 std::vector<bool> converged_filters(num_capture_channels, true); 233 EchoCanceller3Config config; 234 config.erle.onset_detection = true; 235 Block x(kNumBands, num_render_channels); 236 std::vector<std::vector<std::array<float, kFftLengthBy2Plus1>>> 237 filter_frequency_response( 238 config.filter.refined.length_blocks, 239 std::vector<std::array<float, kFftLengthBy2Plus1>>( 240 num_capture_channels)); 241 std::unique_ptr<RenderDelayBuffer> render_delay_buffer( 242 RenderDelayBuffer::Create(config, kSampleRateHz, num_render_channels)); 243 244 GetFilterFreq(config.delay.delay_headroom_samples, filter_frequency_response); 245 246 ErleEstimator estimator(CreateEnvironment(), 247 /*startup_phase_length_blocks=*/0, config, 248 num_capture_channels); 249 250 FormFarendTimeFrame(&x); 251 render_delay_buffer->Insert(x); 252 render_delay_buffer->PrepareCaptureProcessing(); 253 254 for (size_t burst = 0; burst < 20; ++burst) { 255 FormFarendFrame(*render_delay_buffer->GetRenderBuffer(), kTrueErleOnsets, 256 &X2, E2, Y2); 257 for (size_t k = 0; k < 10; ++k) { 258 render_delay_buffer->Insert(x); 259 render_delay_buffer->PrepareCaptureProcessing(); 260 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 261 filter_frequency_response, X2, Y2, E2, 262 converged_filters); 263 } 264 FormFarendFrame(*render_delay_buffer->GetRenderBuffer(), kTrueErle, &X2, E2, 265 Y2); 266 for (size_t k = 0; k < 1000; ++k) { 267 render_delay_buffer->Insert(x); 268 render_delay_buffer->PrepareCaptureProcessing(); 269 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 270 filter_frequency_response, X2, Y2, E2, 271 converged_filters); 272 } 273 FormNearendFrame(&x, &X2, E2, Y2); 274 for (size_t k = 0; k < 300; ++k) { 275 render_delay_buffer->Insert(x); 276 render_delay_buffer->PrepareCaptureProcessing(); 277 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 278 filter_frequency_response, X2, Y2, E2, 279 converged_filters); 280 } 281 } 282 VerifyErleBands(estimator.ErleDuringOnsets(), config.erle.min, 283 config.erle.min); 284 FormNearendFrame(&x, &X2, E2, Y2); 285 for (size_t k = 0; k < 1000; k++) { 286 estimator.Update(*render_delay_buffer->GetRenderBuffer(), 287 filter_frequency_response, X2, Y2, E2, converged_filters); 288 } 289 // Verifies that during ne activity, Erle converges to the Erle for 290 // onsets. 291 VerifyErle(estimator.Erle(/*onset_compensated=*/true), 292 std::pow(2.f, estimator.FullbandErleLog2()), config.erle.min, 293 config.erle.min); 294 } 295 296 } // namespace webrtc