Provide a Chrome-owned buffer to FFmpeg for video decoding, instead of

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 43 matching lines @@
     : message_loop_factory_cb_(message_loop_cb),
       message_loop_(NULL),
       state_(kUninitialized),
       codec_context_(NULL),
       av_frame_(NULL),
       frame_rate_numerator_(0),
       frame_rate_denominator_(0),
       decryptor_(NULL) {
 }
 
+int FFmpegVideoDecoder::GetVideoBuffer(AVFrame *frame) {
+  VideoFrame::Format format = PixelFormatToVideoFormat(codec_context_->pix_fmt);
+  if (format == VideoFrame::INVALID)
+    return AVERROR(EINVAL);
+  DCHECK(format == VideoFrame::YV12 || format == VideoFrame::YV16);
+  int w = codec_context_->width, h = codec_context_->height;
+  avcodec_align_dimensions(codec_context_, &w, &h);
+  int ret;
+  if ((ret = av_image_check_size(w, h, 0, NULL)) < 0)
+    return ret;
+  int strides[4];
+  if ((ret = av_image_fill_linesizes(strides, codec_context_->pix_fmt, w)) < 0)
+    return ret;
+  scoped_refptr<VideoFrame> buf = VideoFrame::CreateFrame(format,
+        codec_context_->width, codec_context_->height, strides[0],
+        strides[1], h, kNoTimestamp(), kNoTimestamp());
+
+  for (int i = 0; i < 3; i++) {
+    frame->base[i] = buf->data(i);
+    frame->data[i] = buf->data(i);
+    frame->linesize[i] = buf->stride(i);
+  }
+
+  frame->opaque = buf.release();
+  frame->type = FF_BUFFER_TYPE_USER;
+  frame->pkt_pts = codec_context_->pkt ? codec_context_->pkt->pts : AV_NOPTS_VALUE;
+  frame->width = codec_context_->width;
+  frame->height = codec_context_->height;
+  frame->format = codec_context_->pix_fmt;
+
+  return 0;
+}
+
+static int callbackGetVideoBuffer(AVCodecContext *s, AVFrame *frame) {
+  FFmpegVideoDecoder *vd = static_cast<FFmpegVideoDecoder *>(s->opaque);
+  return vd->GetVideoBuffer(frame);
+}
+
+static void callbackReleaseVideoBuffer(AVCodecContext *s, AVFrame *frame) {
+  // We're releasing the refenence to the buffer allocated in
+  // GetVideoBuffer() here, so the explicit Release() here is
+  // intentional. Would be nice if scoped_refptr::adopt existed.
+  scoped_refptr<VideoFrame> buf = static_cast<VideoFrame *>(frame->opaque);
+  buf->Release();
+  memset(frame->data, 0, sizeof(frame->data));
+  frame->opaque = NULL;
+}
+
 void FFmpegVideoDecoder::Initialize(const scoped_refptr<DemuxerStream>& stream,
                                     const PipelineStatusCB& status_cb,
                                     const StatisticsCB& statistics_cb) {
   if (!message_loop_) {
     message_loop_ = message_loop_factory_cb_.Run();
     message_loop_factory_cb_.Reset();
 
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Initialize, this,
         stream, status_cb, statistics_cb));
@@ skipping 23 matching lines @@
 
   // Initialize AVCodecContext structure.
   codec_context_ = avcodec_alloc_context();
   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 = callbackGetVideoBuffer;

[Ami GONE FROM CHROMIUM, 2012/06/09 02:51:23]

I still think it should be possible to use base::Bind() to avoid the explicit
trampoline static function.  
Bind()'ing to a member function of |*this| is the most common use of Bind().

+  codec_context_->release_buffer = callbackReleaseVideoBuffer;
 
   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) {
     status_cb.Run(PIPELINE_ERROR_DECODE);
     return;
@@ skipping 238 matching lines @@
   // The decoder is in a bad state and not decoding correctly.
   // Checking for NULL avoids a crash in CopyPlane().
   if (!av_frame_->data[VideoFrame::kYPlane] ||
       !av_frame_->data[VideoFrame::kUPlane] ||
       !av_frame_->data[VideoFrame::kVPlane]) {
     LOG(ERROR) << "Video frame was produced yet has invalid frame data.";
     *video_frame = NULL;
     return false;
   }
 
-  // We've got a frame! Make sure we have a place to store it.
-  *video_frame = AllocateVideoFrame();
-  if (!(*video_frame)) {
-    LOG(ERROR) << "Failed to allocate video frame";
+  if (!av_frame_->opaque) {
+    LOG(ERROR) << "VideoFrame object associated with frame data not set.";
     return false;
   }
+  *video_frame = static_cast<VideoFrame *>(av_frame_->opaque);
 
   // Determine timestamp and calculate the duration based on the repeat picture
   // count.  According to FFmpeg docs, the total duration can be calculated as
   // follows:
   //   fps = 1 / time_base
   //
   //   duration = (1 / fps) + (repeat_pict) / (2 * fps)
   //            = (2 + repeat_pict) / (2 * fps)
   //            = (2 + repeat_pict) / (2 * (1 / time_base))
   DCHECK_LE(av_frame_->repeat_pict, 2);  // Sanity check.
   AVRational doubled_time_base;
   doubled_time_base.num = frame_rate_denominator_;
   doubled_time_base.den = frame_rate_numerator_ * 2;
 
   (*video_frame)->SetTimestamp(
       base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
   (*video_frame)->SetDuration(
       ConvertFromTimeBase(doubled_time_base, 2 + av_frame_->repeat_pict));
 
-  // Copy the frame data since FFmpeg reuses internal buffers for AVFrame
-  // output, meaning the data is only valid until the next
-  // avcodec_decode_video() call.
-  int y_rows = codec_context_->height;
-  int uv_rows = codec_context_->height;
-  if (codec_context_->pix_fmt == PIX_FMT_YUV420P) {
-    uv_rows /= 2;
-  }
-
-  CopyYPlane(av_frame_->data[0], av_frame_->linesize[0], y_rows, *video_frame);
-  CopyUPlane(av_frame_->data[1], av_frame_->linesize[1], uv_rows, *video_frame);
-  CopyVPlane(av_frame_->data[2], av_frame_->linesize[2], uv_rows, *video_frame);
-
   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);
 }
 
 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;
   }
 }
 
-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