Refactoring (bitexact) of the EchoSuppressor in WebRTC AEC (#1)

webrtc/modules/audio_processing/aec/aec_core_neon.c

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 435 matching lines @@
     // Suppress error signal
     efw[0][i] *= hNl[i];
     efw[1][i] *= hNl[i];
 
     // Ooura fft returns incorrect sign on imaginary component. It matters
     // here because we are making an additive change with comfort noise.
     efw[1][i] *= -1;
   }
 }
 
-static int PartitionDelay(const AecCore* aec) {
+static int PartitionDelayNEON(const AecCore* aec) {
   // Measures the energy in each filter partition and returns the partition with
   // highest energy.
   // TODO(bjornv): Spread computational cost by computing one partition per
   // block?
   float wfEnMax = 0;
   int i;
   int delay = 0;
 
   for (i = 0; i < aec->num_partitions; i++) {
     int j;
@@ skipping 164 matching lines @@
 
   if (aec->divergeState)
     memcpy(efw, dfw, sizeof(efw[0][0]) * 2 * PART_LEN1);
 
   // Reset if error is significantly larger than nearend (13 dB).
   if (!aec->extended_filter_enabled && seSum > (19.95f * sdSum))
     memset(aec->wfBuf, 0, sizeof(aec->wfBuf));
 }
 
 // Window time domain data to be used by the fft.
-__inline static void WindowData(float* x_windowed, const float* x) {
+static void WindowDataNEON(float* x_windowed, const float* x) {
   int i;
   for (i = 0; i < PART_LEN; i += 4) {
     const float32x4_t vec_Buf1 = vld1q_f32(&x[i]);
     const float32x4_t vec_Buf2 = vld1q_f32(&x[PART_LEN + i]);
     const float32x4_t vec_sqrtHanning = vld1q_f32(&WebRtcAec_sqrtHanning[i]);
     // A B C D
     float32x4_t vec_sqrtHanning_rev =
         vld1q_f32(&WebRtcAec_sqrtHanning[PART_LEN - i - 3]);
     // B A D C
     vec_sqrtHanning_rev = vrev64q_f32(vec_sqrtHanning_rev);
     // D C B A
     vec_sqrtHanning_rev = vcombine_f32(vget_high_f32(vec_sqrtHanning_rev),
                                        vget_low_f32(vec_sqrtHanning_rev));
     vst1q_f32(&x_windowed[i], vmulq_f32(vec_Buf1, vec_sqrtHanning));
     vst1q_f32(&x_windowed[PART_LEN + i],
             vmulq_f32(vec_Buf2, vec_sqrtHanning_rev));
   }
 }
 
 // Puts fft output data into a complex valued array.
-__inline static void StoreAsComplex(const float* data,
-                                    float data_complex[2][PART_LEN1]) {
+static void StoreAsComplexNEON(const float* data,
+                               float data_complex[2][PART_LEN1]) {
   int i;
   for (i = 0; i < PART_LEN; i += 4) {
     const float32x4x2_t vec_data = vld2q_f32(&data[2 * i]);
     vst1q_f32(&data_complex[0][i], vec_data.val[0]);
     vst1q_f32(&data_complex[1][i], vec_data.val[1]);
   }
   // fix beginning/end values
   data_complex[1][0] = 0;
   data_complex[1][PART_LEN] = 0;
   data_complex[0][0] = data[0];
   data_complex[0][PART_LEN] = data[1];
 }
 
 static void SubbandCoherenceNEON(AecCore* aec,
                                  float efw[2][PART_LEN1],
+                                 float dfw[2][PART_LEN1],
                                  float xfw[2][PART_LEN1],
                                  float* fft,
                                  float* cohde,
                                  float* cohxd) {
-  float dfw[2][PART_LEN1];
   int i;
 
-  if (aec->delayEstCtr == 0)
-    aec->delayIdx = PartitionDelay(aec);
-
-  // Use delayed far.
-  memcpy(xfw,
-         aec->xfwBuf + aec->delayIdx * PART_LEN1,
-         sizeof(xfw[0][0]) * 2 * PART_LEN1);
-
-  // Windowed near fft
-  WindowData(fft, aec->dBuf);
-  aec_rdft_forward_128(fft);
-  StoreAsComplex(fft, dfw);
-
-  // Windowed error fft
-  WindowData(fft, aec->eBuf);
-  aec_rdft_forward_128(fft);
-  StoreAsComplex(fft, efw);
-
   SmoothedPSD(aec, efw, dfw, xfw);
 
   {
     const float32x4_t vec_1eminus10 =  vdupq_n_f32(1e-10f);
 
     // Subband coherence
     for (i = 0; i + 3 < PART_LEN1; i += 4) {
       const float32x4_t vec_sd = vld1q_f32(&aec->sd[i]);
       const float32x4_t vec_se = vld1q_f32(&aec->se[i]);
       const float32x4_t vec_sx = vld1q_f32(&aec->sx[i]);
@@ skipping 22 matching lines @@
         (aec->sx[i] * aec->sd[i] + 1e-10f);
   }
 }
 
 void WebRtcAec_InitAec_neon(void) {
   WebRtcAec_FilterFar = FilterFarNEON;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignalNEON;
   WebRtcAec_FilterAdaptation = FilterAdaptationNEON;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppressNEON;
   WebRtcAec_SubbandCoherence = SubbandCoherenceNEON;
+  WebRtcAec_StoreAsComplex = StoreAsComplexNEON;
+  WebRtcAec_PartitionDelay = PartitionDelayNEON;
+  WebRtcAec_WindowData = WindowDataNEON;
 }