Broke apart the functionalities in the SubbandCoherence method in the AEC

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 123 matching lines @@
 enum { kPrefBandSize = 24 };
 
 #ifdef WEBRTC_AEC_DEBUG_DUMP
 extern int webrtc_aec_instance_count;
 #endif
 
 WebRtcAecFilterFar WebRtcAec_FilterFar;
 WebRtcAecScaleErrorSignal WebRtcAec_ScaleErrorSignal;
 WebRtcAecFilterAdaptation WebRtcAec_FilterAdaptation;
 WebRtcAecOverdriveAndSuppress WebRtcAec_OverdriveAndSuppress;
-WebRtcAecSubBandCoherence WebRtcAec_SubbandCoherence;
+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;
 }
 
 __inline static float MulIm(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bIm + aIm * bRe;
@@ skipping 240 matching lines @@
     // This is to protect overflow, which should almost never happen.
     RTC_CHECK_NE(0u, metric->hicounter);
     metric->hisum += metric->instant;
     metric->himean = metric->hisum / metric->hicounter;
   }
 }
 
 // Threshold to protect against the ill-effects of a zero far-end.
 const float WebRtcAec_kMinFarendPSD = 15;
 
 // Updates the following smoothed  Power Spectral Densities (PSD):

[minyue-webrtc, 2016/05/03 07:29:06]

nit: one extra space

[peah-webrtc, 2016/05/07 21:26:35]

Good find!
Done.

 //  - sd  : near-end
 //  - se  : residual echo
 //  - sx  : far-end
 //  - sde : cross-PSD of near-end and residual echo
 //  - sxd : cross-PSD of near-end and far-end
 //
 // In addition to updating the PSDs, also the filter diverge state is
 // determined.
-static void SmoothedPSD(int mult,
-                        bool extended_filter_enabled,
-                        float efw[2][PART_LEN1],
-                        float dfw[2][PART_LEN1],
-                        float xfw[2][PART_LEN1],
-                        CoherenceState* coherence_state,
-                        short* filter_divergence_state,
-                        int* extreme_filter_divergence) {
+static void UpdateCoherenceSpectra(int mult,
+                                   bool extended_filter_enabled,
+                                   float efw[2][PART_LEN1],
+                                   float dfw[2][PART_LEN1],
+                                   float xfw[2][PART_LEN1],
+                                   CoherenceState* coherence_state,
+                                   short* filter_divergence_state,
+                                   int* extreme_filter_divergence) {
   // Power estimate smoothing coefficients.
   const float* ptrGCoh =
       extended_filter_enabled
           ? WebRtcAec_kExtendedSmoothingCoefficients[mult - 1]
           : WebRtcAec_kNormalSmoothingCoefficients[mult - 1];
   int i;
   float sdSum = 0, seSum = 0;
 
   for (i = 0; i < PART_LEN1; i++) {
     coherence_state->sd[i] =
@@ skipping 56 matching lines @@
   data_complex[0][0] = data[0];
   data_complex[1][0] = 0;
   for (i = 1; i < PART_LEN; i++) {
     data_complex[0][i] = data[2 * i];
     data_complex[1][i] = data[2 * i + 1];
   }
   data_complex[0][PART_LEN] = data[1];
   data_complex[1][PART_LEN] = 0;
 }
 
-static void SubbandCoherence(int mult,
-                             bool extended_filter_enabled,
-                             float efw[2][PART_LEN1],
-                             float dfw[2][PART_LEN1],
-                             float xfw[2][PART_LEN1],
-                             float* fft,
+static void ComputeCoherence(const CoherenceState* coherence_state,
                              float* cohde,
-                             float* cohxd,
-                             CoherenceState* coherence_state,
-                             short* filter_divergence_state,
-                             int* extreme_filter_divergence) {
-  int i;
-
-  SmoothedPSD(mult, extended_filter_enabled, efw, dfw, xfw, coherence_state,
-              filter_divergence_state, extreme_filter_divergence);
-
+                             float* cohxd) {
   // Subband coherence
-  for (i = 0; i < PART_LEN1; i++) {
+  for (int i = 0; i < PART_LEN1; i++) {
     cohde[i] = (coherence_state->sde[i][0] * coherence_state->sde[i][0] +
                 coherence_state->sde[i][1] * coherence_state->sde[i][1]) /
                (coherence_state->sd[i] * coherence_state->se[i] + 1e-10f);
     cohxd[i] = (coherence_state->sxd[i][0] * coherence_state->sxd[i][0] +
                 coherence_state->sxd[i][1] * coherence_state->sxd[i][1]) /
                (coherence_state->sx[i] * coherence_state->sd[i] + 1e-10f);
   }
 }
 
 static void GetHighbandGain(const float* lambda, float* nlpGainHband) {
@@ skipping 535 matching lines @@
   aec->delayEstCtr++;
   if (aec->delayEstCtr == delayEstInterval) {
     aec->delayEstCtr = 0;
     aec->delayIdx = WebRtcAec_PartitionDelay(aec->num_partitions, aec->wfBuf);
   }
 
   // Use delayed far.
   memcpy(xfw, aec->xfwBuf + aec->delayIdx * PART_LEN1,
          sizeof(xfw[0][0]) * 2 * PART_LEN1);
 
-  WebRtcAec_SubbandCoherence(aec->mult, aec->extended_filter_enabled == 1, efw,
-                             dfw, xfw, fft, cohde, cohxd, &aec->coherence_state,
-                             &aec->divergeState,
-                             &aec->extreme_filter_divergence);
+  WebRtcAec_UpdateCoherenceSpectra(aec->mult, aec->extended_filter_enabled == 1,
+                                   efw, dfw, xfw, &aec->coherence_state,
+                                   &aec->divergeState,
+                                   &aec->extreme_filter_divergence);
+
+  WebRtcAec_ComputeCoherence(&aec->coherence_state, cohde, cohxd);
 
   // Select the microphone signal as output if the filter is deemed to have
   // diverged.
   if (aec->divergeState) {
     memcpy(efw, dfw, sizeof(efw[0][0]) * 2 * PART_LEN1);
   }
 
   hNlXdAvg = 0;
   for (i = minPrefBand; i < prefBandSize + minPrefBand; i++) {
     hNlXdAvg += cohxd[i];
@@ skipping 410 matching lines @@
 #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_SubbandCoherence = SubbandCoherence;
+  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();
   }
 #endif
 
@@ skipping 484 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