759 lines
28 KiB
C
759 lines
28 KiB
C
/******************************Module*Header************************************\
|
|
*
|
|
* Module Name: d3dukmdt.h
|
|
*
|
|
* Content: Longhorn Display Driver Model (LDDM) user/kernel mode
|
|
* shared data type definitions.
|
|
*
|
|
* Copyright (c) 2003 Microsoft Corporation. All rights reserved.
|
|
\*******************************************************************************/
|
|
#ifndef _D3DUKMDT_H_
|
|
#define _D3DUKMDT_H_
|
|
|
|
#if !defined(_D3DKMDT_H) && \
|
|
!defined(_D3DKMTHK_H_) && \
|
|
!defined(_D3DUMDDI_H_) && \
|
|
!defined(__DXGKRNLETW_H__)
|
|
#error This header should not be included directly!
|
|
#endif
|
|
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4201) // anonymous unions warning
|
|
|
|
|
|
//
|
|
// WDDM DDI Interface Version
|
|
//
|
|
|
|
#define DXGKDDI_INTERFACE_VERSION_VISTA 0x1052
|
|
#define DXGKDDI_INTERFACE_VERSION_VISTA_SP1 0x1053
|
|
#define DXGKDDI_INTERFACE_VERSION_WIN7 0x2005
|
|
|
|
#if !defined(DXGKDDI_INTERFACE_VERSION)
|
|
#define DXGKDDI_INTERFACE_VERSION DXGKDDI_INTERFACE_VERSION_WIN7
|
|
#endif // !defined(DXGKDDI_INTERFACE_VERSION)
|
|
|
|
#define D3D_UMD_INTERFACE_VERSION_VISTA 0x000C
|
|
#define D3D_UMD_INTERFACE_VERSION_WIN7 0x2003
|
|
|
|
#if !defined(D3D_UMD_INTERFACE_VERSION)
|
|
#define D3D_UMD_INTERFACE_VERSION D3D_UMD_INTERFACE_VERSION_WIN7
|
|
#endif // !defined(D3D_UMD_INTERFACE_VERSION)
|
|
|
|
//
|
|
// 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 ULONGLONG D3DGPU_VIRTUAL_ADDRESS;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Purpose: Video present source unique identification number descriptor type
|
|
//
|
|
|
|
typedef UINT D3DDDI_VIDEO_PRESENT_SOURCE_ID;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Purpose: Video present source unique identification number descriptor type.
|
|
//
|
|
typedef UINT D3DDDI_VIDEO_PRESENT_TARGET_ID;
|
|
|
|
//
|
|
// DDI level handle that represents a kernel mode object (allocation, device, etc)
|
|
//
|
|
typedef UINT D3DKMT_HANDLE;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Purpose: Video present target mode fractional frequency descriptor type.
|
|
//
|
|
// Remarks: Fractional value used to represent vertical and horizontal frequencies of a video mode
|
|
// (i.e. VSync and HSync). Vertical frequencies are stored in Hz. Horizontal frequencies
|
|
// are stored in Hz.
|
|
// The dynamic range of this encoding format, given 10^-7 resolution is {0..(2^32 - 1) / 10^7},
|
|
// which translates to {0..428.4967296} [Hz] for vertical frequencies and {0..428.4967296} [Hz]
|
|
// for horizontal frequencies. This sub-microseconds precision range should be acceptable even
|
|
// for a pro-video application (error in one microsecond for video signal synchronization would
|
|
// imply a time drift with a cycle of 10^7/(60*60*24) = 115.741 days.
|
|
//
|
|
// If rational number with a finite fractional sequence, use denominator of form 10^(length of fractional sequence).
|
|
// If rational number without a finite fractional sequence, or a sequence exceeding the precision allowed by the
|
|
// dynamic range of the denominator, or an irrational number, use an appropriate ratio of integers which best
|
|
// represents the value.
|
|
//
|
|
typedef struct _D3DDDI_RATIONAL
|
|
{
|
|
UINT Numerator;
|
|
UINT Denominator;
|
|
} D3DDDI_RATIONAL;
|
|
|
|
typedef struct _D3DDDI_ALLOCATIONINFO
|
|
{
|
|
D3DKMT_HANDLE hAllocation; // out: Private driver data for allocation
|
|
CONST VOID* pSystemMem; // in: Pointer to pre-allocated sysmem
|
|
VOID* pPrivateDriverData; // in(out optional): Private data for each allocation
|
|
UINT PrivateDriverDataSize; // in: Size of the private data
|
|
D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPN source ID if this is a primary
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT Primary : 1; // 0x00000001
|
|
UINT Reserved :31; // 0xFFFFFFFE
|
|
};
|
|
UINT Value;
|
|
} Flags;
|
|
} D3DDDI_ALLOCATIONINFO;
|
|
|
|
#if ((DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) || \
|
|
(D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WIN7))
|
|
|
|
typedef struct _D3DDDI_ALLOCATIONINFO2
|
|
{
|
|
D3DKMT_HANDLE hAllocation; // out: Private driver data for allocation
|
|
CONST VOID* pSystemMem; // in: Pointer to pre-allocated sysmem
|
|
VOID* pPrivateDriverData; // in(out optional): Private data for each allocation
|
|
UINT PrivateDriverDataSize; // in: Size of the private data
|
|
D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPN source ID if this is a primary
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT Primary : 1; // 0x00000001
|
|
UINT Reserved :31; // 0xFFFFFFFE
|
|
};
|
|
UINT Value;
|
|
} Flags;
|
|
D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress; // out: GPU Virtual address of the allocation created.
|
|
ULONG_PTR Reserved[6]; // Reserved
|
|
} D3DDDI_ALLOCATIONINFO2;
|
|
|
|
#endif
|
|
|
|
typedef struct _D3DDDI_OPENALLOCATIONINFO
|
|
{
|
|
D3DKMT_HANDLE hAllocation; // in: Handle for this allocation in this process
|
|
CONST VOID* pPrivateDriverData; // in: Ptr to driver private buffer for this allocations
|
|
UINT PrivateDriverDataSize; // in: Size in bytes of driver private buffer for this allocations
|
|
} D3DDDI_OPENALLOCATIONINFO;
|
|
|
|
#if ((DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) || \
|
|
(D3D_UMD_INTERFACE_VERSION >= D3D_UMD_INTERFACE_VERSION_WIN7))
|
|
|
|
typedef struct _D3DDDI_OPENALLOCATIONINFO2
|
|
{
|
|
D3DKMT_HANDLE hAllocation; // in: Handle for this allocation in this process
|
|
CONST VOID* pPrivateDriverData; // in: Ptr to driver private buffer for this allocations
|
|
UINT PrivateDriverDataSize; // in: Size in bytes of driver private buffer for this allocations
|
|
D3DGPU_VIRTUAL_ADDRESS GpuVirtualAddress; // out: GPU Virtual address of the allocation opened.
|
|
ULONG_PTR Reserved[6]; // Reserved
|
|
} D3DDDI_OPENALLOCATIONINFO2;
|
|
|
|
#endif
|
|
|
|
typedef struct _D3DDDI_ALLOCATIONLIST
|
|
{
|
|
D3DKMT_HANDLE hAllocation;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT WriteOperation : 1; // 0x00000001
|
|
UINT DoNotRetireInstance : 1; // 0x00000002
|
|
UINT Reserved :30; // 0xFFFFFFFC
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDI_ALLOCATIONLIST;
|
|
|
|
typedef struct _D3DDDI_PATCHLOCATIONLIST
|
|
{
|
|
UINT AllocationIndex;
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT SlotId : 24; // 0x00FFFFFF
|
|
UINT Reserved : 8; // 0xFF000000
|
|
};
|
|
UINT Value;
|
|
};
|
|
UINT DriverId;
|
|
UINT AllocationOffset;
|
|
UINT PatchOffset;
|
|
UINT SplitOffset;
|
|
} D3DDDI_PATCHLOCATIONLIST;
|
|
|
|
typedef struct _D3DDDICB_LOCKFLAGS
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT ReadOnly : 1; // 0x00000001
|
|
UINT WriteOnly : 1; // 0x00000002
|
|
UINT DonotWait : 1; // 0x00000004
|
|
UINT IgnoreSync : 1; // 0x00000008
|
|
UINT LockEntire : 1; // 0x00000010
|
|
UINT DonotEvict : 1; // 0x00000020
|
|
UINT AcquireAperture : 1; // 0x00000040
|
|
UINT Discard : 1; // 0x00000080
|
|
UINT NoExistingReference : 1; // 0x00000100
|
|
UINT UseAlternateVA : 1; // 0x00000200
|
|
UINT IgnoreReadSync : 1; // 0x00000400
|
|
UINT Reserved :21; // 0xFFFFF800
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDICB_LOCKFLAGS;
|
|
|
|
typedef struct _D3DDDI_ESCAPEFLAGS
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT HardwareAccess : 1; // 0x00000001
|
|
UINT Reserved :31; // 0xFFFFFFFE
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDI_ESCAPEFLAGS;
|
|
|
|
typedef struct _D3DDDI_CREATECONTEXTFLAGS
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT NullRendering : 1; // 0x00000001
|
|
UINT Reserved : 31; // 0xFFFFFFFE
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDI_CREATECONTEXTFLAGS;
|
|
|
|
/* Formats
|
|
* Most of these names have the following convention:
|
|
* A = Alpha
|
|
* R = Red
|
|
* G = Green
|
|
* B = Blue
|
|
* X = Unused Bits
|
|
* P = Palette
|
|
* L = Luminance
|
|
* U = dU coordinate for BumpMap
|
|
* V = dV coordinate for BumpMap
|
|
* S = Stencil
|
|
* D = Depth (e.g. Z or W buffer)
|
|
* C = Computed from other channels (typically on certain read operations)
|
|
*
|
|
* Further, the order of the pieces are from MSB first; hence
|
|
* D3DFMT_A8L8 indicates that the high byte of this two byte
|
|
* format is alpha.
|
|
*
|
|
* D16 indicates:
|
|
* - An integer 16-bit value.
|
|
* - An app-lockable surface.
|
|
*
|
|
* All Depth/Stencil formats except D3DFMT_D16_LOCKABLE indicate:
|
|
* - no particular bit ordering per pixel, and
|
|
* - are not app lockable, and
|
|
* - the driver is allowed to consume more than the indicated
|
|
* number of bits per Depth channel (but not Stencil channel).
|
|
*/
|
|
#ifndef MAKEFOURCC
|
|
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
|
|
((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \
|
|
((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
|
|
#endif /* defined(MAKEFOURCC) */
|
|
|
|
|
|
typedef enum _D3DDDIFORMAT
|
|
{
|
|
|
|
D3DDDIFMT_UNKNOWN = 0,
|
|
|
|
D3DDDIFMT_R8G8B8 = 20,
|
|
D3DDDIFMT_A8R8G8B8 = 21,
|
|
D3DDDIFMT_X8R8G8B8 = 22,
|
|
D3DDDIFMT_R5G6B5 = 23,
|
|
D3DDDIFMT_X1R5G5B5 = 24,
|
|
D3DDDIFMT_A1R5G5B5 = 25,
|
|
D3DDDIFMT_A4R4G4B4 = 26,
|
|
D3DDDIFMT_R3G3B2 = 27,
|
|
D3DDDIFMT_A8 = 28,
|
|
D3DDDIFMT_A8R3G3B2 = 29,
|
|
D3DDDIFMT_X4R4G4B4 = 30,
|
|
D3DDDIFMT_A2B10G10R10 = 31,
|
|
D3DDDIFMT_A8B8G8R8 = 32,
|
|
D3DDDIFMT_X8B8G8R8 = 33,
|
|
D3DDDIFMT_G16R16 = 34,
|
|
D3DDDIFMT_A2R10G10B10 = 35,
|
|
D3DDDIFMT_A16B16G16R16 = 36,
|
|
|
|
D3DDDIFMT_A8P8 = 40,
|
|
D3DDDIFMT_P8 = 41,
|
|
|
|
D3DDDIFMT_L8 = 50,
|
|
D3DDDIFMT_A8L8 = 51,
|
|
D3DDDIFMT_A4L4 = 52,
|
|
|
|
D3DDDIFMT_V8U8 = 60,
|
|
D3DDDIFMT_L6V5U5 = 61,
|
|
D3DDDIFMT_X8L8V8U8 = 62,
|
|
D3DDDIFMT_Q8W8V8U8 = 63,
|
|
D3DDDIFMT_V16U16 = 64,
|
|
D3DDDIFMT_W11V11U10 = 65,
|
|
D3DDDIFMT_A2W10V10U10 = 67,
|
|
|
|
D3DDDIFMT_UYVY = MAKEFOURCC('U', 'Y', 'V', 'Y'),
|
|
D3DDDIFMT_R8G8_B8G8 = MAKEFOURCC('R', 'G', 'B', 'G'),
|
|
D3DDDIFMT_YUY2 = MAKEFOURCC('Y', 'U', 'Y', '2'),
|
|
D3DDDIFMT_G8R8_G8B8 = MAKEFOURCC('G', 'R', 'G', 'B'),
|
|
D3DDDIFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'),
|
|
D3DDDIFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'),
|
|
D3DDDIFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'),
|
|
D3DDDIFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'),
|
|
D3DDDIFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'),
|
|
|
|
D3DDDIFMT_D16_LOCKABLE = 70,
|
|
D3DDDIFMT_D32 = 71,
|
|
D3DDDIFMT_D15S1 = 73,
|
|
D3DDDIFMT_D24S8 = 75,
|
|
D3DDDIFMT_D24X8 = 77,
|
|
D3DDDIFMT_D24X4S4 = 79,
|
|
D3DDDIFMT_D16 = 80,
|
|
|
|
D3DDDIFMT_D32F_LOCKABLE = 82,
|
|
D3DDDIFMT_D24FS8 = 83,
|
|
|
|
D3DDDIFMT_D32_LOCKABLE = 84,
|
|
D3DDDIFMT_S8_LOCKABLE = 85,
|
|
|
|
D3DDDIFMT_S1D15 = 72,
|
|
D3DDDIFMT_S8D24 = 74,
|
|
D3DDDIFMT_X8D24 = 76,
|
|
D3DDDIFMT_X4S4D24 = 78,
|
|
|
|
D3DDDIFMT_L16 = 81,
|
|
|
|
D3DDDIFMT_VERTEXDATA =100,
|
|
D3DDDIFMT_INDEX16 =101,
|
|
D3DDDIFMT_INDEX32 =102,
|
|
|
|
D3DDDIFMT_Q16W16V16U16 =110,
|
|
|
|
D3DDDIFMT_MULTI2_ARGB8 = MAKEFOURCC('M','E','T','1'),
|
|
|
|
// Floating point surface formats
|
|
|
|
// s10e5 formats (16-bits per channel)
|
|
D3DDDIFMT_R16F = 111,
|
|
D3DDDIFMT_G16R16F = 112,
|
|
D3DDDIFMT_A16B16G16R16F = 113,
|
|
|
|
// IEEE s23e8 formats (32-bits per channel)
|
|
D3DDDIFMT_R32F = 114,
|
|
D3DDDIFMT_G32R32F = 115,
|
|
D3DDDIFMT_A32B32G32R32F = 116,
|
|
|
|
D3DDDIFMT_CxV8U8 = 117,
|
|
|
|
// Monochrome 1 bit per pixel format
|
|
D3DDDIFMT_A1 = 118,
|
|
|
|
// 2.8 biased fixed point
|
|
D3DDDIFMT_A2B10G10R10_XR_BIAS = 119,
|
|
|
|
// Decode compressed buffer formats
|
|
D3DDDIFMT_DXVACOMPBUFFER_BASE = 150,
|
|
D3DDDIFMT_PICTUREPARAMSDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+0, // 150
|
|
D3DDDIFMT_MACROBLOCKDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+1, // 151
|
|
D3DDDIFMT_RESIDUALDIFFERENCEDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+2, // 152
|
|
D3DDDIFMT_DEBLOCKINGDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+3, // 153
|
|
D3DDDIFMT_INVERSEQUANTIZATIONDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+4, // 154
|
|
D3DDDIFMT_SLICECONTROLDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+5, // 155
|
|
D3DDDIFMT_BITSTREAMDATA = D3DDDIFMT_DXVACOMPBUFFER_BASE+6, // 156
|
|
D3DDDIFMT_MOTIONVECTORBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE+7, // 157
|
|
D3DDDIFMT_FILMGRAINBUFFER = D3DDDIFMT_DXVACOMPBUFFER_BASE+8, // 158
|
|
D3DDDIFMT_DXVA_RESERVED9 = D3DDDIFMT_DXVACOMPBUFFER_BASE+9, // 159
|
|
D3DDDIFMT_DXVA_RESERVED10 = D3DDDIFMT_DXVACOMPBUFFER_BASE+10, // 160
|
|
D3DDDIFMT_DXVA_RESERVED11 = D3DDDIFMT_DXVACOMPBUFFER_BASE+11, // 161
|
|
D3DDDIFMT_DXVA_RESERVED12 = D3DDDIFMT_DXVACOMPBUFFER_BASE+12, // 162
|
|
D3DDDIFMT_DXVA_RESERVED13 = D3DDDIFMT_DXVACOMPBUFFER_BASE+13, // 163
|
|
D3DDDIFMT_DXVA_RESERVED14 = D3DDDIFMT_DXVACOMPBUFFER_BASE+14, // 164
|
|
D3DDDIFMT_DXVA_RESERVED15 = D3DDDIFMT_DXVACOMPBUFFER_BASE+15, // 165
|
|
D3DDDIFMT_DXVA_RESERVED16 = D3DDDIFMT_DXVACOMPBUFFER_BASE+16, // 166
|
|
D3DDDIFMT_DXVA_RESERVED17 = D3DDDIFMT_DXVACOMPBUFFER_BASE+17, // 167
|
|
D3DDDIFMT_DXVA_RESERVED18 = D3DDDIFMT_DXVACOMPBUFFER_BASE+18, // 168
|
|
D3DDDIFMT_DXVA_RESERVED19 = D3DDDIFMT_DXVACOMPBUFFER_BASE+19, // 169
|
|
D3DDDIFMT_DXVA_RESERVED20 = D3DDDIFMT_DXVACOMPBUFFER_BASE+20, // 170
|
|
D3DDDIFMT_DXVA_RESERVED21 = D3DDDIFMT_DXVACOMPBUFFER_BASE+21, // 171
|
|
D3DDDIFMT_DXVA_RESERVED22 = D3DDDIFMT_DXVACOMPBUFFER_BASE+22, // 172
|
|
D3DDDIFMT_DXVA_RESERVED23 = D3DDDIFMT_DXVACOMPBUFFER_BASE+23, // 173
|
|
D3DDDIFMT_DXVA_RESERVED24 = D3DDDIFMT_DXVACOMPBUFFER_BASE+24, // 174
|
|
D3DDDIFMT_DXVA_RESERVED25 = D3DDDIFMT_DXVACOMPBUFFER_BASE+25, // 175
|
|
D3DDDIFMT_DXVA_RESERVED26 = D3DDDIFMT_DXVACOMPBUFFER_BASE+26, // 176
|
|
D3DDDIFMT_DXVA_RESERVED27 = D3DDDIFMT_DXVACOMPBUFFER_BASE+27, // 177
|
|
D3DDDIFMT_DXVA_RESERVED28 = D3DDDIFMT_DXVACOMPBUFFER_BASE+28, // 178
|
|
D3DDDIFMT_DXVA_RESERVED29 = D3DDDIFMT_DXVACOMPBUFFER_BASE+29, // 179
|
|
D3DDDIFMT_DXVA_RESERVED30 = D3DDDIFMT_DXVACOMPBUFFER_BASE+30, // 180
|
|
D3DDDIFMT_DXVA_RESERVED31 = D3DDDIFMT_DXVACOMPBUFFER_BASE+31, // 181
|
|
D3DDDIFMT_DXVACOMPBUFFER_MAX = D3DDDIFMT_DXVA_RESERVED31,
|
|
|
|
D3DDDIFMT_BINARYBUFFER = 199,
|
|
|
|
D3DDDIFMT_FORCE_UINT =0x7fffffff
|
|
} D3DDDIFORMAT;
|
|
|
|
typedef struct _D3DDDIRECT
|
|
{
|
|
LONG left;
|
|
LONG top;
|
|
LONG right;
|
|
LONG bottom;
|
|
} D3DDDIRECT;
|
|
|
|
typedef struct _D3DDDI_KERNELOVERLAYINFO
|
|
{
|
|
D3DKMT_HANDLE hAllocation; // in: Allocation to be displayed
|
|
D3DDDIRECT DstRect; // in: Dest rect
|
|
D3DDDIRECT SrcRect; // in: Source rect
|
|
VOID* pPrivateDriverData; // in: Private driver data
|
|
UINT PrivateDriverDataSize; // in: Size of private driver data
|
|
} D3DDDI_KERNELOVERLAYINFO;
|
|
|
|
typedef enum _D3DDDI_GAMMARAMP_TYPE
|
|
{
|
|
D3DDDI_GAMMARAMP_UNINITIALIZED = 0,
|
|
D3DDDI_GAMMARAMP_DEFAULT = 1,
|
|
D3DDDI_GAMMARAMP_RGB256x3x16 = 2,
|
|
D3DDDI_GAMMARAMP_DXGI_1 = 3,
|
|
} D3DDDI_GAMMARAMP_TYPE;
|
|
|
|
typedef struct _D3DDDI_GAMMA_RAMP_RGB256x3x16
|
|
{
|
|
USHORT Red[256];
|
|
USHORT Green[256];
|
|
USHORT Blue[256];
|
|
} D3DDDI_GAMMA_RAMP_RGB256x3x16;
|
|
|
|
typedef struct D3DDDI_DXGI_RGB
|
|
{
|
|
float Red;
|
|
float Green;
|
|
float Blue;
|
|
} D3DDDI_DXGI_RGB;
|
|
|
|
typedef struct _D3DDDI_GAMMA_RAMP_DXGI_1
|
|
{
|
|
D3DDDI_DXGI_RGB Scale;
|
|
D3DDDI_DXGI_RGB Offset;
|
|
D3DDDI_DXGI_RGB GammaCurve[1025];
|
|
} D3DDDI_GAMMA_RAMP_DXGI_1;
|
|
|
|
|
|
// Used as a value for D3DDDI_VIDEO_PRESENT_SOURCE_ID and D3DDDI_VIDEO_PRESENT_TARGET_ID types to specify
|
|
// that the respective video present source/target ID hasn't been initialized.
|
|
#define D3DDDI_ID_UNINITIALIZED (UINT)(~0)
|
|
|
|
// TODO:[mmilirud] Define this as (UINT)(~1) to avoid collision with valid source ID equal to 0.
|
|
//
|
|
// Used as a value for D3DDDI_VIDEO_PRESENT_SOURCE_ID and D3DDDI_VIDEO_PRESENT_TARGET_ID types to specify
|
|
// that the respective video present source/target ID isn't applicable for the given execution context.
|
|
#define D3DDDI_ID_NOTAPPLICABLE (UINT)(0)
|
|
|
|
// Used as a value for D3DDDI_VIDEO_PRESENT_SOURCE_ID and D3DDDI_VIDEO_PRESENT_TARGET_ID types to specify
|
|
// that the respective video present source/target ID describes every VidPN source/target in question.
|
|
#define D3DDDI_ID_ALL (UINT)(~2)
|
|
|
|
//
|
|
// Hardcoded VidPnSource count
|
|
//
|
|
#define D3DKMDT_MAX_VIDPN_SOURCES_BITCOUNT 4
|
|
#define D3DKMDT_MAX_VIDPN_SOURCES (1 << D3DKMDT_MAX_VIDPN_SOURCES_BITCOUNT)
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Purpose: Multi-sampling method descriptor type.
|
|
//
|
|
// Remarks: Driver is free to partition its quality levels for a given multi-sampling method into as many
|
|
// increments as it likes, with the condition that each incremental step does noticably improve
|
|
// quality of the presented image.
|
|
//
|
|
typedef struct _D3DDDI_MULTISAMPLINGMETHOD
|
|
{
|
|
// Number of sub-pixels employed in this multi-sampling method (e.g. 2 for 2x and 8 for 8x multi-sampling)
|
|
UINT NumSamples;
|
|
|
|
// Upper bound on the quality range supported for this multi-sampling method. The range starts from 0
|
|
// and goes upto and including the reported maximum quality setting.
|
|
UINT NumQualityLevels;
|
|
}
|
|
D3DDDI_MULTISAMPLINGMETHOD;
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Purpose: Video signal scan line ordering descriptor type.
|
|
//
|
|
// Remarks: Scan-line ordering of the video mode, specifies whether each field contains the entire
|
|
// content of a frame, or only half of it (i.e. even/odd lines interchangeably).
|
|
// Note that while for standard interlaced modes, what field comes first can be inferred
|
|
// from the mode, specifying this characteristic explicitly with an enum both frees up the
|
|
// client from having to maintain mode-based look-up tables and is extensible for future
|
|
// standard modes not listed in the D3DKMDT_VIDEO_SIGNAL_STANDARD enum.
|
|
//
|
|
typedef enum _D3DDDI_VIDEO_SIGNAL_SCANLINE_ORDERING
|
|
{
|
|
D3DDDI_VSSLO_UNINITIALIZED = 0,
|
|
D3DDDI_VSSLO_PROGRESSIVE = 1,
|
|
D3DDDI_VSSLO_INTERLACED_UPPERFIELDFIRST = 2,
|
|
D3DDDI_VSSLO_INTERLACED_LOWERFIELDFIRST = 3,
|
|
D3DDDI_VSSLO_OTHER = 255
|
|
}
|
|
D3DDDI_VIDEO_SIGNAL_SCANLINE_ORDERING;
|
|
|
|
|
|
typedef enum D3DDDI_FLIPINTERVAL_TYPE
|
|
{
|
|
D3DDDI_FLIPINTERVAL_IMMEDIATE = 0,
|
|
D3DDDI_FLIPINTERVAL_ONE = 1,
|
|
D3DDDI_FLIPINTERVAL_TWO = 2,
|
|
D3DDDI_FLIPINTERVAL_THREE = 3,
|
|
D3DDDI_FLIPINTERVAL_FOUR = 4,
|
|
} D3DDDI_FLIPINTERVAL_TYPE;
|
|
|
|
|
|
typedef enum _D3DDDI_POOL
|
|
{
|
|
D3DDDIPOOL_SYSTEMMEM = 1,
|
|
D3DDDIPOOL_VIDEOMEMORY = 2,
|
|
D3DDDIPOOL_LOCALVIDMEM = 3,
|
|
D3DDDIPOOL_NONLOCALVIDMEM = 4,
|
|
} D3DDDI_POOL;
|
|
|
|
|
|
typedef enum _D3DDDIMULTISAMPLE_TYPE
|
|
{
|
|
D3DDDIMULTISAMPLE_NONE = 0,
|
|
D3DDDIMULTISAMPLE_NONMASKABLE = 1,
|
|
D3DDDIMULTISAMPLE_2_SAMPLES = 2,
|
|
D3DDDIMULTISAMPLE_3_SAMPLES = 3,
|
|
D3DDDIMULTISAMPLE_4_SAMPLES = 4,
|
|
D3DDDIMULTISAMPLE_5_SAMPLES = 5,
|
|
D3DDDIMULTISAMPLE_6_SAMPLES = 6,
|
|
D3DDDIMULTISAMPLE_7_SAMPLES = 7,
|
|
D3DDDIMULTISAMPLE_8_SAMPLES = 8,
|
|
D3DDDIMULTISAMPLE_9_SAMPLES = 9,
|
|
D3DDDIMULTISAMPLE_10_SAMPLES = 10,
|
|
D3DDDIMULTISAMPLE_11_SAMPLES = 11,
|
|
D3DDDIMULTISAMPLE_12_SAMPLES = 12,
|
|
D3DDDIMULTISAMPLE_13_SAMPLES = 13,
|
|
D3DDDIMULTISAMPLE_14_SAMPLES = 14,
|
|
D3DDDIMULTISAMPLE_15_SAMPLES = 15,
|
|
D3DDDIMULTISAMPLE_16_SAMPLES = 16,
|
|
|
|
D3DDDIMULTISAMPLE_FORCE_UINT = 0x7fffffff
|
|
} D3DDDIMULTISAMPLE_TYPE;
|
|
|
|
typedef struct _D3DDDI_RESOURCEFLAGS
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT RenderTarget : 1; // 0x00000001
|
|
UINT ZBuffer : 1; // 0x00000002
|
|
UINT Dynamic : 1; // 0x00000004
|
|
UINT HintStatic : 1; // 0x00000008
|
|
UINT AutogenMipmap : 1; // 0x00000010
|
|
UINT DMap : 1; // 0x00000020
|
|
UINT WriteOnly : 1; // 0x00000040
|
|
UINT NotLockable : 1; // 0x00000080
|
|
UINT Points : 1; // 0x00000100
|
|
UINT RtPatches : 1; // 0x00000200
|
|
UINT NPatches : 1; // 0x00000400
|
|
UINT SharedResource : 1; // 0x00000800
|
|
UINT DiscardRenderTarget : 1; // 0x00001000
|
|
UINT Video : 1; // 0x00002000
|
|
UINT CaptureBuffer : 1; // 0x00004000
|
|
UINT Primary : 1; // 0x00008000
|
|
UINT Texture : 1; // 0x00010000
|
|
UINT CubeMap : 1; // 0x00020000
|
|
UINT Volume : 1; // 0x00040000
|
|
UINT VertexBuffer : 1; // 0x00080000
|
|
UINT IndexBuffer : 1; // 0x00100000
|
|
UINT DecodeRenderTarget : 1; // 0x00200000
|
|
UINT DecodeCompressedBuffer : 1; // 0x00400000
|
|
UINT VideoProcessRenderTarget: 1; // 0x00800000
|
|
UINT CpuOptimized : 1; // 0x01000000
|
|
UINT MightDrawFromLocked : 1; // 0x02000000
|
|
UINT Overlay : 1; // 0x04000000
|
|
UINT MatchGdiPrimary : 1; // 0x08000000
|
|
UINT InterlacedRefresh : 1; // 0x10000000
|
|
UINT TextApi : 1; // 0x20000000
|
|
UINT RestrictedContent : 1; // 0x40000000
|
|
UINT RestrictSharedAccess : 1; // 0x80000000
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDI_RESOURCEFLAGS;
|
|
|
|
typedef struct _D3DDDI_SURFACEINFO
|
|
{
|
|
UINT Width; // in: For linear, surface and volume
|
|
UINT Height; // in: For surface and volume
|
|
UINT Depth; // in: For volume
|
|
CONST VOID* pSysMem;
|
|
UINT SysMemPitch;
|
|
UINT SysMemSlicePitch;
|
|
} D3DDDI_SURFACEINFO;
|
|
|
|
typedef enum _D3DDDI_ROTATION
|
|
{
|
|
D3DDDI_ROTATION_IDENTITY = 1, // No rotation.
|
|
D3DDDI_ROTATION_90 = 2, // Rotated 90 degrees.
|
|
D3DDDI_ROTATION_180 = 3, // Rotated 180 degrees.
|
|
D3DDDI_ROTATION_270 = 4 // Rotated 270 degrees.
|
|
} D3DDDI_ROTATION;
|
|
|
|
typedef enum D3DDDI_SCANLINEORDERING
|
|
{
|
|
D3DDDI_SCANLINEORDERING_UNKNOWN = 0,
|
|
D3DDDI_SCANLINEORDERING_PROGRESSIVE = 1,
|
|
D3DDDI_SCANLINEORDERING_INTERLACED = 2,
|
|
} D3DDDI_SCANLINEORDERING;
|
|
|
|
typedef struct _D3DDDIARG_CREATERESOURCE
|
|
{
|
|
D3DDDIFORMAT Format;
|
|
D3DDDI_POOL Pool;
|
|
D3DDDIMULTISAMPLE_TYPE MultisampleType;
|
|
UINT MultisampleQuality;
|
|
CONST D3DDDI_SURFACEINFO* pSurfList; // in: List of sub resource objects to create
|
|
UINT SurfCount; // in: Number of sub resource objects
|
|
UINT MipLevels;
|
|
UINT Fvf; // in: FVF format for vertex buffers
|
|
D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; // in: VidPnSourceId on which the primary surface is created
|
|
D3DDDI_RATIONAL RefreshRate; // in: RefreshRate that this primary surface is to be used with
|
|
HANDLE hResource; // in/out: D3D runtime handle/UM driver handle
|
|
D3DDDI_RESOURCEFLAGS Flags;
|
|
D3DDDI_ROTATION Rotation; // in: The orientation of the resource. (0, 90, 180, 270)
|
|
} D3DDDIARG_CREATERESOURCE;
|
|
|
|
typedef struct _D3DDDICB_SIGNALFLAGS
|
|
{
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
UINT SignalAtSubmission : 1;
|
|
UINT Reserved : 31;
|
|
};
|
|
UINT Value;
|
|
};
|
|
} D3DDDICB_SIGNALFLAGS;
|
|
|
|
#define D3DDDI_MAX_OBJECT_WAITED_ON 32
|
|
#define D3DDDI_MAX_OBJECT_SIGNALED 32
|
|
|
|
typedef enum _D3DDDI_SYNCHRONIZATIONOBJECT_TYPE
|
|
{
|
|
D3DDDI_SYNCHRONIZATION_MUTEX = 1,
|
|
D3DDDI_SEMAPHORE = 2,
|
|
D3DDDI_FENCE = 3,
|
|
D3DDDI_CPU_NOTIFICATION = 4,
|
|
} D3DDDI_SYNCHRONIZATIONOBJECT_TYPE;
|
|
|
|
typedef struct _D3DDDI_SYNCHRONIZATIONOBJECTINFO
|
|
{
|
|
D3DDDI_SYNCHRONIZATIONOBJECT_TYPE Type; // in: Type of synchronization object to create.
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
BOOL InitialState; // in: Initial state of a synchronization mutex.
|
|
} SynchronizationMutex;
|
|
|
|
struct
|
|
{
|
|
UINT MaxCount; // in: Max count of the semaphore.
|
|
UINT InitialCount; // in: Initial count of the semaphore.
|
|
} Semaphore;
|
|
|
|
|
|
struct
|
|
{
|
|
UINT Reserved[16]; // Reserved for future use.
|
|
} Reserved;
|
|
};
|
|
} D3DDDI_SYNCHRONIZATIONOBJECTINFO;
|
|
|
|
typedef struct _D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS
|
|
{
|
|
UINT Shared : 1;
|
|
UINT Reserved : 31;
|
|
} D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS;
|
|
|
|
typedef struct _D3DDDI_SYNCHRONIZATIONOBJECTINFO2
|
|
{
|
|
D3DDDI_SYNCHRONIZATIONOBJECT_TYPE Type; // in: Type of synchronization object to create.
|
|
D3DDDI_SYNCHRONIZATIONOBJECT_FLAGS Flags; // in: flags.
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
BOOL InitialState; // in: Initial state of a synchronization mutex.
|
|
} SynchronizationMutex;
|
|
|
|
struct
|
|
{
|
|
UINT MaxCount; // in: Max count of the semaphore.
|
|
UINT InitialCount; // in: Initial count of the semaphore.
|
|
} Semaphore;
|
|
|
|
struct
|
|
{
|
|
UINT64 FenceValue; // in: inital fence value.
|
|
} Fence;
|
|
|
|
struct
|
|
{
|
|
HANDLE Event; // in: Handle to the event
|
|
} CPUNotification;
|
|
|
|
|
|
struct
|
|
{
|
|
UINT64 Reserved[8]; // Reserved for future use.
|
|
} Reserved;
|
|
};
|
|
|
|
D3DKMT_HANDLE SharedHandle; // out: global shared handle (when requested to be shared)
|
|
|
|
} D3DDDI_SYNCHRONIZATIONOBJECTINFO2;
|
|
|
|
//
|
|
// Defines the maximum number of context a particular command buffer can
|
|
// be broadcast to.
|
|
//
|
|
#define D3DDDI_MAX_BROADCAST_CONTEXT 64
|
|
|
|
//
|
|
// Allocation priorities.
|
|
//
|
|
#define D3DDDI_ALLOCATIONPRIORITY_MINIMUM 0x28000000
|
|
#define D3DDDI_ALLOCATIONPRIORITY_LOW 0x50000000
|
|
#define D3DDDI_ALLOCATIONPRIORITY_NORMAL 0x78000000
|
|
#define D3DDDI_ALLOCATIONPRIORITY_HIGH 0xa0000000
|
|
#define D3DDDI_ALLOCATIONPRIORITY_MAXIMUM 0xc8000000
|
|
|
|
#endif // (NTDDI_VERSION >= NTDDI_LONGHORN) || defined(D3DKMDT_SPECIAL_MULTIPLATFORM_TOOL)
|
|
|
|
#pragma warning(pop)
|
|
|
|
#endif /* _D3DUKMDT_H_ */
|
|
|
|
|