Ducking fix #3: Removed the state as an input to the FilterAdaptation function

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 111 matching lines @@
     x = vmulq_f32(vrsqrtsq_f32(vmulq_f32(x, x), s), x);
   }
   // sqrt(s) = s * 1/sqrt(s)
   return vmulq_f32(s, x);;
 }
 #endif  // WEBRTC_ARCH_ARM64
 
 static void ScaleErrorSignalNEON(int extended_filter_enabled,
                                  float normal_mu,
                                  float normal_error_threshold,
-                                 float *xPow,
+                                 float xPow[PART_LEN1],
                                  float ef[2][PART_LEN1]) {
   const float mu = extended_filter_enabled ? kExtendedMu : normal_mu;
   const float error_threshold = extended_filter_enabled ?
       kExtendedErrorThreshold : normal_error_threshold;
   const float32x4_t k1e_10f = vdupq_n_f32(1e-10f);
   const float32x4_t kMu = vmovq_n_f32(mu);
   const float32x4_t kThresh = vmovq_n_f32(error_threshold);
   int i;
   // vectorized code (four at once)
   for (i = 0; i + 3 < PART_LEN1; i += 4) {
@@ skipping 36 matching lines @@
       ef[0][i] *= abs_ef;
       ef[1][i] *= abs_ef;
     }
 
     // Stepsize factor
     ef[0][i] *= mu;
     ef[1][i] *= mu;
   }
 }
 
-static void FilterAdaptationNEON(AecCore* aec,
-                                 float* fft,
-                                 float ef[2][PART_LEN1]) {
+static void FilterAdaptationNEON(
+    int num_partitions,
+    int xfBufBlockPos,
+    float xfBuf[2][kExtendedNumPartitions * PART_LEN1],
+    float ef[2][PART_LEN1],
+    float wfBuf[2][kExtendedNumPartitions * PART_LEN1]) {
+  float fft[PART_LEN2];
   int i;
-  const int num_partitions = aec->num_partitions;
+  const int num_partitions = num_partitions;
   for (i = 0; i < num_partitions; i++) {
-    int xPos = (i + aec->xfBufBlockPos) * PART_LEN1;
+    int xPos = (i + xfBufBlockPos) * PART_LEN1;
     int pos = i * PART_LEN1;
     int j;
     // Check for wrap
-    if (i + aec->xfBufBlockPos >= num_partitions) {
+    if (i + xfBufBlockPos >= num_partitions) {
       xPos -= num_partitions * PART_LEN1;
     }
 
     // Process the whole array...
     for (j = 0; j < PART_LEN; j += 4) {
       // Load xfBuf and ef.
-      const float32x4_t xfBuf_re = vld1q_f32(&aec->xfBuf[0][xPos + j]);
-      const float32x4_t xfBuf_im = vld1q_f32(&aec->xfBuf[1][xPos + j]);
+      const float32x4_t xfBuf_re = vld1q_f32(&xfBuf[0][xPos + j]);
+      const float32x4_t xfBuf_im = vld1q_f32(&xfBuf[1][xPos + j]);
       const float32x4_t ef_re = vld1q_f32(&ef[0][j]);
       const float32x4_t ef_im = vld1q_f32(&ef[1][j]);
       // Calculate the product of conjugate(xfBuf) by ef.
       //   re(conjugate(a) * b) = aRe * bRe + aIm * bIm
       //   im(conjugate(a) * b)=  aRe * bIm - aIm * bRe
       const float32x4_t a = vmulq_f32(xfBuf_re, ef_re);
       const float32x4_t e = vmlaq_f32(a, xfBuf_im, ef_im);
       const float32x4_t c = vmulq_f32(xfBuf_re, ef_im);
       const float32x4_t f = vmlsq_f32(c, xfBuf_im, ef_re);
       // Interleave real and imaginary parts.
       const float32x4x2_t g_n_h = vzipq_f32(e, f);
       // Store
       vst1q_f32(&fft[2 * j + 0], g_n_h.val[0]);
       vst1q_f32(&fft[2 * j + 4], g_n_h.val[1]);
     }
     // ... and fixup the first imaginary entry.
-    fft[1] = MulRe(aec->xfBuf[0][xPos + PART_LEN],
-                   -aec->xfBuf[1][xPos + PART_LEN],
+    fft[1] = MulRe(xfBuf[0][xPos + PART_LEN],
+                   -xfBuf[1][xPos + PART_LEN],
                    ef[0][PART_LEN],
                    ef[1][PART_LEN]);
 
     aec_rdft_inverse_128(fft);
     memset(fft + PART_LEN, 0, sizeof(float) * PART_LEN);
 
     // fft scaling
     {
       const float scale = 2.0f / PART_LEN2;
       const float32x4_t scale_ps = vmovq_n_f32(scale);
       for (j = 0; j < PART_LEN; j += 4) {
         const float32x4_t fft_ps = vld1q_f32(&fft[j]);
         const float32x4_t fft_scale = vmulq_f32(fft_ps, scale_ps);
         vst1q_f32(&fft[j], fft_scale);
       }
     }
     aec_rdft_forward_128(fft);
 
     {
-      const float wt1 = aec->wfBuf[1][pos];
-      aec->wfBuf[0][pos + PART_LEN] += fft[1];
+      const float wt1 = wfBuf[1][pos];
+      wfBuf[0][pos + PART_LEN] += fft[1];
       for (j = 0; j < PART_LEN; j += 4) {
-        float32x4_t wtBuf_re = vld1q_f32(&aec->wfBuf[0][pos + j]);
-        float32x4_t wtBuf_im = vld1q_f32(&aec->wfBuf[1][pos + j]);
+        float32x4_t wtBuf_re = vld1q_f32(&wfBuf[0][pos + j]);
+        float32x4_t wtBuf_im = vld1q_f32(&wfBuf[1][pos + j]);
         const float32x4_t fft0 = vld1q_f32(&fft[2 * j + 0]);
         const float32x4_t fft4 = vld1q_f32(&fft[2 * j + 4]);
         const float32x4x2_t fft_re_im = vuzpq_f32(fft0, fft4);
         wtBuf_re = vaddq_f32(wtBuf_re, fft_re_im.val[0]);
         wtBuf_im = vaddq_f32(wtBuf_im, fft_re_im.val[1]);
 
-        vst1q_f32(&aec->wfBuf[0][pos + j], wtBuf_re);
-        vst1q_f32(&aec->wfBuf[1][pos + j], wtBuf_im);
+        vst1q_f32(&wfBuf[0][pos + j], wtBuf_re);
+        vst1q_f32(&wfBuf[1][pos + j], wtBuf_im);
       }
-      aec->wfBuf[1][pos] = wt1;
+      wfBuf[1][pos] = wt1;
     }
   }
 }
 
 static float32x4_t vpowq_f32(float32x4_t a, float32x4_t b) {
   // a^b = exp2(b * log2(a))
   //   exp2(x) and log2(x) are calculated using polynomial approximations.
   float32x4_t log2_a, b_log2_a, a_exp_b;
 
   // Calculate log2(x), x = a.
@@ skipping 464 matching lines @@
   }
 }
 
 void WebRtcAec_InitAec_neon(void) {
   WebRtcAec_FilterFar = FilterFarNEON;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignalNEON;
   WebRtcAec_FilterAdaptation = FilterAdaptationNEON;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppressNEON;
   WebRtcAec_SubbandCoherence = SubbandCoherenceNEON;
 }