Ducking fix #2: Removed the aec state as an input parameter to the FilterFar function.

webrtc/modules/audio_processing/aec/aec_core.c

 /*
  *  Copyright (c) 2012 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 133 matching lines @@
   return aRe * bIm + aIm * bRe;
 }
 
 static int CmpFloat(const void* a, const void* b) {
   const float* da = (const float*)a;
   const float* db = (const float*)b;
 
   return (*da > *db) - (*da < *db);
 }
 
-static void FilterFar(AecCore* aec, float yf[2][PART_LEN1]) {
+static void FilterFar(int num_partitions,
+                      int x_fft_buffer_block_pos,
+                      float x_fft_buffer[2][kExtendedNumPartitions * PART_LEN1],
+                      float h_fft_buffer[2][kExtendedNumPartitions * PART_LEN1],
+                      float y_fft[2][PART_LEN1]) {
   int i;
-  for (i = 0; i < aec->num_partitions; i++) {
+  for (i = 0; i < num_partitions; i++) {
     int j;
-    int xPos = (i + aec->xfBufBlockPos) * PART_LEN1;
+    int x_pos = (i + x_fft_buffer_block_pos) * PART_LEN1;
     int pos = i * PART_LEN1;
-    // Check for wrap
-    if (i + aec->xfBufBlockPos >= aec->num_partitions) {
-      xPos -= aec->num_partitions * (PART_LEN1);
+    // Check for wrapped buffer.
+    if (i + x_fft_buffer_block_pos >= num_partitions) {
+      x_pos -= num_partitions * (PART_LEN1);
     }
 
     for (j = 0; j < PART_LEN1; j++) {
-      yf[0][j] += MulRe(aec->xfBuf[0][xPos + j],
-                        aec->xfBuf[1][xPos + j],
-                        aec->wfBuf[0][pos + j],
-                        aec->wfBuf[1][pos + j]);
-      yf[1][j] += MulIm(aec->xfBuf[0][xPos + j],
-                        aec->xfBuf[1][xPos + j],
-                        aec->wfBuf[0][pos + j],
-                        aec->wfBuf[1][pos + j]);
+      y_fft[0][j] += MulRe(x_fft_buffer[0][x_pos + j],
+                        x_fft_buffer[1][x_pos + j],
+                        h_fft_buffer[0][pos + j],
+                        h_fft_buffer[1][pos + j]);
+      y_fft[1][j] += MulIm(x_fft_buffer[0][x_pos + j],
+                        x_fft_buffer[1][x_pos + j],
+                        h_fft_buffer[0][pos + j],
+                        h_fft_buffer[1][pos + j]);
     }
   }
 }
 
 static void ScaleErrorSignal(int extended_filter_enabled,
                              float normal_mu,
                              float normal_error_threshold,
                              float *x_pow,
                              float ef[2][PART_LEN1]) {
   const float mu = extended_filter_enabled ? kExtendedMu : normal_mu;
@@ skipping 780 matching lines @@
   float yf[2][PART_LEN1];
   float fft[PART_LEN2];
   float y[PART_LEN];
   float e[PART_LEN];
   float ef[2][PART_LEN1];
   float scale;
   int i;
   memset(yf, 0, sizeof(yf));
 
   // Produce frequency domain echo estimate.
-  WebRtcAec_FilterFar(aec, yf);
+  WebRtcAec_FilterFar(aec->num_partitions,
+                      aec->xfBufBlockPos,
+                      aec->xfBuf,
+                      aec->wfBuf,
+                      yf);
 
   // Inverse fft to obtain echo estimate and error.
   FrequencyToTime(yf, fft);
 
   // Extract the output signal and compute the time-domain error.
   scale = 2.0f / PART_LEN2;
   for (i = 0; i < PART_LEN; ++i) {
     y[i] = fft[PART_LEN + i] * scale;  // fft scaling.
     e[i] = nearend_ptr[i] - y[i];
   }
@@ skipping 954 matching lines @@
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }