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.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);
+
+  int value = 0;

[Ilya Sherman, 2016/08/27 06:38:45]

I think it would be best to document the value here.

[o1ka, 2016/08/29 15:52:17]

I'm not sure if you mean copying the description from the histogram.
Added a reference to it.

+  if (input_buffer_size >= output_buffer_size) {
+    // 0 if input size is a multiply of output size; otherwise -1.

[Ilya Sherman, 2016/08/27 06:38:45]

nit: s/multiply/multiple

[o1ka, 2016/08/29 15:52:17]

Done.

+    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) {

[Henrik Grunell, 2016/08/29 15:26:15]

Nit: (x % y != 0) is more readable. Same above. You could also split == and > to
two different if blocks above (clearer imo).

[o1ka, 2016/08/29 15:52:17]

Acknowledged.

+      // One more callback is issued periodically.
+      value += 1;
+    }
+  }

[Ilya Sherman, 2016/08/27 06:38:45]

The range [-1, 63] sounds like an acceptable range.  Could you please add code
that will explicitly cap the histogram to, say, 64?

[o1ka, 2016/08/29 15:52:17]

Done.

+
+  switch (input_params.latency_tag()) {
+    case AudioLatency::LATENCY_EXACT_MS:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BufferSizeMismatch.LatencyExactMs", value);
+      return;
+    case AudioLatency::LATENCY_INTERACTIVE:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BufferSizeMismatch.LatencyInteractive", value);
+      return;
+    case AudioLatency::LATENCY_RTC:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BufferSizeMismatch.LatencyRtc", value);
+      return;
+    case AudioLatency::LATENCY_PLAYBACK:
+      UMA_HISTOGRAM_SPARSE_SLOWLY(
+          "Media.Audio.Render.BufferSizeMismatch.LatencyPlayback", value);
+      return;
+    default:
+      DLOG(WARNING) << "Latency tag is not set";

[Henrik Grunell, 2016/08/29 15:26:15]

Nit: It seems to me DVLOG that is more appropriate. Or is it expected that the
latency tag is set?

[o1ka, 2016/08/29 15:52:17]

Done.

+  }
+}
+
 // 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