FP16 mode gamma fix

media/gpu/dxva_video_decode_accelerator_win.cc

 // Copyright (c) 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 "media/gpu/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 2814 matching lines @@
 
     video_context_->VideoProcessorSetStreamColorSpace(d3d11_processor_.get(), 0,
                                                       &d3d11_color_space);
     dx11_converter_output_color_space_ = color_space;
   } else {
     dx11_converter_output_color_space_ = gfx::ColorSpace::CreateSRGB();
     if (use_color_info_ || use_fp16_) {
       base::win::ScopedComPtr<ID3D11VideoContext1> video_context1;
       HRESULT hr = video_context_.QueryInterface(video_context1.Receive());
       if (SUCCEEDED(hr)) {
-        if (use_fp16_ && base::CommandLine::ForCurrentProcess()->HasSwitch(
-                             switches::kEnableHDR)) {
+        if (use_fp16_ &&
+            base::CommandLine::ForCurrentProcess()->HasSwitch(
+                switches::kEnableHDR) &&
+            color_space.IsHDR()) {
+          // Note, we only use the SCRGBLinear output color space when
+          // the input is PQ, because nvidia drivers will not convert
+          // G22 to G10 for some reason.
           dx11_converter_output_color_space_ =
               gfx::ColorSpace::CreateSCRGBLinear();
         }
         // Since the video processor doesn't support HLG, let's just do the
         // YUV->RGB conversion and let the output color space be HLG.
         // This won't work well unless color management is on, but if color
         // management is off we don't support HLG anyways.
         if (color_space ==
             gfx::ColorSpace(gfx::ColorSpace::PrimaryID::BT2020,
                             gfx::ColorSpace::TransferID::ARIB_STD_B67,
                             gfx::ColorSpace::MatrixID::BT709,
                             gfx::ColorSpace::RangeID::LIMITED)) {
           video_context1->VideoProcessorSetStreamColorSpace1(
               d3d11_processor_.get(), 0,
               DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020);
           video_context1->VideoProcessorSetOutputColorSpace1(
               d3d11_processor_.get(),
               DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020);
           dx11_converter_output_color_space_ = color_space.GetAsFullRangeRGB();
         } else {
+          DVLOG(2) << "input color space: " << color_space
+                   << " DXGIColorSpace: "
+                   << gfx::ColorSpaceWin::GetDXGIColorSpace(color_space);
+          DVLOG(2) << "output color space:"
+                   << dx11_converter_output_color_space_ << " DXGIColorSpace: "
+                   << gfx::ColorSpaceWin::GetDXGIColorSpace(
+                          dx11_converter_output_color_space_);
           video_context1->VideoProcessorSetStreamColorSpace1(
               d3d11_processor_.get(), 0,
               gfx::ColorSpaceWin::GetDXGIColorSpace(color_space));
           video_context1->VideoProcessorSetOutputColorSpace1(
               d3d11_processor_.get(), gfx::ColorSpaceWin::GetDXGIColorSpace(
                                           dx11_converter_output_color_space_));
         }
       } else {
         D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space =
             gfx::ColorSpaceWin::GetD3D11ColorSpace(color_space);
@@ skipping 107 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
   bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
   return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 }
 
 }  // namespace media