Move VideoDecoder initialization into VideoRendererBase.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 43 matching lines @@
   while (!notified_)
     cv_.Wait();
 }
 
 media::PipelineStatus PipelineStatusNotification::status() {
   base::AutoLock auto_lock(lock_);
   DCHECK(notified_);
   return status_;
 }
 
 struct Pipeline::PipelineInitState {

[Ami GONE FROM CHROMIUM, 2012/08/09 20:30:18]

drop this struct now (and bind the audio decoder into the callback for the
renderer)?

[acolwell GONE FROM CHROMIUM, 2012/08/09 22:23:32]

I can't really do this w/o moving the kInitAudioDecoder block in
InitializeTask() out into a separate method. This may be moot once scherkus@
collapses init into one of his handy callback sequences. 

Another option is to defer this to another CL where I move AudioDecoder init
into AudioRendererImpl. That would likely need to happen anyway for supporting
audio decoder config changes.

   scoped_refptr<AudioDecoder> audio_decoder;
-  scoped_refptr<VideoDecoder> video_decoder;
 };
 
 Pipeline::Pipeline(MessageLoop* message_loop, MediaLog* media_log)
     : message_loop_(message_loop->message_loop_proxy()),
       media_log_(media_log),
       running_(false),
       seek_pending_(false),
       stop_pending_(false),
       tearing_down_(false),
       error_caused_teardown_(false),
