Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-03 15:26:02 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge from branch ReactX to Trunk,

Browse source 
Please make a clean build after this update

Add dxg.sys driver 
----------------------------------------------------------------
This driver contains all DirectX graphic APIs called by win32k. Most of them
are stubbed, and the following APIs are implemented:
DxDxgGenericThunk, DxDdIoctl, DriverEntry, DxDdStartupDxGraphics, DxDdCleanupDxGraphics

Add dxgthk.sys driver, which is 100% finished
---------------------------------------------------------
The following APIs are implemented (almost all are forwarders):
DriverEntry, EngAcquireSemaphore, EngAllocMem, EngAllocUserMem,
EngCopyBits, EngCreateBitmap, EngCreatePalette, EngCreateSemaphore,
EngDeletePalette, EngDeleteSemaphore, EngDeleteSurface,
EngFindImageProcAddress, EngFreeMem, EngFreeUserMem,
EngLoadImage, EngLockSurface, EngReleaseSemaphore,
EngSetLastError, EngUnloadImage, EngUnlockSurface

Add dxapi.sys driver
--------------------------------------------------------------
Most of the APIs used by the graphic card's driver or win32k are stubs.
The following APIs are implemented:
DriverEntry, GsDriverEntry, DxApiGetVersion, DxApi.
All APIs which DxApi wraps are stubs.
 
Changes in win32k
-------------------------------------------------------------------
Move _DC struct to include\reactos\win32k\ntgdihdl.h
--------------------------------------------------------------------------
Implement NtGdiDdCanCreateD3DBuffer, NtGdiD3dContextDestroy,
NtGdiD3dContextDestroyAll, NtGdiDdCreateD3DBuffer, NtGdiDdDestroyD3DBuffer,
NtGdiD3dDrawPrimitives2, NtGdiDdLockD3D, NtGdiD3dValidateTextureStageState, 
NtGdiDdUnlockD3D, NtGdiDdCreateSurface, NtGdiDdWaitForVerticalBlank, 
NtGdiDdCanCreateSurface, NtGdiDdGetScanLine, NtGdiDdCreateSurfaceEx,
DxDdStartupDxGraphics, NtGdiDdCreateDirectDrawObject, NtGdiDxgGenericThunk,
NtGdiDdGetDriverState, NtGdiDdColorControl, NtGdiDdCreateSurfaceObject,
NtGdiDdCreateSurfaceObject, NtGdiDdDeleteDirectDrawObject, NtGdiDdDeleteSurfaceObject,
NtGdiDdQueryDirectDrawObject, NtGdiDdReenableDirectDrawObject, NtGdiDdGetDriverInfo,
NtGdiDdGetAvailDriverMemory, NtGdiDdSetExclusiveMode, NtGdiDdFlipToGDISurface,
NtGdiDdGetDC, NtGdiDdGetDxHandle, NtGdiDdReleaseDC, NtGdiDdResetVisrgn,
NtGdiDdSetGammaRamp, NtGdiDdDestroySurface, NtGdiDdFlip, NtGdiDdLock, NtGdiDdUnlock,
NtGdiDdBlt, NtGdiDdSetColorKey, NtGdiDdAddAttachedSurface, NtGdiDdGetBltStatus,
NtGdiDdGetFlipStatus, NtGdiDdUpdateOverlay, NtGdiDdSetOverlayPosition,
NtGdiDdAlphaBlt, NtGdiDdAttachSurface, NtGdiDdUnattachSurface,
NtGdiDvpCanCreateVideoPort, NtGdiDvpColorControl, NtGdiDvpCreateVideoPort,
NtGdiDvpDestroyVideoPort, NtGdiDvpFlipVideoPort, NtGdiDvpGetVideoPortBandwidth,
NtGdiDvpGetVideoPortFlipStatus, NtGdiDvpGetVideoPortInputFormats, 
NtGdiDvpGetVideoPortLine, NtGdiDvpGetVideoPortOutputFormats, 
NtGdiDvpGetVideoPortConnectInfo, NtGdiDvpGetVideoSignalStatus,
NtGdiDvpUpdateVideoPort, NtGdiDvpWaitForVideoPortSync,
NtGdiDvpAcquireNotification, NtGdiDvpReleaseNotification,
NtGdiDvpGetVideoPortField, NtGdiDdBeginMoCompFrame,
NtGdiDdCreateMoComp, NtGdiDdDestroyMoComp,
NtGdiDdEndMoCompFrame, NtGdiDdGetInternalMoCompInfo,
NtGdiDdGetMoCompBuffInfo, NtGdiDdGetMoCompFormats,
NtGdiDdGetMoCompGuids, NtGdiDdQueryMoCompStatus,
NtGdiDdRenderMoComp, HeapVidMemAllocAligned,
VidMemFree, EngAllocPrivateUserMem, EngFreePrivateUserMem,
EngLockDirectDrawSurface, EngUnlockDirectDrawSurface

But all those functions are stubbed in dxg.sys
----------------------------------------------------------------------------
Implemented APIsL

DxEngLockDC, DxEngUnlockDC, DxEngGetDCState, EngDxIoctl
----------------------------------------------------------------------------
Stubbed APIs:

DxEngNUIsTermSrv, DxEngRedrawDesktop, DxEngDispUniq, DxEngVisRgnUniq,
DxEngEnumerateHdev, DxEngGetDeviceGammaRamp, DxEngCreateMemoryDC,
DxEngScreenAccessCheck, DxEngLockShareSem, DxEngUnlockShareSem,
DxEngLockHdev, DxEngUnlockHdev, DxEngReferenceHdev,
DxEngIsHdevLockedByCurrentThread, DxEngUnreferenceHdev, 
DxEngSetDeviceGammaRamp, DxEngSpTearDownSprites, 
DxEngSpUnTearDownSprites, DxEngSpSpritesVisible,
DxEngGetHdevData, DxEngSetHdevData, DxEngGetDesktopDC,
DxEngDeleteDC, DxEngCleanDC, DxEngSetDCOwner,
DxEngSetDCState, DxEngSelectBitmap,DxEngSetBitmapOwner, 
DxEngDeleteSurface, DxEngGetSurfaceData, DxEngAltLockSurface,
DxEngUploadPaletteEntryToSurface, DxEngMarkSurfaceAsDirectDraw, 
DxEngSelectPaletteToSurface, DxEngSyncPaletteTableWithDevice,
DxEngSetPaletteState, DxEngGetRedirectionBitmap, DxEngLoadImage, 
DxEngIncDispUniq

----------------------------------------------------------------------------
Remember we need the DxEng APIs implemented and HeapVidMemAllocAligned,
VidMemFree, EngAllocPrivateUserMem, EngFreePrivateUserMem,
EngLockDirectDrawSurface, EngUnlockDirectDrawSurface implemented
before it's possible to have full DirectX support at kmode.

svn path=/trunk/; revision=30328
This commit is contained in:
Magnus Olsen 2007-11-10 15:31:49 +00:00
commit 759c0dde2a
45 changed files with 4777 additions and 2930 deletions
Download patch file Download diff file Expand all files Collapse all files

4
reactos/boot/bootdata/packages/reactos.dff
View file

@ -271,6 +271,10 @@ drivers\bus\acpi\acpi.sys 2
drivers\bus\isapnp\isapnp.sys 2
drivers\bus\pci\pci.sys 2
\drivers\directx\dxapi\dxapi.sys 2
drivers\directx\dxeng\dxeng.sys 2
drivers\directx\dxg\dxg.sys 2
drivers\filesystems\fs_rec\fs_rec.sys 2
drivers\filesystems\msfs\msfs.sys 2
drivers\filesystems\mup\mup.sys 2

13
reactos/drivers/directx/directory.rbuild Normal file
View file

@ -0,0 +1,13 @@
<?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>

15
reactos/drivers/directx/dxapi/dxapi.def Normal file
View file

@ -0,0 +1,15 @@
; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $
;
; dxapi.def - export definition file for ReactOS
;
EXPORTS
DxApi@20
DxApiGetVersion@0
;DxApiInitialize@32
;DxAutoflipUpdate@20
;DxEnableIRQ@8
;DxLoseObject@8
;DxUpdateCapture@12
GsDriverEntry@8

14
reactos/drivers/directx/dxapi/dxapi.rbuild Normal file
View file

@ -0,0 +1,14 @@
<?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>

7
reactos/drivers/directx/dxapi/dxapi.rc Normal file
View file

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

158
reactos/drivers/directx/dxapi/dxapi_driver.h Normal file
View file

@ -0,0 +1,158 @@
/* 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}
};

274
reactos/drivers/directx/dxapi/main.c Normal file
View file

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

9
reactos/drivers/directx/dxg/dxg.def Normal file
View file

@ -0,0 +1,9 @@
; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $
;
; dxg.def - export definition file for ReactOS
;
EXPORTS
DriverEntry@8
DxDdCleanupDxGraphics@0
DxDdStartupDxGraphics@24

14
reactos/drivers/directx/dxg/dxg.rbuild Normal file
View file

@ -0,0 +1,14 @@
<?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>

7
reactos/drivers/directx/dxg/dxg.rc Normal file
View file

@ -0,0 +1,7 @@
/* $Id: vbemp.rc 21844 2006-05-07 19:34:23Z ion $ */
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "DXG DirectX interface Device Driver\0"
#define REACTOS_STR_INTERNAL_NAME "dxg\0"
#define REACTOS_STR_ORIGINAL_FILENAME "dxg.sys\0"
#include <reactos/version.rc>

98
reactos/drivers/directx/dxg/dxg_driver.h Normal file
View file

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

55
reactos/drivers/directx/dxg/dxg_int.h Normal file
View file

@ -0,0 +1,55 @@
/* 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]

14
reactos/drivers/directx/dxg/eng.c Normal file
View file

@ -0,0 +1,14 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: drivers/directx/dxg/main.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/

88
reactos/drivers/directx/dxg/historic.c Normal file
View file

@ -0,0 +1,88 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: 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;
}

195
reactos/drivers/directx/dxg/main.c Normal file
View file

@ -0,0 +1,195 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: drivers/directx/dxg/main.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
#include <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;
}

8
reactos/drivers/directx/dxg/tags.h Normal file
View file

@ -0,0 +1,8 @@
#define TAG_THDD TAG('t', 'h', 'd', 'd')
#define TAG_GINI TAG('G', 'i', 'n', 'i')

26
reactos/drivers/directx/dxgthk/dxgthk.def Normal file
View file

@ -0,0 +1,26 @@
; $Id: videoprt.def 27062 2007-06-07 21:13:06Z greatlrd $
;
; dxg.def - export definition file for ReactOS
;
EXPORTS
DriverEntry@8
EngAcquireSemaphore@4=win32k.EngAcquireSemaphore@4
EngAllocMem@12=win32k.EngAllocMem@12
EngAllocUserMem@8=win32k.EngAllocUserMem@8
EngCopyBits@24=win32k.EngCopyBits@24
EngCreateBitmap@24=win32k.EngCreateBitmap@24
EngCreatePalette@24=win32k.EngCreatePalette@24
EngCreateSemaphore@0=win32k.EngCreateSemaphore@0
EngDeletePalette@4=win32k.EngDeletePalette@4
EngDeleteSemaphore@4=win32k.EngDeleteSemaphore@4
EngDeleteSurface@4=win32k.EngDeleteSurface@4
EngFindImageProcAddress@8=win32k.EngFindImageProcAddress@8
EngFreeMem@4=win32k.EngFreeMem@4
EngFreeUserMem@4=win32k.EngFreeUserMem@4
EngLoadImage@4=win32k.EngLoadImage@4
EngLockSurface@4=win32k.EngLockSurface@4
EngReleaseSemaphore@4=win32k.EngReleaseSemaphore@4
EngSetLastError@4=win32k.EngSetLastError@4
EngUnloadImage@4=win32k.EngUnloadImage@4
EngUnlockSurface@4=win32k.EngUnlockSurface@4

11
reactos/drivers/directx/dxgthk/dxgthk.rbuild Normal file
View file

@ -0,0 +1,11 @@
<?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>

7
reactos/drivers/directx/dxgthk/dxgthk.rc Normal file
View file

@ -0,0 +1,7 @@
/* $Id: vbemp.rc 21844 2006-05-07 19:34:23Z ion $ */
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "DirectX Graphics Driver Thunk\0"
#define REACTOS_STR_INTERNAL_NAME "dxgthk\0"
#define REACTOS_STR_ORIGINAL_FILENAME "dxgthk\0"
#include <reactos/version.rc>

26
reactos/drivers/directx/dxgthk/main.c Normal file
View file

@ -0,0 +1,26 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver for dxg implementation
* FILE: 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;
}

3
reactos/drivers/drivers.rbuild
View file

@ -7,6 +7,9 @@
<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>

32
reactos/include/ddk/d3dnthal.h
View file

