Move VideoDecoder initialization into VideoRendererBase.

media/filters/video_renderer_base.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/video_renderer_base.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/threading/platform_thread.h"
@@ skipping 94 matching lines @@
   DCHECK(!cb.is_null());
   DCHECK(preroll_cb_.is_null());
 
   state_ = kPrerolling;
   preroll_cb_ = cb;
   preroll_timestamp_ = time;
   prerolling_delayed_frame_ = NULL;
   AttemptRead_Locked();
 }
 
-void VideoRendererBase::Initialize(const scoped_refptr<VideoDecoder>& decoder,
+void VideoRendererBase::Initialize(const scoped_refptr<DemuxerStream>& stream,
+                                   const VideoDecoderList& decoders,
                                    const PipelineStatusCB& init_cb,
                                    const StatisticsCB& statistics_cb,
                                    const TimeCB& max_time_cb,
                                    const NaturalSizeChangedCB& size_changed_cb,
                                    const base::Closure& ended_cb,
                                    const PipelineStatusCB& error_cb,
                                    const TimeDeltaCB& get_time_cb,
                                    const TimeDeltaCB& get_duration_cb) {
   base::AutoLock auto_lock(lock_);
-  DCHECK(decoder);
+  DCHECK(stream);
+  DCHECK(!decoders.empty());
+  DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_time_cb.is_null());
   DCHECK(!size_changed_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!get_time_cb.is_null());
   DCHECK(!get_duration_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
-  decoder_ = decoder;
 
+  demuxer_stream_ = stream;
+  decoders_ = decoders;
+  init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_time_cb;
   size_changed_cb_ = size_changed_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   get_time_cb_ = get_time_cb;
   get_duration_cb_ = get_duration_cb;
 
+  InitializeNextDecoder();
+}
+
+void VideoRendererBase::InitializeNextDecoder() {
+  lock_.AssertAcquired();
+  DCHECK(!decoders_.empty());
+
+  scoped_refptr<VideoDecoder> decoder = decoders_.front();
+  decoders_.pop_front();
+
+  DCHECK(decoder);
+  decoder_ = decoder;
+
+  base::AutoUnlock auto_unlock(lock_);
+  decoder->Initialize(
+      demuxer_stream_,
+      base::Bind(&VideoRendererBase::OnDecoderInitDone, this),
+      statistics_cb_);
+}
+
+void VideoRendererBase::OnDecoderInitDone(PipelineStatus status) {
+  base::AutoLock auto_lock(lock_);
+  if (!decoders_.empty() && status == DECODER_ERROR_NOT_SUPPORTED) {
+    InitializeNextDecoder();
+    return;
+  }
+
+  if (state_ == kStopped)

[xhwang, 2012/08/09 21:38:29]

Q: if VBR is already stopped, do we want to InitializeNextDecoder above?

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

Good point. Moved this to the top.

+    return;
+
+  if (status != PIPELINE_OK) {
+    state_ = kError;
+    base::ResetAndReturn(&init_cb_).Run(status);
+    return;
+  }
+
   // We're all good!  Consider ourselves flushed. (ThreadMain() should never
   // see us in the kUninitialized state).
   // Since we had an initial Preroll(), we consider ourself flushed, because we
   // have not populated any buffers yet.
+
+  // Clear out remaining decoders since we don't need them now.
+  decoders_.clear();
+
   state_ = kFlushed;
 
-  set_opaque_cb_.Run(!decoder->HasAlpha());
+  set_opaque_cb_.Run(!decoder_->HasAlpha());
   set_opaque_cb_.Reset();
 
   // Create our video thread.
   if (!base::PlatformThread::Create(0, this, &thread_)) {
     NOTREACHED() << "Video thread creation failed";
     state_ = kError;
-    init_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+    base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
     return;
   }
 
 #if defined(OS_WIN)
   // Bump up our priority so our sleeping is more accurate.
   // TODO(scherkus): find out if this is necessary, but it seems to help.
   ::SetThreadPriority(thread_, THREAD_PRIORITY_ABOVE_NORMAL);
 #endif  // defined(OS_WIN)
-  init_cb.Run(PIPELINE_OK);
+  base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 bool VideoRendererBase::HasEnded() {
   base::AutoLock auto_lock(lock_);
   return state_ == kEnded;
 }
 
+void VideoRendererBase::PrepareForShutdownHack() {
+  base::AutoLock auto_lock(lock_);
+  if (decoder_)
+    decoder_->PrepareForShutdownHack();
+}
+
 // PlatformThread::Delegate implementation.
 void VideoRendererBase::ThreadMain() {
   base::PlatformThread::SetName("CrVideoRenderer");
 
   // The number of milliseconds to idle when we do not have anything to do.
   // Nothing special about the value, other than we're being more OS-friendly
   // than sleeping for 1 millisecond.
   //
   // TOOD(scherkus): switch to pure event-driven frame timing instead of this
   // kIdleTimeDelta business http://crbug.com/106874
@@ skipping 394 matching lines @@
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
   int outstanding_frames =
       (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
       (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
   return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media