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(

[henrika (OOO until Aug 14), 2015/01/21 08:54:38]

What effect does the provided time value have here?

[hubbe, 2015/01/23 00:54:56]

The audio shifter tries to provide audio for the given timestamp.
There is a fair amount of comments in audio_shifter.h, but the gist of
it is that Push() can specify exactly when a piece of audio should be played,
and Pull() can specify when it intends to play the pulled audio and audio
shifter will take care of doing the right amount of buffering/stretching.

If Push() uses timestamps that are int he past, audio shifter tries to use the
smallest amount of buffering it can that will still result in smooth playout.

+      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());
+    media::AudioShifter* const new_shifter = new media::AudioShifter(

[henrika (OOO until Aug 14), 2015/01/21 08:54:38]

It is not clear to me why you use 2 and 20 here. Care to comment about who they
were selected?

[hubbe, 2015/01/23 00:54:56]

2 was selected because we need at least 1 second for cast.
Note that if push timestamps are in the past, a minimal buffer
will be used regardless of this argument

The 20 millseconds comes from the fact that windows clocks tend to have a 15
millsecond accuracy.

(Comment added)

+        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