Move the aec_rdft* files to a more proper place beneath APM and make them thread-safe.

webrtc/modules/audio_processing/utility/ooura_fft_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.
  */
 
 /*
  * The rdft AEC algorithm, neon version of speed-critical functions.
  *
  * Based on the sse2 version.
  */
 
-
-#include "webrtc/modules/audio_processing/aec/aec_rdft.h"
+#include "webrtc/modules/audio_processing/utility/ooura_fft.h"
 
 #include <arm_neon.h>
 
-static const ALIGN16_BEG float ALIGN16_END
-    k_swap_sign[4] = {-1.f, 1.f, -1.f, 1.f};
+#include "webrtc/modules/audio_processing/utility/ooura_fft_tables_common.h"
+#include "webrtc/modules/audio_processing/utility/ooura_fft_tables_neon_sse2.h"
 
-static void cft1st_128_neon(float* a) {
+namespace webrtc {
+
+#if defined(WEBRTC_HAS_NEON)
+void cft1st_128_neon(float* a) {
   const float32x4_t vec_swap_sign = vld1q_f32((float32_t*)k_swap_sign);
   int j, k2;
 
   for (k2 = 0, j = 0; j < 128; j += 16, k2 += 4) {
     float32x4_t a00v = vld1q_f32(&a[j + 0]);
     float32x4_t a04v = vld1q_f32(&a[j + 4]);
     float32x4_t a08v = vld1q_f32(&a[j + 8]);
     float32x4_t a12v = vld1q_f32(&a[j + 12]);
     float32x4_t a01v = vcombine_f32(vget_low_f32(a00v), vget_low_f32(a08v));
     float32x4_t a23v = vcombine_f32(vget_high_f32(a00v), vget_high_f32(a08v));
@@ skipping 28 matching lines @@
     a04v = vcombine_f32(vget_low_f32(a45v), vget_low_f32(a67v));
     a08v = vcombine_f32(vget_high_f32(a01v), vget_high_f32(a23v));
     a12v = vcombine_f32(vget_high_f32(a45v), vget_high_f32(a67v));
     vst1q_f32(&a[j + 0], a00v);
     vst1q_f32(&a[j + 4], a04v);
     vst1q_f32(&a[j + 8], a08v);
     vst1q_f32(&a[j + 12], a12v);
   }
 }
 
-static void cftmdl_128_neon(float* a) {
+void cftmdl_128_neon(float* a) {
   int j;
   const int l = 8;
   const float32x4_t vec_swap_sign = vld1q_f32((float32_t*)k_swap_sign);
   float32x4_t wk1rv = vld1q_f32(cftmdl_wk1r);
 
   for (j = 0; j < l; j += 2) {
     const float32x2_t a_00 = vld1_f32(&a[j + 0]);
     const float32x2_t a_08 = vld1_f32(&a[j + 8]);
     const float32x2_t a_32 = vld1_f32(&a[j + 32]);
     const float32x2_t a_40 = vld1_f32(&a[j + 40]);
@@ skipping 93 matching lines @@
   }
 }
 
 __inline static float32x4_t reverse_order_f32x4(float32x4_t in) {
   // A B C D -> C D A B
   const float32x4_t rev = vcombine_f32(vget_high_f32(in), vget_low_f32(in));
   // C D A B -> D C B A
   return vrev64q_f32(rev);
 }
 
-static void rftfsub_128_neon(float* a) {
+void rftfsub_128_neon(float* a) {
   const float* c = rdft_w + 32;
   int j1, j2;
   const float32x4_t mm_half = vdupq_n_f32(0.5f);
 
   // Vectorized code (four at once).
   // Note: commented number are indexes for the first iteration of the loop.
   for (j1 = 1, j2 = 2; j2 + 7 < 64; j1 += 4, j2 += 8) {
     // Load 'wk'.
     const float32x4_t c_j1 = vld1q_f32(&c[j1]);          //  1,  2,  3,  4,
     const float32x4_t c_k1 = vld1q_f32(&c[29 - j1]);     // 28, 29, 30, 31,
@@ skipping 58 matching lines @@
     const float xi = a[j2 + 1] + a[k2 + 1];
     const float yr = wkr * xr - wki * xi;
     const float yi = wkr * xi + wki * xr;
     a[j2 + 0] -= yr;
     a[j2 + 1] -= yi;
     a[k2 + 0] += yr;
     a[k2 + 1] -= yi;
   }
 }
 
-static void rftbsub_128_neon(float* a) {
+void rftbsub_128_neon(float* a) {
   const float* c = rdft_w + 32;
   int j1, j2;
   const float32x4_t mm_half = vdupq_n_f32(0.5f);
 
   a[1] = -a[1];
   // Vectorized code (four at once).
   //    Note: commented number are indexes for the first iteration of the loop.
   for (j1 = 1, j2 = 2; j2 + 7 < 64; j1 += 4, j2 += 8) {
     // Load 'wk'.
-    const float32x4_t c_j1 = vld1q_f32(&c[j1]);         //  1,  2,  3,  4,
-    const float32x4_t c_k1 = vld1q_f32(&c[29 - j1]);    // 28, 29, 30, 31,
-    const float32x4_t wkrt = vsubq_f32(mm_half, c_k1);  // 28, 29, 30, 31,
-    const float32x4_t wkr_ = reverse_order_f32x4(wkrt); // 31, 30, 29, 28,
-    const float32x4_t wki_ = c_j1;                      //  1,  2,  3,  4,
+    const float32x4_t c_j1 = vld1q_f32(&c[j1]);          //  1,  2,  3,  4,
+    const float32x4_t c_k1 = vld1q_f32(&c[29 - j1]);     // 28, 29, 30, 31,
+    const float32x4_t wkrt = vsubq_f32(mm_half, c_k1);   // 28, 29, 30, 31,
+    const float32x4_t wkr_ = reverse_order_f32x4(wkrt);  // 31, 30, 29, 28,
+    const float32x4_t wki_ = c_j1;                       //  1,  2,  3,  4,
     // Load and shuffle 'a'.
     //   2,   4,   6,   8,   3,   5,   7,   9
     float32x4x2_t a_j2_p = vld2q_f32(&a[0 + j2]);
     // 120, 122, 124, 126, 121, 123, 125, 127,
     const float32x4x2_t k2_0_4 = vld2q_f32(&a[122 - j2]);
     // 126, 124, 122, 120
     const float32x4_t a_k2_p0 = reverse_order_f32x4(k2_0_4.val[0]);
     // 127, 125, 123, 121
     const float32x4_t a_k2_p1 = reverse_order_f32x4(k2_0_4.val[1]);
     // Calculate 'x'.
@@ skipping 46 matching lines @@
     const float xi = a[j2 + 1] + a[k2 + 1];
     const float yr = wkr * xr + wki * xi;
     const float yi = wkr * xi - wki * xr;
     a[j2 + 0] = a[j2 + 0] - yr;
     a[j2 + 1] = yi - a[j2 + 1];
     a[k2 + 0] = yr + a[k2 + 0];
     a[k2 + 1] = yi - a[k2 + 1];
   }
   a[65] = -a[65];
 }
+#endif
 
-void aec_rdft_init_neon(void) {
-  cft1st_128 = cft1st_128_neon;
-  cftmdl_128 = cftmdl_128_neon;
-  rftfsub_128 = rftfsub_128_neon;
-  rftbsub_128 = rftbsub_128_neon;
-}
-
+}  // namespace webrtc