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

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 10 matching lines @@
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 extern "C" {
 #include "webrtc/common_audio/ring_buffer.h"
 }
 #include "webrtc/base/checks.h"
 #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
 #include "webrtc/modules/audio_processing/aec/aec_common.h"
 #include "webrtc/modules/audio_processing/aec/aec_core_optimized_methods.h"
-#include "webrtc/modules/audio_processing/aec/aec_rdft.h"
 #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h"
 #include "webrtc/modules/audio_processing/utility/delay_estimator_wrapper.h"
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 namespace {
 enum class DelaySource {
   kSystemDelay,    // The delay values come from the OS.
@@ skipping 288 matching lines @@
       ef[1][i] *= abs_ef;
     }
 
     // Stepsize factor
     ef[0][i] *= mu;
     ef[1][i] *= mu;
   }
 }
 
 static void FilterAdaptation(
+    const OouraFft& ooura_fft,
     int num_partitions,
     int x_fft_buf_block_pos,
     float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
     float e_fft[2][PART_LEN1],
     float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1]) {
   int i, j;
   float fft[PART_LEN2];
   for (i = 0; i < num_partitions; i++) {
     int xPos = (i + x_fft_buf_block_pos) * (PART_LEN1);
     int pos;
     // Check for wrap
     if (i + x_fft_buf_block_pos >= num_partitions) {
       xPos -= num_partitions * PART_LEN1;
     }
 
     pos = i * PART_LEN1;
 
     for (j = 0; j < PART_LEN; j++) {
       fft[2 * j] = MulRe(x_fft_buf[0][xPos + j], -x_fft_buf[1][xPos + j],
                          e_fft[0][j], e_fft[1][j]);
       fft[2 * j + 1] = MulIm(x_fft_buf[0][xPos + j], -x_fft_buf[1][xPos + j],
                              e_fft[0][j], e_fft[1][j]);
     }
     fft[1] =
         MulRe(x_fft_buf[0][xPos + PART_LEN], -x_fft_buf[1][xPos + PART_LEN],
               e_fft[0][PART_LEN], e_fft[1][PART_LEN]);
 
-    aec_rdft_inverse_128(fft);
+    ooura_fft.InverseFft(fft);
     memset(fft + PART_LEN, 0, sizeof(float) * PART_LEN);
 
     // fft scaling
     {
       float scale = 2.0f / PART_LEN2;
       for (j = 0; j < PART_LEN; j++) {
         fft[j] *= scale;
       }
     }
-    aec_rdft_forward_128(fft);
+    ooura_fft.Fft(fft);
 
     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];
     }
   }
 }
@@ skipping 440 matching lines @@
         static_cast<float>(num_delays_out_of_bounds) / self->num_delay_values;
   }
 
   // Reset histogram.
   memset(self->delay_histogram, 0, sizeof(self->delay_histogram));
   self->num_delay_values = 0;
 
   return;
 }
 
