-/*
- *
+/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* PURPOSE: Native DirectDraw implementation
* 25-10-2003 PB Created
*/
-#include <ddk/ntddk.h>
-#include <win32k/ntddraw.h>
-#include <win32k/win32k.h>
-#include <include/intddraw.h>
-#include <win32k/gdiobj.h>
+#include <w32k.h>
#define NDEBUG
#include <debug.h>
/* DIRECT DRAW OBJECT */
/************************************************************************/
-BOOL FASTCALL
-DD_Cleanup(PDD_DIRECTDRAW pDD)
+BOOL INTERNAL_CALL
+DD_Cleanup(PVOID ObjectBody)
{
- pDD->DrvDisableDirectDraw(pDD->Global.dhpdev);
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(ObjectBody, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("DD_Cleanup\n");
+
+ if (!pDirectDraw)
+ return FALSE;
+
+ pDirectDraw->DrvDisableDirectDraw(pDirectDraw->Global.dhpdev);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return TRUE;
}
-HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
+HANDLE STDCALL NtGdiDdCreateDirectDrawObject(
HDC hdc
)
{
DD_CALLBACKS callbacks;
DD_SURFACECALLBACKS surface_callbacks;
DD_PALETTECALLBACKS palette_callbacks;
-
- RtlZeroMemory(&callbacks, sizeof(callbacks));
- callbacks.dwSize = sizeof(callbacks);
- RtlZeroMemory(&surface_callbacks, sizeof(surface_callbacks));
- surface_callbacks.dwSize = sizeof(surface_callbacks);
- RtlZeroMemory(&palette_callbacks, sizeof(palette_callbacks));
- palette_callbacks.dwSize = sizeof(palette_callbacks);
-
+ DPRINT1("NtGdiDdCreateDirectDrawObject\n");
+
+ RtlZeroMemory(&callbacks, sizeof(DD_CALLBACKS));
+ callbacks.dwSize = sizeof(DD_CALLBACKS);
+ RtlZeroMemory(&surface_callbacks, sizeof(DD_SURFACECALLBACKS));
+ surface_callbacks.dwSize = sizeof(DD_SURFACECALLBACKS);
+ RtlZeroMemory(&palette_callbacks, sizeof(DD_PALETTECALLBACKS));
+ palette_callbacks.dwSize = sizeof(DD_PALETTECALLBACKS);
+
+ /* FIXME hdc can be zero for d3d9 */
+ /* we need create it, if in that case */
+ if (hdc == NULL)
+ {
+ return NULL;
+ }
+
DC *pDC = DC_LockDc(hdc);
if (!pDC)
return NULL;
if (!pDC->DriverFunctions.EnableDirectDraw)
{
// Driver doesn't support DirectDraw
- DC_UnlockDc(hdc);
+ DC_UnlockDc(pDC);
return NULL;
}
-
+
BOOL success = pDC->DriverFunctions.EnableDirectDraw(
pDC->PDev, &callbacks, &surface_callbacks, &palette_callbacks);
if (!success)
{
// DirectDraw creation failed
- DC_UnlockDc(hdc);
+ DC_UnlockDc(pDC);
return NULL;
}
HANDLE hDirectDraw = GDIOBJ_AllocObj(GDI_OBJECT_TYPE_DIRECTDRAW);
+ if (!hDirectDraw)
+ {
+ /* No more memmory */
+ DC_UnlockDc(pDC);
+ return NULL;
+ }
+
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
+ if (!pDirectDraw)
+ {
+ /* invalid handle */
+ DC_UnlockDc(pDC);
+ return NULL;
+ }
+
pDirectDraw->Global.dhpdev = pDC->PDev;
pDirectDraw->Local.lpGbl = &pDirectDraw->Global;
pDirectDraw->DrvGetDirectDrawInfo = pDC->DriverFunctions.GetDirectDrawInfo;
pDirectDraw->DrvDisableDirectDraw = pDC->DriverFunctions.DisableDirectDraw;
- if (callbacks.dwFlags & DDHAL_CB32_CREATESURFACE)
- pDirectDraw->DdCreateSurface = callbacks.CreateSurface;
- if (callbacks.dwFlags & DDHAL_CB32_SETCOLORKEY)
- pDirectDraw->DdDrvSetColorKey = callbacks.SetColorKey;
- if (callbacks.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
- pDirectDraw->DdWaitForVerticalBlank = callbacks.WaitForVerticalBlank;
- if (callbacks.dwFlags & DDHAL_CB32_CANCREATESURFACE)
- pDirectDraw->DdCanCreateSurface = callbacks.CanCreateSurface;
- if (callbacks.dwFlags & DDHAL_CB32_CREATEPALETTE)
- pDirectDraw->DdCreatePalette = callbacks.CreatePalette;
- if (callbacks.dwFlags & DDHAL_CB32_GETSCANLINE)
- pDirectDraw->DdGetScanLine = callbacks.GetScanLine;
- if (callbacks.dwFlags & DDHAL_CB32_MAPMEMORY)
- pDirectDraw->DdMapMemory = callbacks.MapMemory;
-
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE)
- pDirectDraw->DdDestroySurface = surface_callbacks.DestroySurface;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_FLIP)
- pDirectDraw->DdFlip = surface_callbacks.Flip;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETCLIPLIST)
- pDirectDraw->DdSetClipList = surface_callbacks.SetClipList;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_LOCK)
- pDirectDraw->DdLock = surface_callbacks.Lock;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_UNLOCK)
- pDirectDraw->DdUnlock = surface_callbacks.Unlock;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_BLT)
- pDirectDraw->DdBlt = surface_callbacks.Blt;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
- pDirectDraw->DdSetColorKey = surface_callbacks.SetColorKey;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)
- pDirectDraw->DdAddAttachedSurface = surface_callbacks.AddAttachedSurface;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS)
- pDirectDraw->DdGetBltStatus = surface_callbacks.GetBltStatus;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS)
- pDirectDraw->DdGetFlipStatus = surface_callbacks.GetFlipStatus;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY)
- pDirectDraw->DdUpdateOverlay = surface_callbacks.UpdateOverlay;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
- pDirectDraw->DdSetOverlayPosition = surface_callbacks.SetOverlayPosition;
- if (surface_callbacks.dwFlags & DDHAL_SURFCB32_SETPALETTE)
- pDirectDraw->DdSetPalette = surface_callbacks.SetPalette;
-
- if (palette_callbacks.dwFlags & DDHAL_PALCB32_DESTROYPALETTE)
- pDirectDraw->DdDestroyPalette = palette_callbacks.DestroyPalette;
- if (palette_callbacks.dwFlags & DDHAL_PALCB32_SETENTRIES)
- pDirectDraw->DdSetEntries = palette_callbacks.SetEntries;
-
- GDIOBJ_UnlockObj(hDirectDraw);
- DC_UnlockDc(hdc);
+ /* DD_CALLBACKS setup */
+ RtlMoveMemory(&pDirectDraw->DD, &callbacks, sizeof(DD_CALLBACKS));
+
+ /* DD_SURFACECALLBACKS setup*/
+ RtlMoveMemory(&pDirectDraw->Surf, &surface_callbacks, sizeof(DD_SURFACECALLBACKS));
+
+ /* DD_PALETTECALLBACKS setup*/
+ RtlMoveMemory(&pDirectDraw->Pal, &surface_callbacks, sizeof(DD_PALETTECALLBACKS));
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ DC_UnlockDc(pDC);
return hDirectDraw;
}
-BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
+BOOL STDCALL NtGdiDdDeleteDirectDrawObject(
HANDLE hDirectDrawLocal
)
{
+ DPRINT1("NtGdiDdDeleteDirectDrawObject\n");
return GDIOBJ_FreeObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
}
-BOOL STDCALL NtGdiDdQueryDirectDrawObject(
+BOOL STDCALL NtGdiDdQueryDirectDrawObject(
HANDLE hDirectDrawLocal,
DD_HALINFO *pHalInfo,
DWORD *pCallBackFlags,
- PD3DNTHAL_CALLBACKS puD3dCallbacks,
- PD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
+ LPD3DNTHAL_CALLBACKS puD3dCallbacks,
+ LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
LPDDSURFACEDESC puD3dTextureFormats,
DWORD *puNumHeaps,
)
{
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdQueryDirectDrawObject\n");
+
if (!pDirectDraw)
return FALSE;
if (!success)
{
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return FALSE;
}
- if (pHalInfo->lpD3DHALCallbacks)
+ if (pHalInfo)
{
- RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
- pDirectDraw->D3dContextCreate = puD3dCallbacks->ContextCreate;
- pDirectDraw->D3dContextDestroy = puD3dCallbacks->ContextDestroy;
+ RtlMoveMemory(&pDirectDraw->Hal, pHalInfo, sizeof(DD_HALINFO));
+
+ if (pHalInfo->lpD3DHALCallbacks)
+ {
+ RtlMoveMemory(puD3dCallbacks, pHalInfo->lpD3DHALCallbacks, sizeof(D3DNTHAL_CALLBACKS));
+ }
+
+ if (pHalInfo->lpD3DGlobalDriverData)
+ {
+ RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
+ }
+ if (pHalInfo->lpD3DBufCallbacks)
+ {
+ RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
+ }
+
+ }
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ return TRUE;
+}
+
+
+DWORD STDCALL NtGdiDdGetDriverInfo(
+ HANDLE hDirectDrawLocal,
+ PDD_GETDRIVERINFODATA puGetDriverInfoData)
+
+{
+ DWORD ddRVal;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetDriverInfo\n");
+
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ if (!(pDirectDraw->Hal.dwFlags & DDHALINFO_GETDRIVERINFOSET))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Hal.GetDriverInfo(puGetDriverInfoData);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ return ddRVal;
+}
+
+/************************************************************************/
+/* DD CALLBACKS */
+/* FIXME NtGdiDdCreateSurface we do not call to ddCreateSurface */
+/************************************************************************/
+
+DWORD STDCALL NtGdiDdCreateSurface(
+ HANDLE hDirectDrawLocal,
+ HANDLE *hSurface,
+ DDSURFACEDESC *puSurfaceDescription,
+ DD_SURFACE_GLOBAL *puSurfaceGlobalData,
+ DD_SURFACE_LOCAL *puSurfaceLocalData,
+ DD_SURFACE_MORE *puSurfaceMoreData,
+ PDD_CREATESURFACEDATA puCreateSurfaceData,
+ HANDLE *puhSurface
+)
+{
+ DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+ DPRINT1("NtGdiDdCreateSurface\n");
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puCreateSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puCreateSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ {
+ ddRVal = pDirectDraw->DD.CreateSurface(puCreateSurfaceData);
}
- if (pHalInfo->lpD3DGlobalDriverData)
+ /* But back the orignal PDev */
+ puCreateSurfaceData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdWaitForVerticalBlank(
+ HANDLE hDirectDrawLocal,
+ PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+ DPRINT1("NtGdiDdWaitForVerticalBlank\n");
+
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puWaitForVerticalBlankData->lpDD;
+
+ /* use our cache version instead */
+ puWaitForVerticalBlankData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->DD.WaitForVerticalBlank(puWaitForVerticalBlankData);
+
+ /* But back the orignal PDev */
+ puWaitForVerticalBlankData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdCanCreateSurface(
+ HANDLE hDirectDrawLocal,
+ PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdCanCreateSurface\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puCanCreateSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puCanCreateSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_CANCREATESURFACE))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->DD.CanCreateSurface(puCanCreateSurfaceData);
+
+ /* But back the orignal PDev */
+ puCanCreateSurfaceData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdGetScanLine(
+ HANDLE hDirectDrawLocal,
+ PDD_GETSCANLINEDATA puGetScanLineData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetScanLine\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetScanLineData->lpDD;
+
+ /* use our cache version instead */
+ puGetScanLineData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->DD.dwFlags & DDHAL_CB32_GETSCANLINE))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->DD.GetScanLine(puGetScanLineData);
+
+ /* But back the orignal PDev */
+ puGetScanLineData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+
+
+/************************************************************************/
+/* Surface CALLBACKS */
+/* FIXME */
+/* NtGdiDdDestroySurface */
+/************************************************************************/
+
+DWORD STDCALL NtGdiDdDestroySurface(
+ HANDLE hSurface,
+ BOOL bRealDestroy
+)
+{
+ DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdDestroySurface\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_DESTROYSURFACE))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
{
- RtlMoveMemory(puD3dDriverData, pHalInfo->lpD3DGlobalDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
- }
+ DD_DESTROYSURFACEDATA DestroySurf;
- if (pHalInfo->lpD3DBufCallbacks)
- {
- RtlMoveMemory(puD3dBufferCallbacks, pHalInfo->lpD3DBufCallbacks, sizeof(DD_D3DBUFCALLBACKS));
- pDirectDraw->DdCanCreateD3DBuffer = puD3dBufferCallbacks->CanCreateD3DBuffer;
- pDirectDraw->DdCreateD3DBuffer = puD3dBufferCallbacks->CreateD3DBuffer;
- pDirectDraw->DdDestroyD3DBuffer = puD3dBufferCallbacks->DestroyD3DBuffer;
- pDirectDraw->DdLockD3DBuffer = puD3dBufferCallbacks->LockD3DBuffer;
- pDirectDraw->DdUnlockD3DBuffer = puD3dBufferCallbacks->UnlockD3DBuffer;
+ /* FIXME
+ * bRealDestroy
+ * are we doing right ??
+ */
+ DestroySurf.lpDD = &pDirectDraw->Global;
+
+ DestroySurf.lpDDSurface = hSurface; // ?
+ DestroySurf.DestroySurface = pDirectDraw->Surf.DestroySurface;
+
+ ddRVal = pDirectDraw->Surf.DestroySurface(&DestroySurf);
}
+
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdFlip(
+ HANDLE hSurfaceCurrent,
+ HANDLE hSurfaceTarget,
+ HANDLE hSurfaceCurrentLeft,
+ HANDLE hSurfaceTargetLeft,
+ PDD_FLIPDATA puFlipData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceTarget, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdFlip\n");
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
- return TRUE;
+ /* backup the orignal PDev and info */
+ lgpl = puFlipData->lpDD;
+
+ /* use our cache version instead */
+ puFlipData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_FLIP))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.Flip(puFlipData);
+
+ /* But back the orignal PDev */
+ puFlipData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
}
+DWORD STDCALL NtGdiDdLock(
+ HANDLE hSurface,
+ PDD_LOCKDATA puLockData,
+ HDC hdcClip
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdLock\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puLockData->lpDD;
+
+ /* use our cache version instead */
+ puLockData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_LOCK))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.Lock(puLockData);
+
+ /* But back the orignal PDev */
+ puLockData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdUnlock(
+ HANDLE hSurface,
+ PDD_UNLOCKDATA puUnlockData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdUnlock\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puUnlockData->lpDD;
+
+ /* use our cache version instead */
+ puUnlockData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UNLOCK))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.Unlock(puUnlockData);
+
+ /* But back the orignal PDev */
+ puUnlockData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdBlt(
+ HANDLE hSurfaceDest,
+ HANDLE hSurfaceSrc,
+ PDD_BLTDATA puBltData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDest, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdBlt\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puBltData->lpDD;
+
+ /* use our cache version instead */
+ puBltData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_BLT))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.Blt(puBltData);
+
+ /* But back the orignal PDev */
+ puBltData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+ }
+
+DWORD STDCALL NtGdiDdSetColorKey(
+ HANDLE hSurface,
+ PDD_SETCOLORKEYDATA puSetColorKeyData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetColorKey\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puSetColorKeyData->lpDD;
+
+ /* use our cache version instead */
+ puSetColorKeyData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETCOLORKEY))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.SetColorKey(puSetColorKeyData);
+
+ /* But back the orignal PDev */
+ puSetColorKeyData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+
+DWORD STDCALL NtGdiDdAddAttachedSurface(
+ HANDLE hSurface,
+ HANDLE hSurfaceAttached,
+ PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceAttached, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdAddAttachedSurface\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puAddAttachedSurfaceData->lpDD;
+
+ /* use our cache version instead */
+ puAddAttachedSurfaceData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_ADDATTACHEDSURFACE))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.AddAttachedSurface(puAddAttachedSurfaceData);
+
+ /* But back the orignal PDev */
+ puAddAttachedSurfaceData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdGetBltStatus(
+ HANDLE hSurface,
+ PDD_GETBLTSTATUSDATA puGetBltStatusData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetBltStatus\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetBltStatusData->lpDD;
+
+ /* use our cache version instead */
+ puGetBltStatusData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETBLTSTATUS))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.GetBltStatus(puGetBltStatusData);
+
+ /* But back the orignal PDev */
+ puGetBltStatusData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdGetFlipStatus(
+ HANDLE hSurface,
+ PDD_GETFLIPSTATUSDATA puGetFlipStatusData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetFlipStatus\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puGetFlipStatusData->lpDD;
+
+ /* use our cache version instead */
+ puGetFlipStatusData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_GETFLIPSTATUS))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.GetFlipStatus(puGetFlipStatusData);
+
+ /* But back the orignal PDev */
+ puGetFlipStatusData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdUpdateOverlay(
+ HANDLE hSurfaceDestination,
+ HANDLE hSurfaceSource,
+ PDD_UPDATEOVERLAYDATA puUpdateOverlayData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdUpdateOverlay\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puUpdateOverlayData->lpDD;
+
+ /* use our cache version instead */
+ puUpdateOverlayData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_UPDATEOVERLAY))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.UpdateOverlay(puUpdateOverlayData);
+
+ /* But back the orignal PDev */
+ puUpdateOverlayData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+DWORD STDCALL NtGdiDdSetOverlayPosition(
+ HANDLE hSurfaceSource,
+ HANDLE hSurfaceDestination,
+ PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
+)
+{
+ DWORD ddRVal;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hSurfaceDestination, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetOverlayPosition\n");
+ if (pDirectDraw == NULL)
+ return DDHAL_DRIVER_NOTHANDLED;
+
+ /* backup the orignal PDev and info */
+ lgpl = puSetOverlayPositionData->lpDD;
+
+ /* use our cache version instead */
+ puSetOverlayPositionData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ if (!(pDirectDraw->Surf.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION))
+ ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ else
+ ddRVal = pDirectDraw->Surf.SetOverlayPosition(puSetOverlayPositionData);
+
+ /* But back the orignal PDev */
+ puSetOverlayPositionData->lpDD = lgpl;
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+ return ddRVal;
+}
+
+
/************************************************************************/
/* SURFACE OBJECT */
/************************************************************************/
-BOOL FASTCALL
-DDSURF_Cleanup(PDD_SURFACE pDDSurf)
+BOOL INTERNAL_CALL
+DDSURF_Cleanup(PVOID pDDSurf)
{
- //FIXME: implement
+ /* FIXME: implement
+ * PDD_SURFACE pDDSurf = PVOID pDDSurf
+ */
+ DPRINT1("DDSURF_Cleanup\n");
return TRUE;
}
-HANDLE STDCALL NtGdiDdCreateSurfaceObject(
+HANDLE STDCALL NtGdiDdCreateSurfaceObject(
HANDLE hDirectDrawLocal,
HANDLE hSurface,
PDD_SURFACE_LOCAL puSurfaceLocal,
)
{
PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdCreateSurfaceObject\n");
if (!pDirectDraw)
return NULL;
PDD_SURFACE pSurface = GDIOBJ_LockObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
/* FIXME - Handle pSurface == NULL!!!! */
-
+
RtlMoveMemory(&pSurface->Local, puSurfaceLocal, sizeof(DD_SURFACE_LOCAL));
RtlMoveMemory(&pSurface->More, puSurfaceMore, sizeof(DD_SURFACE_MORE));
RtlMoveMemory(&pSurface->Global, puSurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
// FIXME: figure out how to use this
pSurface->bComplete = bComplete;
- GDIOBJ_UnlockObj(hSurface);
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ GDIOBJ_UnlockObjByPtr(pSurface);
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
return hSurface;
}
-BOOL STDCALL NtGdiDdDeleteSurfaceObject(
+BOOL STDCALL NtGdiDdDeleteSurfaceObject(
HANDLE hSurface
)
{
+ DPRINT1("NtGdiDdDeleteSurfaceObject\n");
return GDIOBJ_FreeObj(hSurface, GDI_OBJECT_TYPE_DD_SURFACE);
}
+
+
+/************************************************************************/
+/* DIRECT DRAW SURFACR END */
+/************************************************************************/
+
+
/*
-BOOL STDCALL NtGdiDdAttachSurface(
+BOOL STDCALL NtGdiDdAttachSurface(
HANDLE hSurfaceFrom,
HANDLE hSurfaceTo
)
PDD_SURFACE pSurfaceTo = GDIOBJ_LockObj(hSurfaceTo, GDI_OBJECT_TYPE_DD_SURFACE);
if (!pSurfaceTo)
{
- GDIOBJ_UnlockObj(hSurfaceFrom);
+ GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
return FALSE;
}
pSurfaceFrom->Local.lpAttachListFrom = pSurfaceFrom->AttachListFrom;
}
- GDIOBJ_UnlockObj(hSurfaceFrom);
- GDIOBJ_UnlockObj(hSurfaceTo);
+ GDIOBJ_UnlockObjByPtr(pSurfaceFrom);
+ GDIOBJ_UnlockObjByPtr(pSurfaceTo);
return TRUE;
}
*/
+DWORD STDCALL NtGdiDdGetAvailDriverMemory(
+ HANDLE hDirectDrawLocal,
+ PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
+)
+{
+ DWORD ddRVal = DDHAL_DRIVER_NOTHANDLED;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
+
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdGetAvailDriverMemory\n");
+ /* backup the orignal PDev and info */
+ lgpl = puGetAvailDriverMemoryData->lpDD;
-DWORD STDCALL NtGdiDdGetDriverInfo(
- HANDLE hDirectDrawLocal,
- PDD_GETDRIVERINFODATA puGetDriverInfoData)
+ /* use our cache version instead */
+ puGetAvailDriverMemoryData->lpDD = &pDirectDraw->Global;
-{
- DWORD pdwNumHeaps;
- VIDEOMEMORY *pvmList = NULL;
- DWORD pdwNumFourCC;
- DWORD *pdwFourCC = NULL;
- DWORD ddRVal;
-
+ /* make the call */
+ // ddRVal = pDirectDraw->DdGetAvailDriverMemory(puGetAvailDriverMemoryData);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
- PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
- ddRVal = pDirectDraw->DrvGetDirectDrawInfo(
- pDirectDraw->Global.dhpdev,(PDD_HALINFO) puGetDriverInfoData,
- &pdwNumHeaps, pvmList, &pdwNumFourCC, pdwFourCC);
+ /* But back the orignal PDev */
+ puGetAvailDriverMemoryData->lpDD = lgpl;
- GDIOBJ_UnlockObj(hDirectDrawLocal);
-
return ddRVal;
}
-DWORD STDCALL NtGdiDdWaitForVerticalBlank(
- HANDLE hDirectDrawLocal,
- PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
+
+DWORD STDCALL NtGdiDdSetExclusiveMode(
+ HANDLE hDirectDraw,
+ PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
)
{
DWORD ddRVal;
- PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDrawLocal, GDI_OBJECT_TYPE_DIRECTDRAW);
-
- puWaitForVerticalBlankData->lpDD = pDirectDraw->Local.lpGbl;
+ PDD_DIRECTDRAW_GLOBAL lgpl;
- ddRVal = pDirectDraw->DdWaitForVerticalBlank(puWaitForVerticalBlankData);
+ PDD_DIRECTDRAW pDirectDraw = GDIOBJ_LockObj(hDirectDraw, GDI_OBJECT_TYPE_DIRECTDRAW);
+ DPRINT1("NtGdiDdSetExclusiveMode\n");
- GDIOBJ_UnlockObj(hDirectDrawLocal);
+ /* backup the orignal PDev and info */
+ lgpl = puSetExclusiveModeData->lpDD;
- return ddRVal;
+ /* use our cache version instead */
+ puSetExclusiveModeData->lpDD = &pDirectDraw->Global;
+
+ /* make the call */
+ ddRVal = pDirectDraw->DdSetExclusiveMode(puSetExclusiveModeData);
+
+ GDIOBJ_UnlockObjByPtr(pDirectDraw);
+
+ /* But back the orignal PDev */
+ puSetExclusiveModeData->lpDD = lgpl;
+
+ return ddRVal;
}
+
/* EOF */
projects / reactos.git / blobdiff