Relanding 1143663007: VideoFrame: Separate Pixel Format from Storage Type.

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"
@@ skipping 119 matching lines @@
 
 void VideoResourceUpdater::DeleteResource(ResourceList::iterator resource_it) {
   DCHECK_EQ(resource_it->ref_count, 0);
   resource_provider_->DeleteResource(resource_it->resource_id);
   all_resources_.erase(resource_it);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::
     CreateExternalResourcesFromVideoFrame(
         const scoped_refptr<media::VideoFrame>& video_frame) {
-  if (!VerifyFrame(video_frame))
+  if (video_frame->format() == media::VideoFrame::UNKNOWN)
     return VideoFrameExternalResources();
 
-  if (video_frame->format() == media::VideoFrame::NATIVE_TEXTURE)
+  if (video_frame->storage_type() == media::VideoFrame::STORAGE_TEXTURE)
     return CreateForHardwarePlanes(video_frame);
   else
     return CreateForSoftwarePlanes(video_frame);
 }
 
-bool VideoResourceUpdater::VerifyFrame(
-    const scoped_refptr<media::VideoFrame>& video_frame) {
-  switch (video_frame->format()) {
-    // Acceptable inputs.
-    case media::VideoFrame::YV12:
-    case media::VideoFrame::I420:
-    case media::VideoFrame::YV12A:
-    case media::VideoFrame::YV16:
-    case media::VideoFrame::YV24:
-    case media::VideoFrame::NATIVE_TEXTURE:
-#if defined(VIDEO_HOLE)
-    case media::VideoFrame::HOLE:
-#endif  // defined(VIDEO_HOLE)
-    case media::VideoFrame::ARGB:
-      return true;
-
-    // Unacceptable inputs. ¯\(°_o)/¯
-    case media::VideoFrame::UNKNOWN:
-    case media::VideoFrame::NV12:
-      break;
-  }
-  return false;
-}
-
 // For frames that we receive in software format, determine the dimensions of
 // each plane in the frame.
 static gfx::Size SoftwarePlaneDimension(
     const scoped_refptr<media::VideoFrame>& input_frame,
     bool software_compositor,
     size_t plane_index) {
   if (!software_compositor) {
     return media::VideoFrame::PlaneSize(
         input_frame->format(), plane_index, input_frame->coded_size());
   }
   return input_frame->coded_size();
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForSoftwarePlanes");
-  media::VideoFrame::Format input_frame_format = video_frame->format();
+  const media::VideoFrame::Format input_frame_format = video_frame->format();
 
 #if defined(VIDEO_HOLE)
-  if (input_frame_format == media::VideoFrame::HOLE) {
+  if (video_frame->storage_type() == media::VideoFrame::STORAGE_HOLE) {
     VideoFrameExternalResources external_resources;
     external_resources.type = VideoFrameExternalResources::HOLE;
     return external_resources;
   }
 #endif  // defined(VIDEO_HOLE)
 
   // Only YUV software video frames are supported.
-  if (input_frame_format != media::VideoFrame::YV12 &&
-      input_frame_format != media::VideoFrame::I420 &&
-      input_frame_format != media::VideoFrame::YV12A &&
-      input_frame_format != media::VideoFrame::YV16 &&
-      input_frame_format != media::VideoFrame::YV24) {
-    NOTREACHED() << input_frame_format;
+  if (!media::VideoFrame::IsYuvPlanar(input_frame_format)) {
+    NOTREACHED() << media::VideoFrame::FormatToString(input_frame_format);
     return VideoFrameExternalResources();
   }
 
-  bool software_compositor = context_provider_ == NULL;
+  const bool software_compositor = context_provider_ == NULL;
 
   ResourceFormat output_resource_format =
       resource_provider_->yuv_resource_format();
   size_t output_plane_count = media::VideoFrame::NumPlanes(input_frame_format);
 
   // TODO(skaslev): If we're in software compositing mode, we do the YUV -> RGB
   // conversion here. That involves an extra copy of each frame to a bitmap.
   // Obviously, this is suboptimal and should be addressed once ubercompositor
   // starts shaping up.
   if (software_compositor) {
@@ skipping 167 matching lines @@
   // returned by the compositor and emit a WaitSyncPointCHROMIUM on
   // |video_frame|'s previous sync point using the current GL context.
   SyncPointClientImpl client(updater->context_provider_->ContextGL(),
                              sync_point);
   video_frame->UpdateReleaseSyncPoint(&client);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForHardwarePlanes(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForHardwarePlanes");
-  media::VideoFrame::Format frame_format = video_frame->format();
-
-  DCHECK_EQ(frame_format, media::VideoFrame::NATIVE_TEXTURE);
+  DCHECK_EQ(video_frame->storage_type(), media::VideoFrame::STORAGE_TEXTURE);
   if (!context_provider_)
     return VideoFrameExternalResources();
 
-  size_t textures =
-      media::VideoFrame::NumTextures(video_frame->texture_format());
+  const size_t textures = media::VideoFrame::NumPlanes(video_frame->format());
   DCHECK_GE(textures, 1u);
   VideoFrameExternalResources external_resources;
-  switch (video_frame->texture_format()) {
-    case media::VideoFrame::TEXTURE_RGBA:
-    case media::VideoFrame::TEXTURE_RGB:
+  switch (video_frame->format()) {
+    case media::VideoFrame::ARGB:
+    case media::VideoFrame::XRGB:
       DCHECK_EQ(1u, textures);
       switch (video_frame->mailbox_holder(0).texture_target) {
         case GL_TEXTURE_2D:
-          if (video_frame->texture_format() == media::VideoFrame::TEXTURE_RGB)
-            external_resources.type = VideoFrameExternalResources::RGB_RESOURCE;
-          else
-            external_resources.type =
-                VideoFrameExternalResources::RGBA_RESOURCE;
+          external_resources.type =
+              (video_frame->format() == media::VideoFrame::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();
       }
       break;
-    case media::VideoFrame::TEXTURE_YUV_420:
+    case media::VideoFrame::I420:
       external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
       break;
+#if defined(OS_MACOSX) || defined(OS_CHROMEOS)
+    case media::VideoFrame::NV12:
+#endif
+    case media::VideoFrame::YV12:
+    case media::VideoFrame::YV16:
+    case media::VideoFrame::YV24:
+    case media::VideoFrame::YV12A:
+    case media::VideoFrame::UNKNOWN:
+      DLOG(ERROR) << "Unsupported Texture format"
+                  << media::VideoFrame::FormatToString(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));
     external_resources.mailboxes.back().set_allow_overlay(
         video_frame->allow_overlay());
@@ skipping 32 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