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

webrtc/modules/audio_processing/aec/aec_core_mips.c

 /*
  *  Copyright (c) 2013 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 304 matching lines @@
     for (i = 0; i < PART_LEN1; i++) {
       // Use average NLP weight for H band
       comfortNoiseHband[i][0] = tmpAvg * u[i][0];
       comfortNoiseHband[i][1] = tmpAvg * u[i][1];
     }
   }
 }
 
 void WebRtcAec_FilterFar_mips(
     int num_partitions,
-    int xfBufBlockPos,
-    float xfBuf[2][kExtendedNumPartitions * PART_LEN1],
-    float wfBuf[2][kExtendedNumPartitions * PART_LEN1],
-    float yf[2][PART_LEN1]) {
+    int x_fft_buf_block_pos,
+    float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
+    float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
+    float y_fft[2][PART_LEN1]) {
   int i;
   for (i = 0; i < num_partitions; i++) {
-    int xPos = (i + xfBufBlockPos) * PART_LEN1;
+    int xPos = (i + x_fft_buf_block_pos) * PART_LEN1;
     int pos = i * PART_LEN1;
     // Check for wrap
-    if (i + xfBufBlockPos >=  num_partitions) {
+    if (i + x_fft_buf_block_pos >=  num_partitions) {
       xPos -=  num_partitions * (PART_LEN1);
     }
-    float* yf0 = yf[0];
-    float* yf1 = yf[1];
-    float* aRe = xfBuf[0] + xPos;
-    float* aIm = xfBuf[1] + xPos;
-    float* bRe = wfBuf[0] + pos;
-    float* bIm = wfBuf[1] + pos;
+    float* yf0 = y_fft[0];
+    float* yf1 = y_fft[1];
+    float* aRe = x_fft_buf[0] + xPos;
+    float* aIm = x_fft_buf[1] + xPos;
+    float* bRe = h_fft_buf[0] + pos;
+    float* bIm = h_fft_buf[1] + pos;
     float f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13;
     int len = PART_LEN1 >> 1;
 
     __asm __volatile (
       ".set       push                                                \n\t"
       ".set       noreorder                                           \n\t"
      "1:                                                              \n\t"
       "lwc1       %[f0],      0(%[aRe])                               \n\t"
       "lwc1       %[f1],      0(%[bRe])                               \n\t"
       "lwc1       %[f2],      0(%[bIm])                               \n\t"
@@ skipping 77 matching lines @@
         [f9] "=&f" (f9), [f10] "=&f" (f10), [f11] "=&f" (f11),
         [f12] "=&f" (f12), [f13] "=&f" (f13), [aRe] "+r" (aRe),
         [aIm] "+r" (aIm), [bRe] "+r" (bRe), [bIm] "+r" (bIm),
         [yf0] "+r" (yf0), [yf1] "+r" (yf1), [len] "+r" (len)
       :
       : "memory"
     );
   }
 }
 
-void WebRtcAec_FilterAdaptation_mips(AecCore* aec,
-                                     float* fft,
-                                     float ef[2][PART_LEN1]) {
+void WebRtcAec_FilterAdaptation_mips(
+    int num_partitions,
+    int x_fft_buf_block_pos,
+    float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
+    float e_fft[2][PART_LEN1],
+    float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1]) {
+  float fft[PART_LEN2];
   int i;
-  for (i = 0; i < aec->num_partitions; i++) {
-    int xPos = (i + aec->xfBufBlockPos)*(PART_LEN1);
+  for (i = 0; i < num_partitions; i++) {
+    int xPos = (i + x_fft_buf_block_pos)*(PART_LEN1);
     int pos;
     // Check for wrap
-    if (i + aec->xfBufBlockPos >= aec->num_partitions) {
-      xPos -= aec->num_partitions * PART_LEN1;
+    if (i + x_fft_buf_block_pos >= num_partitions) {
+      xPos -= num_partitions * PART_LEN1;
     }
 
     pos = i * PART_LEN1;
-    float* aRe = aec->xfBuf[0] + xPos;
-    float* aIm = aec->xfBuf[1] + xPos;
-    float* bRe = ef[0];
-    float* bIm = ef[1];
+    float* aRe = x_fft_buf[0] + xPos;
+    float* aIm = x_fft_buf[1] + xPos;
+    float* bRe = e_fft[0];
+    float* bIm = e_fft[1];
     float* fft_tmp;
 
     float f0, f1, f2, f3, f4, f5, f6 ,f7, f8, f9, f10, f11, f12;
     int len = PART_LEN >> 1;
 
     __asm __volatile (
       ".set       push                                                \n\t"
       ".set       noreorder                                           \n\t"
       "addiu      %[fft_tmp], %[fft],         0                       \n\t"
      "1:                                                              \n\t"
@@ skipping 104 matching lines @@
         ".set     pop                                     \n\t"
         : [f0] "=&f" (f0), [f1] "=&f" (f1), [f2] "=&f" (f2),
           [f3] "=&f" (f3), [f4] "=&f" (f4), [f5] "=&f" (f5),
           [f6] "=&f" (f6), [f7] "=&f" (f7), [len] "=&r" (len),
           [fft_tmp] "=&r" (fft_tmp)
         : [scale] "f" (scale), [fft] "r" (fft)
         : "memory"
       );
     }
     aec_rdft_forward_128(fft);
-    aRe = aec->wfBuf[0] + pos;
-    aIm = aec->wfBuf[1] + pos;
+    aRe = h_fft_buf[0] + pos;
+    aIm = h_fft_buf[1] + pos;
     __asm __volatile (
       ".set     push                                    \n\t"
       ".set     noreorder                               \n\t"
       "addiu    %[fft_tmp], %[fft],        0            \n\t"
       "addiu    %[len],     $zero,         31           \n\t"
       "lwc1     %[f0],      0(%[aRe])                   \n\t"
       "lwc1     %[f1],      0(%[fft_tmp])               \n\t"
       "lwc1     %[f2],      256(%[aRe])                 \n\t"
       "lwc1     %[f3],      4(%[fft_tmp])               \n\t"
       "lwc1     %[f4],      4(%[aRe])                   \n\t"
@@ skipping 107 matching lines @@
         [p_hNl] "+r" (p_hNl)
       :
       : "memory"
     );
   }
 }
 
 void WebRtcAec_ScaleErrorSignal_mips(int extended_filter_enabled,
                                      float normal_mu,
                                      float normal_error_threshold,
-                                     float *x_pow,
+                                     float x_pow[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;
   int len = (PART_LEN1);
   float* ef0 = ef[0];
   float* ef1 = ef[1];
   float fac1 = 1e-10f;
   float err_th2 = error_threshold * error_threshold;
@@ skipping 51 matching lines @@
   );
 }
 
 void WebRtcAec_InitAec_mips(void) {
   WebRtcAec_FilterFar = WebRtcAec_FilterFar_mips;
   WebRtcAec_FilterAdaptation = WebRtcAec_FilterAdaptation_mips;
   WebRtcAec_ScaleErrorSignal = WebRtcAec_ScaleErrorSignal_mips;
   WebRtcAec_ComfortNoise = WebRtcAec_ComfortNoise_mips;
   WebRtcAec_OverdriveAndSuppress = WebRtcAec_OverdriveAndSuppress_mips;
 }