Cleaned up the EchoSuppression method in the AEC so that it does not have to use the aec state as a…

webrtc/modules/audio_processing/aec/aec_core.cc

 /*
  *  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 941 matching lines @@
 
     ++partition;
     if (partition == num_partitions) {
       partition = 0;
       RTC_DCHECK_EQ(num_partitions * PART_LEN1, x_fft_buf_position);
       x_fft_buf_position = 0;
     }
   }
 }
 
-static void EchoSubtraction(AecCore* aec,
-                            int num_partitions,
+static void EchoSubtraction(int num_partitions,
                             int extended_filter_enabled,
+                            int* extreme_filter_divergence,
                             float filter_step_size,
                             float error_threshold,
                             float* x_fft,
                             int* x_fft_buf_block_pos,
                             float x_fft_buf[2]
                                            [kExtendedNumPartitions * PART_LEN1],
                             float* const y,
                             float x_pow[PART_LEN1],
                             float h_fft_buf[2]
                                            [kExtendedNumPartitions * PART_LEN1],
@@ skipping 15 matching lines @@
   // Buffer x_fft.
   memcpy(x_fft_buf[0] + (*x_fft_buf_block_pos) * PART_LEN1, x_fft,
          sizeof(float) * PART_LEN1);
   memcpy(x_fft_buf[1] + (*x_fft_buf_block_pos) * PART_LEN1, &x_fft[PART_LEN1],
          sizeof(float) * PART_LEN1);
 
   memset(s_fft, 0, sizeof(s_fft));
 
   // Conditionally reset the echo subtraction filter if the filter has diverged
   // significantly.
-  if (!aec->extended_filter_enabled && aec->extreme_filter_divergence) {
-    memset(aec->wfBuf, 0, sizeof(aec->wfBuf));
-    aec->extreme_filter_divergence = 0;
+  if (!extended_filter_enabled && *extreme_filter_divergence) {
+    memset(h_fft_buf, 0,
+           2 * kExtendedNumPartitions * PART_LEN1 * sizeof(h_fft_buf[0][0]));
+    *extreme_filter_divergence = 0;
   }
 
   // Produce echo estimate s_fft.
   WebRtcAec_FilterFar(num_partitions, *x_fft_buf_block_pos, x_fft_buf,
                       h_fft_buf, s_fft);
 
   // Compute the time-domain echo estimate s.
   ScaledInverseFft(s_fft, s_extended, 2.0f, 0);
   s = &s_extended[PART_LEN];
 
   // Compute the time-domain echo prediction error.
   for (i = 0; i < PART_LEN; ++i) {
     e[i] = y[i] - s[i];
   }
 
   // Compute the frequency domain echo prediction error.
   memset(e_extended, 0, sizeof(float) * PART_LEN);
   memcpy(e_extended + PART_LEN, e, sizeof(float) * PART_LEN);
   Fft(e_extended, e_fft);
 
-  RTC_AEC_DEBUG_RAW_WRITE(aec->e_fft_file, &e_fft[0][0],
-                          sizeof(e_fft[0][0]) * PART_LEN1 * 2);
-
   // Scale error signal inversely with far power.
   WebRtcAec_ScaleErrorSignal(filter_step_size, error_threshold, x_pow, e_fft);
   WebRtcAec_FilterAdaptation(num_partitions, *x_fft_buf_block_pos, x_fft_buf,
                              e_fft, h_fft_buf);
   memcpy(echo_subtractor_output, e, sizeof(float) * PART_LEN);
 }
 
 static void EchoSuppression(AecCore* aec,
                             float farend[PART_LEN2],
                             float* echo_subtractor_output,
@@ skipping 370 matching lines @@
         aec->num_delay_values++;
       }
       if (aec->delay_metrics_delivered == 1 &&
           aec->num_delay_values >= kDelayMetricsAggregationWindow) {
         UpdateDelayMetrics(aec);
       }
     }
   }
 
   // Perform echo subtraction.
-  EchoSubtraction(aec, aec->num_partitions, aec->extended_filter_enabled,
-                  aec->filter_step_size, aec->error_threshold, &x_fft[0][0],
-                  &aec->xfBufBlockPos, aec->xfBuf, nearend_ptr, aec->xPow,
-                  aec->wfBuf, echo_subtractor_output);
+  EchoSubtraction(aec->num_partitions, aec->extended_filter_enabled,
+                  &aec->extreme_filter_divergence, aec->filter_step_size,
+                  aec->error_threshold, &x_fft[0][0], &aec->xfBufBlockPos,
+                  aec->xfBuf, nearend_ptr, aec->xPow, aec->wfBuf,
+                  echo_subtractor_output);
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outLinearFile, echo_subtractor_output, PART_LEN);
 
   if (aec->metricsMode == 1) {
     UpdateLevel(&aec->linoutlevel,
                 CalculatePower(echo_subtractor_output, PART_LEN));
   }
 
   // Perform echo suppression.
   EchoSuppression(aec, farend_ptr, echo_subtractor_output, output, outputH_ptr);
@@ skipping 596 matching lines @@
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc