Broke apart the functionalities in the SubbandCoherence method in the AEC

webrtc/modules/audio_processing/aec/aec_core_neon.cc

 /*
  *  Copyright (c) 2014 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 486 matching lines @@
 
 // Updates the following smoothed  Power Spectral Densities (PSD):
 //  - 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
 // upon actions are taken.
-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 UpdateCoherenceSpectraNEON(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;
   const float32x4_t vec_15 = vdupq_n_f32(WebRtcAec_kMinFarendPSD);
   float32x4_t vec_sdSum = vdupq_n_f32(0.0f);
   float32x4_t vec_seSum = vdupq_n_f32(0.0f);
@@ skipping 147 matching lines @@
     vst1q_f32(&data_complex[0][i], vec_data.val[0]);
     vst1q_f32(&data_complex[1][i], vec_data.val[1]);
   }
   // fix beginning/end values
   data_complex[1][0] = 0;
   data_complex[1][PART_LEN] = 0;
   data_complex[0][0] = data[0];
   data_complex[0][PART_LEN] = data[1];
 }
 
-static void SubbandCoherenceNEON(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 ComputeCoherenceNEON(const CoherenceState* coherence_state,
                                  float* cohde,
-                                 float* cohxd,
-                                 CoherenceState* coherence_state,
-                                 short* filter_divergence_state,
-                                 int* extreme_filter_divergence) {
+                                 float* cohxd) {
   int i;
 
-  SmoothedPSD(mult, extended_filter_enabled, efw, dfw, xfw, coherence_state,
-              filter_divergence_state, extreme_filter_divergence);
-
   {
     const float32x4_t vec_1eminus10 = vdupq_n_f32(1e-10f);
 
     // Subband coherence
     for (i = 0; i + 3 < PART_LEN1; i += 4) {
       const float32x4_t vec_sd = vld1q_f32(&coherence_state->sd[i]);
       const float32x4_t vec_se = vld1q_f32(&coherence_state->se[i]);
       const float32x4_t vec_sx = vld1q_f32(&coherence_state->sx[i]);
       const float32x4_t vec_sdse = vmlaq_f32(vec_1eminus10, vec_sd, vec_se);
       const float32x4_t vec_sdsx = vmlaq_f32(vec_1eminus10, vec_sd, vec_sx);
@@ skipping 19 matching lines @@
                 coherence_state->sxd[i][1] * coherence_state->sxd[i][1]) /
                (coherence_state->sx[i] * coherence_state->sd[i] + 1e-10f);
   }
 }
 
 void WebRtcAec_InitAec_neon(void) {
   WebRtcAec_FilterFar = FilterFarNEON;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignalNEON;
   WebRtcAec_FilterAdaptation = FilterAdaptationNEON;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppressNEON;
-  WebRtcAec_SubbandCoherence = SubbandCoherenceNEON;
+  WebRtcAec_ComputeCoherence = ComputeCoherenceNEON;
+  WebRtcAec_UpdateCoherenceSpectra = UpdateCoherenceSpectraNEON;
   WebRtcAec_StoreAsComplex = StoreAsComplexNEON;
   WebRtcAec_PartitionDelay = PartitionDelayNEON;
   WebRtcAec_WindowData = WindowDataNEON;
 }
 }  // namespace webrtc