* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: lib/ddraw/ddraw.c
- * PURPOSE: DirectDraw Library
+ * PURPOSE: DirectDraw Library
* PROGRAMMER: Magnus Olsen (greatlrd)
*
*/
-#include <windows.h>
#include "rosdraw.h"
-#include "d3dhal.h"
+DDRAWI_DIRECTDRAW_GBL ddgbl;
+DDRAWI_DDRAWSURFACE_GBL ddSurfGbl;
-HRESULT WINAPI
-StartDirectDraw(LPDIRECTDRAW* iface)
+WCHAR classname[128];
+WNDCLASSW wnd_class;
+
+
+HRESULT WINAPI
+Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW* pIface,
+ REFIID id, BOOL reenable)
{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- DWORD hal_ret;
- DWORD hel_ret;
- DEVMODE devmode;
- HBITMAP hbmp;
- const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10;
- UCHAR *pbmiData;
- BITMAPINFO *pbmi;
- DWORD *pMasks;
- DWORD Flags;
-
+ LPDDRAWI_DIRECTDRAW_INT This;
+
DX_WINDBG_trace();
-
- RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
-
- /* cObsolete is undoc in msdn it being use in CreateDCA */
- RtlCopyMemory(&This->mDDrawGlobal.cObsolete,&"DISPLAY",7);
- RtlCopyMemory(&This->mDDrawGlobal.cDriverName,&"DISPLAY",7);
-
- /* Same for HEL and HAL */
- This->mcModeInfos = 1;
- This->mpModeInfos = (DDHALMODEINFO*) DxHeapMemAlloc(This->mcModeInfos * sizeof(DDHALMODEINFO));
-
- if (This->mpModeInfos == NULL)
+
+ if ((IsBadReadPtr(pIface,sizeof(LPDIRECTDRAW))) ||
+ (IsBadWritePtr(pIface,sizeof(LPDIRECTDRAW))))
{
- DX_STUB_str("DD_FALSE");
- return DD_FALSE;
+ return DDERR_INVALIDPARAMS;
}
- EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
+ This = (LPDDRAWI_DIRECTDRAW_INT)*pIface;
+
+ /* fixme linking too second link when we shall not doing it */
+ if (IsBadReadPtr(This,sizeof(LPDIRECTDRAW)))
+ {
+ /* We do not have a DirectDraw interface, we need alloc it*/
+ LPDDRAWI_DIRECTDRAW_INT memThis;
- This->mpModeInfos[0].dwWidth = devmode.dmPelsWidth;
- This->mpModeInfos[0].dwHeight = devmode.dmPelsHeight;
- This->mpModeInfos[0].dwBPP = devmode.dmBitsPerPel;
- This->mpModeInfos[0].lPitch = (devmode.dmPelsWidth*devmode.dmBitsPerPel)/8;
- This->mpModeInfos[0].wRefreshRate = (WORD)devmode.dmDisplayFrequency;
-
- This->hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
+ DX_STUB_str("1. no linking\n");
- if (This->hdc == NULL)
+ DxHeapMemAlloc(memThis, sizeof(DDRAWI_DIRECTDRAW_INT));
+ if (memThis == NULL)
+ {
+ return DDERR_OUTOFMEMORY;
+ }
+
+ This = memThis;
+
+ /* Fixme release memory alloc if we fail */
+
+ DxHeapMemAlloc(This->lpLcl, sizeof(DDRAWI_DIRECTDRAW_LCL));
+ if (This->lpLcl == NULL)
+ {
+ return DDERR_OUTOFMEMORY;
+ }
+ }
+ else
{
- DX_STUB_str("DDERR_OUTOFMEMORY");
- return DDERR_OUTOFMEMORY ;
+ /* We got the DirectDraw interface alloc and we need create the link */
+ LPDDRAWI_DIRECTDRAW_INT newThis;
+
+ DX_STUB_str("2.linking\n");
+
+ /* step 1.Alloc the new DDRAWI_DIRECTDRAW_INT for the lnking */
+ DxHeapMemAlloc(newThis, sizeof(DDRAWI_DIRECTDRAW_INT));
+ if (newThis == NULL)
+ {
+ return DDERR_OUTOFMEMORY;
+ }
+
+ /* step 2 check if it not DDCREATE_HARDWAREONLY we got if so we fail */
+ if ((pGUID) && (pGUID != (LPGUID)DDCREATE_HARDWAREONLY))
+ {
+ if (pGUID !=NULL)
+ {
+ This = newThis;
+ return DDERR_INVALIDDIRECTDRAWGUID;
+ }
+ }
+
+ /* step 3 do the link the old interface are store in the new one */
+ newThis->lpLink = This;
+
+ /* step 4 we need create new local directdraw struct for the new linked interface */
+ DxHeapMemAlloc(newThis->lpLcl, sizeof(DDRAWI_DIRECTDRAW_LCL));
+ if (newThis->lpLcl == NULL)
+ {
+ This = newThis;
+ return DDERR_OUTOFMEMORY;
+ }
+
+ This = newThis;
}
- hbmp = CreateCompatibleBitmap(This->hdc, 1, 1);
- if (hbmp==NULL)
+ This->lpLcl->lpGbl = &ddgbl;
+
+ *pIface = (LPDIRECTDRAW)This;
+
+ /* Get right interface we whant */
+
+ This->lpVtbl = 0;
+ if (IsEqualGUID(&IID_IDirectDraw7, id))
+ {
+ /* DirectDraw7 Vtable */
+ This->lpVtbl = &DirectDraw7_Vtable;
+ This->lpLcl->dwLocalFlags = This->lpLcl->dwLocalFlags + DDRAWILCL_DIRECTDRAW7;
+ *pIface = (LPDIRECTDRAW)&This->lpVtbl;
+ Main_DirectDraw_AddRef(This);
+ }
+ else if (IsEqualGUID(&IID_IDirectDraw4, id))
+ {
+ /* DirectDraw4 Vtable */
+ This->lpVtbl = &DirectDraw4_Vtable;
+ *pIface = (LPDIRECTDRAW)&This->lpVtbl;
+ Main_DirectDraw_AddRef(This);
+ }
+ else if (IsEqualGUID(&IID_IDirectDraw2, id))
+ {
+ /* DirectDraw2 Vtable */
+ This->lpVtbl = &DirectDraw2_Vtable;
+ *pIface = (LPDIRECTDRAW)&This->lpVtbl;
+ Main_DirectDraw_AddRef(This);
+ }
+ else if (IsEqualGUID(&IID_IDirectDraw, id))
{
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- DX_STUB_str("DDERR_OUTOFMEMORY");
- return DDERR_OUTOFMEMORY;
+ /* DirectDraw Vtable */
+ This->lpVtbl = &DirectDraw_Vtable;
+ *pIface = (LPDIRECTDRAW)&This->lpVtbl;
+ Main_DirectDraw_AddRef(This);
}
-
- pbmiData = (UCHAR *) DxHeapMemAlloc(bmiSize);
- pbmi = (BITMAPINFO*)pbmiData;
- if (pbmiData==NULL)
+ if ( This->lpVtbl != 0)
{
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- DeleteObject(hbmp);
- DX_STUB_str("DDERR_OUTOFMEMORY");
- return DDERR_OUTOFMEMORY;
+ DX_STUB_str("Got iface\n");
+
+ if (StartDirectDraw((LPDIRECTDRAW)This, pGUID, FALSE) == DD_OK);
+ {
+ /*
+ RtlZeroMemory(&wnd_class, sizeof(wnd_class));
+ wnd_class.style = CS_HREDRAW | CS_VREDRAW;
+ wnd_class.lpfnWndProc = DefWindowProcW;
+ wnd_class.cbClsExtra = 0;
+ wnd_class.cbWndExtra = 0;
+ wnd_class.hInstance = GetModuleHandleW(0);
+ wnd_class.hIcon = 0;
+ wnd_class.hCursor = 0;
+ wnd_class.hbrBackground = (HBRUSH) GetStockObject(BLACK_BRUSH);
+ wnd_class.lpszMenuName = NULL;
+ wnd_class.lpszClassName = classname;
+ if(!RegisterClassW(&wnd_class))
+ {
+ DX_STUB_str("DDERR_GENERIC");
+ return DDERR_GENERIC;
+ }
+ */
+ This->lpLcl->hDD = ddgbl.hDD;
+ return DD_OK;
+ }
}
- pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- pbmi->bmiHeader.biBitCount = (WORD)devmode.dmBitsPerPel;
- pbmi->bmiHeader.biCompression = BI_BITFIELDS;
- pbmi->bmiHeader.biWidth = 1;
- pbmi->bmiHeader.biHeight = 1;
+ return DDERR_INVALIDPARAMS;
+}
+
+
+HRESULT WINAPI
+StartDirectDraw(LPDIRECTDRAW iface, LPGUID lpGuid, BOOL reenable)
+{
+ LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
+ DWORD hal_ret = DD_FALSE;
+ DWORD hel_ret = DD_FALSE;
+ DWORD devicetypes = 0;
+ DWORD dwFlags = 0;
- GetDIBits(This->hdc, hbmp, 0, 0, NULL, pbmi, 0);
- DeleteObject(hbmp);
- pMasks = (DWORD*)(pbmiData + sizeof(BITMAPINFOHEADER));
- This->mpModeInfos[0].dwRBitMask = pMasks[0];
- This->mpModeInfos[0].dwGBitMask = pMasks[1];
- This->mpModeInfos[0].dwBBitMask = pMasks[2];
- This->mpModeInfos[0].dwAlphaBitMask = pMasks[3];
+ DX_WINDBG_trace();
- DxHeapMemFree(pbmiData);
+
+ /*
+ * ddgbl.dwPDevice is not longer in use in windows 2000 and higher
+ * I am using it for device type
+ * devicetypes = 1 : both hal and hel are enable
+ * devicetypes = 2 : both hal are enable
+ * devicetypes = 3 : both hel are enable
+ * devicetypes = 4 :loading a guid drv from the register
+ */
+
+ ddgbl.lpDriverHandle = &ddgbl;
+ ddgbl.hDDVxd = -1;
+
+
+
+
+ if (reenable == FALSE)
+ {
+ if ((!IsBadReadPtr(This->lpLink,sizeof(LPDIRECTDRAW))) && (This->lpLink == NULL))
+ {
+ RtlZeroMemory(&ddgbl, sizeof(DDRAWI_DIRECTDRAW_GBL));
+ This->lpLcl->lpGbl->dwRefCnt++;
+ if (ddgbl.lpDDCBtmp == NULL)
+ {
+ // LPDDHAL_CALLBACKS
+ DxHeapMemAlloc( ddgbl.lpDDCBtmp , sizeof(DDHAL_CALLBACKS));
+ if (ddgbl.lpDDCBtmp == NULL)
+ {
+ DX_STUB_str("Out of memmory\n");
+ return DD_FALSE;
+ }
+ }
+ }
+
+ DxHeapMemAlloc(ddgbl.lpModeInfo, sizeof(DDHALMODEINFO));
+ if (!ddgbl.lpModeInfo)
+ {
+ return DDERR_OUTOFMEMORY;
+ }
+
+ }
+ /* Windows handler are by set of SetCooperLevel
+ * so do not set it
+ */
+
+ if (reenable == FALSE)
+ {
+ if (lpGuid == NULL)
+ {
+ devicetypes= 1;
+
+ /* Create HDC for default, hal and hel driver */
+ // This->lpLcl->hWnd = (ULONG_PTR) GetActiveWindow();
+ This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
+
+ /* cObsolete is undoc in msdn it being use in CreateDCA */
+ RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
+ RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
+ dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
+
+
+ }
+ else if (lpGuid == (LPGUID) DDCREATE_HARDWAREONLY)
+ {
+ devicetypes = 2;
+ /* Create HDC for default, hal driver */
+ // This->lpLcl->hWnd =(ULONG_PTR) GetActiveWindow();
+ This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
+
+ /* cObsolete is undoc in msdn it being use in CreateDCA */
+ RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
+ RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
+ dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
+ }
+ else if (lpGuid == (LPGUID) DDCREATE_EMULATIONONLY)
+ {
+ devicetypes = 3;
+
+ /* Create HDC for default, hal and hel driver */
+ //This->lpLcl->hWnd = (ULONG_PTR) GetActiveWindow();
+ This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
+
+ /* cObsolete is undoc in msdn it being use in CreateDCA */
+ RtlCopyMemory(&ddgbl.cObsolete,&"DISPLAY",7);
+ RtlCopyMemory(&ddgbl.cDriverName,&"DISPLAY",7);
+
+ dwFlags |= DDRAWI_DISPLAYDRV | DDRAWI_GDIDRV;
+ }
+ else
+ {
+ /* FIXME : need getting driver from the GUID that have been pass in from
+ * the register. we do not support that yet
+ */
+ devicetypes = 4;
+ //This->lpLcl->hDC = (ULONG_PTR) NULL ;
+ //This->lpLcl->hDC = (ULONG_PTR)CreateDCA("DISPLAY",NULL,NULL,NULL);
+ }
+
+ /*
+ if ( (HDC)This->lpLcl->hDC == NULL)
+ {
+ DX_STUB_str("DDERR_OUTOFMEMORY\n");
+ return DDERR_OUTOFMEMORY ;
+ }
+ */
+ }
+
+ This->lpLcl->lpDDCB = ddgbl.lpDDCBtmp;
/* Startup HEL and HAL */
- RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
- RtlZeroMemory(&This->mHALInfo, sizeof(DDHALINFO));
- RtlZeroMemory(&This->mCallbacks, sizeof(DDHAL_CALLBACKS));
+ This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
+ This->lpLcl->dwProcessId = GetCurrentProcessId();
- This->mDDrawLocal.lpDDCB = &This->mCallbacks;
- This->mDDrawLocal.lpGbl = &This->mDDrawGlobal;
- This->mDDrawLocal.dwProcessId = GetCurrentProcessId();
+ switch (devicetypes)
+ {
+ case 2:
+ hal_ret = StartDirectDrawHal(iface, reenable);
+ This->lpLcl->lpDDCB->HELDD.dwFlags = 0;
+ break;
+
+ case 3:
+ hel_ret = StartDirectDrawHel(iface, reenable);
+ This->lpLcl->lpDDCB->HALDD.dwFlags = 0;
+ break;
+
+ default:
+ hal_ret = StartDirectDrawHal(iface, reenable);
+ hel_ret = StartDirectDrawHel(iface, reenable);
+ }
+
+ if (hal_ret!=DD_OK)
+ {
+ if (hel_ret!=DD_OK)
+ {
+ DX_STUB_str("DDERR_NODIRECTDRAWSUPPORT\n");
+ return DDERR_NODIRECTDRAWSUPPORT;
+ }
+ dwFlags |= DDRAWI_NOHARDWARE;
+ }
- This->mDDrawGlobal.lpDDCBtmp = &This->mCallbacks;
- This->mDDrawGlobal.lpExclusiveOwner = &This->mDDrawLocal;
+ if (hel_ret!=DD_OK)
+ {
+ dwFlags |= DDRAWI_NOEMULATION;
- hal_ret = StartDirectDrawHal(iface);
- hel_ret = StartDirectDrawHel(iface);
- if ((hal_ret!=DD_OK) && (hel_ret!=DD_OK))
+ }
+ else
{
- DX_STUB_str("DDERR_NODIRECTDRAWSUPPORT");
- return DDERR_NODIRECTDRAWSUPPORT;
+ dwFlags |= DDRAWI_EMULATIONINITIALIZED;
}
- /*
- Setup HEL or HAL for DD_CALLBACKS
- */
-
- This->mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
- This->mDdCreatePalette.lpDD = &This->mDDrawGlobal;
- This->mDdCreateSurface.lpDD = &This->mDDrawGlobal;
- This->mDdFlipToGDISurface.lpDD = &This->mDDrawGlobal;
- This->mDdDestroyDriver.lpDD = &This->mDDrawGlobal;
- This->mDdGetScanLine.lpDD = &This->mDDrawGlobal;
- This->mDdSetExclusiveMode.lpDD = &This->mDDrawGlobal;
- This->mDdSetMode.lpDD = &This->mDDrawGlobal;
- This->mDdWaitForVerticalBlank.lpDD = &This->mDDrawGlobal;
- This->mDdSetColorKey.lpDD = &This->mDDrawGlobal;
-
- if (This->devicetype!=1)
- {
- /* both or only hel */
- This->mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HELDD.CanCreateSurface;
- This->mDdCreatePalette.CreatePalette = This->mCallbacks.HELDD.CreatePalette;
- This->mDdCreateSurface.CreateSurface = This->mCallbacks.HELDD.CreateSurface;
- This->mDdDestroyDriver.DestroyDriver = This->mCallbacks.HELDD.DestroyDriver;
- This->mDdFlipToGDISurface.FlipToGDISurface = This->mCallbacks.HELDD.FlipToGDISurface;
- This->mDdGetScanLine.GetScanLine = This->mCallbacks.HELDD.GetScanLine;
- This->mDdSetExclusiveMode.SetExclusiveMode = This->mCallbacks.HELDD.SetExclusiveMode;
- This->mDdSetMode.SetMode = This->mCallbacks.HELDD.SetMode;
- This->mDdWaitForVerticalBlank.WaitForVerticalBlank = This->mCallbacks.HELDD.WaitForVerticalBlank;
- // This->mDdSetColorKey.SetColorKey = This->mCallbacks.HELDD.SetColorKey;
- }
-
- if (This->devicetype!=2)
- {
- Flags = This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags;
- if (Flags & DDHAL_CB32_CANCREATESURFACE)
- {
- This->mDdCanCreateSurface.CanCreateSurface = This->mCallbacks.HALDD.CanCreateSurface;
- }
-
- if (Flags & DDHAL_CB32_CREATEPALETTE)
- {
- This->mDdCreatePalette.CreatePalette = This->mCallbacks.HALDD.CreatePalette;
- }
-
- if (Flags & DDHAL_CB32_CREATESURFACE)
- {
- This->mDdCreateSurface.CreateSurface = This->mCallbacks.HALDD.CreateSurface;
- }
-
- if (Flags & DDHAL_CB32_DESTROYDRIVER)
- {
- This->mDdDestroyDriver.DestroyDriver = This->mCallbacks.HALDD.DestroyDriver;
- }
-
- if (Flags & DDHAL_CB32_FLIPTOGDISURFACE)
- {
- This->mDdFlipToGDISurface.FlipToGDISurface = This->mCallbacks.HALDD.FlipToGDISurface;
- }
-
- if (Flags & DDHAL_CB32_GETSCANLINE)
- {
- This->mDdGetScanLine.GetScanLine = This->mCallbacks.HALDD.GetScanLine;
- }
-
- if (Flags & DDHAL_CB32_SETEXCLUSIVEMODE)
- {
- This->mDdSetExclusiveMode.SetExclusiveMode = This->mCallbacks.HALDD.SetExclusiveMode;
- }
-
- if (Flags & DDHAL_CB32_SETMODE)
- {
- This->mDdSetMode.SetMode = This->mCallbacks.HALDD.SetMode;
- }
-
- if (Flags & DDHAL_CB32_WAITFORVERTICALBLANK)
- {
- This->mDdWaitForVerticalBlank.WaitForVerticalBlank = This->mCallbacks.HALDD.WaitForVerticalBlank;
- }
-
- if (Flags & DDHAL_CB32_SETCOLORKEY)
- {
- // This->mDdSetColorKey.SetColorKey = This->mCallbacks.HALDD.SetColorKey;
- }
- }
-
- /*
- Setup HEL or HAL for SURFACE CALLBACK
- */
-
- // FIXME
-
- /* Setup calback struct so we do not need refill same info again */
- This->mDdCreateSurface.lpDD = &This->mDDrawGlobal;
- This->mDdCanCreateSurface.lpDD = &This->mDDrawGlobal;
-
+ /* Fill some basic info for Surface */
+ This->lpLcl->lpGbl->dwFlags = This->lpLcl->lpGbl->dwFlags | dwFlags | DDRAWI_ATTACHEDTODESKTOP;
+ This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
+ This->lpLcl->hDD = ddgbl.hDD;
+
+ ddgbl.rectDevice.top = 0;
+ ddgbl.rectDevice.left = 0;
+ ddgbl.rectDevice.right = ddgbl.vmiData.dwDisplayWidth;
+ ddgbl.rectDevice.bottom = ddgbl.vmiData.dwDisplayHeight;
+
+ ddgbl.rectDesktop.top = 0;
+ ddgbl.rectDesktop.left = 0;
+ ddgbl.rectDesktop.right = ddgbl.vmiData.dwDisplayWidth;
+ ddgbl.rectDesktop.bottom = ddgbl.vmiData.dwDisplayHeight;
+
+ ddgbl.dwMonitorFrequency = GetDeviceCaps(GetWindowDC(NULL),VREFRESH);
+ ddgbl.lpModeInfo->dwWidth = ddgbl.vmiData.dwDisplayWidth;
+ ddgbl.lpModeInfo->dwHeight = ddgbl.vmiData.dwDisplayHeight;
+ ddgbl.lpModeInfo->dwBPP = ddgbl.vmiData.ddpfDisplay.dwRGBBitCount;
+ ddgbl.lpModeInfo->lPitch = ddgbl.vmiData.lDisplayPitch;
+ ddgbl.lpModeInfo->wRefreshRate = ddgbl.dwMonitorFrequency;
+ ddgbl.lpModeInfo->dwRBitMask = ddgbl.vmiData.ddpfDisplay.dwRBitMask;
+ ddgbl.lpModeInfo->dwGBitMask = ddgbl.vmiData.ddpfDisplay.dwGBitMask;
+ ddgbl.lpModeInfo->dwBBitMask = ddgbl.vmiData.ddpfDisplay.dwBBitMask;
+ ddgbl.lpModeInfo->dwAlphaBitMask = ddgbl.vmiData.ddpfDisplay.dwRGBAlphaBitMask;
+
return DD_OK;
}
-HRESULT WINAPI
-StartDirectDrawHal(LPDIRECTDRAW* iface)
+HRESULT WINAPI
+StartDirectDrawHel(LPDIRECTDRAW iface, BOOL reenable)
{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
+ 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;
+
+ This->lpLcl->lpGbl->lpDDCBtmp->HELDD.dwFlags = DDHAL_CB32_CANCREATESURFACE |
+ DDHAL_CB32_CREATESURFACE |
+ DDHAL_CB32_CREATEPALETTE |
+ DDHAL_CB32_DESTROYDRIVER |
+ DDHAL_CB32_FLIPTOGDISURFACE |
+ DDHAL_CB32_GETSCANLINE |
+ DDHAL_CB32_SETCOLORKEY |
+ DDHAL_CB32_SETEXCLUSIVEMODE |
+ DDHAL_CB32_SETMODE |
+ DDHAL_CB32_WAITFORVERTICALBLANK ;
+
+ This->lpLcl->lpGbl->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 |
+ DDHAL_SURFCB32_BLT |
+ DDHAL_SURFCB32_DESTROYSURFACE |
+ DDHAL_SURFCB32_FLIP |
+ DDHAL_SURFCB32_GETBLTSTATUS |
+ DDHAL_SURFCB32_GETFLIPSTATUS |
+ DDHAL_SURFCB32_LOCK |
+ DDHAL_SURFCB32_RESERVED4 |
+ DDHAL_SURFCB32_SETCLIPLIST |
+ DDHAL_SURFCB32_SETCOLORKEY |
+ DDHAL_SURFCB32_SETOVERLAYPOSITION |
+ DDHAL_SURFCB32_SETPALETTE |
+ DDHAL_SURFCB32_UNLOCK |
+ DDHAL_SURFCB32_UPDATEOVERLAY;
+
+ This->lpLcl->lpGbl->lpDDCBtmp->HELDDSurface.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDSurface);
- /* HAL Startup process */
- BOOL newmode = FALSE;
-
+ /*
+ This->lpLcl->lpDDCB->HELDDPalette.DestroyPalette = HelDdPalDestroyPalette;
+ This->lpLcl->lpDDCB->HELDDPalette.SetEntries = HelDdPalSetEntries;
+ This->lpLcl->lpDDCB->HELDDPalette.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDPalette);
+ */
- /*
- Startup DX HAL step one of three
+ /*
+ This->lpLcl->lpDDCB->HELDDExeBuf.CanCreateExecuteBuffer = HelDdExeCanCreateExecuteBuffer;
+ This->lpLcl->lpDDCB->HELDDExeBuf.CreateExecuteBuffer = HelDdExeCreateExecuteBuffer;
+ This->lpLcl->lpDDCB->HELDDExeBuf.DestroyExecuteBuffer = HelDdExeDestroyExecuteBuffer;
+ This->lpLcl->lpDDCB->HELDDExeBuf.LockExecuteBuffer = HelDdExeLockExecuteBuffer;
+ This->lpLcl->lpDDCB->HELDDExeBuf.UnlockExecuteBuffer = HelDdExeUnlockExecuteBuffer;
*/
- if (!DdCreateDirectDrawObject(&This->mDDrawGlobal, This->hdc))
+
+ return DD_OK;
+}
+
+
+HRESULT WINAPI
+StartDirectDrawHal(LPDIRECTDRAW iface, BOOL reenable)
+{
+ LPDWORD mpFourCC = NULL;
+ DDHALINFO mHALInfo;
+ BOOL newmode = FALSE;
+ LPDDSURFACEDESC mpTextures;
+ D3DHAL_CALLBACKS mD3dCallbacks;
+ D3DHAL_GLOBALDRIVERDATA mD3dDriverData;
+ DDHAL_DDEXEBUFCALLBACKS mD3dBufferCallbacks;
+ LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
+ DDHAL_GETDRIVERINFODATA DdGetDriverInfo = { 0 };
+
+ DX_WINDBG_trace();
+
+ RtlZeroMemory(&mHALInfo, sizeof(DDHALINFO));
+ RtlZeroMemory(&mD3dCallbacks, sizeof(D3DHAL_CALLBACKS));
+ RtlZeroMemory(&mD3dDriverData, sizeof(D3DHAL_GLOBALDRIVERDATA));
+ RtlZeroMemory(&mD3dBufferCallbacks, sizeof(DDHAL_DDEXEBUFCALLBACKS));
+
+ if (reenable == FALSE)
+ {
+ if (ddgbl.lpDDCBtmp == NULL)
+ {
+ DxHeapMemAlloc(ddgbl.lpDDCBtmp, sizeof(DDHAL_CALLBACKS));
+ if ( ddgbl.lpDDCBtmp == NULL)
+ {
+ return DD_FALSE;
+ }
+ }
+ }
+ else
+ {
+ RtlZeroMemory(ddgbl.lpDDCBtmp,sizeof(DDHAL_CALLBACKS));
+ }
+
+ /*
+ * Startup DX HAL step one of three
+ */
+ if (!DdCreateDirectDrawObject(This->lpLcl->lpGbl, (HDC)This->lpLcl->hDC))
{
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
return DD_FALSE;
}
-
- // Do not relase HDC it have been map in kernel mode
- // DeleteDC(hdc);
-
- if (!DdReenableDirectDrawObject(&This->mDDrawGlobal, &newmode))
+
+ /* Some card disable the dx after it have been created so
+ * we are force reanble it
+ */
+ if (!DdReenableDirectDrawObject(This->lpLcl->lpGbl, &newmode))
{
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
return DD_FALSE;
}
-
-
- /*
- Startup DX HAL step two of three
- */
- if (!DdQueryDirectDrawObject(&This->mDDrawGlobal,
- &This->mHALInfo,
- &This->mCallbacks.HALDD,
- &This->mCallbacks.HALDDSurface,
- &This->mCallbacks.HALDDPalette,
- &This->mD3dCallbacks,
- &This->mD3dDriverData,
- &This->mD3dBufferCallbacks,
- NULL,
+ if (!DdQueryDirectDrawObject(This->lpLcl->lpGbl,
+ &mHALInfo,
+ &ddgbl.lpDDCBtmp->HALDD,
+ &ddgbl.lpDDCBtmp->HALDDSurface,
+ &ddgbl.lpDDCBtmp->HALDDPalette,
+ &mD3dCallbacks,
+ &mD3dDriverData,
+ &mD3dBufferCallbacks,
NULL,
+ mpFourCC,
NULL))
{
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- // FIXME Close DX fristcall and second call
+ DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX first and second call
return DD_FALSE;
}
- This->mcvmList = This->mHALInfo.vmiData.dwNumHeaps;
- This->mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * This->mcvmList);
- if (This->mpvmList == NULL)
- {
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- // FIXME Close DX fristcall and second call
- return DD_FALSE;
+ /* Alloc mpFourCC */
+ if (This->lpLcl->lpGbl->lpdwFourCC != NULL)
+ {
+ DxHeapMemFree(This->lpLcl->lpGbl->lpdwFourCC);
}
- This->mcFourCC = This->mHALInfo.ddCaps.dwNumFourCCCodes;
- This->mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * This->mcFourCC);
- if (This->mpFourCC == NULL)
+ if (mHALInfo.ddCaps.dwNumFourCCCodes > 0 )
{
- DxHeapMemFree(This->mpvmList);
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- // FIXME Close DX fristcall and second call
- return DD_FALSE;
+
+ DxHeapMemAlloc(mpFourCC, sizeof(DWORD) * (mHALInfo.ddCaps.dwNumFourCCCodes + 2));
+
+ if (mpFourCC == NULL)
+ {
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX first and second call
+ return DD_FALSE;
+ }
}
- This->mcTextures = This->mD3dDriverData.dwNumTextureFormats;
- This->mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * This->mcTextures);
- if (This->mpTextures == NULL)
- {
- DxHeapMemFree( This->mpFourCC);
- DxHeapMemFree( This->mpvmList);
- DxHeapMemFree( This->mpModeInfos);
- DeleteDC(This->hdc);
- // FIXME Close DX fristcall and second call
- return DD_FALSE;
+ /* Alloc mpTextures */
+#if 0
+ DX_STUB_str("1 Here\n");
+
+ if (This->lpLcl->lpGbl->texture != NULL)
+ {
+ DxHeapMemFree(This->lpLcl->lpGbl->texture;
+ }
+
+ mpTextures = NULL;
+ if (mD3dDriverData.dwNumTextureFormats > 0)
+ {
+ mpTextures = (DDSURFACEDESC*) DxHeapMemAlloc(sizeof(DDSURFACEDESC) * mD3dDriverData.dwNumTextureFormats);
+ if (mpTextures == NULL)
+ {
+ DxHeapMemFree(mpFourCC);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX first and second call
+ }
}
- This->mHALInfo.vmiData.pvmList = This->mpvmList;
- This->mHALInfo.lpdwFourCC = This->mpFourCC;
- This->mD3dDriverData.lpTextureFormats = (DDSURFACEDESC*) This->mpTextures;
+ DX_STUB_str("2 Here\n");
+#else
+ mpTextures = NULL;
+#endif
+
+
+ /* Get all basic data from the driver */
if (!DdQueryDirectDrawObject(
- &This->mDDrawGlobal,
- &This->mHALInfo,
- &This->mCallbacks.HALDD,
- &This->mCallbacks.HALDDSurface,
- &This->mCallbacks.HALDDPalette,
- &This->mD3dCallbacks,
- &This->mD3dDriverData,
- &This->mCallbacks.HALDDExeBuf,
- (DDSURFACEDESC*)This->mpTextures,
- This->mpFourCC,
- This->mpvmList))
-
+ This->lpLcl->lpGbl,
+ &mHALInfo,
+ &ddgbl.lpDDCBtmp->HALDD,
+ &ddgbl.lpDDCBtmp->HALDDSurface,
+ &ddgbl.lpDDCBtmp->HALDDPalette,
+ &mD3dCallbacks,
+ &mD3dDriverData,
+ &ddgbl.lpDDCBtmp->HALDDExeBuf,
+ (DDSURFACEDESC*)mpTextures,
+ mpFourCC,
+ NULL))
{
- DxHeapMemFree(This->mpTextures);
- DxHeapMemFree(This->mpFourCC);
- DxHeapMemFree(This->mpvmList);
- DxHeapMemFree(This->mpModeInfos);
- DeleteDC(This->hdc);
- // FIXME Close DX fristcall and second call
- return DD_FALSE;
+ DxHeapMemFree(mpFourCC);
+ DxHeapMemFree(mpTextures);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX first and second call
+ return DD_FALSE;
}
- /*
- Copy over from HalInfo to DirectDrawGlobal
- */
-
- // this is wrong, cDriverName need be in ASC code not UNICODE
- //memcpy(mDDrawGlobal.cDriverName, mDisplayAdapter, sizeof(wchar)*MAX_DRIVER_NAME);
-
- memcpy(&This->mDDrawGlobal.vmiData, &This->mHALInfo.vmiData,sizeof(VIDMEMINFO));
- memcpy(&This->mDDrawGlobal.ddCaps, &This->mHALInfo.ddCaps,sizeof(DDCORECAPS));
-
- This->mHALInfo.dwNumModes = This->mcModeInfos;
- This->mHALInfo.lpModeInfo = This->mpModeInfos;
- This->mHALInfo.dwMonitorFrequency = This->mpModeInfos[0].wRefreshRate;
-
- This->mDDrawGlobal.dwMonitorFrequency = This->mHALInfo.dwMonitorFrequency;
- This->mDDrawGlobal.dwModeIndex = This->mHALInfo.dwModeIndex;
- This->mDDrawGlobal.dwNumModes = This->mHALInfo.dwNumModes;
- This->mDDrawGlobal.lpModeInfo = This->mHALInfo.lpModeInfo;
- This->mDDrawGlobal.hInstance = This->mHALInfo.hInstance;
-
- This->mDDrawGlobal.lp16DD = &This->mDDrawGlobal;
-
- //DeleteDC(This->hdc);
-
- DDHAL_GETDRIVERINFODATA DriverInfo;
- memset(&DriverInfo,0, sizeof(DDHAL_GETDRIVERINFODATA));
- DriverInfo.dwSize = sizeof(DDHAL_GETDRIVERINFODATA);
- DriverInfo.dwContext = This->mDDrawGlobal.hDD;
-
- /* Get the MiscellaneousCallbacks */
- DriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
- DriverInfo.lpvData = &This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS);
- This->mHALInfo.GetDriverInfo(&DriverInfo);
-
- if (This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY)
- {
- This->mDdGetDriverMemory.GetAvailDriverMemory = This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.GetAvailDriverMemory;
- }
-
- /* Setup global surface */
- /*This->mPrimaryGlobal.dwGlobalFlags = DDRAWISURFGBL_ISGDISURFACE;
- This->mPrimaryGlobal.lpDD = &This->mDDrawGlobal;
- This->mPrimaryGlobal.lpDDHandle = &This->mDDrawGlobal;
- This->mPrimaryGlobal.wWidth = (WORD)This->mpModeInfos[0].dwWidth;
- This->mPrimaryGlobal.wHeight = (WORD)This->mpModeInfos[0].dwHeight;
- This->mPrimaryGlobal.lPitch = This->mpModeInfos[0].lPitch;*/
-
- /* FIXME free it in cleanup */
- This->mDDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)DxHeapMemAlloc(sizeof(DDRAWI_DDRAWSURFACE_INT));
- return DD_OK;
-}
+ memcpy(&ddgbl.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
-HRESULT WINAPI
-StartDirectDrawHel(LPDIRECTDRAW* iface)
-{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
-
- This->HELMemoryAvilable = HEL_GRAPHIC_MEMORY_MAX;
-
- This->mCallbacks.HELDD.dwFlags = DDHAL_CB32_DESTROYDRIVER;
- This->mCallbacks.HELDD.DestroyDriver = HelDdDestroyDriver;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CREATESURFACE;
- This->mCallbacks.HELDD.CreateSurface = HelDdCreateSurface;
-
- // DDHAL_CB32_
- //This->mCallbacks.HELDD.SetColorKey = HelDdSetColorKey;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_SETMODE;
- This->mCallbacks.HELDD.SetMode = HelDdSetMode;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_WAITFORVERTICALBLANK;
- This->mCallbacks.HELDD.WaitForVerticalBlank = HelDdWaitForVerticalBlank;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CANCREATESURFACE;
- This->mCallbacks.HELDD.CanCreateSurface = HelDdCanCreateSurface;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_CREATEPALETTE;
- This->mCallbacks.HELDD.CreatePalette = HelDdCreatePalette;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_GETSCANLINE;
- This->mCallbacks.HELDD.GetScanLine = HelDdGetScanLine;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_SETEXCLUSIVEMODE;
- This->mCallbacks.HELDD.SetExclusiveMode = HelDdSetExclusiveMode;
-
- This->mCallbacks.HELDD.dwFlags += DDHAL_CB32_FLIPTOGDISURFACE;
- This->mCallbacks.HELDD.FlipToGDISurface = HelDdFlipToGDISurface;
-
- return DD_OK;
-}
-HRESULT
-WINAPI
-Create_DirectDraw (LPGUID pGUID,
- LPDIRECTDRAW* pIface,
- REFIID id,
- BOOL ex)
-{
- IDirectDrawImpl* This = (IDirectDrawImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectDrawImpl));
-
- DX_WINDBG_trace();
-
- if (This == NULL)
- {
- return E_OUTOFMEMORY;
- }
-
- ZeroMemory(This,sizeof(IDirectDrawImpl));
-
- This->lpVtbl = &DirectDraw7_Vtable;
- This->lpVtbl_v1 = &DDRAW_IDirectDraw_VTable;
- This->lpVtbl_v2 = &DDRAW_IDirectDraw2_VTable;
- This->lpVtbl_v4 = &DDRAW_IDirectDraw4_VTable;
-
- *pIface = (LPDIRECTDRAW)This;
-
- This->devicetype = 0;
-
- if (pGUID == (LPGUID) DDCREATE_HARDWAREONLY)
- {
- This->devicetype = 1; /* hal only */
- }
-
- if (pGUID == (LPGUID) DDCREATE_EMULATIONONLY)
- {
- This->devicetype = 2; /* hel only */
- }
-
- if(This->lpVtbl->QueryInterface ((LPDIRECTDRAW7)This, id, (void**)&pIface) != S_OK)
- {
- return DDERR_INVALIDPARAMS;
- }
-
- if (StartDirectDraw((LPDIRECTDRAW*)This) == DD_OK);
+ memcpy(&ddgbl.ddCaps, &mHALInfo.ddCaps,sizeof(DDCORECAPS));
+
+ This->lpLcl->lpGbl->dwNumFourCC = mHALInfo.ddCaps.dwNumFourCCCodes;
+ This->lpLcl->lpGbl->lpdwFourCC = mpFourCC;
+ // This->lpLcl->lpGbl->dwMonitorFrequency = mHALInfo.dwMonitorFrequency; // 0
+ This->lpLcl->lpGbl->dwModeIndex = mHALInfo.dwModeIndex;
+ // This->lpLcl->lpGbl->dwNumModes = mHALInfo.dwNumModes;
+ // This->lpLcl->lpGbl->lpModeInfo = mHALInfo.lpModeInfo;
+
+ /* FIXME convert mpTextures to DDHALMODEINFO */
+ // DxHeapMemFree( mpTextures);
+
+ /* FIXME D3D setup mD3dCallbacks and mD3dDriverData */
+
+
+
+
+ if (mHALInfo.dwFlags & DDHALINFO_GETDRIVERINFOSET)
+ {
+ DdGetDriverInfo.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
+ DdGetDriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
+ DdGetDriverInfo.lpvData = (PVOID)&ddgbl.lpDDCBtmp->HALDDMiscellaneous;
+ DdGetDriverInfo.dwExpectedSize = sizeof (DDHAL_DDMISCELLANEOUSCALLBACKS);
+
+ if(mHALInfo.GetDriverInfo (&DdGetDriverInfo) == DDHAL_DRIVER_NOTHANDLED || DdGetDriverInfo.ddRVal != DD_OK)
+ {
+ DxHeapMemFree(mpFourCC);
+ DxHeapMemFree(mpTextures);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
+ }
+
+ RtlZeroMemory(&DdGetDriverInfo, sizeof(DDHAL_GETDRIVERINFODATA));
+ DdGetDriverInfo.dwSize = sizeof (DDHAL_GETDRIVERINFODATA);
+ DdGetDriverInfo.guidInfo = GUID_Miscellaneous2Callbacks;
+
+ /* FIXME
+ DdGetDriverInfo.lpvData = (PVOID)&ddgbl.lpDDCBtmp->HALDDMiscellaneous;
+ DdGetDriverInfo.dwExpectedSize = sizeof (DDHAL_DDMISCELLANEOUS2CALLBACKS);
+
+ if(mHALInfo.GetDriverInfo (&DdGetDriverInfo) == DDHAL_DRIVER_NOTHANDLED || DdGetDriverInfo.ddRVal != DD_OK)
+ {
+ DxHeapMemFree(mpFourCC);
+ DxHeapMemFree(mpTextures);
+ DxHeapMemFree(ddgbl.lpDDCBtmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
+ }
+ DD_MISCELLANEOUS2CALLBACKS
+ {
+ DWORD dwSize;
+ DWORD dwFlags;
+ PDD_ALPHABLT AlphaBlt; // unsuse acoding msdn and always set to NULL
+ PDD_CREATESURFACEEX CreateSurfaceEx;
+ PDD_GETDRIVERSTATE GetDriverState;
+ PDD_DESTROYDDLOCAL DestroyDDLocal;
+ }
+ DDHAL_MISC2CB32_CREATESURFACEEX
+ DDHAL_MISC2CB32_GETDRIVERSTATE
+ DDHAL_MISC2CB32_DESTROYDDLOCAL
+ */
+ }
+
+ if (mHALInfo.dwFlags & DDHALINFO_GETDRIVERINFO2)
{
- return This->lpVtbl->Initialize ((LPDIRECTDRAW7)This, pGUID);
- }
+ This->lpLcl->lpGbl->dwFlags = This->lpLcl->lpGbl->dwFlags | DDRAWI_DRIVERINFO2;
+ }
- return DDERR_INVALIDPARAMS;
-}
+ return DD_OK;
+}
projects / reactos.git / blobdiff