Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-07 18:30:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

[SDK][WIN32SS] Prepare d3dkmt functions up to Windows Vista (#5612)

Browse source 
Prepare the d3dkmt APIs up to Vista RTM
Build the skeleton needed for having userspace components talk to a WDDM KMD driver

Co-authored-by: Mark Jansen <mark.jansen@reactos.org>
Co-authored-by: Hermès BÉLUSCA - MAÏTO <hermes.belusca-maito@reactos.org>
This commit is contained in:
Justin Miller 2025-03-24 21:21:09 +01:00 committed by GitHub
parent 818842de06
commit e7a9e7ca3d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 1987 additions and 16 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

241
sdk/include/ddk/d3dkmddi.h Normal file
View file

@ -0,0 +1,241 @@
/*
* PROJECT: ReactOS Display Driver Model
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: Header file for WDDM style DDIs
* COPYRIGHT: Copyright 2024 Justin Miller <justin.miller@reactos.org>
*/
#ifndef _D3DKMDDI_H_
#define _D3DKMDDI_H_
#include <d3dkmdt.h>
typedef struct _DXGK_ALLOCATIONINFOFLAGS_WDDM2_0
{
union
{
struct
{
UINT CpuVisible : 1;
UINT PermanentSysMem : 1;
UINT Cached : 1;
UINT Protected : 1;
UINT ExistingSysMem : 1;
UINT ExistingKernelSysMem : 1;
UINT FromEndOfSegment : 1;
UINT DisableLargePageMapping : 1;
UINT Overlay : 1;
UINT Capture : 1;
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1)
UINT CreateInVpr : 1;
#else
UINT Reserved00 : 1;
#endif
UINT DXGK_ALLOC_RESERVED17 : 1;
UINT Reserved02 : 1;
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9)
UINT MapApertureCpuVisible : 1;
#else
UINT Reserved03 : 1;
#endif
UINT HistoryBuffer : 1;
UINT AccessedPhysically : 1;
UINT ExplicitResidencyNotification : 1;
UINT HardwareProtected : 1;
UINT CpuVisibleOnDemand : 1;
UINT DXGK_ALLOC_RESERVED16 : 1;
UINT DXGK_ALLOC_RESERVED15 : 1;
UINT DXGK_ALLOC_RESERVED14 : 1;
UINT DXGK_ALLOC_RESERVED13 : 1;
UINT DXGK_ALLOC_RESERVED12 : 1;
UINT DXGK_ALLOC_RESERVED11 : 1;
UINT DXGK_ALLOC_RESERVED10 : 1;
UINT DXGK_ALLOC_RESERVED9 : 1;
UINT DXGK_ALLOC_RESERVED4 : 1;
UINT DXGK_ALLOC_RESERVED3 : 1;
UINT DXGK_ALLOC_RESERVED2 : 1;
UINT DXGK_ALLOC_RESERVED1 : 1;
UINT DXGK_ALLOC_RESERVED0 : 1;
};
UINT Value;
};
} DXGK_ALLOCATIONINFOFLAGS_WDDM2_0;
C_ASSERT(sizeof(DXGK_ALLOCATIONINFOFLAGS_WDDM2_0) == 0x4);
typedef struct _DXGK_SEGMENTPREFERENCE
{
union
{
struct
{
UINT SegmentId0 : 5;
UINT Direction0 : 1;
UINT SegmentId1 : 5;
UINT Direction1 : 1;
UINT SegmentId2 : 5;
UINT Direction2 : 1;
UINT SegmentId3 : 5;
UINT Direction3 : 1;
UINT SegmentId4 : 5;
UINT Direction4 : 1;
UINT Reserved : 2;
};
UINT Value;
};
} DXGK_SEGMENTPREFERENCE, *PDXGK_SEGMENTPREFERENCE;
C_ASSERT(sizeof(DXGK_SEGMENTPREFERENCE) == 0x4);
typedef struct _DXGK_SEGMENTBANKPREFERENCE
{
union
{
struct
{
UINT Bank0 : 7;
UINT Direction0 : 1;
UINT Bank1 : 7;
UINT Direction1 : 1;
UINT Bank2 : 7;
UINT Direction2 : 1;
UINT Bank3 : 7;
UINT Direction3 : 1;
};
UINT Value;
};
} DXGK_SEGMENTBANKPREFERENCE;
C_ASSERT(sizeof(DXGK_SEGMENTBANKPREFERENCE) == 0x4);
typedef struct _DXGK_ALLOCATIONINFOFLAGS
{
union
{
struct
{
UINT CpuVisible : 1;
UINT PermanentSysMem : 1;
UINT Cached : 1;
UINT Protected : 1;
UINT ExistingSysMem : 1;
UINT ExistingKernelSysMem : 1;
UINT FromEndOfSegment : 1;
UINT Swizzled : 1;
UINT Overlay : 1;
UINT Capture : 1;
UINT UseAlternateVA : 1;
UINT SynchronousPaging : 1;
UINT LinkMirrored : 1;
UINT LinkInstanced : 1;
UINT HistoryBuffer : 1;
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0)
UINT AccessedPhysically : 1;
UINT ExplicitResidencyNotification : 1;
UINT HardwareProtected : 1;
UINT CpuVisibleOnDemand : 1;
#else
UINT Reserved : 4;
#endif
UINT DXGK_ALLOC_RESERVED16 : 1;
UINT DXGK_ALLOC_RESERVED15 : 1;
UINT DXGK_ALLOC_RESERVED14 : 1;
UINT DXGK_ALLOC_RESERVED13 : 1;
UINT DXGK_ALLOC_RESERVED12 : 1;
UINT DXGK_ALLOC_RESERVED11 : 1;
UINT DXGK_ALLOC_RESERVED10 : 1;
UINT DXGK_ALLOC_RESERVED9 : 1;
UINT DXGK_ALLOC_RESERVED4 : 1;
UINT DXGK_ALLOC_RESERVED3 : 1;
UINT DXGK_ALLOC_RESERVED2 : 1;
UINT DXGK_ALLOC_RESERVED1 : 1;
UINT DXGK_ALLOC_RESERVED0 : 1;
};
UINT Value;
};
} DXGK_ALLOCATIONINFOFLAGS;
C_ASSERT(sizeof(DXGK_ALLOCATIONINFOFLAGS) == 0x4);
typedef struct _DXGK_ALLOCATIONUSAGEINFO1
{
union
{
struct
{
UINT PrivateFormat : 1;
UINT Swizzled : 1;
UINT MipMap : 1;
UINT Cube : 1;
UINT Volume : 1;
UINT Vertex : 1;
UINT Index : 1;
UINT Reserved : 25;
};
UINT Value;
} Flags;
union
{
D3DDDIFORMAT Format;
UINT PrivateFormat;
};
UINT SwizzledFormat;
UINT ByteOffset;
UINT Width;
UINT Height;
UINT Pitch;
UINT Depth;
UINT SlicePitch;
} DXGK_ALLOCATIONUSAGEINFO1;
C_ASSERT(sizeof(DXGK_ALLOCATIONUSAGEINFO1) == 0x24);
typedef struct _DXGK_ALLOCATIONUSAGEHINT
{
UINT Version;
DXGK_ALLOCATIONUSAGEINFO1 v1;
} DXGK_ALLOCATIONUSAGEHINT;
C_ASSERT(sizeof(DXGK_ALLOCATIONUSAGEHINT) == 0x28);
typedef struct _DXGK_ALLOCATIONINFO
{
VOID* pPrivateDriverData;
UINT PrivateDriverDataSize;
UINT Alignment;
SIZE_T Size;
SIZE_T PitchAlignedSize;
DXGK_SEGMENTBANKPREFERENCE HintedBank;
DXGK_SEGMENTPREFERENCE PreferredSegment;
UINT SupportedReadSegmentSet;
UINT SupportedWriteSegmentSet;
UINT EvictionSegmentSet;
union
{
UINT MaximumRenamingListLength;
UINT PhysicalAdapterIndex;
};
HANDLE hAllocation;
union
{
DXGK_ALLOCATIONINFOFLAGS Flags;
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0)
DXGK_ALLOCATIONINFOFLAGS_WDDM2_0 FlagsWddm2;
#endif
};
DXGK_ALLOCATIONUSAGEHINT* pAllocationUsageHint;
UINT AllocationPriority;
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0)
DXGK_ALLOCATIONINFOFLAGS2 Flags2;
#endif
} DXGK_ALLOCATIONINFO;
#ifdef _WIN64
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0)
C_ASSERT(sizeof(DXGK_ALLOCATIONINFO) == 0x5C);
#else
C_ASSERT(sizeof(DXGK_ALLOCATIONINFO) == 0x58);
#endif
#else
#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_0)
C_ASSERT(sizeof(DXGK_ALLOCATIONINFO) == 0x40);
#else
C_ASSERT(sizeof(DXGK_ALLOCATIONINFO) == 0x3C);
#endif
#endif
#endif // _D3DKMDDI_H_

388
sdk/include/psdk/ntgdi.h
View file

@ -3923,4 +3923,392 @@ NtGdiGetCurrentDpiInfo(
#endif /* PRIVATE_DWM_INTERFACE */
/* ReactOS Display Driver Model */
__kernel_entry
W32KAPI
BOOLEAN
APIENTRY
NtGdiDdDDICheckExclusiveOwnership(VOID);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICreateAllocation(
_Inout_ D3DKMT_CREATEALLOCATION* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICheckMonitorPowerState(
_In_ const D3DKMT_CHECKMONITORPOWERSTATE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICheckOcclusion(
_In_ const D3DKMT_CHECKOCCLUSION* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICloseAdapter(
_In_ const D3DKMT_CLOSEADAPTER* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
WINAPI
NtGdiDdDDICreateContext(
_Inout_ D3DKMT_CREATECONTEXT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICreateDevice(
_Inout_ D3DKMT_CREATEDEVICE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICreateOverlay(
_Inout_ D3DKMT_CREATEOVERLAY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDICreateSynchronizationObject(
_Inout_ D3DKMT_CREATESYNCHRONIZATIONOBJECT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForVerticalBlankEvent(
_In_ const D3DKMT_WAITFORVERTICALBLANKEVENT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForIdle(
_In_ const D3DKMT_WAITFORIDLE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIUpdateOverlay(
_In_ const D3DKMT_UPDATEOVERLAY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
WINAPI
NtGdiDdDDIUnlock(
_In_ const D3DKMT_UNLOCK* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyAllocation(
_In_ const D3DKMT_DESTROYALLOCATION* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyContext(
_In_ const D3DKMT_DESTROYCONTEXT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyDevice(
_In_ const D3DKMT_DESTROYDEVICE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyOverlay(
_In_ const D3DKMT_DESTROYOVERLAY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIDestroySynchronizationObject(
_In_ const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIEscape(
_In_ const D3DKMT_ESCAPE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIFlipOverlay(
_In_ const D3DKMT_FLIPOVERLAY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetContextSchedulingPriority(
_Inout_ D3DKMT_GETCONTEXTSCHEDULINGPRIORITY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetDeviceState(
_Inout_ D3DKMT_GETDEVICESTATE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetDisplayModeList(
_Inout_ D3DKMT_GETDISPLAYMODELIST* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetMultisampleMethodList(
_Inout_ D3DKMT_GETMULTISAMPLEMETHODLIST* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetPresentHistory(
_Inout_ D3DKMT_GETPRESENTHISTORY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetProcessSchedulingPriorityClass(
_In_ HANDLE unnamedParam1,
_Out_ D3DKMT_SCHEDULINGPRIORITYCLASS *unnamedParam2);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetRuntimeData(
_In_ const D3DKMT_GETRUNTIMEDATA* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetScanLine(
_In_ D3DKMT_GETSCANLINE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIGetSharedPrimaryHandle(
_Inout_ D3DKMT_GETSHAREDPRIMARYHANDLE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIInvalidateActiveVidPn(
_In_ const D3DKMT_INVALIDATEACTIVEVIDPN* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDILock(
_Inout_ D3DKMT_LOCK* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromDeviceName(
_Inout_ D3DKMT_OPENADAPTERFROMDEVICENAME* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromGdiDisplayName(
_Inout_ D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromHdc(
_Inout_ D3DKMT_OPENADAPTERFROMHDC* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIOpenResource(
_Inout_ D3DKMT_OPENRESOURCE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIPollDisplayChildren(
_In_ const D3DKMT_POLLDISPLAYCHILDREN* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIPresent(
_In_ D3DKMT_PRESENT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIQueryAdapterInfo(
_Inout_ const D3DKMT_QUERYADAPTERINFO* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIQueryAllocationResidency(
_In_ const D3DKMT_QUERYALLOCATIONRESIDENCY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIQueryResourceInfo(
_Inout_ D3DKMT_QUERYRESOURCEINFO* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIQueryStatistics(
_Inout_ const D3DKMT_QUERYSTATISTICS* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIReleaseProcessVidPnSourceOwners(
_In_ HANDLE unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIRender(
_In_ D3DKMT_RENDER* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetAllocationPriority(
_In_ const D3DKMT_SETALLOCATIONPRIORITY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetContextSchedulingPriority(
_In_ const D3DKMT_SETCONTEXTSCHEDULINGPRIORITY* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetDisplayMode(
_In_ const D3DKMT_SETDISPLAYMODE* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetDisplayPrivateDriverFormat(
_In_ const D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetGammaRamp(
_In_ const D3DKMT_SETGAMMARAMP* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetProcessSchedulingPriorityClass(
_In_ HANDLE unnamedParam1,
_In_ D3DKMT_SCHEDULINGPRIORITYCLASS unnamedParam2);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetQueuedLimit(
_Inout_ const D3DKMT_SETQUEUEDLIMIT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISetVidPnSourceOwner(
_In_ const D3DKMT_SETVIDPNSOURCEOWNER* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISharedPrimaryLockNotification(
_In_ const D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISharedPrimaryUnLockNotification(
_In_ const D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDISignalSynchronizationObject(
_In_ const D3DKMT_SIGNALSYNCHRONIZATIONOBJECT* unnamedParam1);
__kernel_entry
W32KAPI
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForSynchronizationObject(
_In_ const D3DKMT_WAITFORSYNCHRONIZATIONOBJECT* unnamedParam1);
#endif /* _NTGDI_ */

410
sdk/include/reactos/rddm/rxgkinterface.h Normal file
View file

@ -0,0 +1,410 @@
/*
* PROJECT: ReactOS Display Driver Model
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: Dxgkrnl callbacks header
* COPYRIGHT: Copyright 2023 Justin Miller <justin.miller@reactos.org>
*/
#pragma once
#include <d3dkmddi.h>
/*
* Every structure in here is shared across two or more modules and doesn't currently
* match a single Windows version/update.
*
* These structures DO have variants in Windows, I just would like to track what
* we don't match 1:1 yet. Or haven't bother attempting to do so.
*/
/* REACTOS_WIN32K_DXGKRNL_INTERFACE function Pointers: */
typedef
NTSTATUS
DXGADAPTER_CREATEALLOCATION(_Inout_ D3DKMT_CREATEALLOCATION* unnamedParam1);
typedef DXGADAPTER_CREATEALLOCATION *PDXGADAPTER_CREATEALLOCATION;
typedef
NTSTATUS
DXGADAPTER_CHECKMONITORPOWERSTATE(_In_ const D3DKMT_CHECKMONITORPOWERSTATE* unnamedParam1);
typedef DXGADAPTER_CHECKMONITORPOWERSTATE *PDXGADAPTER_CHECKMONITORPOWERSTATE;
typedef
NTSTATUS
DXGADAPTER_CHECKOCCLUSION(_In_ const D3DKMT_CHECKOCCLUSION* unnamedParam1);
typedef DXGADAPTER_CHECKOCCLUSION *PDXGADAPTER_CHECKOCCLUSION;
typedef
NTSTATUS
DXGADAPTER_CLOSEADAPTER(_In_ const D3DKMT_CLOSEADAPTER* unnamedParam1);
typedef DXGADAPTER_CLOSEADAPTER *PDXGADAPTER_CLOSEADAPTER;
typedef
NTSTATUS
DXGADAPTER_CREATECONTEXT(_Inout_ const D3DKMT_CREATECONTEXT* unnamedParam1);
typedef DXGADAPTER_CREATECONTEXT *PDXGADAPTER_CREATECONTEXT;
typedef
NTSTATUS
DXGADAPTER_CREATEDEVICE(_Inout_ const D3DKMT_CREATEDEVICE* unnamedParam1);
typedef DXGADAPTER_CREATEDEVICE *PDXGADAPTER_CREATEDEVICE;
typedef
NTSTATUS
DXGADAPTER_CREATEOVERLAY(_Inout_ const D3DKMT_CREATEOVERLAY* unnamedParam1);
typedef DXGADAPTER_CREATEOVERLAY *PDXGADAPTER_CREATEOVERLAY;
typedef
NTSTATUS
DXGADAPTER_CREATESYNCHRONIZATIONOBJECT(_Inout_ const D3DKMT_CREATESYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_CREATESYNCHRONIZATIONOBJECT *PDXGADAPTER_CREATESYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_DESTROYALLOCATION(_In_ const D3DKMT_DESTROYALLOCATION* unnamedParam1);
typedef DXGADAPTER_DESTROYALLOCATION *PDXGADAPTER_DESTROYALLOCATION;
typedef
NTSTATUS
DXGADAPTER_DESTROYCONTEXT(_In_ const D3DKMT_DESTROYCONTEXT* unnamedParam1);
typedef DXGADAPTER_DESTROYCONTEXT *PDXGADAPTER_DESTROYCONTEXT;
typedef
NTSTATUS
DXGADAPTER_DESTROYDEVICE(_In_ const D3DKMT_DESTROYDEVICE* unnamedParam1);
typedef DXGADAPTER_DESTROYDEVICE *PDXGADAPTER_DESTROYDEVICE;
typedef
NTSTATUS
DXGADAPTER_DESTROYOVERLAY(_In_ const D3DKMT_DESTROYOVERLAY* unnamedParam1);
typedef DXGADAPTER_DESTROYOVERLAY *PDXGADAPTER_DESTROYOVERLAY;
typedef
NTSTATUS
DXGADAPTER_DESTROYSYNCHRONIZATIONOBJECT(_In_ const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_DESTROYSYNCHRONIZATIONOBJECT *PDXGADAPTER_DESTROYSYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_ESCAPE(_In_ const D3DKMT_ESCAPE* unnamedParam1);
typedef DXGADAPTER_ESCAPE *PDXGADAPTER_ESCAPE;
typedef
NTSTATUS
DXGADAPTER_FLIPOVERLAY(_In_ const D3DKMT_FLIPOVERLAY* unnamedParam1);
typedef DXGADAPTER_FLIPOVERLAY *PDXGADAPTER_FLIPOVERLAY;
typedef
NTSTATUS
DXGADAPTER_GETCONTEXTSCHEDULINGPRIORITY(_Inout_ const D3DKMT_GETCONTEXTSCHEDULINGPRIORITY* unnamedParam1);
typedef DXGADAPTER_GETCONTEXTSCHEDULINGPRIORITY *PDXGADAPTER_GETCONTEXTSCHEDULINGPRIORITY;
typedef
NTSTATUS
DXGADAPTER_GETDEVICESTATE(_Inout_ D3DKMT_GETDEVICESTATE* unnamedParam1);
typedef DXGADAPTER_GETDEVICESTATE *PDXGADAPTER_GETDEVICESTATE;
typedef
NTSTATUS
DXGADAPTER_GETDISPLAYMODELIST(_Inout_ D3DKMT_GETDISPLAYMODELIST* unnamedParam1);
typedef DXGADAPTER_GETDISPLAYMODELIST *PDXGADAPTER_GETDISPLAYMODELIST;
typedef
NTSTATUS
DXGADAPTER_GETMULTISAMPLEMETHODLIST(_Inout_ D3DKMT_GETMULTISAMPLEMETHODLIST* unnamedParam1);
typedef DXGADAPTER_GETMULTISAMPLEMETHODLIST *PDXGADAPTER_GETMULTISAMPLEMETHODLIST;
typedef
NTSTATUS
DXGADAPTER_GETRUNTIMEDATA(_Inout_ const D3DKMT_GETRUNTIMEDATA* unnamedParam1);
typedef DXGADAPTER_GETRUNTIMEDATA *PDXGADAPTER_GETRUNTIMEDATA;
typedef
NTSTATUS
DXGADAPTER_GETSCANLINE(_Inout_ D3DKMT_GETSCANLINE* unnamedParam1);
typedef DXGADAPTER_GETSCANLINE *PDXGADAPTER_GETSCANLINE;
typedef
NTSTATUS
DXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT(_In_ const D3DKMT_SIGNALSYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT *PDXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_WAITFORVERTICALBLANKEVENT(_In_ const D3DKMT_WAITFORVERTICALBLANKEVENT* unnamedParam1);
typedef DXGADAPTER_WAITFORVERTICALBLANKEVENT *PDXGADAPTER_WAITFORVERTICALBLANKEVENT;
typedef
NTSTATUS
DXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT(_In_ const D3DKMT_WAITFORSYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT *PDXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_SETVIDPNSOURCEOWNER(_In_ const D3DKMT_SETVIDPNSOURCEOWNER* unnamedParam1);
typedef DXGADAPTER_SETVIDPNSOURCEOWNER *PDXGADAPTER_SETVIDPNSOURCEOWNER;
typedef
NTSTATUS
DXGADAPTER_WAITFORIDLE(_In_ const D3DKMT_WAITFORIDLE* unnamedParam1);
typedef DXGADAPTER_WAITFORIDLE *PDXGADAPTER_WAITFORIDLE;
typedef
NTSTATUS
DXGADAPTER_UPDATEOVERLAY(_In_ const D3DKMT_UPDATEOVERLAY* unnamedParam1);
typedef DXGADAPTER_UPDATEOVERLAY *PDXGADAPTER_UPDATEOVERLAY;
typedef
NTSTATUS
DXGADAPTER_SETQUEUEDLIMIT(_In_ const D3DKMT_SETQUEUEDLIMIT* unnamedParam1);
typedef DXGADAPTER_SETQUEUEDLIMIT *PDXGADAPTER_SETQUEUEDLIMIT;
typedef
NTSTATUS
DXGADAPTER_SETGAMMARAMP(_In_ const D3DKMT_SETGAMMARAMP* unnamedParam1);
typedef DXGADAPTER_SETGAMMARAMP *PDXGADAPTER_SETGAMMARAMP;
typedef
NTSTATUS
DXGADAPTER_SETDISPLAYMODE(_In_ const D3DKMT_SETDISPLAYMODE* unnamedParam1);
typedef DXGADAPTER_SETDISPLAYMODE *PDXGADAPTER_SETDISPLAYMODE;
typedef
NTSTATUS
DXGADAPTER_SETDISPLAYPRIVATEDRIVERFORMAT(_In_ const D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT* unnamedParam1);
typedef DXGADAPTER_SETDISPLAYPRIVATEDRIVERFORMAT *PDXGADAPTER_SETDISPLAYPRIVATEDRIVERFORMAT;
typedef
NTSTATUS
DXGADAPTER_SETGAMMARAMP(_In_ const D3DKMT_SETGAMMARAMP* unnamedParam1);
typedef DXGADAPTER_SETGAMMARAMP *PDXGADAPTER_SETGAMMARAMP;
typedef
NTSTATUS
DXGADAPTER_SETQUEUEDLIMIT(_In_ const D3DKMT_SETQUEUEDLIMIT* unnamedParam1);
typedef DXGADAPTER_SETQUEUEDLIMIT *PDXGADAPTER_SETQUEUEDLIMIT;
typedef
NTSTATUS
DXGADAPTER_SETVIDPNSOURCEOWNER(_In_ const D3DKMT_SETVIDPNSOURCEOWNER* unnamedParam1);
typedef DXGADAPTER_SETVIDPNSOURCEOWNER *PDXGADAPTER_SETVIDPNSOURCEOWNER;
typedef
NTSTATUS
DXGADAPTER_UNLOCK(_In_ const D3DKMT_UNLOCK* unnamedParam1);
typedef DXGADAPTER_UNLOCK *PDXGADAPTER_UNLOCK;
typedef
NTSTATUS
DXGADAPTER_UPDATEOVERLAY(_In_ const D3DKMT_UPDATEOVERLAY* unnamedParam1);
typedef DXGADAPTER_UPDATEOVERLAY *PDXGADAPTER_UPDATEOVERLAY;
typedef
NTSTATUS
DXGADAPTER_WAITFORIDLE(_In_ const D3DKMT_WAITFORIDLE* unnamedParam1);
typedef DXGADAPTER_WAITFORIDLE *PDXGADAPTER_WAITFORIDLE;
typedef
NTSTATUS
DXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT(_In_ const D3DKMT_WAITFORSYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT *PDXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_WAITFORVERTICALBLANKEVENT(_In_ const D3DKMT_WAITFORVERTICALBLANKEVENT* unnamedParam1);
typedef DXGADAPTER_WAITFORVERTICALBLANKEVENT *PDXGADAPTER_WAITFORVERTICALBLANKEVENT;
typedef
NTSTATUS
DXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT(_In_ const D3DKMT_SIGNALSYNCHRONIZATIONOBJECT* unnamedParam1);
typedef DXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT *PDXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT;
typedef
NTSTATUS
DXGADAPTER_QUERYRESOURCEINFO(_Inout_ D3DKMT_QUERYRESOURCEINFO* unnamedParam1);
typedef DXGADAPTER_QUERYRESOURCEINFO *PDXGADAPTER_QUERYRESOURCEINFO;
typedef
NTSTATUS
DXGADAPTER_GETPRESENTHISTORY(_Inout_ D3DKMT_GETPRESENTHISTORY* unnamedParam1);
typedef DXGADAPTER_GETPRESENTHISTORY *PDXGADAPTER_GETPRESENTHISTORY;
typedef
NTSTATUS
DXGADAPTER_SETALLOCATIONPRIORITY(_In_ const D3DKMT_SETALLOCATIONPRIORITY* unnamedParam1);
typedef DXGADAPTER_SETALLOCATIONPRIORITY *PDXGADAPTER_SETALLOCATIONPRIORITY;
typedef
NTSTATUS
DXGADAPTER_INVALIDATEACTIVEVIDPN(_In_ const D3DKMT_INVALIDATEACTIVEVIDPN* unnamedParam1);
typedef DXGADAPTER_INVALIDATEACTIVEVIDPN *PDXGADAPTER_INVALIDATEACTIVEVIDPN;
typedef
NTSTATUS
DXGADAPTER_GETSHAREDPRIMARYHANDLE(_In_ D3DKMT_GETSHAREDPRIMARYHANDLE* unnamedParam1);
typedef DXGADAPTER_GETSHAREDPRIMARYHANDLE *PDXGADAPTER_GETSHAREDPRIMARYHANDLE;
typedef
NTSTATUS
DXGADAPTER_LOCK(_In_ D3DKMT_LOCK* unnamedParam1);
typedef DXGADAPTER_LOCK *PDXGADAPTER_LOCK;
typedef
NTSTATUS
DXGADAPTER_POLLDISPLAYCHILDREN(_In_ const D3DKMT_POLLDISPLAYCHILDREN* unnamedParam1);
typedef DXGADAPTER_POLLDISPLAYCHILDREN *PDXGADAPTER_POLLDISPLAYCHILDREN;
typedef
NTSTATUS
DXGADAPTER_OPENRESOURCE(_Inout_ D3DKMT_OPENRESOURCE* unnamedParam1);
typedef DXGADAPTER_OPENRESOURCE *PDXGADAPTER_OPENRESOURCE;
typedef
NTSTATUS
DXGADAPTER_PRESENT(_In_ D3DKMT_PRESENT* unnamedParam1);
typedef DXGADAPTER_PRESENT *PDXGADAPTER_PRESENT;
typedef
NTSTATUS
DXGADAPTER_QUERYADAPTERINFO(_Inout_ const D3DKMT_QUERYADAPTERINFO* unnamedParam1);
typedef DXGADAPTER_QUERYADAPTERINFO *PDXGADAPTER_QUERYADAPTERINFO;
typedef
NTSTATUS
DXGADAPTER_QUERYALLOCATIONRESIDENCY(_In_ const D3DKMT_QUERYALLOCATIONRESIDENCY* unnamedParam1);
typedef DXGADAPTER_QUERYALLOCATIONRESIDENCY *PDXGADAPTER_QUERYALLOCATIONRESIDENCY;
typedef
NTSTATUS
DXGADAPTER_QUERYSTATISTICS(_Inout_ const D3DKMT_QUERYSTATISTICS* unnamedParam1);
typedef DXGADAPTER_QUERYSTATISTICS *PDXGADAPTER_QUERYSTATISTICS;
typedef
NTSTATUS
DXGADAPTER_RELEASEPROCESSVIDPNSOURCEOWNERS(_In_ HANDLE unnamedParam1);
typedef DXGADAPTER_RELEASEPROCESSVIDPNSOURCEOWNERS *PDXGADAPTER_RELEASEPROCESSVIDPNSOURCEOWNERS;
typedef
NTSTATUS
DXGADAPTER_RENDER(_In_ D3DKMT_RENDER* unnamedParam1);
typedef DXGADAPTER_RENDER *PDXGADAPTER_RENDER;
typedef
NTSTATUS
DXGADAPTER_SETCONTEXTSCHEDULINGPRIORITY(_In_ const D3DKMT_SETCONTEXTSCHEDULINGPRIORITY* unnamedParam1);
typedef DXGADAPTER_SETCONTEXTSCHEDULINGPRIORITY *PDXGADAPTER_SETCONTEXTSCHEDULINGPRIORITY;
/*
* This structure is the callbacks list that exist between DXGKNRL and Win32k.
* This private interface is undocumented and changes with every Windows update
* that remotely touches WDDM.
*
* Reversing this isn't possible until we can throw our DxgKrnl into vista or above at runtime.
* But this cannot happen without us first supporting watchdog.
*/
typedef struct _REACTOS_WIN32K_DXGKRNL_INTERFACE
{
PDXGADAPTER_PRESENT RxgkIntPfnPresent;
PDXGADAPTER_QUERYADAPTERINFO RxgkIntPfnQueryAdapterInfo;
PDXGADAPTER_QUERYALLOCATIONRESIDENCY RxgkIntPfnQueryAllocationResidency;
PDXGADAPTER_QUERYSTATISTICS RxgkIntPfnQueryStatistics;
PDXGADAPTER_RELEASEPROCESSVIDPNSOURCEOWNERS RxgkIntPfnReleaseProcessVidPnSourceOwners;
PDXGADAPTER_RENDER RxgkIntPfnRender;
PDXGADAPTER_SETCONTEXTSCHEDULINGPRIORITY RxgkIntPfnSetContextSchedulingPriority;
PDXGADAPTER_OPENRESOURCE RxgkIntPfnOpenResource;
PDXGADAPTER_POLLDISPLAYCHILDREN RxgkIntPfnPollDisplayChildren;
PDXGADAPTER_LOCK RxgkIntPfnLock;
PDXGADAPTER_GETSHAREDPRIMARYHANDLE RxgkIntPfnGetSharedPrimaryHandle;
PDXGADAPTER_INVALIDATEACTIVEVIDPN RxgkIntPfnInvalidateActiveVidPn;
PDXGADAPTER_SETALLOCATIONPRIORITY RxgkIntPfnSetAllocationPriority;
PDXGADAPTER_GETPRESENTHISTORY RxgkIntPfnGetPresentHistory;
PDXGADAPTER_QUERYRESOURCEINFO RxgkIntPfnQueryResourceInfo;
PDXGADAPTER_CREATEALLOCATION RxgkIntPfnCreateAllocation;
PDXGADAPTER_CHECKMONITORPOWERSTATE RxgkIntPfnCheckMonitorPowerState;
PDXGADAPTER_CHECKOCCLUSION RxgkIntPfnCheckOcclusion;
PDXGADAPTER_CLOSEADAPTER RxgkIntPfnCloseAdapter;
PDXGADAPTER_CREATECONTEXT RxgkIntPfnCreateContext;
PDXGADAPTER_CREATEDEVICE RxgkIntPfnCreateDevice;
PDXGADAPTER_CREATEOVERLAY RxgkIntPfnCreateOverlay;
PDXGADAPTER_CREATESYNCHRONIZATIONOBJECT RxgkIntPfnCreateSynchronizationObject;
PDXGADAPTER_DESTROYCONTEXT RxgkIntPfnDestroyContext;
PDXGADAPTER_DESTROYDEVICE RxgkIntPfnDestroyDevice;
PDXGADAPTER_DESTROYOVERLAY RxgkIntPfnDestroyOverlay;
PDXGADAPTER_DESTROYSYNCHRONIZATIONOBJECT RxgkIntPfnDestroySynchronizationObject;
PDXGADAPTER_ESCAPE RxgkIntPfnEscape;
PDXGADAPTER_DESTROYALLOCATION RxgkIntPfnDestroyAllocation;
PDXGADAPTER_FLIPOVERLAY RxgkIntPfnFlipOverlay;
PDXGADAPTER_GETCONTEXTSCHEDULINGPRIORITY RxgkIntPfnGetContextSchedulingPriority;
PDXGADAPTER_GETDEVICESTATE RxgkIntPfnGetDeviceState;
PDXGADAPTER_GETDISPLAYMODELIST RxgkIntPfnGetDisplayModeList;
PDXGADAPTER_GETMULTISAMPLEMETHODLIST RxgkIntPfnGetMultisampleMethodList;
PDXGADAPTER_GETRUNTIMEDATA RxgkIntPfnGetRuntimeData;
PDXGADAPTER_GETSCANLINE RxgkIntPfnGetScanLine;
PDXGADAPTER_SIGNALSYNCHRONIZATIONOBJECT RxgkIntPfnSignalSynchronizationObject;
PDXGADAPTER_WAITFORVERTICALBLANKEVENT RxgkIntPfnWaitForVerticalBlankEvent;
PDXGADAPTER_WAITFORSYNCHRONIZATIONOBJECT RxgkIntPfnWaitForSynchronizationObject;
PDXGADAPTER_SETVIDPNSOURCEOWNER RxgkIntPfnSetVidPnSourceOwner;
PDXGADAPTER_WAITFORIDLE RxgkIntPfnWaitForIdle;
PDXGADAPTER_UPDATEOVERLAY RxgkIntPfnUpdateOverlay;
PDXGADAPTER_SETQUEUEDLIMIT RxgkIntPfnSetQueuedLimit;
PDXGADAPTER_SETGAMMARAMP RxgkIntPfnSetGammaRamp;
PDXGADAPTER_SETDISPLAYMODE RxgkIntPfnSetDisplayMode;
PDXGADAPTER_SETDISPLAYPRIVATEDRIVERFORMAT RxgkIntPfnSetDisplayPrivateDriverFormat;
PDXGADAPTER_UNLOCK RxgkIntPfnUnlock;
} REACTOS_WIN32K_DXGKRNL_INTERFACE, *PREACTOS_WIN32K_DXGKRNL_INTERFACE;

1
win32ss/CMakeLists.txt
View file

@ -173,6 +173,7 @@ list(APPEND SOURCE
gdi/ntgdi/bitmaps.c
gdi/ntgdi/cliprgn.c
gdi/ntgdi/coord.c
gdi/ntgdi/d3dkmt.c
gdi/ntgdi/dcattr.c
gdi/ntgdi/dclife.c
gdi/ntgdi/dcobjs.c

1
win32ss/gdi/gdi32/CMakeLists.txt
View file

@ -53,6 +53,7 @@ add_library(gdi32 MODULE
set_module_type(gdi32 win32dll UNICODE ENTRYPOINT DllMain 12)
target_link_libraries(gdi32
gdi32_vista_static
winegdi
wine
win32ksys

59
win32ss/gdi/gdi32/gdi32.spec
View file

@ -608,3 +608,62 @@
608 stdcall bMakePathNameW(wstr wstr wstr long)
609 stdcall cGetTTFFromFOT(long long long long long long long)
610 stdcall gdiPlaySpoolStream(long long long long long long)
; ReactOS Display Driver Model
@ stdcall -version=0x600+ D3DKMTCheckExclusiveOwnership() NtGdiDdDDICheckExclusiveOwnership
@ stdcall -version=0x600+ D3DKMTCheckMonitorPowerState(ptr) NtGdiDdDDICheckMonitorPowerState
@ stdcall -version=0x600+ D3DKMTCheckOcclusion(ptr) NtGdiDdDDICheckOcclusion
@ stdcall -version=0x600+ D3DKMTCloseAdapter(ptr) NtGdiDdDDICloseAdapter
@ stdcall -version=0x600+ D3DKMTCreateAllocation(ptr) NtGdiDdDDICreateAllocation
@ stdcall -version=0x600+ D3DKMTCreateContext(ptr) NtGdiDdDDICreateContext
@ stdcall -version=0x600+ D3DKMTCreateDCFromMemory(ptr)
@ stdcall -version=0x600+ D3DKMTCreateDevice(ptr) NtGdiDdDDICreateDevice
@ stdcall -version=0x600+ D3DKMTCreateOverlay(ptr) NtGdiDdDDICreateOverlay
@ stdcall -version=0x600+ D3DKMTCreateSynchronizationObject(ptr) NtGdiDdDDICreateSynchronizationObject
@ stdcall -version=0x600+ D3DKMTDestroyAllocation(ptr) NtGdiDdDDIDestroyAllocation
@ stdcall -version=0x600+ D3DKMTDestroyContext(ptr) NtGdiDdDDIDestroyContext
@ stdcall -version=0x600+ D3DKMTDestroyDCFromMemory(ptr)
@ stdcall -version=0x600+ D3DKMTDestroyDevice(ptr) NtGdiDdDDIDestroyDevice
@ stdcall -version=0x600+ D3DKMTDestroyOverlay(ptr) NtGdiDdDDIDestroyOverlay
@ stdcall -version=0x600+ D3DKMTDestroySynchronizationObject(ptr) NtGdiDdDDIDestroySynchronizationObject
@ stdcall -version=0x600+ D3DKMTEscape(ptr) NtGdiDdDDIEscape
@ stdcall -version=0x600+ D3DKMTFlipOverlay(ptr) NtGdiDdDDIFlipOverlay
@ stdcall -version=0x600+ D3DKMTGetContextSchedulingPriority(ptr) NtGdiDdDDIGetContextSchedulingPriority
@ stdcall -version=0x600+ D3DKMTGetDeviceState(ptr) NtGdiDdDDIGetDeviceState
@ stdcall -version=0x600+ D3DKMTGetDisplayModeList(ptr) NtGdiDdDDIGetDisplayModeList
@ stdcall -version=0x600+ D3DKMTGetMultisampleMethodList(ptr) NtGdiDdDDIGetMultisampleMethodList
@ stdcall -version=0x600+ D3DKMTGetPresentHistory(ptr) NtGdiDdDDIGetPresentHistory
@ stdcall -version=0x600+ D3DKMTGetProcessSchedulingPriorityClass(ptr ptr) NtGdiDdDDIGetProcessSchedulingPriorityClass
@ stdcall -version=0x600+ D3DKMTGetRuntimeData(ptr) NtGdiDdDDIGetRuntimeData
@ stdcall -version=0x600+ D3DKMTGetScanLine(ptr) NtGdiDdDDIGetScanLine
@ stdcall -version=0x600+ D3DKMTGetSharedPrimaryHandle(ptr) NtGdiDdDDIGetSharedPrimaryHandle
@ stdcall -version=0x600+ D3DKMTInvalidateActiveVidPn(ptr) NtGdiDdDDIInvalidateActiveVidPn
@ stdcall -version=0x600+ D3DKMTLock(ptr) NtGdiDdDDILock
@ stdcall -version=0x600+ D3DKMTOpenAdapterFromDeviceName(ptr) NtGdiDdDDIOpenAdapterFromDeviceName
@ stdcall -version=0x600+ D3DKMTOpenAdapterFromGdiDisplayName(ptr)
@ stdcall -version=0x600+ D3DKMTOpenAdapterFromHdc(ptr) NtGdiDdDDIOpenAdapterFromHdc
@ stdcall -version=0x600+ D3DKMTOpenResource(ptr) NtGdiDdDDIOpenResource
@ stdcall -version=0x600+ D3DKMTPollDisplayChildren(ptr) NtGdiDdDDIPollDisplayChildren
@ stdcall -version=0x600+ D3DKMTPresent(ptr) NtGdiDdDDIPresent
@ stdcall -version=0x600+ D3DKMTQueryAdapterInfo(ptr) NtGdiDdDDIQueryAdapterInfo
@ stdcall -version=0x600+ D3DKMTQueryAllocationResidency(ptr) NtGdiDdDDIQueryAllocationResidency
@ stdcall -version=0x600+ D3DKMTQueryResourceInfo(ptr) NtGdiDdDDIQueryResourceInfo
@ stdcall -version=0x600+ D3DKMTQueryStatistics(ptr) NtGdiDdDDIQueryStatistics
@ stdcall -version=0x600+ D3DKMTReleaseProcessVidPnSourceOwners(ptr) NtGdiDdDDIReleaseProcessVidPnSourceOwners
@ stdcall -version=0x600+ D3DKMTRender(ptr) NtGdiDdDDIRender
@ stdcall -version=0x600+ D3DKMTSetAllocationPriority(ptr) NtGdiDdDDISetAllocationPriority
@ stdcall -version=0x600+ D3DKMTSetContextSchedulingPriority(ptr) NtGdiDdDDISetContextSchedulingPriority
@ stdcall -version=0x600+ D3DKMTSetDisplayMode(ptr) NtGdiDdDDISetDisplayMode
@ stdcall -version=0x600+ D3DKMTSetDisplayPrivateDriverFormat(ptr) NtGdiDdDDISetDisplayPrivateDriverFormat
@ stdcall -version=0x600+ D3DKMTSetGammaRamp(ptr) NtGdiDdDDISetGammaRamp
@ stdcall -version=0x600+ D3DKMTSetProcessSchedulingPriorityClass(ptr ptr) NtGdiDdDDISetProcessSchedulingPriorityClass
@ stdcall -version=0x600+ D3DKMTSetQueuedLimit(ptr) NtGdiDdDDISetQueuedLimit
@ stdcall -version=0x600+ D3DKMTSetVidPnSourceOwner(ptr) NtGdiDdDDISetVidPnSourceOwner
@ stdcall -version=0x600+ D3DKMTSharedPrimaryLockNotification(ptr) NtGdiDdDDISharedPrimaryLockNotification
@ stdcall -version=0x600+ D3DKMTSharedPrimaryUnLockNotification(ptr) NtGdiDdDDISharedPrimaryUnLockNotification
@ stdcall -version=0x600+ D3DKMTSignalSynchronizationObject(ptr) NtGdiDdDDISignalSynchronizationObject
@ stdcall -version=0x600+ D3DKMTUnlock(ptr) NtGdiDdDDIUnlock
@ stdcall -version=0x600+ D3DKMTUpdateOverlay(ptr) NtGdiDdDDIUpdateOverlay
@ stdcall -version=0x600+ D3DKMTWaitForIdle(ptr) NtGdiDdDDIWaitForIdle
@ stdcall -version=0x600+ D3DKMTWaitForSynchronizationObject(ptr) NtGdiDdDDIWaitForSynchronizationObject
@ stdcall -version=0x600+ D3DKMTWaitForVerticalBlankEvent(ptr) NtGdiDdDDIWaitForVerticalBlankEvent

7
win32ss/gdi/gdi32_vista/CMakeLists.txt
View file

@ -6,7 +6,8 @@ include_directories(
spec2def(gdi32_vista.dll gdi32_vista.spec ADD_IMPORTLIB)
list(APPEND SOURCE
dc.c)
dc.c
d3dkmt.c)
add_library(gdi32_vista MODULE
${SOURCE}
@ -15,6 +16,10 @@ add_library(gdi32_vista MODULE
set_module_type(gdi32_vista win32dll UNICODE ENTRYPOINT 0)
add_library(gdi32_vista_static ${SOURCE})
target_link_libraries(gdi32_vista_static win32ksys)
add_dependencies(gdi32_vista_static psdk)
target_link_libraries(gdi32_vista win32ksys)
#add_importlibs(gdi32_vista user32 advapi32 kernel32 ntdll)

17
win32ss/gdi/gdi32_vista/d3dkmt.c Normal file
View file

@ -0,0 +1,17 @@
/*
* PROJECT: ReactOS Display Driver Model
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: D3DKMT dxgkrnl syscalls
* COPYRIGHT: Copyright 2023 Justin Miller <justin.miller@reactos.org>
*/
#include <gdi32_vista.h>
#include <d3dkmddi.h>
/* Not just a syscall even in wine. */
NTSTATUS
WINAPI
D3DKMTOpenAdapterFromGdiDisplayName(_Inout_ D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME* unnamedParam1)
{
return STATUS_PROCEDURE_NOT_FOUND;
}

14
win32ss/gdi/gdi32_vista/dc.c
View file

@ -1,16 +1,4 @@
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#define NTOS_MODE_USER
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <ndk/rtlfuncs.h>
#include <wingdi.h>
#include <winddi.h>
#include <prntfont.h>
#include <ntgdityp.h>
#include <ntgdi.h>
#include <gdi32_vista.h>
/***********************************************************************
* D3DKMTCreateDCFromMemory (GDI32.@)

16
win32ss/gdi/gdi32_vista/gdi32_vista.h Normal file
View file

@ -0,0 +1,16 @@
#pragma once
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#define NTOS_MODE_USER
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <ndk/rtlfuncs.h>
#include <wingdi.h>
#include <winddi.h>
#include <prntfont.h>
#include <ntgdityp.h>
#include <ntgdi.h>

716
win32ss/gdi/ntgdi/d3dkmt.c Normal file
View file

@ -0,0 +1,716 @@
/*
* PROJECT: ReactOS Display Driver Model
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: D3DKMT dxgkrnl callbacks
* COPYRIGHT: Copyright 2023 Justin Miller <justin.miller@reactos.org>
*/
#include <win32k.h>
#include <reactos/rddm/rxgkinterface.h>
#include <debug.h>
/*
* It looks like Windows saves all the function pointers globally inside win32k.
* Instead, we're going to keep it static to this file and keep it organized in struct
* we obtained with the IOCTL.
*/
static REACTOS_WIN32K_DXGKRNL_INTERFACE DxgAdapterCallbacks = {0};
/*
* This looks like it's done inside DxDdStartupDxGraphics, but I'd rather keep this organized.
* Dxg gets start inevitably anyway it seems at least on vista.
*/
VOID
APIENTRY
DxStartupDxgkInt(VOID)
{
DPRINT("DxStartupDxgkInt: Entry\n");
/*
* TODO: Let DxgKrnl know it's time to start all adapters, and obtain the win32k<->dxgkrnl interface via an IOCTRL.
* https://jira.reactos.org/browse/CORE-20027
*/
}
BOOLEAN
APIENTRY
NtGdiDdDDICheckExclusiveOwnership(VOID)
{
// We don't support DWM at this time, excusive ownership is always false.
return FALSE;
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetProcessSchedulingPriorityClass(_In_ HANDLE unnamedParam1,
_Out_ D3DKMT_SCHEDULINGPRIORITYCLASS *unnamedParam2)
{
return 1;
}
NTSTATUS
APIENTRY
NtGdiDdDDISetProcessSchedulingPriorityClass(_In_ HANDLE unnamedParam1,
_In_ D3DKMT_SCHEDULINGPRIORITYCLASS unnamedParam2)
{
return 1;
}
NTSTATUS
APIENTRY
NtGdiDdDDISharedPrimaryLockNotification(_In_ const D3DKMT_SHAREDPRIMARYLOCKNOTIFICATION* unnamedParam1)
{
return 1;
}
NTSTATUS
APIENTRY
NtGdiDdDDISharedPrimaryUnLockNotification(_In_ const D3DKMT_SHAREDPRIMARYUNLOCKNOTIFICATION* unnamedParam1)
{
return 1;
}
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromGdiDisplayName(_Inout_ D3DKMT_OPENADAPTERFROMGDIDISPLAYNAME* unnamedParam1)
{
return 0;
}
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromHdc(_Inout_ D3DKMT_OPENADAPTERFROMHDC* unnamedParam1)
{
return 0;
}
NTSTATUS
APIENTRY
NtGdiDdDDIOpenAdapterFromDeviceName(_Inout_ D3DKMT_OPENADAPTERFROMDEVICENAME* unnamedParam1)
{
return 0;
}
/*
* The following APIs all have the same idea.
* Most of the parameters are stuffed in custom typedefs with a bunch of types inside them.
* The idea here is this:
* if we're dealing with a d3dkmt API that directly calls into a miniport if the function pointer doesn't
* exist we're returning STATUS_PROCEDURE_NOT_FOUND.
*
* This essentially means the Dxgkrnl interface was never made as Win32k doesn't do any handling for these routines.
*/
NTSTATUS
APIENTRY
NtGdiDdDDICreateAllocation(_Inout_ D3DKMT_CREATEALLOCATION* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCreateAllocation)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCreateAllocation(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICheckMonitorPowerState(_In_ const D3DKMT_CHECKMONITORPOWERSTATE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCheckMonitorPowerState)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCheckMonitorPowerState(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICheckOcclusion(_In_ const D3DKMT_CHECKOCCLUSION* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCheckOcclusion)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCheckOcclusion(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICloseAdapter(_In_ const D3DKMT_CLOSEADAPTER* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCloseAdapter)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCloseAdapter(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICreateContext(_Inout_ D3DKMT_CREATECONTEXT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCreateContext)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCreateContext(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICreateDevice(_Inout_ D3DKMT_CREATEDEVICE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCreateDevice)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCreateDevice(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICreateOverlay(_Inout_ D3DKMT_CREATEOVERLAY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCreateOverlay)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCreateOverlay(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDICreateSynchronizationObject(_Inout_ D3DKMT_CREATESYNCHRONIZATIONOBJECT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnCreateSynchronizationObject)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnCreateSynchronizationObject(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyAllocation(_In_ const D3DKMT_DESTROYALLOCATION* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnDestroyAllocation)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnDestroyAllocation(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyContext(_In_ const D3DKMT_DESTROYCONTEXT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnDestroyContext)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnDestroyContext(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyDevice(_In_ const D3DKMT_DESTROYDEVICE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnDestroyDevice)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnDestroyDevice(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIDestroyOverlay(_In_ const D3DKMT_DESTROYOVERLAY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnDestroyOverlay)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnDestroyOverlay(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIDestroySynchronizationObject(_In_ const D3DKMT_DESTROYSYNCHRONIZATIONOBJECT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnDestroySynchronizationObject)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnDestroySynchronizationObject(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIEscape(_In_ const D3DKMT_ESCAPE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnEscape)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnEscape(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIFlipOverlay(_In_ const D3DKMT_FLIPOVERLAY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnFlipOverlay)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnFlipOverlay(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetContextSchedulingPriority(_Inout_ D3DKMT_GETCONTEXTSCHEDULINGPRIORITY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetContextSchedulingPriority)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetContextSchedulingPriority(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetDeviceState(_Inout_ D3DKMT_GETDEVICESTATE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetDeviceState)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetDeviceState(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetDisplayModeList(_Inout_ D3DKMT_GETDISPLAYMODELIST* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetDisplayModeList)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetDisplayModeList(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetMultisampleMethodList(_Inout_ D3DKMT_GETMULTISAMPLEMETHODLIST* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetMultisampleMethodList)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetMultisampleMethodList(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetPresentHistory(_Inout_ D3DKMT_GETPRESENTHISTORY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetPresentHistory)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetPresentHistory(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetRuntimeData(_In_ const D3DKMT_GETRUNTIMEDATA* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetRuntimeData)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetRuntimeData(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetScanLine(_In_ D3DKMT_GETSCANLINE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetScanLine)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetScanLine(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIGetSharedPrimaryHandle(_Inout_ D3DKMT_GETSHAREDPRIMARYHANDLE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnGetSharedPrimaryHandle)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnGetSharedPrimaryHandle(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIInvalidateActiveVidPn(_In_ const D3DKMT_INVALIDATEACTIVEVIDPN* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnInvalidateActiveVidPn)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnInvalidateActiveVidPn(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDILock(_Inout_ D3DKMT_LOCK* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnLock)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnLock(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIOpenResource(_Inout_ D3DKMT_OPENRESOURCE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnOpenResource)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnOpenResource(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIPollDisplayChildren(_In_ const D3DKMT_POLLDISPLAYCHILDREN* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnPollDisplayChildren)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnPollDisplayChildren(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIPresent(_In_ D3DKMT_PRESENT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnPresent)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnPresent(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIQueryAdapterInfo(_Inout_ const D3DKMT_QUERYADAPTERINFO* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnQueryAdapterInfo)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnQueryAdapterInfo(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIQueryAllocationResidency(_In_ const D3DKMT_QUERYALLOCATIONRESIDENCY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnQueryAllocationResidency)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnQueryAllocationResidency(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIQueryResourceInfo(_Inout_ D3DKMT_QUERYRESOURCEINFO* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnQueryResourceInfo)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnQueryResourceInfo(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIQueryStatistics(_Inout_ const D3DKMT_QUERYSTATISTICS* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnQueryStatistics)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnQueryStatistics(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIReleaseProcessVidPnSourceOwners(_In_ HANDLE unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnReleaseProcessVidPnSourceOwners)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnReleaseProcessVidPnSourceOwners(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIRender(_In_ D3DKMT_RENDER* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnRender)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnRender(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetAllocationPriority(_In_ const D3DKMT_SETALLOCATIONPRIORITY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetAllocationPriority)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetAllocationPriority(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetContextSchedulingPriority(_In_ const D3DKMT_SETCONTEXTSCHEDULINGPRIORITY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetContextSchedulingPriority)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetContextSchedulingPriority(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetDisplayMode(_In_ const D3DKMT_SETDISPLAYMODE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetDisplayMode)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetDisplayMode(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetDisplayPrivateDriverFormat(_In_ const D3DKMT_SETDISPLAYPRIVATEDRIVERFORMAT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetDisplayPrivateDriverFormat)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetDisplayPrivateDriverFormat(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetGammaRamp(_In_ const D3DKMT_SETGAMMARAMP* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetGammaRamp)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetGammaRamp(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetQueuedLimit(_Inout_ const D3DKMT_SETQUEUEDLIMIT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetQueuedLimit)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetQueuedLimit(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISetVidPnSourceOwner(_In_ const D3DKMT_SETVIDPNSOURCEOWNER* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSetVidPnSourceOwner)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSetVidPnSourceOwner(unnamedParam1);
}
NTSTATUS
WINAPI
NtGdiDdDDIUnlock(_In_ const D3DKMT_UNLOCK* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnUnlock)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnUnlock(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIUpdateOverlay(_In_ const D3DKMT_UPDATEOVERLAY* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnUpdateOverlay)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnUpdateOverlay(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForIdle(_In_ const D3DKMT_WAITFORIDLE* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnWaitForIdle)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnWaitForIdle(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForSynchronizationObject(_In_ const D3DKMT_WAITFORSYNCHRONIZATIONOBJECT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnWaitForSynchronizationObject)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnWaitForSynchronizationObject(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDIWaitForVerticalBlankEvent(_In_ const D3DKMT_WAITFORVERTICALBLANKEVENT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnWaitForVerticalBlankEvent)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnWaitForVerticalBlankEvent(unnamedParam1);
}
NTSTATUS
APIENTRY
NtGdiDdDDISignalSynchronizationObject(_In_ const D3DKMT_SIGNALSYNCHRONIZATIONOBJECT* unnamedParam1)
{
if (!unnamedParam1)
STATUS_INVALID_PARAMETER;
if (!DxgAdapterCallbacks.RxgkIntPfnSignalSynchronizationObject)
return STATUS_PROCEDURE_NOT_FOUND;
return DxgAdapterCallbacks.RxgkIntPfnSignalSynchronizationObject(unnamedParam1);
}

7
win32ss/gdi/ntgdi/init.c
View file

@ -75,11 +75,14 @@ GdiThreadDestroy(PETHREAD Thread)
return STATUS_SUCCESS;
}
BOOL
APIENTRY
InitializeGreCSRSS(VOID)
{
/* Initialize DirectX graphics driver */
/* Initialize Dxgkrnl interfaces and run startup routine */
DxStartupDxgkInt(VOID);
/* Initialize Legacy DirectX graphics driver */
if (DxDdStartupDxGraphics(0, NULL, 0, NULL, NULL, gpepCSRSS) != STATUS_SUCCESS)
{
ERR("Unable to initialize DirectX graphics\n");

1
win32ss/pch.h
View file

@ -53,6 +53,7 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
#define LPPOINT PPOINTL
#define PPOINT PPOINTL
#include <d3dkmddi.h>
#include <winerror.h>
#include <wingdi.h>
#define _ENGINE_EXPORT_

12
win32ss/reactx/ntdxvista/dxprivate.h Normal file
View file

@ -0,0 +1,12 @@
/*
* PROJECT: ReactOS Display Driver Model
* LICENSE: MIT (https://spdx.org/licenses/MIT)
* PURPOSE: Header file to hold win32k dxvista information
* COPYRIGHT: Copyright 2025 Justin Miller <justin.miller@reactos.org>
*/
#pragma once
VOID
APIENTRY
DxStartupDxgkInt(VOID);

56
win32ss/w32ksvc32.h
View file

@ -694,3 +694,59 @@
// For Wine DX
SVC_(GdiDdDDICreateDCFromMemory, 1)
SVC_(GdiDdDDIDestroyDCFromMemory, 1)
// ReactOS Display Driver Model
SVC_(GdiDdDDICheckExclusiveOwnership, 0)
SVC_(GdiDdDDICreateAllocation, 1)
SVC_(GdiDdDDICheckMonitorPowerState, 1)
SVC_(GdiDdDDICheckOcclusion, 1)
SVC_(GdiDdDDICloseAdapter, 1)
SVC_(GdiDdDDICreateContext, 1)
SVC_(GdiDdDDICreateDevice, 1)
SVC_(GdiDdDDICreateOverlay, 1)
SVC_(GdiDdDDICreateSynchronizationObject, 1)
SVC_(GdiDdDDIWaitForVerticalBlankEvent, 1)
SVC_(GdiDdDDIWaitForIdle, 1)
SVC_(GdiDdDDIUpdateOverlay, 1)
SVC_(GdiDdDDIUnlock, 1)
SVC_(GdiDdDDIDestroyAllocation, 1)
SVC_(GdiDdDDIDestroyContext, 1)
SVC_(GdiDdDDIDestroyDevice, 1)
SVC_(GdiDdDDIDestroyOverlay, 1)
SVC_(GdiDdDDIDestroySynchronizationObject, 1)
SVC_(GdiDdDDIEscape, 1)
SVC_(GdiDdDDIFlipOverlay, 1)
SVC_(GdiDdDDIGetContextSchedulingPriority, 1)
SVC_(GdiDdDDIGetDeviceState, 1)
SVC_(GdiDdDDIGetDisplayModeList, 1)
SVC_(GdiDdDDIGetMultisampleMethodList, 1)
SVC_(GdiDdDDIGetPresentHistory, 1)
SVC_(GdiDdDDIGetProcessSchedulingPriorityClass, 2)
SVC_(GdiDdDDIGetRuntimeData, 1)
SVC_(GdiDdDDIGetScanLine, 1)
SVC_(GdiDdDDIGetSharedPrimaryHandle, 1)
SVC_(GdiDdDDIInvalidateActiveVidPn, 1)
SVC_(GdiDdDDILock, 1)
SVC_(GdiDdDDIOpenAdapterFromDeviceName, 1)
SVC_(GdiDdDDIOpenAdapterFromGdiDisplayName, 1)
SVC_(GdiDdDDIOpenAdapterFromHdc, 1)
SVC_(GdiDdDDIOpenResource, 1)
SVC_(GdiDdDDIPollDisplayChildren, 1)
SVC_(GdiDdDDIPresent, 1)
SVC_(GdiDdDDIQueryAdapterInfo, 1)
SVC_(GdiDdDDIQueryAllocationResidency, 1)
SVC_(GdiDdDDIQueryResourceInfo, 1)
SVC_(GdiDdDDIQueryStatistics, 1)
SVC_(GdiDdDDIReleaseProcessVidPnSourceOwners, 1)
SVC_(GdiDdDDIRender, 1)
SVC_(GdiDdDDISetAllocationPriority, 1)
SVC_(GdiDdDDISetContextSchedulingPriority, 1)
SVC_(GdiDdDDISetDisplayMode, 1)
SVC_(GdiDdDDISetDisplayPrivateDriverFormat, 1)
SVC_(GdiDdDDISetGammaRamp, 1)
SVC_(GdiDdDDISetProcessSchedulingPriorityClass, 2)
SVC_(GdiDdDDISetQueuedLimit, 1)
SVC_(GdiDdDDISetVidPnSourceOwner, 1)
SVC_(GdiDdDDISharedPrimaryLockNotification, 1)
SVC_(GdiDdDDISharedPrimaryUnLockNotification, 1)
SVC_(GdiDdDDISignalSynchronizationObject, 1)
SVC_(GdiDdDDIWaitForSynchronizationObject, 1)

56
win32ss/w32ksvc64.h
View file

@ -688,3 +688,59 @@
SVC_(UserSetDbgTagCount, 1) //
SVC_(UserSetRipFlags, 1) //
SVC_(UserSetScrollBarInfo, 3) //
// ReactOS Display Driver Model
SVC_(GdiDdDDICheckExclusiveOwnership, 0)
SVC_(GdiDdDDICreateAllocation, 1)
SVC_(GdiDdDDICheckMonitorPowerState, 1)
SVC_(GdiDdDDICheckOcclusion, 1)
SVC_(GdiDdDDICloseAdapter, 1)
SVC_(GdiDdDDICreateContext, 1)
SVC_(GdiDdDDICreateDevice, 1)
SVC_(GdiDdDDICreateOverlay, 1)
SVC_(GdiDdDDICreateSynchronizationObject, 1)
SVC_(GdiDdDDIWaitForVerticalBlankEvent, 1)
SVC_(GdiDdDDIWaitForIdle, 1)
SVC_(GdiDdDDIUpdateOverlay, 1)
SVC_(GdiDdDDIUnlock, 1)
SVC_(GdiDdDDIDestroyAllocation, 1)
SVC_(GdiDdDDIDestroyContext, 1)
SVC_(GdiDdDDIDestroyDevice, 1)
SVC_(GdiDdDDIDestroyOverlay, 1)
SVC_(GdiDdDDIDestroySynchronizationObject, 1)
SVC_(GdiDdDDIEscape, 1)
SVC_(GdiDdDDIFlipOverlay, 1)
SVC_(GdiDdDDIGetContextSchedulingPriority, 1)
SVC_(GdiDdDDIGetDeviceState, 1)
SVC_(GdiDdDDIGetDisplayModeList, 1)
SVC_(GdiDdDDIGetMultisampleMethodList, 1)
SVC_(GdiDdDDIGetPresentHistory, 1)
SVC_(GdiDdDDIGetProcessSchedulingPriorityClass, 2)
SVC_(GdiDdDDIGetRuntimeData, 1)
SVC_(GdiDdDDIGetScanLine, 1)
SVC_(GdiDdDDIGetSharedPrimaryHandle, 1)
SVC_(GdiDdDDIInvalidateActiveVidPn, 1)
SVC_(GdiDdDDILock, 1)
SVC_(GdiDdDDIOpenAdapterFromDeviceName, 1)
SVC_(GdiDdDDIOpenAdapterFromGdiDisplayName, 1)
SVC_(GdiDdDDIOpenAdapterFromHdc, 1)
SVC_(GdiDdDDIOpenResource, 1)
SVC_(GdiDdDDIPollDisplayChildren, 1)
SVC_(GdiDdDDIPresent, 1)
SVC_(GdiDdDDIQueryAdapterInfo, 1)
SVC_(GdiDdDDIQueryAllocationResidency, 1)
SVC_(GdiDdDDIQueryResourceInfo, 1)
SVC_(GdiDdDDIQueryStatistics, 1)
SVC_(GdiDdDDIReleaseProcessVidPnSourceOwners, 1)
SVC_(GdiDdDDIRender, 1)
SVC_(GdiDdDDISetAllocationPriority, 1)
SVC_(GdiDdDDISetContextSchedulingPriority, 1)
SVC_(GdiDdDDISetDisplayMode, 1)
SVC_(GdiDdDDISetDisplayPrivateDriverFormat, 1)
SVC_(GdiDdDDISetGammaRamp, 1)
SVC_(GdiDdDDISetProcessSchedulingPriorityClass, 2)
SVC_(GdiDdDDISetQueuedLimit, 1)
SVC_(GdiDdDDISetVidPnSourceOwner, 1)
SVC_(GdiDdDDISharedPrimaryLockNotification, 1)
SVC_(GdiDdDDISharedPrimaryUnLockNotification, 1)
SVC_(GdiDdDDISignalSynchronizationObject, 1)
SVC_(GdiDdDDIWaitForSynchronizationObject, 1)

1
win32ss/win32kp.h
View file

@ -53,6 +53,7 @@ typedef struct _DC *PDC;
#include "gdi/ntgdi/path.h"
#include "gdi/dib/dib.h"
#include "reactx/ntddraw/intddraw.h"
#include "reactx/ntdxvista/dxprivate.h"
/* Internal NtUser Headers */
#include "user/ntuser/win32kdebug.h"