Add config change support to FFmpegVideoDecoder

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/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 65 matching lines @@
   DCHECK(format == VideoFrame::YV12 || format == VideoFrame::YV16);
 
   int width = codec_context->width;
   int height = codec_context->height;
   int ret;
   if ((ret = av_image_check_size(width, height, 0, NULL)) < 0)
     return ret;
 
   scoped_refptr<VideoFrame> video_frame =
       VideoFrame::CreateFrame(format, width, height,
+                              natural_size_.width(),
+                              natural_size_.height(),
                               kNoTimestamp(), kNoTimestamp());
 
   for (int i = 0; i < 3; i++) {
     frame->base[i] = video_frame->data(i);
     frame->data[i] = video_frame->data(i);
     frame->linesize[i] = video_frame->stride(i);
   }
 
   frame->opaque = video_frame.release();
   frame->type = FF_BUFFER_TYPE_USER;
@@ skipping 55 matching lines @@
   const VideoDecoderConfig& config = stream->video_decoder_config();
 
   // TODO(scherkus): this check should go in Pipeline prior to creating
   // decoder objects.
   if (!config.IsValidConfig()) {
     DLOG(ERROR) << "Invalid video stream - " << config.AsHumanReadableString();
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
-  // Initialize AVCodecContext structure.
-  codec_context_ = avcodec_alloc_context3(NULL);
-  VideoDecoderConfigToAVCodecContext(config, codec_context_);
-
-  // Enable motion vector search (potentially slow), strong deblocking filter
-  // for damaged macroblocks, and set our error detection sensitivity.
-  codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
-  codec_context_->err_recognition = AV_EF_CAREFUL;
-  codec_context_->thread_count = GetThreadCount(codec_context_->codec_id);
-  codec_context_->opaque = this;
-  codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
-  codec_context_->get_buffer = GetVideoBufferImpl;
-  codec_context_->release_buffer = ReleaseVideoBufferImpl;
-
-  AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
-  if (!codec) {
-    status_cb.Run(PIPELINE_ERROR_DECODE);
-    return;
-  }
-
-  if (avcodec_open2(codec_context_, codec, NULL) < 0) {
+  if (!AllocateFFmpegResources(config)) {

[Ami GONE FROM CHROMIUM, 2012/07/13 00:59:05]

I wonder if it doesn't make sense to inline AFFMR() into HandleConfigChange and
call the latter from here (and make it tolerant to not having a "previous" set
of ffmpeg resources to release).

     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   // Success!
   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();

[Ami GONE FROM CHROMIUM, 2012/07/13 00:59:05]

...in which case these can go away

   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Read(const ReadCB& read_cb) {
   // 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, read_cb));
 }
 
@@ skipping 92 matching lines @@
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kDecodeFinished);
   DCHECK(!read_cb_.is_null());
 
   if (!reset_cb_.is_null()) {
     DeliverFrame(NULL);
     DoReset();
     return;
   }
 
-  if (status != DemuxerStream::kOk) {
-    DecoderStatus decoder_status =
-        (status == DemuxerStream::kAborted) ? kOk : kDecodeError;
-    base::ResetAndReturn(&read_cb_).Run(decoder_status, NULL);
+  if (status == DemuxerStream::kAborted) {
+    base::ResetAndReturn(&read_cb_).Run(kOk, NULL);
     return;
   }
 
+  if (status == DemuxerStream::kConfigChanged) {
+    if (!HandleConfigChange()) {
+      base::ResetAndReturn(&read_cb_).Run(kDecodeError, NULL);
+      return;
+    }
+
+    ReadFromDemuxerStream();
+    return;
+  }
+
   // During decode, because reads are issued asynchronously, it is possible to
   // receive multiple end of stream buffers since each read is acked. When the
   // first end of stream buffer is read, FFmpeg may still have frames queued
   // up in the decoder so we need to go through the decode loop until it stops
   // giving sensible data.  After that, the decoder should output empty
   // frames.  There are three states the decoder can be in:
   //
   //   kNormal: This is the starting state. Buffers are decoded. Decode errors
   //            are discarded.
   //   kFlushCodec: There isn't any more input data. Call avcodec_decode_video2
@@ skipping 149 matching lines @@
 
   return true;
 }
 
 void FFmpegVideoDecoder::DeliverFrame(
     const scoped_refptr<VideoFrame>& video_frame) {
   // Reset the callback before running to protect against reentrancy.
   base::ResetAndReturn(&read_cb_).Run(kOk, video_frame);
 }
 
+bool FFmpegVideoDecoder::AllocateFFmpegResources(
+    const VideoDecoderConfig& config) {
+  DCHECK(!codec_context_);
+  DCHECK(!av_frame_);
+
+  // Initialize AVCodecContext structure.
+  codec_context_ = avcodec_alloc_context3(NULL);
+  VideoDecoderConfigToAVCodecContext(config, codec_context_);
+
+  // Enable motion vector search (potentially slow), strong deblocking filter
+  // for damaged macroblocks, and set our error detection sensitivity.
+  codec_context_->error_concealment = FF_EC_GUESS_MVS | FF_EC_DEBLOCK;
+  codec_context_->err_recognition = AV_EF_CAREFUL;
+  codec_context_->thread_count = GetThreadCount(codec_context_->codec_id);
+  codec_context_->opaque = this;
+  codec_context_->flags |= CODEC_FLAG_EMU_EDGE;
+  codec_context_->get_buffer = GetVideoBufferImpl;
+  codec_context_->release_buffer = ReleaseVideoBufferImpl;
+
+  AVCodec* codec = avcodec_find_decoder(codec_context_->codec_id);
+  if (!codec)
+    return false;
+
+  if (avcodec_open2(codec_context_, codec, NULL) < 0)
+    return false;
+
+  av_frame_ = avcodec_alloc_frame();
+  return true;
+}
+
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
   if (codec_context_) {
     av_free(codec_context_->extradata);
     avcodec_close(codec_context_);
     av_free(codec_context_);
     codec_context_ = NULL;
   }
   if (av_frame_) {
     av_free(av_frame_);
     av_frame_ = NULL;
   }
 }
 
+bool FFmpegVideoDecoder::HandleConfigChange() {
+  const VideoDecoderConfig& config = demuxer_stream_->video_decoder_config();
+
+  if (!config.IsValidConfig())
+    return false;
+
+  ReleaseFFmpegResources();
+  if (!AllocateFFmpegResources(config))
+    return false;
+
+  natural_size_ = config.natural_size();
+  frame_rate_numerator_ = config.frame_rate_numerator();
+  frame_rate_denominator_ = config.frame_rate_denominator();
+  return true;
+}
+
 }  // namespace media