Create video and audio decoder threads on demand.

media/filters/ffmpeg_audio_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_audio_decoder.h"
 
 #include "base/bind.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/data_buffer.h"
 #include "media/base/demuxer.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/ffmpeg/ffmpeg_common.h"
 
 namespace media {
 
 // Returns true if the decode result was an error.
 static bool IsErrorResult(int result, int decoded_size) {
   return result < 0 ||
       decoded_size < 0 ||
       decoded_size > AVCODEC_MAX_AUDIO_FRAME_SIZE;
@@ skipping 17 matching lines @@
 // Returns true if the decode result was end of stream.
 static bool IsEndOfStream(int result, int decoded_size, Buffer* input) {
   // Three conditions to meet to declare end of stream for this decoder:
   // 1. FFmpeg didn't read anything.
   // 2. FFmpeg didn't output anything.
   // 3. An end of stream buffer is received.
   return result == 0 && decoded_size == 0 && input->IsEndOfStream();
 }
 
 
-FFmpegAudioDecoder::FFmpegAudioDecoder(MessageLoop* message_loop)
-    : message_loop_(message_loop),
+FFmpegAudioDecoder::FFmpegAudioDecoder(
+    const base::Callback<MessageLoop*()>& message_loop_cb)
+    : message_loop_cb_(message_loop_cb),
+      message_loop_(NULL),
       codec_context_(NULL),
       bits_per_channel_(0),
       channel_layout_(CHANNEL_LAYOUT_NONE),
       samples_per_second_(0),
       decoded_audio_size_(AVCODEC_MAX_AUDIO_FRAME_SIZE),
       decoded_audio_(static_cast<uint8*>(av_malloc(decoded_audio_size_))) {
 }
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
   av_free(decoded_audio_);
 
   // TODO(scherkus): should we require Stop() to be called? this might end up
   // getting called on a random thread due to refcounting.
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
   }
 }
 
 void FFmpegAudioDecoder::Initialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& callback,
     const StatisticsCallback& stats_callback) {
-  message_loop_->PostTask(
-      FROM_HERE,
+  message_loop_ = message_loop_cb_.Run();
+  message_loop_->PostTask(FROM_HERE,

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

style -- I'd do the following:

message_loop_->PostTask(FROM_HERE, base::Bind(
____&FFmpegAudioDecoder::DoInitialize, ....

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

Done.

       base::Bind(&FFmpegAudioDecoder::DoInitialize, this,
                  stream, callback, stats_callback));
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& callback) {
   // Complete operation asynchronously on different stack of execution as per
   // the API contract of AudioDecoder::Read()
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &FFmpegAudioDecoder::DoRead, this, callback));
+  message_loop_->PostTask(FROM_HERE,

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

ditto here + below (i.e., revert these edits)

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

Done.

+      base::Bind(&FFmpegAudioDecoder::DoRead, this, callback));
 }
 
 int FFmpegAudioDecoder::bits_per_channel() {
   return bits_per_channel_;
 }
 
 ChannelLayout FFmpegAudioDecoder::channel_layout() {
   return channel_layout_;
 }
 
 int FFmpegAudioDecoder::samples_per_second() {
   return samples_per_second_;
 }
 
 void FFmpegAudioDecoder::Reset(const base::Closure& closure) {
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &FFmpegAudioDecoder::DoReset, this, closure));
+  message_loop_->PostTask(FROM_HERE,
+      base::Bind(&FFmpegAudioDecoder::DoReset, this, closure));
 }
 
 void FFmpegAudioDecoder::DoInitialize(
     const scoped_refptr<DemuxerStream>& stream,
     const PipelineStatusCB& callback,
     const StatisticsCallback& stats_callback) {
   demuxer_stream_ = stream;
   const AudioDecoderConfig& config = stream->audio_decoder_config();
   stats_callback_ = stats_callback;
 
@@ skipping 130 matching lines @@
 
 void FFmpegAudioDecoder::ReadFromDemuxerStream() {
   DCHECK(!read_cb_.is_null());
 
   demuxer_stream_->Read(base::Bind(&FFmpegAudioDecoder::DecodeBuffer, this));
 }
 
 void FFmpegAudioDecoder::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(
-      &FFmpegAudioDecoder::DoDecodeBuffer, this, buffer));
+  message_loop_->PostTask(FROM_HERE,
+      base::Bind(&FFmpegAudioDecoder::DoDecodeBuffer, this, buffer));
 }
 
 void FFmpegAudioDecoder::UpdateDurationAndTimestamp(
     const Buffer* input,
     DataBuffer* output) {
   // Always calculate duration based on the actual number of samples decoded.
   base::TimeDelta duration = CalculateDuration(output->GetDataSize());
   output->SetDuration(duration);
 
   // Use the incoming timestamp if it's valid.
@@ skipping 20 matching lines @@
 }
 
 void FFmpegAudioDecoder::DeliverSamples(const scoped_refptr<Buffer>& samples) {
   // Reset the callback before running to protect against reentrancy.
   ReadCB read_cb = read_cb_;
   read_cb_.Reset();
   read_cb.Run(samples);
 }
 
 }  // namespace media