Move audio decoder initialization to AudioRendererImpl.

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 "media/audio/audio_util.h"
+#include "media/base/demuxer_stream.h"
 
 namespace media {
 
 AudioRendererImpl::AudioRendererImpl(media::AudioRendererSink* sink)
     : state_(kUninitialized),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
@@ skipping 52 matching lines @@
 void AudioRendererImpl::DoPause() {
   DCHECK(sink_.get());
   sink_->Pause(false);
 }
 
 void AudioRendererImpl::Flush(const base::Closure& callback) {
   decoder_->Reset(callback);
 }
 
 void AudioRendererImpl::Stop(const base::Closure& callback) {
+  DCHECK(!callback.is_null());
+
   if (!stopped_) {
     DCHECK(sink_.get());
     sink_->Stop();
 
     stopped_ = true;
   }
   {
     base::AutoLock auto_lock(lock_);
     state_ = kStopped;
     algorithm_.reset(NULL);
+    init_cb_.Reset();
+    underflow_cb_.Reset();
     time_cb_.Reset();
-    underflow_cb_.Reset();
   }
-  if (!callback.is_null()) {
-    callback.Run();
-  }
+
+  callback.Run();

[xhwang, 2012/10/15 22:52:23]

I found AudioDecoder doesn't have a Stop() method. So we don't need to stop the
audio decoder anywhere during teardown? What if the audio decoder has a pending
demuxer read? Are we relying on the fact that the demuxer is shut down before we
stopping the audio renderer? Or are we relying on the fact that AudioDecoder is
ref-counted, so the audio decoder will not be destroyed before all pending
callbacks are executed. When we add DecryptingAudioDecoder later, it will not
only has pending demuxer reads, but also has pending decrypt callbacks. I need
to make sure everything still work :)

[acolwell GONE FROM CHROMIUM, 2012/10/16 16:23:38]

I was a little surprised to see that the decode interface didn't have a Stop()
method myself. I believe this code is relying on the fact that the demuxer is
stopped before the renderer is and when that Stop() happens, the pending reads
are cancelled. By the time this Stop() call happens I believe there shouldn't be
any reads pending or if there are they will have kAborted status.

 }
 
 void AudioRendererImpl::Preroll(base::TimeDelta time,
                                 const PipelineStatusCB& cb) {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK(!pending_read_) << "Pending read must complete before seeking";
   DCHECK(pause_cb_.is_null());
   DCHECK(preroll_cb_.is_null());
   state_ = kPrerolling;
@@ skipping 11 matching lines @@
   algorithm_->FlushBuffers();
 
   if (stopped_)
     return;
 
   // Pause and flush the stream when we preroll to a new location.
   earliest_end_time_ = base::Time::Now();
   sink_->Pause(true);
 }
 
