Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-06 12:45:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

- merge some of the more meaningful stuff from the reactx branch

Browse source 
svn path=/trunk/; revision=43715
This commit is contained in:
Kamil Hornicek 2009-10-24 14:09:48 +00:00
parent 580d28894c
commit 0601bc5633
6 changed files with 442 additions and 167 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
reactos/dll/directx/ddraw/Ddraw/ddraw_main.c
View file

@ -129,6 +129,19 @@ Main_DirectDraw_QueryInterface (LPDDRAWI_DIRECTDRAW_INT This,
return retVal;
}
/*++
* @name DDraw->AddRef
* @implemented
*
* The function DDraw->AddRef manages all ref counters in the COM object DDraw->
* @return
* Returns the local Ref counter value for the COM object
*
* @remarks.
* none
*
*--*/
ULONG WINAPI
Main_DirectDraw_AddRef (LPDDRAWI_DIRECTDRAW_INT This)
{
@ -136,13 +149,20 @@ Main_DirectDraw_AddRef (LPDDRAWI_DIRECTDRAW_INT This)
DX_WINDBG_trace();
/* Lock the thread */
AcquireDDThreadLock();
_SEH2_TRY
{
/* Increment the internal ref counter */
This->dwIntRefCnt++;
/* Increment the local internal ref counter */
This->lpLcl->dwLocalRefCnt++;
if (This->lpLcl->lpGbl != NULL)
{
/* Increment the gobal internal ref counter */
This->lpLcl->lpGbl->dwRefCnt++;
}
}
@ -161,6 +181,10 @@ Main_DirectDraw_AddRef (LPDDRAWI_DIRECTDRAW_INT This)
}
_SEH2_END;
/* Release the thread lock */
ReleaseDDThreadLock();
/* Return the local Ref counter */
return retValue;
}
@ -173,6 +197,10 @@ Main_DirectDraw_Release (LPDDRAWI_DIRECTDRAW_INT This)
ULONG Counter = 0;
DX_WINDBG_trace();
/* Lock the thread */
AcquireDDThreadLock();
_SEH2_TRY
{
if (This!=NULL)
@ -208,30 +236,47 @@ Main_DirectDraw_Release (LPDDRAWI_DIRECTDRAW_INT This)
{
}
_SEH2_END;
/* Release the thread lock */
ReleaseDDThreadLock();
return Counter;
}
HRESULT WINAPI
Main_DirectDraw_Initialize (LPDDRAWI_DIRECTDRAW_INT This, LPGUID lpGUID)
{
return DDERR_ALREADYINITIALIZED;
}
/*
* Main_DirectDraw_Compact
* ms say this one is not implement but it return DDERR_NOEXCLUSIVEMODE
* when no exclusive owner are set in corpativelevel
*/
/*++
* @name DDraw->Compact
* @implemented
*
* In exlusive mode the function DDraw->Compact returns DERR_NOEXCLUSIVEMODE, otherwise it returns DD_OK
*
* @return
* Returns only error code DD_OK or DERR_NOEXCLUSIVEMODE
*
* @remarks.
* Microsoft says Compact is not implemented in ddraw.dll, but it returns DDERR_NOEXCLUSIVEMODE or DD_OK
*
*--*/
HRESULT WINAPI
Main_DirectDraw_Compact(LPDDRAWI_DIRECTDRAW_INT This)
{
HRESULT retVal = DD_OK;
DX_WINDBG_trace();
// EnterCriticalSection(&ddcs);
/* Lock the thread */
AcquireDDThreadLock();
_SEH2_TRY
{
/* Check if Exclusive mode has been activated */
if (This->lpLcl->lpGbl->lpExclusiveOwner != This->lpLcl)
{
retVal = DDERR_NOEXCLUSIVEMODE;
@ -241,7 +286,10 @@ Main_DirectDraw_Compact(LPDDRAWI_DIRECTDRAW_INT This)
{
}
_SEH2_END;
// LeaveCriticalSection(&ddcs);
/* Release the thread lock */
ReleaseDDThreadLock();
return retVal;
}

187
reactos/dll/directx/ddraw/Surface/callbacks_surf_hel.c
View file

@ -17,7 +17,31 @@ DWORD CALLBACK HelDdSurfAddAttachedSurface(LPDDHAL_ADDATTACHEDSURFACEDATA lpDest
DWORD CALLBACK HelDdSurfBlt(LPDDHAL_BLTDATA lpBltData)
{
DX_STUB;
DX_WINDBG_trace();
if (lpBltData->dwFlags & DDBLT_COLORFILL)
{
HBRUSH hbr = CreateSolidBrush(lpBltData->bltFX.dwFillColor );
FillRect( (HDC)lpBltData->lpDDDestSurface->lpSurfMore->lpDD_lcl->hDC,
(CONST RECT *)&lpBltData->rDest,
hbr);
DeleteObject(hbr);
lpBltData->ddRVal = DD_OK;
}
else if (lpBltData->dwFlags & DDBLT_ROP)
{
BitBlt( (HDC)lpBltData->lpDDDestSurface->lpSurfMore->lpDD_lcl->hDC,
lpBltData->rDest.top,
lpBltData->rDest.left,
lpBltData->rDest.right,
lpBltData->rDest.bottom,
(HDC)lpBltData->lpDDSrcSurface->lpSurfMore->lpDD_lcl->hDC,
lpBltData->rSrc.top,
lpBltData->rSrc.right,
lpBltData->bltFX.dwROP);
lpBltData->ddRVal = DD_OK;
}
return DDHAL_DRIVER_HANDLED;
}
DWORD CALLBACK HelDdSurfDestroySurface(LPDDHAL_DESTROYSURFACEDATA lpDestroySurfaceData)
@ -42,17 +66,105 @@ DWORD CALLBACK HelDdSurfGetFlipStatus(LPDDHAL_GETFLIPSTATUSDATA lpGetFlipStatusD
DWORD CALLBACK HelDdSurfLock(LPDDHAL_LOCKDATA lpLockData)
{
DX_STUB;
}
HDC hDC;
HBITMAP hImage = NULL;
LONG cbBuffer = 0;
LPDWORD pixels = NULL;
HDC hMemDC = NULL;
HBITMAP hDCBmp = NULL;
BITMAP bm = {0};
DX_WINDBG_trace();
/* ToDo tell ddraw internal this surface is locked */
/* ToDo add support for dwFlags */
/* Get our hdc for the active window */
hDC = GetDC(lpLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
/* Create a memory bitmap to store a copy of current hdc surface */
if (!lpLockData->bHasRect)
{
hImage = CreateCompatibleBitmap (hDC, lpLockData->lpDDSurface->lpGbl->wWidth, lpLockData->lpDDSurface->lpGbl->wHeight);
}
else
{
hImage = CreateCompatibleBitmap (hDC, lpLockData->rArea.right, lpLockData->rArea.bottom);
}
/* Create a memory hdc so we can draw on our current memory bitmap */
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL)
{
/* Select our memory bitmap to our memory hdc */
hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
/* Get our memory bitmap information */
GetObject(hImage, sizeof(BITMAP), &bm);
if (!lpLockData->bHasRect)
{
BitBlt (hMemDC, 0, 0, bm.bmWidth, bm.bmHeight, hDC, 0, 0, SRCCOPY);
}
else
{
BitBlt (hMemDC, lpLockData->rArea.top, lpLockData->rArea.left, lpLockData->rArea.right, lpLockData->rArea.bottom, hDC, 0, 0, SRCCOPY);
}
SelectObject (hMemDC, hDCBmp);
/* Allocate memory buffer for the bitmap pixel data */
cbBuffer = bm.bmWidthBytes * bm.bmHeight ;
pixels = (PDWORD) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, cbBuffer );
if (pixels != NULL)
{
/* Get the bitmap bits */
GetBitmapBits(hImage,cbBuffer,pixels);
/* Fixme HACK - check which member stores the HEL bitmap buffer */
lpLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 = pixels;
/* Setup return value */
lpLockData->ddRVal = DD_OK;
lpLockData->lpSurfData = pixels;
}
}
}
/* Free the pixels buffer if we fail */
if ( (pixels != NULL) &&
(lpLockData->ddRVal != DD_OK) )
{
HeapFree(GetProcessHeap(), 0, pixels );
}
/* Cleanup after us */
if (hImage != NULL)
{
DeleteObject (hImage);
}
if (hMemDC != NULL)
{
DeleteDC (hMemDC);
}
return DDHAL_DRIVER_HANDLED;
}
DWORD CALLBACK HelDdSurfreserved4(DWORD *lpPtr)
{
/*
This api is not doucment by MS So I leave it
as stub.
*/
/* This api is not doucmented by MS, keep it stubbed */
DX_STUB;
}
@ -78,7 +190,64 @@ DWORD CALLBACK HelDdSurfSetPalette(LPDDHAL_SETPALETTEDATA lpSetPaletteData)
DWORD CALLBACK HelDdSurfUnlock(LPDDHAL_UNLOCKDATA lpUnLockData)
{
DX_STUB;
HDC hDC;
HBITMAP hImage = NULL;
HDC hMemDC = NULL;
HBITMAP hDCBmp = NULL;
BITMAP bm = {0};
DX_WINDBG_trace();
/* Get our hdc for the active window */
hDC = GetDC(lpUnLockData->lpDDSurface->lpSurfMore->lpDD_lcl->hFocusWnd);
if (hDC != NULL)
{
/* Create a memory bitmap to store a copy of current hdc surface */
/* fixme the rcarea are not store in the struct yet so the data will look corupted */
hImage = CreateCompatibleBitmap (hDC, lpUnLockData->lpDDSurface->lpGbl->wWidth, lpUnLockData->lpDDSurface->lpGbl->wHeight);
/* Create a memory hdc so we can draw on our current memory bitmap */
hMemDC = CreateCompatibleDC(hDC);
if (hMemDC != NULL)
{
/* Select our memory bitmap to our memory hdc */
hDCBmp = (HBITMAP) SelectObject (hMemDC, hImage);
/* Get our memory bitmap information */
GetObject(hImage, sizeof(BITMAP), &bm);
SetBitmapBits(hImage,bm.bmWidthBytes * bm.bmHeight, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2);
BitBlt (hDC, 0, 0, bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
SelectObject (hMemDC, hDCBmp);
/* Setup return value */
lpUnLockData->ddRVal = DD_OK;
}
}
/* Cleanup after us */
if (hImage != NULL)
{
DeleteObject (hImage);
}
if (hMemDC != NULL)
{
DeleteDC (hMemDC);
}
if (lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 != NULL)
{
HeapFree(GetProcessHeap(), 0, lpUnLockData->lpDDSurface->lpSurfMore->lpDDRAWReserved2 );
}
return DDHAL_DRIVER_HANDLED;
}
DWORD CALLBACK HelDdSurfUpdateOverlay(LPDDHAL_UPDATEOVERLAYDATA lpUpDateOveryLayData)

12
reactos/dll/directx/ddraw/Surface/createsurface.c
View file

@ -35,7 +35,7 @@ Internal_CreateSurface( LPDDRAWI_DIRECTDRAW_INT pDDraw, LPDDSURFACEDESC2 pDDSD,
DWORD count;
HRESULT ret;
if(pDDraw->lpLcl->dwLocalFlags != DDRAWILCL_SETCOOPCALLED)
if((pDDraw->lpLcl->dwLocalFlags & DDRAWILCL_SETCOOPCALLED) != DDRAWILCL_SETCOOPCALLED)
{
return DDERR_NOCOOPERATIVELEVELSET;
}
@ -45,7 +45,7 @@ Internal_CreateSurface( LPDDRAWI_DIRECTDRAW_INT pDDraw, LPDDSURFACEDESC2 pDDSD,
return CLASS_E_NOAGGREGATION;
}
if(!pDDSD->dwFlags & DDSD_CAPS)
if(!(pDDSD->dwFlags & DDSD_CAPS))
{
return DDERR_INVALIDPARAMS;
}
@ -60,14 +60,14 @@ Internal_CreateSurface( LPDDRAWI_DIRECTDRAW_INT pDDraw, LPDDSURFACEDESC2 pDDSD,
return DDERR_INVALIDCAPS;
}
if(!(pDDSD->dwFlags & DDSD_HEIGHT) && !(pDDSD->dwFlags & DDSD_HEIGHT)
&& !(pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
if((!(pDDSD->dwFlags & DDSD_HEIGHT) || !(pDDSD->dwFlags & DDSD_WIDTH))
&& !(pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
{
return DDERR_INVALIDPARAMS;
}
else if(pDDSD->dwFlags & DDSD_HEIGHT && pDDSD->dwFlags & DDSD_HEIGHT
&& pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
else if(((pDDSD->dwFlags & DDSD_HEIGHT) || (pDDSD->dwFlags & DDSD_WIDTH))
&& (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
{
return DDERR_INVALIDPARAMS;
}

268
reactos/dll/directx/ddraw/Surface/surface_main.c
View file

@ -272,129 +272,166 @@ ULONG WINAPI Main_DDrawSurface_Release(LPDDRAWI_DDRAWSURFACE_INT This)
return This->dwIntRefCnt;
}
HRESULT WINAPI Main_DDrawSurface_Blt(LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT rdst,
LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{
DDHAL_BLTDATA mDdBlt;
DDHAL_BLTDATA mDdBlt;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (ThisDest == NULL)
{
return DDERR_INVALIDPARAMS;
}
if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags
& DDHAL_SURFCB32_BLT) != DDHAL_SURFCB32_BLT)
{
return DDERR_GENERIC;
}
/* Zero out members in DDHAL_BLTDATA */
ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
/* Check if we got HAL support for this api */
if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
{
mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
}
/* Check if we got HEL support for this api */
else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
{
mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt;
}
if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("DdResetVisrgn failed");
}
if (mDdBlt.Blt == NULL)
{
/* This API is unsupported */
return DDERR_UNSUPPORTED;
}
mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
/* Prepare for draw, if we do not reset the DdResetVisrgn some graphics card will not draw on the screen */
if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("DdResetVisrgn failed");
}
ThisDest->lpLcl->lpSurfMore->slist[0]->hDC =
ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;
mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
ThisDest->lpLcl->lpSurfMore->slist[0]->hDC = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;
/* Setup Src */
if (ThisSrc != NULL)
{
mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
/* Setup Src */
if (( ThisSrc != NULL ) )
{
ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC =
ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;
mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC = ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;
if (rsrc != NULL)
{
memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
}
else
{
if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rSrc))
{
DX_STUB_str("GetWindowRect failed");
}
}
if (rsrc != NULL)
{
memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
}
else
{
if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rSrc))
{
DX_STUB_str("GetWindowRect failed");
}
}
/* FIXME
* compare so we do not write to far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
}
}
/* Setup dest */
if (rdst != NULL)
{
memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
}
else
{
if(!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rDest))
{
/* Setup dest */
if (rdst != NULL)
{
memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
}
else
{
if (!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
(RECT *)&mDdBlt.rDest))
{
DX_STUB_str("GetWindowRect failed");
}
}
}
}
/* FIXME
* compare so we do not write to far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
/* setup bltFX */
if (lpbltfx != NULL)
{
memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
}
/* setup bltFX */
if (lpbltfx != NULL)
{
memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
}
/* setup value that are not config yet */
mDdBlt.dwFlags = dwFlags;
mDdBlt.IsClipped = FALSE;
mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
/* setup value that are not config yet */
mDdBlt.dwFlags = dwFlags;
mDdBlt.IsClipped = FALSE;
mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
/* FIXME
BltData.dwRectCnt
BltData.dwROPFlags
BltData.IsClipped
BltData.prDestRects
BltData.rOrigDest
BltData.rOrigSrc
BltData.ddRVal
*/
BltData.dwRectCnt
BltData.dwROPFlags
BltData.IsClipped
BltData.prDestRects
BltData.rOrigDest
BltData.rOrigSrc
BltData.ddRVal
*/
if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
{
if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
return DDERR_NOBLTHW;
return DDERR_NOBLTHW;
}
return mDdBlt.ddRVal;
return mDdBlt.ddRVal;
}
HRESULT WINAPI
Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT prect,
Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT prect,
LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
{
DDHAL_LOCKDATA mdLock;
DX_WINDBG_trace();
DX_WINDBG_trace_res( (DWORD)This->lpLcl->lpGbl->wWidth, (DWORD)This->lpLcl->lpGbl->wHeight, (DWORD)This->lpLcl->lpGbl->lPitch, (DWORD) 0);
DX_WINDBG_trace_res( (DWORD)ThisDest->lpLcl->lpGbl->wWidth, (DWORD)ThisDest->lpLcl->lpGbl->wHeight, (DWORD)ThisDest->lpLcl->lpGbl->lPitch, (DWORD) 0);
/* Zero out members in DDHAL_LOCKDATA */
ZeroMemory(&mdLock, sizeof(DDHAL_LOCKDATA));
/* Check if we got HAL support for this api */
if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
{
mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Lock;
}
/* Check if we got HEL support for this api */
else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
{
mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock;
}
if (mdLock.Lock == NULL)
{
/* This api are unsupported */
return DDERR_UNSUPPORTED;
}
if (events != NULL)
{
@ -415,21 +452,19 @@ Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT prect,
//FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary
mdLock.ddRVal = DDERR_NOTPALETTIZED;
mdLock.Lock = This->lpLcl->lpSurfMore->lpDD_lcl->lpDDCB->HALDDSurface.Lock;
mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
mdLock.dwFlags = flags;
mdLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
mdLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mdLock.lpSurfData = NULL;
if (!DdResetVisrgn(This->lpLcl->lpSurfMore->slist[0], NULL))
if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("Here DdResetVisrgn lock");
return DDERR_UNSUPPORTED;
// return DDERR_UNSUPPORTED;
}
if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
@ -460,11 +495,11 @@ Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT prect,
pDDSD->lpSurface = (LPVOID) mdLock.lpSurfData;
pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = This->lpLcl->lpGbl->wWidth;
pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;
pDDSD->ddpfPixelFormat.dwRGBBitCount = This->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
pDDSD->lPitch = This->lpLcl->lpGbl->lPitch;
pDDSD->ddpfPixelFormat.dwRGBBitCount = ThisDest->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
pDDSD->lPitch = ThisDest->lpLcl->lpGbl->lPitch;
pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;
}
@ -474,30 +509,45 @@ Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT prect,
HRESULT WINAPI Main_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT pRect)
{
DDHAL_UNLOCKDATA mdUnLock;
DDHAL_UNLOCKDATA mdUnLock;
DX_WINDBG_trace();
DX_WINDBG_trace();
if (!(This->lpLcl->lpSurfMore->lpDD_lcl->lpDDCB->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_UNLOCK))
{
DX_STUB_str("DDERR_UNSUPPORTED");
return DDERR_UNSUPPORTED;
}
/* Zero out members in DDHAL_UNLOCKDATA */
ZeroMemory(&mdUnLock, sizeof(DDHAL_UNLOCKDATA));
/* Check if we got HAL support for this api */
if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
{
mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Unlock;
}
/* Check if we got HEL support for this api */
else if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
{
mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock;
}
if (mdUnLock.Unlock == NULL)
{
/* This api are unsupported */
return DDERR_UNSUPPORTED;
}
mdUnLock.ddRVal = DDERR_NOTPALETTIZED;
mdUnLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpDDCB->HALDDSurface.Unlock;
mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
{
DX_STUB_str("DDERR_UNSUPPORTED");
return DDERR_UNSUPPORTED;
DX_STUB_str("DdResetVisrgn fail");
//return DDERR_UNSUPPORTED; /* this can fail */
}
if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("unLock fail");
DX_STUB_str("unLock fail");
return DDERR_UNSUPPORTED;
}

1
reactos/dll/directx/ddraw/rosdraw.h
View file

@ -8,6 +8,7 @@
#include <ddrawi.h>
#include <d3dhal.h>
#include <ddrawgdi.h>
#include <pseh/pseh.h>
#include <pseh/pseh2.h>

79
reactos/dll/directx/ddraw/startup.c
View file

@ -33,8 +33,8 @@ Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW* pIface,
This = (LPDDRAWI_DIRECTDRAW_INT)*pIface;
/* fixme linking too second link when we shall not doing it */
if (IsBadReadPtr(This,sizeof(LPDIRECTDRAW)))
if ( (IsBadWritePtr(This,sizeof(LPDDRAWI_DIRECTDRAW_INT)) != 0) ||
(IsBadWritePtr(This->lpLcl,sizeof(LPDDRAWI_DIRECTDRAW_LCL)) != 0) )
{
/* We do not have a DirectDraw interface, we need alloc it*/
LPDDRAWI_DIRECTDRAW_INT memThis;
@ -190,9 +190,6 @@ StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
ddgbl.lpDriverHandle = &ddgbl;
ddgbl.hDDVxd = -1;
if (reenable == FALSE)
{
if ((!IsBadReadPtr(This->lpLink,sizeof(LPDIRECTDRAW))) && (This->lpLink == NULL))
@ -236,8 +233,6 @@ StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
}
else if (lpGuid == (LPGUID) DDCREATE_HARDWAREONLY)
{
@ -289,7 +284,6 @@ StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
/* Startup HEL and HAL */
This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
This->lpLcl->dwProcessId = GetCurrentProcessId();
switch (devicetypes)
{
case 2:
@ -305,6 +299,7 @@ StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
default:
hal_ret = StartDirectDrawHal(iface, reenable);
hel_ret = StartDirectDrawHel(iface, reenable);
break;
}
if (hal_ret!=DD_OK)
@ -362,18 +357,30 @@ StartDirectDrawHel(LPDIRECTDRAW iface, BOOL reenable)
{
LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.CanCreateSurface = HelDdCanCreateSurface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.CreateSurface = HelDdCreateSurface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.CreatePalette = HelDdCreatePalette;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.DestroyDriver = HelDdDestroyDriver;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.FlipToGDISurface = HelDdFlipToGDISurface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.GetScanLine = HelDdGetScanLine;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.SetColorKey = HelDdSetColorKey;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.SetMode = HelDdSetMode;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
if (reenable == FALSE)
{
if (ddgbl.lpDDCBtmp == NULL)
{
DxHeapMemAlloc(ddgbl.lpDDCBtmp, sizeof(DDHAL_CALLBACKS));
if ( ddgbl.lpDDCBtmp == NULL)
{
return DD_FALSE;
}
}
}
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
ddgbl.lpDDCBtmp->HELDD.CanCreateSurface = HelDdCanCreateSurface;
ddgbl.lpDDCBtmp->HELDD.CreateSurface = HelDdCreateSurface;
ddgbl.lpDDCBtmp->HELDD.CreatePalette = HelDdCreatePalette;
ddgbl.lpDDCBtmp->HELDD.DestroyDriver = HelDdDestroyDriver;
ddgbl.lpDDCBtmp->HELDD.FlipToGDISurface = HelDdFlipToGDISurface;
ddgbl.lpDDCBtmp->HELDD.GetScanLine = HelDdGetScanLine;
ddgbl.lpDDCBtmp->HELDD.SetColorKey = HelDdSetColorKey;
ddgbl.lpDDCBtmp->HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
ddgbl.lpDDCBtmp->HELDD.SetMode = HelDdSetMode;
ddgbl.lpDDCBtmp->HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
ddgbl.lpDDCBtmp->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
DDHAL_CB32_CREATESURFACE |
DDHAL_CB32_CREATEPALETTE |
DDHAL_CB32_DESTROYDRIVER |
@ -384,23 +391,23 @@ StartDirectDrawHel(LPDIRECTDRAW iface, BOOL reenable)
DDHAL_CB32_SETMODE |
DDHAL_CB32_WAITFORVERTICALBLANK ;
This->lpLcl->lpGbl->lpDDCBtmp->HELDD.dwSize = sizeof(This->lpLcl->lpDDCB->HELDD);
ddgbl.lpDDCBtmp->HELDD.dwSize = sizeof(This->lpLcl->lpDDCB->HELDD);
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.AddAttachedSurface = HelDdSurfAddAttachedSurface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt = HelDdSurfBlt;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.DestroySurface = HelDdSurfDestroySurface;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.Flip = HelDdSurfFlip;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.GetBltStatus = HelDdSurfGetBltStatus;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.GetFlipStatus = HelDdSurfGetFlipStatus;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock = HelDdSurfLock;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.reserved4 = HelDdSurfreserved4;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.SetClipList = HelDdSurfSetClipList;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.SetColorKey = HelDdSurfSetColorKey;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.SetOverlayPosition = HelDdSurfSetOverlayPosition;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.SetPalette = HelDdSurfSetPalette;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock = HelDdSurfUnlock;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.UpdateOverlay = HelDdSurfUpdateOverlay;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.dwFlags = DDHAL_SURFCB32_ADDATTACHEDSURFACE |
ddgbl.lpDDCBtmp->HELDDSurface.AddAttachedSurface = HelDdSurfAddAttachedSurface;
ddgbl.lpDDCBtmp->HELDDSurface.Blt = HelDdSurfBlt;
ddgbl.lpDDCBtmp->HELDDSurface.DestroySurface = HelDdSurfDestroySurface;
ddgbl.lpDDCBtmp->HELDDSurface.Flip = HelDdSurfFlip;
ddgbl.lpDDCBtmp->HELDDSurface.GetBltStatus = HelDdSurfGetBltStatus;
ddgbl.lpDDCBtmp->HELDDSurface.GetFlipStatus = HelDdSurfGetFlipStatus;
ddgbl.lpDDCBtmp->HELDDSurface.Lock = HelDdSurfLock;
ddgbl.lpDDCBtmp->HELDDSurface.reserved4 = HelDdSurfreserved4;
ddgbl.lpDDCBtmp->HELDDSurface.SetClipList = HelDdSurfSetClipList;
ddgbl.lpDDCBtmp->HELDDSurface.SetColorKey = HelDdSurfSetColorKey;
ddgbl.lpDDCBtmp->HELDDSurface.SetOverlayPosition = HelDdSurfSetOverlayPosition;
ddgbl.lpDDCBtmp->HELDDSurface.SetPalette = HelDdSurfSetPalette;
ddgbl.lpDDCBtmp->HELDDSurface.Unlock = HelDdSurfUnlock;
ddgbl.lpDDCBtmp->HELDDSurface.UpdateOverlay = HelDdSurfUpdateOverlay;
ddgbl.lpDDCBtmp->HELDDSurface.dwFlags = DDHAL_SURFCB32_ADDATTACHEDSURFACE |
DDHAL_SURFCB32_BLT |
DDHAL_SURFCB32_DESTROYSURFACE |
DDHAL_SURFCB32_FLIP |
@ -415,7 +422,7 @@ StartDirectDrawHel(LPDIRECTDRAW iface, BOOL reenable)
DDHAL_SURFCB32_UNLOCK |
DDHAL_SURFCB32_UPDATEOVERLAY;
This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDSurface);
ddgbl.lpDDCBtmp->HELDDSurface.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDSurface);
/*
This->lpLcl->lpDDCB->HELDDPalette.DestroyPalette = HelDdPalDestroyPalette;