Separated the functionalities in the OverdriveAndSuppress method in the AEC into two methods

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 113 matching lines @@
                                                               {0.92f, 0.08f}};
 const float WebRtcAec_kNormalSmoothingCoefficients[2][2] = {{0.9f, 0.1f},
                                                             {0.93f, 0.07f}};
 
 // Number of partitions forming the NLP's "preferred" bands.
 enum { kPrefBandSize = 24 };
 
 WebRtcAecFilterFar WebRtcAec_FilterFar;
 WebRtcAecScaleErrorSignal WebRtcAec_ScaleErrorSignal;
 WebRtcAecFilterAdaptation WebRtcAec_FilterAdaptation;
-WebRtcAecOverdriveAndSuppress WebRtcAec_OverdriveAndSuppress;
+WebRtcAecOverdrive WebRtcAec_Overdrive;
+WebRtcAecSuppress WebRtcAec_Suppress;
 WebRtcAecComputeCoherence WebRtcAec_ComputeCoherence;
 WebRtcAecUpdateCoherenceSpectra WebRtcAec_UpdateCoherenceSpectra;
 WebRtcAecStoreAsComplex WebRtcAec_StoreAsComplex;
 WebRtcAecPartitionDelay WebRtcAec_PartitionDelay;
 WebRtcAecWindowData WebRtcAec_WindowData;
 
 __inline static float MulRe(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bRe - aIm * bIm;
 }
 
@@ skipping 155 matching lines @@
     h_fft_buf[0][pos] += fft[0];
     h_fft_buf[0][pos + PART_LEN] += fft[1];
 
     for (j = 1; j < PART_LEN; j++) {
       h_fft_buf[0][pos + j] += fft[2 * j];
       h_fft_buf[1][pos + j] += fft[2 * j + 1];
     }
   }
 }
 
-static void OverdriveAndSuppress(float overdrive_scaling,
-                                 float hNl[PART_LEN1],
-                                 const float hNlFb,
-                                 float efw[2][PART_LEN1]) {
-  int i;
-  for (i = 0; i < PART_LEN1; i++) {
+static void Overdrive(float overdrive_scaling,
+                      const float hNlFb,
+                      float hNl[PART_LEN1]) {
+  for (int i = 0; i < PART_LEN1; ++i) {
     // Weight subbands
     if (hNl[i] > hNlFb) {
       hNl[i] = WebRtcAec_weightCurve[i] * hNlFb +
                (1 - WebRtcAec_weightCurve[i]) * hNl[i];
     }
     hNl[i] = powf(hNl[i], overdrive_scaling * WebRtcAec_overDriveCurve[i]);
+  }
+}
 
+static void Suppress(const float hNl[PART_LEN1], float efw[2][PART_LEN1]) {
+  for (int i = 0; i < PART_LEN1; ++i) {
     // 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;
   }
 }
 
@@ skipping 817 matching lines @@
 
   // Smooth the overdrive.
   if (aec->overDrive < aec->overdrive_scaling) {
     aec->overdrive_scaling =
         0.99f * aec->overdrive_scaling + 0.01f * aec->overDrive;
   } else {
     aec->overdrive_scaling =
         0.9f * aec->overdrive_scaling + 0.1f * aec->overDrive;
   }
 
-  WebRtcAec_OverdriveAndSuppress(aec->overdrive_scaling, hNl, hNlFb, efw);
+  WebRtcAec_Overdrive(aec->overdrive_scaling, hNlFb, hNl);
+  WebRtcAec_Suppress(hNl, efw);
 
   // Add comfort noise.
   ComfortNoise(aec, efw, comfortNoiseHband, aec->noisePow, hNl);
 
   // Inverse error fft.
   ScaledInverseFft(efw, fft, 2.0f, 1);
 
   // Overlap and add to obtain output.
   for (i = 0; i < PART_LEN; i++) {
     output[i] = (fft[i] * WebRtcAec_sqrtHanning[i] +
@@ skipping 299 matching lines @@
   WebRtc_set_lookahead(aec->delay_estimator, kLookaheadBlocks);
 #endif
   aec->extended_filter_enabled = 0;
   aec->aec3_enabled = 0;
   aec->refined_adaptive_filter_enabled = false;
 
   // Assembly optimization
   WebRtcAec_FilterFar = FilterFar;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignal;
   WebRtcAec_FilterAdaptation = FilterAdaptation;
-  WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppress;
+  WebRtcAec_Overdrive = Overdrive;
+  WebRtcAec_Suppress = Suppress;
   WebRtcAec_ComputeCoherence = ComputeCoherence;
   WebRtcAec_UpdateCoherenceSpectra = UpdateCoherenceSpectra;
   WebRtcAec_StoreAsComplex = StoreAsComplex;
   WebRtcAec_PartitionDelay = PartitionDelay;
   WebRtcAec_WindowData = WindowData;
 
 #if defined(WEBRTC_ARCH_X86_FAMILY)
   if (WebRtc_GetCPUInfo(kSSE2)) {
     WebRtcAec_InitAec_SSE2();
   }
@@ skipping 460 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