mirrors/reactos
0
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-27 05:23:33 +08:00
Code Issues Packages Projects Releases 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; return (DHPDEV) PDev;
} }
// DrvCompletePDEV // DrvCompletePDEV
// DESCRIPTION // DESCRIPTION
// Called after initialization of PDEV is complete. Supplies // Called after initialization of PDEV is complete. Supplies
@ -294,7 +293,6 @@ DrvCompletePDEV(IN DHPDEV PDev,
((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC ((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC
} }
BOOL APIENTRY BOOL APIENTRY
DrvAssertMode(IN DHPDEV DPev, DrvAssertMode(IN DHPDEV DPev,
IN BOOL Enable) IN BOOL Enable)
@ -324,7 +322,7 @@ DrvAssertMode(IN DHPDEV DPev,
else else
{ {
/* Go back to last known mode */ /* 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)) if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength))
{ {
/* Failed to go back to mode */ /* Failed to go back to mode */
@ -335,7 +333,6 @@ DrvAssertMode(IN DHPDEV DPev,
return TRUE; return TRUE;
} }
VOID APIENTRY VOID APIENTRY
DrvDisablePDEV(IN DHPDEV PDev) DrvDisablePDEV(IN DHPDEV PDev)
{ {
@ -352,7 +349,6 @@ DrvDisablePDEV(IN DHPDEV PDev)
EngFreeMem(PDev); EngFreeMem(PDev);
} }
VOID APIENTRY VOID APIENTRY
DrvDisableSurface(IN DHPDEV PDev) DrvDisableSurface(IN DHPDEV PDev)
{ {
@ -389,7 +385,6 @@ DrvDisableSurface(IN DHPDEV PDev)
/* EngFreeMem(pdsurf); */ /* free the surface */ /* EngFreeMem(pdsurf); */ /* free the surface */
} }
static VOID static VOID
InitSavedBits(IN PPDEV ppdev) InitSavedBits(IN PPDEV ppdev)
{ {
@ -429,7 +424,6 @@ InitSavedBits(IN PPDEV ppdev)
ppdev->BitsSaved = FALSE; ppdev->BitsSaved = FALSE;
} }
HSURF APIENTRY HSURF APIENTRY
DrvEnableSurface(IN DHPDEV PDev) DrvEnableSurface(IN DHPDEV PDev)
{ {
@ -516,7 +510,6 @@ error_done:
return NULL; return NULL;
} }
ULONG APIENTRY ULONG APIENTRY
DrvGetModes(IN HANDLE Driver, DrvGetModes(IN HANDLE Driver,
IN ULONG DataSize, IN ULONG DataSize,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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