@ -1,4 +1,4 @@
/*
/*
* Direct3D NT driver interface
*/
@ -167,6 +167,36 @@ typedef struct _D3DNTHAL_CALLBACKS
ULONG_PTR dwReserved9;
} D3DNTHAL_CALLBACKS, *LPD3DNTHAL_CALLBACKS;
typedef DWORD (APIENTRY *LPD3DNTHAL_SETRENDERTARGETCB)(LPD3DNTHAL_SETRENDERTARGETDATA);
typedef struct _D3DNTHAL_CALLBACKS2
{
DWORD dwSize;
DWORD dwFlags;
LPD3DNTHAL_SETRENDERTARGETCB SetRenderTarget;
LPVOID dwReserved1;
LPVOID dwReserved2;
LPVOID dwReserved3;
LPVOID dwReserved4;
} D3DNTHAL_CALLBACKS2, *LPD3DNTHAL_CALLBACKS2;
typedef DWORD (APIENTRY *LPD3DNTHAL_CLEAR2CB)(LPD3DNTHAL_CLEAR2DATA);
typedef DWORD (APIENTRY *LPD3DNTHAL_VALIDATETEXTURESTAGESTATECB)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA);
typedef DWORD (APIENTRY *LPD3DNTHAL_DRAWPRIMITIVES2CB)(LPD3DNTHAL_DRAWPRIMITIVES2DATA);
typedef struct _D3DNTHAL_CALLBACKS3
{
DWORD dwSize;
DWORD dwFlags;
LPD3DNTHAL_CLEAR2CB Clear2;
LPVOID lpvReserved;
LPD3DNTHAL_VALIDATETEXTURESTAGESTATECB ValidateTextureStageState;
LPD3DNTHAL_DRAWPRIMITIVES2CB DrawPrimitives2;
} D3DNTHAL_CALLBACKS3, *LPD3DNTHAL_CALLBACKS3;
typedef struct _D3DNTHAL_VALIDATETEXTURESTAGESTATEDATA
{
ULONG_PTR dwhContext;

320
reactos/include/ddk/ddkmapi.h
View file

@ -3,10 +3,8 @@
*
* 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
*
@ -20,16 +18,9 @@
*
*/
#ifndef __DDKMAPI_H
#define __DDKMAPI_H
#ifndef __DDKMAPI_INCLUDED__
#define __DDKMAPI_INCLUDED__
#if __GNUC__ >=3
#pragma GCC system_header
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_DXAPI_)
#define DXAPI DECLSPEC_EXPORT
@ -37,29 +28,12 @@ extern "C" {
#define DXAPI DECLSPEC_IMPORT
#endif
DXAPI
DWORD
FAR PASCAL
DxApi(
IN DWORD dwFunctionNum,
IN LPVOID lpvInBuffer,
IN DWORD cbInBuffer,
OUT LPVOID lpvOutBuffer,
OUT DWORD cbOutBuffer);
typedef DWORD (FAR PASCAL *LPDXAPI)(
DWORD dwFunctionNum,
LPVOID lpvInBuffer,
DWORD cbInBuffer,
LPVOID lpvOutBuffer,
DWORD cbOutBuffer);
#define DXAPI_MAJORVERSION 1
#define DXAPI_MINORVERSION 0
#define DD_FIRST_DXAPI 0x500
#define DD_FIRST_DXAPI 0x500
#define DD_DXAPI_GETVERSIONNUMBER (DD_FIRST_DXAPI)
#define DD_DXAPI_CLOSEHANDLE (DD_FIRST_DXAPI+1)
#define DD_DXAPI_OPENDIRECTDRAW (DD_FIRST_DXAPI+2)
@ -83,114 +57,159 @@ typedef DWORD (FAR PASCAL *LPDXAPI)(
#define DD_DXAPI_ADDVPCAPTUREBUFFER (DD_FIRST_DXAPI+20)
#define DD_DXAPI_FLUSHVPCAPTUREBUFFERS (DD_FIRST_DXAPI+21)
typedef struct _DDCAPBUFFINFO {
DWORD dwFieldNumber;
DWORD bPolarity;
LARGE_INTEGER liTimeStamp;
DWORD ddRVal;
} DDCAPBUFFINFO, FAR * LPDDCAPBUFFINFO;
/* DDOPENVPCAPTUREDEVICEIN.dwFlags constants */
#define DDOPENCAPTURE_VIDEO 0x0001
#define DDOPENCAPTURE_VBI 0x0002
/* DDADDVPCAPTUREBUFF.dwFlags constants */
#define DDADDBUFF_SYSTEMMEMORY 0x0001
#define DDADDBUFF_NONLOCALVIDMEM 0x0002
#define DDADDBUFF_INVERT 0x0004
#define DDADDBUFF_SYSTEMMEMORY 0x0001
#define DDADDBUFF_NONLOCALVIDMEM 0x0002
#define DDADDBUFF_INVERT 0x0004
typedef struct _DDADDVPCAPTUREBUFF {
HANDLE hCapture;
DWORD dwFlags;
PMDL pMDL;
PKEVENT pKEvent;
LPDDCAPBUFFINFO lpBuffInfo;
} DDADDVPCAPTUREBUFF, FAR * LPDDADDVPCAPTUREBUFF;
/* DDGETSURFACESTATEOUT.dwStateCaps/dwStateStatus constants */
#define DDSTATE_BOB 0x0001
#define DDSTATE_WEAVE 0x0002
#define DDSTATE_EXPLICITLY_SET 0x0004
#define DDSTATE_SOFTWARE_AUTOFLIP 0x0008
#define DDSTATE_SKIPEVENFIELDS 0x0010
typedef struct _DDCLOSEHANDLE {
HANDLE hHandle;
} DDCLOSEHANDLE, FAR *LPDDCLOSEHANDLE;
/* DDREGISTERCALLBACK.dwEvents constants */
#define DDEVENT_DISPLAY_VSYNC 0x0001
#define DDEVENT_VP_VSYNC 0x0002
#define DDEVENT_VP_LINE 0x0004
#define DDEVENT_PRERESCHANGE 0x0008
#define DDEVENT_POSTRESCHANGE 0x0010
#define DDEVENT_PREDOSBOX 0x0020
#define DDEVENT_POSTDOSBOX 0x0040
typedef struct _DDFLIPOVERLAY {
HANDLE hDirectDraw;
HANDLE hCurrentSurface;
HANDLE hTargetSurface;
DWORD dwFlags;
} DDFLIPOVERLAY, FAR *LPDDFLIPOVERLAY;
/* LPDD_NOTIFYCALLBACK.dwFlags constants */
#define DDNOTIFY_DISPLAY_VSYNC 0x0001
#define DDNOTIFY_VP_VSYNC 0x0002
#define DDNOTIFY_VP_LINE 0x0004
#define DDNOTIFY_PRERESCHANGE 0x0008
#define DDNOTIFY_POSTRESCHANGE 0x0010
#define DDNOTIFY_PREDOSBOX 0x0020
#define DDNOTIFY_POSTDOSBOX 0x0040
#define DDNOTIFY_CLOSEDIRECTDRAW 0x0080
#define DDNOTIFY_CLOSESURFACE 0x0100
#define DDNOTIFY_CLOSEVIDEOPORT 0x0200
#define DDNOTIFY_CLOSECAPTURE 0x0400
typedef struct _DDFLIPVIDEOPORT {
typedef DWORD (*LPDXAPI)(DWORD dwFunctionNum, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer);
typedef ULONG (*LPDD_NOTIFYCALLBACK) (DWORD dwFlags, PVOID pContext, DWORD dwParam1, DWORD dwParam2);
typedef struct _DDCAPBUFFINFO
{
DWORD dwFieldNumber;
DWORD bPolarity;
LARGE_INTEGER liTimeStamp;
DWORD ddRVal;
} DDCAPBUFFINFO, * LPDDCAPBUFFINFO;
typedef struct _DDADDVPCAPTUREBUFF
{
HANDLE hCapture;
DWORD dwFlags;
PMDL pMDL;
PKEVENT pKEvent;
LPDDCAPBUFFINFO lpBuffInfo;
} DDADDVPCAPTUREBUFF, * LPDDADDVPCAPTUREBUFF;
typedef struct _DDCLOSEHANDLE
{
HANDLE hHandle;
} DDCLOSEHANDLE, *LPDDCLOSEHANDLE;
typedef struct _DDFLIPOVERLAY
{
HANDLE hDirectDraw;
HANDLE hCurrentSurface;
HANDLE hTargetSurface;
DWORD dwFlags;
} DDFLIPOVERLAY, *LPDDFLIPOVERLAY;
typedef struct _DDFLIPVIDEOPORT
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
HANDLE hCurrentSurface;
HANDLE hTargetSurface;
DWORD dwFlags;
} DDFLIPVIDEOPORT, FAR *LPDDFLIPVIDEOPORT;
} DDFLIPVIDEOPORT, *LPDDFLIPVIDEOPORT;
typedef struct _DDGETAUTOFLIPIN {
typedef struct _DDGETAUTOFLIPIN
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
} DDGETAUTOFLIPIN, FAR *LPDDGETAUTOFLIPIN;
} DDGETAUTOFLIPIN, *LPDDGETAUTOFLIPIN;
typedef struct _DDGETAUTOFLIPOUT {
typedef struct _DDGETAUTOFLIPOUT
{
DWORD ddRVal;
HANDLE hVideoSurface;
HANDLE hVBISurface;
BOOL bPolarity;
} DDGETAUTOFLIPOUT, FAR *LPDDGETAUTOFLIPOUT;
} DDGETAUTOFLIPOUT, *LPDDGETAUTOFLIPOUT;
typedef struct _DDGETPOLARITYIN {
typedef struct _DDGETPOLARITYIN
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
} DDGETPOLARITYIN, FAR *LPDDGETPOLARITYIN;
} DDGETPOLARITYIN, *LPDDGETPOLARITYIN;
typedef struct _DDGETPOLARITYOUT {
typedef struct _DDGETPOLARITYOUT
{
DWORD ddRVal;
BOOL bPolarity;
} DDGETPOLARITYOUT, FAR *LPDDGETPOLARITYOUT;
} DDGETPOLARITYOUT, *LPDDGETPOLARITYOUT;
typedef struct _DDGETSURFACESTATEIN {
typedef struct _DDGETSURFACESTATEIN
{
HANDLE hDirectDraw;
HANDLE hSurface;
} DDGETSURFACESTATEIN, FAR *LPDDGETSURFACESTATEIN;
} DDGETSURFACESTATEIN, *LPDDGETSURFACESTATEIN;
/* DDGETSURFACESTATEOUT.dwStateCaps/dwStateStatus constants */
#define DDSTATE_BOB 0x0001
#define DDSTATE_WEAVE 0x0002
#define DDSTATE_EXPLICITLY_SET 0x0004
#define DDSTATE_SOFTWARE_AUTOFLIP 0x0008
#define DDSTATE_SKIPEVENFIELDS 0x0010
typedef struct _DDGETSURFACESTATEOUT {
typedef struct _DDGETSURFACESTATEOUT
{
DWORD ddRVal;
DWORD dwStateCaps;
DWORD dwStateStatus;
} DDGETSURFACESTATEOUT, FAR *LPDDGETSURFACESTATEOUT;
} DDGETSURFACESTATEOUT, *LPDDGETSURFACESTATEOUT;
typedef struct _DDGETFIELDNUMIN {
typedef struct _DDGETFIELDNUMIN
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
} DDGETFIELDNUMIN, FAR *LPDDGETFIELDNUMIN;
} DDGETFIELDNUMIN, *LPDDGETFIELDNUMIN;
typedef struct _DDGETFIELDNUMOUT {
typedef struct _DDGETFIELDNUMOUT
{
DWORD ddRVal;
DWORD dwFieldNum;
} DDGETFIELDNUMOUT, FAR *LPDDGETFIELDNUMOUT;
} DDGETFIELDNUMOUT, *LPDDGETFIELDNUMOUT;
typedef struct _DDGETKERNELCAPSOUT {
typedef struct _DDGETKERNELCAPSOUT
{
DWORD ddRVal;
DWORD dwCaps;
DWORD dwIRQCaps;
} DDGETKERNELCAPSOUT, FAR *LPDDGETKERNELCAPSOUT;
} DDGETKERNELCAPSOUT, *LPDDGETKERNELCAPSOUT;
typedef struct _DDGETVERSIONNUMBER {
typedef struct _DDGETVERSIONNUMBER
{
DWORD ddRVal;
DWORD dwMajorVersion;
DWORD dwMinorVersion;
} DDGETVERSIONNUMBER, FAR *LPDDGETVERSIONNUMBER;
} DDGETVERSIONNUMBER, *LPDDGETVERSIONNUMBER;
typedef struct _DDLOCKIN {
typedef struct _DDLOCKIN
{
HANDLE hDirectDraw;
HANDLE hSurface;
} DDLOCKIN, FAR *LPDDLOCKIN;
} DDLOCKIN, *LPDDLOCKIN;
typedef struct _DDLOCKOUT {
typedef struct _DDLOCKOUT
{
DWORD ddRVal;
DWORD dwSurfHeight;
DWORD dwSurfWidth;
@ -200,79 +219,67 @@ typedef struct _DDLOCKOUT {
DWORD dwFormatFlags;
DWORD dwFormatFourCC;
DWORD dwFormatBitCount;
_ANONYMOUS_UNION union {
union
{
DWORD dwRBitMask;
DWORD dwYBitMask;
} DUMMYUNIONNAME;
_ANONYMOUS_UNION union {
};
union
{
DWORD dwGBitMask;
DWORD dwUBitMask;
} DUMMYUNIONNAME2;
_ANONYMOUS_UNION union {
};
union
{
DWORD dwBBitMask;
DWORD dwVBitMask;
} DUMMYUNIONNAME3;
} DDLOCKOUT, FAR *LPDDLOCKOUT;
};
} DDLOCKOUT, *LPDDLOCKOUT;
/* LPDD_NOTIFYCALLBACK.dwFlags constants */
#define DDNOTIFY_DISPLAY_VSYNC 0x0001
#define DDNOTIFY_VP_VSYNC 0x0002
#define DDNOTIFY_VP_LINE 0x0004
#define DDNOTIFY_PRERESCHANGE 0x0008
#define DDNOTIFY_POSTRESCHANGE 0x0010
#define DDNOTIFY_PREDOSBOX 0x0020
#define DDNOTIFY_POSTDOSBOX 0x0040
#define DDNOTIFY_CLOSEDIRECTDRAW 0x0080
#define DDNOTIFY_CLOSESURFACE 0x0100
#define DDNOTIFY_CLOSEVIDEOPORT 0x0200
#define DDNOTIFY_CLOSECAPTURE 0x0400
typedef ULONG (FAR PASCAL *LPDD_NOTIFYCALLBACK)(
DWORD dwFlags,
PVOID pContext,
DWORD dwParam1,
DWORD dwParam2);
typedef struct _DDOPENDIRECTDRAWIN {
ULONG_PTR dwDirectDrawHandle;
typedef struct _DDOPENDIRECTDRAWIN
{
ULONG_PTR dwDirectDrawHandle;
LPDD_NOTIFYCALLBACK pfnDirectDrawClose;
PVOID pContext;
} DDOPENDIRECTDRAWIN, FAR *LPDDOPENDIRECTDRAWIN;
} DDOPENDIRECTDRAWIN, *LPDDOPENDIRECTDRAWIN;
typedef struct _DDOPENDIRECTDRAWOUT {
typedef struct _DDOPENDIRECTDRAWOUT
{
DWORD ddRVal;
HANDLE hDirectDraw;
} DDOPENDIRECTDRAWOUT, FAR *LPDDOPENDIRECTDRAWOUT;
} DDOPENDIRECTDRAWOUT, *LPDDOPENDIRECTDRAWOUT;
typedef struct _DDOPENSURFACEIN {
typedef struct _DDOPENSURFACEIN
{
HANDLE hDirectDraw;
ULONG_PTR dwSurfaceHandle;
LPDD_NOTIFYCALLBACK pfnSurfaceClose;
PVOID pContext;
} DDOPENSURFACEIN, FAR *LPDDOPENSURFACEIN;
} DDOPENSURFACEIN, *LPDDOPENSURFACEIN;
typedef struct _DDOPENSURFACEOUT {
typedef struct _DDOPENSURFACEOUT
{
DWORD ddRVal;
HANDLE hSurface;
} DDOPENSURFACEOUT, FAR *LPDDOPENSURFACEOUT;
} DDOPENSURFACEOUT, *LPDDOPENSURFACEOUT;
typedef struct _DDOPENVIDEOPORTIN {
typedef struct _DDOPENVIDEOPORTIN
{
HANDLE hDirectDraw;
ULONG dwVideoPortHandle;
LPDD_NOTIFYCALLBACK pfnVideoPortClose;
PVOID pContext;
} DDOPENVIDEOPORTIN, FAR *LPDDOPENVIDEOPORTIN;
} DDOPENVIDEOPORTIN, *LPDDOPENVIDEOPORTIN;
typedef struct _DDOPENVIDEOPORTOUT {
typedef struct _DDOPENVIDEOPORTOUT
{
DWORD ddRVal;
HANDLE hVideoPort;
} DDOPENVIDEOPORTOUT, FAR *LPDDOPENVIDEOPORTOUT;
} DDOPENVIDEOPORTOUT, *LPDDOPENVIDEOPORTOUT;
/* DDOPENVPCAPTUREDEVICEIN.dwFlags constants */
#define DDOPENCAPTURE_VIDEO 0x0001
#define DDOPENCAPTURE_VBI 0x0002
typedef struct _DDOPENVPCAPTUREDEVICEIN {
typedef struct _DDOPENVPCAPTUREDEVICEIN
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
DWORD dwStartLine;
@ -281,52 +288,55 @@ typedef struct _DDOPENVPCAPTUREDEVICEIN {
LPDD_NOTIFYCALLBACK pfnCaptureClose;
PVOID pContext;
DWORD dwFlags;
} DDOPENVPCAPTUREDEVICEIN, FAR * LPDDOPENVPCAPTUREDEVICEIN;
} DDOPENVPCAPTUREDEVICEIN, * LPDDOPENVPCAPTUREDEVICEIN;
typedef struct _DDOPENVPCAPTUREDEVICEOUT {
typedef struct _DDOPENVPCAPTUREDEVICEOUT
{
DWORD ddRVal;
HANDLE hCapture;
} DDOPENVPCAPTUREDEVICEOUT, FAR * LPDDOPENVPCAPTUREDEVICEOUT;
} DDOPENVPCAPTUREDEVICEOUT, * LPDDOPENVPCAPTUREDEVICEOUT;
/* DDREGISTERCALLBACK.dwEvents constants */
#define DDEVENT_DISPLAY_VSYNC 0x0001
#define DDEVENT_VP_VSYNC 0x0002
#define DDEVENT_VP_LINE 0x0004
#define DDEVENT_PRERESCHANGE 0x0008
#define DDEVENT_POSTRESCHANGE 0x0010
#define DDEVENT_PREDOSBOX 0x0020
#define DDEVENT_POSTDOSBOX 0x0040
typedef struct _DDREGISTERCALLBACK {
typedef struct _DDREGISTERCALLBACK
{
HANDLE hDirectDraw;
ULONG dwEvents;
LPDD_NOTIFYCALLBACK pfnCallback;
ULONG_PTR dwParam1;
ULONG_PTR dwParam2;
PVOID pContext;
} DDREGISTERCALLBACK, FAR *LPDDREGISTERCALLBACK;
} DDREGISTERCALLBACK, *LPDDREGISTERCALLBACK;
typedef struct _DDSETSURFACETATE {
typedef struct _DDSETSURFACETATE
{
HANDLE hDirectDraw;
HANDLE hSurface;
DWORD dwState;
DWORD dwStartField;
} DDSETSURFACESTATE, FAR *LPDDSETSURFACESTATE;
} DDSETSURFACESTATE, *LPDDSETSURFACESTATE;
typedef struct _DDSETFIELDNUM {
typedef struct _DDSETFIELDNUM
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
DWORD dwFieldNum;
} DDSETFIELDNUM, FAR *LPDDSETFIELDNUM;
} DDSETFIELDNUM, *LPDDSETFIELDNUM;
typedef struct _DDSETSKIPFIELD {
typedef struct _DDSETSKIPFIELD
{
HANDLE hDirectDraw;
HANDLE hVideoPort;
DWORD dwStartField;
} DDSETSKIPFIELD, FAR *LPDDSETSKIPFIELD;
} DDSETSKIPFIELD, *LPDDSETSKIPFIELD;
#ifdef __cplusplus
}
#endif
#endif /* __DDKMAPI_H */
DXAPI
DWORD
DxApi(IN DWORD dwFunctionNum,
IN LPVOID lpvInBuffer,
IN DWORD cbInBuffer,
OUT LPVOID lpvOutBuffer,
OUT DWORD cbOutBuffer);
#endif /* __DDKMAPI_INCLUDED__ */

