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 30 matching lines @@
     "googExperimentalNoiseSuppression";
 const char MediaAudioConstraints::kGoogBeamforming[] = "googBeamforming";
 const char MediaAudioConstraints::kGoogArrayGeometry[] = "googArrayGeometry";
 const char MediaAudioConstraints::kGoogHighpassFilter[] = "googHighpassFilter";
 const char MediaAudioConstraints::kGoogTypingNoiseDetection[] =
     "googTypingNoiseDetection";
 const char MediaAudioConstraints::kGoogAudioMirroring[] = "googAudioMirroring";
 
 namespace {
 
+// The interval of which the AEC stats update functions should be called. This
+// is the buffer size that the AP and AEC work on.
+const int kChunkDurationMs = 10;

[tommi (sloooow) - chröme, 2016/06/28 11:43:56]

If this value is defined somewhere else (as I suspect), it would be good to use
that constant instead of adding a new one.

[Henrik Grunell, 2016/06/29 08:47:58]

It is! In AudioProcessing. :) Done.

+
 // Controls whether the hotword audio stream is used on supported platforms.
 const char kMediaStreamAudioHotword[] = "googHotword";
 
 // Constant constraint keys which enables default audio constraints on
 // mediastreams with audio.
 struct {
   const char* key;
   bool value;
 } const kDefaultAudioConstraints[] = {
   { MediaAudioConstraints::kEchoCancellation, true },
@@ skipping 232 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) {
+    : delay_stats_time_ms_(0),
+      echo_frames_received_(false),
+      divergent_filter_stats_time_ms_(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) {
+  delay_stats_time_ms_ += kChunkDurationMs;
+  if (delay_stats_time_ms_ < 500 * kChunkDurationMs)  // 5 seconds
     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;
+    delay_stats_time_ms_ = 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;
+  }
+
+  divergent_filter_stats_time_ms_ += kChunkDurationMs;
+  if (divergent_filter_stats_time_ms_ < 100 * kChunkDurationMs)  // 1 second
+    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_;
+  divergent_filter_stats_time_ms_ = 0;
+}
+
+void EchoInformation::ReportAndResetAecDivergentFilterStats() {

[tommi (sloooow) - chröme, 2016/06/28 11:43:56]

can you add thread checks to these methods? As is, it's not clear to me that
they're all called on the same thread.

[Henrik Grunell, 2016/06/29 08:47:58]

Hmm, they are not accessed on the same thread. That should be safe as it and
MSAP is used now, but needs to be guaranteed. Actually it looks like the
existing code is problematic, since we access |echo_information_| in MSAP on two
different threads. We could have a use after free.

I've changed to posting the update to the main thread, where the new reporting
function is called. Now |echo_information_| is only accessed on the main render
thread.

I've also updated the comments around this, as they seemed stale.

MSAP assumes it's created on the main render thread (that thread checker is not
detached in the ctor), so I've done that as well to get the message loop in the
ctor.

+  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.AecFilterHasDivergence",
+                           non_zero_percent);
+
+  divergent_filter_stats_time_ms_ = 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