Use real colorspace for DirectComposition overlays.

gpu/ipc/service/direct_composition_surface_win.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 <d3d11_1.h>
 #include <dcomptypes.h>
 
 #include <deque>
@@ skipping 536 matching lines @@
     swap_chain_->GetBuffer(0, IID_PPV_ARGS(texture.GetAddressOf()));
     D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC out_desc = {};
     out_desc.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D;
     out_desc.Texture2D.MipSlice = 0;
     HRESULT hr = video_device_->CreateVideoProcessorOutputView(
         texture.Get(), video_processor_enumerator_.Get(), &out_desc,
         out_view_.GetAddressOf());
     CHECK(SUCCEEDED(hr));
   }
 
-  // TODO(jbauman): Use correct colorspace.
-  gfx::ColorSpace src_color_space = gfx::ColorSpace::CreateREC709();
+  gfx::ColorSpace src_color_space = params.color_space;
   base::win::ScopedComPtr<ID3D11VideoContext1> context1;
   if (SUCCEEDED(video_context_.CopyTo(context1.GetAddressOf()))) {
     context1->VideoProcessorSetStreamColorSpace1(
         video_processor_.Get(), 0,
         gfx::ColorSpaceWin::GetDXGIColorSpace(src_color_space));
   } else {
     // This can't handle as many different types of color spaces, so use it
     // only if ID3D11VideoContext1 isn't available.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE color_space =
         gfx::ColorSpaceWin::GetD3D11ColorSpace(src_color_space);
     video_context_->VideoProcessorSetStreamColorSpace(video_processor_.Get(), 0,
                                                       &color_space);
   }
 
   gfx::ColorSpace output_color_space =
       is_yuy2_swapchain_ ? src_color_space : gfx::ColorSpace::CreateSRGB();
   if (base::FeatureList::IsEnabled(kFallbackBT709VideoToBT601) &&
       (output_color_space == gfx::ColorSpace::CreateREC709())) {
     output_color_space = gfx::ColorSpace::CreateREC601();
   }
 
   base::win::ScopedComPtr<IDXGISwapChain3> swap_chain3;
   if (SUCCEEDED(swap_chain_.CopyTo(swap_chain3.GetAddressOf()))) {
     DXGI_COLOR_SPACE_TYPE color_space =
         gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space);
+    if (is_yuy2_swapchain_) {
+      // Swapchains with YUY2 textures can't have RGB color spaces.
+      switch (color_space) {
+        case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709:
+        case DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709:
+          color_space = DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709;
+          break;
+
+        case DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709:
+          color_space = DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709;
+          break;
+
+        case DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020:
+          color_space = DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020;
+          break;
+
+        case DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020:
+        case DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020:
+          color_space = DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020;
+          break;
+
+        case DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020:
+          color_space = DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020;
+          break;
+
+        default:
+          break;
+      }
+    }
     HRESULT hr = swap_chain3->SetColorSpace1(color_space);
-    CHECK(SUCCEEDED(hr));
-    if (context1) {
-      context1->VideoProcessorSetOutputColorSpace1(video_processor_.Get(),
-                                                   color_space);
-    } else {
-      D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
-          gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
-      video_context_->VideoProcessorSetOutputColorSpace(video_processor_.Get(),
-                                                        &d3d11_color_space);
+    if (SUCCEEDED(hr)) {
+      if (context1) {
+        context1->VideoProcessorSetOutputColorSpace1(video_processor_.Get(),
+                                                     color_space);
+      } else {
+        D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
+            gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
+        video_context_->VideoProcessorSetOutputColorSpace(
+            video_processor_.Get(), &d3d11_color_space);
+      }
     }
   }
 
   {
     D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC in_desc = {};
     in_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
     in_desc.Texture2D.ArraySlice = input_level;
     base::win::ScopedComPtr<ID3D11VideoProcessorInputView> in_view;
     HRESULT hr = video_device_->CreateVideoProcessorInputView(
         input_texture.Get(), video_processor_enumerator_.Get(), &in_desc,
@@ skipping 281 matching lines @@
   TRACE_EVENT1("gpu", "DCLayerTree::CommitAndClearPendingOverlays", "size",
                pending_overlays_.size());
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.OverlaysUsed",
                         !pending_overlays_.empty());
   // Add an overlay with z-order 0 representing the main plane.
   gfx::Size surface_size = surface_->GetSize();
   pending_overlays_.push_back(base::MakeUnique<ui::DCRendererLayerParams>(
       false, gfx::Rect(), 0, gfx::Transform(),
       std::vector<scoped_refptr<gl::GLImage>>(),
       gfx::RectF(gfx::SizeF(surface_size)), gfx::Rect(surface_size), 0, 0, 1.0,
-      0));
+      0, gfx::ColorSpace()));
 
   // TODO(jbauman): Reuse swapchains that are switched between overlays and
   // underlays.
   std::sort(pending_overlays_.begin(), pending_overlays_.end(),
             [](const auto& a, const auto& b) -> bool {
               return a->z_order < b->z_order;
             });
 
   while (visual_info_.size() > pending_overlays_.size()) {
     visual_info_.back().clip_visual->RemoveAllVisuals();
@@ skipping 374 matching lines @@
 DirectCompositionSurfaceWin::GetWindowTaskRunnerForTesting() {
   return child_window_.GetTaskRunnerForTesting();
 }
 
 base::win::ScopedComPtr<IDXGISwapChain1>
 DirectCompositionSurfaceWin::GetLayerSwapChainForTesting(size_t index) const {
   return layer_tree_->GetLayerSwapChainForTesting(index);
 }
 
 }  // namespace gpu