https://git.reactos.org/?p=reactos.git;a=commitdiff;h=e09679f2d13b00f136ef65...
commit e09679f2d13b00f136ef65be4b049f772dd92a4e Author: Justin Miller Justin.miller@reactos.org AuthorDate: Thu Oct 17 00:26:01 2024 -0700 Commit: Justin Miller justinmiller100@gmail.com CommitDate: Sat Oct 19 13:45:59 2024 -0700
[SDK] Import WDDM Headers from MIT varient in libdxg --- media/doc/3rd Party Files.txt | 8 + sdk/include/ddk/d3dkmthk.h | 6063 ++++++++++++++++++++++++++++++++++++++++- sdk/include/psdk/d3dkmdt.h | 2476 +++++++++++++++++ sdk/include/psdk/d3dukmdt.h | 2067 +++++++++++++- 4 files changed, 10445 insertions(+), 169 deletions(-)
diff --git a/media/doc/3rd Party Files.txt b/media/doc/3rd Party Files.txt index bd86c57550f..1139bc05a07 100644 --- a/media/doc/3rd Party Files.txt +++ b/media/doc/3rd Party Files.txt @@ -295,3 +295,11 @@ Path: modules/rosapps/lib/vfdlib Used Version: 2.1.2008.206 License: GPL-2.0 (https://spdx.org/licenses/GPL-2.0.html) URL: https://vfd.sourceforge.net/ + +Title: libdxg - WDDM Headers +Path: sdk/include/psdk/d3dukmdt.h +Path: sdk/include/psdk/d3dkmdt.h +Path: sdk/include/ddk/d3dkmthk.h +Used Version: git commit 045831e +License: MIT (https://spdx.org/licenses/MIT.html) +URL: https://github.com/microsoft/libdxg diff --git a/sdk/include/ddk/d3dkmthk.h b/sdk/include/ddk/d3dkmthk.h index 86ba3a1871b..bc382312995 100644 --- a/sdk/include/ddk/d3dkmthk.h +++ b/sdk/include/ddk/d3dkmthk.h @@ -1,55 +1,6036 @@ -/* - * 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 <d3dukmdt.h> +/******************************Module*Header**********************************\ +* +* Module Name: d3dkmthk.h +* +* Content: Windows Display Driver Model (WDDM) kernel mode thunk interfaces +* +* Copyright (c) Microsoft Corporation. +* Licensed under the MIT License. +* +*****************************************************************************/ +#ifndef _D3DKMTHK_H_ +#define _D3DKMTHK_H_ + +#include <d3dkmdt.h> + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +#pragma warning(push) +#pragma warning(disable:4201) // anonymous unions warning +#pragma warning(disable:4200) // zero-sized array in struct/union +#pragma warning(disable:4214) // nonstandard extension used: bit field types other than int + + +typedef struct _OBJECT_ATTRIBUTES OBJECT_ATTRIBUTES; +typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES; + +// +// Available only for Vista (LONGHORN) and later and for +// multiplatform tools such as debugger extensions +// +#if (NTDDI_VERSION >= NTDDI_LONGHORN) || defined(D3DKMDT_SPECIAL_MULTIPLATFORM_TOOL) + +typedef struct _D3DKMT_CREATEDEVICEFLAGS +{ + UINT LegacyMode : 1; // 0x00000001 + UINT RequestVSync : 1; // 0x00000002 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + UINT DisableGpuTimeout : 1; // 0x00000004 + UINT Reserved : 29; // 0xFFFFFFF8 +#else + UINT Reserved : 30; // 0xFFFFFFFC +#endif +} D3DKMT_CREATEDEVICEFLAGS; + +typedef struct _D3DKMT_CREATEDEVICE +{ + union + { + D3DKMT_HANDLE hAdapter; // in: identifies the adapter for user-mode creation + VOID* pAdapter; // in: identifies the adapter for kernel-mode creation + D3DKMT_PTR_HELPER(pAdapter_Align) + }; + + D3DKMT_CREATEDEVICEFLAGS Flags; + + D3DKMT_HANDLE hDevice; // out: Identifies the device + D3DKMT_PTR(VOID*, pCommandBuffer); // out: D3D10 compatibility. + UINT CommandBufferSize; // out: D3D10 compatibility. + D3DKMT_PTR(D3DDDI_ALLOCATIONLIST*, pAllocationList); // out: D3D10 compatibility. + UINT AllocationListSize; // out: D3D10 compatibility. + D3DKMT_PTR(D3DDDI_PATCHLOCATIONLIST*, pPatchLocationList); // out: D3D10 compatibility. + UINT PatchLocationListSize; // out: D3D10 compatibility. +} D3DKMT_CREATEDEVICE; + +typedef struct _D3DKMT_DESTROYDEVICE +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device +}D3DKMT_DESTROYDEVICE; + +typedef enum _D3DKMT_CLIENTHINT +{ + D3DKMT_CLIENTHINT_UNKNOWN = 0, + D3DKMT_CLIENTHINT_OPENGL = 1, + D3DKMT_CLIENTHINT_CDD = 2, // Internal + D3DKMT_CLIENTHINT_OPENCL = 3, + D3DKMT_CLIENTHINT_VULKAN = 4, + D3DKMT_CLIENTHINT_CUDA = 5, + D3DKMT_CLIENTHINT_RESERVED = 6, + D3DKMT_CLIENTHINT_DX7 = 7, + D3DKMT_CLIENTHINT_DX8 = 8, + D3DKMT_CLIENTHINT_DX9 = 9, + D3DKMT_CLIENTHINT_DX10 = 10, + D3DKMT_CLIENTHINT_DX11 = 11, + D3DKMT_CLIENTHINT_DX12 = 12, + D3DKMT_CLIENTHINT_9ON12 = 13, + D3DKMT_CLIENTHINT_11ON12 = 14, + D3DKMT_CLIENTHINT_MFT_ENCODE = 15, + D3DKMT_CLIENTHINT_GLON12 = 16, + D3DKMT_CLIENTHINT_CLON12 = 17, + D3DKMT_CLIENTHINT_DML_TENSORFLOW = 18, + D3DKMT_CLIENTHINT_ONEAPI_LEVEL0 = 19, + D3DKMT_CLIENTHINT_MAX +} D3DKMT_CLIENTHINT; + +typedef struct _D3DKMT_CREATECONTEXT +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device owning this context. + UINT NodeOrdinal; // in: Identifier for the node targetted by this context. + UINT EngineAffinity; // in: Engine affinity within the specified node. + D3DDDI_CREATECONTEXTFLAGS Flags; // in: Context creation flags. + D3DKMT_PTR(VOID*, pPrivateDriverData); // in: Private driver data + UINT PrivateDriverDataSize; // in: Size of private driver data + D3DKMT_CLIENTHINT ClientHint; // in: Hints which client is creating this + D3DKMT_HANDLE hContext; // out: Handle of the created context. + D3DKMT_PTR(VOID*, pCommandBuffer); // out: Pointer to the first command buffer. + UINT CommandBufferSize; // out: Command buffer size (bytes). + D3DKMT_PTR(D3DDDI_ALLOCATIONLIST*, pAllocationList); // out: Pointer to the first allocation list. + UINT AllocationListSize; // out: Allocation list size (elements). + D3DKMT_PTR(D3DDDI_PATCHLOCATIONLIST*, pPatchLocationList); // out: Pointer to the first patch location list. + UINT PatchLocationListSize; // out: Patch location list size (elements). + D3DGPU_VIRTUAL_ADDRESS CommandBuffer; // out: GPU virtual address of the command buffer. _ADVSCH_ +} D3DKMT_CREATECONTEXT; + +typedef struct _D3DKMT_DESTROYCONTEXT +{ + D3DKMT_HANDLE hContext; // in: Identifies the context being destroyed. +} D3DKMT_DESTROYCONTEXT; + +typedef struct _D3DKMT_CREATESYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + D3DDDI_SYNCHRONIZATIONOBJECTINFO Info; // in: Attributes of the synchronization object. + D3DKMT_HANDLE hSyncObject; // out: Handle to the synchronization object created. +} D3DKMT_CREATESYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_CREATESYNCHRONIZATIONOBJECT2 +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + D3DDDI_SYNCHRONIZATIONOBJECTINFO2 Info; // in/out: Attributes of the synchronization object. + D3DKMT_HANDLE hSyncObject; // out: Handle to the synchronization object created. +} D3DKMT_CREATESYNCHRONIZATIONOBJECT2; + +typedef struct _D3DKMT_DESTROYSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hSyncObject; // in: Identifies the synchronization objects being destroyed. +} D3DKMT_DESTROYSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_OPENSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hSharedHandle; // in: shared handle to synchronization object to be opened. + D3DKMT_HANDLE hSyncObject; // out: Handle to sync object in this process. + + D3DKMT_ALIGN64 UINT64 Reserved[8]; +} D3DKMT_OPENSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_WAITFORSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hContext; // in: Identifies the context that needs to wait. + UINT ObjectCount; // in: Specifies the number of object to wait on. + D3DKMT_HANDLE ObjectHandleArray[D3DDDI_MAX_OBJECT_WAITED_ON]; // in: Specifies the object to wait on. +} D3DKMT_WAITFORSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2 +{ + D3DKMT_HANDLE hContext; // in: Identifies the context that needs to wait. + UINT ObjectCount; // in: Specifies the number of object to wait on. + D3DKMT_HANDLE ObjectHandleArray[D3DDDI_MAX_OBJECT_WAITED_ON]; // in: Specifies the object to wait on. + union + { + struct { + D3DKMT_ALIGN64 UINT64 FenceValue; // in: fence value to be waited. + } Fence; + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; +} D3DKMT_WAITFORSYNCHRONIZATIONOBJECT2; + +typedef struct _D3DKMT_SIGNALSYNCHRONIZATIONOBJECT +{ + D3DKMT_HANDLE hContext; // in: Identifies the context that needs to signal. + UINT ObjectCount; // in: Specifies the number of object to signal. + D3DKMT_HANDLE ObjectHandleArray[D3DDDI_MAX_OBJECT_SIGNALED]; // in: Specifies the object to be signaled. + D3DDDICB_SIGNALFLAGS Flags; // in: Specifies signal behavior. +} D3DKMT_SIGNALSYNCHRONIZATIONOBJECT; + +typedef struct _D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2 +{ + D3DKMT_HANDLE hContext; // in: Identifies the context that needs to signal. + UINT ObjectCount; // in: Specifies the number of object to signal. + D3DKMT_HANDLE ObjectHandleArray[D3DDDI_MAX_OBJECT_SIGNALED]; // in: Specifies the object to be signaled. + D3DDDICB_SIGNALFLAGS Flags; // in: Specifies signal behavior. + ULONG BroadcastContextCount; // in: Specifies the number of context + // to broadcast this command buffer to. + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + // broadcast to. + union + { + struct { + D3DKMT_ALIGN64 UINT64 FenceValue; // in: fence value to be signaled; + } Fence; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + HANDLE CpuEventHandle; // in: handle of a CPU event to be signaled +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; +} D3DKMT_SIGNALSYNCHRONIZATIONOBJECT2; + +typedef struct _D3DKMT_LOCK +{ + D3DKMT_HANDLE hDevice; // in: identifies the device + D3DKMT_HANDLE hAllocation; // in: allocation to lock + // out: New handle representing the allocation after the lock. + UINT PrivateDriverData; // in: Used by UMD for AcquireAperture + UINT NumPages; + D3DKMT_PTR(CONST UINT*, pPages); + D3DKMT_PTR(VOID*, pData); // out: pointer to memory + D3DDDICB_LOCKFLAGS Flags; // in: Bit field defined by D3DDDI_LOCKFLAGS + D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress; // out: GPU's Virtual Address of locked allocation. _ADVSCH_ +} D3DKMT_LOCK; + +typedef struct _D3DKMT_UNLOCK +{ + D3DKMT_HANDLE hDevice; // in: Identifies the device + UINT NumAllocations; // in: Number of allocations in the array + D3DKMT_PTR(CONST D3DKMT_HANDLE*, phAllocations); // in: array of allocations to unlock +} D3DKMT_UNLOCK; + +typedef enum _D3DKMDT_MODE_PRUNING_REASON +{ + D3DKMDT_MPR_UNINITIALIZED = 0, // mode was pruned or is supported because of: + D3DKMDT_MPR_ALLCAPS = 1, // all of the monitor caps (only used to imply lack of support - for support, specific reason is always indicated) + D3DKMDT_MPR_DESCRIPTOR_MONITOR_SOURCE_MODE = 2, // monitor source mode in the monitor descriptor + D3DKMDT_MPR_DESCRIPTOR_MONITOR_FREQUENCY_RANGE = 3, // monitor frequency range in the monitor descriptor + D3DKMDT_MPR_DESCRIPTOR_OVERRIDE_MONITOR_SOURCE_MODE = 4, // monitor source mode in the monitor descriptor override + D3DKMDT_MPR_DESCRIPTOR_OVERRIDE_MONITOR_FREQUENCY_RANGE = 5, // monitor frequency range in the monitor descriptor override + D3DKMDT_MPR_DEFAULT_PROFILE_MONITOR_SOURCE_MODE = 6, // monitor source mode in the default monitor profile + D3DKMDT_MPR_DRIVER_RECOMMENDED_MONITOR_SOURCE_MODE = 7, // monitor source mode recommended by the driver + D3DKMDT_MPR_MONITOR_FREQUENCY_RANGE_OVERRIDE = 8, // monitor frequency range override + D3DKMDT_MPR_CLONE_PATH_PRUNED = 9, // Mode is pruned because other path(s) in clone cluster has(have) no mode supported by monitor + D3DKMDT_MPR_MAXVALID = 10 +} +D3DKMDT_MODE_PRUNING_REASON; + +// This structure takes 8 bytes. +// The unnamed UINT of size 0 forces alignment of the structure to +// make it exactly occupy 8 bytes, see MSDN docs on C++ bitfields +// for more details +typedef struct _D3DKMDT_DISPLAYMODE_FLAGS +{ +#if (DXGKDDI_INTERFACE_VERSION < DXGKDDI_INTERFACE_VERSION_WIN8) + BOOLEAN ValidatedAgainstMonitorCaps : 1; + BOOLEAN RoundedFakeMode : 1; + D3DKMDT_MODE_PRUNING_REASON ModePruningReason : 4; + UINT Reserved : 28; +#else + UINT ValidatedAgainstMonitorCaps : 1; + UINT RoundedFakeMode : 1; + UINT : 0; + D3DKMDT_MODE_PRUNING_REASON ModePruningReason : 4; + UINT Stereo : 1; + UINT AdvancedScanCapable : 1; +#if (DXGKDDI_INTERFACE_VERSION < DXGKDDI_INTERFACE_VERSION_WDDM2_0) + UINT Reserved : 26; +#else + UINT PreferredTiming : 1; + UINT PhysicalModeSupported : 1; +#if (DXGKDDI_INTERFACE_VERSION < DXGKDDI_INTERFACE_VERSION_WDDM2_9) + UINT Reserved : 24; +#else + UINT VirtualRefreshRate : 1; + UINT Reserved : 23; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#endif +#endif +} +D3DKMDT_DISPLAYMODE_FLAGS; + +typedef struct _D3DKMT_DISPLAYMODE +{ + UINT Width; + UINT Height; + D3DDDIFORMAT Format; + UINT IntegerRefreshRate; + D3DDDI_RATIONAL RefreshRate; + D3DDDI_VIDEO_SIGNAL_SCANLINE_ORDERING ScanLineOrdering; + D3DDDI_ROTATION DisplayOrientation; + UINT DisplayFixedOutput; + D3DKMDT_DISPLAYMODE_FLAGS Flags; +} D3DKMT_DISPLAYMODE; + +typedef struct _D3DKMT_GETDISPLAYMODELIST +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN source ID + D3DKMT_PTR(D3DKMT_DISPLAYMODE*, pModeList); // out: + UINT ModeCount; // in/out: +} D3DKMT_GETDISPLAYMODELIST; + +typedef struct _D3DKMT_DISPLAYMODELIST +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT ModeCount; + D3DKMT_DISPLAYMODE pModeList[0]; +} D3DKMT_DISPLAYMODELIST; + +typedef struct _D3DKMT_SETDISPLAYMODE_FLAGS +{ + BOOLEAN PreserveVidPn : 1; + UINT Reserved : 31; +} +D3DKMT_SETDISPLAYMODE_FLAGS; + +typedef struct _D3DKMT_SETDISPLAYMODE +{ + D3DKMT_HANDLE hDevice; // in: Identifies the device + D3DKMT_HANDLE hPrimaryAllocation; // in: + D3DDDI_VIDEO_SIGNAL_SCANLINE_ORDERING ScanLineOrdering; // in: + D3DDDI_ROTATION DisplayOrientation; // in: + UINT PrivateDriverFormatAttribute; // out: Private Format Attribute of the current primary surface if DxgkSetDisplayMode failed with STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT + D3DKMT_SETDISPLAYMODE_FLAGS Flags; // in: +} D3DKMT_SETDISPLAYMODE; + + +typedef struct _D3DKMT_MULTISAMPLEMETHOD +{ + UINT NumSamples; + UINT NumQualityLevels; + UINT Reserved; //workaround for NTRAID#Longhorn-1124385-2005/03/14-kanqiu +} D3DKMT_MULTISAMPLEMETHOD; + +typedef struct _D3DKMT_GETMULTISAMPLEMETHODLIST +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN source ID + UINT Width; // in: + UINT Height; // in: + D3DDDIFORMAT Format; // in: + D3DKMT_PTR(D3DKMT_MULTISAMPLEMETHOD*, pMethodList); // out: + UINT MethodCount; // in/out: +} D3DKMT_GETMULTISAMPLEMETHODLIST; + +typedef struct _D3DKMT_PRESENTFLAGS +{ + union + { + struct + { + UINT Blt : 1; // 0x00000001 + UINT ColorFill : 1; // 0x00000002 + UINT Flip : 1; // 0x00000004 + UINT FlipDoNotFlip : 1; // 0x00000008 + UINT FlipDoNotWait : 1; // 0x00000010 + UINT FlipRestart : 1; // 0x00000020 + UINT DstRectValid : 1; // 0x00000040 + UINT SrcRectValid : 1; // 0x00000080 + UINT RestrictVidPnSource : 1; // 0x00000100 + UINT SrcColorKey : 1; // 0x00000200 + UINT DstColorKey : 1; // 0x00000400 + UINT LinearToSrgb : 1; // 0x00000800 + UINT PresentCountValid : 1; // 0x00001000 + UINT Rotate : 1; // 0x00002000 + UINT PresentToBitmap : 1; // 0x00004000 + UINT RedirectedFlip : 1; // 0x00008000 + UINT RedirectedBlt : 1; // 0x00010000 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + UINT FlipStereo : 1; // 0x00020000 // This is a flip from a stereo alloc. Used in addition to Flip. + UINT FlipStereoTemporaryMono : 1; // 0x00040000 // This is a flip from a stereo alloc. The left image should used to produce both images. Used in addition to Flip. + UINT FlipStereoPreferRight : 1; // 0x00080000 // This is a flip from a stereo alloc. Use the right image when cloning to a mono monitor. Used in addition to Flip. + UINT BltStereoUseRight : 1; // 0x00100000 // This is a Blt from a stereo alloc to a mono alloc. The right image should be used. + UINT PresentHistoryTokenOnly : 1; // 0x00200000 // Submit Present History Token only. + UINT PresentRegionsValid : 1; // 0x00400000 // Ptr to present regions is valid + UINT PresentDDA : 1; // 0x00800000 // Present from a DDA swapchain + UINT ProtectedContentBlankedOut : 1; // 0x01000000 + UINT RemoteSession : 1; // 0x02000000 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + UINT CrossAdapter : 1; // 0x04000000 + UINT DurationValid : 1; // 0x08000000 + UINT PresentIndirect : 1; // 0x10000000 // Present to an indirect-display adapter + UINT PresentHMD : 1; // 0x20000000 // Present from an HMD swapchain. + UINT Reserved : 2; // 0xC0000000 +#else + UINT Reserved : 6; // 0xFC000000 +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +#else + UINT Reserved : 15; // 0xFFFE0000 +#endif + }; + UINT Value; + }; +} D3DKMT_PRESENTFLAGS; + +typedef enum _D3DKMT_PRESENT_MODEL +{ + D3DKMT_PM_UNINITIALIZED = 0, + D3DKMT_PM_REDIRECTED_GDI = 1, + D3DKMT_PM_REDIRECTED_FLIP = 2, + D3DKMT_PM_REDIRECTED_BLT = 3, + D3DKMT_PM_REDIRECTED_VISTABLT = 4, + D3DKMT_PM_SCREENCAPTUREFENCE = 5, + D3DKMT_PM_REDIRECTED_GDI_SYSMEM = 6, + D3DKMT_PM_REDIRECTED_COMPOSITION = 7, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_PM_SURFACECOMPLETE = 8, +#endif + D3DKMT_PM_FLIPMANAGER = 9, +} D3DKMT_PRESENT_MODEL; + +typedef enum _D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE +{ + D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE_FLIP_SUBMITTED = 0, + D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE_FLIP_COMPLETE = 1 +} D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE; + +typedef struct _D3DKMT_FLIPMODEL_PRESENTHISTORYTOKENFLAGS +{ + union + { + struct + { + UINT Video : 1; // 0x00000001 + UINT RestrictedContent : 1; // 0x00000002 + UINT ClipToView : 1; // 0x00000004 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + UINT StereoPreferRight : 1; // 0x00000008 + UINT TemporaryMono : 1; // 0x00000010 + UINT FlipRestart : 1; // 0x00000020 + UINT HDRMetaDataChanged : 1; // 0x00000040 + UINT AlphaMode : 2; // 0x00000180 + UINT SignalLimitOnTokenCompletion : 1; // 0x00000200 + UINT YCbCrFlags : 3; // 0x00001C00 + UINT IndependentFlip : 1; // 0x00002000 + D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE IndependentFlipStage : 2; // 0x0000C000 + UINT IndependentFlipReleaseCount : 2; // 0x00030000 + UINT IndependentFlipForceNotifyDwm : 1; // 0x00040000 + UINT UseCustomDuration : 1; // 0x00080000 + UINT IndependentFlipRequestDwmConfirm:1; // 0x00100000 + UINT IndependentFlipCandidate : 1; // 0x00200000 + UINT IndependentFlipCheckNeeded : 1; // 0x00400000 + UINT IndependentFlipTrueImmediate : 1; // 0x00800000 + UINT IndependentFlipRequestDwmExit : 1; // 0x01000000 + UINT CompSurfaceNotifiedEarly : 1; // 0x02000000 + UINT IndependentFlipDoNotFlip : 1; // 0x04000000 + UINT RequirePairedToken : 1; // 0x08000000 + UINT VariableRefreshOverrideEligible :1; // 0x10000000 + UINT Reserved : 3; // 0xE0000000 +#else + UINT Reserved : 29; // 0xFFFFFFF8 +#endif + }; + + UINT Value; + }; +} D3DKMT_FLIPMODEL_PRESENTHISTORYTOKENFLAGS; + +#define D3DKMT_MAX_PRESENT_HISTORY_RECTS 16 + +typedef struct _D3DKMT_DIRTYREGIONS +{ + UINT NumRects; + RECT Rects[D3DKMT_MAX_PRESENT_HISTORY_RECTS]; +} D3DKMT_DIRTYREGIONS; + +typedef struct _D3DKMT_COMPOSITION_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hPrivateData; +} D3DKMT_COMPOSITION_PRESENTHISTORYTOKEN; + +typedef struct _D3DKMT_FLIPMANAGER_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hPrivateData; + D3DKMT_ALIGN64 ULONGLONG PresentAtQpc; + union + { + struct + { + UINT Discard : 1; + UINT PresentAt : 1; + UINT hPrivateDataIsPointer : 1; + UINT Reserved : 29; + }; + UINT Value; + }Flags; +} D3DKMT_FLIPMANAGER_PRESENTHISTORYTOKEN; + +typedef enum _D3DKMT_AUXILIARYPRESENTINFO_TYPE +{ + D3DKMT_AUXILIARYPRESENTINFO_TYPE_FLIPMANAGER = 0 +} D3DKMT_AUXILIARYPRESENTINFO_TYPE; + +typedef struct _D3DKMT_AUXILIARYPRESENTINFO +{ + UINT size; + D3DKMT_AUXILIARYPRESENTINFO_TYPE type; +} D3DKMT_AUXILIARYPRESENTINFO; + +typedef struct _D3DKMT_FLIPMANAGER_AUXILIARYPRESENTINFO +{ + // in: Base information + D3DKMT_AUXILIARYPRESENTINFO auxiliaryPresentInfo; + + // in: Tracing ID of owner flip manager + UINT flipManagerTracingId; + + // in: Whether or not the application requested a different custom duration + // than the previous present + BOOL customDurationChanged; + + // out: The adapter LUID/VidPn source of the flip output + LUID FlipAdapterLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + + // out: Independent flip stage + D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE independentFlipStage; + + // out: The DPC frame time of the frame on which the flip was completed + D3DKMT_ALIGN64 ULONGLONG FlipCompletedQpc; + + // out: The approved frame duration + UINT HwPresentDurationQpc; + + // out: Whether or not the present was canceled in the scheduler + BOOL WasCanceled; +} D3DKMT_FLIPMANAGER_AUXILIARYPRESENTINFO; + +typedef struct _D3DKMT_GDIMODEL_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hLogicalSurface; + D3DKMT_ALIGN64 ULONG64 hPhysicalSurface; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + RECT ScrollRect; + POINT ScrollOffset; +#endif + D3DKMT_DIRTYREGIONS DirtyRegions; +} D3DKMT_GDIMODEL_PRESENTHISTORYTOKEN; + +typedef struct _D3DKMT_GDIMODEL_SYSMEM_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hlsurf; + DWORD dwDirtyFlags; + D3DKMT_ALIGN64 UINT64 uiCookie; +} D3DKMT_GDIMODEL_SYSMEM_PRESENTHISTORYTOKEN; + +typedef ULONGLONG D3DKMT_VISTABLTMODEL_PRESENTHISTORYTOKEN; + +typedef struct _D3DKMT_FENCE_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 UINT64 Key; +} D3DKMT_FENCE_PRESENTHISTORYTOKEN; + +typedef struct _D3DKMT_BLTMODEL_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hLogicalSurface; + D3DKMT_ALIGN64 ULONG64 hPhysicalSurface; + D3DKMT_ALIGN64 ULONG64 EventId; + D3DKMT_DIRTYREGIONS DirtyRegions; +} D3DKMT_BLTMODEL_PRESENTHISTORYTOKEN; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +#define D3DKMT_MAX_PRESENT_HISTORY_SCATTERBLTS 12 + +typedef struct _D3DKMT_SCATTERBLT +{ + D3DKMT_ALIGN64 ULONG64 hLogicalSurfaceDestination; + D3DKMT_ALIGN64 LONG64 hDestinationCompSurfDWM; + D3DKMT_ALIGN64 UINT64 DestinationCompositionBindingId; + RECT SourceRect; + POINT DestinationOffset; +} D3DKMT_SCATTERBLT; + +typedef struct _D3DKMT_SCATTERBLTS +{ + UINT NumBlts; + D3DKMT_SCATTERBLT Blts[D3DKMT_MAX_PRESENT_HISTORY_SCATTERBLTS]; +} D3DKMT_SCATTERBLTS; +#endif + +typedef struct _D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 UINT64 FenceValue; + D3DKMT_ALIGN64 ULONG64 hLogicalSurface; + D3DKMT_ALIGN64 D3DKMT_UINT_PTR dxgContext; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT SwapChainIndex; + D3DKMT_ALIGN64 UINT64 PresentLimitSemaphoreId; + D3DDDI_FLIPINTERVAL_TYPE FlipInterval; + D3DKMT_FLIPMODEL_PRESENTHISTORYTOKENFLAGS Flags; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ALIGN64 LONG64 hCompSurf; + LUID compSurfLuid; + D3DKMT_ALIGN64 UINT64 confirmationCookie; + D3DKMT_ALIGN64 UINT64 CompositionSyncKey; + UINT RemainingTokens; + RECT ScrollRect; + POINT ScrollOffset; + UINT PresentCount; + FLOAT RevealColor[4]; // index 0 == R, ... , 3 == A + D3DDDI_ROTATION Rotation; + union + { + D3DKMT_SCATTERBLTS ScatterBlts; // Unused + struct + { + HANDLE hSyncObject; // NT handle to FlipEx fence. + D3DDDI_HDR_METADATA_TYPE HDRMetaDataType; + union + { + D3DDDI_HDR_METADATA_HDR10 HDRMetaDataHDR10; + D3DDDI_HDR_METADATA_HDR10PLUS HDRMetaDataHDR10Plus; + }; + }; + }; + UINT InkCookie; + RECT SourceRect; + UINT DestWidth; + UINT DestHeight; + RECT TargetRect; + // DXGI_MATRIX_3X2_F: _11 _12 _21 _22 _31 _32 + FLOAT Transform[6]; + UINT CustomDuration; + D3DDDI_FLIPINTERVAL_TYPE CustomDurationFlipInterval; + UINT PlaneIndex; +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DDDI_COLOR_SPACE_TYPE ColorSpace; +#endif + D3DKMT_DIRTYREGIONS DirtyRegions; +} D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN; + +// User mode timeout is in milliseconds, kernel mode timeout is in 100 nanoseconds +#define FLIPEX_TIMEOUT_USER (2000) +#define FLIPEX_TIMEOUT_KERNEL (FLIPEX_TIMEOUT_USER*10000) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef struct _D3DKMT_SURFACECOMPLETE_PRESENTHISTORYTOKEN +{ + D3DKMT_ALIGN64 ULONG64 hLogicalSurface; +} D3DKMT_SURFACECOMPLETE_PRESENTHISTORYTOKEN; +#endif + +typedef struct _D3DKMT_PRESENTHISTORYTOKEN +{ + D3DKMT_PRESENT_MODEL Model; + // The size of the present history token in bytes including Model. + // Should be set to zero by when submitting a token. + // It will be initialized when reading present history and can be used to + // go to the next token in the present history buffer. + UINT TokenSize; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + // The binding id as specified by the Composition Surface + UINT64 CompositionBindingId; +#endif + + union + { + D3DKMT_FLIPMODEL_PRESENTHISTORYTOKEN Flip; + D3DKMT_BLTMODEL_PRESENTHISTORYTOKEN Blt; + D3DKMT_VISTABLTMODEL_PRESENTHISTORYTOKEN VistaBlt; + D3DKMT_GDIMODEL_PRESENTHISTORYTOKEN Gdi; + D3DKMT_FENCE_PRESENTHISTORYTOKEN Fence; + D3DKMT_GDIMODEL_SYSMEM_PRESENTHISTORYTOKEN GdiSysMem; + D3DKMT_COMPOSITION_PRESENTHISTORYTOKEN Composition; + D3DKMT_FLIPMANAGER_PRESENTHISTORYTOKEN FlipManager; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_SURFACECOMPLETE_PRESENTHISTORYTOKEN SurfaceComplete; +#endif + } + Token; +} D3DKMT_PRESENTHISTORYTOKEN; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_PRESENT_RGNS +{ + UINT DirtyRectCount; + D3DKMT_PTR(_Field_size_( DirtyRectCount ) const RECT*, pDirtyRects); + UINT MoveRectCount; + D3DKMT_PTR(_Field_size_( MoveRectCount ) const D3DKMT_MOVE_RECT*, pMoveRects); +}D3DKMT_PRESENT_RGNS; +#endif + +typedef struct _D3DKMT_PRESENT +{ + union + { + D3DKMT_HANDLE hDevice; // in: D3D10 compatibility. + D3DKMT_HANDLE hContext; // in: Indentifies the context + }; + D3DKMT_PTR(HWND, hWindow); // in: window to present to + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPn source ID if RestrictVidPnSource is flagged + D3DKMT_HANDLE hSource; // in: Source allocation to present from + D3DKMT_HANDLE hDestination; // in: Destination allocation whenever non-zero + UINT Color; // in: color value in ARGB 32 bit format + RECT DstRect; // in: unclipped dest rect + RECT SrcRect; // in: unclipped src rect + UINT SubRectCnt; // in: count of sub rects + D3DKMT_PTR(CONST RECT*, pSrcSubRects); // in: sub rects in source space + UINT PresentCount; // in: present counter + D3DDDI_FLIPINTERVAL_TYPE FlipInterval; // in: flip interval + D3DKMT_PRESENTFLAGS Flags; // in: + ULONG BroadcastContextCount; // in: Specifies the number of context + // to broadcast this command buffer to. + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + // broadcast to. + HANDLE PresentLimitSemaphore; + D3DKMT_PRESENTHISTORYTOKEN PresentHistoryToken; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_PRESENT_RGNS* pPresentRegions; +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + union + { + D3DKMT_HANDLE hAdapter; // in: iGpu adapter for PHT redirection. Valid only when the CrossAdapter flag is set. + D3DKMT_HANDLE hIndirectContext; // in: indirect adapter context for redirecting through the DoD present path. Only + // valid if PresentIndirect flag is set. + }; + UINT Duration; // in: Per-present duration. Valid only when the DurationValid flag is set. +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DKMT_PTR(_Field_size_(BroadcastContextCount) + D3DKMT_HANDLE*, BroadcastSrcAllocation); // in: LDA + D3DKMT_PTR(_Field_size_opt_(BroadcastContextCount) + D3DKMT_HANDLE*, BroadcastDstAllocation); // in: LDA + UINT PrivateDriverDataSize; // in: + D3DKMT_PTR(_Field_size_bytes_(PrivateDriverDataSize) + PVOID, pPrivateDriverData); // in: Private driver data to pass to DdiPresent and DdiSetVidPnSourceAddress + BOOLEAN bOptimizeForComposition; // out: DWM is involved in composition +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +} D3DKMT_PRESENT; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +typedef struct _D3DKMT_PRESENT_REDIRECTEDS_FLAGS +{ + union + { + struct + { + UINT Reserved : 32; // 0xFFFFFFFF + }; + UINT Value; + }; +}D3DKMT_PRESENT_REDIRECTED_FLAGS; + +typedef struct _D3DKMT_PRESENT_REDIRECTED +{ + D3DKMT_HANDLE hSyncObj; // in: Sync object PHT waits on + D3DKMT_HANDLE hDevice; // in: Device associated with the present + D3DKMT_ALIGN64 ULONGLONG WaitedFenceValue; // in: Fence value of hSyncObj that PHT waits on + D3DKMT_PRESENTHISTORYTOKEN PresentHistoryToken; + D3DKMT_PRESENT_REDIRECTED_FLAGS Flags; + D3DKMT_HANDLE hSource; // in: Source allocation to present from + UINT PrivateDriverDataSize; // in: + D3DKMT_PTR(_Field_size_bytes_(PrivateDriverDataSize) + PVOID, pPrivateDriverData); // in: Private driver data to pass to DdiPresent and DdiSetVidPnSourceAddress +}D3DKMT_PRESENT_REDIRECTED; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) +typedef struct _D3DKMT_CANCEL_PRESENTS_FLAGS +{ + union + { + // D3DKMT_CANCEL_PRESENTS_OPERATION_REPROGRAM_INTERRUPT flags + struct + { + UINT NewVSyncInterruptState : 1; + UINT Reserved : 31; + } ReprogramInterrupt; + + UINT Value; + }; +}D3DKMT_CANCEL_PRESENTS_FLAGS; + + +typedef enum D3DKMT_CANCEL_PRESENTS_OPERATION +{ + D3DKMT_CANCEL_PRESENTS_OPERATION_CANCEL_FROM = 0, + D3DKMT_CANCEL_PRESENTS_OPERATION_REPROGRAM_INTERRUPT = 1 +} D3DKMT_CANCEL_PRESENTS_OPERATION; + +typedef struct _D3DKMT_CANCEL_PRESENTS +{ + UINT cbSize; + D3DKMT_HANDLE hDevice; + D3DKMT_CANCEL_PRESENTS_FLAGS Flags; + D3DKMT_CANCEL_PRESENTS_OPERATION Operation; + D3DKMT_ALIGN64 UINT64 CancelFromPresentId; + LUID CompSurfaceLuid; + D3DKMT_ALIGN64 UINT64 BindId; +}D3DKMT_CANCEL_PRESENTS; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + +typedef struct _D3DKMT_SUBMITPRESENTBLTTOHWQUEUE +{ + D3DKMT_HANDLE hHwQueue; + D3DKMT_ALIGN64 UINT64 HwQueueProgressFenceId; + D3DKMT_PRESENT PrivatePresentData; +} D3DKMT_SUBMITPRESENTBLTTOHWQUEUE; + +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_5) + +typedef struct _D3DKMT_SUBMITPRESENTTOHWQUEUE +{ + D3DKMT_PTR(_Field_size_(PrivatePresentData.BroadcastContextCount + 1) + D3DKMT_HANDLE*, hHwQueues); + D3DKMT_PRESENT PrivatePresentData; +} D3DKMT_SUBMITPRESENTTOHWQUEUE; + +#endif + +#define D3DKMT_MAX_MULTIPLANE_OVERLAY_PLANES 8 +#define D3DKMT_MAX_MULTIPLANE_OVERLAY_ALLOCATIONS_PER_PLANE 256 + +typedef enum D3DKMT_MULTIPLANE_OVERLAY_FLAGS +{ + D3DKMT_MULTIPLANE_OVERLAY_FLAG_VERTICAL_FLIP = 0x1, + D3DKMT_MULTIPLANE_OVERLAY_FLAG_HORIZONTAL_FLIP = 0x2, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) + D3DKMT_MULTIPLANE_OVERLAY_FLAG_STATIC_CHECK = 0x4, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM3_0 +} D3DKMT_MULTIPLANE_OVERLAY_FLAGS; + +typedef enum D3DKMT_MULTIPLANE_OVERLAY_BLEND +{ + D3DKMT_MULTIPLANE_OVERLAY_BLEND_OPAQUE = 0x0, + D3DKMT_MULTIPLANE_OVERLAY_BLEND_ALPHABLEND = 0x1, +} D3DKMT_MULTIPLANE_OVERLAY_BLEND; + +typedef enum D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT +{ + D3DKMT_MULIIPLANE_OVERLAY_VIDEO_FRAME_FORMAT_PROGRESSIVE = 0, + D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST = 1, + D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST = 2 +} D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT; + +typedef enum D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAGS +{ + D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAG_NOMINAL_RANGE = 0x1, // 16 - 235 vs. 0 - 255 + D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAG_BT709 = 0x2, // BT.709 vs. BT.601 + D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAG_xvYCC = 0x4, // xvYCC vs. conventional YCbCr +} D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAGS; + +typedef enum D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT +{ + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_MONO = 0, + D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_HORIZONTAL = 1, + D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_VERTICAL = 2, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_SEPARATE = 3, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_MONO_OFFSET = 4, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_ROW_INTERLEAVED = 5, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_COLUMN_INTERLEAVED = 6, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT_CHECKERBOARD = 7 +} D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT; + +typedef enum _DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_MODE +{ + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_NONE = 0, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_FRAME0 = 1, + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_FRAME1 = 2, +} DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_MODE; + +typedef enum _DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY +{ + DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY_BILINEAR = 0x1, // Bilinear + DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY_HIGH = 0x2, // Maximum +} DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY; + +typedef struct D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES +{ + UINT Flags; // D3DKMT_MULTIPLANE_OVERLAY_FLAGS + RECT SrcRect; + RECT DstRect; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + RECT ClipRect; +#endif + D3DDDI_ROTATION Rotation; + D3DKMT_MULTIPLANE_OVERLAY_BLEND Blend; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + UINT DirtyRectCount; + D3DKMT_PTR(RECT*, pDirtyRects); +#else + UINT NumFilters; + D3DKMT_PTR(void*, pFilters); +#endif + D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT VideoFrameFormat; + UINT YCbCrFlags; // D3DKMT_MULTIPLANE_OVERLAY_YCbCr_FLAGS + D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT StereoFormat; + BOOL StereoLeftViewFrame0; + BOOL StereoBaseViewFrame0; + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_MODE StereoFlipMode; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY StretchQuality; +#endif +} D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM_1_3) +typedef struct D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE +{ + D3DKMT_HANDLE hResource; + LUID CompSurfaceLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES PlaneAttributes; +} D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE; + +typedef struct D3DKMT_CHECK_MULTIPLANE_OVERLAY_SUPPORT_RETURN_INFO +{ + union + { + struct + { + UINT FailingPlane : 4; // The 0 based index of the first plane that could not be supported + UINT TryAgain : 1; // The configuration is not supported due to a transition condition, which should shortly go away + UINT Reserved : 27; + }; + UINT Value; + }; +} D3DKMT_CHECK_MULTIPLANE_OVERLAY_SUPPORT_RETURN_INFO; + +typedef struct _D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT PlaneCount; // in : Number of resources to pin + D3DKMT_PTR(D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE*, pOverlayPlanes); // in : Array of resource handles to pin + BOOL Supported; + D3DKMT_CHECK_MULTIPLANE_OVERLAY_SUPPORT_RETURN_INFO ReturnInfo; +} D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM_2_0) +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES2 +{ + UINT Flags; // D3DKMT_MULTIPLANE_OVERLAY_FLAGS + RECT SrcRect; // Specifies the source rectangle, of type RECT, relative to the source resource. + RECT DstRect; // Specifies the destination rectangle, of type RECT, relative to the monitor resolution. + RECT ClipRect; // Specifies any additional clipping, of type RECT, relative to the DstRect rectangle, + // after the data has been stretched according to the values of SrcRect and DstRect. + + // The driver and hardware can use the ClipRect member to apply a common stretch factor + // as the clipping changes when an app occludes part of the DstRect destination rectangle. + D3DDDI_ROTATION Rotation; // Specifies the clockwise rotation of the overlay plane, given as a value from the D3DDDI_ROTATION enumeration. + D3DKMT_MULTIPLANE_OVERLAY_BLEND Blend; // Specifies the blend mode that applies to this overlay plane and the plane beneath it, given as a value from the DXGK_MULTIPLANE_OVERLAY_BLEND enumeration. + UINT DirtyRectCount; + D3DKMT_PTR(RECT*, pDirtyRects); + D3DKMT_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT VideoFrameFormat; // DXGK_MULTIPLANE_OVERLAY_VIDEO_FRAME_FORMAT + D3DDDI_COLOR_SPACE_TYPE ColorSpace; + D3DKMT_MULTIPLANE_OVERLAY_STEREO_FORMAT StereoFormat; // DXGK_MULTIPLANE_OVERLAY_STEREO_FORMAT + BOOL StereoLeftViewFrame0; // Reserved for system use. Must always be FALSE. + BOOL StereoBaseViewFrame0; // Reserved for system use. Must always be FALSE. + DXGKMT_MULTIPLANE_OVERLAY_STEREO_FLIP_MODE StereoFlipMode; // DXGK_MULTIPLANE_OVERLAY_STEREO_FLIP_MODE + DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY StretchQuality; // DXGK_MULTIPLANE_OVERLAY_STRETCH_QUALITY + UINT Reserved1; +} D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES2; + +typedef struct _D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE2 +{ + UINT LayerIndex; + D3DKMT_HANDLE hResource; + LUID CompSurfaceLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES2 PlaneAttributes; +} D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE2; + +typedef struct _D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT2 +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT PlaneCount; // in : Number of resources to pin + D3DKMT_PTR(D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE2*, pOverlayPlanes); // in : Array of resource handles to pin + BOOL Supported; + D3DKMT_CHECK_MULTIPLANE_OVERLAY_SUPPORT_RETURN_INFO ReturnInfo; +} D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT2; + +typedef struct _D3DKMT_MULTIPLANE_OVERLAY2 +{ + UINT LayerIndex; + BOOL Enabled; + D3DKMT_HANDLE hAllocation; + D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES2 PlaneAttributes; +} D3DKMT_MULTIPLANE_OVERLAY2; + +typedef struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + union + { + D3DKMT_HANDLE hDevice; // in: D3D10 compatibility. + D3DKMT_HANDLE hContext; // in: Indentifies the context + }; + ULONG BroadcastContextCount; // in: Specifies the number of context + // to broadcast this command buffer to. + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + // broadcast to. + + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPn source ID if RestrictVidPnSource is flagged + UINT PresentCount; // in: present counter + D3DDDI_FLIPINTERVAL_TYPE FlipInterval; // in: flip interval + D3DKMT_PRESENTFLAGS Flags; // in: + + UINT PresentPlaneCount; + D3DKMT_PTR(D3DKMT_MULTIPLANE_OVERLAY2*, pPresentPlanes); + UINT Duration; +} D3DKMT_PRESENT_MULTIPLANE_OVERLAY2; +#endif // DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 +{ + UINT Flags; // D3DKMT_MULTIPLANE_OVERLAY_FLAGS + RECT SrcRect; // Specifies the source rectangle, of type RECT, relative to the source resource. + RECT DstRect; // Specifies the destination rectangle, of type RECT, relative to the monitor resolution. + RECT ClipRect; // Specifies any additional clipping, of type RECT, relative to the DstRect rectangle, + // after the data has been stretched according to the values of SrcRect and DstRect. + + // The driver and hardware can use the ClipRect member to apply a common stretch factor + // as the clipping changes when an app occludes part of the DstRect destination rectangle. + D3DDDI_ROTATION Rotation; // Specifies the clockwise rotation of the overlay plane, given as a value from the D3DDDI_ROTATION enumeration. + D3DKMT_MULTIPLANE_OVERLAY_BLEND Blend; // Specifies the blend mode that applies to this overlay plane and the plane beneath it, given as a value from the DXGK_MULTIPLANE_OVERLAY_BLEND enumeration. + UINT DirtyRectCount; + D3DKMT_PTR(_Field_size_(DirtyRectCount) RECT*, pDirtyRects); + D3DDDI_COLOR_SPACE_TYPE ColorSpace; + DXGKMT_MULTIPLANE_OVERLAY_STRETCH_QUALITY StretchQuality; // DXGK_MULTIPLANE_OVERLAY_STRETCH_QUALITY +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + UINT SDRWhiteLevel; +#endif +} D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3; + +typedef struct _D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE3 +{ + UINT LayerIndex; + D3DKMT_HANDLE hResource; + LUID CompSurfaceLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_PTR(D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3*, pPlaneAttributes); +} D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE3; + +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_FLAGS +{ + union + { + struct + { + UINT VerticalFlip : 1; // 0x00000001 + UINT HorizontalFlip : 1; // 0x00000002 + UINT Reserved :30; // 0xFFFFFFFC + }; + UINT Value; + }; +} D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_FLAGS; + +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION +{ + D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_FLAGS Flags; + RECT SrcRect; + RECT DstRect; + D3DDDI_ROTATION Rotation; +} D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION; + +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_WITH_SOURCE +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION PostComposition; +} D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_WITH_SOURCE; + +typedef struct _D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT3 +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT PlaneCount; // in : Number of resources to pin + // Note: Array-of-pointers don't work in 32bit WSL + _Field_size_(PlaneCount) + D3DKMT_CHECK_MULTIPLANE_OVERLAY_PLANE3** ppOverlayPlanes; // in : Array of pointers to overlay planes + UINT PostCompositionCount; // in : Number of resources to pin + _Field_size_(PostCompositionCount) + D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION_WITH_SOURCE** ppPostComposition; // in : Array of pointers to overlay planes + BOOL Supported; + D3DKMT_CHECK_MULTIPLANE_OVERLAY_SUPPORT_RETURN_INFO ReturnInfo; +} D3DKMT_CHECKMULTIPLANEOVERLAYSUPPORT3; + +typedef struct _D3DKMT_PLANE_SPECIFIC_INPUT_FLAGS +{ + union + { + struct + { + UINT Enabled : 1; // 0x00000001 + UINT Reserved :31; // 0xFFFFFFFE + }; + UINT Value; + }; +} D3DKMT_PLANE_SPECIFIC_INPUT_FLAGS; + +typedef struct _D3DKMT_PLANE_SPECIFIC_OUTPUT_FLAGS +{ + union + { + struct + { + UINT FlipConvertedToImmediate : 1; // 0x00000001 + UINT Reserved :31; // 0xFFFFFFFE + }; + UINT Value; + }; +} D3DKMT_PLANE_SPECIFIC_OUTPUT_FLAGS; + +typedef struct _D3DKMT_MULTIPLANE_OVERLAY3 +{ + UINT LayerIndex; + D3DKMT_PLANE_SPECIFIC_INPUT_FLAGS InputFlags; + D3DDDI_FLIPINTERVAL_TYPE FlipInterval; + UINT MaxImmediateFlipLine; + UINT AllocationCount; + D3DKMT_PTR(_Field_size_(AllocationCount) + D3DKMT_HANDLE*, pAllocationList); + UINT DriverPrivateDataSize; + D3DKMT_PTR(_Field_size_bytes_(DriverPrivateDataSize) + VOID*, pDriverPrivateData); + D3DKMT_PTR(const D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3*, pPlaneAttributes); + D3DKMT_HANDLE hFlipToFence; + D3DKMT_HANDLE hFlipAwayFence; + D3DKMT_ALIGN64 UINT64 FlipToFenceValue; + D3DKMT_ALIGN64 UINT64 FlipAwayFenceValue; +} D3DKMT_MULTIPLANE_OVERLAY3; + +typedef struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY_FLAGS +{ + union + { + struct + { + UINT FlipStereo : 1; // 0x00000001 This is a flip from a stereo alloc. Used in addition to FlipImmediate or FlipOnNextVSync. + UINT FlipStereoTemporaryMono : 1; // 0x00000002 This is a flip from a stereo alloc. The left image should used. Used in addition to FlipImmediate or FlipOnNextVSync. + UINT FlipStereoPreferRight : 1; // 0x00000004 This is a flip from a stereo alloc. The right image should used when cloning to a mono monitor. Used in addition to FlipImmediate or FlipOnNextVSync. + UINT FlipDoNotWait : 1; // 0x00000008 + UINT FlipDoNotFlip : 1; // 0x00000010 + UINT FlipRestart : 1; // 0x00000020 + UINT DurationValid : 1; // 0x00000040 + UINT HDRMetaDataValid : 1; // 0x00000080 + UINT HMD : 1; // 0x00000100 + UINT TrueImmediate : 1; // 0x00000200 If a present interval is 0, allow tearing rather than override a previously queued flip + UINT Reserved :22; // 0xFFFFFE00 + }; + UINT Value; + }; +} D3DKMT_PRESENT_MULTIPLANE_OVERLAY_FLAGS; + +typedef struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + UINT ContextCount; + D3DKMT_PTR(_Field_size_(ContextCount) + D3DKMT_HANDLE*, pContextList); + + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPn source ID if RestrictVidPnSource is flagged + UINT PresentCount; // in: present counter + D3DKMT_PRESENT_MULTIPLANE_OVERLAY_FLAGS Flags; // in: + + UINT PresentPlaneCount; + // Note: Array-of-pointers don't work in 32bit WSL + _Field_size_(PresentPlaneCount) + D3DKMT_MULTIPLANE_OVERLAY3** ppPresentPlanes; + D3DKMT_PTR(D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION*, pPostComposition); + UINT Duration; + D3DDDI_HDR_METADATA_TYPE HDRMetaDataType; + UINT HDRMetaDataSize; + D3DKMT_PTR(_Field_size_bytes_(HDRMetaDataSize) + const VOID*, pHDRMetaData); + UINT BoostRefreshRateMultiplier; +} D3DKMT_PRESENT_MULTIPLANE_OVERLAY3; +#endif // DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +typedef struct _D3DKMT_MULTIPLANE_OVERLAY_CAPS +{ + union + { + struct + { + UINT Rotation : 1; // Full rotation + UINT RotationWithoutIndependentFlip : 1; // Rotation, but without simultaneous IndependentFlip support + UINT VerticalFlip : 1; // Can flip the data vertically + UINT HorizontalFlip : 1; // Can flip the data horizontally + UINT StretchRGB : 1; // Supports stretching RGB formats + UINT StretchYUV : 1; // Supports stretching YUV formats + UINT BilinearFilter : 1; // Blinear filtering + UINT HighFilter : 1; // Better than bilinear filtering + UINT Shared : 1; // MPO resources are shared across VidPnSources + UINT Immediate : 1; // Immediate flip support + UINT Plane0ForVirtualModeOnly : 1; // Stretching plane 0 will also stretch the HW cursor and should only be used for virtual mode support + UINT Version3DDISupport : 1; // Driver supports the 2.2 MPO DDIs + UINT Reserved : 20; + }; + UINT Value; + }; +} D3DKMT_MULTIPLANE_OVERLAY_CAPS; + +typedef struct _D3DKMT_GET_MULTIPLANE_OVERLAY_CAPS +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in + UINT MaxPlanes; // out: Total number of planes currently supported + UINT MaxRGBPlanes; // out: Number of RGB planes currently supported + UINT MaxYUVPlanes; // out: Number of YUV planes currently supported + D3DKMT_MULTIPLANE_OVERLAY_CAPS OverlayCaps; // out: Overlay capabilities + float MaxStretchFactor; // out + float MaxShrinkFactor; // out +} D3DKMT_GET_MULTIPLANE_OVERLAY_CAPS; + +typedef struct _D3DKMT_GET_POST_COMPOSITION_CAPS +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in + float MaxStretchFactor; // out + float MaxShrinkFactor; // out +} D3DKMT_GET_POST_COMPOSITION_CAPS; + +typedef struct _D3DKMT_MULTIPLANEOVERLAY_STRETCH_SUPPORT +{ + UINT VidPnSourceId; + BOOL Update; + BOOL Supported; +} D3DKMT_MULTIPLANEOVERLAY_STRETCH_SUPPORT; +#endif // DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2 + +typedef struct D3DKMT_MULTIPLANE_OVERLAY +{ + UINT LayerIndex; + BOOL Enabled; + D3DKMT_HANDLE hAllocation; + D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES PlaneAttributes; +} D3DKMT_MULTIPLANE_OVERLAY; + +typedef struct D3DKMT_PRESENT_MULTIPLANE_OVERLAY +{ + union + { + D3DKMT_HANDLE hDevice; // in: D3D10 compatibility. + D3DKMT_HANDLE hContext; // in: Indentifies the context + }; + ULONG BroadcastContextCount; // in: Specifies the number of context + // to broadcast this command buffer to. + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + // broadcast to. + + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPn source ID if RestrictVidPnSource is flagged + UINT PresentCount; // in: present counter + D3DDDI_FLIPINTERVAL_TYPE FlipInterval; // in: flip interval + D3DKMT_PRESENTFLAGS Flags; // in: + + UINT PresentPlaneCount; + D3DKMT_MULTIPLANE_OVERLAY* pPresentPlanes; + UINT Duration; +} D3DKMT_PRESENT_MULTIPLANE_OVERLAY; + +typedef struct _D3DKMT_RENDERFLAGS +{ + UINT ResizeCommandBuffer : 1; // 0x00000001 + UINT ResizeAllocationList : 1; // 0x00000002 + UINT ResizePatchLocationList : 1; // 0x00000004 + UINT NullRendering : 1; // 0x00000008 + UINT PresentRedirected : 1; // 0x00000010 + UINT RenderKm : 1; // 0x00000020 Cannot be used with DxgkRender + UINT RenderKmReadback : 1; // 0x00000040 Cannot be used with DxgkRender + UINT Reserved : 25; // 0xFFFFFF80 +} D3DKMT_RENDERFLAGS; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_OUTPUTDUPLPRESENTFLAGS +{ + union + { + struct + { + UINT ProtectedContentBlankedOut : 1; + UINT RemoteSession : 1; + UINT FullScreenPresent : 1; + UINT PresentIndirect : 1; + UINT Reserved : 28; + }; + UINT Value; + }; +}D3DKMT_OUTPUTDUPLPRESENTFLAGS; + +typedef struct _D3DKMT_OUTPUTDUPLPRESENT +{ + D3DKMT_HANDLE hContext; // in: Indentifies the context + D3DKMT_HANDLE hSource; // in: Source allocation to present from + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + ULONG BroadcastContextCount; // in: Specifies the number of context + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + D3DKMT_PRESENT_RGNS PresentRegions; // in: Dirty and move regions + D3DKMT_OUTPUTDUPLPRESENTFLAGS Flags; + D3DKMT_HANDLE hIndirectContext; +} D3DKMT_OUTPUTDUPLPRESENT; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + +typedef struct _D3DKMT_OUTPUTDUPLPRESENTTOHWQUEUE +{ + D3DKMT_HANDLE hSource; // in: Source allocation to present from + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + ULONG BroadcastHwQueueCount; + D3DKMT_PTR(_Field_size_(BroadcastHwQueueCount) + D3DKMT_HANDLE*, hHwQueues); + D3DKMT_PRESENT_RGNS PresentRegions; // in: Dirty and move regions + D3DKMT_OUTPUTDUPLPRESENTFLAGS Flags; + D3DKMT_HANDLE hIndirectHwQueue; +} D3DKMT_OUTPUTDUPLPRESENTTOHWQUEUE; + +#endif + +typedef struct _D3DKMT_RENDER +{ + union + { + D3DKMT_HANDLE hDevice; // in: D3D10 compatibility. + D3DKMT_HANDLE hContext; // in: Indentifies the context + }; + UINT CommandOffset; // in: offset in bytes from start + UINT CommandLength; // in: number of bytes + UINT AllocationCount; // in: Number of allocations in allocation list. + UINT PatchLocationCount; // in: Number of patch locations in patch allocation list. + D3DKMT_PTR(VOID*, pNewCommandBuffer); // out: Pointer to the next command buffer to use. + // in: When RenderKm flag is set, it points to a command buffer. + UINT NewCommandBufferSize; // in: Size requested for the next command buffer. + // out: Size of the next command buffer to use. + D3DKMT_PTR(D3DDDI_ALLOCATIONLIST*, pNewAllocationList); // out: Pointer to the next allocation list to use. + // in: When RenderKm flag is set, it points to an allocation list. + UINT NewAllocationListSize; // in: Size requested for the next allocation list. + // out: Size of the new allocation list. + D3DKMT_PTR(D3DDDI_PATCHLOCATIONLIST*, pNewPatchLocationList); // out: Pointer to the next patch location list. + UINT NewPatchLocationListSize; // in: Size requested for the next patch location list. + // out: Size of the new patch location list. + D3DKMT_RENDERFLAGS Flags; // in: + D3DKMT_ALIGN64 ULONGLONG PresentHistoryToken; // in: Present history token for redirected present calls + ULONG BroadcastContextCount; // in: Specifies the number of context + // to broadcast this command buffer to. + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; // in: Specifies the handle of the context to + // broadcast to. + ULONG QueuedBufferCount; // out: Number of DMA buffer queued to this context after this submission. + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS NewCommandBuffer; // out: GPU virtual address of next command buffer to use. _ADVSCH_ + D3DKMT_PTR(VOID*, pPrivateDriverData); // in: pointer to private driver data. _ADVSCH_ + UINT PrivateDriverDataSize; // in: size of private driver data. _ADVSCH_ +} D3DKMT_RENDER; + + +typedef enum _D3DKMT_STANDARDALLOCATIONTYPE +{ + D3DKMT_STANDARDALLOCATIONTYPE_EXISTINGHEAP = 1, + D3DKMT_STANDARDALLOCATIONTYPE_INTERNALBACKINGSTORE = 2, + D3DKMT_STANDARDALLOCATIONTYPE_MAX, +} D3DKMT_STANDARDALLOCATIONTYPE; + +typedef struct _D3DKMT_STANDARDALLOCATION_EXISTINGHEAP +{ + D3DKMT_ALIGN64 D3DKMT_SIZE_T Size; // in: Size in bytes of existing heap +} D3DKMT_STANDARDALLOCATION_EXISTINGHEAP; + +typedef struct _D3DKMT_CREATESTANDARDALLOCATIONFLAGS +{ + union + { + struct + { + UINT Reserved : 32; // 0xFFFFFFFF + }; + UINT Value; + }; +} D3DKMT_CREATESTANDARDALLOCATIONFLAGS; + +typedef struct _D3DKMT_CREATESTANDARDALLOCATION +{ + // + // update onecoreuap/windows/core/ntuser/inc/whwin32.tpl when adding new memeber + // to this struct + // + D3DKMT_STANDARDALLOCATIONTYPE Type; + union + { + D3DKMT_STANDARDALLOCATION_EXISTINGHEAP ExistingHeapData; + }; + D3DKMT_CREATESTANDARDALLOCATIONFLAGS Flags; +} D3DKMT_CREATESTANDARDALLOCATION; + +typedef struct _D3DKMT_CREATEALLOCATIONFLAGS +{ + UINT CreateResource : 1; // 0x00000001 + UINT CreateShared : 1; // 0x00000002 + UINT NonSecure : 1; // 0x00000004 + UINT CreateProtected : 1; // 0x00000008 Cannot be used when allocation is created from the user mode. + UINT RestrictSharedAccess : 1; // 0x00000010 + UINT ExistingSysMem : 1; // 0x00000020 Cannot be used when allocation is created from the user mode. +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + UINT NtSecuritySharing : 1; // 0x00000040 + UINT ReadOnly : 1; // 0x00000080 + UINT CreateWriteCombined : 1; // 0x00000100 Cannot be used when allocation is created from the user mode. + UINT CreateCached : 1; // 0x00000200 Cannot be used when allocation is created from the user mode. + UINT SwapChainBackBuffer : 1; // 0x00000400 Specifies whether an allocation corresponds to a swap chain back buffer. +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + UINT CrossAdapter : 1; // 0x00000800 + UINT OpenCrossAdapter : 1; // 0x00001000 Cannot be used when allocation is created from the user mode. + UINT PartialSharedCreation : 1; // 0x00002000 + UINT Zeroed : 1; // 0x00004000 // out: set when allocation fulfilled by zero pages + UINT WriteWatch : 1; // 0x00008000 // in: request Mm to track writes to pages of this allocation +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + UINT StandardAllocation : 1; // 0x00010000 // in: use pStandardAllocation instead of pPrivateDriverData + UINT ExistingSection : 1; // 0x00020000 // in: Use Section Handle instead of SysMem in D3DDI_ALLOCATIONINFO2 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + UINT AllowNotZeroed : 1; // 0x00040000 // in: indicate zeroed pages are not required +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + UINT PhysicallyContiguous : 1; // 0x00080000 // in: indicate allocation must be physically contguous + UINT NoKmdAccess : 1; // 0x00100000 // in: KMD is not notified about the allocation +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) + UINT SharedDisplayable : 1; // 0x00200000 + UINT Reserved : 10; // 0xFFC00000 +#else + UINT Reserved : 11; // 0xFFE00000 +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) +#else + UINT Reserved : 13; // 0xFFF80000 +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) +#else + UINT Reserved : 14; // 0xFFFC0000 +#endif //(DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) +#else + UINT Reserved : 16; // 0xFFFF0000 +#endif //(DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +#else + UINT Reserved : 21; // 0xFFFFF800 +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +#else + UINT Reserved : 26; // 0xFFFFFFC0 +#endif +} D3DKMT_CREATEALLOCATIONFLAGS; + +typedef struct _D3DKMT_CREATEALLOCATION +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hResource; //in/out:valid only within device + D3DKMT_HANDLE hGlobalShare; //out:Shared handle if CreateShared and not NtSecuritySharing + D3DKMT_PTR(_Field_size_bytes_(PrivateRuntimeDataSize) + CONST VOID*, pPrivateRuntimeData); + UINT PrivateRuntimeDataSize; + union + { + // + // update onecoreuap/windows/core/ntuser/inc/whwin32.tpl when adding new memeber + // to this union + // + D3DKMT_CREATESTANDARDALLOCATION* pStandardAllocation; + _Field_size_bytes_(PrivateDriverDataSize) + CONST VOID* pPrivateDriverData; + D3DKMT_PTR_HELPER( AlignUnionTo64_1) + }; + UINT PrivateDriverDataSize; + UINT NumAllocations; + union + { + _Field_size_(NumAllocations) D3DDDI_ALLOCATIONINFO* pAllocationInfo; +#if ((DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) || \ + (D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WIN7)) + _Field_size_(NumAllocations) D3DDDI_ALLOCATIONINFO2* pAllocationInfo2; // _ADVSCH_ +#endif + D3DKMT_PTR_HELPER( AlignUnionTo64_2) + }; + D3DKMT_CREATEALLOCATIONFLAGS Flags; + D3DKMT_PTR(HANDLE, hPrivateRuntimeResourceHandle); // opaque handle used for event tracing +} D3DKMT_CREATEALLOCATION; + +typedef struct _D3DKMT_OPENRESOURCE +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + D3DKMT_HANDLE hGlobalShare; // in : Shared resource handle + UINT NumAllocations; // in : Number of allocations associated with the resource + union { + _Field_size_(NumAllocations) D3DDDI_OPENALLOCATIONINFO* pOpenAllocationInfo; // in : Array of open allocation structs +#if ((DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) || \ + (D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WIN7)) + _Field_size_(NumAllocations) D3DDDI_OPENALLOCATIONINFO2* pOpenAllocationInfo2; // in : Array of open allocation structs // _ADVSCH_ +#endif + D3DKMT_PTR_HELPER(AlignUnionTo64) + }; + D3DKMT_PTR(_Field_size_bytes_(PrivateRuntimeDataSize) VOID*, pPrivateRuntimeData); // in : Caller supplied buffer where the runtime private data associated with this resource will be copied + UINT PrivateRuntimeDataSize; // in : Size in bytes of the pPrivateRuntimeData buffer + D3DKMT_PTR(_Field_size_bytes_(ResourcePrivateDriverDataSize) VOID*, pResourcePrivateDriverData); // in : Caller supplied buffer where the driver private data associated with the resource will be copied + UINT ResourcePrivateDriverDataSize; // in : Size in bytes of the pResourcePrivateDriverData buffer + D3DKMT_PTR(_Field_size_bytes_(TotalPrivateDriverDataBufferSize) VOID*, pTotalPrivateDriverDataBuffer); // in : Caller supplied buffer where the Driver private data will be stored + UINT TotalPrivateDriverDataBufferSize; // in/out : Size in bytes of pTotalPrivateDriverDataBuffer / Size in bytes of data written to pTotalPrivateDriverDataBuffer + D3DKMT_HANDLE hResource; // out : Handle for this resource in this process +}D3DKMT_OPENRESOURCE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_OPENRESOURCEFROMNTHANDLE +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + D3DKMT_PTR( HANDLE, hNtHandle); // in : Process's NT handle + UINT NumAllocations; // in : Number of allocations associated with the resource + D3DKMT_PTR(_Field_size_(NumAllocations) D3DDDI_OPENALLOCATIONINFO2*, pOpenAllocationInfo2); // in : Array of open allocation structs // _ADVSCH_ + UINT PrivateRuntimeDataSize; // in : Size in bytes of the pPrivateRuntimeData buffer + D3DKMT_PTR(_Field_size_bytes_(PrivateRuntimeDataSize) VOID*, pPrivateRuntimeData); // in : Caller supplied buffer where the runtime private data associated with this resource will be copied + UINT ResourcePrivateDriverDataSize; // in : Size in bytes of the pResourcePrivateDriverData buffer + D3DKMT_PTR(_Field_size_bytes_(ResourcePrivateDriverDataSize) VOID*, pResourcePrivateDriverData); // in : Caller supplied buffer where the driver private data associated with the resource will be copied + UINT TotalPrivateDriverDataBufferSize; // in/out : Size in bytes of pTotalPrivateDriverDataBuffer / Size in bytes of data written to pTotalPrivateDriverDataBuffer + D3DKMT_PTR(_Field_size_bytes_(TotalPrivateDriverDataBufferSize) VOID*, pTotalPrivateDriverDataBuffer); // in : Caller supplied buffer where the Driver private data will be stored + D3DKMT_HANDLE hResource; // out : Handle for this resource in this process + + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process + D3DKMT_PTR(_In_reads_bytes_opt_(PrivateRuntimeDataSize) VOID*, pKeyedMutexPrivateRuntimeData); // in: Buffer containing initial private data. + // If NULL then PrivateRuntimeDataSize must be 0. + // It will only be copied if the keyed mutex does not already have private data. + UINT KeyedMutexPrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. + D3DKMT_HANDLE hSyncObject; // out: Handle to sync object in this process. +} D3DKMT_OPENRESOURCEFROMNTHANDLE; + +typedef struct _D3DKMT_OPENSYNCOBJECTFROMNTHANDLE +{ + D3DKMT_PTR(HANDLE, hNtHandle); // in : NT handle for the sync object. + D3DKMT_HANDLE hSyncObject; // out: Handle to sync object in this process. +} D3DKMT_OPENSYNCOBJECTFROMNTHANDLE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 +{ + D3DKMT_PTR(HANDLE, hNtHandle); // in : NT handle for the sync object. + D3DKMT_HANDLE hDevice; // in : Device handle to use this sync object on. + D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS Flags; // in : specifies sync object behavior for this device. + D3DKMT_HANDLE hSyncObject; // out: Handle to sync object in this process. + + union + { + + struct + { + D3DKMT_PTR(VOID*, FenceValueCPUVirtualAddress); // out: Read-only mapping of the fence value for the CPU + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS FenceValueGPUVirtualAddress; // out: Read/write mapping of the fence value for the GPU + UINT EngineAffinity; // in: Defines physical adapters where the GPU VA should be mapped + } MonitoredFence; + + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; + +} D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2; + +typedef struct _D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME +{ + DWORD dwDesiredAccess; + D3DKMT_PTR(OBJECT_ATTRIBUTES*, pObjAttrib); + D3DKMT_PTR(HANDLE, hNtHandle); +} D3DKMT_OPENSYNCOBJECTNTHANDLEFROMNAME; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 + +typedef struct _D3DKMT_OPENNTHANDLEFROMNAME +{ + DWORD dwDesiredAccess; + D3DKMT_PTR(OBJECT_ATTRIBUTES*, pObjAttrib); + D3DKMT_PTR(HANDLE, hNtHandle); +} D3DKMT_OPENNTHANDLEFROMNAME; + +#define SHARED_ALLOCATION_WRITE 0x1 +#define SHARED_ALLOCATION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SHARED_ALLOCATION_WRITE) + +typedef struct _D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + D3DKMT_PTR(HANDLE, hNtHandle); // in : Global resource handle to open + D3DKMT_PTR(VOID*, pPrivateRuntimeData); // in : Ptr to buffer that will receive runtime private data for the resource + UINT PrivateRuntimeDataSize; // in/out : Size in bytes of buffer passed in for runtime private data / If pPrivateRuntimeData was NULL then size in bytes of buffer required for the runtime private data otherwise size in bytes of runtime private data copied into the buffer + UINT TotalPrivateDriverDataSize; // out : Size in bytes of buffer required to hold all the DriverPrivate data for all of the allocations associated withe the resource + UINT ResourcePrivateDriverDataSize; // out : Size in bytes of the driver's resource private data + UINT NumAllocations; // out : Number of allocations associated with this resource +}D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE; + +#endif + +typedef struct _D3DKMT_QUERYRESOURCEINFO +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + D3DKMT_HANDLE hGlobalShare; // in : Global resource handle to open + D3DKMT_PTR(VOID*, pPrivateRuntimeData); // in : Ptr to buffer that will receive runtime private data for the resource + UINT PrivateRuntimeDataSize; // in/out : Size in bytes of buffer passed in for runtime private data / If pPrivateRuntimeData was NULL then size in bytes of buffer required for the runtime private data otherwise size in bytes of runtime private data copied into the buffer + UINT TotalPrivateDriverDataSize; // out : Size in bytes of buffer required to hold all the DriverPrivate data for all of the allocations associated withe the resource + UINT ResourcePrivateDriverDataSize; // out : Size in bytes of the driver's resource private data + UINT NumAllocations; // out : Number of allocations associated with this resource +}D3DKMT_QUERYRESOURCEINFO; + +typedef struct _D3DKMT_DESTROYALLOCATION +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hResource; + D3DKMT_PTR(CONST D3DKMT_HANDLE*, phAllocationList); // in: pointer to an array allocation handles to destroy + UINT AllocationCount; // in: Number of allocations in phAllocationList +} D3DKMT_DESTROYALLOCATION; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_DESTROYALLOCATION2 +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hResource; + D3DKMT_PTR(CONST D3DKMT_HANDLE*, phAllocationList); // in: pointer to an array allocation handles to destroy + UINT AllocationCount; // in: Number of allocations in phAllocationList + D3DDDICB_DESTROYALLOCATION2FLAGS Flags; // in: Bit field defined by D3DDDICB_DESTROYALLOCATION2FLAGS +} D3DKMT_DESTROYALLOCATION2; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 + +typedef struct _D3DKMT_SETALLOCATIONPRIORITY +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hResource; // in: Specify the resource to set priority to. + D3DKMT_PTR(CONST D3DKMT_HANDLE*, phAllocationList); // in: pointer to an array allocation handles to destroy + UINT AllocationCount; // in: Number of allocations in phAllocationList + D3DKMT_PTR(CONST UINT*, pPriorities); // in: New priority for each of the allocation in the array. +} D3DKMT_SETALLOCATIONPRIORITY; + +typedef enum _D3DKMT_ALLOCATIONRESIDENCYSTATUS +{ + D3DKMT_ALLOCATIONRESIDENCYSTATUS_RESIDENTINGPUMEMORY=1, + D3DKMT_ALLOCATIONRESIDENCYSTATUS_RESIDENTINSHAREDMEMORY=2, + D3DKMT_ALLOCATIONRESIDENCYSTATUS_NOTRESIDENT=3, +} D3DKMT_ALLOCATIONRESIDENCYSTATUS; + +typedef struct _D3DKMT_QUERYALLOCATIONRESIDENCY +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hResource; // in: pointer to resource owning the list of allocation. + D3DKMT_PTR(CONST D3DKMT_HANDLE*, phAllocationList); // in: pointer to an array allocation to get residency status. + UINT AllocationCount; // in: Number of allocations in phAllocationList + D3DKMT_PTR(D3DKMT_ALLOCATIONRESIDENCYSTATUS*, pResidencyStatus); // out: Residency status of each allocation in the array. +} D3DKMT_QUERYALLOCATIONRESIDENCY; + +typedef struct _D3DKMT_GETRUNTIMEDATA +{ + D3DKMT_HANDLE hAdapter; + D3DKMT_HANDLE hGlobalShare; // in: shared handle + D3DKMT_PTR(VOID*, pRuntimeData); // out: in: for a version? + UINT RuntimeDataSize; // in: +} D3DKMT_GETRUNTIMEDATA; + +typedef enum _KMTUMDVERSION +{ + KMTUMDVERSION_DX9 = 0, + KMTUMDVERSION_DX10, + KMTUMDVERSION_DX11, + KMTUMDVERSION_DX12, + NUM_KMTUMDVERSIONS +} KMTUMDVERSION; + +typedef struct _D3DKMT_UMDFILENAMEINFO +{ + KMTUMDVERSION Version; // In: UMD version + WCHAR UmdFileName[MAX_PATH]; // Out: UMD file name +} D3DKMT_UMDFILENAMEINFO; + +#define D3DKMT_COMPONENTIZED_INDICATOR L'#' +#define D3DKMT_SUBKEY_DX9 L"DX9" +#define D3DKMT_SUBKEY_OPENGL L"OpenGL" + +typedef struct _D3DKMT_OPENGLINFO +{ + WCHAR UmdOpenGlIcdFileName[MAX_PATH]; + ULONG Version; + ULONG Flags; +} D3DKMT_OPENGLINFO; + +typedef struct _D3DKMT_SEGMENTSIZEINFO +{ + D3DKMT_ALIGN64 ULONGLONG DedicatedVideoMemorySize; + D3DKMT_ALIGN64 ULONGLONG DedicatedSystemMemorySize; + D3DKMT_ALIGN64 ULONGLONG SharedSystemMemorySize; +} D3DKMT_SEGMENTSIZEINFO; + +typedef struct _D3DKMT_SEGMENTGROUPSIZEINFO +{ + UINT32 PhysicalAdapterIndex; + D3DKMT_SEGMENTSIZEINFO LegacyInfo; + D3DKMT_ALIGN64 ULONGLONG LocalMemory; + D3DKMT_ALIGN64 ULONGLONG NonLocalMemory; + D3DKMT_ALIGN64 ULONGLONG NonBudgetMemory; +} D3DKMT_SEGMENTGROUPSIZEINFO; + +typedef struct _D3DKMT_WORKINGSETFLAGS +{ + UINT UseDefault : 1; // 0x00000001 + UINT Reserved : 31; // 0xFFFFFFFE +} D3DKMT_WORKINGSETFLAGS; + +typedef struct _D3DKMT_WORKINGSETINFO +{ + D3DKMT_WORKINGSETFLAGS Flags; + ULONG MinimumWorkingSetPercentile; + ULONG MaximumWorkingSetPercentile; +} D3DKMT_WORKINGSETINFO; + +typedef struct _D3DKMT_FLIPINFOFLAGS +{ + UINT FlipInterval : 1; // 0x00000001 // Set when kmd driver support FlipInterval natively + UINT Reserved : 31; // 0xFFFFFFFE +} D3DKMT_FLIPINFOFLAGS; + +typedef struct _D3DKMT_FLIPQUEUEINFO +{ + UINT MaxHardwareFlipQueueLength; // Max flip can be queued for hardware flip queue. + UINT MaxSoftwareFlipQueueLength; // Max flip can be queued for software flip queue for non-legacy device. + D3DKMT_FLIPINFOFLAGS FlipFlags; +} D3DKMT_FLIPQUEUEINFO; + +typedef struct _D3DKMT_ADAPTERADDRESS +{ + UINT BusNumber; // Bus number on which the physical device is located. + UINT DeviceNumber; // Index of the physical device on the bus. + UINT FunctionNumber; // Function number of the adapter on the physical device. +} D3DKMT_ADAPTERADDRESS; + +typedef struct _D3DKMT_ADAPTERREGISTRYINFO +{ + WCHAR AdapterString[MAX_PATH]; + WCHAR BiosString[MAX_PATH]; + WCHAR DacType[MAX_PATH]; + WCHAR ChipType[MAX_PATH]; +} D3DKMT_ADAPTERREGISTRYINFO; + +typedef struct _D3DKMT_CURRENTDISPLAYMODE +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_DISPLAYMODE DisplayMode; +} D3DKMT_CURRENTDISPLAYMODE; + +typedef struct _D3DKMT_VIRTUALADDRESSFLAGS // _ADVSCH_ +{ + UINT VirtualAddressSupported : 1; + UINT Reserved : 31; +} D3DKMT_VIRTUALADDRESSFLAGS; + +typedef struct _D3DKMT_VIRTUALADDRESSINFO // _ADVSCH_ +{ + D3DKMT_VIRTUALADDRESSFLAGS VirtualAddressFlags; +} D3DKMT_VIRTUALADDRESSINFO; + +typedef enum _QAI_DRIVERVERSION +{ + KMT_DRIVERVERSION_WDDM_1_0 = 1000, + KMT_DRIVERVERSION_WDDM_1_1_PRERELEASE = 1102, + KMT_DRIVERVERSION_WDDM_1_1 = 1105, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + KMT_DRIVERVERSION_WDDM_1_2 = 1200, +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + KMT_DRIVERVERSION_WDDM_1_3 = 1300, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + KMT_DRIVERVERSION_WDDM_2_0 = 2000, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + KMT_DRIVERVERSION_WDDM_2_1 = 2100, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + KMT_DRIVERVERSION_WDDM_2_2 = 2200, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + KMT_DRIVERVERSION_WDDM_2_3 = 2300, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + KMT_DRIVERVERSION_WDDM_2_4 = 2400, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_4 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_5) + KMT_DRIVERVERSION_WDDM_2_5 = 2500, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_5 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + KMT_DRIVERVERSION_WDDM_2_6 = 2600, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + KMT_DRIVERVERSION_WDDM_2_7 = 2700, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_7 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_8) + KMT_DRIVERVERSION_WDDM_2_8 = 2800, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_8 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + KMT_DRIVERVERSION_WDDM_2_9 = 2900, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) + KMT_DRIVERVERSION_WDDM_3_0 = 3000 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM3_0 +} D3DKMT_DRIVERVERSION; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_ADAPTERTYPE +{ + union + { + struct + { + UINT RenderSupported : 1; + UINT DisplaySupported : 1; + UINT SoftwareDevice : 1; + UINT PostDevice : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + UINT HybridDiscrete : 1; + UINT HybridIntegrated : 1; + UINT IndirectDisplayDevice : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + UINT Paravirtualized : 1; + UINT ACGSupported : 1; + UINT SupportSetTimingsFromVidPn : 1; + UINT Detachable : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + UINT ComputeOnly : 1; + UINT Prototype : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + UINT RuntimePowerManagement : 1; + UINT Reserved : 18; +#else + UINT Reserved : 19; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) +#else + UINT Reserved : 21; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) +#else + UINT Reserved : 25; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +#else + UINT Reserved : 28; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + }; + UINT Value; + }; +} D3DKMT_ADAPTERTYPE; + +typedef struct _D3DKMT_OUTPUTDUPLCONTEXTSCOUNT +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT OutputDuplicationCount; +} D3DKMT_OUTPUTDUPLCONTEXTSCOUNT; + +typedef struct _D3DKMT_UMD_DRIVER_VERSION +{ + D3DKMT_ALIGN64 LARGE_INTEGER DriverVersion; +} D3DKMT_UMD_DRIVER_VERSION; + +typedef struct _D3DKMT_KMD_DRIVER_VERSION +{ + D3DKMT_ALIGN64 LARGE_INTEGER DriverVersion; +} D3DKMT_KMD_DRIVER_VERSION; + +typedef struct _D3DKMT_DIRECTFLIP_SUPPORT +{ + BOOL Supported; +} D3DKMT_DIRECTFLIP_SUPPORT; + +typedef struct _D3DKMT_MULTIPLANEOVERLAY_SUPPORT +{ + BOOL Supported; +} D3DKMT_MULTIPLANEOVERLAY_SUPPORT; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3_PATH_INDEPENDENT_ROTATION) +typedef struct _D3DKMT_MULTIPLANEOVERLAY_HUD_SUPPORT +{ + UINT VidPnSourceId; // Not yet used. + BOOL Update; + BOOL KernelSupported; + BOOL HudSupported; +} D3DKMT_MULTIPLANEOVERLAY_HUD_SUPPORT; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3_PATH_INDEPENDENT_ROTATION + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +typedef struct _D3DKMT_DLIST_DRIVER_NAME +{ + WCHAR DListFileName[MAX_PATH]; // Out: DList driver file name +} D3DKMT_DLIST_DRIVER_NAME; + +typedef struct _D3DKMT_CPDRIVERNAME +{ + WCHAR ContentProtectionFileName[MAX_PATH]; +} D3DKMT_CPDRIVERNAME; + +typedef struct _D3DKMT_MIRACASTCOMPANIONDRIVERNAME +{ + WCHAR MiracastCompanionDriverName[MAX_PATH]; +} D3DKMT_MIRACASTCOMPANIONDRIVERNAME; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_XBOX +{ + BOOL IsXBOX; +} D3DKMT_XBOX; + +typedef struct _D3DKMT_INDEPENDENTFLIP_SUPPORT +{ + BOOL Supported; +} D3DKMT_INDEPENDENTFLIP_SUPPORT; + +typedef struct _D3DKMT_MULTIPLANEOVERLAY_DECODE_SUPPORT +{ + BOOL Supported; +} D3DKMT_MULTIPLANEOVERLAY_DECODE_SUPPORT; + +typedef struct _D3DKMT_ISBADDRIVERFORHWPROTECTIONDISABLED +{ + BOOL Disabled; +} D3DKMT_ISBADDRIVERFORHWPROTECTIONDISABLED; + +typedef struct _D3DKMT_MULTIPLANEOVERLAY_SECONDARY_SUPPORT +{ + BOOL Supported; +} D3DKMT_MULTIPLANEOVERLAY_SECONDARY_SUPPORT; + +typedef struct _D3DKMT_INDEPENDENTFLIP_SECONDARY_SUPPORT +{ + BOOL Supported; +} D3DKMT_INDEPENDENTFLIP_SECONDARY_SUPPORT; + +typedef struct _D3DKMT_PANELFITTER_SUPPORT +{ + BOOL Supported; +} D3DKMT_PANELFITTER_SUPPORT; + +typedef struct _D3DKMT_PHYSICAL_ADAPTER_COUNT +{ + UINT Count; +} D3DKMT_PHYSICAL_ADAPTER_COUNT; + +typedef struct _D3DKMT_DEVICE_IDS +{ + UINT VendorID; + UINT DeviceID; + UINT SubVendorID; + UINT SubSystemID; + UINT RevisionID; + UINT BusType; +} D3DKMT_DEVICE_IDS; + +typedef struct _D3DKMT_QUERY_DEVICE_IDS +{ + UINT PhysicalAdapterIndex; // in: + D3DKMT_DEVICE_IDS DeviceIds; // out: +} D3DKMT_QUERY_DEVICE_IDS; + +typedef enum _D3DKMT_PNP_KEY_TYPE +{ + D3DKMT_PNP_KEY_HARDWARE = 1, + D3DKMT_PNP_KEY_SOFTWARE = 2 +} D3DKMT_PNP_KEY_TYPE; + +typedef struct _D3DKMT_QUERY_PHYSICAL_ADAPTER_PNP_KEY +{ + UINT PhysicalAdapterIndex; + D3DKMT_PNP_KEY_TYPE PnPKeyType; + D3DKMT_PTR(_Field_size_opt_(*pCchDest) WCHAR*, pDest); + D3DKMT_PTR(UINT*, pCchDest); +} D3DKMT_QUERY_PHYSICAL_ADAPTER_PNP_KEY; + +typedef enum _D3DKMT_MIRACAST_DRIVER_TYPE +{ + D3DKMT_MIRACAST_DRIVER_NOT_SUPPORTED = 0, + D3DKMT_MIRACAST_DRIVER_IHV = 1, + D3DKMT_MIRACAST_DRIVER_MS = 2, +} D3DKMT_MIRACAST_DRIVER_TYPE; + +typedef struct _D3DKMT_QUERY_MIRACAST_DRIVER_TYPE +{ + D3DKMT_MIRACAST_DRIVER_TYPE MiracastDriverType; +} D3DKMT_QUERY_MIRACAST_DRIVER_TYPE; + +typedef struct _D3DKMT_GPUMMU_CAPS +{ + union + { + struct + { + UINT ReadOnlyMemorySupported : 1; + UINT NoExecuteMemorySupported : 1; + UINT CacheCoherentMemorySupported : 1; + UINT Reserved : 29; + }; + UINT Value; + } Flags; + UINT VirtualAddressBitCount; +} D3DKMT_GPUMMU_CAPS; + +typedef struct _D3DKMT_QUERY_GPUMMU_CAPS +{ + UINT PhysicalAdapterIndex; // in: + D3DKMT_GPUMMU_CAPS Caps; // out: +} D3DKMT_QUERY_GPUMMU_CAPS; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef struct _D3DKMT_MPO3DDI_SUPPORT +{ + BOOL Supported; +} D3DKMT_MPO3DDI_SUPPORT; + +typedef struct _D3DKMT_HWDRM_SUPPORT +{ + BOOLEAN Supported; +} D3DKMT_HWDRM_SUPPORT; + +typedef struct _D3DKMT_MPOKERNELCAPS_SUPPORT +{ + BOOL Supported; +} D3DKMT_MPOKERNELCAPS_SUPPORT; + +typedef struct _D3DKMT_GET_DEVICE_VIDPN_OWNERSHIP_INFO +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + BOOLEAN bFailedDwmAcquireVidPn; // out : True if Dwm Acquire VidPn failed due to another Dwm device having ownership +} D3DKMT_GET_DEVICE_VIDPN_OWNERSHIP_INFO; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + +typedef struct _D3DKMT_BLOCKLIST_INFO +{ + UINT Size; + WCHAR BlockList[1]; +} D3DKMT_BLOCKLIST_INFO; + +typedef struct _D3DKMT_QUERY_ADAPTER_UNIQUE_GUID +{ + WCHAR AdapterUniqueGUID[40]; +} D3DKMT_QUERY_ADAPTER_UNIQUE_GUID; + +typedef struct _D3DKMT_NODE_PERFDATA +{ + UINT32 NodeOrdinal; // in: Node ordinal of the requested engine. + UINT32 PhysicalAdapterIndex; // in: The physical adapter index, in an LDA chain + D3DKMT_ALIGN64 ULONGLONG Frequency; // out: Clock frequency of the engine in hertz + D3DKMT_ALIGN64 ULONGLONG MaxFrequency; // out: Max engine clock frequency + D3DKMT_ALIGN64 ULONGLONG MaxFrequencyOC;// out: Max engine over clock frequency + ULONG Voltage; // out: Voltage of the engine in milli volts mV + ULONG VoltageMax; // out: Max voltage levels in milli volts. + ULONG VoltageMaxOC; // out: Max voltage level while overclocked in milli volts. +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_5) + D3DKMT_ALIGN64 ULONGLONG MaxTransitionLatency; // out: Max transition latency to change the frequency in 100 nanoseconds +#else + D3DKMT_ALIGN64 ULONGLONG Reserved; +#endif +} D3DKMT_NODE_PERFDATA; + +typedef struct _D3DKMT_ADAPTER_PERFDATA +{ + UINT32 PhysicalAdapterIndex; // in: The physical adapter index, in an LDA chain + D3DKMT_ALIGN64 ULONGLONG MemoryFrequency; // out: Clock frequency of the memory in hertz + D3DKMT_ALIGN64 ULONGLONG MaxMemoryFrequency; // out: Max memory clock frequency + D3DKMT_ALIGN64 ULONGLONG MaxMemoryFrequencyOC; // out: Clock frequency of the memory while overclocked in hertz. + D3DKMT_ALIGN64 ULONGLONG MemoryBandwidth; // out: Amount of memory transferred in bytes + D3DKMT_ALIGN64 ULONGLONG PCIEBandwidth; // out: Amount of memory transferred over PCI-E in bytes + ULONG FanRPM; // out: Fan rpm + ULONG Power; // out: Power draw of the adapter in tenths of a percentage + ULONG Temperature; // out: Temperature in deci-Celsius 1 = 0.1C + UCHAR PowerStateOverride; // out: Overrides dxgkrnls power view of linked adapters. +} D3DKMT_ADAPTER_PERFDATA; + +typedef struct _D3DKMT_ADAPTER_PERFDATACAPS +{ + UINT32 PhysicalAdapterIndex; // in: The physical adapter index, in an LDA chain + D3DKMT_ALIGN64 ULONGLONG MaxMemoryBandwidth; // out: Max memory bandwidth in bytes for 1 second + D3DKMT_ALIGN64 ULONGLONG MaxPCIEBandwidth; // out: Max pcie bandwidth in bytes for 1 second + ULONG MaxFanRPM; // out: Max fan rpm + ULONG TemperatureMax; // out: Max temperature before damage levels + ULONG TemperatureWarning; // out: The temperature level where throttling begins. +} D3DKMT_ADAPTER_PERFDATACAPS; + +#define DXGK_MAX_GPUVERSION_NAME_LENGTH 32 +typedef struct _D3DKMT_GPUVERSION +{ + UINT32 PhysicalAdapterIndex; // in: The physical adapter index, in an LDA chain + WCHAR BiosVersion[DXGK_MAX_GPUVERSION_NAME_LENGTH]; //out: The gpu bios version + WCHAR GpuArchitecture[DXGK_MAX_GPUVERSION_NAME_LENGTH]; //out: The gpu architectures name. +} D3DKMT_GPUVERSION; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_4 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + +typedef struct _D3DKMT_DRIVER_DESCRIPTION +{ + WCHAR DriverDescription[4096]; //out: The driver description +} D3DKMT_DRIVER_DESCRIPTION; + +typedef struct _D3DKMT_QUERY_SCANOUT_CAPS +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT Caps; +} D3DKMT_QUERY_SCANOUT_CAPS; + +typedef enum _KMT_DISPLAY_UMD_VERSION +{ + KMT_DISPLAY_UMDVERSION_1 = 0, + NUM_KMT_DISPLAY_UMDVERSIONS +} KMT_DISPLAY_UMD_VERSION; + +typedef struct _D3DKMT_DISPLAY_UMD_FILENAMEINFO +{ + KMT_DISPLAY_UMD_VERSION Version; // In: UMD version + WCHAR UmdFileName[MAX_PATH]; // Out: UMD file name +} D3DKMT_DISPLAY_UMD_FILENAMEINFO; + +typedef struct _D3DKMT_PARAVIRTUALIZATION +{ + // This adapter property originates from the VM/ Container, and is currently replicated on adapters. + // It precludes extended device functions (i.e. Escapes) for paravirtualized devices which not known at all, + // and therefore assumed not to be secure enough for demanding server scenarios. + BOOLEAN SecureContainer; +} D3DKMT_PARAVIRTUALIZATION; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_8) + +typedef struct _D3DKMT_HYBRID_DLIST_DLL_SUPPORT +{ + BOOL Supported; +} D3DKMT_HYBRID_DLIST_DLL_SUPPORT; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_8 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + + +typedef enum _D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER +{ + D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER_NONE = 0, + D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER_COPY = 1, + D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER_TEXTURE = 2, + D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER_SCANOUT = 3, +} D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER; + +typedef struct _D3DKMT_CROSSADAPTERRESOURCE_SUPPORT +{ + D3DKMT_CROSSADAPTERRESOURCE_SUPPORT_TIER SupportTier; +} D3DKMT_CROSSADAPTERRESOURCE_SUPPORT; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 + +typedef enum _KMTQUERYADAPTERINFOTYPE +{ + KMTQAITYPE_UMDRIVERPRIVATE = 0, + KMTQAITYPE_UMDRIVERNAME = 1, + KMTQAITYPE_UMOPENGLINFO = 2, + KMTQAITYPE_GETSEGMENTSIZE = 3, + KMTQAITYPE_ADAPTERGUID = 4, + KMTQAITYPE_FLIPQUEUEINFO = 5, + KMTQAITYPE_ADAPTERADDRESS = 6, + KMTQAITYPE_SETWORKINGSETINFO = 7, + KMTQAITYPE_ADAPTERREGISTRYINFO = 8, + KMTQAITYPE_CURRENTDISPLAYMODE = 9, + KMTQAITYPE_MODELIST = 10, + KMTQAITYPE_CHECKDRIVERUPDATESTATUS = 11, + KMTQAITYPE_VIRTUALADDRESSINFO = 12, // _ADVSCH_ + KMTQAITYPE_DRIVERVERSION = 13, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + KMTQAITYPE_ADAPTERTYPE = 15, + KMTQAITYPE_OUTPUTDUPLCONTEXTSCOUNT = 16, + KMTQAITYPE_WDDM_1_2_CAPS = 17, + KMTQAITYPE_UMD_DRIVER_VERSION = 18, + KMTQAITYPE_DIRECTFLIP_SUPPORT = 19, +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + KMTQAITYPE_MULTIPLANEOVERLAY_SUPPORT = 20, + KMTQAITYPE_DLIST_DRIVER_NAME = 21, + KMTQAITYPE_WDDM_1_3_CAPS = 22, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3_PATH_INDEPENDENT_ROTATION) + KMTQAITYPE_MULTIPLANEOVERLAY_HUD_SUPPORT = 23, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3_PATH_INDEPENDENT_ROTATION +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + KMTQAITYPE_WDDM_2_0_CAPS = 24, + KMTQAITYPE_NODEMETADATA = 25, + KMTQAITYPE_CPDRIVERNAME = 26, + KMTQAITYPE_XBOX = 27, + KMTQAITYPE_INDEPENDENTFLIP_SUPPORT = 28, + KMTQAITYPE_MIRACASTCOMPANIONDRIVERNAME = 29, + KMTQAITYPE_PHYSICALADAPTERCOUNT = 30, + KMTQAITYPE_PHYSICALADAPTERDEVICEIDS = 31, + KMTQAITYPE_DRIVERCAPS_EXT = 32, + KMTQAITYPE_QUERY_MIRACAST_DRIVER_TYPE = 33, + KMTQAITYPE_QUERY_GPUMMU_CAPS = 34, + KMTQAITYPE_QUERY_MULTIPLANEOVERLAY_DECODE_SUPPORT = 35, + KMTQAITYPE_QUERY_HW_PROTECTION_TEARDOWN_COUNT = 36, + KMTQAITYPE_QUERY_ISBADDRIVERFORHWPROTECTIONDISABLED = 37, + KMTQAITYPE_MULTIPLANEOVERLAY_SECONDARY_SUPPORT = 38, + KMTQAITYPE_INDEPENDENTFLIP_SECONDARY_SUPPORT = 39, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + KMTQAITYPE_PANELFITTER_SUPPORT = 40, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + KMTQAITYPE_PHYSICALADAPTERPNPKEY = 41, + KMTQAITYPE_GETSEGMENTGROUPSIZE = 42, + KMTQAITYPE_MPO3DDI_SUPPORT = 43, + KMTQAITYPE_HWDRM_SUPPORT = 44, + KMTQAITYPE_MPOKERNELCAPS_SUPPORT = 45, + KMTQAITYPE_MULTIPLANEOVERLAY_STRETCH_SUPPORT = 46, + KMTQAITYPE_GET_DEVICE_VIDPN_OWNERSHIP_INFO = 47, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + KMTQAITYPE_QUERYREGISTRY = 48, + KMTQAITYPE_KMD_DRIVER_VERSION = 49, + KMTQAITYPE_BLOCKLIST_KERNEL = 50, + KMTQAITYPE_BLOCKLIST_RUNTIME = 51, + KMTQAITYPE_ADAPTERGUID_RENDER = 52, + KMTQAITYPE_ADAPTERADDRESS_RENDER = 53, + KMTQAITYPE_ADAPTERREGISTRYINFO_RENDER = 54, + KMTQAITYPE_CHECKDRIVERUPDATESTATUS_RENDER = 55, + KMTQAITYPE_DRIVERVERSION_RENDER = 56, + KMTQAITYPE_ADAPTERTYPE_RENDER = 57, + KMTQAITYPE_WDDM_1_2_CAPS_RENDER = 58, + KMTQAITYPE_WDDM_1_3_CAPS_RENDER = 59, + KMTQAITYPE_QUERY_ADAPTER_UNIQUE_GUID = 60, + KMTQAITYPE_NODEPERFDATA = 61, + KMTQAITYPE_ADAPTERPERFDATA = 62, + KMTQAITYPE_ADAPTERPERFDATA_CAPS = 63, + KMTQUITYPE_GPUVERSION = 64, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_4 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + KMTQAITYPE_DRIVER_DESCRIPTION = 65, + KMTQAITYPE_DRIVER_DESCRIPTION_RENDER = 66, + KMTQAITYPE_SCANOUT_CAPS = 67, + KMTQAITYPE_DISPLAY_UMDRIVERNAME = 71, // Added in 19H2 + KMTQAITYPE_PARAVIRTUALIZATION_RENDER = 68, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + KMTQAITYPE_SERVICENAME = 69, + KMTQAITYPE_WDDM_2_7_CAPS = 70, + KMTQAITYPE_TRACKEDWORKLOAD_SUPPORT = 72, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_7 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_8) + KMTQAITYPE_HYBRID_DLIST_DLL_SUPPORT = 73, + KMTQAITYPE_DISPLAY_CAPS = 74, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_8 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + KMTQAITYPE_WDDM_2_9_CAPS = 75, + KMTQAITYPE_CROSSADAPTERRESOURCE_SUPPORT = 76, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) + KMTQAITYPE_WDDM_3_0_CAPS = 77, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM3_0 +// If a new enum will be used by DXGI or D3D11 software driver code, update the test content in the area. +// Search for KMTQAITYPE_PARAVIRTUALIZATION_RENDER in directx\dxg\dxgi\unittests for references. +} KMTQUERYADAPTERINFOTYPE; + +typedef struct _D3DKMT_QUERYADAPTERINFO +{ + D3DKMT_HANDLE hAdapter; + KMTQUERYADAPTERINFOTYPE Type; + D3DKMT_PTR(VOID*, pPrivateDriverData); + UINT PrivateDriverDataSize; +} D3DKMT_QUERYADAPTERINFO; + +typedef struct _D3DKMT_OPENADAPTERFROMHDC +{ + D3DKMT_PTR(HDC, hDc); // in: DC that maps to a single display + D3DKMT_HANDLE hAdapter; // out: adapter handle + LUID AdapterLuid; // out: adapter LUID + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // out: VidPN source ID for that particular display +} D3DKMT_OPENADAPTERFROMHDC; + +typedef struct _D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME +{ + WCHAR DeviceName[32]; // in: Name of GDI device from which to open an adapter instance + D3DKMT_HANDLE hAdapter; // out: adapter handle + LUID AdapterLuid; // out: adapter LUID + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // out: VidPN source ID for that particular display +} D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME; + +typedef struct _D3DKMT_OPENADAPTERFROMDEVICENAME +{ + D3DKMT_PTR(PCWSTR, pDeviceName); // in: NULL terminated string containing the device name to open + D3DKMT_HANDLE hAdapter; // out: adapter handle + LUID AdapterLuid; // out: adapter LUID +} D3DKMT_OPENADAPTERFROMDEVICENAME; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +#define MAX_ENUM_ADAPTERS 16 + +typedef struct _D3DKMT_ADAPTERINFO +{ + D3DKMT_HANDLE hAdapter; + LUID AdapterLuid; + ULONG NumOfSources; + BOOL bPrecisePresentRegionsPreferred; +} D3DKMT_ADAPTERINFO; + +typedef struct _D3DKMT_ENUMADAPTERS +{ + _In_range_(0, MAX_ENUM_ADAPTERS) ULONG NumAdapters; + D3DKMT_ADAPTERINFO Adapters[MAX_ENUM_ADAPTERS]; +} D3DKMT_ENUMADAPTERS; + +typedef struct _D3DKMT_ENUMADAPTERS2 +{ + ULONG NumAdapters; // in/out: On input, the count of the pAdapters array buffer. On output, the number of adapters enumerated. + D3DKMT_PTR(D3DKMT_ADAPTERINFO*, pAdapters); // out: Array of enumerated adapters containing NumAdapters elements +} D3DKMT_ENUMADAPTERS2; + +typedef struct _D3DKMT_OPENADAPTERFROMLUID +{ + LUID AdapterLuid; + D3DKMT_HANDLE hAdapter; +} D3DKMT_OPENADAPTERFROMLUID; + +typedef struct _D3DKMT_QUERYREMOTEVIDPNSOURCEFROMGDIDISPLAYNAME +{ + WCHAR DeviceName[32]; // in: Name of GDI device from which to open an adapter instance + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // out: VidPN source ID for that particular display +} D3DKMT_QUERYREMOTEVIDPNSOURCEFROMGDIDISPLAYNAME; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) +typedef union _D3DKMT_ENUMADAPTERS_FILTER +{ + // Setting none of these flags will still enumerate adapters, + // but there are fewer adapters than EnumAdapters2 enumerates. + // ComputeOnly adapters are left out of the default enumeration, to avoid breaking applications. + // DisplayOnly adapters are also left out of the default enumeration. + struct + { + ULONGLONG IncludeComputeOnly : 1; + ULONGLONG IncludeDisplayOnly : 1; + ULONGLONG Reserved : 62; + }; + D3DKMT_ALIGN64 ULONGLONG Value; +} D3DKMT_ENUMADAPTERS_FILTER; + +typedef struct _D3DKMT_ENUMADAPTERS3 +{ + D3DKMT_ENUMADAPTERS_FILTER Filter; // in: Defines the filter + ULONG NumAdapters; // in/out: On input, the count of the pAdapters array buffer. On output, the number of adapters enumerated. + D3DKMT_PTR(D3DKMT_ADAPTERINFO*, pAdapters); // out: Array of enumerated adapters containing NumAdapters elements +} D3DKMT_ENUMADAPTERS3; +#endif + +typedef struct _D3DKMT_CLOSEADAPTER +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle +} D3DKMT_CLOSEADAPTER; + +typedef struct _D3DKMT_GETSHAREDPRIMARYHANDLE +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN source ID + D3DKMT_HANDLE hSharedPrimary; // out: global shared primary handle (if one exists currently) +} D3DKMT_GETSHAREDPRIMARYHANDLE; + +typedef struct _D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION +{ + LUID AdapterLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + RECTL LockRect; // in: If zero rect then we are locking the whole primary else the lock sub-rect +} D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION; + +typedef struct _D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION +{ + LUID AdapterLuid; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; +} D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_PINDIRECTFLIPRESOURCES +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT ResourceCount; // in : Number of resources to pin + D3DKMT_PTR(_Field_size_(ResourceCount) D3DKMT_HANDLE*, pResourceList); // in : Array of resource handles to pin +} D3DKMT_PINDIRECTFLIPRESOURCES; + +typedef struct _D3DKMT_UNPINDIRECTFLIPRESOURCES +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT ResourceCount; // in : Number of resources to unpin + D3DKMT_PTR(_Field_size_(ResourceCount) D3DKMT_HANDLE*, pResourceList); // in : Array of resource handles to unpin +} D3DKMT_UNPINDIRECTFLIPRESOURCES; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) +typedef union _D3DKMT_PINRESOURCEFLAGS +{ + struct + { + UINT DirectFlipResources : 1; // Used by DWM to indicate the resources are DirectFlip resources + // and should be pinned in-place. + UINT Reserved : 31; + }; + UINT Value; +} D3DKMT_PINRESOURCEFLAGS; + +typedef struct _D3DKMT_PINRESOURCES +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT ResourceCount; // in : Number of resources to pin + D3DKMT_PTR(_Field_size_(ResourceCount) D3DKMT_HANDLE*, pResourceList); // in : Array of resource handles to pin + D3DKMT_PINRESOURCEFLAGS Flags; // in : Flags + D3DKMT_HANDLE hPagingQueue; // in opt : Handle to a paging queue used to synchronize the operation + D3DKMT_ALIGN64 UINT64 PagingFence; // out : Fence value returned if hPagingQueue is not NULL +} D3DKMT_PINRESOURCES; + +typedef struct _D3DKMT_UNPINRESOURCES +{ + D3DKMT_HANDLE hDevice; // in : Indentifies the device + UINT ResourceCount; // in : Number of resources to unpin + D3DKMT_PTR(_Field_size_(ResourceCount) D3DKMT_HANDLE*, pResourceList); // in : Array of resource handles to unpin + UINT Reserved; +} D3DKMT_UNPINRESOURCES; +#endif + +typedef enum _D3DKMT_ESCAPETYPE +{ + D3DKMT_ESCAPE_DRIVERPRIVATE = 0, + D3DKMT_ESCAPE_VIDMM = 1, + D3DKMT_ESCAPE_TDRDBGCTRL = 2, + D3DKMT_ESCAPE_VIDSCH = 3, + D3DKMT_ESCAPE_DEVICE = 4, + D3DKMT_ESCAPE_DMM = 5, + D3DKMT_ESCAPE_DEBUG_SNAPSHOT = 6, + // unused (7 was previously used to set driver update in-progress status, D3DKMT_ESCAPE_SETDRIVERUPDATESTATUS) + D3DKMT_ESCAPE_DRT_TEST = 8, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ESCAPE_DIAGNOSTICS = 9, + D3DKMT_ESCAPE_OUTPUTDUPL_SNAPSHOT = 10, + D3DKMT_ESCAPE_OUTPUTDUPL_DIAGNOSTICS = 11, + D3DKMT_ESCAPE_BDD_PNP = 12, + D3DKMT_ESCAPE_BDD_FALLBACK = 13, + D3DKMT_ESCAPE_ACTIVATE_SPECIFIC_DIAG = 14, + D3DKMT_ESCAPE_MODES_PRUNED_OUT = 15, + D3DKMT_ESCAPE_WHQL_INFO = 16, + D3DKMT_ESCAPE_BRIGHTNESS = 17, + D3DKMT_ESCAPE_EDID_CACHE = 18, + // unused (19 was previously D3DKMT_ESCAPE_GENERIC_ADAPTER_DIAG_INFO) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + D3DKMT_ESCAPE_MIRACAST_DISPLAY_REQUEST = 20, + D3DKMT_ESCAPE_HISTORY_BUFFER_STATUS = 21, + // 22 can be reused for future needs as it was never exposed for external purposes + D3DKMT_ESCAPE_MIRACAST_ADAPTER_DIAG_INFO = 23, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DKMT_ESCAPE_FORCE_BDDFALLBACK_HEADLESS = 24, + D3DKMT_ESCAPE_REQUEST_MACHINE_CRASH = 25, + // unused (26 was previously D3DKMT_ESCAPE_HMD_GET_EDID_BASE_BLOCK) + D3DKMT_ESCAPE_SOFTGPU_ENABLE_DISABLE_HMD = 27, + D3DKMT_ESCAPE_PROCESS_VERIFIER_OPTION = 28, + D3DKMT_ESCAPE_ADAPTER_VERIFIER_OPTION = 29, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_ESCAPE_IDD_REQUEST = 30, + D3DKMT_ESCAPE_DOD_SET_DIRTYRECT_MODE = 31, + D3DKMT_ESCAPE_LOG_CODEPOINT_PACKET = 32, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + D3DKMT_ESCAPE_LOG_USERMODE_DAIG_PACKET = 33, + D3DKMT_ESCAPE_GET_EXTERNAL_DIAGNOSTICS = 34, + // unused (35 previously was D3DKMT_ESCAPE_GET_PREFERRED_MODE) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + D3DKMT_ESCAPE_GET_DISPLAY_CONFIGURATIONS = 36, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_ESCAPE_QUERY_IOMMU_STATUS = 37, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + D3DKMT_ESCAPE_CCD_DATABASE = 38, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0) + D3DKMT_ESCAPE_QUERY_DMA_REMAPPING_STATUS = 39, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM3_0 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_4 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_3 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 + + D3DKMT_ESCAPE_WIN32K_START = 1024, + D3DKMT_ESCAPE_WIN32K_HIP_DEVICE_INFO = 1024, + D3DKMT_ESCAPE_WIN32K_QUERY_CD_ROTATION_BLOCK = 1025, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + D3DKMT_ESCAPE_WIN32K_DPI_INFO = 1026, // Use hContext for the desired hdev + D3DKMT_ESCAPE_WIN32K_PRESENTER_VIEW_INFO = 1027, + D3DKMT_ESCAPE_WIN32K_SYSTEM_DPI = 1028, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DKMT_ESCAPE_WIN32K_BDD_FALLBACK = 1029, + D3DKMT_ESCAPE_WIN32K_DDA_TEST_CTL = 1030, + D3DKMT_ESCAPE_WIN32K_USER_DETECTED_BLACK_SCREEN = 1031, + // unused (1032 was previously D3DKMT_ESCAPE_WIN32K_HMD_ENUM) + // unused (1033 was previously D3DKMT_ESCAPE_WIN32K_HMD_CONTROL) + // unused (1034 was previously D3DKMT_ESCAPE_WIN32K_LPMDISPLAY_CONTROL) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_5) + D3DKMT_ESCAPE_WIN32K_DISPBROKER_TEST = 1035, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + D3DKMT_ESCAPE_WIN32K_COLOR_PROFILE_INFO = 1036, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + D3DKMT_ESCAPE_WIN32K_SET_DIMMED_STATE = 1037, + D3DKMT_ESCAPE_WIN32K_SPECIALIZED_DISPLAY_TEST = 1038, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_7 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_5 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 +} D3DKMT_ESCAPETYPE; + +typedef struct _D3DKMT_DOD_SET_DIRTYRECT_MODE +{ + BOOL bForceFullScreenDirty; // in: indicates if this adapter should always give full screen dirty for every Dod present +}D3DKMT_DOD_SET_DIRTYRECT_MODE; + +typedef enum _D3DKMT_TDRDBGCTRLTYPE +{ + D3DKMT_TDRDBGCTRLTYPE_FORCETDR = 0, //Simulate a TDR + D3DKMT_TDRDBGCTRLTYPE_DISABLEBREAK = 1, //Disable DebugBreak on timeout + D3DKMT_TDRDBGCTRLTYPE_ENABLEBREAK = 2, //Enable DebugBreak on timeout + D3DKMT_TDRDBGCTRLTYPE_UNCONDITIONAL = 3, //Disables all safety conditions (e.g. check for consecutive recoveries) + D3DKMT_TDRDBGCTRLTYPE_VSYNCTDR = 4, //Simulate a Vsync TDR + D3DKMT_TDRDBGCTRLTYPE_GPUTDR = 5, //Simulate a GPU TDR +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_TDRDBGCTRLTYPE_FORCEDODTDR = 6, //Simulate a Display Only Present TDR + D3DKMT_TDRDBGCTRLTYPE_FORCEDODVSYNCTDR = 7, //Simulate a Display Only Vsync TDR + D3DKMT_TDRDBGCTRLTYPE_ENGINETDR = 8, //Simulate an engine TDR +#endif +} D3DKMT_TDRDBGCTRLTYPE; + +typedef enum _D3DKMT_VIDMMESCAPETYPE +{ + D3DKMT_VIDMMESCAPETYPE_SETFAULT = 0, + D3DKMT_VIDMMESCAPETYPE_RUN_COHERENCY_TEST = 1, + D3DKMT_VIDMMESCAPETYPE_RUN_UNMAP_TO_DUMMY_PAGE_TEST = 2, + D3DKMT_VIDMMESCAPETYPE_APERTURE_CORRUPTION_CHECK = 3, + D3DKMT_VIDMMESCAPETYPE_SUSPEND_CPU_ACCESS_TEST = 4, + D3DKMT_VIDMMESCAPETYPE_EVICT = 5, + D3DKMT_VIDMMESCAPETYPE_EVICT_BY_NT_HANDLE = 6, + D3DKMT_VIDMMESCAPETYPE_GET_VAD_INFO = 7, + D3DKMT_VIDMMESCAPETYPE_SET_BUDGET = 8, + D3DKMT_VIDMMESCAPETYPE_SUSPEND_PROCESS = 9, + D3DKMT_VIDMMESCAPETYPE_RESUME_PROCESS = 10, + D3DKMT_VIDMMESCAPETYPE_GET_BUDGET = 11, + D3DKMT_VIDMMESCAPETYPE_SET_TRIM_INTERVALS = 12, + D3DKMT_VIDMMESCAPETYPE_EVICT_BY_CRITERIA = 13, + D3DKMT_VIDMMESCAPETYPE_WAKE = 14, + D3DKMT_VIDMMESCAPETYPE_DEFRAG = 15, + D3DKMT_VIDMMESCAPETYPE_DELAYEXECUTION = 16, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + D3DKMT_VIDMMESCAPETYPE_VALIDATE_INTEGRITY = 17, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + D3DKMT_VIDMMESCAPETYPE_SET_EVICTION_CONFIG = 18, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_7 +} D3DKMT_VIDMMESCAPETYPE; + +typedef enum _D3DKMT_VIDSCHESCAPETYPE +{ + D3DKMT_VIDSCHESCAPETYPE_PREEMPTIONCONTROL = 0, //Enable/Disable preemption + D3DKMT_VIDSCHESCAPETYPE_SUSPENDSCHEDULER = 1, //Suspend/Resume scheduler (obsolate) + D3DKMT_VIDSCHESCAPETYPE_TDRCONTROL = 2, //Tdr control + D3DKMT_VIDSCHESCAPETYPE_SUSPENDRESUME = 3, //Suspend/Resume scheduler +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_VIDSCHESCAPETYPE_ENABLECONTEXTDELAY = 4, //Enable/Disable context delay +#endif + D3DKMT_VIDSCHESCAPETYPE_CONFIGURE_TDR_LIMIT = 5, // Configure TdrLimitCount and TdrLimitTime + D3DKMT_VIDSCHESCAPETYPE_VGPU_RESET = 6, // Trigger VGPU reset + D3DKMT_VIDSCHESCAPETYPE_PFN_CONTROL = 7, // Periodic frame notification control + D3DKMT_VIDSCHESCAPETYPE_VIRTUAL_REFRESH_RATE = 8, +} D3DKMT_VIDSCHESCAPETYPE; + +typedef enum _D3DKMT_DMMESCAPETYPE +{ + D3DKMT_DMMESCAPETYPE_UNINITIALIZED = 0, + D3DKMT_DMMESCAPETYPE_GET_SUMMARY_INFO = 1, + D3DKMT_DMMESCAPETYPE_GET_VIDEO_PRESENT_SOURCES_INFO = 2, + D3DKMT_DMMESCAPETYPE_GET_VIDEO_PRESENT_TARGETS_INFO = 3, + D3DKMT_DMMESCAPETYPE_GET_ACTIVEVIDPN_INFO = 4, + D3DKMT_DMMESCAPETYPE_GET_MONITORS_INFO = 5, + D3DKMT_DMMESCAPETYPE_RECENTLY_COMMITTED_VIDPNS_INFO = 6, + D3DKMT_DMMESCAPETYPE_RECENT_MODECHANGE_REQUESTS_INFO = 7, + D3DKMT_DMMESCAPETYPE_RECENTLY_RECOMMENDED_VIDPNS_INFO = 8, + D3DKMT_DMMESCAPETYPE_RECENT_MONITOR_PRESENCE_EVENTS_INFO = 9, + D3DKMT_DMMESCAPETYPE_ACTIVEVIDPN_SOURCEMODESET_INFO = 10, + D3DKMT_DMMESCAPETYPE_ACTIVEVIDPN_COFUNCPATHMODALITY_INFO = 11, + D3DKMT_DMMESCAPETYPE_GET_LASTCLIENTCOMMITTEDVIDPN_INFO = 12, + D3DKMT_DMMESCAPETYPE_GET_VERSION_INFO = 13, + D3DKMT_DMMESCAPETYPE_VIDPN_MGR_DIAGNOSTICS = 14 +} D3DKMT_DMMESCAPETYPE; + +typedef struct _D3DKMT_HISTORY_BUFFER_STATUS +{ + BOOLEAN Enabled; + UINT Reserved; +} D3DKMT_HISTORY_BUFFER_STATUS; + +typedef enum _D3DKMT_VAD_ESCAPE_COMMAND +{ + D3DKMT_VAD_ESCAPE_GETNUMVADS, + D3DKMT_VAD_ESCAPE_GETVAD, + D3DKMT_VAD_ESCAPE_GETVADRANGE, + D3DKMT_VAD_ESCAPE_GET_PTE, + D3DKMT_VAD_ESCAPE_GET_GPUMMU_CAPS, + D3DKMT_VAD_ESCAPE_GET_SEGMENT_CAPS, +} D3DKMT_VAD_ESCAPE_COMMAND; + +typedef struct _D3DKMT_VAD_DESC +{ + UINT VadIndex; // in: 0xFFFFFFFF to use the VAD address + D3DKMT_ALIGN64 UINT64 VadAddress; // in + UINT NumMappedRanges; // out + UINT VadType; // out: 0 - reserved, 1 - Mapped + D3DKMT_ALIGN64 UINT64 StartAddress; // out + D3DKMT_ALIGN64 UINT64 EndAddress; // out +} D3DKMT_VAD_DESC; + +typedef struct _D3DKMT_VA_RANGE_DESC +{ + D3DKMT_ALIGN64 UINT64 VadAddress; // in + UINT VaRangeIndex; // in + UINT PhysicalAdapterIndex; // in + D3DKMT_ALIGN64 UINT64 StartAddress; // out + D3DKMT_ALIGN64 UINT64 EndAddress; // out + D3DKMT_ALIGN64 UINT64 DriverProtection; // out + UINT OwnerType; // out: VIDMM_VAD_OWNER_TYPE + D3DKMT_ALIGN64 UINT64 pOwner; // out + D3DKMT_ALIGN64 UINT64 OwnerOffset; // out + UINT Protection; // out: D3DDDIGPUVIRTUALADDRESS_PROTECTION_TYPE +} D3DKMT_VA_RANGE_DESC; + +typedef struct _D3DKMT_EVICTION_CRITERIA +{ + D3DKMT_ALIGN64 UINT64 MinimumSize; + D3DKMT_ALIGN64 UINT64 MaximumSize; + struct + { + union + { + struct + { + UINT Primary : 1; // 0x00000001 + UINT Reserved : 31; // 0xFFFFFFFE + } Flags; + UINT Value; + }; + }; +} D3DKMT_EVICTION_CRITERIA; + +typedef enum _D3DKMT_DEFRAG_ESCAPE_OPERATION +{ + D3DKMT_DEFRAG_ESCAPE_GET_FRAGMENTATION_STATS = 0, + D3DKMT_DEFRAG_ESCAPE_DEFRAG_UPWARD = 1, + D3DKMT_DEFRAG_ESCAPE_DEFRAG_DOWNWARD = 2, + D3DKMT_DEFRAG_ESCAPE_DEFRAG_PASS = 3, + D3DKMT_DEFRAG_ESCAPE_VERIFY_TRANSFER = 4, +} D3DKMT_DEFRAG_ESCAPE_OPERATION; + +typedef struct _D3DKMT_PAGE_TABLE_LEVEL_DESC +{ + UINT IndexBitCount; + D3DKMT_ALIGN64 UINT64 IndexMask; + D3DKMT_ALIGN64 UINT64 IndexShift; + D3DKMT_ALIGN64 UINT64 LowerLevelsMask; + D3DKMT_ALIGN64 UINT64 EntryCoverageInPages; +} D3DKMT_PAGE_TABLE_LEVEL_DESC; + +typedef struct _DXGK_ESCAPE_GPUMMUCAPS +{ + BOOLEAN ReadOnlyMemorySupported; + BOOLEAN NoExecuteMemorySupported; + BOOLEAN ZeroInPteSupported; + BOOLEAN CacheCoherentMemorySupported; + BOOLEAN LargePageSupported; + BOOLEAN DualPteSupported; + BOOLEAN AllowNonAlignedLargePageAddress; + UINT VirtualAddressBitCount; + UINT PageTableLevelCount; + D3DKMT_PAGE_TABLE_LEVEL_DESC PageTableLevelDesk[DXGK_MAX_PAGE_TABLE_LEVEL_COUNT]; +} DXGK_ESCAPE_GPUMMUCAPS; + +typedef struct _D3DKMT_GET_GPUMMU_CAPS +{ + UINT PhysicalAdapterIndex; // In + DXGK_ESCAPE_GPUMMUCAPS GpuMmuCaps; // Out +} D3DKMT_GET_GPUMMU_CAPS; + +#define D3DKMT_GET_PTE_MAX 64 + +typedef struct _D3DKMT_GET_PTE +{ + UINT PhysicalAdapterIndex; // In + UINT PageTableLevel; // In + UINT PageTableIndex[DXGK_MAX_PAGE_TABLE_LEVEL_COUNT]; // In + BOOLEAN b64KBPte; // In - Valid only when dual PTEs are supported. Out - PT is 64KB. + UINT NumPtes; // In - Number of PTEs to fill. Out - number of filled PTEs + DXGK_PTE Pte[D3DKMT_GET_PTE_MAX]; // Out + UINT NumValidEntries; // Out +} D3DKMT_GET_PTE; + +#define D3DKMT_MAX_SEGMENT_COUNT 32 + +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_SEGMENT_CAPS +{ + D3DKMT_ALIGN64 UINT64 Size; + UINT PageSize; + ULONG SegmentId; + BOOLEAN bAperture; + BOOLEAN bReservedSysMem; + D3DKMT_MEMORY_SEGMENT_GROUP BudgetGroup; +} D3DKMT_SEGMENT_CAPS; + +typedef struct _D3DKMT_GET_SEGMENT_CAPS +{ + UINT PhysicalAdapterIndex; // In + UINT NumSegments; // Out + D3DKMT_SEGMENT_CAPS SegmentCaps[D3DKMT_MAX_SEGMENT_COUNT]; // Out +} D3DKMT_GET_SEGMENT_CAPS; + +typedef enum _D3DKMT_ESCAPE_PFN_CONTROL_COMMAND +{ + D3DKMT_ESCAPE_PFN_CONTROL_DEFAULT, + D3DKMT_ESCAPE_PFN_CONTROL_FORCE_CPU, + D3DKMT_ESCAPE_PFN_CONTROL_FORCE_GPU +} D3DKMT_ESCAPE_PFN_CONTROL_COMMAND; + +// params for D3DKMT_VIDSCHESCAPETYPE_VIRTUAL_REFRESH_RATE +typedef enum _D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE +{ + D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE_SET_BASE_DESKTOP_DURATION = 0, + D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE_SET_VSYNC_MULTIPLIER = 1, + D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE_SET_PROCESS_BOOST_ELIGIBLE = 2, +} D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE; + +typedef struct _D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE +{ + D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE_TYPE Type; + UINT VidPnSourceId; + BOOLEAN ProcessBoostEligible; + UINT VSyncMultiplier; + UINT BaseDesktopDuration; + UCHAR Reserved[16]; +} D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE; + +typedef struct _D3DKMT_VIDMM_ESCAPE +{ + D3DKMT_VIDMMESCAPETYPE Type; + union + { + struct + { + union + { + struct + { + ULONG ProbeAndLock : 1; + ULONG SplitPoint : 1; + ULONG NoDemotion : 1; + ULONG SwizzlingAperture : 1; + ULONG PagingPathLockSubRange : 1; + ULONG PagingPathLockMinRange : 1; + ULONG ComplexLock : 1; + ULONG FailVARotation : 1; + ULONG NoWriteCombined : 1; + ULONG NoPrePatching : 1; + ULONG AlwaysRepatch : 1; + ULONG ExpectPreparationFailure : 1; + ULONG FailUserModeVAMapping : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + ULONG NeverDiscardOfferedAllocation : 1; + ULONG AlwaysDiscardOfferedAllocation : 1; + ULONG Reserved : 17; +#else + ULONG Reserved : 19; +#endif + }; + ULONG Value; + }; + } SetFault; + struct + { + D3DKMT_HANDLE ResourceHandle; + D3DKMT_HANDLE AllocationHandle; + D3DKMT_PTR(HANDLE, hProcess); // 0 to evict memory for the current process, otherwise it is a process handle from OpenProcess(PROCESS_ALL_ACCESS, FALSE, ProcessId). + } Evict; + struct + { + D3DKMT_ALIGN64 UINT64 NtHandle; // Used by D3DKMT_VIDMMESCAPETYPE_EVICT_BY_NT_HANDLE + } EvictByNtHandle; + struct + { + union + { + struct + { + UINT NumVads; + } GetNumVads; + D3DKMT_VAD_DESC GetVad; + D3DKMT_VA_RANGE_DESC GetVadRange; + D3DKMT_GET_GPUMMU_CAPS GetGpuMmuCaps; + D3DKMT_GET_PTE GetPte; + D3DKMT_GET_SEGMENT_CAPS GetSegmentCaps; + }; + D3DKMT_VAD_ESCAPE_COMMAND Command; // in + NTSTATUS Status; // out + } GetVads; + struct + { + D3DKMT_ALIGN64 ULONGLONG LocalMemoryBudget; + D3DKMT_ALIGN64 ULONGLONG SystemMemoryBudget; + } SetBudget; + struct + { + D3DKMT_PTR(HANDLE, hProcess); + BOOL bAllowWakeOnSubmission; + } SuspendProcess; + struct + { + D3DKMT_PTR(HANDLE, hProcess); + } ResumeProcess; + struct + { + D3DKMT_ALIGN64 UINT64 NumBytesToTrim; + } GetBudget; + struct + { + ULONG MinTrimInterval; // In 100ns units + ULONG MaxTrimInterval; // In 100ns units + ULONG IdleTrimInterval; // In 100ns units + } SetTrimIntervals; + D3DKMT_EVICTION_CRITERIA EvictByCriteria; + struct + { + BOOL bFlush; + } Wake; + struct + { + D3DKMT_DEFRAG_ESCAPE_OPERATION Operation; + + UINT SegmentId; + + D3DKMT_ALIGN64 ULONGLONG TotalCommitted; + D3DKMT_ALIGN64 ULONGLONG TotalFree; + D3DKMT_ALIGN64 ULONGLONG LargestGapBefore; + D3DKMT_ALIGN64 ULONGLONG LargestGapAfter; + } Defrag; + struct + { + D3DKMT_HANDLE hPagingQueue; + UINT PhysicalAdapterIndex; + ULONG Milliseconds; + D3DKMT_ALIGN64 ULONGLONG PagingFenceValue; + } DelayExecution; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + struct + { + UINT SegmentId; + } VerifyIntegrity; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + struct + { + D3DKMT_ALIGN64 LONGLONG TimerValue; + } DelayedEvictionConfig; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_7 + }; +} D3DKMT_VIDMM_ESCAPE; + +typedef struct _D3DKMT_VIDSCH_ESCAPE +{ + D3DKMT_VIDSCHESCAPETYPE Type; + union + { + BOOL PreemptionControl; // enable/disable preemption +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + BOOL EnableContextDelay; // enable/disable context delay + struct + { + ULONG TdrControl; // control tdr + union + { + ULONG NodeOrdinal; // valid if TdrControl is set to D3DKMT_TDRDBGCTRLTYPE_ENGINETDR + }; + } TdrControl2; +#endif + BOOL SuspendScheduler; // suspend/resume scheduler (obsolate) + ULONG TdrControl; // control tdr + ULONG SuspendTime; // time period to suspend. + struct + { + UINT Count; + UINT Time; // In seconds + } TdrLimit; + + D3DKMT_ESCAPE_PFN_CONTROL_COMMAND PfnControl; // periodic frame notification control + }; + D3DKMT_ESCAPE_VIRTUAL_REFRESH_RATE VirtualRefreshRateControl; +} D3DKMT_VIDSCH_ESCAPE; + +typedef struct _D3DKMT_TDRDBGCTRL_ESCAPE +{ + D3DKMT_TDRDBGCTRLTYPE TdrControl; // control tdr +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + union + { + ULONG NodeOrdinal; // valid if TdrControl is set to D3DKMT_TDRDBGCTRLTYPE_ENGINETDR + }; +#endif +} D3DKMT_TDRDBGCTRL_ESCAPE; + +// Upper boundary on the DMM escape data size (in bytes). +enum +{ + D3DKMT_MAX_DMM_ESCAPE_DATASIZE = 100*1024 +}; + +// NOTE: If (ProvidedBufferSize >= MinRequiredBufferSize), then MinRequiredBufferSize = size of the actual complete data set in the Data[] array. +typedef struct _D3DKMT_DMM_ESCAPE +{ + _In_ D3DKMT_DMMESCAPETYPE Type; + _In_ D3DKMT_ALIGN64 D3DKMT_SIZE_T ProvidedBufferSize; // actual size of Data[] array, in bytes. + _Out_ D3DKMT_ALIGN64 D3DKMT_SIZE_T MinRequiredBufferSize; // minimum required size of Data[] array to contain requested data. + _Out_writes_bytes_(ProvidedBufferSize) UCHAR Data[1]; +} D3DKMT_DMM_ESCAPE; + +typedef enum _D3DKMT_BRIGHTNESS_INFO_TYPE +{ + D3DKMT_BRIGHTNESS_INFO_GET_POSSIBLE_LEVELS = 1, + D3DKMT_BRIGHTNESS_INFO_GET = 2, + D3DKMT_BRIGHTNESS_INFO_SET = 3, + D3DKMT_BRIGHTNESS_INFO_GET_CAPS = 4, + D3DKMT_BRIGHTNESS_INFO_SET_STATE = 5, + D3DKMT_BRIGHTNESS_INFO_SET_OPTIMIZATION = 6, + D3DKMT_BRIGHTNESS_INFO_GET_REDUCTION = 7, + D3DKMT_BRIGHTNESS_INFO_BEGIN_MANUAL_MODE = 8, + D3DKMT_BRIGHTNESS_INFO_END_MANUAL_MODE = 9, + D3DKMT_BRIGHTNESS_INFO_TOGGLE_LOGGING = 10, + D3DKMT_BRIGHTNESS_INFO_GET_NIT_RANGES = 11, +} D3DKMT_BRIGHTNESS_INFO_TYPE; + +typedef struct _D3DKMT_BRIGHTNESS_POSSIBLE_LEVELS +{ + UCHAR LevelCount; + UCHAR BrightnessLevels[256]; +} D3DKMT_BRIGHTNESS_POSSIBLE_LEVELS; + +typedef struct _D3DKMT_BRIGHTNESS_INFO +{ + D3DKMT_BRIGHTNESS_INFO_TYPE Type; + ULONG ChildUid; + union + { + D3DKMT_BRIGHTNESS_POSSIBLE_LEVELS PossibleLevels; + UCHAR Brightness; + DXGK_BRIGHTNESS_CAPS BrightnessCaps; + DXGK_BRIGHTNESS_STATE BrightnessState; + DXGK_BACKLIGHT_OPTIMIZATION_LEVEL OptimizationLevel; + DXGK_BACKLIGHT_INFO ReductionInfo; + BOOLEAN VerboseLogging; + DXGK_BRIGHTNESS_GET_NIT_RANGES_OUT NitRanges; + DXGK_BRIGHTNESS_GET_OUT GetBrightnessMillinits; + DXGK_BRIGHTNESS_SET_IN SetBrightnessMillinits; + }; +} D3DKMT_BRIGHTNESS_INFO; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +typedef struct _D3DKMT_BDDFALLBACK_CTL +{ + BOOLEAN ForceBddHeadlessNextFallback; +} D3DKMT_BDDFALLBACK_CTL; + +typedef struct _D3DKMT_REQUEST_MACHINE_CRASH_ESCAPE +{ + D3DKMT_ALIGN64 D3DKMT_ULONG_PTR Param1; + D3DKMT_ALIGN64 D3DKMT_ULONG_PTR Param2; + D3DKMT_ALIGN64 D3DKMT_ULONG_PTR Param3; +} D3DKMT_REQUEST_MACHINE_CRASH_ESCAPE; + +// +// VERIFIER OPTIONS +// +typedef enum _D3DKMT_VERIFIER_OPTION_MODE +{ + D3DKMT_VERIFIER_OPTION_QUERY, + D3DKMT_VERIFIER_OPTION_SET +} D3DKMT_VERIFIER_OPTION_MODE; + +typedef enum _D3DKMT_PROCESS_VERIFIER_OPTION_TYPE +{ + // + // Dxgkrnl (0xxx) + // + + // + // VidMm (1xxx) + // + D3DKMT_PROCESS_VERIFIER_OPTION_VIDMM_FLAGS = 1000, + D3DKMT_PROCESS_VERIFIER_OPTION_VIDMM_RESTRICT_BUDGET = 1001, + + // + // VidSch (2xxx) + // + +} D3DKMT_PROCESS_VERIFIER_OPTION_TYPE; + +typedef union _D3DKMT_PROCESS_VERIFIER_VIDMM_FLAGS +{ + struct + { + UINT ForceSynchronousEvict : 1; + UINT NeverDeferEvictions : 1; + UINT AlwaysFailCommitOnReclaim : 1; + UINT AlwaysPlaceInDemotedLocation : 1; + UINT Reserved : 28; + }; + UINT32 Value; +} D3DKMT_PROCESS_VERIFIER_VIDMM_FLAGS; + +typedef struct _D3DKMT_PROCESS_VERIFIER_VIDMM_RESTRICT_BUDGET +{ + D3DKMT_ALIGN64 UINT64 LocalBudget; + D3DKMT_ALIGN64 UINT64 NonLocalBudget; +} D3DKMT_PROCESS_VERIFIER_VIDMM_RESTRICT_BUDGET; + +typedef union _D3DKMT_PROCESS_VERIFIER_OPTION_DATA +{ + D3DKMT_PROCESS_VERIFIER_VIDMM_FLAGS VidMmFlags; + D3DKMT_PROCESS_VERIFIER_VIDMM_RESTRICT_BUDGET VidMmRestrictBudget; +} D3DKMT_PROCESS_VERIFIER_OPTION_DATA; + +typedef struct _D3DKMT_PROCESS_VERIFIER_OPTION +{ + D3DKMT_PTR(HANDLE, hProcess); + D3DKMT_PROCESS_VERIFIER_OPTION_TYPE Type; + D3DKMT_VERIFIER_OPTION_MODE Mode; + D3DKMT_PROCESS_VERIFIER_OPTION_DATA Data; +} D3DKMT_PROCESS_VERIFIER_OPTION; + +typedef enum _D3DKMT_ADAPTER_VERIFIER_OPTION_TYPE +{ + // + // Dxgkrnl (0xxx) + // + + // + // VidMm (1xxx) + // + D3DKMT_ADAPTER_VERIFIER_OPTION_VIDMM_FLAGS = 1000, + D3DKMT_ADAPTER_VERIFIER_OPTION_VIDMM_TRIM_INTERVAL = 1001, + + // + // VidSch (2xxx) + // +} D3DKMT_ADAPTER_VERIFIER_OPTION_TYPE; + +typedef union _D3DKMT_ADAPTER_VERIFIER_VIDMM_FLAGS +{ + struct + { + UINT AlwaysRepatch : 1; + UINT FailSharedPrimary : 1; + UINT FailProbeAndLock : 1; + UINT AlwaysDiscardOffer : 1; + UINT NeverDiscardOffer : 1; + UINT ForceComplexLock : 1; + UINT NeverPrepatch : 1; + UINT ExpectPreparationFailure : 1; + UINT TakeSplitPoint : 1; + UINT FailAcquireSwizzlingRange : 1; + UINT PagingPathLockSubrange : 1; + UINT PagingPathLockMinrange : 1; + UINT FailVaRotation : 1; + UINT NoDemotion : 1; + UINT FailDefragPass : 1; + UINT AlwaysProcessOfferList : 1; + UINT AlwaysDecommitOffer : 1; + UINT NeverMoveDefrag : 1; + UINT AlwaysRelocateDisplayableResources : 1; + UINT AlwaysFailGrowVPRMoves : 1; + UINT Reserved : 12; + }; + UINT32 Value; +} D3DKMT_ADAPTER_VERIFIER_VIDMM_FLAGS; + +typedef struct _D3DKMT_ADAPTER_VERIFIER_VIDMM_TRIM_INTERVAL +{ + D3DKMT_ALIGN64 UINT64 MinimumTrimInterval; + D3DKMT_ALIGN64 UINT64 MaximumTrimInterval; + D3DKMT_ALIGN64 UINT64 IdleTrimInterval; +} D3DKMT_ADAPTER_VERIFIER_VIDMM_TRIM_INTERVAL; + +typedef union _D3DKMT_ADAPTER_VERIFIER_OPTION_DATA +{ + D3DKMT_ADAPTER_VERIFIER_VIDMM_FLAGS VidMmFlags; + D3DKMT_ADAPTER_VERIFIER_VIDMM_TRIM_INTERVAL VidMmTrimInterval; +} D3DKMT_ADAPTER_VERIFIER_OPTION_DATA; + +typedef struct _D3DKMT_ADAPTER_VERIFIER_OPTION +{ + D3DKMT_ADAPTER_VERIFIER_OPTION_TYPE Type; + D3DKMT_VERIFIER_OPTION_MODE Mode; + D3DKMT_ADAPTER_VERIFIER_OPTION_DATA Data; +} D3DKMT_ADAPTER_VERIFIER_OPTION; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 + +typedef enum _D3DKMT_DEVICEESCAPE_TYPE +{ + D3DKMT_DEVICEESCAPE_VIDPNFROMALLOCATION = 0, + D3DKMT_DEVICEESCAPE_RESTOREGAMMA = 1, +} D3DKMT_DEVICEESCAPE_TYPE; + +typedef struct _D3DKMT_DEVICE_ESCAPE +{ + D3DKMT_DEVICEESCAPE_TYPE Type; + union + { + struct + { + D3DKMT_HANDLE hPrimaryAllocation; // in: Primary allocation handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // out: VidPnSoureId of primary allocation + } VidPnFromAllocation; + }; +} D3DKMT_DEVICE_ESCAPE; + +typedef struct _D3DKMT_DEBUG_SNAPSHOT_ESCAPE +{ + ULONG Length; // out: Actual length of the snapshot written in Buffer + BYTE Buffer[1]; // out: Buffer to place snapshot +} D3DKMT_DEBUG_SNAPSHOT_ESCAPE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +#ifndef DXGK_DIAG_PROCESS_NAME_LENGTH +#define DXGK_DIAG_PROCESS_NAME_LENGTH 16 +#endif + +typedef enum _OUTPUTDUPL_CONTEXT_DEBUG_STATUS +{ + OUTPUTDUPL_CONTEXT_DEBUG_STATUS_INACTIVE = 0, + OUTPUTDUPL_CONTEXT_DEBUG_STATUS_ACTIVE = 1, + OUTPUTDUPL_CONTEXT_DEBUG_STATUS_PENDING_DESTROY = 2, + OUTPUTDUPL_CONTEXT_DEBUG_STATUS_FORCE_UINT32 = 0xffffffff +}OUTPUTDUPL_CONTEXT_DEBUG_STATUS; + +typedef struct _OUTPUTDUPL_CONTEXT_DEBUG_INFO +{ + OUTPUTDUPL_CONTEXT_DEBUG_STATUS Status; + D3DKMT_PTR(HANDLE, ProcessID); + UINT32 AccumulatedPresents; + D3DKMT_ALIGN64 LARGE_INTEGER LastPresentTime; + D3DKMT_ALIGN64 LARGE_INTEGER LastMouseTime; + CHAR ProcessName[DXGK_DIAG_PROCESS_NAME_LENGTH]; +} OUTPUTDUPL_CONTEXT_DEBUG_INFO; + +#define GET_OUTPUT_DUPL_DEBUG_INFO_FROM_SNAPSHOT(pSnapshot, VidPnSource, OutputDuplContextIndex) \ + (pSnapshot->OutputDuplDebugInfos[(VidPnSource * pSnapshot->NumOutputDuplContexts) + OutputDuplContextIndex]) + +typedef struct _D3DKMT_OUTPUTDUPL_SNAPSHOT +{ + UINT Size; // _In_/out: Size of entire structure + + UINT SessionProcessCount; // _Out_: Number of processes currently duplicating output in this session (max possible will be equal to NumOutputDuplContexts) + UINT SessionActiveConnectionsCount; // _Out_: Total number of active contexts in this session, may be more than number active in 2D array because that is per adapter + + UINT NumVidPnSources; // _Out_: Max of first array index + UINT NumOutputDuplContexts; // _Out_: Max of second array index + + UINT Padding; + + // This field is in reality a two dimensional array, use GET_OUTPUT_DUPL_DEBUG_INFO_FROM_SNAPSHOT macro to get a specific one + _Field_size_bytes_(Size - sizeof(_D3DKMT_OUTPUTDUPL_SNAPSHOT)) OUTPUTDUPL_CONTEXT_DEBUG_INFO OutputDuplDebugInfos[0]; +} D3DKMT_OUTPUTDUPL_SNAPSHOT; +#endif + +typedef enum _D3DKMT_ACTIVATE_SPECIFIC_DIAG_TYPE +{ + D3DKMT_ACTIVATE_SPECIFIC_DIAG_TYPE_EXTRA_CCD_DATABASE_INFO = 0, + D3DKMT_ACTIVATE_SPECIFIC_DIAG_TYPE_MODES_PRUNED = 15, +}D3DKMT_ACTIVATE_SPECIFIC_DIAG_TYPE; + +typedef struct _D3DKMT_ACTIVATE_SPECIFIC_DIAG_ESCAPE +{ + D3DKMT_ACTIVATE_SPECIFIC_DIAG_TYPE Type; // The escape type that needs to be (de)activated + BOOL Activate; // FALSE means deactivate +} D3DKMT_ACTIVATE_SPECIFIC_DIAG_ESCAPE; + +typedef struct _D3DKMT_ESCAPE +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in: device handle [Optional] + D3DKMT_ESCAPETYPE Type; // in: escape type. + D3DDDI_ESCAPEFLAGS Flags; // in: flags + D3DKMT_PTR(VOID*, pPrivateDriverData); // in/out: escape data + UINT PrivateDriverDataSize; // in: size of escape data + D3DKMT_HANDLE hContext; // in: context handle [Optional] +} D3DKMT_ESCAPE; + +// +// begin D3DKMT_QUERYSTATISTICS +// + +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 = 16, +} D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT; + +// +// WOW will not allow enum member as array length, so define it as a constant +// +#define D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT_MAX 16 +C_ASSERT(D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT_MAX == D3DKMT_PreemptionAttemptStatisticsMax); + +// +// Command packet type +// +typedef enum _D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE { + D3DKMT_ClientRenderBuffer = 0, // (Dma packet) should be 0 base. + D3DKMT_ClientPagingBuffer = 1, // (Dma packet) + D3DKMT_SystemPagingBuffer = 2, // (Dma packet) + D3DKMT_SystemPreemptionBuffer = 3, // (Dma packet) + D3DKMT_DmaPacketTypeMax = 4 +} D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE; + +// +// WOW will not allow enum member as array length, so define it as a constant +// +#define D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_MAX 4 +C_ASSERT(D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_MAX == D3DKMT_DmaPacketTypeMax); + +typedef enum _D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE { + D3DKMT_RenderCommandBuffer = 0, // (Queue Packet) should be 0 base. + D3DKMT_DeferredCommandBuffer = 1, // (Queue Packet) + D3DKMT_SystemCommandBuffer = 2, // (Queue Packet) + D3DKMT_MmIoFlipCommandBuffer = 3, // (Queue Packet) + D3DKMT_WaitCommandBuffer = 4, // (Queue Packet) + D3DKMT_SignalCommandBuffer = 5, // (Queue Packet) + D3DKMT_DeviceCommandBuffer = 6, // (Queue Packet) + D3DKMT_SoftwareCommandBuffer = 7, // (Queue Packet) + D3DKMT_QueuePacketTypeMax = 8 +} D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE; + +// +// WOW will not allow enum member as array length, so define it as a constant +// +#define D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_MAX 8 +C_ASSERT(D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_MAX == D3DKMT_QueuePacketTypeMax); + +typedef enum _D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS +{ + D3DKMT_AllocationPriorityClassMinimum = 0, + D3DKMT_AllocationPriorityClassLow = 1, + D3DKMT_AllocationPriorityClassNormal = 2, + D3DKMT_AllocationPriorityClassHigh = 3, + D3DKMT_AllocationPriorityClassMaximum = 4, + D3DKMT_MaxAllocationPriorityClass = 5 +} D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS; + +// +// WOW will not allow enum member as array length, so define it as a constant +// + +#define D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX 5 +C_ASSERT(D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX == D3DKMT_MaxAllocationPriorityClass); + +// +// Allocation segment preference set can contain 5 preferences +// +#define D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX 5 + +typedef struct _D3DKMT_QUERYSTATISTICS_COUNTER +{ + ULONG Count; + ULONGLONG Bytes; +} D3DKMT_QUERYSTATISTICS_COUNTER; + +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_QUEUE_PACKET_TYPE_INFORMATION { + ULONG PacketSubmited; + ULONG PacketCompleted; +} D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION { + D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_INFORMATION QueuePacket[D3DKMT_QUERYSTATISTICS_QUEUE_PACKET_TYPE_MAX]; //Size = D3DKMT_QueuePacketTypeMax + D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_INFORMATION DmaPacket[D3DKMT_QUERYSTATISTICS_DMA_PACKET_TYPE_MAX]; //Size = D3DKMT_DmaPacketTypeMax +} D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION { + ULONG PreemptionCounter[D3DKMT_QUERYRESULT_PREEMPTION_ATTEMPT_RESULT_MAX]; +} D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION { + D3DKMT_ALIGN64 LARGE_INTEGER RunningTime; // Running time in micro-second. + ULONG ContextSwitch; + D3DKMT_QUERYSTATISTICS_PREEMPTION_INFORMATION PreemptionStatistics; + D3DKMT_QUERYSTATISTICS_PACKET_INFORMATION PacketStatistics; + D3DKMT_ALIGN64 UINT64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_NODE_INFORMATION { + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION GlobalInformation; //Global statistics + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION SystemInformation; //Statistics for system thread +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_NODE_PERFDATA NodePerfData; + UINT32 Reserved[3]; +#else + D3DKMT_ALIGN64 UINT64 Reserved[8]; +#endif +} D3DKMT_QUERYSTATISTICS_NODE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION { + ULONG Frame; // both by Blt and Flip. + ULONG CancelledFrame; // by restart (flip only). + ULONG QueuedPresent; // queued present. + UINT Padding; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_7) + D3DKMT_ALIGN64 UINT64 IsVSyncEnabled; + D3DKMT_ALIGN64 UINT64 VSyncOnTotalTimeMs; + D3DKMT_ALIGN64 UINT64 VSyncOffKeepPhaseTotalTimeMs; + D3DKMT_ALIGN64 UINT64 VSyncOffNoPhaseTotalTimeMs; + D3DKMT_ALIGN64 UINT64 Reserved[4]; +#else + D3DKMT_ALIGN64 UINT64 Reserved[8]; +#endif + +} D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION { + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION GlobalInformation; //Global statistics + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION SystemInformation; //Statistics for system thread + D3DKMT_ALIGN64 UINT64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION; + +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_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_PAGING_TRANSFER +{ + D3DKMT_ALIGN64 ULONGLONG BytesFilled; + D3DKMT_ALIGN64 ULONGLONG BytesDiscarded; + D3DKMT_ALIGN64 ULONGLONG BytesMappedIntoAperture; + D3DKMT_ALIGN64 ULONGLONG BytesUnmappedFromAperture; + D3DKMT_ALIGN64 ULONGLONG BytesTransferredFromMdlToMemory; + D3DKMT_ALIGN64 ULONGLONG BytesTransferredFromMemoryToMdl; + D3DKMT_ALIGN64 ULONGLONG BytesTransferredFromApertureToMemory; + D3DKMT_ALIGN64 ULONGLONG BytesTransferredFromMemoryToAperture; +} D3DKMT_QUERYSTATSTICS_PAGING_TRANSFER; + +typedef struct _D3DKMT_QUERYSTATSTICS_SWIZZLING_RANGE +{ + ULONG NbRangesAcquired; + ULONG NbRangesReleased; +} D3DKMT_QUERYSTATSTICS_SWIZZLING_RANGE; + +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 +{ + // + // We separate shared / nonshared because for nonshared we know that every alloc + // terminated will lead cause a global alloc destroyed, but not for nonshared. + // + D3DKMT_QUERYSTATISTICS_COUNTER TerminatedShared; + D3DKMT_QUERYSTATISTICS_COUNTER TerminatedNonShared; + D3DKMT_QUERYSTATISTICS_COUNTER DestroyedShared; + D3DKMT_QUERYSTATISTICS_COUNTER DestroyedNonShared; +} D3DKMT_QUERYSTATSTICS_TERMINATIONS; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef struct _D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION_FLAGS +{ + union + { + struct + { + UINT64 NumberOfMemoryGroups : 2; + UINT64 SupportsDemotion : 1; + UINT64 Reserved :61; + }; + D3DKMT_ALIGN64 UINT64 Value; + }; +} D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION_FLAGS; +#endif + +typedef struct _D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION +{ + ULONG NbSegments; + ULONG NodeCount; + ULONG VidPnSourceCount; + + ULONG VSyncEnabled; + ULONG TdrDetectedCount; + + D3DKMT_ALIGN64 LONGLONG ZeroLengthDmaBuffers; + D3DKMT_ALIGN64 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; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION_FLAGS Flags; + D3DKMT_ALIGN64 UINT64 Reserved[7]; +#else + D3DKMT_ALIGN64 UINT64 Reserved[8]; +#endif +} D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) +typedef struct _D3DKMT_QUERYSTATISTICS_PHYSICAL_ADAPTER_INFORMATION +{ + D3DKMT_ADAPTER_PERFDATA AdapterPerfData; + D3DKMT_ADAPTER_PERFDATACAPS AdapterPerfDataCaps; + D3DKMT_GPUVERSION GpuVersion; +} D3DKMT_QUERYSTATISTICS_PHYSICAL_ADAPTER_INFORMATION; +#endif + +typedef struct _D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY +{ + D3DKMT_ALIGN64 ULONGLONG BytesAllocated; + D3DKMT_ALIGN64 ULONGLONG BytesReserved; + ULONG SmallAllocationBlocks; + ULONG LargeAllocationBlocks; + D3DKMT_ALIGN64 ULONGLONG WriteCombinedBytesAllocated; + D3DKMT_ALIGN64 ULONGLONG WriteCombinedBytesReserved; + D3DKMT_ALIGN64 ULONGLONG CachedBytesAllocated; + D3DKMT_ALIGN64 ULONGLONG CachedBytesReserved; + D3DKMT_ALIGN64 ULONGLONG SectionBytesAllocated; + D3DKMT_ALIGN64 ULONGLONG SectionBytesReserved; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_ALIGN64 ULONGLONG BytesZeroed; +#else + D3DKMT_ALIGN64 ULONGLONG Reserved; +#endif +} D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION +{ + ULONG NodeCount; + ULONG VidPnSourceCount; + + D3DKMT_QUERYSTATISTICS_SYSTEM_MEMORY SystemMemory; + + D3DKMT_ALIGN64 UINT64 Reserved[7]; +} D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_DMA_BUFFER +{ + D3DKMT_QUERYSTATISTICS_COUNTER Size; + ULONG AllocationListBytes; + ULONG PatchLocationListBytes; +} D3DKMT_QUERYSTATISTICS_DMA_BUFFER; + +typedef struct _D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA +{ + D3DKMT_ALIGN64 UINT64 TotalBytesEvictedFromProcess; + D3DKMT_ALIGN64 UINT64 BytesBySegmentPreference[D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX]; +} D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA; + +typedef struct _D3DKMT_QUERYSTATISTICS_POLICY +{ + D3DKMT_ALIGN64 ULONGLONG PreferApertureForRead[D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX]; + D3DKMT_ALIGN64 ULONGLONG PreferAperture[D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX]; + D3DKMT_ALIGN64 ULONGLONG MemResetOnPaging; + D3DKMT_ALIGN64 ULONGLONG RemovePagesFromWorkingSetOnPaging; + D3DKMT_ALIGN64 ULONGLONG MigrationEnabled; +} D3DKMT_QUERYSTATISTICS_POLICY; + +// Process interference counters indicate how much this process GPU workload interferes with packets +// attempting to preempt it. 9 buckets will be exposed based on how long preemption took: +// [0] 100 microseconds <= preemption time < 250 microseconds +// [1] 250 microseconds <= preemption time < 500 microseconds +// [2] 500 microseconds <= preemption time < 1 milliseconds +// [3] 1 milliseconds <= preemption time < 2.5 milliseconds +// [4] 2.5 milliseconds <= preemption time < 5 milliseconds +// [5] 5 milliseconds <= preemption time < 10 milliseconds +// [6] 10 milliseconds <= preemption time < 25 milliseconds +// [7] 25 milliseconds <= preemption time < 50 milliseconds +// [8] 50 milliseconds <= preemption time +// +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +#define D3DKMT_QUERYSTATISTICS_PROCESS_INTERFERENCE_BUCKET_COUNT 9 + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_INTERFERENCE_COUNTERS +{ + D3DKMT_ALIGN64 UINT64 InterferenceCount[D3DKMT_QUERYSTATISTICS_PROCESS_INTERFERENCE_BUCKET_COUNT]; +} D3DKMT_QUERYSTATISTICS_PROCESS_INTERFERENCE_COUNTERS; +#endif + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION +{ + ULONG NbSegments; + ULONG NodeCount; + ULONG VidPnSourceCount; + + // + // Virtual address space used by vidmm for this process + // + ULONG VirtualMemoryUsage; + + D3DKMT_QUERYSTATISTICS_DMA_BUFFER DmaBuffer; + D3DKMT_QUERYSTATISTICS_COMMITMENT_DATA CommitmentData; + D3DKMT_QUERYSTATISTICS_POLICY _Policy; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_QUERYSTATISTICS_PROCESS_INTERFERENCE_COUNTERS ProcessInterferenceCounters; +#else + D3DKMT_ALIGN64 UINT64 Reserved[9]; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + D3DKMT_CLIENTHINT ClientHint; +#else + UINT Reserve; +#endif +} D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION; + +typedef struct _D3DKMT_QUERYSTATISTICS_MEMORY +{ + D3DKMT_ALIGN64 ULONGLONG TotalBytesEvicted; + ULONG AllocsCommitted; + ULONG AllocsResident; +} D3DKMT_QUERYSTATISTICS_MEMORY; + +typedef struct _D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION +{ +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ALIGN64 ULONGLONG CommitLimit; + D3DKMT_ALIGN64 ULONGLONG BytesCommitted; + D3DKMT_ALIGN64 ULONGLONG BytesResident; +#else + ULONG CommitLimit; + ULONG BytesCommitted; + ULONG BytesResident; +#endif + + D3DKMT_QUERYSTATISTICS_MEMORY Memory; + + // + // Boolean, whether this is an aperture segment + // + ULONG Aperture; + + // + // Breakdown of bytes evicted by priority class + // + D3DKMT_ALIGN64 ULONGLONG TotalBytesEvictedByPriority[D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX]; //Size = D3DKMT_MaxAllocationPriorityClass + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ALIGN64 UINT64 SystemMemoryEndAddress; + struct D3DKMT_ALIGN64 + { + UINT64 PreservedDuringStandby : 1; + UINT64 PreservedDuringHibernate : 1; + UINT64 PartiallyPreservedDuringHibernate : 1; + UINT64 Reserved : 61; + } PowerFlags; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + struct D3DKMT_ALIGN64 + { + UINT64 SystemMemory : 1; + UINT64 PopulatedByReservedDDRByFirmware : 1; + UINT64 Reserved : 62; + } SegmentProperties; + D3DKMT_ALIGN64 UINT64 Reserved[5]; +#else + D3DKMT_ALIGN64 UINT64 Reserved[6]; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) +#else + D3DKMT_ALIGN64 UINT64 Reserved[8]; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +} D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION; + +// +// Video memory statistics. +// +typedef struct _D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY +{ + ULONG AllocsCommitted; + D3DKMT_QUERYSTATISTICS_COUNTER AllocsResidentInP[D3DKMT_QUERYSTATISTICS_SEGMENT_PREFERENCE_MAX]; + D3DKMT_QUERYSTATISTICS_COUNTER AllocsResidentInNonPreferred; + D3DKMT_ALIGN64 ULONGLONG TotalBytesEvictedDueToPreparation; +} D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY; + +// +// VidMM Policies +// +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY +{ + D3DKMT_ALIGN64 ULONGLONG UseMRU; +} D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY; + +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION +{ +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + D3DKMT_ALIGN64 ULONGLONG BytesCommitted; + D3DKMT_ALIGN64 ULONGLONG MaximumWorkingSet; + D3DKMT_ALIGN64 ULONGLONG MinimumWorkingSet; + + ULONG NbReferencedAllocationEvictedInPeriod; + UINT Padding; +#else + ULONG BytesCommitted; + ULONG NbReferencedAllocationEvictedInPeriod; + ULONG MaximumWorkingSet; + ULONG MinimumWorkingSet; +#endif + + D3DKMT_QUERYSTATISTICS_VIDEO_MEMORY VideoMemory; + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_POLICY _Policy; + + D3DKMT_ALIGN64 UINT64 Reserved[8]; +} D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef struct _D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP_INFORMATION +{ + D3DKMT_ALIGN64 UINT64 Budget; + D3DKMT_ALIGN64 UINT64 Requested; + D3DKMT_ALIGN64 UINT64 Usage; + D3DKMT_ALIGN64 UINT64 Demoted[D3DKMT_QUERYSTATISTICS_ALLOCATION_PRIORITY_CLASS_MAX]; +} D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP_INFORMATION; +#endif + +typedef enum _D3DKMT_QUERYSTATISTICS_TYPE +{ + D3DKMT_QUERYSTATISTICS_ADAPTER = 0, + D3DKMT_QUERYSTATISTICS_PROCESS = 1, + D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER = 2, + D3DKMT_QUERYSTATISTICS_SEGMENT = 3, + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT = 4, + D3DKMT_QUERYSTATISTICS_NODE = 5, + D3DKMT_QUERYSTATISTICS_PROCESS_NODE = 6, + D3DKMT_QUERYSTATISTICS_VIDPNSOURCE = 7, + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE = 8, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP = 9, +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_QUERYSTATISTICS_PHYSICAL_ADAPTER = 10, +#endif +} D3DKMT_QUERYSTATISTICS_TYPE; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT +{ + ULONG SegmentId; // in: id of node to get statistics for +} D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_NODE +{ + ULONG NodeId; +} D3DKMT_QUERYSTATISTICS_QUERY_NODE; + +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE +{ + ULONG VidPnSourceId; // in: id of segment to get statistics for +} D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) +typedef struct _D3DKMT_QUERYSTATISTICS_QUERY_PHYSICAL_ADAPTER +{ + ULONG PhysicalAdapterIndex; +} D3DKMT_QUERYSTATISTICS_QUERY_PHYSICAL_ADAPTER; +#endif + +typedef union _D3DKMT_QUERYSTATISTICS_RESULT +{ + D3DKMT_QUERYSTATISTICS_ADAPTER_INFORMATION AdapterInformation; // out: result of D3DKMT_QUERYSTATISTICS_ADAPTER query +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_QUERYSTATISTICS_PHYSICAL_ADAPTER_INFORMATION PhysAdapterInformation; // out: result of D3DKMT_QUERYSTATISTICS_PHYSICAL_ADAPTER query +#endif + D3DKMT_QUERYSTATISTICS_SEGMENT_INFORMATION SegmentInformation; // out: result of D3DKMT_QUERYSTATISTICS_SEGMENT query + D3DKMT_QUERYSTATISTICS_NODE_INFORMATION NodeInformation; // out: result of D3DKMT_QUERYSTATISTICS_NODE query + D3DKMT_QUERYSTATISTICS_VIDPNSOURCE_INFORMATION VidPnSourceInformation; // out: result of D3DKMT_QUERYSTATISTICS_VIDPNSOURCE query + D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION ProcessInformation; // out: result of D3DKMT_QUERYSTATISTICS_PROCESS query + D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION ProcessAdapterInformation; // out: result of D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER query + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_INFORMATION ProcessSegmentInformation; // out: result of D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT query + D3DKMT_QUERYSTATISTICS_PROCESS_NODE_INFORMATION ProcessNodeInformation; // out: result of D3DKMT_QUERYSTATISTICS_PROCESS_NODE query + D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION ProcessVidPnSourceInformation; // out: result of D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE query +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP_INFORMATION ProcessSegmentGroupInformation;// out: result of D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP query +#endif +} D3DKMT_QUERYSTATISTICS_RESULT; + +typedef struct _D3DKMT_QUERYSTATISTICS +{ + D3DKMT_QUERYSTATISTICS_TYPE Type; // in: type of data requested + LUID AdapterLuid; // in: adapter to get export / statistics from + D3DKMT_PTR(HANDLE, hProcess); // in: process to get statistics for, if required for this query type + D3DKMT_QUERYSTATISTICS_RESULT QueryResult; // out: requested data + + union + { + D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT QuerySegment; // in: id of segment to get statistics for + D3DKMT_QUERYSTATISTICS_QUERY_SEGMENT QueryProcessSegment; // in: id of segment to get statistics for +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + D3DKMT_MEMORY_SEGMENT_GROUP QueryProcessSegmentGroup; // in: id of segment group to get statistics for +#endif + D3DKMT_QUERYSTATISTICS_QUERY_NODE QueryNode; // in: id of node to get statistics for + D3DKMT_QUERYSTATISTICS_QUERY_NODE QueryProcessNode; // in: id of node to get statistics for + D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE QueryVidPnSource; // in: id of vidpnsource to get statistics for + D3DKMT_QUERYSTATISTICS_QUERY_VIDPNSOURCE QueryProcessVidPnSource; // in: id of vidpnsource to get statistics for +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + D3DKMT_QUERYSTATISTICS_QUERY_PHYSICAL_ADAPTER QueryPhysAdapter; // in: id of physical adapter to get statistics for +#endif + }; +} D3DKMT_QUERYSTATISTICS; +#if defined(_AMD64_) +C_ASSERT(sizeof(D3DKMT_QUERYSTATISTICS) == 0x328); +#endif + +// +// end D3DKMT_QUERYSTATISTICS +// + + +typedef struct _D3DKMT_PRESENT_STATS_DWM2 +{ + ULONG cbSize; // in: size of struct for versioning + UINT PresentCount; + UINT PresentRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER PresentQPCTime; + UINT SyncRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER SyncQPCTime; + UINT CustomPresentDuration; + UINT VirtualSyncRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER VirtualSyncQPCTime; +} D3DKMT_PRESENT_STATS_DWM2; + + +typedef enum _D3DKMT_VIDPNSOURCEOWNER_TYPE +{ + D3DKMT_VIDPNSOURCEOWNER_UNOWNED = 0, //Has no owner or GDI is the owner + D3DKMT_VIDPNSOURCEOWNER_SHARED = 1, //Has shared owner, that is owner can yield to any exclusive owner, not available to legacy devices + D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVE = 2, //Has exclusive owner without shared gdi primary, + D3DKMT_VIDPNSOURCEOWNER_EXCLUSIVEGDI = 3, //Has exclusive owner with shared gdi primary and must be exclusive owner of all VidPn sources, only available to legacy devices + D3DKMT_VIDPNSOURCEOWNER_EMULATED = 4, //Does not have real primary ownership, but allows the device to set gamma on its owned sources +} D3DKMT_VIDPNSOURCEOWNER_TYPE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_VIDPNSOURCEOWNER_FLAGS +{ + union + { + struct + { + UINT AllowOutputDuplication : 1; + UINT DisableDWMVirtualMode : 1; + UINT UseNtHandles : 1; + UINT Reserved : 29; + }; + UINT Value; + }; +} D3DKMT_VIDPNSOURCEOWNER_FLAGS; +#endif + +typedef struct _D3DKMT_SETVIDPNSOURCEOWNER +{ + D3DKMT_HANDLE hDevice; // in: Device handle + D3DKMT_PTR(CONST D3DKMT_VIDPNSOURCEOWNER_TYPE*, pType); // in: OwnerType array + D3DKMT_PTR(CONST D3DDDI_VIDEO_PRESENT_SOURCE_ID*, pVidPnSourceId); // in: VidPn source ID array + UINT VidPnSourceCount; // in: Number of valid entries in above array +} D3DKMT_SETVIDPNSOURCEOWNER; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef struct _D3DKMT_SETVIDPNSOURCEOWNER1 +{ + D3DKMT_SETVIDPNSOURCEOWNER Version0; + D3DKMT_VIDPNSOURCEOWNER_FLAGS Flags; +} D3DKMT_SETVIDPNSOURCEOWNER1; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +typedef struct _D3DKMT_SETVIDPNSOURCEOWNER2 +{ + D3DKMT_SETVIDPNSOURCEOWNER1 Version1; + D3DKMT_PTR(CONST D3DKMT_PTR_TYPE*, pVidPnSourceNtHandles); // in: VidPn source owner DispMgr NT handles +} D3DKMT_SETVIDPNSOURCEOWNER2; +#endif + +typedef struct _D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP +{ + D3DKMT_HANDLE hAdapter; // in: Adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPn source ID array +} D3DKMT_CHECKVIDPNEXCLUSIVEOWNERSHIP; + +#define D3DKMT_GETPRESENTHISTORY_MAXTOKENS 2048 + +typedef struct _D3DKMT_GETPRESENTHISTORY +{ + D3DKMT_HANDLE hAdapter; // in: Handle to adapter + UINT ProvidedSize; // in: Size of provided buffer + UINT WrittenSize; // out: Copied token size or required size for first token + D3DKMT_PTR(_Field_size_bytes_(ProvidedSize) D3DKMT_PRESENTHISTORYTOKEN*, pTokens); // in: Pointer to buffer. + UINT NumTokens; // out: Number of copied token +} D3DKMT_GETPRESENTHISTORY; + +typedef struct _D3DKMT_CREATEOVERLAY +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DDDI_KERNELOVERLAYINFO OverlayInfo; // in + D3DKMT_HANDLE hOverlay; // out: Kernel overlay handle +} D3DKMT_CREATEOVERLAY; + +typedef struct _D3DKMT_UPDATEOVERLAY +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hOverlay; // in: Kernel overlay handle + D3DDDI_KERNELOVERLAYINFO OverlayInfo; // in +} D3DKMT_UPDATEOVERLAY; + +typedef struct _D3DKMT_FLIPOVERLAY +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hOverlay; // in: Kernel overlay handle + D3DKMT_HANDLE hSource; // in: Allocation currently displayed + D3DKMT_PTR(VOID*, pPrivateDriverData); // in: Private driver data + UINT PrivateDriverDataSize; // in: Size of private driver data +} D3DKMT_FLIPOVERLAY; + +typedef struct _D3DKMT_GETOVERLAYSTATE +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hOverlay; // in: Kernel overlay handle + BOOLEAN OverlayEnabled; +} D3DKMT_GETOVERLAYSTATE; + +typedef struct _D3DKMT_DESTROYOVERLAY +{ + D3DKMT_HANDLE hDevice; // in: Indentifies the device + D3DKMT_HANDLE hOverlay; // in: Kernel overlay handle +} D3DKMT_DESTROYOVERLAY; + +typedef struct _D3DKMT_WAITFORVERTICALBLANKEVENT +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in: device handle [Optional] + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID +} D3DKMT_WAITFORVERTICALBLANKEVENT; + +#define D3DKMT_MAX_WAITFORVERTICALBLANK_OBJECTS 8 + +typedef struct _D3DKMT_WAITFORVERTICALBLANKEVENT2 +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in: device handle [Optional] + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + UINT NumObjects; + D3DKMT_PTR_TYPE ObjectHandleArray[D3DKMT_MAX_WAITFORVERTICALBLANK_OBJECTS]; // in: Specifies the objects to wait on. +} D3DKMT_WAITFORVERTICALBLANKEVENT2; + +typedef struct _D3DKMT_GETVERTICALBLANKEVENT +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in: device handle [Optional] + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + D3DKMT_PTR(D3DKMT_PTR_TYPE*, phEvent); +} D3DKMT_GETVERTICALBLANKEVENT; + +typedef struct _D3DKMT_SETSYNCREFRESHCOUNTWAITTARGET +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DKMT_HANDLE hDevice; // in: device handle [Optional] + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + UINT TargetSyncRefreshCount; +} D3DKMT_SETSYNCREFRESHCOUNTWAITTARGET; + +typedef struct _D3DKMT_SETGAMMARAMP +{ + D3DKMT_HANDLE hDevice; // in: device handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + D3DDDI_GAMMARAMP_TYPE Type; // in: Gamma ramp type + + union + { + D3DDDI_GAMMA_RAMP_RGB256x3x16* pGammaRampRgb256x3x16; + D3DDDI_GAMMA_RAMP_DXGI_1* pGammaRampDXGI1; + D3DKMT_PTR_HELPER( AlignUnionTo64) + }; + UINT Size; +} D3DKMT_SETGAMMARAMP; + +typedef struct _D3DKMT_ADJUSTFULLSCREENGAMMA +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + D3DDDI_DXGI_RGB Scale; + D3DDDI_DXGI_RGB Offset; +} D3DKMT_ADJUSTFULLSCREENGAMMA; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + +typedef struct _D3DKMT_SET_COLORSPACE_TRANSFORM +{ + _In_ LUID AdapterLuid; + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + _In_ D3DDDI_GAMMARAMP_TYPE Type; + _In_ UINT Size; + union + { + _In_reads_bytes_opt_(Size) D3DKMDT_3x4_COLORSPACE_TRANSFORM* pColorSpaceTransform; + D3DKMT_PTR_HELPER( AlignUnionTo64) + }; +} D3DKMT_SET_COLORSPACE_TRANSFORM; + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_3 + +typedef struct _D3DKMT_SETVIDPNSOURCEHWPROTECTION +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN Source ID + BOOL HwProtected; // in: HW protection status +} D3DKMT_SETVIDPNSOURCEHWPROTECTION; + +typedef struct _D3DKMT_SETHWPROTECTIONTEARDOWNRECOVERY +{ + D3DKMT_HANDLE hAdapter; // in: adapter handle + BOOL Recovered; // in: HW protection teardown recovery +} D3DKMT_SETHWPROTECTIONTEARDOWNRECOVERY; + +typedef enum _D3DKMT_DEVICEEXECUTION_STATE +{ + D3DKMT_DEVICEEXECUTION_ACTIVE = 1, + D3DKMT_DEVICEEXECUTION_RESET = 2, + D3DKMT_DEVICEEXECUTION_HUNG = 3, + D3DKMT_DEVICEEXECUTION_STOPPED = 4, + D3DKMT_DEVICEEXECUTION_ERROR_OUTOFMEMORY = 5, + D3DKMT_DEVICEEXECUTION_ERROR_DMAFAULT = 6, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DKMT_DEVICEEXECUTION_ERROR_DMAPAGEFAULT = 7, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +} D3DKMT_DEVICEEXECUTION_STATE; + +typedef struct _D3DKMT_DEVICERESET_STATE +{ + union + { + struct + { + UINT DesktopSwitched : 1; // 0x00000001 + UINT Reserved :31; // 0xFFFFFFFE + }; + UINT Value; + }; +} D3DKMT_DEVICERESET_STATE; + +typedef struct _D3DKMT_PRESENT_STATS +{ + UINT PresentCount; + UINT PresentRefreshCount; + UINT SyncRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER SyncQPCTime; + D3DKMT_ALIGN64 LARGE_INTEGER SyncGPUTime; +} D3DKMT_PRESENT_STATS; + +typedef struct _D3DKMT_DEVICEPRESENT_STATE +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: present source id + D3DKMT_PRESENT_STATS PresentStats; // out: present stats +} D3DKMT_DEVICEPRESENT_STATE; + +typedef struct _D3DKMT_PRESENT_STATS_DWM +{ + UINT PresentCount; + UINT PresentRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER PresentQPCTime; + UINT SyncRefreshCount; + D3DKMT_ALIGN64 LARGE_INTEGER SyncQPCTime; + UINT CustomPresentDuration; +} D3DKMT_PRESENT_STATS_DWM; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_DEVICEPAGEFAULT_STATE +{ + D3DKMT_ALIGN64 UINT64 FaultedPrimitiveAPISequenceNumber; // when per draw fence write is enabled, identifies the draw that caused the page fault, or DXGK_PRIMITIVE_API_SEQUENCE_NUMBER_UNKNOWN if such information is not available. + DXGK_RENDER_PIPELINE_STAGE FaultedPipelineStage; // render pipeline stage during which the fault was generated, or DXGK_RENDER_PIPELINE_STAGE_UNKNOWN if such information is not available. + UINT FaultedBindTableEntry; // a bind table index of a resource being accessed at the time of the fault, or DXGK_BIND_TABLE_ENTRY_UNKNOWN if such information is not available. + DXGK_PAGE_FAULT_FLAGS PageFaultFlags; // flags specifying the nature of the fault + DXGK_FAULT_ERROR_CODE FaultErrorCode; // Structure that contains error code describing the fault. + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS FaultedVirtualAddress; // virtual address of faulting resource, or D3DGPU_NULL if such information is not available. +} D3DKMT_DEVICEPAGEFAULT_STATE; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_DEVICEPRESENT_STATE_DWM +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: present source id + D3DKMT_PRESENT_STATS_DWM PresentStatsDWM; // out: present stats rev 2 +} D3DKMT_DEVICEPRESENT_STATE_DWM; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + +typedef struct _D3DKMT_DEVICEPRESENT_QUEUE_STATE +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: present source id + BOOLEAN bQueuedPresentLimitReached; // out: whether the queued present limit has been reached +} D3DKMT_DEVICEPRESENT_QUEUE_STATE; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + +typedef enum _D3DKMT_DEVICESTATE_TYPE +{ + D3DKMT_DEVICESTATE_EXECUTION = 1, + D3DKMT_DEVICESTATE_PRESENT = 2, + D3DKMT_DEVICESTATE_RESET = 3, + D3DKMT_DEVICESTATE_PRESENT_DWM = 4, + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + + D3DKMT_DEVICESTATE_PAGE_FAULT = 5, + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + + D3DKMT_DEVICESTATE_PRESENT_QUEUE = 6, + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 +} D3DKMT_DEVICESTATE_TYPE; + +typedef struct _D3DKMT_GETDEVICESTATE +{ + D3DKMT_HANDLE hDevice; // in: device handle + D3DKMT_DEVICESTATE_TYPE StateType; // in: device state type + union + { + D3DKMT_DEVICEEXECUTION_STATE ExecutionState; // out: device state + D3DKMT_DEVICEPRESENT_STATE PresentState; // in/out: present state + D3DKMT_DEVICERESET_STATE ResetState; // out: reset state + D3DKMT_DEVICEPRESENT_STATE_DWM PresentStateDWM; // in/out: present state + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + + D3DKMT_DEVICEPAGEFAULT_STATE PageFaultState; // out: page fault state + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + + D3DKMT_DEVICEPRESENT_QUEUE_STATE PresentQueueState; // in/out: present queue state + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 + }; +} D3DKMT_GETDEVICESTATE;
typedef struct _D3DKMT_CREATEDCFROMMEMORY { - void *pMemory; - D3DDDIFORMAT Format; - UINT Width; - UINT Height; - UINT Pitch; - HDC hDeviceDc; - PALETTEENTRY *pColorTable; - HDC hDc; - HANDLE hBitmap; -} D3DKMT_CREATEDCFROMMEMORY; + D3DKMT_PTR(VOID*, pMemory); // in: memory for DC + D3DDDIFORMAT Format; // in: Memory pixel format + UINT Width; // in: Memory Width + UINT Height; // in: Memory Height + UINT Pitch; // in: Memory pitch + D3DKMT_PTR(HDC, hDeviceDc); // in: DC describing the device + D3DKMT_PTR(PALETTEENTRY*, pColorTable); // in: Palette + D3DKMT_PTR(HDC, hDc); // out: HDC + D3DKMT_PTR(HANDLE, hBitmap); // out: Handle to bitmap +} D3DKMT_CREATEDCFROMMEMORY; + +typedef struct _D3DKMT_DESTROYDCFROMMEMORY +{ + D3DKMT_PTR(HDC, hDc); // in: + D3DKMT_PTR(HANDLE, hBitmap); // in: +} D3DKMT_DESTROYDCFROMMEMORY; + +#define D3DKMT_SETCONTEXTSCHEDULINGPRIORITY_ABSOLUTE 0x40000000 + +typedef struct _D3DKMT_SETCONTEXTSCHEDULINGPRIORITY +{ + D3DKMT_HANDLE hContext; // in: context handle + INT Priority; // in: context priority +} D3DKMT_SETCONTEXTSCHEDULINGPRIORITY; + +typedef struct _D3DKMT_SETCONTEXTINPROCESSSCHEDULINGPRIORITY +{ + D3DKMT_HANDLE hContext; // in: context handle + INT Priority; // in: context priority +} D3DKMT_SETCONTEXTINPROCESSSCHEDULINGPRIORITY; + +typedef struct _D3DKMT_CHANGESURFACEPOINTER +{ + D3DKMT_PTR(HDC, hDC); // in: dc handle + D3DKMT_PTR(HANDLE, hBitmap); // in: bitmap handle + D3DKMT_PTR(LPVOID, pSurfacePointer);// in: new surface pointer + UINT Width; // in: Memory Width + UINT Height; // in: Memory Height + UINT Pitch; // in: Memory pitch +} D3DKMT_CHANGESURFACEPOINTER; + +typedef struct _D3DKMT_GETCONTEXTSCHEDULINGPRIORITY +{ + D3DKMT_HANDLE hContext; // in: context handle + INT Priority; // out: context priority +} D3DKMT_GETCONTEXTSCHEDULINGPRIORITY; + +typedef struct _D3DKMT_GETCONTEXTINPROCESSSCHEDULINGPRIORITY +{ + D3DKMT_HANDLE hContext; // in: context handle + INT Priority; // out: context priority +} D3DKMT_GETCONTEXTINPROCESSSCHEDULINGPRIORITY; + +typedef enum _D3DKMT_SCHEDULINGPRIORITYCLASS +{ + D3DKMT_SCHEDULINGPRIORITYCLASS_IDLE = 0, + D3DKMT_SCHEDULINGPRIORITYCLASS_BELOW_NORMAL = 1, + D3DKMT_SCHEDULINGPRIORITYCLASS_NORMAL = 2, + D3DKMT_SCHEDULINGPRIORITYCLASS_ABOVE_NORMAL = 3, + D3DKMT_SCHEDULINGPRIORITYCLASS_HIGH = 4, + D3DKMT_SCHEDULINGPRIORITYCLASS_REALTIME = 5, +} D3DKMT_SCHEDULINGPRIORITYCLASS; + +typedef struct _D3DKMT_GETSCANLINE +{ + D3DKMT_HANDLE hAdapter; // in: Adapter handle + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: Adapter's VidPN Source ID + BOOLEAN InVerticalBlank; // out: Within vertical blank + UINT ScanLine; // out: Current scan line +} D3DKMT_GETSCANLINE; + +typedef enum _D3DKMT_QUEUEDLIMIT_TYPE +{ + D3DKMT_SET_QUEUEDLIMIT_PRESENT = 1, + D3DKMT_GET_QUEUEDLIMIT_PRESENT = 2, +} D3DKMT_QUEUEDLIMIT_TYPE; + +typedef struct _D3DKMT_SETQUEUEDLIMIT +{ + D3DKMT_HANDLE hDevice; // in: device handle + D3DKMT_QUEUEDLIMIT_TYPE Type; // in: limit type + union + { + UINT QueuedPresentLimit; // in (or out): queued present limit + struct + { + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: adapter's VidPN source ID + UINT QueuedPendingFlipLimit; // in (or out): flip pending limit + }; + }; +} D3DKMT_SETQUEUEDLIMIT; + +typedef struct _D3DKMT_POLLDISPLAYCHILDREN +{ + D3DKMT_HANDLE hAdapter; // in: Adapter handle + UINT NonDestructiveOnly : 1; // in: 0x00000001 Destructive or not + UINT SynchronousPolling : 1; // in: 0x00000002 Synchronous polling or not + UINT DisableModeReset : 1; // in: 0x00000004 Disable DMM mode reset on monitor event + UINT PollAllAdapters : 1; // in: 0x00000008 Poll all adapters + UINT PollInterruptible : 1; // in: 0x00000010 Poll interruptible targets as well. + UINT Reserved : 27; // in: 0xffffffc0 +} D3DKMT_POLLDISPLAYCHILDREN; + +typedef struct _D3DKMT_INVALIDATEACTIVEVIDPN +{ + D3DKMT_HANDLE hAdapter; // in: Adapter handle + D3DKMT_PTR(VOID*, pPrivateDriverData); // in: Private driver data + UINT PrivateDriverDataSize; // in: Size of private driver data +} D3DKMT_INVALIDATEACTIVEVIDPN; + +typedef struct _D3DKMT_CHECKOCCLUSION +{ + D3DKMT_PTR(HWND, hWindow); // in: Destination window handle +} D3DKMT_CHECKOCCLUSION; + +typedef struct _D3DKMT_WAITFORIDLE +{ + D3DKMT_HANDLE hDevice; // in: Device to wait for idle +} D3DKMT_WAITFORIDLE; + +typedef struct _D3DKMT_CHECKMONITORPOWERSTATE +{ + D3DKMT_HANDLE hAdapter; // in: Adapter to check on + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: Adapter's VidPN Source ID +} D3DKMT_CHECKMONITORPOWERSTATE; + +typedef struct _D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT +{ + D3DKMT_HANDLE hDevice; // in: Identifies the device + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: Identifies which VidPn we are changing the private driver format attribute for + UINT PrivateDriverFormatAttribute; // In: Requested private format attribute for VidPn specified +} D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT; + +typedef struct _D3DKMT_CREATEKEYEDMUTEX +{ + D3DKMT_ALIGN64 UINT64 InitialValue; // in: Initial value to release to + D3DKMT_HANDLE hSharedHandle; // out: Global handle to keyed mutex + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process +} D3DKMT_CREATEKEYEDMUTEX; + +typedef struct _D3DKMT_OPENKEYEDMUTEX +{ + D3DKMT_HANDLE hSharedHandle; // in: Global handle to keyed mutex + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process +} D3DKMT_OPENKEYEDMUTEX; + +typedef struct _D3DKMT_DESTROYKEYEDMUTEX +{ + D3DKMT_HANDLE hKeyedMutex; // in: Identifies the keyed mutex being destroyed. +} D3DKMT_DESTROYKEYEDMUTEX; + +typedef struct _D3DKMT_ACQUIREKEYEDMUTEX +{ + D3DKMT_HANDLE hKeyedMutex; // in: Handle to the keyed mutex + D3DKMT_ALIGN64 UINT64 Key; // in: Key value to Acquire + D3DKMT_PTR(PLARGE_INTEGER, pTimeout); // in: NT-style timeout value + D3DKMT_ALIGN64 UINT64 FenceValue; // out: Current fence value of the GPU sync object +} D3DKMT_ACQUIREKEYEDMUTEX; + +typedef struct _D3DKMT_RELEASEKEYEDMUTEX +{ + D3DKMT_HANDLE hKeyedMutex; // in: Handle to the keyed mutex + D3DKMT_ALIGN64 UINT64 Key; // in: Key value to Release to + D3DKMT_ALIGN64 UINT64 FenceValue; // in: New fence value to use for GPU sync object +} D3DKMT_RELEASEKEYEDMUTEX; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef struct _D3DKMT_CREATEKEYEDMUTEX2_FLAGS +{ + union + { + struct + { + UINT NtSecuritySharing : 1; // If set, the keyed mutex will be shared using DxgkShareObjects instead of D3DKMT_CREATEKEYEDMUTEX2::hSharedHandle + UINT Reserved : 31; + }; + UINT Value; + }; +} D3DKMT_CREATEKEYEDMUTEX2_FLAGS; + +typedef struct _D3DKMT_CREATEKEYEDMUTEX2 +{ + D3DKMT_ALIGN64 UINT64 InitialValue; // in: Initial value to release to + D3DKMT_HANDLE hSharedHandle; // out: Global handle to keyed mutex, NULL if NtSecuritySharing is set. + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process + D3DKMT_PTR(_In_reads_bytes_opt_(PrivateRuntimeDataSize) + VOID*, pPrivateRuntimeData); // in: Buffer containing initial private data. + // If NULL then PrivateRuntimeDataSize must be 0. + UINT PrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. + D3DKMT_CREATEKEYEDMUTEX2_FLAGS Flags; // in: Creation flags. +} D3DKMT_CREATEKEYEDMUTEX2; + +typedef struct _D3DKMT_OPENKEYEDMUTEX2 +{ + D3DKMT_HANDLE hSharedHandle; // in: Global handle to keyed mutex + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process + D3DKMT_PTR(_In_reads_bytes_opt_(PrivateRuntimeDataSize) + VOID*, pPrivateRuntimeData); // in: Buffer containing initial private data. + // If NULL then PrivateRuntimeDataSize must be 0. + // It will only be copied if the keyed mutex does not already have private data. + UINT PrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. +} D3DKMT_OPENKEYEDMUTEX2; + +typedef struct _D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE +{ + D3DKMT_PTR(HANDLE, hNtHandle); // in: NT handle to keyed mutex + D3DKMT_HANDLE hKeyedMutex; // out: Handle to the keyed mutex in this process + D3DKMT_PTR(_In_reads_bytes_opt_(PrivateRuntimeDataSize) + VOID*, pPrivateRuntimeData); // in: Buffer containing initial private data. + // If NULL then PrivateRuntimeDataSize must be 0. + // It will only be copied if the keyed mutex does not already have private data. + UINT PrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. +} D3DKMT_OPENKEYEDMUTEXFROMNTHANDLE; + +typedef struct _D3DKMT_ACQUIREKEYEDMUTEX2 +{ + D3DKMT_HANDLE hKeyedMutex; // in: Handle to the keyed mutex + D3DKMT_ALIGN64 UINT64 Key; // in: Key value to Acquire + D3DKMT_PTR(PLARGE_INTEGER, pTimeout); // in: NT-style timeout value + D3DKMT_ALIGN64 UINT64 FenceValue; // out: Current fence value of the GPU sync object + D3DKMT_PTR(_Out_writes_bytes_all_opt_(PrivateRuntimeDataSize) + VOID*, pPrivateRuntimeData); // out: Buffer to copy private data to. + // If NULL then PrivateRuntimeDataSize must be 0. + UINT PrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. +} D3DKMT_ACQUIREKEYEDMUTEX2; + +typedef struct _D3DKMT_RELEASEKEYEDMUTEX2 +{ + D3DKMT_HANDLE hKeyedMutex; // in: Handle to the keyed mutex + D3DKMT_ALIGN64 UINT64 Key; // in: Key value to Release to + D3DKMT_ALIGN64 UINT64 FenceValue; // in: New fence value to use for GPU sync object + D3DKMT_PTR(_In_reads_bytes_opt_(PrivateRuntimeDataSize) + VOID*, pPrivateRuntimeData); // in: Buffer containing new private data. + // If NULL then PrivateRuntimeDataSize must be 0. + UINT PrivateRuntimeDataSize; // in: Size in bytes of pPrivateRuntimeData. +} D3DKMT_RELEASEKEYEDMUTEX2; +#endif + + +typedef struct _D3DKMT_CONFIGURESHAREDRESOURCE +{ + D3DKMT_HANDLE hDevice; // in: Device that created the resource + D3DKMT_HANDLE hResource; // in: Handle for shared resource + BOOLEAN IsDwm; // in: TRUE when the process is DWM + D3DKMT_PTR(HANDLE, hProcess); // in: Process handle for the non-DWM case + BOOLEAN AllowAccess; // in: Indicates whereh the process is allowed access +} D3DKMT_CONFIGURESHAREDRESOURCE; + +typedef struct _D3DKMT_CHECKSHAREDRESOURCEACCESS +{ + D3DKMT_HANDLE hResource; // in: Handle for the resource + UINT ClientPid; // in: Client process PID +} D3DKMT_CHECKSHAREDRESOURCEACCESS; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef enum _D3DKMT_OFFER_PRIORITY +{ + D3DKMT_OFFER_PRIORITY_LOW=1, // Content is not useful + D3DKMT_OFFER_PRIORITY_NORMAL, // Content is useful but easy to regenerate + D3DKMT_OFFER_PRIORITY_HIGH, // Content is useful and difficult to regenerate + D3DKMT_OFFER_PRIORITY_AUTO, // Let VidMm decide offer priority based on eviction priority +} D3DKMT_OFFER_PRIORITY; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +typedef struct _D3DKMT_OFFER_FLAGS +{ + union + { + struct + { + UINT OfferImmediately : 1; // 0x00000001 + UINT AllowDecommit : 1; // 0x00000002 + UINT Reserved : 30; // 0xFFFFFFFC + }; + UINT Value; + }; +} D3DKMT_OFFER_FLAGS; +#endif // DXGKDDI_INTERFACE_VERSION + +typedef struct _D3DKMT_OFFERALLOCATIONS +{ + D3DKMT_HANDLE hDevice; // in: Device that created the allocations + D3DKMT_PTR(D3DKMT_HANDLE*, pResources); // in: array of D3D runtime resource handles. + D3DKMT_PTR(CONST D3DKMT_HANDLE*, HandleList); // in: array of allocation handles. If non-NULL, pResources must be NULL. + UINT NumAllocations; // in: number of items in whichever of pResources or HandleList is non-NULL. + D3DKMT_OFFER_PRIORITY Priority; // in: priority with which to offer the allocations +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + D3DKMT_OFFER_FLAGS Flags; // in: various flags for determining offer behavior +#endif // DXGKDDI_INTERFACE_VERSION +} D3DKMT_OFFERALLOCATIONS; + +typedef struct _D3DKMT_RECLAIMALLOCATIONS +{ + D3DKMT_HANDLE hDevice; // in: Device that created the allocations + D3DKMT_PTR(D3DKMT_HANDLE*, pResources); // in: array of D3D runtime resource handles. + D3DKMT_PTR(CONST D3DKMT_HANDLE*, HandleList); // in: array of allocation handles. If non-NULL, pResources must be NULL. + D3DKMT_PTR(BOOL*, pDiscarded); // out: optional array of booleans specifying whether each resource or allocation was discarded. + UINT NumAllocations; // in: number of items in pDiscarded and whichever of pResources or HandleList is non-NULL. +} D3DKMT_RECLAIMALLOCATIONS; + +typedef struct _D3DKMT_RECLAIMALLOCATIONS2 +{ + D3DKMT_HANDLE hPagingQueue; // in: Device that created the allocations + UINT NumAllocations; // in: number of items in pDiscarded and whichever of pResources or HandleList is non-NULL. + D3DKMT_PTR(D3DKMT_HANDLE*, pResources); // in: array of D3D runtime resource handles. + D3DKMT_PTR(CONST D3DKMT_HANDLE*, HandleList); // in: array of allocation handles. If non-NULL, pResources must be NULL. +#if(DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1 || \ + D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WDDM2_1) + union + { + BOOL* pDiscarded; // out: optional array of booleans specifying whether each resource or allocation was discarded. + D3DDDI_RECLAIM_RESULT* pResults; // out: array of results specifying whether each resource or allocation is OK, discarded, or has no commitment. + D3DKMT_PTR_HELPER(AlignUnionTo64) + }; +#else + D3DKMT_PTR(BOOL*, pDiscarded); // out: optional array of booleans specifying whether each resource or allocation was discarded. +#endif // (DXGKDDI_INTERFACE_VERSION || D3D_UMD_INTERFACE_VERSION) + D3DKMT_ALIGN64 UINT64 PagingFenceValue; // out: The paging fence to synchronize against before submitting work to the GPU which + // references any of the resources or allocations in the provided arrays +} D3DKMT_RECLAIMALLOCATIONS2; + +typedef struct _D3DKMT_OUTPUTDUPLCREATIONFLAGS +{ + union + { + struct + { + UINT CompositionUiCaptureOnly : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} D3DKMT_OUTPUTDUPLCREATIONFLAGS; + +typedef struct _D3DKMT_OUTPUTDUPL_KEYEDMUTEX +{ + D3DKMT_PTR(HANDLE, hSharedSurfaceNt); +}D3DKMT_OUTPUTDUPL_KEYEDMUTEX; + +#define OUTPUTDUPL_CREATE_MAX_KEYEDMUTXES 3 +typedef struct _D3DKMT_CREATE_OUTPUTDUPL +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT KeyedMutexCount; // in : If zero then means is this the pre-create check + UINT RequiredKeyedMutexCount; // out: The number of keyed mutexs needed + D3DKMT_OUTPUTDUPL_KEYEDMUTEX KeyedMutexs[OUTPUTDUPL_CREATE_MAX_KEYEDMUTXES]; + D3DKMT_OUTPUTDUPLCREATIONFLAGS Flags; +} D3DKMT_CREATE_OUTPUTDUPL; + +typedef struct _D3DKMT_DESTROY_OUTPUTDUPL +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + BOOL bDestroyAllContexts; +} D3DKMT_DESTROY_OUTPUTDUPL; + +typedef struct _D3DKMT_OUTPUTDUPL_POINTER_POSITION +{ + POINT Position; + BOOL Visible; +} D3DKMT_OUTPUTDUPL_POINTER_POSITION; + +typedef struct _D3DKMT_OUTPUTDUPL_FRAMEINFO +{ + D3DKMT_ALIGN64 LARGE_INTEGER LastPresentTime; + D3DKMT_ALIGN64 LARGE_INTEGER LastMouseUpdateTime; + UINT AccumulatedFrames; + BOOL RectsCoalesced; + BOOL ProtectedContentMaskedOut; + D3DKMT_OUTPUTDUPL_POINTER_POSITION PointerPosition; + UINT TotalMetadataBufferSize; + UINT PointerShapeBufferSize; +} D3DKMT_OUTPUTDUPL_FRAMEINFO; + +typedef struct _D3DKMT_OUTPUTDUPL_GET_FRAMEINFO +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_OUTPUTDUPL_FRAMEINFO FrameInfo; +} D3DKMT_OUTPUTDUPL_GET_FRAMEINFO; + +typedef enum _D3DKMT_OUTPUTDUPL_METADATATYPE +{ + D3DKMT_OUTPUTDUPL_METADATATYPE_DIRTY_RECTS = 0, + D3DKMT_OUTPUTDUPL_METADATATYPE_MOVE_RECTS = 1 +} D3DKMT_OUTPUTDUPL_METADATATYPE; + +typedef struct _D3DKMT_OUTPUTDUPL_METADATA +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DKMT_OUTPUTDUPL_METADATATYPE Type; + UINT BufferSizeSupplied; + D3DKMT_PTR(_Field_size_bytes_part_(BufferSizeSupplied, BufferSizeRequired) PVOID, pBuffer); + UINT BufferSizeRequired; +} D3DKMT_OUTPUTDUPL_METADATA; + +typedef enum _D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE +{ + D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME = 0x00000001, + D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE_COLOR = 0x00000002, + D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE_MASKED_COLOR = 0x00000004 +} D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE; + +typedef struct _D3DKMT_OUTDUPL_POINTER_SHAPE_INFO +{ + D3DKMT_OUTDUPL_POINTER_SHAPE_TYPE Type; + UINT Width; + UINT Height; + UINT Pitch; + POINT HotSpot; +} D3DKMT_OUTDUPL_POINTER_SHAPE_INFO; + +typedef struct _D3DKMT_OUTPUTDUPL_GET_POINTER_SHAPE_DATA +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT BufferSizeSupplied; + D3DKMT_PTR(_Field_size_bytes_part_(BufferSizeSupplied, BufferSizeRequired) PVOID, pShapeBuffer); + UINT BufferSizeRequired; + D3DKMT_OUTDUPL_POINTER_SHAPE_INFO ShapeInfo; +} D3DKMT_OUTPUTDUPL_GET_POINTER_SHAPE_DATA; + +typedef struct _D3DKMT_OUTPUTDUPL_RELEASE_FRAME +{ + D3DKMT_HANDLE hAdapter; + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT NextKeyMutexIdx; // out : index of the next keyed mutex to use +} D3DKMT_OUTPUTDUPL_RELEASE_FRAME; + + +#define D3DKMT_MAX_OBJECTS_PER_HANDLE 3 + +#define D3DKMT_MAX_BUNDLE_OBJECTS_PER_HANDLE 16 + +#define D3DKMT_GDI_STYLE_HANDLE_DECORATION 0x2 + +typedef struct _D3DKMT_GETSHAREDRESOURCEADAPTERLUID +{ + D3DKMT_HANDLE hGlobalShare; // in : Shared resource handle + D3DKMT_PTR(HANDLE, hNtHandle); // in : Process's NT handle + LUID AdapterLuid; // out: adapter LUID +} D3DKMT_GETSHAREDRESOURCEADAPTERLUID; + +typedef enum _D3DKMT_GPU_PREFERENCE_QUERY_STATE +{ + D3DKMT_GPU_PREFERENCE_STATE_UNINITIALIZED, + D3DKMT_GPU_PREFERENCE_STATE_HIGH_PERFORMANCE, + D3DKMT_GPU_PREFERENCE_STATE_MINIMUM_POWER, + D3DKMT_GPU_PREFERENCE_STATE_UNSPECIFIED, + D3DKMT_GPU_PREFERENCE_STATE_NOT_FOUND, + D3DKMT_GPU_PREFERENCE_STATE_USER_SPECIFIED_GPU +} D3DKMT_GPU_PREFERENCE_QUERY_STATE; + +typedef enum _D3DKMT_GPU_PREFERENCE_QUERY_TYPE +{ + D3DKMT_GPU_PREFERENCE_TYPE_IHV_DLIST, + D3DKMT_GPU_PREFERENCE_TYPE_DX_DATABASE, + D3DKMT_GPU_PREFERENCE_TYPE_USER_PREFERENCE +} D3DKMT_GPU_PREFERENCE_QUERY_TYPE; + +typedef struct _D3DKMT_HYBRID_LIST +{ + D3DKMT_GPU_PREFERENCE_QUERY_STATE State; // Gpu preference query state + LUID AdapterLuid; // in,opt: Adapter luid to per-adapter DList state. Optional if QueryType == D3DKMT_GPU_PREFERENCE_TYPE_IHV_DLIST + BOOL bUserPreferenceQuery; // Whether referring to user gpu preference, or per-adapter DList query +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + D3DKMT_GPU_PREFERENCE_QUERY_TYPE QueryType; // Replaced bUserPreferenceQuery, for referring to which D3DKMT_GPU_PREFERENCE_QUERY_TYPE +#endif +} D3DKMT_HYBRID_LIST; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +typedef struct +{ + DXGK_MIRACAST_CHUNK_INFO ChunkInfo; + UINT PrivateDriverDataSize; // Size of private data + BYTE PrivateDriverData[1]; // Private data buffer +} D3DKMT_MIRACAST_CHUNK_DATA; + +typedef enum +{ + MiracastStopped = 0, + MiracastStartPending = 1, + MiracastStarted = 2, + MiracastStopPending = 3, +} D3DKMT_MIRACAST_DISPLAY_DEVICE_STATE; + +typedef enum +{ + D3DKMT_MIRACAST_DEVICE_STATUS_SUCCESS = 0, + D3DKMT_MIRACAST_DEVICE_STATUS_SUCCESS_NO_MONITOR = 1, + D3DKMT_MIRACAST_DEVICE_STATUS_PENDING = 2, + D3DKMT_MIRACAST_DEVICE_STATUS_UNKOWN_ERROR = 0x80000001, + D3DKMT_MIRACAST_DEVICE_STATUS_GPU_RESOURCE_IN_USE = 0x80000002, + D3DKMT_MIRACAST_DEVICE_STATUS_DEVICE_ERROR = 0x80000003, + D3DKMT_MIRACAST_DEVICE_STATUS_UNKOWN_PAIRING = 0x80000004, + D3DKMT_MIRACAST_DEVICE_STATUS_REMOTE_SESSION = 0x80000005, + D3DKMT_MIRACAST_DEVICE_STATUS_DEVICE_NOT_FOUND = 0x80000006, + D3DKMT_MIRACAST_DEVICE_STATUS_DEVICE_NOT_STARTED = 0x80000007, + D3DKMT_MIRACAST_DEVICE_STATUS_INVALID_PARAMETER = 0x80000008, + D3DKMT_MIRACAST_DEVICE_STATUS_INSUFFICIENT_BANDWIDTH = 0x80000009, + D3DKMT_MIRACAST_DEVICE_STATUS_INSUFFICIENT_MEMORY = 0x8000000A, + D3DKMT_MIRACAST_DEVICE_STATUS_CANCELLED = 0x8000000B, +} D3DKMT_MIRACAST_DEVICE_STATUS; + +typedef struct _D3DKMT_MIRACAST_DISPLAY_DEVICE_STATUS +{ + // + // Miracast display device state. + // + D3DKMT_MIRACAST_DISPLAY_DEVICE_STATE State; +} D3DKMT_MIRACAST_DISPLAY_DEVICE_STATUS, *PD3DKMT_MIRACAST_DISPLAY_DEVICE_STATUS; + +typedef struct _D3DKMT_MIRACAST_DISPLAY_DEVICE_CAPS +{ + BOOLEAN HdcpSupported; + ULONG DefaultControlPort; + BOOLEAN UsesIhvSolution; +} D3DKMT_MIRACAST_DISPLAY_DEVICE_CAPS, *PD3DKMT_MIRACAST_DISPLAY_DEVICE_CAPS; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +typedef struct _D3DKMT_MIRACAST_DISPLAY_STOP_SESSIONS +{ + LUID AdapterLuid; + D3DDDI_VIDEO_PRESENT_TARGET_ID TargetId; + UINT StopReason; +} D3DKMT_MIRACAST_DISPLAY_STOP_SESSIONS, *PD3DKMT_MIRACAST_DISPLAY_STOP_SESSIONS; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef struct _D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + UINT ObjectCount; // in: Number of objects to wait on. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Handle to monitored fence synchronization objects to wait on. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const UINT64*, FenceValueArray); // in: Fence values to be waited on. + + D3DKMT_PTR(HANDLE, hAsyncEvent); // in: Event to be signaled when the wait condition is satisfied. + // When set to NULL, the call will not return until the wait condition is satisfied. + + D3DDDI_WAITFORSYNCHRONIZATIONOBJECTFROMCPU_FLAGS Flags; // in: Flags that specify the wait mode. +} D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU; + +typedef struct _D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + UINT ObjectCount; // in: Number of objects to signal. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Handle to monitored fence synchronization objects to signal. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const UINT64*, FenceValueArray); // in: Fence values to be signaled. + + D3DDDICB_SIGNALFLAGS Flags; // in: Specifies signal behavior. +} D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU; + +typedef struct _D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU +{ + D3DKMT_HANDLE hContext; // in: Specify the context that should be waiting. + UINT ObjectCount; // in: Number of object to wait on. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Handles to synchronization objects to wait on. + + union + { + _Field_size_(ObjectCount) + const UINT64* MonitoredFenceValueArray; // in: monitored fence values to be waited. + + D3DKMT_ALIGN64 UINT64 FenceValue; // in: fence value to be waited. + + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; +} D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU; + +typedef struct _D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU +{ + D3DKMT_HANDLE hContext; // in: Identifies the context that the signal is being submitted to. + UINT ObjectCount; // in: Specifies the number of objects to signal. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Specifies the objects to signal. + + union + { + _Field_size_(ObjectCount) + const UINT64* MonitoredFenceValueArray; // in: monitored fence values to be signaled + + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; +} D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU; + +typedef struct _D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU2 +{ + UINT ObjectCount; // in: Specifies the number of objects to signal. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Specifies the objects to signal. + + D3DDDICB_SIGNALFLAGS Flags; // in: Specifies signal behavior. + + ULONG BroadcastContextCount; // in: Specifies the number of contexts to broadcast this signal to. + + D3DKMT_PTR(_Field_size_(BroadcastContextCount) + const D3DKMT_HANDLE*, BroadcastContextArray); // in: Specifies context handles to broadcast to. + + union + { + D3DKMT_ALIGN64 UINT64 FenceValue; // in: fence value to be signaled; + + HANDLE CpuEventHandle; // in: handle of a CPU event to be signaled if Flags.EnqueueCpuEvent flag is set. + + _Field_size_(ObjectCount) + const UINT64* MonitoredFenceValueArray; // in: monitored fence values to be signaled + + D3DKMT_ALIGN64 UINT64 Reserved[8]; + }; +} D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU2; + +typedef struct _D3DKMT_CREATEPAGINGQUEUE +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + D3DDDI_PAGINGQUEUE_PRIORITY Priority; // in: scheduling priority relative to other paging queues on this device + D3DKMT_HANDLE hPagingQueue; // out: handle to the paging queue used to synchronize paging operations for this device. + D3DKMT_HANDLE hSyncObject; // out: handle to the monitored fence object used to synchronize paging operations for this paging queue. + D3DKMT_PTR(VOID*, FenceValueCPUVirtualAddress); // out: Read-only mapping of the fence value for the CPU + UINT PhysicalAdapterIndex; // in: Physical adapter index (engine ordinal) +} D3DKMT_CREATEPAGINGQUEUE;
-typedef struct _D3DKMT_DESTROYDCFROMMEMORY +typedef struct _D3DKMT_EVICT { - HDC hDc; - HANDLE hBitmap; -} D3DKMT_DESTROYDCFROMMEMORY; + D3DKMT_HANDLE hDevice; // in: Device that created the allocations + UINT NumAllocations; // in: number of allocation handles + D3DKMT_PTR(CONST D3DKMT_HANDLE*, AllocationList); // in: an array of NumAllocations allocation handles + D3DDDI_EVICT_FLAGS Flags; // in: eviction flags + D3DKMT_ALIGN64 UINT64 NumBytesToTrim; // out: This value indicates how much to trim in order to satisfy the new budget. +} D3DKMT_EVICT; + +typedef struct _D3DKMT_LOCK2 +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + D3DKMT_HANDLE hAllocation; // in: allocation to lock + D3DDDICB_LOCK2FLAGS Flags; // in: Bit field defined by D3DDDI_LOCK2FLAGS + D3DKMT_PTR(PVOID, pData); // out: Virtual address of the locked allocation +} D3DKMT_LOCK2; + +typedef struct _D3DKMT_UNLOCK2 +{ + D3DKMT_HANDLE hDevice; // in: Handle to the device. + D3DKMT_HANDLE hAllocation; // in: allocation to unlock +} D3DKMT_UNLOCK2; + +typedef struct _D3DKMT_INVALIDATECACHE +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hAllocation; + D3DKMT_ALIGN64 D3DKMT_SIZE_T Offset; + D3DKMT_ALIGN64 D3DKMT_SIZE_T Length; +} D3DKMT_INVALIDATECACHE; + +typedef struct _D3DKMT_FREEGPUVIRTUALADDRESS +{ + D3DKMT_HANDLE hAdapter; // in: Handle to an adapter. + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS BaseAddress; // in: Start of a virtual address range in bytes + D3DKMT_ALIGN64 D3DGPU_SIZE_T Size; // in: Size of the virtual address range in bytes +} D3DKMT_FREEGPUVIRTUALADDRESS; + +typedef struct _D3DKMT_UPDATEGPUVIRTUALADDRESS +{ + D3DKMT_HANDLE hDevice; + D3DKMT_HANDLE hContext; + D3DKMT_HANDLE hFenceObject; + UINT NumOperations; + D3DKMT_PTR(D3DDDI_UPDATEGPUVIRTUALADDRESS_OPERATION*, Operations); + D3DKMT_ALIGN64 D3DKMT_SIZE_T Reserved0; + D3DKMT_ALIGN64 UINT64 Reserved1; + D3DKMT_ALIGN64 UINT64 FenceValue; + union + { + struct + { + UINT DoNotWait : 1; + UINT Reserved : 31; + }; + UINT Value; + } Flags; +} D3DKMT_UPDATEGPUVIRTUALADDRESS; + +typedef struct _D3DKMT_CREATECONTEXTVIRTUAL +{ + D3DKMT_HANDLE hDevice; // in: + UINT NodeOrdinal; // in: + UINT EngineAffinity; // in: + D3DDDI_CREATECONTEXTFLAGS Flags; // in: + D3DKMT_PTR(VOID*, pPrivateDriverData); // in: + UINT PrivateDriverDataSize; // in: + D3DKMT_CLIENTHINT ClientHint; // in: Hints which client is creating the context + D3DKMT_HANDLE hContext; // out: +} D3DKMT_CREATECONTEXTVIRTUAL; + +typedef struct _D3DKMT_SUBMITCOMMANDFLAGS +{ + UINT NullRendering : 1; // 0x00000001 + UINT PresentRedirected : 1; // 0x00000002 + UINT NoKmdAccess : 1; // 0x00000004 + UINT Reserved : 29; // 0xFFFFFFF8 +} D3DKMT_SUBMITCOMMANDFLAGS; + +typedef struct _D3DKMT_SUBMITCOMMAND +{ + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS Commands; + UINT CommandLength; + D3DKMT_SUBMITCOMMANDFLAGS Flags; + D3DKMT_ALIGN64 ULONGLONG PresentHistoryToken; // in: Present history token for redirected present calls + UINT BroadcastContextCount; + D3DKMT_HANDLE BroadcastContext[D3DDDI_MAX_BROADCAST_CONTEXT]; + D3DKMT_PTR(VOID*, pPrivateDriverData); + UINT PrivateDriverDataSize; + UINT NumPrimaries; + D3DKMT_HANDLE WrittenPrimaries[D3DDDI_MAX_WRITTEN_PRIMARIES]; + UINT NumHistoryBuffers; + D3DKMT_PTR(D3DKMT_HANDLE*, HistoryBufferArray); +} D3DKMT_SUBMITCOMMAND; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef struct _D3DKMT_SUBMITCOMMANDTOHWQUEUE +{ + D3DKMT_HANDLE hHwQueue; // in: Context queue to submit the command to. + + D3DKMT_ALIGN64 UINT64 HwQueueProgressFenceId; // in: Hardware queue progress fence value that will be signaled once the command is finished. + + D3DKMT_ALIGN64 D3DGPU_VIRTUAL_ADDRESS CommandBuffer;// in: GPU VA of the command buffer to be executed on the GPU. + UINT CommandLength; // in: Length in bytes of the command buffer. + + UINT PrivateDriverDataSize; // in: Size of private driver data in bytes. + + D3DKMT_PTR(_Field_size_bytes_(PrivateDriverDataSize) + VOID*, pPrivateDriverData); // in: Pointer to the private driver data. + + UINT NumPrimaries; // in: The number of primaries written by this command buffer. + + D3DKMT_PTR(_Field_size_ (NumPrimaries) + D3DKMT_HANDLE CONST*, WrittenPrimaries); // in: The array of primaries written by this command buffer. +} D3DKMT_SUBMITCOMMANDTOHWQUEUE; + +typedef struct _D3DKMT_SUBMITWAITFORSYNCOBJECTSTOHWQUEUE +{ + D3DKMT_HANDLE hHwQueue; // in: Context queue to submit the command to. + + UINT ObjectCount; // in: Number of objects to wait on. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const D3DKMT_HANDLE*, ObjectHandleArray); // in: Handles to monitored fence synchronization objects to wait on. + + D3DKMT_PTR(_Field_size_(ObjectCount) + const UINT64*, FenceValueArray); // in: monitored fence values to be waited. +} D3DKMT_SUBMITWAITFORSYNCOBJECTSTOHWQUEUE; + +typedef struct _D3DKMT_SUBMITSIGNALSYNCOBJECTSTOHWQUEUE +{ + D3DDDICB_SIGNALFLAGS Flags; // in: Specifies signal behavior. + + ULONG BroadcastHwQueueCount; // in: Specifies the number of hardware queues to broadcast this signal to. + + D3DKMT_PTR(_Field_size_(BroadcastHwQueueCount) + const D3DKMT_HANDLE*, BroadcastHwQueueArray); // in: Specifies hardware queue handles to broadcast to. ... 5677 lines suppressed ...
-
Justin Miller