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

* Create a branch for USB experiments.

Browse source 
svn path=/branches/usb-experiments/; revision=72629
This commit is contained in:
Amine Khaldi 2016-09-09 15:11:19 +00:00
parent 28d8ba0d3e
commit 0ee830d7a4
23049 changed files with 0 additions and 1313991 deletions
Download patch file Download diff file Expand all files Collapse all files

4
win32ss/reactx/CMakeLists.txt Normal file
View file

@ -0,0 +1,4 @@
add_subdirectory(dxapi)
add_subdirectory(dxg)
add_subdirectory(dxgthk)

12
win32ss/reactx/dxapi/CMakeLists.txt Normal file
View file

@ -0,0 +1,12 @@
add_definitions(-D_DXAPI_)
spec2def(dxapi.sys dxapi.spec)
add_library(dxapi SHARED
main.c
dxapi.rc
${CMAKE_CURRENT_BINARY_DIR}/dxapi.def)
set_module_type(dxapi kernelmodedriver)
add_importlibs(dxapi ntoskrnl hal videoprt)
add_cd_file(TARGET dxapi DESTINATION reactos/system32/drivers FOR all)

5
win32ss/reactx/dxapi/dxapi.rc Normal file
View file

@ -0,0 +1,5 @@
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "DirectX API Driver"
#define REACTOS_STR_INTERNAL_NAME "dxgapi"
#define REACTOS_STR_ORIGINAL_FILENAME "dxgapi"
#include <reactos/version.rc>

7
win32ss/reactx/dxapi/dxapi.spec Normal file
View file

@ -0,0 +1,7 @@
@ stdcall _DxApi@20(long ptr long ptr long)
@ stdcall _DxApiGetVersion@0()
@ stdcall _DxApiInitialize@32(ptr ptr ptr ptr ptr ptr ptr ptr)
@ stdcall _DxAutoflipUpdate@20(ptr ptr ptr ptr ptr)
@ stdcall _DxEnableIRQ@8(ptr ptr)
@ stdcall _DxLoseObject@8(ptr ptr)
@ stdcall _DxUpdateCapture@12(ptr ptr ptr)

141
win32ss/reactx/dxapi/dxapi_driver.h Normal file
View file

