Removed the state as an input to OverdriveAndSuppress 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 356 matching lines @@
     exp2_y = vmlaq_f32(C1, y, exp2_y);
     exp2_y = vmlaq_f32(C0, y, exp2_y);
 
     // Combine parts.
     a_exp_b = vmulq_f32(exp2_y, two_n);
   }
 
   return a_exp_b;
 }
 
-static void OverdriveAndSuppressNEON(AecCore* aec,
+static void OverdriveAndSuppressNEON(float overdrive_scaling,
                                      float hNl[PART_LEN1],
                                      const float hNlFb,
                                      float efw[2][PART_LEN1]) {
   int i;
   const float32x4_t vec_hNlFb = vmovq_n_f32(hNlFb);
   const float32x4_t vec_one = vdupq_n_f32(1.0f);
   const float32x4_t vec_minus_one = vdupq_n_f32(-1.0f);
-  const float32x4_t vec_overDriveSm = vmovq_n_f32(aec->overDriveSm);
+  const float32x4_t vec_overdrive_scaling = vmovq_n_f32(overdrive_scaling);
 
   // vectorized code (four at once)
   for (i = 0; i + 3 < PART_LEN1; i += 4) {
     // Weight subbands
     float32x4_t vec_hNl = vld1q_f32(&hNl[i]);
     const float32x4_t vec_weightCurve = vld1q_f32(&WebRtcAec_weightCurve[i]);
     const uint32x4_t bigger = vcgtq_f32(vec_hNl, vec_hNlFb);
     const float32x4_t vec_weightCurve_hNlFb =
         vmulq_f32(vec_weightCurve, vec_hNlFb);
     const float32x4_t vec_one_weightCurve = vsubq_f32(vec_one, vec_weightCurve);
     const float32x4_t vec_one_weightCurve_hNl =
         vmulq_f32(vec_one_weightCurve, vec_hNl);
     const uint32x4_t vec_if0 =
         vandq_u32(vmvnq_u32(bigger), vreinterpretq_u32_f32(vec_hNl));
     const float32x4_t vec_one_weightCurve_add =
         vaddq_f32(vec_weightCurve_hNlFb, vec_one_weightCurve_hNl);
     const uint32x4_t vec_if1 =
         vandq_u32(bigger, vreinterpretq_u32_f32(vec_one_weightCurve_add));
 
     vec_hNl = vreinterpretq_f32_u32(vorrq_u32(vec_if0, vec_if1));
 
     {
       const float32x4_t vec_overDriveCurve =
           vld1q_f32(&WebRtcAec_overDriveCurve[i]);
       const float32x4_t vec_overDriveSm_overDriveCurve =
-          vmulq_f32(vec_overDriveSm, vec_overDriveCurve);
+          vmulq_f32(vec_overdrive_scaling, vec_overDriveCurve);
       vec_hNl = vpowq_f32(vec_hNl, vec_overDriveSm_overDriveCurve);
       vst1q_f32(&hNl[i], vec_hNl);
     }
 
     // Suppress error signal
     {
       float32x4_t vec_efw_re = vld1q_f32(&efw[0][i]);
       float32x4_t vec_efw_im = vld1q_f32(&efw[1][i]);
       vec_efw_re = vmulq_f32(vec_efw_re, vec_hNl);
       vec_efw_im = vmulq_f32(vec_efw_im, vec_hNl);
 
       // Ooura fft returns incorrect sign on imaginary component. It matters
       // here because we are making an additive change with comfort noise.
       vec_efw_im = vmulq_f32(vec_efw_im, vec_minus_one);
       vst1q_f32(&efw[0][i], vec_efw_re);
       vst1q_f32(&efw[1][i], vec_efw_im);
     }
   }
 
   // scalar code for the remaining items.
   for (; 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], aec->overDriveSm * WebRtcAec_overDriveCurve[i]);
+    hNl[i] = powf(hNl[i], overdrive_scaling * WebRtcAec_overDriveCurve[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 267 matching lines @@
   WebRtcAec_FilterFar = FilterFarNEON;
   WebRtcAec_ScaleErrorSignal = ScaleErrorSignalNEON;
   WebRtcAec_FilterAdaptation = FilterAdaptationNEON;
   WebRtcAec_OverdriveAndSuppress = OverdriveAndSuppressNEON;
   WebRtcAec_SubbandCoherence = SubbandCoherenceNEON;
   WebRtcAec_StoreAsComplex = StoreAsComplexNEON;
   WebRtcAec_PartitionDelay = PartitionDelayNEON;
   WebRtcAec_WindowData = WindowDataNEON;
 }
 }  // namespace webrtc