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 int subCountLen = 4;
 static const int countLen = 50;
 static const int kDelayMetricsAggregationWindow = 1250;  // 5 seconds at 16 kHz.
 
+// Diverge metric is based on audio level, which gets updated which every

[tlegrand-webrtc, 2016/03/17 12:28:39]

You haven't addressed my comments from Patch Set 1:
Diverge -> Divergence
which every -> every.

[minyue-webrtc, 2016/04/03 21:42:06]

Sorry, I might have missed it. Now it is addressed.

+// |subCountLen + 1| * 10 milliseconds. Diverge metric takes the statistics of
+// |kDivergeMetricAggregationWindow| samples. Current value corresponds to  0.5
+// seconds at 16 kHz.
+static const int kDivergeMetricAggregationWindow = 25;
+
 // 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->fraction_filter_divergent->Clear();
 }
 
 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) {
+    const float level_increase =
+        aec->linoutlevel.framelevel - aec->nearlevel.framelevel;
+    // Level increase should be, in principle, negative, when the filter
+    // does not diverge. Here we allow some margin (0.001 * near end level) and
+    // numerical error (1.0).
+    aec->fraction_filter_divergent->AddSample(level_increase >
+        std::max(0.001 * aec->nearlevel.framelevel, 1.0) ? 1.0 : 0.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 732 matching lines @@
   // For high bands
   for (i = 0; i < aec->num_bands - 1; ++i) {
     WebRtc_WriteBuffer(aec->outFrBufH[i], outputH[i], PART_LEN);
   }
 
   RTC_AEC_DEBUG_WAV_WRITE(aec->outFile, output, PART_LEN);
 }
 
 AecCore* WebRtcAec_CreateAec() {
   int i;
-  AecCore* aec = reinterpret_cast<AecCore*>(malloc(sizeof(AecCore)));
+  AecCore* aec = new AecCore;
   if (!aec) {
     return NULL;
   }
 
   aec->nearFrBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN, sizeof(float));
   if (!aec->nearFrBuf) {
     WebRtcAec_FreeAec(aec);
     return NULL;
   }
 
@@ skipping 43 matching lines @@
     return NULL;
   }
   // We create the delay_estimator with the same amount of maximum lookahead as
   // the delay history size (kHistorySizeBlocks) for symmetry reasons.
   aec->delay_estimator = WebRtc_CreateDelayEstimator(
       aec->delay_estimator_farend, kHistorySizeBlocks);
   if (aec->delay_estimator == NULL) {
     WebRtcAec_FreeAec(aec);
     return NULL;
   }
+
+  aec->fraction_filter_divergent.reset(
+      new webrtc::MeanCalculator(kDivergeMetricAggregationWindow));

[tlegrand-webrtc, 2016/03/17 12:28:39]

Do you need webrtc:: here? Looks like we are in the webrtc namespace.

[minyue-webrtc, 2016/04/03 21:42:05]

True. the namespace was added recently. now I can remove webrtc::

+  if (aec->fraction_filter_divergent.get() == nullptr) {

[tlegrand-webrtc, 2016/03/17 12:28:39]

Can you explain what happens here?

[minyue-webrtc, 2016/04/03 21:42:06]

This is to check if the memory is allocated correctly. But now I avoid dynamic
memory allocation.

+    WebRtcAec_FreeAec(aec);
+    return NULL;
+  }
+
 #ifdef WEBRTC_ANDROID
   aec->delay_agnostic_enabled = 1;  // DA-AEC enabled by default.
   // DA-AEC assumes the system is causal from the beginning and will self adjust
   // the lookahead when shifting is required.
   WebRtc_set_lookahead(aec->delay_estimator, 0);
 #else
   aec->delay_agnostic_enabled = 0;
   WebRtc_set_lookahead(aec->delay_estimator, kLookaheadBlocks);
 #endif
   aec->extended_filter_enabled = 0;
@@ skipping 454 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