Add UMA stats for AEC filter divergence metric.

content/renderer/media/media_stream_audio_processor_options.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/media_stream_audio_processor_options.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 282 matching lines @@
   std::string the_value;
   if (GetConstraintValueAsString(
           constraints_, &blink::WebMediaTrackConstraintSet::googArrayGeometry,
           &the_value)) {
     return the_value;
   }
   return "";
 }
 
 EchoInformation::EchoInformation()
-    : num_chunks_(0), echo_frames_received_(false) {
+    : chunks_for_delay_stats_(0),
+      echo_frames_received_(false),
+      chunks_for_divergent_filter_stats_(0),
+      num_divergent_filter_fraction_(0),
+      num_non_zero_divergent_filter_fraction_(0) {}
+
+EchoInformation::~EchoInformation() {
+  ReportAndResetAecDivergentFilterStats();
 }
 
-EchoInformation::~EchoInformation() {}
-
 void EchoInformation::UpdateAecDelayStats(
     webrtc::EchoCancellation* echo_cancellation) {
   // Only start collecting stats if we know echo cancellation has measured an
   // echo. Otherwise we clutter the stats with for example cases where only the
   // microphone is used.
   if (!echo_frames_received_ & !echo_cancellation->stream_has_echo())
     return;
 
   echo_frames_received_ = true;
   // In WebRTC, three echo delay metrics are calculated and updated every
   // five seconds. We use one of them, |fraction_poor_delays| to log in a UMA
   // histogram an Echo Cancellation quality metric. The stat in WebRTC has a
   // fixed aggregation window of five seconds, so we use the same query
   // frequency to avoid logging old values.
   const int kNumChunksInFiveSeconds = 500;
   if (!echo_cancellation->is_delay_logging_enabled() ||
       !echo_cancellation->is_enabled()) {
     return;
   }
 
-  num_chunks_++;
-  if (num_chunks_ < kNumChunksInFiveSeconds) {
+  ++chunks_for_delay_stats_;
+  if (chunks_for_delay_stats_ < kNumChunksInFiveSeconds)
     return;
-  }
 
   int dummy_median = 0, dummy_std = 0;
   float fraction_poor_delays = 0;
   if (echo_cancellation->GetDelayMetrics(
           &dummy_median, &dummy_std, &fraction_poor_delays) ==
       webrtc::AudioProcessing::kNoError) {
-    num_chunks_ = 0;
+    chunks_for_delay_stats_ = 0;
     // Map |fraction_poor_delays| to an Echo Cancellation quality and log in UMA
     // histogram. See DelayBasedEchoQuality for information on histogram
     // buckets.
     UMA_HISTOGRAM_ENUMERATION("WebRTC.AecDelayBasedQuality",
                               EchoDelayFrequencyToQuality(fraction_poor_delays),
                               DELAY_BASED_ECHO_QUALITY_MAX);
   }
 }
 
+void EchoInformation::UpdateAecDivergentFilterStats(
+    webrtc::EchoCancellation* echo_cancellation) {
+  if (!echo_cancellation->is_enabled() ||
+      !echo_cancellation->are_metrics_enabled()) {
+    return;
+  }
+
+  const int kNumChunksInOneSecond = 100;

[minyue, 2016/06/28 08:18:41]

kNumChunksInOneSecond and kNumChunksInFiveSeconds can be calculated by
kChunkDurationMs (can be defined in anonymous namespace)

But if you take my suggestion of counting time, you need only kChunkDurationMs.

[Henrik Grunell, 2016/06/28 09:33:10]

Using time and kChunkDurationMs.

+  ++chunks_for_divergent_filter_stats_;
+  if (chunks_for_divergent_filter_stats_ < kNumChunksInOneSecond)
+    return;
+
+  webrtc::EchoCancellation::Metrics metrics;
+  if (echo_cancellation->GetMetrics(&metrics) ==
+      webrtc::AudioProcessing::kNoError) {
+    // If not yet calculated, |metrics.divergent_filter_fraction| is -1.0. After
+    // being calculated the first time, it is updated periodically.
+    if (metrics.divergent_filter_fraction < 0.0f) {
+      DCHECK_EQ(num_divergent_filter_fraction_, 0);
+      return;
+    }
+    if (metrics.divergent_filter_fraction > 0.0f) {
+      ++num_non_zero_divergent_filter_fraction_;
+    }
+  } else {
+    DLOG(WARNING) << "Get echo cancellation metrics failed.";
+  }
+  ++num_divergent_filter_fraction_;
+  chunks_for_divergent_filter_stats_ = 0;
+}
+
+void EchoInformation::ReportAndResetAecDivergentFilterStats() {
+  if (num_divergent_filter_fraction_ == 0)
+    return;
+
+  int non_zero_percent = 100 * num_non_zero_divergent_filter_fraction_ /
+                         num_divergent_filter_fraction_;
+  UMA_HISTOGRAM_PERCENTAGE("WebRTC.AecDivergentFilterNonZeroPeriods",
+                           non_zero_percent);
+
+  chunks_for_divergent_filter_stats_ = 0;
+  num_non_zero_divergent_filter_fraction_ = 0;
+  num_divergent_filter_fraction_ = 0;
+}
+
 void EnableEchoCancellation(AudioProcessing* audio_processing) {
 #if defined(OS_ANDROID)
   // Mobile devices are using AECM.
   CHECK_EQ(0, audio_processing->echo_control_mobile()->set_routing_mode(
                   webrtc::EchoControlMobile::kSpeakerphone));
   CHECK_EQ(0, audio_processing->echo_control_mobile()->Enable(true));
   return;
 #endif
   int err = audio_processing->echo_cancellation()->set_suppression_level(
       webrtc::EchoCancellation::kHighSuppression);
@@ skipping 108 matching lines @@
 
   // Give preference to the audio constraint over the device-supplied mic
   // positions. This is mainly for testing purposes.
   return WebrtcPointsFromMediaPoints(
       constraints_geometry.empty()
           ? input_params.mic_positions
           : media::ParsePointsFromString(constraints_geometry));
 }
 
 }  // namespace content