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/render_signal_analyzer.h" |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 12 | |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 13 | #include <math.h> |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 14 | #include <algorithm> |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame^] | 15 | #include <utility> |
| 16 | #include <vector> |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 17 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame^] | 18 | #include "api/array_view.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "rtc_base/checks.h" |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 20 | |
| 21 | namespace webrtc { |
| 22 | |
| 23 | namespace { |
| 24 | constexpr size_t kCounterThreshold = 5; |
| 25 | |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 26 | // Identifies local bands with narrow characteristics. |
| 27 | void IdentifySmallNarrowBandRegions( |
| 28 | const RenderBuffer& render_buffer, |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 29 | const absl::optional<size_t>& delay_partitions, |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 30 | std::array<size_t, kFftLengthBy2 - 1>* narrow_band_counters) { |
| 31 | if (!delay_partitions) { |
| 32 | narrow_band_counters->fill(0); |
| 33 | return; |
| 34 | } |
| 35 | |
Per Åhgren | 8ba5861 | 2017-12-01 23:01:44 +0100 | [diff] [blame] | 36 | rtc::ArrayView<const float> X2 = render_buffer.Spectrum(*delay_partitions); |
| 37 | RTC_DCHECK_EQ(kFftLengthBy2Plus1, X2.size()); |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 38 | |
| 39 | for (size_t k = 1; k < (X2.size() - 1); ++k) { |
| 40 | (*narrow_band_counters)[k - 1] = X2[k] > 3 * std::max(X2[k - 1], X2[k + 1]) |
| 41 | ? (*narrow_band_counters)[k - 1] + 1 |
| 42 | : 0; |
| 43 | } |
| 44 | } |
| 45 | |
| 46 | // Identifies whether the signal has a single strong narrow-band component. |
| 47 | void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer, |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 48 | int strong_peak_freeze_duration, |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 49 | absl::optional<int>* narrow_peak_band, |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 50 | size_t* narrow_peak_counter) { |
| 51 | const auto X2_latest = render_buffer.Spectrum(0); |
| 52 | |
| 53 | // Identify the spectral peak. |
| 54 | const int peak_bin = static_cast<int>( |
| 55 | std::max_element(X2_latest.begin(), X2_latest.end()) - X2_latest.begin()); |
| 56 | |
| 57 | // Compute the level around the peak. |
| 58 | float non_peak_power = 0.f; |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 59 | for (int k = std::max(0, peak_bin - 14); k < peak_bin - 4; ++k) { |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 60 | non_peak_power = std::max(X2_latest[k], non_peak_power); |
| 61 | } |
| 62 | for (int k = peak_bin + 5; |
| 63 | k < std::min(peak_bin + 15, static_cast<int>(kFftLengthBy2Plus1)); ++k) { |
| 64 | non_peak_power = std::max(X2_latest[k], non_peak_power); |
| 65 | } |
| 66 | |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 67 | // Assess the render signal strength. |
Per Åhgren | ec22e3f | 2017-12-20 15:20:37 +0100 | [diff] [blame] | 68 | const std::vector<std::vector<float>>& x_latest = render_buffer.Block(0); |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 69 | auto result0 = std::minmax_element(x_latest[0].begin(), x_latest[0].end()); |
| 70 | float max_abs = std::max(fabs(*result0.first), fabs(*result0.second)); |
| 71 | |
| 72 | if (x_latest.size() > 1) { |
| 73 | const auto result1 = |
| 74 | std::minmax_element(x_latest[1].begin(), x_latest[1].end()); |
| 75 | max_abs = |
| 76 | std::max(max_abs, static_cast<float>(std::max(fabs(*result1.first), |
| 77 | fabs(*result1.second)))); |
| 78 | } |
| 79 | |
| 80 | // Detect whether the spectal peak has as strong narrowband nature. |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 81 | if (peak_bin > 0 && max_abs > 100 && |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 82 | X2_latest[peak_bin] > 100 * non_peak_power) { |
Oskar Sundbom | aa8b67d | 2017-11-17 14:34:48 +0100 | [diff] [blame] | 83 | *narrow_peak_band = peak_bin; |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 84 | *narrow_peak_counter = 0; |
| 85 | } else { |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 86 | if (*narrow_peak_band && |
| 87 | ++(*narrow_peak_counter) > |
| 88 | static_cast<size_t>(strong_peak_freeze_duration)) { |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 89 | *narrow_peak_band = absl::nullopt; |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 90 | } |
| 91 | } |
| 92 | } |
| 93 | |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 94 | } // namespace |
| 95 | |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 96 | RenderSignalAnalyzer::RenderSignalAnalyzer(const EchoCanceller3Config& config) |
| 97 | : strong_peak_freeze_duration_(config.filter.main.length_blocks) { |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 98 | narrow_band_counters_.fill(0); |
| 99 | } |
| 100 | RenderSignalAnalyzer::~RenderSignalAnalyzer() = default; |
| 101 | |
| 102 | void RenderSignalAnalyzer::Update( |
peah | cf02cf1 | 2017-04-05 14:18:07 -0700 | [diff] [blame] | 103 | const RenderBuffer& render_buffer, |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 104 | const absl::optional<size_t>& delay_partitions) { |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 105 | // Identify bands of narrow nature. |
| 106 | IdentifySmallNarrowBandRegions(render_buffer, delay_partitions, |
| 107 | &narrow_band_counters_); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 108 | |
peah | 14c11a4 | 2017-07-11 06:13:43 -0700 | [diff] [blame] | 109 | // Identify the presence of a strong narrow band. |
Per Åhgren | 971de07 | 2018-03-14 23:23:47 +0100 | [diff] [blame] | 110 | IdentifyStrongNarrowBandComponent(render_buffer, strong_peak_freeze_duration_, |
| 111 | &narrow_peak_band_, &narrow_peak_counter_); |
peah | 522d71b | 2017-02-23 05:16:26 -0800 | [diff] [blame] | 112 | } |
| 113 | |
| 114 | void RenderSignalAnalyzer::MaskRegionsAroundNarrowBands( |
| 115 | std::array<float, kFftLengthBy2Plus1>* v) const { |
| 116 | RTC_DCHECK(v); |
| 117 | |
| 118 | // Set v to zero around narrow band signal regions. |
| 119 | if (narrow_band_counters_[0] > kCounterThreshold) { |
| 120 | (*v)[1] = (*v)[0] = 0.f; |
| 121 | } |
| 122 | for (size_t k = 2; k < kFftLengthBy2 - 1; ++k) { |
| 123 | if (narrow_band_counters_[k - 1] > kCounterThreshold) { |
| 124 | (*v)[k - 2] = (*v)[k - 1] = (*v)[k] = (*v)[k + 1] = (*v)[k + 2] = 0.f; |
| 125 | } |
| 126 | } |
| 127 | if (narrow_band_counters_[kFftLengthBy2 - 2] > kCounterThreshold) { |
| 128 | (*v)[kFftLengthBy2] = (*v)[kFftLengthBy2 - 1] = 0.f; |
| 129 | } |
| 130 | } |
| 131 | |
| 132 | } // namespace webrtc |