diff --git a/reactos/boot/bootdata/packages/reactos.dff b/reactos/boot/bootdata/packages/reactos.dff index becc2959a31..c996e56891c 100644 --- a/reactos/boot/bootdata/packages/reactos.dff +++ b/reactos/boot/bootdata/packages/reactos.dff @@ -271,6 +271,10 @@ drivers\bus\acpi\acpi.sys 2 drivers\bus\isapnp\isapnp.sys 2 drivers\bus\pci\pci.sys 2 +\drivers\directx\dxapi\dxapi.sys 2 +drivers\directx\dxeng\dxeng.sys 2 +drivers\directx\dxg\dxg.sys 2 + drivers\filesystems\fs_rec\fs_rec.sys 2 drivers\filesystems\msfs\msfs.sys 2 drivers\filesystems\mup\mup.sys 2 diff --git a/reactos/drivers/directx/directory.rbuild b/reactos/drivers/directx/directory.rbuild new file mode 100644 index 00000000000..850deb34bf1 --- /dev/null +++ b/reactos/drivers/directx/directory.rbuild @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/reactos/drivers/directx/dxapi/dxapi.def b/reactos/drivers/directx/dxapi/dxapi.def new file mode 100644 index 00000000000..bcb4d177d78 --- /dev/null +++ b/reactos/drivers/directx/dxapi/dxapi.def @@ -0,0 +1,15 @@ +; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $ +; +; dxapi.def - export definition file for ReactOS +; +EXPORTS +DxApi@20 +DxApiGetVersion@0 +;DxApiInitialize@32 +;DxAutoflipUpdate@20 +;DxEnableIRQ@8 +;DxLoseObject@8 +;DxUpdateCapture@12 +GsDriverEntry@8 + + diff --git a/reactos/drivers/directx/dxapi/dxapi.rbuild b/reactos/drivers/directx/dxapi/dxapi.rbuild new file mode 100644 index 00000000000..5a356f9ad84 --- /dev/null +++ b/reactos/drivers/directx/dxapi/dxapi.rbuild @@ -0,0 +1,14 @@ + + + + + . + + + ntoskrnl + hal + videoprt + main.c + dxapi.rc + diff --git a/reactos/drivers/directx/dxapi/dxapi.rc b/reactos/drivers/directx/dxapi/dxapi.rc new file mode 100644 index 00000000000..0e1ae884202 --- /dev/null +++ b/reactos/drivers/directx/dxapi/dxapi.rc @@ -0,0 +1,7 @@ + + +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "DirectX API Driver\0" +#define REACTOS_STR_INTERNAL_NAME "dxgapi\0" +#define REACTOS_STR_ORIGINAL_FILENAME "dxgapi\0" +#include diff --git a/reactos/drivers/directx/dxapi/dxapi_driver.h b/reactos/drivers/directx/dxapi/dxapi_driver.h new file mode 100644 index 00000000000..6c17e0e874b --- /dev/null +++ b/reactos/drivers/directx/dxapi/dxapi_driver.h @@ -0,0 +1,158 @@ + + + +/* DDK/NDK/SDK Headers */ +/* DDK/NDK/SDK Headers */ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/* 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} +}; + + + diff --git a/reactos/drivers/directx/dxapi/main.c b/reactos/drivers/directx/dxapi/main.c new file mode 100644 index 00000000000..870d8a7d6b4 --- /dev/null +++ b/reactos/drivers/directx/dxapi/main.c @@ -0,0 +1,274 @@ + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver for dxg implementation + * FILE: drivers/directx/dxg/main.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + + +#include "dxapi_driver.h" + +NTSTATUS +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; +} + +NTSTATUS +GsDriverEntry(IN PVOID Context1, + IN PVOID Context2) +{ + return DriverEntry(Context1, Context2); +} + + + +/*++ +* @name DxApiGetVersion +* @implemented +* +* The function DxApiGetVersion return the dsound version, and it always return 4.02 +* +* @return +* Always return 4.02 +* +* @remarks. +* none +* +*--*/ +ULONG +DxApiGetVersion() +{ + /* 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 ; +* +*--*/ + +DXAPI +DWORD +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; +} + +/*++ +* @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 */ +} + + + diff --git a/reactos/drivers/directx/dxg/dxg.def b/reactos/drivers/directx/dxg/dxg.def new file mode 100644 index 00000000000..6500bd5809a --- /dev/null +++ b/reactos/drivers/directx/dxg/dxg.def @@ -0,0 +1,9 @@ +; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $ +; +; dxg.def - export definition file for ReactOS +; +EXPORTS +DriverEntry@8 +DxDdCleanupDxGraphics@0 +DxDdStartupDxGraphics@24 + diff --git a/reactos/drivers/directx/dxg/dxg.rbuild b/reactos/drivers/directx/dxg/dxg.rbuild new file mode 100644 index 00000000000..57421e86592 --- /dev/null +++ b/reactos/drivers/directx/dxg/dxg.rbuild @@ -0,0 +1,14 @@ + + + + + . + + dxgthk + ntoskrnl + main.c + eng.c + historic.c + dxg.rc + diff --git a/reactos/drivers/directx/dxg/dxg.rc b/reactos/drivers/directx/dxg/dxg.rc new file mode 100644 index 00000000000..9418600f0ba --- /dev/null +++ b/reactos/drivers/directx/dxg/dxg.rc @@ -0,0 +1,7 @@ +/* $Id: vbemp.rc 21844 2006-05-07 19:34:23Z ion $ */ + +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "DXG DirectX interface Device Driver\0" +#define REACTOS_STR_INTERNAL_NAME "dxg\0" +#define REACTOS_STR_ORIGINAL_FILENAME "dxg.sys\0" +#include diff --git a/reactos/drivers/directx/dxg/dxg_driver.h b/reactos/drivers/directx/dxg/dxg_driver.h new file mode 100644 index 00000000000..b3b726c05a7 --- /dev/null +++ b/reactos/drivers/directx/dxg/dxg_driver.h @@ -0,0 +1,98 @@ + + +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_DxDdUnlockD3D2, (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} + +}; diff --git a/reactos/drivers/directx/dxg/dxg_int.h b/reactos/drivers/directx/dxg/dxg_int.h new file mode 100644 index 00000000000..24135a1e967 --- /dev/null +++ b/reactos/drivers/directx/dxg/dxg_int.h @@ -0,0 +1,55 @@ + +/* DDK/NDK/SDK Headers */ +#include +#include +#include +#include +#include + +#define WINBASEAPI +#define STARTF_USESIZE 2 +#define STARTF_USEPOSITION 4 +#define INTERNAL_CALL NTAPI + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include + +#include "tags.h" + + +/* exported functions */ +NTSTATUS DriverEntry(IN PVOID Context1, IN PVOID Context2); +NTSTATUS GsDriverEntry(IN PVOID Context1, IN PVOID Context2); +NTSTATUS DxDdCleanupDxGraphics(); + + +/* Driver list export functions */ +DWORD STDCALL DxDxgGenericThunk(ULONG_PTR ulIndex, ULONG_PTR ulHandle, SIZE_T *pdwSizeOfPtr1, PVOID pvPtr1, SIZE_T *pdwSizeOfPtr2, PVOID pvPtr2); +DWORD STDCALL DxDdIoctl(ULONG ulIoctl, PVOID pBuffer, ULONG ulBufferSize); + +/* Internel functions */ +BOOL DdHmgCreate(); +BOOL DdHmgDestroy(); + +/* 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] diff --git a/reactos/drivers/directx/dxg/eng.c b/reactos/drivers/directx/dxg/eng.c new file mode 100644 index 00000000000..f83a44bfa74 --- /dev/null +++ b/reactos/drivers/directx/dxg/eng.c @@ -0,0 +1,14 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver for dxg implementation + * FILE: drivers/directx/dxg/main.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + + + + + diff --git a/reactos/drivers/directx/dxg/historic.c b/reactos/drivers/directx/dxg/historic.c new file mode 100644 index 00000000000..f69e1e8407c --- /dev/null +++ b/reactos/drivers/directx/dxg/historic.c @@ -0,0 +1,88 @@ + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver for dxg implementation + * FILE: drivers/directx/dxg/main.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + +#include + +/*++ +* @name DxDxgGenericThunk +* @implemented +* +* The function DxDxgGenericThunk redirect dx call to other thing. +* +* @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 return DDHAL_DRIVER_NOTHANDLED +* +* @remarks. +* This api are not longer use in Windows NT 2000/XP/2003 +* +*--*/ +DWORD +STDCALL +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 diffent dx 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 return DDERR_UNSUPPORTED +* +* @remarks. +* This api are not longer use in Windows NT 2000/XP/2003 +* +*--*/ +DWORD +STDCALL +DxDdIoctl(ULONG ulIoctl, + PVOID pBuffer, + ULONG ulBufferSize) +{ + return DDERR_UNSUPPORTED; +} + diff --git a/reactos/drivers/directx/dxg/main.c b/reactos/drivers/directx/dxg/main.c new file mode 100644 index 00000000000..3e171c244ed --- /dev/null +++ b/reactos/drivers/directx/dxg/main.c @@ -0,0 +1,195 @@ + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver for dxg implementation + * FILE: drivers/directx/dxg/main.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + + +#include +#include "dxg_driver.h" + +ULONG gcMaxDdHmgr = 0; +ULONG gcSizeDdHmgr = 0; +LONG gcDummyPageRefCnt = 0; +HSEMAPHORE ghsemHmgr = NULL; +HSEMAPHORE ghsemDummyPage = NULL; +VOID *gpDummyPage = NULL; +PEPROCESS gpepSession = NULL; +PLARGE_INTEGER gpLockShortDelay = NULL; +HANDLE ghFreeDdHmgr = 0; +VOID *gpentDdHmgr = NULL; +VOID *gpentDdHmgrLast = NULL; + + +PDRVFN gpEngFuncs; +const ULONG gcDxgFuncs = DXG_INDEX_DxDdIoctl + 1; + + + +NTSTATUS +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; + INT 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 +DxDdCleanupDxGraphics() +{ + DdHmgDestroy(); + + if (!ghsemDummyPage) + { + if (!gpDummyPage) + { + ExFreePoolWithTag(gpDummyPage,0); + gpDummyPage = NULL; + gcDummyPageRefCnt = 0; + } + EngDeleteSemaphore(ghsemDummyPage); + } + + return 0; +} + +BOOL +DdHmgDestroy() +{ + gcMaxDdHmgr = 0; + gcSizeDdHmgr = 0; + ghFreeDdHmgr = 0; + gpentDdHmgrLast = NULL; + + if (gpentDdHmgr) + { + EngFreeMem(gpentDdHmgr); + gpentDdHmgr = NULL; + } + + if (ghsemHmgr) + { + EngDeleteSemaphore(ghsemHmgr); + ghsemHmgr = NULL; + } + + return TRUE; +} + + +BOOL +DdHmgCreate() +{ + 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->QuadPart = ((LONGLONG)-100000); + return TRUE; + } + + EngDeleteSemaphore(ghsemHmgr); + ghsemHmgr = NULL; + } + + EngFreeMem(gpentDdHmgr); + gpentDdHmgr = NULL; + } + + return FALSE; +} diff --git a/reactos/drivers/directx/dxg/tags.h b/reactos/drivers/directx/dxg/tags.h new file mode 100644 index 00000000000..2dadac66208 --- /dev/null +++ b/reactos/drivers/directx/dxg/tags.h @@ -0,0 +1,8 @@ + + + +#define TAG_THDD TAG('t', 'h', 'd', 'd') +#define TAG_GINI TAG('G', 'i', 'n', 'i') + + + diff --git a/reactos/drivers/directx/dxgthk/dxgthk.def b/reactos/drivers/directx/dxgthk/dxgthk.def new file mode 100644 index 00000000000..ce0bc1b844f --- /dev/null +++ b/reactos/drivers/directx/dxgthk/dxgthk.def @@ -0,0 +1,26 @@ +; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $ +; +; dxg.def - export definition file for ReactOS +; +EXPORTS +DriverEntry@8 +EngAcquireSemaphore@4=win32k.EngAcquireSemaphore@4 +EngAllocMem@12=win32k.EngAllocMem@12 +EngAllocUserMem@8=win32k.EngAllocUserMem@8 +EngCopyBits@24=win32k.EngCopyBits@24 +EngCreateBitmap@24=win32k.EngCreateBitmap@24 +EngCreatePalette@24=win32k.EngCreatePalette@24 +EngCreateSemaphore@0=win32k.EngCreateSemaphore@0 +EngDeletePalette@4=win32k.EngDeletePalette@4 +EngDeleteSemaphore@4=win32k.EngDeleteSemaphore@4 +EngDeleteSurface@4=win32k.EngDeleteSurface@4 +EngFindImageProcAddress@8=win32k.EngFindImageProcAddress@8 +EngFreeMem@4=win32k.EngFreeMem@4 +EngFreeUserMem@4=win32k.EngFreeUserMem@4 +EngLoadImage@4=win32k.EngLoadImage@4 +EngLockSurface@4=win32k.EngLockSurface@4 +EngReleaseSemaphore@4=win32k.EngReleaseSemaphore@4 +EngSetLastError@4=win32k.EngSetLastError@4 +EngUnloadImage@4=win32k.EngUnloadImage@4 +EngUnlockSurface@4=win32k.EngUnlockSurface@4 + diff --git a/reactos/drivers/directx/dxgthk/dxgthk.rbuild b/reactos/drivers/directx/dxgthk/dxgthk.rbuild new file mode 100644 index 00000000000..d6e2448d1db --- /dev/null +++ b/reactos/drivers/directx/dxgthk/dxgthk.rbuild @@ -0,0 +1,11 @@ + + + + + . + + win32k + main.c + dxgthk.rc + diff --git a/reactos/drivers/directx/dxgthk/dxgthk.rc b/reactos/drivers/directx/dxgthk/dxgthk.rc new file mode 100644 index 00000000000..5f88c536cfa --- /dev/null +++ b/reactos/drivers/directx/dxgthk/dxgthk.rc @@ -0,0 +1,7 @@ +/* $Id: vbemp.rc 21844 2006-05-07 19:34:23Z ion $ */ + +#define REACTOS_VERSION_DLL +#define REACTOS_STR_FILE_DESCRIPTION "DirectX Graphics Driver Thunk\0" +#define REACTOS_STR_INTERNAL_NAME "dxgthk\0" +#define REACTOS_STR_ORIGINAL_FILENAME "dxgthk\0" +#include diff --git a/reactos/drivers/directx/dxgthk/main.c b/reactos/drivers/directx/dxgthk/main.c new file mode 100644 index 00000000000..11add7a18e0 --- /dev/null +++ b/reactos/drivers/directx/dxgthk/main.c @@ -0,0 +1,26 @@ + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver for dxg implementation + * FILE: drivers/directx/dxg/main.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + +/* DDK/NDK/SDK Headers */ +#include + +NTSTATUS +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; +} + + diff --git a/reactos/drivers/drivers.rbuild b/reactos/drivers/drivers.rbuild index 92a0bc725b1..5cc82caaca0 100644 --- a/reactos/drivers/drivers.rbuild +++ b/reactos/drivers/drivers.rbuild @@ -7,6 +7,9 @@ + + + diff --git a/reactos/include/ddk/d3dnthal.h b/reactos/include/ddk/d3dnthal.h index a890704345b..39142c4d2df 100644 --- a/reactos/include/ddk/d3dnthal.h +++ b/reactos/include/ddk/d3dnthal.h @@ -1,4 +1,4 @@ -/* +/* * Direct3D NT driver interface */ @@ -167,6 +167,36 @@ typedef struct _D3DNTHAL_CALLBACKS ULONG_PTR dwReserved9; } D3DNTHAL_CALLBACKS, *LPD3DNTHAL_CALLBACKS; +typedef DWORD (APIENTRY *LPD3DNTHAL_SETRENDERTARGETCB)(LPD3DNTHAL_SETRENDERTARGETDATA); + +typedef struct _D3DNTHAL_CALLBACKS2 +{ + DWORD dwSize; + DWORD dwFlags; + + LPD3DNTHAL_SETRENDERTARGETCB SetRenderTarget; + LPVOID dwReserved1; + LPVOID dwReserved2; + LPVOID dwReserved3; + LPVOID dwReserved4; +} D3DNTHAL_CALLBACKS2, *LPD3DNTHAL_CALLBACKS2; + +typedef DWORD (APIENTRY *LPD3DNTHAL_CLEAR2CB)(LPD3DNTHAL_CLEAR2DATA); +typedef DWORD (APIENTRY *LPD3DNTHAL_VALIDATETEXTURESTAGESTATECB)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA); +typedef DWORD (APIENTRY *LPD3DNTHAL_DRAWPRIMITIVES2CB)(LPD3DNTHAL_DRAWPRIMITIVES2DATA); + +typedef struct _D3DNTHAL_CALLBACKS3 +{ + DWORD dwSize; + DWORD dwFlags; + + LPD3DNTHAL_CLEAR2CB Clear2; + LPVOID lpvReserved; + LPD3DNTHAL_VALIDATETEXTURESTAGESTATECB ValidateTextureStageState; + LPD3DNTHAL_DRAWPRIMITIVES2CB DrawPrimitives2; +} D3DNTHAL_CALLBACKS3, *LPD3DNTHAL_CALLBACKS3; + + typedef struct _D3DNTHAL_VALIDATETEXTURESTAGESTATEDATA { ULONG_PTR dwhContext; diff --git a/reactos/include/ddk/ddkmapi.h b/reactos/include/ddk/ddkmapi.h index b0a177f2989..86a13994711 100644 --- a/reactos/include/ddk/ddkmapi.h +++ b/reactos/include/ddk/ddkmapi.h @@ -3,10 +3,8 @@ * * DirectDraw support for DxApi function * - * This file is part of the w32api package. - * * Contributors: - * Created by Casper S. Hornstrup + * Created by Magnus Olsen * * THIS SOFTWARE IS NOT COPYRIGHTED * @@ -20,16 +18,9 @@ * */ -#ifndef __DDKMAPI_H -#define __DDKMAPI_H +#ifndef __DDKMAPI_INCLUDED__ +#define __DDKMAPI_INCLUDED__ -#if __GNUC__ >=3 -#pragma GCC system_header -#endif - -#ifdef __cplusplus -extern "C" { -#endif #if defined(_DXAPI_) #define DXAPI DECLSPEC_EXPORT @@ -37,29 +28,12 @@ extern "C" { #define DXAPI DECLSPEC_IMPORT #endif -DXAPI -DWORD -FAR PASCAL -DxApi( - IN DWORD dwFunctionNum, - IN LPVOID lpvInBuffer, - IN DWORD cbInBuffer, - OUT LPVOID lpvOutBuffer, - OUT DWORD cbOutBuffer); - -typedef DWORD (FAR PASCAL *LPDXAPI)( - DWORD dwFunctionNum, - LPVOID lpvInBuffer, - DWORD cbInBuffer, - LPVOID lpvOutBuffer, - DWORD cbOutBuffer); #define DXAPI_MAJORVERSION 1 #define DXAPI_MINORVERSION 0 -#define DD_FIRST_DXAPI 0x500 - +#define DD_FIRST_DXAPI 0x500 #define DD_DXAPI_GETVERSIONNUMBER (DD_FIRST_DXAPI) #define DD_DXAPI_CLOSEHANDLE (DD_FIRST_DXAPI+1) #define DD_DXAPI_OPENDIRECTDRAW (DD_FIRST_DXAPI+2) @@ -83,114 +57,159 @@ typedef DWORD (FAR PASCAL *LPDXAPI)( #define DD_DXAPI_ADDVPCAPTUREBUFFER (DD_FIRST_DXAPI+20) #define DD_DXAPI_FLUSHVPCAPTUREBUFFERS (DD_FIRST_DXAPI+21) - -typedef struct _DDCAPBUFFINFO { - DWORD dwFieldNumber; - DWORD bPolarity; - LARGE_INTEGER liTimeStamp; - DWORD ddRVal; -} DDCAPBUFFINFO, FAR * LPDDCAPBUFFINFO; +/* DDOPENVPCAPTUREDEVICEIN.dwFlags constants */ +#define DDOPENCAPTURE_VIDEO 0x0001 +#define DDOPENCAPTURE_VBI 0x0002 /* DDADDVPCAPTUREBUFF.dwFlags constants */ -#define DDADDBUFF_SYSTEMMEMORY 0x0001 -#define DDADDBUFF_NONLOCALVIDMEM 0x0002 -#define DDADDBUFF_INVERT 0x0004 +#define DDADDBUFF_SYSTEMMEMORY 0x0001 +#define DDADDBUFF_NONLOCALVIDMEM 0x0002 +#define DDADDBUFF_INVERT 0x0004 -typedef struct _DDADDVPCAPTUREBUFF { - HANDLE hCapture; - DWORD dwFlags; - PMDL pMDL; - PKEVENT pKEvent; - LPDDCAPBUFFINFO lpBuffInfo; -} DDADDVPCAPTUREBUFF, FAR * LPDDADDVPCAPTUREBUFF; +/* DDGETSURFACESTATEOUT.dwStateCaps/dwStateStatus constants */ +#define DDSTATE_BOB 0x0001 +#define DDSTATE_WEAVE 0x0002 +#define DDSTATE_EXPLICITLY_SET 0x0004 +#define DDSTATE_SOFTWARE_AUTOFLIP 0x0008 +#define DDSTATE_SKIPEVENFIELDS 0x0010 -typedef struct _DDCLOSEHANDLE { - HANDLE hHandle; -} DDCLOSEHANDLE, FAR *LPDDCLOSEHANDLE; +/* DDREGISTERCALLBACK.dwEvents constants */ +#define DDEVENT_DISPLAY_VSYNC 0x0001 +#define DDEVENT_VP_VSYNC 0x0002 +#define DDEVENT_VP_LINE 0x0004 +#define DDEVENT_PRERESCHANGE 0x0008 +#define DDEVENT_POSTRESCHANGE 0x0010 +#define DDEVENT_PREDOSBOX 0x0020 +#define DDEVENT_POSTDOSBOX 0x0040 -typedef struct _DDFLIPOVERLAY { - HANDLE hDirectDraw; - HANDLE hCurrentSurface; - HANDLE hTargetSurface; - DWORD dwFlags; -} DDFLIPOVERLAY, FAR *LPDDFLIPOVERLAY; +/* LPDD_NOTIFYCALLBACK.dwFlags constants */ +#define DDNOTIFY_DISPLAY_VSYNC 0x0001 +#define DDNOTIFY_VP_VSYNC 0x0002 +#define DDNOTIFY_VP_LINE 0x0004 +#define DDNOTIFY_PRERESCHANGE 0x0008 +#define DDNOTIFY_POSTRESCHANGE 0x0010 +#define DDNOTIFY_PREDOSBOX 0x0020 +#define DDNOTIFY_POSTDOSBOX 0x0040 +#define DDNOTIFY_CLOSEDIRECTDRAW 0x0080 +#define DDNOTIFY_CLOSESURFACE 0x0100 +#define DDNOTIFY_CLOSEVIDEOPORT 0x0200 +#define DDNOTIFY_CLOSECAPTURE 0x0400 -typedef struct _DDFLIPVIDEOPORT { +typedef DWORD (*LPDXAPI)(DWORD dwFunctionNum, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer); +typedef ULONG (*LPDD_NOTIFYCALLBACK) (DWORD dwFlags, PVOID pContext, DWORD dwParam1, DWORD dwParam2); + +typedef struct _DDCAPBUFFINFO +{ + DWORD dwFieldNumber; + DWORD bPolarity; + LARGE_INTEGER liTimeStamp; + DWORD ddRVal; +} DDCAPBUFFINFO, * LPDDCAPBUFFINFO; + +typedef struct _DDADDVPCAPTUREBUFF +{ + HANDLE hCapture; + DWORD dwFlags; + PMDL pMDL; + PKEVENT pKEvent; + LPDDCAPBUFFINFO lpBuffInfo; +} DDADDVPCAPTUREBUFF, * LPDDADDVPCAPTUREBUFF; + +typedef struct _DDCLOSEHANDLE +{ + HANDLE hHandle; +} DDCLOSEHANDLE, *LPDDCLOSEHANDLE; + +typedef struct _DDFLIPOVERLAY +{ + HANDLE hDirectDraw; + HANDLE hCurrentSurface; + HANDLE hTargetSurface; + DWORD dwFlags; +} DDFLIPOVERLAY, *LPDDFLIPOVERLAY; + +typedef struct _DDFLIPVIDEOPORT +{ HANDLE hDirectDraw; HANDLE hVideoPort; HANDLE hCurrentSurface; HANDLE hTargetSurface; DWORD dwFlags; -} DDFLIPVIDEOPORT, FAR *LPDDFLIPVIDEOPORT; +} DDFLIPVIDEOPORT, *LPDDFLIPVIDEOPORT; -typedef struct _DDGETAUTOFLIPIN { +typedef struct _DDGETAUTOFLIPIN +{ HANDLE hDirectDraw; HANDLE hVideoPort; -} DDGETAUTOFLIPIN, FAR *LPDDGETAUTOFLIPIN; +} DDGETAUTOFLIPIN, *LPDDGETAUTOFLIPIN; -typedef struct _DDGETAUTOFLIPOUT { +typedef struct _DDGETAUTOFLIPOUT +{ DWORD ddRVal; HANDLE hVideoSurface; HANDLE hVBISurface; BOOL bPolarity; -} DDGETAUTOFLIPOUT, FAR *LPDDGETAUTOFLIPOUT; +} DDGETAUTOFLIPOUT, *LPDDGETAUTOFLIPOUT; -typedef struct _DDGETPOLARITYIN { +typedef struct _DDGETPOLARITYIN +{ HANDLE hDirectDraw; HANDLE hVideoPort; -} DDGETPOLARITYIN, FAR *LPDDGETPOLARITYIN; +} DDGETPOLARITYIN, *LPDDGETPOLARITYIN; -typedef struct _DDGETPOLARITYOUT { +typedef struct _DDGETPOLARITYOUT +{ DWORD ddRVal; BOOL bPolarity; -} DDGETPOLARITYOUT, FAR *LPDDGETPOLARITYOUT; +} DDGETPOLARITYOUT, *LPDDGETPOLARITYOUT; -typedef struct _DDGETSURFACESTATEIN { +typedef struct _DDGETSURFACESTATEIN +{ HANDLE hDirectDraw; HANDLE hSurface; -} DDGETSURFACESTATEIN, FAR *LPDDGETSURFACESTATEIN; +} DDGETSURFACESTATEIN, *LPDDGETSURFACESTATEIN; -/* DDGETSURFACESTATEOUT.dwStateCaps/dwStateStatus constants */ -#define DDSTATE_BOB 0x0001 -#define DDSTATE_WEAVE 0x0002 -#define DDSTATE_EXPLICITLY_SET 0x0004 -#define DDSTATE_SOFTWARE_AUTOFLIP 0x0008 -#define DDSTATE_SKIPEVENFIELDS 0x0010 - -typedef struct _DDGETSURFACESTATEOUT { +typedef struct _DDGETSURFACESTATEOUT +{ DWORD ddRVal; DWORD dwStateCaps; DWORD dwStateStatus; -} DDGETSURFACESTATEOUT, FAR *LPDDGETSURFACESTATEOUT; +} DDGETSURFACESTATEOUT, *LPDDGETSURFACESTATEOUT; -typedef struct _DDGETFIELDNUMIN { +typedef struct _DDGETFIELDNUMIN +{ HANDLE hDirectDraw; HANDLE hVideoPort; -} DDGETFIELDNUMIN, FAR *LPDDGETFIELDNUMIN; +} DDGETFIELDNUMIN, *LPDDGETFIELDNUMIN; -typedef struct _DDGETFIELDNUMOUT { +typedef struct _DDGETFIELDNUMOUT +{ DWORD ddRVal; DWORD dwFieldNum; -} DDGETFIELDNUMOUT, FAR *LPDDGETFIELDNUMOUT; +} DDGETFIELDNUMOUT, *LPDDGETFIELDNUMOUT; -typedef struct _DDGETKERNELCAPSOUT { +typedef struct _DDGETKERNELCAPSOUT +{ DWORD ddRVal; DWORD dwCaps; DWORD dwIRQCaps; -} DDGETKERNELCAPSOUT, FAR *LPDDGETKERNELCAPSOUT; +} DDGETKERNELCAPSOUT, *LPDDGETKERNELCAPSOUT; -typedef struct _DDGETVERSIONNUMBER { +typedef struct _DDGETVERSIONNUMBER +{ DWORD ddRVal; DWORD dwMajorVersion; DWORD dwMinorVersion; -} DDGETVERSIONNUMBER, FAR *LPDDGETVERSIONNUMBER; +} DDGETVERSIONNUMBER, *LPDDGETVERSIONNUMBER; -typedef struct _DDLOCKIN { +typedef struct _DDLOCKIN +{ HANDLE hDirectDraw; HANDLE hSurface; -} DDLOCKIN, FAR *LPDDLOCKIN; +} DDLOCKIN, *LPDDLOCKIN; -typedef struct _DDLOCKOUT { +typedef struct _DDLOCKOUT +{ DWORD ddRVal; DWORD dwSurfHeight; DWORD dwSurfWidth; @@ -200,79 +219,67 @@ typedef struct _DDLOCKOUT { DWORD dwFormatFlags; DWORD dwFormatFourCC; DWORD dwFormatBitCount; - _ANONYMOUS_UNION union { + union + { DWORD dwRBitMask; DWORD dwYBitMask; - } DUMMYUNIONNAME; - _ANONYMOUS_UNION union { + }; + union + { DWORD dwGBitMask; DWORD dwUBitMask; - } DUMMYUNIONNAME2; - _ANONYMOUS_UNION union { + }; + union + { DWORD dwBBitMask; DWORD dwVBitMask; - } DUMMYUNIONNAME3; -} DDLOCKOUT, FAR *LPDDLOCKOUT; + }; +} DDLOCKOUT, *LPDDLOCKOUT; -/* LPDD_NOTIFYCALLBACK.dwFlags constants */ -#define DDNOTIFY_DISPLAY_VSYNC 0x0001 -#define DDNOTIFY_VP_VSYNC 0x0002 -#define DDNOTIFY_VP_LINE 0x0004 -#define DDNOTIFY_PRERESCHANGE 0x0008 -#define DDNOTIFY_POSTRESCHANGE 0x0010 -#define DDNOTIFY_PREDOSBOX 0x0020 -#define DDNOTIFY_POSTDOSBOX 0x0040 -#define DDNOTIFY_CLOSEDIRECTDRAW 0x0080 -#define DDNOTIFY_CLOSESURFACE 0x0100 -#define DDNOTIFY_CLOSEVIDEOPORT 0x0200 -#define DDNOTIFY_CLOSECAPTURE 0x0400 -typedef ULONG (FAR PASCAL *LPDD_NOTIFYCALLBACK)( - DWORD dwFlags, - PVOID pContext, - DWORD dwParam1, - DWORD dwParam2); - -typedef struct _DDOPENDIRECTDRAWIN { - ULONG_PTR dwDirectDrawHandle; +typedef struct _DDOPENDIRECTDRAWIN +{ + ULONG_PTR dwDirectDrawHandle; LPDD_NOTIFYCALLBACK pfnDirectDrawClose; PVOID pContext; -} DDOPENDIRECTDRAWIN, FAR *LPDDOPENDIRECTDRAWIN; +} DDOPENDIRECTDRAWIN, *LPDDOPENDIRECTDRAWIN; -typedef struct _DDOPENDIRECTDRAWOUT { +typedef struct _DDOPENDIRECTDRAWOUT +{ DWORD ddRVal; HANDLE hDirectDraw; -} DDOPENDIRECTDRAWOUT, FAR *LPDDOPENDIRECTDRAWOUT; +} DDOPENDIRECTDRAWOUT, *LPDDOPENDIRECTDRAWOUT; -typedef struct _DDOPENSURFACEIN { +typedef struct _DDOPENSURFACEIN +{ HANDLE hDirectDraw; ULONG_PTR dwSurfaceHandle; LPDD_NOTIFYCALLBACK pfnSurfaceClose; PVOID pContext; -} DDOPENSURFACEIN, FAR *LPDDOPENSURFACEIN; +} DDOPENSURFACEIN, *LPDDOPENSURFACEIN; -typedef struct _DDOPENSURFACEOUT { +typedef struct _DDOPENSURFACEOUT +{ DWORD ddRVal; HANDLE hSurface; -} DDOPENSURFACEOUT, FAR *LPDDOPENSURFACEOUT; +} DDOPENSURFACEOUT, *LPDDOPENSURFACEOUT; -typedef struct _DDOPENVIDEOPORTIN { +typedef struct _DDOPENVIDEOPORTIN +{ HANDLE hDirectDraw; ULONG dwVideoPortHandle; LPDD_NOTIFYCALLBACK pfnVideoPortClose; PVOID pContext; -} DDOPENVIDEOPORTIN, FAR *LPDDOPENVIDEOPORTIN; +} DDOPENVIDEOPORTIN, *LPDDOPENVIDEOPORTIN; -typedef struct _DDOPENVIDEOPORTOUT { +typedef struct _DDOPENVIDEOPORTOUT +{ DWORD ddRVal; HANDLE hVideoPort; -} DDOPENVIDEOPORTOUT, FAR *LPDDOPENVIDEOPORTOUT; +} DDOPENVIDEOPORTOUT, *LPDDOPENVIDEOPORTOUT; -/* DDOPENVPCAPTUREDEVICEIN.dwFlags constants */ -#define DDOPENCAPTURE_VIDEO 0x0001 -#define DDOPENCAPTURE_VBI 0x0002 - -typedef struct _DDOPENVPCAPTUREDEVICEIN { +typedef struct _DDOPENVPCAPTUREDEVICEIN +{ HANDLE hDirectDraw; HANDLE hVideoPort; DWORD dwStartLine; @@ -281,52 +288,55 @@ typedef struct _DDOPENVPCAPTUREDEVICEIN { LPDD_NOTIFYCALLBACK pfnCaptureClose; PVOID pContext; DWORD dwFlags; -} DDOPENVPCAPTUREDEVICEIN, FAR * LPDDOPENVPCAPTUREDEVICEIN; +} DDOPENVPCAPTUREDEVICEIN, * LPDDOPENVPCAPTUREDEVICEIN; -typedef struct _DDOPENVPCAPTUREDEVICEOUT { +typedef struct _DDOPENVPCAPTUREDEVICEOUT +{ DWORD ddRVal; HANDLE hCapture; -} DDOPENVPCAPTUREDEVICEOUT, FAR * LPDDOPENVPCAPTUREDEVICEOUT; +} DDOPENVPCAPTUREDEVICEOUT, * LPDDOPENVPCAPTUREDEVICEOUT; -/* DDREGISTERCALLBACK.dwEvents constants */ -#define DDEVENT_DISPLAY_VSYNC 0x0001 -#define DDEVENT_VP_VSYNC 0x0002 -#define DDEVENT_VP_LINE 0x0004 -#define DDEVENT_PRERESCHANGE 0x0008 -#define DDEVENT_POSTRESCHANGE 0x0010 -#define DDEVENT_PREDOSBOX 0x0020 -#define DDEVENT_POSTDOSBOX 0x0040 - -typedef struct _DDREGISTERCALLBACK { +typedef struct _DDREGISTERCALLBACK +{ HANDLE hDirectDraw; ULONG dwEvents; LPDD_NOTIFYCALLBACK pfnCallback; ULONG_PTR dwParam1; ULONG_PTR dwParam2; PVOID pContext; -} DDREGISTERCALLBACK, FAR *LPDDREGISTERCALLBACK; +} DDREGISTERCALLBACK, *LPDDREGISTERCALLBACK; -typedef struct _DDSETSURFACETATE { +typedef struct _DDSETSURFACETATE +{ HANDLE hDirectDraw; HANDLE hSurface; DWORD dwState; DWORD dwStartField; -} DDSETSURFACESTATE, FAR *LPDDSETSURFACESTATE; +} DDSETSURFACESTATE, *LPDDSETSURFACESTATE; -typedef struct _DDSETFIELDNUM { +typedef struct _DDSETFIELDNUM +{ HANDLE hDirectDraw; HANDLE hVideoPort; DWORD dwFieldNum; -} DDSETFIELDNUM, FAR *LPDDSETFIELDNUM; +} DDSETFIELDNUM, *LPDDSETFIELDNUM; -typedef struct _DDSETSKIPFIELD { +typedef struct _DDSETSKIPFIELD +{ HANDLE hDirectDraw; HANDLE hVideoPort; DWORD dwStartField; -} DDSETSKIPFIELD, FAR *LPDDSETSKIPFIELD; +} DDSETSKIPFIELD, *LPDDSETSKIPFIELD; -#ifdef __cplusplus -} -#endif -#endif /* __DDKMAPI_H */ +DXAPI +DWORD +DxApi(IN DWORD dwFunctionNum, + IN LPVOID lpvInBuffer, + IN DWORD cbInBuffer, + OUT LPVOID lpvOutBuffer, + OUT DWORD cbOutBuffer); + + + +#endif /* __DDKMAPI_INCLUDED__ */ diff --git a/reactos/include/psdk/ntgdi.h b/reactos/include/psdk/ntgdi.h index 28db5f7a35c..ffba4ea422b 100644 --- a/reactos/include/psdk/ntgdi.h +++ b/reactos/include/psdk/ntgdi.h @@ -698,7 +698,7 @@ NtGdiDdSetOverlayPosition( ); W32KAPI -VOID +DWORD APIENTRY NtGdiDdUnattachSurface( IN HANDLE hSurface, @@ -794,7 +794,7 @@ NtGdiDdDestroyD3DBuffer( ); W32KAPI -DWORD +BOOL APIENTRY NtGdiD3dContextCreate( IN HANDLE hDirectDrawLocal, diff --git a/reactos/include/reactos/drivers/directx/directxint.h b/reactos/include/reactos/drivers/directx/directxint.h new file mode 100644 index 00000000000..7084b750f8a --- /dev/null +++ b/reactos/include/reactos/drivers/directx/directxint.h @@ -0,0 +1,141 @@ + +#ifndef _DXINTERNEL_ +#define _DXINTERNEL_ + +typedef struct _EDD_DIRECTDRAW_LOCAL +{ + // + // GDI Object Header + // + HANDLE hHmgr; + PVOID pEntry; + INT cExcLock; + HANDLE Tid; + + struct _EDD_DIRECTDRAW_GLOBAL * peDirectDrawGlobal; + struct _EDD_DIRECTDRAW_GLOBAL * peDirectDrawGlobal2; + struct _EDD_SURFACE * peSurface_DdList; + ULONG unk_01c[2]; + struct _EDD_DIRECTDRAW_LOCAL * peDirectDrawLocalNext; + FLATPTR fpProcess; + FLONG fl; + HANDLE UniqueProcess; + PEPROCESS Process; + ULONG unk_038[2]; + VOID *unk_040; + VOID *unk_044; +} EDD_DIRECTDRAW_LOCAL, PEDD_DIRECTDRAW_LOCAL; + + +// +// Surface Object +// +typedef struct _EDD_SURFACE +{ + // + // GDI Object Header + // + HANDLE hHmgr; + PVOID pEntry; + INT cExcLock; + HANDLE Tid; + + // + // Direct Draw Surface Data + // + DD_SURFACE_LOCAL ddsSurfaceLocal; + DD_SURFACE_MORE ddsSurfaceMore; + DD_SURFACE_GLOBAL ddsSurfaceGlobal; + DD_SURFACE_INT ddsSurfaceInt; + + // + // Surface pointers + // + struct _EDD_SURFACE *peSurface_DdNext; + struct _EDD_SURFACE *peSurface_LockNext; + + // + // Unknown + // + ULONG field_C0; + + // + // Private Direct Draw Data + // + struct _EDD_DIRECTDRAW_GLOBAL* peDirectDrawGlobal; + struct _EDD_DIRECTDRAW_LOCAL* peDirectDrawLocal; + + // + // Flags + // + FLONG fl; + + // + // Surface Attributes + // + ULONG cLocks; + ULONG iVisRgnUniqueness; + BOOL bLost; + HANDLE hSecure; + HANDLE hdc; + HBITMAP hbmGdi; + + // + // Unknown + // + ULONG field_E8; + + // + // Surface Lock + // + RECTL rclLock; + ULONG field_FC[2]; +} EDD_SURFACE, *PEDD_SURFACE; + + +typedef struct _EDD_DIRECTDRAW_GLOBAL +{ +/* 0x000 */ PVOID dhpdev; /* The assign pdev */ +/* 0x004 */ DWORD dwReserved1; +/* 0x008 */ DWORD dwReserved2; +/* 0x00C */ ULONG unk_000c[3]; +/* 0x018 */ LONG cDriverReferences; +/* 0x01C */ ULONG unk_01c[3]; +/* 0x028 */ LONGLONG llAssertModeTimeout; +/* 0x030 */ DWORD dwNumHeaps; +/* 0x034 */ VIDEOMEMORY *pvmList; +/* 0x038 */ DWORD dwNumFourCC; +/* 0x03C */ PDWORD pdwFourCC; +/* 0x040 */ DD_HALINFO ddHalInfo; +/* 0x1E0 */ ULONG unk_1e0[44]; +/* 0x290 */ DD_CALLBACKS ddCallbacks; +/* 0x2C4 */ DD_SURFACECALLBACKS ddSurfaceCallbacks; +/* 0x304 */ DD_PALETTECALLBACKS ddPaletteCallbacks; +/* 0x314 */ ULONG unk_314[48]; +/* 0x3D4 */ D3DNTHAL_CALLBACKS d3dNtHalCallbacks; +/* 0x460 */ ULONG unk_460[7]; +/* 0x47C */ D3DNTHAL_CALLBACKS2 d3dNtHalCallbacks2; +/* 0x498 */ ULONG unk_498[18]; +/* 0x4E0 */ DD_MISCELLANEOUSCALLBACKS ddMiscellanousCallbacks; +/* 0x4EC */ ULONG unk_4ec[18]; +/* 0x534 */ D3DNTHAL_CALLBACKS3 d3dNtHalCallbacks3; +/* 0x54C */ ULONG unk_54c[23]; +/* 0x5A8 */ EDD_DIRECTDRAW_LOCAL* peDirectDrawLocalList; +/* 0x5ac */ EDD_SURFACE* peSurface_LockList; +/* 0x5B0 */ FLONG fl; +/* 0x5B4 */ ULONG cSurfaceLocks; +/* 0x5B8 */ PKEVENT pAssertModeEvent; +/* 0x5Bc */ EDD_SURFACE *peSurfaceCurrent; +/* 0x5C0 */ EDD_SURFACE *peSurfacePrimary; +/* 0x5C4 */ BOOL bSuspended; +/* 0x5C8 */ ULONG unk_5c8[12]; +/* 0x5F8 */ RECTL rcbounds; +/* 0x608 */ HDEV hDev; +/* 0x60c */ PVOID hPDev; /* The real Pdev */ + +/* Windows XP and higher */ +/* 0x610 */ ULONG unk_610[63]; +/* 0x70C */ ULONG unk_70C; +} EDD_DIRECTDRAW_GLOBAL, *PEDD_DIRECTDRAW_GLOBAL; + +#endif diff --git a/reactos/include/reactos/drivers/directx/dxeng.h b/reactos/include/reactos/drivers/directx/dxeng.h new file mode 100644 index 00000000000..0488557573c --- /dev/null +++ b/reactos/include/reactos/drivers/directx/dxeng.h @@ -0,0 +1,117 @@ + +/************************************************************************/ +/* This driver interface are exported from win32k.sys to dxg.sys */ +/************************************************************************/ +#define DXENG_INDEX_Resverd0 0x00 +#define DXENG_INDEX_DxEngNUIsTermSrv 0x01 +#define DXENG_INDEX_DxEngScreenAccessCheck 0x02 +#define DXENG_INDEX_DxEngRedrawDesktop 0x03 +#define DXENG_INDEX_DxEngDispUniq 0x04 +#define DXENG_INDEX_DxEngIncDispUniq 0x05 +#define DXENG_INDEX_DxEngVisRgnUniq 0x06 +#define DXENG_INDEX_DxEngLockShareSem 0x07 +#define DXENG_INDEX_DxEngUnlockShareSem 0x08 +#define DXENG_INDEX_DxEngEnumerateHdev 0x09 +#define DXENG_INDEX_DxEngLockHdev 0x0A +#define DXENG_INDEX_DxEngUnlockHdev 0x0B +#define DXENG_INDEX_DxEngIsHdevLockedByCurrentThread 0x0C +#define DXENG_INDEX_DxEngReferenceHdev 0x0D +#define DXENG_INDEX_DxEngUnreferenceHdev 0x0E +#define DXENG_INDEX_DxEngGetDeviceGammaRamp 0x0F +#define DXENG_INDEX_DxEngSetDeviceGammaRamp 0x10 +#define DXENG_INDEX_DxEngSpTearDownSprites 0x11 +#define DXENG_INDEX_DxEngSpUnTearDownSprites 0x12 +#define DXENG_INDEX_DxEngSpSpritesVisible 0x13 +#define DXENG_INDEX_DxEngGetHdevData 0x14 +#define DXENG_INDEX_DxEngSetHdevData 0x15 +#define DXENG_INDEX_DxEngCreateMemoryDC 0x16 +#define DXENG_INDEX_DxEngGetDesktopDC 0x17 +#define DXENG_INDEX_DxEngDeleteDC 0x18 +#define DXENG_INDEX_DxEngCleanDC 0x19 +#define DXENG_INDEX_DxEngSetDCOwner 0x1A +#define DXENG_INDEX_DxEngLockDC 0x1B +#define DXENG_INDEX_DxEngUnlockDC 0x1C +#define DXENG_INDEX_DxEngSetDCState 0x1D +#define DXENG_INDEX_DxEngGetDCState 0x1E +#define DXENG_INDEX_DxEngSelectBitmap 0x1F +#define DXENG_INDEX_DxEngSetBitmapOwner 0x20 +#define DXENG_INDEX_DxEngDeleteSurface 0x21 +#define DXENG_INDEX_DxEngGetSurfaceData 0x22 +#define DXENG_INDEX_DxEngAltLockSurface 0x23 +#define DXENG_INDEX_DxEngUploadPaletteEntryToSurface 0x24 +#define DXENG_INDEX_DxEngMarkSurfaceAsDirectDraw 0x25 +#define DXENG_INDEX_DxEngSelectPaletteToSurface 0x26 +#define DXENG_INDEX_DxEngSyncPaletteTableWithDevice 0x27 +#define DXENG_INDEX_DxEngSetPaletteState 0x28 +#define DXENG_INDEX_DxEngGetRedirectionBitmap 0x29 +#define DXENG_INDEX_DxEngLoadImage 0x2A + +/************************************************************************/ +/* win32k.sys internal protypes for the driver functions it export */ +/************************************************************************/ + +/* Notes : Check see if termal server got a connections or not */ +BOOL DxEngNUIsTermSrv(); + +/* Notes : it always return TRUE, and it update whole the screen (redaw current desktop) */ +BOOL DxEngRedrawDesktop(); + +/* Notes : return the DisplayUniqVisrgn counter from gdishare memory */ +ULONG DxEngDispUniq(); + +/* Notes : return the VisRgnUniq counter for win32k */ +ULONG DxEngVisRgnUniq(); + +/* Notes : Enumate all drivers in win32k */ +HDEV *DxEngEnumerateHdev(HDEV *hdev); + +/* Notes : same protypes NtGdiEngGetDeviceGammaRamp, diffent is we skipp the user mode checks and seh */ +BOOL +DxEngGetDeviceGammaRamp(HDC hDC, LPVOID lpRamp); + +/* Notes : Lock the hDC */ +PDC DxEngLockDC(HDC hDC); + +/* Notes : Unlock the hDC */ +BOOL DxEngUnlockDC(PDC pDC); + + + +/* prototypes are not done yet, I need gather all my notes + * to make them correct + */ +DWORD DxEngCreateMemoryDC(DWORD x1); +DWORD DxEngScreenAccessCheck(); +DWORD DxEngLockShareSem(); +DWORD DxEngUnlockShareSem(); +DWORD DxEngLockHdev(DWORD x1); +DWORD DxEngUnlockHdev(DWORD x1); +DWORD DxEngReferenceHdev(DWORD x1); +DWORD DxEngIsHdevLockedByCurrentThread(DWORD x1); +DWORD DxEngUnreferenceHdev(DWORD x1); +DWORD DxEngSetDeviceGammaRamp(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngSpSpritesVisible(DWORD x1); +DWORD DxEngGetHdevData(PEDD_DIRECTDRAW_GLOBAL pEDDgpl, DWORD Index); +DWORD DxEngSetHdevData(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngGetDesktopDC(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngDeleteDC(DWORD x1, DWORD x2); +DWORD DxEngCleanDC(DWORD x1); +DWORD DxEngSetDCOwner(DWORD x1, DWORD x2); +DWORD DxEngSetDCState(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngGetDCState(HDC hDC, DWORD type); +DWORD DxEngSelectBitmap(DWORD x1, DWORD x2); +DWORD DxEngSetBitmapOwner(DWORD x1, DWORD x2); +DWORD DxEngDeleteSurface(DWORD x1); +DWORD DxEngGetSurfaceData(DWORD x1, DWORD x2); +DWORD DxEngAltLockSurface(DWORD x1); +DWORD DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4); +DWORD DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2); +DWORD DxEngSelectPaletteToSurface(DWORD x1, DWORD x2); +DWORD DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2); +DWORD DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3); +DWORD DxEngGetRedirectionBitmap(DWORD x1); +DWORD DxEngLoadImage(DWORD x1,DWORD x2); +DWORD DxEngIncDispUniq(); + diff --git a/reactos/include/reactos/drivers/directx/dxg.h b/reactos/include/reactos/drivers/directx/dxg.h new file mode 100644 index 00000000000..7b89b994a3d --- /dev/null +++ b/reactos/include/reactos/drivers/directx/dxg.h @@ -0,0 +1,217 @@ + + +/* win32k driver functions table it have created for the engine the DxEng* api */ + + +/* DXG.SYS FUNCTIONS INDEX */ +/***************************************************************************/ +/* This driver functions are exported raw from NtGdiDd* / NtDvp* / NtD3d* */ +/***************************************************************************/ +#define DXG_INDEX_DxDxgGenericThunk 0x00 +#define DXG_INDEX_DxD3dContextCreate 0x01 +#define DXG_INDEX_DxD3dContextDestroy 0x02 +#define DXG_INDEX_DxD3dContextDestroyAll 0x03 +#define DXG_INDEX_DxD3dValidateTextureStageState 0x04 +#define DXG_INDEX_DxD3dDrawPrimitives2 0x05 +#define DXG_INDEX_DxDdGetDriverState 0x06 +#define DXG_INDEX_DxDdAddAttachedSurface 0x07 +#define DXG_INDEX_DxDdAlphaBlt 0x08 +#define DXG_INDEX_DxDdAttachSurface 0x09 +#define DXG_INDEX_DxDdBeginMoCompFrame 0x0A +#define DXG_INDEX_DxDdBlt 0x0B +#define DXG_INDEX_DxDdCanCreateSurface 0x0C +#define DXG_INDEX_DxDdCanCreateD3DBuffer 0x0D +#define DXG_INDEX_DxDdColorControl 0x0E +#define DXG_INDEX_DxDdCreateDirectDrawObject 0x0F +/* DXG_INDEX_DxDdCreateSurface and DXG_INDEX_DxDdCreateD3DBuffer2 are same */ +#define DXG_INDEX_DxDdCreateSurface 0x10 +#define DXG_INDEX_DxDdCreateD3DBuffer 0x11 +#define DXG_INDEX_DxDdCreateMoComp 0x12 +#define DXG_INDEX_DxDdCreateSurfaceObject 0x13 +#define DXG_INDEX_DxDdDeleteDirectDrawObject 0x14 +#define DXG_INDEX_DxDdDeleteSurfaceObject 0x15 +#define DXG_INDEX_DxDdDestroyMoComp 0x16 +#define DXG_INDEX_DxDdDestroySurface 0x17 +#define DXG_INDEX_DxDdDestroyD3DBuffer 0x18 +#define DXG_INDEX_DxDdEndMoCompFrame 0x19 +#define DXG_INDEX_DxDdFlip 0x1A +#define DXG_INDEX_DxDdFlipToGDISurface 0x1B +#define DXG_INDEX_DxDdGetAvailDriverMemory 0x1C +#define DXG_INDEX_DxDdGetBltStatus 0x1D +#define DXG_INDEX_DxDdGetDC 0x1E +#define DXG_INDEX_DxDdGetDriverInfo 0x1F +#define DXG_INDEX_DxDdGetDxHandle 0x20 +#define DXG_INDEX_DxDdGetFlipStatus 0x21 +#define DXG_INDEX_DxDdGetInternalMoCompInfo 0x22 +#define DXG_INDEX_DxDdGetMoCompBuffInfo 0x23 +#define DXG_INDEX_DxDdGetMoCompGuids 0x24 +#define DXG_INDEX_DxDdGetMoCompFormats 0x25 +#define DXG_INDEX_DxDdGetScanLine 0x26 +/* DXG_INDEX_DxDdLock and DXG_INDEX_DxDdLockD3D are same */ +#define DXG_INDEX_DxDdLock 0x27 +#define DXG_INDEX_DxDdLockD3D 0x28 +#define DXG_INDEX_DxDdQueryDirectDrawObject 0x29 +#define DXG_INDEX_DxDdQueryMoCompStatus 0x2A +#define DXG_INDEX_DxDdReenableDirectDrawObject 0x2B +#define DXG_INDEX_DxDdReleaseDC 0x2C +#define DXG_INDEX_DxDdRenderMoComp 0x2D +#define DXG_INDEX_DxDdResetVisrgn 0x2E +#define DXG_INDEX_DxDdSetColorKey 0x2F +#define DXG_INDEX_DxDdSetExclusiveMode 0x30 +#define DXG_INDEX_DxDdSetGammaRamp 0x31 +#define DXG_INDEX_DxDdCreateSurfaceEx 0x32 +#define DXG_INDEX_DxDdSetOverlayPosition 0x33 +#define DXG_INDEX_DxDdUnattachSurface 0x34 +/* DXG_INDEX_DxDdUnlock and DXG_INDEX_DxDdUnlockD3D are same */ +#define DXG_INDEX_DxDdUnlock 0x35 +#define DXG_INDEX_DxDdUnlockD3D 0x36 +#define DXG_INDEX_DxDdUpdateOverlay 0x37 +#define DXG_INDEX_DxDdWaitForVerticalBlank 0x38 +#define DXG_INDEX_DxDvpCanCreateVideoPort 0x39 +#define DXG_INDEX_DxDvpColorControl 0x3A +#define DXG_INDEX_DxDvpCreateVideoPort 0x3B +#define DXG_INDEX_DxDvpDestroyVideoPort 0x3C +#define DXG_INDEX_DxDvpFlipVideoPort 0x3D +#define DXG_INDEX_DxDvpGetVideoPortBandwidth 0x3E +#define DXG_INDEX_DxDvpGetVideoPortField 0x3F +#define DXG_INDEX_DxDvpGetVideoPortFlipStatus 0x40 +#define DXG_INDEX_DxDvpGetVideoPortInputFormats 0x41 +#define DXG_INDEX_DxDvpGetVideoPortLine 0x42 +#define DXG_INDEX_DxDvpGetVideoPortOutputFormats 0x43 +#define DXG_INDEX_DxDvpGetVideoPortConnectInfo 0x44 +#define DXG_INDEX_DxDvpGetVideoSignalStatus 0x45 +#define DXG_INDEX_DxDvpUpdateVideoPort 0x46 +#define DXG_INDEX_DxDvpWaitForVideoPortSync 0x47 +#define DXG_INDEX_DxDvpAcquireNotification 0x48 +#define DXG_INDEX_DxDvpReleaseNotification 0x49 + +/***********************************************************************************/ +/* This driver functions are exported raw from Eng* it only exists in the def file */ +/* you can not do syscallback to thuse but you can import them from win32k.sys */ +/* for them are in the export list */ +/***********************************************************************************/ +/* not addedd yet */ +#define DXG_INDEX_DxDdHeapVidMemAllocAligned 0x4A +#define DXG_INDEX_DxDdHeapVidMemFree 0x4B +#define DXG_INDEX_DxDdAllocPrivateUserMem 0x54 +#define DXG_INDEX_DxDdFreePrivateUserMem 0x55 +#define DXG_INDEX_DxDdLockDirectDrawSurface 0x56 +#define DXG_INDEX_DxDdUnlockDirectDrawSurface 0x57 +#define DXG_INDEX_DxDdIoctl 0x5B + + +/***********************************************************************************/ +/* Internal use in diffent part in Windows and ReactOS */ +/***********************************************************************************/ +/* not inuse yet */ +#define DXG_INDEX_DxDdEnableDirectDraw 0x4C +#define DXG_INDEX_DxDdDisableDirectDraw 0x4D +#define DXG_INDEX_DxDdSuspendDirectDraw 0x4E +#define DXG_INDEX_DxDdResumeDirectDraw 0x4F +#define DXG_INDEX_DxDdDynamicModeChange 0x50 +#define DXG_INDEX_DxDdCloseProcess 0x51 +#define DXG_INDEX_DxDdGetDirectDrawBound 0x52 +#define DXG_INDEX_DxDdEnableDirectDrawRedirection 0x53 +#define DXG_INDEX_DxDdSetAccelLevel 0x58 +#define DXG_INDEX_DxDdGetSurfaceLock 0x59 +#define DXG_INDEX_DxDdEnumLockedSurfaceRect 0x5A + + +/***********************************************************************************/ +/* Driver Functions Protypes */ +/***********************************************************************************/ +typedef DWORD (NTAPI *PGD_DXGENERICTRUNK)(ULONG_PTR, ULONG_PTR, SIZE_T*, PVOID, SIZE_T*, PVOID); +//typedef x (NTAPI *PGD_DxD3dContextCreate)( +//typedef x (NTAPI *PGD_DxD3dContextDestroy)( +//typedef x (NTAPI *PGD_DxD3dContextDestroyAll)( +//typedef x (NTAPI *PGD_DxD3dValidateTextureStageState)( +//typedef x (NTAPI *PGD_DxD3dDrawPrimitives2)( +//typedef x (NTAPI *PGD_DxDdGetDriverState)( +//typedef x (NTAPI *PGD_DxDdAddAttachedSurface)( +//typedef x (NTAPI *PGD_DxDdAlphaBlt)( +//typedef x (NTAPI *PGD_DxDdAttachSurface)( +//typedef x (NTAPI *PGD_DxDdBeginMoCompFrame)( +//typedef x (NTAPI *PGD_DxDdBlt)( +//typedef x (NTAPI *PGD_DxDdCanCreateSurface)( +//typedef x (NTAPI *PGD_DxDdCanCreateD3DBuffer)( +//typedef x (NTAPI *PGD_DxDdColorControl)( +//typedef x (NTAPI *PGD_DxDdCreateDirectDrawObject)( +//typedef x (NTAPI *PGD_DxDdCreateSurface)( +//typedef x (NTAPI *PGD_DxDdCreateD3DBuffer)( +//typedef x (NTAPI *PGD_DxDdCreateMoComp)( +//typedef x (NTAPI *PGD_DxDdCreateSurfaceObject)( +//typedef x (NTAPI *PGD_DxDdDeleteDirectDrawObject)( +//typedef x (NTAPI *PGD_DxDdDeleteSurfaceObject)( +//typedef x (NTAPI *PGD_DxDdDestroyMoComp)( +//typedef x (NTAPI *PGD_DxDdDestroySurface)( +//typedef x (NTAPI *PGD_DxDdDestroyD3DBuffer)( +//typedef x (NTAPI *PGD_DxDdEndMoCompFrame)( +//typedef x (NTAPI *PGD_DxDdFlip)( +//typedef x (NTAPI *PGD_DxDdFlipToGDISurface)( +//typedef x (NTAPI *PGD_DxDdGetAvailDriverMemory)( +//typedef x (NTAPI *PGD_DxDdGetBltStatus)( +//typedef x (NTAPI *PGD_DxDdGetDC)( +//typedef x (NTAPI *PGD_DxDdGetDriverInfo)( +//typedef x (NTAPI *PGD_DxDdGetDxHandle)( +//typedef x (NTAPI *PGD_DxDdGetFlipStatus)( +//typedef x (NTAPI *PGD_DxDdGetInternalMoCompInfo)( +//typedef x (NTAPI *PGD_DxDdGetMoCompBuffInfo)( +//typedef x (NTAPI *PGD_DxDdGetMoCompGuids)( +//typedef x (NTAPI *PGD_DxDdGetMoCompFormats)( +//typedef x (NTAPI *PGD_DxDdGetScanLine)( +//typedef x (NTAPI *PGD_DxDdLock)( +//typedef x (NTAPI *PGD_DxDdLockD3D)( +//typedef x (NTAPI *PGD_DxDdQueryDirectDrawObject)( +//typedef x (NTAPI *PGD_DxDdQueryMoCompStatus)( +//typedef x (NTAPI *PGD_DxDdReenableDirectDrawObject)( +//typedef x (NTAPI *PGD_DxDdReleaseDC)( +//typedef x (NTAPI *PGD_DxDdRenderMoComp)( +//typedef x (NTAPI *PGD_DxDdResetVisrgn)( +//typedef x (NTAPI *PGD_DxDdSetColorKey)( +//typedef x (NTAPI *PGD_DxDdSetExclusiveMode)( +//typedef x (NTAPI *PGD_DxDdSetGammaRamp)( +//typedef x (NTAPI *PGD_DxDdCreateSurfaceEx)( +//typedef x (NTAPI *PGD_DxDdSetOverlayPosition)( +//typedef x (NTAPI *PGD_DxDdUnattachSurface)( +//typedef x (NTAPI *PGD_DxDdUnlock)( +//typedef x (NTAPI *PGD_DxDdUnlockD3D)( +//typedef x (NTAPI *PGD_DxDdUpdateOverlay)( +//typedef x (NTAPI *PGD_DxDdWaitForVerticalBlank)( +//typedef x (NTAPI *PGD_DxDvpCanCreateVideoPort)( +//typedef x (NTAPI *PGD_DxDvpColorControl)( +//typedef x (NTAPI *PGD_DxDvpCreateVideoPort)( +//typedef x (NTAPI *PGD_DxDvpDestroyVideoPort)( +//typedef x (NTAPI *PGD_DxDvpFlipVideoPort)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortBandwidth)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortField)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortFlipStatus)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortInputFormats)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortLine)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortOutputFormats)( +//typedef x (NTAPI *PGD_DxDvpGetVideoPortConnectInfo)( +//typedef x (NTAPI *PGD_DxDvpGetVideoSignalStatus)( +//typedef x (NTAPI *PGD_DxDvpUpdateVideoPort)( +//typedef x (NTAPI *PGD_DxDvpWaitForVideoPortSync)( +//typedef x (NTAPI *PGD_DxDvpAcquireNotification)( +//typedef x (NTAPI *PGD_DxDvpReleaseNotification)( +//typedef x (NTAPI *PGD_DxDdHeapVidMemAllocAligned)( +//typedef x (NTAPI *PGD_DxDdHeapVidMemFree)( +//typedef x (NTAPI *PGD_DxDdEnableDirectDraw)( +//typedef x (NTAPI *PGD_DxDdDisableDirectDraw)( +//typedef x (NTAPI *PGD_DxDdSuspendDirectDraw)( +//typedef x (NTAPI *PGD_DxDdResumeDirectDraw)( +//typedef x (NTAPI *PGD_DxDdDynamicModeChange)( +//typedef x (NTAPI *PGD_DxDdCloseProcess)( +//typedef x (NTAPI *PGD_DxDdGetDirectDrawBound)( +//typedef x (NTAPI *PGD_DxDdEnableDirectDrawRedirection)( +//typedef x (NTAPI *PGD_DxDdAllocPrivateUserMem)( +//typedef x (NTAPI *PGD_DxDdFreePrivateUserMem)( +//typedef x (NTAPI *PGD_DxDdLockDirectDrawSurface)( +//typedef x (NTAPI *PGD_DxDdUnlockDirectDrawSurface)( +//typedef x (NTAPI *PGD_DxDdSetAccelLevel)( +//typedef x (NTAPI *PGD_DxDdGetSurfaceLock)( +//typedef x (NTAPI *PGD_DxDdEnumLockedSurfaceRect)( +typedef DWORD (NTAPI *PGD_ENGDXIOCTL)(ULONG, PVOID, ULONG); + + + diff --git a/reactos/include/reactos/win32k/ntgdihdl.h b/reactos/include/reactos/win32k/ntgdihdl.h index c6300134cbb..a5853d913b9 100644 --- a/reactos/include/reactos/win32k/ntgdihdl.h +++ b/reactos/include/reactos/win32k/ntgdihdl.h @@ -11,6 +11,8 @@ #ifndef _NTGDIHDL_ #define _NTGDIHDL_ +#include + /* DEFINES *******************************************************************/ /* Base address where the handle table is mapped to */ @@ -289,6 +291,7 @@ typedef struct _BRUSH_ATTR DWORD dwUnused[3]; } BRUSH_ATTR, *PBRUSH_ATTR; + typedef struct _REGION_ATTR { DWORD dwUnknown1; @@ -305,4 +308,226 @@ typedef struct _FONT_ATTR void *pCharWidthData; } FONT_ATTR, *PFONT_ATTR; + +typedef enum tagGdiPathState +{ + PATH_Null, + PATH_Open, + PATH_Closed +} GdiPathState; + +typedef struct tagGdiPath +{ + GdiPathState state; + POINT *pPoints; + BYTE *pFlags; + int numEntriesUsed, numEntriesAllocated; + BOOL newStroke; +} GdiPath; + +typedef struct _WIN_DC_INFO +{ + int flags; + HRGN hClipRgn; /* Clip region (may be 0) */ + HRGN hVisRgn; /* Visible region (must never be 0) */ + HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */ + HBITMAP hBitmap; + HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */ + +/* #if 0 */ + HANDLE hDevice; + HPALETTE hPalette; + + GdiPath path; +/* #endif */ + + RECT totalExtent; + BYTE bitsPerPixel; + + INT DCOrgX; /* DC origin */ + INT DCOrgY; + INT ArcDirection; + + XFORM xformWorld2Wnd; /* World-to-window transformation */ + XFORM xformWorld2Vport; /* World-to-viewport transformation */ + XFORM xformVport2World; /* Inverse of the above transformation */ + BOOL vport2WorldValid; /* Is xformVport2World valid? */ +} WIN_DC_INFO; + + +typedef BOOL (NTAPI *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA); +typedef DHPDEV (NTAPI *PGD_ENABLEPDEV)(DEVMODEW *, LPWSTR, ULONG, HSURF *, ULONG, ULONG *, ULONG, DEVINFO *, LPWSTR, LPWSTR, HANDLE); +typedef VOID (NTAPI *PGD_COMPLETEPDEV)(DHPDEV, HDEV); +typedef VOID (NTAPI *PGD_DISABLEPDEV)(DHPDEV); +typedef HSURF (NTAPI *PGD_ENABLESURFACE)(DHPDEV); +typedef VOID (NTAPI *PGD_DISABLESURFACE)(DHPDEV); +typedef BOOL (NTAPI *PGD_ASSERTMODE)(DHPDEV, BOOL); +typedef BOOL (NTAPI *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG); +typedef BOOL (NTAPI *PGD_RESETPDEV)(DHPDEV, DHPDEV); +typedef VOID (NTAPI *PGD_DISABLEDRIVER)(VOID); +typedef HBITMAP (NTAPI *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG); +typedef VOID (NTAPI *PGD_DELETEDEVICEBITMAP)(DHSURF); +typedef BOOL (NTAPI *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*); +typedef BOOL (NTAPI *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG); +typedef ULONG (NTAPI *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG); +typedef BOOL (NTAPI *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, PLINEATTRS, MIX); +typedef BOOL (NTAPI *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, ULONG); +typedef BOOL (NTAPI *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, PLINEATTRS, BRUSHOBJ*, POINTL*, MIX, ULONG); +typedef BOOL (NTAPI *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX); +typedef BOOL (NTAPI *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4); +typedef BOOL (NTAPI *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, ULONG, ULONG); +typedef BOOL (NTAPI *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*); +typedef BOOL (NTAPI *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG); +typedef BOOL (NTAPI *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG, BRUSHOBJ*, DWORD); +typedef BOOL (NTAPI *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG); +typedef BOOL (NTAPI *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX); +typedef ULONG (NTAPI *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *); +typedef ULONG (NTAPI *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG, PVOID *); +typedef PIFIMETRICS (NTAPI *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG); +typedef PVOID (NTAPI *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG); +typedef LONG (NTAPI *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*, PVOID, ULONG); +typedef ULONG (NTAPI *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, ULONG); +typedef VOID (NTAPI *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*); +typedef BOOL (NTAPI *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG, RECTL*, MIX); +typedef BOOL (NTAPI *PGD_SENDPAGE)(SURFOBJ*); +typedef BOOL (NTAPI *PGD_STARTPAGE)(SURFOBJ*); +typedef BOOL (NTAPI *PGD_ENDDOC)(SURFOBJ*, ULONG); +typedef BOOL (NTAPI *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD); +typedef ULONG (NTAPI *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*); +typedef VOID (NTAPI *PGD_SYNCHRONIZE)(DHPDEV, RECTL*); +typedef ULONG (NTAPI *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*); +typedef ULONG (NTAPI *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW); +typedef VOID (NTAPI *PGD_FREE)(PVOID, ULONG); +typedef VOID (NTAPI *PGD_DESTROYFONT)(FONTOBJ*); +typedef LONG (NTAPI *PGD_QUERYFONTCAPS)(ULONG, PULONG); +typedef ULONG (NTAPI *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG); +typedef BOOL (NTAPI *PGD_UNLOADFONTFILE)(ULONG); +typedef ULONG (NTAPI *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID, ULONG, PVOID); +typedef LONG (NTAPI *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG, PBYTE); +typedef LONG (NTAPI *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL, GLYPHDATA*, ULONG, TTPOLYGONHEADER*); +typedef PVOID (NTAPI *PGD_GETTRUETYPEFILE)(ULONG, PULONG); +typedef LONG (NTAPI *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG); +typedef BOOL (NTAPI *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *, PVOID *, ULONG); +typedef BOOL (NTAPI *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG); +typedef LONG (NTAPI *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG, PPIXELFORMATDESCRIPTOR); +typedef BOOL (NTAPI *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ); +typedef BOOL (NTAPI *PGD_STARTBANDING)(SURFOBJ*, POINTL*); +typedef BOOL (NTAPI *PGD_NEXTBAND)(SURFOBJ*, POINTL*); +typedef BOOL (NTAPI *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD); +typedef BOOL (NTAPI *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS); +typedef VOID (NTAPI *PGD_DISABLEDIRECTDRAW)(DHPDEV); +typedef LONG (NTAPI *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR); +typedef BOOL (NTAPI *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG); +typedef VOID (NTAPI *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG); + +typedef struct _DRIVER_FUNCTIONS +{ + PGD_ENABLEDRIVER EnableDriver; + PGD_ENABLEPDEV EnablePDEV; + PGD_COMPLETEPDEV CompletePDEV; + PGD_DISABLEPDEV DisablePDEV; + PGD_ENABLESURFACE EnableSurface; + PGD_DISABLESURFACE DisableSurface; + PGD_ASSERTMODE AssertMode; + PGD_OFFSET Offset; + PGD_RESETPDEV ResetPDEV; + PGD_DISABLEDRIVER DisableDriver; + PGD_CREATEDEVICEBITMAP CreateDeviceBitmap; + PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap; + PGD_REALIZEBRUSH RealizeBrush; + PGD_DITHERCOLOR DitherColor; + PGD_STROKEPATH StrokePath; + PGD_FILLPATH FillPath; + PGD_STROKEANDFILLPATH StrokeAndFillPath; + PGD_PAINT Paint; + PGD_BITBLT BitBlt; + PGD_TRANSPARENTBLT TransparentBlt; + PGD_COPYBITS CopyBits; + PGD_STRETCHBLT StretchBlt; + PGD_STRETCHBLTROP StretchBltROP; + PGD_SETPALETTE SetPalette; + PGD_TEXTOUT TextOut; + PGD_ESCAPE Escape; + PGD_DRAWESCAPE DrawEscape; + PGD_QUERYFONT QueryFont; + PGD_QUERYFONTTREE QueryFontTree; + PGD_QUERYFONTDATA QueryFontData; + PGD_SETPOINTERSHAPE SetPointerShape; + PGD_MOVEPOINTER MovePointer; + PGD_LINETO LineTo; + PGD_SENDPAGE SendPage; + PGD_STARTPAGE StartPage; + PGD_ENDDOC EndDoc; + PGD_STARTDOC StartDoc; + PGD_GETGLYPHMODE GetGlyphMode; + PGD_SYNCHRONIZE Synchronize; + PGD_SAVESCREENBITS SaveScreenBits; + PGD_GETMODES GetModes; + PGD_FREE Free; + PGD_DESTROYFONT DestroyFont; + PGD_QUERYFONTCAPS QueryFontCaps; + PGD_LOADFONTFILE LoadFontFile; + PGD_UNLOADFONTFILE UnloadFontFile; + PGD_FONTMANAGEMENT FontManagement; + PGD_QUERYTRUETYPETABLE QueryTrueTypeTable; + PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline; + PGD_GETTRUETYPEFILE GetTrueTypeFile; + PGD_QUERYFONTFILE QueryFontFile; + PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths; + PGD_SETPIXELFORMAT SetPixelFormat; + PGD_DESCRIBEPIXELFORMAT DescribePixelFormat; + PGD_SWAPBUFFERS SwapBuffers; + PGD_STARTBANDING StartBanding; + PGD_NEXTBAND NextBand; + PGD_GETDIRECTDRAWINFO GetDirectDrawInfo; + PGD_ENABLEDIRECTDRAW EnableDirectDraw; + PGD_DISABLEDIRECTDRAW DisableDirectDraw; + PGD_QUERYSPOOLTYPE QuerySpoolType; + PGD_GRADIENTFILL GradientFill; + PGD_SYNCHRONIZESURFACE SynchronizeSurface; + PGD_ALPHABLEND AlphaBlend; +} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS; + +typedef struct _DC +{ + HGDIOBJ hHmgr; // Handle for this DC object. + PVOID pvEntry; + ULONG lucExcLock; + ULONG Tid; + + DHPDEV PDev; + INT DC_Type; + INT DC_Flags; + PDC_ATTR pDc_Attr; + DC_ATTR Dc_Attr; + + struct _EDD_DIRECTDRAW_GLOBAL * pEDDgpl; + + HDC hSelf; // Used only for MemoryDC & SaveDC. + HDC hNext; + HSURF FillPatternSurfaces[HS_DDI_MAX]; + PGDIINFO GDIInfo; + PDEVINFO DevInfo; + HDEV GDIDevice; + + DRIVER_FUNCTIONS DriverFunctions; + UNICODE_STRING DriverName; + HANDLE DeviceDriver; + + CLIPOBJ *CombinedClip; + + XLATEOBJ *XlateBrush; + XLATEOBJ *XlatePen; + + INT saveLevel; + BOOL IsIC; + + HPALETTE PalIndexed; + + WIN_DC_INFO w; + + HANDLE hFile; + LPENHMETAHEADER emh; +} DC, *PDC; + #endif diff --git a/reactos/subsystems/win32/win32k/include/dc.h b/reactos/subsystems/win32/win32k/include/dc.h index 788ef665402..b667bb7dd69 100644 --- a/reactos/subsystems/win32/win32k/include/dc.h +++ b/reactos/subsystems/win32/win32k/include/dc.h @@ -4,50 +4,9 @@ #include "driver.h" -typedef enum tagGdiPathState -{ - PATH_Null, - PATH_Open, - PATH_Closed -} GdiPathState; -typedef struct tagGdiPath -{ - GdiPathState state; - POINT *pPoints; - BYTE *pFlags; - int numEntriesUsed, numEntriesAllocated; - BOOL newStroke; -} GdiPath; -typedef struct _WIN_DC_INFO -{ - int flags; - HRGN hClipRgn; /* Clip region (may be 0) */ - HRGN hVisRgn; /* Visible region (must never be 0) */ - HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */ - HBITMAP hBitmap; - HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */ -/* #if 0 */ - HANDLE hDevice; - HPALETTE hPalette; - - GdiPath path; -/* #endif */ - - RECT totalExtent; - BYTE bitsPerPixel; - - INT DCOrgX; /* DC origin */ - INT DCOrgY; - INT ArcDirection; - - XFORM xformWorld2Wnd; /* World-to-window transformation */ - XFORM xformWorld2Vport; /* World-to-viewport transformation */ - XFORM xformVport2World; /* Inverse of the above transformation */ - BOOL vport2WorldValid; /* Is xformVport2World valid? */ -} WIN_DC_INFO; /* DC flags */ #define DC_MEMORY 0x0001 /* It is a memory DC */ @@ -57,45 +16,7 @@ typedef struct _WIN_DC_INFO #define GDI_DC_TYPE (1) -typedef struct _DC -{ - HGDIOBJ hHmgr; // Handle for this DC object. - PVOID pvEntry; - ULONG lucExcLock; - ULONG Tid; - DHPDEV PDev; - INT DC_Type; - INT DC_Flags; - PDC_ATTR pDc_Attr; - DC_ATTR Dc_Attr; - - HDC hSelf; // Used only for MemoryDC & SaveDC. - HDC hNext; - HSURF FillPatternSurfaces[HS_DDI_MAX]; - PGDIINFO GDIInfo; - PDEVINFO DevInfo; - HDEV GDIDevice; - - DRIVER_FUNCTIONS DriverFunctions; - UNICODE_STRING DriverName; - HANDLE DeviceDriver; - - CLIPOBJ *CombinedClip; - - XLATEOBJ *XlateBrush; - XLATEOBJ *XlatePen; - - INT saveLevel; - BOOL IsIC; - - HPALETTE PalIndexed; - - WIN_DC_INFO w; - - HANDLE hFile; - LPENHMETAHEADER emh; -} DC, *PDC; typedef struct _GDIPOINTER /* should stay private to ENG */ { diff --git a/reactos/subsystems/win32/win32k/include/driver.h b/reactos/subsystems/win32/win32k/include/driver.h index 3b976755095..7121ff2ff10 100644 --- a/reactos/subsystems/win32/win32k/include/driver.h +++ b/reactos/subsystems/win32/win32k/include/driver.h @@ -4,176 +4,11 @@ #include -typedef BOOL (NTAPI *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA); -typedef DHPDEV (NTAPI *PGD_ENABLEPDEV)(DEVMODEW *, - LPWSTR, - ULONG, - HSURF *, - ULONG, - ULONG *, - ULONG, - DEVINFO *, - LPWSTR, - LPWSTR, - HANDLE); -typedef VOID (NTAPI *PGD_COMPLETEPDEV)(DHPDEV, HDEV); -typedef VOID (NTAPI *PGD_DISABLEPDEV)(DHPDEV); -typedef HSURF (NTAPI *PGD_ENABLESURFACE)(DHPDEV); -typedef VOID (NTAPI *PGD_DISABLESURFACE)(DHPDEV); -typedef BOOL (NTAPI *PGD_ASSERTMODE)(DHPDEV, BOOL); -typedef BOOL (NTAPI *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG); -typedef BOOL (NTAPI *PGD_RESETPDEV)(DHPDEV, DHPDEV); -typedef VOID (NTAPI *PGD_DISABLEDRIVER)(VOID); -typedef HBITMAP (NTAPI *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG); -typedef VOID (NTAPI *PGD_DELETEDEVICEBITMAP)(DHSURF); -typedef BOOL (NTAPI *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*); -typedef BOOL (NTAPI *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, - XLATEOBJ*, ULONG); -typedef ULONG (NTAPI *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG); -typedef BOOL (NTAPI *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, - BRUSHOBJ*, POINTL*, PLINEATTRS, MIX); -typedef BOOL (NTAPI *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, - POINTL*, MIX, ULONG); -typedef BOOL (NTAPI *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, - XFORMOBJ*, BRUSHOBJ*, PLINEATTRS, - BRUSHOBJ*, POINTL*, MIX, ULONG); -typedef BOOL (NTAPI *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX); -typedef BOOL (NTAPI *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, - XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, - POINTL*, ROP4); -typedef BOOL (NTAPI *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, - RECTL*, RECTL*, ULONG, ULONG); -typedef BOOL (NTAPI *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, - RECTL*, POINTL*); -typedef BOOL (NTAPI *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, - XLATEOBJ*, COLORADJUSTMENT*, POINTL*, - RECTL*, RECTL*, POINTL*, ULONG); -typedef BOOL (NTAPI *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, - XLATEOBJ*, COLORADJUSTMENT*, POINTL*, - RECTL*, RECTL*, POINTL*, ULONG, - BRUSHOBJ*, DWORD); -typedef BOOL (NTAPI *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG); -typedef BOOL (NTAPI *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, - RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX); -typedef ULONG (NTAPI *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *); -typedef ULONG (NTAPI *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG, - PVOID *); -typedef PIFIMETRICS (NTAPI *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG); -typedef PVOID (NTAPI *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG); -typedef LONG (NTAPI *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*, - PVOID, ULONG); -typedef ULONG (NTAPI *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, - LONG, LONG, LONG, LONG, RECTL*, ULONG); -typedef VOID (NTAPI *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*); -typedef BOOL (NTAPI *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, - LONG, RECTL*, MIX); -typedef BOOL (NTAPI *PGD_SENDPAGE)(SURFOBJ*); -typedef BOOL (NTAPI *PGD_STARTPAGE)(SURFOBJ*); -typedef BOOL (NTAPI *PGD_ENDDOC)(SURFOBJ*, ULONG); -typedef BOOL (NTAPI *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD); -typedef ULONG (NTAPI *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*); -typedef VOID (NTAPI *PGD_SYNCHRONIZE)(DHPDEV, RECTL*); -typedef ULONG (NTAPI *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*); -typedef ULONG (NTAPI *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW); -typedef VOID (NTAPI *PGD_FREE)(PVOID, ULONG); -typedef VOID (NTAPI *PGD_DESTROYFONT)(FONTOBJ*); -typedef LONG (NTAPI *PGD_QUERYFONTCAPS)(ULONG, PULONG); -typedef ULONG (NTAPI *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG); -typedef BOOL (NTAPI *PGD_UNLOADFONTFILE)(ULONG); -typedef ULONG (NTAPI *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID, - ULONG, PVOID); -typedef LONG (NTAPI *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG, - PBYTE); -typedef LONG (NTAPI *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL, - GLYPHDATA*, ULONG, TTPOLYGONHEADER*); -typedef PVOID (NTAPI *PGD_GETTRUETYPEFILE)(ULONG, PULONG); -typedef LONG (NTAPI *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG); -typedef BOOL (NTAPI *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *, - PVOID *, ULONG); -typedef BOOL (NTAPI *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG); -typedef LONG (NTAPI *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG, - PPIXELFORMATDESCRIPTOR); -typedef BOOL (NTAPI *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ); -typedef BOOL (NTAPI *PGD_STARTBANDING)(SURFOBJ*, POINTL*); -typedef BOOL (NTAPI *PGD_NEXTBAND)(SURFOBJ*, POINTL*); -typedef BOOL (NTAPI *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD); -typedef BOOL (NTAPI *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS); -typedef VOID (NTAPI *PGD_DISABLEDIRECTDRAW)(DHPDEV); -typedef LONG (NTAPI *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR); -typedef BOOL (NTAPI *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG); -typedef VOID (NTAPI *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG); -typedef struct _DRIVER_FUNCTIONS -{ - PGD_ENABLEDRIVER EnableDriver; - PGD_ENABLEPDEV EnablePDEV; - PGD_COMPLETEPDEV CompletePDEV; - PGD_DISABLEPDEV DisablePDEV; - PGD_ENABLESURFACE EnableSurface; - PGD_DISABLESURFACE DisableSurface; - PGD_ASSERTMODE AssertMode; - PGD_OFFSET Offset; - PGD_RESETPDEV ResetPDEV; - PGD_DISABLEDRIVER DisableDriver; - PGD_CREATEDEVICEBITMAP CreateDeviceBitmap; - PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap; - PGD_REALIZEBRUSH RealizeBrush; - PGD_DITHERCOLOR DitherColor; - PGD_STROKEPATH StrokePath; - PGD_FILLPATH FillPath; - PGD_STROKEANDFILLPATH StrokeAndFillPath; - PGD_PAINT Paint; - PGD_BITBLT BitBlt; - PGD_TRANSPARENTBLT TransparentBlt; - PGD_COPYBITS CopyBits; - PGD_STRETCHBLT StretchBlt; - PGD_STRETCHBLTROP StretchBltROP; - PGD_SETPALETTE SetPalette; - PGD_TEXTOUT TextOut; - PGD_ESCAPE Escape; - PGD_DRAWESCAPE DrawEscape; - PGD_QUERYFONT QueryFont; - PGD_QUERYFONTTREE QueryFontTree; - PGD_QUERYFONTDATA QueryFontData; - PGD_SETPOINTERSHAPE SetPointerShape; - PGD_MOVEPOINTER MovePointer; - PGD_LINETO LineTo; - PGD_SENDPAGE SendPage; - PGD_STARTPAGE StartPage; - PGD_ENDDOC EndDoc; - PGD_STARTDOC StartDoc; - PGD_GETGLYPHMODE GetGlyphMode; - PGD_SYNCHRONIZE Synchronize; - PGD_SAVESCREENBITS SaveScreenBits; - PGD_GETMODES GetModes; - PGD_FREE Free; - PGD_DESTROYFONT DestroyFont; - PGD_QUERYFONTCAPS QueryFontCaps; - PGD_LOADFONTFILE LoadFontFile; - PGD_UNLOADFONTFILE UnloadFontFile; - PGD_FONTMANAGEMENT FontManagement; - PGD_QUERYTRUETYPETABLE QueryTrueTypeTable; - PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline; - PGD_GETTRUETYPEFILE GetTrueTypeFile; - PGD_QUERYFONTFILE QueryFontFile; - PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths; - PGD_SETPIXELFORMAT SetPixelFormat; - PGD_DESCRIBEPIXELFORMAT DescribePixelFormat; - PGD_SWAPBUFFERS SwapBuffers; - PGD_STARTBANDING StartBanding; - PGD_NEXTBAND NextBand; - PGD_GETDIRECTDRAWINFO GetDirectDrawInfo; - PGD_ENABLEDIRECTDRAW EnableDirectDraw; - PGD_DISABLEDIRECTDRAW DisableDirectDraw; - PGD_QUERYSPOOLTYPE QuerySpoolType; - PGD_GRADIENTFILL GradientFill; - PGD_SYNCHRONIZESURFACE SynchronizeSurface; - PGD_ALPHABLEND AlphaBlend; -} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS; BOOL DRIVER_RegisterDriver(LPCWSTR Name, PGD_ENABLEDRIVER EnableDriver); PGD_ENABLEDRIVER DRIVER_FindExistingDDIDriver(LPCWSTR Name); diff --git a/reactos/subsystems/win32/win32k/include/gdifloat.h b/reactos/subsystems/win32/win32k/include/gdifloat.h index fd05a1616ca..23e3ab6e84c 100644 --- a/reactos/subsystems/win32/win32k/include/gdifloat.h +++ b/reactos/subsystems/win32/win32k/include/gdifloat.h @@ -1,6 +1,9 @@ #ifndef __WIN32K_FLOAT_H #define __WIN32K_FLOAT_H + +#include +#include #include "dc.h" #include "math.h" #include diff --git a/reactos/subsystems/win32/win32k/include/intddraw.h b/reactos/subsystems/win32/win32k/include/intddraw.h index 82ce0d6acf4..b0c563cd9ad 100644 --- a/reactos/subsystems/win32/win32k/include/intddraw.h +++ b/reactos/subsystems/win32/win32k/include/intddraw.h @@ -3,121 +3,123 @@ #include #include +#include +#include +#include -typedef struct -{ - /* for the driver */ - PDD_SURFACE_LOCAL lcllist[2]; +/* From ddraw.c */ +extern PDRVFN gpDxFuncs; - DDRAWI_DDRAWSURFACE_LCL lcl; - - DDRAWI_DDRAWSURFACE_GBL gpl; - DDRAWI_DDRAWSURFACE_MORE more; - - /* DD_CREATESURFACEDATA CreateSurfaceData */ - DD_CREATESURFACEDATA CreateSurfaceData; - - /* for win32k stuff */ - DD_SURFACE_LOCAL Local; - DD_SURFACE_MORE More; - DD_SURFACE_GLOBAL Global; - DDSURFACEDESC desc; - - DD_ATTACHLIST AttachList; - DD_ATTACHLIST AttachListFrom; - BOOL bComplete; - - HANDLE hDirectDrawLocal; - -} DD_SURFACE, *PDD_SURFACE; - -typedef struct -{ - DD_DIRECTDRAW_LOCAL Local; - DD_DIRECTDRAW_GLOBAL Global; - - /* Drv callbacks */ - PGD_GETDIRECTDRAWINFO DrvGetDirectDrawInfo; - PGD_DISABLEDIRECTDRAW DrvDisableDirectDraw; - PGD_ENABLEDIRECTDRAW EnableDirectDraw; - - /* DD callbacks */ - DD_CALLBACKS DD; - - /* Surface callbacks */ - DD_SURFACECALLBACKS Surf; - - /* Palette callbacks */ - DD_PALETTECALLBACKS Pal; - - /* HAL */ - DD_HALINFO Hal; - - /* Color Control Callback */ - DD_COLORCONTROLCALLBACKS Color; - - /* D3DHAL_CALLBACKS */ - //D3DHAL_CALLBACKS D3dHal; - // D3DHAL_CALLBACKS3 D3dHal3; - // D3DHAL_D3DEXTENDEDCAPS D3dHal3Ext; - - /* Heap Callback */ - PDD_GETHEAPALIGNMENTDATA HeapData; - - /* Kernel Callback */ - DD_KERNELCALLBACKS Kernel; - DDKERNELCAPS KernelCaps; - - /* Miscellaneous Callback */ - DD_MISCELLANEOUSCALLBACKS Misc; - - /* NT-based Callback */ - PDD_FLIPTOGDISURFACE DdFlipToGDISurface; - PDD_FREEDRIVERMEMORY DdFreeDriverMemory; - PDD_SETEXCLUSIVEMODE DdSetExclusiveMode; - - /*.Motion Compensation .*/ - PDD_MOCOMPCB_BEGINFRAME DdMoCompBeginFrame; - PDD_MOCOMPCB_CREATE DdMoCompCreate; - PDD_MOCOMPCB_DESTROY DdMoCompDestroy; - PDD_MOCOMPCB_ENDFRAME DdMoCompEndFrame; - PDD_MOCOMPCB_GETCOMPBUFFINFO DdMoCompGetBuffInfo; - PDD_MOCOMPCB_GETFORMATS DdMoCompGetFormats; - PDD_MOCOMPCB_GETGUIDS DdMoCompGetGuids; - PDD_MOCOMPCB_GETINTERNALINFO DdMoCompGetInternalInfo; - PDD_MOCOMPCB_QUERYSTATUS DdMoCompQueryStatus; - PDD_MOCOMPCB_RENDER DdMoCompRender; - - /* Video Port Callback */ - PDD_VPORTCB_CANCREATEVIDEOPORT DdVideoPortCanCreate; - PDD_VPORTCB_COLORCONTROL DdVideoPortColorControl; - PDD_VPORTCB_CREATEVIDEOPORT DdVideoPortCreate; - PDD_VPORTCB_DESTROYVPORT DdVideoPortDestroy; - PDD_VPORTCB_FLIP DdVideoPortFlip; - PDD_VPORTCB_GETBANDWIDTH DdVideoPortGetBandwidth; - PDD_VPORTCB_GETVPORTCONNECT DdVideoPortGetConnectInfo; - PDD_VPORTCB_GETFIELD DdVideoPortGetField; - PDD_VPORTCB_GETFLIPSTATUS DdVideoPortGetFlipStatus; - PDD_VPORTCB_GETINPUTFORMATS DdVideoPortGetInputFormats; - PDD_VPORTCB_GETLINE DdVideoPortGetLine; - PDD_VPORTCB_GETOUTPUTFORMATS DdVideoPortGetOutputFormats; - PDD_VPORTCB_GETSIGNALSTATUS DdVideoPortGetSignalStatus; - PDD_VPORTCB_UPDATE DdVideoPortUpdate; - PDD_VPORTCB_WAITFORSYNC DdVideoPortWaitForSync; - /* Notify Callback */ - //LPDD_NOTIFYCALLBACK NotifyCallback - - /* memory stuff */ - DWORD dwNumHeaps; - PVIDEOMEMORY pvmList; - - DWORD dwNumFourCC; - LPDWORD pdwFourCC; +typedef BOOL (NTAPI* PGD_DDSETGAMMARAMP)(HANDLE, HDC, LPVOID); +typedef BOOL (NTAPI* PGD_DDRELEASEDC)(HANDLE); +typedef BOOL (NTAPI* PGD_DDRESTVISRGN)(HANDLE, HWND); +typedef HANDLE (NTAPI* PGD_DDGETDXHANDLE)(HANDLE, HANDLE, BOOL); +typedef HDC (NTAPI *PGD_DDGETDC)(HANDLE, PALETTEENTRY *); +typedef DWORD (NTAPI *PGD_DXDDREENABLEDIRECTDRAWOBJECT)(HANDLE, BOOL*); +typedef DWORD (NTAPI *PGD_DXDDGETDRIVERINFO)(HANDLE, PDD_GETDRIVERINFODATA); +typedef DWORD (NTAPI *PGD_DXDDSETEXCLUSIVEMODE)(HANDLE, PDD_SETEXCLUSIVEMODEDATA); +typedef NTSTATUS (NTAPI *PGD_DXDDSTARTUPDXGRAPHICS) (ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS); +typedef NTSTATUS (NTAPI *PGD_DXDDCLEANUPDXGRAPHICS) (VOID); +typedef HANDLE (NTAPI *PGD_DDCREATEDIRECTDRAWOBJECT) (HDC hdc); +typedef DWORD (NTAPI *PGD_DDGETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA); +typedef DWORD (NTAPI *PGD_DDCOLORCONTROL)(HANDLE hSurface,PDD_COLORCONTROLDATA puColorControlData); +typedef HANDLE (NTAPI *PGD_DXDDCREATESURFACEOBJECT)(HANDLE, HANDLE, PDD_SURFACE_LOCAL, PDD_SURFACE_MORE, PDD_SURFACE_GLOBAL, BOOL); +typedef BOOL (NTAPI *PGD_DXDDDELETEDIRECTDRAWOBJECT)(HANDLE); +typedef BOOL (NTAPI *PGD_DXDDDELETESURFACEOBJECT)(HANDLE); +typedef DWORD (NTAPI *PGD_DXDDFLIPTOGDISURFACE)(HANDLE, PDD_FLIPTOGDISURFACEDATA); +typedef DWORD (NTAPI *PGD_DXDDGETAVAILDRIVERMEMORY)(HANDLE , PDD_GETAVAILDRIVERMEMORYDATA); +typedef BOOL (NTAPI *PGD_DXDDQUERYDIRECTDRAWOBJECT)(HANDLE, DD_HALINFO*, DWORD*, LPD3DNTHAL_CALLBACKS, LPD3DNTHAL_GLOBALDRIVERDATA, + PDD_D3DBUFCALLBACKS, LPDDSURFACEDESC, DWORD *, VIDEOMEMORY *, DWORD *, DWORD *); -} DD_DIRECTDRAW, *PDD_DIRECTDRAW; +/* From d3d.c */ +typedef DWORD (NTAPI *PGD_DXDDDESTROYD3DBUFFER)(HANDLE); +typedef DWORD (NTAPI *PGD_DDCANCREATED3DBUFFER)(HANDLE, PDD_CANCREATESURFACEDATA); +typedef DWORD (NTAPI *PGD_DXDDUNLOCKD3D)(HANDLE, PDD_UNLOCKDATA); +typedef DWORD (NTAPI *PGD_DXDDLOCKD3D)(HANDLE, PDD_LOCKDATA); +typedef DWORD (NTAPI *PGD_D3DVALIDATETEXTURESTAGESTATE)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA); +typedef DWORD (NTAPI *PGD_D3DDRAWPRIMITIVES2)(HANDLE, HANDLE, LPD3DNTHAL_DRAWPRIMITIVES2DATA, FLATPTR *, DWORD *, FLATPTR *, DWORD *); +typedef DWORD (NTAPI *PGD_DDCREATED3DBUFFER)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *); +typedef BOOL (NTAPI *PGD_D3DCONTEXTCREATE)(HANDLE, HANDLE, HANDLE, LPD3DNTHAL_CONTEXTCREATEDATA); +typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROY)(LPD3DNTHAL_CONTEXTDESTROYDATA); +typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROYALL)(LPD3DNTHAL_CONTEXTDESTROYALLDATA); + +/* From dvp.c */ +typedef DWORD (NTAPI* PGD_DVPCANCREATEVIDEOPORT)(HANDLE, PDD_CANCREATEVPORTDATA); +typedef DWORD (NTAPI* PGD_DVPCOLORCONTROL)(HANDLE, PDD_VPORTCOLORDATA); +typedef HANDLE (NTAPI* PGD_DVPCREATEVIDEOPORT)(HANDLE, PDD_CREATEVPORTDATA); +typedef DWORD (NTAPI* PGD_DVPDESTROYVIDEOPORT)(HANDLE, PDD_DESTROYVPORTDATA); +typedef DWORD (NTAPI* PGD_DVPFLIPVIDEOPORT)(HANDLE,HANDLE,HANDLE,PDD_FLIPVPORTDATA); +typedef DWORD (NTAPI* PGD_DVPGETVIDEOPORTBANDWITH)(HANDLE, PDD_GETVPORTBANDWIDTHDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFLIPSTATUS)(HANDLE, PDD_GETVPORTFLIPSTATUSDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTINPUTFORMATS)(HANDLE, PDD_GETVPORTINPUTFORMATDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTLINE)(HANDLE, PDD_GETVPORTLINEDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)(HANDLE, PDD_GETVPORTOUTPUTFORMATDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTCONNECTINFO)(HANDLE, PDD_GETVPORTCONNECTDATA); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOSIGNALSTATUS)(HANDLE, PDD_GETVPORTSIGNALDATA); +typedef DWORD (NTAPI *PGD_DXDVPUPDATEVIDEOPORT)(HANDLE, HANDLE*, HANDLE*, PDD_UPDATEVPORTDATA); +typedef DWORD (NTAPI *PGD_DXDVPWAITFORVIDEOPORTSYNC)(HANDLE, PDD_WAITFORVPORTSYNCDATA); +typedef DWORD (NTAPI *PGD_DXDVPACQUIRENOTIFICATION)(HANDLE, HANDLE*, LPDDVIDEOPORTNOTIFY); +typedef DWORD (NTAPI *PGD_DXDVPRELEASENOTIFICATION)(HANDLE, HANDLE); +typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFIELD)(HANDLE, PDD_GETVPORTFIELDDATA); + +/* From mocomp.c */ +typedef DWORD (NTAPI *PGD_DDBEGINMOCOMPFRAME)(HANDLE, PDD_BEGINMOCOMPFRAMEDATA); +typedef HANDLE (NTAPI *PGD_DXDDCREATEMOCOMP)(HANDLE, PDD_CREATEMOCOMPDATA ); +typedef DWORD (NTAPI *PGD_DXDDDESTROYMOCOMP)(HANDLE, PDD_DESTROYMOCOMPDATA); +typedef DWORD (NTAPI *PGD_DXDDENDMOCOMPFRAME)(HANDLE, PDD_ENDMOCOMPFRAMEDATA); +typedef DWORD (NTAPI *PGD_DXDDGETINTERNALMOCOMPINFO)(HANDLE, PDD_GETINTERNALMOCOMPDATA); +typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPBUFFINFO)(HANDLE, PDD_GETMOCOMPCOMPBUFFDATA); +typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPGUIDS)(HANDLE, PDD_GETMOCOMPGUIDSDATA); +typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPFORMATS)(HANDLE, PDD_GETMOCOMPFORMATSDATA); +typedef DWORD (NTAPI *PGD_DXDDQUERYMOCOMPSTATUS)(HANDLE, PDD_QUERYMOCOMPSTATUSDATA); +typedef DWORD (NTAPI *PGD_DXDDRENDERMOCOMP)(HANDLE, PDD_RENDERMOCOMPDATA); + +/* From dd.c */ +typedef DWORD (NTAPI *PGD_DDCREATESURFACE)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *); +typedef DWORD (NTAPI *PGD_DXDDWAITFORVERTICALBLANK)(HANDLE, PDD_WAITFORVERTICALBLANKDATA); +typedef DWORD (NTAPI *PGD_DDCANCREATESURFACE)(HANDLE hDirectDrawLocal, PDD_CANCREATESURFACEDATA puCanCreateSurfaceData); +typedef DWORD (NTAPI *PGD_DXDDGETSCANLINE)(HANDLE, PDD_GETSCANLINEDATA); +typedef DWORD (NTAPI *PGD_DXDDCREATESURFACEEX)(HANDLE,HANDLE,DWORD); + +/* From ddsurf.c */ +typedef DWORD (NTAPI *PGD_DDALPHABLT)(HANDLE, HANDLE, PDD_BLTDATA); +typedef BOOL (NTAPI *PGD_DDATTACHSURFACE)(HANDLE, HANDLE); +typedef DWORD (NTAPI *PGD_DXDDUNATTACHSURFACE)(HANDLE, HANDLE); +typedef DWORD (NTAPI *PGD_DXDDDESTROYSURFACE)(HANDLE, BOOL); +typedef DWORD (NTAPI *PGD_DXDDFLIP)(HANDLE, HANDLE, HANDLE, HANDLE, PDD_FLIPDATA); +typedef DWORD (NTAPI *PGD_DXDDLOCK)(HANDLE, PDD_LOCKDATA, HDC); +typedef DWORD (NTAPI *PGD_DXDDUNLOCK)(HANDLE, PDD_UNLOCKDATA ); +typedef DWORD (NTAPI *PGD_DDBLT)(HANDLE, HANDLE, PDD_BLTDATA); +typedef DWORD (NTAPI *PGD_DXDDSETCOLORKEY)(HANDLE, PDD_SETCOLORKEYDATA); +typedef DWORD (NTAPI *PGD_DDADDATTACHEDSURFACE)(HANDLE, HANDLE,PDD_ADDATTACHEDSURFACEDATA); +typedef DWORD (NTAPI *PGD_DXDDGETBLTSTATUS)(HANDLE, PDD_GETBLTSTATUSDATA); +typedef DWORD (NTAPI *PGD_DXDDGETFLIPSTATUS)(HANDLE, PDD_GETFLIPSTATUSDATA); +typedef DWORD (NTAPI *PGD_DXDDUPDATEOVERLAY)(HANDLE, HANDLE, PDD_UPDATEOVERLAYDATA); +typedef DWORD (NTAPI *PGD_DXDDSETOVERLAYPOSITION)(HANDLE, HANDLE, PDD_SETOVERLAYPOSITIONDATA); + +/* From eng.c */ +typedef FLATPTR (NTAPI *PGD_HEAPVIDMEMALLOCALIGNED)(LPVIDMEM, DWORD, DWORD, LPSURFACEALIGNMENT, LPLONG); +typedef VOID (NTAPI *PGD_VIDMEMFREE)(LPVMEMHEAP, FLATPTR); +typedef PVOID (NTAPI *PGD_ENGALLOCPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, SIZE_T, ULONG) ; +typedef VOID (NTAPI *PGD_ENGFREEPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, PVOID); +typedef PDD_SURFACE_LOCAL (NTAPI *PGD_ENGLOCKDIRECTDRAWSURFACE)(HANDLE); +typedef BOOL (NTAPI *PGD_ENGUNLOCKDIRECTDRAWSURFACE)(PDD_SURFACE_LOCAL); + + +/* Standard macro */ +#define DXG_GET_INDEX_FUNCTION(INDEX, FUNCTION) \ + if (gpDxFuncs) \ + { \ + for (i = 0; i <= DXG_INDEX_DxDdIoctl; i++) \ + { \ + if (gpDxFuncs[i].iFunc == INDEX) \ + { \ + FUNCTION = (VOID *)gpDxFuncs[i].pfn; \ + break; \ + } \ + } \ + } -BOOL INTERNAL_CALL DD_Cleanup(PVOID pDD); -BOOL INTERNAL_CALL DDSURF_Cleanup(PVOID pDDSurf); #endif /* _INT_W32k_DDRAW */ diff --git a/reactos/subsystems/win32/win32k/ntddraw/d3d.c b/reactos/subsystems/win32/win32k/ntddraw/d3d.c new file mode 100644 index 00000000000..67ea6e76985 --- /dev/null +++ b/reactos/subsystems/win32/win32k/ntddraw/d3d.c @@ -0,0 +1,398 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native DirectDraw implementation + * FILE: subsys/win32k/ntddraw/d3d.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 19/1-2006 Magnus Olsen + */ + +/* Comment + * NtGdiDdLock and NtGdiDdLockD3D at end calls to same api in the dxg.sys + * NtGdiDdUnlock and NtGdiDdUnlockD3D at end calls to same api in the dxg.sys + */ + +#include +#include + + +/*++ +* @name NtGdiDdCanCreateD3DBuffer +* @implemented +* +* The function NtGdiDdCanCreateD3DBuffer checks if you can create a +* surface for DirectX. It is redirected to dxg.sys. +* +* @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 API 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 call are redirect to dxg.sys +* inside the dxg.sys they ar redirect to same functions. examine the driver list functions +* table, the memory address you will see they are pointed to same memory address. +* +* Before call to this api please set the puCanCreateSurfaceData->ddRVal to a error value example DDERR_NOTUSPORTED. +* for the ddRVal will other wise be unchange if some error happen inside the driver. +* puCanCreateSurfaceData->lpDD is pointer to DDRAWI_DIRECTDRAW_GBL, MSDN say it is PDD_DIRECTDRAW_GLOBAL it is not. +* puCanCreateSurfaceData->lpDD->hDD need also be fill in with the handle we got from NtGdiDdCreateDirectDrawObject +* puCreateSurfaceData->CanCreateSurface pointer to the real functions the HAL or HEL, that u need fill in +* +*--*/ + +DWORD +STDCALL +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 NtGdiDdCanCreateD3DBuffer check if you can create a +* surface for directx it redirect the call to dxg.sys. +* +* @param HANDLE hDirectDrawLocal +* The handle we got from NtGdiDdCreateDirectDrawObject +* +* @param HANDLE hSurfColor +* Handle to DD_SURFACE_LOCAL to be use as target rendring +* +* @param HANDLE hSurfZ +* Handle to a DD_SURFACE_LOCAL it is the Z deep buffer, accdoing MSDN if it set to NULL nothing should happen. +* +* @param D3DNTHAL_CONTEXTCREATEDATA* hSurfZ +* the buffer to create the context data +* +* @return +* DDHAL_DRIVER_HANDLED or DDHAL_DRIVER_NOTHANDLED if the driver support this api. +* Todo full check if we sussess is to check the return value DDHAL_DRIVER_HANDLED +* puCanCreateSurfaceData->ddRVal are set to DD_OK. +* +* +* @remarks. +* dxg.sys NtGdiD3dContextCreate call are redirect to +* same functions in the dxg.sys. So they are working exacly same. everthing else is lying if they +* are diffent. +* +* Before call to this api please set the hSurfZ->ddRVal to a error value example DDERR_NOTUSPORTED. +* for the ddRVal will other wise be unchange if some error happen inside the driver. +* hSurfZ->dwhContext need also be fill in with the handle we got from NtGdiDdCreateDirectDrawObject +* +*--*/ +BOOL +STDCALL +NtGdiD3dContextCreate(HANDLE hDirectDrawLocal, + HANDLE hSurfColor, + HANDLE hSurfZ, + D3DNTHAL_CONTEXTCREATEDATA* pdcci) +{ + PGD_D3DCONTEXTCREATE pfnD3dContextCreate = (PGD_D3DCONTEXTCREATE)gpDxFuncs[DXG_INDEX_DxD3dContextCreate].pfn; + + if (pfnD3dContextCreate == NULL) + { + DPRINT1("Warring no pfnD3dContextCreate"); + return FALSE; + } + + DPRINT1("Calling on dxg.sys D3dContextCreate"); + return pfnD3dContextCreate(hDirectDrawLocal, hSurfColor, hSurfZ, pdcci); +} + +/*++ +* @name NtGdiD3dContextDestroy +* @implemented +* +* The Function NtGdiD3dContextDestroy Destory the context data we got from NtGdiD3dContextCreate +* +* @param LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData +* The context data we want to destory +* +* @remarks. +* dxg.sys NtGdiD3dContextDestroy call are redirect to +* same functions in the dxg.sys. So they are working exacly same. everthing else is lying if they +* are diffent. +* +* Before call to this api please set the pContextDestroyData->ddRVal to a error value example DDERR_NOTUSPORTED. +* for the ddRVal will other wise be unchange if some error happen inside the driver. +* pContextDestroyData->dwhContext need also be fill in with the handle we got from NtGdiDdCreateDirectDrawObject +* +*--*/ +DWORD +STDCALL +NtGdiD3dContextDestroy(LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData) +{ + PGD_D3DCONTEXTDESTROY pfnD3dContextDestroy = (PGD_D3DCONTEXTDESTROY)gpDxFuncs[DXG_INDEX_DxD3dContextDestroy].pfn; + + if ( pfnD3dContextDestroy == NULL) + { + DPRINT1("Warring no pfnD3dContextDestroy"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys D3dContextDestroy"); + return pfnD3dContextDestroy(pContextDestroyData); +} + +/*++ +* @name NtGdiD3dContextDestroyAll +* @implemented +* +* The Function NtGdiD3dContextDestroyAll Destory the all context data we got in a process +* The data have been alloc with NtGdiD3dContextCreate +* +* @param LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad +* The context data we want to destory +* +* @remarks. +* dxg.sys NtGdiD3dContextDestroyAll call are redirect to +* same functions in the dxg.sys. So they are working exacly same. everthing else is lying if they +* are diffent. +* +* Before call to this api please set the pdcad->ddRVal to a error value example DDERR_NOTUSPORTED. +* for the ddRVal will other wise be unchange if some error happen inside the driver. +* pdcad->dwPID need also be fill in with the Process ID we need destore the data for +* +* Waring MSDN is wrong about this api. it say it queare free memory and it does not accpect +* any parama, last time checked in msdn 19/10-2007 +*--*/ +DWORD +STDCALL +NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad) +{ + PGD_D3DCONTEXTDESTROYALL pfnD3dContextDestroyAll = (PGD_D3DCONTEXTDESTROYALL)gpDxFuncs[DXG_INDEX_DxD3dContextDestroyAll].pfn; + + if (pfnD3dContextDestroyAll == NULL) + { + DPRINT1("Warring no pfnD3dContextDestroyAll"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys D3dContextDestroyAll"); + return pfnD3dContextDestroyAll(pdcad); +} + +/*++ +* @name NtGdiDdCreateD3DBuffer +* @implemented +* +* The function NtGdiDdCreateD3DBuffer create a +* surface for DirectX. It is redirected to dxg.sys. +* +* @param HANDLE hDirectDraw +* The handle we got from NtGdiDdCreateDirectDrawObject +* +* @param HANDLE *hSurface +* +* +* @param DDSURFACEDESC puSurfaceDescription +* surface desc what kind of surface it should be, example rgb, compress, deep, and more, +* see DDSURFACEDESC for more infomations +* +* @param DD_SURFACE_GLOBAL *puSurfaceGlobalData +* +* +* @param DD_SURFACE_LOCAL *puSurfaceLocalData +* +* +* @param DD_SURFACE_MORE *puSurfaceMoreData +* +* +* @param PDD_CREATESURFACEDATA puCreateSurfaceData +* +* +* @param HANDLE *puhSurface +* +* +* @return +* Depending on if the driver supports this API 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 NtGdiDdCreateD3DBuffer and NtGdiDdCreateSurface call are redirect to dxg.sys +* inside the dxg.sys they ar redirect to same functions. examine the driver list functions +* table, the memory address you will see they are pointed to same memory address. +* +* Before call to this api please set the puCreateSurfaceData->ddRVal to a error value example DDERR_NOTUSPORTED. +* for the ddRVal will other wise be unchange if some error happen inside the driver. +* puCreateSurfaceData->lpDD is pointer to DDRAWI_DIRECTDRAW_GBL, MSDN say it is PDD_DIRECTDRAW_GLOBAL it is not. +* puCreateSurfaceData->lpDD->hDD need also be fill in with the handle we got from NtGdiDdCreateDirectDrawObject +* puCreateSurfaceData->CreateSurface pointer to the real functions the HAL or HEL, that u need fill in +* +*--*/ +DWORD +STDCALL +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("Warring no pfnDdCreateD3DBuffer"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdCreateD3DBuffer"); + return pfnDdCreateD3DBuffer(hDirectDraw, hSurface, + puSurfaceDescription, puSurfaceGlobalData, + puSurfaceLocalData, puSurfaceMoreData, + puCreateSurfaceData, puhSurface); +} + +/************************************************************************/ +/* NtGdiDdDestroyD3DBuffer */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdDestroyD3DBuffer(HANDLE hSurface) +{ + PGD_DXDDDESTROYD3DBUFFER pfnDdDestroyD3DBuffer = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDestroyD3DBuffer, pfnDdDestroyD3DBuffer); + + if (pfnDdDestroyD3DBuffer == NULL) + { + DPRINT1("Warring no pfnDdDestroyD3DBuffer"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdDestroyD3DBuffer"); + return pfnDdDestroyD3DBuffer(hSurface); +} + +/************************************************************************/ +/* NtGdiD3dDrawPrimitives2 */ +/************************************************************************/ +DWORD +STDCALL +NtGdiD3dDrawPrimitives2(HANDLE hCmdBuf, + HANDLE hVBuf, + LPD3DNTHAL_DRAWPRIMITIVES2DATA pded, + FLATPTR *pfpVidMemCmd, + DWORD *pdwSizeCmd, + FLATPTR *pfpVidMemVtx, + DWORD *pdwSizeVtx) +{ + PGD_D3DDRAWPRIMITIVES2 pfnD3dDrawPrimitives2 = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxD3dDrawPrimitives2, pfnD3dDrawPrimitives2); + + if (pfnD3dDrawPrimitives2 == NULL) + { + DPRINT1("Warring no pfnD3dDrawPrimitives2"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys D3dDrawPrimitives2"); + return pfnD3dDrawPrimitives2(hCmdBuf,hVBuf,pded,pfpVidMemCmd,pdwSizeCmd,pfpVidMemVtx,pdwSizeVtx); +} + + +/************************************************************************/ +/* NtGdiD3dValidateTextureStageState */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdLockD3D(HANDLE hSurface, + PDD_LOCKDATA puLockData) +{ + PGD_DXDDLOCKD3D pfnDdLockD3D = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdLockD3D, pfnDdLockD3D); + + if (pfnDdLockD3D == NULL) + { + DPRINT1("Warring no pfnDdLockD3D"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdLockD3D"); + return pfnDdLockD3D(hSurface, puLockData); +} + +/************************************************************************/ +/* NtGdiD3dValidateTextureStageState */ +/************************************************************************/ +DWORD +STDCALL +NtGdiD3dValidateTextureStageState(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData) +{ + PGD_D3DVALIDATETEXTURESTAGESTATE pfnD3dValidateTextureStageState = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxD3dValidateTextureStageState, pfnD3dValidateTextureStageState); + + if (pfnD3dValidateTextureStageState == NULL) + { + DPRINT1("Warring no pfnD3dValidateTextureStageState"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys D3dValidateTextureStageState"); + return pfnD3dValidateTextureStageState(pData); +} + +/************************************************************************/ +/* NtGdiDdUnlockD3D */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdUnlockD3D(HANDLE hSurface, + PDD_UNLOCKDATA puUnlockData) +{ + PGD_DXDDUNLOCKD3D pfnDdUnlockD3D = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnlockD3D, pfnDdUnlockD3D); + + if (pfnDdUnlockD3D == NULL) + { + DPRINT1("Warring no pfnDdUnlockD3D"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdUnlockD3D"); + return pfnDdUnlockD3D(hSurface, puUnlockData); + +} + + + + diff --git a/reactos/subsystems/win32/win32k/ntddraw/dd.c b/reactos/subsystems/win32/win32k/ntddraw/dd.c index b8b8112c044..b07ec8abcce 100644 --- a/reactos/subsystems/win32/win32k/ntddraw/dd.c +++ b/reactos/subsystems/win32/win32k/ntddraw/dd.c @@ -5,576 +5,139 @@ * FILE: subsys/win32k/ntddraw/dd.c * PROGRAMER: Magnus Olsen (greatlord@reactos.org) * REVISION HISTORY: - * 19/7-2006 Magnus Olsen + * 19/1-2006 Magnus Olsen */ #include - -#define NDEBUG #include -#define DdHandleTable GdiHandleTable - -/* - DdMapMemory, DdDestroyDriver are not exported as NtGdi calls - This file is complete for DD_CALLBACKS setup - - TODO: Fix the NtGdiDdCreateSurface (something is missing in - either GdiEntry or GdiEntry's callback for DdCreateSurface) -*/ - /************************************************************************/ /* NtGdiDdCreateSurface */ -/* Status : Bugs out */ /************************************************************************/ - -DWORD STDCALL NtGdiDdCreateSurface( - HANDLE hDirectDrawLocal, - HANDLE *hSurface, - DDSURFACEDESC *puSurfaceDescription, - DD_SURFACE_GLOBAL *puSurfaceGlobalData, - DD_SURFACE_LOCAL *puSurfaceLocalData, - DD_SURFACE_MORE *puSurfaceMoreData, - PDD_CREATESURFACEDATA puCreateSurfaceData, - HANDLE *puhSurface -) +DWORD +STDCALL +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 = NULL; INT i; - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - NTSTATUS Status = FALSE; - PDD_DIRECTDRAW pDirectDraw; - PDD_SURFACE phsurface; - PDD_SURFACE_LOCAL pLocal; - PDD_SURFACE_MORE pMore; - PDD_SURFACE_GLOBAL pGlobal; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurface, pfnDdCreateSurface); - DD_CREATESURFACEDATA CreateSurfaceData; - - /* FIXME: Alloc as much as needed */ - PHANDLE *myhSurface; - - /* GCC4 gives warnings about uninitialized - values, but they are initialized in SEH */ - - DPRINT1("NtGdiDdCreateSurface\n"); - - DPRINT1("Copy puCreateSurfaceData to kmode CreateSurfaceData\n"); - _SEH_TRY + if (pfnDdCreateSurface == NULL) { - ProbeForRead(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1); - RtlCopyMemory( &CreateSurfaceData, puCreateSurfaceData, - sizeof( DD_CREATESURFACEDATA ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - return ddRVal; + DPRINT1("Warring no pfnDdCreateSurface"); + return DDHAL_DRIVER_NOTHANDLED; } - /* FIXME: There is only support for one surface at the moment. - This is a hack to prevent more than one surface creation */ - if (CreateSurfaceData.dwSCnt > 1) - { - DPRINT1("HACK: Limiting quantity of created surfaces from %d to 1!\n", - CreateSurfaceData.dwSCnt); - CreateSurfaceData.dwSCnt = 1; - } - - - DPRINT1("Setup surface in put handler\n"); - myhSurface = ExAllocatePool(PagedPool, CreateSurfaceData.dwSCnt * sizeof(HANDLE)); - - _SEH_TRY - { - ProbeForRead(hSurface, CreateSurfaceData.dwSCnt * sizeof(HANDLE), 1); - for (i=0;iGlobal\n"); - _SEH_TRY - { - ProbeForRead(puSurfaceGlobalData, sizeof(DD_SURFACE_GLOBAL), 1); - RtlCopyMemory( &phsurface->Global, puSurfaceGlobalData, - sizeof( DD_SURFACE_GLOBAL ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - SetLastNtError(Status); - return ddRVal; - } - - DPRINT1("Copy puSurfaceMoreData to kmode phsurface->More\n"); - _SEH_TRY - { - ProbeForRead(puSurfaceMoreData, sizeof(DD_SURFACE_MORE), 1); - RtlCopyMemory( &phsurface->More, puSurfaceMoreData, - sizeof( DD_SURFACE_MORE ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - SetLastNtError(Status); - return ddRVal; - } - - DPRINT1("Copy puSurfaceLocalData to kmode phsurface->Local\n"); - _SEH_TRY - { - ProbeForRead(puSurfaceLocalData, sizeof(DD_SURFACE_LOCAL), 1); - RtlCopyMemory( &phsurface->Local, puSurfaceLocalData, - sizeof( DD_SURFACE_LOCAL ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - SetLastNtError(Status); - return ddRVal; - } - - DPRINT1("Copy puSurfaceDescription to kmode phsurface->desc\n"); - _SEH_TRY - { - ProbeForRead(puSurfaceDescription, sizeof(DDSURFACEDESC), 1); - RtlCopyMemory( &phsurface->desc, puSurfaceDescription, - sizeof( DDSURFACEDESC ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - SetLastNtError(Status); - return ddRVal; - } - - DPRINT1("Lock hDirectDrawLocal \n"); - phsurface->hDirectDrawLocal = hDirectDrawLocal; - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - if (!pDirectDraw) - { - DPRINT1("fail \n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - return ddRVal; - } - - - /* FIXME: unlock phsurface, free phsurface at failure */ - /* FIXME: unlock hsurface, free phsurface at failure */ - /* FIXME: add support for more than one surface create, once more */ - /* FIXME: alloc memory if it's more than one surface (5th mention - that this long function doesn't support more than one - surface creation. I guess it was easier to support it - than to write such comments 10 times). */ - - pLocal = &phsurface->Local; - pMore = &phsurface->More; - pGlobal = &phsurface->Global; - - for (i = 0; i < CreateSurfaceData.dwSCnt; i++) - { - phsurface->lcllist[i] = (PDD_SURFACE_LOCAL)pLocal; - pLocal->lpGbl = pGlobal; - pLocal->lpSurfMore = pMore; - - /* FIXME ? - pLocal->lpAttachList; - pLocal->lpAttachListFrom; - */ - - /* FIXME: a countup to next pLocal, pMore, pGlobal */ - - } - - /* Setup DD_CREATESURFACEDATA CreateSurfaceData for the driver */ - CreateSurfaceData.lplpSList = (PDD_SURFACE_LOCAL *) &phsurface->lcllist; - CreateSurfaceData.lpDDSurfaceDesc = &phsurface->desc; - CreateSurfaceData.CreateSurface = NULL; - CreateSurfaceData.ddRVal = DDERR_GENERIC; - CreateSurfaceData.lpDD = &pDirectDraw->Global; - - /* CreateSurface must crash with lcl converting */ - if ((pDirectDraw->DD.dwFlags & DDHAL_CB32_CREATESURFACE)) - { - DPRINT1("0x%04x",pDirectDraw->DD.CreateSurface); - - ddRVal = pDirectDraw->DD.CreateSurface(&CreateSurfaceData); - } - - DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,CreateSurfaceData.ddRVal); - - /* FIXME: support for more that one surface (once more!!!!) */ - _SEH_TRY - { - ProbeForWrite(puSurfaceDescription, sizeof(DDSURFACEDESC), 1); - RtlCopyMemory( puSurfaceDescription, &phsurface->desc, sizeof( DDSURFACEDESC ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - _SEH_TRY - { - ProbeForWrite(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1); - puCreateSurfaceData->ddRVal = CreateSurfaceData.ddRVal; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - for (i = 0; i < CreateSurfaceData.dwSCnt; i++) - { - _SEH_TRY - { - ProbeForWrite(puSurfaceGlobalData, sizeof(DD_SURFACE_GLOBAL), 1); - RtlCopyMemory( puSurfaceGlobalData, &phsurface->Global, sizeof( DD_SURFACE_GLOBAL ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - _SEH_TRY - { - ProbeForWrite(puSurfaceLocalData, sizeof(DD_SURFACE_LOCAL), 1); - RtlCopyMemory( puSurfaceLocalData, &phsurface->Local, sizeof( DD_SURFACE_LOCAL ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - _SEH_TRY - { - ProbeForWrite(puSurfaceMoreData, sizeof(DD_SURFACE_MORE), 1); - RtlCopyMemory( puSurfaceMoreData, &phsurface->More, sizeof( DD_SURFACE_MORE ) ); - - puSurfaceLocalData->lpGbl = puSurfaceGlobalData; - puSurfaceLocalData->lpSurfMore = puSurfaceMoreData; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - DPRINT1("GDIOBJ_UnlockObjByPtr\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface); - _SEH_TRY - { - ProbeForWrite(puhSurface, sizeof(HANDLE), 1); - puhSurface[i] = myhSurface[i]; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - } - - - /* FIXME: Fil the return handler */ - DPRINT1("GDIOBJ_UnlockObjByPtr\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - - DPRINT1("Return value is %04x and driver return code is %04x\n", - ddRVal, CreateSurfaceData.ddRVal); - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdCreateSurface"); + return pfnDdCreateSurface(hDirectDrawLocal,hSurface,puSurfaceDescription,puSurfaceGlobalData, + puSurfaceLocalData,puSurfaceMoreData,puCreateSurfaceData,puhSurface); } /************************************************************************/ /* NtGdiDdWaitForVerticalBlank */ -/* status : Works as intended */ /************************************************************************/ - - -DWORD STDCALL NtGdiDdWaitForVerticalBlank( - HANDLE hDirectDrawLocal, - PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData) +DWORD +STDCALL +NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw, + PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData) { - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - PDD_DIRECTDRAW pDirectDraw = NULL; - NTSTATUS Status = FALSE; - DD_WAITFORVERTICALBLANKDATA WaitForVerticalBlankData; - LPDDHAL_WAITFORVERTICALBLANKDATA pWaitForVerticalBlankData = (LPDDHAL_WAITFORVERTICALBLANKDATA)puWaitForVerticalBlankData; + PGD_DXDDWAITFORVERTICALBLANK pfnDdWaitForVerticalBlank = NULL; + INT i; - if ((hDirectDrawLocal) && - (puWaitForVerticalBlankData)) + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdWaitForVerticalBlank, pfnDdWaitForVerticalBlank); + + if (pfnDdWaitForVerticalBlank == NULL) { - RtlZeroMemory(&WaitForVerticalBlankData,sizeof(DD_WAITFORVERTICALBLANKDATA)); - - _SEH_TRY - { - ProbeForRead(pWaitForVerticalBlankData, sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1); - WaitForVerticalBlankData.dwFlags = pWaitForVerticalBlankData->dwFlags; - WaitForVerticalBlankData.bIsInVB = pWaitForVerticalBlankData->bIsInVB; - WaitForVerticalBlankData.hEvent = pWaitForVerticalBlankData->hEvent; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - if(NT_SUCCESS(Status)) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - - if (pDirectDraw != NULL) - { - if (pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK) - { - WaitForVerticalBlankData.ddRVal = DDERR_GENERIC; - WaitForVerticalBlankData.lpDD = &pDirectDraw->Global;; - ddRVal = pDirectDraw->DD.WaitForVerticalBlank(&WaitForVerticalBlankData); - } - _SEH_TRY - { - ProbeForWrite(pWaitForVerticalBlankData, sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1); - pWaitForVerticalBlankData->ddRVal = WaitForVerticalBlankData.ddRVal; - pWaitForVerticalBlankData->bIsInVB = WaitForVerticalBlankData.bIsInVB; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } - } + DPRINT1("Warring no pfnDdWaitForVerticalBlank"); + return DDHAL_DRIVER_NOTHANDLED; } - return ddRVal; + + DPRINT1("Calling on dxg.sys pfnDdWaitForVerticalBlank"); + return pfnDdWaitForVerticalBlank(hDirectDraw, puWaitForVerticalBlankData); +} + +/************************************************************************/ +/* NtGdiDdCanCreateSurface */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal, + PDD_CANCREATESURFACEDATA puCanCreateSurfaceData) +{ + PGD_DDCANCREATESURFACE pfnDdCanCreateSurface = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCanCreateSurface, pfnDdCanCreateSurface); + + if (pfnDdCanCreateSurface == NULL) + { + DPRINT1("Warring no pfnDdCanCreateSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdCanCreateSurface"); + return pfnDdCanCreateSurface(hDirectDrawLocal,puCanCreateSurfaceData); +} + +/************************************************************************/ +/* NtGdiDdGetScanLine */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetScanLine(HANDLE hDirectDrawLocal, + PDD_GETSCANLINEDATA puGetScanLineData) +{ + PGD_DXDDGETSCANLINE pfnDdGetScanLine = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetScanLine, pfnDdGetScanLine); + + if (pfnDdGetScanLine == NULL) + { + DPRINT1("Warring no pfnDdGetScanLine"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetScanLine"); + return pfnDdGetScanLine(hDirectDrawLocal,puGetScanLineData); } /************************************************************************/ -/* CanCreateSurface */ -/* status : Works as intended */ +/* This is not part of the ddsurface interface but it have */ +/* deal with the surface */ /************************************************************************/ -DWORD STDCALL NtGdiDdCanCreateSurface( - HANDLE hDirectDrawLocal, - PDD_CANCREATESURFACEDATA puCanCreateSurfaceData -) +/************************************************************************/ +/* NtGdiDdCreateSurfaceEx */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw, + HANDLE hSurface, + DWORD dwSurfaceHandle) { - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; + PGD_DXDDCREATESURFACEEX pfnDdCreateSurfaceEx = NULL; + INT i; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurfaceEx, pfnDdCreateSurfaceEx); - - if ((puCanCreateSurfaceData) && - (hDirectDrawLocal)) + if (pfnDdCreateSurfaceEx == NULL) { - DDSURFACEDESC desc; - DWORD descSize = 0; - NTSTATUS Status = FALSE; - PDD_DIRECTDRAW pDirectDraw = NULL; - DD_CANCREATESURFACEDATA CanCreateSurfaceData; - LPDDHAL_CANCREATESURFACEDATA pCanCreateSurfaceData = (LPDDHAL_CANCREATESURFACEDATA)puCanCreateSurfaceData; - - RtlZeroMemory(&CanCreateSurfaceData,sizeof(DDSURFACEDESC)); - RtlZeroMemory(&desc,sizeof(DDSURFACEDESC)); - - _SEH_TRY - { - ProbeForRead(pCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1); - CanCreateSurfaceData.bIsDifferentPixelFormat = pCanCreateSurfaceData->bIsDifferentPixelFormat; - - if (pCanCreateSurfaceData->lpDDSurfaceDesc) - { - ProbeForRead(pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1); - RtlCopyMemory(&desc,pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC)); - - /*if it was DDSURFACEDESC2 been pass down */ - descSize = desc.dwSize; - desc.dwSize = sizeof(DDSURFACEDESC); - } - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - if ((NT_SUCCESS(Status)) && - (desc.dwSize != 0)) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - if ((pDirectDraw) && - (pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE)) - { - CanCreateSurfaceData.ddRVal = DDERR_GENERIC; - CanCreateSurfaceData.lpDD = &pDirectDraw->Global; - CanCreateSurfaceData.lpDDSurfaceDesc = &desc; - ddRVal = pDirectDraw->DD.CanCreateSurface(&CanCreateSurfaceData); - - /*if it was DDSURFACEDESC2 been pass down */ - desc.dwSize = descSize; - _SEH_TRY - { - ProbeForWrite(puCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1); - puCanCreateSurfaceData->ddRVal = CanCreateSurfaceData.ddRVal; - - ProbeForWrite(puCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1); - RtlCopyMemory(puCanCreateSurfaceData->lpDDSurfaceDesc,&desc, sizeof(DDSURFACEDESC)); - - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - } - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } + DPRINT1("Warring no pfnDdCreateSurfaceEx"); + return DDHAL_DRIVER_NOTHANDLED; } - return ddRVal; + + DPRINT1("Calling on dxg.sys pfnDdCreateSurfaceEx"); + return pfnDdCreateSurfaceEx(hDirectDraw,hSurface,dwSurfaceHandle); + } -/************************************************************************/ -/* GetScanLine */ -/* status : This func is now documented in MSDN, and now it's compatible*/ -/* with Windows 2000 implementation */ -/************************************************************************/ -DWORD STDCALL -NtGdiDdGetScanLine( HANDLE hDirectDrawLocal, PDD_GETSCANLINEDATA puGetScanLineData) -{ - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - DD_GETSCANLINEDATA GetScanLineData; - PDD_DIRECTDRAW pDirectDraw = NULL; - NTSTATUS Status = FALSE; - LPDDHAL_GETSCANLINEDATA ourpuGetScanLineData; - - if (hDirectDrawLocal) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);; - } - - if (pDirectDraw != NULL) - { - DPRINT1("GetScanLine\n"); - if (pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE) - { - RtlZeroMemory(&GetScanLineData,sizeof(DD_GETSCANLINEDATA)); - GetScanLineData.ddRVal = DDERR_GENERIC; - GetScanLineData.lpDD = &pDirectDraw->Global; - ddRVal = pDirectDraw->DD.GetScanLine(&GetScanLineData); - - DPRINT1("GetScanLine\n"); - _SEH_TRY - { - ProbeForWrite(puGetScanLineData, sizeof(DD_GETSCANLINEDATA), 1); - ourpuGetScanLineData = (LPDDHAL_GETSCANLINEDATA)puGetScanLineData; - ourpuGetScanLineData->dwScanLine = GetScanLineData.dwScanLine; - ourpuGetScanLineData->ddRVal = GetScanLineData.ddRVal; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - if (!NT_SUCCESS(Status)) - { - DPRINT1("GetScanLine\n"); - ddRVal = DDHAL_DRIVER_NOTHANDLED; - } - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } - - return ddRVal; -} diff --git a/reactos/subsystems/win32/win32k/ntddraw/ddraw.c b/reactos/subsystems/win32/win32k/ntddraw/ddraw.c index eb28e18ed14..ddc8fe5cc2f 100644 --- a/reactos/subsystems/win32/win32k/ntddraw/ddraw.c +++ b/reactos/subsystems/win32/win32k/ntddraw/ddraw.c @@ -3,1035 +3,598 @@ * PROJECT: ReactOS kernel * PURPOSE: Native DirectDraw implementation * FILE: subsys/win32k/ntddraw/ddraw.c - * PROGRAMER: Peter Bajusz (hyp-x@stormregion.com) * PROGRAMER: Magnus olsen (magnus@greatlord.com) * REVISION HISTORY: - * 25-10-2003 PB Created - from 2003 to year 2007 - * rewrote almost all code Peter did. - * only few line are left from him + * 19/1-2006 Magnus Olsen */ #include - -//#define NDEBUG #include -/* swtich this off to get rid of all dx debug msg */ -#define DX_DEBUG - -#define DdHandleTable GdiHandleTable +PGD_DXDDSTARTUPDXGRAPHICS gpfnStartupDxGraphics = NULL; +PGD_DXDDCLEANUPDXGRAPHICS gpfnCleanupDxGraphics = NULL; +/* export from dxeng.c */ +extern DRVFN gaEngFuncs; +extern ULONG gcEngFuncs; +PDRVFN gpDxFuncs; +HANDLE ghDxGraphics; +ULONG gdwDirectDrawContext; /************************************************************************/ -/* DIRECT DRAW OBJECT */ +/* DirectX graphic/video driver loading and cleanup start here */ /************************************************************************/ - -BOOL INTERNAL_CALL -DD_Cleanup(PVOID ObjectBody) +NTSTATUS +STDCALL +DxDdStartupDxGraphics( ULONG ulc1, + PDRVENABLEDATA DxEngDrvOld, + ULONG ulc2, + PDRVENABLEDATA DxgDrvOld, + PULONG DirectDrawContext, + PEPROCESS Proc) { - PDD_DIRECTDRAW pDirectDraw = (PDD_DIRECTDRAW) ObjectBody; + DRVENABLEDATA DxEngDrv; + DRVENABLEDATA DxgDrv; - DPRINT1("DD_Cleanup\n"); + NTSTATUS Status = STATUS_PROCEDURE_NOT_FOUND; - if (!pDirectDraw) - { - return FALSE; - } - - if (pDirectDraw->Global.dhpdev == NULL) - { - return FALSE; - } - - if (pDirectDraw->DrvDisableDirectDraw == NULL) - { - return FALSE; - } - - pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev); - return TRUE; -} - -/* code for enable and reanble the drv */ -BOOL -intEnableDriver(PDD_DIRECTDRAW pDirectDraw) -{ - BOOL success; - DD_HALINFO HalInfo; - - /*clean up some of the cache entry */ - RtlZeroMemory(&pDirectDraw->DD, sizeof(DD_CALLBACKS)); - RtlZeroMemory(&pDirectDraw->Surf, sizeof(DD_SURFACECALLBACKS)); - RtlZeroMemory(&pDirectDraw->Pal, sizeof(DD_PALETTECALLBACKS)); - RtlZeroMemory(&pDirectDraw->Hal, sizeof(DD_HALINFO)); - RtlZeroMemory(&HalInfo, sizeof(DD_HALINFO)); - pDirectDraw->dwNumHeaps =0; - pDirectDraw->dwNumFourCC = 0; - pDirectDraw->pdwFourCC = NULL; - pDirectDraw->pvmList = NULL; - - /* Get DirectDraw infomations form the driver - * DDK say pvmList, pdwFourCC is always NULL in frist call here - * but we get back how many pvmList it whant we should alloc, same - * with pdwFourCC. + /* FIXME setup of gaEngFuncs driver export list + * but not in this api, we can add it here tempary until we figout where + * no code have been writen for it yet */ - if (pDirectDraw->DrvGetDirectDrawInfo) + + + /* FIXME ReactOS does not loading the dxapi.sys or import functions from it yet */ + // DxApiGetVersion() + + /* Loading the kernel interface of directx for win32k */ + ghDxGraphics = EngLoadImage(L"drivers\\dxg.sys"); + if (!ghDxGraphics) { - success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev, - &HalInfo, - &pDirectDraw->dwNumHeaps, - NULL, - &pDirectDraw->dwNumFourCC, - NULL); - if (!success) + DPRINT1("Warring no dxg.sys in ReactOS"); + Status = STATUS_DLL_NOT_FOUND; + } + else + { + /* import DxDdStartupDxGraphics and DxDdCleanupDxGraphics */ + gpfnStartupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdStartupDxGraphics"); + gpfnCleanupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdCleanupDxGraphics"); + + if ((gpfnStartupDxGraphics) && + (gpfnCleanupDxGraphics)) { - DPRINT1("DrvGetDirectDrawInfo frist call fail\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; + /* Setup driver data for activate the dx interface */ + DxEngDrv.iDriverVersion = DDI_DRIVER_VERSION_NT5_01; + DxEngDrv.pdrvfn = &gaEngFuncs; + DxEngDrv.c = gcEngFuncs; + + Status = gpfnStartupDxGraphics ( sizeof(DRVENABLEDATA), + &DxEngDrv, + sizeof(DRVENABLEDATA), + &DxgDrv, + &gdwDirectDrawContext, + Proc ); } - - /* The driver are not respnose to alloc the memory for pvmList - * but it is win32k responsible todo, Windows 9x it is gdi32.dll - */ - if (pDirectDraw->dwNumHeaps != 0) + /* check if we manger loading the data and execute the dxStartupDxGraphics and it susscess */ + if (!NT_SUCCESS(Status)) { - DPRINT1("Setup pvmList\n"); - pDirectDraw->pvmList = (PVIDEOMEMORY) ExAllocatePoolWithTag(PagedPool, pDirectDraw->dwNumHeaps * sizeof(VIDEOMEMORY), TAG_DXPVMLIST); - if (pDirectDraw->pvmList == NULL) + gpfnStartupDxGraphics = NULL; + gpfnCleanupDxGraphics = NULL; + EngUnloadImage( ghDxGraphics); + ghDxGraphics = NULL; + DPRINT1("Warring no init of DirectX graphic interface"); + } + else + { + /* Sort the drv functions list in index order, this allown us doing, smaller optimze + * in api that are redirect to dx.sys + */ + + PDRVFN lstDrvFN = DxgDrv.pdrvfn; + INT t; + for (t=0;t<=DXG_INDEX_DxDdIoctl;t++) { - DPRINT1("pvmList memmery alloc fail\n"); - return FALSE; + gpDxFuncs[lstDrvFN[t].iFunc].iFunc =lstDrvFN[t].iFunc; + gpDxFuncs[lstDrvFN[t].iFunc].pfn =lstDrvFN[t].pfn; } + DPRINT1("DirectX interface is Activated"); } - - /* The driver are not respnose to alloc the memory for pdwFourCC - * but it is win32k responsible todo, Windows 9x it is gdi32.dll - */ - - if (pDirectDraw->dwNumFourCC != 0) - { - DPRINT1("Setup pdwFourCC\n"); - pDirectDraw->pdwFourCC = (LPDWORD) ExAllocatePoolWithTag(PagedPool, pDirectDraw->dwNumFourCC * sizeof(DWORD), TAG_DXFOURCC); - - if (pDirectDraw->pdwFourCC == NULL) - { - DPRINT1("pdwFourCC memmery alloc fail\n"); - return FALSE; - } - } - success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev, - &HalInfo, - &pDirectDraw->dwNumHeaps, - pDirectDraw->pvmList, - &pDirectDraw->dwNumFourCC, - pDirectDraw->pdwFourCC); - if (!success) - { - DPRINT1("DrvGetDirectDrawInfo second call fail\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - - /* We need now convert the DD_HALINFO we got, it can be NT4 driver we - * loading ReactOS supporting NT4 and higher to be loading.so we make - * the HALInfo compatible here so we can easy pass it to gdi32.dll - * without converting it later - */ - - if ((HalInfo.dwSize != sizeof(DD_HALINFO)) && - (HalInfo.dwSize != sizeof(DD_HALINFO_V4))) - { - DPRINT1(" Fail not vaild driver DD_HALINFO struct found\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - if (HalInfo.dwSize != sizeof(DD_HALINFO)) - { - if (HalInfo.dwSize == sizeof(DD_HALINFO_V4)) - { - /* NT4 Compatible */ - DPRINT1("Got DD_HALINFO_V4 sturct we convert it to DD_HALINFO \n"); - HalInfo.dwSize = sizeof(DD_HALINFO); - HalInfo.lpD3DGlobalDriverData = NULL; - HalInfo.lpD3DHALCallbacks = NULL; - HalInfo.lpD3DBufCallbacks = NULL; - } - else - { - /* Unknown version found */ - DPRINT1(" Fail : did not get DD_HALINFO size \n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - /* Copy it to user mode pointer the data */ - RtlCopyMemory(&pDirectDraw->Hal, &HalInfo, sizeof(DD_HALINFO)); + /* return the status */ } - DPRINT1("Trying EnableDirectDraw the driver\n"); - - success = pDirectDraw->EnableDirectDraw( pDirectDraw->Global.dhpdev, - &pDirectDraw->DD, - &pDirectDraw->Surf, - &pDirectDraw->Pal); - - if (!success) - { - DPRINT1("EnableDirectDraw call fail\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - return TRUE; + return Status; } +/************************************************************************/ +/* DirectX graphic/video driver loading cleanup ends here */ +/************************************************************************/ -/* NtGdiDdCreateDirectDrawObject is finish and works as it should - * it maybe have some memory leack or handler leack in this code - * if you found any case you maybe think it leacks the handler - * or memory please tell me, before you start fixing the code - * Magnus Olsen - */ -HANDLE STDCALL + + +/************************************************************************/ +/* NtGdiDdCreateDirectDrawObject */ +/************************************************************************/ +HANDLE +STDCALL NtGdiDdCreateDirectDrawObject(HDC hdc) { - DC *pDC; - HANDLE hDirectDraw; - PDD_DIRECTDRAW pDirectDraw; - /* Create a hdc if we do not have one */ - if (hdc == NULL) + PGD_DDCREATEDIRECTDRAWOBJECT pfnDdCreateDirectDrawObject = NULL; + NTSTATUS Status; + PEPROCESS Proc = NULL; + INT i=0; + + /* FIXME get the process data */ + /* FIXME this code should be add where the driver being load */ + Status = DxDdStartupDxGraphics(0,NULL,0,NULL,NULL, Proc); + if (!NT_SUCCESS(Status)) { - return NULL; + DPRINT1("Warring : Fail to statup the directx interface"); + return 0; } - /* Look the hdc to gain the internal struct */ - pDC = DC_LockDc(hdc); - if (!pDC) - { - return NULL; - } - - /* test see if drv got a dx interface or not */ - if ( ( pDC->DriverFunctions.DisableDirectDraw == NULL) || - ( pDC->DriverFunctions.EnableDirectDraw == NULL)) - { - DC_UnlockDc(pDC); - return NULL; - } - - /* alloc and lock the stucrt */ - hDirectDraw = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DIRECTDRAW); - if (!hDirectDraw) - { - /* No more memmory */ - DC_UnlockDc(pDC); - return NULL; - } - - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW); - if (!pDirectDraw) - { - /* invalid handle */ - DC_UnlockDc(pDC); - return NULL; - } - - /* setup the internal stuff */ - pDirectDraw->Global.dhpdev = pDC->PDev; - pDirectDraw->Local.lpGbl = &pDirectDraw->Global; - - pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo; - pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw; - pDirectDraw->EnableDirectDraw = pDC->DriverFunctions.EnableDirectDraw; - - if (intEnableDriver(pDirectDraw) == FALSE) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - DC_UnlockDc(pDC); - return NULL; - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - DC_UnlockDc(pDC); - return hDirectDraw; -} - - -/* NtGdiDdCreateDirectDrawObject is finish and works as it should - * it maybe have some memory leack or handler leack in this code - * if you found any case you maybe think it leacks the handler - * or memory please tell me, before you start fixing the code - * Magnus Olsen - */ - -BOOL STDCALL -NtGdiDdQueryDirectDrawObject( - HANDLE hDirectDrawLocal, - DD_HALINFO *pHalInfo, - DWORD *pCallBackFlags, - LPD3DNTHAL_CALLBACKS puD3dCallbacks, - LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData, - PDD_D3DBUFCALLBACKS puD3dBufferCallbacks, - LPDDSURFACEDESC puD3dTextureFormats, - DWORD *puNumHeaps, - VIDEOMEMORY *puvmList, - DWORD *puNumFourCC, - DWORD *puFourCC -) -{ - PDD_DIRECTDRAW pDirectDraw; - NTSTATUS Status = FALSE; - BOOL Ret=FALSE; - LPD3DNTHAL_GLOBALDRIVERDATA pD3dDriverData; - - if (hDirectDrawLocal == NULL) - { - return FALSE; - } - - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, - GDI_OBJECT_TYPE_DIRECTDRAW); - if (!pDirectDraw) - { - return FALSE; - } - - /* - * Get pHalInfo - */ - if (pHalInfo != NULL) - { - _SEH_TRY - { - ProbeForWrite(pHalInfo, sizeof(DD_HALINFO), 1); - RtlCopyMemory(pHalInfo,&pDirectDraw->Hal, sizeof(DD_HALINFO)); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - else - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /* - * Get pCallBackFlags - */ - if (pCallBackFlags != NULL) - { - _SEH_TRY - { - ProbeForWrite(pCallBackFlags, sizeof(DWORD)*3, 1); - pCallBackFlags[0]=pDirectDraw->DD.dwFlags; - pCallBackFlags[1]=pDirectDraw->Surf.dwFlags; - pCallBackFlags[2]=pDirectDraw->Pal.dwFlags; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - else - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /* - * Get puD3dCallbacks - */ - if ((puD3dCallbacks) && - (pDirectDraw->Hal.lpD3DHALCallbacks)) - { - _SEH_TRY - { - ProbeForWrite(puD3dCallbacks, sizeof(D3DNTHAL_CALLBACKS), 1); - RtlCopyMemory( puD3dCallbacks, pDirectDraw->Hal.lpD3DHALCallbacks, sizeof( D3DNTHAL_CALLBACKS ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - else - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /* - * Get lpD3DGlobalDriverData - */ - if ((puD3dDriverData) && - (pDirectDraw->Hal.lpD3DGlobalDriverData != NULL)) - { - /* Get D3dDriverData */ - _SEH_TRY - { - ProbeForWrite(puD3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA), 1); - RtlCopyMemory( puD3dDriverData, pDirectDraw->Hal.lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA)); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /* Get TextureFormats */ - pD3dDriverData =pDirectDraw->Hal.lpD3DGlobalDriverData; - if ((puD3dTextureFormats) && - (pD3dDriverData->dwNumTextureFormats>0) && - (pD3dDriverData->lpTextureFormats)) - { - DWORD Size = sizeof(DDSURFACEDESC) * pD3dDriverData->dwNumTextureFormats; - _SEH_TRY - { - ProbeForWrite(puD3dTextureFormats, Size, 1); - RtlCopyMemory( puD3dTextureFormats, pD3dDriverData->lpTextureFormats, Size); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - } - else - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /*Get D3dBufferCallbacks */ - if ( (puD3dBufferCallbacks) && - (pDirectDraw->Hal.lpD3DBufCallbacks)) - { - _SEH_TRY - { - ProbeForWrite(puD3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS), 1); - RtlCopyMemory( puD3dBufferCallbacks, pDirectDraw->Hal.lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS)); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - } - else - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return FALSE; - } - - /* Get puNumFourCC and dwNumFourCC */ - _SEH_TRY - { - ProbeForWrite(puNumFourCC, sizeof(DWORD), 1); - *puNumFourCC = pDirectDraw->dwNumFourCC; - - if ((pDirectDraw->pdwFourCC) && - (puFourCC)) - { - ProbeForWrite(puFourCC, sizeof(DWORD) * pDirectDraw->dwNumFourCC, 1); - RtlCopyMemory( puFourCC, pDirectDraw->pdwFourCC, sizeof(DWORD) * pDirectDraw->dwNumFourCC); - } - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - } - else - { - Ret = TRUE; - } - return Ret; -} - - -BOOL STDCALL -NtGdiDdDeleteDirectDrawObject( HANDLE hDirectDrawLocal) -{ - DPRINT1("NtGdiDdDeleteDirectDrawObject\n"); - if (hDirectDrawLocal == NULL) - { - return FALSE; - } - - return GDIOBJ_FreeObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); -} - - -BOOL STDCALL NtGdiDdReenableDirectDrawObject( - HANDLE hDirectDrawLocal, - BOOL *pubNewMode -) -{ - BOOL Ret=FALSE; - NTSTATUS Status = FALSE; - PDD_DIRECTDRAW pDirectDraw; - - if (hDirectDrawLocal == NULL) - { - return Ret; - } - - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, - GDI_OBJECT_TYPE_DIRECTDRAW); - - if (!pDirectDraw) - { - return Ret; - } - - /* - * FIXME detect mode change thic code maybe are not correct - * if we call on intEnableDriver it will cause some memory leak - * we need free the alloc memory before we call on it - */ - Ret = intEnableDriver(pDirectDraw); - - _SEH_TRY - { - ProbeForWrite(pubNewMode, sizeof(BOOL), 1); - *pubNewMode = Ret; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - return Ret; - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - - return Ret; - -} - - - -DWORD STDCALL NtGdiDdGetDriverInfo( - HANDLE hDirectDrawLocal, - PDD_GETDRIVERINFODATA puGetDriverInfoData) - -{ - DWORD ddRVal = 0; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, - GDI_OBJECT_TYPE_DIRECTDRAW); - - DPRINT1("NtGdiDdGetDriverInfo\n"); - - if (pDirectDraw == NULL) + /* This is in correct place */ + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateDirectDrawObject, pfnDdCreateDirectDrawObject); + + if (pfnDdCreateDirectDrawObject == NULL) { + DPRINT1("Warring no pfnDdCreateDirectDrawObject"); return DDHAL_DRIVER_NOTHANDLED; } - /* it exsist two version of NtGdiDdGetDriverInfo we need check for both flags */ - if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET)) - ddRVal++; + DPRINT1("Calling on dxg.sys DdCreateDirectDrawObject"); + return pfnDdCreateDirectDrawObject(hdc); - if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFO2)) - ddRVal++; +} - /* Now we are doing the call to drv DrvGetDriverInfo */ - if (ddRVal == 2) +/*++ +* @name NtGdiDxgGenericThunk +* @implemented +* +* The function NtGdiDxgGenericThunk redirect dx call to other thing. +* from dxg.sys +* +* @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 return DDHAL_DRIVER_NOTHANDLED +* +* @remarks. +* dxg.sys NtGdiDxgGenericThunk call are redirect to dxg.sys +* This api are not longer use in Windows NT 2000/XP/2003 +* +*--*/ +DWORD +STDCALL +NtGdiDxgGenericThunk(ULONG_PTR ulIndex, + ULONG_PTR ulHandle, + SIZE_T *pdwSizeOfPtr1, + PVOID pvPtr1, + SIZE_T *pdwSizeOfPtr2, + PVOID pvPtr2) +{ + PGD_DXGENERICTRUNK pfnDxgGenericThunk = (PGD_DXGENERICTRUNK)gpDxFuncs[DXG_INDEX_DxDxgGenericThunk].pfn; + + if (pfnDxgGenericThunk == NULL) { - DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED"); - ddRVal = DDHAL_DRIVER_NOTHANDLED; - } - else - { - ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData); + DPRINT1("Warring no pfnDxgGenericThunk"); + return DDHAL_DRIVER_NOTHANDLED; } - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDxgGenericThunk"); + return pfnDxgGenericThunk(ulIndex, ulHandle, pdwSizeOfPtr1, pvPtr1, pdwSizeOfPtr2, pvPtr2); } - - - -DWORD STDCALL NtGdiDdUnlock( - HANDLE hSurface, - PDD_UNLOCKDATA puUnlockData -) +/************************************************************************/ +/* NtGdiDdGetDriverState */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetDriverState(PDD_GETDRIVERSTATEDATA pdata) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DDGETDRIVERSTATE pfnDdGetDriverState = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdUnlock\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDriverState, pfnDdGetDriverState); - /* backup the orignal PDev and info */ - lgpl = puUnlockData->lpDD; + if (pfnDdGetDriverState == NULL) + { + DPRINT1("Warring no pfnDdGetDriverState"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puUnlockData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.Unlock(puUnlockData); - - /* But back the orignal PDev */ - puUnlockData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys DdGetDriverState"); + return pfnDdGetDriverState(pdata); } - - -DWORD STDCALL NtGdiDdSetColorKey( - HANDLE hSurface, - PDD_SETCOLORKEYDATA puSetColorKeyData -) +/************************************************************************/ +/* NtGdiDdColorControl */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdColorControl(HANDLE hSurface, + PDD_COLORCONTROLDATA puColorControlData) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DDCOLORCONTROL pfnDdColorControl = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdSetColorKey\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdColorControl, pfnDdColorControl); - /* backup the orignal PDev and info */ - lgpl = puSetColorKeyData->lpDD; + if (pfnDdColorControl == NULL) + { + DPRINT1("Warring no pfnDdColorControl"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puSetColorKeyData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData); - - /* But back the orignal PDev */ - puSetColorKeyData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys DdColorControl"); + return pfnDdColorControl(hSurface,puColorControlData); } - -DWORD STDCALL NtGdiDdAddAttachedSurface( - HANDLE hSurface, - HANDLE hSurfaceAttached, - PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData +/************************************************************************/ +/* NtGdiDdCreateSurfaceObject */ +/************************************************************************/ +HANDLE +STDCALL +NtGdiDdCreateSurfaceObject(HANDLE hDirectDrawLocal, + HANDLE hSurface, + PDD_SURFACE_LOCAL puSurfaceLocal, + PDD_SURFACE_MORE puSurfaceMore, + PDD_SURFACE_GLOBAL puSurfaceGlobal, + BOOL bComplete ) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DXDDCREATESURFACEOBJECT pfnDdCreateSurfaceObject = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdAddAttachedSurface\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurfaceObject, pfnDdCreateSurfaceObject); - /* backup the orignal PDev and info */ - lgpl = puAddAttachedSurfaceData->lpDD; + if (pfnDdCreateSurfaceObject == NULL) + { + DPRINT1("Warring no pfnDdCreateSurfaceObject"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData); - - /* But back the orignal PDev */ - puAddAttachedSurfaceData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdCreateSurfaceObject"); + return pfnDdCreateSurfaceObject(hDirectDrawLocal, hSurface, puSurfaceLocal, puSurfaceMore, puSurfaceGlobal, bComplete); } -DWORD STDCALL NtGdiDdGetBltStatus( - HANDLE hSurface, - PDD_GETBLTSTATUSDATA puGetBltStatusData -) +/************************************************************************/ +/* NtGdiDdDeleteDirectDrawObject */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DXDDDELETEDIRECTDRAWOBJECT pfnDdDeleteDirectDrawObject = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdGetBltStatus\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDeleteDirectDrawObject, pfnDdDeleteDirectDrawObject); - /* backup the orignal PDev and info */ - lgpl = puGetBltStatusData->lpDD; + if (pfnDdDeleteDirectDrawObject == NULL) + { + DPRINT1("Warring no pfnDdDeleteDirectDrawObject"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puGetBltStatusData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData); - - /* But back the orignal PDev */ - puGetBltStatusData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdDeleteDirectDrawObject"); + return pfnDdDeleteDirectDrawObject(hDirectDrawLocal); } -DWORD STDCALL NtGdiDdGetFlipStatus( - HANDLE hSurface, - PDD_GETFLIPSTATUSDATA puGetFlipStatusData -) +/************************************************************************/ +/* NtGdiDdDeleteSurfaceObject */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdDeleteSurfaceObject(HANDLE hSurface) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DXDDDELETESURFACEOBJECT pfnDdDeleteSurfaceObject = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdGetFlipStatus\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDeleteSurfaceObject, pfnDdDeleteSurfaceObject); - /* backup the orignal PDev and info */ - lgpl = puGetFlipStatusData->lpDD; + if (pfnDdDeleteSurfaceObject == NULL) + { + DPRINT1("Warring no pfnDdDeleteSurfaceObject"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puGetFlipStatusData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData); - - /* But back the orignal PDev */ - puGetFlipStatusData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys DdDeleteSurfaceObject"); + return pfnDdDeleteSurfaceObject(hSurface); } -DWORD STDCALL NtGdiDdUpdateOverlay( - HANDLE hSurfaceDestination, - HANDLE hSurfaceSource, - PDD_UPDATEOVERLAYDATA puUpdateOverlayData -) +/************************************************************************/ +/* NtGdiDdDeleteSurfaceObject */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdQueryDirectDrawObject(HANDLE hDirectDrawLocal, + DD_HALINFO *pHalInfo, + DWORD *pCallBackFlags, + LPD3DNTHAL_CALLBACKS puD3dCallbacks, + LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData, + PDD_D3DBUFCALLBACKS puD3dBufferCallbacks, + LPDDSURFACEDESC puD3dTextureFormats, + DWORD *puNumHeaps, + VIDEOMEMORY *puvmList, + DWORD *puNumFourCC, + DWORD *puFourCC) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DXDDQUERYDIRECTDRAWOBJECT pfnDdQueryDirectDrawObject = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdUpdateOverlay\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdQueryDirectDrawObject, pfnDdQueryDirectDrawObject); - /* backup the orignal PDev and info */ - lgpl = puUpdateOverlayData->lpDD; + if (pfnDdQueryDirectDrawObject == NULL) + { + DPRINT1("Warring no pfnDdQueryDirectDrawObject"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* use our cache version instead */ - puUpdateOverlayData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData); - - /* But back the orignal PDev */ - puUpdateOverlayData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; -} - -DWORD STDCALL NtGdiDdSetOverlayPosition( - HANDLE hSurfaceSource, - HANDLE hSurfaceDestination, - PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData -) -{ - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; - - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdSetOverlayPosition\n"); -#endif - if (pDirectDraw == NULL) - return DDHAL_DRIVER_NOTHANDLED; - - /* backup the orignal PDev and info */ - lgpl = puSetOverlayPositionData->lpDD; - - /* use our cache version instead */ - puSetOverlayPositionData->lpDD = &pDirectDraw->Global; - - /* make the call */ - if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)) - ddRVal = DDHAL_DRIVER_NOTHANDLED; - else - ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData); - - /* But back the orignal PDev */ - puSetOverlayPositionData->lpDD = lgpl; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdQueryDirectDrawObject"); + return pfnDdQueryDirectDrawObject(hDirectDrawLocal, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData, + puD3dBufferCallbacks, puD3dTextureFormats, puNumHeaps, puvmList, puNumFourCC, puFourCC); } /************************************************************************/ -/* SURFACE OBJECT */ +/* NtGdiDdReenableDirectDrawObject */ /************************************************************************/ - -BOOL INTERNAL_CALL -DDSURF_Cleanup(PVOID pDDSurf) +BOOL +STDCALL +NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal, + BOOL *pubNewMode) { - /* FIXME: implement - * PDD_SURFACE pDDSurf = PVOID pDDSurf - */ -#ifdef DX_DEBUG - DPRINT1("DDSURF_Cleanup\n"); -#endif - return TRUE; + PGD_DXDDREENABLEDIRECTDRAWOBJECT pfnDdReenableDirectDrawObject = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdReenableDirectDrawObject, pfnDdReenableDirectDrawObject); + + if (pfnDdReenableDirectDrawObject == NULL) + { + DPRINT1("Warring no pfnDdReenableDirectDrawObject"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdReenableDirectDrawObject"); + return pfnDdReenableDirectDrawObject(hDirectDrawLocal, pubNewMode); } -HANDLE STDCALL NtGdiDdCreateSurfaceObject( - HANDLE hDirectDrawLocal, - HANDLE hSurface, - PDD_SURFACE_LOCAL puSurfaceLocal, - PDD_SURFACE_MORE puSurfaceMore, - PDD_SURFACE_GLOBAL puSurfaceGlobal, - BOOL bComplete -) -{ - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - PDD_SURFACE pSurface; -#ifdef DX_DEBUG - DPRINT1("NtGdiDdCreateSurfaceObject\n"); -#endif - if (!pDirectDraw) - return NULL; - - if (!hSurface) - hSurface = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DD_SURFACE); - - pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE); - - if (!pSurface) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return NULL; - } - - pSurface->hDirectDrawLocal = hDirectDrawLocal; - - RtlMoveMemory(&pSurface->Local, puSurfaceLocal, sizeof(DD_SURFACE_LOCAL)); - RtlMoveMemory(&pSurface->More, puSurfaceMore, sizeof(DD_SURFACE_MORE)); - RtlMoveMemory(&pSurface->Global, puSurfaceGlobal, sizeof(DD_SURFACE_GLOBAL)); - pSurface->Local.lpGbl = &pSurface->Global; - pSurface->Local.lpSurfMore = &pSurface->More; - pSurface->Local.lpAttachList = NULL; - pSurface->Local.lpAttachListFrom = NULL; - pSurface->More.lpVideoPort = NULL; - // FIXME: figure out how to use this - pSurface->bComplete = bComplete; - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - - return hSurface; -} - -BOOL STDCALL NtGdiDdDeleteSurfaceObject( - HANDLE hSurface -) -{ -#ifdef DX_DEBUG - DPRINT1("NtGdiDdDeleteSurfaceObject\n"); -#endif - /* FIXME add right GDI_OBJECT_TYPE_ for everthing for now - we are using same type */ - /* return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE); */ - return GDIOBJ_FreeObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE); - -} - - /************************************************************************/ -/* DIRECT DRAW SURFACR END */ +/* NtGdiDdGetDriverInfo */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetDriverInfo(HANDLE hDirectDrawLocal, + PDD_GETDRIVERINFODATA puGetDriverInfoData) + +{ + PGD_DXDDGETDRIVERINFO pfnDdGetDriverInfo = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDriverInfo, pfnDdGetDriverInfo); + + if (pfnDdGetDriverInfo == NULL) + { + DPRINT1("Warring no pfnDdGetDriverInfo"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetDriverInfo"); + return pfnDdGetDriverInfo(hDirectDrawLocal, puGetDriverInfoData); +} + + +/************************************************************************/ +/* NtGdiDdGetAvailDriverMemory */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetAvailDriverMemory(HANDLE hDirectDrawLocal, + PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData) +{ + PGD_DXDDGETAVAILDRIVERMEMORY pfnDdGetAvailDriverMemory = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetAvailDriverMemory, pfnDdGetAvailDriverMemory); + + if (pfnDdGetAvailDriverMemory == NULL) + { + DPRINT1("Warring no pfnDdGetAvailDriverMemory"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetAvailDriverMemory"); + return pfnDdGetAvailDriverMemory(hDirectDrawLocal, puGetAvailDriverMemoryData); +} + + +/************************************************************************/ +/* NtGdiDdSetExclusiveMode */ /************************************************************************/ - -/* -BOOL STDCALL NtGdiDdAttachSurface( - HANDLE hSurfaceFrom, - HANDLE hSurfaceTo -) +DWORD +STDCALL +NtGdiDdSetExclusiveMode(HANDLE hDirectDraw, + PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData) { - PDD_SURFACE pSurfaceFrom = GDIOBJ_LockObj(hSurfaceFrom, GDI_OBJECT_TYPE_DD_SURFACE); - if (!pSurfaceFrom) - return FALSE; - PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE); - if (!pSurfaceTo) - { - GDIOBJ_UnlockObjByPtr(pSurfaceFrom); - return FALSE; - } + PGD_DXDDSETEXCLUSIVEMODE pfnDdSetExclusiveMode = NULL; + INT i; - if (pSurfaceFrom->Local.lpAttachListFrom) - { - pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom; - } + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetExclusiveMode, pfnDdSetExclusiveMode); - GDIOBJ_UnlockObjByPtr(pSurfaceFrom); - GDIOBJ_UnlockObjByPtr(pSurfaceTo); - return TRUE; -} -*/ + if (pfnDdSetExclusiveMode == NULL) + { + DPRINT1("Warring no pfnDdSetExclusiveMode"); + return DDHAL_DRIVER_NOTHANDLED; + } -DWORD STDCALL NtGdiDdGetAvailDriverMemory( - HANDLE hDirectDrawLocal, - PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData -) -{ - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - PDD_DIRECTDRAW_GLOBAL lgpl; + DPRINT1("Calling on dxg.sys pfnDdSetExclusiveMode"); + return pfnDdSetExclusiveMode(hDirectDraw, puSetExclusiveModeData); - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdGetAvailDriverMemory\n"); -#endif - - /* backup the orignal PDev and info */ - lgpl = puGetAvailDriverMemoryData->lpDD; - - /* use our cache version instead */ - puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global; - - /* make the call */ - // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData); - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - - - /* But back the orignal PDev */ - puGetAvailDriverMemoryData->lpDD = lgpl; - - return ddRVal; } - - -DWORD STDCALL NtGdiDdSetExclusiveMode( - HANDLE hDirectDraw, - PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData -) +/************************************************************************/ +/* NtGdiDdFlipToGDISurface */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdFlipToGDISurface(HANDLE hDirectDraw, + PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData) { - DWORD ddRVal; - PDD_DIRECTDRAW_GLOBAL lgpl; + PGD_DXDDFLIPTOGDISURFACE pfnDdFlipToGDISurface = NULL; + INT i; - PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW); + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFlipToGDISurface, pfnDdFlipToGDISurface); -#ifdef DX_DEBUG - DPRINT1("NtGdiDdSetExclusiveMode\n"); -#endif + if (pfnDdFlipToGDISurface == NULL) + { + DPRINT1("Warring no pfnDdFlipToGDISurface"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* backup the orignal PDev and info */ - lgpl = puSetExclusiveModeData->lpDD; + DPRINT1("Calling on dxg.sys pfnDdFlipToGDISurface"); + return pfnDdFlipToGDISurface(hDirectDraw, puFlipToGDISurfaceData); - /* use our cache version instead */ - puSetExclusiveModeData->lpDD = &pDirectDraw->Global; +} - /* make the call */ - ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData); +/************************************************************************/ +/* NtGdiDdGetDC */ +/************************************************************************/ +HDC +STDCALL +NtGdiDdGetDC(HANDLE hSurface, + PALETTEENTRY *puColorTable) +{ + PGD_DDGETDC pfnDdGetDC = NULL; + INT i; - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDC, pfnDdGetDC); - /* But back the orignal PDev */ - puSetExclusiveModeData->lpDD = lgpl; + if (pfnDdGetDC == NULL) + { + DPRINT1("Warring no pfnDdGetDC"); + return DDHAL_DRIVER_NOTHANDLED; + } - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdGetDC"); + return pfnDdGetDC(hSurface, puColorTable); +} + +/************************************************************************/ +/* NtGdiDdGetDxHandle */ +/************************************************************************/ +HANDLE +STDCALL +NtGdiDdGetDxHandle(HANDLE hDirectDraw, + HANDLE hSurface, + BOOL bRelease) +{ + + PGD_DDGETDXHANDLE pfnDdGetDxHandle = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDxHandle, pfnDdGetDxHandle); + + if (pfnDdGetDxHandle == NULL) + { + DPRINT1("Warring no pfnDdGetDxHandle"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetDxHandle"); + return pfnDdGetDxHandle(hDirectDraw, hSurface, bRelease); +} + + +/************************************************************************/ +/* NtGdiDdReleaseDC */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdReleaseDC(HANDLE hSurface) +{ + PGD_DDRELEASEDC pfnDdReleaseDC = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdReleaseDC, pfnDdReleaseDC); + + if (pfnDdReleaseDC == NULL) + { + DPRINT1("Warring no pfnDdReleaseDC"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdReleaseDC"); + return pfnDdReleaseDC(hSurface); +} + +/************************************************************************/ +/* NtGdiDdResetVisrgn */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdResetVisrgn(HANDLE hSurface, + HWND hwnd) +{ + + PGD_DDRESTVISRGN pfnDdResetVisrgn = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdResetVisrgn, pfnDdResetVisrgn); + + if (pfnDdResetVisrgn == NULL) + { + DPRINT1("Warring no pfnDdResetVisrgn"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdResetVisrgn"); + return pfnDdResetVisrgn(hSurface, hwnd); +} + +/************************************************************************/ +/* NtGdiDdSetGammaRamp */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdSetGammaRamp(HANDLE hDirectDraw, + HDC hdc, + LPVOID lpGammaRamp) +{ + PGD_DDSETGAMMARAMP pfnDdSetGammaRamp = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetGammaRamp, pfnDdSetGammaRamp); + + if (pfnDdSetGammaRamp == NULL) + { + DPRINT1("Warring no pfnDdSetGammaRamp"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdSetGammaRamp"); + return pfnDdSetGammaRamp(hDirectDraw, hdc, lpGammaRamp); } diff --git a/reactos/subsystems/win32/win32k/ntddraw/ddsurf.c b/reactos/subsystems/win32/win32k/ntddraw/ddsurf.c index 42186d4f325..652ba235426 100644 --- a/reactos/subsystems/win32/win32k/ntddraw/ddsurf.c +++ b/reactos/subsystems/win32/win32k/ntddraw/ddsurf.c @@ -9,264 +9,350 @@ */ #include - -#define NDEBUG #include -#define DdHandleTable GdiHandleTable - - - -DWORD STDCALL NtGdiDdBlt( - HANDLE hSurfaceDest, - HANDLE hSurfaceSrc, - PDD_BLTDATA puBltData -) -{ - NTSTATUS Status = FALSE; - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - DD_BLTDATA Blt; - PDD_SURFACE pDstSurface = NULL; - PDD_SURFACE pSrcSurface = NULL; - PDD_DIRECTDRAW pDirectDraw; - - DPRINT1("NtGdiDdBlt\n"); - - _SEH_TRY - { - ProbeForRead(puBltData, sizeof(DD_BLTDATA), 1); - RtlCopyMemory( &Blt, puBltData, sizeof( DD_BLTDATA ) ); - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - if(!NT_SUCCESS(Status)) - { - SetLastNtError(Status); - return ddRVal; - } - - pDstSurface = GDIOBJ_LockObj(DdHandleTable, hSurfaceDest, GDI_OBJECT_TYPE_DD_SURFACE); - if (!pDstSurface) - { - DPRINT1("Fail\n"); - return ddRVal; - } - - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pDstSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - if (!pDirectDraw) - { - DPRINT1("Fail\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface); - return ddRVal; - } - - if (pSrcSurface) - { - pSrcSurface = GDIOBJ_LockObj(DdHandleTable, pSrcSurface, GDI_OBJECT_TYPE_DD_SURFACE); - if (!pSrcSurface) - { - DPRINT1("Fail\n"); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDstSurface); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - return ddRVal; - } - } - - Blt.lpDDDestSurface = &pDstSurface->Local; - if (pDstSurface) - { - Blt.lpDDSrcSurface = &pDstSurface->Local; - } - - Blt.ddRVal = DDERR_GENERIC; - - /* MSDN say this member is always set to FALSE in windows 2000 or higher */ - Blt.IsClipped = FALSE; - - /* MSDN say this member is always unuse in windows 2000 or higher */ - Blt.dwROPFlags = 0; - - if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT) - { - Blt.lpDD = &pDirectDraw->Global; - Blt.Blt = NULL; - ddRVal = pDirectDraw->Surf.Blt(&Blt); - } - - DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal); - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDstSurface); - - if(pSrcSurface) - { - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface); - } - - _SEH_TRY - { - ProbeForWrite(puBltData, sizeof(DD_BLTDATA), 1); - puBltData->ddRVal = Blt.ddRVal; - } - _SEH_HANDLE - { - Status = _SEH_GetExceptionCode(); - } - _SEH_END; - - DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal); - return ddRVal; - } - - - /************************************************************************/ -/* NtGdiDdCreateSurface */ -/* status : untested */ +/* NtGdiDdDestroySurface */ /************************************************************************/ -DWORD STDCALL NtGdiDdDestroySurface( - HANDLE hSurface, - BOOL bRealDestroy -) +DWORD +STDCALL +NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy) { - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - PDD_SURFACE pSurface; - PDD_DIRECTDRAW pDirectDraw; - DD_DESTROYSURFACEDATA DestroySurf; + PGD_DXDDDESTROYSURFACE pfnDdDestroySurface = NULL; + INT i; - DPRINT1("NtGdiDdDestroySurface\n"); + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDestroySurface, pfnDdDestroySurface); - pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE); - if (pSurface != NULL) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - if (pDirectDraw != NULL) - { - if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE) - { - //DestroySurf.lpDD = pSurface->Global; - DestroySurf.lpDDSurface = hSurface; + if (pfnDdDestroySurface == NULL) + { + DPRINT1("Warring no pfnDdDestroySurface"); + return DDHAL_DRIVER_NOTHANDLED; + } - /* FIXME - in parma bRealDestroy - Specifies how to destroy the surface. Can be one of the following values. - TRUE = Destroy the surface and free video memory. - FALSE = Free the video memory but leave the surface in an uninitialized state - */ - - DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface; - ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf); - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface); - } - - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdDestroySurface"); + return pfnDdDestroySurface(hSurface, bRealDestroy); } +/************************************************************************/ +/* NtGdiDdFlip */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdFlip(HANDLE hSurfaceCurrent, + HANDLE hSurfaceTarget, + HANDLE hSurfaceCurrentLeft, + HANDLE hSurfaceTargetLeft, + PDD_FLIPDATA puFlipData) +{ + PGD_DXDDFLIP pfnDdDdFlip = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFlip, pfnDdDdFlip); + + if (pfnDdDdFlip == NULL) + { + DPRINT1("Warring no pfnDdDdFlip"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdDdFlip"); + return pfnDdDdFlip(hSurfaceCurrent, hSurfaceTarget, hSurfaceCurrentLeft, hSurfaceTargetLeft, puFlipData); +} + +/************************************************************************/ +/* NtGdiDdUnlock */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdLock(HANDLE hSurface, + PDD_LOCKDATA puLockData, + HDC hdcClip) +{ + PGD_DXDDLOCK pfnDdLock = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdLock, pfnDdLock); + + if (pfnDdLock == NULL) + { + DPRINT1("Warring no pfnDdLock"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdLock"); + return pfnDdLock(hSurface, puLockData, hdcClip); +} + +/************************************************************************/ +/* NtGdiDdunlock */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdUnlock(HANDLE hSurface, + PDD_UNLOCKDATA puUnlockData) +{ + PGD_DXDDUNLOCK pfnDdUnlock = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnlock, pfnDdUnlock); + + if (pfnDdUnlock == NULL) + { + DPRINT1("Warring no pfnDdUnlock"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdUnlock"); + return pfnDdUnlock(hSurface, puUnlockData); +} + +/************************************************************************/ +/* NtGdiDdBlt */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdBlt(HANDLE hSurfaceDest, + HANDLE hSurfaceSrc, + PDD_BLTDATA puBltData) +{ + PGD_DDBLT pfnDdBlt = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdBlt, pfnDdBlt); + + if (pfnDdBlt == NULL) + { + DPRINT1("Warring no pfnDdBlt"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdBlt"); + return pfnDdBlt(hSurfaceDest,hSurfaceSrc,puBltData); +} + +/************************************************************************/ +/* NtGdiDdSetColorKey */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdSetColorKey(HANDLE hSurface, + PDD_SETCOLORKEYDATA puSetColorKeyData) +{ + PGD_DXDDSETCOLORKEY pfnDdSetColorKey = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetColorKey, pfnDdSetColorKey); + + if (pfnDdSetColorKey == NULL) + { + DPRINT1("Warring no pfnDdSetColorKey"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdSetColorKey"); + return pfnDdSetColorKey(hSurface,puSetColorKeyData); + +} + +/************************************************************************/ +/* NtGdiDdAddAttachedSurface */ +/************************************************************************/ + +DWORD +STDCALL +NtGdiDdAddAttachedSurface(HANDLE hSurface, + HANDLE hSurfaceAttached, + PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData) +{ + PGD_DDADDATTACHEDSURFACE pfnDdAddAttachedSurface = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAddAttachedSurface, pfnDdAddAttachedSurface); + + if (pfnDdAddAttachedSurface == NULL) + { + DPRINT1("Warring no pfnDdAddAttachedSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdAddAttachedSurface"); + return pfnDdAddAttachedSurface(hSurface,hSurfaceAttached,puAddAttachedSurfaceData); +} + +/************************************************************************/ +/* NtGdiDdGetBltStatus */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetBltStatus(HANDLE hSurface, + PDD_GETBLTSTATUSDATA puGetBltStatusData) +{ + PGD_DXDDGETBLTSTATUS pfnDdGetBltStatus = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetBltStatus, pfnDdGetBltStatus); + + if (pfnDdGetBltStatus == NULL) + { + DPRINT1("Warring no pfnDdGetBltStatus"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetBltStatus"); + return pfnDdGetBltStatus(hSurface,puGetBltStatusData); +} + +/************************************************************************/ +/* NtGdiDdGetFlipStatus */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetFlipStatus(HANDLE hSurface, + PDD_GETFLIPSTATUSDATA puGetFlipStatusData) +{ + PGD_DXDDGETFLIPSTATUS pfnDdGetFlipStatus = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetFlipStatus, pfnDdGetFlipStatus); + + if (pfnDdGetFlipStatus == NULL) + { + DPRINT1("Warring no pfnDdGetFlipStatus"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetFlipStatus"); + return pfnDdGetFlipStatus(hSurface,puGetFlipStatusData); +} + +/************************************************************************/ +/* NtGdiDdUpdateOverlay */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdUpdateOverlay(HANDLE hSurfaceDestination, + HANDLE hSurfaceSource, + PDD_UPDATEOVERLAYDATA puUpdateOverlayData) +{ + PGD_DXDDUPDATEOVERLAY pfnDdUpdateOverlay = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUpdateOverlay, pfnDdUpdateOverlay); + + if (pfnDdUpdateOverlay == NULL) + { + DPRINT1("Warring no pfnDdUpdateOverlay"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdUpdateOverlay"); + return pfnDdUpdateOverlay(hSurfaceDestination,hSurfaceSource,puUpdateOverlayData); +} + +/************************************************************************/ +/* NtGdiDdSetOverlayPosition */ +/************************************************************************/ + +DWORD +STDCALL +NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource, + HANDLE hSurfaceDestination, + PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData) +{ + PGD_DXDDSETOVERLAYPOSITION pfnDdSetOverlayPosition = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetOverlayPosition, pfnDdSetOverlayPosition); + + if (pfnDdSetOverlayPosition == NULL) + { + DPRINT1("Warring 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 have */ +/* deal with the surface */ +/************************************************************************/ /************************************************************************/ -/* NtGdiDdFlip */ -/* status : untested */ +/* NtGdiDdAlphaBlt */ /************************************************************************/ +DWORD +STDCALL +NtGdiDdAlphaBlt(HANDLE hSurfaceDest, + HANDLE hSurfaceSrc, + PDD_BLTDATA puBltData) +{ + PGD_DDALPHABLT pfnDdAlphaBlt = NULL; + INT i; -DWORD STDCALL NtGdiDdFlip( - HANDLE hSurfaceCurrent, - HANDLE hSurfaceTarget, - HANDLE hSurfaceCurrentLeft, - HANDLE hSurfaceTargetLeft, - PDD_FLIPDATA puFlipData + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAlphaBlt, pfnDdAlphaBlt); + + if (pfnDdAlphaBlt == NULL) + { + DPRINT1("Warring no pfnDdAlphaBlt"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdAlphaBlt"); + return pfnDdAlphaBlt(hSurfaceDest,hSurfaceSrc,puBltData); +} + +/************************************************************************/ +/* NtGdiDdAttachSurface */ +/************************************************************************/ +BOOL +STDCALL +NtGdiDdAttachSurface(HANDLE hSurfaceFrom, + HANDLE hSurfaceTo ) { - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - PDD_SURFACE pSurface; - PDD_DIRECTDRAW pDirectDraw; - DPRINT1("NtGdiDdFlip\n"); + PGD_DDATTACHSURFACE pfnDdAttachSurface = NULL; + INT i; - /* DO we need looking all surface or is okay for one */ - pSurface = GDIOBJ_LockObj(DdHandleTable, hSurfaceCurrent, GDI_OBJECT_TYPE_DD_SURFACE); - if (pSurface != NULL) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAttachSurface, pfnDdAttachSurface); - if (pDirectDraw != NULL) - { - if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP) - { - /* FIXME is lpDD typecasted tp driver PEV ?? */ - ddRVal = pDirectDraw->Surf.Flip(puFlipData); - } + if (pfnDdAttachSurface == NULL) + { + DPRINT1("Warring no pfnDdAttachSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface); - } - - return ddRVal; + DPRINT1("Calling on dxg.sys pfnDdAttachSurface"); + return pfnDdAttachSurface(hSurfaceFrom,hSurfaceTo); } - - - /************************************************************************/ -/* NtGdiDdLock */ -/* status : untested */ +/* NtGdiDdUnattachSurface */ /************************************************************************/ - -DWORD STDCALL NtGdiDdLock( - HANDLE hSurface, - PDD_LOCKDATA puLockData, - HDC hdcClip) -{ - DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED; - PDD_SURFACE pSurface; - PDD_DIRECTDRAW pDirectDraw; - - DPRINT1("NtGdiDdLock\n"); - - pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE); - if (pSurface != NULL) - { - pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW); - - if (pDirectDraw != NULL) - { - /* Do we need lock hdc from hdcClip ?? */ - if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK) - { - /* FIXME is lpDD typecasted tp driver PEV ?? */ - ddRVal = pDirectDraw->Surf.Lock(puLockData); - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw); - } - - GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface); - } - - return ddRVal; -} - -/* -00414 PDD_SURFCB_SETCLIPLIST SetClipList; -00416 PDD_SURFCB_UNLOCK Unlock; -00417 PDD_SURFCB_BLT Blt; -00418 PDD_SURFCB_SETCOLORKEY SetColorKey; -00419 PDD_SURFCB_ADDATTACHEDSURFACE AddAttachedSurface; -00420 PDD_SURFCB_GETBLTSTATUS GetBltStatus; -00421 PDD_SURFCB_GETFLIPSTATUS GetFlipStatus; -00422 PDD_SURFCB_UPDATEOVERLAY UpdateOverlay; -00423 PDD_SURFCB_SETOVERLAYPOSITION SetOverlayPosition; -00424 PVOID reserved4; -00425 PDD_SURFCB_SETPALETTE SetPalette; -00426 } DD_SURFACECALLBACKS, *PDD_SURFACECALLBACKS; +/* 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 protypes for the info talk against it self */ +DWORD +STDCALL +NtGdiDdUnattachSurface(HANDLE hSurface, + HANDLE hSurfaceAttached) +{ + PGD_DXDDUNATTACHSURFACE pfnDdUnattachSurface = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnattachSurface, pfnDdUnattachSurface); + + if (pfnDdUnattachSurface == NULL) + { + DPRINT1("Warring no pfnDdUnattachSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdUnattachSurface"); + return pfnDdUnattachSurface(hSurface,hSurfaceAttached); +} + diff --git a/reactos/subsystems/win32/win32k/ntddraw/dvp.c b/reactos/subsystems/win32/win32k/ntddraw/dvp.c new file mode 100644 index 00000000000..d02efe0739c --- /dev/null +++ b/reactos/subsystems/win32/win32k/ntddraw/dvp.c @@ -0,0 +1,428 @@ + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native DirectDraw implementation + * FILE: subsys/win32k/ntddraw/dvd.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 19/1-2006 Magnus Olsen + */ + + +#include +#include + +/************************************************************************/ +/* NtGdiDvpCanCreateVideoPort */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpCanCreateVideoPort(HANDLE hDirectDraw, + PDD_CANCREATEVPORTDATA puCanCreateVPortData) +{ + PGD_DVPCANCREATEVIDEOPORT pfnDvpCanCreateVideoPort = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpCanCreateVideoPort, pfnDvpCanCreateVideoPort); + + if (pfnDvpCanCreateVideoPort == NULL) + { + DPRINT1("Warring no pfnDvpCanCreateVideoPort"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpCanCreateVideoPort"); + return pfnDvpCanCreateVideoPort(hDirectDraw, puCanCreateVPortData); +} + +/************************************************************************/ +/* NtGdiDvpColorControl */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpColorControl(HANDLE hVideoPort, + PDD_VPORTCOLORDATA puVPortColorData) +{ + PGD_DVPCOLORCONTROL pfnDvpColorControl = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpColorControl, pfnDvpColorControl); + + if (pfnDvpColorControl == NULL) + { + DPRINT1("Warring no pfnDvpColorControl"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpColorControl"); + return pfnDvpColorControl(hVideoPort, puVPortColorData); +} + +/************************************************************************/ +/* NtGdiDvpCreateVideoPort */ +/************************************************************************/ +HANDLE +STDCALL +NtGdiDvpCreateVideoPort(HANDLE hDirectDraw, + PDD_CREATEVPORTDATA puCreateVPortData) +{ + PGD_DVPCREATEVIDEOPORT pfnDvpCreateVideoPort = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpCreateVideoPort, pfnDvpCreateVideoPort); + + if (pfnDvpCreateVideoPort == NULL) + { + DPRINT1("Warring no pfnDvpCreateVideoPort"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpCreateVideoPort"); + return pfnDvpCreateVideoPort(hDirectDraw, puCreateVPortData); +} + +/************************************************************************/ +/* NtGdiDvpDestroyVideoPort */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpDestroyVideoPort(HANDLE hVideoPort, + PDD_DESTROYVPORTDATA puDestroyVPortData) +{ + PGD_DVPDESTROYVIDEOPORT pfnDvpDestroyVideoPort = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpDestroyVideoPort, pfnDvpDestroyVideoPort); + + if (pfnDvpDestroyVideoPort == NULL) + { + DPRINT1("Warring no pfnDvpDestroyVideoPort"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpDestroyVideoPort"); + return pfnDvpDestroyVideoPort(hVideoPort, puDestroyVPortData); +} + +/************************************************************************/ +/* NtGdiDvpFlipVideoPort */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpFlipVideoPort(HANDLE hVideoPort, + HANDLE hDDSurfaceCurrent, + HANDLE hDDSurfaceTarget, + PDD_FLIPVPORTDATA puFlipVPortData) +{ + PGD_DVPFLIPVIDEOPORT pfnDvpFlipVideoPort = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpFlipVideoPort, pfnDvpFlipVideoPort); + + if (pfnDvpFlipVideoPort == NULL) + { + DPRINT1("Warring no pfnDvpFlipVideoPort"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpFlipVideoPort"); + return pfnDvpFlipVideoPort(hVideoPort, hDDSurfaceCurrent, hDDSurfaceTarget, puFlipVPortData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortBandwidth */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortBandwidth(HANDLE hVideoPort, + PDD_GETVPORTBANDWIDTHDATA puGetVPortBandwidthData) +{ + PGD_DVPGETVIDEOPORTBANDWITH pfnDvpGetVideoPortBandwidth = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortBandwidth, pfnDvpGetVideoPortBandwidth); + + if (pfnDvpGetVideoPortBandwidth == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortBandwidth"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortBandwidth"); + return pfnDvpGetVideoPortBandwidth(hVideoPort, puGetVPortBandwidthData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortFlipStatus */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortFlipStatus(HANDLE hDirectDraw, + PDD_GETVPORTFLIPSTATUSDATA puGetVPortFlipStatusData) +{ + PGD_DXDVPGETVIDEOPORTFLIPSTATUS pfnDvpGetVideoPortFlipStatus = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortFlipStatus, pfnDvpGetVideoPortFlipStatus); + + if (pfnDvpGetVideoPortFlipStatus == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortFlipStatus"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortFlipStatus"); + return pfnDvpGetVideoPortFlipStatus(hDirectDraw, puGetVPortFlipStatusData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortInputFormats */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortInputFormats(HANDLE hVideoPort, + PDD_GETVPORTINPUTFORMATDATA puGetVPortInputFormatData) +{ + PGD_DXDVPGETVIDEOPORTINPUTFORMATS pfnDvpGetVideoPortInputFormats = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortInputFormats, pfnDvpGetVideoPortInputFormats); + + if (pfnDvpGetVideoPortInputFormats == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortInputFormats"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortInputFormats"); + return pfnDvpGetVideoPortInputFormats(hVideoPort, puGetVPortInputFormatData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortLine */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortLine(HANDLE hVideoPort, + PDD_GETVPORTLINEDATA puGetVPortLineData) +{ + PGD_DXDVPGETVIDEOPORTLINE pfnDvpGetVideoPortLine = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortLine, pfnDvpGetVideoPortLine); + + if (pfnDvpGetVideoPortLine == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortLine"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortLine"); + return pfnDvpGetVideoPortLine(hVideoPort, puGetVPortLineData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortOutputFormats */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortOutputFormats(HANDLE hVideoPort, + PDD_GETVPORTOUTPUTFORMATDATA puGetVPortOutputFormatData) +{ + PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS pfnDvpGetVideoPortOutputFormats = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortOutputFormats, puGetVPortOutputFormatData); + + if (pfnDvpGetVideoPortOutputFormats == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortOutputFormats"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortOutputFormats"); + return pfnDvpGetVideoPortOutputFormats(hVideoPort, puGetVPortOutputFormatData); + +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortConnectInfo */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortConnectInfo(HANDLE hDirectDraw, + PDD_GETVPORTCONNECTDATA puGetVPortConnectData) +{ + PGD_DXDVPGETVIDEOPORTCONNECTINFO pfnDvpGetVideoPortConnectInfo = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortConnectInfo, pfnDvpGetVideoPortConnectInfo); + + if (pfnDvpGetVideoPortConnectInfo == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortConnectInfo"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortConnectInfo"); + return pfnDvpGetVideoPortConnectInfo(hDirectDraw, puGetVPortConnectData); +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoSignalStatus */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoSignalStatus(HANDLE hVideoPort, + PDD_GETVPORTSIGNALDATA puGetVPortSignalData) +{ + PGD_DXDVPGETVIDEOSIGNALSTATUS pfnDvpGetVideoSignalStatus = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoSignalStatus, pfnDvpGetVideoSignalStatus); + + if (pfnDvpGetVideoSignalStatus == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoSignalStatus"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoSignalStatus"); + return pfnDvpGetVideoSignalStatus(hVideoPort, puGetVPortSignalData); + +} + + +/************************************************************************/ +/* NtGdiDvpUpdateVideoPort */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpUpdateVideoPort(HANDLE hVideoPort, + HANDLE* phSurfaceVideo, + HANDLE* phSurfaceVbi, + PDD_UPDATEVPORTDATA puUpdateVPortData) +{ + PGD_DXDVPUPDATEVIDEOPORT pfnDvpUpdateVideoPort = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpUpdateVideoPort, pfnDvpUpdateVideoPort); + + if (pfnDvpUpdateVideoPort == NULL) + { + DPRINT1("Warring no pfnDvpUpdateVideoPort"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpUpdateVideoPort"); + return pfnDvpUpdateVideoPort(hVideoPort, phSurfaceVideo, phSurfaceVbi, puUpdateVPortData); + +} + + +/************************************************************************/ +/* NtGdiDvpWaitForVideoPortSync */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpWaitForVideoPortSync(HANDLE hVideoPort, + PDD_WAITFORVPORTSYNCDATA puWaitForVPortSyncData) +{ + PGD_DXDVPWAITFORVIDEOPORTSYNC pfnDvpWaitForVideoPortSync = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpWaitForVideoPortSync, pfnDvpWaitForVideoPortSync); + + if (pfnDvpWaitForVideoPortSync == NULL) + { + DPRINT1("Warring no pfnDvpWaitForVideoPortSync"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpWaitForVideoPortSync"); + return pfnDvpWaitForVideoPortSync(hVideoPort, puWaitForVPortSyncData); +} + + +/************************************************************************/ +/* NtGdiDvpAcquireNotification */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpAcquireNotification(HANDLE hVideoPort, + HANDLE* hEvent, + LPDDVIDEOPORTNOTIFY pNotify) +{ + PGD_DXDVPACQUIRENOTIFICATION pfnDvpAcquireNotification = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpAcquireNotification, pfnDvpAcquireNotification); + + if (pfnDvpAcquireNotification == NULL) + { + DPRINT1("Warring no pfnDvpAcquireNotification"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpAcquireNotification"); + return pfnDvpAcquireNotification(hVideoPort, hEvent, pNotify); +} + + +/************************************************************************/ +/* NtGdiDvpReleaseNotification */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpReleaseNotification(HANDLE hVideoPort, + HANDLE hEvent) +{ + PGD_DXDVPRELEASENOTIFICATION pfnDvpReleaseNotification = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpReleaseNotification, pfnDvpReleaseNotification); + + if (pfnDvpReleaseNotification == NULL) + { + DPRINT1("Warring no pfnDvpReleaseNotification"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpReleaseNotification"); + return pfnDvpReleaseNotification(hVideoPort, hEvent); + +} + + +/************************************************************************/ +/* NtGdiDvpGetVideoPortField */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDvpGetVideoPortField(HANDLE hVideoPort, + PDD_GETVPORTFIELDDATA puGetVPortFieldData) +{ + PGD_DXDVPGETVIDEOPORTFIELD pfnDvpGetVideoPortField = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDvpGetVideoPortField, pfnDvpGetVideoPortField); + + if (pfnDvpGetVideoPortField == NULL) + { + DPRINT1("Warring no pfnDvpGetVideoPortField"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDvpGetVideoPortField"); + return pfnDvpGetVideoPortField(hVideoPort, puGetVPortFieldData); + +} + diff --git a/reactos/subsystems/win32/win32k/ntddraw/dxeng.c b/reactos/subsystems/win32/win32k/ntddraw/dxeng.c new file mode 100644 index 00000000000..a65275367aa --- /dev/null +++ b/reactos/subsystems/win32/win32k/ntddraw/dxeng.c @@ -0,0 +1,521 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native driver enumate of dxeng implementation + * FILE: subsys/win32k/ntddraw/dxeng.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 15/10-2007 Magnus Olsen + */ + +#include +#include + + + +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)DxEngGetDCState}, + {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} +}; + +/************************************************************************/ +/* DxEngNUIsTermSrv */ +/************************************************************************/ + +/* Notes : Check see if termal server got a connections or not */ +BOOL +DxEngNUIsTermSrv() +{ + /* FIXME ReactOS does not suport terminal server yet, we can not check if we got a connections or not */ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngRedrawDesktop */ +/************************************************************************/ + +/* Notes : it always return TRUE, and it update whole the screen (redaw current desktop) */ +BOOL +DxEngRedrawDesktop() +{ + /* FIXME add redraw code */ + UNIMPLEMENTED; + return TRUE; +} + + +/************************************************************************/ +/* DxEngDispUniq */ +/************************************************************************/ + +/* Notes : return the DisplayUniqVisrgn counter from gdishare memory */ +ULONG +DxEngDispUniq() +{ + /* FIXME DisplayUniqVisrgn from gdishare memory */ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngVisRgnUniq */ +/************************************************************************/ +/* Notes : return the VisRgnUniq counter for win32k */ +ULONG +DxEngVisRgnUniq() +{ + /* FIXME DisplayUniqVisrgn from gdishare memory */ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngEnumerateHdev */ +/************************************************************************/ +/* Enumate all drivers in win32k */ +HDEV * +DxEngEnumerateHdev(HDEV *hdev) +{ + /* FIXME Enumate all drivers in win32k */ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetDeviceGammaRamp */ +/************************************************************************/ +/* same protypes NtGdiEngGetDeviceGammaRamp, diffent is we skipp the user mode checks and seh */ +BOOL +DxEngGetDeviceGammaRamp(HDC hDC, LPVOID lpRamp) +{ + /* FIXME redirect it to NtGdiEngGetDeviceGammaRamp internal call */ + UNIMPLEMENTED; + return FALSE; +} + + +/*++ +* @name DxEngLockDC +* @implemented +* +* The function DxEngLockDC lock a hdc from dxg.sys +* +* @param HDC hDC +* The handle we need want lock +* +* @return +* This api return PDC or NULL depns if it sussess lock the hdc or not +* +* @remarks. +* none +* +*--*/ +PDC +DxEngLockDC(HDC hDC) +{ + return DC_LockDc(hDC); +} + + +/*++ +* @name DxEngUnlockDC +* @implemented +* +* The function DxEngUnlockDC Unlock a pDC (hdc) from dxg.sys + +* @param PDC pDC +* The handle we need unlock +* +* @return +* This api always return TRUE if it sussess or not +* +* @remarks. +* none +* +*--*/ +BOOL +DxEngUnlockDC(PDC pDC) +{ + DC_UnlockDc(pDC); + return TRUE; +} + + +/************************************************************************/ +/* DxEngCreateMemoryDC */ +/************************************************************************/ +DWORD DxEngCreateMemoryDC(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngScreenAccessCheck */ +/************************************************************************/ +DWORD DxEngScreenAccessCheck() +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngLockShareSem */ +/************************************************************************/ +DWORD DxEngLockShareSem() +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngUnlockShareSem */ +/************************************************************************/ +DWORD DxEngUnlockShareSem() +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngLockHdev */ +/************************************************************************/ +DWORD DxEngLockHdev(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngUnlockHdev */ +/************************************************************************/ +DWORD DxEngUnlockHdev(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngReferenceHdev */ +/************************************************************************/ +DWORD DxEngReferenceHdev(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngIsHdevLockedByCurrentThread */ +/************************************************************************/ +DWORD DxEngIsHdevLockedByCurrentThread(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + + +/************************************************************************/ +/* DxEngUnreferenceHdev */ +/************************************************************************/ +DWORD DxEngUnreferenceHdev(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSetDeviceGammaRamp */ +/************************************************************************/ +DWORD DxEngSetDeviceGammaRamp(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSpTearDownSprites */ +/************************************************************************/ +DWORD DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSpUnTearDownSprites */ +/************************************************************************/ +DWORD DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSpSpritesVisible */ +/************************************************************************/ +DWORD DxEngSpSpritesVisible(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetHdevData */ +/************************************************************************/ +DWORD +DxEngGetHdevData(PEDD_DIRECTDRAW_GLOBAL pEDDgpl, + DWORD Index) +{ + UNIMPLEMENTED; + return 0; +} + +/************************************************************************/ +/* DxEngSetHdevData */ +/************************************************************************/ +DWORD DxEngSetHdevData(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetDesktopDC */ +/************************************************************************/ +DWORD DxEngGetDesktopDC(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngDeleteDC */ +/************************************************************************/ +DWORD DxEngDeleteDC(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngCleanDC */ +/************************************************************************/ +DWORD DxEngCleanDC(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSetDCOwner */ +/************************************************************************/ +DWORD DxEngSetDCOwner(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSetDCState */ +/************************************************************************/ +DWORD DxEngSetDCState(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetDCState */ +/************************************************************************/ +DWORD +DxEngGetDCState(HDC hDC, + DWORD type) +{ + PEDD_DIRECTDRAW_GLOBAL pEDDgpl = NULL; + PDC pDC = DC_LockDc(hDC); + if (pDC) + { + switch (type) + { + case 1: + UNIMPLEMENTED; + return 0; + case 2: + UNIMPLEMENTED; + return 0; + case 3: + pEDDgpl = pDC->pEDDgpl; + DC_UnlockDc(pDC); + return (DWORD)pEDDgpl; + + default: + UNIMPLEMENTED; + break; + } + } + + return 0; +} + +/************************************************************************/ +/* DxEngSelectBitmap */ +/************************************************************************/ +DWORD DxEngSelectBitmap(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSetBitmapOwner */ +/************************************************************************/ +DWORD DxEngSetBitmapOwner(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngDeleteSurface */ +/************************************************************************/ +DWORD DxEngDeleteSurface(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetSurfaceData */ +/************************************************************************/ +DWORD DxEngGetSurfaceData(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngAltLockSurface */ +/************************************************************************/ +DWORD DxEngAltLockSurface(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngUploadPaletteEntryToSurface */ +/************************************************************************/ +DWORD DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngMarkSurfaceAsDirectDraw */ +/************************************************************************/ +DWORD DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSelectPaletteToSurface */ +/************************************************************************/ +DWORD DxEngSelectPaletteToSurface(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSyncPaletteTableWithDevice */ +/************************************************************************/ +DWORD DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngSetPaletteState */ +/************************************************************************/ +DWORD DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngGetRedirectionBitmap */ +/************************************************************************/ +DWORD DxEngGetRedirectionBitmap(DWORD x1) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngLoadImage */ +/************************************************************************/ +DWORD DxEngLoadImage(DWORD x1,DWORD x2) +{ + UNIMPLEMENTED; + return FALSE; +} + +/************************************************************************/ +/* DxEngIncDispUniq */ +/************************************************************************/ +DWORD DxEngIncDispUniq() +{ + UNIMPLEMENTED; + return FALSE; +} + + diff --git a/reactos/subsystems/win32/win32k/ntddraw/eng.c b/reactos/subsystems/win32/win32k/ntddraw/eng.c new file mode 100644 index 00000000000..c447499da57 --- /dev/null +++ b/reactos/subsystems/win32/win32k/ntddraw/eng.c @@ -0,0 +1,200 @@ + + +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native DirectDraw implementation + * FILE: subsys/win32k/ntddraw/dvd.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 19/1-2006 Magnus Olsen + */ + + +#include +#include + +/************************************************************************/ +/* HeapVidMemAllocAligned */ +/************************************************************************/ +FLATPTR +STDCALL +HeapVidMemAllocAligned(LPVIDMEM lpVidMem, + DWORD dwWidth, + DWORD dwHeight, + LPSURFACEALIGNMENT lpAlignment, + LPLONG lpNewPitch) +{ + PGD_HEAPVIDMEMALLOCALIGNED pfnHeapVidMemAllocAligned = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdHeapVidMemAllocAligned, pfnHeapVidMemAllocAligned); + + if (pfnHeapVidMemAllocAligned == NULL) + { + DPRINT1("Warring no pfnHeapVidMemAllocAligned"); + return 0; + } + + DPRINT1("Calling on dxg.sys pfnHeapVidMemAllocAligned"); + return pfnHeapVidMemAllocAligned(lpVidMem, dwWidth, dwHeight, lpAlignment, lpNewPitch); +} + +/************************************************************************/ +/* VidMemFree */ +/************************************************************************/ +VOID +STDCALL +VidMemFree(LPVMEMHEAP pvmh, + FLATPTR ptr) +{ + PGD_VIDMEMFREE pfnVidMemFree = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdHeapVidMemFree, pfnVidMemFree); + + if (pfnVidMemFree == NULL) + { + DPRINT1("Warring no pfnVidMemFree"); + } + else + { + DPRINT1("Calling on dxg.sys pfnVidMemFree"); + pfnVidMemFree(pvmh, ptr); + } +} + +/************************************************************************/ +/* EngAllocPrivateUserMem */ +/************************************************************************/ +PVOID +STDCALL +EngAllocPrivateUserMem(PDD_SURFACE_LOCAL psl, + SIZE_T cj, + ULONG tag) +{ + PGD_ENGALLOCPRIVATEUSERMEM pfnEngAllocPrivateUserMem = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAllocPrivateUserMem, pfnEngAllocPrivateUserMem); + + if (pfnEngAllocPrivateUserMem == NULL) + { + DPRINT1("Warring no pfnEngAllocPrivateUserMem"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnEngAllocPrivateUserMem"); + return pfnEngAllocPrivateUserMem(psl, cj, tag); +} + +/************************************************************************/ +/* EngFreePrivateUserMem */ +/************************************************************************/ +VOID +STDCALL +EngFreePrivateUserMem(PDD_SURFACE_LOCAL psl, + PVOID pv) +{ + PGD_ENGFREEPRIVATEUSERMEM pfnEngFreePrivateUserMem = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFreePrivateUserMem, pfnEngFreePrivateUserMem); + + if (pfnEngFreePrivateUserMem == NULL) + { + DPRINT1("Warring no pfnEngFreePrivateUserMem"); + } + else + { + DPRINT1("Calling on dxg.sys pfnEngFreePrivateUserMem"); + pfnEngFreePrivateUserMem(psl, pv); + } +} + +/*++ +* @name EngDxIoctl +* @implemented +* +* The function EngDxIoctl is the ioctl call to diffent dx functions +* to 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 return DDERR_UNSUPPORTED +* +* @remarks. +* dxg.sys EngDxIoctl call are redirect to dxg.sys +* This api are not longer use in Windows NT 2000/XP/2003 +* +*--*/ +DWORD +STDCALL +EngDxIoctl(ULONG ulIoctl, + PVOID pBuffer, + ULONG ulBufferSize) +{ + PGD_ENGDXIOCTL pfnEngDxIoctl = (PGD_ENGDXIOCTL)gpDxFuncs[DXG_INDEX_DxDdIoctl].pfn; + + if (pfnEngDxIoctl == NULL) + { + DPRINT1("Warring no pfnEngDxIoctl"); + return DDERR_UNSUPPORTED; + } + + DPRINT1("Calling on dxg.sys pfnEngDxIoctl"); + return pfnEngDxIoctl(ulIoctl, pBuffer, ulBufferSize); +} + +/************************************************************************/ +/* EngLockDirectDrawSurface */ +/************************************************************************/ +PDD_SURFACE_LOCAL +STDCALL +EngLockDirectDrawSurface(HANDLE hSurface) +{ + PGD_ENGLOCKDIRECTDRAWSURFACE pfnEngLockDirectDrawSurface = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdLockDirectDrawSurface, pfnEngLockDirectDrawSurface); + + if (pfnEngLockDirectDrawSurface == NULL) + { + DPRINT1("Warring no pfnEngLockDirectDrawSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnEngLockDirectDrawSurface"); + return pfnEngLockDirectDrawSurface(hSurface); +} + +/************************************************************************/ +/* EngUnlockDirectDrawSurface */ +/************************************************************************/ +BOOL +STDCALL +EngUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface) +{ + PGD_ENGUNLOCKDIRECTDRAWSURFACE pfnEngUnlockDirectDrawSurface = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnlockDirectDrawSurface, pfnEngUnlockDirectDrawSurface); + + if (pfnEngUnlockDirectDrawSurface == NULL) + { + DPRINT1("Warring no pfnEngUnlockDirectDrawSurface"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnEngUnlockDirectDrawSurface"); + return pfnEngUnlockDirectDrawSurface(pSurface); +} + diff --git a/reactos/subsystems/win32/win32k/ntddraw/mocomp.c b/reactos/subsystems/win32/win32k/ntddraw/mocomp.c new file mode 100644 index 00000000000..ce5d2d0af08 --- /dev/null +++ b/reactos/subsystems/win32/win32k/ntddraw/mocomp.c @@ -0,0 +1,250 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * PURPOSE: Native DirectDraw implementation + * FILE: subsys/win32k/ntddraw/mocomp.c + * PROGRAMER: Magnus olsen (magnus@greatlord.com) + * REVISION HISTORY: + * 19/1-2006 Magnus Olsen + */ + + +#include +#include + +/************************************************************************/ +/* NtGdiDdBeginMoCompFrame */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdBeginMoCompFrame(HANDLE hMoComp, + PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData) +{ + PGD_DDBEGINMOCOMPFRAME pfnDdBeginMoCompFrame = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdBeginMoCompFrame, pfnDdBeginMoCompFrame); + + if (pfnDdBeginMoCompFrame == NULL) + { + DPRINT1("Warring no pfnDdBeginMoCompFrame"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdBeginMoCompFrame"); + return pfnDdBeginMoCompFrame(hMoComp,puBeginFrameData); +} + +/************************************************************************/ +/* NtGdiDdCreateMoComp */ +/************************************************************************/ +HANDLE +STDCALL +NtGdiDdCreateMoComp(HANDLE hDirectDraw, PDD_CREATEMOCOMPDATA puCreateMoCompData) +{ + PGD_DXDDCREATEMOCOMP pfnDdCreateMoComp = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateMoComp, pfnDdCreateMoComp); + + if (pfnDdCreateMoComp == NULL) + { + DPRINT1("Warring no pfnDdCreateMoComp"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DdCreateMoComp"); + return pfnDdCreateMoComp(hDirectDraw, puCreateMoCompData); +} + +/************************************************************************/ +/* NtGdiDdDestroyMoComp */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdDestroyMoComp(HANDLE hMoComp, + PDD_DESTROYMOCOMPDATA puBeginFrameData) +{ + PGD_DXDDDESTROYMOCOMP pfnDxDdDestroyMoComp = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDestroyMoComp, pfnDxDdDestroyMoComp); + + if (pfnDxDdDestroyMoComp == NULL) + { + DPRINT1("Warring no pfnDxDdDestroyMoComp"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys DxDdDestroyMoComp"); + return pfnDxDdDestroyMoComp(hMoComp, puBeginFrameData); +} + +/************************************************************************/ +/* NtGdiDdEndMoCompFrame */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdEndMoCompFrame(HANDLE hMoComp, + PDD_ENDMOCOMPFRAMEDATA puEndFrameData) +{ + PGD_DXDDENDMOCOMPFRAME pfnDdEndMoCompFrame = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdEndMoCompFrame, pfnDdEndMoCompFrame); + + if (pfnDdEndMoCompFrame == NULL) + { + DPRINT1("Warring no pfnDdEndMoCompFrame"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdEndMoCompFrame"); + return pfnDdEndMoCompFrame(hMoComp, puEndFrameData); +} + +/************************************************************************/ +/* NtGdiDdGetInternalMoCompInfo */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetInternalMoCompInfo(HANDLE hDirectDraw, + PDD_GETINTERNALMOCOMPDATA puGetInternalData) +{ + PGD_DXDDGETINTERNALMOCOMPINFO pfnDdGetInternalMoCompInfo = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetInternalMoCompInfo, pfnDdGetInternalMoCompInfo); + + if (pfnDdGetInternalMoCompInfo == NULL) + { + DPRINT1("Warring no pfnDdGetInternalMoCompInfo"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetInternalMoCompInfo"); + return pfnDdGetInternalMoCompInfo(hDirectDraw, puGetInternalData); +} + + +/************************************************************************/ +/* NtGdiDdGetMoCompBuffInfo */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetMoCompBuffInfo(HANDLE hDirectDraw, + PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData) +{ + PGD_DXDDGETMOCOMPBUFFINFO pfnDdGetMoCompBuffInfo = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetMoCompBuffInfo, pfnDdGetMoCompBuffInfo); + + if (pfnDdGetMoCompBuffInfo == NULL) + { + DPRINT1("Warring no pfnDdGetMoCompBuffInfo"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetMoCompBuffInfo"); + return pfnDdGetMoCompBuffInfo(hDirectDraw, puGetBuffData); +} + +/************************************************************************/ +/* NtGdiDdGetMoCompFormats */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetMoCompFormats(HANDLE hDirectDraw, + PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData) +{ + PGD_DXDDGETMOCOMPFORMATS pfnDdGetMoCompFormats = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetMoCompFormats, pfnDdGetMoCompFormats); + + if (pfnDdGetMoCompFormats == NULL) + { + DPRINT1("Warring no pfnDdGetMoCompFormats"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetMoCompFormats"); + return pfnDdGetMoCompFormats(hDirectDraw, puGetMoCompFormatsData); +} + + +/************************************************************************/ +/* NtGdiDdGetMoCompGuids */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdGetMoCompGuids(HANDLE hDirectDraw, + PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData) +{ + PGD_DXDDGETMOCOMPGUIDS pfnDdGetMoCompGuids = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetMoCompGuids, pfnDdGetMoCompGuids); + + if (pfnDdGetMoCompGuids == NULL) + { + DPRINT1("Warring no pfnDdGetMoCompGuids"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdGetMoCompGuids"); + return pfnDdGetMoCompGuids(hDirectDraw, puGetMoCompGuidsData); +} + + + +/************************************************************************/ +/* NtGdiDdQueryMoCompStatus */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdQueryMoCompStatus(HANDLE hMoComp, + PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData) +{ + PGD_DXDDQUERYMOCOMPSTATUS pfnDdQueryMoCompStatus = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdQueryMoCompStatus, pfnDdQueryMoCompStatus); + + if (pfnDdQueryMoCompStatus == NULL) + { + DPRINT1("Warring no pfnDdQueryMoCompStatus"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdQueryMoCompStatus"); + return pfnDdQueryMoCompStatus(hMoComp, puQueryMoCompStatusData); +} + + +/************************************************************************/ +/* NtGdiDdRenderMoComp */ +/************************************************************************/ +DWORD +STDCALL +NtGdiDdRenderMoComp(HANDLE hMoComp, + PDD_RENDERMOCOMPDATA puRenderMoCompData) +{ + PGD_DXDDRENDERMOCOMP pfnDdRenderMoComp = NULL; + INT i; + + DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdRenderMoComp, pfnDdRenderMoComp); + + if (pfnDdRenderMoComp == NULL) + { + DPRINT1("Warring no pfnDdRenderMoComp"); + return DDHAL_DRIVER_NOTHANDLED; + } + + DPRINT1("Calling on dxg.sys pfnDdRenderMoComp"); + return pfnDdRenderMoComp(hMoComp, puRenderMoCompData); +} + + + diff --git a/reactos/subsystems/win32/win32k/ntddraw/stubs.c b/reactos/subsystems/win32/win32k/ntddraw/stubs.c deleted file mode 100644 index 3937ca2aefa..00000000000 --- a/reactos/subsystems/win32/win32k/ntddraw/stubs.c +++ /dev/null @@ -1,394 +0,0 @@ -/* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS kernel - * PURPOSE: Native DirectDraw stubs - * FILE: subsys/win32k/ntddraw/stubs.c - * PROGRAMER: Peter Bajusz (hyp-x@stormregion.com) - * REVISION HISTORY: - * 25-10-2003 PB Created - */ - -#include - -#define NDEBUG -#include - - - - -DWORD STDCALL NtGdiD3dContextCreate( - HANDLE hDirectDrawLocal, - HANDLE hSurfColor, - HANDLE hSurfZ, - LPD3DNTHAL_CONTEXTCREATEDATA pdcci -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiD3dContextDestroy( - LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad) -{ - /* This entry point is not supported on NT5 and ROS */ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiD3dDrawPrimitives2( - HANDLE hCmdBuf, - HANDLE hVBuf, - LPD3DNTHAL_DRAWPRIMITIVES2DATA pded, - FLATPTR *pfpVidMemCmd, - DWORD *pdwSizeCmd, - FLATPTR *pfpVidMemVtx, - DWORD *pdwSizeVtx -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiD3dValidateTextureStageState( - LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData -) -{ - UNIMPLEMENTED - - return 0; -} - - - - - -BOOL STDCALL NtGdiDdAttachSurface( - HANDLE hSurfaceFrom, - HANDLE hSurfaceTo -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdBeginMoCompFrame( - HANDLE hMoComp, - PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData -) -{ - UNIMPLEMENTED - - return 0; -} - - -DWORD STDCALL NtGdiDdCanCreateD3DBuffer( - HANDLE hDirectDraw, - PDD_CANCREATESURFACEDATA puCanCreateSurfaceData -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdColorControl( - HANDLE hSurface, - PDD_COLORCONTROLDATA puColorControlData -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdCreateD3DBuffer( - HANDLE hDirectDraw, - HANDLE *hSurface, - DDSURFACEDESC *puSurfaceDescription, - DD_SURFACE_GLOBAL *puSurfaceGlobalData, - DD_SURFACE_LOCAL *puSurfaceLocalData, - DD_SURFACE_MORE *puSurfaceMoreData, - PDD_CREATESURFACEDATA puCreateSurfaceData, - HANDLE *puhSurface -) -{ - UNIMPLEMENTED - - return 0; -} - - - -HANDLE STDCALL NtGdiDdCreateMoComp( - HANDLE hDirectDraw, - PDD_CREATEMOCOMPDATA puCreateMoCompData -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdCreateSurfaceEx( - HANDLE hDirectDraw, - HANDLE hSurface, - DWORD dwSurfaceHandle -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdDestroyD3DBuffer( - HANDLE hSurface -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdDestroyMoComp( - HANDLE hMoComp, - PDD_DESTROYMOCOMPDATA puBeginFrameData -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdEndMoCompFrame( - HANDLE hMoComp, - PDD_ENDMOCOMPFRAMEDATA puEndFrameData -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdFlipToGDISurface( - HANDLE hDirectDraw, - PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData -) -{ - UNIMPLEMENTED - - return 0; -} - - - - -HDC STDCALL NtGdiDdGetDC( - HANDLE hSurface, - PALETTEENTRY *puColorTable -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdGetDriverState( - PDD_GETDRIVERSTATEDATA pdata -) -{ - UNIMPLEMENTED - - return 0; -} - -HANDLE STDCALL NtGdiDdGetDxHandle( - HANDLE hDirectDraw, - HANDLE hSurface, - BOOL bRelease -) -{ - UNIMPLEMENTED - - return 0; -} - - - -DWORD STDCALL NtGdiDdGetInternalMoCompInfo( - HANDLE hDirectDraw, - PDD_GETINTERNALMOCOMPDATA puGetInternalData -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdGetMoCompBuffInfo( - HANDLE hDirectDraw, - PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdGetMoCompFormats( - HANDLE hDirectDraw, - PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdGetMoCompGuids( - HANDLE hDirectDraw, - PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData -) -{ - UNIMPLEMENTED - - return 0; -} - - - - - -DWORD STDCALL NtGdiDdLockD3D( - HANDLE hSurface, - PDD_LOCKDATA puLockData -) -{ - UNIMPLEMENTED - - return 0; -} - - -DWORD STDCALL NtGdiDdQueryMoCompStatus( - HANDLE hMoComp, - PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData -) -{ - UNIMPLEMENTED - - return 0; -} - - -BOOL STDCALL NtGdiDdReleaseDC( - HANDLE hSurface -) -{ - UNIMPLEMENTED - - return 0; -} - -DWORD STDCALL NtGdiDdRenderMoComp( - HANDLE hMoComp, - PDD_RENDERMOCOMPDATA puRenderMoCompData -) -{ - UNIMPLEMENTED - - return 0; -} - -BOOL STDCALL NtGdiDdResetVisrgn( - HANDLE hSurface, - HWND hwnd -) -{ - DPRINT1("UNIMPLEMENTED NtGdiDdResetVisrgn \n"); - /* see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/lowlevelclientsupport/graphics/ddresetvisrgn.asp - for more info, I pasted some part of it here - Clipping can change asynchronously from the point of view of user-mode threads. - The kernel-mode parts of DirectDraw and Microsoft Windows Graphics Device Interface (GDI) - maintain a counter that is incremented whenever the clipping list for the entire desktop - changes. A call to this function records this counter with every existing DirectDraw - primary surface on the system. - - */ - - return TRUE; -} - - - - - -BOOL STDCALL NtGdiDdSetGammaRamp( - HANDLE hDirectDraw, - HDC hdc, - LPVOID lpGammaRamp -) -{ - UNIMPLEMENTED - - return 0; -} - - - -VOID STDCALL NtGdiDdUnattachSurface( - HANDLE hSurface, - HANDLE hSurfaceAttached -) -{ - UNIMPLEMENTED -} - - - -DWORD STDCALL NtGdiDdUnlockD3D( - HANDLE hSurface, - PDD_UNLOCKDATA puUnlockData -) -{ - UNIMPLEMENTED - - return 0; -} - - - - -DWORD STDCALL NtGdiDdAlphaBlt(IN HANDLE hSurfaceDest, - IN OPTIONAL HANDLE hSurfaceSrc, - IN OUT PDD_BLTDATA puBltData) -{ - UNIMPLEMENTED - - return 0; -} -/* EOF */ diff --git a/reactos/subsystems/win32/win32k/objects/gdiobj.c b/reactos/subsystems/win32/win32k/objects/gdiobj.c index 73acabd8b6c..3476581d6ba 100644 --- a/reactos/subsystems/win32/win32k/objects/gdiobj.c +++ b/reactos/subsystems/win32/win32k/objects/gdiobj.c @@ -70,8 +70,8 @@ OBJ_TYPE_INFO ObjTypeInfo[] = { {0, 0, 0, NULL}, /* 00 reserved entry */ {1, sizeof(DC), GDI_OBJECT_TAG_DC, DC_Cleanup}, /* 01 DC */ - {1, sizeof(DD_DIRECTDRAW), GDI_OBJECT_TAG_DDRAW, DD_Cleanup}, /* 02 DD_DDRAW, should be moved away from gdi objects */ - {1, sizeof(DD_SURFACE), GDI_OBJECT_TAG_DDSURF, DDSURF_Cleanup}, /* 03 DD_SURFACE, should be moved away from gdi objects */ + {1, 0, 0, 0}, /* 02 DD_DDRAW, should be moved away from gdi objects */ + {1, 0, 0, 0}, /* 03 DD_SURFACE, should be moved away from gdi objects */ {1, sizeof(ROSRGNDATA), GDI_OBJECT_TAG_REGION, RGNDATA_Cleanup}, /* 04 REGION */ {1, sizeof(BITMAPOBJ), GDI_OBJECT_TAG_BITMAP, BITMAP_Cleanup}, /* 05 BITMAP */ {0, sizeof(DC), GDI_OBJECT_TAG_CLIOBJ, GDI_CleanupDummy}, /* 06 CLIOBJ: METADC,... FIXME: don't use DC struct */ diff --git a/reactos/subsystems/win32/win32k/stubs/stubs.c b/reactos/subsystems/win32/win32k/stubs/stubs.c index dca918b0a4f..e33890d819b 100644 --- a/reactos/subsystems/win32/win32k/stubs/stubs.c +++ b/reactos/subsystems/win32/win32k/stubs/stubs.c @@ -851,31 +851,6 @@ EngQuerySystemAttribute( return FALSE; } -/* - * @unimplemented - */ -FLATPTR STDCALL -HeapVidMemAllocAligned( - IN LPVIDMEM lpVidMem, - IN DWORD dwWidth, - IN DWORD dwHeight, - IN LPSURFACEALIGNMENT lpAlignment, - OUT LPLONG lpNewPitch) -{ - UNIMPLEMENTED; - return 0; -} - -/* - * @unimplemented - */ -VOID STDCALL -VidMemFree( - IN LPVMEMHEAP pvmh, - IN FLATPTR ptr) -{ - UNIMPLEMENTED; -} /* * @unimplemented @@ -888,19 +863,6 @@ BRUSHOBJ_hGetColorTransform( return NULL; } -/* - * @unimplemented - */ -PVOID STDCALL -EngAllocPrivateUserMem( - IN PDD_SURFACE_LOCAL psl, - IN SIZE_T cj, - IN ULONG tag) -{ - UNIMPLEMENTED; - return NULL; -} - /* * @unimplemented */ @@ -922,16 +884,7 @@ EngDeleteFile( return FALSE; } -/* - * @unimplemented - */ -VOID STDCALL -EngFreePrivateUserMem( - IN PDD_SURFACE_LOCAL psl, - IN PVOID pv) -{ - UNIMPLEMENTED; -} + /* * @unimplemented @@ -961,16 +914,7 @@ EngHangNotification( return EHN_ERROR; } -/* - * @unimplemented - */ -PDD_SURFACE_LOCAL STDCALL -EngLockDirectDrawSurface( - IN HANDLE Surface) -{ - UNIMPLEMENTED; - return NULL; -} + /* * @unimplemented @@ -1062,16 +1006,6 @@ EngStretchBltROP( return FALSE; } -/* - * @unimplemented - */ -BOOL STDCALL -EngUnlockDirectDrawSurface( - IN PDD_SURFACE_LOCAL Surface) -{ - UNIMPLEMENTED; - return FALSE; -} /* * @unimplemented @@ -1970,88 +1904,6 @@ NtGdiFONTOBJ_pxoGetXform(IN FONTOBJ *pfo) return NULL; } - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpCanCreateVideoPort( - IN HANDLE hDirectDraw, - IN OUT PDD_CANCREATEVPORTDATA puCanCreateVPortData) -{ - UNIMPLEMENTED; - return 0; -} - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpColorControl( - IN HANDLE hVideoPort, - IN OUT PDD_VPORTCOLORDATA puVPortColorData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -HANDLE -STDCALL -NtGdiDvpCreateVideoPort( - IN HANDLE hDirectDraw, - IN OUT PDD_CREATEVPORTDATA puCreateVPortData) -{ - UNIMPLEMENTED; - return 0; -} - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpDestroyVideoPort( - IN HANDLE hVideoPort, - IN OUT PDD_DESTROYVPORTDATA puDestroyVPortData) -{ - UNIMPLEMENTED; - return 0; -} - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpFlipVideoPort( - IN HANDLE hVideoPort, - IN HANDLE hDDSurfaceCurrent, - IN HANDLE hDDSurfaceTarget, - IN OUT PDD_FLIPVPORTDATA puFlipVPortData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortBandwidth( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTBANDWIDTHDATA puGetVPortBandwidthData) -{ - UNIMPLEMENTED; - return 0; -} - /* * @unimplemented */ @@ -2141,170 +1993,6 @@ NtGdiConvertMetafileRect( return 0; } - - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortFlipStatus( - IN HANDLE hDirectDraw, - IN OUT PDD_GETVPORTFLIPSTATUSDATA puGetVPortFlipStatusData) -{ - UNIMPLEMENTED; - return 0; -} - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortInputFormats( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTINPUTFORMATDATA puGetVPortInputFormatData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortLine( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTLINEDATA puGetVPortLineData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortOutputFormats( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTOUTPUTFORMATDATA puGetVPortOutputFormatData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoPortConnectInfo( - IN HANDLE hDirectDraw, - IN OUT PDD_GETVPORTCONNECTDATA puGetVPortConnectData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpGetVideoSignalStatus( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTSIGNALDATA puGetVPortSignalData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpUpdateVideoPort( - IN HANDLE hVideoPort, - IN HANDLE* phSurfaceVideo, - IN HANDLE* phSurfaceVbi, - IN OUT PDD_UPDATEVPORTDATA puUpdateVPortData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpWaitForVideoPortSync( - IN HANDLE hVideoPort, - IN OUT PDD_WAITFORVPORTSYNCDATA puWaitForVPortSyncData) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpAcquireNotification( - IN HANDLE hVideoPort, - IN OUT HANDLE* hEvent, - IN LPDDVIDEOPORTNOTIFY pNotify) -{ - UNIMPLEMENTED; - return 0; -} - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDvpReleaseNotification( - IN HANDLE hVideoPort, - IN HANDLE hEvent) -{ - UNIMPLEMENTED; - return 0; -} - - - - /* - * @unimplemented - */ -DWORD -STDCALL -NtGdiDxgGenericThunk( - IN ULONG_PTR ulIndex, - IN ULONG_PTR ulHandle, - IN OUT SIZE_T *pdwSizeOfPtr1, - IN OUT PVOID pvPtr1, - IN OUT SIZE_T *pdwSizeOfPtr2, - IN OUT PVOID pvPtr2) -{ - UNIMPLEMENTED; - return 0; -} - - /* * @unimplemented */ @@ -2557,19 +2245,6 @@ NtGdiGetEudcTimeStampEx( return 0; } - /* - * @unimplemented - */ - DWORD -STDCALL -NtGdiDvpGetVideoPortField( - IN HANDLE hVideoPort, - IN OUT PDD_GETVPORTFIELDDATA puGetVPortFieldData) -{ - UNIMPLEMENTED; - return 0; -} - /* * @unimplemented diff --git a/reactos/subsystems/win32/win32k/win32k.def b/reactos/subsystems/win32/win32k/win32k.def index 77a5903aed2..e1b98a087a7 100644 --- a/reactos/subsystems/win32/win32k/win32k.def +++ b/reactos/subsystems/win32/win32k/win32k.def @@ -1,3 +1,5 @@ +; $Id$ +; ; win32k.def ; ; ReactOS win32k.sys @@ -13,7 +15,6 @@ CLIPOBJ_ppoGetPath@4 EngAlphaBlend@28 EngAcquireSemaphore@4 EngAllocMem@12 -EngAllocPrivateUserMem@12 EngAllocUserMem@8 EngAssociateSurface@12 EngBitBlt@44 @@ -51,7 +52,6 @@ EngFindImageProcAddress@8 EngFindResource@16 EngFreeMem@4 EngFreeModule@4 -EngFreePrivateUserMem@8 EngFreeUserMem@4 EngGetCurrentCodePage@8=ntoskrnl.RtlGetCurrentCodePage EngGetCurrentProcessId@0 @@ -149,7 +149,6 @@ FONTOBJ_pifi@4 FONTOBJ_pvTrueTypeFontFile@8 FONTOBJ_pxoGetXform@4 FONTOBJ_vGetInfo@12 -HeapVidMemAllocAligned@20 HT_ComputeRGBGammaTable@24 HT_Get8BPPFormatPalette@16 PALOBJ_cGetColors@16 @@ -173,7 +172,6 @@ RtlUpcaseUnicodeToMultiByteN@20=NTOSKRNL.RtlUpcaseUnicodeToMultiByteN STROBJ_bEnum@12 STROBJ_dwGetCodePage@4 STROBJ_vEnumStart@4 -VidMemFree@8 Win32kInitialize@0 WNDOBJ_bEnum@12 WNDOBJ_cEnumStart@16 @@ -188,4 +186,12 @@ _abnormal_termination=NTOSKRNL._abnormal_termination _except_handler2=NTOSKRNL._except_handler2 _global_unwind2=NTOSKRNL._global_unwind2 _local_unwind2=NTOSKRNL._local_unwind2 +EngLockDirectDrawSurface@4 +EngUnlockDirectDrawSurface@4 +EngDxIoctl@12 +EngAllocPrivateUserMem@12 +HeapVidMemAllocAligned@20 +VidMemFree@8 +EngFreePrivateUserMem@8 + ;EOF diff --git a/reactos/subsystems/win32/win32k/win32k.rbuild b/reactos/subsystems/win32/win32k/win32k.rbuild index 47fe46bc1e1..31dea0a020f 100644 --- a/reactos/subsystems/win32/win32k/win32k.rbuild +++ b/reactos/subsystems/win32/win32k/win32k.rbuild @@ -95,7 +95,11 @@ ddraw.c dd.c ddsurf.c - stubs.c + d3d.c + dvp.c + mocomp.c + eng.c + dxeng.c accelerator.c