Unify code to query D3D device object from ANGLE

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 33 matching lines @@
 #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/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
 // Path is appended on to the PROGRAM_FILES base path.
 const wchar_t kAMDVPXDecoderDLLPath[] =
@@ skipping 254 matching lines @@
 
   base::win::ScopedComPtr<IClassFactory> factory;
   HRESULT hr =
       get_class_object(clsid, __uuidof(IClassFactory), factory.ReceiveVoid());
   RETURN_ON_HR_FAILURE(hr, "DllGetClassObject failed", hr);
 
   hr = factory->CreateInstance(NULL, iid, object);
   return hr;
 }
 
-// Helper function to query the ANGLE device object. The template argument T
-// identifies the device interface being queried. IDirect3DDevice9Ex for d3d9
-// and ID3D11Device for dx11.
-template <class T>
-base::win::ScopedComPtr<T> QueryDeviceObjectFromANGLE(int object_type) {
-  base::win::ScopedComPtr<T> device_object;
-
-  EGLDisplay egl_display = nullptr;
-  intptr_t egl_device = 0;
-  intptr_t device = 0;
-
-  {
-    TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. GetHardwareDisplay");
-    egl_display = gl::GLSurfaceEGL::GetHardwareDisplay();
-  }
-
-  RETURN_ON_FAILURE(gl::GLSurfaceEGL::HasEGLExtension("EGL_EXT_device_query"),
-                    "EGL_EXT_device_query missing", device_object);
-
-  PFNEGLQUERYDISPLAYATTRIBEXTPROC QueryDisplayAttribEXT = nullptr;
-
-  {
-    TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. eglGetProcAddress");
-
-    QueryDisplayAttribEXT = reinterpret_cast<PFNEGLQUERYDISPLAYATTRIBEXTPROC>(
-        eglGetProcAddress("eglQueryDisplayAttribEXT"));
-
-    RETURN_ON_FAILURE(
-        QueryDisplayAttribEXT,
-        "Failed to get the eglQueryDisplayAttribEXT function from ANGLE",
-        device_object);
-  }
-
-  PFNEGLQUERYDEVICEATTRIBEXTPROC QueryDeviceAttribEXT = nullptr;
-
-  {
-    TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. eglGetProcAddress");
-
-    QueryDeviceAttribEXT = reinterpret_cast<PFNEGLQUERYDEVICEATTRIBEXTPROC>(
-        eglGetProcAddress("eglQueryDeviceAttribEXT"));
-
-    RETURN_ON_FAILURE(
-        QueryDeviceAttribEXT,
-        "Failed to get the eglQueryDeviceAttribEXT function from ANGLE",
-        device_object);
-  }
-
-  {
-    TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. QueryDisplayAttribEXT");
-
-    RETURN_ON_FAILURE(
-        QueryDisplayAttribEXT(egl_display, EGL_DEVICE_EXT, &egl_device),
-        "The eglQueryDisplayAttribEXT function failed to get the EGL device",
-        device_object);
-  }
-
-  RETURN_ON_FAILURE(egl_device, "Failed to get the EGL device", device_object);
-
-  {
-    TRACE_EVENT0("gpu", "QueryDeviceObjectFromANGLE. QueryDisplayAttribEXT");
-
-    RETURN_ON_FAILURE(
-        QueryDeviceAttribEXT(reinterpret_cast<EGLDeviceEXT>(egl_device),
-                             object_type, &device),
-        "The eglQueryDeviceAttribEXT function failed to get the device",
-        device_object);
-
-    RETURN_ON_FAILURE(device, "Failed to get the ANGLE device", device_object);
-  }
-
-  device_object = reinterpret_cast<T*>(device);
-  return device_object;
-}
-
 H264ConfigChangeDetector::H264ConfigChangeDetector()
     : last_sps_id_(0),
       last_pps_id_(0),
       config_changed_(false),
       pending_config_changed_(false) {}
 
 H264ConfigChangeDetector::~H264ConfigChangeDetector() {}
 
 bool H264ConfigChangeDetector::DetectConfig(const uint8_t* stream,
                                             unsigned int size) {
@@ skipping 288 matching lines @@
   hr = Direct3DCreate9Ex(D3D_SDK_VERSION, d3d9_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Direct3DCreate9Ex failed", false);
 
   hr = d3d9_->CheckDeviceFormatConversion(
       D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
       static_cast<D3DFORMAT>(MAKEFOURCC('N', 'V', '1', '2')), D3DFMT_X8R8G8B8);
   RETURN_ON_HR_FAILURE(hr, "D3D9 driver does not support H/W format conversion",
                        false);
 
   base::win::ScopedComPtr<IDirect3DDevice9> angle_device =
-      QueryDeviceObjectFromANGLE<IDirect3DDevice9>(EGL_D3D9_DEVICE_ANGLE);
+      gl::QueryD3D9DeviceObjectFromANGLE();
   if (angle_device.get())
     using_angle_device_ = true;
 
   if (using_angle_device_) {
     hr = d3d9_device_ex_.QueryFrom(angle_device.get());
     RETURN_ON_HR_FAILURE(
         hr, "QueryInterface for IDirect3DDevice9Ex from angle device failed",
         false);
   } else {
     D3DPRESENT_PARAMETERS present_params = {0};
@@ skipping 119 matching lines @@
 }
 
 bool DXVAVideoDecodeAccelerator::CreateDX11DevManager() {
   // The device may exist if the last state was a config change.
   if (d3d11_device_.get())
     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_ =
-      QueryDeviceObjectFromANGLE<ID3D11Device>(EGL_D3D11_DEVICE_ANGLE);
+  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 {
     // This array defines the set of DirectX hardware feature levels we support.
     // The ordering MUST be preserved. All applications are assumed to support
@@ skipping 481 matching lines @@
   // To detect if a driver supports the desired resolutions, we try and create
   // a DXVA decoder instance for that resolution and profile. If that succeeds
   // we assume that the driver supports H/W H.264 decoding for that resolution.
   HRESULT hr = E_FAIL;
   base::win::ScopedComPtr<ID3D11Device> device;
 
   {
     TRACE_EVENT0("gpu,startup",
                  "GetMaxH264Resolution. QueryDeviceObjectFromANGLE");
 
-    device = QueryDeviceObjectFromANGLE<ID3D11Device>(EGL_D3D11_DEVICE_ANGLE);
+    device = gl::QueryD3D11DeviceObjectFromANGLE();
     if (!device.get())
       return max_resolution;
   }
 
   base::win::ScopedComPtr<ID3D11VideoDevice> video_device;
   hr = device.QueryInterface(__uuidof(ID3D11VideoDevice),
                              video_device.ReceiveVoid());
   if (FAILED(hr))
     return max_resolution;
 
@@ skipping 1583 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