HRESULT WINAPI Main_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT pRect)
{
DDHAL_UNLOCKDATA mdUnLock;
DX_WINDBG_trace();
/* 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];
if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
{
DX_STUB_str("DdResetVisrgn fail");
//return DDERR_UNSUPPORTED; /* this can fail */
}
if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("unLock fail");
return DDERR_UNSUPPORTED;
}
return mdUnLock.ddRVal;
}
ULONG WINAPI
DirectDrawColorControl_Release( LPDIRECTDRAWCOLORCONTROL iface)
{
LPDDRAWI_DDCOLORCONTROL_INT This = (LPDDRAWI_DDCOLORCONTROL_INT)iface;
DX_WINDBG_trace();
/* FIXME
This is not right exiame how it should be done
*/
DX_STUB_str("FIXME This is not right exiame how it should be done\n");
return This->dwIntRefCnt;
}
ULONG WINAPI Main_DDrawSurface_Release(LPDDRAWI_DDRAWSURFACE_INT This)
{
/* FIXME
This is not right exiame how it should be done
*/
ULONG ret = --This->dwIntRefCnt;
if(!ret)
{
DX_STUB_str("Release is a bit simplistic right now\n");
AcquireDDThreadLock();
DxHeapMemFree(This);
ReleaseDDThreadLock();
}
return ret;
}
HRESULT WINAPI
Main_DirectDraw_QueryInterface (LPDDRAWI_DIRECTDRAW_INT This,
REFIID id,
LPVOID *obj)
{
HRESULT retVal = DD_OK;
DX_WINDBG_trace();
_SEH2_TRY
{
/* FIXME
the D3D object can be optained from here
Direct3D7
*/
if (IsEqualGUID(&IID_IDirectDraw7, id))
{
if (This->lpVtbl != &DirectDraw7_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw7_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw4, id))
{
if (This->lpVtbl != &DirectDraw4_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw4_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw2, id))
{
if (This->lpVtbl != &DirectDraw2_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw2_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDraw, id))
{
if (This->lpVtbl != &DirectDraw_Vtable)
{
This = internal_directdraw_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDraw_Vtable;
*obj = This;
Main_DirectDraw_AddRef(This);
}
else
{
*obj = NULL;
DX_STUB_str("E_NOINTERFACE");
retVal = E_NOINTERFACE;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
HRESULT WINAPI
Main_DDrawSurface_QueryInterface(LPDDRAWI_DDRAWSURFACE_INT This, REFIID riid, LPVOID* ppObj)
{
HRESULT retVal = DD_OK;
*ppObj = NULL;
DX_WINDBG_trace();
_SEH2_TRY
{
if (IsEqualGUID(&IID_IDirectDrawSurface7, riid))
{
if (This->lpVtbl != &DirectDrawSurface7_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface7_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface4, riid))
{
if (This->lpVtbl != &DirectDrawSurface4_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface4_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface3, riid))
{
if (This->lpVtbl != &DirectDrawSurface3_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface3_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface2, riid))
{
if (This->lpVtbl != &DirectDrawSurface2_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface2_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurface, riid))
{
if (This->lpVtbl != &DirectDrawSurface_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurface_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawColorControl, riid))
{
if (This->lpVtbl != &DirectDrawColorControl_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawColorControl_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
{
if (This->lpVtbl != &DirectDrawGammaControl_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawGammaControl_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirectDrawSurfaceKernel, riid))
{
if (This->lpVtbl != &DirectDrawSurfaceKernel_Vtable)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &DirectDrawSurfaceKernel_Vtable;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D, riid))
{
if (This->lpVtbl != &IDirect3D_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D2, riid))
{
if (This->lpVtbl != &IDirect3D2_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D2_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D3, riid))
{
if (This->lpVtbl != &IDirect3D3_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D3_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else if (IsEqualGUID(&IID_IDirect3D7, riid))
{
if (This->lpVtbl != &IDirect3D7_Vtbl)
{
This = internal_directdrawsurface_int_alloc(This);
if (!This)
{
retVal = DDERR_OUTOFVIDEOMEMORY;
_SEH2_LEAVE;
}
}
This->lpVtbl = &IDirect3D7_Vtbl;
*ppObj = This;
Main_DDrawSurface_AddRef(This);
}
else
{
DX_STUB_str("E_NOINTERFACE");
retVal = E_NOINTERFACE;
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return retVal;
}
HRESULT WINAPI
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)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)
{
return DDERR_INVALIDPARAMS;
}
/* FIXME add a check see if lock support or not */
if (prect!=NULL)
{
mdLock.bHasRect = TRUE;
memcpy(&mdLock.rArea,prect,sizeof(RECTL));
}
else
{
mdLock.bHasRect = FALSE;
}
//FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary
mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
mdLock.dwFlags = flags;
mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
mdLock.lpSurfData = NULL;
if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
{
DX_STUB_str("Here DdResetVisrgn lock");
// return DDERR_UNSUPPORTED;
}
if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
return DDERR_UNSUPPORTED;
}
// FIXME ??? is this right ??
if (pDDSD != NULL)
{
ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
pDDSD->dwSize = sizeof(DDSURFACEDESC2);
//if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
//{
// ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
// // FIXME the internal mddsdPrimary shall be DDSURFACEDESC2
// memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
// pDDSD->dwSize = sizeof(DDSURFACEDESC2);
//}
//if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
//{
// RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
// memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
// pDDSD->dwSize = sizeof(DDSURFACEDESC);
//}
pDDSD->lpSurface = (LPVOID) mdLock.lpSurfData;
pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;
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;
}
return mdLock.ddRVal;
}
HRESULT WINAPI Main_DDrawSurface_Blt(LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT rdst,
LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
{
DDHAL_BLTDATA mDdBlt;
DX_WINDBG_trace();
if (ThisDest == NULL)
{
return DDERR_INVALIDPARAMS;
}
/* Zero out members in DDHAL_BLTDATA */
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 (mDdBlt.Blt == NULL)
{
/* This API is unsupported */
return DDERR_UNSUPPORTED;
}
/* 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");
}
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];
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");
}
}
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max height
* 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))
{
DX_STUB_str("GetWindowRect failed");
}
}
/* FIXME
* compare so we do not write too far
* ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
* ThisDest->lpLcl->lpGbl->wHeight <- surface max height
* ThisDest->lpLcl->lpGbl->lPitch <- surface bpp
*/
/* 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);
/* FIXME
BltData.dwRectCnt
BltData.dwROPFlags
BltData.IsClipped
BltData.prDestRects
BltData.rOrigDest
BltData.rOrigSrc
BltData.ddRVal
*/
if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
{
DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
return DDERR_NOBLTHW;
}
return mDdBlt.ddRVal;
}
HRESULT
Internal_CreateSurface( LPDDRAWI_DIRECTDRAW_INT pDDraw, LPDDSURFACEDESC2 pDDSD,
LPDDRAWI_DDRAWSURFACE_INT *ppSurf, IUnknown *pUnkOuter)
{
DDHAL_CANCREATESURFACEDATA mDdCanCreateSurface = { 0 };
DDHAL_CREATESURFACEDATA mDdCreateSurface = { 0 };
LPDDRAWI_DDRAWSURFACE_INT ThisSurfInt;
LPDDRAWI_DDRAWSURFACE_LCL ThisSurfLcl;
LPDDRAWI_DDRAWSURFACE_GBL ThisSurfGbl;
LPDDRAWI_DDRAWSURFACE_MORE ThisSurfMore;
LPDDRAWI_DDRAWSURFACE_INT * slist_int = NULL;
LPDDRAWI_DDRAWSURFACE_LCL * slist_lcl = NULL;
LPDDRAWI_DDRAWSURFACE_GBL * slist_gbl = NULL;
LPDDRAWI_DDRAWSURFACE_MORE * slist_more = NULL;
DWORD num_of_surf=1;
DWORD count;
HRESULT ret;
if((pDDraw->lpLcl->dwLocalFlags & DDRAWILCL_SETCOOPCALLED) != DDRAWILCL_SETCOOPCALLED)
{
return DDERR_NOCOOPERATIVELEVELSET;
}
if(pUnkOuter)
{
return CLASS_E_NOAGGREGATION;
}
if(!(pDDSD->dwFlags & DDSD_CAPS))
{
return DDERR_INVALIDPARAMS;
}
if (pDDraw->lpLcl->dwProcessId != GetCurrentProcessId() )
{
return DDERR_INVALIDOBJECT;
}
if ( ((pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) == DDSCAPS_SYSTEMMEMORY) &&
((pDDSD->ddsCaps.dwCaps & DDSCAPS_VIDEOMEMORY) == DDSCAPS_VIDEOMEMORY) )
{
return DDERR_INVALIDCAPS;
}
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_WIDTH))
&& (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE))
{
return DDERR_INVALIDPARAMS;
}
/*
* program does not need set the DDSD_LPSURFACE,
* if they forget set it, the ddraw will automatic
* set it for system memory.
*/
if ( ((pDDSD->ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) == DDSCAPS_SYSTEMMEMORY) &&
((pDDSD->dwFlags & DDSD_LPSURFACE) != DDSD_LPSURFACE) )
{
pDDSD->dwFlags = pDDSD->dwFlags | DDSD_LPSURFACE;
}
/* FIXME count how many surfaces we need */
DxHeapMemAlloc(slist_int, num_of_surf * sizeof( LPDDRAWI_DDRAWSURFACE_INT ) );
if( slist_int == NULL)
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
DxHeapMemAlloc(slist_lcl, num_of_surf * sizeof( LPDDRAWI_DDRAWSURFACE_LCL ) );
if( slist_lcl == NULL )
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
/* keep pointers to all gbl surfs to be able to free them on error */
DxHeapMemAlloc(slist_gbl, num_of_surf * sizeof( LPDDRAWI_DDRAWSURFACE_GBL ) );
if( slist_gbl == NULL )
{
DxHeapMemFree(slist_int);
return DDERR_OUTOFMEMORY;
}
/* keep pointers to all more surfs to be able to free them on error */
DxHeapMemAlloc(slist_more, num_of_surf * sizeof( LPDDRAWI_DDRAWSURFACE_MORE ) );
if( slist_more == NULL )
{
DxHeapMemFree(slist_int);
return DDERR_OUTOFMEMORY;
}
for( count=0; count < num_of_surf; count++ )
{
/* Allocate the surface interface and needed members */
DxHeapMemAlloc(ThisSurfInt, sizeof( DDRAWI_DDRAWSURFACE_INT ) );
if( ThisSurfInt == NULL )
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
DxHeapMemAlloc(ThisSurfLcl, sizeof( DDRAWI_DDRAWSURFACE_LCL ) );
if( ThisSurfLcl == NULL )
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
DxHeapMemAlloc(ThisSurfGbl, sizeof( DDRAWI_DDRAWSURFACE_GBL ) );
if( ThisSurfGbl == NULL )
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
DxHeapMemAlloc(ThisSurfMore, sizeof( DDRAWI_DDRAWSURFACE_MORE ) );
if( ThisSurfMore == NULL )
{
ret = DDERR_OUTOFMEMORY;
goto cleanup;
}
/* setup lists, really needed are slist_lcl, slist_int
other slists should be released on return */
slist_int[count] = ThisSurfInt;
slist_lcl[count] = ThisSurfLcl;
slist_gbl[count] = ThisSurfGbl;
slist_more[count] = ThisSurfMore;
/* Start now fill in the member as they shall look like before call to createsurface */
ThisSurfInt->lpLcl = ThisSurfLcl;
ThisSurfLcl->lpGbl = ThisSurfGbl;
ThisSurfLcl->ddsCaps.dwCaps = pDDSD->ddsCaps.dwCaps;
ThisSurfGbl->lpDD = pDDraw->lpLcl->lpGbl;
ThisSurfGbl->lpDDHandle = pDDraw->lpLcl->lpGbl;
/* FIXME ? */
ThisSurfGbl->dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
if (pDDSD->ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
{
ThisSurfGbl->wWidth = pDDraw->lpLcl->lpGbl->vmiData.dwDisplayWidth;
ThisSurfGbl->wHeight = pDDraw->lpLcl->lpGbl->vmiData.dwDisplayHeight;
ThisSurfGbl->lPitch = pDDraw->lpLcl->lpGbl->vmiData.lDisplayPitch;
ThisSurfGbl->dwLinearSize = pDDraw->lpLcl->lpGbl->vmiData.lDisplayPitch;
ThisSurfMore->dmiDDrawReserved7.wWidth = pDDraw->lpLcl->lpGbl->vmiData.dwDisplayWidth;
ThisSurfMore->dmiDDrawReserved7.wHeight = pDDraw->lpLcl->lpGbl->vmiData.dwDisplayHeight;
ThisSurfMore->dmiDDrawReserved7.wBPP = pDDraw->lpLcl->lpGbl->dwMonitorFrequency;
/* FIXME ThisSurfaceMore->dmiDDrawReserved7.wMonitorsAttachedToDesktop */
ThisSurfMore->dmiDDrawReserved7.wMonitorsAttachedToDesktop = 1;
pDDraw->lpLcl->lpPrimary = ThisSurfInt;
}
else
{
ThisSurfGbl->wWidth = (WORD)pDDSD->dwWidth;
ThisSurfGbl->wHeight = (WORD)pDDSD->dwHeight;
ThisSurfGbl->lPitch = pDDSD->lPitch;
ThisSurfGbl->dwLinearSize = pDDSD->lPitch;
}
if(pDDraw->lpVtbl == &DirectDraw7_Vtable)
{
ThisSurfInt->lpVtbl = &DirectDrawSurface7_Vtable;
}
else if(pDDraw->lpVtbl == &DirectDraw4_Vtable)
{
ThisSurfInt->lpVtbl = &DirectDrawSurface4_Vtable;
}
else if(pDDraw->lpVtbl == &DirectDraw2_Vtable)
{
ThisSurfInt->lpVtbl = &DirectDrawSurface2_Vtable;
}
else if(pDDraw->lpVtbl == &DirectDraw_Vtable)
{
ThisSurfInt->lpVtbl = &DirectDrawSurface_Vtable;
}
else
{
ret = DDERR_NOTINITIALIZED;
goto cleanup;
}
ThisSurfLcl->lpSurfMore = ThisSurfMore;
ThisSurfMore->dwSize = sizeof(DDRAWI_DDRAWSURFACE_MORE);
ThisSurfMore->lpDD_int = pDDraw;
ThisSurfMore->lpDD_lcl = pDDraw->lpLcl;
ThisSurfMore->slist = slist_lcl;
ThisSurfLcl->dwProcessId = GetCurrentProcessId();
/* FIXME the lpLnk */
Main_DDrawSurface_AddRef(ThisSurfInt);
}
pDDraw->lpLcl->lpGbl->dsList = (LPDDRAWI_DDRAWSURFACE_INT) slist_int;
/* Fixme call on DdCanCreate then on DdCreateSurface createsurface data here */
/* FIXME bIsDifferentPixelFormat being set to true or false with automatic detections */
mDdCanCreateSurface.bIsDifferentPixelFormat = FALSE;
mDdCanCreateSurface.lpDD = pDDraw->lpLcl->lpGbl;
mDdCanCreateSurface.CanCreateSurface = pDDraw->lpLcl->lpDDCB->HALDD.CanCreateSurface;
mDdCanCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD;
mDdCanCreateSurface.ddRVal = DDERR_GENERIC;
if (mDdCanCreateSurface.CanCreateSurface(&mDdCanCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
{
DX_STUB_str("mDdCanCreateSurface failed with DDHAL_DRIVER_NOTHANDLED.");
ret = DDERR_NOTINITIALIZED;
goto cleanup;
}
if (mDdCanCreateSurface.ddRVal != DD_OK)
{
DX_STUB_str("mDdCanCreateSurface failed.");
ret = mDdCanCreateSurface.ddRVal;
goto cleanup;
}
mDdCreateSurface.lpDD = pDDraw->lpLcl->lpGbl;
mDdCreateSurface.CreateSurface = pDDraw->lpLcl->lpGbl->lpDDCBtmp->HALDD.CreateSurface;
mDdCreateSurface.ddRVal = DDERR_GENERIC;
mDdCreateSurface.dwSCnt = num_of_surf;
mDdCreateSurface.lpDDSurfaceDesc = (LPDDSURFACEDESC) pDDSD;
mDdCreateSurface.lplpSList = slist_lcl;
if (mDdCreateSurface.CreateSurface(&mDdCreateSurface) == DDHAL_DRIVER_NOTHANDLED)
{
DX_STUB_str("mDdCreateSurface failed with DDHAL_DRIVER_NOTHANDLED.");
ret = DDERR_NOTINITIALIZED;
goto cleanup;
}
if (mDdCreateSurface.ddRVal != DD_OK)
{
DX_STUB_str("mDdCreateSurface failed.");
ret = mDdCreateSurface.ddRVal;
goto cleanup;
}
/* free unneeded slists */
if (slist_more != NULL)
DxHeapMemFree(slist_more);
if (slist_gbl != NULL)
DxHeapMemFree(slist_gbl);
*ppSurf = (LPDDRAWI_DDRAWSURFACE_INT) &slist_int[0]->lpVtbl;
return DD_OK;
cleanup:
for(count = 0; count < num_of_surf; count++)
{
if (slist_more[count] != NULL)
DxHeapMemFree(slist_more[count]);
if (slist_gbl[count] != NULL)
DxHeapMemFree(slist_gbl[count]);
if (slist_lcl[count] != NULL)
DxHeapMemFree(slist_lcl[count]);
if (slist_int[count] != NULL)
DxHeapMemFree(slist_int[count]);
}
if (slist_more != NULL)
DxHeapMemFree(slist_more);
if (slist_gbl != NULL)
DxHeapMemFree(slist_gbl);
if (slist_lcl != NULL)
DxHeapMemFree(slist_lcl);
if (slist_int != NULL)
DxHeapMemFree(slist_int);
return ret;
}
HRESULT WINAPI
Main_DirectDraw_SetDisplayMode2 (LPDDRAWI_DIRECTDRAW_INT This, DWORD dwWidth, DWORD dwHeight,
DWORD dwBPP, DWORD dwRefreshRate, DWORD dwFlags)
{
HRESULT ret = DD_OK;
DX_WINDBG_trace();
_SEH2_TRY
{
// FIXME: Check primary if surface is locked / busy etc.
// Check Parameters
if(dwFlags != 0)
{
ret = DDERR_INVALIDPARAMS;
}
else
{
if ((!dwHeight || This->lpLcl->lpGbl->vmiData.dwDisplayHeight == dwHeight) &&
(!dwWidth || This->lpLcl->lpGbl->vmiData.dwDisplayWidth == dwWidth) &&
(!dwBPP || This->lpLcl->lpGbl->vmiData.ddpfDisplay.dwRGBBitCount == dwBPP) &&
(!dwRefreshRate || This->lpLcl->lpGbl->dwMonitorFrequency == dwRefreshRate))
{
ret = DD_OK; // nothing to do here for us
}
else
{
LONG retval;
// Here we go
DEVMODE DevMode;
ZeroMemory(&DevMode, sizeof(DEVMODE));
DevMode.dmSize = sizeof(DEVMODE);
if (dwHeight)
DevMode.dmFields |= DM_PELSHEIGHT;
if (dwWidth)
DevMode.dmFields |= DM_PELSWIDTH;
if (dwBPP)
DevMode.dmFields |= DM_BITSPERPEL;
if (dwRefreshRate)
DevMode.dmFields |= DM_DISPLAYFREQUENCY;
DevMode.dmPelsHeight = dwHeight;
DevMode.dmPelsWidth = dwWidth;
DevMode.dmBitsPerPel = dwBPP;
DevMode.dmDisplayFrequency = dwRefreshRate;
DX_WINDBG_trace_res(dwWidth, dwHeight,dwBPP, dwRefreshRate);
retval = ChangeDisplaySettings(&DevMode, CDS_FULLSCREEN);
/* FIXME: Are we supposed to set CDS_SET_PRIMARY as well ? */
if(retval == DISP_CHANGE_BADMODE)
{
/* Note : it seam ms ddraw ignore this and try using the bad mode any case.
* tested with Ati HD2400 that only support 16 and 32 Bpp in windows
*/
DX_STUB_str("Warning ChangeDisplaySettings return DISP_CHANGE_BADMODE, but ddraw.dll ignore it\n");
//ret = DDERR_UNSUPPORTED;
BOOL ModeChanged;
This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
}
else if(retval != DISP_CHANGE_SUCCESSFUL)
{
ret = DDERR_GENERIC;
}
else
{
// Update Interals
BOOL ModeChanged;
This->lpLcl->lpGbl->hDD = This->lpLcl->hDD;
DdReenableDirectDrawObject(This->lpLcl->lpGbl, &ModeChanged);
StartDirectDraw((LPDIRECTDRAW)This, 0, TRUE);
}
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
}
_SEH2_END;
return ret;
}
