enable fp16 when --enable-hdr-output is on

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.
 #endif  // !defined(OS_WIN)
 
 #include <codecapi.h>
 #include <dxgi1_2.h>
 #include <ks.h>
 #include <mfapi.h>
 #include <mferror.h>
 #include <ntverp.h>
 #include <stddef.h>
 #include <string.h>
 #include <wmcodecdsp.h>
 
 #include "base/atomicops.h"
 #include "base/base_paths_win.h"
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/windows_version.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/config/gpu_driver_bug_workarounds.h"
 #include "media/base/media_switches.h"
 #include "media/base/win/mf_helpers.h"
 #include "media/base/win/mf_initializer.h"
 #include "media/gpu/dxva_picture_buffer_win.h"
 #include "media/video/video_decode_accelerator.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/gfx/color_space_win.h"
 #include "ui/gl/gl_angle_util_win.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_surface_egl.h"
 
 namespace {
 
 // AMD
@@ skipping 494 matching lines @@
                                  PLATFORM_FAILURE, false);
   }
 
   if (config.profile == VP9PROFILE_PROFILE2 ||
       config.profile == VP9PROFILE_PROFILE3 ||
       config.profile == H264PROFILE_HIGH10PROFILE) {
     // Input file has more than 8 bits per channel.
     use_fp16_ = true;
   }
 
+  // Unfortunately, the profile is currently unreliable for
+  // VP9 (crbug.com/592074) so also try to use fp16 if HDR is on.
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableHDROutput)) {
+    use_fp16_ = true;
+  }
+
   // Not all versions of Windows 7 and later include Media Foundation DLLs.
   // Instead of crashing while delay loading the DLL when calling MFStartup()
   // below, probe whether we can successfully load the DLL now.
   // See http://crbug.com/339678 for details.
   HMODULE dxgi_manager_dll = ::GetModuleHandle(L"MFPlat.dll");
   RETURN_ON_FAILURE(dxgi_manager_dll, "MFPlat.dll is required for decoding",
                     false);
 
 // On Windows 8+ mfplat.dll provides the MFCreateDXGIDeviceManager API.
 // On Windows 7 mshtmlmedia.dll provides it.
@@ skipping 1912 matching lines @@
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
 
   DCHECK(!output_picture_buffers_.empty());
 
   bool result = picture_buffer->CopySurfaceComplete(src_surface, dest_surface);
   RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
                                PLATFORM_FAILURE, );
 
-  NotifyPictureReady(
-      picture_buffer->id(), input_buffer_id,
-      copy_nv12_textures_ ? picture_buffer->color_space() : gfx::ColorSpace());
+  NotifyPictureReady(picture_buffer->id(), input_buffer_id,
+                     picture_buffer->color_space());
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
   if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
@@ skipping 80 matching lines @@
 
   D3D11_TEXTURE2D_DESC source_desc;
   src_texture->GetDesc(&source_desc);
   if (!InitializeID3D11VideoProcessor(source_desc.Width, source_desc.Height,
                                       color_space)) {
     RETURN_AND_NOTIFY_ON_FAILURE(false,
                                  "Failed to initialize D3D11 video processor.",
                                  PLATFORM_FAILURE, );
   }
 
+  OutputBuffers::iterator it = output_picture_buffers_.find(picture_buffer_id);
+  if (it != output_picture_buffers_.end()) {
+    it->second->set_color_space(dx11_converter_output_color_space_);
+  }
+
   // The input to the video processor is the output sample.
   base::win::ScopedComPtr<IMFSample> input_sample_for_conversion;
   {
     base::AutoLock lock(decoder_lock_);
     PendingSampleInfo& sample_info = pending_output_samples_.front();
     input_sample_for_conversion = sample_info.output_sample;
   }
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
@@ skipping 191 matching lines @@
     // color space on input and output.
     D3D11_VIDEO_PROCESSOR_COLOR_SPACE d3d11_color_space = {0};
     d3d11_color_space.RGB_Range = 1;
     d3d11_color_space.Nominal_Range = D3D11_VIDEO_PROCESSOR_NOMINAL_RANGE_0_255;
 
     video_context_->VideoProcessorSetOutputColorSpace(d3d11_processor_.get(),
                                                       &d3d11_color_space);
 
     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();
     // Not sure if this call is expensive, let's only do it if the color
     // space changes.
-    gfx::ColorSpace output_color_space = gfx::ColorSpace::CreateSRGB();
-    if (use_color_info_ && dx11_converter_color_space_ != color_space) {
+    if ((use_color_info_ || use_fp16_) &&
+        dx11_converter_color_space_ != color_space) {
       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::kEnableHDROutput)) {
+          dx11_converter_output_color_space_ =
+              gfx::ColorSpace::CreateSCRGBLinear();
+        }
         video_context1->VideoProcessorSetStreamColorSpace1(
             d3d11_processor_.get(), 0,
             gfx::ColorSpaceWin::GetDXGIColorSpace(color_space));
         video_context1->VideoProcessorSetOutputColorSpace1(
-            d3d11_processor_.get(),
-            gfx::ColorSpaceWin::GetDXGIColorSpace(output_color_space));
+            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);
         video_context_->VideoProcessorSetStreamColorSpace(
             d3d11_processor_.get(), 0, &d3d11_color_space);
-        d3d11_color_space =
-            gfx::ColorSpaceWin::GetD3D11ColorSpace(output_color_space);
+        d3d11_color_space = gfx::ColorSpaceWin::GetD3D11ColorSpace(
+            dx11_converter_output_color_space_);
         video_context_->VideoProcessorSetOutputColorSpace(
             d3d11_processor_.get(), &d3d11_color_space);
       }
       dx11_converter_color_space_ = color_space;
     }
   }
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::GetVideoFrameDimensions(IMFSample* sample,
@@ skipping 94 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