Using buffered signal to calculate the level of echo cancellation.

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 649 matching lines @@
 
       // Upper mean
       if (dtmp > aec->erl.average) {
         aec->erl.hicounter++;
         aec->erl.hisum += dtmp;
         aec->erl.himean = aec->erl.hisum / aec->erl.hicounter;
       }
 
       // A_NLP
       dtmp = 10 * (float)log10(aec->nearlevel.averagelevel /
-                                   (2 * aec->linoutlevel.averagelevel) +
-                               1e-10f);
+          aec->linoutlevel.averagelevel + 1e-10f);
 
       // subtract noise power
-      suppressedEcho = 2 * (aec->linoutlevel.averagelevel -
-                            safety * aec->linoutlevel.minlevel);
+      suppressedEcho = aec->linoutlevel.averagelevel -
+          safety * aec->linoutlevel.minlevel;
 
       dtmp2 = 10 * (float)log10(echo / suppressedEcho + 1e-10f);
 
       aec->aNlp.instant = dtmp2;
       if (dtmp > aec->aNlp.max) {
         aec->aNlp.max = dtmp;
       }
 
       if (dtmp < aec->aNlp.min) {
         aec->aNlp.min = dtmp;
@@ skipping 210 matching lines @@
         (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]) {
   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;
   memset(s_fft, 0, sizeof(s_fft));
 
@@ skipping 23 matching lines @@
 
   // 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);
 
   RTC_AEC_DEBUG_RAW_WRITE(aec->e_fft_file,
                           &e_fft[0][0],
                           sizeof(e_fft[0][0]) * PART_LEN1 * 2);
 
-  if (metrics_mode == 1) {
-    // Note that the first PART_LEN samples in fft (before transformation) are
-    // zero. Hence, the scaling by two in UpdateLevel() should not be
-    // 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);
   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];
   float xfw[2][PART_LEN1];
   float dfw[2][PART_LEN1];
   float comfortNoiseHband[2][PART_LEN1];
   float fft[PART_LEN2];
@@ skipping 282 matching lines @@
 #ifdef WEBRTC_AEC_DEBUG_DUMP
   {
     // 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
 
+  if (aec->metricsMode == 1) {

[minyue-webrtc, 2016/01/26 16:46:47]

I reduced the buffer sizes for calculating farlevel and nearlevel. I also moved
the code a bit to make it read more nicely.

+    // Update power levels
+    UpdateLevel(&aec->farlevel,
+                CalculatePower(&farend_ptr[PART_LEN], PART_LEN));
+    UpdateLevel(&aec->nearlevel, CalculatePower(nearend_ptr, PART_LEN));
+  }
+
   // Convert far-end signal to the frequency domain.
   memcpy(fft, farend_ptr, sizeof(float) * PART_LEN2);
   Fft(fft, xf);
   xf_ptr = &xf[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]);
     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];
@@ skipping 60 matching lines @@
          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);
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outLinearFile, echo_subtractor_output, PART_LEN);
 
+  if (aec->metricsMode == 1) {
+    UpdateLevel(&aec->linoutlevel,
+                CalculatePower(echo_subtractor_output, PART_LEN));
+  }
+
   // Perform echo suppression.
   EchoSuppression(aec, farend_ptr, echo_subtractor_output, output, outputH_ptr);
 
   if (aec->metricsMode == 1) {
     UpdateMetrics(aec);
   }
 
   // Store the output block.
   WebRtc_WriteBuffer(aec->outFrBuf, output, PART_LEN);
   // For high bands
@@ skipping 306 matching lines @@
 
   aec->extreme_filter_divergence = 0;
 
   // Metrics disabled by default
   aec->metricsMode = 0;
   InitMetrics(aec);
 
   return 0;
 }
 
-
 // For bit exactness with a legacy code, |farend| is supposed to contain
 // |PART_LEN2| samples with an overlap of |PART_LEN| samples from the last
 // frame.
 // TODO(minyue): reduce |farend| to non-overlapped |PART_LEN| samples.
 void WebRtcAec_BufferFarendPartition(AecCore* aec, const float* farend) {
   // Check if the buffer is full, and in that case flush the oldest data.
   if (WebRtc_available_write(aec->far_time_buf) < 1) {
     WebRtcAec_MoveFarReadPtr(aec, 1);
   }
 
@@ skipping 197 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;
 }