@ -0,0 +1,141 @@
#include <wdm.h>
#include <windef.h>
#include <winerror.h>
#include <wingdi.h>
#define NT_BUILD_ENVIRONMENT
#include <winddi.h>
#include <ddkmapi.h>
/* Prototypes */
VOID DxGetVersionNumber(PVOID lpvInBuffer, LPDDGETVERSIONNUMBER lpvOutBuffer);
VOID DxCloseHandle(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxOpenDirectDraw(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxOpenSurface(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxOpenVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetKernelCaps(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxSetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxSetSkipPattern(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxSetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxLock(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxFlipOverlay(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxFlipVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetCurrentAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetPreviousAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxRegisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxUnregisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxGetPolarity(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxOpenVpCatureDevice(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxAddVpCaptureBuffer(PVOID lpvInBuffer, PVOID lpvOutBuffer);
VOID DxFlushVpCaptureBuffs(PVOID lpvInBuffer, PVOID lpvOutBuffer);
/* Internal driver table being use as looking up table for correct size of structs */
DWORD tblCheckInBuffer [] =
{
/* DD_DXAPI_GETVERSIONNUMBER */
0,
/* DD_DXAPI_CLOSEHANDLE */
sizeof(DDCLOSEHANDLE),
0, // DD_DXAPI_OPENDIRECTDRAW
0, // DD_DXAPI_OPENSURFACE
0, // DD_DXAPI_OPENVIDEOPORT
/* DD_DXAPI_GETKERNELCAPS */
sizeof(HANDLE),
/* DD_DXAPI_GET_VP_FIELD_NUMBER */
sizeof(DDGETFIELDNUMIN),
0, // DD_DXAPI_SET_VP_FIELD_NUMBER
0, // DD_DXAPI_SET_VP_SKIP_FIELD
0, // DD_DXAPI_GET_SURFACE_STATE
0, // DD_DXAPI_SET_SURFACE_STATE
0, // DD_DXAPI_LOCK
/* DD_DXAPI_FLIP_OVERLAY */
sizeof(DDFLIPOVERLAY),
/* DD_DXAPI_FLIP_VP */
sizeof(DDFLIPVIDEOPORT),
/* DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE */
sizeof(DDGETAUTOFLIPIN),
/* DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE */
sizeof(DDGETAUTOFLIPIN),
/* DD_DXAPI_REGISTER_CALLBACK */
sizeof(DDREGISTERCALLBACK),
/* DD_DXAPI_UNREGISTER_CALLBACK */
sizeof(DDREGISTERCALLBACK),
/* DD_DXAPI_GET_POLARITY */
sizeof(DDGETPOLARITYIN),
/* DD_DXAPI_OPENVPCAPTUREDEVICE */
sizeof(DDOPENVPCAPTUREDEVICEIN),
/* DD_DXAPI_ADDVPCAPTUREBUFFER */
sizeof(DDADDVPCAPTUREBUFF),
/* DD_DXAPI_FLUSHVPCAPTUREBUFFERS */
sizeof(HANDLE)
};
DWORD tblCheckOutBuffer [] =
{
/* DD_DXAPI_GETVERSIONNUMBER */
sizeof(DDGETVERSIONNUMBER),
/* DD_DXAPI_CLOSEHANDLE */
sizeof(DWORD),
0, // DD_DXAPI_OPENDIRECTDRAW
0, // DD_DXAPI_OPENSURFACE
0, // DD_DXAPI_OPENVIDEOPORT
/* DD_DXAPI_GETKERNELCAPS */
sizeof(DDGETKERNELCAPSOUT),
/* DD_DXAPI_GET_VP_FIELD_NUMBER */
sizeof(DDGETFIELDNUMOUT),
0, // DD_DXAPI_SET_VP_FIELD_NUMBER
0, // DD_DXAPI_SET_VP_SKIP_FIELD
0, // DD_DXAPI_GET_SURFACE_STATE
0, // DD_DXAPI_SET_SURFACE_STATE
0, // DD_DXAPI_LOCK
/* DD_DXAPI_FLIP_OVERLAY */
sizeof(DWORD),
/* DD_DXAPI_FLIP_VP */
sizeof(DWORD),
/* DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE */
sizeof(DDGETAUTOFLIPOUT),
/* DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE */
sizeof(DDGETAUTOFLIPOUT),
/* DD_DXAPI_REGISTER_CALLBACK */
sizeof(DWORD),
/* DD_DXAPI_UNREGISTER_CALLBACK */
sizeof(DWORD),
/* DD_DXAPI_GET_POLARITY */
sizeof(DDGETPOLARITYOUT),
/* DD_DXAPI_OPENVPCAPTUREDEVICE */
sizeof(DDOPENVPCAPTUREDEVICEOUT),
/* DD_DXAPI_ADDVPCAPTUREBUFFER */
sizeof(DWORD),
/* DD_DXAPI_FLUSHVPCAPTUREBUFFERS */
sizeof(DWORD)
};
/* Internal driver function */
DRVFN gDxApiEntryPoint [] =
{
{DD_DXAPI_GETVERSIONNUMBER - DD_FIRST_DXAPI, (PFN) DxGetVersionNumber},
{DD_DXAPI_CLOSEHANDLE - DD_FIRST_DXAPI, (PFN) DxCloseHandle},
{DD_DXAPI_OPENDIRECTDRAW - DD_FIRST_DXAPI, (PFN) DxOpenDirectDraw},
{DD_DXAPI_OPENSURFACE - DD_FIRST_DXAPI, (PFN) DxOpenSurface},
{DD_DXAPI_OPENVIDEOPORT - DD_FIRST_DXAPI, (PFN) DxOpenVideoPort},
{DD_DXAPI_GETKERNELCAPS - DD_FIRST_DXAPI, (PFN) DxGetKernelCaps},
{DD_DXAPI_GET_VP_FIELD_NUMBER - DD_FIRST_DXAPI, (PFN) DxGetFieldNumber},
{DD_DXAPI_SET_VP_FIELD_NUMBER - DD_FIRST_DXAPI, (PFN) DxSetFieldNumber},
{DD_DXAPI_SET_VP_SKIP_FIELD - DD_FIRST_DXAPI, (PFN) DxSetSkipPattern},
{DD_DXAPI_GET_SURFACE_STATE - DD_FIRST_DXAPI, (PFN) DxGetSurfaceState},
{DD_DXAPI_SET_SURFACE_STATE - DD_FIRST_DXAPI, (PFN) DxSetSurfaceState},
{DD_DXAPI_LOCK - DD_FIRST_DXAPI, (PFN) DxLock},
{DD_DXAPI_FLIP_OVERLAY - DD_FIRST_DXAPI, (PFN) DxFlipOverlay},
{DD_DXAPI_FLIP_VP - DD_FIRST_DXAPI, (PFN) DxFlipVideoPort},
{DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE - DD_FIRST_DXAPI, (PFN) DxGetCurrentAutoflip},
{DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE - DD_FIRST_DXAPI, (PFN) DxGetPreviousAutoflip},
{DD_DXAPI_REGISTER_CALLBACK - DD_FIRST_DXAPI, (PFN) DxRegisterEvent},
{DD_DXAPI_UNREGISTER_CALLBACK - DD_FIRST_DXAPI, (PFN) DxUnregisterEvent},
{DD_DXAPI_GET_POLARITY - DD_FIRST_DXAPI, (PFN) DxGetPolarity},
{DD_DXAPI_OPENVPCAPTUREDEVICE - DD_FIRST_DXAPI, (PFN) DxOpenVpCatureDevice},
{DD_DXAPI_ADDVPCAPTUREBUFFER - DD_FIRST_DXAPI, (PFN) DxAddVpCaptureBuffer},
{DD_DXAPI_FLUSHVPCAPTUREBUFFERS - DD_FIRST_DXAPI, (PFN) DxFlushVpCaptureBuffs}
};

325
win32ss/reactx/dxapi/main.c Normal file
View file

@ -0,0 +1,325 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxapi/main.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
#include "dxapi_driver.h"
#define NDEBU /* debug prints are enabled, add a G at the end to disable it ;-) */
#include <debug.h>
NTSTATUS NTAPI
DriverEntry(IN PVOID Context1,
IN PVOID Context2)
{
/*
* NOTE this driver will never be load, it only contain export list
* to win32k eng functions
*/
return STATUS_SUCCESS;
}
/*++
* @name DxApiGetVersion
* @implemented
*
* The function DxApiGetVersion return the dsound version, and it always return 4.02
*
* @return
* Always return 4.02
*
* @remarks.
* none
*
*--*/
ULONG
NTAPI
DxApiGetVersion(VOID)
{
/* MSDN say this always return Direct Sound version 4.02 */
return 0x402;
}
/*++
* @name DxApi
* @implemented
*
* The function DxApi calls to diffent functions, follow functions
* are supported
* DxGetVersionNumber, DxCloseHandle, DxOpenDirectDraw, DxOpenSurface,
* DxOpenVideoPort, DxGetKernelCaps, DxGetFieldNumber, DxSetFieldNumber,
* DxSetSkipPattern, DxGetSurfaceState, DxSetSurfaceState, DxLock,
* DxFlipOverlay, DxFlipVideoPort, DxGetCurrentAutoflip, DxGetPreviousAutoflip,
* DxRegisterEvent, DxUnregisterEvent, DxGetPolarity, DxOpenVpCatureDevice,
* DxAddVpCaptureBuffer, DxFlushVpCaptureBuffs
*
* See ddkmapi.h as well
*
* @param ULONG dwFunctionNum
* The function id we want call on in the dxapi.sys see ddkmapi.h for the id
*
* @param PVOID lpvInBuffer
* Our input buffer to the functions we call to, This param can be NULL
*
* @param ULONG cbInBuffer
* Our size in bytes of the input buffer, rember wrong size will result in the function
* does not being call.
*
* @param PVOID lpvOutBuffer
* Our Output buffer, there the function fill in the info, this param can not
* be null. if it null the functions we trying call on will not be call
*
* @param ULONG cbOutBuffer
* Our size in bytes of the output buffer, rember wrong size will result in the function
* does not being call.
*
* @return
* Return Always 0.
*
* @remarks.
* before call to any of this functions, do not forget set lpvOutBuffer->ddRVal = DDERR_GEN*,
* if that member exists in the outbuffer ;
*
*--*/
DWORD
NTAPI
DxApi(IN DWORD dwFunctionNum,
IN LPVOID lpvInBuffer,
IN DWORD cbInBuffer,
OUT LPVOID lpvOutBuffer,
OUT DWORD cbOutBuffer)
{
dwFunctionNum -= DD_FIRST_DXAPI;
if ((lpvOutBuffer == NULL) ||
/*(dwFunctionNum < (DD_FIRST_DXAPI - DD_FIRST_DXAPI)) ||*/
(dwFunctionNum > (DD_DXAPI_FLUSHVPCAPTUREBUFFERS - DD_FIRST_DXAPI)) ||
(gDxApiEntryPoint[dwFunctionNum].pfn == NULL) ||
(cbInBuffer != tblCheckInBuffer[dwFunctionNum]) ||
(cbOutBuffer != tblCheckOutBuffer[dwFunctionNum]))
{
return 0;
}
gDxApiEntryPoint[dwFunctionNum].pfn(lpvInBuffer, lpvOutBuffer);
return 0;
}
VOID
NTAPI
DxApiInitialize (
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5,
PVOID p6,
PVOID p7,
PVOID p8)
{
UNIMPLEMENTED;
}
VOID
NTAPI
DxAutoflipUpdate (
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5)
{
UNIMPLEMENTED;
}
VOID
NTAPI
DxEnableIRQ (
PVOID p1,
PVOID p2)
{
UNIMPLEMENTED;
}
VOID
NTAPI
DxLoseObject (
PVOID p1,
PVOID p2)
{
UNIMPLEMENTED;
}
VOID
NTAPI
DxUpdateCapture (
PVOID p1,
PVOID p2,
PVOID p3)
{
UNIMPLEMENTED;
}
/*++
* @name DxGetVersionNumber
* @implemented
*
* The function DxGetVersionNumber return dxapi interface version, that is 1.0
*
* @return
* Always return 1.0
*
* @remarks.
* none
*
*--*/
VOID
DxGetVersionNumber(PVOID lpvInBuffer, LPDDGETVERSIONNUMBER lpvOutBuffer)
{
lpvOutBuffer->ddRVal = DD_OK;
lpvOutBuffer->dwMajorVersion = 1;
lpvOutBuffer->dwMinorVersion = 0;
}
VOID
DxCloseHandle(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxOpenDirectDraw(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxOpenSurface(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxOpenVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetKernelCaps(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxSetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxSetSkipPattern(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxSetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxLock(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxFlipOverlay(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxFlipVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetCurrentAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetPreviousAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxRegisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxUnregisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxGetPolarity(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxOpenVpCatureDevice(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxAddVpCaptureBuffer(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}
VOID
DxFlushVpCaptureBuffs(PVOID lpvInBuffer, PVOID lpvOutBuffer)
{
/* FIXME Unimplement */
}

19
win32ss/reactx/dxg/CMakeLists.txt Normal file
View file

@ -0,0 +1,19 @@
spec2def(dxg.sys dxg.spec)
list(APPEND SOURCE
main.c
ddhmg.c
eng.c
historic.c
dxg_int.h)
add_library(dxg SHARED
${SOURCE}
dxg.rc
${CMAKE_CURRENT_BINARY_DIR}/dxg.def)
set_module_type(dxg kernelmodedriver)
add_importlibs(dxg dxgthk ntoskrnl)
add_pch(dxg dxg_int.h SOURCE)
add_cd_file(TARGET dxg DESTINATION reactos/system32/drivers FOR all)

182
win32ss/reactx/dxg/ddhmg.c Normal file
View file

@ -0,0 +1,182 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxg/ddhmg.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 30/12-2007 Magnus Olsen
*/
#include <dxg_int.h>
/* The DdHmgr manger stuff */
ULONG gcSizeDdHmgr = 64 * sizeof(DD_ENTRY);
PDD_ENTRY gpentDdHmgr = NULL;
ULONG gcMaxDdHmgr = 0;
PDD_ENTRY gpentDdHmgrLast = NULL;
HANDLE ghFreeDdHmgr = 0;
HSEMAPHORE ghsemHmgr = NULL;
BOOL
FASTCALL
VerifyObjectOwner(PDD_ENTRY pEntry)
{
DWORD Pid = (DWORD)(DWORD_PTR)PsGetCurrentProcessId() & 0xFFFFFFFC;
DWORD check = pEntry->ObjectOwner.ulObj & 0xFFFFFFFE;
return ( (check == Pid) || (!check));
}
/*++
* @name DdHmgCreate
* @implemented
*
* The function DdHmgCreate is used internally in dxg.sys
* It creates all DX kernel objects that are need it for creation of DX objects.
*
* @return
* Return FALSE for failure and TRUE for success in creating the DX object
*
* @remarks.
* Only used internally in dxg.sys
*--*/
BOOL
FASTCALL
DdHmgCreate(VOID)
{
gpentDdHmgr = EngAllocMem(FL_ZERO_MEMORY, gcSizeDdHmgr, TAG_THDD);
ghFreeDdHmgr = 0;
gcMaxDdHmgr = 1;
if (gpentDdHmgr)
{
ghsemHmgr = EngCreateSemaphore();
if (ghsemHmgr)
{
gpLockShortDelay = EngAllocMem(FL_ZERO_MEMORY | FL_NONPAGED_MEMORY, sizeof(LARGE_INTEGER), TAG_GINI);
if (gpLockShortDelay)
{
gpLockShortDelay->HighPart = -1;
return TRUE;
}
EngDeleteSemaphore(ghsemHmgr);
ghsemHmgr = NULL;
}
EngFreeMem(gpentDdHmgr);
gpentDdHmgr = NULL;
}
return FALSE;
}
/*++
* @name DdHmgDestroy
* @implemented
*
* The function DdHmgDestroy is used internally in dxg.sys
* It destroys all DX kernel objects
*
* @return
* Always returns true, as a failure here would result in a BSOD.
*
* @remarks.
* Only used internally in dxg.sys
*--*/
BOOL
FASTCALL
DdHmgDestroy(VOID)
{
gcMaxDdHmgr = 0;
gcSizeDdHmgr = 0;
ghFreeDdHmgr = 0;
gpentDdHmgrLast = NULL;
if (gpentDdHmgr)
{
EngFreeMem(gpentDdHmgr);
gpentDdHmgr = NULL;
}
if (ghsemHmgr)
{
EngDeleteSemaphore(ghsemHmgr);
ghsemHmgr = NULL;
}
return TRUE;
}
/*++
* @name DdHmgLock
* @implemented
*
* The function DdHmgLock is used internally in dxg.sys
* It locks a DX kernel object
*
* @param HANDLE DdHandle
* The handle we want locked
*
* @param UCHAR ObjectType
* The type of the object we expected the handle to contain
* value 0 is for ?
* value 1 is for EDD_DIRECTDRAW_LOCAL
* value 2 is for EDD_SURFACE
* value 3 is for ?
* value 4 is for EDD_VIDEOPORT
* value 5 is for EDD_MOTIONCOMP
* @param BOOLEAN LockOwned
* If it needs to call EngAcquireSemaphore or not
*
* @return
* Returns an EDD_* object, or NULL if it fails
*
* @remarks.
* Only used internally in dxg.sys
*--*/
PVOID
FASTCALL
DdHmgLock(HANDLE DdHandle, UCHAR ObjectType, BOOLEAN LockOwned)
{
DWORD Index = (DWORD)(DWORD_PTR)DdHandle & 0x1FFFFF;
PDD_ENTRY pEntry = NULL;
PVOID Object = NULL;
if ( !LockOwned )
{
EngAcquireSemaphore(ghsemHmgr);
}
if ( Index < gcMaxDdHmgr )
{
pEntry = (PDD_ENTRY)((PBYTE)gpentDdHmgr + (sizeof(DD_ENTRY) * Index));
if ( VerifyObjectOwner(pEntry) )
{
/* FIXME
if ( (pEntry->Objt == ObjectType ) &&
(pEntry->FullUnique == (((DWORD)DdHandle >> 21) & 0x7FF) ) &&
(pEntry->pobj->cExclusiveLock == 0) &&
(pEntry->pobj->Tid == PsGetCurrentThread()))
{
InterlockedIncrement(&pEntry->pobj->cExclusiveLock);
pEntry->pobj->Tid = PsGetCurrentThread();
Object = pEntry->pobj;
}
*/
}
}
if ( !LockOwned )
{
EngDeleteSemaphore(ghsemHmgr);
}
return Object;
}

5
win32ss/reactx/dxg/dxg.rc Normal file
View file

@ -0,0 +1,5 @@
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "DXG DirectX interface Device Driver"
#define REACTOS_STR_INTERNAL_NAME "dxg"
#define REACTOS_STR_ORIGINAL_FILENAME "dxg.sys"
#include <reactos/version.rc>

2
win32ss/reactx/dxg/dxg.spec Normal file
View file

@ -0,0 +1,2 @@
@ stdcall DxDdCleanupDxGraphics()
@ stdcall DxDdStartupDxGraphics(long ptr long ptr ptr ptr)

988
win32ss/reactx/dxg/dxg_driver.h Normal file
View file

@ -0,0 +1,988 @@
#define TRACE() \
DbgPrint("DXG: %s\n", __FUNCTION__)
DWORD
NTAPI
DxD3dContextCreate(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxD3dContextDestroy(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxD3dContextDestroyAll(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxD3dValidateTextureStageState(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxD3dDrawPrimitives2(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5,
PVOID p6,
PVOID p7)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetDriverState(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdAddAttachedSurface(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdAlphaBlt(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdAttachSurface(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdBeginMoCompFrame(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdBlt(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCanCreateSurface(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCanCreateD3DBuffer(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdColorControl(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCreateDirectDrawObject(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCreateD3DBuffer(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5,
PVOID p6,
PVOID p7,
PVOID p8)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCreateMoComp(
PVOID p1,
PVOID p2)
{
return 0;
}
DWORD
NTAPI
DxDdCreateSurfaceObject(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5,
PVOID p6)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdDeleteDirectDrawObject(
PVOID p1)
{
return 0;
}
DWORD
NTAPI
DxDdDeleteSurfaceObject(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdDestroyMoComp(
PVOID p1,
PVOID p2)
{
return 0;
}
DWORD
NTAPI
DxDdDestroySurface(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdDestroyD3DBuffer(
PVOID p1)
{
return 0;
}
DWORD
NTAPI
DxDdEndMoCompFrame(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdFlip(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5)
{
return 0;
}
DWORD
NTAPI
DxDdFlipToGDISurface(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetAvailDriverMemory(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetBltStatus(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetDC(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetDriverInfo(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetDxHandle(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetFlipStatus(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetInternalMoCompInfo(
PVOID p1,
PVOID p2)
{
return 0;
}
DWORD
NTAPI
DxDdGetMoCompBuffInfo(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetMoCompGuids(
PVOID p1,
PVOID p2)
{
return 0;
}
DWORD
NTAPI
DxDdGetMoCompFormats(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetScanLine(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdLock(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdLockD3D(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdQueryDirectDrawObject(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5,
PVOID p6,
PVOID p7,
PVOID p8,
PVOID p9,
PVOID p10,
PVOID p11)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdQueryMoCompStatus(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdReenableDirectDrawObject(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdReleaseDC(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdRenderMoComp(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdResetVisrgn(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdSetColorKey(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdSetExclusiveMode(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdSetGammaRamp(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCreateSurfaceEx(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdSetOverlayPosition(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdUnattachSurface(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdUnlock(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdUnlockD3D(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdUpdateOverlay(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdWaitForVerticalBlank(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpCanCreateVideoPort(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpColorControl(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpCreateVideoPort(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpDestroyVideoPort(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpFlipVideoPort(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortBandwidth(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortField(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortFlipStatus(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortInputFormats(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortLine(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortOutputFormats(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoPortConnectInfo(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpGetVideoSignalStatus(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpUpdateVideoPort(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpWaitForVideoPortSync(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpAcquireNotification(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDvpReleaseNotification(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdHeapVidMemAllocAligned(
PVOID p1,
PVOID p2,
PVOID p3,
PVOID p4,
PVOID p5)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdHeapVidMemFree(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdDisableDirectDraw(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdSuspendDirectDraw(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdResumeDirectDraw(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdDynamicModeChange(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdCloseProcess(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetDirectDrawBound(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdEnableDirectDrawRedirection(
PVOID p1,
PVOID p2)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdAllocPrivateUserMem(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdFreePrivateUserMem(
PVOID p1,
PVOID p2)
{
return 0;
}
DWORD
NTAPI
DxDdSetAccelLevel(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdGetSurfaceLock(
PVOID p1)
{
TRACE();
return 0;
}
DWORD
NTAPI
DxDdEnumLockedSurfaceRect(
PVOID p1,
PVOID p2,
PVOID p3)
{
TRACE();
return 0;
}
DRVFN gaDxgFuncs [] =
{
{DXG_INDEX_DxDxgGenericThunk, (PFN)DxDxgGenericThunk},
{DXG_INDEX_DxD3dContextCreate, (PFN)DxD3dContextCreate},
{DXG_INDEX_DxD3dContextDestroy, (PFN)DxD3dContextDestroy},
{DXG_INDEX_DxD3dContextDestroyAll, (PFN)DxD3dContextDestroyAll},
{DXG_INDEX_DxD3dValidateTextureStageState, (PFN)DxD3dValidateTextureStageState},
{DXG_INDEX_DxD3dDrawPrimitives2, (PFN)DxD3dDrawPrimitives2},
{DXG_INDEX_DxDdGetDriverState, (PFN)DxDdGetDriverState},
{DXG_INDEX_DxDdAddAttachedSurface, (PFN)DxDdAddAttachedSurface},
{DXG_INDEX_DxDdAlphaBlt, (PFN)DxDdAlphaBlt},
{DXG_INDEX_DxDdAttachSurface, (PFN)DxDdAttachSurface},
{DXG_INDEX_DxDdBeginMoCompFrame, (PFN)DxDdBeginMoCompFrame},
{DXG_INDEX_DxDdBlt, (PFN)DxDdBlt},
{DXG_INDEX_DxDdCanCreateSurface, (PFN)DxDdCanCreateSurface},
{DXG_INDEX_DxDdCanCreateD3DBuffer, (PFN)DxDdCanCreateD3DBuffer},
{DXG_INDEX_DxDdColorControl, (PFN)DxDdColorControl},
{DXG_INDEX_DxDdCreateDirectDrawObject, (PFN)DxDdCreateDirectDrawObject},
{DXG_INDEX_DxDdCreateSurface, (PFN)DxDdCreateD3DBuffer},
{DXG_INDEX_DxDdCreateD3DBuffer, (PFN)DxDdCreateD3DBuffer},
{DXG_INDEX_DxDdCreateMoComp, (PFN)DxDdCreateMoComp},
{DXG_INDEX_DxDdCreateSurfaceObject, (PFN)DxDdCreateSurfaceObject},
{DXG_INDEX_DxDdDeleteDirectDrawObject, (PFN)DxDdDeleteDirectDrawObject},
{DXG_INDEX_DxDdDeleteSurfaceObject, (PFN)DxDdDeleteSurfaceObject},
{DXG_INDEX_DxDdDestroyMoComp, (PFN)DxDdDestroyMoComp},
{DXG_INDEX_DxDdDestroySurface, (PFN)DxDdDestroySurface},
{DXG_INDEX_DxDdDestroyD3DBuffer, (PFN)DxDdDestroyD3DBuffer},
{DXG_INDEX_DxDdEndMoCompFrame, (PFN)DxDdEndMoCompFrame},
{DXG_INDEX_DxDdFlip, (PFN)DxDdFlip},
{DXG_INDEX_DxDdFlipToGDISurface, (PFN)DxDdFlipToGDISurface},
{DXG_INDEX_DxDdGetAvailDriverMemory, (PFN)DxDdGetAvailDriverMemory},
{DXG_INDEX_DxDdGetBltStatus, (PFN)DxDdGetBltStatus},
{DXG_INDEX_DxDdGetDC, (PFN)DxDdGetDC},
{DXG_INDEX_DxDdGetDriverInfo, (PFN)DxDdGetDriverInfo},
{DXG_INDEX_DxDdGetDxHandle, (PFN)DxDdGetDxHandle},
{DXG_INDEX_DxDdGetFlipStatus, (PFN)DxDdGetFlipStatus},
{DXG_INDEX_DxDdGetInternalMoCompInfo, (PFN)DxDdGetInternalMoCompInfo},
{DXG_INDEX_DxDdGetMoCompBuffInfo, (PFN)DxDdGetMoCompBuffInfo},
{DXG_INDEX_DxDdGetMoCompGuids, (PFN)DxDdGetMoCompGuids},
{DXG_INDEX_DxDdGetMoCompFormats, (PFN)DxDdGetMoCompFormats},
{DXG_INDEX_DxDdGetScanLine, (PFN)DxDdGetScanLine},
{DXG_INDEX_DxDdLock, (PFN)DxDdLock},
{DXG_INDEX_DxDdLockD3D, (PFN)DxDdLockD3D},
{DXG_INDEX_DxDdQueryDirectDrawObject, (PFN)DxDdQueryDirectDrawObject},
{DXG_INDEX_DxDdQueryMoCompStatus, (PFN)DxDdQueryMoCompStatus},
{DXG_INDEX_DxDdReenableDirectDrawObject, (PFN)DxDdReenableDirectDrawObject},
{DXG_INDEX_DxDdReleaseDC, (PFN)DxDdReleaseDC},
{DXG_INDEX_DxDdRenderMoComp, (PFN)DxDdRenderMoComp},
{DXG_INDEX_DxDdResetVisrgn, (PFN)DxDdResetVisrgn},
{DXG_INDEX_DxDdSetColorKey, (PFN)DxDdSetColorKey},
{DXG_INDEX_DxDdSetExclusiveMode, (PFN)DxDdSetExclusiveMode},
{DXG_INDEX_DxDdSetGammaRamp, (PFN)DxDdSetGammaRamp},
{DXG_INDEX_DxDdCreateSurfaceEx, (PFN)DxDdCreateSurfaceEx},
{DXG_INDEX_DxDdSetOverlayPosition, (PFN)DxDdSetOverlayPosition},
{DXG_INDEX_DxDdUnattachSurface, (PFN)DxDdUnattachSurface},
{DXG_INDEX_DxDdUnlock, (PFN)DxDdUnlock},
{DXG_INDEX_DxDdUnlockD3D, (PFN)DxDdUnlockD3D},
{DXG_INDEX_DxDdUpdateOverlay, (PFN)DxDdUpdateOverlay},
{DXG_INDEX_DxDdWaitForVerticalBlank, (PFN)DxDdWaitForVerticalBlank},
{DXG_INDEX_DxDvpCanCreateVideoPort, (PFN)DxDvpCanCreateVideoPort},
{DXG_INDEX_DxDvpColorControl, (PFN)DxDvpColorControl},
{DXG_INDEX_DxDvpCreateVideoPort, (PFN)DxDvpCreateVideoPort},
{DXG_INDEX_DxDvpDestroyVideoPort, (PFN)DxDvpDestroyVideoPort},
{DXG_INDEX_DxDvpFlipVideoPort, (PFN)DxDvpFlipVideoPort},
{DXG_INDEX_DxDvpGetVideoPortBandwidth, (PFN)DxDvpGetVideoPortBandwidth},
{DXG_INDEX_DxDvpGetVideoPortField, (PFN)DxDvpGetVideoPortField},
{DXG_INDEX_DxDvpGetVideoPortFlipStatus, (PFN)DxDvpGetVideoPortFlipStatus},
{DXG_INDEX_DxDvpGetVideoPortInputFormats, (PFN)DxDvpGetVideoPortInputFormats},
{DXG_INDEX_DxDvpGetVideoPortLine, (PFN)DxDvpGetVideoPortLine},
{DXG_INDEX_DxDvpGetVideoPortOutputFormats, (PFN)DxDvpGetVideoPortOutputFormats},
{DXG_INDEX_DxDvpGetVideoPortConnectInfo, (PFN)DxDvpGetVideoPortConnectInfo},
{DXG_INDEX_DxDvpGetVideoSignalStatus, (PFN)DxDvpGetVideoSignalStatus},
{DXG_INDEX_DxDvpUpdateVideoPort, (PFN)DxDvpUpdateVideoPort},
{DXG_INDEX_DxDvpWaitForVideoPortSync, (PFN)DxDvpWaitForVideoPortSync},
{DXG_INDEX_DxDvpAcquireNotification, (PFN)DxDvpAcquireNotification},
{DXG_INDEX_DxDvpReleaseNotification, (PFN)DxDvpReleaseNotification},
{DXG_INDEX_DxDdHeapVidMemAllocAligned, (PFN)DxDdHeapVidMemAllocAligned},
{DXG_INDEX_DxDdHeapVidMemFree, (PFN)DxDdHeapVidMemFree},
{DXG_INDEX_DxDdEnableDirectDraw, (PFN)DxDdEnableDirectDraw},
{DXG_INDEX_DxDdDisableDirectDraw, (PFN)DxDdDisableDirectDraw},
{DXG_INDEX_DxDdSuspendDirectDraw, (PFN)DxDdSuspendDirectDraw},
{DXG_INDEX_DxDdResumeDirectDraw, (PFN)DxDdResumeDirectDraw},
{DXG_INDEX_DxDdDynamicModeChange, (PFN)DxDdDynamicModeChange},
{DXG_INDEX_DxDdCloseProcess, (PFN)DxDdCloseProcess},
{DXG_INDEX_DxDdGetDirectDrawBound, (PFN)DxDdGetDirectDrawBound},
{DXG_INDEX_DxDdEnableDirectDrawRedirection, (PFN)DxDdEnableDirectDrawRedirection},
{DXG_INDEX_DxDdAllocPrivateUserMem, (PFN)DxDdAllocPrivateUserMem},
{DXG_INDEX_DxDdFreePrivateUserMem, (PFN)DxDdFreePrivateUserMem},
{DXG_INDEX_DxDdLockDirectDrawSurface, (PFN)DxDdLockDirectDrawSurface},
{DXG_INDEX_DxDdUnlockDirectDrawSurface, (PFN)DxDdUnlockDirectDrawSurface},
{DXG_INDEX_DxDdSetAccelLevel, (PFN)DxDdSetAccelLevel},
{DXG_INDEX_DxDdGetSurfaceLock, (PFN)DxDdGetSurfaceLock},
{DXG_INDEX_DxDdEnumLockedSurfaceRect, (PFN)DxDdEnumLockedSurfaceRect},
{DXG_INDEX_DxDdIoctl, (PFN)DxDdIoctl}
};

109
win32ss/reactx/dxg/dxg_int.h Normal file
View file

@ -0,0 +1,109 @@
#ifndef _DXG_PCH_
#define _DXG_PCH_
#include <ntifs.h>
/* Win32 Headers */
#define WINBASEAPI
#define STARTF_USESIZE 2
#define STARTF_USEPOSITION 4
#define INTERNAL_CALL NTAPI
#define NT_BUILD_ENVIRONMENT
#include <windef.h>
#include <winerror.h>
#include <wingdi.h>
#include <winddi.h>
/* DXG treats this as opaque */
typedef PVOID PDC;
typedef PVOID PW32THREAD;
typedef struct _DD_BASEOBJECT
{
HGDIOBJ hHmgr;
ULONG ulShareCount;
USHORT cExclusiveLock;
USHORT BaseFlags;
PW32THREAD Tid;
} DD_BASEOBJECT, *PDD_BASEOBJECT;
#include <drivers/directx/directxint.h>
#include <drivers/directx/dxg.h>
#include <drivers/directx/dxeng.h>
#include "tags.h"
#define ObjType_DDSURFACE_TYPE 2
#define ObjType_DDVIDEOPORT_TYPE 4
#define ObjType_DDMOTIONCOMP_TYPE 5
typedef struct _DD_ENTRY
{
union
{
PDD_BASEOBJECT pobj;
HANDLE hFree;
};
union
{
ULONG ulObj;
struct
{
USHORT Count;
USHORT Lock;
HANDLE Pid;
};
} ObjectOwner;
USHORT FullUnique;
UCHAR Objt;
UCHAR Flags;
PVOID pUser;
} DD_ENTRY, *PDD_ENTRY;
typedef struct _EDD_SURFACE_LOCAL
{
DD_BASEOBJECT Object;
DD_SURFACE_LOCAL Surfacelcl;
} EDD_SURFACE_LOCAL, *PEDD_SURFACE_LOCAL;
/* exported functions */
NTSTATUS NTAPI DriverEntry(IN PVOID Context1, IN PVOID Context2);
NTSTATUS NTAPI GsDriverEntry(IN PVOID Context1, IN PVOID Context2);
NTSTATUS APIENTRY DxDdCleanupDxGraphics(VOID);
BOOL NTAPI DxDdEnableDirectDraw(PVOID arg1, BOOL arg2);
/* Global pointers */
extern ULONG gcSizeDdHmgr;
extern PDD_ENTRY gpentDdHmgr;
extern ULONG gcMaxDdHmgr;
extern PDD_ENTRY gpentDdHmgrLast;
extern HANDLE ghFreeDdHmgr;
extern HSEMAPHORE ghsemHmgr;
extern LONG gcDummyPageRefCnt;
extern HSEMAPHORE ghsemDummyPage;
extern VOID *gpDummyPage;
extern PEPROCESS gpepSession;
extern PLARGE_INTEGER gpLockShortDelay;
/* Driver list export functions */
DWORD NTAPI DxDxgGenericThunk(ULONG_PTR ulIndex, ULONG_PTR ulHandle, SIZE_T *pdwSizeOfPtr1, PVOID pvPtr1, SIZE_T *pdwSizeOfPtr2, PVOID pvPtr2);
DWORD NTAPI DxDdIoctl(ULONG ulIoctl, PVOID pBuffer, ULONG ulBufferSize);
PDD_SURFACE_LOCAL NTAPI DxDdLockDirectDrawSurface(HANDLE hDdSurface);
BOOL NTAPI DxDdUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface);
/* Internal functions */
BOOL FASTCALL VerifyObjectOwner(PDD_ENTRY pEntry);
BOOL FASTCALL DdHmgCreate(VOID);
BOOL FASTCALL DdHmgDestroy(VOID);
PVOID FASTCALL DdHmgLock(HANDLE DdHandle, UCHAR ObjectType, BOOLEAN LockOwned);
/* define stuff */
#define drvDxEngLockDC gpEngFuncs[DXENG_INDEX_DxEngLockDC]
#define drvDxEngGetDCState gpEngFuncs[DXENG_INDEX_DxEngGetDCState]
#define drvDxEngGetHdevData gpEngFuncs[DXENG_INDEX_DxEngGetHdevData]
#define drvDxEngUnlockDC gpEngFuncs[DXENG_INDEX_DxEngUnlockDC]
#define drvDxEngUnlockHdev gpEngFuncs[DXENG_INDEX_DxEngUnlockHdev]
#define drvDxEngLockHdev gpEngFuncs[DXENG_INDEX_DxEngLockHdev]
#endif /* _DXG_PCH_ */

59
win32ss/reactx/dxg/eng.c Normal file
View file

@ -0,0 +1,59 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxg/eng.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 30/12-2007 Magnus Olsen
*/
#include <dxg_int.h>
PDD_SURFACE_LOCAL
NTAPI
DxDdLockDirectDrawSurface(HANDLE hDdSurface)
{
PEDD_SURFACE pEDDSurface = NULL;
PDD_SURFACE_LOCAL pSurfacelcl = NULL;
pEDDSurface = DdHmgLock(hDdSurface, ObjType_DDSURFACE_TYPE, FALSE);
if (pEDDSurface != NULL)
{
pSurfacelcl = &pEDDSurface->ddsSurfaceLocal;
}
return pSurfacelcl;
}
BOOL
NTAPI
DxDdUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
{
BOOL retVal = FALSE;
//PEDD_SURFACE pEDDSurface = NULL;
if (pSurface)
{
// pEDDSurface = (PEDD_SURFACE)( ((PBYTE)pSurface) - sizeof(DD_BASEOBJECT));
// InterlockedDecrement(&pEDDSurface->pobj.cExclusiveLock);
retVal = TRUE;
}
return retVal;
}
BOOL
NTAPI
DxDdEnableDirectDraw(PVOID arg1, BOOL arg2/*What for?*/)
{
// taken from CORE-4490
//PDEV_WIN32K pdev = (PDEV_WIN32K) arg1 ;
//return pdev->DriverFunctions.EnableDirectDraw(pdev->dhpdev,
// &pdev->EDDgpl.ddCallbacks,
// &pdev->EDDgpl.ddSurfaceCallbacks,
// &pdev->EDDgpl.ddPaletteCallbacks) ;
return TRUE;
}

88
win32ss/reactx/dxg/historic.c Normal file
View file

@ -0,0 +1,88 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxg/historic.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
#include <dxg_int.h>
/*++
* @name DxDxgGenericThunk
* @implemented
*
* The function DxDxgGenericThunk redirects DirectX calls to other functions.
*
* @param ULONG_PTR ulIndex
* The functions we want redirct
*
* @param ULONG_PTR ulHandle
* Unknown
*
* @param SIZE_T *pdwSizeOfPtr1
* Unknown
*
* @param PVOID pvPtr1
* Unknown
*
* @param SIZE_T *pdwSizeOfPtr2
* Unknown
*
* @param PVOID pvPtr2
* Unknown
*
* @return
* Always returns DDHAL_DRIVER_NOTHANDLED
*
* @remarks.
* This function is no longer used in Windows NT 2000/XP/2003
*
*--*/
DWORD
NTAPI
DxDxgGenericThunk(ULONG_PTR ulIndex,
ULONG_PTR ulHandle,
SIZE_T *pdwSizeOfPtr1,
PVOID pvPtr1,
SIZE_T *pdwSizeOfPtr2,
PVOID pvPtr2)
{
return DDHAL_DRIVER_NOTHANDLED;
}
/*++
* @name DxDdIoctl
* @implemented
*
* The function DxDdIoctl is the ioctl call to different DirectX functions
*
* @param ULONG ulIoctl
* The ioctl code that we want call to
*
* @param PVOID pBuffer
* Our in or out buffer with data to the ioctl code we are using
*
* @param ULONG ulBufferSize
* The buffer size in bytes
*
* @return
* Always returns DDERR_UNSUPPORTED
*
* @remarks.
* This function is no longer used in Windows NT 2000/XP/2003
*
*--*/
DWORD
NTAPI
DxDdIoctl(ULONG ulIoctl,
PVOID pBuffer,
ULONG ulBufferSize)
{
return DDERR_UNSUPPORTED;
}

131
win32ss/reactx/dxg/main.c Normal file
View file

@ -0,0 +1,131 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxg/main.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
#include <dxg_int.h>
#include "dxg_driver.h"
LONG gcDummyPageRefCnt = 0;
HSEMAPHORE ghsemDummyPage = NULL;
VOID *gpDummyPage = NULL;
PEPROCESS gpepSession = NULL;
PLARGE_INTEGER gpLockShortDelay = NULL;
PDRVFN gpEngFuncs;
const ULONG gcDxgFuncs = DXG_INDEX_DxDdIoctl + 1;
NTSTATUS NTAPI
DriverEntry(IN PVOID Context1,
IN PVOID Context2)
{
return 0;
}
NTSTATUS
APIENTRY
DxDdStartupDxGraphics (ULONG SizeEngDrv,
PDRVENABLEDATA pDxEngDrv,
ULONG SizeDxgDrv,
PDRVENABLEDATA pDxgDrv,
PULONG DirectDrawContext,
PEPROCESS Proc )
{
PDRVFN drv_func;
UINT i;
/* Test see if the data is vaild we got from win32k.sys */
if ((SizeEngDrv != sizeof(DRVENABLEDATA)) ||
(SizeDxgDrv != sizeof(DRVENABLEDATA)))
{
return STATUS_BUFFER_TOO_SMALL;
}
/* rest static value */
gpDummyPage = NULL;
gcDummyPageRefCnt = 0;
ghsemDummyPage = NULL;
/*
* Setup internal driver functions list we got from dxg driver functions list
*/
pDxgDrv->iDriverVersion = 0x80000; /* Note 12/1-2004 : DirectX 8 ? */
pDxgDrv->c = gcDxgFuncs;
pDxgDrv->pdrvfn = gaDxgFuncs;
/* check how many driver functions and fail if the value does not match */
if (pDxEngDrv->c != DXENG_INDEX_DxEngLoadImage + 1)
{
return STATUS_INTERNAL_ERROR;
}
/*
* Check if all drv functions are sorted right
* and if it really are exported
*/
for (i=1 ; i < DXENG_INDEX_DxEngLoadImage + 1; i++)
{
drv_func = &pDxEngDrv->pdrvfn[i];
if ((drv_func->iFunc != i) ||
(drv_func->pfn == NULL))
{
return STATUS_INTERNAL_ERROR;
}
}
gpEngFuncs = pDxEngDrv->pdrvfn;
/* Note 12/1-2004 : Why is this set to 0x618 */
*DirectDrawContext = 0x618;
if (DdHmgCreate())
{
ghsemDummyPage = EngCreateSemaphore();
if (ghsemDummyPage)
{
gpepSession = Proc;
return STATUS_SUCCESS;
}
}
DdHmgDestroy();
if (ghsemDummyPage)
{
EngDeleteSemaphore(ghsemDummyPage);
ghsemDummyPage = 0;
}
return STATUS_NO_MEMORY;
}
NTSTATUS
APIENTRY
DxDdCleanupDxGraphics(VOID)
{
DdHmgDestroy();
if (ghsemDummyPage != 0 )
{
if (gpDummyPage != 0 )
{
ExFreePoolWithTag(gpDummyPage,0);
gpDummyPage = NULL;
gcDummyPageRefCnt = 0;
}
EngDeleteSemaphore(ghsemDummyPage);
ghsemDummyPage = 0;
}
return 0;
}

2
win32ss/reactx/dxg/tags.h Normal file
View file

@ -0,0 +1,2 @@
#define TAG_THDD 'ddht'
#define TAG_GINI 'iniG'

12
win32ss/reactx/dxgthk/CMakeLists.txt Normal file
View file

@ -0,0 +1,12 @@
spec2def(dxgthk.sys dxgthk.spec ADD_IMPORTLIB)
list(APPEND SOURCE
main.c
dxgthk.rc
${CMAKE_CURRENT_BINARY_DIR}/dxgthk.def)
add_library(dxgthk SHARED ${SOURCE})
set_module_type(dxgthk kernelmodedriver)
add_importlibs(dxgthk win32k)
add_cd_file(TARGET dxgthk DESTINATION reactos/system32/drivers FOR all)

5
win32ss/reactx/dxgthk/dxgthk.rc Normal file
View file

@ -0,0 +1,5 @@
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "DirectX Graphics Driver Thunk"
#define REACTOS_STR_INTERNAL_NAME "dxgthk"
#define REACTOS_STR_ORIGINAL_FILENAME "dxgthk"
#include <reactos/version.rc>

19
win32ss/reactx/dxgthk/dxgthk.spec Normal file
View file

@ -0,0 +1,19 @@
@ stdcall EngAcquireSemaphore(ptr) win32k.EngAcquireSemaphore
@ stdcall EngAllocMem(long long long) win32k.EngAllocMem
@ stdcall EngAllocUserMem(long long) win32k.EngAllocUserMem
@ stdcall EngCopyBits(ptr ptr ptr ptr ptr ptr) win32k.EngCopyBits
@ stdcall EngCreateBitmap(long long long long ptr) win32k.EngCreateBitmap
@ stdcall EngCreatePalette(long long long long long long) win32k.EngCreatePalette
@ stdcall EngCreateSemaphore() win32k.EngCreateSemaphore
@ stdcall EngDeletePalette(ptr) win32k.EngDeletePalette
@ stdcall EngDeleteSemaphore(ptr) win32k.EngDeleteSemaphore
@ stdcall EngDeleteSurface(ptr) win32k.EngDeleteSurface
@ stdcall EngFindImageProcAddress(ptr str) win32k.EngFindImageProcAddress
@ stdcall EngFreeMem(ptr) win32k.EngFreeMem
@ stdcall EngFreeUserMem(ptr) win32k.EngFreeUserMem
@ stdcall EngLoadImage(wstr) win32k.EngLoadImage
@ stdcall EngLockSurface(ptr) win32k.EngLockSurface
@ stdcall EngReleaseSemaphore(ptr) win32k.EngReleaseSemaphore
@ stdcall EngSetLastError(long) win32k.EngSetLastError
@ stdcall EngUnloadImage(ptr) win32k.EngUnloadImage
@ stdcall EngUnlockSurface(ptr) win32k.EngUnlockSurface

26
win32ss/reactx/dxgthk/main.c Normal file
View file

@ -0,0 +1,26 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: win32ss/reactx/dxgthk/main.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
/* DDK/NDK/SDK Headers */
#include <ddk/ntddk.h>
NTSTATUS NTAPI
DriverEntry(IN PVOID Context1,
IN PVOID Context2)
{
/*
* NOTE this driver will never be load, it only contain export list
* to win32k eng functions
*/
return STATUS_SUCCESS;
}

392
win32ss/reactx/ntddraw/d3d.c Normal file
View file

@ -0,0 +1,392 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/d3d.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
/* Comment
* NtGdiDdLock and NtGdiDdLockD3D ultimately call the same function in dxg.sys
* NtGdiDdUnlock and NtGdiDdUnlockD3D ultimately call the same function in dxg.sys
*/
#include <win32k.h>
#include <debug.h>
/*++
* @name NtGdiDdCanCreateD3DBuffer
* @implemented
*
* The function NtGdiDdCanCreateD3DBuffer checks if you can create a
* surface for DirectX. it redirects to dxg.sys in windows XP/2003,
* dxkrnl.sys in vista and is fully implemented in win32k.sys in windows 2000 and below
*
* @param HANDLE hDirectDraw
* The handle we got from NtGdiDdCreateDirectDrawObject
*
* @param PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
* This contains information to check if the driver can create the buffers,
* surfaces, textures and vertexes, and how many of each the driver can create.
*
* @return
* Depending on if the driver supports this function or not, DDHAL_DRIVER_HANDLED
* or DDHAL_DRIVER_NOTHANDLED is returned.
* To check if the function has been successful, do a full check.
* A full check is done by checking if the return value is DDHAL_DRIVER_HANDLED
* and puCanCreateSurfaceData->ddRVal is set to DD_OK.
*
* @remarks.
* dxg.sys NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface calls are redirected to dxg.sys.
* Inside the dxg.sys they are redirected to the same function. Examine the memory addresses on the driver list functions
* table and you will see they are pointed to the same memory address.
*
* Before calling this function please set the puCanCreateSurfaceData->ddRVal to an error value such as DDERR_NOTUSPORTED,
* for the ddRVal will otherwise be unchanged even if an error occurs inside the driver.
* puCanCreateSurfaceData->lpDD is a pointer to DDRAWI_DIRECTDRAW_GBL, not PDD_DIRECTDRAW_GLOBAL as MSDN claims.
* puCanCreateSurfaceData->lpDD->hDD also needs be filled in with the handle we got from NtGdiDdCreateDirectDrawObject.
* puCreateSurfaceData->CanCreateSurface is a pointer to the real functions in the HAL or HEL, that you need fill in.
* Do not forget PDD_CANCREATESURFACEDATA is typecast of LPDDHAL_CANCREATESURFACEDATA and thuse two struct are different size,
* the correct struct is LPDDHAL_CANCREATESURFACEDATA.
*
*--*/
DWORD
APIENTRY
NtGdiDdCanCreateD3DBuffer(HANDLE hDirectDraw,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
PGD_DDCANCREATED3DBUFFER pfnDdCanCreateD3DBuffer = (PGD_DDCANCREATED3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdCanCreateD3DBuffer].pfn;
if (pfnDdCanCreateD3DBuffer == NULL)
{
DPRINT1("Warring no pfnDdCanCreateD3DBuffer");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdCanCreateD3DBuffer");
return pfnDdCanCreateD3DBuffer(hDirectDraw,puCanCreateSurfaceData);
}
/*++
* @name NtGdiD3dContextCreate
* @implemented
*
* The Function NtGdiD3dContextCreate checks if you can create a
* context for Directx. It redirects to dxg.sys in windows XP/2003,
* dxkrnl.sys in vista and is fully implemented in win32k.sys in windows 2000 and below
*
* @param HANDLE hDirectDrawLocal
* The handle we got from NtGdiDdCreateDirectDrawObject
*
* @param HANDLE hSurfColor
* Handle to DD_SURFACE_LOCAL to be used for the rendering target
*
* @param HANDLE hSurfZ
* Handle to a DD_SURFACE_LOCAL. It is the Z deep buffer. According MSDN if it is set to NULL nothing should happen.
*
* @param LPD3DNTHAL_CONTEXTCREATEDATA pdcci
* The buffer to create the context data
*
* @return
* DDHAL_DRIVER_HANDLED or DDHAL_DRIVER_NOTHANDLED if the driver supports this function.
* A full check is done by checking if the return value is DDHAL_DRIVER_HANDLED
* and pdcci->ddRVal is set to DD_OK.
*
*
* @remarks.
* dxg.sys NtGdiD3dContextCreate calls are redirected to the same function in the dxg.sys. As such they all work the same way.
*
* Before calling this function please set the pdcci->ddRVal to an error value such as DDERR_NOTSUPORTED,
* for the ddRVal will otherwise be unchanged even if an error occurs inside the driver.
*
* pdcci->lpDDLcl is a pointer to DDRAWI_DIRECTDRAW_LCL, not DD_DIRECTDRAW_LOCAL as MSDN claims.
* pdcci->lpDDSLcl is a pointer to DDRAWI_DDRAWSURFACE_LCL, not DD_DDDRAWSURFACE_LOCAL as MSDN claims.
* pdcci->lpDDSZLcl is a pointer to DDRAWI_DDRAWSURFACE_LCL, not DD_DDRAWSURFACE_LOCAL as MSDN claims.
* pdcci->dwhContext also needs be filled in with the handle we receive from NtGdiDdCreateDirectDrawObject.
* pdcci->dwPID the processid it belong to, that you need to fill in.
* Do not forget LPD3DNTHAL_CONTEXTCREATEDATA is typecast of LPD3DHAL_CONTEXTCREATEDATA and thuse two struct are different size,
* the correct struct is LPD3DHAL_CONTEXTCREATEDATA.
*--*/
BOOL
APIENTRY
NtGdiD3dContextCreate(HANDLE hDirectDrawLocal,
HANDLE hSurfColor,
HANDLE hSurfZ,
LPD3DNTHAL_CONTEXTCREATEDATA pdcci)
{
PGD_D3DCONTEXTCREATE pfnD3dContextCreate = (PGD_D3DCONTEXTCREATE)gpDxFuncs[DXG_INDEX_DxD3dContextCreate].pfn;
if (pfnD3dContextCreate == NULL)
{
DPRINT1("Warning: no pfnD3dContextCreate");
return FALSE;
}
DPRINT1("Calling dxg.sys D3dContextCreate");
return pfnD3dContextCreate(hDirectDrawLocal, hSurfColor, hSurfZ, pdcci);
}
/*++
* @name NtGdiD3dContextDestroy
* @implemented
*
* The Function NtGdiD3dContextDestroy destorys the context data we got from NtGdiD3dContextCreate
* It redirects to dxg.sys in windows XP/2003, dxkrnl.sys in vista and is fully implemented
* in win32k.sys in windows 2000 and below
*
* @param LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData
* The context data we want to destroy
*
* @remarks.
* dxg.sys NtGdiD3dContextDestroy calls are redirected to the same functions in the dxg.sys. As such they all work the same way.
*
* Before calling this function please set the pContextDestroyData->ddRVal to an error value such DDERR_NOTUSPORTED,
* for the ddRVal will otherwise be unchanged even if an error occurs inside the driver.
* pContextDestroyData->dwhContext also needs to be filled in with the handle we got from NtGdiDdCreateDirectDrawObject
*
*--*/
DWORD
APIENTRY
NtGdiD3dContextDestroy(LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData)
{
PGD_D3DCONTEXTDESTROY pfnD3dContextDestroy = (PGD_D3DCONTEXTDESTROY)gpDxFuncs[DXG_INDEX_DxD3dContextDestroy].pfn;
if ( pfnD3dContextDestroy == NULL)
{
DPRINT1("Warning: no pfnD3dContextDestroy");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dContextDestroy");
return pfnD3dContextDestroy(pContextDestroyData);
}
/*++
* @name NtGdiD3dContextDestroyAll
* @implemented
*
* The Function NtGdiD3dContextDestroyAll destroys all the context data in a process
* The data having been allocated with NtGdiD3dContextCreate
* It redirects to dxg.sys in windows XP/2003, dxkrnl.sys in vista and is fully implemented
* in win32k.sys in windows 2000 and below
*
* @param LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad
* The context data we want to destory
*
* @remarks.
* dxg.sys NtGdiD3dContextDestroy calls are redirected to the same function in the dxg.sys. As such they all work the same way.
*
* Before calling this function please set the pdcad->ddRVal to an error value such as DDERR_NOTUSPORTED,
* for the ddRVal will otherwise be unchanged even if an error occurs inside the driver.
* pdcad->dwPID also needs to be filled in with the ID of the process that needs its context data destroyed.
*
* Warning: MSDN is wrong about this function. It claims the function queries free memory and does not accept
* any parameters. Last time MSDN checked: 19/10-2007
*--*/
DWORD
APIENTRY
NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad)
{
PGD_D3DCONTEXTDESTROYALL pfnD3dContextDestroyAll = (PGD_D3DCONTEXTDESTROYALL)gpDxFuncs[DXG_INDEX_DxD3dContextDestroyAll].pfn;
if (pfnD3dContextDestroyAll == NULL)
{
DPRINT1("Warning: no pfnD3dContextDestroyAll");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dContextDestroyAll");
return pfnD3dContextDestroyAll(pdcad);
}
/*++
* @name NtGdiDdCreateD3DBuffer
* @implemented
*
* The function NtGdiDdCreateD3DBuffer creates a surface for DirectX.
* It redirects to dxg.sys in windows XP/2003, dxkrnl.sys in vista and is fully implemented
* in win32k.sys in windows 2000 and below
*
* @param HANDLE hDirectDraw
* The handle we got from NtGdiDdCreateDirectDrawObject
*
* @param HANDLE *hSurface
* <FILLMEIN>
*
* @param DDSURFACEDESC puSurfaceDescription
* Surface description: what kind of surface it should be. Examples: RGB, compress, deep, and etc
* See DDSURFACEDESC for more information
*
* @param DD_SURFACE_GLOBAL *puSurfaceGlobalData
* <FILLMEIN>
*
* @param DD_SURFACE_LOCAL *puSurfaceLocalData
* <FILLMEIN>
*
* @param DD_SURFACE_MORE *puSurfaceMoreData
* <FILLMEIN>
*
* @param PDD_CREATESURFACEDATA puCreateSurfaceData
* <FILLMEIN>
*
* @param HANDLE *puhSurface
* <FILLMEIN>
*
* @return
* Depending on if the driver supports this function or not, DDHAL_DRIVER_HANDLED
* or DDHAL_DRIVER_NOTHANDLED is returned.
* To check if the function was successful, do a full check.
* A full check is done by checking if the return value is DDHAL_DRIVER_HANDLED
* and puCanCreateSurfaceData->ddRVal is set to DD_OK.
*
* @remarks.
* dxg.sys NtGdiDdCreateD3DBuffer and NtGdiDdCreateSurface calls are redirected to dxg.sys.
* Inside the dxg.sys they are redirected to the same function. Examine the memory addresses on the driver list functions
* table and you will see they are pointed to the same memory address.
*
* Before calling this function please set the puCreateSurfaceData->ddRVal to an error value such as DDERR_NOTUSPORTED,
* for the ddRVal will otherwise be unchanged even if an error occurs inside the driver.
* puCreateSurfaceData->lpDD is a pointer to DDRAWI_DIRECTDRAW_GBL. MSDN claims it is PDD_DIRECTDRAW_GLOBAL but it is not.
* puCreateSurfaceData->lpDD->hDD also needs to be filled in with the handle we got from NtGdiDdCreateDirectDrawObject
* puCreateSurfaceData->CreateSurface is a pointer to the real functions in the HAL or HEL, that you need fill in
*
*--*/
DWORD
APIENTRY
NtGdiDdCreateD3DBuffer(HANDLE hDirectDraw,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
DD_SURFACE_GLOBAL *puSurfaceGlobalData,
DD_SURFACE_LOCAL *puSurfaceLocalData,
DD_SURFACE_MORE *puSurfaceMoreData,
PDD_CREATESURFACEDATA puCreateSurfaceData,
HANDLE *puhSurface)
{
PGD_DDCREATED3DBUFFER pfnDdCreateD3DBuffer = (PGD_DDCREATED3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdCreateD3DBuffer].pfn;
if (pfnDdCreateD3DBuffer == NULL)
{
DPRINT1("Warning: no pfnDdCreateD3DBuffer");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateD3DBuffer");
return pfnDdCreateD3DBuffer(hDirectDraw, hSurface,
puSurfaceDescription, puSurfaceGlobalData,
puSurfaceLocalData, puSurfaceMoreData,
puCreateSurfaceData, puhSurface);
}
/************************************************************************/
/* NtGdiDdDestroyD3DBuffer */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdDestroyD3DBuffer(HANDLE hSurface)
{
PGD_DXDDDESTROYD3DBUFFER pfnDdDestroyD3DBuffer = (PGD_DXDDDESTROYD3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdDestroyD3DBuffer].pfn;
if (pfnDdDestroyD3DBuffer == NULL)
{
DPRINT1("Warning: no pfnDdDestroyD3DBuffer");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdDestroyD3DBuffer");
return pfnDdDestroyD3DBuffer(hSurface);
}
/************************************************************************/
/* NtGdiD3dDrawPrimitives2 */
/************************************************************************/
DWORD
APIENTRY
NtGdiD3dDrawPrimitives2(HANDLE hCmdBuf,
HANDLE hVBuf,
LPD3DNTHAL_DRAWPRIMITIVES2DATA pded,
FLATPTR *pfpVidMemCmd,
DWORD *pdwSizeCmd,
FLATPTR *pfpVidMemVtx,
DWORD *pdwSizeVtx)
{
PGD_D3DDRAWPRIMITIVES2 pfnD3dDrawPrimitives2 = (PGD_D3DDRAWPRIMITIVES2)gpDxFuncs[DXG_INDEX_DxD3dDrawPrimitives2].pfn;
if (pfnD3dDrawPrimitives2 == NULL)
{
DPRINT1("Warning: no pfnD3dDrawPrimitives2");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dDrawPrimitives2");
return pfnD3dDrawPrimitives2(hCmdBuf,hVBuf,pded,pfpVidMemCmd,pdwSizeCmd,pfpVidMemVtx,pdwSizeVtx);
}
/************************************************************************/
/* NtGdiD3dValidateTextureStageState */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdLockD3D(HANDLE hSurface,
PDD_LOCKDATA puLockData)
{
PGD_DXDDLOCKD3D pfnDdLockD3D = (PGD_DXDDLOCKD3D)gpDxFuncs[DXG_INDEX_DxDdLockD3D].pfn;
if (pfnDdLockD3D == NULL)
{
DPRINT1("Warning: no pfnDdLockD3D");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdLockD3D");
return pfnDdLockD3D(hSurface, puLockData);
}
/************************************************************************/
/* NtGdiD3dValidateTextureStageState */
/************************************************************************/
DWORD
APIENTRY
NtGdiD3dValidateTextureStageState(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData)
{
PGD_D3DVALIDATETEXTURESTAGESTATE pfnD3dValidateTextureStageState = (PGD_D3DVALIDATETEXTURESTAGESTATE)gpDxFuncs[DXG_INDEX_DxD3dValidateTextureStageState].pfn;
if (pfnD3dValidateTextureStageState == NULL)
{
DPRINT1("Warning: no pfnD3dValidateTextureStageState");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dValidateTextureStageState");
return pfnD3dValidateTextureStageState(pData);
}
/************************************************************************/
/* NtGdiDdUnlockD3D */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdUnlockD3D(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
PGD_DXDDUNLOCKD3D pfnDdUnlockD3D = (PGD_DXDDUNLOCKD3D)gpDxFuncs[DXG_INDEX_DxDdUnlockD3D].pfn;
if (pfnDdUnlockD3D == NULL)
{
DPRINT1("Warning: no pfnDdUnlockD3D");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdUnlockD3D");
return pfnDdUnlockD3D(hSurface, puUnlockData);
}

130
win32ss/reactx/ntddraw/dd.c Normal file
View file

@ -0,0 +1,130 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/dd.c
* PROGRAMER: Magnus Olsen (greatlord@reactos.org)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
/************************************************************************/
/* NtGdiDdCreateSurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdCreateSurface(HANDLE hDirectDrawLocal,
HANDLE *hSurface,
DDSURFACEDESC *puSurfaceDescription,
DD_SURFACE_GLOBAL *puSurfaceGlobalData,
DD_SURFACE_LOCAL *puSurfaceLocalData,
DD_SURFACE_MORE *puSurfaceMoreData,
PDD_CREATESURFACEDATA puCreateSurfaceData,
HANDLE *puhSurface)
{
PGD_DDCREATESURFACE pfnDdCreateSurface = (PGD_DDCREATESURFACE)gpDxFuncs[DXG_INDEX_DxDdCreateSurface].pfn;
if (pfnDdCreateSurface == NULL)
{
DPRINT1("Warning: no pfnDdCreateSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurface\n");
return pfnDdCreateSurface(hDirectDrawLocal,hSurface,puSurfaceDescription,puSurfaceGlobalData,
puSurfaceLocalData,puSurfaceMoreData,puCreateSurfaceData,puhSurface);
}
/************************************************************************/
/* NtGdiDdWaitForVerticalBlank */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
{
PGD_DXDDWAITFORVERTICALBLANK pfnDdWaitForVerticalBlank = (PGD_DXDDWAITFORVERTICALBLANK)gpDxFuncs[DXG_INDEX_DxDdWaitForVerticalBlank].pfn;
if (pfnDdWaitForVerticalBlank == NULL)
{
DPRINT1("Warning: no pfnDdWaitForVerticalBlank\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdWaitForVerticalBlank\n");
return pfnDdWaitForVerticalBlank(hDirectDraw, puWaitForVerticalBlankData);
}
/************************************************************************/
/* NtGdiDdCanCreateSurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
PGD_DDCANCREATESURFACE pfnDdCanCreateSurface = (PGD_DDCANCREATESURFACE)gpDxFuncs[DXG_INDEX_DxDdCanCreateSurface].pfn;
if (pfnDdCanCreateSurface == NULL)
{
DPRINT1("Warning: no pfnDdCanCreateSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCanCreateSurface\n");
return pfnDdCanCreateSurface(hDirectDrawLocal,puCanCreateSurfaceData);
}
/************************************************************************/
/* NtGdiDdGetScanLine */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetScanLine(HANDLE hDirectDrawLocal,
PDD_GETSCANLINEDATA puGetScanLineData)
{
PGD_DXDDGETSCANLINE pfnDdGetScanLine = (PGD_DXDDGETSCANLINE)gpDxFuncs[DXG_INDEX_DxDdGetScanLine].pfn;
if (pfnDdGetScanLine == NULL)
{
DPRINT1("Warning: no pfnDdGetScanLine\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetScanLine\n");
return pfnDdGetScanLine(hDirectDrawLocal,puGetScanLineData);
}
/************************************************************************/
/* This is not part of the ddsurface interface but it */
/* deals with the surface */
/************************************************************************/
/************************************************************************/
/* NtGdiDdCreateSurfaceEx */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw,
HANDLE hSurface,
DWORD dwSurfaceHandle)
{
PGD_DXDDCREATESURFACEEX pfnDdCreateSurfaceEx = (PGD_DXDDCREATESURFACEEX)gpDxFuncs[DXG_INDEX_DxDdCreateSurfaceEx].pfn;
if (pfnDdCreateSurfaceEx == NULL)
{
DPRINT1("Warning: no pfnDdCreateSurfaceEx\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurfaceEx\n");
return pfnDdCreateSurfaceEx(hDirectDraw,hSurface,dwSurfaceHandle);
}

1506
win32ss/reactx/ntddraw/ddraw.c Normal file
View file

File diff suppressed because it is too large Load diff

314
win32ss/reactx/ntddraw/ddsurf.c Normal file
View file

@ -0,0 +1,314 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/ddsurf.c
* PROGRAMER: Magnus Olsen (greatlord@reactos.org)
* REVISION HISTORY:
* 19/7-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
/************************************************************************/
/* NtGdiDdDestroySurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy)
{
PGD_DXDDDESTROYSURFACE pfnDdDestroySurface = (PGD_DXDDDESTROYSURFACE)gpDxFuncs[DXG_INDEX_DxDdDestroySurface].pfn;
if (pfnDdDestroySurface == NULL)
{
DPRINT1("Warning: no pfnDdDestroySurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdDestroySurface");
return pfnDdDestroySurface(hSurface, bRealDestroy);
}
/************************************************************************/
/* NtGdiDdFlip */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdFlip(HANDLE hSurfaceCurrent,
HANDLE hSurfaceTarget,
HANDLE hSurfaceCurrentLeft,
HANDLE hSurfaceTargetLeft,
PDD_FLIPDATA puFlipData)
{
PGD_DXDDFLIP pfnDdDdFlip = (PGD_DXDDFLIP)gpDxFuncs[DXG_INDEX_DxDdFlip].pfn;
if (pfnDdDdFlip == NULL)
{
DPRINT1("Warning: no pfnDdDdFlip");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdDdFlip");
return pfnDdDdFlip(hSurfaceCurrent, hSurfaceTarget, hSurfaceCurrentLeft, hSurfaceTargetLeft, puFlipData);
}
/************************************************************************/
/* NtGdiDdUnlock */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdLock(HANDLE hSurface,
PDD_LOCKDATA puLockData,
HDC hdcClip)
{
PGD_DXDDLOCK pfnDdLock = (PGD_DXDDLOCK)gpDxFuncs[DXG_INDEX_DxDdLock].pfn;
if (pfnDdLock == NULL)
{
DPRINT1("Warning: no pfnDdLock");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdLock");
return pfnDdLock(hSurface, puLockData, hdcClip);
}
/************************************************************************/
/* NtGdiDdunlock */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdUnlock(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
PGD_DXDDUNLOCK pfnDdUnlock = (PGD_DXDDUNLOCK)gpDxFuncs[DXG_INDEX_DxDdUnlock].pfn;
if (pfnDdUnlock == NULL)
{
DPRINT1("Warning: no pfnDdUnlock");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUnlock");
return pfnDdUnlock(hSurface, puUnlockData);
}
/************************************************************************/
/* NtGdiDdBlt */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
{
PGD_DDBLT pfnDdBlt = (PGD_DDBLT)gpDxFuncs[DXG_INDEX_DxDdBlt].pfn;
if (pfnDdBlt == NULL)
{
DPRINT1("Warning: no pfnDdBlt");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdBlt");
return pfnDdBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
/************************************************************************/
/* NtGdiDdSetColorKey */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdSetColorKey(HANDLE hSurface,
PDD_SETCOLORKEYDATA puSetColorKeyData)
{
PGD_DXDDSETCOLORKEY pfnDdSetColorKey = (PGD_DXDDSETCOLORKEY)gpDxFuncs[DXG_INDEX_DxDdSetColorKey].pfn;
if (pfnDdSetColorKey == NULL)
{
DPRINT1("Warning: no pfnDdSetColorKey");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetColorKey");
return pfnDdSetColorKey(hSurface,puSetColorKeyData);
}
/************************************************************************/
/* NtGdiDdAddAttachedSurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdAddAttachedSurface(HANDLE hSurface,
HANDLE hSurfaceAttached,
PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData)
{
PGD_DDADDATTACHEDSURFACE pfnDdAddAttachedSurface = (PGD_DDADDATTACHEDSURFACE)gpDxFuncs[DXG_INDEX_DxDdAddAttachedSurface].pfn;
if (pfnDdAddAttachedSurface == NULL)
{
DPRINT1("Warning: no pfnDdAddAttachedSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAddAttachedSurface");
return pfnDdAddAttachedSurface(hSurface,hSurfaceAttached,puAddAttachedSurfaceData);
}
/************************************************************************/
/* NtGdiDdGetBltStatus */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetBltStatus(HANDLE hSurface,
PDD_GETBLTSTATUSDATA puGetBltStatusData)
{
PGD_DXDDGETBLTSTATUS pfnDdGetBltStatus = (PGD_DXDDGETBLTSTATUS)gpDxFuncs[DXG_INDEX_DxDdGetBltStatus].pfn;
if (pfnDdGetBltStatus == NULL)
{
DPRINT1("Warning: no pfnDdGetBltStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetBltStatus");
return pfnDdGetBltStatus(hSurface,puGetBltStatusData);
}
/************************************************************************/
/* NtGdiDdGetFlipStatus */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetFlipStatus(HANDLE hSurface,
PDD_GETFLIPSTATUSDATA puGetFlipStatusData)
{
PGD_DXDDGETFLIPSTATUS pfnDdGetFlipStatus = (PGD_DXDDGETFLIPSTATUS)gpDxFuncs[DXG_INDEX_DxDdGetFlipStatus].pfn;
if (pfnDdGetFlipStatus == NULL)
{
DPRINT1("Warning: no pfnDdGetFlipStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetFlipStatus");
return pfnDdGetFlipStatus(hSurface,puGetFlipStatusData);
}
/************************************************************************/
/* NtGdiDdUpdateOverlay */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdUpdateOverlay(HANDLE hSurfaceDestination,
HANDLE hSurfaceSource,
PDD_UPDATEOVERLAYDATA puUpdateOverlayData)
{
PGD_DXDDUPDATEOVERLAY pfnDdUpdateOverlay = (PGD_DXDDUPDATEOVERLAY)gpDxFuncs[DXG_INDEX_DxDdUpdateOverlay].pfn;
if (pfnDdUpdateOverlay == NULL)
{
DPRINT1("Warning: no pfnDdUpdateOverlay");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUpdateOverlay");
return pfnDdUpdateOverlay(hSurfaceDestination,hSurfaceSource,puUpdateOverlayData);
}
/************************************************************************/
/* NtGdiDdSetOverlayPosition */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource,
HANDLE hSurfaceDestination,
PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData)
{
PGD_DXDDSETOVERLAYPOSITION pfnDdSetOverlayPosition = (PGD_DXDDSETOVERLAYPOSITION)gpDxFuncs[DXG_INDEX_DxDdSetOverlayPosition].pfn;
if (pfnDdSetOverlayPosition == NULL)
{
DPRINT1("Warning: no pfnDdSetOverlayPosition");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetOverlayPosition");
return pfnDdSetOverlayPosition(hSurfaceSource,hSurfaceDestination,puSetOverlayPositionData);
}
/************************************************************************/
/* This is not part of the ddsurface interface but it */
/* deals with the surface */
/************************************************************************/
/************************************************************************/
/* NtGdiDdAlphaBlt */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdAlphaBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
{
PGD_DDALPHABLT pfnDdAlphaBlt = (PGD_DDALPHABLT)gpDxFuncs[DXG_INDEX_DxDdAlphaBlt].pfn;
if (pfnDdAlphaBlt == NULL)
{
DPRINT1("Warning: no pfnDdAlphaBlt");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAlphaBlt");
return pfnDdAlphaBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
/************************************************************************/
/* NtGdiDdAttachSurface */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdAttachSurface(HANDLE hSurfaceFrom,
HANDLE hSurfaceTo
)
{
PGD_DDATTACHSURFACE pfnDdAttachSurface = (PGD_DDATTACHSURFACE)gpDxFuncs[DXG_INDEX_DxDdAttachSurface].pfn;
if (pfnDdAttachSurface == NULL)
{
DPRINT1("Warning: no pfnDdAttachSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdAttachSurface");
return pfnDdAttachSurface(hSurfaceFrom,hSurfaceTo);
}
/************************************************************************/
/* NtGdiDdUnattachSurface */
/************************************************************************/
/* Note: MSDN protypes is VOID APIENTRY NtGdiDdUnattachSurface(HANDLE hSurface, HANDLE hSurfaceAttached)
But it say it return either DDHAL_DRIVER_NOTHANDLED or DDHAL_DRIVER_HANDLED
so I guess it is a typo in MSDN for this prototype for the info contradicts itself.
*/
NTSTATUS
APIENTRY
NtGdiDdUnattachSurface(HANDLE hSurface,
HANDLE hSurfaceAttached)
{
PGD_DXDDUNATTACHSURFACE pfnDdUnattachSurface = (PGD_DXDDUNATTACHSURFACE)gpDxFuncs[DXG_INDEX_DxDdUnattachSurface].pfn;
if (pfnDdUnattachSurface == NULL)
{
DPRINT1("Warning: no pfnDdUnattachSurface");
//return DDHAL_DRIVER_NOTHANDLED;
return STATUS_NOT_IMPLEMENTED;
}
DPRINT1("Calling on dxg.sys pfnDdUnattachSurface");
return pfnDdUnattachSurface(hSurface,hSurfaceAttached);
}

375
win32ss/reactx/ntddraw/dvp.c Normal file
View file

@ -0,0 +1,375 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/dvp.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
/************************************************************************/
/* NtGdiDvpCanCreateVideoPort */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpCanCreateVideoPort(HANDLE hDirectDraw,
PDD_CANCREATEVPORTDATA puCanCreateVPortData)
{
PGD_DVPCANCREATEVIDEOPORT pfnDvpCanCreateVideoPort = (PGD_DVPCANCREATEVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpCanCreateVideoPort].pfn;
if (pfnDvpCanCreateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpCanCreateVideoPort");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpCanCreateVideoPort");
return pfnDvpCanCreateVideoPort(hDirectDraw, puCanCreateVPortData);
}
/************************************************************************/
/* NtGdiDvpColorControl */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpColorControl(HANDLE hVideoPort,
PDD_VPORTCOLORDATA puVPortColorData)
{
PGD_DVPCOLORCONTROL pfnDvpColorControl = (PGD_DVPCOLORCONTROL)gpDxFuncs[DXG_INDEX_DxDvpColorControl].pfn;
if (pfnDvpColorControl == NULL)
{
DPRINT1("Warning: no pfnDvpColorControl");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpColorControl");
return pfnDvpColorControl(hVideoPort, puVPortColorData);
}
/************************************************************************/
/* NtGdiDvpCreateVideoPort */
/************************************************************************/
HANDLE
APIENTRY
NtGdiDvpCreateVideoPort(HANDLE hDirectDraw,
PDD_CREATEVPORTDATA puCreateVPortData)
{
PGD_DVPCREATEVIDEOPORT pfnDvpCreateVideoPort = (PGD_DVPCREATEVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpCreateVideoPort].pfn;
if (pfnDvpCreateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpCreateVideoPort");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpCreateVideoPort");
return pfnDvpCreateVideoPort(hDirectDraw, puCreateVPortData);
}
/************************************************************************/
/* NtGdiDvpDestroyVideoPort */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpDestroyVideoPort(HANDLE hVideoPort,
PDD_DESTROYVPORTDATA puDestroyVPortData)
{
PGD_DVPDESTROYVIDEOPORT pfnDvpDestroyVideoPort = (PGD_DVPDESTROYVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpDestroyVideoPort].pfn;
if (pfnDvpDestroyVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpDestroyVideoPort");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpDestroyVideoPort");
return pfnDvpDestroyVideoPort(hVideoPort, puDestroyVPortData);
}
/************************************************************************/
/* NtGdiDvpFlipVideoPort */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpFlipVideoPort(HANDLE hVideoPort,
HANDLE hDDSurfaceCurrent,
HANDLE hDDSurfaceTarget,
PDD_FLIPVPORTDATA puFlipVPortData)
{
PGD_DVPFLIPVIDEOPORT pfnDvpFlipVideoPort = (PGD_DVPFLIPVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpFlipVideoPort].pfn;
if (pfnDvpFlipVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpFlipVideoPort");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpFlipVideoPort");
return pfnDvpFlipVideoPort(hVideoPort, hDDSurfaceCurrent, hDDSurfaceTarget, puFlipVPortData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortBandwidth */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortBandwidth(HANDLE hVideoPort,
PDD_GETVPORTBANDWIDTHDATA puGetVPortBandwidthData)
{
PGD_DVPGETVIDEOPORTBANDWITH pfnDvpGetVideoPortBandwidth = (PGD_DVPGETVIDEOPORTBANDWITH)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortBandwidth].pfn;
if (pfnDvpGetVideoPortBandwidth == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortBandwidth");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortBandwidth");
return pfnDvpGetVideoPortBandwidth(hVideoPort, puGetVPortBandwidthData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortFlipStatus */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortFlipStatus(HANDLE hDirectDraw,
PDD_GETVPORTFLIPSTATUSDATA puGetVPortFlipStatusData)
{
PGD_DXDVPGETVIDEOPORTFLIPSTATUS pfnDvpGetVideoPortFlipStatus = (PGD_DXDVPGETVIDEOPORTFLIPSTATUS)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortFlipStatus].pfn;
if (pfnDvpGetVideoPortFlipStatus == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortFlipStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortFlipStatus");
return pfnDvpGetVideoPortFlipStatus(hDirectDraw, puGetVPortFlipStatusData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortInputFormats */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortInputFormats(HANDLE hVideoPort,
PDD_GETVPORTINPUTFORMATDATA puGetVPortInputFormatData)
{
PGD_DXDVPGETVIDEOPORTINPUTFORMATS pfnDvpGetVideoPortInputFormats = (PGD_DXDVPGETVIDEOPORTINPUTFORMATS)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortInputFormats].pfn;
if (pfnDvpGetVideoPortInputFormats == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortInputFormats");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortInputFormats");
return pfnDvpGetVideoPortInputFormats(hVideoPort, puGetVPortInputFormatData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortLine */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortLine(HANDLE hVideoPort,
PDD_GETVPORTLINEDATA puGetVPortLineData)
{
PGD_DXDVPGETVIDEOPORTLINE pfnDvpGetVideoPortLine = (PGD_DXDVPGETVIDEOPORTLINE)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortLine].pfn;
if (pfnDvpGetVideoPortLine == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortLine");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortLine");
return pfnDvpGetVideoPortLine(hVideoPort, puGetVPortLineData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortOutputFormats */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortOutputFormats(HANDLE hVideoPort,
PDD_GETVPORTOUTPUTFORMATDATA puGetVPortOutputFormatData)
{
PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS pfnDvpGetVideoPortOutputFormats = (PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortOutputFormats].pfn;
if (pfnDvpGetVideoPortOutputFormats == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortOutputFormats");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortOutputFormats");
return pfnDvpGetVideoPortOutputFormats(hVideoPort, puGetVPortOutputFormatData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortConnectInfo */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortConnectInfo(HANDLE hDirectDraw,
PDD_GETVPORTCONNECTDATA puGetVPortConnectData)
{
PGD_DXDVPGETVIDEOPORTCONNECTINFO pfnDvpGetVideoPortConnectInfo = (PGD_DXDVPGETVIDEOPORTCONNECTINFO)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortConnectInfo].pfn;
if (pfnDvpGetVideoPortConnectInfo == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortConnectInfo");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortConnectInfo");
return pfnDvpGetVideoPortConnectInfo(hDirectDraw, puGetVPortConnectData);
}
/************************************************************************/
/* NtGdiDvpGetVideoSignalStatus */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoSignalStatus(HANDLE hVideoPort,
PDD_GETVPORTSIGNALDATA puGetVPortSignalData)
{
PGD_DXDVPGETVIDEOSIGNALSTATUS pfnDvpGetVideoSignalStatus = (PGD_DXDVPGETVIDEOSIGNALSTATUS)gpDxFuncs[DXG_INDEX_DxDvpGetVideoSignalStatus].pfn;
if (pfnDvpGetVideoSignalStatus == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoSignalStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoSignalStatus");
return pfnDvpGetVideoSignalStatus(hVideoPort, puGetVPortSignalData);
}
/************************************************************************/
/* NtGdiDvpUpdateVideoPort */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpUpdateVideoPort(HANDLE hVideoPort,
HANDLE* phSurfaceVideo,
HANDLE* phSurfaceVbi,
PDD_UPDATEVPORTDATA puUpdateVPortData)
{
PGD_DXDVPUPDATEVIDEOPORT pfnDvpUpdateVideoPort = (PGD_DXDVPUPDATEVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpUpdateVideoPort].pfn;
if (pfnDvpUpdateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpUpdateVideoPort");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpUpdateVideoPort");
return pfnDvpUpdateVideoPort(hVideoPort, phSurfaceVideo, phSurfaceVbi, puUpdateVPortData);
}
/************************************************************************/
/* NtGdiDvpWaitForVideoPortSync */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpWaitForVideoPortSync(HANDLE hVideoPort,
PDD_WAITFORVPORTSYNCDATA puWaitForVPortSyncData)
{
PGD_DXDVPWAITFORVIDEOPORTSYNC pfnDvpWaitForVideoPortSync = (PGD_DXDVPWAITFORVIDEOPORTSYNC)gpDxFuncs[DXG_INDEX_DxDvpWaitForVideoPortSync].pfn;
if (pfnDvpWaitForVideoPortSync == NULL)
{
DPRINT1("Warning: no pfnDvpWaitForVideoPortSync");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpWaitForVideoPortSync");
return pfnDvpWaitForVideoPortSync(hVideoPort, puWaitForVPortSyncData);
}
/************************************************************************/
/* NtGdiDvpAcquireNotification */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpAcquireNotification(HANDLE hVideoPort,
HANDLE* hEvent,
LPDDVIDEOPORTNOTIFY pNotify)
{
PGD_DXDVPACQUIRENOTIFICATION pfnDvpAcquireNotification = (PGD_DXDVPACQUIRENOTIFICATION)gpDxFuncs[DXG_INDEX_DxDvpAcquireNotification].pfn;
if (pfnDvpAcquireNotification == NULL)
{
DPRINT1("Warning: no pfnDvpAcquireNotification");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpAcquireNotification");
return pfnDvpAcquireNotification(hVideoPort, hEvent, pNotify);
}
/************************************************************************/
/* NtGdiDvpReleaseNotification */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpReleaseNotification(HANDLE hVideoPort,
HANDLE hEvent)
{
PGD_DXDVPRELEASENOTIFICATION pfnDvpReleaseNotification = (PGD_DXDVPRELEASENOTIFICATION)gpDxFuncs[DXG_INDEX_DxDvpReleaseNotification].pfn;
if (pfnDvpReleaseNotification == NULL)
{
DPRINT1("Warning: no pfnDvpReleaseNotification");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpReleaseNotification");
return pfnDvpReleaseNotification(hVideoPort, hEvent);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortField */
/************************************************************************/
DWORD
APIENTRY
NtGdiDvpGetVideoPortField(HANDLE hVideoPort,
PDD_GETVPORTFIELDDATA puGetVPortFieldData)
{
PGD_DXDVPGETVIDEOPORTFIELD pfnDvpGetVideoPortField = (PGD_DXDVPGETVIDEOPORTFIELD)gpDxFuncs[DXG_INDEX_DxDvpGetVideoPortField].pfn;
if (pfnDvpGetVideoPortField == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortField");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortField");
return pfnDvpGetVideoPortField(hVideoPort, puGetVPortFieldData);
}

893
win32ss/reactx/ntddraw/dxeng.c Normal file
View file

@ -0,0 +1,893 @@
/*
* PROJECT: ReactOS Win32 Subsystem
* LICENSE: GPL - See COPYING in the top level directory
* FILE: win32ss/reactx/ntddraw/dxeng.c
* PURPOSE: Implementation of DxEng functions
* PROGRAMMERS: Magnus Olsen (magnus@greatlord.com)
*/
#include <win32k.h>
#include <debug.h>
HSEMAPHORE ghsemShareDevLock = NULL;
ULONG gcEngFuncs = DXENG_INDEX_DxEngLoadImage + 1;
DRVFN gaEngFuncs[] =
{
{0, (PFN) NULL},
{DXENG_INDEX_DxEngNUIsTermSrv, (PFN)DxEngNUIsTermSrv},
{DXENG_INDEX_DxEngScreenAccessCheck, (PFN)DxEngScreenAccessCheck},
{DXENG_INDEX_DxEngRedrawDesktop, (PFN)DxEngRedrawDesktop},
{DXENG_INDEX_DxEngDispUniq, (PFN)DxEngDispUniq},
{DXENG_INDEX_DxEngIncDispUniq, (PFN)DxEngIncDispUniq},
{DXENG_INDEX_DxEngVisRgnUniq, (PFN)DxEngVisRgnUniq},
{DXENG_INDEX_DxEngLockShareSem, (PFN)DxEngLockShareSem},
{DXENG_INDEX_DxEngUnlockShareSem, (PFN)DxEngUnlockShareSem},
{DXENG_INDEX_DxEngEnumerateHdev, (PFN)DxEngEnumerateHdev},
{DXENG_INDEX_DxEngLockHdev, (PFN)DxEngLockHdev},
{DXENG_INDEX_DxEngUnlockHdev, (PFN)DxEngUnlockHdev},
{DXENG_INDEX_DxEngIsHdevLockedByCurrentThread, (PFN)DxEngIsHdevLockedByCurrentThread},
{DXENG_INDEX_DxEngReferenceHdev, (PFN)DxEngReferenceHdev},
{DXENG_INDEX_DxEngUnreferenceHdev, (PFN)DxEngUnreferenceHdev},
{DXENG_INDEX_DxEngGetDeviceGammaRamp, (PFN)DxEngGetDeviceGammaRamp},
{DXENG_INDEX_DxEngSetDeviceGammaRamp, (PFN)DxEngSetDeviceGammaRamp},
{DXENG_INDEX_DxEngSpTearDownSprites, (PFN)DxEngSpTearDownSprites},
{DXENG_INDEX_DxEngSpUnTearDownSprites, (PFN)DxEngSpUnTearDownSprites},
{DXENG_INDEX_DxEngSpSpritesVisible, (PFN)DxEngSpSpritesVisible},
{DXENG_INDEX_DxEngGetHdevData, (PFN)DxEngGetHdevData},
{DXENG_INDEX_DxEngSetHdevData, (PFN)DxEngSetHdevData},
{DXENG_INDEX_DxEngCreateMemoryDC, (PFN)DxEngCreateMemoryDC},
{DXENG_INDEX_DxEngGetDesktopDC, (PFN)DxEngGetDesktopDC},
{DXENG_INDEX_DxEngDeleteDC, (PFN)DxEngDeleteDC},
{DXENG_INDEX_DxEngCleanDC, (PFN)DxEngCleanDC},
{DXENG_INDEX_DxEngSetDCOwner, (PFN)DxEngSetDCOwner},
{DXENG_INDEX_DxEngLockDC, (PFN)DxEngLockDC},
{DXENG_INDEX_DxEngUnlockDC, (PFN)DxEngUnlockDC},
{DXENG_INDEX_DxEngSetDCState, (PFN)DxEngSetDCState},
{DXENG_INDEX_DxEngGetDCState, (PFN)DxEngGetDCState},
{DXENG_INDEX_DxEngSelectBitmap, (PFN)DxEngSelectBitmap},
{DXENG_INDEX_DxEngSetBitmapOwner, (PFN)DxEngSetBitmapOwner},
{DXENG_INDEX_DxEngDeleteSurface, (PFN)DxEngDeleteSurface},
{DXENG_INDEX_DxEngGetSurfaceData, (PFN)DxEngGetSurfaceData},
{DXENG_INDEX_DxEngAltLockSurface, (PFN)DxEngAltLockSurface},
{DXENG_INDEX_DxEngUploadPaletteEntryToSurface, (PFN)DxEngUploadPaletteEntryToSurface},
{DXENG_INDEX_DxEngMarkSurfaceAsDirectDraw, (PFN)DxEngMarkSurfaceAsDirectDraw},
{DXENG_INDEX_DxEngSelectPaletteToSurface, (PFN)DxEngSelectPaletteToSurface},
{DXENG_INDEX_DxEngSyncPaletteTableWithDevice, (PFN)DxEngSyncPaletteTableWithDevice},
{DXENG_INDEX_DxEngSetPaletteState, (PFN)DxEngSetPaletteState},
{DXENG_INDEX_DxEngGetRedirectionBitmap, (PFN)DxEngGetRedirectionBitmap},
{DXENG_INDEX_DxEngLoadImage, (PFN)DxEngLoadImage}
};
/*++
* @name DxEngDispUniq
* @implemented
*
* The function DxEngDispUniq returns the DisplayUniqVisrgn counter value from GDI shared memory
*
* @return
* Returns the DisplayUniqVisrgn counter value from GDI shared memory
*
* @remarks.
* none
*
*--*/
ULONG
APIENTRY
DxEngDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngDispUniq\n");
return GdiHandleTable->flDeviceUniq;
}
/*++
* @name DxEngGetDeviceGammaRamp
* @implemented
*
* The function DxEngGetDeviceGammaRamp gets the gamma ramp to dxg.sys.
* @param HDEV hPDev
* The hdev.
*
* @param PGAMMARAMP Ramp
* Pointer to store the gamma ramp value in.
*
* @return
*Returns TRUE for success, FALSE for failure
*
* @remarks.
* None
*
*--*/
BOOL
APIENTRY
DxEngGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
{
DPRINT1("ReactX Calling : DxEngGetDeviceGammaRamp\n");
return IntGetDeviceGammaRamp(hPDev, Ramp);
}
/*++
* @name DxEngLockDC
* @implemented
*
* The function DxEngLockDC locks a hdc from dxg.sys
*
* @param HDC hDC
* The handle we want to lock
*
* @return
* Returns PDC if lock succeeded or NULL if it failed.
*
* @remarks.
* none
*
*--*/
PDC
APIENTRY
DxEngLockDC(HDC hDC)
{
DPRINT1("ReactX Calling : DxEngLockDC\n");
return DC_LockDc(hDC);
}
/*++
* @name DxEngUnlockDC
* @implemented
*
* The function DxEngUnlockDC unlocks a pDC (hdc) from dxg.sys.
* @param PDC pDC
* The handle we want to unlock.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockDC(PDC pDC)
{
DPRINT1("ReactX Calling : DxEngUnlockDC\n");
DC_UnlockDc(pDC);
return TRUE;
}
/*++
* @name DxEngLockShareSem
* @implemented
*
* The function DxEngLockShareSem locks a struct of type ghsemShareDevLock that can be shared.
*
* @return
* This function returns TRUE for success and FALSE for failure.
* FALSE must mean the struct has already been locked.
*
* @remarks.
* It is being used in various ntuser* functions and ntgdi*
* ReactOS specific: It is not in use yet?
*SystemResourcesList
*--*/
BOOLEAN
APIENTRY
DxEngLockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngLockShareSem\n");
if(!ghsemShareDevLock) ghsemShareDevLock = EngCreateSemaphore(); // Hax, should be in dllmain.c
EngAcquireSemaphore(ghsemShareDevLock);
return TRUE;
}
/*++
* @name DxEngUnlockShareSem
* @implemented
*
* The function DxEngUnlockShareSem unlocks the struct of type ghsemShareDevLock.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* ReactOS specific: It is not in use yet?
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngUnlockShareSem\n");
EngReleaseSemaphore(ghsemShareDevLock);
return TRUE;
}
/*++
* @name DxEngSetDeviceGammaRamp
* @implemented
*
* The function DxEngSetDeviceGammaRamp sets gamma ramp from dxg.sys
* @param HDEV hPDev
* The hdev
*
* @param PGAMMARAMP Ramp
* Value to change gamma ramp to.
*
* @param BOOL Test
* Whether gamma should be tested. TRUE to test, FALSE to not test.
*
* @return
*Returns TRUE for success, FALSE for failure.
*
* @remarks.
* None
*
*--*/
BOOLEAN
APIENTRY
DxEngSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
{
DPRINT1("ReactX Calling : DxEngSetDeviceGammaRamp\n");
return IntSetDeviceGammaRamp(hPDev, Ramp, Test);
}
/*++
* @name DxEngGetHdevData
* @implemented
*
* The function DxEngGetHdevData retrieves a value from the HDEV
* @param HDEV hPDev
* The HDEV
*
* @param DXEGSHDEVDATA Type
* The following typs are supported
* Type Purpose
* DxEGShDevData_Surface Retrieve pointer to Surface handle.
* DxEGShDevData_hSpooler See if the device is a spooler driver.
* DxEGShDevData_DitherFmt Retrieve the device iDitherFormat
* DxEGShDevData_FxCaps Retrieve the device flGraphicsCaps
* DxEGShDevData_FxCaps2 Retrieve the device flGraphicsCaps2
* DxEGShDevData_DrvFuncs Retrieve the device DriverFunctions function table
* DxEGShDevData_dhpdev Retrieve the device hPDev, the real DHPDEV
* DxEGShDevData_eddg Retrieve the device pEDDgpl
* DxEGShDevData_dd_nCount Retrieve the device DxDd_nCount
* DxEGShDevData_dd_flags Retrieve the device DxDd_Flags
* DxEGShDevData_disable See if the device pdev is disabled
* DxEGShDevData_metadev See if the device pdev is a meta device
* DxEGShDevData_display See if the device is the primary display driver
* DxEGShDevData_Parent Retrieve the ppdevParent
* DxEGShDevData_OpenRefs Retrieve the pdevOpenRefs counter
* DxEGShDevData_palette See if the device RC_PALETTE is set
* DxEGShDevData_ldev ATM we do not support the Loader Device driver structure
* DxEGShDevData_GDev Retrieve the device pGraphicsDevice
* DxEGShDevData_clonedev Retrieve the device PDEV_CLONE_DEVICE flag is set or not
*
* @return
* Returns the data we requested
*
* @remarks.
* ReactOS specific: Implementation is incomplete, I do not save the value into the hdev yet.
*
*--*/
DWORD_PTR
APIENTRY
DxEngGetHdevData(HDEV hDev,
DXEGSHDEVDATA Type)
{
DWORD_PTR retVal = 0;
PPDEVOBJ PDev = (PPDEVOBJ)hDev;
DPRINT1("ReactX Calling : DxEngGetHdevData DXEGSHDEVDATA : %ld\n", Type);
#if 1
DPRINT1("HDEV hDev %p\n", hDev);
#endif
switch ( Type )
{
case DxEGShDevData_Surface:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Surface\n");
retVal = (DWORD_PTR) PDev->pSurface; // ptr to Surface handle.
break;
case DxEGShDevData_hSpooler:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_hSpooler\n");
retVal = 0; // (DWORD_PTR) PDev->hSpooler; // If the device is a spooler driver.
break;
case DxEGShDevData_DitherFmt:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DitherFmt\n");
retVal = (DWORD_PTR) PDev->devinfo.iDitherFormat;
break;
case DxEGShDevData_FxCaps:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps;
break;
case DxEGShDevData_FxCaps2:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps2\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps2;
break;
case DxEGShDevData_DrvFuncs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DrvFuncs\n");
retVal = (DWORD_PTR) &PDev->DriverFunctions;
break;
case DxEGShDevData_dhpdev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dhpdev\n");
retVal = (DWORD_PTR) PDev->dhpdev; // DHPDEV
break;
case DxEGShDevData_eddg:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_eddg\n");
retVal = (DWORD_PTR) PDev->pEDDgpl;
break;
case DxEGShDevData_dd_nCount:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_nCount\n");
retVal = (DWORD_PTR) PDev->DxDd_nCount;
break;
case DxEGShDevData_dd_flags:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_flags\n");
retVal = (DWORD_PTR) PDev->DxDd_Flags;
break;
case DxEGShDevData_disable:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_disable\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISABLED;
break;
case DxEGShDevData_metadev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_metadev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_META_DEVICE;
break;
case DxEGShDevData_display:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_display\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISPLAY;
break;
case DxEGShDevData_Parent:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Parent\n");
retVal = (DWORD_PTR) PDev->ppdevParent;
break;
case DxEGShDevData_OpenRefs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_OpenRefs\n");
retVal = (DWORD_PTR) PDev->cPdevOpenRefs != 0;
break;
case DxEGShDevData_palette:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_palette\n");
retVal = (DWORD_PTR) PDev->gdiinfo.flRaster & RC_PALETTE;
break;
case DxEGShDevData_ldev:
DPRINT1("DxEGShDevData_ldev not supported yet\n");
// ATM we do not support the Loader Device driver structure.
// retVal = (DWORD) PDev->pldev;
break;
case DxEGShDevData_GDev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_GDev\n");
retVal = (DWORD_PTR) PDev->pGraphicsDevice; // P"GRAPHICS_DEVICE"
break;
case DxEGShDevData_clonedev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_clonedev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_CLONE_DEVICE;
break;
default:
break;
}
#if 1
DPRINT1("return value %08lx\n", retVal);
#endif
return retVal;
}
/*++
* @name DxEngSetHdevData
* @implemented
*
* The function DxEngSetHdevData sets a value in hdev
* @param HDEV hPDev
* The hdev
*
* @param DXEGSHDEVDATA Type
* Supports only DxEGShDevData_dd_nCount. It is an internal counter on how many times hdev has been locked and unlocked
*
* @param DWORD Data
* The value to be saved to hdev's internal counter.
*
* @return
* Returns TRUE for success, FALSE for failure
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngSetHdevData(HDEV hDev,
DXEGSHDEVDATA Type,
DWORD_PTR Data)
{
BOOLEAN retVal = FALSE; // Default, no set.
DPRINT1("ReactX Calling : DxEngSetHdevData DXEGSHDEVDATA : %ld\n", Type);
if ( Type == DxEGShDevData_dd_nCount )
{
((PPDEVOBJ)hDev)->DxDd_nCount = Data;
retVal = TRUE; // Set
}
return retVal;
}
/*++
* @name DxEngGetDCState
* @implemented
*
* The function DxEngGetDCState is capable of returning three
* DC states depending on what value is passed in its second parameter:
* 1. If the DC is full screen
* 2. Get Complexity of visible region
* 3. Get Driver hdev, which is ppdev
*
* @param HDC hdc
* The DC handle
*
* @param DWORD type
* value 1 = Is DC fullscreen
* value 2 = Get Complexity of visible region.
* value 3 = Get Driver hdev, which is a ppdev.
*
* @return
* Return one of the type values
*
* @remarks.
* We do not have type 2 implemented yet
*
*--*/
DWORD_PTR
APIENTRY
DxEngGetDCState(HDC hDC,
DWORD type)
{
PDC pDC = DC_LockDc(hDC);
DWORD_PTR retVal = 0;
DPRINT1("ReactX Calling : DxEngGetDCState type : %lu\n", type);
if (pDC)
{
switch (type)
{
case 1:
retVal = (DWORD_PTR) pDC->fs & DC_FLAG_FULLSCREEN;
break;
case 2:
UNIMPLEMENTED;
break;
case 3:
{
/* Return the HDEV of this DC. */
retVal = (DWORD_PTR) pDC->ppdev;
break;
}
default:
/* If a valid type is not found, zero is returned */
DPRINT1("Warning: did not find type %lu\n", type);
break;
}
DC_UnlockDc(pDC);
}
return retVal;
}
/*++
* @name DxEngIncDispUniq
* @implemented
*
* The function DxEngIncDispUniq increments the DisplayUniqVisrgn counter from GDI shared memory.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngIncDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngIncDispUniq \n");
InterlockedIncrement((LONG*)&GdiHandleTable->flDeviceUniq);
return TRUE;
}
/*++
* @name DxEngLockHdev
* @implemented
*
* The function DxEngLockHdev lock the internal PDEV
*
* @param HDEV type
* it is a pointer to win32k internal pdev struct known as PPDEVOBJ
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngLockHdev(HDEV hDev)
{
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource;
DPRINT1("ReactX Calling : DxEngLockHdev \n");
DPRINT1("hDev : 0x%p\n",hDev);
Resource = (PERESOURCE)ppdev->hsemDevLock;
if (Resource)
{
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite( Resource , TRUE); // Lock monitor.
}
return TRUE;
}
/*++
* @name DxEngUnlockHdev
* @implemented
*
* The function DxEngUnlockHdev unlock the internal PDEV
*
* @param HDEV type
* it is a pointer to win32k internal pdev struct known as PPDEVOBJ
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockHdev(HDEV hDev)
{
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource = (PERESOURCE)ppdev->hsemDevLock;
DPRINT1("ReactX Calling : DxEngUnlockHdev \n");
if (Resource)
{
ExReleaseResourceLite( Resource );
KeLeaveCriticalRegion();
}
return TRUE;
}
/************************************************************************/
/* DxEngReferenceHdev */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngReferenceHdev(HDEV hDev)
{
IntGdiReferencePdev((PPDEVOBJ) hDev);
/* ALWAYS return true */
return TRUE;
}
/************************************************************************/
/* DxEngNUIsTermSrv */
/************************************************************************/
/* Notes: Check if terminal server got connections or not */
BOOLEAN
APIENTRY
DxEngNUIsTermSrv(VOID)
{
/* FIXME: ReactOS does not suport terminal server yet, we can not check if we got connections or not */
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngRedrawDesktop */
/************************************************************************/
/* Notes: it always returns TRUE, and it updates whole screen
(redraws current desktop) */
BOOLEAN
APIENTRY
DxEngRedrawDesktop(VOID)
{
UserRedrawDesktop();
return TRUE;
}
ULONG gulVisRgnUniqueness; // Increase count everytime client region is updated.
/************************************************************************/
/* DxEngVisRgnUniq */
/************************************************************************/
/* Notes: returns the VisRgnUniq counter for win32k */
ULONG
APIENTRY
DxEngVisRgnUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngVisRgnUniq \n");
return gulVisRgnUniqueness;
}
/************************************************************************/
/* DxEngEnumerateHdev */
/************************************************************************/
/* Enumerate all drivers in win32k */
HDEV *
APIENTRY
DxEngEnumerateHdev(HDEV *hdev)
{
/* FIXME: Enumerate all drivers in win32k */
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngCreateMemoryDC */
/************************************************************************/
HDC
APIENTRY
DxEngCreateMemoryDC(HDEV hDev)
{
return IntGdiCreateDisplayDC(hDev, DC_TYPE_MEMORY, FALSE);
}
/************************************************************************/
/* DxEngScreenAccessCheck */
/************************************************************************/
DWORD APIENTRY DxEngScreenAccessCheck(VOID)
{
UNIMPLEMENTED;
/* We're cheating here and telling dxg.sys it has always had permissions to access the screen */
return TRUE;
}
/************************************************************************/
/* DxEngIsHdevLockedByCurrentThread */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngIsHdevLockedByCurrentThread(HDEV hDev)
{ // Based on EngIsSemaphoreOwnedByCurrentThread w/o the Ex call.
PERESOURCE pSem = (PERESOURCE)(((PPDEVOBJ)hDev)->hsemDevLock);
return pSem->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread();
}
/************************************************************************/
/* DxEngUnreferenceHdev */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngUnreferenceHdev(HDEV hDev)
{
IntGdiUnreferencePdev((PPDEVOBJ) hDev, 0);
return TRUE; // Always true.
}
/************************************************************************/
/* DxEngGetDesktopDC */
/************************************************************************/
HDC
APIENTRY
DxEngGetDesktopDC(ULONG DcType, BOOL EmptyDC, BOOL ValidatehWnd)
{
return UserGetDesktopDC(DcType, EmptyDC, ValidatehWnd);
}
/************************************************************************/
/* DxEngDeleteDC */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngDeleteDC(HDC hdc, BOOL Force)
{
return IntGdiDeleteDC(hdc, Force);
}
/************************************************************************/
/* DxEngCleanDC */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngCleanDC(HDC hdc)
{
return IntGdiCleanDC(hdc);
}
/************************************************************************/
/* DxEngSetDCOwner */
/************************************************************************/
BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
{
DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
return GreSetDCOwner(hObject, OwnerMask);
}
/************************************************************************/
/* DxEngSetDCState */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
{
BOOLEAN Ret = FALSE;
PDC pDC = DC_LockDc(hDC);
if (pDC)
{
if (SetType == 1)
{
if ( Set )
pDC->fs |= DC_FLAG_FULLSCREEN;
else
pDC->fs &= ~DC_FLAG_FULLSCREEN;
Ret = TRUE;
}
DC_UnlockDc(pDC);
return Ret; // Everything else returns FALSE.
}
return Ret;
}
/************************************************************************/
/* DxEngSelectBitmap */
/************************************************************************/
DWORD APIENTRY DxEngSelectBitmap(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSetBitmapOwner */
/************************************************************************/
DWORD APIENTRY DxEngSetBitmapOwner(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngDeleteSurface */
/************************************************************************/
DWORD APIENTRY DxEngDeleteSurface(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngGetSurfaceData */
/************************************************************************/
DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngAltLockSurface */
/************************************************************************/
DWORD APIENTRY DxEngAltLockSurface(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngUploadPaletteEntryToSurface */
/************************************************************************/
DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngMarkSurfaceAsDirectDraw */
/************************************************************************/
DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSelectPaletteToSurface */
/************************************************************************/
DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSyncPaletteTableWithDevice */
/************************************************************************/
DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSetPaletteState */
/************************************************************************/
DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngGetRedirectionBitmap */
/************************************************************************/
DWORD
APIENTRY
DxEngGetRedirectionBitmap(DWORD x1)
{
return FALSE; // Normal return.
}
/************************************************************************/
/* DxEngLoadImage */
/************************************************************************/
DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpTearDownSprites */
/************************************************************************/
DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpUnTearDownSprites */
/************************************************************************/
DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpSpritesVisible */
/************************************************************************/
DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
}

215
win32ss/reactx/ntddraw/eng.c Normal file
View file

@ -0,0 +1,215 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/eng.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
/************************************************************************/
/* HeapVidMemAllocAligned */
/************************************************************************/
FLATPTR
APIENTRY
HeapVidMemAllocAligned(LPVIDMEM lpVidMem,
DWORD dwWidth,
DWORD dwHeight,
LPSURFACEALIGNMENT lpAlignment,
LPLONG lpNewPitch)
{
PGD_HEAPVIDMEMALLOCALIGNED pfnHeapVidMemAllocAligned = (PGD_HEAPVIDMEMALLOCALIGNED)gpDxFuncs[DXG_INDEX_DxDdHeapVidMemAllocAligned].pfn;
if (pfnHeapVidMemAllocAligned == NULL)
{
DPRINT1("Warning: no pfnHeapVidMemAllocAligned\n");
return 0;
}
DPRINT1("Calling dxg.sys pfnHeapVidMemAllocAligned\n");
return pfnHeapVidMemAllocAligned(lpVidMem, dwWidth, dwHeight, lpAlignment, lpNewPitch);
}
/************************************************************************/
/* VidMemFree */
/************************************************************************/
VOID
APIENTRY
VidMemFree(LPVMEMHEAP pvmh,
FLATPTR ptr)
{
PGD_VIDMEMFREE pfnVidMemFree = (PGD_VIDMEMFREE)gpDxFuncs[DXG_INDEX_DxDdHeapVidMemFree].pfn;
if (pfnVidMemFree == NULL)
{
DPRINT1("Warning: no pfnVidMemFree\n");
}
else
{
DPRINT1("Calling dxg.sys pfnVidMemFree\n");
pfnVidMemFree(pvmh, ptr);
}
}
/************************************************************************/
/* EngAllocPrivateUserMem */
/************************************************************************/
_Must_inspect_result_
_Ret_opt_bytecount_(cjMemSize)
__drv_allocatesMem(PrivateUserMem)
ENGAPI
PVOID
APIENTRY
EngAllocPrivateUserMem(
_In_ PDD_SURFACE_LOCAL psl,
_In_ SIZE_T cjMemSize,
_In_ ULONG ulTag)
{
PGD_ENGALLOCPRIVATEUSERMEM pfnEngAllocPrivateUserMem = (PGD_ENGALLOCPRIVATEUSERMEM)gpDxFuncs[DXG_INDEX_DxDdAllocPrivateUserMem].pfn;
if (pfnEngAllocPrivateUserMem == NULL)
{
DPRINT1("Warning: no pfnEngAllocPrivateUserMem\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnEngAllocPrivateUserMem\n");
return pfnEngAllocPrivateUserMem(psl, cjMemSize, ulTag);
}
/************************************************************************/
/* EngFreePrivateUserMem */
/************************************************************************/
VOID
APIENTRY
EngFreePrivateUserMem(PDD_SURFACE_LOCAL psl,
PVOID pv)
{
PGD_ENGFREEPRIVATEUSERMEM pfnEngFreePrivateUserMem = (PGD_ENGFREEPRIVATEUSERMEM)gpDxFuncs[DXG_INDEX_DxDdFreePrivateUserMem].pfn;
if (pfnEngFreePrivateUserMem == NULL)
{
DPRINT1("Warning: no pfnEngFreePrivateUserMem\n");
}
else
{
DPRINT1("Calling dxg.sys pfnEngFreePrivateUserMem\n");
pfnEngFreePrivateUserMem(psl, pv);
}
}
/*++
* @name EngDxIoctl
* @implemented
*
* The function EngDxIoctl is the ioctl call to different DirectX functions
* in the driver dxg.sys
*
* @param ULONG ulIoctl
* The ioctl code that we want call to
*
* @param PVOID pBuffer
* Our in or out buffer with data to the ioctl code we are using
*
* @param ULONG ulBufferSize
* The buffer size in bytes
*
* @return
* Always returns DDERR_UNSUPPORTED
*
* @remarks.
* dxg.sys EngDxIoctl call is redirected to dxg.sys
* This function is no longer used in Windows NT 2000/XP/2003
*
*--*/
HRESULT
APIENTRY
EngDxIoctl(ULONG ulIoctl,
PVOID pBuffer,
ULONG ulBufferSize)
{
PGD_ENGDXIOCTL pfnEngDxIoctl = (PGD_ENGDXIOCTL)gpDxFuncs[DXG_INDEX_DxDdIoctl].pfn;
DWORD retVal = DDERR_UNSUPPORTED;
DPRINT1("Calling dxg.sys pfnEngDxIoctl\n");
if (pfnEngDxIoctl != NULL)
{
retVal = pfnEngDxIoctl(ulIoctl, pBuffer, ulBufferSize);
}
return retVal;
}
/*++
* @name EngLockDirectDrawSurface
* @implemented
*
* The function EngUnlockDirectDrawSurface locks the DirectX surface.
* @param HANDLE hSurface
* The handle of a surface
*
* @return
* This return a vaild or NULL pointer to a PDD_SURFACE_LOCAL object
*
* @remarks.
* None
*
*--*/
PDD_SURFACE_LOCAL
APIENTRY
EngLockDirectDrawSurface(HANDLE hSurface)
{
PGD_ENGLOCKDIRECTDRAWSURFACE pfnEngLockDirectDrawSurface = (PGD_ENGLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdLockDirectDrawSurface].pfn;
PDD_SURFACE_LOCAL retVal = NULL;
DPRINT1("Calling dxg.sys pfnEngLockDirectDrawSurface\n");
if (pfnEngLockDirectDrawSurface != NULL)
{
retVal = pfnEngLockDirectDrawSurface(hSurface);
}
return retVal;
}
/*++
* @name EngUnlockDirectDrawSurface
* @implemented
*
* The function EngUnlockDirectDrawSurface unlocks the DirectX surface
* @param PDD_SURFACE_LOCAL pSurface
* The Surface we want to unlock
*
* @return
* This return TRUE for success, FALSE for failure
*
* @remarks.
* None
*
*--*/
BOOL
APIENTRY
EngUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
{
PGD_ENGUNLOCKDIRECTDRAWSURFACE pfnEngUnlockDirectDrawSurface = (PGD_ENGUNLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdUnlockDirectDrawSurface].pfn;
BOOL retVal = FALSE;
DPRINT1("Calling dxg.sys pfnEngUnlockDirectDrawSurface\n");
if (pfnEngUnlockDirectDrawSurface != NULL)
{
retVal = pfnEngUnlockDirectDrawSurface(pSurface);
}
return retVal;
}

137
win32ss/reactx/ntddraw/intddraw.h Normal file
View file

@ -0,0 +1,137 @@
#pragma once
#include <ddrawint.h>
#include <ddkernel.h>
#include <reactos/drivers/directx/directxint.h>
#include <reactos/drivers/directx/dxg.h>
#include <reactos/drivers/directx/dxeng.h>
/* From ddraw.c */
BOOL intEnableReactXDriver(HDC);
NTSTATUS APIENTRY DxDdStartupDxGraphics(ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
extern DRVFN gpDxFuncs[];
typedef BOOL (APIENTRY* PGD_DDSETGAMMARAMP)(HANDLE, HDC, LPVOID);
typedef BOOL (APIENTRY* PGD_DDRELEASEDC)(HANDLE);
typedef BOOL (APIENTRY* PGD_DDRESTVISRGN)(HANDLE, HWND);
typedef HANDLE (APIENTRY* PGD_DDGETDXHANDLE)(HANDLE, HANDLE, BOOL);
typedef HDC (APIENTRY *PGD_DDGETDC)(HANDLE, PALETTEENTRY *);
typedef DWORD (APIENTRY *PGD_DXDDREENABLEDIRECTDRAWOBJECT)(HANDLE, BOOL*);
typedef DWORD (APIENTRY *PGD_DXDDGETDRIVERINFO)(HANDLE, PDD_GETDRIVERINFODATA);
typedef DWORD (APIENTRY *PGD_DXDDSETEXCLUSIVEMODE)(HANDLE, PDD_SETEXCLUSIVEMODEDATA);
typedef NTSTATUS (APIENTRY *PGD_DXDDSTARTUPDXGRAPHICS) (ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
typedef NTSTATUS (APIENTRY *PGD_DXDDCLEANUPDXGRAPHICS) (VOID);
typedef HANDLE (APIENTRY *PGD_DDCREATEDIRECTDRAWOBJECT) (HDC hdc);
typedef DWORD (APIENTRY *PGD_DDGETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA);
typedef DWORD (APIENTRY *PGD_DDCOLORCONTROL)(HANDLE hSurface,PDD_COLORCONTROLDATA puColorControlData);
typedef HANDLE (APIENTRY *PGD_DXDDCREATESURFACEOBJECT)(HANDLE, HANDLE, PDD_SURFACE_LOCAL, PDD_SURFACE_MORE, PDD_SURFACE_GLOBAL, BOOL);
typedef BOOL (APIENTRY *PGD_DXDDDELETEDIRECTDRAWOBJECT)(HANDLE);
typedef BOOL (APIENTRY *PGD_DXDDDELETESURFACEOBJECT)(HANDLE);
typedef DWORD (APIENTRY *PGD_DXDDFLIPTOGDISURFACE)(HANDLE, PDD_FLIPTOGDISURFACEDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETAVAILDRIVERMEMORY)(HANDLE , PDD_GETAVAILDRIVERMEMORYDATA);
typedef BOOL (APIENTRY *PGD_DXDDQUERYDIRECTDRAWOBJECT)(HANDLE, DD_HALINFO*, DWORD*, LPD3DNTHAL_CALLBACKS, LPD3DNTHAL_GLOBALDRIVERDATA,
PDD_D3DBUFCALLBACKS, LPDDSURFACEDESC, DWORD *, VIDEOMEMORY *, DWORD *, DWORD *);
/* From d3d.c */
typedef DWORD (APIENTRY *PGD_DXDDDESTROYD3DBUFFER)(HANDLE);
typedef DWORD (APIENTRY *PGD_DDCANCREATED3DBUFFER)(HANDLE, PDD_CANCREATESURFACEDATA);
typedef DWORD (APIENTRY *PGD_DXDDUNLOCKD3D)(HANDLE, PDD_UNLOCKDATA);
typedef DWORD (APIENTRY *PGD_DXDDLOCKD3D)(HANDLE, PDD_LOCKDATA);
typedef DWORD (APIENTRY *PGD_D3DVALIDATETEXTURESTAGESTATE)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA);
typedef DWORD (APIENTRY *PGD_D3DDRAWPRIMITIVES2)(HANDLE, HANDLE, LPD3DNTHAL_DRAWPRIMITIVES2DATA, FLATPTR *, DWORD *, FLATPTR *, DWORD *);
typedef DWORD (APIENTRY *PGD_DDCREATED3DBUFFER)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
typedef BOOL (APIENTRY *PGD_D3DCONTEXTCREATE)(HANDLE, HANDLE, HANDLE, LPD3DNTHAL_CONTEXTCREATEDATA);
typedef DWORD (APIENTRY *PGD_D3DCONTEXTDESTROY)(LPD3DNTHAL_CONTEXTDESTROYDATA);
typedef DWORD (APIENTRY *PGD_D3DCONTEXTDESTROYALL)(LPD3DNTHAL_CONTEXTDESTROYALLDATA);
/* From dvp.c */
typedef DWORD (APIENTRY* PGD_DVPCANCREATEVIDEOPORT)(HANDLE, PDD_CANCREATEVPORTDATA);
typedef DWORD (APIENTRY* PGD_DVPCOLORCONTROL)(HANDLE, PDD_VPORTCOLORDATA);
typedef HANDLE (APIENTRY* PGD_DVPCREATEVIDEOPORT)(HANDLE, PDD_CREATEVPORTDATA);
typedef DWORD (APIENTRY* PGD_DVPDESTROYVIDEOPORT)(HANDLE, PDD_DESTROYVPORTDATA);
typedef DWORD (APIENTRY* PGD_DVPFLIPVIDEOPORT)(HANDLE,HANDLE,HANDLE,PDD_FLIPVPORTDATA);
typedef DWORD (APIENTRY* PGD_DVPGETVIDEOPORTBANDWITH)(HANDLE, PDD_GETVPORTBANDWIDTHDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTFLIPSTATUS)(HANDLE, PDD_GETVPORTFLIPSTATUSDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTINPUTFORMATS)(HANDLE, PDD_GETVPORTINPUTFORMATDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTLINE)(HANDLE, PDD_GETVPORTLINEDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)(HANDLE, PDD_GETVPORTOUTPUTFORMATDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTCONNECTINFO)(HANDLE, PDD_GETVPORTCONNECTDATA);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOSIGNALSTATUS)(HANDLE, PDD_GETVPORTSIGNALDATA);
typedef DWORD (APIENTRY *PGD_DXDVPUPDATEVIDEOPORT)(HANDLE, HANDLE*, HANDLE*, PDD_UPDATEVPORTDATA);
typedef DWORD (APIENTRY *PGD_DXDVPWAITFORVIDEOPORTSYNC)(HANDLE, PDD_WAITFORVPORTSYNCDATA);
typedef DWORD (APIENTRY *PGD_DXDVPACQUIRENOTIFICATION)(HANDLE, HANDLE*, LPDDVIDEOPORTNOTIFY);
typedef DWORD (APIENTRY *PGD_DXDVPRELEASENOTIFICATION)(HANDLE, HANDLE);
typedef DWORD (APIENTRY *PGD_DXDVPGETVIDEOPORTFIELD)(HANDLE, PDD_GETVPORTFIELDDATA);
/* From mocomp.c */
typedef DWORD (APIENTRY *PGD_DDBEGINMOCOMPFRAME)(HANDLE, PDD_BEGINMOCOMPFRAMEDATA);
typedef HANDLE (APIENTRY *PGD_DXDDCREATEMOCOMP)(HANDLE, PDD_CREATEMOCOMPDATA );
typedef DWORD (APIENTRY *PGD_DXDDDESTROYMOCOMP)(HANDLE, PDD_DESTROYMOCOMPDATA);
typedef DWORD (APIENTRY *PGD_DXDDENDMOCOMPFRAME)(HANDLE, PDD_ENDMOCOMPFRAMEDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETINTERNALMOCOMPINFO)(HANDLE, PDD_GETINTERNALMOCOMPDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPBUFFINFO)(HANDLE, PDD_GETMOCOMPCOMPBUFFDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPGUIDS)(HANDLE, PDD_GETMOCOMPGUIDSDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETMOCOMPFORMATS)(HANDLE, PDD_GETMOCOMPFORMATSDATA);
typedef DWORD (APIENTRY *PGD_DXDDQUERYMOCOMPSTATUS)(HANDLE, PDD_QUERYMOCOMPSTATUSDATA);
typedef DWORD (APIENTRY *PGD_DXDDRENDERMOCOMP)(HANDLE, PDD_RENDERMOCOMPDATA);
/* From dd.c */
typedef DWORD (APIENTRY *PGD_DDCREATESURFACE)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
typedef DWORD (APIENTRY *PGD_DXDDWAITFORVERTICALBLANK)(HANDLE, PDD_WAITFORVERTICALBLANKDATA);
typedef DWORD (APIENTRY *PGD_DDCANCREATESURFACE)(HANDLE hDirectDrawLocal, PDD_CANCREATESURFACEDATA puCanCreateSurfaceData);
typedef DWORD (APIENTRY *PGD_DXDDGETSCANLINE)(HANDLE, PDD_GETSCANLINEDATA);
typedef DWORD (APIENTRY *PGD_DXDDCREATESURFACEEX)(HANDLE,HANDLE,DWORD);
/* From ddsurf.c */
typedef DWORD (APIENTRY *PGD_DDALPHABLT)(HANDLE, HANDLE, PDD_BLTDATA);
typedef BOOL (APIENTRY *PGD_DDATTACHSURFACE)(HANDLE, HANDLE);
typedef DWORD (APIENTRY *PGD_DXDDUNATTACHSURFACE)(HANDLE, HANDLE);
typedef DWORD (APIENTRY *PGD_DXDDDESTROYSURFACE)(HANDLE, BOOL);
typedef DWORD (APIENTRY *PGD_DXDDFLIP)(HANDLE, HANDLE, HANDLE, HANDLE, PDD_FLIPDATA);
typedef DWORD (APIENTRY *PGD_DXDDLOCK)(HANDLE, PDD_LOCKDATA, HDC);
typedef DWORD (APIENTRY *PGD_DXDDUNLOCK)(HANDLE, PDD_UNLOCKDATA );
typedef DWORD (APIENTRY *PGD_DDBLT)(HANDLE, HANDLE, PDD_BLTDATA);
typedef DWORD (APIENTRY *PGD_DXDDSETCOLORKEY)(HANDLE, PDD_SETCOLORKEYDATA);
typedef DWORD (APIENTRY *PGD_DDADDATTACHEDSURFACE)(HANDLE, HANDLE,PDD_ADDATTACHEDSURFACEDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETBLTSTATUS)(HANDLE, PDD_GETBLTSTATUSDATA);
typedef DWORD (APIENTRY *PGD_DXDDGETFLIPSTATUS)(HANDLE, PDD_GETFLIPSTATUSDATA);
typedef DWORD (APIENTRY *PGD_DXDDUPDATEOVERLAY)(HANDLE, HANDLE, PDD_UPDATEOVERLAYDATA);
typedef DWORD (APIENTRY *PGD_DXDDSETOVERLAYPOSITION)(HANDLE, HANDLE, PDD_SETOVERLAYPOSITIONDATA);
/* From eng.c */
typedef FLATPTR (APIENTRY *PGD_HEAPVIDMEMALLOCALIGNED)(LPVIDMEM, DWORD, DWORD, LPSURFACEALIGNMENT, LPLONG);
typedef VOID (APIENTRY *PGD_VIDMEMFREE)(LPVMEMHEAP, FLATPTR);
typedef PVOID (APIENTRY *PGD_ENGALLOCPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, SIZE_T, ULONG) ;
typedef VOID (APIENTRY *PGD_ENGFREEPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, PVOID);
typedef PDD_SURFACE_LOCAL (APIENTRY *PGD_ENGLOCKDIRECTDRAWSURFACE)(HANDLE);
typedef BOOL (APIENTRY *PGD_ENGUNLOCKDIRECTDRAWSURFACE)(PDD_SURFACE_LOCAL);
/* Gammaramp internal prototype */
BOOL FASTCALL IntGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp);
BOOL FASTCALL IntSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL);
/* Debug function oly for win32k dx */
void dump_edd_directdraw_global(EDD_DIRECTDRAW_GLOBAL *pEddgbl);
void dump_edd_directdraw_local(PEDD_DIRECTDRAW_LOCAL pEddlcl);
void dump_halinfo(DD_HALINFO *pHalInfo);
#define checkflag(dwflag,dwvalue,text) \
if (dwflag & dwvalue) \
{ \
if (count!=0) \
{ \
DPRINT1("| "); \
} \
dwflag = (ULONG)dwflag - (ULONG)dwvalue; \
DPRINT1("%s ",text); \
count++; \
}
#define endcheckflag(dwflag,text) \
if (count==0) \
DPRINT1("0x%08lx\n", (ULONG) dwflag);\
else \
DPRINT1("\n");\
if (flag != 0) \
DPRINT1("undoc value in %s flags value %08lx\n",text, (ULONG) dwflag);

218
win32ss/reactx/ntddraw/mocomp.c Normal file
View file

@ -0,0 +1,218 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/mocomp.c
* PROGRAMER: Magnus Olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
/************************************************************************/
/* NtGdiDdBeginMoCompFrame */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdBeginMoCompFrame(HANDLE hMoComp,
PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData)
{
PGD_DDBEGINMOCOMPFRAME pfnDdBeginMoCompFrame = (PGD_DDBEGINMOCOMPFRAME)gpDxFuncs[DXG_INDEX_DxDdBeginMoCompFrame].pfn;
if (pfnDdBeginMoCompFrame == NULL)
{
DPRINT1("Warning: no pfnDdBeginMoCompFrame");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdBeginMoCompFrame");
return pfnDdBeginMoCompFrame(hMoComp,puBeginFrameData);
}
/************************************************************************/
/* NtGdiDdCreateMoComp */
/************************************************************************/
HANDLE
APIENTRY
NtGdiDdCreateMoComp(HANDLE hDirectDraw, PDD_CREATEMOCOMPDATA puCreateMoCompData)
{
PGD_DXDDCREATEMOCOMP pfnDdCreateMoComp = (PGD_DXDDCREATEMOCOMP)gpDxFuncs[DXG_INDEX_DxDdCreateMoComp].pfn;
if (pfnDdCreateMoComp == NULL)
{
DPRINT1("Warning: no pfnDdCreateMoComp");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateMoComp");
return pfnDdCreateMoComp(hDirectDraw, puCreateMoCompData);
}
/************************************************************************/
/* NtGdiDdDestroyMoComp */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdDestroyMoComp(HANDLE hMoComp,
PDD_DESTROYMOCOMPDATA puBeginFrameData)
{
PGD_DXDDDESTROYMOCOMP pfnDxDdDestroyMoComp = (PGD_DXDDDESTROYMOCOMP)gpDxFuncs[DXG_INDEX_DxDdDestroyMoComp].pfn;
if (pfnDxDdDestroyMoComp == NULL)
{
DPRINT1("Warning: no pfnDxDdDestroyMoComp");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DxDdDestroyMoComp");
return pfnDxDdDestroyMoComp(hMoComp, puBeginFrameData);
}
/************************************************************************/
/* NtGdiDdEndMoCompFrame */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdEndMoCompFrame(HANDLE hMoComp,
PDD_ENDMOCOMPFRAMEDATA puEndFrameData)
{
PGD_DXDDENDMOCOMPFRAME pfnDdEndMoCompFrame = (PGD_DXDDENDMOCOMPFRAME)gpDxFuncs[DXG_INDEX_DxDdEndMoCompFrame].pfn;
if (pfnDdEndMoCompFrame == NULL)
{
DPRINT1("Warning: no pfnDdEndMoCompFrame");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdEndMoCompFrame");
return pfnDdEndMoCompFrame(hMoComp, puEndFrameData);
}
/************************************************************************/
/* NtGdiDdGetInternalMoCompInfo */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetInternalMoCompInfo(HANDLE hDirectDraw,
PDD_GETINTERNALMOCOMPDATA puGetInternalData)
{
PGD_DXDDGETINTERNALMOCOMPINFO pfnDdGetInternalMoCompInfo = (PGD_DXDDGETINTERNALMOCOMPINFO)gpDxFuncs[DXG_INDEX_DxDdGetInternalMoCompInfo].pfn;
if (pfnDdGetInternalMoCompInfo == NULL)
{
DPRINT1("Warning: no pfnDdGetInternalMoCompInfo");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetInternalMoCompInfo");
return pfnDdGetInternalMoCompInfo(hDirectDraw, puGetInternalData);
}
/************************************************************************/
/* NtGdiDdGetMoCompBuffInfo */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetMoCompBuffInfo(HANDLE hDirectDraw,
PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData)
{
PGD_DXDDGETMOCOMPBUFFINFO pfnDdGetMoCompBuffInfo = (PGD_DXDDGETMOCOMPBUFFINFO)gpDxFuncs[DXG_INDEX_DxDdGetMoCompBuffInfo].pfn;
if (pfnDdGetMoCompBuffInfo == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompBuffInfo");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompBuffInfo");
return pfnDdGetMoCompBuffInfo(hDirectDraw, puGetBuffData);
}
/************************************************************************/
/* NtGdiDdGetMoCompFormats */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetMoCompFormats(HANDLE hDirectDraw,
PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData)
{
PGD_DXDDGETMOCOMPFORMATS pfnDdGetMoCompFormats = (PGD_DXDDGETMOCOMPFORMATS)gpDxFuncs[DXG_INDEX_DxDdGetMoCompFormats].pfn;
if (pfnDdGetMoCompFormats == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompFormats");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompFormats");
return pfnDdGetMoCompFormats(hDirectDraw, puGetMoCompFormatsData);
}
/************************************************************************/
/* NtGdiDdGetMoCompGuids */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetMoCompGuids(HANDLE hDirectDraw,
PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData)
{
PGD_DXDDGETMOCOMPGUIDS pfnDdGetMoCompGuids = (PGD_DXDDGETMOCOMPGUIDS)gpDxFuncs[DXG_INDEX_DxDdGetMoCompGuids].pfn;
if (pfnDdGetMoCompGuids == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompGuids");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompGuids");
return pfnDdGetMoCompGuids(hDirectDraw, puGetMoCompGuidsData);
}
/************************************************************************/
/* NtGdiDdQueryMoCompStatus */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdQueryMoCompStatus(HANDLE hMoComp,
PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData)
{
PGD_DXDDQUERYMOCOMPSTATUS pfnDdQueryMoCompStatus = (PGD_DXDDQUERYMOCOMPSTATUS)gpDxFuncs[DXG_INDEX_DxDdQueryMoCompStatus].pfn;
if (pfnDdQueryMoCompStatus == NULL)
{
DPRINT1("Warning: no pfnDdQueryMoCompStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdQueryMoCompStatus");
return pfnDdQueryMoCompStatus(hMoComp, puQueryMoCompStatusData);
}
/************************************************************************/
/* NtGdiDdRenderMoComp */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdRenderMoComp(HANDLE hMoComp,
PDD_RENDERMOCOMPDATA puRenderMoCompData)
{
PGD_DXDDRENDERMOCOMP pfnDdRenderMoComp = (PGD_DXDDRENDERMOCOMP)gpDxFuncs[DXG_INDEX_DxDdRenderMoComp].pfn;
if (pfnDdRenderMoComp == NULL)
{
DPRINT1("Warning: no pfnDdRenderMoComp");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdRenderMoComp");
return pfnDdRenderMoComp(hMoComp, puRenderMoCompData);
}