Fix fp16 mode on intel gpus.

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 780 matching lines @@
     processor_->GetProcAmpRange(DXVA2_ProcAmp_Saturation, &range);
     default_procamp_values_.Saturation = range.DefaultValue;
 
     return true;
   }
   return false;
 }
 
 bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
   // The device may exist if the last state was a config change.
-  if (d3d11_device_.Get())
+  if (D3D11Device())
     return true;
   HRESULT hr = create_dxgi_device_manager_(&dx11_dev_manager_reset_token_,
                                            d3d11_device_manager_.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateDXGIDeviceManager failed", false);
 
   angle_device_ = gl::QueryD3D11DeviceObjectFromANGLE();
   if (!angle_device_)
     copy_nv12_textures_ = false;
   if (share_nv12_textures_) {
     RETURN_ON_FAILURE(angle_device_.Get(), "Failed to get d3d11 device", false);
 
     using_angle_device_ = true;
-    d3d11_device_ = angle_device_;
-  } else {
+  }
+
+  if (use_fp16_ || !share_nv12_textures_) {

[jbauman, 2017/04/20 19:41:10]

Could we set share_nv12_textures_ before this if we're using fp16?  Because in
that case we're not actually sharing nv12 textures.

[hubbe, 2017/04/20 19:43:16]

Problem is that use_fp16_ can become false later if we fail to get an fp16
context from egl further down..

     // This array defines the set of DirectX hardware feature levels we support.
     // The ordering MUST be preserved. All applications are assumed to support
     // 9.1 unless otherwise stated by the application.
     D3D_FEATURE_LEVEL feature_levels[] = {
         D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
         D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3,  D3D_FEATURE_LEVEL_9_2,
         D3D_FEATURE_LEVEL_9_1};
 
     UINT flags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 
@@ skipping 22 matching lines @@
     }
 
     hr = d3d11_device_.QueryInterface(video_device_.Receive());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video device", false);
 
     hr = d3d11_device_context_.QueryInterface(video_context_.Receive());
     RETURN_ON_HR_FAILURE(hr, "Failed to get video context", false);
   }
 
   D3D11_FEATURE_DATA_D3D11_OPTIONS options;
-  hr = d3d11_device_->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &options,
+  hr = D3D11Device()->CheckFeatureSupport(D3D11_FEATURE_D3D11_OPTIONS, &options,
                                           sizeof(options));
   RETURN_ON_HR_FAILURE(hr, "Failed to retrieve D3D11 options", false);
 
   // Need extended resource sharing so we can share the NV12 texture between
   // ANGLE and the decoder context.
   if (!options.ExtendedResourceSharing)
     copy_nv12_textures_ = false;
 
   UINT nv12_format_support = 0;
   hr =
-      d3d11_device_->CheckFormatSupport(DXGI_FORMAT_NV12, &nv12_format_support);
+      D3D11Device()->CheckFormatSupport(DXGI_FORMAT_NV12, &nv12_format_support);
   RETURN_ON_HR_FAILURE(hr, "Failed to check NV12 format support", false);
 
   if (!(nv12_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
     copy_nv12_textures_ = false;
 
   UINT fp16_format_support = 0;
-  hr = d3d11_device_->CheckFormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT,
+  hr = D3D11Device()->CheckFormatSupport(DXGI_FORMAT_R16G16B16A16_FLOAT,
                                          &fp16_format_support);
   if (FAILED(hr) ||
       !(fp16_format_support & D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_OUTPUT))
     use_fp16_ = false;
 
   // Enable multithreaded mode on the device. This ensures that accesses to
   // context are synchronized across threads. We have multiple threads
   // accessing the context, the media foundation decoder threads and the
   // decoder thread via the video format conversion transform.
-  hr = multi_threaded_.QueryFrom(d3d11_device_.Get());
+  hr = multi_threaded_.QueryFrom(D3D11Device());
   RETURN_ON_HR_FAILURE(hr, "Failed to query ID3D10Multithread", false);
   multi_threaded_->SetMultithreadProtected(TRUE);
 
-  hr = d3d11_device_manager_->ResetDevice(d3d11_device_.Get(),
+  hr = d3d11_device_manager_->ResetDevice(D3D11Device(),
                                           dx11_dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   D3D11_QUERY_DESC query_desc;
   query_desc.Query = D3D11_QUERY_EVENT;
   query_desc.MiscFlags = 0;
-  hr = d3d11_device_->CreateQuery(&query_desc, d3d11_query_.Receive());
+  hr = D3D11Device()->CreateQuery(&query_desc, d3d11_query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create DX11 device query", false);
 
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
     const BitstreamBuffer& bitstream_buffer) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::Decode");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 844 matching lines @@
 void DXVAVideoDecodeAccelerator::DoDecode(const gfx::ColorSpace& color_space) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::DoDecode");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   // This function is also called from FlushInternal in a loop which could
   // result in the state transitioning to kStopped due to no decoded output.
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE(
       (state == kNormal || state == kFlushing || state == kStopped),
       "DoDecode: not in normal/flushing/stopped state", ILLEGAL_STATE, );
 
-  if (d3d11_device_)
-    g_last_device_removed_reason = d3d11_device_->GetDeviceRemovedReason();
+  if (D3D11Device())
+    g_last_device_removed_reason = D3D11Device()->GetDeviceRemovedReason();
 
   MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
   DWORD status = 0;
   HRESULT hr;
   {
     ScopedExceptionCatcher catcher(using_ms_vp9_mft_);
     g_last_process_output_time = GetCurrentQPC();
     hr = decoder_->ProcessOutput(0,  // No flags
                                  1,  // # of out streams to pull from
                                  &output_data_buffer, &status);
@@ skipping 1211 matching lines @@
       FROM_HERE,
       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;
 }
 
+ID3D11Device* DXVAVideoDecodeAccelerator::D3D11Device() const {
+  return share_nv12_textures_ ? angle_device_.Get() : d3d11_device_.Get();
+}
+
 }  // namespace media