Adding new functionality for SIMD optimizations in AEC3

webrtc/modules/audio_processing/aec3/suppression_gain.cc

Index: webrtc/modules/audio_processing/aec3/suppression_gain.cc
diff --git a/webrtc/modules/audio_processing/aec3/suppression_gain.cc b/webrtc/modules/audio_processing/aec3/suppression_gain.cc
index 4bf452cbbea51563b86516e770385ac48d32ee33..4507d21518e3a1074e4bc9d0196ce67fc5a87736 100644
--- a/webrtc/modules/audio_processing/aec3/suppression_gain.cc
+++ b/webrtc/modules/audio_processing/aec3/suppression_gain.cc
@@ -20,6 +20,7 @@
 #include <numeric>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/modules/audio_processing/aec3/vector_math.h"
 
 namespace webrtc {
 namespace {
@@ -48,127 +49,9 @@ constexpr float kEchoMaskingMargin = 1.f / 20.f;
 constexpr float kBandMaskingFactor = 1.f / 10.f;
 constexpr float kTimeMaskingFactor = 1.f / 10.f;
 
-}  // namespace
-
-namespace aec3 {
-
-#if defined(WEBRTC_ARCH_X86_FAMILY)
-
-// Optimized SSE2 code for the gain computation.
 // TODO(peah): Add further optimizations, in particular for the divisions.

[ivoc, 2017/04/11 12:03:01]

Is this still relevant?

[peah-webrtc, 2017/04/11 13:09:26]

Yes, I did not add the optimizations for the divisions on line 71. Furthermore,
we probably want to do some more optimized methods for the rest of the vector
operations.

-void ComputeGains_SSE2(
-    const std::array<float, kFftLengthBy2Plus1>& nearend_power,
-    const std::array<float, kFftLengthBy2Plus1>& residual_echo_power,
-    const std::array<float, kFftLengthBy2Plus1>& comfort_noise_power,
-    float strong_nearend_margin,
-    std::array<float, kFftLengthBy2Minus1>* previous_gain_squared,
-    std::array<float, kFftLengthBy2Minus1>* previous_masker,
-    std::array<float, kFftLengthBy2Plus1>* gain) {
-  std::array<float, kFftLengthBy2Minus1> masker;
-  std::array<float, kFftLengthBy2Minus1> same_band_masker;
-  std::array<float, kFftLengthBy2Minus1> one_by_residual_echo_power;
-  std::array<bool, kFftLengthBy2Minus1> strong_nearend;
-  std::array<float, kFftLengthBy2Plus1> neighboring_bands_masker;
-  std::array<float, kFftLengthBy2Plus1>* gain_squared = gain;
-
-  // Precompute 1/residual_echo_power.
-  std::transform(residual_echo_power.begin() + 1, residual_echo_power.end() - 1,
-                 one_by_residual_echo_power.begin(),
-                 [](float a) { return a > 0.f ? 1.f / a : -1.f; });
-
-  // Precompute indicators for bands with strong nearend.
-  std::transform(
-      residual_echo_power.begin() + 1, residual_echo_power.end() - 1,
-      nearend_power.begin() + 1, strong_nearend.begin(),
-      [&](float a, float b) { return a <= strong_nearend_margin * b; });
-
-  //  Precompute masker for the same band.
-  std::transform(comfort_noise_power.begin() + 1, comfort_noise_power.end() - 1,
-                 previous_masker->begin(), same_band_masker.begin(),
-                 [&](float a, float b) { return a + kTimeMaskingFactor * b; });
-
-  for (int k = 0; k < kNumIterations; ++k) {
-    if (k == 0) {
-      // Add masker from the same band.
-      std::copy(same_band_masker.begin(), same_band_masker.end(),
-                masker.begin());
-    } else {
-      // Add masker for neighboring bands.
-      std::transform(nearend_power.begin(), nearend_power.end(),
-                     gain_squared->begin(), neighboring_bands_masker.begin(),
-                     std::multiplies<float>());
-      std::transform(neighboring_bands_masker.begin(),
-                     neighboring_bands_masker.end(),
-                     comfort_noise_power.begin(),
-                     neighboring_bands_masker.begin(), std::plus<float>());
-      std::transform(
-          neighboring_bands_masker.begin(), neighboring_bands_masker.end() - 2,
-          neighboring_bands_masker.begin() + 2, masker.begin(),
-          [&](float a, float b) { return kBandMaskingFactor * (a + b); });
-
-      // Add masker from the same band.
-      std::transform(same_band_masker.begin(), same_band_masker.end(),
-                     masker.begin(), masker.begin(), std::plus<float>());
-    }
-
-    // Compute new gain as:
-    // G2(t,f) = (comfort_noise_power(t,f) + G2(t-1)*nearend_power(t-1)) *
-    //           kTimeMaskingFactor
-    //           * kEchoMaskingMargin / residual_echo_power(t,f).
-    // or
-    // G2(t,f) = ((comfort_noise_power(t,f) + G2(t-1) *
-    //             nearend_power(t-1)) * kTimeMaskingFactor +
-    //            (comfort_noise_power(t, f-1) + comfort_noise_power(t, f+1) +
-    //             (G2(t,f-1)*nearend_power(t, f-1) +
-    //              G2(t,f+1)*nearend_power(t, f+1)) *
-    //             kTimeMaskingFactor) * kBandMaskingFactor)
-    //           * kEchoMaskingMargin / residual_echo_power(t,f).
-    std::transform(
-        masker.begin(), masker.end(), one_by_residual_echo_power.begin(),
-        gain_squared->begin() + 1, [&](float a, float b) {
-          return b >= 0 ? std::min(kEchoMaskingMargin * a * b, 1.f) : 1.f;
-        });
-
-    // Limit gain for bands with strong nearend.
-    std::transform(gain_squared->begin() + 1, gain_squared->end() - 1,
-                   strong_nearend.begin(), gain_squared->begin() + 1,
-                   [](float a, bool b) { return b ? 1.f : a; });
-
-    // Limit the allowed gain update over time.
-    std::transform(gain_squared->begin() + 1, gain_squared->end() - 1,
-                   previous_gain_squared->begin(), gain_squared->begin() + 1,
-                   [](float a, float b) {
-                     return b < 0.001f ? std::min(a, 0.001f)
-                                       : std::min(a, b * 2.f);
-                   });
-
-    // Process the gains to avoid artefacts caused by gain realization in the
-    // filterbank and impact of external pre-processing of the signal.
-    GainPostProcessing(gain_squared);
-  }
-
-  std::copy(gain_squared->begin() + 1, gain_squared->end() - 1,
-            previous_gain_squared->begin());
-
-  std::transform(gain_squared->begin() + 1, gain_squared->end() - 1,
-                 nearend_power.begin() + 1, previous_masker->begin(),
-                 std::multiplies<float>());
-  std::transform(previous_masker->begin(), previous_masker->end(),
-                 comfort_noise_power.begin() + 1, previous_masker->begin(),
-                 std::plus<float>());
-
-  for (size_t k = 0; k < kFftLengthBy2; k += 4) {
-    __m128 g = _mm_loadu_ps(&(*gain_squared)[k]);
-    g = _mm_sqrt_ps(g);
-    _mm_storeu_ps(&(*gain)[k], g);
-  }
-
-  (*gain)[kFftLengthBy2] = sqrtf((*gain)[kFftLengthBy2]);
-}
-
-#endif
-
 void ComputeGains(
+    Aec3Optimization optimization,
     const std::array<float, kFftLengthBy2Plus1>& nearend_power,
     const std::array<float, kFftLengthBy2Plus1>& residual_echo_power,
     const std::array<float, kFftLengthBy2Plus1>& comfort_noise_power,
@@ -182,6 +65,7 @@ void ComputeGains(
   std::array<bool, kFftLengthBy2Minus1> strong_nearend;
   std::array<float, kFftLengthBy2Plus1> neighboring_bands_masker;
   std::array<float, kFftLengthBy2Plus1>* gain_squared = gain;
+  aec3::VectorMath math(optimization);
 
   // Precompute 1/residual_echo_power.
   std::transform(residual_echo_power.begin() + 1, residual_echo_power.end() - 1,
@@ -205,22 +89,16 @@ void ComputeGains(
       std::copy(same_band_masker.begin(), same_band_masker.end(),
                 masker.begin());
     } else {
-      // Add masker for neightboring bands.
-      std::transform(nearend_power.begin(), nearend_power.end(),
-                     gain_squared->begin(), neighboring_bands_masker.begin(),
-                     std::multiplies<float>());
-      std::transform(neighboring_bands_masker.begin(),
-                     neighboring_bands_masker.end(),
-                     comfort_noise_power.begin(),
-                     neighboring_bands_masker.begin(), std::plus<float>());
+      // Add masker for neighboring bands.
+      math.Multiply(nearend_power, *gain_squared, neighboring_bands_masker);
+      math.Accumulate(comfort_noise_power, neighboring_bands_masker);
       std::transform(
           neighboring_bands_masker.begin(), neighboring_bands_masker.end() - 2,
           neighboring_bands_masker.begin() + 2, masker.begin(),
           [&](float a, float b) { return kBandMaskingFactor * (a + b); });
 
       // Add masker from the same band.
-      std::transform(same_band_masker.begin(), same_band_masker.end(),
-                     masker.begin(), masker.begin(), std::plus<float>());
+      math.Accumulate(same_band_masker, masker);
     }
 
     // Compute new gain as:
@@ -262,18 +140,18 @@ void ComputeGains(
   std::copy(gain_squared->begin() + 1, gain_squared->end() - 1,
             previous_gain_squared->begin());
 
-  std::transform(gain_squared->begin() + 1, gain_squared->end() - 1,
-                 nearend_power.begin() + 1, previous_masker->begin(),
-                 std::multiplies<float>());
-  std::transform(previous_masker->begin(), previous_masker->end(),
-                 comfort_noise_power.begin() + 1, previous_masker->begin(),
-                 std::plus<float>());
-
-  std::transform(gain_squared->begin(), gain_squared->end(), gain->begin(),
-                 [](float a) { return sqrtf(a); });
+  math.Multiply(rtc::ArrayView<const float>(gain_squared->begin() + 1,
+                                            previous_masker->size()),
+                rtc::ArrayView<const float>(nearend_power.begin() + 1,
+                                            previous_masker->size()),
+                *previous_masker);
+  math.Accumulate(rtc::ArrayView<const float>(comfort_noise_power.begin() + 1,
+                                              previous_masker->size()),
+                  *previous_masker);
+  math.Sqrt(*gain);
 }
 
-}  // namespace aec3
+}  // namespace
 
 // Computes an upper bound on the gain to apply for high frequencies.
 float HighFrequencyGainBound(bool saturated_echo,
@@ -342,19 +220,9 @@ void SuppressionGain::GetGain(
 
   // Choose margin to use.
   const float margin = saturated_echo ? 0.001f : 0.01f;
-  switch (optimization_) {
-#if defined(WEBRTC_ARCH_X86_FAMILY)
-    case Aec3Optimization::kSse2:
-      aec3::ComputeGains_SSE2(
-          nearend_power, residual_echo_power, comfort_noise_power, margin,
-          &previous_gain_squared_, &previous_masker_, low_band_gain);
-      break;
-#endif
-    default:
-      aec3::ComputeGains(nearend_power, residual_echo_power,
-                         comfort_noise_power, margin, &previous_gain_squared_,
-                         &previous_masker_, low_band_gain);
-  }
+  ComputeGains(optimization_, nearend_power, residual_echo_power,
+               comfort_noise_power, margin, &previous_gain_squared_,
+               &previous_masker_, low_band_gain);
 
   if (num_capture_bands > 1) {
     // Compute the gain for upper frequencies.