blob: 0bed6645840bdb5fb003102b8a99f251025e8a5e [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/suppression_gain.h"
peah522d71b2017-02-23 05:16:26 -080012
Mirko Bonadei71207422017-09-15 13:58:09 +020013#include "typedefs.h" // NOLINT(build/include)
peah522d71b2017-02-23 05:16:26 -080014#if defined(WEBRTC_ARCH_X86_FAMILY)
15#include <emmintrin.h>
16#endif
17#include <math.h>
18#include <algorithm>
19#include <functional>
peah86afe9d2017-04-06 15:45:32 -070020#include <numeric>
peah522d71b2017-02-23 05:16:26 -080021
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "modules/audio_processing/aec3/vector_math.h"
23#include "rtc_base/checks.h"
peahcf02cf12017-04-05 14:18:07 -070024
peah522d71b2017-02-23 05:16:26 -080025namespace webrtc {
26namespace {
27
peah14c11a42017-07-11 06:13:43 -070028// Reduce gain to avoid narrow band echo leakage.
29void NarrowBandAttenuation(int narrow_bin,
30 std::array<float, kFftLengthBy2Plus1>* gain) {
31 const int upper_bin =
32 std::min(narrow_bin + 6, static_cast<int>(kFftLengthBy2Plus1 - 1));
33 for (int k = std::max(0, narrow_bin - 6); k <= upper_bin; ++k) {
34 (*gain)[k] = std::min((*gain)[k], 0.001f);
35 }
36}
37
peah1d680892017-05-23 04:07:10 -070038// Adjust the gains according to the presence of known external filters.
39void AdjustForExternalFilters(std::array<float, kFftLengthBy2Plus1>* gain) {
peaha2376e72017-02-27 01:15:24 -080040 // Limit the low frequency gains to avoid the impact of the high-pass filter
41 // on the lower-frequency gain influencing the overall achieved gain.
peah1d680892017-05-23 04:07:10 -070042 (*gain)[0] = (*gain)[1] = std::min((*gain)[1], (*gain)[2]);
peaha2376e72017-02-27 01:15:24 -080043
44 // Limit the high frequency gains to avoid the impact of the anti-aliasing
45 // filter on the upper-frequency gains influencing the overall achieved
46 // gain. TODO(peah): Update this when new anti-aliasing filters are
47 // implemented.
peah86afe9d2017-04-06 15:45:32 -070048 constexpr size_t kAntiAliasingImpactLimit = (64 * 2000) / 8000;
peah1d680892017-05-23 04:07:10 -070049 const float min_upper_gain = (*gain)[kAntiAliasingImpactLimit];
50 std::for_each(
51 gain->begin() + kAntiAliasingImpactLimit, gain->end() - 1,
52 [min_upper_gain](float& a) { a = std::min(a, min_upper_gain); });
53 (*gain)[kFftLengthBy2] = (*gain)[kFftLengthBy2Minus1];
peaha2376e72017-02-27 01:15:24 -080054}
55
peah1d680892017-05-23 04:07:10 -070056// Computes the gain to apply for the bands beyond the first band.
57float UpperBandsGain(
peah14c11a42017-07-11 06:13:43 -070058 const rtc::Optional<int>& narrow_peak_band,
peah1d680892017-05-23 04:07:10 -070059 bool saturated_echo,
60 const std::vector<std::vector<float>>& render,
61 const std::array<float, kFftLengthBy2Plus1>& low_band_gain) {
62 RTC_DCHECK_LT(0, render.size());
peah86afe9d2017-04-06 15:45:32 -070063 if (render.size() == 1) {
64 return 1.f;
65 }
66
peah14c11a42017-07-11 06:13:43 -070067 if (narrow_peak_band &&
68 (*narrow_peak_band > static_cast<int>(kFftLengthBy2Plus1 - 10))) {
69 return 0.001f;
70 }
71
peah1d680892017-05-23 04:07:10 -070072 constexpr size_t kLowBandGainLimit = kFftLengthBy2 / 2;
73 const float gain_below_8_khz = *std::min_element(
74 low_band_gain.begin() + kLowBandGainLimit, low_band_gain.end());
75
peah86afe9d2017-04-06 15:45:32 -070076 // Always attenuate the upper bands when there is saturated echo.
77 if (saturated_echo) {
peah1d680892017-05-23 04:07:10 -070078 return std::min(0.001f, gain_below_8_khz);
peah86afe9d2017-04-06 15:45:32 -070079 }
80
81 // Compute the upper and lower band energies.
peah1d680892017-05-23 04:07:10 -070082 const auto sum_of_squares = [](float a, float b) { return a + b * b; };
83 const float low_band_energy =
84 std::accumulate(render[0].begin(), render[0].end(), 0.f, sum_of_squares);
85 float high_band_energy = 0.f;
peah86afe9d2017-04-06 15:45:32 -070086 for (size_t k = 1; k < render.size(); ++k) {
peah1d680892017-05-23 04:07:10 -070087 const float energy = std::accumulate(render[k].begin(), render[k].end(),
88 0.f, sum_of_squares);
89 high_band_energy = std::max(high_band_energy, energy);
peah86afe9d2017-04-06 15:45:32 -070090 }
91
92 // If there is more power in the lower frequencies than the upper frequencies,
peah1d680892017-05-23 04:07:10 -070093 // or if the power in upper frequencies is low, do not bound the gain in the
peah86afe9d2017-04-06 15:45:32 -070094 // upper bands.
peah1d680892017-05-23 04:07:10 -070095 float anti_howling_gain;
96 constexpr float kThreshold = kSubBlockSize * 10.f * 10.f;
97 if (high_band_energy < std::max(low_band_energy, kThreshold)) {
98 anti_howling_gain = 1.f;
99 } else {
100 // In all other cases, bound the gain for upper frequencies.
101 RTC_DCHECK_LE(low_band_energy, high_band_energy);
102 RTC_DCHECK_NE(0.f, high_band_energy);
103 anti_howling_gain = 0.01f * sqrtf(low_band_energy / high_band_energy);
peah86afe9d2017-04-06 15:45:32 -0700104 }
105
peah1d680892017-05-23 04:07:10 -0700106 // Choose the gain as the minimum of the lower and upper gains.
107 return std::min(gain_below_8_khz, anti_howling_gain);
108}
109
110// Limits the gain increase.
111void UpdateMaxGainIncrease(
peah8cee56f2017-08-24 22:36:53 -0700112 const AudioProcessing::Config::EchoCanceller3& config,
peah1d680892017-05-23 04:07:10 -0700113 size_t no_saturation_counter,
114 bool low_noise_render,
115 const std::array<float, kFftLengthBy2Plus1>& last_echo,
116 const std::array<float, kFftLengthBy2Plus1>& echo,
117 const std::array<float, kFftLengthBy2Plus1>& last_gain,
118 const std::array<float, kFftLengthBy2Plus1>& new_gain,
119 std::array<float, kFftLengthBy2Plus1>* gain_increase) {
120 float max_increasing;
121 float max_decreasing;
122 float rate_increasing;
123 float rate_decreasing;
124 float min_increasing;
125 float min_decreasing;
126
peah8cee56f2017-08-24 22:36:53 -0700127 auto& param = config.param.gain_updates;
peah1d680892017-05-23 04:07:10 -0700128 if (low_noise_render) {
peah8cee56f2017-08-24 22:36:53 -0700129 max_increasing = param.low_noise.max_inc;
130 max_decreasing = param.low_noise.max_dec;
131 rate_increasing = param.low_noise.rate_inc;
132 rate_decreasing = param.low_noise.rate_dec;
133 min_increasing = param.low_noise.min_inc;
134 min_decreasing = param.low_noise.min_dec;
peah1d680892017-05-23 04:07:10 -0700135 } else if (no_saturation_counter > 10) {
peah8cee56f2017-08-24 22:36:53 -0700136 max_increasing = param.normal.max_inc;
137 max_decreasing = param.normal.max_dec;
138 rate_increasing = param.normal.rate_inc;
139 rate_decreasing = param.normal.rate_dec;
140 min_increasing = param.normal.min_inc;
141 min_decreasing = param.normal.min_dec;
peah1d680892017-05-23 04:07:10 -0700142 } else {
peah8cee56f2017-08-24 22:36:53 -0700143 max_increasing = param.saturation.max_inc;
144 max_decreasing = param.saturation.max_dec;
145 rate_increasing = param.saturation.rate_inc;
146 rate_decreasing = param.saturation.rate_dec;
147 min_increasing = param.saturation.min_inc;
148 min_decreasing = param.saturation.min_dec;
peah1d680892017-05-23 04:07:10 -0700149 }
150
151 for (size_t k = 0; k < new_gain.size(); ++k) {
152 if (echo[k] > last_echo[k]) {
153 (*gain_increase)[k] =
154 new_gain[k] > last_gain[k]
155 ? std::min(max_increasing, (*gain_increase)[k] * rate_increasing)
156 : min_increasing;
157 } else {
158 (*gain_increase)[k] =
159 new_gain[k] > last_gain[k]
160 ? std::min(max_decreasing, (*gain_increase)[k] * rate_decreasing)
161 : min_decreasing;
162 }
163 }
164}
165
166// Computes the gain to reduce the echo to a non audible level.
167void GainToNoAudibleEcho(
peah8cee56f2017-08-24 22:36:53 -0700168 const AudioProcessing::Config::EchoCanceller3& config,
peah1d680892017-05-23 04:07:10 -0700169 bool low_noise_render,
170 bool saturated_echo,
171 const std::array<float, kFftLengthBy2Plus1>& nearend,
172 const std::array<float, kFftLengthBy2Plus1>& echo,
173 const std::array<float, kFftLengthBy2Plus1>& masker,
174 const std::array<float, kFftLengthBy2Plus1>& min_gain,
175 const std::array<float, kFftLengthBy2Plus1>& max_gain,
176 const std::array<float, kFftLengthBy2Plus1>& one_by_echo,
177 std::array<float, kFftLengthBy2Plus1>* gain) {
peah1d680892017-05-23 04:07:10 -0700178 const float nearend_masking_margin =
peah8cee56f2017-08-24 22:36:53 -0700179 low_noise_render ? 0.1f
180 : (saturated_echo ? config.param.gain_mask.m2
181 : config.param.gain_mask.m3);
peah1d680892017-05-23 04:07:10 -0700182
183 for (size_t k = 0; k < gain->size(); ++k) {
184 RTC_DCHECK_LE(0.f, nearend_masking_margin * nearend[k]);
185 if (echo[k] <= nearend_masking_margin * nearend[k]) {
186 (*gain)[k] = 1.f;
187 } else {
peah8cee56f2017-08-24 22:36:53 -0700188 (*gain)[k] = config.param.gain_mask.m1 * masker[k] * one_by_echo[k];
peah1d680892017-05-23 04:07:10 -0700189 }
190
191 (*gain)[k] = std::min(std::max((*gain)[k], min_gain[k]), max_gain[k]);
192 }
193}
194
195// Computes the signal output power that masks the echo signal.
peah8cee56f2017-08-24 22:36:53 -0700196void MaskingPower(const AudioProcessing::Config::EchoCanceller3& config,
197 const std::array<float, kFftLengthBy2Plus1>& nearend,
peah1d680892017-05-23 04:07:10 -0700198 const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
199 const std::array<float, kFftLengthBy2Plus1>& last_masker,
200 const std::array<float, kFftLengthBy2Plus1>& gain,
201 std::array<float, kFftLengthBy2Plus1>* masker) {
202 std::array<float, kFftLengthBy2Plus1> side_band_masker;
203 for (size_t k = 0; k < gain.size(); ++k) {
204 side_band_masker[k] = nearend[k] * gain[k] + comfort_noise[k];
peah8cee56f2017-08-24 22:36:53 -0700205 (*masker)[k] =
206 comfort_noise[k] + config.param.gain_mask.m4 * last_masker[k];
peah1d680892017-05-23 04:07:10 -0700207 }
208 for (size_t k = 1; k < gain.size() - 1; ++k) {
209 (*masker)[k] += 0.1f * (side_band_masker[k - 1] + side_band_masker[k + 1]);
210 }
211}
212
213} // namespace
214
215// TODO(peah): Add further optimizations, in particular for the divisions.
216void SuppressionGain::LowerBandGain(
217 bool low_noise_render,
peah14c11a42017-07-11 06:13:43 -0700218 const rtc::Optional<int>& narrow_peak_band,
peah1d680892017-05-23 04:07:10 -0700219 bool saturated_echo,
220 const std::array<float, kFftLengthBy2Plus1>& nearend,
221 const std::array<float, kFftLengthBy2Plus1>& echo,
222 const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
223 std::array<float, kFftLengthBy2Plus1>* gain) {
224 // Count the number of blocks since saturation.
225 no_saturation_counter_ = saturated_echo ? 0 : no_saturation_counter_ + 1;
226
227 // Precompute 1/echo (note that when the echo is zero, the precomputed value
228 // is never used).
229 std::array<float, kFftLengthBy2Plus1> one_by_echo;
230 std::transform(echo.begin(), echo.end(), one_by_echo.begin(),
231 [](float a) { return a > 0.f ? 1.f / a : 1.f; });
232
233 // Compute the minimum gain as the attenuating gain to put the signal just
234 // above the zero sample values.
235 std::array<float, kFftLengthBy2Plus1> min_gain;
peah8cee56f2017-08-24 22:36:53 -0700236 const float min_echo_power =
237 low_noise_render ? config_.param.echo_audibility.low_render_limit
238 : config_.param.echo_audibility.normal_render_limit;
peah1d680892017-05-23 04:07:10 -0700239 if (no_saturation_counter_ > 10) {
240 for (size_t k = 0; k < nearend.size(); ++k) {
241 const float denom = std::min(nearend[k], echo[k]);
242 min_gain[k] = denom > 0.f ? min_echo_power / denom : 1.f;
243 min_gain[k] = std::min(min_gain[k], 1.f);
244 }
245 } else {
246 min_gain.fill(0.f);
247 }
248
249 // Compute the maximum gain by limiting the gain increase from the previous
250 // gain.
251 std::array<float, kFftLengthBy2Plus1> max_gain;
252 for (size_t k = 0; k < gain->size(); ++k) {
253 max_gain[k] =
peah8cee56f2017-08-24 22:36:53 -0700254 std::min(std::max(last_gain_[k] * gain_increase_[k],
255 config_.param.gain_updates.floor_first_increase),
256 1.f);
peah1d680892017-05-23 04:07:10 -0700257 }
258
259 // Iteratively compute the gain required to attenuate the echo to a non
260 // noticeable level.
261 gain->fill(0.f);
262 for (int k = 0; k < 2; ++k) {
263 std::array<float, kFftLengthBy2Plus1> masker;
peah8cee56f2017-08-24 22:36:53 -0700264 MaskingPower(config_, nearend, comfort_noise, last_masker_, *gain, &masker);
265 GainToNoAudibleEcho(config_, low_noise_render, saturated_echo, nearend,
266 echo, masker, min_gain, max_gain, one_by_echo, gain);
peah1d680892017-05-23 04:07:10 -0700267 AdjustForExternalFilters(gain);
peah14c11a42017-07-11 06:13:43 -0700268 if (narrow_peak_band) {
269 NarrowBandAttenuation(*narrow_peak_band, gain);
270 }
peah1d680892017-05-23 04:07:10 -0700271 }
272
273 // Update the allowed maximum gain increase.
peah8cee56f2017-08-24 22:36:53 -0700274 UpdateMaxGainIncrease(config_, no_saturation_counter_, low_noise_render,
275 last_echo_, echo, last_gain_, *gain, &gain_increase_);
peah1d680892017-05-23 04:07:10 -0700276
277 // Store data required for the gain computation of the next block.
278 std::copy(echo.begin(), echo.end(), last_echo_.begin());
279 std::copy(gain->begin(), gain->end(), last_gain_.begin());
peah8cee56f2017-08-24 22:36:53 -0700280 MaskingPower(config_, nearend, comfort_noise, last_masker_, *gain,
281 &last_masker_);
peah1d680892017-05-23 04:07:10 -0700282 aec3::VectorMath(optimization_).Sqrt(*gain);
peah86afe9d2017-04-06 15:45:32 -0700283}
284
peah8cee56f2017-08-24 22:36:53 -0700285SuppressionGain::SuppressionGain(
286 const AudioProcessing::Config::EchoCanceller3& config,
287 Aec3Optimization optimization)
288 : optimization_(optimization), config_(config) {
peah1d680892017-05-23 04:07:10 -0700289 last_gain_.fill(1.f);
290 last_masker_.fill(0.f);
291 gain_increase_.fill(1.f);
292 last_echo_.fill(0.f);
peah522d71b2017-02-23 05:16:26 -0800293}
294
295void SuppressionGain::GetGain(
peah1d680892017-05-23 04:07:10 -0700296 const std::array<float, kFftLengthBy2Plus1>& nearend,
297 const std::array<float, kFftLengthBy2Plus1>& echo,
298 const std::array<float, kFftLengthBy2Plus1>& comfort_noise,
peah14c11a42017-07-11 06:13:43 -0700299 const RenderSignalAnalyzer& render_signal_analyzer,
peah86afe9d2017-04-06 15:45:32 -0700300 bool saturated_echo,
301 const std::vector<std::vector<float>>& render,
peah6d822ad2017-04-10 13:52:14 -0700302 bool force_zero_gain,
peah86afe9d2017-04-06 15:45:32 -0700303 float* high_bands_gain,
304 std::array<float, kFftLengthBy2Plus1>* low_band_gain) {
305 RTC_DCHECK(high_bands_gain);
306 RTC_DCHECK(low_band_gain);
307
peah6d822ad2017-04-10 13:52:14 -0700308 if (force_zero_gain) {
peah1d680892017-05-23 04:07:10 -0700309 last_gain_.fill(0.f);
310 std::copy(comfort_noise.begin(), comfort_noise.end(), last_masker_.begin());
peah6d822ad2017-04-10 13:52:14 -0700311 low_band_gain->fill(0.f);
peah1d680892017-05-23 04:07:10 -0700312 gain_increase_.fill(1.f);
peah6d822ad2017-04-10 13:52:14 -0700313 *high_bands_gain = 0.f;
314 return;
315 }
316
peah1d680892017-05-23 04:07:10 -0700317 bool low_noise_render = low_render_detector_.Detect(render);
peah86afe9d2017-04-06 15:45:32 -0700318
peah1d680892017-05-23 04:07:10 -0700319 // Compute gain for the lower band.
peah14c11a42017-07-11 06:13:43 -0700320 const rtc::Optional<int> narrow_peak_band =
321 render_signal_analyzer.NarrowPeakBand();
322 LowerBandGain(low_noise_render, narrow_peak_band, saturated_echo, nearend,
323 echo, comfort_noise, low_band_gain);
peah86afe9d2017-04-06 15:45:32 -0700324
peah1d680892017-05-23 04:07:10 -0700325 // Compute the gain for the upper bands.
peah14c11a42017-07-11 06:13:43 -0700326 *high_bands_gain =
327 UpperBandsGain(narrow_peak_band, saturated_echo, render, *low_band_gain);
peah1d680892017-05-23 04:07:10 -0700328}
peah86afe9d2017-04-06 15:45:32 -0700329
peah1d680892017-05-23 04:07:10 -0700330// Detects when the render signal can be considered to have low power and
331// consist of stationary noise.
332bool SuppressionGain::LowNoiseRenderDetector::Detect(
333 const std::vector<std::vector<float>>& render) {
334 float x2_sum = 0.f;
335 float x2_max = 0.f;
336 for (auto x_k : render[0]) {
337 const float x2 = x_k * x_k;
338 x2_sum += x2;
339 x2_max = std::max(x2_max, x2);
peah522d71b2017-02-23 05:16:26 -0800340 }
peah1d680892017-05-23 04:07:10 -0700341
342 constexpr float kThreshold = 50.f * 50.f * 64.f;
343 const bool low_noise_render =
344 average_power_ < kThreshold && x2_max < 3 * average_power_;
345 average_power_ = average_power_ * 0.9f + x2_sum * 0.1f;
346 return low_noise_render;
peah522d71b2017-02-23 05:16:26 -0800347}
348
349} // namespace webrtc