Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-01-03 21:09:19 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/win32ss/reactx/ntddraw/ddraw.c
Oleg Dubinskiy e7ccb36b9b
[WIN32SS][NTDDRAW] Don't startup DirectX graphics each time on DirectDraw object creation (#5329) 
CORE-17561, CORE-17932, CORE-18221

Do it at each system startup instead: Remove old DirectX initialization code.
It's now outdated and not needed anymore.

Previously, the corresponding hackish intEnableReactXDriver() function
did two things: load dxg.sys and enable DirectDraw.
Now loading DirectX graphics is done during WINSRV initialization, and
enabling DirectDraw is called during each (and also first) display mode
switch, as in Windows. As debug analysis proves, there are no any other
calls in NtGdiDdCreateDirectDrawObject, besides the corresponding DXG
function.
2023-06-21 18:03:27 +02:00

573 lines
19 KiB
C
Raw Blame History

/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* FILE: win32ss/reactx/ntddraw/ddraw.c
* PROGRAMER: Magnus olsen (magnus@greatlord.com)
* REVISION HISTORY:
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
#include <debug.h>
PGD_DXDDSTARTUPDXGRAPHICS gpfnStartupDxGraphics = NULL;
PGD_DXDDCLEANUPDXGRAPHICS gpfnCleanupDxGraphics = NULL;
/* export from dxeng.c */
extern DRVFN gaEngFuncs[];
extern ULONG gcEngFuncs;
extern EDD_DIRECTDRAW_GLOBAL edd_DdirectDraw_Global;
DRVFN gpDxFuncs[DXG_INDEX_DxDdIoctl + 1];
HANDLE ghDxGraphics = NULL;
ULONG gdwDirectDrawContext = 0;
#define DXDBG 1
/************************************************************************/
/* DirectX graphic/video driver loading and cleanup starts here */
/************************************************************************/
NTSTATUS
APIENTRY
DxDdStartupDxGraphics( ULONG ulc1,
PDRVENABLEDATA DxEngDrvOld,
ULONG ulc2,
PDRVENABLEDATA DxgDrvOld,
PULONG DirectDrawContext,
PEPROCESS Proc)
{
DRVENABLEDATA DxEngDrv;
DRVENABLEDATA DxgDrv;
NTSTATUS Status = STATUS_PROCEDURE_NOT_FOUND;
/* FIXME: Setup of gaEngFuncs driver export list
* but not in this api, we can add it here tempary until we figout where
* no code have been writen for it yet
*/
/* FIXME: ReactOS does not loading the dxapi.sys or import functions from it yet */
// DxApiGetVersion()
/* Loading the kernel interface of DirectX for win32k */
DPRINT1("Warning: trying loading xp/2003/windows7/reactos dxg.sys\n");
ghDxGraphics = EngLoadImage(L"\\SystemRoot\\System32\\drivers\\dxg.sys");
if ( ghDxGraphics == NULL)
{
Status = STATUS_DLL_NOT_FOUND;
DPRINT1("Warning: no ReactX or DirectX kernel driver found\n");
}
else
{
/* Import DxDdStartupDxGraphics and DxDdCleanupDxGraphics */
gpfnStartupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdStartupDxGraphics");
gpfnCleanupDxGraphics = EngFindImageProcAddress(ghDxGraphics,"DxDdCleanupDxGraphics");
if ((gpfnStartupDxGraphics) &&
(gpfnCleanupDxGraphics))
{
/* Setup driver data for activate the dx interface */
DxEngDrv.iDriverVersion = DDI_DRIVER_VERSION_NT5_01;
DxEngDrv.pdrvfn = gaEngFuncs;
DxEngDrv.c = gcEngFuncs;
Status = gpfnStartupDxGraphics ( sizeof(DRVENABLEDATA),
&DxEngDrv,
sizeof(DRVENABLEDATA),
&DxgDrv,
&gdwDirectDrawContext,
Proc );
}
/* Check if we manage loading the data and execute the dxStartupDxGraphics if it is successful */
if (!NT_SUCCESS(Status))
{
gpfnStartupDxGraphics = NULL;
gpfnCleanupDxGraphics = NULL;
if (ghDxGraphics != NULL)
{
EngUnloadImage( ghDxGraphics);
ghDxGraphics = NULL;
}
DPRINT1("Warning: DirectX graphics interface can not be initialized\n");
}
else
{
/* Sort the drv functions list in index order, this allows us doing, smaller optimize
* in API that are redirect to dx.sys
*/
PDRVFN lstDrvFN = DxgDrv.pdrvfn;
INT t;
for (t=0;t<=DXG_INDEX_DxDdIoctl;t++)
{
gpDxFuncs[lstDrvFN[t].iFunc].iFunc =lstDrvFN[t].iFunc;
gpDxFuncs[lstDrvFN[t].iFunc].pfn =lstDrvFN[t].pfn;
}
DPRINT1("DirectX interface is activated\n");
}
/* Return the status */
}
return Status;
}
/************************************************************************/
/* DirectX graphic/video driver loading cleanup ends here */
/************************************************************************/
/************************************************************************/
/* NtGdiDdCreateDirectDrawObject */
/************************************************************************/
HANDLE
APIENTRY
NtGdiDdCreateDirectDrawObject(HDC hdc)
{
PGD_DDCREATEDIRECTDRAWOBJECT pfnDdCreateDirectDrawObject;
if (hdc == NULL)
{
DPRINT1("Warning: hdc is NULL\n");
return 0;
}
/* Get the pfnDdCreateDirectDrawObject after we load the drv */
pfnDdCreateDirectDrawObject = (PGD_DDCREATEDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdCreateDirectDrawObject].pfn;
if (pfnDdCreateDirectDrawObject == NULL)
{
DPRINT1("Warning: no pfnDdCreateDirectDrawObject\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateDirectDrawObject\n");
return pfnDdCreateDirectDrawObject(hdc);
}
/*++
* @name NtGdiDxgGenericThunk
* @implemented
*
* The function NtGdiDxgGenericThunk redirects DirectX calls to another function.
* It redirects to dxg.sys in Windows XP/2003, dxkrnl.sys in Vista and is fully implemented in win32k.sys in Windows 2000 and below
*
* @param ULONG_PTR ulIndex
* The functions we want to redirect
*
* @param ULONG_PTR ulHandle
* Unknown
*
* @param SIZE_T *pdwSizeOfPtr1
* Unknown
*
* @param PVOID pvPtr1
* Unknown
*
* @param SIZE_T *pdwSizeOfPtr2
* Unknown
*
* @param PVOID pvPtr2
* Unknown
*
* @return
* Always returns DDHAL_DRIVER_NOTHANDLED
*
* @remarks.
* dxg.sys NtGdiDxgGenericThunk calls are redirected to dxg.sys
* This function is no longer used but is still present in Windows NT 2000/XP/2003.
*
*--*/
DWORD
APIENTRY
NtGdiDxgGenericThunk(ULONG_PTR ulIndex,
ULONG_PTR ulHandle,
SIZE_T *pdwSizeOfPtr1,
PVOID pvPtr1,
SIZE_T *pdwSizeOfPtr2,
PVOID pvPtr2)
{
PGD_DXGENERICTRUNK pfnDxgGenericThunk = (PGD_DXGENERICTRUNK)gpDxFuncs[DXG_INDEX_DxDxgGenericThunk].pfn;
if (pfnDxgGenericThunk == NULL)
{
DPRINT1("Warning: no pfnDxgGenericThunk\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDxgGenericThunk\n");
return pfnDxgGenericThunk(ulIndex, ulHandle, pdwSizeOfPtr1, pvPtr1, pdwSizeOfPtr2, pvPtr2);
}
/************************************************************************/
/* NtGdiDdGetDriverState */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetDriverState(PDD_GETDRIVERSTATEDATA pdata)
{
PGD_DDGETDRIVERSTATE pfnDdGetDriverState = (PGD_DDGETDRIVERSTATE)gpDxFuncs[DXG_INDEX_DxDdGetDriverState].pfn;
if (pfnDdGetDriverState == NULL)
{
DPRINT1("Warning: no pfnDdGetDriverState\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdGetDriverState\n");
return pfnDdGetDriverState(pdata);
}
/************************************************************************/
/* NtGdiDdColorControl */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdColorControl(HANDLE hSurface,
PDD_COLORCONTROLDATA puColorControlData)
{
PGD_DDCOLORCONTROL pfnDdColorControl = (PGD_DDCOLORCONTROL)gpDxFuncs[DXG_INDEX_DxDdColorControl].pfn;
if (pfnDdColorControl == NULL)
{
DPRINT1("Warning: no pfnDdColorControl\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdColorControl\n");
return pfnDdColorControl(hSurface,puColorControlData);
}
/************************************************************************/
/* NtGdiDdCreateSurfaceObject */
/************************************************************************/
HANDLE
APIENTRY
NtGdiDdCreateSurfaceObject(HANDLE hDirectDrawLocal,
HANDLE hSurface,
PDD_SURFACE_LOCAL puSurfaceLocal,
PDD_SURFACE_MORE puSurfaceMore,
PDD_SURFACE_GLOBAL puSurfaceGlobal,
BOOL bComplete
)
{
PGD_DXDDCREATESURFACEOBJECT pfnDdCreateSurfaceObject = (PGD_DXDDCREATESURFACEOBJECT)gpDxFuncs[DXG_INDEX_DxDdCreateSurfaceObject].pfn;
if (pfnDdCreateSurfaceObject == NULL)
{
DPRINT1("Warning: no pfnDdCreateSurfaceObject\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurfaceObject\n");
return pfnDdCreateSurfaceObject(hDirectDrawLocal, hSurface, puSurfaceLocal, puSurfaceMore, puSurfaceGlobal, bComplete);
}
/************************************************************************/
/* NtGdiDdDeleteDirectDrawObject */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal)
{
PGD_DXDDDELETEDIRECTDRAWOBJECT pfnDdDeleteDirectDrawObject = (PGD_DXDDDELETEDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdDeleteDirectDrawObject].pfn;
if (pfnDdDeleteDirectDrawObject == NULL)
{
DPRINT1("Warning: no pfnDdDeleteDirectDrawObject\n");
return FALSE;
}
if (hDirectDrawLocal == NULL)
{
DPRINT1("Warning: hDirectDrawLocal is NULL\n");
return FALSE;
}
DPRINT1("hDirectDrawLocal = %p \n", hDirectDrawLocal);
DPRINT1("Calling dxg.sys pfnDdDeleteDirectDrawObject\n");
return pfnDdDeleteDirectDrawObject(hDirectDrawLocal);
}
/************************************************************************/
/* NtGdiDdDeleteSurfaceObject */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdDeleteSurfaceObject(HANDLE hSurface)
{
PGD_DXDDDELETESURFACEOBJECT pfnDdDeleteSurfaceObject = (PGD_DXDDDELETESURFACEOBJECT)gpDxFuncs[DXG_INDEX_DxDdDeleteSurfaceObject].pfn;
if (pfnDdDeleteSurfaceObject == NULL)
{
DPRINT1("Warning: no pfnDdDeleteSurfaceObject\n");
return DDHAL_DRIVER_NOTHANDLED;
}
/* Try and see if the handle is valid */
DPRINT1("Calling dxg.sys DdDeleteSurfaceObject\n");
return pfnDdDeleteSurfaceObject(hSurface);
}
/************************************************************************/
/* NtGdiDdQueryDirectDrawObject */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdQueryDirectDrawObject(HANDLE hDirectDrawLocal,
DD_HALINFO *pHalInfo,
DWORD *pCallBackFlags,
LPD3DNTHAL_CALLBACKS puD3dCallbacks,
LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
LPDDSURFACEDESC puD3dTextureFormats,
DWORD *puNumHeaps,
VIDEOMEMORY *puvmList,
DWORD *puNumFourCC,
DWORD *puFourCC)
{
PGD_DXDDQUERYDIRECTDRAWOBJECT pfnDdQueryDirectDrawObject = (PGD_DXDDQUERYDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdQueryDirectDrawObject].pfn;
if (pfnDdQueryDirectDrawObject == NULL)
{
DPRINT1("Warning: no pfnDdQueryDirectDrawObject\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdQueryDirectDrawObject\n");
return pfnDdQueryDirectDrawObject(hDirectDrawLocal, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData,
puD3dBufferCallbacks, puD3dTextureFormats, puNumHeaps, puvmList, puNumFourCC, puFourCC);
}
/************************************************************************/
/* NtGdiDdReenableDirectDrawObject */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal,
BOOL *pubNewMode)
{
#if DXDBG
BOOL status = FALSE;
#endif
PGD_DXDDREENABLEDIRECTDRAWOBJECT pfnDdReenableDirectDrawObject = (PGD_DXDDREENABLEDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdReenableDirectDrawObject].pfn;
if (pfnDdReenableDirectDrawObject == NULL)
{
DPRINT1("Warning: no pfnDdReenableDirectDrawObject\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdReenableDirectDrawObject\n");
#if DXDBG
status = pfnDdReenableDirectDrawObject(hDirectDrawLocal, pubNewMode);
DPRINT1("end Calling dxg.sys pfnDdReenableDirectDrawObject\n");
DPRINT1("return value : 0x%08x\n", status);
return status;
#else
return pfnDdReenableDirectDrawObject(hDirectDrawLocal, pubNewMode);
#endif
}
/************************************************************************/
/* NtGdiDdGetDriverInfo */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetDriverInfo(HANDLE hDirectDrawLocal,
PDD_GETDRIVERINFODATA puGetDriverInfoData)
{
PGD_DXDDGETDRIVERINFO pfnDdGetDriverInfo = (PGD_DXDDGETDRIVERINFO)gpDxFuncs[DXG_INDEX_DxDdGetDriverInfo].pfn;
if (pfnDdGetDriverInfo == NULL)
{
DPRINT1("Warning: no pfnDdGetDriverInfo\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDriverInfo\n");
return pfnDdGetDriverInfo(hDirectDrawLocal, puGetDriverInfoData);
}
/************************************************************************/
/* NtGdiDdGetAvailDriverMemory */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdGetAvailDriverMemory(HANDLE hDirectDrawLocal,
PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData)
{
PGD_DXDDGETAVAILDRIVERMEMORY pfnDdGetAvailDriverMemory = (PGD_DXDDGETAVAILDRIVERMEMORY)gpDxFuncs[DXG_INDEX_DxDdGetAvailDriverMemory].pfn;
if (pfnDdGetAvailDriverMemory == NULL)
{
DPRINT1("Warning: no pfnDdGetAvailDriverMemory\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetAvailDriverMemory\n");
return pfnDdGetAvailDriverMemory(hDirectDrawLocal, puGetAvailDriverMemoryData);
}
/************************************************************************/
/* NtGdiDdSetExclusiveMode */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdSetExclusiveMode(HANDLE hDirectDraw,
PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData)
{
PGD_DXDDSETEXCLUSIVEMODE pfnDdSetExclusiveMode = (PGD_DXDDSETEXCLUSIVEMODE)gpDxFuncs[DXG_INDEX_DxDdSetExclusiveMode].pfn;
if (pfnDdSetExclusiveMode == NULL)
{
DPRINT1("Warning: no pfnDdSetExclusiveMode\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdSetExclusiveMode\n");
return pfnDdSetExclusiveMode(hDirectDraw, puSetExclusiveModeData);
}
/************************************************************************/
/* NtGdiDdFlipToGDISurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdFlipToGDISurface(HANDLE hDirectDraw,
PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData)
{
PGD_DXDDFLIPTOGDISURFACE pfnDdFlipToGDISurface = (PGD_DXDDFLIPTOGDISURFACE)gpDxFuncs[DXG_INDEX_DxDdFlipToGDISurface].pfn;
if (pfnDdFlipToGDISurface == NULL)
{
DPRINT1("Warning: no pfnDdFlipToGDISurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdFlipToGDISurface\n");
return pfnDdFlipToGDISurface(hDirectDraw, puFlipToGDISurfaceData);
}
/************************************************************************/
/* NtGdiDdGetDC */
/************************************************************************/
HDC
APIENTRY
NtGdiDdGetDC(HANDLE hSurface,
PALETTEENTRY *puColorTable)
{
PGD_DDGETDC pfnDdGetDC = (PGD_DDGETDC)gpDxFuncs[DXG_INDEX_DxDdGetDC].pfn;
if (pfnDdGetDC == NULL)
{
DPRINT1("Warning: no pfnDdGetDC\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDC\n");
return pfnDdGetDC(hSurface, puColorTable);
}
/************************************************************************/
/* NtGdiDdGetDxHandle */
/************************************************************************/
HANDLE
APIENTRY
NtGdiDdGetDxHandle(HANDLE hDirectDraw,
HANDLE hSurface,
BOOL bRelease)
{
PGD_DDGETDXHANDLE pfnDdGetDxHandle = (PGD_DDGETDXHANDLE)gpDxFuncs[DXG_INDEX_DxDdGetDxHandle].pfn;
if (pfnDdGetDxHandle == NULL)
{
DPRINT1("Warning: no pfnDdGetDxHandle\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDxHandle\n");
return pfnDdGetDxHandle(hDirectDraw, hSurface, bRelease);
}
/************************************************************************/
/* NtGdiDdReleaseDC */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdReleaseDC(HANDLE hSurface)
{
PGD_DDRELEASEDC pfnDdReleaseDC = (PGD_DDRELEASEDC)gpDxFuncs[DXG_INDEX_DxDdReleaseDC].pfn;
if (pfnDdReleaseDC == NULL)
{
DPRINT1("Warning: no pfnDdReleaseDC\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdReleaseDC\n");
return pfnDdReleaseDC(hSurface);
}
/************************************************************************/
/* NtGdiDdResetVisrgn */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdResetVisrgn(HANDLE hSurface,
HWND hwnd)
{
PGD_DDRESTVISRGN pfnDdResetVisrgn = (PGD_DDRESTVISRGN)gpDxFuncs[DXG_INDEX_DxDdResetVisrgn].pfn;
if (pfnDdResetVisrgn == NULL)
{
DPRINT1("Warning: no pfnDdResetVisrgn\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdResetVisrgn\n");
return pfnDdResetVisrgn(hSurface, hwnd);
}
/************************************************************************/
/* NtGdiDdSetGammaRamp */
/************************************************************************/
BOOL
APIENTRY
NtGdiDdSetGammaRamp(HANDLE hDirectDraw,
HDC hdc,
LPVOID lpGammaRamp)
{
PGD_DDSETGAMMARAMP pfnDdSetGammaRamp = (PGD_DDSETGAMMARAMP)gpDxFuncs[DXG_INDEX_DxDdSetGammaRamp].pfn;
if (pfnDdSetGammaRamp == NULL)
{
DPRINT1("Warning: no pfnDdSetGammaRamp\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdSetGammaRamp\n");
return pfnDdSetGammaRamp(hDirectDraw, hdc, lpGammaRamp);
}
Reference in a new issue View git blame Copy permalink