Moved buffering of farend into the EchoSubtraction method.

webrtc/modules/audio_processing/aec/aec_core.c

 /*
  *  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 881 matching lines @@
     float delay_quality = WebRtc_last_delay_quality(self->delay_estimator);
     delay_quality = (delay_quality > kDelayQualityThresholdMax ?
         kDelayQualityThresholdMax : delay_quality);
     self->delay_quality_threshold =
         (delay_quality > self->delay_quality_threshold ? delay_quality :
             self->delay_quality_threshold);
   }
   return delay_correction;
 }
 
-static void EchoSubtraction(
-    AecCore* aec,
-    int num_partitions,
-    int x_fft_buf_block_pos,
-    int metrics_mode,
-    int extended_filter_enabled,
-    float normal_mu,
-    float normal_error_threshold,
-    float x_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    float* const y,
-    float x_pow[PART_LEN1],
-    float h_fft_buf[2][kExtendedNumPartitions * PART_LEN1],
-    PowerLevel* linout_level,
-    float echo_subtractor_output[PART_LEN]) {
+static void EchoSubtraction(AecCore* aec,
+                            int num_partitions,
+                            int metrics_mode,
+                            int extended_filter_enabled,
+                            float normal_mu,
+                            float normal_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],
+                            float h_fft_buf[2]
+                                           [kExtendedNumPartitions * PART_LEN1],
+                            PowerLevel* linout_level,
+                            float echo_subtractor_output[PART_LEN]) {

[ivoc, 2016/02/05 09:05:04]

Although I noticed that most functions in the file don't have this, I was
thinking that a bit of documentation on what the input/output variables are and
do would be useful. What do you think?

[peah-webrtc, 2016/02/05 10:19:49]

Great point! That would definitely make sense. I'm a bit hesitant to add it
right now, though, as this is code that is going through, and for several months
will continue to go through, a lot of changes. Therefore I'll not add any
comments at this point but instead wait with the comments until a later stage.

   float s_fft[2][PART_LEN1];
   float e_extended[PART_LEN2];
   float s_extended[PART_LEN2];
   float *s;
   float e[PART_LEN];
   float e_fft[2][PART_LEN1];
   int i;
+
+  // Update the x_fft_buf block position.
+  (*x_fft_buf_block_pos)--;
+  if ((*x_fft_buf_block_pos) == -1) {
+    *x_fft_buf_block_pos = num_partitions - 1;
+  }
+
+  // Buffer x_fft.
+  memcpy(x_fft_buf[0] + (*x_fft_buf_block_pos) * PART_LEN1, x_fft,
+         sizeof(float) * PART_LEN1);
+  memcpy(x_fft_buf[1] + (*x_fft_buf_block_pos) * PART_LEN1, &x_fft[PART_LEN1],
+         sizeof(float) * PART_LEN1);
+
   memset(s_fft, 0, sizeof(s_fft));
 
   // Conditionally reset the echo subtraction filter if the filter has diverged
   // significantly.
   if (!aec->extended_filter_enabled &&
       aec->extreme_filter_divergence) {
     memset(aec->wfBuf, 0, sizeof(aec->wfBuf));
     aec->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);
+  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);
   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];
   }
 
@@ skipping 12 matching lines @@
     // performed. That scaling is taken care of in UpdateMetrics() instead.
     UpdateLevel(linout_level, CalculatePower(e, PART_LEN) / 2.0f);
   }
 
   // Scale error signal inversely with far power.
   WebRtcAec_ScaleErrorSignal(extended_filter_enabled,
                              normal_mu,
                              normal_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(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 EchoSuppression(AecCore* aec,
                             float farend[PART_LEN2],
                             float* echo_subtractor_output,
                             float* output,
                             float* const* outputH) {
   float efw[2][PART_LEN1];
@@ skipping 232 matching lines @@
 
   memmove(aec->xfwBuf + PART_LEN1,
           aec->xfwBuf,
           sizeof(aec->xfwBuf) - sizeof(complex_t) * PART_LEN1);
 }
 
 static void ProcessBlock(AecCore* aec) {
   size_t i;
 
   float fft[PART_LEN2];
-  float xf[2][PART_LEN1];
+  float x_fft[2][PART_LEN1];
   float df[2][PART_LEN1];
   float far_spectrum = 0.0f;
   float near_spectrum = 0.0f;
   float abs_far_spectrum[PART_LEN1];
   float abs_near_spectrum[PART_LEN1];
 
   const float gPow[2] = {0.9f, 0.1f};
 
   // Noise estimate constants.
   const int noiseInitBlocks = 500 * aec->mult;
   const float step = 0.1f;
   const float ramp = 1.0002f;
   const float gInitNoise[2] = {0.999f, 0.001f};
 
   float nearend[PART_LEN];
   float* nearend_ptr = NULL;
   float farend[PART_LEN2];
   float* farend_ptr = NULL;
   float echo_subtractor_output[PART_LEN];
   float output[PART_LEN];
   float outputH[NUM_HIGH_BANDS_MAX][PART_LEN];
   float* outputH_ptr[NUM_HIGH_BANDS_MAX];
-  float* xf_ptr = NULL;
+  float* x_fft_ptr = NULL;
 
   for (i = 0; i < NUM_HIGH_BANDS_MAX; ++i) {
     outputH_ptr[i] = outputH[i];
   }
 
   // Concatenate old and new nearend blocks.
   for (i = 0; i < aec->num_bands - 1; ++i) {
     WebRtc_ReadBuffer(aec->nearFrBufH[i],
                       (void**)&nearend_ptr,
                       nearend,
@@ skipping 12 matching lines @@
     // TODO(minyue): |farend_ptr| starts from buffered samples. This will be
     // modified when |aec->far_time_buf| is revised.
     RTC_AEC_DEBUG_WAV_WRITE(aec->farFile, &farend_ptr[PART_LEN], PART_LEN);
 
     RTC_AEC_DEBUG_WAV_WRITE(aec->nearFile, nearend_ptr, PART_LEN);
   }
 #endif
 
   // Convert far-end signal to the frequency domain.
   memcpy(fft, farend_ptr, sizeof(float) * PART_LEN2);
-  Fft(fft, xf);
-  xf_ptr = &xf[0][0];
+  Fft(fft, x_fft);
+  x_fft_ptr = &x_fft[0][0];
 
   // Near fft
   memcpy(fft, aec->dBuf, sizeof(float) * PART_LEN2);
   Fft(fft, df);
 
   if (aec->metricsMode == 1) {
     // Update power levels
     UpdateLevel(&aec->farlevel, CalculatePower(farend_ptr, PART_LEN2));
     UpdateLevel(&aec->nearlevel, CalculatePower(aec->dBuf, PART_LEN2));
   }
 
   // Power smoothing
   for (i = 0; i < PART_LEN1; i++) {
-    far_spectrum = (xf_ptr[i] * xf_ptr[i]) +
-                   (xf_ptr[PART_LEN1 + i] * xf_ptr[PART_LEN1 + i]);
+    far_spectrum = (x_fft_ptr[i] * x_fft_ptr[i]) +
+                   (x_fft_ptr[PART_LEN1 + i] * x_fft_ptr[PART_LEN1 + i]);
     aec->xPow[i] =
         gPow[0] * aec->xPow[i] + gPow[1] * aec->num_partitions * far_spectrum;
     // Calculate absolute spectra
     abs_far_spectrum[i] = sqrtf(far_spectrum);
 
     near_spectrum = df[0][i] * df[0][i] + df[1][i] * df[1][i];
     aec->dPow[i] = gPow[0] * aec->dPow[i] + gPow[1] * near_spectrum;
     // Calculate absolute spectra
     abs_near_spectrum[i] = sqrtf(near_spectrum);
   }
@@ skipping 38 matching lines @@
         aec->delay_histogram[delay_estimate]++;
         aec->num_delay_values++;
       }
       if (aec->delay_metrics_delivered == 1 &&
           aec->num_delay_values >= kDelayMetricsAggregationWindow) {
         UpdateDelayMetrics(aec);
       }
     }
   }
 
-  // Update the xfBuf block position.
-  aec->xfBufBlockPos--;
-  if (aec->xfBufBlockPos == -1) {
-    aec->xfBufBlockPos = aec->num_partitions - 1;
-  }
-
-  // Buffer xf
-  memcpy(aec->xfBuf[0] + aec->xfBufBlockPos * PART_LEN1,
-         xf_ptr,
-         sizeof(float) * PART_LEN1);
-  memcpy(aec->xfBuf[1] + aec->xfBufBlockPos * PART_LEN1,
-         &xf_ptr[PART_LEN1],
-         sizeof(float) * PART_LEN1);
-
   // Perform echo subtraction.
-  EchoSubtraction(aec,
-                  aec->num_partitions,
-                  aec->xfBufBlockPos,
-                  aec->metricsMode,
-                  aec->extended_filter_enabled,
-                  aec->normal_mu,
-                  aec->normal_error_threshold,
-                  aec->xfBuf,
-                  nearend_ptr,
-                  aec->xPow,
-                  aec->wfBuf,
-                  &aec->linoutlevel,
-                  echo_subtractor_output);
+  EchoSubtraction(aec, aec->num_partitions, aec->metricsMode,
+                  aec->extended_filter_enabled, aec->normal_mu,
+                  aec->normal_error_threshold, &x_fft[0][0],
+                  &aec->xfBufBlockPos, aec->xfBuf, nearend_ptr, aec->xPow,
+                  aec->wfBuf, &aec->linoutlevel, echo_subtractor_output);
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outLinearFile, echo_subtractor_output, PART_LEN);
 
   // Perform echo suppression.
   EchoSuppression(aec, farend_ptr, echo_subtractor_output, output, outputH_ptr);
 
   if (aec->metricsMode == 1) {
     UpdateMetrics(aec);
   }
 
@@ skipping 527 matching lines @@
 int WebRtcAec_extended_filter_enabled(AecCore* self) {
   return self->extended_filter_enabled;
 }
 
 int WebRtcAec_system_delay(AecCore* self) { return self->system_delay; }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }