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
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE group SYSTEM "../tools/rbuild/project.dtd">
+<group xmlns:xi="http://www.w3.org/2001/XInclude">
+<directory name="dxapi">
+ <xi:include href="dxapi/dxapi.rbuild" />
+</directory>
+<directory name="dxg">
+ <xi:include href="dxg/dxg.rbuild" />
+</directory>
+<directory name="dxgthk">
+ <xi:include href="dxgthk/dxgthk.rbuild" />
+</directory>
+</group>
--- /dev/null
+; $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
+
+
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE module SYSTEM "../../../../tools/rbuild/project.dtd">
+<module name="dxapi" type="kernelmodedriver"
+installbase="system32/drivers" installname="dxapi.sys">
+ <importlibrary definition="dxapi.def" />
+ <include base="dxapi">.</include>
+ <define name="__USE_W32API" />
+ <define name="_DXAPI_" />
+ <library>ntoskrnl</library>
+ <library>hal</library>
+ <library>videoprt</library>
+ <file>main.c</file>
+ <file>dxapi.rc</file>
+</module>
--- /dev/null
+
+
+#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 <reactos/version.rc>
--- /dev/null
+
+
+
+/* DDK/NDK/SDK Headers */
+/* DDK/NDK/SDK Headers */
+#include <ddk/ntddk.h>
+#include <ddk/ntddmou.h>
+#include <ddk/ntifs.h>
+#include <ddk/tvout.h>
+#include <ndk/ntndk.h>
+
+#include <stdarg.h>
+#include <windef.h>
+#include <winerror.h>
+#include <wingdi.h>
+#include <winddi.h>
+#include <winuser.h>
+#include <prntfont.h>
+#include <dde.h>
+#include <wincon.h>
+
+#include <ddk/ddkmapi.h>
+
+/* Prototypes */
+VOID DxGetVersionNumber(PVOID lpvInBuffer, LPDDGETVERSIONNUMBER lpvOutBuffer);
+VOID DxCloseHandle(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxOpenDirectDraw(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxOpenSurface(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxOpenVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetKernelCaps(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxSetFieldNumber(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxSetSkipPattern(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxSetSurfaceState(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxLock(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxFlipOverlay(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxFlipVideoPort(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetCurrentAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetPreviousAutoflip(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxRegisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxUnregisterEvent(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxGetPolarity(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxOpenVpCatureDevice(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxAddVpCaptureBuffer(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+VOID DxFlushVpCaptureBuffs(PVOID lpvInBuffer, PVOID lpvOutBuffer);
+
+/* Internal driver table being use as looking up table for correct size of structs */
+DWORD tblCheckInBuffer [] =
+{
+ /* DD_DXAPI_GETVERSIONNUMBER */
+ 0,
+ /* DD_DXAPI_CLOSEHANDLE */
+ sizeof(DDCLOSEHANDLE),
+ 0, // DD_DXAPI_OPENDIRECTDRAW
+ 0, // DD_DXAPI_OPENSURFACE
+ 0, // DD_DXAPI_OPENVIDEOPORT
+ /* DD_DXAPI_GETKERNELCAPS */
+ sizeof(HANDLE),
+ /* DD_DXAPI_GET_VP_FIELD_NUMBER */
+ sizeof(DDGETFIELDNUMIN),
+ 0, // DD_DXAPI_SET_VP_FIELD_NUMBER
+ 0, // DD_DXAPI_SET_VP_SKIP_FIELD
+ 0, // DD_DXAPI_GET_SURFACE_STATE
+ 0, // DD_DXAPI_SET_SURFACE_STATE
+ 0, // DD_DXAPI_LOCK
+ /* DD_DXAPI_FLIP_OVERLAY */
+ sizeof(DDFLIPOVERLAY),
+ /* DD_DXAPI_FLIP_VP */
+ sizeof(DDFLIPVIDEOPORT),
+ /* DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE */
+ sizeof(DDGETAUTOFLIPIN),
+ /* DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE */
+ sizeof(DDGETAUTOFLIPIN),
+ /* DD_DXAPI_REGISTER_CALLBACK */
+ sizeof(DDREGISTERCALLBACK),
+ /* DD_DXAPI_UNREGISTER_CALLBACK */
+ sizeof(DDREGISTERCALLBACK),
+ /* DD_DXAPI_GET_POLARITY */
+ sizeof(DDGETPOLARITYIN),
+ /* DD_DXAPI_OPENVPCAPTUREDEVICE */
+ sizeof(DDOPENVPCAPTUREDEVICEIN),
+ /* DD_DXAPI_ADDVPCAPTUREBUFFER */
+ sizeof(DDADDVPCAPTUREBUFF),
+ /* DD_DXAPI_FLUSHVPCAPTUREBUFFERS */
+ sizeof(HANDLE)
+};
+
+DWORD tblCheckOutBuffer [] =
+{
+ /* DD_DXAPI_GETVERSIONNUMBER */
+ sizeof(DDGETVERSIONNUMBER),
+ /* DD_DXAPI_CLOSEHANDLE */
+ sizeof(DWORD),
+ 0, // DD_DXAPI_OPENDIRECTDRAW
+ 0, // DD_DXAPI_OPENSURFACE
+ 0, // DD_DXAPI_OPENVIDEOPORT
+ /* DD_DXAPI_GETKERNELCAPS */
+ sizeof(DDGETKERNELCAPSOUT),
+ /* DD_DXAPI_GET_VP_FIELD_NUMBER */
+ sizeof(DDGETFIELDNUMOUT),
+ 0, // DD_DXAPI_SET_VP_FIELD_NUMBER
+ 0, // DD_DXAPI_SET_VP_SKIP_FIELD
+ 0, // DD_DXAPI_GET_SURFACE_STATE
+ 0, // DD_DXAPI_SET_SURFACE_STATE
+ 0, // DD_DXAPI_LOCK
+ /* DD_DXAPI_FLIP_OVERLAY */
+ sizeof(DWORD),
+ /* DD_DXAPI_FLIP_VP */
+ sizeof(DWORD),
+ /* DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE */
+ sizeof(DDGETAUTOFLIPOUT),
+ /* DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE */
+ sizeof(DDGETAUTOFLIPOUT),
+ /* DD_DXAPI_REGISTER_CALLBACK */
+ sizeof(DWORD),
+ /* DD_DXAPI_UNREGISTER_CALLBACK */
+ sizeof(DWORD),
+ /* DD_DXAPI_GET_POLARITY */
+ sizeof(DDGETPOLARITYOUT),
+ /* DD_DXAPI_OPENVPCAPTUREDEVICE */
+ sizeof(DDOPENVPCAPTUREDEVICEOUT),
+ /* DD_DXAPI_ADDVPCAPTUREBUFFER */
+ sizeof(DWORD),
+ /* DD_DXAPI_FLUSHVPCAPTUREBUFFERS */
+ sizeof(DWORD)
+};
+
+
+/* Internal driver function */
+DRVFN gDxApiEntryPoint [] =
+{
+ {DD_DXAPI_GETVERSIONNUMBER - DD_FIRST_DXAPI, (PFN) DxGetVersionNumber},
+ {DD_DXAPI_CLOSEHANDLE - DD_FIRST_DXAPI, (PFN) DxCloseHandle},
+ {DD_DXAPI_OPENDIRECTDRAW - DD_FIRST_DXAPI, (PFN) DxOpenDirectDraw},
+ {DD_DXAPI_OPENSURFACE - DD_FIRST_DXAPI, (PFN) DxOpenSurface},
+ {DD_DXAPI_OPENVIDEOPORT - DD_FIRST_DXAPI, (PFN) DxOpenVideoPort},
+ {DD_DXAPI_GETKERNELCAPS - DD_FIRST_DXAPI, (PFN) DxGetKernelCaps},
+ {DD_DXAPI_GET_VP_FIELD_NUMBER - DD_FIRST_DXAPI, (PFN) DxGetFieldNumber},
+ {DD_DXAPI_SET_VP_FIELD_NUMBER - DD_FIRST_DXAPI, (PFN) DxSetFieldNumber},
+ {DD_DXAPI_SET_VP_SKIP_FIELD - DD_FIRST_DXAPI, (PFN) DxSetSkipPattern},
+ {DD_DXAPI_GET_SURFACE_STATE - DD_FIRST_DXAPI, (PFN) DxGetSurfaceState},
+ {DD_DXAPI_SET_SURFACE_STATE - DD_FIRST_DXAPI, (PFN) DxSetSurfaceState},
+ {DD_DXAPI_LOCK - DD_FIRST_DXAPI, (PFN) DxLock},
+ {DD_DXAPI_FLIP_OVERLAY - DD_FIRST_DXAPI, (PFN) DxFlipOverlay},
+ {DD_DXAPI_FLIP_VP - DD_FIRST_DXAPI, (PFN) DxFlipVideoPort},
+ {DD_DXAPI_GET_CURRENT_VP_AUTOFLIP_SURFACE - DD_FIRST_DXAPI, (PFN) DxGetCurrentAutoflip},
+ {DD_DXAPI_GET_LAST_VP_AUTOFLIP_SURFACE - DD_FIRST_DXAPI, (PFN) DxGetPreviousAutoflip},
+ {DD_DXAPI_REGISTER_CALLBACK - DD_FIRST_DXAPI, (PFN) DxRegisterEvent},
+ {DD_DXAPI_UNREGISTER_CALLBACK - DD_FIRST_DXAPI, (PFN) DxUnregisterEvent},
+ {DD_DXAPI_GET_POLARITY - DD_FIRST_DXAPI, (PFN) DxGetPolarity},
+ {DD_DXAPI_OPENVPCAPTUREDEVICE - DD_FIRST_DXAPI, (PFN) DxOpenVpCatureDevice},
+ {DD_DXAPI_ADDVPCAPTUREBUFFER - DD_FIRST_DXAPI, (PFN) DxAddVpCaptureBuffer},
+ {DD_DXAPI_FLUSHVPCAPTUREBUFFERS - DD_FIRST_DXAPI, (PFN) DxFlushVpCaptureBuffs}
+};
+
+
+
--- /dev/null
+
+/*
+ * 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 */
+}
+
+
+
--- /dev/null
+; $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
+
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE module SYSTEM "../../../../tools/rbuild/project.dtd">
+<module name="dxg" type="kernelmodedriver"
+installbase="system32/drivers" installname="dxg.sys">
+ <importlibrary definition="dxg.def" />
+ <include base="dxg">.</include>
+ <define name="__USE_W32API" />
+ <library>dxgthk</library>
+ <library>ntoskrnl</library>
+ <file>main.c</file>
+ <file>eng.c</file>
+ <file>historic.c</file>
+ <file>dxg.rc</file>
+</module>
--- /dev/null
+/* $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 <reactos/version.rc>
--- /dev/null
+
+
+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}
+
+};
--- /dev/null
+
+/* DDK/NDK/SDK Headers */
+#include <ddk/ntddk.h>
+#include <ddk/ntddmou.h>
+#include <ddk/ntifs.h>
+#include <ddk/tvout.h>
+#include <ndk/ntndk.h>
+
+#define WINBASEAPI
+#define STARTF_USESIZE 2
+#define STARTF_USEPOSITION 4
+#define INTERNAL_CALL NTAPI
+
+#include <stdarg.h>
+#include <windef.h>
+#include <winerror.h>
+#include <wingdi.h>
+#include <winddi.h>
+#include <winuser.h>
+#include <prntfont.h>
+#include <dde.h>
+#include <wincon.h>
+
+#include <reactos/drivers/directx/directxint.h>
+
+#include <reactos/win32k/ntgdityp.h>
+#include <reactos/win32k/ntgdihdl.h>
+
+#include <reactos/drivers/directx/dxg.h>
+#include <reactos/drivers/directx/dxeng.h>
+
+#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]
--- /dev/null
+/*
+ * 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
+ */
+
+
+
+
+
--- /dev/null
+
+/*
+ * 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 <dxg_int.h>
+
+/*++
+* @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;
+}
+
--- /dev/null
+
+/*
+ * 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 <dxg_int.h>
+#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;
+}
--- /dev/null
+
+
+
+#define TAG_THDD TAG('t', 'h', 'd', 'd')
+#define TAG_GINI TAG('G', 'i', 'n', 'i')
+
+
+
--- /dev/null
+; $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
+
--- /dev/null
+<?xml version="1.0"?>
+<!DOCTYPE module SYSTEM "../../../../tools/rbuild/project.dtd">
+<module name="dxgthk" type="kernelmodedriver"
+installbase="system32/drivers" installname="dxgthk.sys">
+ <importlibrary definition="dxgthk.def" />
+ <include base="dxgthk">.</include>
+ <define name="__USE_W32API" />
+ <library>win32k</library>
+ <file>main.c</file>
+ <file>dxgthk.rc</file>
+</module>
--- /dev/null
+/* $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 <reactos/version.rc>
--- /dev/null
+
+/*
+ * 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 <ddk/ntddk.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;
+}
+
+
<directory name="bus">
<xi:include href="bus/directory.rbuild" />
</directory>
+<directory name="directx">
+ <xi:include href="directx/directory.rbuild" />
+</directory>
<directory name="filesystems">
<xi:include href="filesystems/directory.rbuild" />
</directory>
-/*
+/*
* Direct3D NT driver interface
*/
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;
*
* DirectDraw support for DxApi function
*
- * This file is part of the w32api package.
- *
* Contributors:
- * Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
+ * Created by Magnus Olsen
*
* THIS SOFTWARE IS NOT COPYRIGHTED
*
*
*/
-#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
#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)
#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
-
-typedef struct _DDADDVPCAPTUREBUFF {
- HANDLE hCapture;
- DWORD dwFlags;
- PMDL pMDL;
- PKEVENT pKEvent;
- LPDDCAPBUFFINFO lpBuffInfo;
-} DDADDVPCAPTUREBUFF, FAR * LPDDADDVPCAPTUREBUFF;
+#define DDADDBUFF_SYSTEMMEMORY 0x0001
+#define DDADDBUFF_NONLOCALVIDMEM 0x0002
+#define DDADDBUFF_INVERT 0x0004
-typedef struct _DDCLOSEHANDLE {
- HANDLE hHandle;
-} DDCLOSEHANDLE, FAR *LPDDCLOSEHANDLE;
+/* 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 _DDFLIPOVERLAY {
- HANDLE hDirectDraw;
- HANDLE hCurrentSurface;
- HANDLE hTargetSurface;
- DWORD dwFlags;
-} DDFLIPOVERLAY, FAR *LPDDFLIPOVERLAY;
+/* 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 _DDFLIPVIDEOPORT {
+/* 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 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;
-
-/* 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
+} DDGETSURFACESTATEIN, *LPDDGETSURFACESTATEIN;
-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;
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;
-
-/* DDOPENVPCAPTUREDEVICEIN.dwFlags constants */
-#define DDOPENCAPTURE_VIDEO 0x0001
-#define DDOPENCAPTURE_VBI 0x0002
+} DDOPENVIDEOPORTOUT, *LPDDOPENVIDEOPORTOUT;
-typedef struct _DDOPENVPCAPTUREDEVICEIN {
+typedef struct _DDOPENVPCAPTUREDEVICEIN
+{
HANDLE hDirectDraw;
HANDLE hVideoPort;
DWORD dwStartLine;
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;
+
+
+DXAPI
+DWORD
+DxApi(IN DWORD dwFunctionNum,
+ IN LPVOID lpvInBuffer,
+ IN DWORD cbInBuffer,
+ OUT LPVOID lpvOutBuffer,
+ OUT DWORD cbOutBuffer);
+
-#ifdef __cplusplus
-}
-#endif
-#endif /* __DDKMAPI_H */
+#endif /* __DDKMAPI_INCLUDED__ */
);
W32KAPI
-VOID
+DWORD
APIENTRY
NtGdiDdUnattachSurface(
IN HANDLE hSurface,
);
W32KAPI
-DWORD
+BOOL
APIENTRY
NtGdiD3dContextCreate(
IN HANDLE hDirectDrawLocal,
--- /dev/null
+
+#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
--- /dev/null
+
+/************************************************************************/
+/* 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();
+
--- /dev/null
+
+
+/* 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);
+
+
+
#ifndef _NTGDIHDL_\r
#define _NTGDIHDL_\r
\r
+#include <winddi.h>\r
+\r
/* DEFINES *******************************************************************/\r
\r
/* Base address where the handle table is mapped to */\r
DWORD dwUnused[3];\r
} BRUSH_ATTR, *PBRUSH_ATTR;\r
\r
+\r
typedef struct _REGION_ATTR\r
{\r
DWORD dwUnknown1; \r
void *pCharWidthData;\r
} FONT_ATTR, *PFONT_ATTR;\r
\r
+\r
+typedef enum tagGdiPathState\r
+{\r
+ PATH_Null,\r
+ PATH_Open,\r
+ PATH_Closed\r
+} GdiPathState;\r
+\r
+typedef struct tagGdiPath\r
+{\r
+ GdiPathState state;\r
+ POINT *pPoints;\r
+ BYTE *pFlags;\r
+ int numEntriesUsed, numEntriesAllocated;\r
+ BOOL newStroke;\r
+} GdiPath;\r
+\r
+typedef struct _WIN_DC_INFO\r
+{\r
+ int flags;\r
+ HRGN hClipRgn; /* Clip region (may be 0) */\r
+ HRGN hVisRgn; /* Visible region (must never be 0) */\r
+ HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */\r
+ HBITMAP hBitmap;\r
+ HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */\r
+\r
+/* #if 0 */\r
+ HANDLE hDevice;\r
+ HPALETTE hPalette;\r
+\r
+ GdiPath path;\r
+/* #endif */\r
+\r
+ RECT totalExtent;\r
+ BYTE bitsPerPixel;\r
+\r
+ INT DCOrgX; /* DC origin */\r
+ INT DCOrgY;\r
+ INT ArcDirection;\r
+\r
+ XFORM xformWorld2Wnd; /* World-to-window transformation */\r
+ XFORM xformWorld2Vport; /* World-to-viewport transformation */\r
+ XFORM xformVport2World; /* Inverse of the above transformation */\r
+ BOOL vport2WorldValid; /* Is xformVport2World valid? */\r
+} WIN_DC_INFO;\r
+\r
+\r
+typedef BOOL (NTAPI *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA);\r
+typedef DHPDEV (NTAPI *PGD_ENABLEPDEV)(DEVMODEW *, LPWSTR, ULONG, HSURF *, ULONG, ULONG *, ULONG, DEVINFO *, LPWSTR, LPWSTR, HANDLE);\r
+typedef VOID (NTAPI *PGD_COMPLETEPDEV)(DHPDEV, HDEV);\r
+typedef VOID (NTAPI *PGD_DISABLEPDEV)(DHPDEV); \r
+typedef HSURF (NTAPI *PGD_ENABLESURFACE)(DHPDEV);\r
+typedef VOID (NTAPI *PGD_DISABLESURFACE)(DHPDEV);\r
+typedef BOOL (NTAPI *PGD_ASSERTMODE)(DHPDEV, BOOL);\r
+typedef BOOL (NTAPI *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG);\r
+typedef BOOL (NTAPI *PGD_RESETPDEV)(DHPDEV, DHPDEV);\r
+typedef VOID (NTAPI *PGD_DISABLEDRIVER)(VOID);\r
+typedef HBITMAP (NTAPI *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG); \r
+typedef VOID (NTAPI *PGD_DELETEDEVICEBITMAP)(DHSURF); \r
+typedef BOOL (NTAPI *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*);\r
+typedef BOOL (NTAPI *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG); \r
+typedef ULONG (NTAPI *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG); \r
+typedef BOOL (NTAPI *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, PLINEATTRS, MIX); \r
+typedef BOOL (NTAPI *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, ULONG); \r
+typedef BOOL (NTAPI *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, PLINEATTRS, BRUSHOBJ*, POINTL*, MIX, ULONG); \r
+typedef BOOL (NTAPI *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX); \r
+typedef BOOL (NTAPI *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4); \r
+typedef BOOL (NTAPI *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, ULONG, ULONG);\r
+typedef BOOL (NTAPI *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*); \r
+typedef BOOL (NTAPI *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG);\r
+typedef BOOL (NTAPI *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG, BRUSHOBJ*, DWORD);\r
+typedef BOOL (NTAPI *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG); \r
+typedef BOOL (NTAPI *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX); \r
+typedef ULONG (NTAPI *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *); \r
+typedef ULONG (NTAPI *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG, PVOID *); \r
+typedef PIFIMETRICS (NTAPI *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG); \r
+typedef PVOID (NTAPI *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG); \r
+typedef LONG (NTAPI *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*, PVOID, ULONG); \r
+typedef ULONG (NTAPI *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, ULONG); \r
+typedef VOID (NTAPI *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*); \r
+typedef BOOL (NTAPI *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG, RECTL*, MIX);\r
+typedef BOOL (NTAPI *PGD_SENDPAGE)(SURFOBJ*);\r
+typedef BOOL (NTAPI *PGD_STARTPAGE)(SURFOBJ*);\r
+typedef BOOL (NTAPI *PGD_ENDDOC)(SURFOBJ*, ULONG);\r
+typedef BOOL (NTAPI *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD);\r
+typedef ULONG (NTAPI *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*);\r
+typedef VOID (NTAPI *PGD_SYNCHRONIZE)(DHPDEV, RECTL*);\r
+typedef ULONG (NTAPI *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*);\r
+typedef ULONG (NTAPI *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW);\r
+typedef VOID (NTAPI *PGD_FREE)(PVOID, ULONG);\r
+typedef VOID (NTAPI *PGD_DESTROYFONT)(FONTOBJ*);\r
+typedef LONG (NTAPI *PGD_QUERYFONTCAPS)(ULONG, PULONG);\r
+typedef ULONG (NTAPI *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG);\r
+typedef BOOL (NTAPI *PGD_UNLOADFONTFILE)(ULONG);\r
+typedef ULONG (NTAPI *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID, ULONG, PVOID);\r
+typedef LONG (NTAPI *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG, PBYTE);\r
+typedef LONG (NTAPI *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL, GLYPHDATA*, ULONG, TTPOLYGONHEADER*);\r
+typedef PVOID (NTAPI *PGD_GETTRUETYPEFILE)(ULONG, PULONG);\r
+typedef LONG (NTAPI *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG);\r
+typedef BOOL (NTAPI *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *, PVOID *, ULONG);\r
+typedef BOOL (NTAPI *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG);\r
+typedef LONG (NTAPI *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG, PPIXELFORMATDESCRIPTOR);\r
+typedef BOOL (NTAPI *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ);\r
+typedef BOOL (NTAPI *PGD_STARTBANDING)(SURFOBJ*, POINTL*);\r
+typedef BOOL (NTAPI *PGD_NEXTBAND)(SURFOBJ*, POINTL*);\r
+typedef BOOL (NTAPI *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD);\r
+typedef BOOL (NTAPI *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS);\r
+typedef VOID (NTAPI *PGD_DISABLEDIRECTDRAW)(DHPDEV);\r
+typedef LONG (NTAPI *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR);\r
+typedef BOOL (NTAPI *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);\r
+typedef VOID (NTAPI *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG);\r
+\r
+typedef struct _DRIVER_FUNCTIONS\r
+{\r
+ PGD_ENABLEDRIVER EnableDriver;\r
+ PGD_ENABLEPDEV EnablePDEV;\r
+ PGD_COMPLETEPDEV CompletePDEV;\r
+ PGD_DISABLEPDEV DisablePDEV;\r
+ PGD_ENABLESURFACE EnableSurface;\r
+ PGD_DISABLESURFACE DisableSurface;\r
+ PGD_ASSERTMODE AssertMode;\r
+ PGD_OFFSET Offset;\r
+ PGD_RESETPDEV ResetPDEV;\r
+ PGD_DISABLEDRIVER DisableDriver;\r
+ PGD_CREATEDEVICEBITMAP CreateDeviceBitmap;\r
+ PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap;\r
+ PGD_REALIZEBRUSH RealizeBrush;\r
+ PGD_DITHERCOLOR DitherColor;\r
+ PGD_STROKEPATH StrokePath;\r
+ PGD_FILLPATH FillPath;\r
+ PGD_STROKEANDFILLPATH StrokeAndFillPath;\r
+ PGD_PAINT Paint;\r
+ PGD_BITBLT BitBlt;\r
+ PGD_TRANSPARENTBLT TransparentBlt;\r
+ PGD_COPYBITS CopyBits;\r
+ PGD_STRETCHBLT StretchBlt;\r
+ PGD_STRETCHBLTROP StretchBltROP;\r
+ PGD_SETPALETTE SetPalette;\r
+ PGD_TEXTOUT TextOut;\r
+ PGD_ESCAPE Escape;\r
+ PGD_DRAWESCAPE DrawEscape;\r
+ PGD_QUERYFONT QueryFont;\r
+ PGD_QUERYFONTTREE QueryFontTree;\r
+ PGD_QUERYFONTDATA QueryFontData;\r
+ PGD_SETPOINTERSHAPE SetPointerShape;\r
+ PGD_MOVEPOINTER MovePointer;\r
+ PGD_LINETO LineTo;\r
+ PGD_SENDPAGE SendPage;\r
+ PGD_STARTPAGE StartPage;\r
+ PGD_ENDDOC EndDoc;\r
+ PGD_STARTDOC StartDoc;\r
+ PGD_GETGLYPHMODE GetGlyphMode;\r
+ PGD_SYNCHRONIZE Synchronize;\r
+ PGD_SAVESCREENBITS SaveScreenBits;\r
+ PGD_GETMODES GetModes;\r
+ PGD_FREE Free;\r
+ PGD_DESTROYFONT DestroyFont;\r
+ PGD_QUERYFONTCAPS QueryFontCaps;\r
+ PGD_LOADFONTFILE LoadFontFile;\r
+ PGD_UNLOADFONTFILE UnloadFontFile;\r
+ PGD_FONTMANAGEMENT FontManagement;\r
+ PGD_QUERYTRUETYPETABLE QueryTrueTypeTable;\r
+ PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline;\r
+ PGD_GETTRUETYPEFILE GetTrueTypeFile;\r
+ PGD_QUERYFONTFILE QueryFontFile;\r
+ PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths;\r
+ PGD_SETPIXELFORMAT SetPixelFormat;\r
+ PGD_DESCRIBEPIXELFORMAT DescribePixelFormat;\r
+ PGD_SWAPBUFFERS SwapBuffers;\r
+ PGD_STARTBANDING StartBanding;\r
+ PGD_NEXTBAND NextBand;\r
+ PGD_GETDIRECTDRAWINFO GetDirectDrawInfo;\r
+ PGD_ENABLEDIRECTDRAW EnableDirectDraw;\r
+ PGD_DISABLEDIRECTDRAW DisableDirectDraw;\r
+ PGD_QUERYSPOOLTYPE QuerySpoolType;\r
+ PGD_GRADIENTFILL GradientFill;\r
+ PGD_SYNCHRONIZESURFACE SynchronizeSurface;\r
+ PGD_ALPHABLEND AlphaBlend;\r
+} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS;\r
+\r
+typedef struct _DC\r
+{\r
+ HGDIOBJ hHmgr; // Handle for this DC object.\r
+ PVOID pvEntry;\r
+ ULONG lucExcLock;\r
+ ULONG Tid;\r
+\r
+ DHPDEV PDev;\r
+ INT DC_Type;\r
+ INT DC_Flags;\r
+ PDC_ATTR pDc_Attr;\r
+ DC_ATTR Dc_Attr;\r
+\r
+ struct _EDD_DIRECTDRAW_GLOBAL * pEDDgpl;\r
+\r
+ HDC hSelf; // Used only for MemoryDC & SaveDC.\r
+ HDC hNext;\r
+ HSURF FillPatternSurfaces[HS_DDI_MAX];\r
+ PGDIINFO GDIInfo;\r
+ PDEVINFO DevInfo;\r
+ HDEV GDIDevice;\r
+\r
+ DRIVER_FUNCTIONS DriverFunctions;\r
+ UNICODE_STRING DriverName;\r
+ HANDLE DeviceDriver;\r
+\r
+ CLIPOBJ *CombinedClip;\r
+\r
+ XLATEOBJ *XlateBrush;\r
+ XLATEOBJ *XlatePen;\r
+\r
+ INT saveLevel;\r
+ BOOL IsIC;\r
+\r
+ HPALETTE PalIndexed;\r
+\r
+ WIN_DC_INFO w;\r
+\r
+ HANDLE hFile;\r
+ LPENHMETAHEADER emh;\r
+} DC, *PDC;\r
+\r
#endif\r
#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 */
#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 */
{
#include <winddi.h>
-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);
#ifndef __WIN32K_FLOAT_H
#define __WIN32K_FLOAT_H
+
+#include <reactos/win32k/ntgdityp.h>
+#include <reactos/win32k/ntgdihdl.h>
#include "dc.h"
#include "math.h"
#include <ft2build.h>
#include <ddrawint.h>
#include <ddkernel.h>
+#include <reactos/drivers/directx/directxint.h>
+#include <reactos/drivers/directx/dxg.h>
+#include <reactos/drivers/directx/dxeng.h>
+
+/* From ddraw.c */
+extern PDRVFN gpDxFuncs;
+
+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 *);
+
+
+/* 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; \
+ } \
+ } \
+ }
-typedef struct
-{
- /* for the driver */
- PDD_SURFACE_LOCAL lcllist[2];
-
- 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;
-
-
-} DD_DIRECTDRAW, *PDD_DIRECTDRAW;
-
-BOOL INTERNAL_CALL DD_Cleanup(PVOID pDD);
-BOOL INTERNAL_CALL DDSURF_Cleanup(PVOID pDDSurf);
#endif /* _INT_W32k_DDRAW */
--- /dev/null
+/*
+ * 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 <w32k.h>
+#include <debug.h>
+
+
+/*++
+* @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
+* <FILMEIN>
+*
+* @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
+* <FILMEIN>
+*
+* @param DD_SURFACE_LOCAL *puSurfaceLocalData
+* <FILMEIN>
+*
+* @param DD_SURFACE_MORE *puSurfaceMoreData
+* <FILMEIN>
+*
+* @param PDD_CREATESURFACEDATA puCreateSurfaceData
+* <FILMEIN>
+*
+* @param HANDLE *puhSurface
+* <FILMEIN>
+*
+* @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);
+
+}
+
+
+
+
* 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 <w32k.h>
-
-#define NDEBUG
#include <debug.h>
-#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;
-
- 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
- {
- 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;
- }
-
- /* 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;i<CreateSurfaceData.dwSCnt;i++)
- {
- myhSurface[i] = hSurface[i];
- }
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- if(!NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- return ddRVal;
- }
-
- /* Check if a surface has been created */
- for (i=0;i<CreateSurfaceData.dwSCnt;i++)
- {
- if (!myhSurface[i])
- {
- myhSurface[i] = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DD_SURFACE);
- if (!myhSurface[i])
- {
- /* FIXME: lock myhSurface*/
- /* FIXME: free myhSurface, and the contain */
- /* FIXME: add to attach list */
- return ddRVal;
- }
- else
- {
- /* FIXME: lock myhSurface*/
- /* FIXME: add to attach list */
- }
- }
- }
-
- /* FIXME: more than one surface is not supported here, once again */
- /* FIXME: we need release myhSurface before any exits */
-
- phsurface = GDIOBJ_LockObj(DdHandleTable, myhSurface[0], GDI_OBJECT_TYPE_DD_SURFACE);
- if (!phsurface)
- {
- return ddRVal;
- }
-
- DPRINT1("Copy puCreateSurfaceData to kmode CreateSurfaceData\n");
- _SEH_TRY
- {
- ProbeForRead(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1);
- RtlCopyMemory( &CreateSurfaceData, puCreateSurfaceData,
- sizeof( DD_CREATESURFACEDATA ) );
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- if(!NT_SUCCESS(Status))
- {
- GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface);
- SetLastNtError(Status);
- return ddRVal;
- }
-
- DPRINT1("Copy puSurfaceGlobalData to kmode phsurface->Global\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 */
-
- }
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurface, pfnDdCreateSurface);
- /* 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))
+ if (pfnDdCreateSurface == NULL)
{
- DPRINT1("0x%04x",pDirectDraw->DD.CreateSurface);
-
- ddRVal = pDirectDraw->DD.CreateSurface(&CreateSurfaceData);
+ DPRINT1("Warring no pfnDdCreateSurface");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,CreateSurfaceData.ddRVal);
+ DPRINT1("Calling on dxg.sys pfnDdCreateSurface");
+ return pfnDdCreateSurface(hDirectDrawLocal,hSurface,puSurfaceDescription,puSurfaceGlobalData,
+ puSurfaceLocalData,puSurfaceMoreData,puCreateSurfaceData,puhSurface);
+}
- /* 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;
+/************************************************************************/
+/* NtGdiDdWaitForVerticalBlank */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw,
+ PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
+{
+ PGD_DXDDWAITFORVERTICALBLANK pfnDdWaitForVerticalBlank = NULL;
+ INT i;
- _SEH_TRY
- {
- ProbeForWrite(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1);
- puCreateSurfaceData->ddRVal = CreateSurfaceData.ddRVal;
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdWaitForVerticalBlank, pfnDdWaitForVerticalBlank);
- for (i = 0; i < CreateSurfaceData.dwSCnt; i++)
+ if (pfnDdWaitForVerticalBlank == NULL)
{
- _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;
+ DPRINT1("Warring no pfnDdWaitForVerticalBlank");
+ return DDHAL_DRIVER_NOTHANDLED;
}
-
- /* 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 pfnDdWaitForVerticalBlank");
+ return pfnDdWaitForVerticalBlank(hDirectDraw, puWaitForVerticalBlankData);
}
/************************************************************************/
-/* NtGdiDdWaitForVerticalBlank */
-/* status : Works as intended */
+/* NtGdiDdCanCreateSurface */
/************************************************************************/
-
-
-DWORD STDCALL NtGdiDdWaitForVerticalBlank(
- HANDLE hDirectDrawLocal,
- PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
+DWORD
+STDCALL
+NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
+ PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- PDD_DIRECTDRAW pDirectDraw = NULL;
- NTSTATUS Status = FALSE;
- DD_WAITFORVERTICALBLANKDATA WaitForVerticalBlankData;
- LPDDHAL_WAITFORVERTICALBLANKDATA pWaitForVerticalBlankData = (LPDDHAL_WAITFORVERTICALBLANKDATA)puWaitForVerticalBlankData;
-
- if ((hDirectDrawLocal) &&
- (puWaitForVerticalBlankData))
- {
- 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);
+ PGD_DDCANCREATESURFACE pfnDdCanCreateSurface = NULL;
+ INT i;
- 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;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCanCreateSurface, pfnDdCanCreateSurface);
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- }
- }
+ if (pfnDdCanCreateSurface == NULL)
+ {
+ DPRINT1("Warring no pfnDdCanCreateSurface");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- return ddRVal;
-}
+ DPRINT1("Calling on dxg.sys DdCanCreateSurface");
+ return pfnDdCanCreateSurface(hDirectDrawLocal,puCanCreateSurfaceData);
+}
/************************************************************************/
-/* CanCreateSurface */
-/* status : Works as intended */
+/* NtGdiDdGetScanLine */
/************************************************************************/
-
-DWORD STDCALL NtGdiDdCanCreateSurface(
- HANDLE hDirectDrawLocal,
- PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
-)
+DWORD
+STDCALL
+NtGdiDdGetScanLine(HANDLE hDirectDrawLocal,
+ PDD_GETSCANLINEDATA puGetScanLineData)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
-
+ PGD_DXDDGETSCANLINE pfnDdGetScanLine = NULL;
+ INT i;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetScanLine, pfnDdGetScanLine);
- if ((puCanCreateSurfaceData) &&
- (hDirectDrawLocal))
+ if (pfnDdGetScanLine == 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);
+ DPRINT1("Warring no pfnDdGetScanLine");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- /*if it was DDSURFACEDESC2 been pass down */
- desc.dwSize = descSize;
- _SEH_TRY
- {
- ProbeForWrite(puCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1);
- puCanCreateSurfaceData->ddRVal = CanCreateSurfaceData.ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdGetScanLine");
+ return pfnDdGetScanLine(hDirectDrawLocal,puGetScanLineData);
+}
- ProbeForWrite(puCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1);
- RtlCopyMemory(puCanCreateSurfaceData->lpDDSurfaceDesc,&desc, sizeof(DDSURFACEDESC));
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- }
- }
- return ddRVal;
-}
+/************************************************************************/
+/* This is not part of the ddsurface interface but it have */
+/* deal with the surface */
+/************************************************************************/
/************************************************************************/
-/* GetScanLine */
-/* status : This func is now documented in MSDN, and now it's compatible*/
-/* with Windows 2000 implementation */
+/* NtGdiDdCreateSurfaceEx */
/************************************************************************/
-DWORD STDCALL
-NtGdiDdGetScanLine( HANDLE hDirectDrawLocal, PDD_GETSCANLINEDATA puGetScanLineData)
+DWORD
+STDCALL
+NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw,
+ HANDLE hSurface,
+ DWORD dwSurfaceHandle)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- DD_GETSCANLINEDATA GetScanLineData;
- PDD_DIRECTDRAW pDirectDraw = NULL;
- NTSTATUS Status = FALSE;
- LPDDHAL_GETSCANLINEDATA ourpuGetScanLineData;
+ PGD_DXDDCREATESURFACEEX pfnDdCreateSurfaceEx = NULL;
+ INT i;
- if (hDirectDrawLocal)
- {
- pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);;
- }
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurfaceEx, pfnDdCreateSurfaceEx);
- if (pDirectDraw != NULL)
+ if (pfnDdCreateSurfaceEx == 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);
+ DPRINT1("Warring no pfnDdCreateSurfaceEx");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdCreateSurfaceEx");
+ return pfnDdCreateSurfaceEx(hDirectDraw,hSurface,dwSurfaceHandle);
+
}
+
* 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 <w32k.h>
-
-//#define NDEBUG
#include <debug.h>
-/* 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;
- }
+ /* 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->Global.dhpdev == NULL)
- {
- return FALSE;
- }
- if (pDirectDraw->DrvDisableDirectDraw == NULL)
+ /* 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)
{
- return FALSE;
+ DPRINT1("Warring no dxg.sys in ReactOS");
+ Status = STATUS_DLL_NOT_FOUND;
}
-
- 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.
- */
- if (pDirectDraw->DrvGetDirectDrawInfo)
+ else
{
- success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev,
- &HalInfo,
- &pDirectDraw->dwNumHeaps,
- NULL,
- &pDirectDraw->dwNumFourCC,
- NULL);
- if (!success)
- {
- DPRINT1("DrvGetDirectDrawInfo frist call fail\n");
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return FALSE;
- }
-
+ /* import DxDdStartupDxGraphics and DxDdCleanupDxGraphics */
+ gpfnStartupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdStartupDxGraphics");
+ gpfnCleanupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdCleanupDxGraphics");
- /* 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)
+ if ((gpfnStartupDxGraphics) &&
+ (gpfnCleanupDxGraphics))
{
- DPRINT1("Setup pvmList\n");
- pDirectDraw->pvmList = (PVIDEOMEMORY) ExAllocatePoolWithTag(PagedPool, pDirectDraw->dwNumHeaps * sizeof(VIDEOMEMORY), TAG_DXPVMLIST);
- if (pDirectDraw->pvmList == NULL)
- {
- DPRINT1("pvmList memmery alloc fail\n");
- 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 pdwFourCC
- * but it is win32k responsible todo, Windows 9x it is gdi32.dll
- */
-
- if (pDirectDraw->dwNumFourCC != 0)
+ /* check if we manger loading the data and execute the dxStartupDxGraphics and it susscess */
+ if (!NT_SUCCESS(Status))
{
- 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;
- }
+ gpfnStartupDxGraphics = NULL;
+ gpfnCleanupDxGraphics = NULL;
+ EngUnloadImage( ghDxGraphics);
+ ghDxGraphics = NULL;
+ DPRINT1("Warring no init of DirectX graphic interface");
}
- success = pDirectDraw->DrvGetDirectDrawInfo( pDirectDraw->Global.dhpdev,
- &HalInfo,
- &pDirectDraw->dwNumHeaps,
- pDirectDraw->pvmList,
- &pDirectDraw->dwNumFourCC,
- pDirectDraw->pdwFourCC);
- if (!success)
+ else
{
- DPRINT1("DrvGetDirectDrawInfo second call fail\n");
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return FALSE;
- }
-
+ /* Sort the drv functions list in index order, this allown us doing, smaller optimze
+ * in api that are redirect to dx.sys
+ */
- /* 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
+ PDRVFN lstDrvFN = DxgDrv.pdrvfn;
+ INT t;
+ for (t=0;t<=DXG_INDEX_DxDdIoctl;t++)
{
- /* Unknown version found */
- DPRINT1(" Fail : did not get DD_HALINFO size \n");
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return FALSE;
+ gpDxFuncs[lstDrvFN[t].iFunc].iFunc =lstDrvFN[t].iFunc;
+ gpDxFuncs[lstDrvFN[t].iFunc].pfn =lstDrvFN[t].pfn;
}
+ DPRINT1("DirectX interface is Activated");
}
- /* 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);
+ return Status;
+}
- if (!success)
- {
- DPRINT1("EnableDirectDraw call fail\n");
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return FALSE;
- }
+/************************************************************************/
+/* DirectX graphic/video driver loading cleanup ends here */
+/************************************************************************/
- return TRUE;
-}
-/* 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)
- {
- return NULL;
- }
+ PGD_DDCREATEDIRECTDRAWOBJECT pfnDdCreateDirectDrawObject = NULL;
+ NTSTATUS Status;
+ PEPROCESS Proc = NULL;
+ INT i=0;
- /* Look the hdc to gain the internal struct */
- pDC = DC_LockDc(hdc);
- if (!pDC)
+ /* 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;
}
- /* test see if drv got a dx interface or not */
- if ( ( pDC->DriverFunctions.DisableDirectDraw == NULL) ||
- ( pDC->DriverFunctions.EnableDirectDraw == NULL))
- {
- DC_UnlockDc(pDC);
- return NULL;
- }
+ /* This is in correct place */
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateDirectDrawObject, pfnDdCreateDirectDrawObject);
- /* alloc and lock the stucrt */
- hDirectDraw = GDIOBJ_AllocObj(DdHandleTable, GDI_OBJECT_TYPE_DIRECTDRAW);
- if (!hDirectDraw)
+ if (pfnDdCreateDirectDrawObject == NULL)
{
- /* 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;
+ DPRINT1("Warring no pfnDdCreateDirectDrawObject");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- /* 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;
+ DPRINT1("Calling on dxg.sys DdCreateDirectDrawObject");
+ return pfnDdCreateDirectDrawObject(hdc);
- 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
-)
+/*++
+* @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)
{
- PDD_DIRECTDRAW pDirectDraw;
- NTSTATUS Status = FALSE;
- BOOL Ret=FALSE;
- LPD3DNTHAL_GLOBALDRIVERDATA pD3dDriverData;
-
- if (hDirectDrawLocal == NULL)
- {
- return FALSE;
- }
+ PGD_DXGENERICTRUNK pfnDxgGenericThunk = (PGD_DXGENERICTRUNK)gpDxFuncs[DXG_INDEX_DxDxgGenericThunk].pfn;
- 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
+ if (pfnDxgGenericThunk == NULL)
{
- 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;
+ DPRINT1("Warring no pfnDxgGenericThunk");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- /*
- * 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;
- }
+ DPRINT1("Calling on dxg.sys pfnDxgGenericThunk");
+ return pfnDxgGenericThunk(ulIndex, ulHandle, pdwSizeOfPtr1, pvPtr1, pdwSizeOfPtr2, pvPtr2);
+}
- /*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;
- }
+/************************************************************************/
+/* NtGdiDdGetDriverState */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdGetDriverState(PDD_GETDRIVERSTATEDATA pdata)
+{
+ PGD_DDGETDRIVERSTATE pfnDdGetDriverState = NULL;
+ INT i;
- /* Get puNumFourCC and dwNumFourCC */
- _SEH_TRY
- {
- ProbeForWrite(puNumFourCC, sizeof(DWORD), 1);
- *puNumFourCC = pDirectDraw->dwNumFourCC;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDriverState, pfnDdGetDriverState);
- if ((pDirectDraw->pdwFourCC) &&
- (puFourCC))
- {
- ProbeForWrite(puFourCC, sizeof(DWORD) * pDirectDraw->dwNumFourCC, 1);
- RtlCopyMemory( puFourCC, pDirectDraw->pdwFourCC, sizeof(DWORD) * pDirectDraw->dwNumFourCC);
- }
- }
- _SEH_HANDLE
+ if (pfnDdGetDriverState == NULL)
{
- Status = _SEH_GetExceptionCode();
+ DPRINT1("Warring no pfnDdGetDriverState");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- _SEH_END;
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- if(!NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- }
- else
- {
- Ret = TRUE;
- }
- return Ret;
+ DPRINT1("Calling on dxg.sys DdGetDriverState");
+ return pfnDdGetDriverState(pdata);
}
-
-BOOL STDCALL
-NtGdiDdDeleteDirectDrawObject( HANDLE hDirectDrawLocal)
+/************************************************************************/
+/* NtGdiDdColorControl */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdColorControl(HANDLE hSurface,
+ PDD_COLORCONTROLDATA puColorControlData)
{
- DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
- if (hDirectDrawLocal == NULL)
+ PGD_DDCOLORCONTROL pfnDdColorControl = NULL;
+ INT i;
+
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdColorControl, pfnDdColorControl);
+
+ if (pfnDdColorControl == NULL)
{
- return FALSE;
+ DPRINT1("Warring no pfnDdColorControl");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- return GDIOBJ_FreeObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("Calling on dxg.sys DdColorControl");
+ return pfnDdColorControl(hSurface,puColorControlData);
}
-
-BOOL STDCALL NtGdiDdReenableDirectDrawObject(
- HANDLE hDirectDrawLocal,
- BOOL *pubNewMode
+/************************************************************************/
+/* NtGdiDdCreateSurfaceObject */
+/************************************************************************/
+HANDLE
+STDCALL
+NtGdiDdCreateSurfaceObject(HANDLE hDirectDrawLocal,
+ HANDLE hSurface,
+ PDD_SURFACE_LOCAL puSurfaceLocal,
+ PDD_SURFACE_MORE puSurfaceMore,
+ PDD_SURFACE_GLOBAL puSurfaceGlobal,
+ BOOL bComplete
)
{
- BOOL Ret=FALSE;
- NTSTATUS Status = FALSE;
- PDD_DIRECTDRAW pDirectDraw;
+ PGD_DXDDCREATESURFACEOBJECT pfnDdCreateSurfaceObject = NULL;
+ INT i;
- if (hDirectDrawLocal == NULL)
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurfaceObject, pfnDdCreateSurfaceObject);
+
+ if (pfnDdCreateSurfaceObject == NULL)
{
- return Ret;
+ DPRINT1("Warring no pfnDdCreateSurfaceObject");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal,
- GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("Calling on dxg.sys pfnDdCreateSurfaceObject");
+ return pfnDdCreateSurfaceObject(hDirectDrawLocal, hSurface, puSurfaceLocal, puSurfaceMore, puSurfaceGlobal, bComplete);
+}
- if (!pDirectDraw)
- {
- return Ret;
- }
+/************************************************************************/
+/* NtGdiDdDeleteDirectDrawObject */
+/************************************************************************/
+BOOL
+STDCALL
+NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal)
+{
+ PGD_DXDDDELETEDIRECTDRAWOBJECT pfnDdDeleteDirectDrawObject = NULL;
+ INT i;
- /*
- * 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);
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDeleteDirectDrawObject, pfnDdDeleteDirectDrawObject);
- _SEH_TRY
- {
- ProbeForWrite(pubNewMode, sizeof(BOOL), 1);
- *pubNewMode = Ret;
- }
- _SEH_HANDLE
- {
- Status = _SEH_GetExceptionCode();
- }
- _SEH_END;
- if(!NT_SUCCESS(Status))
+ if (pfnDdDeleteDirectDrawObject == NULL)
{
- SetLastNtError(Status);
- return Ret;
+ DPRINT1("Warring no pfnDdDeleteDirectDrawObject");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
-
- return Ret;
-
+ DPRINT1("Calling on dxg.sys pfnDdDeleteDirectDrawObject");
+ return pfnDdDeleteDirectDrawObject(hDirectDrawLocal);
}
-
-
-DWORD STDCALL NtGdiDdGetDriverInfo(
- HANDLE hDirectDrawLocal,
- PDD_GETDRIVERINFODATA puGetDriverInfoData)
-
+/************************************************************************/
+/* NtGdiDdDeleteSurfaceObject */
+/************************************************************************/
+BOOL
+STDCALL
+NtGdiDdDeleteSurfaceObject(HANDLE hSurface)
{
- DWORD ddRVal = 0;
- PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal,
- GDI_OBJECT_TYPE_DIRECTDRAW);
+ PGD_DXDDDELETESURFACEOBJECT pfnDdDeleteSurfaceObject = NULL;
+ INT i;
- DPRINT1("NtGdiDdGetDriverInfo\n");
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDeleteSurfaceObject, pfnDdDeleteSurfaceObject);
- if (pDirectDraw == NULL)
+ if (pfnDdDeleteSurfaceObject == NULL)
{
+ DPRINT1("Warring no pfnDdDeleteSurfaceObject");
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 DdDeleteSurfaceObject");
+ return pfnDdDeleteSurfaceObject(hSurface);
+}
- if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFO2))
- ddRVal++;
+/************************************************************************/
+/* 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)
+{
+ PGD_DXDDQUERYDIRECTDRAWOBJECT pfnDdQueryDirectDrawObject = NULL;
+ INT i;
- /* Now we are doing the call to drv DrvGetDriverInfo */
- if (ddRVal == 2)
- {
- DPRINT1("NtGdiDdGetDriverInfo DDHAL_DRIVER_NOTHANDLED");
- ddRVal = DDHAL_DRIVER_NOTHANDLED;
- }
- else
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdQueryDirectDrawObject, pfnDdQueryDirectDrawObject);
+
+ if (pfnDdQueryDirectDrawObject == NULL)
{
- ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
+ DPRINT1("Warring no pfnDdQueryDirectDrawObject");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- 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);
}
-
-
-DWORD STDCALL NtGdiDdUnlock(
- HANDLE hSurface,
- PDD_UNLOCKDATA puUnlockData
-)
+/************************************************************************/
+/* NtGdiDdReenableDirectDrawObject */
+/************************************************************************/
+BOOL
+STDCALL
+NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal,
+ BOOL *pubNewMode)
{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
+ PGD_DXDDREENABLEDIRECTDRAWOBJECT pfnDdReenableDirectDrawObject = 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_DxDdReenableDirectDrawObject, pfnDdReenableDirectDrawObject);
- /* backup the orignal PDev and info */
- lgpl = puUnlockData->lpDD;
-
- /* 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;
+ if (pfnDdReenableDirectDrawObject == NULL)
+ {
+ DPRINT1("Warring no pfnDdReenableDirectDrawObject");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdReenableDirectDrawObject");
+ return pfnDdReenableDirectDrawObject(hDirectDrawLocal, pubNewMode);
}
+/************************************************************************/
+/* NtGdiDdGetDriverInfo */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdGetDriverInfo(HANDLE hDirectDrawLocal,
+ PDD_GETDRIVERINFODATA puGetDriverInfoData)
-DWORD STDCALL NtGdiDdSetColorKey(
- HANDLE hSurface,
- PDD_SETCOLORKEYDATA puSetColorKeyData
-)
{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
+ PGD_DXDDGETDRIVERINFO pfnDdGetDriverInfo = 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_DxDdGetDriverInfo, pfnDdGetDriverInfo);
- /* backup the orignal PDev and info */
- lgpl = puSetColorKeyData->lpDD;
-
- /* 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;
+ if (pfnDdGetDriverInfo == NULL)
+ {
+ DPRINT1("Warring no pfnDdGetDriverInfo");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdGetDriverInfo");
+ return pfnDdGetDriverInfo(hDirectDrawLocal, puGetDriverInfoData);
}
-DWORD STDCALL NtGdiDdAddAttachedSurface(
- HANDLE hSurface,
- HANDLE hSurfaceAttached,
- PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
-)
+/************************************************************************/
+/* NtGdiDdGetAvailDriverMemory */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdGetAvailDriverMemory(HANDLE hDirectDrawLocal,
+ PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData)
{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
-
- 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;
+ PGD_DXDDGETAVAILDRIVERMEMORY pfnDdGetAvailDriverMemory = NULL;
+ INT i;
- /* backup the orignal PDev and info */
- lgpl = puAddAttachedSurfaceData->lpDD;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetAvailDriverMemory, pfnDdGetAvailDriverMemory);
- /* 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;
+ if (pfnDdGetAvailDriverMemory == NULL)
+ {
+ DPRINT1("Warring no pfnDdGetAvailDriverMemory");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdGetAvailDriverMemory");
+ return pfnDdGetAvailDriverMemory(hDirectDrawLocal, puGetAvailDriverMemoryData);
}
-DWORD STDCALL NtGdiDdGetBltStatus(
- HANDLE hSurface,
- PDD_GETBLTSTATUSDATA puGetBltStatusData
-)
-{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
- 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;
+/************************************************************************/
+/* NtGdiDdSetExclusiveMode */
+/************************************************************************/
- /* backup the orignal PDev and info */
- lgpl = puGetBltStatusData->lpDD;
+DWORD
+STDCALL
+NtGdiDdSetExclusiveMode(HANDLE hDirectDraw,
+ PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData)
+{
+ PGD_DXDDSETEXCLUSIVEMODE pfnDdSetExclusiveMode = NULL;
+ INT i;
- /* use our cache version instead */
- puGetBltStatusData->lpDD = &pDirectDraw->Global;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetExclusiveMode, pfnDdSetExclusiveMode);
- /* make the call */
- if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
- ddRVal = DDHAL_DRIVER_NOTHANDLED;
- else
- ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
+ if (pfnDdSetExclusiveMode == NULL)
+ {
+ DPRINT1("Warring no pfnDdSetExclusiveMode");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- /* But back the orignal PDev */
- puGetBltStatusData->lpDD = lgpl;
+ DPRINT1("Calling on dxg.sys pfnDdSetExclusiveMode");
+ return pfnDdSetExclusiveMode(hDirectDraw, puSetExclusiveModeData);
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
}
-DWORD STDCALL NtGdiDdGetFlipStatus(
- HANDLE hSurface,
- PDD_GETFLIPSTATUSDATA puGetFlipStatusData
-)
-{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
-
- 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;
- /* backup the orignal PDev and info */
- lgpl = puGetFlipStatusData->lpDD;
+/************************************************************************/
+/* NtGdiDdFlipToGDISurface */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdFlipToGDISurface(HANDLE hDirectDraw,
+ PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData)
+{
+ PGD_DXDDFLIPTOGDISURFACE pfnDdFlipToGDISurface = NULL;
+ INT i;
- /* use our cache version instead */
- puGetFlipStatusData->lpDD = &pDirectDraw->Global;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFlipToGDISurface, pfnDdFlipToGDISurface);
- /* make the call */
- if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
- ddRVal = DDHAL_DRIVER_NOTHANDLED;
- else
- ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
+ if (pfnDdFlipToGDISurface == NULL)
+ {
+ DPRINT1("Warring no pfnDdFlipToGDISurface");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- /* But back the orignal PDev */
- puGetFlipStatusData->lpDD = lgpl;
+ DPRINT1("Calling on dxg.sys pfnDdFlipToGDISurface");
+ return pfnDdFlipToGDISurface(hDirectDraw, puFlipToGDISurfaceData);
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
}
-DWORD STDCALL NtGdiDdUpdateOverlay(
- HANDLE hSurfaceDestination,
- HANDLE hSurfaceSource,
- PDD_UPDATEOVERLAYDATA puUpdateOverlayData
-)
+/************************************************************************/
+/* NtGdiDdGetDC */
+/************************************************************************/
+HDC
+STDCALL
+NtGdiDdGetDC(HANDLE hSurface,
+ PALETTEENTRY *puColorTable)
{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
-
- 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;
-
- /* backup the orignal PDev and info */
- lgpl = puUpdateOverlayData->lpDD;
-
- /* use our cache version instead */
- puUpdateOverlayData->lpDD = &pDirectDraw->Global;
+ PGD_DDGETDC pfnDdGetDC = NULL;
+ INT i;
- /* make the call */
- if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
- ddRVal = DDHAL_DRIVER_NOTHANDLED;
- else
- ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDC, pfnDdGetDC);
- /* But back the orignal PDev */
- puUpdateOverlayData->lpDD = lgpl;
+ if (pfnDdGetDC == NULL)
+ {
+ DPRINT1("Warring no pfnDdGetDC");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdGetDC");
+ return pfnDdGetDC(hSurface, puColorTable);
}
-DWORD STDCALL NtGdiDdSetOverlayPosition(
- HANDLE hSurfaceSource,
- HANDLE hSurfaceDestination,
- PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
-)
+/************************************************************************/
+/* NtGdiDdGetDxHandle */
+/************************************************************************/
+HANDLE
+STDCALL
+NtGdiDdGetDxHandle(HANDLE hDirectDraw,
+ HANDLE hSurface,
+ BOOL bRelease)
{
- 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;
+
+ PGD_DDGETDXHANDLE pfnDdGetDxHandle = NULL;
+ INT i;
- /* use our cache version instead */
- puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetDxHandle, pfnDdGetDxHandle);
- /* 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;
+ if (pfnDdGetDxHandle == NULL)
+ {
+ DPRINT1("Warring no pfnDdGetDxHandle");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdGetDxHandle");
+ return pfnDdGetDxHandle(hDirectDraw, hSurface, bRelease);
}
/************************************************************************/
-/* SURFACE OBJECT */
+/* NtGdiDdReleaseDC */
/************************************************************************/
-
-BOOL INTERNAL_CALL
-DDSURF_Cleanup(PVOID pDDSurf)
+BOOL
+STDCALL
+NtGdiDdReleaseDC(HANDLE hSurface)
{
- /* FIXME: implement
- * PDD_SURFACE pDDSurf = PVOID pDDSurf
- */
-#ifdef DX_DEBUG
- DPRINT1("DDSURF_Cleanup\n");
-#endif
- return TRUE;
-}
+ PGD_DDRELEASEDC pfnDdReleaseDC = NULL;
+ INT i;
-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;
-}
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdReleaseDC, pfnDdReleaseDC);
-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);
+ if (pfnDdReleaseDC == NULL)
+ {
+ DPRINT1("Warring no pfnDdReleaseDC");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
+ DPRINT1("Calling on dxg.sys pfnDdReleaseDC");
+ return pfnDdReleaseDC(hSurface);
}
-
-
/************************************************************************/
-/* DIRECT DRAW SURFACR END */
+/* NtGdiDdResetVisrgn */
/************************************************************************/
-
-
-/*
-BOOL STDCALL NtGdiDdAttachSurface(
- HANDLE hSurfaceFrom,
- HANDLE hSurfaceTo
-)
-{
- 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;
- }
-
- if (pSurfaceFrom->Local.lpAttachListFrom)
- {
- pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
- }
-
- GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
- GDIOBJ_UnlockObjByPtr(pSurfaceTo);
- return TRUE;
-}
-*/
-
-DWORD STDCALL NtGdiDdGetAvailDriverMemory(
- HANDLE hDirectDrawLocal,
- PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
-)
+BOOL
+STDCALL
+NtGdiDdResetVisrgn(HANDLE hSurface,
+ HWND hwnd)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- PDD_DIRECTDRAW_GLOBAL lgpl;
-
- 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);
+ PGD_DDRESTVISRGN pfnDdResetVisrgn = NULL;
+ INT i;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdResetVisrgn, pfnDdResetVisrgn);
- /* But back the orignal PDev */
- puGetAvailDriverMemoryData->lpDD = lgpl;
+ if (pfnDdResetVisrgn == NULL)
+ {
+ DPRINT1("Warring no pfnDdResetVisrgn");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdResetVisrgn");
+ return pfnDdResetVisrgn(hSurface, hwnd);
}
-
-
-
-DWORD STDCALL NtGdiDdSetExclusiveMode(
- HANDLE hDirectDraw,
- PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
-)
+/************************************************************************/
+/* NtGdiDdSetGammaRamp */
+/************************************************************************/
+BOOL
+STDCALL
+NtGdiDdSetGammaRamp(HANDLE hDirectDraw,
+ HDC hdc,
+ LPVOID lpGammaRamp)
{
- DWORD ddRVal;
- PDD_DIRECTDRAW_GLOBAL lgpl;
-
- PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
-
-#ifdef DX_DEBUG
- DPRINT1("NtGdiDdSetExclusiveMode\n");
-#endif
-
- /* backup the orignal PDev and info */
- lgpl = puSetExclusiveModeData->lpDD;
-
- /* use our cache version instead */
- puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
+ PGD_DDSETGAMMARAMP pfnDdSetGammaRamp = NULL;
+ INT i;
- /* make the call */
- ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetGammaRamp, pfnDdSetGammaRamp);
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
-
- /* But back the orignal PDev */
- puSetExclusiveModeData->lpDD = lgpl;
+ if (pfnDdSetGammaRamp == NULL)
+ {
+ DPRINT1("Warring no pfnDdSetGammaRamp");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdSetGammaRamp");
+ return pfnDdSetGammaRamp(hDirectDraw, hdc, lpGammaRamp);
}
*/
#include <w32k.h>
-
-#define NDEBUG
#include <debug.h>
-#define DdHandleTable GdiHandleTable
+/************************************************************************/
+/* NtGdiDdDestroySurface */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy)
+{
+ PGD_DXDDDESTROYSURFACE pfnDdDestroySurface = NULL;
+ INT i;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDestroySurface, pfnDdDestroySurface);
+ if (pfnDdDestroySurface == NULL)
+ {
+ DPRINT1("Warring no pfnDdDestroySurface");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
-DWORD STDCALL NtGdiDdBlt(
- HANDLE hSurfaceDest,
- HANDLE hSurfaceSrc,
- PDD_BLTDATA puBltData
-)
+ 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)
{
- NTSTATUS Status = FALSE;
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- DD_BLTDATA Blt;
- PDD_SURFACE pDstSurface = NULL;
- PDD_SURFACE pSrcSurface = NULL;
- PDD_DIRECTDRAW pDirectDraw;
+ PGD_DXDDFLIP pfnDdDdFlip = NULL;
+ INT i;
- DPRINT1("NtGdiDdBlt\n");
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFlip, pfnDdDdFlip);
- _SEH_TRY
- {
- ProbeForRead(puBltData, sizeof(DD_BLTDATA), 1);
- RtlCopyMemory( &Blt, puBltData, sizeof( DD_BLTDATA ) );
- }
- _SEH_HANDLE
+ if (pfnDdDdFlip == NULL)
{
- Status = _SEH_GetExceptionCode();
+ DPRINT1("Warring no pfnDdDdFlip");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- _SEH_END;
- if(!NT_SUCCESS(Status))
+
+ 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)
{
- SetLastNtError(Status);
- return ddRVal;
+ DPRINT1("Warring no pfnDdLock");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- pDstSurface = GDIOBJ_LockObj(DdHandleTable, hSurfaceDest, GDI_OBJECT_TYPE_DD_SURFACE);
- if (!pDstSurface)
+ 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("Fail\n");
- return ddRVal;
+ DPRINT1("Warring no pfnDdUnlock");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pDstSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
- if (!pDirectDraw)
+ 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("Fail\n");
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface);
- return ddRVal;
+ DPRINT1("Warring no pfnDdBlt");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- if (pSrcSurface)
+ 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)
{
- 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;
- }
+ DPRINT1("Warring no pfnDdSetColorKey");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- Blt.lpDDDestSurface = &pDstSurface->Local;
- if (pDstSurface)
+ 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)
{
- Blt.lpDDSrcSurface = &pDstSurface->Local;
+ DPRINT1("Warring no pfnDdAddAttachedSurface");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- Blt.ddRVal = DDERR_GENERIC;
+ DPRINT1("Calling on dxg.sys DdAddAttachedSurface");
+ return pfnDdAddAttachedSurface(hSurface,hSurfaceAttached,puAddAttachedSurfaceData);
+}
- /* MSDN say this member is always set to FALSE in windows 2000 or higher */
- Blt.IsClipped = FALSE;
+/************************************************************************/
+/* NtGdiDdGetBltStatus */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdGetBltStatus(HANDLE hSurface,
+ PDD_GETBLTSTATUSDATA puGetBltStatusData)
+{
+ PGD_DXDDGETBLTSTATUS pfnDdGetBltStatus = NULL;
+ INT i;
- /* MSDN say this member is always unuse in windows 2000 or higher */
- Blt.dwROPFlags = 0;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetBltStatus, pfnDdGetBltStatus);
- if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT)
+ if (pfnDdGetBltStatus == NULL)
{
- Blt.lpDD = &pDirectDraw->Global;
- Blt.Blt = NULL;
- ddRVal = pDirectDraw->Surf.Blt(&Blt);
+ DPRINT1("Warring no pfnDdGetBltStatus");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal);
+ DPRINT1("Calling on dxg.sys pfnDdGetBltStatus");
+ return pfnDdGetBltStatus(hSurface,puGetBltStatusData);
+}
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDstSurface);
+/************************************************************************/
+/* NtGdiDdGetFlipStatus */
+/************************************************************************/
+DWORD
+STDCALL
+NtGdiDdGetFlipStatus(HANDLE hSurface,
+ PDD_GETFLIPSTATUSDATA puGetFlipStatusData)
+{
+ PGD_DXDDGETFLIPSTATUS pfnDdGetFlipStatus = NULL;
+ INT i;
+
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetFlipStatus, pfnDdGetFlipStatus);
- if(pSrcSurface)
+ if (pfnDdGetFlipStatus == NULL)
{
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface);
+ DPRINT1("Warring no pfnDdGetFlipStatus");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- _SEH_TRY
+ 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)
{
- ProbeForWrite(puBltData, sizeof(DD_BLTDATA), 1);
- puBltData->ddRVal = Blt.ddRVal;
+ DPRINT1("Warring no pfnDdUpdateOverlay");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- _SEH_HANDLE
+
+ 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)
{
- Status = _SEH_GetExceptionCode();
+ DPRINT1("Warring no pfnDdSetOverlayPosition");
+ return DDHAL_DRIVER_NOTHANDLED;
}
- _SEH_END;
- DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal);
- return ddRVal;
- }
+ 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 */
+/************************************************************************/
/************************************************************************/
-/* NtGdiDdCreateSurface */
-/* status : untested */
+/* NtGdiDdAlphaBlt */
/************************************************************************/
-DWORD STDCALL NtGdiDdDestroySurface(
- HANDLE hSurface,
- BOOL bRealDestroy
-)
+DWORD
+STDCALL
+NtGdiDdAlphaBlt(HANDLE hSurfaceDest,
+ HANDLE hSurfaceSrc,
+ PDD_BLTDATA puBltData)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- PDD_SURFACE pSurface;
- PDD_DIRECTDRAW pDirectDraw;
- DD_DESTROYSURFACEDATA DestroySurf;
-
- DPRINT1("NtGdiDdDestroySurface\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)
- {
- if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE)
- {
- //DestroySurf.lpDD = pSurface->Global;
- DestroySurf.lpDDSurface = hSurface;
-
- /* 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;
-}
+ PGD_DDALPHABLT pfnDdAlphaBlt = NULL;
+ INT i;
+ 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);
+}
/************************************************************************/
-/* NtGdiDdFlip */
-/* status : untested */
+/* NtGdiDdAttachSurface */
/************************************************************************/
-
-DWORD STDCALL NtGdiDdFlip(
- HANDLE hSurfaceCurrent,
- HANDLE hSurfaceTarget,
- HANDLE hSurfaceCurrentLeft,
- HANDLE hSurfaceTargetLeft,
- PDD_FLIPDATA puFlipData
+BOOL
+STDCALL
+NtGdiDdAttachSurface(HANDLE hSurfaceFrom,
+ HANDLE hSurfaceTo
)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- PDD_SURFACE pSurface;
- PDD_DIRECTDRAW pDirectDraw;
- DPRINT1("NtGdiDdFlip\n");
-
- /* 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);
-
- if (pDirectDraw != NULL)
- {
- if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP)
- {
- /* FIXME is lpDD typecasted tp driver PEV ?? */
- ddRVal = pDirectDraw->Surf.Flip(puFlipData);
- }
-
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
- }
-
- GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface);
- }
-
- return ddRVal;
-}
+ PGD_DDATTACHSURFACE pfnDdAttachSurface = NULL;
+ INT i;
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAttachSurface, pfnDdAttachSurface);
+ if (pfnDdAttachSurface == NULL)
+ {
+ DPRINT1("Warring no pfnDdAttachSurface");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
+ DPRINT1("Calling on dxg.sys pfnDdAttachSurface");
+ return pfnDdAttachSurface(hSurfaceFrom,hSurfaceTo);
+}
/************************************************************************/
-/* NtGdiDdLock */
-/* status : untested */
+/* NtGdiDdUnattachSurface */
/************************************************************************/
-
-DWORD STDCALL NtGdiDdLock(
- HANDLE hSurface,
- PDD_LOCKDATA puLockData,
- HDC hdcClip)
+/* 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)
{
- DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
- PDD_SURFACE pSurface;
- PDD_DIRECTDRAW pDirectDraw;
-
- DPRINT1("NtGdiDdLock\n");
+ PGD_DXDDUNATTACHSURFACE pfnDdUnattachSurface = NULL;
+ INT i;
- pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
- if (pSurface != NULL)
- {
- pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnattachSurface, pfnDdUnattachSurface);
- 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);
- }
+ if (pfnDdUnattachSurface == NULL)
+ {
+ DPRINT1("Warring no pfnDdUnattachSurface");
+ return DDHAL_DRIVER_NOTHANDLED;
+ }
- return ddRVal;
+ DPRINT1("Calling on dxg.sys pfnDdUnattachSurface");
+ return pfnDdUnattachSurface(hSurface,hSurfaceAttached);
}
-/*
-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;
-*/
--- /dev/null
+
+/*
+ * 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 <w32k.h>
+#include <debug.h>
+
+/************************************************************************/
+/* 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);
+
+}
+
--- /dev/null
+/*
+ * 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 <w32k.h>
+#include <debug.h>
+
+
+
+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;
+}
+
+
--- /dev/null
+
+
+/*
+ * 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 <w32k.h>
+#include <debug.h>
+
+/************************************************************************/
+/* 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);
+}
+
--- /dev/null
+/*
+ * 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 <w32k.h>
+#include <debug.h>
+
+/************************************************************************/
+/* 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);
+}
+
+
+
+++ /dev/null
-/*
- * 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 <w32k.h>
-
-#define NDEBUG
-#include <debug.h>
-
-
-
-
-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 */
{
{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 */
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
return NULL;
}
-/*
- * @unimplemented
- */
-PVOID STDCALL
-EngAllocPrivateUserMem(
- IN PDD_SURFACE_LOCAL psl,
- IN SIZE_T cj,
- IN ULONG tag)
-{
- UNIMPLEMENTED;
- return NULL;
-}
-
/*
* @unimplemented
*/
return FALSE;
}
-/*
- * @unimplemented
- */
-VOID STDCALL
-EngFreePrivateUserMem(
- IN PDD_SURFACE_LOCAL psl,
- IN PVOID pv)
-{
- UNIMPLEMENTED;
-}
+
/*
* @unimplemented
return EHN_ERROR;
}
-/*
- * @unimplemented
- */
-PDD_SURFACE_LOCAL STDCALL
-EngLockDirectDrawSurface(
- IN HANDLE Surface)
-{
- UNIMPLEMENTED;
- return NULL;
-}
+
/*
* @unimplemented
return FALSE;
}
-/*
- * @unimplemented
- */
-BOOL STDCALL
-EngUnlockDirectDrawSurface(
- IN PDD_SURFACE_LOCAL Surface)
-{
- UNIMPLEMENTED;
- return FALSE;
-}
/*
* @unimplemented
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
*/
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
*/
return 0;
}
- /*
- * @unimplemented
- */
- DWORD
-STDCALL
-NtGdiDvpGetVideoPortField(
- IN HANDLE hVideoPort,
- IN OUT PDD_GETVPORTFIELDDATA puGetVPortFieldData)
-{
- UNIMPLEMENTED;
- return 0;
-}
-
/*
* @unimplemented
+; $Id$
+;
; win32k.def
;
; ReactOS win32k.sys
EngAlphaBlend@28
EngAcquireSemaphore@4
EngAllocMem@12
-EngAllocPrivateUserMem@12
EngAllocUserMem@8
EngAssociateSurface@12
EngBitBlt@44
EngFindResource@16
EngFreeMem@4
EngFreeModule@4
-EngFreePrivateUserMem@8
EngFreeUserMem@4
EngGetCurrentCodePage@8=ntoskrnl.RtlGetCurrentCodePage
EngGetCurrentProcessId@0
FONTOBJ_pvTrueTypeFontFile@8
FONTOBJ_pxoGetXform@4
FONTOBJ_vGetInfo@12
-HeapVidMemAllocAligned@20
HT_ComputeRGBGammaTable@24
HT_Get8BPPFormatPalette@16
PALOBJ_cGetColors@16
STROBJ_bEnum@12
STROBJ_dwGetCodePage@4
STROBJ_vEnumStart@4
-VidMemFree@8
Win32kInitialize@0
WNDOBJ_bEnum@12
WNDOBJ_cEnumStart@16
_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
<file>ddraw.c</file>
<file>dd.c</file>
<file>ddsurf.c</file>
- <file>stubs.c</file>
+ <file>d3d.c</file>
+ <file>dvp.c</file>
+ <file>mocomp.c</file>
+ <file>eng.c</file>
+ <file>dxeng.c</file>
</directory>
<directory name="ntuser">
<file>accelerator.c</file>
projects / reactos.git / commitdiff