media: Implement zero-copy video playback for ffmpeg.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/ffmpeg_glue.h"
+#include "media/video/hybrid_video_frame_pool.h"
 
 namespace media {
 
 // Always try to use three threads for video decoding.  There is little reason
 // not to since current day CPUs tend to be multi-core and we measured
 // performance benefits on older machines such as P4s with hyperthreading.
 //
 // Handling decoding on separate threads also frees up the pipeline thread to
 // continue processing. Although it'd be nice to have the option of a single
 // decoding thread, FFmpeg treats having one thread the same as having zero
@@ skipping 19 matching lines @@
 }
 
 static int GetVideoBufferImpl(struct AVCodecContext* s,
                               AVFrame* frame,
                               int flags) {
   FFmpegVideoDecoder* decoder = static_cast<FFmpegVideoDecoder*>(s->opaque);
   return decoder->GetVideoBuffer(s, frame, flags);
 }
 
 static void ReleaseVideoBufferImpl(void* opaque, uint8_t* data) {
-  scoped_refptr<VideoFrame> video_frame;
-  video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque));
+  std::unique_ptr<VideoFrameFuture> video_frame_future(
+      static_cast<VideoFrameFuture*>(opaque));
 }
 
 // static
 bool FFmpegVideoDecoder::IsCodecSupported(VideoCodec codec) {
   FFmpegGlue::InitializeFFmpeg();
   return avcodec_find_decoder(VideoCodecToCodecID(codec)) != nullptr;
 }
 
 FFmpegVideoDecoder::FFmpegVideoDecoder()
+    : FFmpegVideoDecoder(std::unique_ptr<GpuMemoryBufferVideoFramePool>()) {}
+
+FFmpegVideoDecoder::FFmpegVideoDecoder(
+    std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_video_frame_pool)
     : state_(kUninitialized), decode_nalus_(false) {
   thread_checker_.DetachFromThread();
+  gpu_video_frame_pool->SetUsage(GpuMemoryBufferVideoFramePool::Usage::FFMPEG);
+  hybrid_frame_pool_.reset(
+      new HybridVideoFramePool(std::move(gpu_video_frame_pool)));
 }
 
 int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context,
                                        AVFrame* frame,
                                        int flags) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
   // updated width/height/pix_fmt, which can change for adaptive
   // content.
@@ skipping 32 matching lines @@
   gfx::Size coded_size(std::max(size.width(), codec_context->coded_width),
                        std::max(size.height(), codec_context->coded_height));
 
   if (!VideoFrame::IsValidConfig(format, VideoFrame::STORAGE_UNKNOWN,
                                  coded_size, gfx::Rect(size), natural_size)) {
     return AVERROR(EINVAL);
   }
 
   // FFmpeg expects the initialize allocation to be zero-initialized.  Failure
   // to do so can lead to unitialized value usage.  See http://crbug.com/390941
-  scoped_refptr<VideoFrame> video_frame = frame_pool_.CreateFrame(
-      format, coded_size, gfx::Rect(size), natural_size, kNoTimestamp());
+  std::unique_ptr<VideoFrameFuture> video_frame_future =
+      hybrid_frame_pool_->CreateFrame(format, coded_size, gfx::Rect(size),
+                                      natural_size, kNoTimestamp());
+  DCHECK(video_frame_future);
 
-  // Prefer the color space from the codec context. If it's not specified (or is
-  // set to an unsupported value), fall back on the value from the config.
-  ColorSpace color_space = AVColorSpaceToColorSpace(codec_context->colorspace,
-                                                    codec_context->color_range);
-  if (color_space == COLOR_SPACE_UNSPECIFIED)
-    color_space = config_.color_space();
-  video_frame->metadata()->SetInteger(VideoFrameMetadata::COLOR_SPACE,
-                                      color_space);
-
-  for (size_t i = 0; i < VideoFrame::NumPlanes(video_frame->format()); i++) {
-    frame->data[i] = video_frame->data(i);
-    frame->linesize[i] = video_frame->stride(i);
+  for (size_t i = 0; i < VideoFrame::NumPlanes(format); i++) {
+    frame->data[i] = video_frame_future->data(i);
+    frame->linesize[i] = video_frame_future->stride(i);
   }
 
   frame->width = coded_size.width();
   frame->height = coded_size.height();
   frame->format = codec_context->pix_fmt;
   frame->reordered_opaque = codec_context->reordered_opaque;
 
   // Now create an AVBufferRef for the data just allocated. It will own the
   // reference to the VideoFrame object.
-  void* opaque = NULL;
-  video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque));
+  void* opaque = video_frame_future.release();
   frame->buf[0] =
-      av_buffer_create(frame->data[0],
-                       VideoFrame::AllocationSize(format, coded_size),
-                       ReleaseVideoBufferImpl,
-                       opaque,
-                       0);
+      av_buffer_create(nullptr, 0, ReleaseVideoBufferImpl, opaque, 0);
   return 0;
 }
 
 std::string FFmpegVideoDecoder::GetDisplayName() const {
   return "FFmpegVideoDecoder";
 }
 
 void FFmpegVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                     bool low_delay,
                                     CdmContext* /* cdm_context */,
@@ skipping 152 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.";
     av_frame_unref(av_frame_.get());
     return false;
   }
 
-  scoped_refptr<VideoFrame> frame =
-      reinterpret_cast<VideoFrame*>(av_buffer_get_opaque(av_frame_->buf[0]));
+  VideoFrameFuture* frame_future =
+      static_cast<VideoFrameFuture*>(av_buffer_get_opaque(av_frame_->buf[0]));
+  scoped_refptr<VideoFrame> frame = frame_future->Release();
+  DCHECK(frame);
+
+  // Prefer the color space from the codec context. If it's not specified (or is
+  // set to an unsupported value), fall back on the value from the config.
+  ColorSpace color_space = AVColorSpaceToColorSpace(
+      codec_context_->colorspace, codec_context_->color_range);
+  if (color_space == COLOR_SPACE_UNSPECIFIED)
+    color_space = config_.color_space();
+  frame->metadata()->SetInteger(VideoFrameMetadata::COLOR_SPACE, color_space);
   frame->set_timestamp(
       base::TimeDelta::FromMicroseconds(av_frame_->reordered_opaque));
   *has_produced_frame = true;
   output_cb_.Run(frame);
 
   av_frame_unref(av_frame_.get());
   return true;
 }
 
 void FFmpegVideoDecoder::ReleaseFFmpegResources() {
@@ skipping 26 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media