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"
@@ skipping 27 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_factory_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& pipeline_status_cb,
     const StatisticsCB& statistics_cb) {
+  if (!message_loop_) {
+    message_loop_ = message_loop_factory_cb_.Run();
+    message_loop_factory_cb_.Reset();
+  } else {
+    // TODO(scherkus): initialization currently happens more than once in
+    // PipelineIntegrationTest.BasicPlayback.
+    LOG(ERROR) << "Initialize has already been called.";
+  }
   message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FFmpegAudioDecoder::DoInitialize, this,
                  stream, pipeline_status_cb, statistics_cb));
 }
 
 void FFmpegAudioDecoder::Read(const ReadCB& read_cb) {
   // Complete operation asynchronously on different stack of execution as per
   // the API contract of AudioDecoder::Read()
   message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 200 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