Add feature flag to convert BT.709 to BT.601 video in 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 "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/switches.h"
 #include "ui/display/display_switches.h"
+#include "ui/gfx/color_space_win.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/dc_renderer_layer_params.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_dxgi.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_make_current.h"
 
 #ifndef EGL_ANGLE_flexible_surface_compatibility
 #define EGL_ANGLE_flexible_surface_compatibility 1
 #define EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE 0x33A6
 #endif /* EGL_ANGLE_flexible_surface_compatibility */
 
 #ifndef EGL_ANGLE_d3d_texture_client_buffer
 #define EGL_ANGLE_d3d_texture_client_buffer 1
 #define EGL_D3D_TEXTURE_ANGLE 0x33A3
 #endif /* EGL_ANGLE_d3d_texture_client_buffer */
 
 namespace gpu {
 namespace {
 
+// Some drivers fail to correctly handle BT.709 video in overlays. This flag
+// converts them to BT.601 in the video processor.
+const base::Feature kFallbackBT709VideoToBT601{
+    "FallbackBT709VideoToBT601", base::FEATURE_ENABLED_BY_DEFAULT};
+
 // This class is used to make sure a specified surface isn't current, and upon
 // destruction it will make the surface current again if it had been before.
 class ScopedReleaseCurrent {
  public:
   explicit ScopedReleaseCurrent(gl::GLSurface* this_surface) {
     gl::GLContext* current_context = gl::GLContext::GetCurrent();
     bool was_current =
         current_context && current_context->IsCurrent(this_surface);
     if (was_current) {
       make_current_.emplace(current_context, this_surface);
@@ skipping 117 matching lines @@
   bool InitializeVideoProcessor(const gfx::Size& in_size,
                                 const gfx::Size& out_size);
   void ReallocateSwapChain();
 
   DCLayerTree* surface_;
   PFN_DCOMPOSITION_CREATE_SURFACE_HANDLE create_surface_handle_function_;
 
   gfx::Size swap_chain_size_;
   gfx::Size processor_input_size_;
   gfx::Size processor_output_size_;
+  bool is_yuy2_swapchain_ = false;
 
   // This is the scale from the swapchain size to the size of the contents
   // onscreen.
   float swap_chain_scale_x_ = 0.0f;
   float swap_chain_scale_y_ = 0.0f;
 
   // This is the GLImage that was presented in the last frame.
   scoped_refptr<gl::GLImageDXGI> last_gl_image_;
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device_;
@@ skipping 128 matching lines @@
     base::win::ScopedComPtr<ID3D11Texture2D> texture;
     swap_chain_->GetBuffer(0, IID_PPV_ARGS(texture.Receive()));
     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_.Receive());
     CHECK(SUCCEEDED(hr));
   }
+
+  // TODO(jbauman): Use correct colorspace.
+  gfx::ColorSpace src_color_space = gfx::ColorSpace::CreateREC709();
+  base::win::ScopedComPtr<ID3D11VideoContext1> context1;
+  if (SUCCEEDED(video_context_.QueryInterface(context1.Receive()))) {
+    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_.QueryInterface(swap_chain3.Receive()))) {
+    DXGI_COLOR_SPACE_TYPE color_space =
+        gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space);
+    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);
+    }
+  }
+
   {
     D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC in_desc = {};
     in_desc.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
     in_desc.Texture2D.ArraySlice = (UINT)image_dxgi->level();
     base::win::ScopedComPtr<ID3D11VideoProcessorInputView> in_view;
     HRESULT hr = video_device_->CreateVideoProcessorInputView(
         image_dxgi->texture().get(), video_processor_enumerator_.get(),
         &in_desc, in_view.Receive());
     CHECK(SUCCEEDED(hr));
 
@@ skipping 79 matching lines @@
   desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
   desc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
   desc.Flags =
       DXGI_SWAP_CHAIN_FLAG_YUV_VIDEO | DXGI_SWAP_CHAIN_FLAG_FULLSCREEN_VIDEO;
 
   HANDLE handle;
   create_surface_handle_function_(COMPOSITIONOBJECT_ALL_ACCESS, nullptr,
                                   &handle);
   swap_chain_handle_.Set(handle);
 
+  is_yuy2_swapchain_ = true;
   // The composition surface handle isn't actually used, but
   // CreateSwapChainForComposition can't create YUY2 swapchains.
   HRESULT hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
       d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
       swap_chain_.Receive());
 
-  bool yuy2_swapchain = true;
-
   if (FAILED(hr)) {
     // This should not be hit in production but is a simple fallback for
     // testing on systems without YUY2 swapchain support.
     DLOG(ERROR) << "YUY2 creation failed with " << std::hex << hr
                 << ". Falling back to BGRA";
+    is_yuy2_swapchain_ = false;
     desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
     desc.Flags = 0;
     hr = media_factory->CreateSwapChainForCompositionSurfaceHandle(
         d3d11_device_.get(), swap_chain_handle_.Get(), &desc, nullptr,
         swap_chain_.Receive());
     CHECK(SUCCEEDED(hr));
-    yuy2_swapchain = false;
-  } else {
-    // This is a sensible default colorspace for most videos.
-    // TODO(jbauman): Use correct colorspace.
-    base::win::ScopedComPtr<IDXGISwapChain3> swap_chain3;
-    swap_chain_.QueryInterface(swap_chain3.Receive());
-    hr = swap_chain3->SetColorSpace1(
-        DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709);
-    CHECK(SUCCEEDED(hr));
   }
   UMA_HISTOGRAM_BOOLEAN("GPU.DirectComposition.SwapchainFormat",
-                        yuy2_swapchain);
+                        is_yuy2_swapchain_);
   out_view_.Reset();
 }
 
 void DCLayerTree::InitVisual(size_t i) {
   DCHECK_GT(visual_info_.size(), i);
   VisualInfo* visual_info = &visual_info_[i];
   if (visual_info->content_visual)
     return;
   DCHECK(!visual_info->clip_visual);
   base::win::ScopedComPtr<IDCompositionVisual2> visual;
@@ skipping 551 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