Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-27 09:34:43 +00:00
Code Issues Projects Releases Packages Wiki Activity

[NTDDRAW][NTGDI][VGADDI] Add missing \n to DPRINT() calls (#5952)

Browse source 
Add missing \n to DPRINT() calls and demote some DPRINT1().
This commit is contained in:
Serge Gautherie 2023-11-15 21:07:27 +01:00 committed by GitHub
parent bd0a5498b0
commit 24757e30e9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 237 additions and 315 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
win32ss/drivers/displays/vga/main/enable.c
View file

@ -281,7 +281,6 @@ DrvEnablePDEV(IN DEVMODEW *DM,
return (DHPDEV) PDev;
}
// DrvCompletePDEV
// DESCRIPTION
// Called after initialization of PDEV is complete. Supplies
@ -294,7 +293,6 @@ DrvCompletePDEV(IN DHPDEV PDev,
((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC
}
BOOL APIENTRY
DrvAssertMode(IN DHPDEV DPev,
IN BOOL Enable)
@ -324,7 +322,7 @@ DrvAssertMode(IN DHPDEV DPev,
else
{
/* Go back to last known mode */
DPRINT( "ppdev: %x, KMDriver: %x", ppdev, ppdev->KMDriver );
DPRINT("ppdev: %p, KMDriver: %p\n", ppdev, ppdev->KMDriver);
if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength))
{
/* Failed to go back to mode */
@ -335,7 +333,6 @@ DrvAssertMode(IN DHPDEV DPev,
return TRUE;
}
VOID APIENTRY
DrvDisablePDEV(IN DHPDEV PDev)
{
@ -352,7 +349,6 @@ DrvDisablePDEV(IN DHPDEV PDev)
EngFreeMem(PDev);
}
VOID APIENTRY
DrvDisableSurface(IN DHPDEV PDev)
{
@ -389,7 +385,6 @@ DrvDisableSurface(IN DHPDEV PDev)
/* EngFreeMem(pdsurf); */ /* free the surface */
}
static VOID
InitSavedBits(IN PPDEV ppdev)
{
@ -429,7 +424,6 @@ InitSavedBits(IN PPDEV ppdev)
ppdev->BitsSaved = FALSE;
}
HSURF APIENTRY
DrvEnableSurface(IN DHPDEV PDev)
{
@ -516,7 +510,6 @@ error_done:
return NULL;
}
ULONG APIENTRY
DrvGetModes(IN HANDLE Driver,
IN ULONG DataSize,

6
win32ss/gdi/ntgdi/dibobj.c
View file

@ -275,7 +275,7 @@ IntSetDIBits(
else
{
/* Compressed format without a size. This is invalid. */
DPRINT1("Compressed format without a size!");
DPRINT1("Compressed format without a size\n");
return 0;
}
@ -711,7 +711,6 @@ Exit:
return ret;
}
/* Converts a device-dependent bitmap to a DIB */
INT
APIENTRY
@ -1218,7 +1217,6 @@ cleanup:
return iResult;
}
W32KAPI
INT
APIENTRY
@ -1537,7 +1535,6 @@ NtGdiStretchDIBitsInternal(
return LinesCopied;
}
HBITMAP
FASTCALL
IntCreateDIBitmap(
@ -2019,7 +2016,6 @@ DIB_CreateDIBSection(
// hSecure = MmSecureVirtualMemory(bm.bmBits, totalSize, PAGE_READWRITE);
hSecure = (HANDLE)0x1; // HACK OF UNIMPLEMENTED KERNEL STUFF !!!!
// Create Device Dependent Bitmap and add DIB pointer
//Size.cx = bm.bmWidth;
//Size.cy = abs(bm.bmHeight);

21
win32ss/gdi/ntgdi/region.c
View file

@ -120,7 +120,6 @@ SOFTWARE.
//
//
#include <win32k.h>
#include <suppress.h>
@ -252,7 +251,6 @@ typedef struct
INT incr1, incr2; /* Error increments */
} BRESINFO;
#define BRESINITPGONSTRUCT(dmaj, min1, min2, bres) \
BRESINITPGON(dmaj, min1, min2, bres.minor_axis, bres.d, \
bres.m, bres.m1, bres.incr1, bres.incr2)
@ -260,8 +258,6 @@ typedef struct
#define BRESINCRPGONSTRUCT(bres) \
BRESINCRPGON(bres.d, bres.minor_axis, bres.m, bres.m1, bres.incr1, bres.incr2)
/*
* These are the data structures needed to scan
* convert regions. Two different scan conversion
@ -324,7 +320,6 @@ typedef struct _EDGE_TABLE_ENTRY
INT ClockWise; /* Flag for winding number rule */
} EDGE_TABLE_ENTRY;
typedef struct _SCANLINE_LIST
{
INT scanline; /* The scanline represented */
@ -332,7 +327,6 @@ typedef struct _SCANLINE_LIST
struct _SCANLINE_LIST *next; /* Next in the list */
} SCANLINE_LIST;
typedef struct
{
INT ymax; /* ymax for the polygon */
@ -340,7 +334,6 @@ typedef struct
SCANLINE_LIST scanlines; /* Header node */
} EDGE_TABLE;
/*
* Here is a struct to help with storage allocation
* so we can allocate a big chunk at a time, and then take
@ -354,7 +347,6 @@ typedef struct _SCANLINE_LISTBLOCK
struct _SCANLINE_LISTBLOCK *next;
} SCANLINE_LISTBLOCK;
/*
* A few macros for the inner loops of the fill code where
* performance considerations don't allow a procedure call.
@ -382,7 +374,6 @@ typedef struct _SCANLINE_LISTBLOCK
} \
}
/*
* Evaluate the given edge at the given scanline.
* If the edge has expired, then we leave it and fix up
@ -561,7 +552,6 @@ IntDumpRegion(HRGN hRgn)
}
#endif /* Not NDEBUG */
INT
FASTCALL
REGION_Complexity(PREGION prgn)
@ -569,7 +559,7 @@ REGION_Complexity(PREGION prgn)
if (prgn == NULL)
return NULLREGION;
DPRINT("Region Complexity -> %lu", prgn->rdh.nCount);
DPRINT("Region Complexity: %lu\n", prgn->rdh.nCount);
switch (prgn->rdh.nCount)
{
case 0:
@ -801,7 +791,6 @@ empty:
return NULLREGION;
}
/*!
* Attempt to merge the rects in the current band with those in the
* previous one. Used only by REGION_RegionOp.
@ -1597,7 +1586,6 @@ REGION_SubtractNonO1(
return TRUE;
}
/*!
* Overlapping band subtraction. x1 is the left-most point not yet
* checked.
@ -1803,7 +1791,6 @@ REGION_XorRegion(
return ret;
}
/*!
* Adds a rectangle to a REGION
*/
@ -2210,10 +2197,8 @@ REGION_bXformRgn(
return bResult;
}
}
PREGION
FASTCALL
REGION_AllocRgnWithHandle(
@ -2304,7 +2289,6 @@ REGION_bAllocRgnAttr(
return TRUE;
}
//
// Allocate User Space Region Handle.
//
@ -2596,7 +2580,6 @@ IntGdiGetRgnBox(
return ret;
}
BOOL
FASTCALL
REGION_PtInRegion(
@ -3051,7 +3034,6 @@ REGION_FreeStorage(
}
}
/***********************************************************************
* REGION_PtsToRegion
*
@ -3524,7 +3506,6 @@ IntRectInRegion(
return Ret;
}
//
// NtGdi Exported Functions
//

73
win32ss/reactx/ntddraw/d3d.c
View file

@ -14,8 +14,9 @@
*/
#include <win32k.h>
#include <debug.h>
// #define NDEBUG
#include <debug.h>
/*++
* @name NtGdiDdCanCreateD3DBuffer
@ -54,7 +55,6 @@
* the correct struct is LPDDHAL_CANCREATESURFACEDATA.
*
*--*/
DWORD
APIENTRY
NtGdiDdCanCreateD3DBuffer(HANDLE hDirectDraw,
@ -64,11 +64,11 @@ NtGdiDdCanCreateD3DBuffer(HANDLE hDirectDraw,
if (pfnDdCanCreateD3DBuffer == NULL)
{
DPRINT1("Warring no pfnDdCanCreateD3DBuffer");
DPRINT1("Warning: no pfnDdCanCreateD3DBuffer\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdCanCreateD3DBuffer");
DPRINT("Calling dxg.sys pfnDdCanCreateD3DBuffer\n");
return pfnDdCanCreateD3DBuffer(hDirectDraw,puCanCreateSurfaceData);
}
@ -112,7 +112,7 @@ NtGdiDdCanCreateD3DBuffer(HANDLE hDirectDraw,
* Do not forget LPD3DNTHAL_CONTEXTCREATEDATA is typecast of LPD3DHAL_CONTEXTCREATEDATA and thuse two struct are different size,
* the correct struct is LPD3DHAL_CONTEXTCREATEDATA.
*--*/
BOOL
BOOL
APIENTRY
NtGdiD3dContextCreate(HANDLE hDirectDrawLocal,
HANDLE hSurfColor,
@ -123,11 +123,11 @@ NtGdiD3dContextCreate(HANDLE hDirectDrawLocal,
if (pfnD3dContextCreate == NULL)
{
DPRINT1("Warning: no pfnD3dContextCreate");
DPRINT1("Warning: no pfnD3dContextCreate\n");
return FALSE;
}
DPRINT1("Calling dxg.sys D3dContextCreate");
DPRINT("Calling dxg.sys pfnD3dContextCreate\n");
return pfnD3dContextCreate(hDirectDrawLocal, hSurfColor, hSurfZ, pdcci);
}
@ -158,11 +158,11 @@ NtGdiD3dContextDestroy(LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData)
if ( pfnD3dContextDestroy == NULL)
{
DPRINT1("Warning: no pfnD3dContextDestroy");
DPRINT1("Warning: no pfnD3dContextDestroy\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dContextDestroy");
DPRINT("Calling dxg.sys pfnD3dContextDestroy\n");
return pfnD3dContextDestroy(pContextDestroyData);
}
@ -196,11 +196,11 @@ NtGdiD3dContextDestroyAll(LPD3DNTHAL_CONTEXTDESTROYALLDATA pdcad)
if (pfnD3dContextDestroyAll == NULL)
{
DPRINT1("Warning: no pfnD3dContextDestroyAll");
DPRINT1("Warning: no pfnD3dContextDestroyAll\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dContextDestroyAll");
DPRINT("Calling dxg.sys pfnD3dContextDestroyAll\n");
return pfnD3dContextDestroyAll(pdcad);
}
@ -271,11 +271,11 @@ NtGdiDdCreateD3DBuffer(HANDLE hDirectDraw,
if (pfnDdCreateD3DBuffer == NULL)
{
DPRINT1("Warning: no pfnDdCreateD3DBuffer");
DPRINT1("Warning: no pfnDdCreateD3DBuffer\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateD3DBuffer");
DPRINT("Calling dxg.sys pfnDdCreateD3DBuffer\n");
return pfnDdCreateD3DBuffer(hDirectDraw, hSurface,
puSurfaceDescription, puSurfaceGlobalData,
puSurfaceLocalData, puSurfaceMoreData,
@ -289,15 +289,16 @@ DWORD
APIENTRY
NtGdiDdDestroyD3DBuffer(HANDLE hSurface)
{
PGD_DXDDDESTROYD3DBUFFER pfnDdDestroyD3DBuffer = (PGD_DXDDDESTROYD3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdDestroyD3DBuffer].pfn;
PGD_DXDDDESTROYD3DBUFFER pfnDdDestroyD3DBuffer =
(PGD_DXDDDESTROYD3DBUFFER)gpDxFuncs[DXG_INDEX_DxDdDestroyD3DBuffer].pfn;
if (pfnDdDestroyD3DBuffer == NULL)
{
DPRINT1("Warning: no pfnDdDestroyD3DBuffer");
DPRINT1("Warning: no pfnDdDestroyD3DBuffer\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdDestroyD3DBuffer");
DPRINT("Calling dxg.sys pfnDdDestroyD3DBuffer\n");
return pfnDdDestroyD3DBuffer(hSurface);
}
@ -314,19 +315,19 @@ NtGdiD3dDrawPrimitives2(HANDLE hCmdBuf,
FLATPTR *pfpVidMemVtx,
DWORD *pdwSizeVtx)
{
PGD_D3DDRAWPRIMITIVES2 pfnD3dDrawPrimitives2 = (PGD_D3DDRAWPRIMITIVES2)gpDxFuncs[DXG_INDEX_DxD3dDrawPrimitives2].pfn;
PGD_D3DDRAWPRIMITIVES2 pfnD3dDrawPrimitives2 =
(PGD_D3DDRAWPRIMITIVES2)gpDxFuncs[DXG_INDEX_DxD3dDrawPrimitives2].pfn;
if (pfnD3dDrawPrimitives2 == NULL)
{
DPRINT1("Warning: no pfnD3dDrawPrimitives2");
DPRINT1("Warning: no pfnD3dDrawPrimitives2\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dDrawPrimitives2");
DPRINT("Calling dxg.sys pfnD3dDrawPrimitives2\n");
return pfnD3dDrawPrimitives2(hCmdBuf,hVBuf,pded,pfpVidMemCmd,pdwSizeCmd,pfpVidMemVtx,pdwSizeVtx);
}
/************************************************************************/
/* NtGdiD3dValidateTextureStageState */
/************************************************************************/
@ -335,15 +336,15 @@ APIENTRY
NtGdiDdLockD3D(HANDLE hSurface,
PDD_LOCKDATA puLockData)
{
PGD_DXDDLOCKD3D pfnDdLockD3D = (PGD_DXDDLOCKD3D)gpDxFuncs[DXG_INDEX_DxDdLockD3D].pfn;
PGD_DXDDLOCKD3D pfnDdLockD3D = (PGD_DXDDLOCKD3D)gpDxFuncs[DXG_INDEX_DxDdLockD3D].pfn;
if (pfnDdLockD3D == NULL)
{
DPRINT1("Warning: no pfnDdLockD3D");
DPRINT1("Warning: no pfnDdLockD3D\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdLockD3D");
DPRINT("Calling dxg.sys pfnDdLockD3D\n");
return pfnDdLockD3D(hSurface, puLockData);
}
@ -354,15 +355,16 @@ DWORD
APIENTRY
NtGdiD3dValidateTextureStageState(LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData)
{
PGD_D3DVALIDATETEXTURESTAGESTATE pfnD3dValidateTextureStageState = (PGD_D3DVALIDATETEXTURESTAGESTATE)gpDxFuncs[DXG_INDEX_DxD3dValidateTextureStageState].pfn;
PGD_D3DVALIDATETEXTURESTAGESTATE pfnD3dValidateTextureStageState =
(PGD_D3DVALIDATETEXTURESTAGESTATE)gpDxFuncs[DXG_INDEX_DxD3dValidateTextureStageState].pfn;
if (pfnD3dValidateTextureStageState == NULL)
{
DPRINT1("Warning: no pfnD3dValidateTextureStageState");
DPRINT1("Warning: no pfnD3dValidateTextureStageState\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys D3dValidateTextureStageState");
DPRINT("Calling dxg.sys pfnD3dValidateTextureStageState\n");
return pfnD3dValidateTextureStageState(pData);
}
@ -375,18 +377,13 @@ NtGdiDdUnlockD3D(HANDLE hSurface,
PDD_UNLOCKDATA puUnlockData)
{
PGD_DXDDUNLOCKD3D pfnDdUnlockD3D = (PGD_DXDDUNLOCKD3D)gpDxFuncs[DXG_INDEX_DxDdUnlockD3D].pfn;
if (pfnDdUnlockD3D == NULL)
{
DPRINT1("Warning: no pfnDdUnlockD3D");
DPRINT1("Warning: no pfnDdUnlockD3D\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdUnlockD3D");
DPRINT("Calling dxg.sys pfnDdUnlockD3D\n");
return pfnDdUnlockD3D(hSurface, puUnlockData);
}

13
win32ss/reactx/ntddraw/d3dkmt.c
View file

@ -7,7 +7,6 @@
*/
#include <win32k.h>
#include <debug.h>
DWORD
APIENTRY
@ -39,10 +38,10 @@ NtGdiDdDDICreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *desc)
{ D3DDDIFMT_P8, 8, BI_RGB, 256, 0x00000000, 0x00000000, 0x00000000 },
};
if (!desc)
if (!desc)
return STATUS_INVALID_PARAMETER;
if (!desc->pMemory)
if (!desc->pMemory)
return STATUS_INVALID_PARAMETER;
for (i = 0; i < sizeof(format_info) / sizeof(*format_info); ++i)
@ -54,7 +53,7 @@ NtGdiDdDDICreateDCFromMemory(D3DKMT_CREATEDCFROMMEMORY *desc)
}
}
if (!format)
if (!format)
return STATUS_INVALID_PARAMETER;
if (desc->Width > (UINT_MAX & ~3) / (format->bit_count / 8) ||
@ -109,11 +108,11 @@ DWORD
APIENTRY
NtGdiDdDDIDestroyDCFromMemory(const D3DKMT_DESTROYDCFROMMEMORY *desc)
{
if (!desc)
if (!desc)
return STATUS_INVALID_PARAMETER;
if (GDI_HANDLE_GET_TYPE(desc->hDc) != GDI_OBJECT_TYPE_DC ||
GDI_HANDLE_GET_TYPE(desc->hBitmap) != GDI_OBJECT_TYPE_BITMAP)
if (GDI_HANDLE_GET_TYPE(desc->hDc) != GDI_OBJECT_TYPE_DC ||
GDI_HANDLE_GET_TYPE(desc->hBitmap) != GDI_OBJECT_TYPE_BITMAP)
return STATUS_INVALID_PARAMETER;
NtGdiDeleteObjectApp(desc->hBitmap);

26
win32ss/reactx/ntddraw/dd.c
View file

@ -9,6 +9,8 @@
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
/************************************************************************/
@ -26,14 +28,14 @@ NtGdiDdCreateSurface(HANDLE hDirectDrawLocal,
HANDLE *puhSurface)
{
PGD_DDCREATESURFACE pfnDdCreateSurface = (PGD_DDCREATESURFACE)gpDxFuncs[DXG_INDEX_DxDdCreateSurface].pfn;
if (pfnDdCreateSurface == NULL)
{
DPRINT1("Warning: no pfnDdCreateSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurface\n");
DPRINT("Calling dxg.sys pfnDdCreateSurface\n");
return pfnDdCreateSurface(hDirectDrawLocal,hSurface,puSurfaceDescription,puSurfaceGlobalData,
puSurfaceLocalData,puSurfaceMoreData,puCreateSurfaceData,puhSurface);
}
@ -47,14 +49,14 @@ NtGdiDdWaitForVerticalBlank(HANDLE hDirectDraw,
PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData)
{
PGD_DXDDWAITFORVERTICALBLANK pfnDdWaitForVerticalBlank = (PGD_DXDDWAITFORVERTICALBLANK)gpDxFuncs[DXG_INDEX_DxDdWaitForVerticalBlank].pfn;
if (pfnDdWaitForVerticalBlank == NULL)
{
DPRINT1("Warning: no pfnDdWaitForVerticalBlank\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdWaitForVerticalBlank\n");
DPRINT("Calling dxg.sys pfnDdWaitForVerticalBlank\n");
return pfnDdWaitForVerticalBlank(hDirectDraw, puWaitForVerticalBlankData);
}
@ -67,14 +69,14 @@ NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
PDD_CANCREATESURFACEDATA puCanCreateSurfaceData)
{
PGD_DDCANCREATESURFACE pfnDdCanCreateSurface = (PGD_DDCANCREATESURFACE)gpDxFuncs[DXG_INDEX_DxDdCanCreateSurface].pfn;
if (pfnDdCanCreateSurface == NULL)
{
DPRINT1("Warning: no pfnDdCanCreateSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCanCreateSurface\n");
DPRINT("Calling dxg.sys pfnDdCanCreateSurface\n");
return pfnDdCanCreateSurface(hDirectDrawLocal,puCanCreateSurfaceData);
}
@ -83,19 +85,19 @@ NtGdiDdCanCreateSurface(HANDLE hDirectDrawLocal,
/* NtGdiDdGetScanLine */
/************************************************************************/
DWORD
APIENTRY
APIENTRY
NtGdiDdGetScanLine(HANDLE hDirectDrawLocal,
PDD_GETSCANLINEDATA puGetScanLineData)
{
PGD_DXDDGETSCANLINE pfnDdGetScanLine = (PGD_DXDDGETSCANLINE)gpDxFuncs[DXG_INDEX_DxDdGetScanLine].pfn;
if (pfnDdGetScanLine == NULL)
{
DPRINT1("Warning: no pfnDdGetScanLine\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetScanLine\n");
DPRINT("Calling dxg.sys pfnDdGetScanLine\n");
return pfnDdGetScanLine(hDirectDrawLocal,puGetScanLineData);
}
@ -116,15 +118,13 @@ NtGdiDdCreateSurfaceEx(HANDLE hDirectDraw,
DWORD dwSurfaceHandle)
{
PGD_DXDDCREATESURFACEEX pfnDdCreateSurfaceEx = (PGD_DXDDCREATESURFACEEX)gpDxFuncs[DXG_INDEX_DxDdCreateSurfaceEx].pfn;
if (pfnDdCreateSurfaceEx == NULL)
{
DPRINT1("Warning: no pfnDdCreateSurfaceEx\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurfaceEx\n");
DPRINT("Calling dxg.sys pfnDdCreateSurfaceEx\n");
return pfnDdCreateSurfaceEx(hDirectDraw,hSurface,dwSurfaceHandle);
}

64
win32ss/reactx/ntddraw/ddraw.c
View file

@ -9,6 +9,8 @@
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
PGD_DXDDSTARTUPDXGRAPHICS gpfnStartupDxGraphics = NULL;
@ -19,7 +21,6 @@ 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;
@ -48,7 +49,6 @@ DxDdStartupDxGraphics( ULONG ulc1,
* no code have been writen for it yet
*/
/* FIXME: ReactOS does not loading the dxapi.sys or import functions from it yet */
// DxApiGetVersion()
@ -109,12 +109,11 @@ DxDdStartupDxGraphics( ULONG ulc1,
gpDxFuncs[lstDrvFN[t].iFunc].pfn =lstDrvFN[t].pfn;
}
DPRINT1("DirectX interface is activated\n");
DPRINT("DirectX interface is activated\n");
}
/* Return the status */
}
/* Return the status */
return Status;
}
@ -146,7 +145,7 @@ NtGdiDdCreateDirectDrawObject(HDC hdc)
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateDirectDrawObject\n");
DPRINT("Calling dxg.sys pfnDdCreateDirectDrawObject\n");
return pfnDdCreateDirectDrawObject(hdc);
}
@ -201,7 +200,7 @@ NtGdiDxgGenericThunk(ULONG_PTR ulIndex,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDxgGenericThunk\n");
DPRINT("Calling dxg.sys pfnDxgGenericThunk\n");
return pfnDxgGenericThunk(ulIndex, ulHandle, pdwSizeOfPtr1, pvPtr1, pdwSizeOfPtr2, pvPtr2);
}
@ -220,7 +219,7 @@ NtGdiDdGetDriverState(PDD_GETDRIVERSTATEDATA pdata)
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdGetDriverState\n");
DPRINT("Calling dxg.sys pfnDdGetDriverState\n");
return pfnDdGetDriverState(pdata);
}
@ -240,7 +239,7 @@ NtGdiDdColorControl(HANDLE hSurface,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdColorControl\n");
DPRINT("Calling dxg.sys pfnDdColorControl\n");
return pfnDdColorControl(hSurface,puColorControlData);
}
@ -265,7 +264,7 @@ NtGdiDdCreateSurfaceObject(HANDLE hDirectDrawLocal,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdCreateSurfaceObject\n");
DPRINT("Calling dxg.sys pfnDdCreateSurfaceObject\n");
return pfnDdCreateSurfaceObject(hDirectDrawLocal, hSurface, puSurfaceLocal, puSurfaceMore, puSurfaceGlobal, bComplete);
}
@ -290,9 +289,7 @@ NtGdiDdDeleteDirectDrawObject(HANDLE hDirectDrawLocal)
return FALSE;
}
DPRINT1("hDirectDrawLocal = %p \n", hDirectDrawLocal);
DPRINT1("Calling dxg.sys pfnDdDeleteDirectDrawObject\n");
DPRINT("Calling dxg.sys pfnDdDeleteDirectDrawObject(%p)\n", hDirectDrawLocal);
return pfnDdDeleteDirectDrawObject(hDirectDrawLocal);
}
@ -312,7 +309,7 @@ NtGdiDdDeleteSurfaceObject(HANDLE hSurface)
}
/* Try and see if the handle is valid */
DPRINT1("Calling dxg.sys DdDeleteSurfaceObject\n");
DPRINT("Calling dxg.sys pfnDdDeleteSurfaceObject\n");
return pfnDdDeleteSurfaceObject(hSurface);
}
@ -341,15 +338,11 @@ NtGdiDdQueryDirectDrawObject(HANDLE hDirectDrawLocal,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdQueryDirectDrawObject\n");
DPRINT("Calling dxg.sys pfnDdQueryDirectDrawObject\n");
return pfnDdQueryDirectDrawObject(hDirectDrawLocal, pHalInfo, pCallBackFlags, puD3dCallbacks, puD3dDriverData,
puD3dBufferCallbacks, puD3dTextureFormats, puNumHeaps, puvmList, puNumFourCC, puFourCC);
}
/************************************************************************/
/* NtGdiDdReenableDirectDrawObject */
/************************************************************************/
@ -359,7 +352,7 @@ NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal,
BOOL *pubNewMode)
{
#if DXDBG
BOOL status = FALSE;
BOOL status;
#endif
PGD_DXDDREENABLEDIRECTDRAWOBJECT pfnDdReenableDirectDrawObject = (PGD_DXDDREENABLEDIRECTDRAWOBJECT)gpDxFuncs[DXG_INDEX_DxDdReenableDirectDrawObject].pfn;
@ -369,19 +362,16 @@ NtGdiDdReenableDirectDrawObject(HANDLE hDirectDrawLocal,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdReenableDirectDrawObject\n");
DPRINT("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);
DPRINT1("end Calling dxg.sys pfnDdReenableDirectDrawObject, status: 0x%08x\n", status);
return status;
#else
return pfnDdReenableDirectDrawObject(hDirectDrawLocal, pubNewMode);
#endif
}
/************************************************************************/
/* NtGdiDdGetDriverInfo */
/************************************************************************/
@ -399,11 +389,10 @@ NtGdiDdGetDriverInfo(HANDLE hDirectDrawLocal,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDriverInfo\n");
DPRINT("Calling dxg.sys pfnDdGetDriverInfo\n");
return pfnDdGetDriverInfo(hDirectDrawLocal, puGetDriverInfoData);
}
/************************************************************************/
/* NtGdiDdGetAvailDriverMemory */
/************************************************************************/
@ -420,11 +409,10 @@ NtGdiDdGetAvailDriverMemory(HANDLE hDirectDrawLocal,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetAvailDriverMemory\n");
DPRINT("Calling dxg.sys pfnDdGetAvailDriverMemory\n");
return pfnDdGetAvailDriverMemory(hDirectDrawLocal, puGetAvailDriverMemoryData);
}
/************************************************************************/
/* NtGdiDdSetExclusiveMode */
/************************************************************************/
@ -442,12 +430,10 @@ NtGdiDdSetExclusiveMode(HANDLE hDirectDraw,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdSetExclusiveMode\n");
DPRINT("Calling dxg.sys pfnDdSetExclusiveMode\n");
return pfnDdSetExclusiveMode(hDirectDraw, puSetExclusiveModeData);
}
/************************************************************************/
/* NtGdiDdFlipToGDISurface */
/************************************************************************/
@ -464,9 +450,8 @@ NtGdiDdFlipToGDISurface(HANDLE hDirectDraw,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdFlipToGDISurface\n");
DPRINT("Calling dxg.sys pfnDdFlipToGDISurface\n");
return pfnDdFlipToGDISurface(hDirectDraw, puFlipToGDISurfaceData);
}
/************************************************************************/
@ -485,7 +470,7 @@ NtGdiDdGetDC(HANDLE hSurface,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDC\n");
DPRINT("Calling dxg.sys pfnDdGetDC\n");
return pfnDdGetDC(hSurface, puColorTable);
}
@ -506,11 +491,10 @@ NtGdiDdGetDxHandle(HANDLE hDirectDraw,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetDxHandle\n");
DPRINT("Calling dxg.sys pfnDdGetDxHandle\n");
return pfnDdGetDxHandle(hDirectDraw, hSurface, bRelease);
}
/************************************************************************/
/* NtGdiDdReleaseDC */
/************************************************************************/
@ -526,7 +510,7 @@ NtGdiDdReleaseDC(HANDLE hSurface)
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdReleaseDC\n");
DPRINT("Calling dxg.sys pfnDdReleaseDC\n");
return pfnDdReleaseDC(hSurface);
}
@ -547,7 +531,7 @@ NtGdiDdResetVisrgn(HANDLE hSurface,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdResetVisrgn\n");
DPRINT("Calling dxg.sys pfnDdResetVisrgn\n");
return pfnDdResetVisrgn(hSurface, hwnd);
}
@ -568,6 +552,6 @@ NtGdiDdSetGammaRamp(HANDLE hDirectDraw,
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdSetGammaRamp\n");
DPRINT("Calling dxg.sys pfnDdSetGammaRamp\n");
return pfnDdSetGammaRamp(hDirectDraw, hdc, lpGammaRamp);
}

61
win32ss/reactx/ntddraw/ddsurf.c
View file

@ -9,6 +9,8 @@
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
/************************************************************************/
@ -22,11 +24,11 @@ NtGdiDdDestroySurface(HANDLE hSurface, BOOL bRealDestroy)
if (pfnDdDestroySurface == NULL)
{
DPRINT1("Warning: no pfnDdDestroySurface");
DPRINT1("Warning: no pfnDdDestroySurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdDestroySurface");
DPRINT("Calling dxg.sys pfnDdDestroySurface\n");
return pfnDdDestroySurface(hSurface, bRealDestroy);
}
@ -45,11 +47,11 @@ NtGdiDdFlip(HANDLE hSurfaceCurrent,
if (pfnDdDdFlip == NULL)
{
DPRINT1("Warning: no pfnDdDdFlip");
DPRINT1("Warning: no pfnDdDdFlip\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdDdFlip");
DPRINT("Calling dxg.sys pfnDdDdFlip\n");
return pfnDdDdFlip(hSurfaceCurrent, hSurfaceTarget, hSurfaceCurrentLeft, hSurfaceTargetLeft, puFlipData);
}
@ -66,11 +68,11 @@ NtGdiDdLock(HANDLE hSurface,
if (pfnDdLock == NULL)
{
DPRINT1("Warning: no pfnDdLock");
DPRINT1("Warning: no pfnDdLock\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdLock");
DPRINT("Calling dxg.sys pfnDdLock\n");
return pfnDdLock(hSurface, puLockData, hdcClip);
}
@ -86,11 +88,11 @@ NtGdiDdUnlock(HANDLE hSurface,
if (pfnDdUnlock == NULL)
{
DPRINT1("Warning: no pfnDdUnlock");
DPRINT1("Warning: no pfnDdUnlock\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUnlock");
DPRINT("Calling dxg.sys pfnDdUnlock\n");
return pfnDdUnlock(hSurface, puUnlockData);
}
@ -107,11 +109,11 @@ NtGdiDdBlt(HANDLE hSurfaceDest,
if (pfnDdBlt == NULL)
{
DPRINT1("Warning: no pfnDdBlt");
DPRINT1("Warning: no pfnDdBlt\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdBlt");
DPRINT("Calling dxg.sys pfnDdBlt\n");
return pfnDdBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
@ -127,19 +129,17 @@ NtGdiDdSetColorKey(HANDLE hSurface,
if (pfnDdSetColorKey == NULL)
{
DPRINT1("Warning: no pfnDdSetColorKey");
DPRINT1("Warning: no pfnDdSetColorKey\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetColorKey");
DPRINT("Calling dxg.sys pfnDdSetColorKey\n");
return pfnDdSetColorKey(hSurface,puSetColorKeyData);
}
/************************************************************************/
/* NtGdiDdAddAttachedSurface */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdAddAttachedSurface(HANDLE hSurface,
@ -150,11 +150,11 @@ NtGdiDdAddAttachedSurface(HANDLE hSurface,
if (pfnDdAddAttachedSurface == NULL)
{
DPRINT1("Warning: no pfnDdAddAttachedSurface");
DPRINT1("Warning: no pfnDdAddAttachedSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAddAttachedSurface");
DPRINT("Calling dxg.sys pfnDdAddAttachedSurface\n");
return pfnDdAddAttachedSurface(hSurface,hSurfaceAttached,puAddAttachedSurfaceData);
}
@ -170,11 +170,11 @@ NtGdiDdGetBltStatus(HANDLE hSurface,
if (pfnDdGetBltStatus == NULL)
{
DPRINT1("Warning: no pfnDdGetBltStatus");
DPRINT1("Warning: no pfnDdGetBltStatus\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetBltStatus");
DPRINT("Calling dxg.sys pfnDdGetBltStatus\n");
return pfnDdGetBltStatus(hSurface,puGetBltStatusData);
}
@ -190,11 +190,11 @@ NtGdiDdGetFlipStatus(HANDLE hSurface,
if (pfnDdGetFlipStatus == NULL)
{
DPRINT1("Warning: no pfnDdGetFlipStatus");
DPRINT1("Warning: no pfnDdGetFlipStatus\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdGetFlipStatus");
DPRINT("Calling dxg.sys pfnDdGetFlipStatus\n");
return pfnDdGetFlipStatus(hSurface,puGetFlipStatusData);
}
@ -211,18 +211,17 @@ NtGdiDdUpdateOverlay(HANDLE hSurfaceDestination,
if (pfnDdUpdateOverlay == NULL)
{
DPRINT1("Warning: no pfnDdUpdateOverlay");
DPRINT1("Warning: no pfnDdUpdateOverlay\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdUpdateOverlay");
DPRINT("Calling dxg.sys pfnDdUpdateOverlay\n");
return pfnDdUpdateOverlay(hSurfaceDestination,hSurfaceSource,puUpdateOverlayData);
}
/************************************************************************/
/* NtGdiDdSetOverlayPosition */
/************************************************************************/
DWORD
APIENTRY
NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource,
@ -233,11 +232,11 @@ NtGdiDdSetOverlayPosition(HANDLE hSurfaceSource,
if (pfnDdSetOverlayPosition == NULL)
{
DPRINT1("Warning: no pfnDdSetOverlayPosition");
DPRINT1("Warning: no pfnDdSetOverlayPosition\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdSetOverlayPosition");
DPRINT("Calling dxg.sys pfnDdSetOverlayPosition\n");
return pfnDdSetOverlayPosition(hSurfaceSource,hSurfaceDestination,puSetOverlayPositionData);
}
@ -260,11 +259,11 @@ NtGdiDdAlphaBlt(HANDLE hSurfaceDest,
if (pfnDdAlphaBlt == NULL)
{
DPRINT1("Warning: no pfnDdAlphaBlt");
DPRINT1("Warning: no pfnDdAlphaBlt\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys DdAlphaBlt");
DPRINT("Calling dxg.sys pfnDdAlphaBlt\n");
return pfnDdAlphaBlt(hSurfaceDest,hSurfaceSrc,puBltData);
}
@ -281,11 +280,11 @@ NtGdiDdAttachSurface(HANDLE hSurfaceFrom,
if (pfnDdAttachSurface == NULL)
{
DPRINT1("Warning: no pfnDdAttachSurface");
DPRINT1("Warning: no pfnDdAttachSurface\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling on dxg.sys pfnDdAttachSurface");
DPRINT("Calling dxg.sys pfnDdAttachSurface\n");
return pfnDdAttachSurface(hSurfaceFrom,hSurfaceTo);
}
@ -304,11 +303,11 @@ NtGdiDdUnattachSurface(HANDLE hSurface,
PGD_DXDDUNATTACHSURFACE pfnDdUnattachSurface = (PGD_DXDDUNATTACHSURFACE)gpDxFuncs[DXG_INDEX_DxDdUnattachSurface].pfn;
if (pfnDdUnattachSurface == NULL)
{
DPRINT1("Warning: no pfnDdUnattachSurface");
DPRINT1("Warning: no pfnDdUnattachSurface\n");
//return DDHAL_DRIVER_NOTHANDLED;
return STATUS_NOT_IMPLEMENTED;
}
DPRINT1("Calling on dxg.sys pfnDdUnattachSurface");
DPRINT("Calling dxg.sys pfnDdUnattachSurface\n");
return pfnDdUnattachSurface(hSurface,hSurfaceAttached);
}

102
win32ss/reactx/ntddraw/dvp.c
View file

@ -8,8 +8,9 @@
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
/************************************************************************/
@ -21,14 +22,14 @@ NtGdiDvpCanCreateVideoPort(HANDLE hDirectDraw,
PDD_CANCREATEVPORTDATA puCanCreateVPortData)
{
PGD_DVPCANCREATEVIDEOPORT pfnDvpCanCreateVideoPort = (PGD_DVPCANCREATEVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpCanCreateVideoPort].pfn;
if (pfnDvpCanCreateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpCanCreateVideoPort");
DPRINT1("Warning: no pfnDvpCanCreateVideoPort\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpCanCreateVideoPort");
DPRINT("Calling dxg.sys pfnDvpCanCreateVideoPort\n");
return pfnDvpCanCreateVideoPort(hDirectDraw, puCanCreateVPortData);
}
@ -41,14 +42,14 @@ NtGdiDvpColorControl(HANDLE hVideoPort,
PDD_VPORTCOLORDATA puVPortColorData)
{
PGD_DVPCOLORCONTROL pfnDvpColorControl = (PGD_DVPCOLORCONTROL)gpDxFuncs[DXG_INDEX_DxDvpColorControl].pfn;
if (pfnDvpColorControl == NULL)
{
DPRINT1("Warning: no pfnDvpColorControl");
DPRINT1("Warning: no pfnDvpColorControl\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpColorControl");
DPRINT("Calling dxg.sys pfnDvpColorControl\n");
return pfnDvpColorControl(hVideoPort, puVPortColorData);
}
@ -61,14 +62,14 @@ NtGdiDvpCreateVideoPort(HANDLE hDirectDraw,
PDD_CREATEVPORTDATA puCreateVPortData)
{
PGD_DVPCREATEVIDEOPORT pfnDvpCreateVideoPort = (PGD_DVPCREATEVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpCreateVideoPort].pfn;
if (pfnDvpCreateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpCreateVideoPort");
DPRINT1("Warning: no pfnDvpCreateVideoPort\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpCreateVideoPort");
DPRINT("Calling dxg.sys pfnDvpCreateVideoPort\n");
return pfnDvpCreateVideoPort(hDirectDraw, puCreateVPortData);
}
@ -80,15 +81,16 @@ APIENTRY
NtGdiDvpDestroyVideoPort(HANDLE hVideoPort,
PDD_DESTROYVPORTDATA puDestroyVPortData)
{
PGD_DVPDESTROYVIDEOPORT pfnDvpDestroyVideoPort = (PGD_DVPDESTROYVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpDestroyVideoPort].pfn;
PGD_DVPDESTROYVIDEOPORT pfnDvpDestroyVideoPort =
(PGD_DVPDESTROYVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpDestroyVideoPort].pfn;
if (pfnDvpDestroyVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpDestroyVideoPort");
DPRINT1("Warning: no pfnDvpDestroyVideoPort\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpDestroyVideoPort");
DPRINT("Calling dxg.sys pfnDvpDestroyVideoPort\n");
return pfnDvpDestroyVideoPort(hVideoPort, puDestroyVPortData);
}
@ -102,19 +104,19 @@ NtGdiDvpFlipVideoPort(HANDLE hVideoPort,
HANDLE hDDSurfaceTarget,
PDD_FLIPVPORTDATA puFlipVPortData)
{
PGD_DVPFLIPVIDEOPORT pfnDvpFlipVideoPort = (PGD_DVPFLIPVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpFlipVideoPort].pfn;
PGD_DVPFLIPVIDEOPORT pfnDvpFlipVideoPort =
(PGD_DVPFLIPVIDEOPORT)gpDxFuncs[DXG_INDEX_DxDvpFlipVideoPort].pfn;
if (pfnDvpFlipVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpFlipVideoPort");
DPRINT1("Warning: no pfnDvpFlipVideoPort\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpFlipVideoPort");
DPRINT("Calling dxg.sys pfnDvpFlipVideoPort\n");
return pfnDvpFlipVideoPort(hVideoPort, hDDSurfaceCurrent, hDDSurfaceTarget, puFlipVPortData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortBandwidth */
/************************************************************************/
@ -127,15 +129,14 @@ NtGdiDvpGetVideoPortBandwidth(HANDLE hVideoPort,
if (pfnDvpGetVideoPortBandwidth == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortBandwidth");
DPRINT1("Warning: no pfnDvpGetVideoPortBandwidth\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortBandwidth");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortBandwidth\n");
return pfnDvpGetVideoPortBandwidth(hVideoPort, puGetVPortBandwidthData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortFlipStatus */
/************************************************************************/
@ -148,15 +149,14 @@ NtGdiDvpGetVideoPortFlipStatus(HANDLE hDirectDraw,
if (pfnDvpGetVideoPortFlipStatus == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortFlipStatus");
DPRINT1("Warning: no pfnDvpGetVideoPortFlipStatus\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortFlipStatus");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortFlipStatus\n");
return pfnDvpGetVideoPortFlipStatus(hDirectDraw, puGetVPortFlipStatusData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortInputFormats */
/************************************************************************/
@ -169,15 +169,14 @@ NtGdiDvpGetVideoPortInputFormats(HANDLE hVideoPort,
if (pfnDvpGetVideoPortInputFormats == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortInputFormats");
DPRINT1("Warning: no pfnDvpGetVideoPortInputFormats\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortInputFormats");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortInputFormats\n");
return pfnDvpGetVideoPortInputFormats(hVideoPort, puGetVPortInputFormatData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortLine */
/************************************************************************/
@ -190,15 +189,14 @@ NtGdiDvpGetVideoPortLine(HANDLE hVideoPort,
if (pfnDvpGetVideoPortLine == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortLine");
DPRINT1("Warning: no pfnDvpGetVideoPortLine\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortLine");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortLine\n");
return pfnDvpGetVideoPortLine(hVideoPort, puGetVPortLineData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortOutputFormats */
/************************************************************************/
@ -211,16 +209,14 @@ NtGdiDvpGetVideoPortOutputFormats(HANDLE hVideoPort,
if (pfnDvpGetVideoPortOutputFormats == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortOutputFormats");
DPRINT1("Warning: no pfnDvpGetVideoPortOutputFormats\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortOutputFormats");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortOutputFormats\n");
return pfnDvpGetVideoPortOutputFormats(hVideoPort, puGetVPortOutputFormatData);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortConnectInfo */
/************************************************************************/
@ -233,15 +229,14 @@ NtGdiDvpGetVideoPortConnectInfo(HANDLE hDirectDraw,
if (pfnDvpGetVideoPortConnectInfo == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortConnectInfo");
DPRINT1("Warning: no pfnDvpGetVideoPortConnectInfo\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortConnectInfo");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortConnectInfo\n");
return pfnDvpGetVideoPortConnectInfo(hDirectDraw, puGetVPortConnectData);
}
/************************************************************************/
/* NtGdiDvpGetVideoSignalStatus */
/************************************************************************/
@ -254,16 +249,14 @@ NtGdiDvpGetVideoSignalStatus(HANDLE hVideoPort,
if (pfnDvpGetVideoSignalStatus == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoSignalStatus");
DPRINT1("Warning: no pfnDvpGetVideoSignalStatus\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoSignalStatus");
DPRINT("Calling dxg.sys pfnDvpGetVideoSignalStatus\n");
return pfnDvpGetVideoSignalStatus(hVideoPort, puGetVPortSignalData);
}
/************************************************************************/
/* NtGdiDvpUpdateVideoPort */
/************************************************************************/
@ -278,16 +271,14 @@ NtGdiDvpUpdateVideoPort(HANDLE hVideoPort,
if (pfnDvpUpdateVideoPort == NULL)
{
DPRINT1("Warning: no pfnDvpUpdateVideoPort");
DPRINT1("Warning: no pfnDvpUpdateVideoPort\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpUpdateVideoPort");
DPRINT("Calling dxg.sys pfnDvpUpdateVideoPort\n");
return pfnDvpUpdateVideoPort(hVideoPort, phSurfaceVideo, phSurfaceVbi, puUpdateVPortData);
}
/************************************************************************/
/* NtGdiDvpWaitForVideoPortSync */
/************************************************************************/
@ -300,15 +291,14 @@ NtGdiDvpWaitForVideoPortSync(HANDLE hVideoPort,
if (pfnDvpWaitForVideoPortSync == NULL)
{
DPRINT1("Warning: no pfnDvpWaitForVideoPortSync");
DPRINT1("Warning: no pfnDvpWaitForVideoPortSync\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpWaitForVideoPortSync");
DPRINT("Calling dxg.sys pfnDvpWaitForVideoPortSync\n");
return pfnDvpWaitForVideoPortSync(hVideoPort, puWaitForVPortSyncData);
}
/************************************************************************/
/* NtGdiDvpAcquireNotification */
/************************************************************************/
@ -322,15 +312,14 @@ NtGdiDvpAcquireNotification(HANDLE hVideoPort,
if (pfnDvpAcquireNotification == NULL)
{
DPRINT1("Warning: no pfnDvpAcquireNotification");
DPRINT1("Warning: no pfnDvpAcquireNotification\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpAcquireNotification");
DPRINT("Calling dxg.sys pfnDvpAcquireNotification\n");
return pfnDvpAcquireNotification(hVideoPort, hEvent, pNotify);
}
/************************************************************************/
/* NtGdiDvpReleaseNotification */
/************************************************************************/
@ -343,16 +332,14 @@ NtGdiDvpReleaseNotification(HANDLE hVideoPort,
if (pfnDvpReleaseNotification == NULL)
{
DPRINT1("Warning: no pfnDvpReleaseNotification");
DPRINT1("Warning: no pfnDvpReleaseNotification\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpReleaseNotification");
DPRINT("Calling dxg.sys pfnDvpReleaseNotification\n");
return pfnDvpReleaseNotification(hVideoPort, hEvent);
}
/************************************************************************/
/* NtGdiDvpGetVideoPortField */
/************************************************************************/
@ -365,11 +352,10 @@ NtGdiDvpGetVideoPortField(HANDLE hVideoPort,
if (pfnDvpGetVideoPortField == NULL)
{
DPRINT1("Warning: no pfnDvpGetVideoPortField");
DPRINT1("Warning: no pfnDvpGetVideoPortField\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDvpGetVideoPortField");
DPRINT("Calling dxg.sys pfnDvpGetVideoPortField\n");
return pfnDvpGetVideoPortField(hVideoPort, puGetVPortFieldData);
}

97
win32ss/reactx/ntddraw/dxeng.c
View file

@ -8,6 +8,8 @@
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
HSEMAPHORE ghsemShareDevLock = NULL;
@ -60,7 +62,6 @@ DRVFN gaEngFuncs[] =
{DXENG_INDEX_DxEngLoadImage, (PFN)DxEngLoadImage}
};
/*++
* @name DxEngDispUniq
* @implemented
@ -78,7 +79,7 @@ ULONG
APIENTRY
DxEngDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngDispUniq\n");
DPRINT("ReactX Calling : DxEngDispUniq\n");
return GdiHandleTable->flDeviceUniq;
}
@ -105,11 +106,10 @@ BOOL
APIENTRY
DxEngGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
{
DPRINT1("ReactX Calling : DxEngGetDeviceGammaRamp\n");
DPRINT("ReactX Calling : DxEngGetDeviceGammaRamp\n");
return IntGetDeviceGammaRamp(hPDev, Ramp);
}
/*++
* @name DxEngLockDC
* @implemented
@ -130,11 +130,10 @@ PDC
APIENTRY
DxEngLockDC(HDC hDC)
{
DPRINT1("ReactX Calling : DxEngLockDC\n");
DPRINT("ReactX Calling : DxEngLockDC\n");
return DC_LockDc(hDC);
}
/*++
* @name DxEngUnlockDC
* @implemented
@ -155,7 +154,7 @@ BOOLEAN
APIENTRY
DxEngUnlockDC(PDC pDC)
{
DPRINT1("ReactX Calling : DxEngUnlockDC\n");
DPRINT("ReactX Calling : DxEngUnlockDC\n");
DC_UnlockDc(pDC);
return TRUE;
}
@ -179,7 +178,7 @@ BOOLEAN
APIENTRY
DxEngLockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngLockShareSem\n");
DPRINT("ReactX Calling : DxEngLockShareSem\n");
if(!ghsemShareDevLock) ghsemShareDevLock = EngCreateSemaphore(); // Hax, should be in dllmain.c
EngAcquireSemaphore(ghsemShareDevLock);
return TRUE;
@ -202,7 +201,7 @@ BOOLEAN
APIENTRY
DxEngUnlockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngUnlockShareSem\n");
DPRINT("ReactX Calling : DxEngUnlockShareSem\n");
EngReleaseSemaphore(ghsemShareDevLock);
return TRUE;
}
@ -233,7 +232,7 @@ BOOLEAN
APIENTRY
DxEngSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
{
DPRINT1("ReactX Calling : DxEngSetDeviceGammaRamp\n");
DPRINT("ReactX Calling : DxEngSetDeviceGammaRamp\n");
return IntSetDeviceGammaRamp(hPDev, Ramp, Test);
}
@ -284,101 +283,100 @@ DxEngGetHdevData(HDEV hDev,
DWORD_PTR retVal = 0;
PPDEVOBJ PDev = (PPDEVOBJ)hDev;
DPRINT1("ReactX Calling : DxEngGetHdevData DXEGSHDEVDATA : %ld\n", Type);
DPRINT("ReactX Calling : DxEngGetHdevData, Type: %d\n", Type);
#if 1
DPRINT1("HDEV hDev %p\n", hDev);
DPRINT("hDev: %p\n", hDev);
#endif
switch ( Type )
{
case DxEGShDevData_Surface:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Surface\n");
DPRINT("requested DxEGShDevData_Surface\n");
retVal = (DWORD_PTR) PDev->pSurface; // ptr to Surface handle.
break;
case DxEGShDevData_hSpooler:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_hSpooler\n");
DPRINT("requested DxEGShDevData_hSpooler\n");
retVal = (DWORD_PTR) PDev->hSpooler;
break;
case DxEGShDevData_DitherFmt:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DitherFmt\n");
DPRINT("requested DxEGShDevData_DitherFmt\n");
retVal = (DWORD_PTR) PDev->devinfo.iDitherFormat;
break;
case DxEGShDevData_FxCaps:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps\n");
DPRINT("requested DxEGShDevData_FxCaps\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps;
break;
case DxEGShDevData_FxCaps2:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps2\n");
DPRINT("requested DxEGShDevData_FxCaps2\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps2;
break;
case DxEGShDevData_DrvFuncs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DrvFuncs\n");
DPRINT("requested DxEGShDevData_DrvFuncs\n");
retVal = (DWORD_PTR) &PDev->DriverFunctions;
break;
case DxEGShDevData_dhpdev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dhpdev\n");
DPRINT("requested DxEGShDevData_dhpdev\n");
retVal = (DWORD_PTR) PDev->dhpdev; // DHPDEV
break;
case DxEGShDevData_eddg:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_eddg\n");
DPRINT("requested DxEGShDevData_eddg\n");
retVal = (DWORD_PTR) PDev->pEDDgpl;
break;
case DxEGShDevData_dd_locks:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_locks\n");
DPRINT("requested DxEGShDevData_dd_locks\n");
retVal = (DWORD_PTR) PDev->cDirectDrawDisableLocks;
break;
case DxEGShDevData_dd_flags:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_flags\n");
DPRINT("requested DxEGShDevData_dd_flags\n");
retVal = (DWORD_PTR) PDev->DxDd_Flags;
break;
case DxEGShDevData_disable:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_disable\n");
DPRINT("requested DxEGShDevData_disable\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISABLED;
break;
case DxEGShDevData_metadev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_metadev\n");
DPRINT("requested DxEGShDevData_metadev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_META_DEVICE;
break;
case DxEGShDevData_display:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_display\n");
DPRINT("requested DxEGShDevData_display\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISPLAY;
break;
case DxEGShDevData_Parent:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Parent\n");
DPRINT("requested DxEGShDevData_Parent\n");
retVal = (DWORD_PTR) PDev->ppdevParent;
break;
case DxEGShDevData_OpenRefs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_OpenRefs\n");
DPRINT("requested DxEGShDevData_OpenRefs\n");
retVal = (DWORD_PTR) PDev->cPdevOpenRefs != 0;
break;
case DxEGShDevData_palette:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_palette\n");
DPRINT("requested DxEGShDevData_palette\n");
retVal = (DWORD_PTR) PDev->gdiinfo.flRaster & RC_PALETTE;
break;
case DxEGShDevData_ldev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_ldev\n");
DPRINT("requested DxEGShDevData_ldev\n");
retVal = (DWORD_PTR) PDev->pldev;
break;
case DxEGShDevData_GDev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_GDev\n");
DPRINT("requested DxEGShDevData_GDev\n");
retVal = (DWORD_PTR) PDev->pGraphicsDevice; // P"GRAPHICS_DEVICE"
break;
case DxEGShDevData_clonedev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_clonedev\n");
DPRINT("requested DxEGShDevData_clonedev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_CLONE_DEVICE;
break;
default:
// TODO: Make this default a bit more useful.
break;
}
#if 1
DPRINT1("return value %08lx\n", retVal);
DPRINT("retVal: %08Ix\n", retVal);
#endif
return retVal;
}
/*++
@ -411,11 +409,11 @@ DxEngSetHdevData(HDEV hDev,
{
BOOLEAN retVal = FALSE; // Default, no set.
DPRINT1("ReactX Calling : DxEngSetHdevData DXEGSHDEVDATA : %ld\n", Type);
DPRINT("ReactX Calling : DxEngSetHdevData, Type: %d\n", Type);
if (Type == DxEGShDevData_dd_locks)
{
DPRINT1("Assigning value %d\n", Data);
DPRINT("Assigning value: %Iu\n", Data);
((PPDEVOBJ)hDev)->cDirectDrawDisableLocks = Data;
retVal = TRUE; // Set
}
@ -455,7 +453,7 @@ DxEngGetDCState(HDC hDC,
PDC pDC = DC_LockDc(hDC);
DWORD_PTR retVal = 0;
DPRINT1("ReactX Calling : DxEngGetDCState type : %lu\n", type);
DPRINT("ReactX Calling : DxEngGetDCState, type: %lu\n", type);
if (pDC)
{
@ -482,7 +480,7 @@ DxEngGetDCState(HDC hDC,
DC_UnlockDc(pDC);
}
DPRINT1("Return value %08lx\n", retVal);
DPRINT("retVal: %08Ix\n", retVal);
return retVal;
}
@ -504,7 +502,7 @@ BOOLEAN
APIENTRY
DxEngIncDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngIncDispUniq \n");
DPRINT("ReactX Calling : DxEngIncDispUniq\n");
InterlockedIncrement((LONG*)&GdiHandleTable->flDeviceUniq);
return TRUE;
@ -533,9 +531,9 @@ DxEngLockHdev(HDEV hDev)
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource;
DPRINT1("ReactX Calling : DxEngLockHdev \n");
DPRINT("ReactX Calling : DxEngLockHdev\n");
DPRINT1("hDev : 0x%p\n",hDev);
DPRINT("hDev: %p\n", hDev);
Resource = (PERESOURCE)ppdev->hsemDevLock;
@ -570,7 +568,7 @@ DxEngUnlockHdev(HDEV hDev)
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource = (PERESOURCE)ppdev->hsemDevLock;
DPRINT1("ReactX Calling : DxEngUnlockHdev \n");
DPRINT("ReactX Calling : DxEngUnlockHdev\n");
if (Resource)
{
@ -580,7 +578,6 @@ DxEngUnlockHdev(HDEV hDev)
return TRUE;
}
/************************************************************************/
/* DxEngReferenceHdev */
/************************************************************************/
@ -621,7 +618,6 @@ DxEngRedrawDesktop(VOID)
return TRUE;
}
ULONG gulVisRgnUniqueness; // Increase count everytime client region is updated.
/************************************************************************/
@ -632,7 +628,7 @@ ULONG
APIENTRY
DxEngVisRgnUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngVisRgnUniq \n");
DPRINT("ReactX Calling : DxEngVisRgnUniq\n");
return gulVisRgnUniqueness;
}
@ -682,7 +678,6 @@ DxEngIsHdevLockedByCurrentThread(HDEV hDev)
return pSem->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread();
}
/************************************************************************/
/* DxEngUnreferenceHdev */
/************************************************************************/
@ -729,7 +724,7 @@ DxEngCleanDC(HDC hdc)
/************************************************************************/
BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
{
DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
DPRINT("ReactX Calling : DxEngSetDCOwner\n");
return GreSetDCOwner(hObject, OwnerMask);
}
@ -765,7 +760,7 @@ DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
/************************************************************************/
HBITMAP APIENTRY DxEngSelectBitmap(HDC hdc, HBITMAP hbmp)
{
DPRINT1("ReactX Calling : DxEngSelectBitmap \n");
DPRINT("ReactX Calling : DxEngSelectBitmap\n");
return NtGdiSelectBitmap(hdc, hbmp);
}
@ -775,7 +770,7 @@ HBITMAP APIENTRY DxEngSelectBitmap(HDC hdc, HBITMAP hbmp)
/************************************************************************/
BOOLEAN APIENTRY DxEngSetBitmapOwner(HBITMAP hbmp, ULONG ulOwner)
{
DPRINT1("ReactX Calling : DxEngSetBitmapOwner \n");
DPRINT("ReactX Calling : DxEngSetBitmapOwner\n");
return GreSetBitmapOwner(hbmp, ulOwner);
}
@ -785,7 +780,7 @@ BOOLEAN APIENTRY DxEngSetBitmapOwner(HBITMAP hbmp, ULONG ulOwner)
/************************************************************************/
BOOLEAN APIENTRY DxEngDeleteSurface(HSURF hsurf)
{
DPRINT1("ReactX Calling : DxEngDeleteSurface \n");
DPRINT("ReactX Calling : DxEngDeleteSurface\n");
return EngDeleteSurface(hsurf);
}
@ -804,7 +799,7 @@ DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
/************************************************************************/
SURFOBJ * APIENTRY DxEngAltLockSurface(HSURF hsurf)
{
DPRINT1("ReactX Calling : DxEngAltLockSurface \n");
DPRINT("ReactX Calling : DxEngAltLockSurface\n");
return EngLockSurface(hsurf);
}

22
win32ss/reactx/ntddraw/eng.c
View file

@ -8,8 +8,9 @@
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
/************************************************************************/
@ -31,7 +32,7 @@ HeapVidMemAllocAligned(LPVIDMEM lpVidMem,
return 0;
}
DPRINT1("Calling dxg.sys pfnHeapVidMemAllocAligned\n");
DPRINT("Calling dxg.sys pfnHeapVidMemAllocAligned\n");
return pfnHeapVidMemAllocAligned(lpVidMem, dwWidth, dwHeight, lpAlignment, lpNewPitch);
}
@ -51,7 +52,7 @@ VidMemFree(LPVMEMHEAP pvmh,
}
else
{
DPRINT1("Calling dxg.sys pfnVidMemFree\n");
DPRINT("Calling dxg.sys pfnVidMemFree\n");
pfnVidMemFree(pvmh, ptr);
}
}
@ -78,7 +79,7 @@ EngAllocPrivateUserMem(
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnEngAllocPrivateUserMem\n");
DPRINT("Calling dxg.sys pfnEngAllocPrivateUserMem\n");
return pfnEngAllocPrivateUserMem(psl, cjMemSize, ulTag);
}
@ -98,7 +99,7 @@ EngFreePrivateUserMem(PDD_SURFACE_LOCAL psl,
}
else
{
DPRINT1("Calling dxg.sys pfnEngFreePrivateUserMem\n");
DPRINT("Calling dxg.sys pfnEngFreePrivateUserMem\n");
pfnEngFreePrivateUserMem(psl, pv);
}
}
@ -136,8 +137,7 @@ EngDxIoctl(ULONG ulIoctl,
PGD_ENGDXIOCTL pfnEngDxIoctl = (PGD_ENGDXIOCTL)gpDxFuncs[DXG_INDEX_DxDdIoctl].pfn;
DWORD retVal = DDERR_UNSUPPORTED;
DPRINT1("Calling dxg.sys pfnEngDxIoctl\n");
DPRINT("Calling dxg.sys pfnEngDxIoctl\n");
if (pfnEngDxIoctl != NULL)
{
retVal = pfnEngDxIoctl(ulIoctl, pBuffer, ulBufferSize);
@ -169,8 +169,7 @@ EngLockDirectDrawSurface(HANDLE hSurface)
PGD_ENGLOCKDIRECTDRAWSURFACE pfnEngLockDirectDrawSurface = (PGD_ENGLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdLockDirectDrawSurface].pfn;
PDD_SURFACE_LOCAL retVal = NULL;
DPRINT1("Calling dxg.sys pfnEngLockDirectDrawSurface\n");
DPRINT("Calling dxg.sys pfnEngLockDirectDrawSurface\n");
if (pfnEngLockDirectDrawSurface != NULL)
{
retVal = pfnEngLockDirectDrawSurface(hSurface);
@ -179,7 +178,6 @@ EngLockDirectDrawSurface(HANDLE hSurface)
return retVal;
}
/*++
* @name EngUnlockDirectDrawSurface
* @implemented
@ -203,8 +201,7 @@ EngUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
PGD_ENGUNLOCKDIRECTDRAWSURFACE pfnEngUnlockDirectDrawSurface = (PGD_ENGUNLOCKDIRECTDRAWSURFACE)gpDxFuncs[DXG_INDEX_DxDdUnlockDirectDrawSurface].pfn;
BOOL retVal = FALSE;
DPRINT1("Calling dxg.sys pfnEngUnlockDirectDrawSurface\n");
DPRINT("Calling dxg.sys pfnEngUnlockDirectDrawSurface\n");
if (pfnEngUnlockDirectDrawSurface != NULL)
{
retVal = pfnEngUnlockDirectDrawSurface(pSurface);
@ -212,4 +209,3 @@ EngUnlockDirectDrawSurface(PDD_SURFACE_LOCAL pSurface)
return retVal;
}

58
win32ss/reactx/ntddraw/mocomp.c
View file

@ -8,8 +8,9 @@
* 19/1-2006 Magnus Olsen
*/
#include <win32k.h>
// #define NDEBUG
#include <debug.h>
/************************************************************************/
@ -24,11 +25,11 @@ NtGdiDdBeginMoCompFrame(HANDLE hMoComp,
if (pfnDdBeginMoCompFrame == NULL)
{
DPRINT1("Warning: no pfnDdBeginMoCompFrame");
DPRINT1("Warning: no pfnDdBeginMoCompFrame\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdBeginMoCompFrame");
DPRINT("Calling dxg.sys pfnDdBeginMoCompFrame\n");
return pfnDdBeginMoCompFrame(hMoComp,puBeginFrameData);
}
@ -43,32 +44,33 @@ NtGdiDdCreateMoComp(HANDLE hDirectDraw, PDD_CREATEMOCOMPDATA puCreateMoCompData)
if (pfnDdCreateMoComp == NULL)
{
DPRINT1("Warning: no pfnDdCreateMoComp");
DPRINT1("Warning: no pfnDdCreateMoComp\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DdCreateMoComp");
DPRINT("Calling dxg.sys pfnDdCreateMoComp\n");
return pfnDdCreateMoComp(hDirectDraw, puCreateMoCompData);
}
/************************************************************************/
/* NtGdiDdDestroyMoComp */
/************************************************************************/
DWORD
DWORD
APIENTRY
NtGdiDdDestroyMoComp(HANDLE hMoComp,
PDD_DESTROYMOCOMPDATA puBeginFrameData)
{
PGD_DXDDDESTROYMOCOMP pfnDxDdDestroyMoComp = (PGD_DXDDDESTROYMOCOMP)gpDxFuncs[DXG_INDEX_DxDdDestroyMoComp].pfn;
PGD_DXDDDESTROYMOCOMP pfnDdDestroyMoComp =
(PGD_DXDDDESTROYMOCOMP)gpDxFuncs[DXG_INDEX_DxDdDestroyMoComp].pfn;
if (pfnDxDdDestroyMoComp == NULL)
if (pfnDdDestroyMoComp == NULL)
{
DPRINT1("Warning: no pfnDxDdDestroyMoComp");
DPRINT1("Warning: no pfnDdDestroyMoComp\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys DxDdDestroyMoComp");
return pfnDxDdDestroyMoComp(hMoComp, puBeginFrameData);
DPRINT("Calling dxg.sys pfnDdDestroyMoComp\n");
return pfnDdDestroyMoComp(hMoComp, puBeginFrameData);
}
/************************************************************************/
@ -83,11 +85,11 @@ NtGdiDdEndMoCompFrame(HANDLE hMoComp,
if (pfnDdEndMoCompFrame == NULL)
{
DPRINT1("Warning: no pfnDdEndMoCompFrame");
DPRINT1("Warning: no pfnDdEndMoCompFrame\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdEndMoCompFrame");
DPRINT("Calling dxg.sys pfnDdEndMoCompFrame\n");
return pfnDdEndMoCompFrame(hMoComp, puEndFrameData);
}
@ -103,15 +105,14 @@ NtGdiDdGetInternalMoCompInfo(HANDLE hDirectDraw,
if (pfnDdGetInternalMoCompInfo == NULL)
{
DPRINT1("Warning: no pfnDdGetInternalMoCompInfo");
DPRINT1("Warning: no pfnDdGetInternalMoCompInfo\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetInternalMoCompInfo");
DPRINT("Calling dxg.sys pfnDdGetInternalMoCompInfo\n");
return pfnDdGetInternalMoCompInfo(hDirectDraw, puGetInternalData);
}
/************************************************************************/
/* NtGdiDdGetMoCompBuffInfo */
/************************************************************************/
@ -124,11 +125,11 @@ NtGdiDdGetMoCompBuffInfo(HANDLE hDirectDraw,
if (pfnDdGetMoCompBuffInfo == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompBuffInfo");
DPRINT1("Warning: no pfnDdGetMoCompBuffInfo\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompBuffInfo");
DPRINT("Calling dxg.sys pfnDdGetMoCompBuffInfo\n");
return pfnDdGetMoCompBuffInfo(hDirectDraw, puGetBuffData);
}
@ -144,15 +145,14 @@ NtGdiDdGetMoCompFormats(HANDLE hDirectDraw,
if (pfnDdGetMoCompFormats == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompFormats");
DPRINT1("Warning: no pfnDdGetMoCompFormats\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompFormats");
DPRINT("Calling dxg.sys pfnDdGetMoCompFormats\n");
return pfnDdGetMoCompFormats(hDirectDraw, puGetMoCompFormatsData);
}
/************************************************************************/
/* NtGdiDdGetMoCompGuids */
/************************************************************************/
@ -165,16 +165,14 @@ NtGdiDdGetMoCompGuids(HANDLE hDirectDraw,
if (pfnDdGetMoCompGuids == NULL)
{
DPRINT1("Warning: no pfnDdGetMoCompGuids");
DPRINT1("Warning: no pfnDdGetMoCompGuids\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdGetMoCompGuids");
DPRINT("Calling dxg.sys pfnDdGetMoCompGuids\n");
return pfnDdGetMoCompGuids(hDirectDraw, puGetMoCompGuidsData);
}
/************************************************************************/
/* NtGdiDdQueryMoCompStatus */
/************************************************************************/
@ -187,15 +185,14 @@ NtGdiDdQueryMoCompStatus(HANDLE hMoComp,
if (pfnDdQueryMoCompStatus == NULL)
{
DPRINT1("Warning: no pfnDdQueryMoCompStatus");
DPRINT1("Warning: no pfnDdQueryMoCompStatus\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdQueryMoCompStatus");
DPRINT("Calling dxg.sys pfnDdQueryMoCompStatus\n");
return pfnDdQueryMoCompStatus(hMoComp, puQueryMoCompStatusData);
}
/************************************************************************/
/* NtGdiDdRenderMoComp */
/************************************************************************/
@ -208,11 +205,10 @@ NtGdiDdRenderMoComp(HANDLE hMoComp,
if (pfnDdRenderMoComp == NULL)
{
DPRINT1("Warning: no pfnDdRenderMoComp");
DPRINT1("Warning: no pfnDdRenderMoComp\n");
return DDHAL_DRIVER_NOTHANDLED;
}
DPRINT1("Calling dxg.sys pfnDdRenderMoComp");
DPRINT("Calling dxg.sys pfnDdRenderMoComp\n");
return pfnDdRenderMoComp(hMoComp, puRenderMoCompData);
}