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 32 matching lines @@
 namespace webrtc {
 
 // Buffer size (samples)
 static const size_t kBufSizePartitions = 250;  // 1 second of audio in 16 kHz.
 
 // Metrics
 static const size_t kSubCountLen = 4;
 static const size_t kCountLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 
+// Divergence metric is based on audio level, which gets updated every
+// |kCountLen + 1| * 10 milliseconds. Divergence metric takes the statistics of
+// |kDivergeMetricAggregationWindow| samples. Current value corresponds to 0.5
+// seconds at 16 kHz.
+static const int kDivergeMetricAggregationWindow = 25;

[peah-webrtc, 2016/04/06 11:01:10]

This should probably be called kDivergeMetricAggregationWindowSize.

[minyue-webrtc, 2016/04/06 13:35:37]

Done.

+
 // 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 80 matching lines @@
 WebRtcAecWindowData WebRtcAec_WindowData;
 
 __inline static float MulRe(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bRe - aIm * bIm;
 }
 
 __inline static float MulIm(float aRe, float aIm, float bRe, float bIm) {
   return aRe * bIm + aIm * bRe;
 }
 
+// TODO(minyue): Due to a legacy bug, |framelevel| and |averagelevel| use a
+// window, of which the length is 1 unit longer than indicated. Remove "+1" when
+// the code is refactored.
 PowerLevel::PowerLevel()
-// TODO(minyue): Due to a legacy bug, |framelevel| and |averagelevel| use a
-// window, of which the length is 1 unit longer than indicated. Remove "+1"
-// when the code is refactored.
-: framelevel(kSubCountLen + 1),
-  averagelevel(kCountLen + 1) {
+    : framelevel(kSubCountLen + 1),
+      averagelevel(kCountLen + 1) {
 }
 
 // TODO(minyue): Moving some initialization from WebRtcAec_CreateAec() to ctor.
-AecCore::AecCore() = default;
+AecCore::AecCore()
+    : divergent_filter_fraction(kDivergeMetricAggregationWindow) {
+}
 
 static int CmpFloat(const void* a, const void* b) {
   const float* da = (const float*)a;
   const float* db = (const float*)b;
 
   return (*da > *db) - (*da < *db);
 }
 
 static void FilterFar(int num_partitions,
                       int x_fft_buf_block_pos,
@@ skipping 382 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->divergent_filter_fraction.Reset();
 }
 
 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 23 matching lines @@
 
   const float noisyPower = 300000.0f;
 
   float actThreshold;
   float echo, suppressedEcho;
 
   if (aec->echoState) {  // Check if echo is likely present
     aec->stateCounter++;
   }
 
+  if (aec->linoutlevel.framelevel.EndOfBlock()) {
+    const float near_level = aec->nearlevel.framelevel.GetLatestMean();
+    const float level_increase =
+        aec->linoutlevel.framelevel.GetLatestMean() - near_level;
+    const bool output_signal_active =
+        aec->nlpoutlevel.framelevel.GetLatestMean() >
+            actThresholdClean * aec->nlpoutlevel.minlevel;
+    // Level increase should be, in principle, negative, when the filter
+    // does not diverge. Here we allow some margin (0.01 * near end level) and
+    // numerical error (1.0). We count divergence only when the AEC output
+    // signal is active.
+    aec->divergent_filter_fraction.AddObservation(output_signal_active &&
+        level_increase > std::max(0.01 * near_level, 1.0));

[peah-webrtc, 2016/04/06 11:01:10]

If this would be a general and common task maybe a separate class would be
merited but at this stage this is only used here, and what is done is so simple,
so I don't think that a separate utility class is motivated for this.

I think the class instead should be locally implemented inside this file.

[minyue-webrtc, 2016/04/06 13:35:37]

Done.

+  }
+
   if (aec->farlevel.averagelevel.EndOfBlock()) {
     if (aec->farlevel.minlevel < noisyPower) {
       actThreshold = actThresholdClean;
     } else {
       actThreshold = actThresholdNoisy;
     }
 
     const float far_average_level = aec->farlevel.averagelevel.GetLatestMean();
 
     // The last condition is to let estimation be made in active far-end
@@ skipping 1274 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;
 }
 }  // namespace webrtc