4
reactos/include/psdk/ntgdi.h
View file

@ -698,7 +698,7 @@ NtGdiDdSetOverlayPosition(
);
W32KAPI
VOID
DWORD
APIENTRY
NtGdiDdUnattachSurface(
IN HANDLE hSurface,
@ -794,7 +794,7 @@ NtGdiDdDestroyD3DBuffer(
);
W32KAPI
DWORD
BOOL
APIENTRY
NtGdiD3dContextCreate(
IN HANDLE hDirectDrawLocal,

141
reactos/include/reactos/drivers/directx/directxint.h Normal file
View file

@ -0,0 +1,141 @@
#ifndef _DXINTERNEL_
#define _DXINTERNEL_
typedef struct _EDD_DIRECTDRAW_LOCAL
{
//
// GDI Object Header
//
HANDLE hHmgr;
PVOID pEntry;
INT cExcLock;
HANDLE Tid;
struct _EDD_DIRECTDRAW_GLOBAL * peDirectDrawGlobal;
struct _EDD_DIRECTDRAW_GLOBAL * peDirectDrawGlobal2;
struct _EDD_SURFACE * peSurface_DdList;
ULONG unk_01c[2];
struct _EDD_DIRECTDRAW_LOCAL * peDirectDrawLocalNext;
FLATPTR fpProcess;
FLONG fl;
HANDLE UniqueProcess;
PEPROCESS Process;
ULONG unk_038[2];
VOID *unk_040;
VOID *unk_044;
} EDD_DIRECTDRAW_LOCAL, PEDD_DIRECTDRAW_LOCAL;
//
// Surface Object
//
typedef struct _EDD_SURFACE
{
//
// GDI Object Header
//
HANDLE hHmgr;
PVOID pEntry;
INT cExcLock;
HANDLE Tid;
//
// Direct Draw Surface Data
//
DD_SURFACE_LOCAL ddsSurfaceLocal;
DD_SURFACE_MORE ddsSurfaceMore;
DD_SURFACE_GLOBAL ddsSurfaceGlobal;
DD_SURFACE_INT ddsSurfaceInt;
//
// Surface pointers
//
struct _EDD_SURFACE *peSurface_DdNext;
struct _EDD_SURFACE *peSurface_LockNext;
//
// Unknown
//
ULONG field_C0;
//
// Private Direct Draw Data
//
struct _EDD_DIRECTDRAW_GLOBAL* peDirectDrawGlobal;
struct _EDD_DIRECTDRAW_LOCAL* peDirectDrawLocal;
//
// Flags
//
FLONG fl;
//
// Surface Attributes
//
ULONG cLocks;
ULONG iVisRgnUniqueness;
BOOL bLost;
HANDLE hSecure;
HANDLE hdc;
HBITMAP hbmGdi;
//
// Unknown
//
ULONG field_E8;
//
// Surface Lock
//
RECTL rclLock;
ULONG field_FC[2];
} EDD_SURFACE, *PEDD_SURFACE;
typedef struct _EDD_DIRECTDRAW_GLOBAL
{
/* 0x000 */ PVOID dhpdev; /* The assign pdev */
/* 0x004 */ DWORD dwReserved1;
/* 0x008 */ DWORD dwReserved2;
/* 0x00C */ ULONG unk_000c[3];
/* 0x018 */ LONG cDriverReferences;
/* 0x01C */ ULONG unk_01c[3];
/* 0x028 */ LONGLONG llAssertModeTimeout;
/* 0x030 */ DWORD dwNumHeaps;
/* 0x034 */ VIDEOMEMORY *pvmList;
/* 0x038 */ DWORD dwNumFourCC;
/* 0x03C */ PDWORD pdwFourCC;
/* 0x040 */ DD_HALINFO ddHalInfo;
/* 0x1E0 */ ULONG unk_1e0[44];
/* 0x290 */ DD_CALLBACKS ddCallbacks;
/* 0x2C4 */ DD_SURFACECALLBACKS ddSurfaceCallbacks;
/* 0x304 */ DD_PALETTECALLBACKS ddPaletteCallbacks;
/* 0x314 */ ULONG unk_314[48];
/* 0x3D4 */ D3DNTHAL_CALLBACKS d3dNtHalCallbacks;
/* 0x460 */ ULONG unk_460[7];
/* 0x47C */ D3DNTHAL_CALLBACKS2 d3dNtHalCallbacks2;
/* 0x498 */ ULONG unk_498[18];
/* 0x4E0 */ DD_MISCELLANEOUSCALLBACKS ddMiscellanousCallbacks;
/* 0x4EC */ ULONG unk_4ec[18];
/* 0x534 */ D3DNTHAL_CALLBACKS3 d3dNtHalCallbacks3;
/* 0x54C */ ULONG unk_54c[23];
/* 0x5A8 */ EDD_DIRECTDRAW_LOCAL* peDirectDrawLocalList;
/* 0x5ac */ EDD_SURFACE* peSurface_LockList;
/* 0x5B0 */ FLONG fl;
/* 0x5B4 */ ULONG cSurfaceLocks;
/* 0x5B8 */ PKEVENT pAssertModeEvent;
/* 0x5Bc */ EDD_SURFACE *peSurfaceCurrent;
/* 0x5C0 */ EDD_SURFACE *peSurfacePrimary;
/* 0x5C4 */ BOOL bSuspended;
/* 0x5C8 */ ULONG unk_5c8[12];
/* 0x5F8 */ RECTL rcbounds;
/* 0x608 */ HDEV hDev;
/* 0x60c */ PVOID hPDev; /* The real Pdev */
/* Windows XP and higher */
/* 0x610 */ ULONG unk_610[63];
/* 0x70C */ ULONG unk_70C;
} EDD_DIRECTDRAW_GLOBAL, *PEDD_DIRECTDRAW_GLOBAL;
#endif

117
reactos/include/reactos/drivers/directx/dxeng.h Normal file
View file

@ -0,0 +1,117 @@
/************************************************************************/
/* This driver interface are exported from win32k.sys to dxg.sys */
/************************************************************************/
#define DXENG_INDEX_Resverd0 0x00
#define DXENG_INDEX_DxEngNUIsTermSrv 0x01
#define DXENG_INDEX_DxEngScreenAccessCheck 0x02
#define DXENG_INDEX_DxEngRedrawDesktop 0x03
#define DXENG_INDEX_DxEngDispUniq 0x04
#define DXENG_INDEX_DxEngIncDispUniq 0x05
#define DXENG_INDEX_DxEngVisRgnUniq 0x06
#define DXENG_INDEX_DxEngLockShareSem 0x07
#define DXENG_INDEX_DxEngUnlockShareSem 0x08
#define DXENG_INDEX_DxEngEnumerateHdev 0x09
#define DXENG_INDEX_DxEngLockHdev 0x0A
#define DXENG_INDEX_DxEngUnlockHdev 0x0B
#define DXENG_INDEX_DxEngIsHdevLockedByCurrentThread 0x0C
#define DXENG_INDEX_DxEngReferenceHdev 0x0D
#define DXENG_INDEX_DxEngUnreferenceHdev 0x0E
#define DXENG_INDEX_DxEngGetDeviceGammaRamp 0x0F
#define DXENG_INDEX_DxEngSetDeviceGammaRamp 0x10
#define DXENG_INDEX_DxEngSpTearDownSprites 0x11
#define DXENG_INDEX_DxEngSpUnTearDownSprites 0x12
#define DXENG_INDEX_DxEngSpSpritesVisible 0x13
#define DXENG_INDEX_DxEngGetHdevData 0x14
#define DXENG_INDEX_DxEngSetHdevData 0x15
#define DXENG_INDEX_DxEngCreateMemoryDC 0x16
#define DXENG_INDEX_DxEngGetDesktopDC 0x17
#define DXENG_INDEX_DxEngDeleteDC 0x18
#define DXENG_INDEX_DxEngCleanDC 0x19
#define DXENG_INDEX_DxEngSetDCOwner 0x1A
#define DXENG_INDEX_DxEngLockDC 0x1B
#define DXENG_INDEX_DxEngUnlockDC 0x1C
#define DXENG_INDEX_DxEngSetDCState 0x1D
#define DXENG_INDEX_DxEngGetDCState 0x1E
#define DXENG_INDEX_DxEngSelectBitmap 0x1F
#define DXENG_INDEX_DxEngSetBitmapOwner 0x20
#define DXENG_INDEX_DxEngDeleteSurface 0x21
#define DXENG_INDEX_DxEngGetSurfaceData 0x22
#define DXENG_INDEX_DxEngAltLockSurface 0x23
#define DXENG_INDEX_DxEngUploadPaletteEntryToSurface 0x24
#define DXENG_INDEX_DxEngMarkSurfaceAsDirectDraw 0x25
#define DXENG_INDEX_DxEngSelectPaletteToSurface 0x26
#define DXENG_INDEX_DxEngSyncPaletteTableWithDevice 0x27
#define DXENG_INDEX_DxEngSetPaletteState 0x28
#define DXENG_INDEX_DxEngGetRedirectionBitmap 0x29
#define DXENG_INDEX_DxEngLoadImage 0x2A
/************************************************************************/
/* win32k.sys internal protypes for the driver functions it export */
/************************************************************************/
/* Notes : Check see if termal server got a connections or not */
BOOL DxEngNUIsTermSrv();
/* Notes : it always return TRUE, and it update whole the screen (redaw current desktop) */
BOOL DxEngRedrawDesktop();
/* Notes : return the DisplayUniqVisrgn counter from gdishare memory */
ULONG DxEngDispUniq();
/* Notes : return the VisRgnUniq counter for win32k */
ULONG DxEngVisRgnUniq();
/* Notes : Enumate all drivers in win32k */
HDEV *DxEngEnumerateHdev(HDEV *hdev);
/* Notes : same protypes NtGdiEngGetDeviceGammaRamp, diffent is we skipp the user mode checks and seh */
BOOL
DxEngGetDeviceGammaRamp(HDC hDC, LPVOID lpRamp);
/* Notes : Lock the hDC */
PDC DxEngLockDC(HDC hDC);
/* Notes : Unlock the hDC */
BOOL DxEngUnlockDC(PDC pDC);
/* prototypes are not done yet, I need gather all my notes
* to make them correct
*/
DWORD DxEngCreateMemoryDC(DWORD x1);
DWORD DxEngScreenAccessCheck();
DWORD DxEngLockShareSem();
DWORD DxEngUnlockShareSem();
DWORD DxEngLockHdev(DWORD x1);
DWORD DxEngUnlockHdev(DWORD x1);
DWORD DxEngReferenceHdev(DWORD x1);
DWORD DxEngIsHdevLockedByCurrentThread(DWORD x1);
DWORD DxEngUnreferenceHdev(DWORD x1);
DWORD DxEngSetDeviceGammaRamp(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngSpSpritesVisible(DWORD x1);
DWORD DxEngGetHdevData(PEDD_DIRECTDRAW_GLOBAL pEDDgpl, DWORD Index);
DWORD DxEngSetHdevData(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngGetDesktopDC(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngDeleteDC(DWORD x1, DWORD x2);
DWORD DxEngCleanDC(DWORD x1);
DWORD DxEngSetDCOwner(DWORD x1, DWORD x2);
DWORD DxEngSetDCState(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngGetDCState(HDC hDC, DWORD type);
DWORD DxEngSelectBitmap(DWORD x1, DWORD x2);
DWORD DxEngSetBitmapOwner(DWORD x1, DWORD x2);
DWORD DxEngDeleteSurface(DWORD x1);
DWORD DxEngGetSurfaceData(DWORD x1, DWORD x2);
DWORD DxEngAltLockSurface(DWORD x1);
DWORD DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4);
DWORD DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2);
DWORD DxEngSelectPaletteToSurface(DWORD x1, DWORD x2);
DWORD DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2);
DWORD DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3);
DWORD DxEngGetRedirectionBitmap(DWORD x1);
DWORD DxEngLoadImage(DWORD x1,DWORD x2);
DWORD DxEngIncDispUniq();

217
reactos/include/reactos/drivers/directx/dxg.h Normal file
View file

@ -0,0 +1,217 @@
/* win32k driver functions table it have created for the engine the DxEng* api */
/* DXG.SYS FUNCTIONS INDEX */
/***************************************************************************/
/* This driver functions are exported raw from NtGdiDd* / NtDvp* / NtD3d* */
/***************************************************************************/
#define DXG_INDEX_DxDxgGenericThunk 0x00
#define DXG_INDEX_DxD3dContextCreate 0x01
#define DXG_INDEX_DxD3dContextDestroy 0x02
#define DXG_INDEX_DxD3dContextDestroyAll 0x03
#define DXG_INDEX_DxD3dValidateTextureStageState 0x04
#define DXG_INDEX_DxD3dDrawPrimitives2 0x05
#define DXG_INDEX_DxDdGetDriverState 0x06
#define DXG_INDEX_DxDdAddAttachedSurface 0x07
#define DXG_INDEX_DxDdAlphaBlt 0x08
#define DXG_INDEX_DxDdAttachSurface 0x09
#define DXG_INDEX_DxDdBeginMoCompFrame 0x0A
#define DXG_INDEX_DxDdBlt 0x0B
#define DXG_INDEX_DxDdCanCreateSurface 0x0C
#define DXG_INDEX_DxDdCanCreateD3DBuffer 0x0D
#define DXG_INDEX_DxDdColorControl 0x0E
#define DXG_INDEX_DxDdCreateDirectDrawObject 0x0F
/* DXG_INDEX_DxDdCreateSurface and DXG_INDEX_DxDdCreateD3DBuffer2 are same */
#define DXG_INDEX_DxDdCreateSurface 0x10
#define DXG_INDEX_DxDdCreateD3DBuffer 0x11
#define DXG_INDEX_DxDdCreateMoComp 0x12
#define DXG_INDEX_DxDdCreateSurfaceObject 0x13
#define DXG_INDEX_DxDdDeleteDirectDrawObject 0x14
#define DXG_INDEX_DxDdDeleteSurfaceObject 0x15
#define DXG_INDEX_DxDdDestroyMoComp 0x16
#define DXG_INDEX_DxDdDestroySurface 0x17
#define DXG_INDEX_DxDdDestroyD3DBuffer 0x18
#define DXG_INDEX_DxDdEndMoCompFrame 0x19
#define DXG_INDEX_DxDdFlip 0x1A
#define DXG_INDEX_DxDdFlipToGDISurface 0x1B
#define DXG_INDEX_DxDdGetAvailDriverMemory 0x1C
#define DXG_INDEX_DxDdGetBltStatus 0x1D
#define DXG_INDEX_DxDdGetDC 0x1E
#define DXG_INDEX_DxDdGetDriverInfo 0x1F
#define DXG_INDEX_DxDdGetDxHandle 0x20
#define DXG_INDEX_DxDdGetFlipStatus 0x21
#define DXG_INDEX_DxDdGetInternalMoCompInfo 0x22
#define DXG_INDEX_DxDdGetMoCompBuffInfo 0x23
#define DXG_INDEX_DxDdGetMoCompGuids 0x24
#define DXG_INDEX_DxDdGetMoCompFormats 0x25
#define DXG_INDEX_DxDdGetScanLine 0x26
/* DXG_INDEX_DxDdLock and DXG_INDEX_DxDdLockD3D are same */
#define DXG_INDEX_DxDdLock 0x27
#define DXG_INDEX_DxDdLockD3D 0x28
#define DXG_INDEX_DxDdQueryDirectDrawObject 0x29
#define DXG_INDEX_DxDdQueryMoCompStatus 0x2A
#define DXG_INDEX_DxDdReenableDirectDrawObject 0x2B
#define DXG_INDEX_DxDdReleaseDC 0x2C
#define DXG_INDEX_DxDdRenderMoComp 0x2D
#define DXG_INDEX_DxDdResetVisrgn 0x2E
#define DXG_INDEX_DxDdSetColorKey 0x2F
#define DXG_INDEX_DxDdSetExclusiveMode 0x30
#define DXG_INDEX_DxDdSetGammaRamp 0x31
#define DXG_INDEX_DxDdCreateSurfaceEx 0x32
#define DXG_INDEX_DxDdSetOverlayPosition 0x33
#define DXG_INDEX_DxDdUnattachSurface 0x34
/* DXG_INDEX_DxDdUnlock and DXG_INDEX_DxDdUnlockD3D are same */
#define DXG_INDEX_DxDdUnlock 0x35
#define DXG_INDEX_DxDdUnlockD3D 0x36
#define DXG_INDEX_DxDdUpdateOverlay 0x37
#define DXG_INDEX_DxDdWaitForVerticalBlank 0x38
#define DXG_INDEX_DxDvpCanCreateVideoPort 0x39
#define DXG_INDEX_DxDvpColorControl 0x3A
#define DXG_INDEX_DxDvpCreateVideoPort 0x3B
#define DXG_INDEX_DxDvpDestroyVideoPort 0x3C
#define DXG_INDEX_DxDvpFlipVideoPort 0x3D
#define DXG_INDEX_DxDvpGetVideoPortBandwidth 0x3E
#define DXG_INDEX_DxDvpGetVideoPortField 0x3F
#define DXG_INDEX_DxDvpGetVideoPortFlipStatus 0x40
#define DXG_INDEX_DxDvpGetVideoPortInputFormats 0x41
#define DXG_INDEX_DxDvpGetVideoPortLine 0x42
#define DXG_INDEX_DxDvpGetVideoPortOutputFormats 0x43
#define DXG_INDEX_DxDvpGetVideoPortConnectInfo 0x44
#define DXG_INDEX_DxDvpGetVideoSignalStatus 0x45
#define DXG_INDEX_DxDvpUpdateVideoPort 0x46
#define DXG_INDEX_DxDvpWaitForVideoPortSync 0x47
#define DXG_INDEX_DxDvpAcquireNotification 0x48
#define DXG_INDEX_DxDvpReleaseNotification 0x49
/***********************************************************************************/
/* This driver functions are exported raw from Eng* it only exists in the def file */
/* you can not do syscallback to thuse but you can import them from win32k.sys */
/* for them are in the export list */
/***********************************************************************************/
/* not addedd yet */
#define DXG_INDEX_DxDdHeapVidMemAllocAligned 0x4A
#define DXG_INDEX_DxDdHeapVidMemFree 0x4B
#define DXG_INDEX_DxDdAllocPrivateUserMem 0x54
#define DXG_INDEX_DxDdFreePrivateUserMem 0x55
#define DXG_INDEX_DxDdLockDirectDrawSurface 0x56
#define DXG_INDEX_DxDdUnlockDirectDrawSurface 0x57
#define DXG_INDEX_DxDdIoctl 0x5B
/***********************************************************************************/
/* Internal use in diffent part in Windows and ReactOS */
/***********************************************************************************/
/* not inuse yet */
#define DXG_INDEX_DxDdEnableDirectDraw 0x4C
#define DXG_INDEX_DxDdDisableDirectDraw 0x4D
#define DXG_INDEX_DxDdSuspendDirectDraw 0x4E
#define DXG_INDEX_DxDdResumeDirectDraw 0x4F
#define DXG_INDEX_DxDdDynamicModeChange 0x50
#define DXG_INDEX_DxDdCloseProcess 0x51
#define DXG_INDEX_DxDdGetDirectDrawBound 0x52
#define DXG_INDEX_DxDdEnableDirectDrawRedirection 0x53
#define DXG_INDEX_DxDdSetAccelLevel 0x58
#define DXG_INDEX_DxDdGetSurfaceLock 0x59
#define DXG_INDEX_DxDdEnumLockedSurfaceRect 0x5A
/***********************************************************************************/
/* Driver Functions Protypes */
/***********************************************************************************/
typedef DWORD (NTAPI *PGD_DXGENERICTRUNK)(ULONG_PTR, ULONG_PTR, SIZE_T*, PVOID, SIZE_T*, PVOID);
//typedef x (NTAPI *PGD_DxD3dContextCreate)(
//typedef x (NTAPI *PGD_DxD3dContextDestroy)(
//typedef x (NTAPI *PGD_DxD3dContextDestroyAll)(
//typedef x (NTAPI *PGD_DxD3dValidateTextureStageState)(
//typedef x (NTAPI *PGD_DxD3dDrawPrimitives2)(
//typedef x (NTAPI *PGD_DxDdGetDriverState)(
//typedef x (NTAPI *PGD_DxDdAddAttachedSurface)(
//typedef x (NTAPI *PGD_DxDdAlphaBlt)(
//typedef x (NTAPI *PGD_DxDdAttachSurface)(
//typedef x (NTAPI *PGD_DxDdBeginMoCompFrame)(
//typedef x (NTAPI *PGD_DxDdBlt)(
//typedef x (NTAPI *PGD_DxDdCanCreateSurface)(
//typedef x (NTAPI *PGD_DxDdCanCreateD3DBuffer)(
//typedef x (NTAPI *PGD_DxDdColorControl)(
//typedef x (NTAPI *PGD_DxDdCreateDirectDrawObject)(
//typedef x (NTAPI *PGD_DxDdCreateSurface)(
//typedef x (NTAPI *PGD_DxDdCreateD3DBuffer)(
//typedef x (NTAPI *PGD_DxDdCreateMoComp)(
//typedef x (NTAPI *PGD_DxDdCreateSurfaceObject)(
//typedef x (NTAPI *PGD_DxDdDeleteDirectDrawObject)(
//typedef x (NTAPI *PGD_DxDdDeleteSurfaceObject)(
//typedef x (NTAPI *PGD_DxDdDestroyMoComp)(
//typedef x (NTAPI *PGD_DxDdDestroySurface)(
//typedef x (NTAPI *PGD_DxDdDestroyD3DBuffer)(
//typedef x (NTAPI *PGD_DxDdEndMoCompFrame)(
//typedef x (NTAPI *PGD_DxDdFlip)(
//typedef x (NTAPI *PGD_DxDdFlipToGDISurface)(
//typedef x (NTAPI *PGD_DxDdGetAvailDriverMemory)(
//typedef x (NTAPI *PGD_DxDdGetBltStatus)(
//typedef x (NTAPI *PGD_DxDdGetDC)(
//typedef x (NTAPI *PGD_DxDdGetDriverInfo)(
//typedef x (NTAPI *PGD_DxDdGetDxHandle)(
//typedef x (NTAPI *PGD_DxDdGetFlipStatus)(
//typedef x (NTAPI *PGD_DxDdGetInternalMoCompInfo)(
//typedef x (NTAPI *PGD_DxDdGetMoCompBuffInfo)(
//typedef x (NTAPI *PGD_DxDdGetMoCompGuids)(
//typedef x (NTAPI *PGD_DxDdGetMoCompFormats)(
//typedef x (NTAPI *PGD_DxDdGetScanLine)(
//typedef x (NTAPI *PGD_DxDdLock)(
//typedef x (NTAPI *PGD_DxDdLockD3D)(
//typedef x (NTAPI *PGD_DxDdQueryDirectDrawObject)(
//typedef x (NTAPI *PGD_DxDdQueryMoCompStatus)(
//typedef x (NTAPI *PGD_DxDdReenableDirectDrawObject)(
//typedef x (NTAPI *PGD_DxDdReleaseDC)(
//typedef x (NTAPI *PGD_DxDdRenderMoComp)(
//typedef x (NTAPI *PGD_DxDdResetVisrgn)(
//typedef x (NTAPI *PGD_DxDdSetColorKey)(
//typedef x (NTAPI *PGD_DxDdSetExclusiveMode)(
//typedef x (NTAPI *PGD_DxDdSetGammaRamp)(
//typedef x (NTAPI *PGD_DxDdCreateSurfaceEx)(
//typedef x (NTAPI *PGD_DxDdSetOverlayPosition)(
//typedef x (NTAPI *PGD_DxDdUnattachSurface)(
//typedef x (NTAPI *PGD_DxDdUnlock)(
//typedef x (NTAPI *PGD_DxDdUnlockD3D)(
//typedef x (NTAPI *PGD_DxDdUpdateOverlay)(
//typedef x (NTAPI *PGD_DxDdWaitForVerticalBlank)(
//typedef x (NTAPI *PGD_DxDvpCanCreateVideoPort)(
//typedef x (NTAPI *PGD_DxDvpColorControl)(
//typedef x (NTAPI *PGD_DxDvpCreateVideoPort)(
//typedef x (NTAPI *PGD_DxDvpDestroyVideoPort)(
//typedef x (NTAPI *PGD_DxDvpFlipVideoPort)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortBandwidth)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortField)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortFlipStatus)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortInputFormats)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortLine)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortOutputFormats)(
//typedef x (NTAPI *PGD_DxDvpGetVideoPortConnectInfo)(
//typedef x (NTAPI *PGD_DxDvpGetVideoSignalStatus)(
//typedef x (NTAPI *PGD_DxDvpUpdateVideoPort)(
//typedef x (NTAPI *PGD_DxDvpWaitForVideoPortSync)(
//typedef x (NTAPI *PGD_DxDvpAcquireNotification)(
//typedef x (NTAPI *PGD_DxDvpReleaseNotification)(
//typedef x (NTAPI *PGD_DxDdHeapVidMemAllocAligned)(
//typedef x (NTAPI *PGD_DxDdHeapVidMemFree)(
//typedef x (NTAPI *PGD_DxDdEnableDirectDraw)(
//typedef x (NTAPI *PGD_DxDdDisableDirectDraw)(
//typedef x (NTAPI *PGD_DxDdSuspendDirectDraw)(
//typedef x (NTAPI *PGD_DxDdResumeDirectDraw)(
//typedef x (NTAPI *PGD_DxDdDynamicModeChange)(
//typedef x (NTAPI *PGD_DxDdCloseProcess)(
//typedef x (NTAPI *PGD_DxDdGetDirectDrawBound)(
//typedef x (NTAPI *PGD_DxDdEnableDirectDrawRedirection)(
//typedef x (NTAPI *PGD_DxDdAllocPrivateUserMem)(
//typedef x (NTAPI *PGD_DxDdFreePrivateUserMem)(
//typedef x (NTAPI *PGD_DxDdLockDirectDrawSurface)(
//typedef x (NTAPI *PGD_DxDdUnlockDirectDrawSurface)(
//typedef x (NTAPI *PGD_DxDdSetAccelLevel)(
//typedef x (NTAPI *PGD_DxDdGetSurfaceLock)(
//typedef x (NTAPI *PGD_DxDdEnumLockedSurfaceRect)(
typedef DWORD (NTAPI *PGD_ENGDXIOCTL)(ULONG, PVOID, ULONG);

225
reactos/include/reactos/win32k/ntgdihdl.h
View file

@ -11,6 +11,8 @@
#ifndef _NTGDIHDL_
#define _NTGDIHDL_
#include <winddi.h>
/* DEFINES *******************************************************************/
/* Base address where the handle table is mapped to */
@ -289,6 +291,7 @@ typedef struct _BRUSH_ATTR
DWORD dwUnused[3];
} BRUSH_ATTR, *PBRUSH_ATTR;
typedef struct _REGION_ATTR
{
DWORD dwUnknown1;
@ -305,4 +308,226 @@ typedef struct _FONT_ATTR
void *pCharWidthData;
} FONT_ATTR, *PFONT_ATTR;
typedef enum tagGdiPathState
{
PATH_Null,
PATH_Open,
PATH_Closed
} GdiPathState;
typedef struct tagGdiPath
{
GdiPathState state;
POINT *pPoints;
BYTE *pFlags;
int numEntriesUsed, numEntriesAllocated;
BOOL newStroke;
} GdiPath;
typedef struct _WIN_DC_INFO
{
int flags;
HRGN hClipRgn; /* Clip region (may be 0) */
HRGN hVisRgn; /* Visible region (must never be 0) */
HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */
HBITMAP hBitmap;
HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */
/* #if 0 */
HANDLE hDevice;
HPALETTE hPalette;
GdiPath path;
/* #endif */
RECT totalExtent;
BYTE bitsPerPixel;
INT DCOrgX; /* DC origin */
INT DCOrgY;
INT ArcDirection;
XFORM xformWorld2Wnd; /* World-to-window transformation */
XFORM xformWorld2Vport; /* World-to-viewport transformation */
XFORM xformVport2World; /* Inverse of the above transformation */
BOOL vport2WorldValid; /* Is xformVport2World valid? */
} WIN_DC_INFO;
typedef BOOL (NTAPI *PGD_ENABLEDRIVER)(ULONG, ULONG, PDRVENABLEDATA);
typedef DHPDEV (NTAPI *PGD_ENABLEPDEV)(DEVMODEW *, LPWSTR, ULONG, HSURF *, ULONG, ULONG *, ULONG, DEVINFO *, LPWSTR, LPWSTR, HANDLE);
typedef VOID (NTAPI *PGD_COMPLETEPDEV)(DHPDEV, HDEV);
typedef VOID (NTAPI *PGD_DISABLEPDEV)(DHPDEV);
typedef HSURF (NTAPI *PGD_ENABLESURFACE)(DHPDEV);
typedef VOID (NTAPI *PGD_DISABLESURFACE)(DHPDEV);
typedef BOOL (NTAPI *PGD_ASSERTMODE)(DHPDEV, BOOL);
typedef BOOL (NTAPI *PGD_OFFSET)(SURFOBJ*, LONG, LONG, FLONG);
typedef BOOL (NTAPI *PGD_RESETPDEV)(DHPDEV, DHPDEV);
typedef VOID (NTAPI *PGD_DISABLEDRIVER)(VOID);
typedef HBITMAP (NTAPI *PGD_CREATEDEVICEBITMAP)(DHPDEV, SIZEL, ULONG);
typedef VOID (NTAPI *PGD_DELETEDEVICEBITMAP)(DHSURF);
typedef BOOL (NTAPI *PGD_ALPHABLEND)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, BLENDOBJ*);
typedef BOOL (NTAPI *PGD_REALIZEBRUSH)(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG);
typedef ULONG (NTAPI *PGD_DITHERCOLOR)(DHPDEV, ULONG, ULONG, PULONG);
typedef BOOL (NTAPI *PGD_STROKEPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, PLINEATTRS, MIX);
typedef BOOL (NTAPI *PGD_FILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, ULONG);
typedef BOOL (NTAPI *PGD_STROKEANDFILLPATH)(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, PLINEATTRS, BRUSHOBJ*, POINTL*, MIX, ULONG);
typedef BOOL (NTAPI *PGD_PAINT)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef BOOL (NTAPI *PGD_BITBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4);
typedef BOOL (NTAPI *PGD_TRANSPARENTBLT)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, RECTL*, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_COPYBITS)(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*);
typedef BOOL (NTAPI *PGD_STRETCHBLT)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG);
typedef BOOL (NTAPI *PGD_STRETCHBLTROP)(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG, BRUSHOBJ*, DWORD);
typedef BOOL (NTAPI *PGD_SETPALETTE)(DHPDEV, PALOBJ*, ULONG, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_TEXTOUT)(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);
typedef ULONG (NTAPI *PGD_ESCAPE)(SURFOBJ*, ULONG, ULONG, PVOID *, ULONG, PVOID *);
typedef ULONG (NTAPI *PGD_DRAWESCAPE)(SURFOBJ*, ULONG, CLIPOBJ*, RECTL*, ULONG, PVOID *);
typedef PIFIMETRICS (NTAPI *PGD_QUERYFONT)(DHPDEV, ULONG, ULONG, PULONG);
typedef PVOID (NTAPI *PGD_QUERYFONTTREE)(DHPDEV, ULONG, ULONG, ULONG, PULONG);
typedef LONG (NTAPI *PGD_QUERYFONTDATA)(DHPDEV, FONTOBJ*, ULONG, HGLYPH, GLYPHDATA*, PVOID, ULONG);
typedef ULONG (NTAPI *PGD_SETPOINTERSHAPE)(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, ULONG);
typedef VOID (NTAPI *PGD_MOVEPOINTER)(SURFOBJ*, LONG, LONG, RECTL*);
typedef BOOL (NTAPI *PGD_LINETO)(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG, RECTL*, MIX);
typedef BOOL (NTAPI *PGD_SENDPAGE)(SURFOBJ*);
typedef BOOL (NTAPI *PGD_STARTPAGE)(SURFOBJ*);
typedef BOOL (NTAPI *PGD_ENDDOC)(SURFOBJ*, ULONG);
typedef BOOL (NTAPI *PGD_STARTDOC)(SURFOBJ*, PWSTR, DWORD);
typedef ULONG (NTAPI *PGD_GETGLYPHMODE)(DHPDEV, FONTOBJ*);
typedef VOID (NTAPI *PGD_SYNCHRONIZE)(DHPDEV, RECTL*);
typedef ULONG (NTAPI *PGD_SAVESCREENBITS)(SURFOBJ*, ULONG, ULONG, RECTL*);
typedef ULONG (NTAPI *PGD_GETMODES)(HANDLE, ULONG, PDEVMODEW);
typedef VOID (NTAPI *PGD_FREE)(PVOID, ULONG);
typedef VOID (NTAPI *PGD_DESTROYFONT)(FONTOBJ*);
typedef LONG (NTAPI *PGD_QUERYFONTCAPS)(ULONG, PULONG);
typedef ULONG (NTAPI *PGD_LOADFONTFILE)(ULONG, PVOID, ULONG, ULONG);
typedef BOOL (NTAPI *PGD_UNLOADFONTFILE)(ULONG);
typedef ULONG (NTAPI *PGD_FONTMANAGEMENT)(SURFOBJ*, FONTOBJ*, ULONG, ULONG, PVOID, ULONG, PVOID);
typedef LONG (NTAPI *PGD_QUERYTRUETYPETABLE)(ULONG, ULONG, ULONG, PTRDIFF, ULONG, PBYTE);
typedef LONG (NTAPI *PGD_QUERYTRUETYPEOUTLINE)(DHPDEV, FONTOBJ*, HGLYPH, BOOL, GLYPHDATA*, ULONG, TTPOLYGONHEADER*);
typedef PVOID (NTAPI *PGD_GETTRUETYPEFILE)(ULONG, PULONG);
typedef LONG (NTAPI *PGD_QUERYFONTFILE)(ULONG, ULONG, ULONG, PULONG);
typedef BOOL (NTAPI *PGD_QUERYADVANCEWIDTHS)(DHPDEV, FONTOBJ*, ULONG, HGLYPH *, PVOID *, ULONG);
typedef BOOL (NTAPI *PGD_SETPIXELFORMAT)(SURFOBJ*, LONG, ULONG);
typedef LONG (NTAPI *PGD_DESCRIBEPIXELFORMAT)(DHPDEV, LONG, ULONG, PPIXELFORMATDESCRIPTOR);
typedef BOOL (NTAPI *PGD_SWAPBUFFERS)(SURFOBJ*, PWNDOBJ);
typedef BOOL (NTAPI *PGD_STARTBANDING)(SURFOBJ*, POINTL*);
typedef BOOL (NTAPI *PGD_NEXTBAND)(SURFOBJ*, POINTL*);
typedef BOOL (NTAPI *PGD_GETDIRECTDRAWINFO)(DHPDEV, PDD_HALINFO, PDWORD, VIDEOMEMORY*, PDWORD, PDWORD);
typedef BOOL (NTAPI *PGD_ENABLEDIRECTDRAW)(DHPDEV, PDD_CALLBACKS, PDD_SURFACECALLBACKS, PDD_PALETTECALLBACKS);
typedef VOID (NTAPI *PGD_DISABLEDIRECTDRAW)(DHPDEV);
typedef LONG (NTAPI *PGD_QUERYSPOOLTYPE)(DHPDEV, LPWSTR);
typedef BOOL (NTAPI *PGD_GRADIENTFILL)(SURFOBJ*, CLIPOBJ*, XLATEOBJ*, TRIVERTEX*, ULONG, PVOID, ULONG, RECTL*, POINTL*, ULONG);
typedef VOID (NTAPI *PGD_SYNCHRONIZESURFACE)(SURFOBJ*, RECTL *, FLONG);
typedef struct _DRIVER_FUNCTIONS
{
PGD_ENABLEDRIVER EnableDriver;
PGD_ENABLEPDEV EnablePDEV;
PGD_COMPLETEPDEV CompletePDEV;
PGD_DISABLEPDEV DisablePDEV;
PGD_ENABLESURFACE EnableSurface;
PGD_DISABLESURFACE DisableSurface;
PGD_ASSERTMODE AssertMode;
PGD_OFFSET Offset;
PGD_RESETPDEV ResetPDEV;
PGD_DISABLEDRIVER DisableDriver;
PGD_CREATEDEVICEBITMAP CreateDeviceBitmap;
PGD_DELETEDEVICEBITMAP DeleteDeviceBitmap;
PGD_REALIZEBRUSH RealizeBrush;
PGD_DITHERCOLOR DitherColor;
PGD_STROKEPATH StrokePath;
PGD_FILLPATH FillPath;
PGD_STROKEANDFILLPATH StrokeAndFillPath;
PGD_PAINT Paint;
PGD_BITBLT BitBlt;
PGD_TRANSPARENTBLT TransparentBlt;
PGD_COPYBITS CopyBits;
PGD_STRETCHBLT StretchBlt;
PGD_STRETCHBLTROP StretchBltROP;
PGD_SETPALETTE SetPalette;
PGD_TEXTOUT TextOut;
PGD_ESCAPE Escape;
PGD_DRAWESCAPE DrawEscape;
PGD_QUERYFONT QueryFont;
PGD_QUERYFONTTREE QueryFontTree;
PGD_QUERYFONTDATA QueryFontData;
PGD_SETPOINTERSHAPE SetPointerShape;
PGD_MOVEPOINTER MovePointer;
PGD_LINETO LineTo;
PGD_SENDPAGE SendPage;
PGD_STARTPAGE StartPage;
PGD_ENDDOC EndDoc;
PGD_STARTDOC StartDoc;
PGD_GETGLYPHMODE GetGlyphMode;
PGD_SYNCHRONIZE Synchronize;
PGD_SAVESCREENBITS SaveScreenBits;
PGD_GETMODES GetModes;
PGD_FREE Free;
PGD_DESTROYFONT DestroyFont;
PGD_QUERYFONTCAPS QueryFontCaps;
PGD_LOADFONTFILE LoadFontFile;
PGD_UNLOADFONTFILE UnloadFontFile;
PGD_FONTMANAGEMENT FontManagement;
PGD_QUERYTRUETYPETABLE QueryTrueTypeTable;
PGD_QUERYTRUETYPEOUTLINE QueryTrueTypeOutline;
PGD_GETTRUETYPEFILE GetTrueTypeFile;
PGD_QUERYFONTFILE QueryFontFile;
PGD_QUERYADVANCEWIDTHS QueryAdvanceWidths;
PGD_SETPIXELFORMAT SetPixelFormat;
PGD_DESCRIBEPIXELFORMAT DescribePixelFormat;
PGD_SWAPBUFFERS SwapBuffers;
PGD_STARTBANDING StartBanding;
PGD_NEXTBAND NextBand;
PGD_GETDIRECTDRAWINFO GetDirectDrawInfo;
PGD_ENABLEDIRECTDRAW EnableDirectDraw;
PGD_DISABLEDIRECTDRAW DisableDirectDraw;
PGD_QUERYSPOOLTYPE QuerySpoolType;
PGD_GRADIENTFILL GradientFill;
PGD_SYNCHRONIZESURFACE SynchronizeSurface;
PGD_ALPHABLEND AlphaBlend;
} DRIVER_FUNCTIONS, *PDRIVER_FUNCTIONS;
typedef struct _DC
{
HGDIOBJ hHmgr; // Handle for this DC object.
PVOID pvEntry;
ULONG lucExcLock;
ULONG Tid;
DHPDEV PDev;
INT DC_Type;
INT DC_Flags;
PDC_ATTR pDc_Attr;
DC_ATTR Dc_Attr;
struct _EDD_DIRECTDRAW_GLOBAL * pEDDgpl;
HDC hSelf; // Used only for MemoryDC & SaveDC.
HDC hNext;
HSURF FillPatternSurfaces[HS_DDI_MAX];
PGDIINFO GDIInfo;
PDEVINFO DevInfo;
HDEV GDIDevice;
DRIVER_FUNCTIONS DriverFunctions;
UNICODE_STRING DriverName;
HANDLE DeviceDriver;
CLIPOBJ *CombinedClip;
XLATEOBJ *XlateBrush;
XLATEOBJ *XlatePen;
INT saveLevel;
BOOL IsIC;
HPALETTE PalIndexed;
WIN_DC_INFO w;
HANDLE hFile;
LPENHMETAHEADER emh;
} DC, *PDC;
#endif

