Create video and audio decoder threads on demand.

media/filters/ffmpeg_video_decoder.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/ffmpeg_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
+#include "media/base/message_loop_factory.h"

[scherkus (not reviewing), 2012/03/09 20:01:16]

not needed

[tommi (sloooow) - chröme, 2012/03/11 18:49:36]

Done.

 #include "media/base/pipeline.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 // Always try to use three threads for video decoding.  There is little reason
 // not to since current day CPUs tend to be multi-core and we measured
@@ skipping 19 matching lines @@
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   std::string threads(cmd_line->GetSwitchValueASCII(switches::kVideoThreads));
   if (threads.empty() || !base::StringToInt(threads, &decode_threads))
     return decode_threads;
 
   decode_threads = std::max(decode_threads, 0);
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
-FFmpegVideoDecoder::FFmpegVideoDecoder(MessageLoop* message_loop)
-    : message_loop_(message_loop),
+FFmpegVideoDecoder::FFmpegVideoDecoder(
+    const base::Callback<MessageLoop*()>& message_loop_cb)
+    : message_loop_cb_(message_loop_cb),
+      message_loop_(NULL),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
       frame_rate_numerator_(0),
       frame_rate_denominator_(0) {
 }
 
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {
   ReleaseFFmpegResources();
 }
 
 void FFmpegVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
                                     const PipelineStatusCB& callback,
                                     const StatisticsCallback& stats_callback) {
+  message_loop_ = message_loop_cb_.Run();

[Ami GONE FROM CHROMIUM, 2012/03/09 16:15:06]

add message_loop_cb_.Reset(); for clarity after this?

[tommi (sloooow) - chröme, 2012/03/11 18:49:36]

Done.

   if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
-        &FFmpegVideoDecoder::Initialize, this,
-        make_scoped_refptr(demuxer_stream), callback, stats_callback));
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&FFmpegVideoDecoder::Initialize, this,

[Ami GONE FROM CHROMIUM, 2012/03/09 16:15:06]

This indentation violates the google style guide.  Either revert or move the
preceding FROM_HERE to this style indent too.
(I prefer revert to match the rest of media code)

Ditto the rest of this CL.

[tommi (sloooow) - chröme, 2012/03/11 18:49:36]

Done.

+                   make_scoped_refptr(demuxer_stream), callback,
+                   stats_callback));
     return;
   }
 
   DCHECK(!demuxer_stream_);
 
   if (!demuxer_stream) {
     callback.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
@@ skipping 35 matching lines @@
   state_ = kNormal;
   av_frame_ = avcodec_alloc_frame();
   natural_size_ = config.natural_size();
   frame_rate_numerator_ = config.frame_rate_numerator();
   frame_rate_denominator_ = config.frame_rate_denominator();
   callback.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Stop(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
-        &FFmpegVideoDecoder::Stop, this, callback));
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&FFmpegVideoDecoder::Stop, this, callback));
     return;
   }
 
   ReleaseFFmpegResources();
   state_ = kUninitialized;
   callback.Run();
 }
 
 void FFmpegVideoDecoder::Seek(base::TimeDelta time, const FilterStatusCB& cb) {
   if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
-        &FFmpegVideoDecoder::Seek, this, time, cb));
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&FFmpegVideoDecoder::Seek, this, time, cb));
     return;
   }
 
   cb.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Pause(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
-        &FFmpegVideoDecoder::Pause, this, callback));
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&FFmpegVideoDecoder::Pause, this, callback));
     return;
   }
 
   callback.Run();
 }
 
 void FFmpegVideoDecoder::Flush(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(FROM_HERE, base::Bind(
-        &FFmpegVideoDecoder::Flush, this, callback));
+    message_loop_->PostTask(FROM_HERE,
+        base::Bind(&FFmpegVideoDecoder::Flush, this, callback));
     return;
   }
 
   avcodec_flush_buffers(codec_context_);
   state_ = kNormal;
   callback.Run();
 }
 
 void FFmpegVideoDecoder::Read(const ReadCB& callback) {
   // Complete operation asynchronously on different stack of execution as per
   // the API contract of VideoDecoder::Read()
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &FFmpegVideoDecoder::DoRead, this, callback));
+  message_loop_->PostTask(FROM_HERE,
+      base::Bind(&FFmpegVideoDecoder::DoRead, this, callback));
 }
 
 const gfx::Size& FFmpegVideoDecoder::natural_size() {
   return natural_size_;
 }
 
 void FFmpegVideoDecoder::DoRead(const ReadCB& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!callback.is_null());
   CHECK(read_cb_.is_null()) << "Overlapping decodes are not supported.";
@@ skipping 18 matching lines @@
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(!read_cb_.is_null());
 
   demuxer_stream_->Read(base::Bind(&FFmpegVideoDecoder::DecodeBuffer, this));
 }
 
 void FFmpegVideoDecoder::DecodeBuffer(const scoped_refptr<Buffer>& buffer) {
   // TODO(scherkus): fix FFmpegDemuxerStream::Read() to not execute our read
   // callback on the same execution stack so we can get rid of forced task post.
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &FFmpegVideoDecoder::DoDecodeBuffer, this, buffer));
+  message_loop_->PostTask(FROM_HERE,
+      base::Bind(&FFmpegVideoDecoder::DoDecodeBuffer, this, buffer));
 }
 
 void FFmpegVideoDecoder::DoDecodeBuffer(const scoped_refptr<Buffer>& buffer) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(!read_cb_.is_null());
 
   if (!buffer) {
     DeliverFrame(NULL);
@@ skipping 191 matching lines @@
 scoped_refptr<VideoFrame> FFmpegVideoDecoder::AllocateVideoFrame() {
   VideoFrame::Format format = PixelFormatToVideoFormat(codec_context_->pix_fmt);
   size_t width = codec_context_->width;
   size_t height = codec_context_->height;
 
   return VideoFrame::CreateFrame(format, width, height,
                                  kNoTimestamp(), kNoTimestamp());
 }
 
 }  // namespace media