Use real colorspace for DirectComposition overlays.

gpu/ipc/service/direct_composition_surface_win_unittest.cc

 // Copyright 2017 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 "gpu/ipc/service/direct_composition_surface_win.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 95 matching lines @@
   desc.Width = size.width();
   desc.Height = size.height();
   desc.MipLevels = 1;
   desc.ArraySize = 1;
   desc.Format = DXGI_FORMAT_NV12;
   desc.Usage = D3D11_USAGE_DEFAULT;
   desc.SampleDesc.Count = 1;
   desc.BindFlags = 0;
 
   std::vector<char> image_data(size.width() * size.height() * 3 / 2);
-  // Y, U, and V should all be Oxff. Output color should be pink.
-  memset(&image_data[0], 0xff, size.width() * size.height() * 3 / 2);
+  // Y, U, and V should all be 160. Output color should be pink.
+  memset(&image_data[0], 160, size.width() * size.height() * 3 / 2);
 
   D3D11_SUBRESOURCE_DATA data = {};
   data.pSysMem = (const void*)&image_data[0];
   data.SysMemPitch = size.width();
 
   base::win::ScopedComPtr<ID3D11Texture2D> texture;
   HRESULT hr =
       d3d11_device->CreateTexture2D(&desc, &data, texture.GetAddressOf());
   CHECK(SUCCEEDED(hr));
   return texture;
@@ skipping 181 matching lines @@
   base::win::ScopedComPtr<ID3D11Texture2D> texture =
       CreateNV12Texture(d3d11_device, texture_size);
 
   scoped_refptr<gl::GLImageDXGI> image_dxgi(
       new gl::GLImageDXGI(texture_size, nullptr));
   image_dxgi->SetTexture(texture, 0);
 
   ui::DCRendererLayerParams params(
       false, gfx::Rect(), 1, gfx::Transform(),
       std::vector<scoped_refptr<gl::GLImage>>{image_dxgi},
-      gfx::RectF(gfx::Rect(texture_size)), gfx::Rect(window_size), 0, 0, 1.0,
-      0);
+      gfx::RectF(gfx::Rect(texture_size)), gfx::Rect(window_size), 0, 0, 1.0, 0,
+      gfx::ColorSpace::CreateREC709());
   surface->ScheduleDCLayer(params);
 
   base::win::ScopedComPtr<IDXGISwapChain1> swap_chain =
       surface->GetLayerSwapChainForTesting(1);
   ASSERT_FALSE(swap_chain);
 
   EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
 
   swap_chain = surface->GetLayerSwapChainForTesting(1);
   ASSERT_TRUE(swap_chain);
@@ skipping 14 matching lines @@
 
   // It's the same image, so it should have the same swapchain.
   EXPECT_TRUE(SUCCEEDED(swap_chain->GetLastPresentCount(&last_present_count)));
   EXPECT_EQ(2u, last_present_count);
 
   // The size of the swapchain changed, so it should be recreated.
   ui::DCRendererLayerParams params2(
       false, gfx::Rect(), 1, gfx::Transform(),
       std::vector<scoped_refptr<gl::GLImage>>{image_dxgi},
       gfx::RectF(gfx::Rect(texture_size)), gfx::Rect(0, 0, 25, 25), 0, 0, 1.0,
-      0);
+      0, gfx::ColorSpace::CreateREC709());
   surface->ScheduleDCLayer(params2);
 
   EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface->SwapBuffers());
 
   base::win::ScopedComPtr<IDXGISwapChain1> swap_chain3 =
       surface->GetLayerSwapChainForTesting(1);
   EXPECT_NE(swap_chain2, swap_chain3);
 
   context = nullptr;
   DestroySurface(std::move(surface));
@@ skipping 94 matching lines @@
 bool AreColorsSimilar(int a, int b) {
   // The precise colors may differ depending on the video processor, so allow
   // a margin for error.
   const int kMargin = 10;
   return abs(SkColorGetA(a) - SkColorGetA(b)) < kMargin &&
          abs(SkColorGetR(a) - SkColorGetR(b)) < kMargin &&
          abs(SkColorGetG(a) - SkColorGetG(b)) < kMargin &&
          abs(SkColorGetB(a) - SkColorGetB(b)) < kMargin;
 }
 
-TEST_F(DirectCompositionPixelTest, VideoSwapchain) {
-  if (!CheckIfDCSupported())
-    return;
-  InitializeSurface();
-  surface_->SetEnableDCLayers(true);
-  gfx::Size window_size(100, 100);
+class DirectCompositionVideoPixelTest : public DirectCompositionPixelTest {
+ protected:
+  void TestVideo(const gfx::ColorSpace& color_space, SkColor expected_color) {
+    if (!CheckIfDCSupported())
+      return;
+    InitializeSurface();
+    surface_->SetEnableDCLayers(true);
+    gfx::Size window_size(100, 100);
 
-  scoped_refptr<gl::GLContext> context = gl::init::CreateGLContext(
-      nullptr, surface_.get(), gl::GLContextAttribs());
-  EXPECT_TRUE(surface_->Resize(window_size, 1.0, true));
+    scoped_refptr<gl::GLContext> context = gl::init::CreateGLContext(
+        nullptr, surface_.get(), gl::GLContextAttribs());
+    EXPECT_TRUE(surface_->Resize(window_size, 1.0, true));
 
-  base::win::ScopedComPtr<ID3D11Device> d3d11_device =
-      gl::QueryD3D11DeviceObjectFromANGLE();
+    base::win::ScopedComPtr<ID3D11Device> d3d11_device =
+        gl::QueryD3D11DeviceObjectFromANGLE();
 
-  gfx::Size texture_size(50, 50);
-  base::win::ScopedComPtr<ID3D11Texture2D> texture =
-      CreateNV12Texture(d3d11_device, texture_size);
+    gfx::Size texture_size(50, 50);
+    base::win::ScopedComPtr<ID3D11Texture2D> texture =
+        CreateNV12Texture(d3d11_device, texture_size);
 
-  scoped_refptr<gl::GLImageDXGI> image_dxgi(
-      new gl::GLImageDXGI(texture_size, nullptr));
-  image_dxgi->SetTexture(texture, 0);
+    scoped_refptr<gl::GLImageDXGI> image_dxgi(
+        new gl::GLImageDXGI(texture_size, nullptr));
+    image_dxgi->SetTexture(texture, 0);
 
-  ui::DCRendererLayerParams params(
-      false, gfx::Rect(), 1, gfx::Transform(),
-      std::vector<scoped_refptr<gl::GLImage>>{image_dxgi},
-      gfx::RectF(gfx::Rect(texture_size)), gfx::Rect(window_size), 0, 0, 1.0,
-      0);
-  surface_->ScheduleDCLayer(params);
+    ui::DCRendererLayerParams params(
+        false, gfx::Rect(), 1, gfx::Transform(),
+        std::vector<scoped_refptr<gl::GLImage>>{image_dxgi},
+        gfx::RectF(gfx::Rect(texture_size)), gfx::Rect(window_size), 0, 0, 1.0,
+        0, color_space);
+    surface_->ScheduleDCLayer(params);
 
-  EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface_->SwapBuffers());
-  Sleep(1000);
+    EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface_->SwapBuffers());
+    Sleep(1000);
 
-  SkColor expected_color = SkColorSetRGB(0xff, 0xb7, 0xff);
-  SkColor actual_color =
-      ReadBackWindowPixel(window_.hwnd(), gfx::Point(75, 75));
-  EXPECT_TRUE(AreColorsSimilar(expected_color, actual_color))
-      << std::hex << "Expected " << expected_color << " Actual "
-      << actual_color;
+    SkColor actual_color =
+        ReadBackWindowPixel(window_.hwnd(), gfx::Point(75, 75));
+    EXPECT_TRUE(AreColorsSimilar(expected_color, actual_color))
+        << std::hex << "Expected " << expected_color << " Actual "
+        << actual_color;
 
-  context = nullptr;
-  DestroySurface(std::move(surface_));
+    context = nullptr;
+    DestroySurface(std::move(surface_));
+  }
+};
+
+TEST_F(DirectCompositionVideoPixelTest, BT601) {
+  TestVideo(gfx::ColorSpace::CreateREC601(), SkColorSetRGB(0xdb, 0x81, 0xe8));
+}
+
+TEST_F(DirectCompositionVideoPixelTest, BT709) {
+  TestVideo(gfx::ColorSpace::CreateREC709(), SkColorSetRGB(0xe1, 0x90, 0xeb));
+}
+
+TEST_F(DirectCompositionVideoPixelTest, SRGB) {
+  // SRGB doesn't make sense on an NV12 input, but don't crash.
+  TestVideo(gfx::ColorSpace::CreateSRGB(), SkColorSetRGB(0xd7, 0x89, 0xe0));
+}
+
+TEST_F(DirectCompositionVideoPixelTest, SCRGBLinear) {
+  // SCRGB doesn't make sense on an NV12 input, but don't crash.
+  TestVideo(gfx::ColorSpace::CreateSCRGBLinear(),
+            SkColorSetRGB(0xd7, 0x89, 0xe0));
+}
+TEST_F(DirectCompositionVideoPixelTest, InvalidColorSpace) {
+  // Invalid color space should be treated as BT.709
+  TestVideo(gfx::ColorSpace(), SkColorSetRGB(0xe1, 0x90, 0xeb));
 }
 
 TEST_F(DirectCompositionPixelTest, SoftwareVideoSwapchain) {
   if (!CheckIfDCSupported())
     return;
   InitializeSurface();
   surface_->SetEnableDCLayers(true);
   gfx::Size window_size(100, 100);
 
   scoped_refptr<gl::GLContext> context = gl::init::CreateGLContext(
@@ skipping 17 matching lines @@
   y_image->Initialize(new base::RefCountedBytes(y_data),
                       gfx::BufferFormat::R_8);
   scoped_refptr<gl::GLImageRefCountedMemory> uv_image(
       new gl::GLImageRefCountedMemory(uv_size, GL_BGRA_EXT));
   uv_image->Initialize(new base::RefCountedBytes(uv_data),
                        gfx::BufferFormat::RG_88);
 
   ui::DCRendererLayerParams params(
       false, gfx::Rect(), 1, gfx::Transform(),
       std::vector<scoped_refptr<gl::GLImage>>{y_image, uv_image},
-      gfx::RectF(gfx::Rect(y_size)), gfx::Rect(window_size), 0, 0, 1.0, 0);
+      gfx::RectF(gfx::Rect(y_size)), gfx::Rect(window_size), 0, 0, 1.0, 0,
+      gfx::ColorSpace::CreateREC709());
   surface_->ScheduleDCLayer(params);
 
   EXPECT_EQ(gfx::SwapResult::SWAP_ACK, surface_->SwapBuffers());
   Sleep(1000);
 
   SkColor expected_color = SkColorSetRGB(0xff, 0xb7, 0xff);
   SkColor actual_color =
       ReadBackWindowPixel(window_.hwnd(), gfx::Point(75, 75));
   EXPECT_TRUE(AreColorsSimilar(expected_color, actual_color))
       << std::hex << "Expected " << expected_color << " Actual "
       << actual_color;
 
   context = nullptr;
   DestroySurface(std::move(surface_));
 }
+
 }  // namespace
 }  // namespace gpu