79
reactos/subsystems/win32/win32k/include/dc.h
View file

@ -4,50 +4,9 @@
#include "driver.h"
typedef enum tagGdiPathState
{
PATH_Null,
PATH_Open,
PATH_Closed
} GdiPathState;
typedef struct tagGdiPath
{
GdiPathState state;
POINT *pPoints;
BYTE *pFlags;
int numEntriesUsed, numEntriesAllocated;
BOOL newStroke;
} GdiPath;
typedef struct _WIN_DC_INFO
{
int flags;
HRGN hClipRgn; /* Clip region (may be 0) */
HRGN hVisRgn; /* Visible region (must never be 0) */
HRGN hGCClipRgn; /* GC clip region (ClipRgn AND VisRgn) */
HBITMAP hBitmap;
HBITMAP hFirstBitmap; /* Bitmap selected at creation of the DC */
/* #if 0 */
HANDLE hDevice;
HPALETTE hPalette;
GdiPath path;
/* #endif */
RECT totalExtent;
BYTE bitsPerPixel;
INT DCOrgX; /* DC origin */
INT DCOrgY;
INT ArcDirection;
XFORM xformWorld2Wnd; /* World-to-window transformation */
XFORM xformWorld2Vport; /* World-to-viewport transformation */
XFORM xformVport2World; /* Inverse of the above transformation */
BOOL vport2WorldValid; /* Is xformVport2World valid? */
} WIN_DC_INFO;
/* DC flags */
#define DC_MEMORY 0x0001 /* It is a memory DC */
@ -57,45 +16,7 @@ typedef struct _WIN_DC_INFO
#define GDI_DC_TYPE (1)
typedef struct _DC
{
HGDIOBJ hHmgr; // Handle for this DC object.
PVOID pvEntry;
ULONG lucExcLock;
ULONG Tid;
DHPDEV PDev;
INT DC_Type;
INT DC_Flags;
PDC_ATTR pDc_Attr;
DC_ATTR Dc_Attr;
HDC hSelf; // Used only for MemoryDC & SaveDC.
HDC hNext;
HSURF FillPatternSurfaces[HS_DDI_MAX];
PGDIINFO GDIInfo;
PDEVINFO DevInfo;
HDEV GDIDevice;
DRIVER_FUNCTIONS DriverFunctions;
UNICODE_STRING DriverName;
HANDLE DeviceDriver;
CLIPOBJ *CombinedClip;
XLATEOBJ *XlateBrush;
XLATEOBJ *XlatePen;
INT saveLevel;
BOOL IsIC;
HPALETTE PalIndexed;
WIN_DC_INFO w;
HANDLE hFile;
LPENHMETAHEADER emh;
} DC, *PDC;
typedef struct _GDIPOINTER /* should stay private to ENG */
{

165
reactos/subsystems/win32/win32k/include/driver.h
View file

@ -4,176 +4,11 @@
#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);

3
reactos/subsystems/win32/win32k/include/gdifloat.h
View file

@ -1,6 +1,9 @@
#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>

224
reactos/subsystems/win32/win32k/include/intddraw.h
View file

@ -3,121 +3,123 @@
#include <ddrawint.h>
#include <ddkernel.h>
#include <reactos/drivers/directx/directxint.h>
#include <reactos/drivers/directx/dxg.h>
#include <reactos/drivers/directx/dxeng.h>
typedef struct
{
/* for the driver */
PDD_SURFACE_LOCAL lcllist[2];
/* From ddraw.c */
extern PDRVFN gpDxFuncs;
DDRAWI_DDRAWSURFACE_LCL lcl;
DDRAWI_DDRAWSURFACE_GBL gpl;
DDRAWI_DDRAWSURFACE_MORE more;
/* DD_CREATESURFACEDATA CreateSurfaceData */
DD_CREATESURFACEDATA CreateSurfaceData;
/* for win32k stuff */
DD_SURFACE_LOCAL Local;
DD_SURFACE_MORE More;
DD_SURFACE_GLOBAL Global;
DDSURFACEDESC desc;
DD_ATTACHLIST AttachList;
DD_ATTACHLIST AttachListFrom;
BOOL bComplete;
HANDLE hDirectDrawLocal;
} DD_SURFACE, *PDD_SURFACE;
typedef struct
{
DD_DIRECTDRAW_LOCAL Local;
DD_DIRECTDRAW_GLOBAL Global;
/* Drv callbacks */
PGD_GETDIRECTDRAWINFO DrvGetDirectDrawInfo;
PGD_DISABLEDIRECTDRAW DrvDisableDirectDraw;
PGD_ENABLEDIRECTDRAW EnableDirectDraw;
/* DD callbacks */
DD_CALLBACKS DD;
/* Surface callbacks */
DD_SURFACECALLBACKS Surf;
/* Palette callbacks */
DD_PALETTECALLBACKS Pal;
/* HAL */
DD_HALINFO Hal;
/* Color Control Callback */
DD_COLORCONTROLCALLBACKS Color;
/* D3DHAL_CALLBACKS */
//D3DHAL_CALLBACKS D3dHal;
// D3DHAL_CALLBACKS3 D3dHal3;
// D3DHAL_D3DEXTENDEDCAPS D3dHal3Ext;
/* Heap Callback */
PDD_GETHEAPALIGNMENTDATA HeapData;
/* Kernel Callback */
DD_KERNELCALLBACKS Kernel;
DDKERNELCAPS KernelCaps;
/* Miscellaneous Callback */
DD_MISCELLANEOUSCALLBACKS Misc;
/* NT-based Callback */
PDD_FLIPTOGDISURFACE DdFlipToGDISurface;
PDD_FREEDRIVERMEMORY DdFreeDriverMemory;
PDD_SETEXCLUSIVEMODE DdSetExclusiveMode;
/*.Motion Compensation .*/
PDD_MOCOMPCB_BEGINFRAME DdMoCompBeginFrame;
PDD_MOCOMPCB_CREATE DdMoCompCreate;
PDD_MOCOMPCB_DESTROY DdMoCompDestroy;
PDD_MOCOMPCB_ENDFRAME DdMoCompEndFrame;
PDD_MOCOMPCB_GETCOMPBUFFINFO DdMoCompGetBuffInfo;
PDD_MOCOMPCB_GETFORMATS DdMoCompGetFormats;
PDD_MOCOMPCB_GETGUIDS DdMoCompGetGuids;
PDD_MOCOMPCB_GETINTERNALINFO DdMoCompGetInternalInfo;
PDD_MOCOMPCB_QUERYSTATUS DdMoCompQueryStatus;
PDD_MOCOMPCB_RENDER DdMoCompRender;
/* Video Port Callback */
PDD_VPORTCB_CANCREATEVIDEOPORT DdVideoPortCanCreate;
PDD_VPORTCB_COLORCONTROL DdVideoPortColorControl;
PDD_VPORTCB_CREATEVIDEOPORT DdVideoPortCreate;
PDD_VPORTCB_DESTROYVPORT DdVideoPortDestroy;
PDD_VPORTCB_FLIP DdVideoPortFlip;
PDD_VPORTCB_GETBANDWIDTH DdVideoPortGetBandwidth;
PDD_VPORTCB_GETVPORTCONNECT DdVideoPortGetConnectInfo;
PDD_VPORTCB_GETFIELD DdVideoPortGetField;
PDD_VPORTCB_GETFLIPSTATUS DdVideoPortGetFlipStatus;
PDD_VPORTCB_GETINPUTFORMATS DdVideoPortGetInputFormats;
PDD_VPORTCB_GETLINE DdVideoPortGetLine;
PDD_VPORTCB_GETOUTPUTFORMATS DdVideoPortGetOutputFormats;
PDD_VPORTCB_GETSIGNALSTATUS DdVideoPortGetSignalStatus;
PDD_VPORTCB_UPDATE DdVideoPortUpdate;
PDD_VPORTCB_WAITFORSYNC DdVideoPortWaitForSync;
/* Notify Callback */
//LPDD_NOTIFYCALLBACK NotifyCallback
/* memory stuff */
DWORD dwNumHeaps;
PVIDEOMEMORY pvmList;
DWORD dwNumFourCC;
LPDWORD pdwFourCC;
typedef BOOL (NTAPI* PGD_DDSETGAMMARAMP)(HANDLE, HDC, LPVOID);
typedef BOOL (NTAPI* PGD_DDRELEASEDC)(HANDLE);
typedef BOOL (NTAPI* PGD_DDRESTVISRGN)(HANDLE, HWND);
typedef HANDLE (NTAPI* PGD_DDGETDXHANDLE)(HANDLE, HANDLE, BOOL);
typedef HDC (NTAPI *PGD_DDGETDC)(HANDLE, PALETTEENTRY *);
typedef DWORD (NTAPI *PGD_DXDDREENABLEDIRECTDRAWOBJECT)(HANDLE, BOOL*);
typedef DWORD (NTAPI *PGD_DXDDGETDRIVERINFO)(HANDLE, PDD_GETDRIVERINFODATA);
typedef DWORD (NTAPI *PGD_DXDDSETEXCLUSIVEMODE)(HANDLE, PDD_SETEXCLUSIVEMODEDATA);
typedef NTSTATUS (NTAPI *PGD_DXDDSTARTUPDXGRAPHICS) (ULONG, PDRVENABLEDATA, ULONG, PDRVENABLEDATA, PULONG, PEPROCESS);
typedef NTSTATUS (NTAPI *PGD_DXDDCLEANUPDXGRAPHICS) (VOID);
typedef HANDLE (NTAPI *PGD_DDCREATEDIRECTDRAWOBJECT) (HDC hdc);
typedef DWORD (NTAPI *PGD_DDGETDRIVERSTATE)(PDD_GETDRIVERSTATEDATA);
typedef DWORD (NTAPI *PGD_DDCOLORCONTROL)(HANDLE hSurface,PDD_COLORCONTROLDATA puColorControlData);
typedef HANDLE (NTAPI *PGD_DXDDCREATESURFACEOBJECT)(HANDLE, HANDLE, PDD_SURFACE_LOCAL, PDD_SURFACE_MORE, PDD_SURFACE_GLOBAL, BOOL);
typedef BOOL (NTAPI *PGD_DXDDDELETEDIRECTDRAWOBJECT)(HANDLE);
typedef BOOL (NTAPI *PGD_DXDDDELETESURFACEOBJECT)(HANDLE);
typedef DWORD (NTAPI *PGD_DXDDFLIPTOGDISURFACE)(HANDLE, PDD_FLIPTOGDISURFACEDATA);
typedef DWORD (NTAPI *PGD_DXDDGETAVAILDRIVERMEMORY)(HANDLE , PDD_GETAVAILDRIVERMEMORYDATA);
typedef BOOL (NTAPI *PGD_DXDDQUERYDIRECTDRAWOBJECT)(HANDLE, DD_HALINFO*, DWORD*, LPD3DNTHAL_CALLBACKS, LPD3DNTHAL_GLOBALDRIVERDATA,
PDD_D3DBUFCALLBACKS, LPDDSURFACEDESC, DWORD *, VIDEOMEMORY *, DWORD *, DWORD *);
} DD_DIRECTDRAW, *PDD_DIRECTDRAW;
/* From d3d.c */
typedef DWORD (NTAPI *PGD_DXDDDESTROYD3DBUFFER)(HANDLE);
typedef DWORD (NTAPI *PGD_DDCANCREATED3DBUFFER)(HANDLE, PDD_CANCREATESURFACEDATA);
typedef DWORD (NTAPI *PGD_DXDDUNLOCKD3D)(HANDLE, PDD_UNLOCKDATA);
typedef DWORD (NTAPI *PGD_DXDDLOCKD3D)(HANDLE, PDD_LOCKDATA);
typedef DWORD (NTAPI *PGD_D3DVALIDATETEXTURESTAGESTATE)(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA);
typedef DWORD (NTAPI *PGD_D3DDRAWPRIMITIVES2)(HANDLE, HANDLE, LPD3DNTHAL_DRAWPRIMITIVES2DATA, FLATPTR *, DWORD *, FLATPTR *, DWORD *);
typedef DWORD (NTAPI *PGD_DDCREATED3DBUFFER)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
typedef BOOL (NTAPI *PGD_D3DCONTEXTCREATE)(HANDLE, HANDLE, HANDLE, LPD3DNTHAL_CONTEXTCREATEDATA);
typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROY)(LPD3DNTHAL_CONTEXTDESTROYDATA);
typedef DWORD (NTAPI *PGD_D3DCONTEXTDESTROYALL)(LPD3DNTHAL_CONTEXTDESTROYALLDATA);
/* From dvp.c */
typedef DWORD (NTAPI* PGD_DVPCANCREATEVIDEOPORT)(HANDLE, PDD_CANCREATEVPORTDATA);
typedef DWORD (NTAPI* PGD_DVPCOLORCONTROL)(HANDLE, PDD_VPORTCOLORDATA);
typedef HANDLE (NTAPI* PGD_DVPCREATEVIDEOPORT)(HANDLE, PDD_CREATEVPORTDATA);
typedef DWORD (NTAPI* PGD_DVPDESTROYVIDEOPORT)(HANDLE, PDD_DESTROYVPORTDATA);
typedef DWORD (NTAPI* PGD_DVPFLIPVIDEOPORT)(HANDLE,HANDLE,HANDLE,PDD_FLIPVPORTDATA);
typedef DWORD (NTAPI* PGD_DVPGETVIDEOPORTBANDWITH)(HANDLE, PDD_GETVPORTBANDWIDTHDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFLIPSTATUS)(HANDLE, PDD_GETVPORTFLIPSTATUSDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTINPUTFORMATS)(HANDLE, PDD_GETVPORTINPUTFORMATDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTLINE)(HANDLE, PDD_GETVPORTLINEDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTOUTPUTFORMATS)(HANDLE, PDD_GETVPORTOUTPUTFORMATDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTCONNECTINFO)(HANDLE, PDD_GETVPORTCONNECTDATA);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOSIGNALSTATUS)(HANDLE, PDD_GETVPORTSIGNALDATA);
typedef DWORD (NTAPI *PGD_DXDVPUPDATEVIDEOPORT)(HANDLE, HANDLE*, HANDLE*, PDD_UPDATEVPORTDATA);
typedef DWORD (NTAPI *PGD_DXDVPWAITFORVIDEOPORTSYNC)(HANDLE, PDD_WAITFORVPORTSYNCDATA);
typedef DWORD (NTAPI *PGD_DXDVPACQUIRENOTIFICATION)(HANDLE, HANDLE*, LPDDVIDEOPORTNOTIFY);
typedef DWORD (NTAPI *PGD_DXDVPRELEASENOTIFICATION)(HANDLE, HANDLE);
typedef DWORD (NTAPI *PGD_DXDVPGETVIDEOPORTFIELD)(HANDLE, PDD_GETVPORTFIELDDATA);
/* From mocomp.c */
typedef DWORD (NTAPI *PGD_DDBEGINMOCOMPFRAME)(HANDLE, PDD_BEGINMOCOMPFRAMEDATA);
typedef HANDLE (NTAPI *PGD_DXDDCREATEMOCOMP)(HANDLE, PDD_CREATEMOCOMPDATA );
typedef DWORD (NTAPI *PGD_DXDDDESTROYMOCOMP)(HANDLE, PDD_DESTROYMOCOMPDATA);
typedef DWORD (NTAPI *PGD_DXDDENDMOCOMPFRAME)(HANDLE, PDD_ENDMOCOMPFRAMEDATA);
typedef DWORD (NTAPI *PGD_DXDDGETINTERNALMOCOMPINFO)(HANDLE, PDD_GETINTERNALMOCOMPDATA);
typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPBUFFINFO)(HANDLE, PDD_GETMOCOMPCOMPBUFFDATA);
typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPGUIDS)(HANDLE, PDD_GETMOCOMPGUIDSDATA);
typedef DWORD (NTAPI *PGD_DXDDGETMOCOMPFORMATS)(HANDLE, PDD_GETMOCOMPFORMATSDATA);
typedef DWORD (NTAPI *PGD_DXDDQUERYMOCOMPSTATUS)(HANDLE, PDD_QUERYMOCOMPSTATUSDATA);
typedef DWORD (NTAPI *PGD_DXDDRENDERMOCOMP)(HANDLE, PDD_RENDERMOCOMPDATA);
/* From dd.c */
typedef DWORD (NTAPI *PGD_DDCREATESURFACE)(HANDLE, HANDLE *, DDSURFACEDESC *, DD_SURFACE_GLOBAL *, DD_SURFACE_LOCAL *, DD_SURFACE_MORE *, PDD_CREATESURFACEDATA , HANDLE *);
typedef DWORD (NTAPI *PGD_DXDDWAITFORVERTICALBLANK)(HANDLE, PDD_WAITFORVERTICALBLANKDATA);
typedef DWORD (NTAPI *PGD_DDCANCREATESURFACE)(HANDLE hDirectDrawLocal, PDD_CANCREATESURFACEDATA puCanCreateSurfaceData);
typedef DWORD (NTAPI *PGD_DXDDGETSCANLINE)(HANDLE, PDD_GETSCANLINEDATA);
typedef DWORD (NTAPI *PGD_DXDDCREATESURFACEEX)(HANDLE,HANDLE,DWORD);
/* From ddsurf.c */
typedef DWORD (NTAPI *PGD_DDALPHABLT)(HANDLE, HANDLE, PDD_BLTDATA);
typedef BOOL (NTAPI *PGD_DDATTACHSURFACE)(HANDLE, HANDLE);
typedef DWORD (NTAPI *PGD_DXDDUNATTACHSURFACE)(HANDLE, HANDLE);
typedef DWORD (NTAPI *PGD_DXDDDESTROYSURFACE)(HANDLE, BOOL);
typedef DWORD (NTAPI *PGD_DXDDFLIP)(HANDLE, HANDLE, HANDLE, HANDLE, PDD_FLIPDATA);
typedef DWORD (NTAPI *PGD_DXDDLOCK)(HANDLE, PDD_LOCKDATA, HDC);
typedef DWORD (NTAPI *PGD_DXDDUNLOCK)(HANDLE, PDD_UNLOCKDATA );
typedef DWORD (NTAPI *PGD_DDBLT)(HANDLE, HANDLE, PDD_BLTDATA);
typedef DWORD (NTAPI *PGD_DXDDSETCOLORKEY)(HANDLE, PDD_SETCOLORKEYDATA);
typedef DWORD (NTAPI *PGD_DDADDATTACHEDSURFACE)(HANDLE, HANDLE,PDD_ADDATTACHEDSURFACEDATA);
typedef DWORD (NTAPI *PGD_DXDDGETBLTSTATUS)(HANDLE, PDD_GETBLTSTATUSDATA);
typedef DWORD (NTAPI *PGD_DXDDGETFLIPSTATUS)(HANDLE, PDD_GETFLIPSTATUSDATA);
typedef DWORD (NTAPI *PGD_DXDDUPDATEOVERLAY)(HANDLE, HANDLE, PDD_UPDATEOVERLAYDATA);
typedef DWORD (NTAPI *PGD_DXDDSETOVERLAYPOSITION)(HANDLE, HANDLE, PDD_SETOVERLAYPOSITIONDATA);
/* From eng.c */
typedef FLATPTR (NTAPI *PGD_HEAPVIDMEMALLOCALIGNED)(LPVIDMEM, DWORD, DWORD, LPSURFACEALIGNMENT, LPLONG);
typedef VOID (NTAPI *PGD_VIDMEMFREE)(LPVMEMHEAP, FLATPTR);
typedef PVOID (NTAPI *PGD_ENGALLOCPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, SIZE_T, ULONG) ;
typedef VOID (NTAPI *PGD_ENGFREEPRIVATEUSERMEM)(PDD_SURFACE_LOCAL, PVOID);
typedef PDD_SURFACE_LOCAL (NTAPI *PGD_ENGLOCKDIRECTDRAWSURFACE)(HANDLE);
typedef BOOL (NTAPI *PGD_ENGUNLOCKDIRECTDRAWSURFACE)(PDD_SURFACE_LOCAL);
/* Standard macro */
#define DXG_GET_INDEX_FUNCTION(INDEX, FUNCTION) \
if (gpDxFuncs) \
{ \
for (i = 0; i <= DXG_INDEX_DxDdIoctl; i++) \
{ \
if (gpDxFuncs[i].iFunc == INDEX) \
{ \
FUNCTION = (VOID *)gpDxFuncs[i].pfn; \
break; \
} \
} \
}
BOOL INTERNAL_CALL DD_Cleanup(PVOID pDD);
BOOL INTERNAL_CALL DDSURF_Cleanup(PVOID pDDSurf);
#endif /* _INT_W32k_DDRAW */

