diff --git a/sdk/include/wine/d3dukmdt.h b/sdk/include/wine/d3dukmdt.h new file mode 100644 index 00000000000..f88771cbce6 --- /dev/null +++ b/sdk/include/wine/d3dukmdt.h @@ -0,0 +1,156 @@ +/* + * Copyright 2016 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DUKMDT_H +#define __WINE_D3DUKMDT_H + +#ifndef MAKEFOURCC +#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ + ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ + ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24)) +#endif /* MAKEFOURCC */ + +typedef UINT D3DKMT_HANDLE; + +typedef enum _D3DDDIFORMAT +{ + D3DDDIFMT_UNKNOWN = 0, + D3DDDIFMT_R8G8B8 = 0x14, + D3DDDIFMT_A8R8G8B8 = 0x15, + D3DDDIFMT_X8R8G8B8 = 0x16, + D3DDDIFMT_R5G6B5 = 0x17, + D3DDDIFMT_X1R5G5B5 = 0x18, + D3DDDIFMT_A1R5G5B5 = 0x19, + D3DDDIFMT_A4R4G4B4 = 0x1a, + D3DDDIFMT_R3G3B2 = 0x1b, + D3DDDIFMT_A8 = 0x1c, + D3DDDIFMT_A8R3G3B2 = 0x1d, + D3DDDIFMT_X4R4G4B4 = 0x1e, + D3DDDIFMT_A2B10G10R10 = 0x1f, + D3DDDIFMT_A8B8G8R8 = 0x20, + D3DDDIFMT_X8B8G8R8 = 0x21, + D3DDDIFMT_G16R16 = 0x22, + D3DDDIFMT_A2R10G10B10 = 0x23, + D3DDDIFMT_A16B16G16R16 = 0x24, + D3DDDIFMT_A8P8 = 0x28, + D3DDDIFMT_P8 = 0x29, + D3DDDIFMT_L8 = 0x32, + D3DDDIFMT_A8L8 = 0x33, + D3DDDIFMT_A4L4 = 0x34, + D3DDDIFMT_V8U8 = 0x3c, + D3DDDIFMT_L6V5U5 = 0x3d, + D3DDDIFMT_X8L8V8U8 = 0x3e, + D3DDDIFMT_Q8W8V8U8 = 0x3f, + D3DDDIFMT_V16U16 = 0x40, + D3DDDIFMT_W11V11U10 = 0x41, + D3DDDIFMT_A2W10V10U10 = 0x43, + D3DDDIFMT_D16_LOCKABLE = 0x46, + D3DDDIFMT_D32 = 0x47, + D3DDDIFMT_S1D15 = 0x48, + D3DDDIFMT_D15S1 = 0x49, + D3DDDIFMT_S8D24 = 0x4a, + D3DDDIFMT_D24S8 = 0x4b, + D3DDDIFMT_X8D24 = 0x4c, + D3DDDIFMT_D24X8 = 0x4d, + D3DDDIFMT_X4S4D24 = 0x4e, + D3DDDIFMT_D24X4S4 = 0x4f, + D3DDDIFMT_D16 = 0x50, + D3DDDIFMT_L16 = 0x51, + D3DDDIFMT_D32F_LOCKABLE = 0x52, + D3DDDIFMT_D24FS8 = 0x53, + D3DDDIFMT_D32_LOCKABLE = 0x54, + D3DDDIFMT_S8_LOCKABLE = 0x55, + D3DDDIFMT_G8R8 = 0x5b, + D3DDDIFMT_R8 = 0x5c, + D3DDDIFMT_VERTEXDATA = 0x64, + D3DDDIFMT_INDEX16 = 0x65, + D3DDDIFMT_INDEX32 = 0x66, + D3DDDIFMT_Q16W16V16U16 = 0x6e, + D3DDDIFMT_R16F = 0x6f, + D3DDDIFMT_G16R16F = 0x70, + D3DDDIFMT_A16B16G16R16F = 0x71, + D3DDDIFMT_R32F = 0x72, + D3DDDIFMT_G32R32F = 0x73, + D3DDDIFMT_A32B32G32R32F = 0x74, + D3DDDIFMT_CxV8U8 = 0x75, + D3DDDIFMT_A1 = 0x76, + D3DDDIFMT_A2B10G10R10_XR_BIAS = 0x77, + D3DDDIFMT_DXVACOMPBUFFER_BASE = 0x96, + D3DDDIFMT_PICTUREPARAMSDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0, + D3DDDIFMT_MACROBLOCKDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x01, + D3DDDIFMT_RESIDUALDIFFERENCEDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x02, + D3DDDIFMT_DEBLOCKINGDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x03, + D3DDDIFMT_INVERSEQUANTIZATIONDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x04, + D3DDDIFMT_SLICECONTROLDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x05, + D3DDDIFMT_BITSTREAMDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x06, + D3DDDIFMT_MOTIONVECTORBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x07, + D3DDDIFMT_FILMGRAINBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x08, + D3DDDIFMT_DXVA_RESERVED9 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x09, + D3DDDIFMT_DXVA_RESERVED10 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0a, + D3DDDIFMT_DXVA_RESERVED11 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0b, + D3DDDIFMT_DXVA_RESERVED12 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0c, + D3DDDIFMT_DXVA_RESERVED13 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0d, + D3DDDIFMT_DXVA_RESERVED14 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0e, + D3DDDIFMT_DXVA_RESERVED15 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x0f, + D3DDDIFMT_DXVA_RESERVED16 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x10, + D3DDDIFMT_DXVA_RESERVED17 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x11, + D3DDDIFMT_DXVA_RESERVED18 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x12, + D3DDDIFMT_DXVA_RESERVED19 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x13, + D3DDDIFMT_DXVA_RESERVED20 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x14, + D3DDDIFMT_DXVA_RESERVED21 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x15, + D3DDDIFMT_DXVA_RESERVED22 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x16, + D3DDDIFMT_DXVA_RESERVED23 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x17, + D3DDDIFMT_DXVA_RESERVED24 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x18, + D3DDDIFMT_DXVA_RESERVED25 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x19, + D3DDDIFMT_DXVA_RESERVED26 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1a, + D3DDDIFMT_DXVA_RESERVED27 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1b, + D3DDDIFMT_DXVA_RESERVED28 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1c, + D3DDDIFMT_DXVA_RESERVED29 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1d, + D3DDDIFMT_DXVA_RESERVED30 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1e, + D3DDDIFMT_DXVA_RESERVED31 = D3DDDIFMT_DXVACOMPBUFFER_BASE + 0x1f, + D3DDDIFMT_DXVACOMPBUFFER_MAX = D3DDDIFMT_DXVA_RESERVED31, + D3DDDIFMT_BINARYBUFFER = 0xc7, + D3DDDIFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'), + D3DDDIFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'), + D3DDDIFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'), + D3DDDIFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'), + D3DDDIFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'), + D3DDDIFMT_G8R8_G8B8 = MAKEFOURCC('G', 'R', 'G', 'B'), + D3DDDIFMT_MULTI2_ARGB8 = MAKEFOURCC('M', 'E', 'T', '1'), + D3DDDIFMT_R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'), + D3DDDIFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'), + D3DDDIFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'), + D3DDDIFMT_FORCE_UINT = 0x7fffffff, +} D3DDDIFORMAT; + +typedef UINT D3DDDI_VIDEO_PRESENT_SOURCE_ID; + +typedef struct _D3DDDI_ESCAPEFLAGS +{ + union + { + struct + { + UINT HardwareAccess :1; + UINT Reserved :31; + }; + UINT Value; + }; +} D3DDDI_ESCAPEFLAGS; + +#endif /* __WINE_D3DUKMDT_H */ diff --git a/sdk/include/wine/ddk/d3dkmthk.h b/sdk/include/wine/ddk/d3dkmthk.h new file mode 100644 index 00000000000..7828941a9d6 --- /dev/null +++ b/sdk/include/wine/ddk/d3dkmthk.h @@ -0,0 +1,1312 @@ +/* + * Copyright 2016 Henri Verbeet for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __WINE_D3DKMTHK_H +#define __WINE_D3DKMTHK_H + +#include +#include + +typedef enum _D3DKMT_VIDPNSOURCEOWNER_TYPE +{ + D3DKMT_VIDPNSOURCEOWNER_UNOWNED = 0, + D3DKMT_VIDPNSOURCEOWNER_SHARED = 1, + D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE = 2, + D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI = 3, + D3DKMT_VIDPNSOURCEOWNER_EMULATED = 4 +} D3DKMT_VIDPNSOURCEOWNER_TYPE; + +typedef enum _D3DKMT_MEMORY_SEGMENT_GROUP +{ + D3DKMT_MEMORY_SEGMENT_GROUP_LOCAL = 0, + D3DKMT_MEMORY_SEGMENT_GROUP_NON_LOCAL = 1 +} D3DKMT_MEMORY_SEGMENT_GROUP; + +typedef struct _D3DKMT_CREATEDEVICEFLAGS +{ + UINT LegacyMode : 1; + UINT RequestVSync : 1; + UINT DisableGpuTimeout : 1; + UINT Reserved : 29; +} D3DKMT_CREATEDEVICEFLAGS; + +typedef struct _D3DDDI_ALLOCATIONLIST +{ + D3DKMT_HANDLE hAllocation; + union + { + struct + { + UINT WriteOperation : 1; + UINT DoNotRetireInstance : 1; + UINT OfferPriority : 3; + UINT Reserved : 27; + } DUMMYSTRUCTNAME; + UINT Value; + } DUMMYUNIONNAME; +} D3DDDI_ALLOCATIONLIST; + +typedef struct _D3DDDI_PATCHLOCATIONLIST +{ + UINT AllocationIndex; + union + { + struct + { + UINT SlotId : 24; + UINT Reserved : 8; + } DUMMYSTRUCTNAME; + UINT Value; + } DUMMYUNIONNAME; + UINT DriverId; + UINT AllocationOffset; + UINT PatchOffset; + UINT SplitOffset; +} D3DDDI_PATCHLOCATIONLIST; + +typedef struct _D3DKMT_DESTROYDEVICE +{ + D3DKMT_HANDLE hDevice; +} D3DKMT_DESTROYDEVICE; + +typedef struct _D3DKMT_CHECKOCCLUSION +{ + HWND hWnd; +} D3DKMT_CHECKOCCLUSION; + +typedef struct _D3DKMT_CREATEDEVICE +{ + union + { + D3DKMT_HANDLE hAdapter; + VOID *pAdapter; + } DUMMYUNIONNAME; + D3DKMT_CREATEDEVICEFLAGS Flags; + D3DKMT_HANDLE hDevice; + VOID *pCommandBuffer; + UINT CommandBufferSize; + D3DDDI_ALLOCATIONLIST *pAllocationList; + UINT AllocationListSize; + D3DDDI_PATCHLOCATIONLIST *pPatchLocationList; + UINT PatchLocationListSize; +} D3DKMT_CREATEDEVICE; + +typedef struct _D3DKMT_OPENADAPTERFROMHDC +{ + HDC hDc; + D3DKMT_HANDLE hAdapter; + LUID AdapterLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} D3DKMT_OPENADAPTERFROMHDC; + +typedef struct _D3DKMT_OPENADAPTERFROMDEVICENAME +{ + const WCHAR *pDeviceName; + D3DKMT_HANDLE hAdapter; + LUID AdapterLuid; +} D3DKMT_OPENADAPTERFROMDEVICENAME; + +typedef struct _D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME +{ + WCHAR DeviceName[32]; + D3DKMT_HANDLE hAdapter; + LUID AdapterLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME; + +typedef struct _D3DKMT_OPENADAPTERFROMLUID +{ + LUID AdapterLuid; + D3DKMT_HANDLE hAdapter; +} D3DKMT_OPENADAPTERFROMLUID; + +typedef struct _D3DKMT_SETVIDPNSOURCEOWNER +{ + D3DKMT_HANDLE hDevice; + const D3DKMT_VIDPNSOURCEOWNER_TYPE *pType; + const D3DDDI_VIDEO_PRESENT_SOURCE_ID *pVidPnSourceId; + UINT VidPnSourceCount; +} D3DKMT_SETVIDPNSOURCEOWNER; + +typedef struct _D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP; + +#define D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX 5 + +typedef struct _D3DKMT_CLOSEADAPTER +{ + D3DKMT_HANDLE hAdapter; +} D3DKMT_CLOSEADAPTER; + +typedef struct _D3DKMT_CREATEDCFROMMEMORY +{ + void *pMemory; + D3DDDIFORMAT Format; + UINT Width; + UINT Height; + UINT Pitch; + HDC hDeviceDc; + PALETTEENTRY *pColorTable; + HDC hDc; + HANDLE hBitmap; +} D3DKMT_CREATEDCFROMMEMORY; + +typedef struct _D3DKMT_DESTROYDCFROMMEMORY +{ + HDC hDc; + HANDLE hBitmap; +} D3DKMT_DESTROYDCFROMMEMORY; + +typedef enum _KMTQUERYADAPTERINFOTYPE +{ + KMTQAITYPE_UMDRIVERPRIVATE, + KMTQAITYPE_UMDRIVERNAME, + KMTQAITYPE_UMOPENGLINFO, + KMTQAITYPE_GETSEGMENTSIZE, + KMTQAITYPE_ADAPTERGUID, + KMTQAITYPE_FLIPQUEUEINFO, + KMTQAITYPE_ADAPTERADDRESS, + KMTQAITYPE_SETWORKINGSETINFO, + KMTQAITYPE_ADAPTERREGISTRYINFO, + KMTQAITYPE_CURRENTDISPLAYMODE, + KMTQAITYPE_MODELIST, + KMTQAITYPE_CHECKDRIVERUPDATESTATUS, + KMTQAITYPE_VIRTUALADDRESSINFO, + KMTQAITYPE_DRIVERVERSION = 13, + KMTQAITYPE_ADAPTERTYPE = 15, + KMTQAITYPE_OUTPUTDUPLCONTEXTSCOUNT, + KMTQAITYPE_WDDM_1_2_CAPS, + KMTQAITYPE_UMD_DRIVER_VERSION, + KMTQAITYPE_DIRECTFLIP_SUPPORT, + KMTQAITYPE_MULTIPLANEOVERLAY_SUPPORT, + KMTQAITYPE_DLIST_DRIVER_NAME, + KMTQAITYPE_WDDM_1_3_CAPS, + KMTQAITYPE_MULTIPLANEOVERLAY_HUD_SUPPORT, + KMTQAITYPE_WDDM_2_0_CAPS, + KMTQAITYPE_NODEMETADATA, + KMTQAITYPE_CPDRIVERNAME, + KMTQAITYPE_XBOX, + KMTQAITYPE_INDEPENDENTFLIP_SUPPORT, + KMTQAITYPE_MIRACASTCOMPANIONDRIVERNAME, + KMTQAITYPE_PHYSICALADAPTERCOUNT, + KMTQAITYPE_PHYSICALADAPTERDEVICEIDS, + KMTQAITYPE_DRIVERCAPS_EXT, + KMTQAITYPE_QUERY_MIRACAST_DRIVER_TYPE, + KMTQAITYPE_QUERY_GPUMMU_CAPS, + KMTQAITYPE_QUERY_MULTIPLANEOVERLAY_DECODE_SUPPORT, + KMTQAITYPE_QUERY_HW_PROTECTION_TEARDOWN_COUNT, + KMTQAITYPE_QUERY_ISBADDRIVERFORHWPROTECTIONDISABLED, + KMTQAITYPE_MULTIPLANEOVERLAY_SECONDARY_SUPPORT, + KMTQAITYPE_INDEPENDENTFLIP_SECONDARY_SUPPORT, + KMTQAITYPE_PANELFITTER_SUPPORT, + KMTQAITYPE_PHYSICALADAPTERPNPKEY, + KMTQAITYPE_GETSEGMENTGROUPSIZE, + KMTQAITYPE_MPO3DDI_SUPPORT, + KMTQAITYPE_HWDRM_SUPPORT, + KMTQAITYPE_MPOKERNELCAPS_SUPPORT, + KMTQAITYPE_MULTIPLANEOVERLAY_STRETCH_SUPPORT, + KMTQAITYPE_GET_DEVICE_VIDPN_OWNERSHIP_INFO, + KMTQAITYPE_QUERYREGISTRY, + KMTQAITYPE_KMD_DRIVER_VERSION, + KMTQAITYPE_BLOCKLIST_KERNEL, + KMTQAITYPE_BLOCKLIST_RUNTIME, + KMTQAITYPE_ADAPTERGUID_RENDER, + KMTQAITYPE_ADAPTERADDRESS_RENDER, + KMTQAITYPE_ADAPTERREGISTRYINFO_RENDER, + KMTQAITYPE_CHECKDRIVERUPDATESTATUS_RENDER, + KMTQAITYPE_DRIVERVERSION_RENDER, + KMTQAITYPE_ADAPTERTYPE_RENDER, + KMTQAITYPE_WDDM_1_2_CAPS_RENDER, + KMTQAITYPE_WDDM_1_3_CAPS_RENDER, + KMTQAITYPE_QUERY_ADAPTER_UNIQUE_GUID, + KMTQAITYPE_NODEPERFDATA, + KMTQAITYPE_ADAPTERPERFDATA, + KMTQAITYPE_ADAPTERPERFDATA_CAPS, + KMTQUITYPE_GPUVERSION, + KMTQAITYPE_DRIVER_DESCRIPTION, + KMTQAITYPE_DRIVER_DESCRIPTION_RENDER, + KMTQAITYPE_SCANOUT_CAPS, + KMTQAITYPE_PARAVIRTUALIZATION_RENDER, + KMTQAITYPE_SERVICENAME, + KMTQAITYPE_WDDM_2_7_CAPS, + KMTQAITYPE_DISPLAY_UMDRIVERNAME = 71, + KMTQAITYPE_TRACKEDWORKLOAD_SUPPORT, + KMTQAITYPE_HYBRID_DLIST_DLL_SUPPORT, + KMTQAITYPE_DISPLAY_CAPS, + KMTQAITYPE_WDDM_2_9_CAPS, + KMTQAITYPE_CROSSADAPTERRESOURCE_SUPPORT, + KMTQAITYPE_WDDM_3_0_CAPS, + KMTQAITYPE_WSAUMDIMAGENAME, + KMTQAITYPE_VGPUINTERFACEID, + KMTQAITYPE_WDDM_3_1_CAPS +} KMTQUERYADAPTERINFOTYPE; + +typedef struct _D3DKMT_QUERYADAPTERINFO +{ + D3DKMT_HANDLE hAdapter; + KMTQUERYADAPTERINFOTYPE Type; + VOID *pPrivateDriverData; + UINT PrivateDriverDataSize; +} D3DKMT_QUERYADAPTERINFO; + +typedef enum _D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT +{ + D3DKMT_PreemptionAttempt = 0, + D3DKMT_PreemptionAttemptSuccess = 1, + D3DKMT_PreemptionAttemptMissNoCommand = 2, + D3DKMT_PreemptionAttemptMissNotEnabled = 3, + D3DKMT_PreemptionAttemptMissNextFence = 4, + D3DKMT_PreemptionAttemptMissPagingCommand = 5, + D3DKMT_PreemptionAttemptMissSplittedCommand = 6, + D3DKMT_PreemptionAttemptMissFenceCommand = 7, + D3DKMT_PreemptionAttemptMissRenderPendingFlip = 8, + D3DKMT_PreemptionAttemptMissNotMakingProgress = 9, + D3DKMT_PreemptionAttemptMissLessPriority = 10, + D3DKMT_PreemptionAttemptMissRemainingQuantum = 11, + D3DKMT_PreemptionAttemptMissRemainingPreemptionQuantum = 12, + D3DKMT_PreemptionAttemptMissAlreadyPreempting = 13, + D3DKMT_PreemptionAttemptMissGlobalBlock = 14, + D3DKMT_PreemptionAttemptMissAlreadyRunning = 15, + D3DKMT_PreemptionAttemptStatisticsMax +} D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT; + +typedef enum _D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS +{ + D3DKMT_AllocationPriorityClassMinimum, + D3DKMT_AllocationPriorityClassLow, + D3DKMT_AllocationPriorityClassNormal, + D3DKMT_AllocationPriorityClassHigh, + D3DKMT_AllocationPriorityClassMaximum, + D3DKMT_MaxAllocationPriorityClass +} D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS; + +typedef enum _D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE +{ + D3DKMT_RenderCommandBuffer, + D3DKMT_DeferredCommandBuffer, + D3DKMT_SystemCommandBuffer, + D3DKMT_MmIoFlipCommandBuffer, + D3DKMT_WaitCommandBuffer, + D3DKMT_SignalCommandBuffer, + D3DKMT_DeviceCommandBuffer, + D3DKMT_SoftwareCommandBuffer, + D3DKMT_QueuePacketTypeMax +} D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE; + +typedef enum _D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE +{ + D3DKMT_ClientRenderBuffer, + D3DKMT_ClientPagingBuffer, + D3DKMT_SystemPagingBuffer, + D3DKMT_SystemPreemptionBuffer, + D3DKMT_DmaPacketTypeMax +} D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE; + +typedef struct _D3DKMT_QUERYSTATSTICS_PAGING_TRANSFER +{ + ULONGLONG BytesFilled; + ULONGLONG BytesDiscarded; + ULONGLONG BytesMappedIntoAperture; + ULONGLONG BytesUnmappedFromAperture; + ULONGLONG BytesTransferredFromMdlToMemory; + ULONGLONG BytesTransferredFromMemoryToMdl; + ULONGLONG BytesTransferredFromApertureToMemory; + ULONGLONG BytesTransferredFromMemoryToAperture; +} D3DKMT_QUERYSTATSTICS_PAGING_TRANSFER; + +typedef struct _D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA +{ + ULONG64 TotalBytesEvictedFromProcess; + ULONG64 BytesBySegmentPreference[D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX]; +} D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA; + +typedef struct _D3DKMT_QUERYSTATSTICS_SWIZZLING_RANGE +{ + ULONG NbRangesAcquired; + ULONG NbRangesReleased; +} D3DKMT_QUERYSTATSTICS_SWIZZLING_RANGE; + +typedef struct _D3DKMT_QUERYSTATISTICS_COUNTER +{ + ULONG Count; + ULONGLONG Bytes; +} D3DKMT_QUERYSTATISTICS_COUNTER; + +typedef struct _D3DKMT_QUERYSTATISTICS_DMA_BUFFER +{ + D3DKMT_QUERYSTATISTICS_COUNTER Size; + ULONG AllocationListBytes; + ULONG PatchLocationListBytes; +} D3DKMT_QUERYSTATISTICS_DMA_BUFFER; + +typedef struct _D3DKMT_QUERYSTATSTICS_LOCKS +{ + ULONG NbLocks; + ULONG NbLocksWaitFlag; + ULONG NbLocksDiscardFlag; + ULONG NbLocksNoOverwrite; + ULONG NbLocksNoReadSync; + ULONG NbLocksLinearization; + ULONG NbComplexLocks; +} D3DKMT_QUERYSTATSTICS_LOCKS; + +typedef struct _D3DKMT_QUERYSTATSTICS_ALLOCATIONS +{ + D3DKMT_QUERYSTATISTICS_COUNTER Created; + D3DKMT_QUERYSTATISTICS_COUNTER Destroyed; + D3DKMT_QUERYSTATISTICS_COUNTER Opened; + D3DKMT_QUERYSTATISTICS_COUNTER Closed; + D3DKMT_QUERYSTATISTICS_COUNTER MigratedSuccess; + D3DKMT_QUERYSTATISTICS_COUNTER MigratedFail; + D3DKMT_QUERYSTATISTICS_COUNTER MigratedAbandoned; +} D3DKMT_QUERYSTATSTICS_ALLOCATIONS; + +typedef struct _D3DKMT_QUERYSTATSTICS_TERMINATIONS +{ + D3DKMT_QUERYSTATISTICS_COUNTER TerminatedShared; + D3DKMT_QUERYSTATISTICS_COUNTER TerminatedNonShared; + D3DKMT_QUERYSTATISTICS_COUNTER DestroyedShared; + D3DKMT_QUERYSTATISTICS_COUNTER DestroyedNonShared; +} D3DKMT_QUERYSTATSTICS_TERMINATIONS; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_NODE +{ + ULONG NodeId; +} D3DKMT_QUERYSTATISTICS_QUERY_NODE; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT +{ + ULONG SegmentId; +} D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT; + +typedef struct _D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION +{ + ULONG PreemptionCounter[D3DKMT_PreemptionAttemptStatisticsMax]; +} D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE +{ + ULONG VidPnSourceId; +} D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_INFORMATION +{ + ULONG PacketSubmited; + ULONG PacketCompleted; +} D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_INFORMATION +{ + ULONG PacketSubmited; + ULONG PacketCompleted; + ULONG PacketPreempted; + ULONG PacketFaulted; +} D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY +{ + ULONGLONG BytesAllocated; + ULONGLONG BytesReserved; + ULONG SmallAllocationBlocks; + ULONG LargeAllocationBlocks; + ULONGLONG WriteCombinedBytesAllocated; + ULONGLONG WriteCombinedBytesReserved; + ULONGLONG CachedBytesAllocated; + ULONGLONG CachedBytesReserved; + ULONGLONG SectionBytesAllocated; + ULONGLONG SectionBytesReserved; +} D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY; + +typedef enum _D3DKMT_QUERYSTATISTICS_TYPE +{ + D3DKMT_QUERYSTATISTICS_ADAPTER, + D3DKMT_QUERYSTATISTICS_PROCESS, + D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER, + D3DKMT_QUERYSTATISTICS_SEGMENT, + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT, + D3DKMT_QUERYSTATISTICS_NODE, + D3DKMT_QUERYSTATISTICS_PROCESS_NODE, + D3DKMT_QUERYSTATISTICS_VIDPNSOURCE, + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE +} D3DKMT_QUERYSTATISTICS_TYPE; + +typedef struct _D3DKMT_QUERYSTATSTICS_PAGING_FAULT +{ + D3DKMT_QUERYSTATISTICS_COUNTER Faults; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsFirstTimeAccess; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsReclaimed; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsMigration; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsIncorrectResource; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsLostContent; + D3DKMT_QUERYSTATISTICS_COUNTER FaultsEvicted; + D3DKMT_QUERYSTATISTICS_COUNTER AllocationsMEM_RESET; + D3DKMT_QUERYSTATISTICS_COUNTER AllocationsUnresetSuccess; + D3DKMT_QUERYSTATISTICS_COUNTER AllocationsUnresetFail; + ULONG AllocationsUnresetSuccessRead; + ULONG AllocationsUnresetFailRead; + D3DKMT_QUERYSTATISTICS_COUNTER Evictions; + D3DKMT_QUERYSTATISTICS_COUNTER EvictionsDueToPreparation; + D3DKMT_QUERYSTATISTICS_COUNTER EvictionsDueToLock; + D3DKMT_QUERYSTATISTICS_COUNTER EvictionsDueToClose; + D3DKMT_QUERYSTATISTICS_COUNTER EvictionsDueToPurge; + D3DKMT_QUERYSTATISTICS_COUNTER EvictionsDueToSuspendCPUAccess; +} D3DKMT_QUERYSTATSTICS_PAGING_FAULT; + +typedef struct _D3DKMT_QUERYSTATSTICS_REFERENCE_DMA_BUFFER +{ + ULONG NbCall; + ULONG NbAllocationsReferenced; + ULONG MaxNbAllocationsReferenced; + ULONG NbNULLReference; + ULONG NbWriteReference; + ULONG NbRenamedAllocationsReferenced; + ULONG NbIterationSearchingRenamedAllocation; + ULONG NbLockedAllocationReferenced; + ULONG NbAllocationWithValidPrepatchingInfoReferenced; + ULONG NbAllocationWithInvalidPrepatchingInfoReferenced; + ULONG NbDMABufferSuccessfullyPrePatched; + ULONG NbPrimariesReferencesOverflow; + ULONG NbAllocationWithNonPreferredResources; + ULONG NbAllocationInsertedInMigrationTable; +} D3DKMT_QUERYSTATSTICS_REFERENCE_DMA_BUFFER; + +typedef struct _D3DKMT_QUERYSTATSTICS_RENAMING +{ + ULONG NbAllocationsRenamed; + ULONG NbAllocationsShrinked; + ULONG NbRenamedBuffer; + ULONG MaxRenamingListLength; + ULONG NbFailuresDueToRenamingLimit; + ULONG NbFailuresDueToCreateAllocation; + ULONG NbFailuresDueToOpenAllocation; + ULONG NbFailuresDueToLowResource; + ULONG NbFailuresDueToNonRetiredLimit; +} D3DKMT_QUERYSTATSTICS_RENAMING; + +typedef struct _D3DKMT_QUERYSTATSTICS_PREPRATION +{ + ULONG BroadcastStall; + ULONG NbDMAPrepared; + ULONG NbDMAPreparedLongPath; + ULONG ImmediateHighestPreparationPass; + D3DKMT_QUERYSTATISTICS_COUNTER AllocationsTrimmed; +} D3DKMT_QUERYSTATSTICS_PREPRATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_MEMORY +{ + ULONGLONG TotalBytesEvicted; + ULONG AllocsCommitted; + ULONG AllocsResident; +} D3DKMT_QUERYSTATISTICS_MEMORY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION +{ + ULONG Frame; + ULONG CancelledFrame; + ULONG QueuedPresent; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION +{ + D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_INFORMATION QueuePacket[D3DKMT_QueuePacketTypeMax]; + D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_INFORMATION DmaPacket[D3DKMT_DmaPacketTypeMax]; +} D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION +{ + LARGE_INTEGER RunningTime; + ULONG ContextSwitch; + D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION PreemptionStatistics; + D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION PacketStatistics; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_NODE_INFORMATION +{ + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION GlobalInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION SystemInformation; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_NODE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION +{ + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION GlobalInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION SystemInformation; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION +{ + ULONG NbSegments; + ULONG NodeCount; + ULONG VidPnSourceCount; + ULONG VSyncEnabled; + ULONG TdrDetectedCount; + LONGLONG ZeroLengthDmaBuffers; + ULONGLONG RestartedPeriod; + D3DKMT_QUERYSTATSTICS_REFERENCE_DMA_BUFFER ReferenceDmaBuffer; + D3DKMT_QUERYSTATSTICS_RENAMING Renaming; + D3DKMT_QUERYSTATSTICS_PREPRATION Preparation; + D3DKMT_QUERYSTATSTICS_PAGING_FAULT PagingFault; + D3DKMT_QUERYSTATSTICS_PAGING_TRANSFER PagingTransfer; + D3DKMT_QUERYSTATSTICS_SWIZZLING_RANGE SwizzlingRange; + D3DKMT_QUERYSTATSTICS_LOCKS Locks; + D3DKMT_QUERYSTATSTICS_ALLOCATIONS Allocations; + D3DKMT_QUERYSTATSTICS_TERMINATIONS Terminations; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_POLICY +{ + ULONGLONG PreferApertureForRead[D3DKMT_MaxAllocationPriorityClass]; + ULONGLONG PreferAperture[D3DKMT_MaxAllocationPriorityClass]; + ULONGLONG MemResetOnPaging; + ULONGLONG RemovePagesFromWorkingSetOnPaging; + ULONGLONG MigrationEnabled; +} D3DKMT_QUERYSTATISTICS_POLICY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION +{ + ULONG NbSegments; + ULONG NodeCount; + ULONG VidPnSourceCount; + ULONG VirtualMemoryUsage; + D3DKMT_QUERYSTATISTICS_DMA_BUFFER DmaBuffer; + D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA CommitmentData; + D3DKMT_QUERYSTATISTICS_POLICY _Policy; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY +{ + ULONG AllocsCommitted; + D3DKMT_QUERYSTATISTICS_COUNTER AllocsResidentInP[D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX]; + D3DKMT_QUERYSTATISTICS_COUNTER AllocsResidentInNonPreferred; + ULONGLONG TotalBytesEvictedDueToPreparation; +} D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY +{ + ULONGLONG UseMRU; +} D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION +{ + ULONGLONG BytesCommitted; + ULONGLONG MaximumWorkingSet; + ULONGLONG MinimumWorkingSet; + + ULONG NbReferencedAllocationEvictedInPeriod; + + D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY VideoMemory; + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY _Policy; + + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION +{ + ULONG NodeCount; + ULONG VidPnSourceCount; + D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY SystemMemory; + ULONG64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION +{ + ULONGLONG CommitLimit; + ULONGLONG BytesCommitted; + ULONGLONG BytesResident; + D3DKMT_QUERYSTATISTICS_MEMORY Memory; + ULONG Aperture; + ULONGLONG TotalBytesEvictedByPriority[D3DKMT_MaxAllocationPriorityClass]; + ULONG64 SystemMemoryEndAddress; + struct + { + ULONG64 PreservedDuringStandby : 1; + ULONG64 PreservedDuringHibernate : 1; + ULONG64 PartiallyPreservedDuringHibernate : 1; + ULONG64 Reserved : 61; + } PowerFlags; + ULONG64 Reserved[6]; +} D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION_V1 +{ + ULONG CommitLimit; + ULONG BytesCommitted; + ULONG BytesResident; + D3DKMT_QUERYSTATISTICS_MEMORY Memory; + ULONG Aperture; + ULONGLONG TotalBytesEvictedByPriority[D3DKMT_MaxAllocationPriorityClass]; + ULONG64 SystemMemoryEndAddress; + struct + { + ULONG64 PreservedDuringStandby : 1; + ULONG64 PreservedDuringHibernate : 1; + ULONG64 PartiallyPreservedDuringHibernate : 1; + ULONG64 Reserved : 61; + } PowerFlags; + + ULONG64 Reserved[7]; +} D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION_V1; + +typedef union _D3DKMT_QUERYSTATISTICS_RESULT +{ + D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION AdapterInformation; + D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION_V1 SegmentInformationV1; + D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION SegmentInformation; + D3DKMT_QUERYSTATISTICS_NODE_INFORMATION NodeInformation; + D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION VidPnSourceInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION ProcessInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION ProcessAdapterInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION ProcessSegmentInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION ProcessNodeInformation; + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION ProcessVidPnSourceInformation; +} D3DKMT_QUERYSTATISTICS_RESULT; + +typedef struct _D3DKMT_QUERYSTATISTICS +{ + D3DKMT_QUERYSTATISTICS_TYPE Type; + LUID AdapterLuid; + HANDLE hProcess; + D3DKMT_QUERYSTATISTICS_RESULT QueryResult; + + union + { + D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT QuerySegment; + D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT QueryProcessSegment; + D3DKMT_QUERYSTATISTICS_QUERY_NODE QueryNode; + D3DKMT_QUERYSTATISTICS_QUERY_NODE QueryProcessNode; + D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE QueryVidPnSource; + D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE QueryProcessVidPnSource; + } DUMMYUNIONNAME; +} D3DKMT_QUERYSTATISTICS; + +typedef struct _D3DKMT_QUERYVIDEOMEMORYINFO +{ + HANDLE hProcess; + D3DKMT_HANDLE hAdapter; + D3DKMT_MEMORY_SEGMENT_GROUP MemorySegmentGroup; + UINT64 Budget; + UINT64 CurrentUsage; + UINT64 CurrentReservation; + UINT64 AvailableForReservation; + UINT PhysicalAdapterIndex; +} D3DKMT_QUERYVIDEOMEMORYINFO; + +typedef enum _D3DKMT_QUEUEDLIMIT_TYPE +{ + D3DKMT_SET_QUEUEDLIMIT_PRESENT = 1, + D3DKMT_GET_QUEUEDLIMIT_PRESENT +} D3DKMT_QUEUEDLIMIT_TYPE; + +typedef struct _D3DKMT_SETQUEUEDLIMIT +{ + D3DKMT_HANDLE hDevice; + D3DKMT_QUEUEDLIMIT_TYPE Type; + union + { + UINT QueuedPresentLimit; + struct + { + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT QueuedPendingFlipLimit; + } DUMMYSTRUCTNAME; + } DUMMYUNIONNAME; +} D3DKMT_SETQUEUEDLIMIT; + +typedef enum _D3DKMT_ESCAPETYPE +{ + D3DKMT_ESCAPE_DRIVERPRIVATE, + D3DKMT_ESCAPE_VIDMM, + D3DKMT_ESCAPE_TDRDBGCTRL, + D3DKMT_ESCAPE_VIDSCH, + D3DKMT_ESCAPE_DEVICE, + D3DKMT_ESCAPE_DMM, + D3DKMT_ESCAPE_DEBUG_SNAPSHOT, + D3DKMT_ESCAPE_SETDRIVERUPDATESTATUS, + D3DKMT_ESCAPE_DRT_TEST, + D3DKMT_ESCAPE_DIAGNOSTICS, +} D3DKMT_ESCAPETYPE; + +typedef struct _D3DKMT_ESCAPE +{ + D3DKMT_HANDLE hAdapter; + D3DKMT_HANDLE hDevice; + D3DKMT_ESCAPETYPE Type; + D3DDDI_ESCAPEFLAGS Flags; + void *pPrivateDriverData; + UINT PrivateDriverDataSize; + D3DKMT_HANDLE hContext; +} D3DKMT_ESCAPE; + +typedef struct _D3DKMT_ADAPTERINFO +{ + D3DKMT_HANDLE hAdapter; + LUID AdapterLuid; + ULONG NumOfSources; + BOOL bPrecisePresentRegionsPreferred; +} D3DKMT_ADAPTERINFO; + +#define MAX_ENUM_ADAPTERS 16 + +typedef struct _D3DKMT_ENUMADAPTERS +{ + ULONG NumAdapters; + D3DKMT_ADAPTERINFO Adapters[MAX_ENUM_ADAPTERS]; +} D3DKMT_ENUMADAPTERS; + +typedef struct _D3DKMT_ENUMADAPTERS2 +{ + ULONG NumAdapters; + D3DKMT_ADAPTERINFO *pAdapters; +} D3DKMT_ENUMADAPTERS2; + +typedef struct _D3DKMT_CREATEKEYEDMUTEX +{ + UINT64 InitialValue; + D3DKMT_HANDLE hSharedHandle; + D3DKMT_HANDLE hKeyedMutex; +} D3DKMT_CREATEKEYEDMUTEX; + +typedef struct _D3DDDICB_SIGNALFLAGS +{ + union + { + struct + { + UINT SignalAtSubmission : 1; + UINT EnqueueCpuEvent : 1; + UINT AllowFenceRewind : 1; + UINT Reserved : 28; + UINT DXGK_SIGNAL_FLAG_INTERNAL0 : 1; + }; + UINT Value; + }; +} D3DDDICB_SIGNALFLAGS; + +typedef struct _D3DKMT_CREATEKEYEDMUTEX2_FLAGS +{ + union + { + struct + { + UINT NtSecuritySharing : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} D3DKMT_CREATEKEYEDMUTEX2_FLAGS; + +typedef struct _D3DKMT_CREATEKEYEDMUTEX2 +{ + UINT64 InitialValue; + D3DKMT_HANDLE hSharedHandle; + D3DKMT_HANDLE hKeyedMutex; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; + D3DKMT_CREATEKEYEDMUTEX2_FLAGS Flags; +} D3DKMT_CREATEKEYEDMUTEX2; + +typedef struct _D3DKMT_DESTROYKEYEDMUTEX +{ + D3DKMT_HANDLE hKeyedMutex; +} D3DKMT_DESTROYKEYEDMUTEX; + +typedef struct _D3DKMT_OPENKEYEDMUTEX +{ + D3DKMT_HANDLE hSharedHandle; + D3DKMT_HANDLE hKeyedMutex; +} D3DKMT_OPENKEYEDMUTEX; + +typedef struct _D3DKMT_OPENKEYEDMUTEX2 +{ + D3DKMT_HANDLE hSharedHandle; + D3DKMT_HANDLE hKeyedMutex; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; +} D3DKMT_OPENKEYEDMUTEX2; + +typedef struct _D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE +{ + HANDLE hNtHandle; + D3DKMT_HANDLE hKeyedMutex; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; +} D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE; + +typedef ULONGLONG D3DGPU_VIRTUAL_ADDRESS; + +#ifndef D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS_EXT +#define D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS_EXT +#define D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS_RESERVED0 Reserved0 +#endif + +typedef struct _D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS +{ + union + { + struct + { + UINT Shared : 1; + UINT NtSecuritySharing : 1; + UINT CrossAdapter : 1; + UINT TopOfPipeline : 1; + UINT NoSignal : 1; + UINT NoWait : 1; + UINT NoSignalMaxValueOnTdr : 1; + UINT NoGPUAccess : 1; + UINT Reserved : 23; + UINT D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS_RESERVED0 : 1; + }; + UINT Value; + }; +} D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS; + +typedef UINT D3DDDI_VIDEO_PRESENT_TARGET_ID; + +typedef enum _D3DDDI_SYNCHRONIZATIONOBJECT_TYPE +{ + D3DDDI_SYNCHRONIZATION_MUTEX = 1, + D3DDDI_SEMAPHORE = 2, + D3DDDI_FENCE = 3, + D3DDDI_CPU_NOTIFICATION = 4, + D3DDDI_MONITORED_FENCE = 5, + D3DDDI_PERIODIC_MONITORED_FENCE = 6, + D3DDDI_SYNCHRONIZATION_TYPE_LIMIT +} D3DDDI_SYNCHRONIZATIONOBJECT_TYPE; + +typedef struct _D3DDDI_SYNCHRONIZATIONOBJECTINFO +{ + D3DDDI_SYNCHRONIZATIONOBJECT_TYPE Type; + union + { + struct + { + BOOL InitialState; + } SynchronizationMutex; + struct + { + UINT MaxCount; + UINT InitialCount; + } Semaphore; + struct + { + UINT Reserved[16]; + } Reserved; + }; +} D3DDDI_SYNCHRONIZATIONOBJECTINFO; + +typedef struct _D3DKMT_CREATESYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hDevice; + D3DDDI_SYNCHRONIZATIONOBJECTINFO Info; + D3DKMT_HANDLE hSyncObject; +} D3DKMT_CREATESYNCHRONIZATIONOBJECT; + +typedef struct _D3DDDI_SYNCHRONIZATIONOBJECTINFO2 +{ + D3DDDI_SYNCHRONIZATIONOBJECT_TYPE Type; + D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS Flags; + union + { + struct + { + BOOL InitialState; + } SynchronizationMutex; + struct + { + UINT MaxCount; + UINT InitialCount; + } Semaphore; + struct + { + UINT64 FenceValue; + } Fence; + struct + { + HANDLE Event; + } CPUNotification; + struct + { + UINT64 InitialFenceValue; + void *FenceValueCPUVirtualAddress; + D3DGPU_VIRTUAL_ADDRESS FenceValueGPUVirtualAddress; + UINT EngineAffinity; + } MonitoredFence; + struct + { + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + UINT64 Time; + void *FenceValueCPUVirtualAddress; + D3DGPU_VIRTUAL_ADDRESS FenceValueGPUVirtualAddress; + UINT EngineAffinity; + } PeriodicMonitoredFence; + struct + { + UINT64 Reserved[8]; + } Reserved; + }; + D3DKMT_HANDLE SharedHandle; +} D3DDDI_SYNCHRONIZATIONOBJECTINFO2; + +typedef struct _D3DKMT_CREATESYNCHRONIZATIONOBJECT2 +{ + D3DKMT_HANDLE hDevice; + D3DDDI_SYNCHRONIZATIONOBJECTINFO2 Info; + D3DKMT_HANDLE hSyncObject; +} D3DKMT_CREATESYNCHRONIZATIONOBJECT2; + +typedef struct _D3DKMT_OPENSYNCOBJECTFROMNTHANDLE +{ + HANDLE hNtHandle; + D3DKMT_HANDLE hSyncObject; +} D3DKMT_OPENSYNCOBJECTFROMNTHANDLE; + +typedef struct _D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 +{ + HANDLE hNtHandle; + D3DKMT_HANDLE hDevice; + D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS Flags; + D3DKMT_HANDLE hSyncObject; + union + { + + struct + { + void *FenceValueCPUVirtualAddress; + D3DGPU_VIRTUAL_ADDRESS FenceValueGPUVirtualAddress; + UINT EngineAffinity; + } MonitoredFence; + UINT64 Reserved[8]; + }; +} D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2; + +typedef struct _D3DKMT_OPENSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hSharedHandle; + D3DKMT_HANDLE hSyncObject; + UINT64 Reserved[8]; +} D3DKMT_OPENSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME +{ + DWORD dwDesiredAccess; + OBJECT_ATTRIBUTES *pObjAttrib; + HANDLE hNtHandle; +} D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME; + +typedef struct _D3DKMT_DESTROYSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hSyncObject; +} D3DKMT_DESTROYSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_CREATESTANDARDALLOCATIONFLAGS +{ + union + { + struct + { + UINT Reserved : 32; + }; + UINT Value; + }; +} D3DKMT_CREATESTANDARDALLOCATIONFLAGS; + +typedef enum _D3DKMT_STANDARDALLOCATIONTYPE +{ + D3DKMT_STANDARDALLOCATIONTYPE_EXISTINGHEAP = 1, +} D3DKMT_STANDARDALLOCATIONTYPE; + +typedef struct _D3DKMT_STANDARDALLOCATION_EXISTINGHEAP +{ + SIZE_T Size; +} D3DKMT_STANDARDALLOCATION_EXISTINGHEAP; + +typedef struct _D3DKMT_CREATESTANDARDALLOCATION +{ + D3DKMT_STANDARDALLOCATIONTYPE Type; + union + { + D3DKMT_STANDARDALLOCATION_EXISTINGHEAP ExistingHeapData; + }; + D3DKMT_CREATESTANDARDALLOCATIONFLAGS Flags; +} D3DKMT_CREATESTANDARDALLOCATION; + +typedef struct _D3DDDI_ALLOCATIONINFO +{ + D3DKMT_HANDLE hAllocation; + const void *pSystemMem; + void *pPrivateDriverData; + UINT PrivateDriverDataSize; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + union + { + struct + { + UINT Primary : 1; + UINT Stereo : 1; + UINT Reserved : 30; + }; + UINT Value; + } Flags; +} D3DDDI_ALLOCATIONINFO; + +typedef struct _D3DDDI_ALLOCATIONINFO2 +{ + D3DKMT_HANDLE hAllocation; + union + { + HANDLE hSection; + const void *pSystemMem; + }; + VOID *pPrivateDriverData; + UINT PrivateDriverDataSize; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + union + { + struct + { + UINT Primary : 1; + UINT Stereo : 1; + UINT OverridePriority : 1; + UINT Reserved : 29; + }; + UINT Value; + } Flags; + D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress; + union + { + UINT Priority; + ULONG_PTR Unused; + }; + ULONG_PTR Reserved[5]; +} D3DDDI_ALLOCATIONINFO2; + +typedef struct _D3DKMT_CREATEALLOCATIONFLAGS +{ + UINT CreateResource : 1; + UINT CreateShared : 1; + UINT NonSecure : 1; + UINT CreateProtected : 1; + UINT RestrictSharedAccess : 1; + UINT ExistingSysMem : 1; + UINT NtSecuritySharing : 1; + UINT ReadOnly : 1; + UINT CreateWriteCombined : 1; + UINT CreateCached : 1; + UINT SwapChainBackBuffer : 1; + UINT CrossAdapter : 1; + UINT OpenCrossAdapter : 1; + UINT PartialSharedCreation : 1; + UINT Zeroed : 1; + UINT WriteWatch : 1; + UINT StandardAllocation : 1; + UINT ExistingSection : 1; + UINT AllowNotZeroed : 1; + UINT PhysicallyContiguous : 1; + UINT Reserved : 12; +} D3DKMT_CREATEALLOCATIONFLAGS; + +typedef struct _D3DKMT_CREATEALLOCATION +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hResource; + D3DKMT_HANDLE hGlobalShare; + const void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; + union + { + D3DKMT_CREATESTANDARDALLOCATION *pStandardAllocation; + const void *pPrivateDriverData; + }; + UINT PrivateDriverDataSize; + UINT NumAllocations; + union + { + D3DDDI_ALLOCATIONINFO *pAllocationInfo; + D3DDDI_ALLOCATIONINFO2 *pAllocationInfo2; + }; + D3DKMT_CREATEALLOCATIONFLAGS Flags; + HANDLE hPrivateRuntimeResourceHandle; +} D3DKMT_CREATEALLOCATION; + +typedef struct _D3DKMT_DESTROYALLOCATION +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hResource; + const D3DKMT_HANDLE *phAllocationList; + UINT AllocationCount; +} D3DKMT_DESTROYALLOCATION; + +typedef struct _D3DDDICB_DESTROYALLOCATION2FLAGS +{ + union + { + struct + { + UINT AssumeNotInUse : 1; + UINT SynchronousDestroy : 1; + UINT Reserved : 29; + UINT SystemUseOnly : 1; + }; + UINT Value; + }; +} D3DDDICB_DESTROYALLOCATION2FLAGS; + +typedef struct _D3DKMT_DESTROYALLOCATION2 +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hResource; + const D3DKMT_HANDLE *phAllocationList; + UINT AllocationCount; + D3DDDICB_DESTROYALLOCATION2FLAGS Flags; +} D3DKMT_DESTROYALLOCATION2; + +typedef struct _D3DDDI_OPENALLOCATIONINFO +{ + D3DKMT_HANDLE hAllocation; + const void *pPrivateDriverData; + UINT PrivateDriverDataSize; +} D3DDDI_OPENALLOCATIONINFO; + +typedef struct _D3DDDI_OPENALLOCATIONINFO2 +{ + D3DKMT_HANDLE hAllocation; + const void *pPrivateDriverData; + UINT PrivateDriverDataSize; + D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress; + ULONG_PTR Reserved[6]; +} D3DDDI_OPENALLOCATIONINFO2; + +typedef struct _D3DKMT_OPENRESOURCE +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hGlobalShare; + UINT NumAllocations; + union + { + D3DDDI_OPENALLOCATIONINFO *pOpenAllocationInfo; + D3DDDI_OPENALLOCATIONINFO2 *pOpenAllocationInfo2; + }; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; + void *pResourcePrivateDriverData; + UINT ResourcePrivateDriverDataSize; + void *pTotalPrivateDriverDataBuffer; + UINT TotalPrivateDriverDataBufferSize; + D3DKMT_HANDLE hResource; +} D3DKMT_OPENRESOURCE; + +typedef struct _D3DKMT_OPENRESOURCEFROMNTHANDLE +{ + D3DKMT_HANDLE hDevice; + HANDLE hNtHandle; + UINT NumAllocations; + D3DDDI_OPENALLOCATIONINFO2 *pOpenAllocationInfo2; + UINT PrivateRuntimeDataSize; + void *pPrivateRuntimeData; + UINT ResourcePrivateDriverDataSize; + void *pResourcePrivateDriverData; + UINT TotalPrivateDriverDataBufferSize; + void *pTotalPrivateDriverDataBuffer; + D3DKMT_HANDLE hResource; + D3DKMT_HANDLE hKeyedMutex; + void *pKeyedMutexPrivateRuntimeData; + UINT KeyedMutexPrivateRuntimeDataSize; + D3DKMT_HANDLE hSyncObject; +} D3DKMT_OPENRESOURCEFROMNTHANDLE; + +typedef struct _D3DKMT_QUERYRESOURCEINFO +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hGlobalShare; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; + UINT TotalPrivateDriverDataSize; + UINT ResourcePrivateDriverDataSize; + UINT NumAllocations; +} D3DKMT_QUERYRESOURCEINFO; + +typedef struct _D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE +{ + D3DKMT_HANDLE hDevice; + HANDLE hNtHandle; + void *pPrivateRuntimeData; + UINT PrivateRuntimeDataSize; + UINT TotalPrivateDriverDataSize; + UINT ResourcePrivateDriverDataSize; + UINT NumAllocations; +} D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE; + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +NTSTATUS WINAPI D3DKMTCheckVidPnExclusiveOwnership(const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc); +NTSTATUS WINAPI D3DKMTCloseAdapter(const D3DKMT_CLOSEADAPTER *desc); +NTSTATUS WINAPI D3DKMTCreateAllocation( D3DKMT_CREATEALLOCATION *params ); +NTSTATUS WINAPI D3DKMTCreateAllocation2( D3DKMT_CREATEALLOCATION *params ); +NTSTATUS WINAPI D3DKMTCreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *desc); +NTSTATUS WINAPI D3DKMTCreateDevice(D3DKMT_CREATEDEVICE *desc); +NTSTATUS WINAPI D3DKMTCreateKeyedMutex( D3DKMT_CREATEKEYEDMUTEX *params ); +NTSTATUS WINAPI D3DKMTCreateKeyedMutex2( D3DKMT_CREATEKEYEDMUTEX2 *params ); +NTSTATUS WINAPI D3DKMTCreateSynchronizationObject( D3DKMT_CREATESYNCHRONIZATIONOBJECT *params ); +NTSTATUS WINAPI D3DKMTCreateSynchronizationObject2( D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *params ); +NTSTATUS WINAPI D3DKMTDestroyAllocation( const D3DKMT_DESTROYALLOCATION *params ); +NTSTATUS WINAPI D3DKMTDestroyAllocation2( const D3DKMT_DESTROYALLOCATION2 *params ); +NTSTATUS WINAPI D3DKMTDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *desc); +NTSTATUS WINAPI D3DKMTDestroyDevice(const D3DKMT_DESTROYDEVICE *desc); +NTSTATUS WINAPI D3DKMTDestroyKeyedMutex( const D3DKMT_DESTROYKEYEDMUTEX *params ); +NTSTATUS WINAPI D3DKMTDestroySynchronizationObject( const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *params ); +NTSTATUS WINAPI D3DKMTEnumAdapters2(D3DKMT_ENUMADAPTERS2 *desc); +NTSTATUS WINAPI D3DKMTEscape( const D3DKMT_ESCAPE *desc ); +NTSTATUS WINAPI D3DKMTOpenAdapterFromGdiDisplayName(D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME *desc); +NTSTATUS WINAPI D3DKMTOpenAdapterFromHdc( D3DKMT_OPENADAPTERFROMHDC *desc ); +NTSTATUS WINAPI D3DKMTOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID * desc ); +NTSTATUS WINAPI D3DKMTOpenKeyedMutex( D3DKMT_OPENKEYEDMUTEX *params ); +NTSTATUS WINAPI D3DKMTOpenKeyedMutex2( D3DKMT_OPENKEYEDMUTEX2 *params ); +NTSTATUS WINAPI D3DKMTOpenKeyedMutexFromNtHandle( D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE *params ); +NTSTATUS WINAPI D3DKMTOpenResource( D3DKMT_OPENRESOURCE *params ); +NTSTATUS WINAPI D3DKMTOpenResource2( D3DKMT_OPENRESOURCE *params ); +NTSTATUS WINAPI D3DKMTOpenResourceFromNtHandle( D3DKMT_OPENRESOURCEFROMNTHANDLE *params ); +NTSTATUS WINAPI D3DKMTOpenSynchronizationObject( D3DKMT_OPENSYNCHRONIZATIONOBJECT *params ); +NTSTATUS WINAPI D3DKMTOpenSyncObjectFromNtHandle( D3DKMT_OPENSYNCOBJECTFROMNTHANDLE *params ); +NTSTATUS WINAPI D3DKMTOpenSyncObjectFromNtHandle2( D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *params ); +NTSTATUS WINAPI D3DKMTOpenSyncObjectNtHandleFromName( D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *params ); +NTSTATUS WINAPI D3DKMTQueryAdapterInfo(D3DKMT_QUERYADAPTERINFO *desc); +NTSTATUS WINAPI D3DKMTQueryResourceInfo( D3DKMT_QUERYRESOURCEINFO *params ); +NTSTATUS WINAPI D3DKMTQueryResourceInfoFromNtHandle( D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *params ); +NTSTATUS WINAPI D3DKMTQueryStatistics(D3DKMT_QUERYSTATISTICS *stats); +NTSTATUS WINAPI D3DKMTQueryVideoMemoryInfo(D3DKMT_QUERYVIDEOMEMORYINFO *desc); +NTSTATUS WINAPI D3DKMTSetQueuedLimit(D3DKMT_SETQUEUEDLIMIT *desc); +NTSTATUS WINAPI D3DKMTSetVidPnSourceOwner(const D3DKMT_SETVIDPNSOURCEOWNER *desc); +NTSTATUS WINAPI D3DKMTShareObjects( UINT count, const D3DKMT_HANDLE *handles, OBJECT_ATTRIBUTES *attr, UINT access, HANDLE *handle ); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __WINE_D3DKMTHK_H */ diff --git a/sdk/include/wine/ntgdi.h b/sdk/include/wine/ntgdi.h new file mode 100644 index 00000000000..2f7b284a679 --- /dev/null +++ b/sdk/include/wine/ntgdi.h @@ -0,0 +1,525 @@ +/* + * Copyright 2021 Jacek Caban for CodeWeavers + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef _NTGDI_ +#define _NTGDI_ + +#include +#include +#include +#include + +#ifndef W32KAPI +# if defined(_WIN32U_) || defined(WINE_UNIX_LIB) +# define W32KAPI DECLSPEC_EXPORT +# else +# define W32KAPI DECLSPEC_IMPORT +# endif +#endif + +typedef struct _GDI_HANDLE_ENTRY +{ + UINT64 Object; + union + { + struct + { + USHORT ProcessId; + USHORT Lock : 1; + USHORT Count : 15; + }; + ULONG Value; + } Owner; + union + { + struct + { + UCHAR ExtType : 7; + UCHAR StockFlag : 1; + UCHAR Generation; + }; + USHORT Unique; + }; + UCHAR Type; + UCHAR Flags; + UINT64 UserPointer; +} GDI_HANDLE_ENTRY, *PGDI_HANDLE_ENTRY; + +#define GDI_MAX_HANDLE_COUNT 0x10000 + +#define NTGDI_OBJ_DC 0x010000 +#define NTGDI_OBJ_ENHMETADC 0x210000 +#define NTGDI_OBJ_REGION 0x040000 +#define NTGDI_OBJ_SURF 0x050000 +#define NTGDI_OBJ_METAFILE 0x260000 +#define NTGDI_OBJ_ENHMETAFILE 0x460000 +#define NTGDI_OBJ_METADC 0x660000 +#define NTGDI_OBJ_PAL 0x080000 +#define NTGDI_OBJ_BITMAP 0x090000 +#define NTGDI_OBJ_FONT 0x0a0000 +#define NTGDI_OBJ_BRUSH 0x100000 +#define NTGDI_OBJ_PEN 0x300000 +#define NTGDI_OBJ_EXTPEN 0x500000 + +/* Wine extension, native uses NTGDI_OBJ_DC */ +#define NTGDI_OBJ_MEMDC 0x410000 + +#define NTGDI_HANDLE_TYPE_SHIFT 16 +#define NTGDI_HANDLE_TYPE_MASK 0x007f0000 +#define NTGDI_HANDLE_STOCK_OBJECT 0x00800000 + +typedef struct _GDI_SHARED_MEMORY +{ + GDI_HANDLE_ENTRY Handles[GDI_MAX_HANDLE_COUNT]; +} GDI_SHARED_MEMORY, *PGDI_SHARED_MEMORY; + +enum +{ + NtGdiArc, + NtGdiArcTo, + NtGdiChord, + NtGdiPie, +}; + +enum +{ + NtGdiPolyPolygon = 1, + NtGdiPolyPolyline, + NtGdiPolyBezier, + NtGdiPolyBezierTo, + NtGdiPolylineTo, + NtGdiPolyPolygonRgn, +}; + +enum +{ + NtGdiLPtoDP, + NtGdiDPtoLP, +}; + +enum +{ + NtGdiSetMapMode = 8, + /* not compatible with Windows */ + NtGdiSetBkColor = 100, + NtGdiSetBkMode, + NtGdiSetTextColor, + NtGdiSetDCBrushColor, + NtGdiSetDCPenColor, + NtGdiSetGraphicsMode, + NtGdiSetROP2, + NtGdiSetTextAlign, +}; + +/* NtGdiGetDCDword parameter, not compatible with Windows */ +enum +{ + NtGdiGetArcDirection, + NtGdiGetBkColor, + NtGdiGetBkMode, + NtGdiGetDCBrushColor, + NtGdiGetDCPenColor, + NtGdiGetGraphicsMode, + NtGdiGetLayout, + NtGdiGetPolyFillMode, + NtGdiGetROP2, + NtGdiGetTextColor, + NtGdiIsMemDC, +}; + +/* NtGdiGetDCPoint parameter, not compatible with Windows */ +enum +{ + NtGdiGetBrushOrgEx, + NtGdiGetCurrentPosition, + NtGdiGetDCOrg, +}; + +enum +{ + NtGdiAnimatePalette, + NtGdiSetPaletteEntries, + NtGdiGetPaletteEntries, + NtGdiGetSystemPaletteEntries, + NtGdiGetDIBColorTable, + NtGdiSetDIBColorTable, +}; + +#define NTGDI_GETCHARWIDTH_INT 0x02 +#define NTGDI_GETCHARWIDTH_INDICES 0x08 + +#define NTGDI_GETCHARABCWIDTHS_INT 0x01 +#define NTGDI_GETCHARABCWIDTHS_INDICES 0x02 + +#define MWT_SET 4 + +/* structs not compatible with native Windows */ +#ifdef __WINESRC__ + +typedef struct DC_ATTR +{ + UINT hdc; /* handle to self */ + LONG disabled; /* disabled flag, controlled by DCHF_(DISABLE|ENABLE)DC */ + int save_level; + COLORREF background_color; + COLORREF brush_color; + COLORREF pen_color; + COLORREF text_color; + POINT cur_pos; + INT graphics_mode; + INT arc_direction; + DWORD layout; + WORD text_align; + WORD background_mode; + WORD poly_fill_mode; + WORD rop_mode; + WORD rel_abs_mode; + WORD stretch_blt_mode; + INT map_mode; + INT char_extra; + DWORD mapper_flags; /* font mapper flags */ + RECT vis_rect; /* visible rectangle in screen coords */ + FLOAT miter_limit; + POINT brush_org; /* brush origin */ + POINT wnd_org; /* window origin */ + SIZE wnd_ext; /* window extent */ + POINT vport_org; /* viewport origin */ + SIZE vport_ext; /* viewport extent */ + SIZE virtual_res; + SIZE virtual_size; + UINT font_code_page; + RECTL emf_bounds; + UINT64 emf; /* client EMF record pointer */ + UINT64 abort_proc; /* AbortProc for printing */ + UINT64 print; /* client printer info pointer */ +} DC_ATTR; + +struct font_enum_entry +{ + DWORD type; + ENUMLOGFONTEXW lf; + NEWTEXTMETRICEXW tm; +}; + +/* flag for NtGdiGetRandomRgn to respect LAYOUT_RTL */ +#define NTGDI_RGN_MIRROR_RTL 0x80000000 +/* internal flag to get region in monitor raw DPI */ +#define NTGDI_RGN_MONITOR_DPI 0x40000000 + +#endif /* __WINESRC__ */ + +struct font_realization_info +{ + DWORD size; /* could be 16 or 24 */ + DWORD flags; /* 1 for bitmap fonts, 3 for scalable fonts */ + DWORD cache_num; /* keeps incrementing */ + DWORD instance_id; /* identifies a realized font instance */ + DWORD file_count; /* number of files that make up this font */ + WORD face_index; /* face index in case of font collections */ + WORD simulations; /* 0 bit - bold simulation, 1 bit - oblique simulation */ +}; + +struct char_width_info +{ + INT lsb; /* minimum left side bearing */ + INT rsb; /* minimum right side bearing */ + INT unk; /* unknown */ +}; + +struct font_fileinfo +{ + FILETIME writetime; + LARGE_INTEGER size; + WCHAR path[1]; +}; + + +W32KAPI INT WINAPI NtGdiAbortDoc( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiAbortPath( HDC hdc ); +W32KAPI HANDLE WINAPI NtGdiAddFontMemResourceEx( void *ptr, DWORD size, void *dv, ULONG dv_size, + DWORD *count ); +W32KAPI INT WINAPI NtGdiAddFontResourceW( const WCHAR *str, ULONG size, ULONG files, DWORD flags, + DWORD tid, void *dv ); +W32KAPI BOOL WINAPI NtGdiAlphaBlend( HDC hdc_dst, int x_dst, int y_dst, int width_dst, int height_dst, + HDC hdc_src, int x_src, int y_src, int width_src, int height_src, + DWORD blend_function, HANDLE xform ); +W32KAPI BOOL WINAPI NtGdiAngleArc( HDC hdc, INT x, INT y, DWORD radius, DWORD start_angle, + DWORD sweep_angle ); +W32KAPI BOOL WINAPI NtGdiArcInternal( UINT type, HDC hdc, INT left, INT top, INT right, INT bottom, + INT xstart, INT ystart, INT xend, INT yend ); +W32KAPI BOOL WINAPI NtGdiBeginPath( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiBitBlt( HDC hdc_dst, INT x_dst, INT y_dst, INT width, INT height, HDC hdc_src, + INT x_src, INT y_src, DWORD rop, DWORD bk_color, FLONG fl ); +W32KAPI BOOL WINAPI NtGdiCancelDC( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiCloseFigure( HDC hdc ); +W32KAPI INT WINAPI NtGdiCombineRgn( HRGN dest, HRGN src1, HRGN src2, INT mode ); +W32KAPI BOOL WINAPI NtGdiComputeXformCoefficients( HDC hdc ); +W32KAPI HBITMAP WINAPI NtGdiCreateBitmap( INT width, INT height, UINT planes, + UINT bpp, const void *bits ); +W32KAPI HANDLE WINAPI NtGdiCreateClientObj( ULONG type ); +W32KAPI HBITMAP WINAPI NtGdiCreateCompatibleBitmap( HDC hdc, INT width, INT height ); +W32KAPI HDC WINAPI NtGdiCreateCompatibleDC( HDC hdc ); +W32KAPI HBRUSH WINAPI NtGdiCreateDIBBrush( const void *data, UINT coloruse, UINT size, + BOOL is_8x8, BOOL pen, const void *client ); +W32KAPI HBITMAP WINAPI NtGdiCreateDIBSection( HDC hdc, HANDLE section, DWORD offset, const BITMAPINFO *bmi, + UINT usage, UINT header_size, ULONG flags, + ULONG_PTR color_space, void **bits ); +W32KAPI HBITMAP WINAPI NtGdiCreateDIBitmapInternal( HDC hdc, INT width, INT height, DWORD init, + const void *bits, const BITMAPINFO *data, + UINT coloruse, UINT max_info, UINT max_bits, + ULONG flags, HANDLE xform ); +W32KAPI HRGN WINAPI NtGdiCreateEllipticRgn( INT left, INT top, INT right, INT bottom ); +W32KAPI HPALETTE WINAPI NtGdiCreateHalftonePalette( HDC hdc ); +W32KAPI HBRUSH WINAPI NtGdiCreateHatchBrushInternal( INT style, COLORREF color, BOOL pen ); +W32KAPI HDC WINAPI NtGdiCreateMetafileDC( HDC hdc ); +W32KAPI HPALETTE WINAPI NtGdiCreatePaletteInternal( const LOGPALETTE *palette, UINT count ); +W32KAPI HBRUSH WINAPI NtGdiCreatePatternBrushInternal( HBITMAP hbitmap, BOOL pen, BOOL is_8x8 ); +W32KAPI HPEN WINAPI NtGdiCreatePen( INT style, INT width, COLORREF color, HBRUSH brush ); +W32KAPI HRGN WINAPI NtGdiCreateRectRgn( INT left, INT top, INT right, INT bottom ); +W32KAPI HRGN WINAPI NtGdiCreateRoundRectRgn( INT left, INT top, INT right, INT bottom, + INT ellipse_width, INT ellipse_height ); +W32KAPI HBRUSH WINAPI NtGdiCreateSolidBrush( COLORREF color, HBRUSH brush ); +W32KAPI BOOL WINAPI NtGdiDeleteClientObj( HGDIOBJ obj ); +W32KAPI BOOL WINAPI NtGdiDeleteObjectApp( HGDIOBJ obj ); +W32KAPI INT WINAPI NtGdiDescribePixelFormat( HDC hdc, INT format, UINT size, + PIXELFORMATDESCRIPTOR *descr ); +W32KAPI LONG WINAPI NtGdiDoPalette( HGDIOBJ handle, WORD start, WORD count, void *entries, + DWORD func, BOOL inbound ); +W32KAPI BOOL WINAPI NtGdiDrawStream( HDC hdc, ULONG in, void *pvin ); +W32KAPI BOOL WINAPI NtGdiEllipse( HDC hdc, INT left, INT top, INT right, INT bottom ); +W32KAPI INT WINAPI NtGdiEndDoc( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiEndPath( HDC hdc ); +W32KAPI INT WINAPI NtGdiEndPage( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiEnumFonts( HDC hdc, ULONG type, ULONG win32_compat, ULONG face_name_len, + const WCHAR *face_name, ULONG charset, ULONG *count, void *buf ); +W32KAPI BOOL WINAPI NtGdiEqualRgn( HRGN hrgn1, HRGN hrgn2 ); +W32KAPI INT WINAPI NtGdiExcludeClipRect( HDC hdc, INT left, INT top, INT right, INT bottom ); +W32KAPI HPEN WINAPI NtGdiExtCreatePen( DWORD style, DWORD width, ULONG brush_style, ULONG color, + ULONG_PTR client_hatch, ULONG_PTR hatch, DWORD style_count, + const DWORD *style_bits, ULONG dib_size, BOOL old_style, + HBRUSH brush ); +W32KAPI INT WINAPI NtGdiExtEscape( HDC hdc, WCHAR *driver, INT driver_id, INT escape, INT input_size, + const char *input, INT output_size, char *output ); +W32KAPI BOOL WINAPI NtGdiExtFloodFill( HDC hdc, INT x, INT y, COLORREF color, UINT type ); +W32KAPI BOOL WINAPI NtGdiExtTextOutW( HDC hdc, INT x, INT y, UINT flags, const RECT *rect, + const WCHAR *str, UINT count, const INT *dx, DWORD cp ); +W32KAPI HRGN WINAPI NtGdiExtCreateRegion( const XFORM *xform, DWORD count, const RGNDATA *data ); +W32KAPI INT WINAPI NtGdiExtGetObjectW( HGDIOBJ handle, INT count, void *buffer ); +W32KAPI INT WINAPI NtGdiExtSelectClipRgn( HDC hdc, HRGN region, INT mode ); +W32KAPI BOOL WINAPI NtGdiFillPath( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiFillRgn( HDC hdc, HRGN hrgn, HBRUSH hbrush ); +W32KAPI BOOL WINAPI NtGdiFlattenPath( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiFontIsLinked( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiFlush(void); +W32KAPI BOOL WINAPI NtGdiFrameRgn( HDC hdc, HRGN hrgn, HBRUSH brush, INT width, INT height ); +W32KAPI BOOL WINAPI NtGdiGetAndSetDCDword( HDC hdc, UINT method, DWORD value, DWORD *result ); +W32KAPI INT WINAPI NtGdiGetAppClipBox( HDC hdc, RECT *rect ); +W32KAPI LONG WINAPI NtGdiGetBitmapBits( HBITMAP bitmap, LONG count, void *bits ); +W32KAPI BOOL WINAPI NtGdiGetBitmapDimension( HBITMAP bitmap, SIZE *size ); +W32KAPI UINT WINAPI NtGdiGetBoundsRect( HDC hdc, RECT *rect, UINT flags ); +W32KAPI BOOL WINAPI NtGdiGetCharABCWidthsW( HDC hdc, UINT first, UINT last, WCHAR *chars, + ULONG flags, void *buffer ); +W32KAPI BOOL WINAPI NtGdiGetCharWidthW( HDC hdc, UINT first_char, UINT last_char, WCHAR *chars, + ULONG flags, void *buffer ); +W32KAPI BOOL WINAPI NtGdiGetCharWidthInfo( HDC hdc, struct char_width_info *info ); +W32KAPI BOOL WINAPI NtGdiGetColorAdjustment( HDC hdc, COLORADJUSTMENT *ca ); +W32KAPI BOOL WINAPI NtGdiGetDCDword( HDC hdc, UINT method, DWORD *result ); +W32KAPI HANDLE WINAPI NtGdiGetDCObject( HDC hdc, UINT type ); +W32KAPI BOOL WINAPI NtGdiGetDCPoint( HDC hdc, UINT method, POINT *result ); +W32KAPI INT WINAPI NtGdiGetDIBitsInternal( HDC hdc, HBITMAP hbitmap, UINT startscan, UINT lines, + void *bits, BITMAPINFO *info, UINT coloruse, + UINT max_bits, UINT max_info ); +W32KAPI INT WINAPI NtGdiGetDeviceCaps( HDC hdc, INT cap ); +W32KAPI BOOL WINAPI NtGdiGetDeviceGammaRamp( HDC hdc, void *ptr ); +W32KAPI DWORD WINAPI NtGdiGetFontData( HDC hdc, DWORD table, DWORD offset, void *buffer, DWORD length ); +W32KAPI BOOL WINAPI NtGdiGetFontFileData( DWORD instance_id, DWORD file_index, UINT64 *offset, + void *buff, SIZE_T buff_size ); +W32KAPI BOOL WINAPI NtGdiGetFontFileInfo( DWORD instance_id, DWORD file_index, struct font_fileinfo *info, + SIZE_T size, SIZE_T *needed ); +W32KAPI DWORD WINAPI NtGdiGetFontUnicodeRanges( HDC hdc, GLYPHSET *lpgs ); +W32KAPI DWORD WINAPI NtGdiGetGlyphIndicesW( HDC hdc, const WCHAR *str, INT count, + WORD *indices, DWORD flags ); +W32KAPI DWORD WINAPI NtGdiGetGlyphOutline( HDC hdc, UINT ch, UINT format, GLYPHMETRICS *metrics, + DWORD size, void *buffer, const MAT2 *mat2, + BOOL ignore_rotation ); +W32KAPI DWORD WINAPI NtGdiGetKerningPairs( HDC hdc, DWORD count, KERNINGPAIR *kern_pair ); +W32KAPI BOOL WINAPI NtGdiGetMiterLimit( HDC hdc, DWORD *limit ); +W32KAPI COLORREF WINAPI NtGdiGetNearestColor( HDC hdc, COLORREF color ); +W32KAPI UINT WINAPI NtGdiGetNearestPaletteIndex( HPALETTE hpalette, COLORREF color ); +W32KAPI UINT WINAPI NtGdiGetOutlineTextMetricsInternalW( HDC hdc, UINT cbData, + OUTLINETEXTMETRICW *otm, ULONG opts ); +W32KAPI INT WINAPI NtGdiGetPath( HDC hdc, POINT *points, BYTE *types, INT size ); +W32KAPI COLORREF WINAPI NtGdiGetPixel( HDC hdc, INT x, INT y ); +W32KAPI INT WINAPI NtGdiGetRandomRgn( HDC hdc, HRGN region, INT code ); +W32KAPI BOOL WINAPI NtGdiGetRasterizerCaps( RASTERIZER_STATUS *status, UINT size ); +W32KAPI BOOL WINAPI NtGdiGetRealizationInfo( HDC hdc, struct font_realization_info *info ); +W32KAPI DWORD WINAPI NtGdiGetRegionData( HRGN hrgn, DWORD count, RGNDATA *data ); +W32KAPI INT WINAPI NtGdiGetRgnBox( HRGN hrgn, RECT *rect ); +W32KAPI DWORD WINAPI NtGdiGetSpoolMessage( void *ptr1, DWORD data2, void *ptr3, DWORD data4 ); +W32KAPI UINT WINAPI NtGdiGetSystemPaletteUse( HDC hdc ); +W32KAPI UINT WINAPI NtGdiGetTextCharsetInfo( HDC hdc, FONTSIGNATURE *fs, DWORD flags ); +W32KAPI BOOL WINAPI NtGdiGetTextExtentExW( HDC hdc, const WCHAR *str, INT count, INT max_ext, + INT *nfit, INT *dxs, SIZE *size, UINT flags ); +W32KAPI INT WINAPI NtGdiGetTextFaceW( HDC hdc, INT count, WCHAR *name, BOOL alias_name ); +W32KAPI BOOL WINAPI NtGdiGetTextMetricsW( HDC hdc, TEXTMETRICW *metrics, ULONG flags ); +W32KAPI BOOL WINAPI NtGdiGetTransform( HDC hdc, DWORD which, XFORM *xform ); +W32KAPI BOOL WINAPI NtGdiGradientFill( HDC hdc, TRIVERTEX *vert_array, ULONG nvert, + void *grad_array, ULONG ngrad, ULONG mode ); +W32KAPI HFONT WINAPI NtGdiHfontCreate( const void *logfont, ULONG unk2, ULONG unk3, + ULONG unk4, void *data ); +W32KAPI BOOL WINAPI NtGdiIcmBrushInfo( HDC hdc, HBRUSH handle, BITMAPINFO *info, void *bits, + ULONG *bits_size, UINT *usage, BOOL *unk, UINT mode ); +W32KAPI DWORD WINAPI NtGdiInitSpool(void); +W32KAPI INT WINAPI NtGdiIntersectClipRect( HDC hdc, INT left, INT top, INT right, INT bottom ); +W32KAPI BOOL WINAPI NtGdiInvertRgn( HDC hdc, HRGN hrgn ); +W32KAPI BOOL WINAPI NtGdiLineTo( HDC hdc, INT x, INT y ); +W32KAPI BOOL WINAPI NtGdiMaskBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, + HDC hdc_src, INT x_src, INT y_src, HBITMAP mask, + INT x_mask, INT y_mask, DWORD rop, DWORD bk_color ); +W32KAPI BOOL WINAPI NtGdiModifyWorldTransform( HDC hdc, const XFORM *xform, DWORD mode ); +W32KAPI BOOL WINAPI NtGdiMoveTo( HDC hdc, INT x, INT y, POINT *pt ); +W32KAPI INT WINAPI NtGdiOffsetClipRgn( HDC hdc, INT x, INT y ); +W32KAPI INT WINAPI NtGdiOffsetRgn( HRGN hrgn, INT x, INT y ); +W32KAPI HDC WINAPI NtGdiOpenDCW( UNICODE_STRING *device, const DEVMODEW *devmode, + UNICODE_STRING *output, ULONG type, BOOL is_display, + HANDLE hspool, DRIVER_INFO_2W *driver_info, void *pdev ); +W32KAPI BOOL WINAPI NtGdiPatBlt( HDC hdc, INT left, INT top, INT width, INT height, DWORD rop ); +W32KAPI HRGN WINAPI NtGdiPathToRegion( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiPlgBlt( HDC hdc, const POINT *point, HDC hdc_src, INT x_src, INT y_src, + INT width, INT height, HBITMAP mask, INT x_mask, INT y_mask, + DWORD bk_color ); +W32KAPI BOOL WINAPI NtGdiPolyDraw(HDC hdc, const POINT *points, const BYTE *types, DWORD count ); +W32KAPI ULONG WINAPI NtGdiPolyPolyDraw( HDC hdc, const POINT *points, const ULONG *counts, + DWORD count, UINT function ); +W32KAPI BOOL WINAPI NtGdiPtInRegion( HRGN hrgn, INT x, INT y ); +W32KAPI BOOL WINAPI NtGdiPtVisible( HDC hdc, INT x, INT y ); +W32KAPI BOOL WINAPI NtGdiRectInRegion( HRGN hrgn, const RECT *rect ); +W32KAPI BOOL WINAPI NtGdiRectVisible( HDC hdc, const RECT *rect ); +W32KAPI BOOL WINAPI NtGdiRectangle( HDC hdc, INT left, INT top, INT right, INT bottom ); +W32KAPI BOOL WINAPI NtGdiRemoveFontMemResourceEx( HANDLE handle ); +W32KAPI BOOL WINAPI NtGdiRemoveFontResourceW( const WCHAR *str, ULONG size, ULONG files, + DWORD flags, DWORD tid, void *dv ); +W32KAPI BOOL WINAPI NtGdiResetDC( HDC hdc, const DEVMODEW *devmode, BOOL *banding, + DRIVER_INFO_2W *driver_info, void *dev ); +W32KAPI BOOL WINAPI NtGdiResizePalette( HPALETTE palette, UINT count ); +W32KAPI BOOL WINAPI NtGdiRestoreDC( HDC hdc, INT level ); +W32KAPI BOOL WINAPI NtGdiRoundRect( HDC hdc, INT left, INT top, INT right, + INT bottom, INT ell_width, INT ell_height ); +W32KAPI INT WINAPI NtGdiSaveDC( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiScaleViewportExtEx( HDC hdc, INT x_num, INT x_denom, + INT y_num, INT y_denom, SIZE *size ); +W32KAPI BOOL WINAPI NtGdiScaleWindowExtEx( HDC hdc, INT x_num, INT x_denom, + INT y_num, INT y_denom, SIZE *size ); +W32KAPI HGDIOBJ WINAPI NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle ); +W32KAPI HGDIOBJ WINAPI NtGdiSelectBrush( HDC hdc, HGDIOBJ handle ); +W32KAPI BOOL WINAPI NtGdiSelectClipPath( HDC hdc, INT mode ); +W32KAPI HGDIOBJ WINAPI NtGdiSelectFont( HDC hdc, HGDIOBJ handle ); +W32KAPI HGDIOBJ WINAPI NtGdiSelectPen( HDC hdc, HGDIOBJ handle ); +W32KAPI LONG WINAPI NtGdiSetBitmapBits( HBITMAP hbitmap, LONG count, const void *bits ); +W32KAPI BOOL WINAPI NtGdiSetBitmapDimension( HBITMAP hbitmap, INT x, INT y, SIZE *prev_size ); +W32KAPI BOOL WINAPI NtGdiSetBrushOrg( HDC hdc, INT x, INT y, POINT *prev_org ); +W32KAPI UINT WINAPI NtGdiSetBoundsRect( HDC hdc, const RECT *rect, UINT flags ); +W32KAPI BOOL WINAPI NtGdiSetColorAdjustment( HDC hdc, const COLORADJUSTMENT *ca ); +W32KAPI INT WINAPI NtGdiSetDIBitsToDeviceInternal( HDC hdc, INT x_dst, INT y_dst, DWORD cx, + DWORD cy, INT x_src, INT y_src, UINT startscan, + UINT lines, const void *bits, const BITMAPINFO *bmi, + UINT coloruse, UINT max_bits, UINT max_info, + BOOL xform_coords, HANDLE xform ); +W32KAPI BOOL WINAPI NtGdiSetDeviceGammaRamp( HDC hdc, void *ptr ); +W32KAPI DWORD WINAPI NtGdiSetLayout( HDC hdc, LONG wox, DWORD layout ); +W32KAPI BOOL WINAPI NtGdiSetMagicColors( HDC hdc, DWORD magic, ULONG index ); +W32KAPI INT WINAPI NtGdiSetMetaRgn( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiSetMiterLimit( HDC hdc, DWORD limit, DWORD *prev_limit ); +W32KAPI COLORREF WINAPI NtGdiSetPixel( HDC hdc, INT x, INT y, COLORREF color ); +W32KAPI BOOL WINAPI NtGdiSetPixelFormat( HDC hdc, INT format ); +W32KAPI BOOL WINAPI NtGdiSetRectRgn( HRGN hrgn, INT left, INT top, INT right, INT bottom ); +W32KAPI UINT WINAPI NtGdiSetSystemPaletteUse( HDC hdc, UINT use ); +W32KAPI BOOL WINAPI NtGdiSetTextJustification( HDC hdc, INT extra, INT breaks ); +W32KAPI BOOL WINAPI NtGdiSetVirtualResolution( HDC hdc, DWORD horz_res, DWORD vert_res, + DWORD horz_size, DWORD vert_size ); +W32KAPI INT WINAPI NtGdiStartDoc( HDC hdc, const DOCINFOW *doc, BOOL *banding, INT job ); +W32KAPI INT WINAPI NtGdiStartPage( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiStretchBlt( HDC hdc, INT x_dst, INT y_dst, INT width_dst, INT height_dst, + HDC hdc_src, INT x_src, INT y_src, INT width_src, INT height_src, + DWORD rop, COLORREF bk_color ); +W32KAPI INT WINAPI NtGdiStretchDIBitsInternal( HDC hdc, INT x_dst, INT y_dst, INT width_dst, + INT height_dst, INT x_src, INT y_src, INT width_src, + INT height_src, const void *bits, const BITMAPINFO *bmi, + UINT coloruse, DWORD rop, UINT max_info, UINT max_bits, + HANDLE xform ); +W32KAPI BOOL WINAPI NtGdiStrokeAndFillPath( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiStrokePath( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiSwapBuffers( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiTransparentBlt( HDC hdc, int x_dst, int y_dst, int width_dst, int height_dst, + HDC hdc_src, int x_src, int y_src, int width_src, int height_src, + UINT color ); +W32KAPI BOOL WINAPI NtGdiTransformPoints( HDC hdc, const POINT *points_in, POINT *points_out, + INT count, UINT mode ); +W32KAPI BOOL WINAPI NtGdiUnrealizeObject( HGDIOBJ obj ); +W32KAPI BOOL WINAPI NtGdiUpdateColors( HDC hdc ); +W32KAPI BOOL WINAPI NtGdiWidenPath( HDC hdc ); + +W32KAPI NTSTATUS WINAPI NtGdiDdDDICheckVidPnExclusiveOwnership( const D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICloseAdapter( const D3DKMT_CLOSEADAPTER *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateAllocation( D3DKMT_CREATEALLOCATION *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateAllocation2( D3DKMT_CREATEALLOCATION *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateDCFromMemory( D3DKMT_CREATEDCFROMMEMORY *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateDevice( D3DKMT_CREATEDEVICE *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateKeyedMutex( D3DKMT_CREATEKEYEDMUTEX *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateKeyedMutex2( D3DKMT_CREATEKEYEDMUTEX2 *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateSynchronizationObject( D3DKMT_CREATESYNCHRONIZATIONOBJECT *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDICreateSynchronizationObject2( D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyAllocation( const D3DKMT_DESTROYALLOCATION *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyAllocation2( const D3DKMT_DESTROYALLOCATION2 *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyDCFromMemory( const D3DKMT_DESTROYDCFROMMEMORY *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyDevice( const D3DKMT_DESTROYDEVICE *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroyKeyedMutex( const D3DKMT_DESTROYKEYEDMUTEX *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIDestroySynchronizationObject( const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIEnumAdapters( D3DKMT_ENUMADAPTERS *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIEnumAdapters2( D3DKMT_ENUMADAPTERS2 *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIEscape( const D3DKMT_ESCAPE *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromDeviceName( D3DKMT_OPENADAPTERFROMDEVICENAME *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromHdc( D3DKMT_OPENADAPTERFROMHDC *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenAdapterFromLuid( D3DKMT_OPENADAPTERFROMLUID *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutex( D3DKMT_OPENKEYEDMUTEX *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutex2( D3DKMT_OPENKEYEDMUTEX2 *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenKeyedMutexFromNtHandle( D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResource( D3DKMT_OPENRESOURCE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResource2( D3DKMT_OPENRESOURCE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenResourceFromNtHandle( D3DKMT_OPENRESOURCEFROMNTHANDLE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSynchronizationObject( D3DKMT_OPENSYNCHRONIZATIONOBJECT *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectFromNtHandle( D3DKMT_OPENSYNCOBJECTFROMNTHANDLE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectFromNtHandle2( D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIOpenSyncObjectNtHandleFromName( D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryAdapterInfo( D3DKMT_QUERYADAPTERINFO *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryResourceInfo( D3DKMT_QUERYRESOURCEINFO *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryResourceInfoFromNtHandle( D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *params ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryStatistics( D3DKMT_QUERYSTATISTICS *stats ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIQueryVideoMemoryInfo( D3DKMT_QUERYVIDEOMEMORYINFO *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDISetQueuedLimit( D3DKMT_SETQUEUEDLIMIT *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDISetVidPnSourceOwner( const D3DKMT_SETVIDPNSOURCEOWNER *desc ); +W32KAPI NTSTATUS WINAPI NtGdiDdDDIShareObjects( UINT count, const D3DKMT_HANDLE *handles, OBJECT_ATTRIBUTES *attr, UINT access, HANDLE *handle ); + +/* Wine extensions */ +W32KAPI const struct vulkan_funcs * __wine_get_vulkan_driver(UINT version); +W32KAPI const struct opengl_funcs *__wine_get_wgl_driver( HDC hdc, UINT version ); +W32KAPI BOOL WINAPI __wine_get_icm_profile( HDC hdc, BOOL allow_default, DWORD *size, WCHAR *filename ); +W32KAPI BOOL WINAPI __wine_get_file_outline_text_metric( const WCHAR *path, TEXTMETRICW *otm, + UINT *em_square, WCHAR *face_name ); + +#endif /* _NTGDI_ */