media: Enabling direct rendering for VP9

media/filters/vpx_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/vpx_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 
 // Include libvpx header files.
 // VPX_CODEC_DISABLE_COMPAT excludes parts of the libvpx API that provide
 // backwards compatibility for legacy applications using the library.
 #define VPX_CODEC_DISABLE_COMPAT 1
 extern "C" {
 #include "third_party/libvpx/source/libvpx/vpx/vpx_decoder.h"
+#include "third_party/libvpx/source/libvpx/vpx/vpx_external_frame_buffer.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8dx.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.
 static const int kDecodeThreads = 2;
 static const int kMaxDecodeThreads = 16;
@@ skipping 23 matching lines @@
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
 VpxVideoDecoder::VpxVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop)
     : message_loop_(message_loop),
       weak_factory_(this),
       state_(kUninitialized),
       vpx_codec_(NULL),
-      vpx_codec_alpha_(NULL) {
+      vpx_codec_alpha_(NULL),
+      frame_buffers_(NULL) {
 }
 
 VpxVideoDecoder::~VpxVideoDecoder() {
   DCHECK_EQ(kUninitialized, state_);
   CloseDecoder();
 }
 
 void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  const PipelineStatusCB& status_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 30 matching lines @@
                                               &vpx_config,
                                               0);
   if (status != VPX_CODEC_OK) {
     LOG(ERROR) << "vpx_codec_dec_init failed, status=" << status;
     delete context;
     return NULL;
   }
   return context;
 }
 
+int32 VpxVideoDecoder::ReallocVP9FrameBuffer(void *user_priv, size_t new_size,
+                                             vpx_codec_frame_buffer *fb) {
+  if (!fb)
+    return -1;
+  if (fb->data)
+    delete[] fb->data;
+  fb->data = new uint8[new_size];
+  if (!fb->data) {
+    fb->size = 0;
+    return -1;
+  }
+  fb->size = new_size;
+  return VPX_CODEC_OK;
+}
+
 bool VpxVideoDecoder::ConfigureDecoder(const VideoDecoderConfig& config) {
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   bool can_handle = false;
   if (config.codec() == kCodecVP9)
     can_handle = true;
   if (!cmd_line->HasSwitch(switches::kDisableVp8AlphaPlayback) &&
       config.codec() == kCodecVP8 && config.format() == VideoFrame::YV12A) {
     can_handle = true;
   }
   if (!can_handle)
     return false;
 
   CloseDecoder();
 
   vpx_codec_ = InitializeVpxContext(vpx_codec_, config);
   if (!vpx_codec_)
     return false;
 
+  // We use our own buffers for VP9 so that there is no need to copy data after
+  // decoding.
+  if (config.codec() == kCodecVP9 &&
+      VPX_DECODER_ABI_VERSION >= kVP9MinABIVersion) {
+    frame_buffers_ = new vpx_codec_frame_buffer[kVP9MaxFrameBuffers]();
+    if (vpx_codec_set_frame_buffers(vpx_codec_,
+                                    frame_buffers_,
+                                    kVP9MaxFrameBuffers,
+                                    VpxVideoDecoder::ReallocVP9FrameBuffer,
+                                    NULL)) {
+      LOG(ERROR) << "Failed to configure external buffers.";
+      return false;
+    }
+  }
+
   if (config.format() == VideoFrame::YV12A) {
     vpx_codec_alpha_ = InitializeVpxContext(vpx_codec_alpha_, config);
     if (!vpx_codec_alpha_)
       return false;
   }
 
   return true;
 }
 
 void VpxVideoDecoder::CloseDecoder() {
   if (vpx_codec_) {
     vpx_codec_destroy(vpx_codec_);
     delete vpx_codec_;
     vpx_codec_ = NULL;
+    if (frame_buffers_) {
+      for (int i = 0; i < kVP9MaxFrameBuffers; i++)
+        delete[] frame_buffers_[i].data;
+      delete[] frame_buffers_;
+      frame_buffers_ = NULL;
+    }
   }
   if (vpx_codec_alpha_) {
     vpx_codec_destroy(vpx_codec_alpha_);
     delete vpx_codec_alpha_;
     vpx_codec_alpha_ = NULL;
   }
 }
 
 void VpxVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                              const DecodeCB& decode_cb) {
@@ skipping 166 matching lines @@
 
 void VpxVideoDecoder::CopyVpxImageTo(const vpx_image* vpx_image,
                                      const struct vpx_image* vpx_image_alpha,
                                      scoped_refptr<VideoFrame>* video_frame) {
   CHECK(vpx_image);
   CHECK(vpx_image->fmt == VPX_IMG_FMT_I420 ||
         vpx_image->fmt == VPX_IMG_FMT_YV12);
 
   gfx::Size size(vpx_image->d_w, vpx_image->d_h);
 
+  if (!vpx_codec_alpha_ && VPX_DECODER_ABI_VERSION >= kVP9MinABIVersion) {
+    *video_frame = VideoFrame::WrapExternalYuvData(
+                       VideoFrame::YV12,
+                       size, gfx::Rect(size), config_.natural_size(),
+                       vpx_image->stride[VPX_PLANE_Y],
+                       vpx_image->stride[VPX_PLANE_U],
+                       vpx_image->stride[VPX_PLANE_V],
+                       vpx_image->planes[VPX_PLANE_Y],
+                       vpx_image->planes[VPX_PLANE_U],
+                       vpx_image->planes[VPX_PLANE_V],
+                       kNoTimestamp(),
+                       base::Closure());
+    return;
+  }
+
   *video_frame = frame_pool_.CreateFrame(
       vpx_codec_alpha_ ? VideoFrame::YV12A : VideoFrame::YV12,
       size,
       gfx::Rect(size),
       config_.natural_size(),
       kNoTimestamp());
 
   CopyYPlane(vpx_image->planes[VPX_PLANE_Y],
              vpx_image->stride[VPX_PLANE_Y],
              vpx_image->d_h,
              video_frame->get());
   CopyUPlane(vpx_image->planes[VPX_PLANE_U],
              vpx_image->stride[VPX_PLANE_U],
              (vpx_image->d_h + 1) / 2,
              video_frame->get());
   CopyVPlane(vpx_image->planes[VPX_PLANE_V],
              vpx_image->stride[VPX_PLANE_V],
              (vpx_image->d_h + 1) / 2,
              video_frame->get());
-  if (!vpx_codec_alpha_)
-    return;
   if (!vpx_image_alpha) {
     MakeOpaqueAPlane(
         vpx_image->stride[VPX_PLANE_Y], vpx_image->d_h, video_frame->get());
     return;
   }
   CopyAPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
              vpx_image->stride[VPX_PLANE_Y],
              vpx_image->d_h,
              video_frame->get());
 }
 
 }  // namespace media