1) Fixing TrackAudioRenderer::Render() to interpret the second parameters as delay in frames, not i…

content/renderer/media/track_audio_renderer.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 "content/renderer/media/track_audio_renderer.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/media_stream_audio_track.h"
+#include "content/renderer/media/webrtc_audio_renderer.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_shifter.h"
 
 namespace content {
 
 namespace {
 
 enum LocalRendererSinkStates {
   kSinkStarted = 0,
   kSinkNeverStarted,
   kSinkStatesMax  // Must always be last!
 };
 
 // Translates |num_samples_rendered| into a TimeDelta duration and adds it to
 // |prior_elapsed_render_time|.
 base::TimeDelta ComputeTotalElapsedRenderTime(
     base::TimeDelta prior_elapsed_render_time,
     int64_t num_samples_rendered,
     int sample_rate) {
   return prior_elapsed_render_time + base::TimeDelta::FromMicroseconds(
       num_samples_rendered * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
 }  // namespace
 
 // media::AudioRendererSink::RenderCallback implementation
 int TrackAudioRenderer::Render(media::AudioBus* audio_bus,
-                               uint32_t audio_delay_milliseconds,
+                               uint32_t frames_delayed,
                                uint32_t frames_skipped) {
   TRACE_EVENT0("audio", "TrackAudioRenderer::Render");
   base::AutoLock auto_lock(thread_lock_);
 
   if (!audio_shifter_) {
     audio_bus->Zero();
     return 0;
   }
 
+  // Source sample rate equals to output one, see MaybeStartSink(), so using it.
+  uint32_t audio_delay_milliseconds = static_cast<double>(frames_delayed) *
+                                      base::Time::kMillisecondsPerSecond /
+                                      source_params_.sample_rate();
+
   // TODO(miu): Plumbing is needed to determine the actual playout timestamp
   // of the audio, instead of just snapshotting TimeTicks::Now(), for proper
   // audio/video sync.  http://crbug.com/335335
   const base::TimeTicks playout_time =
       base::TimeTicks::Now() +
       base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
   DVLOG(2) << "Pulling audio out of shifter to be played "
            << audio_delay_milliseconds << " ms from now.";
   audio_shifter_->Pull(audio_bus, playout_time);
   num_samples_rendered_ += audio_bus->frames();
@@ skipping 236 matching lines @@
   const media::OutputDeviceInfo& device_info = sink_->GetOutputDeviceInfo();
   if (device_info.device_status() != media::OUTPUT_DEVICE_STATUS_OK)
     return;
 
   // Output parameters consist of the same channel layout and sample rate as the
   // source, but having the buffer duration preferred by the hardware.
   const media::AudioParameters& hardware_params = device_info.output_params();
   media::AudioParameters sink_params(
       hardware_params.format(), source_params_.channel_layout(),
       source_params_.sample_rate(), source_params_.bits_per_sample(),
-      hardware_params.frames_per_buffer() * source_params_.sample_rate() /
-          hardware_params.sample_rate());
+      WebRtcAudioRenderer::GetOptimalBufferSize(
+          source_params_.sample_rate(), hardware_params.frames_per_buffer()));
   DVLOG(1) << ("TrackAudioRenderer::MaybeStartSink() -- Starting sink.  "
                "source_params_={")
-           << source_params_.AsHumanReadableString() << "}, sink parameters={"
+           << source_params_.AsHumanReadableString() << "}, hardware_params_={"
+           << hardware_params.AsHumanReadableString() << "}, sink parameters={"
            << sink_params.AsHumanReadableString() << '}';
   sink_->Initialize(sink_params, this);
   sink_->Start();
   sink_->SetVolume(volume_);
   sink_->Play();  // Not all the sinks play on start.
   sink_started_ = true;
   if (IsLocalRenderer()) {
     UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates", kSinkStarted,
                               kSinkStatesMax);
   }
@@ skipping 51 matching lines @@
   if (source_params_.IsValid()) {
     prior_elapsed_render_time_ =
         ComputeTotalElapsedRenderTime(prior_elapsed_render_time_,
                                       num_samples_rendered_,
                                       source_params_.sample_rate());
     num_samples_rendered_ = 0;
   }
 }
 
 }  // namespace content