1 files changed, 156 insertions, 0 deletions
diff --git a/third_party/libwebrtc/modules/audio_processing/aec3/render_signal_analyzer.cc b/third_party/libwebrtc/modules/audio_processing/aec3/render_signal_analyzer.cc
new file mode 100644
index 0000000000..bfbeb0ec2e
--- /dev/null
+++ b/third_party/libwebrtc/modules/audio_processing/aec3/render_signal_analyzer.cc
@@ -0,0 +1,156 @@
+/*
+ *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/audio_processing/aec3/render_signal_analyzer.h"
+
+#include <math.h>
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include "api/array_view.h"
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+
+namespace {
+constexpr size_t kCounterThreshold = 5;
+
+// Identifies local bands with narrow characteristics.
+void IdentifySmallNarrowBandRegions(
+    const RenderBuffer& render_buffer,
+    const absl::optional<size_t>& delay_partitions,
+    std::array<size_t, kFftLengthBy2 - 1>* narrow_band_counters) {
+  RTC_DCHECK(narrow_band_counters);
+
+  if (!delay_partitions) {
+    narrow_band_counters->fill(0);
+    return;
+  }
+
+  std::array<size_t, kFftLengthBy2 - 1> channel_counters;
+  channel_counters.fill(0);
+  rtc::ArrayView<const std::array<float, kFftLengthBy2Plus1>> X2 =
+      render_buffer.Spectrum(*delay_partitions);
+  for (size_t ch = 0; ch < X2.size(); ++ch) {
+    for (size_t k = 1; k < kFftLengthBy2; ++k) {
+      if (X2[ch][k] > 3 * std::max(X2[ch][k - 1], X2[ch][k + 1])) {
+        ++channel_counters[k - 1];
+      }
+    }
+  }
+  for (size_t k = 1; k < kFftLengthBy2; ++k) {
+    (*narrow_band_counters)[k - 1] =
+        channel_counters[k - 1] > 0 ? (*narrow_band_counters)[k - 1] + 1 : 0;
+  }
+}
+
+// Identifies whether the signal has a single strong narrow-band component.
+void IdentifyStrongNarrowBandComponent(const RenderBuffer& render_buffer,
+                                       int strong_peak_freeze_duration,
+                                       absl::optional<int>* narrow_peak_band,
+                                       size_t* narrow_peak_counter) {
+  RTC_DCHECK(narrow_peak_band);
+  RTC_DCHECK(narrow_peak_counter);
+  if (*narrow_peak_band &&
+      ++(*narrow_peak_counter) >
+          static_cast<size_t>(strong_peak_freeze_duration)) {
+    *narrow_peak_band = absl::nullopt;
+  }
+
+  const Block& x_latest = render_buffer.GetBlock(0);
+  float max_peak_level = 0.f;
+  for (int channel = 0; channel < x_latest.NumChannels(); ++channel) {
+    rtc::ArrayView<const float, kFftLengthBy2Plus1> X2_latest =
+        render_buffer.Spectrum(0)[channel];
+
+    // Identify the spectral peak.
+    const int peak_bin =
+        static_cast<int>(std::max_element(X2_latest.begin(), X2_latest.end()) -
+                         X2_latest.begin());
+
+    // Compute the level around the peak.
+    float non_peak_power = 0.f;
+    for (int k = std::max(0, peak_bin - 14); k < peak_bin - 4; ++k) {
+      non_peak_power = std::max(X2_latest[k], non_peak_power);
+    }
+    for (int k = peak_bin + 5;
+         k < std::min(peak_bin + 15, static_cast<int>(kFftLengthBy2Plus1));
+         ++k) {
+      non_peak_power = std::max(X2_latest[k], non_peak_power);
+    }
+
+    // Assess the render signal strength.
+    auto result0 = std::minmax_element(x_latest.begin(/*band=*/0, channel),
+                                       x_latest.end(/*band=*/0, channel));
+    float max_abs = std::max(fabs(*result0.first), fabs(*result0.second));
+
+    if (x_latest.NumBands() > 1) {
+      const auto result1 =
+          std::minmax_element(x_latest.begin(/*band=*/1, channel),
+                              x_latest.end(/*band=*/1, channel));
+      max_abs =
+          std::max(max_abs, static_cast<float>(std::max(
+                                fabs(*result1.first), fabs(*result1.second))));
+    }
+
+    // Detect whether the spectral peak has as strong narrowband nature.
+    const float peak_level = X2_latest[peak_bin];
+    if (peak_bin > 0 && max_abs > 100 && peak_level > 100 * non_peak_power) {
+      // Store the strongest peak across channels.
+      if (peak_level > max_peak_level) {
+        max_peak_level = peak_level;
+        *narrow_peak_band = peak_bin;
+        *narrow_peak_counter = 0;
+      }
+    }
+  }
+}
+
+}  // namespace
+
+RenderSignalAnalyzer::RenderSignalAnalyzer(const EchoCanceller3Config& config)
+    : strong_peak_freeze_duration_(config.filter.refined.length_blocks) {
+  narrow_band_counters_.fill(0);
+}
+RenderSignalAnalyzer::~RenderSignalAnalyzer() = default;
+
+void RenderSignalAnalyzer::Update(
+    const RenderBuffer& render_buffer,
+    const absl::optional<size_t>& delay_partitions) {
+  // Identify bands of narrow nature.
+  IdentifySmallNarrowBandRegions(render_buffer, delay_partitions,
+                                 &narrow_band_counters_);
+
+  // Identify the presence of a strong narrow band.
+  IdentifyStrongNarrowBandComponent(render_buffer, strong_peak_freeze_duration_,
+                                    &narrow_peak_band_, &narrow_peak_counter_);
+}
+
+void RenderSignalAnalyzer::MaskRegionsAroundNarrowBands(
+    std::array<float, kFftLengthBy2Plus1>* v) const {
+  RTC_DCHECK(v);
+
+  // Set v to zero around narrow band signal regions.
+  if (narrow_band_counters_[0] > kCounterThreshold) {
+    (*v)[1] = (*v)[0] = 0.f;
+  }
+  for (size_t k = 2; k < kFftLengthBy2 - 1; ++k) {
+    if (narrow_band_counters_[k - 1] > kCounterThreshold) {
+      (*v)[k - 2] = (*v)[k - 1] = (*v)[k] = (*v)[k + 1] = (*v)[k + 2] = 0.f;
+    }
+  }
+  if (narrow_band_counters_[kFftLengthBy2 - 2] > kCounterThreshold) {
+    (*v)[kFftLengthBy2] = (*v)[kFftLengthBy2 - 1] = 0.f;
+  }
+}
+
+}  // namespace webrtc