-void AudioRendererImpl::Initialize(const scoped_refptr<AudioDecoder>& decoder,
+void AudioRendererImpl::Initialize(const scoped_refptr<DemuxerStream>& stream,
+                                   const AudioDecoderList& decoders,
                                    const PipelineStatusCB& init_cb,
+                                   const StatisticsCB& statistics_cb,
                                    const base::Closure& underflow_cb,
                                    const TimeCB& time_cb,
                                    const base::Closure& ended_cb,
                                    const base::Closure& disabled_cb,
                                    const PipelineStatusCB& error_cb) {
-  DCHECK(decoder);
+  base::AutoLock auto_lock(lock_);
+  DCHECK(stream);
+  DCHECK(!decoders.empty());
+  DCHECK_EQ(stream->type(), DemuxerStream::AUDIO);
   DCHECK(!init_cb.is_null());
   DCHECK(!underflow_cb.is_null());
   DCHECK(!time_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!disabled_cb.is_null());
   DCHECK(!error_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
-  decoder_ = decoder;
+
+  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;
 
+  scoped_ptr<AudioDecoderList> decoder_list(new AudioDecoderList(decoders));
+  InitializeNextDecoder(stream, decoder_list.Pass());
+}
+
+void AudioRendererImpl::InitializeNextDecoder(
+    const scoped_refptr<DemuxerStream>& demuxer_stream,
+    scoped_ptr<AudioDecoderList> decoders) {
+  lock_.AssertAcquired();
+  DCHECK(!decoders->empty());
+
+  scoped_refptr<AudioDecoder> decoder = decoders->front();
+  decoders->pop_front();
+
+  DCHECK(decoder);
+  decoder_ = decoder;
+
+  base::AutoUnlock auto_unlock(lock_);
+  decoder->Initialize(
+      demuxer_stream,
+      base::Bind(&AudioRendererImpl::OnDecoderInitDone, this,
+                 demuxer_stream,
+                 base::Passed(&decoders)),
+      statistics_cb_);
+}
+
+void AudioRendererImpl::OnDecoderInitDone(
+    const scoped_refptr<DemuxerStream>& demuxer_stream,
+    scoped_ptr<AudioDecoderList> decoders,
+    PipelineStatus status) {
+  base::AutoLock auto_lock(lock_);
+
+  if (state_ == kStopped)

[scherkus (not reviewing), 2012/10/18 00:30:28]

also check stopped_?

[xhwang, 2012/10/18 01:35:02]

Done.

+    return;
+
+  if (!decoders->empty() && status == DECODER_ERROR_NOT_SUPPORTED) {
+    InitializeNextDecoder(demuxer_stream, decoders.Pass());
+    return;
+  }
+
+  if (status != PIPELINE_OK) {
+    base::ResetAndReturn(&init_cb_).Run(status);
+    return;
+  }
+
   // Create a callback so our algorithm can request more reads.
   base::Closure cb = base::Bind(&AudioRendererImpl::ScheduleRead_Locked, this);
 
   // Construct the algorithm.
   algorithm_.reset(new AudioRendererAlgorithm());
 
   // Initialize our algorithm with media properties, initial playback rate,
   // and a callback to request more reads from the data source.
   ChannelLayout channel_layout = decoder_->channel_layout();
   int channels = ChannelLayoutToChannelCount(channel_layout);
   int bits_per_channel = decoder_->bits_per_channel();
   int sample_rate = decoder_->samples_per_second();
   // TODO(vrk): Add method to AudioDecoder to compute bytes per frame.
   bytes_per_frame_ = channels * bits_per_channel / 8;
 
   bool config_ok = algorithm_->ValidateConfig(channels, sample_rate,
                                               bits_per_channel);
   if (!config_ok || is_initialized_) {
-    init_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
   if (config_ok)
     algorithm_->Initialize(channels, sample_rate, bits_per_channel, 0.0f, cb);
 
   // We use the AUDIO_PCM_LINEAR flag because AUDIO_PCM_LOW_LATENCY
   // does not currently support all the sample-rates that we require.
   // Please see: http://code.google.com/p/chromium/issues/detail?id=103627
   // for more details.
   audio_parameters_ = AudioParameters(
       AudioParameters::AUDIO_PCM_LINEAR, channel_layout, sample_rate,
       bits_per_channel, GetHighLatencyOutputBufferSize(sample_rate));
 
   bytes_per_second_ = audio_parameters_.GetBytesPerSecond();
 
   DCHECK(sink_.get());
   DCHECK(!is_initialized_);
 
   sink_->Initialize(audio_parameters_, this);
 
   sink_->Start();
   is_initialized_ = true;
 
   // Finally, execute the start callback.
   state_ = kPaused;
-  init_cb.Run(PIPELINE_OK);
+  base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void AudioRendererImpl::ResumeAfterUnderflow(bool buffer_more_audio) {
   base::AutoLock auto_lock(lock_);
   if (state_ == kUnderflow) {
     // The "&& preroll_aborted_" is a hack. If preroll is aborted, then we
     // shouldn't even reach the kUnderflow state to begin with. But for now
     // we're just making sure that the audio buffer capacity (i.e. the
     // number of bytes that need to be buffered for preroll to complete)
     // does not increase due to an aborted preroll.
@@ skipping 315 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media