<video> decode in hardware!

media/base/pipeline_impl.cc

 // Copyright (c) 2011 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.
 //
 // TODO(scherkus): clean up PipelineImpl... too many crazy function names,
 // potential deadlocks, etc...
 
 #include "media/base/pipeline_impl.h"
 
 #include <algorithm>
@@ skipping 568 matching lines @@
   DCHECK(IsRunning());
 
   // Disable renderer on the message loop.
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::DisableAudioRendererTask, this));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::AUDIO_RENDERER_DISABLED));
 }
 
 // Called from any thread.
-void PipelineImpl::OnFilterInitialize() {
+void PipelineImpl::OnFilterInitialize(PipelineStatus status) {
   // Continue the initialize task by proceeding to the next stage.
-  message_loop_->PostTask(FROM_HERE,
-      base::Bind(&PipelineImpl::InitializeTask, this));
+  message_loop_->PostTask(
+      FROM_HERE, base::Bind(&PipelineImpl::InitializeTask, this, status));
 }
 
 // Called from any thread.
 void PipelineImpl::OnFilterStateTransition() {
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::FilterStateTransitionTask, this));
 }
 
 // Called from any thread.
 // This method makes the FilterStatusCB behave like a Closure. It
@@ skipping 51 matching lines @@
 // VideoDecoder to the Demuxer's video stream, and then connects the
 // VideoDecoder to a VideoRenderer.
 //
 // When all required filters have been created and have called their
 // FilterHost's InitializationComplete() method, the pipeline will update its
 // state to kStarted and |init_callback_|, 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 PipelineImpl::InitializeTask() {
+void PipelineImpl::InitializeTask(PipelineStatus last_stage_status) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
+  if (last_stage_status != PIPELINE_OK) {
+    // Currently only VideoDecoders have a recoverable error code.
+    if (state_ == kInitVideoDecoder &&
+        last_stage_status == DECODER_ERROR_NOT_SUPPORTED) {
+      pipeline_init_state_->composite_->RemoveFilter(
+          pipeline_init_state_->video_decoder_.get());
+      state_ = kInitAudioRenderer;
+    } else {
+      SetError(last_stage_status);
+    }
+  }
+
   // 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);
 
@@ skipping 427 matching lines @@
       stop_cb.Run(status_);
     }
   }
 
   tearing_down_ = false;
   error_caused_teardown_ = false;
 }
 
 bool PipelineImpl::PrepareFilter(scoped_refptr<Filter> filter) {
   bool ret = pipeline_init_state_->composite_->AddFilter(filter.get());
-
-  if (!ret) {
+  if (!ret)
     SetError(PIPELINE_ERROR_INITIALIZATION_FAILED);
-  }
   return ret;
 }
 
 void PipelineImpl::InitializeDemuxer() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   filter_collection_->GetDemuxerFactory()->Build(
       url_, base::Bind(&PipelineImpl::OnDemuxerBuilt, this));
 }
@@ skipping 20 matching lines @@
   demuxer_ = demuxer;
   demuxer_->set_host(this);
 
   {
     base::AutoLock auto_lock(lock_);
     // We do not want to start the clock running. We only want to set the base
     // media time so our timestamp calculations will be correct.
     clock_->SetTime(demuxer_->GetStartTime());
   }
 
-  OnFilterInitialize();
+  OnFilterInitialize(PIPELINE_OK);
 }
 
 bool PipelineImpl::InitializeAudioDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer->GetStream(DemuxerStream::AUDIO);
 
   if (!stream)
     return false;
 
   scoped_refptr<AudioDecoder> audio_decoder;
   filter_collection_->SelectAudioDecoder(&audio_decoder);
 
   if (!audio_decoder) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   if (!PrepareFilter(audio_decoder))
     return false;
 
   pipeline_init_state_->audio_decoder_ = audio_decoder;
   audio_decoder->Initialize(
       stream,
-      base::Bind(&PipelineImpl::OnFilterInitialize, this),
+      base::Bind(&PipelineImpl::OnFilterInitialize, this, PIPELINE_OK),
       base::Bind(&PipelineImpl::OnUpdateStatistics, this));
   return true;
 }
 
 bool PipelineImpl::InitializeVideoDecoder(
     const scoped_refptr<Demuxer>& demuxer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   scoped_refptr<DemuxerStream> stream;
@@ skipping 36 matching lines @@
   if (!audio_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   if (!PrepareFilter(audio_renderer_))
     return false;
 
   audio_renderer_->Initialize(
       decoder,
-      base::Bind(&PipelineImpl::OnFilterInitialize, this),
+      base::Bind(&PipelineImpl::OnFilterInitialize, this, PIPELINE_OK),
       base::Bind(&PipelineImpl::OnAudioUnderflow, this));
   return true;
 }
 
 bool PipelineImpl::InitializeVideoRenderer(
     const scoped_refptr<VideoDecoder>& decoder) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(IsPipelineOk());
 
   if (!decoder)
     return false;
 
   filter_collection_->SelectVideoRenderer(&video_renderer_);
   if (!video_renderer_) {
     SetError(PIPELINE_ERROR_REQUIRED_FILTER_MISSING);
     return false;
   }
 
   if (!PrepareFilter(video_renderer_))
     return false;
 
   video_renderer_->Initialize(
       decoder,
-      base::Bind(&PipelineImpl::OnFilterInitialize, this),
+      base::Bind(&PipelineImpl::OnFilterInitialize, this, PIPELINE_OK),
       base::Bind(&PipelineImpl::OnUpdateStatistics, this));
   return true;
 }
 
 void PipelineImpl::TearDownPipeline() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(kStopped, state_);
 
   DCHECK(!tearing_down_ ||  // Teardown on Stop().
          (tearing_down_ && error_caused_teardown_) ||  // Teardown on error.
@@ skipping 136 matching lines @@
   message_loop_->PostTask(FROM_HERE,
       base::Bind(&PipelineImpl::NotifyCanPlayThrough, this));
 }
 
 void PipelineImpl::NotifyCanPlayThrough() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   NotifyNetworkEventTask(CAN_PLAY_THROUGH);
 }
 
 }  // namespace media