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"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/demuxer_stream.h"
+#include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline.h"
 #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 17 matching lines @@
     }
 
     return decode_threads;
   }
 
   decode_threads = std::max(decode_threads, 0);
   decode_threads = std::min(decode_threads, kMaxDecodeThreads);
   return decode_threads;
 }
 
+// Maximum number of frame buffers allowed to be used by libvpx for VP9
+// decoding.
+static const int kVP9MaxFrameBuffers = VP9_MAXIMUM_REF_BUFFERS +
+                                       VPX_MAXIMUM_WORK_BUFFERS +
+                                       limits::kMaxVideoFrames;
+
+// Minimum libvpx decoder ABI version required to support direct rendering.
+static const int kLibvpxMinABIExternalBuffers = 6;
+
+class VpxVideoDecoder::MemoryPool
+    : public base::RefCountedThreadSafe<VpxVideoDecoder::MemoryPool> {
+ public:
+  vpx_codec_frame_buffer* frame_buffers() { return frame_buffers_; }
+  size_t frame_buffers_size() const { return arraysize(frame_buffers_); }
+
+  // Callback that will be called by libvpx if the frame buffer size needs to
+  // increase. Parameters:
+  // user_priv  Data passed into libvpx (we pass NULL).
+  // new_size   Minimum size needed by libvpx to decompress the next frame.
+  // fb         Pointer to the frame buffer to update.
+  // Returns VPX_CODEC_OK on success. Returns < 0 on failure.
+  static int32 ReallocVP9FrameBuffer(void* user_priv, size_t new_size,
+                                     vpx_codec_frame_buffer* fb);
+
+  // Generates a "no_longer_needed" closure that holds a reference
+  // to this pool.
+  base::Closure frame_callback();
+
+ private:
+  friend class base::RefCountedThreadSafe<VpxVideoDecoder::MemoryPool>;
+  ~MemoryPool();
+
+  // Empty method that gets called when a VideoFrame that references
+  // this pool gets destroyed.
+  void OnVideoFrameDestroyed();
+
+  vpx_codec_frame_buffer frame_buffers_[kVP9MaxFrameBuffers];

[acolwell GONE FROM CHROMIUM, 2013/12/19 15:26:12]

Add DISALLOW_COPY_AND_ASSIGN(MemoryPool).

[vignesh, 2013/12/19 20:27:21]

Done.

+};
+
+VpxVideoDecoder::MemoryPool::~MemoryPool() {
+  for (size_t i = 0; i < arraysize(frame_buffers_); ++i)
+    delete [] frame_buffers_[i].data;
+}
+
+int32 VpxVideoDecoder::MemoryPool::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;
+  }
+
+base::Closure VpxVideoDecoder::MemoryPool::frame_callback() {
+  return base::Bind(&MemoryPool::OnVideoFrameDestroyed, this);
+}
+
+void VpxVideoDecoder::MemoryPool::OnVideoFrameDestroyed() {
+}
+
 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),
+      memory_pool_(NULL) {
 }
 
 VpxVideoDecoder::~VpxVideoDecoder() {
   DCHECK_EQ(kUninitialized, state_);
   CloseDecoder();
 }
 
 void VpxVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  const PipelineStatusCB& status_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ skipping 48 matching lines @@
   }
   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 >= kLibvpxMinABIExternalBuffers) {

[acolwell GONE FROM CHROMIUM, 2013/12/19 15:26:12]

Is this really needed? Can this code even build w/ a lower ABI version. If so,
it seems like a COMPILER_ASSERT() by the #includes is what you want instead of
this runtime check.

[vignesh, 2013/12/19 20:27:21]

We don't need this. Getting rid of it.

+    memory_pool_ = new MemoryPool();
+    if (vpx_codec_set_frame_buffers(
+            vpx_codec_,
+            memory_pool_->frame_buffers(),
+            memory_pool_->frame_buffers_size(),
+            &MemoryPool::ReallocVP9FrameBuffer,
+            NULL)) {
+      LOG(ERROR) << "Failed to configure external buffers.";
+      return false;
+    }
+    // Ask libvpx to use LRU to reuse frame buffers so that it doesn't
+    // overwrite the buffers currently in use by chromium (jitter buffers).
+    if (vpx_codec_control(vpx_codec_, VP9D_SET_FRAME_BUFFER_LRU_CACHE, 1)) {
+      LOG(ERROR) << "Failed to set frame buffer lru cache.";
+      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;
+    memory_pool_ = 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_ && memory_pool_) {
+    *video_frame = VideoFrame::WrapExternalYuvData(
+                       VideoFrame::YV12,
+                       size, gfx::Rect(size), config_.natural_size(),
+                       vpx_image->stride[VPX_PLANE_Y],

[acolwell GONE FROM CHROMIUM, 2013/12/19 15:26:12]

It would be nice if vpx_image contained a vpx_codec_frame_buffer* that points to
the buffer that is backing this image. It would also be nice if
vpx_codec_frame_buffer had an "in use by libvpx" field and an "in use by
external code" field so that these two pieces of code can clearly communicate
when the frame buffer data can safely be destroyed. This may allow you to remove
the LRU assumption. libvpx just looks for a frame buffer that isn't in use by
libvpx or external code.

[vignesh, 2013/12/19 20:27:21]

frank's comments address this.

+                       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(),
+                       memory_pool_->frame_callback());
+    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_)

[acolwell GONE FROM CHROMIUM, 2013/12/19 15:26:12]

You should probably leave this in here since the memory_pool is only allocated
for VP9 w/ the right ABI and this code would break if we ever decided to use
this decoder for VP8.

[vignesh, 2013/12/19 20:27:21]

Done.

-    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