From 9fc65fb4feda041b745bb0e15994537f2ad5b400 Mon Sep 17 00:00:00 2001
From: Alexey Pavlov <alexpux@gmail.com>
Date: Thu, 14 Sep 2017 11:18:59 +0300
Subject: [PATCH] DirectX 9 fixes for VLC

---
 mingw-w64-headers/include/d3d9.h     |  37 ++
 1 files changed, 37 insertions(+), 0 deletions(-)

diff --git a/mingw-w64-headers/include/d3d9.h b/mingw-w64-headers/include/d3d9.h
index aea02f4e..27bb2833 100644
--- a/mingw-w64-headers/include/d3d9.h
+++ b/mingw-w64-headers/include/d3d9.h
@@ -2201,6 +2201,43 @@ DECLARE_INTERFACE_(IDirect3DDevice9Ex, IDirect3DDevice9)
 
 #endif /* !defined(D3D_DISABLE_9EX) */
 
+/*****************************************************************************
+ * IDirect3D9ExOverlayExtension interface
+ */
+#define INTERFACE IDirect3D9ExOverlayExtension
+DECLARE_INTERFACE_(IDirect3D9ExOverlayExtension,IUnknown)
+{
+    /*** IUnknown methods ***/
+    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE;
+    STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG,Release)(THIS) PURE;
+    /*** IDirect3D9ExOverlayExtension methods ***/
+    STDMETHOD(CheckDeviceOverlayType)(THIS_ UINT Adapter, D3DDEVTYPE DevType, UINT OverlayWidth, UINT OverlayHeight,
+            D3DFORMAT OverlayFormat, D3DDISPLAYMODEEX* pDisplayMode, D3DDISPLAYROTATION DisplayRotation, D3DOVERLAYCAPS* pOverlayCaps) PURE;
+};
+#undef INTERFACE
+
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IDirect3D9ExOverlayExtension,                   0x187aeb13, 0xaaf5, 0x4c59, 0x87, 0x6d, 0xe0, 0x59, 0x8, 0x8c, 0xd, 0xf8);
+#endif
+
+#if !defined(__cplusplus) || defined(CINTERFACE)
+/*** IUnknown methods ***/
+#define IDirect3D9ExOverlayExtension_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IDirect3D9ExOverlayExtension_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IDirect3D9ExOverlayExtension_Release(p) (p)->lpVtbl->Release(p)
+/*** IDirect3D9ExOverlayExtension ***/
+#define IDirect3D9ExOverlayExtension_CheckDeviceOverlayType(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->CheckDeviceOverlayType(p,a,b,c,d,e,f,g,h)
+#else
+/*** IUnknown methods ***/
+#define IDirect3D9ExOverlayExtension_QueryInterface(p,a,b) (p)->QueryInterface(a,b)
+#define IDirect3D9ExOverlayExtension_AddRef(p) (p)->AddRef()
+#define IDirect3D9ExOverlayExtension_Release(p) (p)->Release()
+/*** IDirect3D9ExOverlayExtension ***/
+#define IDirect3D9ExOverlayExtension_CheckDeviceOverlayType(p,a,b,c,d,e,f,g,h) (p)->CheckDeviceOverlayType(a,b,c,d,e,f,g,h)
+#endif
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif  /* defined(__cplusplus) */
-- 
2.14.2

