Refactor FFmpegVideoDecoder to try and generalize code common to all video decoders.

media/filters/ffmpeg_audio_decoder.cc

 // Copyright (c) 2009 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 "media/base/callback.h"
 #include "media/base/data_buffer.h"
 #include "media/base/limits.h"
 #include "media/filters/ffmpeg_common.h"
 #include "media/filters/ffmpeg_demuxer.h"
 
 namespace media {
 
 // Size of the decoded audio buffer.
 const size_t FFmpegAudioDecoder::kOutputBufferSize =
     AVCODEC_MAX_AUDIO_FRAME_SIZE;
 
 FFmpegAudioDecoder::FFmpegAudioDecoder()
     : codec_context_(NULL) {
 }
 
 FFmpegAudioDecoder::~FFmpegAudioDecoder() {
 }
 
 // static
 bool FFmpegAudioDecoder::IsMediaFormatSupported(const MediaFormat& format) {
   std::string mime_type;
   return format.GetAsString(MediaFormat::kMimeType, &mime_type) &&
       mime_type::kFFmpegAudio == mime_type;
 }
 
-bool FFmpegAudioDecoder::OnInitialize(DemuxerStream* demuxer_stream) {
+void FFmpegAudioDecoder::DoInitialize(DemuxerStream* demuxer_stream,
+                                      bool* success,
+                                      Task* done_cb) {
+  AutoTaskRunner done_runner(done_cb);
+  *success = false;
+
   // Get the AVStream by querying for the provider interface.
   AVStreamProvider* av_stream_provider;
   if (!demuxer_stream->QueryInterface(&av_stream_provider)) {
-    return false;
+    return;
   }
   AVStream* av_stream = av_stream_provider->GetAVStream();
 
   // Grab the AVStream's codec context and make sure we have sensible values.
   codec_context_ = av_stream->codec;
   int bps = av_get_bits_per_sample_format(codec_context_->sample_fmt);
   DCHECK_GT(codec_context_->channels, 0);
   DCHECK_GT(bps, 0);
   DCHECK_GT(codec_context_->sample_rate, 0);
   if (codec_context_->channels == 0 ||
       static_cast<size_t>(codec_context_->channels) > Limits::kMaxChannels ||
       bps == 0 ||
       static_cast<size_t>(bps) > Limits::kMaxBPS ||
       codec_context_->sample_rate == 0 ||
-      static_cast<size_t>(codec_context_->sample_rate) > Limits::kMaxSampleRate)
-      return false;
+      (static_cast<size_t>(codec_context_->sample_rate) >
+       Limits::kMaxSampleRate)) {
+    return;
+  }
 
   // Serialize calls to avcodec_open().
   AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
   {
     AutoLock auto_lock(FFmpegLock::get()->lock());
     if (!codec || avcodec_open(codec_context_, codec) < 0) {
-      return false;
+      return;
     }
   }
 
   // When calling avcodec_find_decoder(), |codec_context_| might be altered by
   // the decoder to give more accurate values of the output format of the
   // decoder. So set the media format after a decoder is allocated.
   // TODO(hclam): Reuse the information provided by the demuxer for now, we may
   // need to wait until the first buffer is decoded to know the correct
   // information.
   media_format_.SetAsInteger(MediaFormat::kChannels, codec_context_->channels);
   media_format_.SetAsInteger(MediaFormat::kSampleBits,
       av_get_bits_per_sample_format(codec_context_->sample_fmt));
   media_format_.SetAsInteger(MediaFormat::kSampleRate,
       codec_context_->sample_rate);
   media_format_.SetAsString(MediaFormat::kMimeType,
       mime_type::kUncompressedAudio);
 
   // Prepare the output buffer.
   output_buffer_.reset(static_cast<uint8*>(av_malloc(kOutputBufferSize)));
   if (!output_buffer_.get()) {
     host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
-    return false;
+    return;
   }
-  return true;
+  *success = true;
 }
 
-void FFmpegAudioDecoder::OnSeek(base::TimeDelta time) {
+void FFmpegAudioDecoder::DoSeek(base::TimeDelta time, Task* done_cb) {
   avcodec_flush_buffers(codec_context_);
   estimated_next_timestamp_ = StreamSample::kInvalidTimestamp;
+  done_cb->Run();
+  delete done_cb;
 }
 
-void FFmpegAudioDecoder::OnStop() {
-}
+void FFmpegAudioDecoder::DoDecode(Buffer* input, Task* done_cb) {
+  AutoTaskRunner done_runner(done_cb);
 
-void FFmpegAudioDecoder::OnDecode(Buffer* input) {
   // Due to FFmpeg API changes we no longer have const read-only pointers.
   AVPacket packet;
   av_init_packet(&packet);
   packet.data = const_cast<uint8*>(input->GetData());
   packet.size = input->GetDataSize();
 
   int16_t* output_buffer = reinterpret_cast<int16_t*>(output_buffer_.get());
   int output_buffer_size = kOutputBufferSize;
   int result = avcodec_decode_audio3(codec_context_,
                                      output_buffer,
@@ skipping 78 matching lines @@
 base::TimeDelta FFmpegAudioDecoder::CalculateDuration(size_t size) {
   int64 denominator = codec_context_->channels *
       av_get_bits_per_sample_format(codec_context_->sample_fmt) / 8 *
       codec_context_->sample_rate;
   double microseconds = size /
       (denominator / static_cast<double>(base::Time::kMicrosecondsPerSecond));
   return base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 }
 
 }  // namespace