cc: make resource keep video buffer format for hardware overlay.

cc/layers/video_layer_impl.cc

 // Copyright 2011 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/layers/video_layer_impl.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/single_release_callback_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "cc/trees/task_runner_provider.h"
 #include "media/base/video_frame.h"
 #include "ui/gfx/color_space.h"
 
 namespace cc {
 
+namespace {
+
+gfx::BufferFormat GetBufferFormat(media::VideoPixelFormat pixel_format) {
+  switch (pixel_format) {
+    case media::PIXEL_FORMAT_YV12:
+      return gfx::BufferFormat::YVU_420;
+    case media::PIXEL_FORMAT_NV12:
+      return gfx::BufferFormat::YUV_420_BIPLANAR;
+    case media::PIXEL_FORMAT_UYVY:
+      return gfx::BufferFormat::UYVY_422;
+    case media::PIXEL_FORMAT_ARGB:
+      return gfx::BufferFormat::BGRA_8888;
+    case media::PIXEL_FORMAT_XRGB:
+      return gfx::BufferFormat::BGRX_8888;
+    case media::PIXEL_FORMAT_RGB32:
+      return gfx::BufferFormat::RGBX_8888;
+    case media::PIXEL_FORMAT_Y8:
+      return gfx::BufferFormat::R_8;
+    case media::PIXEL_FORMAT_Y16:
+      return gfx::BufferFormat::RG_88;
+    case media::PIXEL_FORMAT_UNKNOWN:
+    case media::PIXEL_FORMAT_I420:
+    case media::PIXEL_FORMAT_YV16:
+    case media::PIXEL_FORMAT_YV12A:
+    case media::PIXEL_FORMAT_YV24:
+    case media::PIXEL_FORMAT_NV21:
+    case media::PIXEL_FORMAT_YUY2:
+    case media::PIXEL_FORMAT_RGB24:
+    case media::PIXEL_FORMAT_MJPEG:
+    case media::PIXEL_FORMAT_MT21:
+    case media::PIXEL_FORMAT_YUV420P9:
+    case media::PIXEL_FORMAT_YUV420P10:
+    case media::PIXEL_FORMAT_YUV422P9:
+    case media::PIXEL_FORMAT_YUV422P10:
+    case media::PIXEL_FORMAT_YUV444P9:
+    case media::PIXEL_FORMAT_YUV444P10:
+    case media::PIXEL_FORMAT_YUV420P12:
+    case media::PIXEL_FORMAT_YUV422P12:
+    case media::PIXEL_FORMAT_YUV444P12:
+    case media::PIXEL_FORMAT_I422:
+      break;
+  }
+  NOTREACHED();
+  return gfx::BufferFormat::BGRA_8888;
+}
+
+}  // namespace
+
 // static
 std::unique_ptr<VideoLayerImpl> VideoLayerImpl::Create(
     LayerTreeImpl* tree_impl,
     int id,
     VideoFrameProvider* provider,
     media::VideoRotation video_rotation) {
   DCHECK(tree_impl->task_runner_provider()->IsMainThreadBlocked());
   DCHECK(tree_impl->task_runner_provider()->IsImplThread());
 
   scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl =
       VideoFrameProviderClientImpl::Create(
           provider, tree_impl->GetVideoFrameControllerClient());
 
   return base::WrapUnique(new VideoLayerImpl(
       tree_impl, id, std::move(provider_client_impl), video_rotation));
 }
 
 VideoLayerImpl::VideoLayerImpl(
     LayerTreeImpl* tree_impl,
     int id,
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl,
     media::VideoRotation video_rotation)
     : LayerImpl(tree_impl, id),
       provider_client_impl_(std::move(provider_client_impl)),
       frame_(nullptr),
-      video_rotation_(video_rotation) {
+      video_rotation_(video_rotation),
+      frame_resource_type_(VideoFrameExternalResources::NONE),
+      frame_pixel_format_(media::PIXEL_FORMAT_UNKNOWN),
+      frame_resource_offset_(0.0f),
+      frame_resource_multiplier_(1.0f),
+      frame_bits_per_channel_(8) {
   set_may_contain_video(true);
 }
 
 VideoLayerImpl::~VideoLayerImpl() {
   if (!provider_client_impl_->Stopped()) {
     // In impl side painting, we may have a pending and active layer
     // associated with the video provider at the same time. Both have a ref
     // on the VideoFrameProviderClientImpl, but we stop when the first
     // LayerImpl (the one on the pending tree) is destroyed since we know
     // the main thread is blocked for this commit.
@@ skipping 40 matching lines @@
 
   if (!updater_) {
     updater_.reset(
         new VideoResourceUpdater(layer_tree_impl()->context_provider(),
                                  layer_tree_impl()->resource_provider()));
   }
 
   VideoFrameExternalResources external_resources =
       updater_->CreateExternalResourcesFromVideoFrame(frame_);
   frame_resource_type_ = external_resources.type;
+  frame_pixel_format_ = external_resources.pixel_format;
 
   if (external_resources.type ==
       VideoFrameExternalResources::SOFTWARE_RESOURCE) {
     software_resources_ = external_resources.software_resources;
     software_release_callback_ =
         external_resources.software_release_callback;
     return true;
   }
   frame_resource_offset_ = external_resources.offset;
   frame_resource_multiplier_ = external_resources.multiplier;
@@ skipping 191 matching lines @@
     case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
       DCHECK_EQ(frame_resources_.size(), 1u);
       if (frame_resources_.size() < 1u)
         break;
       gfx::Transform scale;
       scale.Scale(tex_width_scale, tex_height_scale);
       StreamVideoDrawQuad* stream_video_quad =
           render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
       stream_video_quad->SetNew(shared_quad_state, quad_rect, opaque_rect,
                                 visible_quad_rect, frame_resources_[0].id,
-                                frame_resources_[0].size_in_pixels, scale);
+                                frame_resources_[0].size_in_pixels,
+                                GetBufferFormat(frame_pixel_format_), scale);
       ValidateQuadResources(stream_video_quad);
       break;
     }
     case VideoFrameExternalResources::NONE:
       NOTIMPLEMENTED();
       break;
   }
 }
 
 void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) {
@@ skipping 38 matching lines @@
 void VideoLayerImpl::SetNeedsRedraw() {
   SetUpdateRect(gfx::UnionRects(update_rect(), gfx::Rect(bounds())));
   layer_tree_impl()->SetNeedsRedraw();
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc