media: Implement zero-copy video playback for VP8.

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "ui/gfx/buffer_format_util.h"
 
 namespace media {
 
 namespace {
 
 // Return the GpuMemoryBuffer format to use for a specific VideoPixelFormat
 // and plane.
 gfx::BufferFormat GpuMemoryBufferFormat(VideoPixelFormat format, size_t plane) {
   switch (format) {
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_YV12:
       DCHECK_LE(plane, 2u);
       return gfx::BufferFormat::R_8;
+    case PIXEL_FORMAT_YV12A:
+      DCHECK_LE(plane, 3u);
+      return gfx::BufferFormat::R_8;
     case PIXEL_FORMAT_NV12:
       DCHECK_LE(plane, 1u);
       return gfx::BufferFormat::YUV_420_BIPLANAR;
     case PIXEL_FORMAT_UYVY:
       DCHECK_EQ(0u, plane);
       return gfx::BufferFormat::UYVY_422;
     default:
       NOTREACHED();
       return gfx::BufferFormat::BGRA_8888;
   }
 }
 
 unsigned ImageInternalFormat(VideoPixelFormat format, size_t plane) {
   switch (format) {
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_YV12:
       DCHECK_LE(plane, 2u);
       return GL_RED_EXT;
+    case PIXEL_FORMAT_YV12A:
+      DCHECK_LE(plane, 3u);
+      return GL_RED_EXT;
     case PIXEL_FORMAT_NV12:
       // TODO(dshwang): support ChromeOS using GL_RG_EXT. crbug.com/356871
       DCHECK_LE(plane, 1u);
       return GL_RGB_YCBCR_420V_CHROMIUM;
     case PIXEL_FORMAT_UYVY:
       DCHECK_EQ(0u, plane);
       return GL_RGB_YCBCR_422_CHROMIUM;
     default:
       NOTREACHED();
       return 0;
@@ skipping 12 matching lines @@
 
 inline size_t RoundUp(size_t value, size_t alignment) {
   DCHECK(IsPowerOfTwo(alignment));
   return ((value + (alignment - 1)) & ~(alignment - 1));
 }
 
 gfx::Size CodedSize(const gfx::Size& size, VideoPixelFormat format) {
   switch (format) {
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_YV12:
+    case PIXEL_FORMAT_YV12A:
     case PIXEL_FORMAT_NV12:
       return gfx::Size(RoundUp(size.width(), 2), RoundUp(size.height(), 2));
     case PIXEL_FORMAT_UYVY:
       return gfx::Size(RoundUp(size.width(), 2), size.height());
     default:
       NOTREACHED();
   }
   return gfx::Size();
 }
 
@@ skipping 252 matching lines @@
     // Create the VideoFrame backed by native textures.
     switch (format) {
       case PIXEL_FORMAT_I420:
       case PIXEL_FORMAT_YV12:
         released_video_frame_ = VideoFrame::WrapYUV420NativeTextures(
             mailbox_holders[VideoFrame::kYPlane],
             mailbox_holders[VideoFrame::kUPlane],
             mailbox_holders[VideoFrame::kVPlane], release_video_frame_callback,
             coded_size, visible_rect_, natural_size_, timestamp_);
         break;
+      case PIXEL_FORMAT_YV12A:
+        released_video_frame_ = VideoFrame::WrapYV12ANativeTextures(
+            mailbox_holders[VideoFrame::kYPlane],
+            mailbox_holders[VideoFrame::kUPlane],
+            mailbox_holders[VideoFrame::kVPlane],
+            mailbox_holders[VideoFrame::kAPlane], release_video_frame_callback,
+            coded_size, visible_rect_, natural_size_, timestamp_);
+        break;
       case PIXEL_FORMAT_NV12:
       case PIXEL_FORMAT_UYVY:
         released_video_frame_ = VideoFrame::WrapNativeTexture(
             format, mailbox_holders[VideoFrame::kYPlane],
             release_video_frame_callback, coded_size, visible_rect_,
             natural_size_, timestamp_);
         released_video_frame_->metadata()->SetBoolean(
             VideoFrameMetadata::ALLOW_OVERLAY, true);
         break;
       default:
@@ skipping 15 matching lines @@
       const gpu::SyncToken& release_sync_token) {
     frame_resources_return_cb.Run(frame_resources, release_sync_token);
   }
 
   uint8_t* data(size_t plane) const override {
     DCHECK(!released_video_frame_);
     DCHECK(IsValidPlane(plane, frame_resources_->format()));
     switch (frame_resources_->format()) {
       case PIXEL_FORMAT_I420:
       case PIXEL_FORMAT_YV12:
+      case PIXEL_FORMAT_YV12A:
       case PIXEL_FORMAT_UYVY:
         return static_cast<uint8_t*>(
             frame_resources_->GetPlaneResource(plane).gpu_memory_buffer->memory(
                 0));
       case PIXEL_FORMAT_NV12:
         return static_cast<uint8_t*>(
             frame_resources_->GetPlaneResource(0).gpu_memory_buffer->memory(
                 plane));
       default:
         NOTREACHED();
         return 0;
     }
   }
 
   int stride(size_t plane) const override {
     DCHECK(!released_video_frame_);
     DCHECK(IsValidPlane(plane, frame_resources_->format()));
     switch (frame_resources_->format()) {
       case PIXEL_FORMAT_I420:
       case PIXEL_FORMAT_YV12:
+      case PIXEL_FORMAT_YV12A:
       case PIXEL_FORMAT_UYVY:
         return frame_resources_->GetPlaneResource(plane)
             .gpu_memory_buffer->stride(0);
       case PIXEL_FORMAT_NV12:
         return frame_resources_->GetPlaneResource(0).gpu_memory_buffer->stride(
             plane);
       default:
         NOTREACHED();
         return 0;
     }
@@ skipping 143 matching lines @@
         FrameResources::Create(gpu_factories_, format, size);
     resources_pool_.push_back(frame_resources);
     return frame_resources;
   }
 
   static bool IsSupported(VideoPixelFormat format) {
     switch (format) {
       // TODO(dshwang): support more format. crbug.com/356871
       case PIXEL_FORMAT_I420:
       case PIXEL_FORMAT_YV12:
+      case PIXEL_FORMAT_YV12A:
       case PIXEL_FORMAT_NV12:
       case PIXEL_FORMAT_UYVY:
         return true;
       default:
         return false;
     }
   }
 
   // Task runner associated to the GL context provided by |gpu_factories_|.
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
@@ skipping 26 matching lines @@
 }
 
 // static
 size_t GpuMemoryBufferVideoFramePool::PlanesPerCopy(VideoPixelFormat format,
                                                     size_t plane) {
   return gfx::NumberOfPlanesForBufferFormat(
       GpuMemoryBufferFormat(format, plane));
 }
 
 }  // namespace media