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 13 matching lines @@
   // Power estimate smoothing coefficients.
   const float* min_overdrive = aec->extended_filter_enabled
                                    ? kExtendedMinOverDrive
                                    : kNormalMinOverDrive;
 
   // 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, aec->dBuf);
   aec_rdft_forward_128(fft);
   StoreAsComplex(fft, dfw);
 
   // Windowed echo suppressor output ffts.
   WindowData(fft, aec->eBuf);
   aec_rdft_forward_128(fft);
   StoreAsComplex(fft, efw);
@@ skipping 339 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);
 
+  // Update eBuf with echo subtractor output.

[peah-webrtc, 2016/01/25 12:23:02]

This may be affected by changes in the future. As it is now, linoutLevel is
always the level of the linear filter output. Currently, that is equivalent to
echo_subtractor_output but that will change. For instance, during filter
divergence, echo_subtractor_output should be equal to the microphone signal
rather than the linear filter output.

That change may be fine though, depending upon how the metric should be used. If
it is a metric over the ERLE achieved by the EchoSubtraction function call, that
is fine, but if it is a metric of the ERLE currently achieved by the adaptive
filter, that will in that case no longer be correct.

 Just wanted to give a hea

[minyue-webrtc, 2016/01/25 14:26:55]

Good point. It is true that when the linear filter diverges, we bypass it and
the performance of the linear filter does not correspond to any echo
cancellation performance. However, the divergence status can still be used since
1. it works as a double-talk detector
2. it should not toggle too often

Regarding ERLE, this change does not affect it. It affects only A_NLP.

+  memcpy(aec->eBuf + PART_LEN,
+         echo_subtractor_output,
+         sizeof(float) * PART_LEN);
+
+  if (aec->metricsMode == 1) {
+    UpdateLevel(&aec->linoutlevel, CalculatePower(aec->eBuf, PART_LEN2));
+  }
+
   // 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 524 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;
 }