Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 278 insertions, 0 deletions

diff --git a/third_party/libwebrtc/modules/audio_processing/three_band_filter_bank.cc b/third_party/libwebrtc/modules/audio_processing/three_band_filter_bank.cc
new file mode 100644
index 0000000000..bd1c50477a
--- /dev/null
+++ b/third_party/libwebrtc/modules/audio_processing/three_band_filter_bank.cc
@@ -0,0 +1,278 @@
+/*
+ *  Copyright (c) 2015 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.
+ */
+
+// An implementation of a 3-band FIR filter-bank with DCT modulation, similar to
+// the proposed in "Multirate Signal Processing for Communication Systems" by
+// Fredric J Harris.
+//
+// The idea is to take a heterodyne system and change the order of the
+// components to get something which is efficient to implement digitally.
+//
+// It is possible to separate the filter using the noble identity as follows:
+//
+// H(z) = H0(z^3) + z^-1 * H1(z^3) + z^-2 * H2(z^3)
+//
+// This is used in the analysis stage to first downsample serial to parallel
+// and then filter each branch with one of these polyphase decompositions of the
+// lowpass prototype. Because each filter is only a modulation of the prototype,
+// it is enough to multiply each coefficient by the respective cosine value to
+// shift it to the desired band. But because the cosine period is 12 samples,
+// it requires separating the prototype even further using the noble identity.
+// After filtering and modulating for each band, the output of all filters is
+// accumulated to get the downsampled bands.
+//
+// A similar logic can be applied to the synthesis stage.
+
+#include "modules/audio_processing/three_band_filter_bank.h"
+
+#include <array>
+
+#include "rtc_base/checks.h"
+
+namespace webrtc {
+namespace {
+
+// Factors to take into account when choosing `kFilterSize`:
+//   1. Higher `kFilterSize`, means faster transition, which ensures less
+//      aliasing. This is especially important when there is non-linear
+//      processing between the splitting and merging.
+//   2. The delay that this filter bank introduces is
+//      `kNumBands` * `kSparsity` * `kFilterSize` / 2, so it increases linearly
+//      with `kFilterSize`.
+//   3. The computation complexity also increases linearly with `kFilterSize`.
+
+// The Matlab code to generate these `kFilterCoeffs` is:
+//
+// N = kNumBands * kSparsity * kFilterSize - 1;
+// h = fir1(N, 1 / (2 * kNumBands), kaiser(N + 1, 3.5));
+// reshape(h, kNumBands * kSparsity, kFilterSize);
+//
+// The code below uses the values of kFilterSize, kNumBands and kSparsity
+// specified in the header.
+
+// Because the total bandwidth of the lower and higher band is double the middle
+// one (because of the spectrum parity), the low-pass prototype is half the
+// bandwidth of 1 / (2 * `kNumBands`) and is then shifted with cosine modulation
+// to the right places.
+// A Kaiser window is used because of its flexibility and the alpha is set to
+// 3.5, since that sets a stop band attenuation of 40dB ensuring a fast
+// transition.
+
+constexpr int kSubSampling = ThreeBandFilterBank::kNumBands;
+constexpr int kDctSize = ThreeBandFilterBank::kNumBands;
+static_assert(ThreeBandFilterBank::kNumBands *
+                      ThreeBandFilterBank::kSplitBandSize ==
+                  ThreeBandFilterBank::kFullBandSize,
+              "The full band must be split in equally sized subbands");
+
+const float
+    kFilterCoeffs[ThreeBandFilterBank::kNumNonZeroFilters][kFilterSize] = {
+        {-0.00047749f, -0.00496888f, +0.16547118f, +0.00425496f},
+        {-0.00173287f, -0.01585778f, +0.14989004f, +0.00994113f},
+        {-0.00304815f, -0.02536082f, +0.12154542f, +0.01157993f},
+        {-0.00346946f, -0.02587886f, +0.04760441f, +0.00607594f},
+        {-0.00154717f, -0.01136076f, +0.01387458f, +0.00186353f},
+        {+0.00186353f, +0.01387458f, -0.01136076f, -0.00154717f},
+        {+0.00607594f, +0.04760441f, -0.02587886f, -0.00346946f},
+        {+0.00983212f, +0.08543175f, -0.02982767f, -0.00383509f},
+        {+0.00994113f, +0.14989004f, -0.01585778f, -0.00173287f},
+        {+0.00425496f, +0.16547118f, -0.00496888f, -0.00047749f}};
+
+constexpr int kZeroFilterIndex1 = 3;
+constexpr int kZeroFilterIndex2 = 9;
+
+const float kDctModulation[ThreeBandFilterBank::kNumNonZeroFilters][kDctSize] =
+    {{2.f, 2.f, 2.f},
+     {1.73205077f, 0.f, -1.73205077f},
+     {1.f, -2.f, 1.f},
+     {-1.f, 2.f, -1.f},
+     {-1.73205077f, 0.f, 1.73205077f},
+     {-2.f, -2.f, -2.f},
+     {-1.73205077f, 0.f, 1.73205077f},
+     {-1.f, 2.f, -1.f},
+     {1.f, -2.f, 1.f},
+     {1.73205077f, 0.f, -1.73205077f}};
+
+// Filters the input signal `in` with the filter `filter` using a shift by
+// `in_shift`, taking into account the previous state.
+void FilterCore(
+    rtc::ArrayView<const float, kFilterSize> filter,
+    rtc::ArrayView<const float, ThreeBandFilterBank::kSplitBandSize> in,
+    const int in_shift,
+    rtc::ArrayView<float, ThreeBandFilterBank::kSplitBandSize> out,
+    rtc::ArrayView<float, kMemorySize> state) {
+  constexpr int kMaxInShift = (kStride - 1);
+  RTC_DCHECK_GE(in_shift, 0);
+  RTC_DCHECK_LE(in_shift, kMaxInShift);
+  std::fill(out.begin(), out.end(), 0.f);
+
+  for (int k = 0; k < in_shift; ++k) {
+    for (int i = 0, j = kMemorySize + k - in_shift; i < kFilterSize;
+         ++i, j -= kStride) {
+      out[k] += state[j] * filter[i];
+    }
+  }
+
+  for (int k = in_shift, shift = 0; k < kFilterSize * kStride; ++k, ++shift) {
+    RTC_DCHECK_GE(shift, 0);
+    const int loop_limit = std::min(kFilterSize, 1 + (shift >> kStrideLog2));
+    for (int i = 0, j = shift; i < loop_limit; ++i, j -= kStride) {
+      out[k] += in[j] * filter[i];
+    }
+    for (int i = loop_limit, j = kMemorySize + shift - loop_limit * kStride;
+         i < kFilterSize; ++i, j -= kStride) {
+      out[k] += state[j] * filter[i];
+    }
+  }
+
+  for (int k = kFilterSize * kStride, shift = kFilterSize * kStride - in_shift;
+       k < ThreeBandFilterBank::kSplitBandSize; ++k, ++shift) {
+    for (int i = 0, j = shift; i < kFilterSize; ++i, j -= kStride) {
+      out[k] += in[j] * filter[i];
+    }
+  }
+
+  // Update current state.
+  std::copy(in.begin() + ThreeBandFilterBank::kSplitBandSize - kMemorySize,
+            in.end(), state.begin());
+}
+
+}  // namespace
+
+// Because the low-pass filter prototype has half bandwidth it is possible to
+// use a DCT to shift it in both directions at the same time, to the center
+// frequencies [1 / 12, 3 / 12, 5 / 12].
+ThreeBandFilterBank::ThreeBandFilterBank() {
+  RTC_DCHECK_EQ(state_analysis_.size(), kNumNonZeroFilters);
+  RTC_DCHECK_EQ(state_synthesis_.size(), kNumNonZeroFilters);
+  for (int k = 0; k < kNumNonZeroFilters; ++k) {
+    RTC_DCHECK_EQ(state_analysis_[k].size(), kMemorySize);
+    RTC_DCHECK_EQ(state_synthesis_[k].size(), kMemorySize);
+
+    state_analysis_[k].fill(0.f);
+    state_synthesis_[k].fill(0.f);
+  }
+}
+
+ThreeBandFilterBank::~ThreeBandFilterBank() = default;
+
+// The analysis can be separated in these steps:
+//   1. Serial to parallel downsampling by a factor of `kNumBands`.
+//   2. Filtering of `kSparsity` different delayed signals with polyphase
+//      decomposition of the low-pass prototype filter and upsampled by a factor
+//      of `kSparsity`.
+//   3. Modulating with cosines and accumulating to get the desired band.
+void ThreeBandFilterBank::Analysis(
+    rtc::ArrayView<const float, kFullBandSize> in,
+    rtc::ArrayView<const rtc::ArrayView<float>, ThreeBandFilterBank::kNumBands>
+        out) {
+  // Initialize the output to zero.
+  for (int band = 0; band < ThreeBandFilterBank::kNumBands; ++band) {
+    RTC_DCHECK_EQ(out[band].size(), kSplitBandSize);
+    std::fill(out[band].begin(), out[band].end(), 0);
+  }
+
+  for (int downsampling_index = 0; downsampling_index < kSubSampling;
+       ++downsampling_index) {
+    // Downsample to form the filter input.
+    std::array<float, kSplitBandSize> in_subsampled;
+    for (int k = 0; k < kSplitBandSize; ++k) {
+      in_subsampled[k] =
+          in[(kSubSampling - 1) - downsampling_index + kSubSampling * k];
+    }
+
+    for (int in_shift = 0; in_shift < kStride; ++in_shift) {
+      // Choose filter, skip zero filters.
+      const int index = downsampling_index + in_shift * kSubSampling;
+      if (index == kZeroFilterIndex1 || index == kZeroFilterIndex2) {
+        continue;
+      }
+      const int filter_index =
+          index < kZeroFilterIndex1
+              ? index
+              : (index < kZeroFilterIndex2 ? index - 1 : index - 2);
+
+      rtc::ArrayView<const float, kFilterSize> filter(
+          kFilterCoeffs[filter_index]);
+      rtc::ArrayView<const float, kDctSize> dct_modulation(
+          kDctModulation[filter_index]);
+      rtc::ArrayView<float, kMemorySize> state(state_analysis_[filter_index]);
+
+      // Filter.
+      std::array<float, kSplitBandSize> out_subsampled;
+      FilterCore(filter, in_subsampled, in_shift, out_subsampled, state);
+
+      // Band and modulate the output.
+      for (int band = 0; band < ThreeBandFilterBank::kNumBands; ++band) {
+        float* out_band = out[band].data();
+        for (int n = 0; n < kSplitBandSize; ++n) {
+          out_band[n] += dct_modulation[band] * out_subsampled[n];
+        }
+      }
+    }
+  }
+}
+
+// The synthesis can be separated in these steps:
+//   1. Modulating with cosines.
+//   2. Filtering each one with a polyphase decomposition of the low-pass
+//      prototype filter upsampled by a factor of `kSparsity` and accumulating
+//      `kSparsity` signals with different delays.
+//   3. Parallel to serial upsampling by a factor of `kNumBands`.
+void ThreeBandFilterBank::Synthesis(
+    rtc::ArrayView<const rtc::ArrayView<float>, ThreeBandFilterBank::kNumBands>
+        in,
+    rtc::ArrayView<float, kFullBandSize> out) {
+  std::fill(out.begin(), out.end(), 0);
+  for (int upsampling_index = 0; upsampling_index < kSubSampling;
+       ++upsampling_index) {
+    for (int in_shift = 0; in_shift < kStride; ++in_shift) {
+      // Choose filter, skip zero filters.
+      const int index = upsampling_index + in_shift * kSubSampling;
+      if (index == kZeroFilterIndex1 || index == kZeroFilterIndex2) {
+        continue;
+      }
+      const int filter_index =
+          index < kZeroFilterIndex1
+              ? index
+              : (index < kZeroFilterIndex2 ? index - 1 : index - 2);
+
+      rtc::ArrayView<const float, kFilterSize> filter(
+          kFilterCoeffs[filter_index]);
+      rtc::ArrayView<const float, kDctSize> dct_modulation(
+          kDctModulation[filter_index]);
+      rtc::ArrayView<float, kMemorySize> state(state_synthesis_[filter_index]);
+
+      // Prepare filter input by modulating the banded input.
+      std::array<float, kSplitBandSize> in_subsampled;
+      std::fill(in_subsampled.begin(), in_subsampled.end(), 0.f);
+      for (int band = 0; band < ThreeBandFilterBank::kNumBands; ++band) {
+        RTC_DCHECK_EQ(in[band].size(), kSplitBandSize);
+        const float* in_band = in[band].data();
+        for (int n = 0; n < kSplitBandSize; ++n) {
+          in_subsampled[n] += dct_modulation[band] * in_band[n];
+        }
+      }
+
+      // Filter.
+      std::array<float, kSplitBandSize> out_subsampled;
+      FilterCore(filter, in_subsampled, in_shift, out_subsampled, state);
+
+      // Upsample.
+      constexpr float kUpsamplingScaling = kSubSampling;
+      for (int k = 0; k < kSplitBandSize; ++k) {
+        out[upsampling_index + kSubSampling * k] +=
+            kUpsamplingScaling * out_subsampled[k];
+      }
+    }
+  }
+}
+
+}  // namespace webrtc