UMA stats for browser/renderer audio rendering buffer size mismatch.

media/audio/audio_output_resampler.cc

 // Copyright (c) 2012 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 "media/audio/audio_output_resampler.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/sparse_histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_output_proxy.h"
 #include "media/audio/sample_rates.h"
 #include "media/base/audio_converter.h"
 #include "media/base/limits.h"
 
 namespace media {
@@ skipping 104 matching lines @@
     UMA_HISTOGRAM_ENUMERATION(
         "Media.FallbackHardwareAudioSamplesPerSecond",
         asr, kAudioSampleRateMax + 1);
   } else {
     UMA_HISTOGRAM_COUNTS(
         "Media.FallbackHardwareAudioSamplesPerSecondUnexpected",
         output_params.sample_rate());
   }
 }
 
+// Record UMA statistics for input/output rebuffering.
+static void RecordRebufferingStats(const AudioParameters& input_params,
+                                   const AudioParameters& output_params) {
+  const int input_buffer_size = input_params.frames_per_buffer();
+  const int output_buffer_size = output_params.frames_per_buffer();
+  DCHECK_NE(0, input_buffer_size);
+  DCHECK_NE(0, output_buffer_size);
+
+  // Buffer size mismatch; see Media.Audio.Render.BrowserCallbackRegularity
+  // histogram for explanation.
+  int value = 0;
+  if (input_buffer_size >= output_buffer_size) {
+    // 0 if input size is a multiple of output size; otherwise -1.
+    value = (input_buffer_size % output_buffer_size) ? -1 : 0;
+  } else {
+    value = (output_buffer_size / input_buffer_size - 1) * 2;
+    if (output_buffer_size % input_buffer_size) {
+      // One more callback is issued periodically.
+      value += 1;
+    }
+  }
+
+  const int value_cap = (4096 / 128 - 1) * 2 + 1;
+  if (value > value_cap)
+    value = value_cap;
+
+  switch (input_params.latency_tag()) {
+    case AudioLatency::LATENCY_EXACT_MS:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BrowserCallbackRegularity.LatencyExactMs", value);
+      return;
+    case AudioLatency::LATENCY_INTERACTIVE:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BrowserCallbackRegularity.LatencyInteractive",
+          value);
+      return;
+    case AudioLatency::LATENCY_RTC:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BrowserCallbackRegularity.LatencyRtc", value);
+      return;
+    case AudioLatency::LATENCY_PLAYBACK:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BrowserCallbackRegularity.LatencyPlayback",
+          value);
+      return;
+    default:
+      DVLOG(1) << "Latency tag is not set";
+  }
+}
+
 // Converts low latency based |output_params| into high latency appropriate
 // output parameters in error situations.
 void AudioOutputResampler::SetupFallbackParams() {
 // Only Windows has a high latency output driver that is not the same as the low
 // latency path.
 #if defined(OS_WIN)
   // Choose AudioParameters appropriate for opening the device in high latency
   // mode.  |kMinLowLatencyFrameSize| is arbitrarily based on Pepper Flash's
   // MAXIMUM frame size for low latency.
   static const int kMinLowLatencyFrameSize = 2048;
@@ skipping 199 matching lines @@
 
 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params,
                                          const AudioParameters& output_params)
     : io_ratio_(static_cast<double>(input_params.GetBytesPerSecond()) /
                 output_params.GetBytesPerSecond()),
       source_callback_(nullptr),
       input_bytes_per_frame_(input_params.GetBytesPerFrame()),
       audio_converter_(input_params, output_params, false),
       error_occurred_(false),
       input_buffer_size_(input_params.frames_per_buffer()),
-      output_buffer_size_(output_params.frames_per_buffer()) {}
+      output_buffer_size_(output_params.frames_per_buffer()) {
+  RecordRebufferingStats(input_params, output_params);
+}
 
 OnMoreDataConverter::~OnMoreDataConverter() {
   // Ensure Stop() has been called so we don't end up with an AudioOutputStream
   // calling back into OnMoreData() after destruction.
   CHECK(!source_callback_);
 }
 
 void OnMoreDataConverter::Start(
     AudioOutputStream::AudioSourceCallback* callback) {
   CHECK(!source_callback_);
@@ skipping 43 matching lines @@
     dest->ZeroFramesPartial(frames, dest->frames() - frames);
   return frames > 0 ? 1 : 0;
 }
 
 void OnMoreDataConverter::OnError(AudioOutputStream* stream) {
   error_occurred_ = true;
   source_callback_->OnError(stream);
 }
 
 }  // namespace media