26 Nov
2008
26 Nov
'08
6:44 a.m.
Author: greatlrd
Date: Wed Nov 26 00:44:48 2008
New Revision: 37650
URL: http://svn.reactos.org/svn/reactos?rev=37650&view=rev
Log:
rename a fileto better name
Added:
branches/reactx/reactos/dll/win32/gdi32/misc/gdientryhelgl.c
- copied unchanged from r37647,
branches/reactx/reactos/dll/win32/gdi32/misc/gdientryglhel.c
Removed:
branches/reactx/reactos/dll/win32/gdi32/misc/gdientryglhel.c
Removed: branches/reactx/reactos/dll/win32/gdi32/misc/gdientryglhel.c
URL:
http://svn.reactos.org/svn/reactos/branches/reactx/reactos/dll/win32/gdi32/…
==============================================================================
--- branches/reactx/reactos/dll/win32/gdi32/misc/gdientryglhel.c [iso-8859-1] (original)
+++ branches/reactx/reactos/dll/win32/gdi32/misc/gdientryglhel.c (removed)
@@ -1,2312 +1,0 @@
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS GDI32
- * PURPOSE: GDI DirectX inteface
- * FILE: lib/gdi32/misc/gdientry.c
- * PROGRAMERS: Alex Ionescu (alex(a)relsoft.net)
- * Magnus Olsen (magnus(a)greatlord.com)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include "precomp.h"
-#include <ddraw.h>
-#include <ddrawi.h>
-#include <ddrawint.h>
-#include <ddrawgdi.h>
-#include <ntgdi.h>
-#include <d3dhal.h>
-
-/* DATA **********************************************************************/
-
-HANDLE ghDirectDraw;
-ULONG gcDirectDraw;
-
-#define GetDdHandle(Handle) ((HANDLE)Handle ? (HANDLE)Handle : ghDirectDraw)
-
-
-
-/* CALLBACKS *****************************************************************/
-
-/*
- * @implemented
- *
- * DdAddAttachedSurface
- */
-DWORD
-WINAPI
-DdAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA Attach)
-{
-
- /* Fixme for opengl hel emulations */
- return 0;
- /* Call win32k */
-#if 0
- return NtGdiDdAddAttachedSurface((HANDLE)Attach->lpDDSurface->hDDSurface,
- (HANDLE)Attach->lpSurfAttached->hDDSurface,
- (PDD_ADDATTACHEDSURFACEDATA)Attach);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdBlt
- */
-DWORD
-WINAPI
-DdBlt(LPDDHAL_BLTDATA Blt)
-{
- HANDLE Surface = 0;
-
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Use the right surface */
- if (Blt->lpDDSrcSurface)
- {
- Surface = (HANDLE)Blt->lpDDSrcSurface->hDDSurface;
- }
-
- /* Call win32k */
- return NtGdiDdBlt((HANDLE)Blt->lpDDDestSurface->hDDSurface, Surface,
(PDD_BLTDATA)Blt);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdDestroySurface
- */
-DWORD
-WINAPI
-DdDestroySurface(LPDDHAL_DESTROYSURFACEDATA pDestroySurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- DWORD Return = DDHAL_DRIVER_NOTHANDLED;
- BOOL RealDestroy;
-
- if (pDestroySurface->lpDDSurface->hDDSurface)
- {
- /* Check if we shoudl really destroy it */
- RealDestroy = !(pDestroySurface->lpDDSurface->dwFlags &
DDRAWISURF_DRIVERMANAGED) ||
- !(pDestroySurface->lpDDSurface->dwFlags &
DDRAWISURF_INVALID);
-
- /* Call win32k */
- Return =
NtGdiDdDestroySurface((HANDLE)pDestroySurface->lpDDSurface->hDDSurface,
RealDestroy);
- }
-
- return Return;
-#endif
-}
-
-/*
- * @implemented
- *
- * DdFlip
- */
-DWORD
-WINAPI
-DdFlip(LPDDHAL_FLIPDATA Flip)
-{
-
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Note :
- * See http://msdn2.microsoft.com/en-us/library/ms794213.aspx and
- * http://msdn2.microsoft.com/en-us/library/ms792675.aspx
- */
-
- HANDLE hSurfaceCurrentLeft = NULL;
- HANDLE hSurfaceTargetLeft = NULL;
-
- /* Auto flip off or on */
- if (Flip->dwFlags & DDFLIP_STEREO )
- {
- if ( (Flip->lpSurfTargLeft) &&
- (Flip->lpSurfCurrLeft))
- {
- /* Auto flip on */
- hSurfaceTargetLeft = (HANDLE) Flip->lpSurfTargLeft->hDDSurface;
- hSurfaceCurrentLeft = (HANDLE) Flip->lpSurfCurrLeft->hDDSurface;
- }
- }
-
- /* Call win32k */
- return NtGdiDdFlip( (HANDLE) Flip->lpSurfCurr->hDDSurface,
- (HANDLE) Flip->lpSurfTarg->hDDSurface,
- hSurfaceCurrentLeft,
- hSurfaceTargetLeft,
- (PDD_FLIPDATA) Flip);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdLock
- */
-DWORD
-WINAPI
-DdLock(LPDDHAL_LOCKDATA Lock)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k */
- return NtGdiDdLock((HANDLE)Lock->lpDDSurface->hDDSurface,
- (PDD_LOCKDATA)Lock,
- (HANDLE)Lock->lpDDSurface->hDC);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdUnlock
- */
-DWORD
-WINAPI
-DdUnlock(LPDDHAL_UNLOCKDATA Unlock)
-{
- /* Call win32k */
- return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface,
- (PDD_UNLOCKDATA)Unlock);
-}
-
-/*
- * @implemented
- *
- * DdGetBltStatus
- */
-DWORD
-WINAPI
-DdGetBltStatus(LPDDHAL_GETBLTSTATUSDATA GetBltStatus)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k */
- return NtGdiDdGetBltStatus((HANDLE)GetBltStatus->lpDDSurface->hDDSurface,
- (PDD_GETBLTSTATUSDATA)GetBltStatus);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdGetBltStatus
- */
-DWORD
-WINAPI
-DdGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA GetFlipStatus)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k */
- return NtGdiDdGetFlipStatus((HANDLE)GetFlipStatus->lpDDSurface->hDDSurface,
- (PDD_GETFLIPSTATUSDATA)GetFlipStatus);
-#endif
-
-}
-
-/*
- * @implemented
- *
- * DdUpdateOverlay
- */
-DWORD
-WINAPI
-DdUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA UpdateOverlay)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* We have to handle this manually here */
- if (UpdateOverlay->dwFlags & DDOVER_KEYDEST)
- {
- /* Use the override */
- UpdateOverlay->dwFlags &= ~DDOVER_KEYDEST;
- UpdateOverlay->dwFlags |= DDOVER_KEYDESTOVERRIDE;
-
- /* Set the overlay */
- UpdateOverlay->overlayFX.dckDestColorkey =
- UpdateOverlay->lpDDDestSurface->ddckCKDestOverlay;
- }
- if (UpdateOverlay->dwFlags & DDOVER_KEYSRC)
- {
- /* Use the override */
- UpdateOverlay->dwFlags &= ~DDOVER_KEYSRC;
- UpdateOverlay->dwFlags |= DDOVER_KEYSRCOVERRIDE;
-
- /* Set the overlay */
- UpdateOverlay->overlayFX.dckSrcColorkey =
- UpdateOverlay->lpDDSrcSurface->ddckCKSrcOverlay;
- }
-
- /* Call win32k */
- return
NtGdiDdUpdateOverlay((HANDLE)UpdateOverlay->lpDDDestSurface->hDDSurface,
-
(HANDLE)UpdateOverlay->lpDDSrcSurface->hDDSurface,
- (PDD_UPDATEOVERLAYDATA)UpdateOverlay);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdSetOverlayPosition
- */
-DWORD
-WINAPI
-DdSetOverlayPosition(LPDDHAL_SETOVERLAYPOSITIONDATA SetOverlayPosition)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k */
- return NtGdiDdSetOverlayPosition(
(HANDLE)SetOverlayPosition->lpDDSrcSurface->hDDSurface,
-
(HANDLE)SetOverlayPosition->lpDDDestSurface->hDDSurface,
- (PDD_SETOVERLAYPOSITIONDATA) SetOverlayPosition);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdWaitForVerticalBlank
- */
-DWORD
-WINAPI
-DdWaitForVerticalBlank(LPDDHAL_WAITFORVERTICALBLANKDATA WaitForVerticalBlank)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k */
- return NtGdiDdWaitForVerticalBlank(GetDdHandle(
- WaitForVerticalBlank->lpDD->hDD),
- (PDD_WAITFORVERTICALBLANKDATA)
- WaitForVerticalBlank);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdCanCreateSurface
- */
-DWORD
-WINAPI
-DdCanCreateSurface(LPDDHAL_CANCREATESURFACEDATA CanCreateSurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /*
- * Note : This functions are basic same, in win32k
- * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs
- * toghter in win32k at end and retrurn same data, it is still sepreated
- * at user mode but in kmode it is not.
- */
-
- /* Call win32k */
- return NtGdiDdCanCreateSurface(GetDdHandle(CanCreateSurface->lpDD->hDD),
- (PDD_CANCREATESURFACEDATA)CanCreateSurface);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdCreateSurface
- */
-DWORD
-WINAPI
-DdCreateSurface(LPDDHAL_CREATESURFACEDATA pCreateSurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- DWORD Return = DDHAL_DRIVER_NOTHANDLED;
- ULONG SurfaceCount = pCreateSurface->dwSCnt;
- DD_SURFACE_LOCAL DdSurfaceLocal;
- DD_SURFACE_MORE DdSurfaceMore;
- DD_SURFACE_GLOBAL DdSurfaceGlobal;
-
- HANDLE hPrevSurface, hSurface;
-
- PDD_SURFACE_LOCAL pDdSurfaceLocal = NULL;
- PDD_SURFACE_MORE pDdSurfaceMore = NULL;
- PDD_SURFACE_GLOBAL pDdSurfaceGlobal = NULL;
-
- PDD_SURFACE_LOCAL ptmpDdSurfaceLocal = NULL;
- PDD_SURFACE_MORE ptmpDdSurfaceMore = NULL;
- PDD_SURFACE_GLOBAL ptmpDdSurfaceGlobal = NULL;
- PHANDLE phSurface = NULL, puhSurface = NULL;
- ULONG i;
- LPDDSURFACEDESC pSurfaceDesc = NULL;
-
- /* TODO : Speed optimze, most games/dx apps/program does not want 1 surface, they
want lest 2
- * so we need incress the stack so it can contain 2 surface instead of one, this will
incress
- * the speed of the apps when it trying alloc buffer. How to incress the surface
stack space
- * we need create a own struct for DD_SURFACE_LOCAL DdSurfaceLocal, DD_SURFACE_MORE
DdSurfaceMore
- * DD_SURFACE_GLOBAL DdSurfaceGlobal. HANDLE hPrevSurface, hSurface. like
- * struct { DD_SURFACE_LOCAL DdSurfaceLocal1, DD_SURFACE_LOCAL DdSurfaceLocal2 }
- * lest so it contain two surface. maybe 4. we need watch what is most common here
before
- * we create the size activate this IF when you start doing the optimze and please
also
- * take report from user which value they got here
- */
-#if 1
- {
- char buffer[1024]; \
- sprintf ( buffer, "Function %s : Optimze max to %d Surface ?
(%s:%d)\n", __FUNCTION__, (int)SurfaceCount,__FILE__,__LINE__ );
- OutputDebugStringA(buffer);
- }
-#endif
-
- /* Check how many surfaces there are */
- if (SurfaceCount != 1)
- {
- /* We got more that one surface so we need alloc memory for them */
- pDdSurfaceLocal = (PDD_SURFACE_LOCAL) HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, (sizeof(DD_SURFACE_LOCAL) * SurfaceCount ));
- pDdSurfaceMore = (PDD_SURFACE_MORE) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
(sizeof(DD_SURFACE_MORE) * SurfaceCount ));
- pDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, (sizeof(DD_SURFACE_GLOBAL) * SurfaceCount ));
- phSurface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(HANDLE) *
SurfaceCount ));
- puhSurface = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (sizeof(HANDLE) *
SurfaceCount ));
-
- /* check if we sueese alloc all memory we need */
- if ((pDdSurfaceLocal == NULL) || (pDdSurfaceMore == NULL) || (pDdSurfaceGlobal ==
NULL) || (phSurface == NULL) || (puhSurface == NULL))
- {
- pCreateSurface->ddRVal = DDERR_OUTOFMEMORY;
-
- if ( pDdSurfaceLocal != NULL )
- {
- HeapFree(GetProcessHeap(), 0, pDdSurfaceLocal);
- }
-
- if ( pDdSurfaceMore != NULL )
- {
- HeapFree(GetProcessHeap(), 0, pDdSurfaceMore);
- }
-
- if ( phSurface != NULL )
- {
- HeapFree(GetProcessHeap(), 0, phSurface);
- }
-
- if ( puhSurface != NULL )
- {
- HeapFree(GetProcessHeap(), 0, puhSurface);
- }
-
- return DDHAL_DRIVER_HANDLED;
- }
- }
- else
- {
- /* We'll use what we have on the stack */
- pDdSurfaceLocal = &DdSurfaceLocal;
- pDdSurfaceMore = &DdSurfaceMore;
- pDdSurfaceGlobal = &DdSurfaceGlobal;
- phSurface = &hPrevSurface;
- puhSurface = &hSurface;
-
- /* Clear the structures */
- RtlZeroMemory(&DdSurfaceLocal, sizeof(DdSurfaceLocal));
- RtlZeroMemory(&DdSurfaceGlobal, sizeof(DdSurfaceGlobal));
- RtlZeroMemory(&DdSurfaceMore, sizeof(DdSurfaceMore));
- }
-
- /* check if we got a surface or not */
- if (SurfaceCount!=0)
- {
- /* Loop for each surface */
- ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
- ptmpDdSurfaceLocal = pDdSurfaceLocal;
- ptmpDdSurfaceMore = pDdSurfaceMore;
- pSurfaceDesc = pCreateSurface->lpDDSurfaceDesc;
-
- for (i = 0; i < SurfaceCount; i++)
- {
- LPDDRAWI_DDRAWSURFACE_LCL lcl = pCreateSurface->lplpSList[i];
- LPDDRAWI_DDRAWSURFACE_GBL gpl = pCreateSurface->lplpSList[i]->lpGbl;
-
- phSurface[i] = (HANDLE)lcl->hDDSurface;
- ptmpDdSurfaceLocal->ddsCaps.dwCaps = lcl->ddsCaps.dwCaps;
-
- ptmpDdSurfaceLocal->dwFlags = (ptmpDdSurfaceLocal->dwFlags &
- (0xB0000000 | DDRAWISURF_INMASTERSPRITELIST |
- DDRAWISURF_HELCB | DDRAWISURF_FRONTBUFFER |
- DDRAWISURF_BACKBUFFER | DDRAWISURF_INVALID |
- DDRAWISURF_DCIBUSY | DDRAWISURF_DCILOCK)) |
- (lcl->dwFlags &
DDRAWISURF_DRIVERMANAGED);
-
- ptmpDdSurfaceGlobal->wWidth = gpl->wWidth;
- ptmpDdSurfaceGlobal->wHeight = gpl->wHeight;
- ptmpDdSurfaceGlobal->lPitch = gpl->lPitch;
- ptmpDdSurfaceGlobal->fpVidMem = gpl->fpVidMem;
- ptmpDdSurfaceGlobal->dwBlockSizeX = gpl->dwBlockSizeX;
- ptmpDdSurfaceGlobal->dwBlockSizeY = gpl->dwBlockSizeY;
-
- if (lcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
- {
- RtlCopyMemory( &ptmpDdSurfaceGlobal->ddpfSurface ,
- &gpl->ddpfSurface,
- sizeof(DDPIXELFORMAT));
-
- ptmpDdSurfaceGlobal->ddpfSurface.dwSize = sizeof(DDPIXELFORMAT);
- }
- else
- {
- RtlCopyMemory( &ptmpDdSurfaceGlobal->ddpfSurface ,
- &gpl->lpDD->vmiData.ddpfDisplay,
- sizeof(DDPIXELFORMAT));
- }
-
- /* Note if lcl->lpSurfMore is NULL zero out
- * ptmpDdSurfaceMore->ddsCapsEx.dwCaps2,
- * dwCaps3, dwCaps4, ptmpDdSurfaceMore->dwSurfaceHandle
- */
- if (lcl->lpSurfMore)
- {
- ptmpDdSurfaceMore->ddsCapsEx.dwCaps2 =
lcl->lpSurfMore->ddsCapsEx.dwCaps2;
- ptmpDdSurfaceMore->ddsCapsEx.dwCaps3 =
lcl->lpSurfMore->ddsCapsEx.dwCaps3;
- ptmpDdSurfaceMore->ddsCapsEx.dwCaps4 =
lcl->lpSurfMore->ddsCapsEx.dwCaps4;
- ptmpDdSurfaceMore->dwSurfaceHandle =
lcl->lpSurfMore->dwSurfaceHandle;
- }
-
-
- /* count to next SurfaceCount */
- ptmpDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceGlobal)) + sizeof(DD_SURFACE_GLOBAL));
- ptmpDdSurfaceLocal = (PDD_SURFACE_LOCAL) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceLocal)) + sizeof(DD_SURFACE_LOCAL));
- ptmpDdSurfaceMore = (PDD_SURFACE_MORE) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceMore)) + sizeof(DD_SURFACE_MORE));
- }
- }
-
- /* Call win32k now */
- pCreateSurface->ddRVal = DDERR_GENERIC;
-
- Return = NtGdiDdCreateSurface(GetDdHandle(pCreateSurface->lpDD->hDD),
- (HANDLE *)phSurface,
- pSurfaceDesc,
- pDdSurfaceGlobal,
- pDdSurfaceLocal,
- pDdSurfaceMore,
- (PDD_CREATESURFACEDATA)pCreateSurface,
- puhSurface);
-
- if (SurfaceCount == 0)
- {
- pCreateSurface->ddRVal = DDERR_GENERIC;
- }
- else
- {
- ptmpDdSurfaceMore = pDdSurfaceMore;
- ptmpDdSurfaceGlobal = pDdSurfaceGlobal;
- ptmpDdSurfaceLocal = pDdSurfaceLocal;
-
- for (i=0;i<SurfaceCount;i++)
- {
- LPDDRAWI_DDRAWSURFACE_LCL lcl = pCreateSurface->lplpSList[i];
- LPDDRAWI_DDRAWSURFACE_GBL gpl = pCreateSurface->lplpSList[i]->lpGbl;
-
- gpl->lPitch = ptmpDdSurfaceGlobal->lPitch;
- gpl->fpVidMem = ptmpDdSurfaceGlobal->fpVidMem;
- gpl->dwBlockSizeX = ptmpDdSurfaceGlobal->dwBlockSizeX;
- gpl->dwBlockSizeY = ptmpDdSurfaceGlobal->dwBlockSizeY;
-
- if (lcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
- {
- RtlCopyMemory( &gpl->ddpfSurface,
&ptmpDdSurfaceGlobal->ddpfSurface , sizeof(DDPIXELFORMAT));
- }
-
- if (pCreateSurface->ddRVal != DD_OK)
- {
- gpl->fpVidMem = 0;
- if (lcl->hDDSurface)
- {
- NtGdiDdDeleteSurfaceObject( (HANDLE)lcl->hDDSurface);
- }
- lcl->hDDSurface = 0;
- }
- else
- {
-
- lcl->hDDSurface = (ULONG_PTR) puhSurface[i];
- }
-
- lcl->ddsCaps.dwCaps = ptmpDdSurfaceLocal->ddsCaps.dwCaps;
- if (lcl->lpSurfMore)
- {
- lcl->lpSurfMore->ddsCapsEx.dwCaps2 =
ptmpDdSurfaceMore->ddsCapsEx.dwCaps2;
- lcl->lpSurfMore->ddsCapsEx.dwCaps3 =
ptmpDdSurfaceMore->ddsCapsEx.dwCaps3;
- lcl->lpSurfMore->ddsCapsEx.dwCaps4 =
ptmpDdSurfaceMore->ddsCapsEx.dwCaps4;
- }
-
- /* count to next SurfaceCount */
- ptmpDdSurfaceGlobal = (PDD_SURFACE_GLOBAL) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceGlobal)) + sizeof(DD_SURFACE_GLOBAL));
- ptmpDdSurfaceLocal = (PDD_SURFACE_LOCAL) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceLocal)) + sizeof(DD_SURFACE_LOCAL));
- ptmpDdSurfaceMore = (PDD_SURFACE_MORE) (((PBYTE) ((ULONG_PTR)
ptmpDdSurfaceMore)) + sizeof(DD_SURFACE_MORE));
- }
- }
-
- /* Check if we have to free all our local allocations */
- if (SurfaceCount > 1)
- {
- if ( pDdSurfaceLocal != NULL )
- {
- HeapFree(GetProcessHeap(), 0, pDdSurfaceLocal);
- }
-
- if ( pDdSurfaceMore != NULL )
- {
- HeapFree(GetProcessHeap(), 0, pDdSurfaceMore);
- }
-
- if ( phSurface != NULL )
- {
- HeapFree(GetProcessHeap(), 0, phSurface);
- }
-
- if ( puhSurface != NULL )
- {
- HeapFree(GetProcessHeap(), 0, puhSurface);
- }
- }
-
- /* Return */
- return Return;
-#endif
-}
-
-/*
- * @implemented
- *
- * DdSetColorKey
- */
-DWORD
-WINAPI
-DdSetColorKey(LPDDHAL_SETCOLORKEYDATA pSetColorKey)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k */
- return NtGdiDdSetColorKey((HANDLE)pSetColorKey->lpDDSurface->hDDSurface,
- (PDD_SETCOLORKEYDATA)pSetColorKey);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdGetScanLine
- */
-DWORD
-WINAPI
-DdGetScanLine(LPDDHAL_GETSCANLINEDATA pGetScanLine)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k */
- return NtGdiDdGetScanLine(GetDdHandle(pGetScanLine->lpDD->hDD),
- (PDD_GETSCANLINEDATA)pGetScanLine);
-#endif
-}
-
-
-/*
- * @implemented
- *
- * DvpCreateVideoPort
- */
-BOOL
-WINAPI
-DvpCreateVideoPort(LPDDHAL_CREATEVPORTDATA pDvdCreatePort)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- pDvdCreatePort->lpVideoPort->hDDVideoPort =
- NtGdiDvpCreateVideoPort(GetDdHandle(pDvdCreatePort->lpDD->lpGbl->hDD),
- (PDD_CREATEVPORTDATA) pDvdCreatePort);
-#endif
- return TRUE;
-}
-
-/*
- * @implemented
- *
- * DvpCreateVideoPort
- */
-DWORD
-WINAPI
-DvpDestroyVideoPort(LPDDHAL_DESTROYVPORTDATA pDvdDestoryPort)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDvpDestroyVideoPort(pDvdDestoryPort->lpVideoPort->hDDVideoPort,
(PDD_DESTROYVPORTDATA)pDvdDestoryPort);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpCreateVideoPort
- */
-DWORD
-WINAPI
-DvpFlipVideoPort(LPDDHAL_FLIPVPORTDATA pDvdPortFlip)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- return NtGdiDvpFlipVideoPort(pDvdPortFlip->lpVideoPort->hDDVideoPort,
- (HANDLE)pDvdPortFlip->lpSurfCurr->hDDSurface,
- (HANDLE)pDvdPortFlip->lpSurfTarg->hDDSurface,
- (PDD_FLIPVPORTDATA) pDvdPortFlip);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoPortBandwidth
- */
-DWORD
-WINAPI
-DvpGetVideoPortBandwidth(LPDDHAL_GETVPORTBANDWIDTHDATA pDvdPortBandWidth)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortBandwidth(pDvdPortBandWidth->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTBANDWIDTHDATA)pDvdPortBandWidth);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpColorControl
- */
-DWORD
-WINAPI
-DvpColorControl(LPDDHAL_VPORTCOLORDATA pDvdPortColorControl)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDvpColorControl(pDvdPortColorControl->lpVideoPort->hDDVideoPort,
(PDD_VPORTCOLORDATA) pDvdPortColorControl);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoSignalStatus
- */
-DWORD
-WINAPI
-DvpGetVideoSignalStatus(LPDDHAL_GETVPORTSIGNALDATA pDvdPortVideoSignalStatus)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoSignalStatus(pDvdPortVideoSignalStatus->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTSIGNALDATA) pDvdPortVideoSignalStatus);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoPortFlipStatus
- */
-DWORD
-WINAPI
-DvpGetVideoPortFlipStatus(LPDDHAL_GETVPORTFLIPSTATUSDATA pDvdPortVideoPortFlipStatus)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortFlipStatus(GetDdHandle(pDvdPortVideoPortFlipStatus->lpDD->lpGbl->hDD),
(PDD_GETVPORTFLIPSTATUSDATA) pDvdPortVideoPortFlipStatus);
-#endif
-
-}
-
-/*
- * @implemented
- *
- * DvpCanCreateVideoPort
- */
-DWORD
-WINAPI
-DvpCanCreateVideoPort(LPDDHAL_CANCREATEVPORTDATA pDvdCanCreateVideoPort)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpCanCreateVideoPort(GetDdHandle(pDvdCanCreateVideoPort->lpDD->lpGbl->hDD),
(PDD_CANCREATEVPORTDATA) pDvdCanCreateVideoPort);
-#endif
-}
-/*
- * @implemented
- *
- * DvpWaitForVideoPortSync
- */
-DWORD
-WINAPI
-DvpWaitForVideoPortSync(LPDDHAL_WAITFORVPORTSYNCDATA pDvdWaitForVideoPortSync)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpWaitForVideoPortSync(pDvdWaitForVideoPortSync->lpVideoPort->hDDVideoPort,
(PDD_WAITFORVPORTSYNCDATA) pDvdWaitForVideoPortSync);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpUpdateVideoPort
- */
-DWORD
-WINAPI
-DvpUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pDvdUpdateVideoPort)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /*
- * Windows XP limit to max 10 handles of videoport surface and Vbi
- * ReactOS doing same to keep compatible, if it is more that 10
- * videoport surface or vbi the stack will be curpted in windows xp
- * ReactOS safe guard againts that
- *
- */
-
- HANDLE phSurfaceVideo[10];
- HANDLE phSurfaceVbi[10];
-
- if (pDvdUpdateVideoPort->dwFlags != DDRAWI_VPORTSTOP)
- {
- DWORD dwNumAutoflip;
- DWORD dwNumVBIAutoflip;
-
- /* Take copy of lplpDDSurface for the handle value will be modify in dxg */
- dwNumAutoflip = pDvdUpdateVideoPort->dwNumAutoflip;
- if ((dwNumAutoflip == 0) &&
- (pDvdUpdateVideoPort->lplpDDSurface == 0))
- {
- dwNumAutoflip++;
- }
-
- if (dwNumAutoflip != 0)
- {
- if (dwNumAutoflip>10)
- {
- dwNumAutoflip = 10;
- }
-
memcpy(phSurfaceVideo,pDvdUpdateVideoPort->lplpDDSurface,dwNumAutoflip*sizeof(HANDLE));
- }
-
- /* Take copy of lplpDDVBISurface for the handle value will be modify in dxg */
- dwNumVBIAutoflip = pDvdUpdateVideoPort->dwNumVBIAutoflip;
- if ( (dwNumVBIAutoflip == 0) &&
- (pDvdUpdateVideoPort->lplpDDVBISurface == 0) )
- {
- dwNumVBIAutoflip++;
- }
-
- if (dwNumVBIAutoflip != 0)
- {
- if (dwNumVBIAutoflip>10)
- {
- dwNumVBIAutoflip = 10;
- }
-
memcpy(phSurfaceVbi,pDvdUpdateVideoPort->lplpDDVBISurface,dwNumVBIAutoflip*sizeof(HANDLE));
- }
- }
-
- /* Call Win32k */
- return
NtGdiDvpUpdateVideoPort(pDvdUpdateVideoPort->lpVideoPort->hDDVideoPort,phSurfaceVideo,phSurfaceVbi,
(PDD_UPDATEVPORTDATA)pDvdUpdateVideoPort);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpWaitForVideoPortSync
- */
-DWORD
-WINAPI
-DvpGetVideoPortField(LPDDHAL_FLIPVPORTDATA pDvdGetVideoPortField)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortField(pDvdGetVideoPortField->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTFIELDDATA)pDvdGetVideoPortField);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpWaitForVideoPortSync
- */
-DWORD
-WINAPI
-DvpGetVideoPortInputFormats(LPDDHAL_GETVPORTINPUTFORMATDATA pDvdGetVideoPortInputFormat)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortInputFormats(pDvdGetVideoPortInputFormat->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTINPUTFORMATDATA) pDvdGetVideoPortInputFormat);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoPortLine
- */
-DWORD
-WINAPI
-DvpGetVideoPortLine(LPDDHAL_GETVPORTLINEDATA pDvdGetVideoPortLine)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortLine(pDvdGetVideoPortLine->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTLINEDATA)pDvdGetVideoPortLine);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoPortOutputFormats
- */
-DWORD
-WINAPI
-DvpGetVideoPortOutputFormats(LPDDHAL_GETVPORTLINEDATA pDvdGetVideoPortOutputFormat)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return
NtGdiDvpGetVideoPortLine(pDvdGetVideoPortOutputFormat->lpVideoPort->hDDVideoPort,
(PDD_GETVPORTLINEDATA)pDvdGetVideoPortOutputFormat);
-#endif
-}
-
-/*
- * @implemented
- *
- * DvpGetVideoPortConnectInfo
- */
-DWORD
-WINAPI
-DvpGetVideoPortConnectInfo(LPDDHAL_GETVPORTCONNECTDATA pDvdGetVideoPortInfo)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDvpGetVideoPortConnectInfo( GetDdHandle(
pDvdGetVideoPortInfo->lpDD->lpGbl->hDD) , (PDD_GETVPORTCONNECTDATA)
pDvdGetVideoPortInfo);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdGetAvailDriverMemory
- */
-DWORD
-WINAPI
-DdGetAvailDriverMemory(LPDDHAL_GETAVAILDRIVERMEMORYDATA pDdGetAvailDriverMemory)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDdGetAvailDriverMemory(GetDdHandle(
pDdGetAvailDriverMemory->lpDD->hDD), (PDD_GETAVAILDRIVERMEMORYDATA)
pDdGetAvailDriverMemory);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdAlphaBlt
- */
-DWORD
-WINAPI
-DdAlphaBlt(LPDDHAL_BLTDATA pDdAlphaBlt)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- HANDLE hDDSrcSurface = 0;
-
- if (pDdAlphaBlt->lpDDSrcSurface != 0)
- {
- hDDSrcSurface = (HANDLE) pDdAlphaBlt->lpDDSrcSurface->hDDSurface;
- }
-
- return NtGdiDdAlphaBlt((HANDLE)pDdAlphaBlt->lpDDDestSurface->hDDSurface,
hDDSrcSurface, (PDD_BLTDATA)&pDdAlphaBlt);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdCreateSurfaceEx
- */
-DWORD
-WINAPI
-DdCreateSurfaceEx(LPDDHAL_CREATESURFACEEXDATA pDdCreateSurfaceEx)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- pDdCreateSurfaceEx->ddRVal = NtGdiDdCreateSurfaceEx(
GetDdHandle(pDdCreateSurfaceEx->lpDDLcl->lpGbl->hDD),
-
(HANDLE)pDdCreateSurfaceEx->lpDDSLcl->hDDSurface,
-
pDdCreateSurfaceEx->lpDDSLcl->lpSurfMore->dwSurfaceHandle);
- return TRUE;
-#endif
-}
-
-/*
- * @implemented
- *
- * DdColorControl
- */
-DWORD
-WINAPI
-DdColorControl(LPDDHAL_COLORCONTROLDATA pDdColorControl)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- return NtGdiDdColorControl( (HANDLE) pDdColorControl->lpDDSurface->hDDSurface,
(PDD_COLORCONTROLDATA) &pDdColorControl);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdSetExclusiveMode
- */
-DWORD
-WINAPI
-DdSetExclusiveMode(LPDDHAL_SETEXCLUSIVEMODEDATA pDdSetExclusiveMode)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDdSetExclusiveMode( GetDdHandle(pDdSetExclusiveMode->lpDD->hDD),
(PDD_SETEXCLUSIVEMODEDATA) &pDdSetExclusiveMode);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdFlipToGDISurface
- */
-DWORD
-WINAPI
-DdFlipToGDISurface(LPDDHAL_FLIPTOGDISURFACEDATA pDdFlipToGDISurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return NtGdiDdFlipToGDISurface( GetDdHandle(pDdFlipToGDISurface->lpDD->hDD),
(PDD_FLIPTOGDISURFACEDATA) &pDdFlipToGDISurface);
-#endif
-}
-
-/* TODO */
-DWORD
-WINAPI
-DdGetDriverInfo(LPDDHAL_GETDRIVERINFODATA pData)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- DDHAL_GETDRIVERINFODATA pDrvInfoData;
- DWORD retValue = DDHAL_DRIVER_NOTHANDLED;
- HANDLE hDD;
-
- /* FIXME add SEH around this functions */
-
- RtlZeroMemory(&pDrvInfoData, sizeof (DDHAL_GETDRIVERINFODATA));
- RtlCopyMemory(&pDrvInfoData.guidInfo, &pData->guidInfo,
sizeof(GUID));
-
- hDD = GetDdHandle(pData->dwContext);
-
- pDrvInfoData.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
- pDrvInfoData.ddRVal = DDERR_GENERIC;
- pDrvInfoData.dwContext = (ULONG_PTR)hDD;
-
-
- /* Videoport Callbacks check and setup for DirectX/ ReactX */
- if (IsEqualGUID(&pData->guidInfo, &GUID_VideoPortCallbacks))
- {
- DDHAL_DDVIDEOPORTCALLBACKS pDvdPort;
- DDHAL_DDVIDEOPORTCALLBACKS* pUserDvdPort = (DDHAL_DDVIDEOPORTCALLBACKS
*)pData->lpvData;
-
- /* Clear internal out buffer and set it up*/
- RtlZeroMemory(&pDvdPort, DDVIDEOPORTCALLBACKSSIZE);
- pDvdPort.dwSize = DDVIDEOPORTCALLBACKSSIZE;
-
- /* set up internal buffer */
- pDrvInfoData.lpvData = (PVOID)&pDvdPort;
- pDrvInfoData.dwExpectedSize = DDVIDEOPORTCALLBACKSSIZE ;
-
- /* Call win32k */
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- /* Setup user out buffer and convert kmode callbacks to user mode */
- pUserDvdPort->dwSize = DDVIDEOPORTCALLBACKSSIZE;
- pUserDvdPort->dwFlags = pDrvInfoData.dwFlags = 0;
-
- pUserDvdPort->dwFlags = (pDrvInfoData.dwFlags &
~(DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP |
- DDHAL_VPORT32_DESTROY |
DDHAL_VPORT32_UPDATE | DDHAL_VPORT32_WAITFORSYNC)) |
-
(DDHAL_VPORT32_CREATEVIDEOPORT | DDHAL_VPORT32_FLIP |
- DDHAL_VPORT32_DESTROY |
DDHAL_VPORT32_UPDATE);
-
- pData->dwActualSize = DDVIDEOPORTCALLBACKSSIZE;
- pUserDvdPort->CreateVideoPort = (LPDDHALVPORTCB_CREATEVIDEOPORT)
DvpCreateVideoPort;
- pUserDvdPort->FlipVideoPort = (LPDDHALVPORTCB_FLIP) DvpFlipVideoPort;
- pUserDvdPort->DestroyVideoPort = (LPDDHALVPORTCB_DESTROYVPORT)
DvpDestroyVideoPort;
- pUserDvdPort->UpdateVideoPort = (LPDDHALVPORTCB_UPDATE)
DvpUpdateVideoPort;
-
- if (pDvdPort.CanCreateVideoPort)
- {
- pUserDvdPort->CanCreateVideoPort = (LPDDHALVPORTCB_CANCREATEVIDEOPORT)
DvpCanCreateVideoPort;
- }
-
- if (pDvdPort.GetVideoPortBandwidth)
- {
- pUserDvdPort->GetVideoPortBandwidth = (LPDDHALVPORTCB_GETBANDWIDTH)
DvpGetVideoPortBandwidth;
- }
-
- if (pDvdPort.GetVideoPortInputFormats)
- {
- pUserDvdPort->GetVideoPortInputFormats =
(LPDDHALVPORTCB_GETINPUTFORMATS) DvpGetVideoPortInputFormats;
- }
-
- if (pDvdPort.GetVideoPortOutputFormats)
- {
- pUserDvdPort->GetVideoPortOutputFormats =
(LPDDHALVPORTCB_GETOUTPUTFORMATS) DvpGetVideoPortOutputFormats;
- }
-
- if (pDvdPort.GetVideoPortField)
- {
- pUserDvdPort->GetVideoPortField = (LPDDHALVPORTCB_GETFIELD)
DvpGetVideoPortField;
- }
-
- if (pDvdPort.GetVideoPortLine)
- {
- pUserDvdPort->GetVideoPortLine = (LPDDHALVPORTCB_GETLINE)
DvpGetVideoPortLine;
- }
-
- if (pDvdPort.GetVideoPortConnectInfo)
- {
- pUserDvdPort->GetVideoPortConnectInfo =
(LPDDHALVPORTCB_GETVPORTCONNECT) DvpGetVideoPortConnectInfo;
- }
-
- if (pDvdPort.GetVideoPortFlipStatus)
- {
- pUserDvdPort->GetVideoPortFlipStatus = (LPDDHALVPORTCB_GETFLIPSTATUS)
DvpGetVideoPortFlipStatus;
- }
-
- if (pDvdPort.WaitForVideoPortSync)
- {
- pUserDvdPort->WaitForVideoPortSync = (LPDDHALVPORTCB_WAITFORSYNC)
DvpWaitForVideoPortSync;
- }
-
- if (pDvdPort.GetVideoSignalStatus)
- {
- pUserDvdPort->GetVideoSignalStatus = (LPDDHALVPORTCB_GETSIGNALSTATUS)
DvpGetVideoSignalStatus;
- }
-
- if (pDvdPort.ColorControl)
- {
- pUserDvdPort->ColorControl = (LPDDHALVPORTCB_COLORCONTROL)
DvpColorControl;
- }
-
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- /* Color Control Callbacks check and setup for DirectX/ ReactX */
- if (IsEqualGUID(&pData->guidInfo, &GUID_ColorControlCallbacks))
- {
- DDHAL_DDCOLORCONTROLCALLBACKS pColorControl;
- DDHAL_DDCOLORCONTROLCALLBACKS* pUserColorControl =
(DDHAL_DDCOLORCONTROLCALLBACKS *)pData->lpvData;
-
- /* Clear internal out buffer and set it up*/
- RtlZeroMemory(&pColorControl, DDCOLORCONTROLCALLBACKSSIZE);
- pColorControl.dwSize = DDCOLORCONTROLCALLBACKSSIZE;
-
- /* set up internal buffer */
- pDrvInfoData.lpvData = (PVOID)&pColorControl;
- pDrvInfoData.dwExpectedSize = DDCOLORCONTROLCALLBACKSSIZE ;
-
- /* Call win32k */
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- pData->dwActualSize = DDCOLORCONTROLCALLBACKSSIZE;
- pData->dwFlags = pDrvInfoData.dwFlags;
-
- pUserColorControl->dwSize = DDCOLORCONTROLCALLBACKSSIZE;
- pUserColorControl->dwFlags = pUserColorControl->dwFlags;
-
- if (pColorControl.ColorControl != NULL)
- {
- pUserColorControl->ColorControl = (LPDDHALCOLORCB_COLORCONTROL)
DdColorControl;
- }
-
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- /* Misc Callbacks check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo, &GUID_MiscellaneousCallbacks))
- {
- DDHAL_DDMISCELLANEOUSCALLBACKS pMisc;
- DDHAL_DDMISCELLANEOUSCALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUSCALLBACKS
*)pData->lpvData;
-
- /* Clear internal out buffer and set it up*/
- RtlZeroMemory(&pMisc, DDMISCELLANEOUSCALLBACKSSIZE);
- pMisc.dwSize = DDMISCELLANEOUSCALLBACKSSIZE;
-
- /* set up internal buffer */
- pDrvInfoData.lpvData = (PVOID)&pMisc;
- pDrvInfoData.dwExpectedSize = DDMISCELLANEOUSCALLBACKSSIZE ;
-
- /* Call win32k */
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- pData->dwActualSize = DDMISCELLANEOUSCALLBACKSSIZE;
-
- /* Only one callbacks are supported */
- pUserMisc->dwFlags = pMisc.dwFlags &
DDHAL_MISCCB32_GETAVAILDRIVERMEMORY;
- pUserMisc->GetAvailDriverMemory = (LPDDHAL_GETAVAILDRIVERMEMORY)
DdGetAvailDriverMemory;
-
- /* This callbacks are only for win9x and theirfor it is not longer use in NT
or ReactOS
- * pUserMisc->UpdateNonLocalHeap;
- * pUserMisc->GetHeapAlignment;
- * pUserMisc->GetSysmemBltStatus; */
-
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- /* Misc 2 Callbacks check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo,
&GUID_Miscellaneous2Callbacks))
- {
- DDHAL_DDMISCELLANEOUS2CALLBACKS pMisc;
- DDHAL_DDMISCELLANEOUS2CALLBACKS* pUserMisc = (DDHAL_DDMISCELLANEOUS2CALLBACKS
*)pData->lpvData;
-
- /* Clear internal out buffer and set it up*/
- RtlZeroMemory(&pMisc, DDMISCELLANEOUS2CALLBACKSSIZE);
- pMisc.dwSize = DDMISCELLANEOUS2CALLBACKSSIZE;
-
- /* set up internal buffer */
- pDrvInfoData.lpvData = (PVOID)&pMisc;
- pDrvInfoData.dwExpectedSize = DDMISCELLANEOUS2CALLBACKSSIZE ;
-
- /* Call win32k */
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- pData->dwActualSize = DDMISCELLANEOUS2CALLBACKSSIZE;
-
- pUserMisc->dwFlags = pMisc.dwFlags;
-
- /* This functions are not documneted in MSDN for this struct, here is
directx/reactx alpha blend */
- if ( pMisc.Reserved )
- {
- pUserMisc->Reserved = (LPVOID) DdAlphaBlt;
- }
-
- if ( pMisc.CreateSurfaceEx )
- {
- pUserMisc->CreateSurfaceEx = (LPDDHAL_CREATESURFACEEX)
DdCreateSurfaceEx;
- }
-
- if ( pMisc.GetDriverState )
- {
- pUserMisc->GetDriverState = (LPDDHAL_GETDRIVERSTATE)
NtGdiDdGetDriverState;
- }
-
- /* NOTE : pUserMisc->DestroyDDLocal is outdated and are not beign tuch */
-
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- /* NT Callbacks check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo, &GUID_NTCallbacks))
- {
- /* MS does not have DHAL_* version of this callbacks
- * so we are force using PDD_* callbacks here
- */
- DD_NTCALLBACKS pNtKernel;
- PDD_NTCALLBACKS pUserNtKernel = (PDD_NTCALLBACKS)pData->lpvData;
-
- /* Clear internal out buffer and set it up*/
- RtlZeroMemory(&pNtKernel, sizeof(DD_NTCALLBACKS));
- pNtKernel.dwSize = sizeof(DD_NTCALLBACKS);
-
- /* set up internal buffer */
- pDrvInfoData.lpvData = (PVOID)&pNtKernel;
- pDrvInfoData.dwExpectedSize = sizeof(DD_NTCALLBACKS) ;
-
- /* Call win32k */
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- pData->dwActualSize = sizeof(DD_NTCALLBACKS);
-
- pUserNtKernel->dwSize = sizeof(DD_NTCALLBACKS);
- pUserNtKernel->dwFlags = pNtKernel.dwFlags;
- pUserNtKernel->FreeDriverMemory = 0;
-
- if (pNtKernel.SetExclusiveMode)
- {
- pUserNtKernel->SetExclusiveMode = (PDD_SETEXCLUSIVEMODE)
DdSetExclusiveMode;
- }
-
- if (pNtKernel.FlipToGDISurface)
- {
- pUserNtKernel->FlipToGDISurface = (PDD_FLIPTOGDISURFACE)
DdFlipToGDISurface;
- }
-
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- /* D3D Callbacks version 2 check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks2))
- {
- // FIXME GUID_D3DCallbacks2
- }
-
- /* D3D Callbacks version 3 check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo, &GUID_D3DCallbacks3))
- {
- // FIXME GUID_D3DCallbacks3
- }
-
- /* D3DParseUnknownCommand Callbacks check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo,
&GUID_D3DParseUnknownCommandCallback))
- {
- // FIXME GUID_D3DParseUnknownCommandCallback
- }
-
- /* MotionComp Callbacks check and setup for DirectX/ ReactX */
- else if (IsEqualGUID(&pData->guidInfo, &GUID_MotionCompCallbacks))
- {
- // FIXME GUID_MotionCompCallbacks
- }
-
- /* FIXME VPE2 Callbacks check and setup for DirectX/ ReactX */
- //else if (IsEqualGUID(&pData->guidInfo, &GUID_VPE2Callbacks))
- //{
- // FIXME GUID_VPE2Callbacks
- //}
- else
- {
- /* set up internal buffer */
- pDrvInfoData.dwExpectedSize = pData->dwExpectedSize;
- pDrvInfoData.lpvData = pData->lpvData;
-
- /* We do not cover all callbacks for user mode, they are only cover by kmode
*/
- retValue = NtGdiDdGetDriverInfo(hDD,
(PDD_GETDRIVERINFODATA)&pDrvInfoData);
-
- /* Setup return data */
- pData->dwActualSize = pDrvInfoData.dwActualSize;
- pData->lpvData = pDrvInfoData.lpvData;
- /* Windows XP never repot back the true return value,
- * it only report back if we have a driver or not
- * ReactOS keep this behoir to be compatible with
- * Windows XP
- */
- pData->ddRVal = retValue;
- }
-
- return retValue;
-#endif
-}
-
-
-/*
- * @implemented
- *
- * D3dContextCreate
- */
-BOOL
-WINAPI
-D3dContextCreate(LPD3DHAL_CONTEXTCREATEDATA pdcci)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- HANDLE hSurfZ = NULL;
-
- if (pdcci->lpDDSZLcl)
- {
- hSurfZ = (HANDLE)pdcci->lpDDSZLcl->hDDSurface;
- }
-
- return NtGdiD3dContextCreate(GetDdHandle(pdcci->lpDDLcl->hDD),
- (HANDLE)pdcci->lpDDSLcl->hDDSurface,
- hSurfZ,
- (D3DNTHAL_CONTEXTCREATEI *)pdcci);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdCanCreateD3DBuffer
- */
-DWORD
-WINAPI
-DdCanCreateD3DBuffer(LPDDHAL_CANCREATESURFACEDATA CanCreateD3DBuffer)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /*
- * Note : This functions are basic same, in win32k
- * NtGdiDdCanCreateD3DBuffer and NtGdiDdCanCreateSurface are mergs
- * toghter in win32k at end and retrurn same data, it is still sepreated
- * at user mode but in kmode it is not.
- */
-
- /* Call win32k */
- return NtGdiDdCanCreateD3DBuffer(GetDdHandle(CanCreateD3DBuffer->lpDD->hDD),
- (PDD_CANCREATESURFACEDATA)CanCreateD3DBuffer);
-#endif
-}
-
-
-/*
- * @implemented
- *
- * DdCreateD3DBuffer
- */
-DWORD
-WINAPI
-DdCreateD3DBuffer(LPDDHAL_CREATESURFACEDATA pCreateSurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- HANDLE puhSurface = 0;
- DDRAWI_DDRAWSURFACE_GBL *pSurfGBL;
- DDRAWI_DDRAWSURFACE_LCL *pSurfLcl;
- DD_SURFACE_GLOBAL puSurfaceGlobalData;
- DD_SURFACE_MORE puSurfaceMoreData;
- DD_SURFACE_LOCAL puSurfaceLocalData;
- DWORD retValue;
-
- /* Zero all local memory pointer */
- RtlZeroMemory(&puSurfaceGlobalData, sizeof(DD_SURFACE_GLOBAL) );
- RtlZeroMemory(&puSurfaceMoreData, sizeof(DD_SURFACE_MORE) ) ;
- RtlZeroMemory(&puSurfaceLocalData, sizeof(DD_SURFACE_LOCAL) );
-
- pCreateSurface->dwSCnt = 1;
- pSurfLcl = pCreateSurface->lplpSList[0];
- pSurfGBL = pSurfLcl->lpGbl;
-
- /* Convert DDRAWI_DDRAWSURFACE_GBL to DD_SURFACE_GLOBAL */
- puSurfaceGlobalData.wWidth = pSurfGBL->wWidth;
- puSurfaceGlobalData.wHeight = pSurfGBL->wHeight;
- puSurfaceGlobalData.dwLinearSize = pSurfGBL->dwLinearSize;
- puSurfaceGlobalData.fpVidMem = pSurfGBL->fpVidMem;
- puSurfaceGlobalData.dwBlockSizeX = pSurfGBL->dwBlockSizeX;
- puSurfaceGlobalData.dwBlockSizeY = pSurfGBL->dwBlockSizeY;
-
- /* Convert DDRAWI_DDRAWSURFACE_MORE to DD_SURFACE_MORE */
- puSurfaceMoreData.dwSurfaceHandle = pSurfLcl->lpSurfMore->dwSurfaceHandle;
- puSurfaceMoreData.ddsCapsEx.dwCaps2 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps2;
- puSurfaceMoreData.ddsCapsEx.dwCaps3 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps3;
- puSurfaceMoreData.ddsCapsEx.dwCaps4 = pSurfLcl->lpSurfMore->ddsCapsEx.dwCaps4;
-
- /* Convert DDRAWI_DDRAWSURFACE_LCL to DD_SURFACE_LOCAL */
- puSurfaceLocalData.dwFlags = pSurfLcl->dwFlags;
- puSurfaceLocalData.ddsCaps.dwCaps = pSurfLcl->ddsCaps.dwCaps;
-
- /* Call win32k */
- retValue = NtGdiDdCreateD3DBuffer( GetDdHandle(pCreateSurface->lpDD->hDD),
- (HANDLE*)&pSurfLcl->hDDSurface,
- pCreateSurface->lpDDSurfaceDesc,
- &puSurfaceGlobalData,
- &puSurfaceLocalData,
- &puSurfaceMoreData,
- (DD_CREATESURFACEDATA *) pCreateSurface,
- &puhSurface);
-
- /* Setup surface handle if we got one back */
- if ( puhSurface != NULL )
- {
- pCreateSurface->lplpSList[0]->hDDSurface = (ULONG_PTR)puhSurface;
- }
-
- /* Convert DD_SURFACE_GLOBAL to DDRAWI_DDRAWSURFACE_GBL */
- pSurfGBL->dwLinearSize = puSurfaceGlobalData.dwLinearSize;
- pSurfGBL->fpVidMem = puSurfaceGlobalData.fpVidMem;
- pSurfGBL->dwBlockSizeX = puSurfaceGlobalData.dwBlockSizeX;
- pSurfGBL->dwBlockSizeY = puSurfaceGlobalData.dwBlockSizeY;
-
- return retValue;
-#endif
-}
-
-/*
- * @implemented
- *
- * DdDestroyD3DBuffer
- */
-DWORD
-WINAPI
-DdDestroyD3DBuffer(LPDDHAL_DESTROYSURFACEDATA pDestroySurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- DWORD retValue = 0;
- if ( pDestroySurface->lpDDSurface->hDDSurface)
- {
- /* Call win32k */
- retValue =
NtGdiDdDestroyD3DBuffer((HANDLE)pDestroySurface->lpDDSurface->hDDSurface);
- }
-
- return retValue;
-#endif
-}
-
-/*
- * @implemented
- *
- * DdLockD3D
- */
-DWORD
-WINAPI
-DdLockD3D(LPDDHAL_LOCKDATA Lock)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k */
- return NtGdiDdLockD3D((HANDLE)Lock->lpDDSurface->hDDSurface,
(PDD_LOCKDATA)Lock);
-#endif
-}
-
-/*
- * @implemented
- *
- * DdUnlockD3D
- */
-DWORD
-WINAPI
-DdUnlockD3D(LPDDHAL_UNLOCKDATA Unlock)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k */
- return NtGdiDdUnlock((HANDLE)Unlock->lpDDSurface->hDDSurface,
- (PDD_UNLOCKDATA)Unlock);
-#endif
-}
-
-
-/* PRIVATE FUNCTIONS *********************************************************/
-
-BOOL
-WINAPI
-bDDCreateSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface,
- BOOL bComplete)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- DD_SURFACE_LOCAL SurfaceLocal;
- DD_SURFACE_GLOBAL SurfaceGlobal;
- DD_SURFACE_MORE SurfaceMore;
-
- /* Zero struct */
- RtlZeroMemory(&SurfaceLocal, sizeof(DD_SURFACE_LOCAL));
- RtlZeroMemory(&SurfaceGlobal, sizeof(DD_SURFACE_GLOBAL));
- RtlZeroMemory(&SurfaceMore, sizeof(DD_SURFACE_MORE));
-
- /* Set up SurfaceLocal struct */
- SurfaceLocal.ddsCaps.dwCaps = pSurface->ddsCaps.dwCaps;
- SurfaceLocal.dwFlags = pSurface->dwFlags;
-
- /* Set up SurfaceMore struct */
- RtlMoveMemory(&SurfaceMore.ddsCapsEx,
- &pSurface->ddckCKDestBlt,
- sizeof(DDSCAPSEX));
- SurfaceMore.dwSurfaceHandle =
(DWORD)pSurface->dbnOverlayNode.object_int->lpVtbl;
-
- /* Set up SurfaceGlobal struct */
- SurfaceGlobal.fpVidMem = pSurface->lpGbl->fpVidMem;
- SurfaceGlobal.dwLinearSize = pSurface->lpGbl->dwLinearSize;
- SurfaceGlobal.wHeight = pSurface->lpGbl->wHeight;
- SurfaceGlobal.wWidth = pSurface->lpGbl->wWidth;
-
- /* Check if we have a pixel format */
- if (pSurface->dwFlags & DDSD_PIXELFORMAT)
- {
- /* Use global one */
- SurfaceGlobal.ddpfSurface = pSurface->lpGbl->lpDD->vmiData.ddpfDisplay;
- SurfaceGlobal.ddpfSurface.dwSize = sizeof(DDPIXELFORMAT);
- }
- else
- {
- /* Use local one */
- SurfaceGlobal.ddpfSurface = pSurface->lpGbl->lpDD->vmiData.ddpfDisplay;
- }
-
- /* Create the object */
- pSurface->hDDSurface =
(DWORD)NtGdiDdCreateSurfaceObject(GetDdHandle(pSurface->lpGbl->lpDD->hDD),
-
(HANDLE)pSurface->hDDSurface,
- &SurfaceLocal,
- &SurfaceMore,
- &SurfaceGlobal,
- bComplete);
-
- /* Return status */
- if (pSurface->hDDSurface) return TRUE;
- return FALSE;
-#endif
-}
-
-/* PUBLIC FUNCTIONS **********************************************************/
-
-/*
- * @implemented
- *
- * GDIEntry 1
- */
-BOOL
-WINAPI
-DdCreateDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
- HDC hdc)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- BOOL Return = FALSE;
-
- /* Check if the global hDC (hdc == 0) is being used */
- if (!hdc)
- {
- /* We'll only allow this if the global object doesn't exist yet */
- if (!ghDirectDraw)
- {
- /* Create the DC */
- if ((hdc = CreateDCW(L"Display", NULL, NULL, NULL)))
- {
- /* Create the DDraw Object */
- ghDirectDraw = NtGdiDdCreateDirectDrawObject(hdc);
-
- /* Delete our DC */
- DeleteDC(hdc);
- }
- }
-
- /* If we created the object, or had one ...*/
- if (ghDirectDraw)
- {
- /* Increase count and set success */
- gcDirectDraw++;
- Return = TRUE;
- }
-
- /* Zero the handle */
- pDirectDrawGlobal->hDD = 0;
- }
- else
- {
- /* Using the per-process object, so create it */
- pDirectDrawGlobal->hDD = (ULONG_PTR)NtGdiDdCreateDirectDrawObject(hdc);
-
- /* Set the return value */
- Return = pDirectDrawGlobal->hDD ? TRUE : FALSE;
- }
-
- /* Return to caller */
- return Return;
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 2
- */
-BOOL
-WINAPI
-DdQueryDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
- LPDDHALINFO pHalInfo,
- LPDDHAL_DDCALLBACKS pDDCallbacks,
- LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
- LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
- LPD3DHAL_CALLBACKS pD3dCallbacks,
- LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
- LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
- LPDDSURFACEDESC pD3dTextureFormats,
- LPDWORD pdwFourCC,
- LPVIDMEM pvmList)
- {
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- PVIDEOMEMORY VidMemList = NULL;
- DD_HALINFO HalInfo;
- D3DNTHAL_CALLBACKS D3dCallbacks;
- D3DNTHAL_GLOBALDRIVERDATA D3dDriverData;
- DD_D3DBUFCALLBACKS D3dBufferCallbacks;
- DWORD CallbackFlags[3];
- DWORD dwNumHeaps=0, FourCCs=0;
- DWORD Flags;
- BOOL retVal = TRUE;
-
- /* Clear the structures */
- RtlZeroMemory(&HalInfo, sizeof(DD_HALINFO));
- RtlZeroMemory(&D3dCallbacks, sizeof(D3DNTHAL_CALLBACKS));
- RtlZeroMemory(&D3dDriverData, sizeof(D3DNTHAL_GLOBALDRIVERDATA));
- RtlZeroMemory(&D3dBufferCallbacks, sizeof(DD_D3DBUFCALLBACKS));
- RtlZeroMemory(CallbackFlags, sizeof(DWORD)*3);
-
- /* Note : XP always alloc 24*sizeof(VIDEOMEMORY) of pvmlist so we change it to it */
- if ( (pvmList != NULL) &&
- (pHalInfo->vmiData.dwNumHeaps != 0) )
- {
- VidMemList = (PVIDEOMEMORY) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
(sizeof(VIDEOMEMORY) * 24 ) * pHalInfo->vmiData.dwNumHeaps);
- }
-
-
- /* Do the query */
- if (!NtGdiDdQueryDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
- &HalInfo,
- CallbackFlags,
- &D3dCallbacks,
- &D3dDriverData,
- &D3dBufferCallbacks,
- pD3dTextureFormats,
- &dwNumHeaps,
- VidMemList,
- &FourCCs,
- pdwFourCC))
- {
- /* We failed, free the memory and return */
- retVal = FALSE;
- goto cleanup;
- }
-
- /* Clear the incoming pointer */
- RtlZeroMemory(pHalInfo, sizeof(DDHALINFO));
-
- /* Convert all the data */
- pHalInfo->dwSize = sizeof(DDHALINFO);
- pHalInfo->lpDDCallbacks = pDDCallbacks;
- pHalInfo->lpDDSurfaceCallbacks = pDDSurfaceCallbacks;
- pHalInfo->lpDDPaletteCallbacks = pDDPaletteCallbacks;
-
- /* Check for NT5+ D3D Data */
- if ( (D3dCallbacks.dwSize != 0) &&
- (D3dDriverData.dwSize != 0) )
- {
- /* Write these down */
- pHalInfo->lpD3DGlobalDriverData = (ULONG_PTR)pD3dDriverData;
- pHalInfo->lpD3DHALCallbacks = (ULONG_PTR)pD3dCallbacks;
-
- /* Check for Buffer Callbacks */
- if (D3dBufferCallbacks.dwSize)
- {
- /* Write this one too */
- pHalInfo->lpDDExeBufCallbacks = pD3dBufferCallbacks;
- }
- }
-
- /* Continue converting the rest */
- pHalInfo->vmiData.dwFlags = HalInfo.vmiData.dwFlags;
- pHalInfo->vmiData.dwDisplayWidth = HalInfo.vmiData.dwDisplayWidth;
- pHalInfo->vmiData.dwDisplayHeight = HalInfo.vmiData.dwDisplayHeight;
- pHalInfo->vmiData.lDisplayPitch = HalInfo.vmiData.lDisplayPitch;
- pHalInfo->vmiData.fpPrimary = 0;
-
- RtlCopyMemory( &pHalInfo->vmiData.ddpfDisplay,
- &HalInfo.vmiData.ddpfDisplay,
- sizeof(DDPIXELFORMAT));
-
- pHalInfo->vmiData.dwOffscreenAlign = HalInfo.vmiData.dwOffscreenAlign;
- pHalInfo->vmiData.dwOverlayAlign = HalInfo.vmiData.dwOverlayAlign;
- pHalInfo->vmiData.dwTextureAlign = HalInfo.vmiData.dwTextureAlign;
- pHalInfo->vmiData.dwZBufferAlign = HalInfo.vmiData.dwZBufferAlign;
- pHalInfo->vmiData.dwAlphaAlign = HalInfo.vmiData.dwAlphaAlign;
-
- pHalInfo->vmiData.dwNumHeaps = dwNumHeaps;
- pHalInfo->vmiData.pvmList = pvmList;
-
- RtlCopyMemory( &pHalInfo->ddCaps,
- &HalInfo.ddCaps,
- sizeof(DDCORECAPS ));
-
- pHalInfo->ddCaps.dwNumFourCCCodes = FourCCs;
- pHalInfo->lpdwFourCC = pdwFourCC;
-
- /* always force rope 0x1000 for hal it mean only source copy is supported */
- pHalInfo->ddCaps.dwRops[6] = 0x1000;
-
- /* Set the HAL flags what ReactX got from the driver
- * Windows XP force setting DDHALINFO_GETDRIVERINFOSET if the driver does not set it
- * and ReactX doing same to keep compatible with drivers, but the driver are
- * force support DdGetDriverInfo acoriding MSDN but it seam some driver do not set
- * this flag even it is being supported. that is mean. It is small hack to keep
- * bad driver working, that trust this is always being setting by it self at end
- */
- pHalInfo->dwFlags = (HalInfo.dwFlags & ~DDHALINFO_GETDRIVERINFOSET) |
DDHALINFO_GETDRIVERINFOSET;
- pHalInfo->GetDriverInfo = (LPDDHAL_GETDRIVERINFO) DdGetDriverInfo;
-
- /* Now check if we got any DD callbacks */
- if (pDDCallbacks)
- {
- /* Zero the structure */
- RtlZeroMemory(pDDCallbacks, sizeof(DDHAL_DDCALLBACKS));
- pDDCallbacks->dwSize = sizeof(DDHAL_DDCALLBACKS);
-
- /* Set the flags for this structure
- * Windows XP force setting DDHAL_CB32_CREATESURFACE if the driver does not set
it
- * and ReactX doing same to keep compatible with drivers, but the driver are
- * force support pDDCallbacks acoriding MSDN but it seam some driver do not set
- * this flag even it is being supported. that is mean. It is small hack to keep
- * bad driver working, that trust this is always being setting by it self at end
- */
- Flags = (CallbackFlags[0] & ~DDHAL_CB32_CREATESURFACE) |
DDHAL_CB32_CREATESURFACE;
- pDDCallbacks->dwFlags = Flags;
-
- /* Write the always-on functions */
- pDDCallbacks->CreateSurface = DdCreateSurface;
-
- /* Now write the pointers, if applicable */
- if (Flags & DDHAL_CB32_WAITFORVERTICALBLANK)
- {
- pDDCallbacks->WaitForVerticalBlank = DdWaitForVerticalBlank;
- }
- if (Flags & DDHAL_CB32_CANCREATESURFACE)
- {
- pDDCallbacks->CanCreateSurface = DdCanCreateSurface;
- }
- if (Flags & DDHAL_CB32_GETSCANLINE)
- {
- pDDCallbacks->GetScanLine = DdGetScanLine;
- }
- }
-
- /* Check for DD Surface Callbacks */
- if (pDDSurfaceCallbacks)
- {
- /* Zero the structures */
- RtlZeroMemory(pDDSurfaceCallbacks, sizeof(DDHAL_DDSURFACECALLBACKS));
- pDDSurfaceCallbacks->dwSize = sizeof(DDHAL_DDSURFACECALLBACKS);
-
- /* Set the flags for this structure
- * Windows XP force setting DDHAL_SURFCB32_LOCK, DDHAL_SURFCB32_UNLOCK,
- * DDHAL_SURFCB32_SETCOLORKEY, DDHAL_SURFCB32_DESTROYSURFACE if the driver
- * does not set it and ReactX doing same to keep compatible with drivers,
- * but the driver are force support pDDSurfaceCallbacks acoriding MSDN but it
seam
- * some driver do not set this flag even it is being supported. that is mean.
- * It is small hack to keep bad driver working, that trust this is always being
- * setting by it self at end
- */
-
- Flags = (CallbackFlags[1] & ~(DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
- DDHAL_SURFCB32_SETCOLORKEY |
DDHAL_SURFCB32_DESTROYSURFACE)) |
- (DDHAL_SURFCB32_LOCK | DDHAL_SURFCB32_UNLOCK |
- DDHAL_SURFCB32_SETCOLORKEY |
DDHAL_SURFCB32_DESTROYSURFACE);
-
- pDDSurfaceCallbacks->dwFlags = Flags;
-
- /* Write the always-on functions */
- pDDSurfaceCallbacks->Lock = DdLock;
- pDDSurfaceCallbacks->Unlock = DdUnlock;
- pDDSurfaceCallbacks->SetColorKey = DdSetColorKey;
- pDDSurfaceCallbacks->DestroySurface = DdDestroySurface;
-
- /* Write the optional ones */
- if (Flags & DDHAL_SURFCB32_FLIP)
- {
- pDDSurfaceCallbacks->Flip = DdFlip;
- }
- if (Flags & DDHAL_SURFCB32_BLT)
- {
- pDDSurfaceCallbacks->Blt = DdBlt;
- }
- if (Flags & DDHAL_SURFCB32_GETBLTSTATUS)
- {
- pDDSurfaceCallbacks->GetBltStatus = DdGetBltStatus;
- }
- if (Flags & DDHAL_SURFCB32_GETFLIPSTATUS)
- {
- pDDSurfaceCallbacks->GetFlipStatus = DdGetFlipStatus;
- }
- if (Flags & DDHAL_SURFCB32_UPDATEOVERLAY)
- {
- pDDSurfaceCallbacks->UpdateOverlay = DdUpdateOverlay;
- }
- if (Flags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
- {
- pDDSurfaceCallbacks->SetOverlayPosition = DdSetOverlayPosition;
- }
- if (Flags & DDHAL_SURFCB32_ADDATTACHEDSURFACE)
- {
- pDDSurfaceCallbacks->AddAttachedSurface = DdAddAttachedSurface;
- }
- }
-
- /* Check for DD Palette Callbacks, This interface are dead for user mode,
- * only what it can support are being report back.
- */
- if (pDDPaletteCallbacks)
- {
- /* Zero the struct */
- RtlZeroMemory(pDDPaletteCallbacks, sizeof(DDHAL_DDPALETTECALLBACKS));
-
- /* Write the header */
- pDDPaletteCallbacks->dwSize = sizeof(DDHAL_DDPALETTECALLBACKS);
- pDDPaletteCallbacks->dwFlags = CallbackFlags[2];
- }
-
- if (pD3dCallbacks)
- {
- /* Zero the struct */
- RtlZeroMemory(pD3dCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
-
- /* Check if we have one */
- if (D3dCallbacks.dwSize)
- {
- /* Write the header */
- pD3dCallbacks->dwSize = sizeof(DDHAL_DDEXEBUFCALLBACKS);
-
- /* Now check for each callback */
- if (D3dCallbacks.ContextCreate)
- {
- pD3dCallbacks->ContextCreate = (LPD3DHAL_CONTEXTCREATECB)
D3dContextCreate;
- }
- if (D3dCallbacks.ContextDestroy)
- {
- pD3dCallbacks->ContextDestroy = (LPD3DHAL_CONTEXTDESTROYCB)
NtGdiD3dContextDestroy;
- }
- if (D3dCallbacks.ContextDestroyAll)
- {
- pD3dCallbacks->ContextDestroyAll = (LPD3DHAL_CONTEXTDESTROYALLCB)
NtGdiD3dContextDestroyAll;
- }
- }
- }
-
- /* Check for D3D Driver Data */
- if (pD3dDriverData)
- {
- /* Copy the struct */
- RtlMoveMemory(pD3dDriverData, &D3dDriverData,
sizeof(D3DHAL_GLOBALDRIVERDATA));
-
- /* Write the pointer to the texture formats */
- pD3dDriverData->lpTextureFormats = pD3dTextureFormats;
- }
-
- /* Check for D3D Buffer Callbacks */
- if (pD3dBufferCallbacks)
- {
- /* Zero the struct */
- RtlZeroMemory(pD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
-
- if ( D3dBufferCallbacks.dwSize)
- {
- pD3dBufferCallbacks->dwSize = D3dBufferCallbacks.dwSize;
-
- pD3dBufferCallbacks->dwFlags = D3dBufferCallbacks.dwFlags;
- if ( D3dBufferCallbacks.CanCreateD3DBuffer)
- {
- pD3dBufferCallbacks->CanCreateExecuteBuffer =
(LPDDHALEXEBUFCB_CANCREATEEXEBUF)DdCanCreateD3DBuffer;
- }
-
- if ( D3dBufferCallbacks.CanCreateD3DBuffer)
- {
- pD3dBufferCallbacks->CreateExecuteBuffer =
(LPDDHALEXEBUFCB_CREATEEXEBUF) DdCreateD3DBuffer;
- }
-
- if ( D3dBufferCallbacks.DestroyD3DBuffer )
- {
- pD3dBufferCallbacks->DestroyExecuteBuffer =
(LPDDHALEXEBUFCB_DESTROYEXEBUF) DdDestroyD3DBuffer;
- }
-
- if ( D3dBufferCallbacks.LockD3DBuffer )
- {
- pD3dBufferCallbacks->LockExecuteBuffer = (LPDDHALEXEBUFCB_LOCKEXEBUF)
DdLockD3D;
- }
-
- if ( D3dBufferCallbacks.UnlockD3DBuffer )
- {
- pD3dBufferCallbacks->UnlockExecuteBuffer =
(LPDDHALEXEBUFCB_UNLOCKEXEBUF) DdUnlockD3D;
- }
-
- }
- }
-
- /* FIXME VidMemList */
-
-cleanup:
- if (VidMemList)
- {
- HeapFree(GetProcessHeap(), 0, VidMemList);
- }
-
- return retVal;
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 3
- */
-BOOL
-WINAPI
-DdDeleteDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- BOOL Return = FALSE;
-
- /* If this is the global object */
- if(pDirectDrawGlobal->hDD)
- {
- /* Free it */
- Return = NtGdiDdDeleteDirectDrawObject((HANDLE)pDirectDrawGlobal->hDD);
- if (Return == TRUE)
- {
- pDirectDrawGlobal->hDD = 0;
- }
- }
- else if (ghDirectDraw)
- {
- /* Always success here */
- Return = TRUE;
-
- /* Make sure this is the last instance */
- if (!(--gcDirectDraw))
- {
- /* Delete the object */
- Return = NtGdiDdDeleteDirectDrawObject(ghDirectDraw);
- if (Return == TRUE)
- {
- ghDirectDraw = 0;
- }
- }
- }
-
- /* Return */
- return Return;
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 4
- */
-BOOL
-WINAPI
-DdCreateSurfaceObject( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
- BOOL bPrimarySurface)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- return bDDCreateSurface(pSurfaceLocal, TRUE);
-#endif
-}
-
-
-/*
- * @implemented
- *
- * GDIEntry 5
- */
-BOOL
-WINAPI
-DdDeleteSurfaceObject(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- BOOL Return = FALSE;
-
- /* Make sure there is one */
- if (pSurfaceLocal->hDDSurface)
- {
- /* Delete it */
- Return = NtGdiDdDeleteSurfaceObject((HANDLE)pSurfaceLocal->hDDSurface);
- pSurfaceLocal->hDDSurface = 0;
- }
-
- return Return;
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 6
- */
-BOOL
-WINAPI
-DdResetVisrgn(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
- HWND hWnd)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k directly */
- return NtGdiDdResetVisrgn((HANDLE) pSurfaceLocal->hDDSurface, hWnd);
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 7
- */
-HDC
-WINAPI
-DdGetDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
- LPPALETTEENTRY pColorTable)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k directly */
- return NtGdiDdGetDC(pColorTable, (HANDLE) pSurfaceLocal->hDDSurface);
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 8
- */
-BOOL
-WINAPI
-DdReleaseDC(LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k directly */
- return NtGdiDdReleaseDC((HANDLE) pSurfaceLocal->hDDSurface);
-#endif
-}
-
-/*
- * @unimplemented
- * GDIEntry 9
- */
-HBITMAP
-STDCALL
-DdCreateDIBSection(HDC hdc,
- CONST BITMAPINFO *pbmi,
- UINT iUsage,
- VOID **ppvBits,
- HANDLE hSectionApp,
- DWORD dwOffset)
-{
- SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
- return 0;
-}
-
-/*
- * @implemented
- *
- * GDIEntry 10
- */
-BOOL
-WINAPI
-DdReenableDirectDrawObject(LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
- BOOL *pbNewMode)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Call win32k directly */
- return NtGdiDdReenableDirectDrawObject(GetDdHandle(pDirectDrawGlobal->hDD),
- pbNewMode);
-#endif
-}
-
-
-/*
- * @implemented
- *
- * GDIEntry 11
- */
-BOOL
-STDCALL
-DdAttachSurface( LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom,
- LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- /* Create Surface if it does not exits one */
- if (!pSurfaceFrom->hDDSurface)
- {
- if (!bDDCreateSurface(pSurfaceFrom, FALSE))
- {
- return FALSE;
- }
- }
-
- /* Create Surface if it does not exits one */
- if (!pSurfaceTo->hDDSurface)
- {
- if (!bDDCreateSurface(pSurfaceTo, FALSE))
- {
- return FALSE;
- }
- }
-
- /* Call win32k */
- return NtGdiDdAttachSurface((HANDLE)pSurfaceFrom->hDDSurface,
- (HANDLE)pSurfaceTo->hDDSurface);
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 12
- */
-VOID
-STDCALL
-DdUnattachSurface(LPDDRAWI_DDRAWSURFACE_LCL pSurface,
- LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached)
-{
- /* Fixme for opengl hel emulations */
- return ;
-#if 0
- /* Call win32k */
- NtGdiDdUnattachSurface((HANDLE)pSurface->hDDSurface,
- (HANDLE)pSurfaceAttached->hDDSurface);
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 13
- */
-ULONG
-STDCALL
-DdQueryDisplaySettingsUniqueness()
-{
- return GdiSharedHandleTable->flDeviceUniq;
-}
-
-/*
- * @implemented
- *
- * GDIEntry 14
- */
-HANDLE
-WINAPI
-DdGetDxHandle(LPDDRAWI_DIRECTDRAW_LCL pDDraw,
- LPDDRAWI_DDRAWSURFACE_LCL pSurface,
- BOOL bRelease)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-#if 0
- HANDLE hDD = NULL;
- HANDLE hSurface = (HANDLE)pSurface->hDDSurface;
-
- /* Check if we already have a surface */
- if (!pSurface)
- {
- /* We don't have one, use the DirectDraw Object handle instead */
- hSurface = NULL;
- hDD = GetDdHandle(pDDraw->lpGbl->hDD);
- }
-
- /* Call the API */
- return (HANDLE)NtGdiDdGetDxHandle(hDD, hSurface, bRelease);
-#endif
-}
-
-/*
- * @implemented
- *
- * GDIEntry 15
- */
-BOOL
-WINAPI
-DdSetGammaRamp(LPDDRAWI_DIRECTDRAW_LCL pDDraw,
- HDC hdc,
- LPVOID lpGammaRamp)
-{
- /* Fixme for opengl hel emulations */
- return 0;
-
-#if 0
- /* Call win32k directly */
- return NtGdiDdSetGammaRamp(GetDdHandle(pDDraw->lpGbl->hDD),
- hdc,
- lpGammaRamp);
-#endif
-}
-
-
-
-
-