Move bulk of media::AudioRendererImpl::Render() logic to media thread.

media/filters/audio_renderer_impl.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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
+#include "base/time/default_tick_clock.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_buffer_converter.h"
 #include "media/base/audio_hardware_config.h"
 #include "media/base/audio_splicer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/filters/audio_clock.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 
 namespace media {
 
 namespace {
 
 enum AudioRendererEvent {
   INITIALIZED,
   RENDER_ERROR,
   RENDER_EVENT_MAX = RENDER_ERROR,
 };
 
 void HistogramRendererEvent(AudioRendererEvent event) {
   UMA_HISTOGRAM_ENUMERATION(
       "Media.AudioRendererEvents", event, RENDER_EVENT_MAX + 1);
 }
 
 }  // namespace
 
+AudioRendererImpl::RenderResult::RenderResult()
+    : requested_frames(0),
+      delay_frames(0),
+      frames_written(0),
+      playback_rate(0),
+      endpoint_timestamp(kNoTimestamp()) {
+}
+
 AudioRendererImpl::AudioRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     AudioHardwareConfig* hardware_config)
     : task_runner_(task_runner),
       sink_(sink),
       audio_buffer_stream_(task_runner,
                            decoders.Pass(),
                            set_decryptor_ready_cb),
       hardware_config_(hardware_config),
-      now_cb_(base::Bind(&base::TimeTicks::Now)),
+      tick_clock_(new base::DefaultTickClock()),
       state_(kUninitialized),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       rendering_(false),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       weak_factory_(this) {
   audio_buffer_stream_.set_splice_observer(base::Bind(
       &AudioRendererImpl::OnNewSpliceBuffer, weak_factory_.GetWeakPtr()));
@@ skipping 103 matching lines @@
 
     DCHECK_EQ(state_, kFlushed);
     DCHECK(!flush_cb_.is_null());
 
     audio_clock_.reset(new AudioClock(audio_parameters_.sample_rate()));
     received_end_of_stream_ = false;
     rendered_end_of_stream_ = false;
 
     // Flush() may have been called while underflowed/not fully buffered.
     if (buffering_state_ != BUFFERING_HAVE_NOTHING)
-      SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
+      SetBufferingState(BUFFERING_HAVE_NOTHING);
 
     splicer_->Reset();
     if (buffer_converter_)
       buffer_converter_->Reset();
     algorithm_->FlushBuffers();
   }
 
   // Changes in buffering state are always posted. Flush callback must only be
   // run after buffering state has been set back to nothing.
   task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&flush_cb_));
@@ skipping 163 matching lines @@
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void AudioRendererImpl::SetVolume(float volume) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(sink_);
   sink_->SetVolume(volume);
 }
 
+void AudioRendererImpl::SetTickClockForTesting(
+    scoped_ptr<base::TickClock> tick_clock) {
+  tick_clock_.swap(tick_clock);
+}
+
 void AudioRendererImpl::DecodedAudioReady(
     AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
   DVLOG(2) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized);
 
   CHECK(pending_read_);
@@ skipping 37 matching lines @@
 
   if (!splicer_->HasNextBuffer()) {
     AttemptRead_Locked();
     return;
   }
 
   bool need_another_buffer = false;
   while (splicer_->HasNextBuffer())
     need_another_buffer = HandleSplicerBuffer_Locked(splicer_->GetNextBuffer());
 
-  if (!need_another_buffer && !CanRead_Locked())
+  if (!need_another_buffer)
     return;
 
   AttemptRead_Locked();
 }
 
 bool AudioRendererImpl::HandleSplicerBuffer_Locked(
     const scoped_refptr<AudioBuffer>& buffer) {
   lock_.AssertAcquired();
   if (buffer->end_of_stream()) {
     received_end_of_stream_ = true;
@@ skipping 25 matching lines @@
       NOTREACHED();
       return false;
 
     case kFlushed:
       DCHECK(!pending_read_);
       return false;
 
     case kPlaying:
       if (buffer->end_of_stream() || algorithm_->IsQueueFull()) {
         if (buffering_state_ == BUFFERING_HAVE_NOTHING)
-          SetBufferingState_Locked(BUFFERING_HAVE_ENOUGH);
+          SetBufferingState(BUFFERING_HAVE_ENOUGH);
         return false;
       }
       return true;
 
     case kStopped:
       return false;
   }
   return false;
 }
 
-void AudioRendererImpl::AttemptRead() {
-  base::AutoLock auto_lock(lock_);
-  AttemptRead_Locked();
-}
-
 void AudioRendererImpl::AttemptRead_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
