Add support for converting I420 software frames into NV12 hardware frames

cc/resources/video_resource_updater.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
 #include "media/blink/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 namespace {
 
 const ResourceFormat kRGBResourceFormat = RGBA_8888;
 
+VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
+    media::VideoFrame* video_frame) {
+  switch (video_frame->format()) {
+    case media::PIXEL_FORMAT_ARGB:
+    case media::PIXEL_FORMAT_XRGB:
+    case media::PIXEL_FORMAT_UYVY:

[Daniele Castagna, 2015/08/31 16:28:14]

Are we return VideoFrameExternalResources::IO_SURFACE since we need an
IOSurfaceDrawQuad for this format to be promoted to overlay?

[Andre, 2015/08/31 18:29:31]

That's right. It's also a better fit because it has one resource id while
YUV_VIDEO_RESOURCE has 3.

+      switch (video_frame->mailbox_holder(0).texture_target) {
+        case GL_TEXTURE_2D:
+          return (video_frame->format() == media::PIXEL_FORMAT_XRGB)
+                     ? VideoFrameExternalResources::RGB_RESOURCE
+                     : VideoFrameExternalResources::RGBA_RESOURCE;
+        case GL_TEXTURE_EXTERNAL_OES:
+          return VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
+        case GL_TEXTURE_RECTANGLE_ARB:
+          return VideoFrameExternalResources::IO_SURFACE;
+        default:
+          NOTREACHED();
+          break;
+      }
+      break;
+    case media::PIXEL_FORMAT_I420:
+      return VideoFrameExternalResources::YUV_RESOURCE;
+    case media::PIXEL_FORMAT_NV12:
+      DCHECK_EQ(static_cast<uint32_t>(GL_TEXTURE_RECTANGLE_ARB),
+                video_frame->mailbox_holder(0).texture_target);
+      return VideoFrameExternalResources::IO_SURFACE;
+    case media::PIXEL_FORMAT_YV12:
+    case media::PIXEL_FORMAT_YV16:
+    case media::PIXEL_FORMAT_YV24:
+    case media::PIXEL_FORMAT_YV12A:
+    case media::PIXEL_FORMAT_UNKNOWN:
+      break;
+  }
+  return VideoFrameExternalResources::NONE;
+}
+
 class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
  public:
   explicit SyncPointClientImpl(gpu::gles2::GLES2Interface* gl,
                                uint32 sync_point)
       : gl_(gl), sync_point_(sync_point) {}
   ~SyncPointClientImpl() override {}
   uint32 InsertSyncPoint() override {
     if (sync_point_)
       return sync_point_;
     return gl_->InsertSyncPointCHROMIUM();
@@ skipping 330 matching lines @@
   video_frame->UpdateReleaseSyncPoint(&client);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
   DCHECK(video_frame->HasTextures());
   if (!context_provider_)
     return VideoFrameExternalResources();
 
-  const size_t textures = media::VideoFrame::NumPlanes(video_frame->format());
-  DCHECK_GE(textures, 1u);
   VideoFrameExternalResources external_resources;
   external_resources.read_lock_fences_enabled = true;
-  switch (video_frame->format()) {
-    case media::PIXEL_FORMAT_ARGB:
-    case media::PIXEL_FORMAT_XRGB:
-    case media::PIXEL_FORMAT_UYVY:
-      DCHECK_EQ(1u, textures);
-      switch (video_frame->mailbox_holder(0).texture_target) {
-        case GL_TEXTURE_2D:
-          external_resources.type =
-              (video_frame->format() == media::PIXEL_FORMAT_XRGB)
-                  ? VideoFrameExternalResources::RGB_RESOURCE
-                  : VideoFrameExternalResources::RGBA_RESOURCE;
-          break;
-        case GL_TEXTURE_EXTERNAL_OES:
-          external_resources.type =
-              VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE;
-          break;
-        case GL_TEXTURE_RECTANGLE_ARB:
-          external_resources.type = VideoFrameExternalResources::IO_SURFACE;
-          break;
-        default:
-          NOTREACHED();
-          return VideoFrameExternalResources();
-      }
+
+  external_resources.type = ResourceTypeForVideoFrame(video_frame.get());
+  if (external_resources.type == VideoFrameExternalResources::NONE) {
+    DLOG(ERROR) << "Unsupported Texture format"
+                << media::VideoPixelFormatToString(video_frame->format());
+    return external_resources;
+  }
+
+  const size_t num_planes = media::VideoFrame::NumPlanes(video_frame->format());
+  for (size_t i = 0; i < num_planes; ++i) {
+    const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
+    if (mailbox_holder.mailbox.IsZero())
       break;
-    case media::PIXEL_FORMAT_I420:
-      external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
-      break;
-    case media::PIXEL_FORMAT_NV12:
-    case media::PIXEL_FORMAT_YV12:
-    case media::PIXEL_FORMAT_YV16:
-    case media::PIXEL_FORMAT_YV24:
-    case media::PIXEL_FORMAT_YV12A:
-    case media::PIXEL_FORMAT_UNKNOWN:
-      DLOG(ERROR) << "Unsupported Texture format"
-                  << media::VideoPixelFormatToString(video_frame->format());
-      return external_resources;
-  }
-  DCHECK_NE(VideoFrameExternalResources::NONE, external_resources.type);
-
-  for (size_t i = 0; i < textures; ++i) {
-    const gpu::MailboxHolder& mailbox_holder = video_frame->mailbox_holder(i);
     external_resources.mailboxes.push_back(
         TextureMailbox(mailbox_holder.mailbox, mailbox_holder.texture_target,
                        mailbox_holder.sync_point, video_frame->coded_size(),
                        video_frame->metadata()->IsTrue(
                            media::VideoFrameMetadata::ALLOW_OVERLAY)));
     external_resources.release_callbacks.push_back(
         base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
   }
   return external_resources;
 }
@@ skipping 27 matching lines @@
     resource_it->ref_count = 0;
     updater->DeleteResource(resource_it);
     return;
   }
 
   --resource_it->ref_count;
   DCHECK_GE(resource_it->ref_count, 0);
 }
 
 }  // namespace cc