More tracing for audio rendering

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"
@@ skipping 54 matching lines @@
   const int input_bytes_per_frame_;
 
   // Handles resampling, buffering, and channel mixing between input and output
   // parameters.
   AudioConverter audio_converter_;
 
   // True if OnError() was ever called.  Should only be read if the underlying
   // stream has been stopped.
   bool error_occurred_;
 
+  // Information about input and output buffer sizes to be traced.
+  const int input_buffer_size_;
+  const int output_buffer_size_;
+
   DISALLOW_COPY_AND_ASSIGN(OnMoreDataConverter);
 };
 
 // Record UMA statistics for hardware output configuration.
 static void RecordStats(const AudioParameters& output_params) {
   // Note the 'PRESUBMIT_IGNORE_UMA_MAX's below, these silence the PRESUBMIT.py
   // check for uma enum max usage, since we're abusing UMA_HISTOGRAM_ENUMERATION
   // to report a discrete value.
   UMA_HISTOGRAM_ENUMERATION(
       "Media.HardwareAudioBitsPerChannel",
@@ skipping 256 matching lines @@
   DCHECK(callbacks_.empty());
 }
 
 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) {}
+      error_occurred_(false),
+      input_buffer_size_(input_params.frames_per_buffer()),
+      output_buffer_size_(output_params.frames_per_buffer()) {}
 
 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_);
   source_callback_ = callback;
 
   // While AudioConverter can handle multiple inputs, we're using it only with
   // a single input currently.  Eventually this may be the basis for a browser
   // side mixer.
   audio_converter_.AddInput(this);
 }
 
 void OnMoreDataConverter::Stop() {
   CHECK(source_callback_);
   source_callback_ = nullptr;
   audio_converter_.RemoveInput(this);
 }
 
 int OnMoreDataConverter::OnMoreData(AudioBus* dest,
                                     uint32_t total_bytes_delay,
                                     uint32_t frames_skipped) {
+  TRACE_EVENT2("audio", "OnMoreDataConverter::OnMoreData", "input buffer size",

[o1ka, 2016/08/19 13:20:47]

Passing buffer sizes on each trace does not look cute, but it seems to be the
easiest and guaranteed way to get the data. Another way would be to add it to
the native log, but it requires passing log callback all the way from content.
(I'll try to come up with some more or less neat CL for that later).
Note that we can't trace it in the constructor, because at that point tracing is
usually disabled: we will ask a user to enable and record tracing when audio
glitches are observed, i.e. rendering is already ongoing.

[DaleCurtis, 2016/08/19 16:49:00]

Also is it useful to have this information? Isn't it displayed in
chrome://media-internals anyways?

+               input_buffer_size_, "output buffer size", output_buffer_size_);
   current_total_bytes_delay_ = total_bytes_delay;
   audio_converter_.Convert(dest);
 
   // Always return the full number of frames requested, ProvideInput()
   // will pad with silence if it wasn't able to acquire enough data.
   return dest->frames();
 }
 
 double OnMoreDataConverter::ProvideInput(AudioBus* dest,
                                          uint32_t frames_delayed) {
@@ skipping 14 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