-  if (!CanRead_Locked())
-    return;
-
-  pending_read_ = true;
-  audio_buffer_stream_.Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
-                                       weak_factory_.GetWeakPtr()));
-}
-
-bool AudioRendererImpl::CanRead_Locked() {
-  lock_.AssertAcquired();
-
   switch (state_) {
     case kUninitialized:
     case kInitializing:
     case kFlushing:
     case kFlushed:
     case kStopped:
-      return false;
+      return;
 
     case kPlaying:
       break;
   }
 
-  return !pending_read_ && !received_end_of_stream_ &&
-      !algorithm_->IsQueueFull();
+  if (pending_read_ || received_end_of_stream_ || algorithm_->IsQueueFull())
+    return;
+
+  pending_read_ = true;
+  audio_buffer_stream_.Read(base::Bind(&AudioRendererImpl::DecodedAudioReady,
+                                       weak_factory_.GetWeakPtr()));
 }
 
 void AudioRendererImpl::SetPlaybackRate(float playback_rate) {
   DVLOG(1) << __FUNCTION__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_GE(playback_rate, 0);
   DCHECK(sink_);
 
   base::AutoLock auto_lock(lock_);
 
@@ skipping 19 matching lines @@
 
 bool AudioRendererImpl::IsBeforeStartTime(
     const scoped_refptr<AudioBuffer>& buffer) {
   DCHECK_EQ(state_, kPlaying);
   return buffer && !buffer->end_of_stream() &&
          (buffer->timestamp() + buffer->duration()) < start_timestamp_;
 }
 
 int AudioRendererImpl::Render(AudioBus* audio_bus,
                               int audio_delay_milliseconds) {
-  const int requested_frames = audio_bus->frames();
-  base::TimeDelta playback_delay = base::TimeDelta::FromMilliseconds(
-      audio_delay_milliseconds);
-  const int delay_frames = static_cast<int>(playback_delay.InSecondsF() *
-                                            audio_parameters_.sample_rate());
-  int frames_written = 0;
-  base::Closure time_cb;
+  DVLOG(2) << __FUNCTION__;
+  base::TimeDelta playback_delay =
+      base::TimeDelta::FromMilliseconds(audio_delay_milliseconds);
+
+  RenderResult result;
+  result.ticks = tick_clock_->NowTicks();
+  result.requested_frames = audio_bus->frames();
+  result.delay_frames = static_cast<int>(playback_delay.InSecondsF() *
+                                         audio_parameters_.sample_rate());
+
   {
     base::AutoLock auto_lock(lock_);
-
-    // Ensure Stop() hasn't destroyed our |algorithm_| on the pipeline thread.
-    if (!algorithm_) {
-      audio_clock_->WroteSilence(requested_frames, delay_frames);
-      return 0;
-    }
-
-    float playback_rate = algorithm_->playback_rate();
-    if (playback_rate == 0) {
-      audio_clock_->WroteSilence(requested_frames, delay_frames);
-      return 0;
-    }
-
-    // Mute audio by returning 0 when not playing.
-    if (state_ != kPlaying) {
-      audio_clock_->WroteSilence(requested_frames, delay_frames);
-      return 0;
-    }
-
-    // We use the following conditions to determine end of playback:
-    //   1) Algorithm can not fill the audio callback buffer
-    //   2) We received an end of stream buffer
-    //   3) We haven't already signalled that we've ended
-    //   4) We've played all known audio data sent to hardware
-    //
-    // We use the following conditions to determine underflow:
-    //   1) Algorithm can not fill the audio callback buffer
-    //   2) We have NOT received an end of stream buffer
-    //   3) We are in the kPlaying state
-    //
-    // Otherwise the buffer has data we can send to the device.
-    const base::TimeDelta media_timestamp_before_filling =
-        audio_clock_->CurrentMediaTimestamp(base::TimeDelta());
-    if (algorithm_->frames_buffered() > 0) {
-      frames_written = algorithm_->FillBuffer(audio_bus, requested_frames);
-      audio_clock_->WroteAudio(
-          frames_written, delay_frames, playback_rate, algorithm_->GetTime());
-    }
-    audio_clock_->WroteSilence(requested_frames - frames_written, delay_frames);
-
-    if (frames_written == 0) {
-      if (received_end_of_stream_ && !rendered_end_of_stream_ &&
-          audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) ==
-              audio_clock_->last_endpoint_timestamp()) {
-        rendered_end_of_stream_ = true;
-        ended_cb_.Run();
-      } else if (!received_end_of_stream_ && state_ == kPlaying) {
-        if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
-          algorithm_->IncreaseQueueCapacity();
-          SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
-        }
-      }
-    }
-
-    if (CanRead_Locked()) {
-      task_runner_->PostTask(FROM_HERE,
-                             base::Bind(&AudioRendererImpl::AttemptRead,
-                                        weak_factory_.GetWeakPtr()));
-    }
-
-    // We only want to execute |time_cb_| if time has progressed and we haven't
-    // signaled end of stream yet.
-    if (media_timestamp_before_filling !=
-            audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) &&
-        !rendered_end_of_stream_) {
-      time_cb =
-          base::Bind(time_cb_,
-                     audio_clock_->CurrentMediaTimestamp(base::TimeDelta()),
-                     audio_clock_->last_endpoint_timestamp());
+    if (state_ == kPlaying && algorithm_->frames_buffered() > 0) {
+      result.frames_written =
+          algorithm_->FillBuffer(audio_bus, result.requested_frames);
+      result.playback_rate = algorithm_->playback_rate();
+      result.endpoint_timestamp = algorithm_->GetTime();
     }
   }
 
-  if (!time_cb.is_null())
-    task_runner_->PostTask(FROM_HERE, time_cb);
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &AudioRendererImpl::DidRender, weak_factory_.GetWeakPtr(), result));
 
-  DCHECK_LE(frames_written, requested_frames);
-  return frames_written;
+  return result.frames_written;
+}
+
+void AudioRendererImpl::DidRender(RenderResult result) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DVLOG(2) << __FUNCTION__;
+
+  base::AutoLock auto_lock(lock_);
+  if (state_ == kStopped)
+    return;
+
+  if (result.frames_written > 0) {
+    audio_clock_->WroteAudio(result.frames_written,
+                             result.delay_frames,
+                             result.playback_rate,
+                             result.endpoint_timestamp);
+  }
+  audio_clock_->WroteSilence(result.requested_frames - result.frames_written,
+                             result.delay_frames);
+
+  // We use the following conditions to determine end of playback:
+  //   1) Algorithm can not fill the audio callback buffer
+  //   2) We received an end of stream buffer
+  //   3) We haven't already signalled that we've ended
+  //   4) We've played all known audio data sent to hardware
+  //
+  // We use the following conditions to determine underflow:
+  //   1) Algorithm can not fill the audio callback buffer
+  //   2) We have NOT received an end of stream buffer
+  //   3) We are in the kPlaying state
+  if (result.frames_written == 0) {
+    if (received_end_of_stream_ && !rendered_end_of_stream_ &&
+        audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) ==

[DaleCurtis, 2014/07/15 19:25:28]

Shouldn't this be using the time since writing?

[scherkus (not reviewing), 2014/07/15 20:14:22]

Maybe ... I'm still thinking what the right option is.

Using zero means we'll signal ended when there is no audio left in the hardware.

Using time_since_writing could make it so that we signal sooner than needed.


I suspect using time_since_writing should be fine, but I'll do some testing.

+            audio_clock_->last_endpoint_timestamp()) {
+      rendered_end_of_stream_ = true;
+      ended_cb_.Run();
+    } else if (!received_end_of_stream_ && state_ == kPlaying) {
+      if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
+        algorithm_->IncreaseQueueCapacity();
+        SetBufferingState(BUFFERING_HAVE_NOTHING);
+      }
+    }
+  }
+
+  // Use adjusted media timestamp that takes time since writing into account.
+  if (!rendered_end_of_stream_) {
+    base::TimeDelta time_since_writing = tick_clock_->NowTicks() - result.ticks;
+    time_cb_.Run(audio_clock_->CurrentMediaTimestamp(time_since_writing),
+                 audio_clock_->last_endpoint_timestamp());
+  }
+
+  AttemptRead_Locked();
 }
 
 void AudioRendererImpl::OnRenderError() {
   // UMA data tells us this happens ~0.01% of the time. Trigger an error instead
   // of trying to gracefully fall back to a fake sink. It's very likely
   // OnRenderError() should be removed and the audio stack handle errors without
   // notifying clients. See http://crbug.com/234708 for details.
   HistogramRendererEvent(RENDER_ERROR);
   error_cb_.Run(PIPELINE_ERROR_DECODE);
 }
@@ skipping 42 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(expecting_config_changes_);
   buffer_converter_->ResetTimestampState();
   // Drain flushed buffers from the converter so the AudioSplicer receives all
   // data ahead of any OnNewSpliceBuffer() calls.  Since discontinuities should
   // only appear after config changes, AddInput() should never fail here.
   while (buffer_converter_->HasNextBuffer())
     CHECK(splicer_->AddInput(buffer_converter_->GetNextBuffer()));
 }
 
-void AudioRendererImpl::SetBufferingState_Locked(
-    BufferingState buffering_state) {
+void AudioRendererImpl::SetBufferingState(BufferingState buffering_state) {
   DVLOG(1) << __FUNCTION__ << " : " << buffering_state_ << " -> "
            << buffering_state;
+  DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_NE(buffering_state_, buffering_state);
-  lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media