media: Implement zero-copy video playback for VP8.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 15 matching lines @@
 #include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/memory_allocator_dump.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_switches.h"
+#include "media/video/gpu_memory_buffer_video_frame_pool.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/vp8dx.h"
 #include "third_party/libvpx/source/libvpx/vpx/vpx_decoder.h"
 #include "third_party/libvpx/source/libvpx/vpx/vpx_frame_buffer.h"
 }
@@ skipping 305 matching lines @@
 }
 
 void VpxVideoDecoder::MemoryPool::OnVideoFrameDestroyed(
     VP9FrameBuffer* frame_buffer) {
   --frame_buffer->ref_cnt;
   if (frame_buffer->ref_cnt)
     --in_use_by_decoder_and_video_frame_;
 }
 
 VpxVideoDecoder::VpxVideoDecoder()
-    : state_(kUninitialized), vpx_codec_(nullptr), vpx_codec_alpha_(nullptr) {
+    : VpxVideoDecoder(std::unique_ptr<GpuMemoryBufferVideoFramePool>()) {}
+
+VpxVideoDecoder::VpxVideoDecoder(
+    std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_video_frame_pool)
+    : state_(kUninitialized),
+      vpx_codec_(nullptr),
+      vpx_codec_alpha_(nullptr),
+      gpu_video_frame_pool_(std::move(gpu_video_frame_pool)) {
   thread_checker_.DetachFromThread();
 }
 
 VpxVideoDecoder::~VpxVideoDecoder() {
   DCHECK(thread_checker_.CalledOnValidThread());
   CloseDecoder();
   // Ensure CloseDecoder() released the offload thread.
   DCHECK(!offload_task_runner_);
 }
 
@@ skipping 191 matching lines @@
   if (!vpx_image) {
     *video_frame = nullptr;
     return true;
   }
 
   if (vpx_image->user_priv != user_priv) {
     DLOG(ERROR) << "Invalid output timestamp.";
     return false;
   }
 
-  if (!CopyVpxImageToVideoFrame(vpx_image, video_frame))
+  if (!CopyVpxImageToVideoFrame(vpx_image, buffer, video_frame))
     return false;
 
+  // VP8 alpha vpx_image_t is missing. Regard it as success.
+  if (!(*video_frame))
+    return true;
+
   (*video_frame)->set_timestamp(base::TimeDelta::FromMicroseconds(timestamp));
 
   // Default to the color space from the config, but if the bistream specifies
   // one, prefer that instead.
   ColorSpace color_space = config_.color_space();
   if (vpx_image->cs == VPX_CS_BT_709)
     color_space = COLOR_SPACE_HD_REC709;
   else if (vpx_image->cs == VPX_CS_BT_601)
     color_space = COLOR_SPACE_SD_REC601;
   (*video_frame)
       ->metadata()
       ->SetInteger(VideoFrameMetadata::COLOR_SPACE, color_space);
 
-  if (!vpx_codec_alpha_)
-    return true;
-
-  if (buffer->side_data_size() < 8) {
-    // TODO(mcasas): Is this a warning or an error?
-    DLOG(WARNING) << "Making Alpha channel opaque due to missing input";
-    const uint32_t kAlphaOpaqueValue = 255;
-    libyuv::SetPlane((*video_frame)->visible_data(VideoFrame::kAPlane),
-                     (*video_frame)->stride(VideoFrame::kAPlane),
-                     (*video_frame)->visible_rect().width(),
-                     (*video_frame)->visible_rect().height(),
-                     kAlphaOpaqueValue);
-    return true;
-  }
-
-  // First 8 bytes of side data is |side_data_id| in big endian.
-  const uint64_t side_data_id = base::NetToHost64(
-      *(reinterpret_cast<const uint64_t*>(buffer->side_data())));
-  if (side_data_id != 1)
-    return true;
-
-  // Try and decode buffer->side_data() minus the first 8 bytes as a full frame.
-  int64_t timestamp_alpha = buffer->timestamp().InMicroseconds();
-  void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
-  {
-    TRACE_EVENT1("media", "vpx_codec_decode_alpha", "timestamp_alpha",
-                 timestamp_alpha);
-    vpx_codec_err_t status = vpx_codec_decode(
-        vpx_codec_alpha_, buffer->side_data() + 8, buffer->side_data_size() - 8,
-        user_priv_alpha, 0 /* deadline */);
-    if (status != VPX_CODEC_OK) {
-      DLOG(ERROR) << "vpx_codec_decode() failed for the alpha: "
-                  << vpx_codec_error(vpx_codec_);
-      return false;
-    }
-  }
-
-  vpx_codec_iter_t iter_alpha = NULL;
-  const vpx_image_t* vpx_image_alpha =
-      vpx_codec_get_frame(vpx_codec_alpha_, &iter_alpha);
-  if (!vpx_image_alpha) {
-    *video_frame = nullptr;
-    return true;
-  }
-
-  if (vpx_image_alpha->user_priv != user_priv_alpha) {
-    DLOG(ERROR) << "Invalid output timestamp on alpha.";
-    return false;
-  }
-
-  if (vpx_image_alpha->d_h != vpx_image->d_h ||
-      vpx_image_alpha->d_w != vpx_image->d_w) {
-    DLOG(ERROR) << "The alpha plane dimensions are not the same as the "
-                   "image dimensions.";
-    return false;
-  }
-
-  libyuv::CopyPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
-                    vpx_image_alpha->stride[VPX_PLANE_Y],
-                    (*video_frame)->visible_data(VideoFrame::kAPlane),
-                    (*video_frame)->stride(VideoFrame::kAPlane),
-                    (*video_frame)->visible_rect().width(),
-                    (*video_frame)->visible_rect().height());
   return true;
 }
 
 bool VpxVideoDecoder::CopyVpxImageToVideoFrame(
     const struct vpx_image* vpx_image,
+    const scoped_refptr<DecoderBuffer>& buffer,
     scoped_refptr<VideoFrame>* video_frame) {
   DCHECK(vpx_image);
 
   VideoPixelFormat codec_format;
   switch (vpx_image->fmt) {
     case VPX_IMG_FMT_I420:
       codec_format = vpx_codec_alpha_ ? PIXEL_FORMAT_YV12A : PIXEL_FORMAT_YV12;
       break;
 
     case VPX_IMG_FMT_I444:
@@ skipping 36 matching lines @@
     UMA_HISTOGRAM_COUNTS(
         "Media.Vpx.VideoDecoderBuffersInUseByDecoderAndVideoFrame",
         memory_pool_->NumberOfFrameBuffersInUseByDecoderAndVideoFrame());
 
     return true;
   }
 
   DCHECK(codec_format == PIXEL_FORMAT_YV12 ||
          codec_format == PIXEL_FORMAT_YV12A);
 
-  *video_frame = frame_pool_.CreateFrame(
-      codec_format, visible_size, gfx::Rect(visible_size),
-      config_.natural_size(), kNoTimestamp());
-  if (!(*video_frame))
-    return false;
-
+  std::unique_ptr<VideoFrameFuture> video_frame_future =
+      gpu_video_frame_pool_->CreateFrame(
+          codec_format, visible_size, gfx::Rect(visible_size),
+          config_.natural_size(), kNoTimestamp());
   libyuv::I420Copy(
       vpx_image->planes[VPX_PLANE_Y], vpx_image->stride[VPX_PLANE_Y],
       vpx_image->planes[VPX_PLANE_U], vpx_image->stride[VPX_PLANE_U],
       vpx_image->planes[VPX_PLANE_V], vpx_image->stride[VPX_PLANE_V],
-      (*video_frame)->visible_data(VideoFrame::kYPlane),
-      (*video_frame)->stride(VideoFrame::kYPlane),
-      (*video_frame)->visible_data(VideoFrame::kUPlane),
-      (*video_frame)->stride(VideoFrame::kUPlane),
-      (*video_frame)->visible_data(VideoFrame::kVPlane),
-      (*video_frame)->stride(VideoFrame::kVPlane), coded_size.width(),
+      video_frame_future->data(VideoFrame::kYPlane),
+      video_frame_future->stride(VideoFrame::kYPlane),
+      video_frame_future->data(VideoFrame::kUPlane),
+      video_frame_future->stride(VideoFrame::kUPlane),
+      video_frame_future->data(VideoFrame::kVPlane),
+      video_frame_future->stride(VideoFrame::kVPlane), coded_size.width(),
       coded_size.height());
 
+  for (int i = 0; i < 1 && vpx_codec_alpha_; i++) {
+    if (buffer->side_data_size() < 8) {
+      // TODO(mcasas): Is this a warning or an error?
+      DLOG(WARNING) << "Making Alpha channel opaque due to missing input";
+      const uint32_t kAlphaOpaqueValue = 255;
+      libyuv::SetPlane(video_frame_future->data(VideoFrame::kAPlane),
+                       video_frame_future->stride(VideoFrame::kAPlane),
+                       coded_size.width(), coded_size.height(),
+                       kAlphaOpaqueValue);
+      break;
+    }
+
+    // First 8 bytes of side data is |side_data_id| in big endian.
+    const uint64_t side_data_id = base::NetToHost64(
+        *(reinterpret_cast<const uint64_t*>(buffer->side_data())));
+    if (side_data_id != 1)
+      break;
+
+    // Try and decode buffer->side_data() minus the first 8 bytes as a full
+    // frame.
+    int64_t timestamp_alpha = buffer->timestamp().InMicroseconds();
+    void* user_priv_alpha = reinterpret_cast<void*>(&timestamp_alpha);
+    {
+      TRACE_EVENT1("media", "vpx_codec_decode_alpha", "timestamp_alpha",
+                   timestamp_alpha);
+      vpx_codec_err_t status = vpx_codec_decode(
+          vpx_codec_alpha_, buffer->side_data() + 8,
+          buffer->side_data_size() - 8, user_priv_alpha, 0 /* deadline */);
+      if (status != VPX_CODEC_OK) {
+        DLOG(ERROR) << "vpx_codec_decode() failed for the alpha: "
+                    << vpx_codec_error(vpx_codec_);
+        return false;
+      }
+    }
+
+    vpx_codec_iter_t iter_alpha = NULL;
+    const vpx_image_t* vpx_image_alpha =
+        vpx_codec_get_frame(vpx_codec_alpha_, &iter_alpha);
+    if (!vpx_image_alpha) {
+      *video_frame = nullptr;
+      return true;
+    }
+
+    if (vpx_image_alpha->user_priv != user_priv_alpha) {
+      DLOG(ERROR) << "Invalid output timestamp on alpha.";
+      return false;
+    }
+
+    if (vpx_image_alpha->d_h != vpx_image->d_h ||
+        vpx_image_alpha->d_w != vpx_image->d_w) {
+      DLOG(ERROR) << "The alpha plane dimensions are not the same as the "
+                     "image dimensions.";
+      return false;
+    }
+
+    libyuv::CopyPlane(vpx_image_alpha->planes[VPX_PLANE_Y],
+                      vpx_image_alpha->stride[VPX_PLANE_Y],
+                      video_frame_future->data(VideoFrame::kAPlane),
+                      video_frame_future->stride(VideoFrame::kAPlane),
+                      coded_size.width(), coded_size.height());
+  }
+
+  *video_frame = video_frame_future->Release();
+  if (!(*video_frame))
+    return false;
   return true;
 }
 
 }  // namespace media