Add AudioBufferStream.

media/filters/audio_renderer_impl.cc

Index: media/filters/audio_renderer_impl.cc
diff --git a/media/filters/audio_renderer_impl.cc b/media/filters/audio_renderer_impl.cc
index f08ef83b418a5fb97808f973c9428ee899243817..82d887497abc66739791826928c9998ad2ea8e9a 100644
--- a/media/filters/audio_renderer_impl.cc
+++ b/media/filters/audio_renderer_impl.cc
@@ -44,8 +44,9 @@ AudioRendererImpl::AudioRendererImpl(
     : task_runner_(task_runner),
       weak_factory_(this),
       sink_(sink),
-      decoder_selector_(new AudioDecoderSelector(
-          task_runner, decoders.Pass(), set_decryptor_ready_cb)),
+      audio_buffer_stream_(task_runner,
+                           decoders.Pass(),
+                           set_decryptor_ready_cb),
       now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
       sink_playing_(false),
@@ -55,10 +56,10 @@ AudioRendererImpl::AudioRendererImpl(
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       underflow_disabled_(false),
-      preroll_aborted_(false) {
-}
+      preroll_aborted_(false) {}
 
 AudioRendererImpl::~AudioRendererImpl() {
+  base::AutoLock auto_lock(lock_);

[DaleCurtis, 2014/02/21 21:48:48]

What's this for?  To ensure outstanding calls have completed?  ARI is
ref-counted, so nothing should be in flight at destruction time.

I see VRI does this, but it also seems wrong to me there. xhwang@/scherkus@ do
you know why it's done there?

https://code.google.com/p/chromium/codesearch#chromium/src/media/filters/vide...

[rileya (GONE FROM CHROMIUM), 2014/02/21 23:04:02]

Yeah, I added this because of VRI doing it, I wasn't sure...

[xhwang, 2014/02/21 23:57:56]

Yeah, this shouldn't be necessary unless someone is holding a raw pointer to
|this|, which doesn't seem to be the case.

[rileya (GONE FROM CHROMIUM), 2014/02/24 21:04:11]

Alright, removed it. The one in VRI should probably be nuked too, but I won't
clutter this CL any more...

   // Stop() should have been called and |algorithm_| should have been destroyed.
   DCHECK(state_ == kUninitialized || state_ == kStopped);
   DCHECK(!algorithm_.get());
@@ -145,18 +146,8 @@ void AudioRendererImpl::DoFlush_Locked() {
   DCHECK(!pending_read_);
   DCHECK_EQ(state_, kPaused);
 
-  if (decrypting_demuxer_stream_) {
-    decrypting_demuxer_stream_->Reset(
-        base::Bind(&AudioRendererImpl::ResetDecoder, weak_this_));
-    return;
-  }
-
-  ResetDecoder();
-}
-
-void AudioRendererImpl::ResetDecoder() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  decoder_->Reset(base::Bind(&AudioRendererImpl::ResetDecoderDone, weak_this_));
+  audio_buffer_stream_.Reset(
+      base::Bind(&AudioRendererImpl::ResetDecoderDone, weak_this_));
 }
 
 void AudioRendererImpl::ResetDecoderDone() {
@@ -194,10 +185,6 @@ void AudioRendererImpl::Stop(const base::Closure& callback) {
 
   {
     base::AutoLock auto_lock(lock_);
-    if (state_ == kInitializing) {
-      decoder_selector_->Abort();
-      return;
-    }
 
     if (state_ == kStopped) {
       task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&stop_cb_));
@@ -216,12 +203,7 @@ void AudioRendererImpl::Stop(const base::Closure& callback) {
     sink_ = NULL;
   }
 
-  if (decoder_) {
-    decoder_->Stop(base::ResetAndReturn(&stop_cb_));
-    return;
-  }
-
-  task_runner_->PostTask(FROM_HERE, base::ResetAndReturn(&stop_cb_));
+  audio_buffer_stream_.Stop(base::ResetAndReturn(&stop_cb_));
 }
 
 void AudioRendererImpl::Preroll(base::TimeDelta time,
@@ -266,53 +248,45 @@ void AudioRendererImpl::Initialize(DemuxerStream* stream,
 
   weak_this_ = weak_factory_.GetWeakPtr();
   init_cb_ = init_cb;
-  statistics_cb_ = statistics_cb;
   underflow_cb_ = underflow_cb;
   time_cb_ = time_cb;
   ended_cb_ = ended_cb;
   disabled_cb_ = disabled_cb;
   error_cb_ = error_cb;
 
-  decoder_selector_->SelectDecoder(
+  audio_buffer_stream_.Initialize(
       stream,
       statistics_cb,
-      base::Bind(&AudioRendererImpl::OnDecoderSelected, weak_this_));
+      base::Bind(&AudioRendererImpl::OnAudioBufferStreamInitialized,
+                 weak_this_));
 }
 
-void AudioRendererImpl::OnDecoderSelected(
-    scoped_ptr<AudioDecoder> decoder,
-    scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
+void AudioRendererImpl::OnAudioBufferStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
-  scoped_ptr<AudioDecoderSelector> deleter(decoder_selector_.Pass());
 
-  if (!decoder) {
-    {
-      base::AutoLock auto_lock(lock_);
-      ChangeState_Locked(kUninitialized);
-    }
-    // Stop() called during initialization.
-    if (!stop_cb_.is_null()) {
-      base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
-      Stop(base::ResetAndReturn(&stop_cb_));
-    } else {
-      base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
-    }
+  base::AutoLock auto_lock(lock_);
+
+  if (!success) {
+    state_ = kUninitialized;
+    base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  base::AutoLock auto_lock(lock_);
-  decoder_ = decoder.Pass();
-  decrypting_demuxer_stream_ = decrypting_demuxer_stream.Pass();
-
-  int sample_rate = decoder_->samples_per_second();
+  int sample_rate = audio_buffer_stream_.decoder()->samples_per_second();
 
   // The actual buffer size is controlled via the size of the AudioBus
   // provided to Render(), so just choose something reasonable here for looks.
-  int buffer_size = decoder_->samples_per_second() / 100;
-  audio_parameters_ = AudioParameters(
-      AudioParameters::AUDIO_PCM_LOW_LATENCY, decoder_->channel_layout(),
-      sample_rate, decoder_->bits_per_channel(), buffer_size);
+  int buffer_size = audio_buffer_stream_.decoder()->samples_per_second() / 100;
+
+  // TODO(rileya): Remove the channel_layout/bits_per_channel/samples_per_second
+  // getters from AudioDecoder, and adjust this accordingly.

[rileya (GONE FROM CHROMIUM), 2014/02/19 22:37:51]

This will require some plumbing that's beyond the scope of this already
large-ish CL... we'll also need to properly update the |algorithm_| upon config
changes.

[DaleCurtis, 2014/02/21 21:48:48]

My plan was for ARI and ARA to be agnostic to config changes, the resampling and
channel remixing will happen in some wrapper around AudioBuffers received from
the AudioBufferStream.  We can discuss more offline.

+  audio_parameters_ =
+      AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                      audio_buffer_stream_.decoder()->channel_layout(),
+                      sample_rate,
+                      audio_buffer_stream_.decoder()->bits_per_channel(),
+                      buffer_size);
   if (!audio_parameters_.IsValid()) {
     ChangeState_Locked(kUninitialized);
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
@@ -368,7 +342,7 @@ void AudioRendererImpl::SetVolume(float volume) {
 }
 
 void AudioRendererImpl::DecodedAudioReady(
-    AudioDecoder::Status status,
+    AudioBufferStream::Status status,
     const scoped_refptr<AudioBuffer>& buffer) {
   DVLOG(1) << __FUNCTION__ << "(" << status << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ -379,17 +353,18 @@ void AudioRendererImpl::DecodedAudioReady(
   CHECK(pending_read_);
   pending_read_ = false;
 
-  if (status == AudioDecoder::kAborted) {
+  if (status == AudioBufferStream::ABORTED ||
+      status == AudioBufferStream::DEMUXER_READ_ABORTED) {
     HandleAbortedReadOrDecodeError(false);
     return;
   }
 
-  if (status == AudioDecoder::kDecodeError) {
+  if (status == AudioBufferStream::DECODE_ERROR) {
     HandleAbortedReadOrDecodeError(true);
     return;
   }
 
-  DCHECK_EQ(status, AudioDecoder::kOk);
+  DCHECK_EQ(status, AudioBufferStream::OK);
   DCHECK(buffer.get());
 
   if (state_ == kFlushing) {
@@ -496,7 +471,8 @@ void AudioRendererImpl::AttemptRead_Locked() {
     return;
 
   pending_read_ = true;
-  decoder_->Read(base::Bind(&AudioRendererImpl::DecodedAudioReady, weak_this_));
+  audio_buffer_stream_.Read(
+      base::Bind(&AudioRendererImpl::DecodedAudioReady, weak_this_));
 }
 
 bool AudioRendererImpl::CanRead_Locked() {