Video Color Managament

cc/output/renderer_pixeltest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 #include <memory>
 
 #include "base/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
 #include "cc/test/fake_raster_source.h"
 #include "cc/test/fake_recording_source.h"
 #include "cc/test/pixel_test.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "media/base/video_color_space.h"
 #include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h"
 #include "third_party/skia/include/effects/SkColorMatrixFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
@@ skipping 170 matching lines @@
     ResourceProvider* resource_provider) {
   const bool with_alpha = (video_frame->format() == media::PIXEL_FORMAT_YV12A);
   YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601;
   int video_frame_color_space;
   if (video_frame->metadata()->GetInteger(
           media::VideoFrameMetadata::COLOR_SPACE, &video_frame_color_space) &&
       video_frame_color_space == media::COLOR_SPACE_JPEG) {
     color_space = YUVVideoDrawQuad::JPEG;
   }
 
+  media::VideoColorSpace video_color_space(video_frame.get());
+
   const gfx::Rect opaque_rect(0, 0, 0, 0);
 
   if (with_alpha) {
     memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value,
            video_frame->stride(media::VideoFrame::kAPlane) *
                video_frame->rows(media::VideoFrame::kAPlane));
   }
 
   VideoFrameExternalResources resources =
       video_resource_updater->CreateExternalResourcesFromVideoFrame(
@@ skipping 45 matching lines @@
   gfx::RectF uv_tex_coord_rect(tex_coord_rect.x() * uv_tex_size.width(),
                                tex_coord_rect.y() * uv_tex_size.height(),
                                tex_coord_rect.width() * uv_tex_size.width(),
                                tex_coord_rect.height() * uv_tex_size.height());
 
   YUVVideoDrawQuad* yuv_quad =
       render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
   yuv_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
                    ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size,
                    uv_tex_size, y_resource, u_resource, v_resource, a_resource,
-                   color_space, 0.0f, 1.0f);
+                   color_space, video_color_space, 0.0f, 1.0f);
 }
 
 // Upshift video frame to 10 bit.
 scoped_refptr<media::VideoFrame> CreateHighbitVideoFrame(
     media::VideoFrame* video_frame) {
   media::VideoPixelFormat format;
   switch (video_frame->format()) {
     case media::PIXEL_FORMAT_I420:
     case media::PIXEL_FORMAT_YV12:
       format = media::PIXEL_FORMAT_YUV420P10;
@@ skipping 182 matching lines @@
   memset(video_frame->data(media::VideoFrame::kVPlane), v,
          video_frame->stride(media::VideoFrame::kVPlane) *
              video_frame->rows(media::VideoFrame::kVPlane));
 
   uint8_t alpha_value = is_transparent ? 0 : 128;
   CreateTestYUVVideoDrawQuad_FromVideoFrame(
       shared_state, video_frame, alpha_value, tex_coord_rect, render_pass,
       video_resource_updater, rect, visible_rect, resource_provider);
 }
 
-void CreateTestYUVVideoDrawQuad_NV12(const SharedQuadState* shared_state,
-                                     media::ColorSpace video_frame_color_space,
-                                     const gfx::RectF& tex_coord_rect,
-                                     uint8_t y,
-                                     uint8_t u,
-                                     uint8_t v,
-                                     RenderPass* render_pass,
-                                     const gfx::Rect& rect,
-                                     const gfx::Rect& visible_rect,
-                                     ResourceProvider* resource_provider) {
+void CreateTestYUVVideoDrawQuad_NV12(
+    const SharedQuadState* shared_state,
+    media::ColorSpace video_frame_color_space,
+    const media::VideoColorSpace& video_color_space,
+    const gfx::RectF& tex_coord_rect,
+    uint8_t y,
+    uint8_t u,
+    uint8_t v,
+    RenderPass* render_pass,
+    const gfx::Rect& rect,
+    const gfx::Rect& visible_rect,
+    ResourceProvider* resource_provider) {
   YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601;
   if (video_frame_color_space == media::COLOR_SPACE_JPEG) {
     color_space = YUVVideoDrawQuad::JPEG;
   }
 
   const gfx::Rect opaque_rect(0, 0, 0, 0);
   const gfx::Size ya_tex_size = rect.size();
   const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize(
       media::PIXEL_FORMAT_NV12, media::VideoFrame::kUVPlane, rect.size());
 
@@ skipping 21 matching lines @@
   gfx::RectF uv_tex_coord_rect(tex_coord_rect.x() * uv_tex_size.width(),
                                tex_coord_rect.y() * uv_tex_size.height(),
                                tex_coord_rect.width() * uv_tex_size.width(),
                                tex_coord_rect.height() * uv_tex_size.height());
 
   YUVVideoDrawQuad* yuv_quad =
       render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
   yuv_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
                    ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size,
                    uv_tex_size, y_resource, u_resource, v_resource, a_resource,
-                   color_space, 0.0f, 1.0f);
+                   color_space, video_color_space, 0.0f, 1.0f);
 }
 
 typedef ::testing::Types<GLRenderer,
                          SoftwareRenderer,
                          GLRendererWithExpandedViewport,
                          SoftwareRendererWithExpandedViewport> RendererTypes;
 TYPED_TEST_CASE(RendererPixelTest, RendererTypes);
 
 template <typename RendererType>
 class SoftwareRendererPixelTest : public RendererPixelTest<RendererType> {};
@@ skipping 678 matching lines @@
   gfx::Rect rect(this->device_viewport_size_);
 
   RenderPassId id(1, 1);
   std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
 
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
   CreateTestYUVVideoDrawQuad_NV12(
-      shared_state, media::COLOR_SPACE_JPEG, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-      149, 43, 21, pass.get(), rect, rect, resource_provider_.get());
+      shared_state, media::COLOR_SPACE_JPEG,
+      media::VideoColorSpace(media::COLOR_SPACE_JPEG),
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), rect, rect,
+      resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(std::move(pass));
 
   EXPECT_TRUE(this->RunPixelTest(&pass_list,
                                  base::FilePath(FILE_PATH_LITERAL("green.png")),
                                  FuzzyPixelOffByOneComparator(true)));
 }
 
 // Test that a YUV video doesn't bleed outside of its tex coords when the
@@ skipping 1935 matching lines @@
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc