Use audio shifter instead of a fifo for local mediastream playback.

content/renderer/media/webrtc_local_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/webrtc_local_audio_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/webrtc_audio_capturer.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "content/renderer/render_frame_impl.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_bus.h"
-#include "media/base/audio_fifo.h"
+#include "media/base/audio_shifter.h"
 
 namespace content {
 
 namespace {
 
 enum LocalRendererSinkStates {
   kSinkStarted = 0,
   kSinkNeverStarted,
   kSinkStatesMax  // Must always be last!
 };
 
 }  // namespace
 
 // media::AudioRendererSink::RenderCallback implementation
 int WebRtcLocalAudioRenderer::Render(
     media::AudioBus* audio_bus, int audio_delay_milliseconds) {
   TRACE_EVENT0("audio", "WebRtcLocalAudioRenderer::Render");
   base::AutoLock auto_lock(thread_lock_);
 
-  if (!playing_ || !volume_ || !loopback_fifo_) {
+  if (!playing_ || !volume_ || !audio_shifter_) {
     audio_bus->Zero();
     return 0;
   }
 
-  // Provide data by reading from the FIFO if the FIFO contains enough
-  // to fulfill the request.
-  if (loopback_fifo_->frames() >= audio_bus->frames()) {
-    loopback_fifo_->Consume(audio_bus, 0, audio_bus->frames());
-  } else {
-    audio_bus->Zero();
-    // This warning is perfectly safe if it happens for the first audio
-    // frames. It should not happen in a steady-state mode.
-    DVLOG(2) << "loopback FIFO is not full enough yet";
-  }
+  audio_shifter_->Pull(
+      audio_bus,
+      base::TimeTicks::Now() -
+      base::TimeDelta::FromMilliseconds(audio_delay_milliseconds));
 
   return audio_bus->frames();
 }
 
 void WebRtcLocalAudioRenderer::OnRenderError() {
   NOTIMPLEMENTED();
 }
 
 // content::MediaStreamAudioSink implementation
 void WebRtcLocalAudioRenderer::OnData(const media::AudioBus& audio_bus,
                                       base::TimeTicks estimated_capture_time) {
   DCHECK(capture_thread_checker_.CalledOnValidThread());
   DCHECK(!estimated_capture_time.is_null());
 
   TRACE_EVENT0("audio", "WebRtcLocalAudioRenderer::CaptureData");
 
   base::AutoLock auto_lock(thread_lock_);
-  if (!playing_ || !volume_ || !loopback_fifo_)
+  if (!playing_ || !volume_ || !audio_shifter_)
     return;
 
-  // Push captured audio to FIFO so it can be read by a local sink.
-  if ((loopback_fifo_->frames() + audio_bus.frames()) <=
-          loopback_fifo_->max_frames()) {
-    // TODO(miu): Make sure the Render() method accounts for time shifting
-    // appropriately, per the comments for the usage of the
-    // |estimated_capture_time| field found in media_stream_audio_sink.h.
-    // http://crbug.com/437064
-    loopback_fifo_->Push(&audio_bus);
-
-    const base::TimeTicks now = base::TimeTicks::Now();
-    total_render_time_ += now - last_render_time_;
-    last_render_time_ = now;
-  } else {
-    DVLOG(1) << "FIFO is full";
-  }
+  scoped_ptr<media::AudioBus> audio_data(
+      media::AudioBus::Create(audio_bus.channels(), audio_bus.frames()));
+  audio_bus.CopyTo(audio_data.get());
+  audio_shifter_->Push(audio_data.Pass(), estimated_capture_time);
+  const base::TimeTicks now = base::TimeTicks::Now();
+  total_render_time_ += now - last_render_time_;
+  last_render_time_ = now;
 }
 
 void WebRtcLocalAudioRenderer::OnSetFormat(
     const media::AudioParameters& params) {
   DVLOG(1) << "WebRtcLocalAudioRenderer::OnSetFormat()";
   // If the source is restarted, we might have changed to another capture
   // thread.
   capture_thread_checker_.DetachFromThread();
   DCHECK(capture_thread_checker_.CalledOnValidThread());
 
@@ skipping 46 matching lines @@
   playing_ = false;
 }
 
 void WebRtcLocalAudioRenderer::Stop() {
   DVLOG(1) << "WebRtcLocalAudioRenderer::Stop()";
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   {
     base::AutoLock auto_lock(thread_lock_);
     playing_ = false;
-    loopback_fifo_.reset();
+    audio_shifter_.reset();
   }
 
   // Stop the output audio stream, i.e, stop asking for data to render.
   // It is safer to call Stop() on the |sink_| to clean up the resources even
   // when the |sink_| is never started.
   if (sink_.get()) {
     sink_->Stop();
     sink_ = NULL;
   }
 
@@ skipping 73 matching lines @@
 void WebRtcLocalAudioRenderer::MaybeStartSink() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink()";
 
   if (!sink_.get() || !source_params_.IsValid())
     return;
 
   {
     // Clear up the old data in the FIFO.
     base::AutoLock auto_lock(thread_lock_);
-    loopback_fifo_->Clear();
+    audio_shifter_->Flush();
   }
 
   if (!sink_params_.IsValid() || !playing_ || !volume_ || sink_started_)
     return;
 
   DVLOG(1) << "WebRtcLocalAudioRenderer::MaybeStartSink() -- Starting sink_.";
   sink_->InitializeWithSessionId(sink_params_, this, session_id_);
   sink_->Start();
   sink_started_ = true;
   UMA_HISTOGRAM_ENUMERATION("Media.LocalRendererSinkStates",
@@ skipping 29 matching lines @@
   sink_params_ = media::AudioParameters(source_params_.format(),
       source_params_.channel_layout(), source_params_.sample_rate(),
       source_params_.bits_per_sample(),
       WebRtcAudioRenderer::GetOptimalBufferSize(source_params_.sample_rate(),
                                                 frames_per_buffer_),
       // If DUCKING is enabled on the source, it needs to be enabled on the
       // sink as well.
       source_params_.effects() | implicit_ducking_effect);
 
   {
-    // TODO(henrika): we could add a more dynamic solution here but I prefer
-    // a fixed size combined with bad audio at overflow. The alternative is
-    // that we start to build up latency and that can be more difficult to
-    // detect. Tests have shown that the FIFO never contains more than 2 or 3
-    // audio frames but I have selected a max size of ten buffers just
-    // in case since these tests were performed on a 16 core, 64GB Win 7
-    // machine. We could also add some sort of error notifier in this area if
-    // the FIFO overflows.
-    media::AudioFifo* const new_fifo = new media::AudioFifo(
-        params.channels(), 10 * params.frames_per_buffer());
+    // Note: The max buffer is fairly large, but will rarely be used.
+    // Cast needs the buffer to hold at least one second of audio.
+    // The clock accuracy is set to 20ms because clock accuracy is
+    // ~15ms on windows.
+    media::AudioShifter* const new_shifter = new media::AudioShifter(
+        base::TimeDelta::FromSeconds(2),
+        base::TimeDelta::FromMilliseconds(20),
+        base::TimeDelta::FromSeconds(20),
+        source_params_.sample_rate(),
+        params.channels());
 
     base::AutoLock auto_lock(thread_lock_);
-    loopback_fifo_.reset(new_fifo);
+    audio_shifter_.reset(new_shifter);
   }
 
   if (!sink_.get())
     return;  // WebRtcLocalAudioRenderer has not yet been started.
 
   // Stop |sink_| and re-create a new one to be initialized with different audio
   // parameters.  Then, invoke MaybeStartSink() to restart everything again.
   if (sink_started_) {
     sink_->Stop();
     sink_started_ = false;
   }
 
   sink_ = AudioDeviceFactory::NewOutputDevice(source_render_view_id_,
                                               source_render_frame_id_);
   MaybeStartSink();
 }
 
 }  // namespace content