398
reactos/subsystems/win32/win32k/ntddraw/d3d.c Normal file
View file

@ -0,0 +1,398 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: subsys/win32k/ntddraw/d3d.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
/* Comment
* NtGdiDdLock and NtGdiDdLockD3D at end calls to same api in the dxg.sys
* NtGdiDdUnlock and NtGdiDdUnlockD3D at end calls to same api in the dxg.sys
*/
#include <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);
}

635
reactos/subsystems/win32/win32k/ntddraw/dd.c
View file

@ -5,576 +5,139 @@
* FILE: subsys/win32k/ntddraw/dd.c
* PROGRAMER: Magnus Olsen (greatlord@reactos.org)
* REVISION HISTORY:
* 19/7-2006 Magnus Olsen
* 19/1-2006 Magnus Olsen
*/
#include <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;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurface, pfnDdCreateSurface);
DD_CREATESURFACEDATA CreateSurfaceData;
/* FIXME: Alloc as much as needed */
PHANDLE *myhSurface;
/* GCC4 gives warnings about uninitialized
values, but they are initialized in SEH */
DPRINT1("NtGdiDdCreateSurface\n");
DPRINT1("Copy puCreateSurfaceData to kmode CreateSurfaceData\n");
_SEH_TRY
if (pfnDdCreateSurface == NULL)
{
ProbeForRead(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1);
RtlCopyMemory( &CreateSurfaceData, puCreateSurfaceData,
sizeof( DD_CREATESURFACEDATA ) );
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
return ddRVal;
DPRINT1("Warring no pfnDdCreateSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
/* FIXME: There is only support for one surface at the moment.
This is a hack to prevent more than one surface creation */
if (CreateSurfaceData.dwSCnt > 1)
{
DPRINT1("HACK: Limiting quantity of created surfaces from %d to 1!\n",
CreateSurfaceData.dwSCnt);
CreateSurfaceData.dwSCnt = 1;
}
DPRINT1("Setup surface in put handler\n");
myhSurface = ExAllocatePool(PagedPool, CreateSurfaceData.dwSCnt * sizeof(HANDLE));
_SEH_TRY
{
ProbeForRead(hSurface, CreateSurfaceData.dwSCnt * sizeof(HANDLE), 1);
for (i=0;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 */
}
/* Setup DD_CREATESURFACEDATA CreateSurfaceData for the driver */
CreateSurfaceData.lplpSList = (PDD_SURFACE_LOCAL *) &phsurface->lcllist;
CreateSurfaceData.lpDDSurfaceDesc = &phsurface->desc;
CreateSurfaceData.CreateSurface = NULL;
CreateSurfaceData.ddRVal = DDERR_GENERIC;
CreateSurfaceData.lpDD = &pDirectDraw->Global;
/* CreateSurface must crash with lcl converting */
if ((pDirectDraw->DD.dwFlags & DDHAL_CB32_CREATESURFACE))
{
DPRINT1("0x%04x",pDirectDraw->DD.CreateSurface);
ddRVal = pDirectDraw->DD.CreateSurface(&CreateSurfaceData);
}
DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,CreateSurfaceData.ddRVal);
/* FIXME: support for more that one surface (once more!!!!) */
_SEH_TRY
{
ProbeForWrite(puSurfaceDescription, sizeof(DDSURFACEDESC), 1);
RtlCopyMemory( puSurfaceDescription, &phsurface->desc, sizeof( DDSURFACEDESC ) );
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
_SEH_TRY
{
ProbeForWrite(puCreateSurfaceData, sizeof(DD_CREATESURFACEDATA), 1);
puCreateSurfaceData->ddRVal = CreateSurfaceData.ddRVal;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
for (i = 0; i < CreateSurfaceData.dwSCnt; i++)
{
_SEH_TRY
{
ProbeForWrite(puSurfaceGlobalData, sizeof(DD_SURFACE_GLOBAL), 1);
RtlCopyMemory( puSurfaceGlobalData, &phsurface->Global, sizeof( DD_SURFACE_GLOBAL ) );
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
_SEH_TRY
{
ProbeForWrite(puSurfaceLocalData, sizeof(DD_SURFACE_LOCAL), 1);
RtlCopyMemory( puSurfaceLocalData, &phsurface->Local, sizeof( DD_SURFACE_LOCAL ) );
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
_SEH_TRY
{
ProbeForWrite(puSurfaceMoreData, sizeof(DD_SURFACE_MORE), 1);
RtlCopyMemory( puSurfaceMoreData, &phsurface->More, sizeof( DD_SURFACE_MORE ) );
puSurfaceLocalData->lpGbl = puSurfaceGlobalData;
puSurfaceLocalData->lpSurfMore = puSurfaceMoreData;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
DPRINT1("GDIOBJ_UnlockObjByPtr\n");
GDIOBJ_UnlockObjByPtr(DdHandleTable, phsurface);
_SEH_TRY
{
ProbeForWrite(puhSurface, sizeof(HANDLE), 1);
puhSurface[i] = myhSurface[i];
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
}
/* FIXME: Fil the return handler */
DPRINT1("GDIOBJ_UnlockObjByPtr\n");
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
DPRINT1("Return value is %04x and driver return code is %04x\n",
ddRVal, CreateSurfaceData.ddRVal);
return ddRVal;
DPRINT1("Calling on dxg.sys pfnDdCreateSurface");
return pfnDdCreateSurface(hDirectDrawLocal,hSurface,puSurfaceDescription,puSurfaceGlobalData,
puSurfaceLocalData,puSurfaceMoreData,puCreateSurfaceData,puhSurface);
}
/************************************************************************/
/* NtGdiDdWaitForVerticalBlank */
/* status : Works as intended */
/************************************************************************/
DWORD STDCALL NtGdiDdWaitForVerticalBlank(
HANDLE hDirectDrawLocal,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
DWORD
STDCALL
NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PDD_DIRECTDRAW pDirectDraw = NULL;
NTSTATUS Status = FALSE;
DD_WAITFORVERTICALBLANKDATA WaitForVerticalBlankData;
LPDDHAL_WAITFORVERTICALBLANKDATA pWaitForVerticalBlankData = (LPDDHAL_WAITFORVERTICALBLANKDATA)puWaitForVerticalBlankData;
PGD_DXDDWAITFORVERTICALBLANK pfnDdWaitForVerticalBlank = NULL;
INT i;
if ((hDirectDrawLocal) &&
(puWaitForVerticalBlankData))
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdWaitForVerticalBlank, pfnDdWaitForVerticalBlank);
if (pfnDdWaitForVerticalBlank == NULL)
{
RtlZeroMemory(&WaitForVerticalBlankData,sizeof(DD_WAITFORVERTICALBLANKDATA));
_SEH_TRY
{
ProbeForRead(pWaitForVerticalBlankData, sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1);
WaitForVerticalBlankData.dwFlags = pWaitForVerticalBlankData->dwFlags;
WaitForVerticalBlankData.bIsInVB = pWaitForVerticalBlankData->bIsInVB;
WaitForVerticalBlankData.hEvent = pWaitForVerticalBlankData->hEvent;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
if(NT_SUCCESS(Status))
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (pDirectDraw != NULL)
{
if (pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
{
WaitForVerticalBlankData.ddRVal = DDERR_GENERIC;
WaitForVerticalBlankData.lpDD = &pDirectDraw->Global;;
ddRVal = pDirectDraw->DD.WaitForVerticalBlank(&WaitForVerticalBlankData);
}
_SEH_TRY
{
ProbeForWrite(pWaitForVerticalBlankData, sizeof(DDHAL_WAITFORVERTICALBLANKDATA), 1);
pWaitForVerticalBlankData->ddRVal = WaitForVerticalBlankData.ddRVal;
pWaitForVerticalBlankData->bIsInVB = WaitForVerticalBlankData.bIsInVB;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
}
DPRINT1("Warring no pfnDdWaitForVerticalBlank");
return DDHAL_DRIVER_NOTHANDLED;
}
return ddRVal;
DPRINT1("Calling on dxg.sys pfnDdWaitForVerticalBlank");
return pfnDdWaitForVerticalBlank(hDirectDraw, puWaitForVerticalBlankData);
}
/************************************************************************/
/* NtGdiDdCanCreateSurface */
/************************************************************************/
DWORD
STDCALL
NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
PGD_DDCANCREATESURFACE pfnDdCanCreateSurface = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCanCreateSurface, pfnDdCanCreateSurface);
if (pfnDdCanCreateSurface == NULL)
{
DPRINT1("Warring no pfnDdCanCreateSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdCanCreateSurface");
return pfnDdCanCreateSurface(hDirectDrawLocal,puCanCreateSurfaceData);
}
/************************************************************************/
/* NtGdiDdGetScanLine */
/************************************************************************/
DWORD
STDCALL
NtGdiDdGetScanLine(HANDLE hDirectDrawLocal,
PDD_GETSCANLINEDATA puGetScanLineData)
{
PGD_DXDDGETSCANLINE pfnDdGetScanLine = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetScanLine, pfnDdGetScanLine);
if (pfnDdGetScanLine == NULL)
{
DPRINT1("Warring no pfnDdGetScanLine");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetScanLine");
return pfnDdGetScanLine(hDirectDrawLocal,puGetScanLineData);
}
/************************************************************************/
/* CanCreateSurface */
/* status : Works as intended */
/* This is not part of the ddsurface interface but it have */
/* deal with the surface */
/************************************************************************/
DWORD STDCALL NtGdiDdCanCreateSurface(
HANDLE hDirectDrawLocal,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
)
/************************************************************************/
/* NtGdiDdCreateSurfaceEx */
/************************************************************************/
DWORD
STDCALL
NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw,
HANDLE hSurface,
DWORD dwSurfaceHandle)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PGD_DXDDCREATESURFACEEX pfnDdCreateSurfaceEx = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdCreateSurfaceEx, pfnDdCreateSurfaceEx);
if ((puCanCreateSurfaceData) &&
(hDirectDrawLocal))
if (pfnDdCreateSurfaceEx == NULL)
{
DDSURFACEDESC desc;
DWORD descSize = 0;
NTSTATUS Status = FALSE;
PDD_DIRECTDRAW pDirectDraw = NULL;
DD_CANCREATESURFACEDATA CanCreateSurfaceData;
LPDDHAL_CANCREATESURFACEDATA pCanCreateSurfaceData = (LPDDHAL_CANCREATESURFACEDATA)puCanCreateSurfaceData;
RtlZeroMemory(&CanCreateSurfaceData,sizeof(DDSURFACEDESC));
RtlZeroMemory(&desc,sizeof(DDSURFACEDESC));
_SEH_TRY
{
ProbeForRead(pCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1);
CanCreateSurfaceData.bIsDifferentPixelFormat = pCanCreateSurfaceData->bIsDifferentPixelFormat;
if (pCanCreateSurfaceData->lpDDSurfaceDesc)
{
ProbeForRead(pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1);
RtlCopyMemory(&desc,pCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC));
/*if it was DDSURFACEDESC2 been pass down */
descSize = desc.dwSize;
desc.dwSize = sizeof(DDSURFACEDESC);
}
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
if ((NT_SUCCESS(Status)) &&
(desc.dwSize != 0))
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if ((pDirectDraw) &&
(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
{
CanCreateSurfaceData.ddRVal = DDERR_GENERIC;
CanCreateSurfaceData.lpDD = &pDirectDraw->Global;
CanCreateSurfaceData.lpDDSurfaceDesc = &desc;
ddRVal = pDirectDraw->DD.CanCreateSurface(&CanCreateSurfaceData);
/*if it was DDSURFACEDESC2 been pass down */
desc.dwSize = descSize;
_SEH_TRY
{
ProbeForWrite(puCanCreateSurfaceData, sizeof(DDHAL_CANCREATESURFACEDATA), 1);
puCanCreateSurfaceData->ddRVal = CanCreateSurfaceData.ddRVal;
ProbeForWrite(puCanCreateSurfaceData->lpDDSurfaceDesc, sizeof(DDSURFACEDESC), 1);
RtlCopyMemory(puCanCreateSurfaceData->lpDDSurfaceDesc,&desc, sizeof(DDSURFACEDESC));
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
DPRINT1("Warring no pfnDdCreateSurfaceEx");
return DDHAL_DRIVER_NOTHANDLED;
}
return ddRVal;
DPRINT1("Calling on dxg.sys pfnDdCreateSurfaceEx");
return pfnDdCreateSurfaceEx(hDirectDraw,hSurface,dwSurfaceHandle);
}
/************************************************************************/
/* GetScanLine */
/* status : This func is now documented in MSDN, and now it's compatible*/
/* with Windows 2000 implementation */
/************************************************************************/
DWORD STDCALL
NtGdiDdGetScanLine( HANDLE hDirectDrawLocal, PDD_GETSCANLINEDATA puGetScanLineData)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
DD_GETSCANLINEDATA GetScanLineData;
PDD_DIRECTDRAW pDirectDraw = NULL;
NTSTATUS Status = FALSE;
LPDDHAL_GETSCANLINEDATA ourpuGetScanLineData;
if (hDirectDrawLocal)
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);;
}
if (pDirectDraw != NULL)
{
DPRINT1("GetScanLine\n");
if (pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE)
{
RtlZeroMemory(&GetScanLineData,sizeof(DD_GETSCANLINEDATA));
GetScanLineData.ddRVal = DDERR_GENERIC;
GetScanLineData.lpDD = &pDirectDraw->Global;
ddRVal = pDirectDraw->DD.GetScanLine(&GetScanLineData);
DPRINT1("GetScanLine\n");
_SEH_TRY
{
ProbeForWrite(puGetScanLineData, sizeof(DD_GETSCANLINEDATA), 1);
ourpuGetScanLineData = (LPDDHAL_GETSCANLINEDATA)puGetScanLineData;
ourpuGetScanLineData->dwScanLine = GetScanLineData.dwScanLine;
ourpuGetScanLineData->ddRVal = GetScanLineData.ddRVal;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
if (!NT_SUCCESS(Status))
{
DPRINT1("GetScanLine\n");
ddRVal = DDHAL_DRIVER_NOTHANDLED;
}
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
return ddRVal;
}

1399
reactos/subsystems/win32/win32k/ntddraw/ddraw.c
View file

File diff suppressed because it is too large Load diff

556
reactos/subsystems/win32/win32k/ntddraw/ddsurf.c
View file

@ -9,264 +9,350 @@
*/
#include <w32k.h>
#define NDEBUG
#include <debug.h>
#define DdHandleTable GdiHandleTable
DWORD STDCALL NtGdiDdBlt(
HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData
)
{
NTSTATUS Status = FALSE;
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
DD_BLTDATA Blt;
PDD_SURFACE pDstSurface = NULL;
PDD_SURFACE pSrcSurface = NULL;
PDD_DIRECTDRAW pDirectDraw;
DPRINT1("NtGdiDdBlt\n");
_SEH_TRY
{
ProbeForRead(puBltData, sizeof(DD_BLTDATA), 1);
RtlCopyMemory( &Blt, puBltData, sizeof( DD_BLTDATA ) );
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
if(!NT_SUCCESS(Status))
{
SetLastNtError(Status);
return ddRVal;
}
pDstSurface = GDIOBJ_LockObj(DdHandleTable, hSurfaceDest, GDI_OBJECT_TYPE_DD_SURFACE);
if (!pDstSurface)
{
DPRINT1("Fail\n");
return ddRVal;
}
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pDstSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (!pDirectDraw)
{
DPRINT1("Fail\n");
GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface);
return ddRVal;
}
if (pSrcSurface)
{
pSrcSurface = GDIOBJ_LockObj(DdHandleTable, pSrcSurface, GDI_OBJECT_TYPE_DD_SURFACE);
if (!pSrcSurface)
{
DPRINT1("Fail\n");
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDstSurface);
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
return ddRVal;
}
}
Blt.lpDDDestSurface = &pDstSurface->Local;
if (pDstSurface)
{
Blt.lpDDSrcSurface = &pDstSurface->Local;
}
Blt.ddRVal = DDERR_GENERIC;
/* MSDN say this member is always set to FALSE in windows 2000 or higher */
Blt.IsClipped = FALSE;
/* MSDN say this member is always unuse in windows 2000 or higher */
Blt.dwROPFlags = 0;
if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT)
{
Blt.lpDD = &pDirectDraw->Global;
Blt.Blt = NULL;
ddRVal = pDirectDraw->Surf.Blt(&Blt);
}
DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal);
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDstSurface);
if(pSrcSurface)
{
GDIOBJ_UnlockObjByPtr(DdHandleTable, pSrcSurface);
}
_SEH_TRY
{
ProbeForWrite(puBltData, sizeof(DD_BLTDATA), 1);
puBltData->ddRVal = Blt.ddRVal;
}
_SEH_HANDLE
{
Status = _SEH_GetExceptionCode();
}
_SEH_END;
DPRINT1("Retun value is %04x and driver return code is %04x\n",ddRVal,Blt.ddRVal);
return ddRVal;
}
/************************************************************************/
/* NtGdiDdCreateSurface */
/* status : untested */
/* NtGdiDdDestroySurface */
/************************************************************************/
DWORD STDCALL NtGdiDdDestroySurface(
HANDLE hSurface,
BOOL bRealDestroy
)
DWORD
STDCALL
NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PDD_SURFACE pSurface;
PDD_DIRECTDRAW pDirectDraw;
DD_DESTROYSURFACEDATA DestroySurf;
PGD_DXDDDESTROYSURFACE pfnDdDestroySurface = NULL;
INT i;
DPRINT1("NtGdiDdDestroySurface\n");
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdDestroySurface, pfnDdDestroySurface);
pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
if (pSurface != NULL)
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (pDirectDraw != NULL)
{
if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE)
{
//DestroySurf.lpDD = pSurface->Global;
DestroySurf.lpDDSurface = hSurface;
if (pfnDdDestroySurface == NULL)
{
DPRINT1("Warring no pfnDdDestroySurface");
return DDHAL_DRIVER_NOTHANDLED;
}
/* FIXME
in parma bRealDestroy
Specifies how to destroy the surface. Can be one of the following values.
TRUE = Destroy the surface and free video memory.
FALSE = Free the video memory but leave the surface in an uninitialized state
*/
DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface;
ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf);
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface);
}
return ddRVal;
DPRINT1("Calling on dxg.sys pfnDdDestroySurface");
return pfnDdDestroySurface(hSurface, bRealDestroy);
}
/************************************************************************/
/* NtGdiDdFlip */
/************************************************************************/
DWORD
STDCALL
NtGdiDdFlip(HANDLE hSurfaceCurrent,
HANDLE hSurfaceTarget,
HANDLE hSurfaceCurrentLeft,
HANDLE hSurfaceTargetLeft,
PDD_FLIPDATA puFlipData)
{
PGD_DXDDFLIP pfnDdDdFlip = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdFlip, pfnDdDdFlip);
if (pfnDdDdFlip == NULL)
{
DPRINT1("Warring no pfnDdDdFlip");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdDdFlip");
return pfnDdDdFlip(hSurfaceCurrent, hSurfaceTarget, hSurfaceCurrentLeft, hSurfaceTargetLeft, puFlipData);
}
/************************************************************************/
/* NtGdiDdUnlock */
/************************************************************************/
DWORD
STDCALL
NtGdiDdLock(HANDLE hSurface,
PDD_LOCKDATA puLockData,
HDC hdcClip)
{
PGD_DXDDLOCK pfnDdLock = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdLock, pfnDdLock);
if (pfnDdLock == NULL)
{
DPRINT1("Warring no pfnDdLock");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdLock");
return pfnDdLock(hSurface, puLockData, hdcClip);
}
/************************************************************************/
/* NtGdiDdunlock */
/************************************************************************/
DWORD
STDCALL
NtGdiDdUnlock(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
PGD_DXDDUNLOCK pfnDdUnlock = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnlock, pfnDdUnlock);
if (pfnDdUnlock == NULL)
{
DPRINT1("Warring no pfnDdUnlock");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUnlock");
return pfnDdUnlock(hSurface, puUnlockData);
}
/************************************************************************/
/* NtGdiDdBlt */
/************************************************************************/
DWORD
STDCALL
NtGdiDdBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
{
PGD_DDBLT pfnDdBlt = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdBlt, pfnDdBlt);
if (pfnDdBlt == NULL)
{
DPRINT1("Warring no pfnDdBlt");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdBlt");
return pfnDdBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
/************************************************************************/
/* NtGdiDdSetColorKey */
/************************************************************************/
DWORD
STDCALL
NtGdiDdSetColorKey(HANDLE hSurface,
PDD_SETCOLORKEYDATA puSetColorKeyData)
{
PGD_DXDDSETCOLORKEY pfnDdSetColorKey = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetColorKey, pfnDdSetColorKey);
if (pfnDdSetColorKey == NULL)
{
DPRINT1("Warring no pfnDdSetColorKey");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetColorKey");
return pfnDdSetColorKey(hSurface,puSetColorKeyData);
}
/************************************************************************/
/* NtGdiDdAddAttachedSurface */
/************************************************************************/
DWORD
STDCALL
NtGdiDdAddAttachedSurface(HANDLE hSurface,
HANDLE hSurfaceAttached,
PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData)
{
PGD_DDADDATTACHEDSURFACE pfnDdAddAttachedSurface = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAddAttachedSurface, pfnDdAddAttachedSurface);
if (pfnDdAddAttachedSurface == NULL)
{
DPRINT1("Warring no pfnDdAddAttachedSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAddAttachedSurface");
return pfnDdAddAttachedSurface(hSurface,hSurfaceAttached,puAddAttachedSurfaceData);
}
/************************************************************************/
/* NtGdiDdGetBltStatus */
/************************************************************************/
DWORD
STDCALL
NtGdiDdGetBltStatus(HANDLE hSurface,
PDD_GETBLTSTATUSDATA puGetBltStatusData)
{
PGD_DXDDGETBLTSTATUS pfnDdGetBltStatus = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetBltStatus, pfnDdGetBltStatus);
if (pfnDdGetBltStatus == NULL)
{
DPRINT1("Warring no pfnDdGetBltStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetBltStatus");
return pfnDdGetBltStatus(hSurface,puGetBltStatusData);
}
/************************************************************************/
/* NtGdiDdGetFlipStatus */
/************************************************************************/
DWORD
STDCALL
NtGdiDdGetFlipStatus(HANDLE hSurface,
PDD_GETFLIPSTATUSDATA puGetFlipStatusData)
{
PGD_DXDDGETFLIPSTATUS pfnDdGetFlipStatus = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdGetFlipStatus, pfnDdGetFlipStatus);
if (pfnDdGetFlipStatus == NULL)
{
DPRINT1("Warring no pfnDdGetFlipStatus");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetFlipStatus");
return pfnDdGetFlipStatus(hSurface,puGetFlipStatusData);
}
/************************************************************************/
/* NtGdiDdUpdateOverlay */
/************************************************************************/
DWORD
STDCALL
NtGdiDdUpdateOverlay(HANDLE hSurfaceDestination,
HANDLE hSurfaceSource,
PDD_UPDATEOVERLAYDATA puUpdateOverlayData)
{
PGD_DXDDUPDATEOVERLAY pfnDdUpdateOverlay = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUpdateOverlay, pfnDdUpdateOverlay);
if (pfnDdUpdateOverlay == NULL)
{
DPRINT1("Warring no pfnDdUpdateOverlay");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUpdateOverlay");
return pfnDdUpdateOverlay(hSurfaceDestination,hSurfaceSource,puUpdateOverlayData);
}
/************************************************************************/
/* NtGdiDdSetOverlayPosition */
/************************************************************************/
DWORD
STDCALL
NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource,
HANDLE hSurfaceDestination,
PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData)
{
PGD_DXDDSETOVERLAYPOSITION pfnDdSetOverlayPosition = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdSetOverlayPosition, pfnDdSetOverlayPosition);
if (pfnDdSetOverlayPosition == NULL)
{
DPRINT1("Warring no pfnDdSetOverlayPosition");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetOverlayPosition");
return pfnDdSetOverlayPosition(hSurfaceSource,hSurfaceDestination,puSetOverlayPositionData);
}
/************************************************************************/
/* This is not part of the ddsurface interface but it have */
/* deal with the surface */
/************************************************************************/
/************************************************************************/
/* NtGdiDdFlip */
/* status : untested */
/* NtGdiDdAlphaBlt */
/************************************************************************/
DWORD
STDCALL
NtGdiDdAlphaBlt(HANDLE hSurfaceDest,
HANDLE hSurfaceSrc,
PDD_BLTDATA puBltData)
{
PGD_DDALPHABLT pfnDdAlphaBlt = NULL;
INT i;
DWORD STDCALL NtGdiDdFlip(
HANDLE hSurfaceCurrent,
HANDLE hSurfaceTarget,
HANDLE hSurfaceCurrentLeft,
HANDLE hSurfaceTargetLeft,
PDD_FLIPDATA puFlipData
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAlphaBlt, pfnDdAlphaBlt);
if (pfnDdAlphaBlt == NULL)
{
DPRINT1("Warring no pfnDdAlphaBlt");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAlphaBlt");
return pfnDdAlphaBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
/************************************************************************/
/* NtGdiDdAttachSurface */
/************************************************************************/
BOOL
STDCALL
NtGdiDdAttachSurface(HANDLE hSurfaceFrom,
HANDLE hSurfaceTo
)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PDD_SURFACE pSurface;
PDD_DIRECTDRAW pDirectDraw;
DPRINT1("NtGdiDdFlip\n");
PGD_DDATTACHSURFACE pfnDdAttachSurface = NULL;
INT i;
/* DO we need looking all surface or is okay for one */
pSurface = GDIOBJ_LockObj(DdHandleTable, hSurfaceCurrent, GDI_OBJECT_TYPE_DD_SURFACE);
if (pSurface != NULL)
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdAttachSurface, pfnDdAttachSurface);
if (pDirectDraw != NULL)
{
if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP)
{
/* FIXME is lpDD typecasted tp driver PEV ?? */
ddRVal = pDirectDraw->Surf.Flip(puFlipData);
}
if (pfnDdAttachSurface == NULL)
{
DPRINT1("Warring no pfnDdAttachSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface);
}
return ddRVal;
DPRINT1("Calling on dxg.sys pfnDdAttachSurface");
return pfnDdAttachSurface(hSurfaceFrom,hSurfaceTo);
}
/************************************************************************/
/* NtGdiDdLock */
/* status : untested */
/* NtGdiDdUnattachSurface */
/************************************************************************/
DWORD STDCALL NtGdiDdLock(
HANDLE hSurface,
PDD_LOCKDATA puLockData,
HDC hdcClip)
{
DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
PDD_SURFACE pSurface;
PDD_DIRECTDRAW pDirectDraw;
DPRINT1("NtGdiDdLock\n");
pSurface = GDIOBJ_LockObj(DdHandleTable, hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
if (pSurface != NULL)
{
pDirectDraw = GDIOBJ_LockObj(DdHandleTable, pSurface->hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
if (pDirectDraw != NULL)
{
/* Do we need lock hdc from hdcClip ?? */
if (pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK)
{
/* FIXME is lpDD typecasted tp driver PEV ?? */
ddRVal = pDirectDraw->Surf.Lock(puLockData);
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pDirectDraw);
}
GDIOBJ_UnlockObjByPtr(DdHandleTable, pSurface);
}
return ddRVal;
}
/*
00414 PDD_SURFCB_SETCLIPLIST SetClipList;
00416 PDD_SURFCB_UNLOCK Unlock;
00417 PDD_SURFCB_BLT Blt;
00418 PDD_SURFCB_SETCOLORKEY SetColorKey;
00419 PDD_SURFCB_ADDATTACHEDSURFACE AddAttachedSurface;
00420 PDD_SURFCB_GETBLTSTATUS GetBltStatus;
00421 PDD_SURFCB_GETFLIPSTATUS GetFlipStatus;
00422 PDD_SURFCB_UPDATEOVERLAY UpdateOverlay;
00423 PDD_SURFCB_SETOVERLAYPOSITION SetOverlayPosition;
00424 PVOID reserved4;
00425 PDD_SURFCB_SETPALETTE SetPalette;
00426 } DD_SURFACECALLBACKS, *PDD_SURFACECALLBACKS;
/* Note : msdn protypes is VOID APIENTRY NtGdiDdUnattachSurface(HANDLE hSurface, HANDLE hSurfaceAttached)
But it say it return either DDHAL_DRIVER_NOTHANDLED or DDHAL_DRIVER_HANDLED
so I guess it is a typo in MSDN for this protypes for the info talk against it self
*/
DWORD
STDCALL
NtGdiDdUnattachSurface(HANDLE hSurface,
HANDLE hSurfaceAttached)
{
PGD_DXDDUNATTACHSURFACE pfnDdUnattachSurface = NULL;
INT i;
DXG_GET_INDEX_FUNCTION(DXG_INDEX_DxDdUnattachSurface, pfnDdUnattachSurface);
if (pfnDdUnattachSurface == NULL)
{
DPRINT1("Warring no pfnDdUnattachSurface");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUnattachSurface");
return pfnDdUnattachSurface(hSurface,hSurfaceAttached);
}

428
reactos/subsystems/win32/win32k/ntddraw/dvp.c Normal file
View file

@ -0,0 +1,428 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: subsys/win32k/ntddraw/dvd.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <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);
}

521
reactos/subsystems/win32/win32k/ntddraw/dxeng.c Normal file
View file

@ -0,0 +1,521 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native driver enumate of dxeng implementation
* FILE: subsys/win32k/ntddraw/dxeng.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 15/10-2007 Magnus Olsen
*/
#include <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;
}

200
reactos/subsystems/win32/win32k/ntddraw/eng.c Normal file
View file

@ -0,0 +1,200 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: subsys/win32k/ntddraw/dvd.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <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);
}

