Adding fraction of filter divergence in AEC metrics.

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 29 matching lines @@
 #include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
 #include "webrtc/typedefs.h"
 
 // Buffer size (samples)
 static const size_t kBufSizePartitions = 250;  // 1 second of audio in 16 kHz.
 
 // Metrics
 static const int subCountLen = 4;
 static const int countLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 

[tlegrand-webrtc, 2016/03/02 15:30:29]

I'm wondering if "Diverge" is the right term, or if we should call it
"Divergence". What do you guys think makes most sense?

[kwiberg-webrtc, 2016/03/02 18:33:03]

I believe "Divergent" is the trendy form.

+// Diverge metric is based on audio level, which gets updated which every

[tlegrand-webrtc, 2016/03/02 15:30:29]

remove "which" in "which every"

+// |subCountLen + 1| * 10 milliseconds. Diverge metric takes the statistics of
+// |kDivergeMetricAggregationWindow| samples.
+static const int kDivergeMetricAggregationWindow = 50;  // 1 seconds at 16 kHz.
+
 // Quantities to control H band scaling for SWB input
 static const float cnScaleHband = 0.4f;  // scale for comfort noise in H band.
 // Initial bin for averaging nlp gain in low band
 static const int freqAvgIc = PART_LEN / 2;
 
 // Matlab code to produce table:
 // win = sqrt(hanning(63)); win = [0 ; win(1:32)];
 // fprintf(1, '\t%.14f, %.14f, %.14f,\n', win);
 ALIGN16_BEG const float ALIGN16_END WebRtcAec_sqrtHanning[65] = {
     0.00000000000000f, 0.02454122852291f, 0.04906767432742f, 0.07356456359967f,
@@ skipping 486 matching lines @@
   self->stateCounter = 0;
   InitLevel(&self->farlevel);
   InitLevel(&self->nearlevel);
   InitLevel(&self->linoutlevel);
   InitLevel(&self->nlpoutlevel);
 
   InitStats(&self->erl);
   InitStats(&self->erle);
   InitStats(&self->aNlp);
   InitStats(&self->rerl);
+
+  self->num_diverge_values = 0;
+  self->num_filter_diverge = 0;
+  self->fraction_filter_diverge = 0.0f;
 }
 
 static float CalculatePower(const float* in, size_t num_samples) {
   size_t k;
   float energy = 0.0f;
 
   for (k = 0; k < num_samples; ++k) {
     energy += in[k] * in[k];
   }
   return energy / num_samples;
@@ skipping 37 matching lines @@
   // a per-sample energy (i.e., power).
   const float noisyPower = 300000.0f * 2.0f / PART_LEN2;
 
   float actThreshold;
   float echo, suppressedEcho;
 
   if (aec->echoState) {  // Check if echo is likely present
     aec->stateCounter++;
   }
 
+  if (aec->linoutlevel.sfrcounter == 0) {
+    // We count a filter divergence when the audio level of linear filter output
+    // is larger than that of near-end signal by -30dB or more.

[peah-webrtc, 2016/02/29 14:05:56]

I don't think the usage of "-30dB" is correct. I think that it should be 0.0043
dB.

I.e. (including some rephrasing):
// We count it as a filter divergence when the audio level of the linear filter
output
// is larger than that of the near-end signal by 0.0043 dB or more.

+    if (aec->linoutlevel.framelevel > 1.001 * aec->nearlevel.framelevel)
+      aec->num_filter_diverge++;
+    aec->num_diverge_values++;
+    if (aec->num_diverge_values >= kDivergeMetricAggregationWindow) {
+      aec->fraction_filter_diverge =
+          static_cast<float>(aec->num_filter_diverge) / aec->num_diverge_values;
+      aec->num_diverge_values = 0;
+      aec->num_filter_diverge = 0;
+    }
+  }
+
   if (aec->farlevel.frcounter == 0) {
     if (aec->farlevel.minlevel < noisyPower) {
       actThreshold = actThresholdClean;
     } else {
       actThreshold = actThresholdNoisy;
     }
 
     if ((aec->stateCounter > (0.5f * countLen * subCountLen)) &&
         (aec->farlevel.sfrcounter == 0)
 
@@ skipping 1280 matching lines @@
 }
 
 int WebRtcAec_system_delay(AecCore* self) {
   return self->system_delay;
 }
 
 void WebRtcAec_SetSystemDelay(AecCore* self, int delay) {
   assert(delay >= 0);
   self->system_delay = delay;
 }