-static void ScaledInverseFft(float freq_data[2][PART_LEN1],
+static void ScaledInverseFft(const OouraFft& ooura_fft,
+                             float freq_data[2][PART_LEN1],
                              float time_data[PART_LEN2],
                              float scale,
                              int conjugate) {
   int i;
   const float normalization = scale / static_cast<float>(PART_LEN2);
   const float sign = (conjugate ? -1 : 1);
   time_data[0] = freq_data[0][0] * normalization;
   time_data[1] = freq_data[0][PART_LEN] * normalization;
   for (i = 1; i < PART_LEN; i++) {
     time_data[2 * i] = freq_data[0][i] * normalization;
     time_data[2 * i + 1] = sign * freq_data[1][i] * normalization;
   }
-  aec_rdft_inverse_128(time_data);
+  ooura_fft.InverseFft(time_data);
 }
 
-static void Fft(float time_data[PART_LEN2], float freq_data[2][PART_LEN1]) {
+static void Fft(const OouraFft& ooura_fft,
+                float time_data[PART_LEN2],
+                float freq_data[2][PART_LEN1]) {
   int i;
-  aec_rdft_forward_128(time_data);
+  ooura_fft.Fft(time_data);
 
   // Reorder fft output data.
   freq_data[1][0] = 0;
   freq_data[1][PART_LEN] = 0;
   freq_data[0][0] = time_data[0];
   freq_data[0][PART_LEN] = time_data[1];
   for (i = 1; i < PART_LEN; i++) {
     freq_data[0][i] = time_data[2 * i];
     freq_data[1][i] = time_data[2 * i + 1];
   }
@@ skipping 96 matching lines @@
 
     ++partition;
     if (partition == num_partitions) {
       partition = 0;
       RTC_DCHECK_EQ(num_partitions * PART_LEN1, x_fft_buf_position);
       x_fft_buf_position = 0;
     }
   }
 }
 
-static void EchoSubtraction(int num_partitions,
+static void EchoSubtraction(const OouraFft& ooura_fft,
+                            int num_partitions,
                             int extended_filter_enabled,
                             int* extreme_filter_divergence,
                             float filter_step_size,
                             float error_threshold,
                             float* x_fft,
                             int* x_fft_buf_block_pos,
                             float x_fft_buf[2]
                                            [kExtendedNumPartitions * PART_LEN1],
                             float* const y,
                             float x_pow[PART_LEN1],
@@ skipping 28 matching lines @@
     memset(h_fft_buf, 0,
            2 * kExtendedNumPartitions * PART_LEN1 * sizeof(h_fft_buf[0][0]));
     *extreme_filter_divergence = 0;
   }
 
   // Produce echo estimate s_fft.
   WebRtcAec_FilterFar(num_partitions, *x_fft_buf_block_pos, x_fft_buf,
                       h_fft_buf, s_fft);
 
   // Compute the time-domain echo estimate s.
-  ScaledInverseFft(s_fft, s_extended, 2.0f, 0);
+  ScaledInverseFft(ooura_fft, s_fft, s_extended, 2.0f, 0);
   s = &s_extended[PART_LEN];
 
   // Compute the time-domain echo prediction error.
   for (i = 0; i < PART_LEN; ++i) {
     e[i] = y[i] - s[i];
   }
 
   // Compute the frequency domain echo prediction error.
   memset(e_extended, 0, sizeof(float) * PART_LEN);
   memcpy(e_extended + PART_LEN, e, sizeof(float) * PART_LEN);
-  Fft(e_extended, e_fft);
+  Fft(ooura_fft, e_extended, e_fft);
 
   // Scale error signal inversely with far power.
   WebRtcAec_ScaleErrorSignal(filter_step_size, error_threshold, x_pow, e_fft);
-  WebRtcAec_FilterAdaptation(num_partitions, *x_fft_buf_block_pos, x_fft_buf,
-                             e_fft, h_fft_buf);
+  WebRtcAec_FilterAdaptation(ooura_fft, num_partitions, *x_fft_buf_block_pos,
+                             x_fft_buf, e_fft, h_fft_buf);
   memcpy(echo_subtractor_output, e, sizeof(float) * PART_LEN);
 }
 
 static void FormSuppressionGain(AecCore* aec,
                                 float cohde[PART_LEN1],
                                 float cohxd[PART_LEN1],
                                 float hNl[PART_LEN1]) {
   float hNlDeAvg, hNlXdAvg;
   float hNlPref[kPrefBandSize];
   float hNlFb = 0, hNlFbLow = 0;
@@ skipping 96 matching lines @@
         0.99f * aec->overdrive_scaling + 0.01f * aec->overDrive;
   } else {
     aec->overdrive_scaling =
         0.9f * aec->overdrive_scaling + 0.1f * aec->overDrive;
   }
 
   // Apply the overdrive.
   WebRtcAec_Overdrive(aec->overdrive_scaling, hNlFb, hNl);
 }
 