250
reactos/subsystems/win32/win32k/ntddraw/mocomp.c Normal file
View file

@ -0,0 +1,250 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: subsys/win32k/ntddraw/mocomp.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <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);
}

394
reactos/subsystems/win32/win32k/ntddraw/stubs.c
View file

@ -1,394 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw stubs
* FILE: subsys/win32k/ntddraw/stubs.c
* PROGRAMER: Peter Bajusz (hyp-x@stormregion.com)
* REVISION HISTORY:
* 25-10-2003 PB Created
*/
#include <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 */

4
reactos/subsystems/win32/win32k/objects/gdiobj.c
View file

@ -70,8 +70,8 @@ OBJ_TYPE_INFO ObjTypeInfo[] =
{
{0, 0, 0, NULL}, /* 00 reserved entry */
{1, sizeof(DC), GDI_OBJECT_TAG_DC, DC_Cleanup}, /* 01 DC */
{1, sizeof(DD_DIRECTDRAW), GDI_OBJECT_TAG_DDRAW, DD_Cleanup}, /* 02 DD_DDRAW, should be moved away from gdi objects */
{1, sizeof(DD_SURFACE), GDI_OBJECT_TAG_DDSURF, DDSURF_Cleanup}, /* 03 DD_SURFACE, should be moved away from gdi objects */
{1, 0, 0, 0}, /* 02 DD_DDRAW, should be moved away from gdi objects */
{1, 0, 0, 0}, /* 03 DD_SURFACE, should be moved away from gdi objects */
{1, sizeof(ROSRGNDATA), GDI_OBJECT_TAG_REGION, RGNDATA_Cleanup}, /* 04 REGION */
{1, sizeof(BITMAPOBJ), GDI_OBJECT_TAG_BITMAP, BITMAP_Cleanup}, /* 05 BITMAP */
{0, sizeof(DC), GDI_OBJECT_TAG_CLIOBJ, GDI_CleanupDummy}, /* 06 CLIOBJ: METADC,... FIXME: don't use DC struct */

329
reactos/subsystems/win32/win32k/stubs/stubs.c
View file

@ -851,31 +851,6 @@ EngQuerySystemAttribute(
return FALSE;
}
/*
* @unimplemented
*/
FLATPTR STDCALL
HeapVidMemAllocAligned(
IN LPVIDMEM lpVidMem,
IN DWORD dwWidth,
IN DWORD dwHeight,
IN LPSURFACEALIGNMENT lpAlignment,
OUT LPLONG lpNewPitch)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
VOID STDCALL
VidMemFree(
IN LPVMEMHEAP pvmh,
IN FLATPTR ptr)
{
UNIMPLEMENTED;
}
/*
* @unimplemented
@ -888,19 +863,6 @@ BRUSHOBJ_hGetColorTransform(
return NULL;
}
/*
* @unimplemented
*/
PVOID STDCALL
EngAllocPrivateUserMem(
IN PDD_SURFACE_LOCAL psl,
IN SIZE_T cj,
IN ULONG tag)
{
UNIMPLEMENTED;
return NULL;
}
/*
* @unimplemented
*/
@ -922,16 +884,7 @@ EngDeleteFile(
return FALSE;
}
/*
* @unimplemented
*/
VOID STDCALL
EngFreePrivateUserMem(
IN PDD_SURFACE_LOCAL psl,
IN PVOID pv)
{
UNIMPLEMENTED;
}
/*
* @unimplemented
@ -961,16 +914,7 @@ EngHangNotification(
return EHN_ERROR;
}
/*
* @unimplemented
*/
PDD_SURFACE_LOCAL STDCALL
EngLockDirectDrawSurface(
IN HANDLE Surface)
{
UNIMPLEMENTED;
return NULL;
}
/*
* @unimplemented
@ -1062,16 +1006,6 @@ EngStretchBltROP(
return FALSE;
}
/*
* @unimplemented
*/
BOOL STDCALL
EngUnlockDirectDrawSurface(
IN PDD_SURFACE_LOCAL Surface)
{
UNIMPLEMENTED;
return FALSE;
}
/*
* @unimplemented
@ -1970,88 +1904,6 @@ NtGdiFONTOBJ_pxoGetXform(IN FONTOBJ *pfo)
return NULL;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpCanCreateVideoPort(
IN HANDLE hDirectDraw,
IN OUT PDD_CANCREATEVPORTDATA puCanCreateVPortData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpColorControl(
IN HANDLE hVideoPort,
IN OUT PDD_VPORTCOLORDATA puVPortColorData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
HANDLE
STDCALL
NtGdiDvpCreateVideoPort(
IN HANDLE hDirectDraw,
IN OUT PDD_CREATEVPORTDATA puCreateVPortData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpDestroyVideoPort(
IN HANDLE hVideoPort,
IN OUT PDD_DESTROYVPORTDATA puDestroyVPortData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpFlipVideoPort(
IN HANDLE hVideoPort,
IN HANDLE hDDSurfaceCurrent,
IN HANDLE hDDSurfaceTarget,
IN OUT PDD_FLIPVPORTDATA puFlipVPortData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortBandwidth(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTBANDWIDTHDATA puGetVPortBandwidthData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
@ -2141,170 +1993,6 @@ NtGdiConvertMetafileRect(
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortFlipStatus(
IN HANDLE hDirectDraw,
IN OUT PDD_GETVPORTFLIPSTATUSDATA puGetVPortFlipStatusData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortInputFormats(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTINPUTFORMATDATA puGetVPortInputFormatData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortLine(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTLINEDATA puGetVPortLineData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortOutputFormats(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTOUTPUTFORMATDATA puGetVPortOutputFormatData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortConnectInfo(
IN HANDLE hDirectDraw,
IN OUT PDD_GETVPORTCONNECTDATA puGetVPortConnectData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoSignalStatus(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTSIGNALDATA puGetVPortSignalData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpUpdateVideoPort(
IN HANDLE hVideoPort,
IN HANDLE* phSurfaceVideo,
IN HANDLE* phSurfaceVbi,
IN OUT PDD_UPDATEVPORTDATA puUpdateVPortData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpWaitForVideoPortSync(
IN HANDLE hVideoPort,
IN OUT PDD_WAITFORVPORTSYNCDATA puWaitForVPortSyncData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpAcquireNotification(
IN HANDLE hVideoPort,
IN OUT HANDLE* hEvent,
IN LPDDVIDEOPORTNOTIFY pNotify)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpReleaseNotification(
IN HANDLE hVideoPort,
IN HANDLE hEvent)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDxgGenericThunk(
IN ULONG_PTR ulIndex,
IN ULONG_PTR ulHandle,
IN OUT SIZE_T *pdwSizeOfPtr1,
IN OUT PVOID pvPtr1,
IN OUT SIZE_T *pdwSizeOfPtr2,
IN OUT PVOID pvPtr2)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented
*/
@ -2557,19 +2245,6 @@ NtGdiGetEudcTimeStampEx(
return 0;
}
/*
* @unimplemented
*/
DWORD
STDCALL
NtGdiDvpGetVideoPortField(
IN HANDLE hVideoPort,
IN OUT PDD_GETVPORTFIELDDATA puGetVPortFieldData)
{
UNIMPLEMENTED;
return 0;
}
/*
* @unimplemented

14
reactos/subsystems/win32/win32k/win32k.def
View file

@ -1,3 +1,5 @@
; $Id$
;
; win32k.def
;
; ReactOS win32k.sys
@ -13,7 +15,6 @@ CLIPOBJ_ppoGetPath@4
EngAlphaBlend@28
EngAcquireSemaphore@4
EngAllocMem@12
EngAllocPrivateUserMem@12
EngAllocUserMem@8
EngAssociateSurface@12
EngBitBlt@44
@ -51,7 +52,6 @@ EngFindImageProcAddress@8
EngFindResource@16
EngFreeMem@4
EngFreeModule@4
EngFreePrivateUserMem@8
EngFreeUserMem@4
EngGetCurrentCodePage@8=ntoskrnl.RtlGetCurrentCodePage
EngGetCurrentProcessId@0
@ -149,7 +149,6 @@ FONTOBJ_pifi@4
FONTOBJ_pvTrueTypeFontFile@8
FONTOBJ_pxoGetXform@4
FONTOBJ_vGetInfo@12
HeapVidMemAllocAligned@20
HT_ComputeRGBGammaTable@24
HT_Get8BPPFormatPalette@16
PALOBJ_cGetColors@16
@ -173,7 +172,6 @@ RtlUpcaseUnicodeToMultiByteN@20=NTOSKRNL.RtlUpcaseUnicodeToMultiByteN
STROBJ_bEnum@12
STROBJ_dwGetCodePage@4
STROBJ_vEnumStart@4
VidMemFree@8
Win32kInitialize@0
WNDOBJ_bEnum@12
WNDOBJ_cEnumStart@16
@ -188,4 +186,12 @@ _abnormal_termination=NTOSKRNL._abnormal_termination
_except_handler2=NTOSKRNL._except_handler2
_global_unwind2=NTOSKRNL._global_unwind2
_local_unwind2=NTOSKRNL._local_unwind2
EngLockDirectDrawSurface@4
EngUnlockDirectDrawSurface@4
EngDxIoctl@12
EngAllocPrivateUserMem@12
HeapVidMemAllocAligned@20
VidMemFree@8
EngFreePrivateUserMem@8
;EOF

6
reactos/subsystems/win32/win32k/win32k.rbuild
View file

@ -95,7 +95,11 @@
<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>