@@ skipping 525 matching lines @@
 // FilterHost's InitializationComplete() method, the pipeline will update its
 // state to kStarted and |init_cb_|, will be executed.
 //
 // TODO(hclam): InitializeTask() is now starting the pipeline asynchronously. It
 // works like a big state change table. If we no longer need to start filters
 // in order, we need to get rid of all the state change.
 void Pipeline::InitializeTask(PipelineStatus last_stage_status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   if (last_stage_status != PIPELINE_OK) {
-    // Currently only VideoDecoders have a recoverable error code.
-    if (state_ == kInitVideoDecoder &&
-        last_stage_status == DECODER_ERROR_NOT_SUPPORTED) {
-      state_ = kInitAudioRenderer;
-    } else {
-      SetError(last_stage_status);
-      return;
-    }
+    SetError(last_stage_status);
+    return;
   }
 
   // If we have received the stop or error signal, return immediately.
   if (IsPipelineStopPending() || IsPipelineStopped() || !IsPipelineOk())
     return;
 
   DCHECK(state_ == kInitDemuxer ||
          state_ == kInitAudioDecoder ||
          state_ == kInitAudioRenderer ||
-         state_ == kInitVideoDecoder ||
          state_ == kInitVideoRenderer);
 
   // Demuxer created, create audio decoder.
   if (state_ == kInitDemuxer) {
     SetState(kInitAudioDecoder);
     // If this method returns false, then there's no audio stream.
     if (InitializeAudioDecoder(demuxer_))
       return;
   }
 
   // Assuming audio decoder was created, create audio renderer.
   if (state_ == kInitAudioDecoder) {
     SetState(kInitAudioRenderer);
 
     // Returns false if there's no audio stream.
     if (InitializeAudioRenderer(pipeline_init_state_->audio_decoder)) {
       base::AutoLock auto_lock(lock_);
       has_audio_ = true;
       return;
     }
   }
 
   // Assuming audio renderer was created, create video decoder.

[Ami GONE FROM CHROMIUM, 2012/08/09 20:30:18]

s/decoder/renderer/

[acolwell GONE FROM CHROMIUM, 2012/08/09 22:23:32]

Done.

   if (state_ == kInitAudioRenderer) {
-    // Then perform the stage of initialization, i.e. initialize video decoder.
-    SetState(kInitVideoDecoder);
-    if (InitializeVideoDecoder(demuxer_))
-      return;
-  }
-
-  // Assuming video decoder was created, create video renderer.
-  if (state_ == kInitVideoDecoder) {
     SetState(kInitVideoRenderer);
-    if (InitializeVideoRenderer(pipeline_init_state_->video_decoder)) {
+    if (InitializeVideoRenderer(demuxer_->GetStream(DemuxerStream::VIDEO))) {
       base::AutoLock auto_lock(lock_);
       has_video_ = true;
       return;
     }
   }
 
   if (state_ == kInitVideoRenderer) {
     if (!IsPipelineOk() || !(HasAudio() || HasVideo())) {
       SetError(PIPELINE_ERROR_COULD_NOT_RENDER);
       return;
@@ skipping 23 matching lines @@
 // We stop the filters in the reverse order.
 //
 // TODO(scherkus): beware!  this can get posted multiple times since we post
 // Stop() tasks even if we've already stopped.  Perhaps this should no-op for
 // additional calls, however most of this logic will be changing.
 void Pipeline::StopTask(const base::Closure& stop_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!IsPipelineStopPending());
   DCHECK_NE(state_, kStopped);
 
-  if (video_decoder_) {
-    video_decoder_->PrepareForShutdownHack();
-    video_decoder_ = NULL;
-  }
+  if (video_renderer_)
+    video_renderer_->PrepareForShutdownHack();
 
   if (IsPipelineTearingDown() && error_caused_teardown_) {
     // If we are stopping due to SetError(), stop normally instead of
     // going to error state and calling |error_cb_|. This converts
     // the teardown in progress from an error teardown into one that acts
     // like the error never occurred.
     base::AutoLock auto_lock(lock_);
     status_ = PIPELINE_OK;
     error_caused_teardown_ = false;
   }
@@ skipping 257 matching lines @@
     case kFlushing:
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
       break;
 
     case kCreated:
     case kError:
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
-    case kInitVideoDecoder:
     case kInitVideoRenderer:
     case kSeeking:
     case kStarting:
     case kStopped:
     case kStarted:
     case kEnded:
       NOTREACHED() << "Unexpected state for teardown: " << state_;
       break;
     // default: intentionally left out to force new states to cause compiler
     // errors.
@@ skipping 80 matching lines @@
     return false;
   }
 
   pipeline_init_state_->audio_decoder->Initialize(
       stream,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this));
   return true;
 }
 
-bool Pipeline::InitializeVideoDecoder(
-    const scoped_refptr<Demuxer>& demuxer) {
-  DCHECK(message_loop_->BelongsToCurrentThread());
-  DCHECK(IsPipelineOk());
-  DCHECK(demuxer);
-
-  scoped_refptr<DemuxerStream> stream =
-      demuxer->GetStream(DemuxerStream::VIDEO);
-
-  if (!stream)
-    return false;
-
-  filter_collection_->SelectVideoDecoder(&pipeline_init_state_->video_decoder);
-
-  if (!pipeline_init_state_->video_decoder) {
-    SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
-    return false;
-  }
-
-  pipeline_init_state_->video_decoder->Initialize(
-      stream,
-      base::Bind(&Pipeline::OnFilterInitialize, this),
-      base::Bind(&Pipeline::OnUpdateStatistics, this));
-
-  video_decoder_ = pipeline_init_state_->video_decoder;
-  return true;
-}
-
 bool Pipeline::InitializeAudioRenderer(
     const scoped_refptr<AudioDecoder>& decoder) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineOk());
 
   if (!decoder)
     return false;
 
   filter_collection_->SelectAudioRenderer(&audio_renderer_);
   if (!audio_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   audio_renderer_->Initialize(
       decoder,
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
       base::Bind(&Pipeline::OnAudioTimeUpdate, this),
       base::Bind(&Pipeline::OnRendererEnded, this),
       base::Bind(&Pipeline::OnAudioDisabled, this),
       base::Bind(&Pipeline::SetError, this));
   return true;
 }
 
 bool Pipeline::InitializeVideoRenderer(
-    const scoped_refptr<VideoDecoder>& decoder) {
+    const scoped_refptr<DemuxerStream>& stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(IsPipelineOk());
 
-  if (!decoder)
+  if (!stream)
     return false;
 
   filter_collection_->SelectVideoRenderer(&video_renderer_);
   if (!video_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   video_renderer_->Initialize(
-      decoder,
+      stream,
+      filter_collection_->GetVideoDecoders(),
       base::Bind(&Pipeline::OnFilterInitialize, this),
       base::Bind(&Pipeline::OnUpdateStatistics, this),
       base::Bind(&Pipeline::OnVideoTimeUpdate, this),
       base::Bind(&Pipeline::OnNaturalVideoSizeChanged, this),
       base::Bind(&Pipeline::OnRendererEnded, this),
       base::Bind(&Pipeline::SetError, this),
       base::Bind(&Pipeline::GetMediaTime, this),
       base::Bind(&Pipeline::GetMediaDuration, this));
+  filter_collection_->GetVideoDecoders().clear();
   return true;
 }
 
 void Pipeline::TearDownPipeline() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_NE(kStopped, state_);
 
   DCHECK(!tearing_down_ ||  // Teardown on Stop().
          (tearing_down_ && error_caused_teardown_) ||  // Teardown on error.
          (tearing_down_ && stop_pending_));  // Stop during teardown by error.
@@ skipping 10 matching lines @@
       SetState(kStopped);
       // Need to put this in the message loop to make sure that it comes
       // after any pending callback tasks that are already queued.
       message_loop_->PostTask(FROM_HERE, base::Bind(
           &Pipeline::FinishDestroyingFiltersTask, this));
       break;
 
     case kInitDemuxer:
     case kInitAudioDecoder:
     case kInitAudioRenderer:
-    case kInitVideoDecoder:
     case kInitVideoRenderer:
       // Make it look like initialization was successful.
       filter_collection_.reset();
       pipeline_init_state_.reset();
 
       SetState(kStopping);
       DoStop(base::Bind(&Pipeline::OnTeardownStateTransition, this));
 
       FinishInitialization();
       break;
@@ skipping 69 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media