-static void EchoSuppression(AecCore* aec,
+static void EchoSuppression(const OouraFft& ooura_fft,
+                            AecCore* aec,
                             float* nearend_extended_block_lowest_band,
                             float farend_extended_block[PART_LEN2],
                             float* echo_subtractor_output,
                             float output[NUM_HIGH_BANDS_MAX + 1][PART_LEN]) {
   float efw[2][PART_LEN1];
   float xfw[2][PART_LEN1];
   float dfw[2][PART_LEN1];
   float comfortNoiseHband[2][PART_LEN1];
   float fft[PART_LEN2];
   float nlpGainHband;
   int i;
   size_t j;
 
   // Coherence and non-linear filter
   float cohde[PART_LEN1], cohxd[PART_LEN1];
   float hNl[PART_LEN1];
 
   // Filter energy
   const int delayEstInterval = 10 * aec->mult;
 
   float* xfw_ptr = NULL;
 
   // Update eBuf with echo subtractor output.
   memcpy(aec->eBuf + PART_LEN, echo_subtractor_output,
          sizeof(float) * PART_LEN);
 
   // Analysis filter banks for the echo suppressor.
   // Windowed near-end ffts.
   WindowData(fft, nearend_extended_block_lowest_band);
-  aec_rdft_forward_128(fft);
+  ooura_fft.Fft(fft);
   StoreAsComplex(fft, dfw);
 
   // Windowed echo suppressor output ffts.
   WindowData(fft, aec->eBuf);
-  aec_rdft_forward_128(fft);
+  ooura_fft.Fft(fft);
   StoreAsComplex(fft, efw);
 
   // NLP
 
   // Convert far-end partition to the frequency domain with windowing.
   WindowData(fft, farend_extended_block);
-  Fft(fft, xfw);
+  Fft(ooura_fft, fft, xfw);
   xfw_ptr = &xfw[0][0];
 
   // Buffer far.
   memcpy(aec->xfwBuf, xfw_ptr, sizeof(float) * 2 * PART_LEN1);
 
   aec->delayEstCtr++;
   if (aec->delayEstCtr == delayEstInterval) {
     aec->delayEstCtr = 0;
     aec->delayIdx = WebRtcAec_PartitionDelay(aec->num_partitions, aec->wfBuf);
   }
@@ skipping 21 matching lines @@
 
   aec->data_dumper->DumpRaw("aec_nlp_gain", PART_LEN1, hNl);
 
   WebRtcAec_Suppress(hNl, efw);
 
   // Add comfort noise.
   ComfortNoise(aec->num_bands > 1, &aec->seed, efw, comfortNoiseHband,
                aec->noisePow, hNl);
 
   // Inverse error fft.
-  ScaledInverseFft(efw, fft, 2.0f, 1);
+  ScaledInverseFft(ooura_fft, efw, fft, 2.0f, 1);
 
   // Overlap and add to obtain output.
   for (i = 0; i < PART_LEN; i++) {
     output[0][i] = (fft[i] * WebRtcAec_sqrtHanning[i] +
                     aec->outBuf[i] * WebRtcAec_sqrtHanning[PART_LEN - i]);
 
     // Saturate output to keep it in the allowed range.
     output[0][i] = WEBRTC_SPL_SAT(WEBRTC_SPL_WORD16_MAX, output[0][i],
                                   WEBRTC_SPL_WORD16_MIN);
   }
   memcpy(aec->outBuf, &fft[PART_LEN], PART_LEN * sizeof(aec->outBuf[0]));
 
   // For H band
   if (aec->num_bands > 1) {
     // H band gain
     // average nlp over low band: average over second half of freq spectrum
     // (4->8khz)
     GetHighbandGain(hNl, &nlpGainHband);
 
     // Inverse comfort_noise
-    ScaledInverseFft(comfortNoiseHband, fft, 2.0f, 0);
+    ScaledInverseFft(ooura_fft, comfortNoiseHband, fft, 2.0f, 0);
 
     // compute gain factor
     for (j = 1; j < aec->num_bands; ++j) {
       for (i = 0; i < PART_LEN; i++) {
         output[j][i] = aec->previous_nearend_block[j][i] * nlpGainHband;
       }
     }
 
     // Add some comfort noise where Hband is attenuated.
     for (i = 0; i < PART_LEN; i++) {
@@ skipping 52 matching lines @@
     // Update power levels
     UpdateLevel(
         &aec->farlevel,
         CalculatePower(&farend_extended_block_lowest_band[PART_LEN], PART_LEN));
     UpdateLevel(&aec->nearlevel,
                 CalculatePower(&nearend_block[0][0], PART_LEN));
   }
 
   // Convert far-end signal to the frequency domain.
   memcpy(fft, farend_extended_block_lowest_band, sizeof(float) * PART_LEN2);
-  Fft(fft, farend_fft);
+  Fft(aec->ooura_fft, fft, farend_fft);
 
   // Form extended nearend frame.
   memcpy(&nearend_extended_block_lowest_band[0],
          &aec->previous_nearend_block[0][0], sizeof(float) * PART_LEN);
   memcpy(&nearend_extended_block_lowest_band[PART_LEN], &nearend_block[0][0],
          sizeof(float) * PART_LEN);
 
   // Convert near-end signal to the frequency domain.
   memcpy(fft, nearend_extended_block_lowest_band, sizeof(float) * PART_LEN2);
-  Fft(fft, nearend_fft);
+  Fft(aec->ooura_fft, fft, nearend_fft);
 
   // Power smoothing.
   if (aec->refined_adaptive_filter_enabled) {
     for (i = 0; i < PART_LEN1; ++i) {
       far_spectrum = farend_fft[0][i] * farend_fft[0][i] +
                      farend_fft[1][i] * farend_fft[1][i];
       // Calculate the magnitude spectrum.
       abs_far_spectrum[i] = sqrtf(far_spectrum);
     }
     RegressorPower(aec->num_partitions, aec->xfBufBlockPos, aec->xfBuf,
@@ skipping 58 matching lines @@
         aec->num_delay_values++;
       }
       if (aec->delay_metrics_delivered == 1 &&
           aec->num_delay_values >= kDelayMetricsAggregationWindow) {
         UpdateDelayMetrics(aec);
       }
     }
   }
 
   // Perform echo subtraction.
-  EchoSubtraction(aec->num_partitions, aec->extended_filter_enabled,
-                  &aec->extreme_filter_divergence, aec->filter_step_size,
-                  aec->error_threshold, &farend_fft[0][0], &aec->xfBufBlockPos,
-                  aec->xfBuf, &nearend_block[0][0], aec->xPow, aec->wfBuf,
-                  echo_subtractor_output);
+  EchoSubtraction(
+      aec->ooura_fft, aec->num_partitions, aec->extended_filter_enabled,
+      &aec->extreme_filter_divergence, aec->filter_step_size,
+      aec->error_threshold, &farend_fft[0][0], &aec->xfBufBlockPos, aec->xfBuf,
+      &nearend_block[0][0], aec->xPow, aec->wfBuf, echo_subtractor_output);
   aec->data_dumper->DumpRaw("aec_h_fft", PART_LEN1 * aec->num_partitions,
                             &aec->wfBuf[0][0]);
   aec->data_dumper->DumpRaw("aec_h_fft", PART_LEN1 * aec->num_partitions,
                             &aec->wfBuf[1][0]);
 
   aec->data_dumper->DumpWav("aec_out_linear", PART_LEN, echo_subtractor_output,
                             std::min(aec->sampFreq, 16000), 1);
 
   if (aec->metricsMode == 1) {
     UpdateLevel(&aec->linoutlevel,
                 CalculatePower(echo_subtractor_output, PART_LEN));
   }
 
   // Perform echo suppression.
-  EchoSuppression(aec, nearend_extended_block_lowest_band,
+  EchoSuppression(aec->ooura_fft, aec, nearend_extended_block_lowest_band,
                   farend_extended_block_lowest_band, echo_subtractor_output,
                   output_block);
 
   if (aec->metricsMode == 1) {
     UpdateLevel(&aec->nlpoutlevel,
                 CalculatePower(&output_block[0][0], PART_LEN));
     UpdateMetrics(aec);
   }
 
   // Store the nearend signal until the next frame.
@@ skipping 65 matching lines @@
 #endif
 
 #if defined(MIPS_FPU_LE)
   WebRtcAec_InitAec_mips();
 #endif
 
 #if defined(WEBRTC_HAS_NEON)
   WebRtcAec_InitAec_neon();
 #endif
 
-  aec_rdft_init();
-
   return aec;
 }
 
 void WebRtcAec_FreeAec(AecCore* aec) {
   if (aec == NULL) {
     return;
   }
 
   WebRtc_FreeDelayEstimator(aec->delay_estimator);
   WebRtc_FreeDelayEstimatorFarend(aec->delay_estimator_farend);
@@ skipping 507 matching lines @@
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   RTC_DCHECK_GE(delay, 0);
   self->system_delay = delay;
 }
 }  // namespace webrtc