HRESULT Hal_DirectDraw_Initialize (LPDIRECTDRAW7 iface)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
-
- /* point to it self */
- This->DirectDrawGlobal.lp16DD = &This->DirectDrawGlobal;
- /* get the object */
- if(!DdCreateDirectDrawObject (&This->DirectDrawGlobal, (HDC)This->DirectDrawGlobal.lpExclusiveOwner->hDC ))
- return DDERR_INVALIDPARAMS;
-
- /* alloc all the space */
- This->DirectDrawGlobal.lpDDCBtmp = (LPDDHAL_CALLBACKS)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DDHAL_CALLBACKS));
+ /* HAL Startup process */
+ DEVMODE devmode;
+ HBITMAP hbmp;
+ const UINT bmiSize = sizeof(BITMAPINFOHEADER) + 0x10;
+ UCHAR *pbmiData;
+ BITMAPINFO *pbmi;
+ DWORD *pMasks;
+ BOOL newmode = FALSE;
+
+ /*
+ Get Display mode res and caps
+ We need fill the mDDrawGlobal
+ vmidata struct right
+
+ this code is from Steffen Schulze
+ 1. Add the mpModeInfos to inisate
+ */
+ This->mcModeInfos = 1;
+ This->mpModeInfos = (DDHALMODEINFO*) DxHeapMemAlloc(This->mcModeInfos * sizeof(DDHALMODEINFO));
+
+ if (This->mpModeInfos == NULL)
+ {
+ return DD_FALSE;
+ }
- This->DirectDrawGlobal.lpD3DHALCallbacks = (ULONG_PTR)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
- sizeof(D3DHAL_CALLBACKS));
+ EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &devmode);
- This->DirectDrawGlobal.lpD3DGlobalDriverData = (ULONG_PTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(D3DHAL_GLOBALDRIVERDATA));
-
- /* Fill in some info */
- This->HalInfo.lpD3DGlobalDriverData = This->DirectDrawGlobal.lpD3DGlobalDriverData;
- This->HalInfo.lpD3DHALCallbacks = This->DirectDrawGlobal.lpD3DHALCallbacks;
- This->HalInfo.lpDDCallbacks = &This->DirectDrawGlobal.lpDDCBtmp->HALDD;
- This->HalInfo.lpDDExeBufCallbacks = &This->DirectDrawGlobal.lpDDCBtmp->HALDDExeBuf;
- This->HalInfo.lpDDPaletteCallbacks = &This->DirectDrawGlobal.lpDDCBtmp->HALDDPalette;
- This->HalInfo.lpDDSurfaceCallbacks = &This->DirectDrawGlobal.lpDDCBtmp->HALDDSurface;
-
- /* query all kinds of infos from the driver */
- if(!DdQueryDirectDrawObject (
- &This->DirectDrawGlobal,
- &This->HalInfo,
- This->HalInfo.lpDDCallbacks,
- This->HalInfo.lpDDSurfaceCallbacks,
- This->HalInfo.lpDDPaletteCallbacks,
- (LPD3DHAL_CALLBACKS)This->DirectDrawGlobal.lpD3DHALCallbacks,
- (LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData,
- This->HalInfo.lpDDExeBufCallbacks,
- NULL,
- NULL,
- NULL ))
- {
- return DD_FALSE;
+ 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;
+
+ /*
+ Create HDC
+ we need it for doing the Call to GdiEntry1
+ */
+ This->hdc = CreateDCW(L"DISPLAY",L"DISPLAY",NULL,NULL);
+
+ if (This->hdc == NULL)
+ {
+ return DD_FALSE;
}
-
- This->HalInfo.vmiData.pvmList = (LPVIDMEM) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(VIDMEM) * This->HalInfo.vmiData.dwNumHeaps);
-
- This->DirectDrawGlobal.lpdwFourCC = (DWORD *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DWORD) * This->HalInfo.ddCaps.dwNumFourCCCodes);
- ((LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData)->lpTextureFormats =
- (LPDDSURFACEDESC) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DDSURFACEDESC) *
- ((LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData)->dwNumTextureFormats);
-
- if(!DdQueryDirectDrawObject (
- &This->DirectDrawGlobal,
- &This->HalInfo,
- This->HalInfo.lpDDCallbacks,
- This->HalInfo.lpDDSurfaceCallbacks,
- This->HalInfo.lpDDPaletteCallbacks,
- (LPD3DHAL_CALLBACKS)This->DirectDrawGlobal.lpD3DHALCallbacks,
- (LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData,
- This->HalInfo.lpDDExeBufCallbacks,
- ((LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData)->lpTextureFormats,
- This->DirectDrawGlobal.lpdwFourCC,
- This->HalInfo.vmiData.pvmList
- ))
- {
- return DD_FALSE;
+
+ /* Do not release HDC it is mapen in kernel mode
+ we can only release it at exit of ddraw.dll
+ */
+
+ /*
+ Dectect RGB bit mask
+ this code is from Steffen Schulze
+ why it need I do not know yet but it
+ will allown us to create any type of
+ surface later
+ */
+
+ hbmp = CreateCompatibleBitmap(This->hdc, 1, 1);
+ if (hbmp==NULL)
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ return DD_FALSE;
}
-
- /* Copy HalInfo to DirectDrawGlobal (Not complete)*/
- RtlCopyMemory(&This->DirectDrawGlobal.vmiData,&This->HalInfo.vmiData,sizeof(VIDMEMINFO));
- RtlCopyMemory(&This->DirectDrawGlobal.ddCaps,&This->HalInfo.ddCaps,sizeof(DDCORECAPS));
- This->DirectDrawGlobal.dwMonitorFrequency = This->HalInfo.dwMonitorFrequency;
-
- This->DirectDrawGlobal.dwModeIndex = This->HalInfo.dwModeIndex;
- This->DirectDrawGlobal.dwNumModes = This->HalInfo.dwNumModes;
- This->DirectDrawGlobal.lpModeInfo = This->HalInfo.lpModeInfo;
-
- /* Unsure which of these two for lpPDevice
- This->DirectDrawGlobal.dwPDevice = This->HalInfo.lpPDevice;
- This->lpDriverHandle = This->HalInfo.lpPDevice;
- */
- This->DirectDrawGlobal.hInstance = This->HalInfo.hInstance;
- RtlCopyMemory(&This->DirectDrawGlobal.lpDDCBtmp->HALDDExeBuf,
- &This->HalInfo.lpDDExeBufCallbacks,sizeof(DDHAL_DDEXEBUFCALLBACKS));
-
- /************************************************************************/
- /* Set up the rest of the callbacks all callbacks we get back from */
- /* gdi32.dll is user mode */
- /************************************************************************/
-
- /* Todo add a check see if HalInfo.GetDriverInfo is supported or not */
- /* Do not trust msdn what it say about dwContext it is not in use for
- windows nt, it is in use for all os, and it always pont to
- DirectDrawGlobal.hDD */
-
- /* FIXME add all callback that have been commect out to gpl */
- /* FIXME free the memmor that being alloc when ddraw.dll exists */
- /* FIXME add check for DriverInfo if the handle or not */
-
- DDHAL_GETDRIVERINFODATA DriverInfo;
- memset(&DriverInfo,0, sizeof(DDHAL_GETDRIVERINFODATA));
- DriverInfo.dwSize = sizeof(DDHAL_GETDRIVERINFODATA);
- DriverInfo.dwContext = This->DirectDrawGlobal.hDD;
-
- /* Get ColorControlCallbacks */
- DriverInfo.guidInfo = GUID_ColorControlCallbacks;
- DriverInfo.lpvData = &This->DirectDrawGlobal.lpDDCBtmp->HALDDColorControl;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDCOLORCONTROLCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the GUID_D3DCallbacks callback */
- /* Problem with include files
- DDHAL_DDMISCELLANEOUSCALLBACKS misc;
- DriverInfo.guidInfo = GUID_D3DCallbacks;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);*/
-
- /* Get the D3DCallbacks2 */
- This->DirectDrawGlobal.lpD3DHALCallbacks2 = (ULONG_PTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(D3DHAL_CALLBACKS2));
- DriverInfo.guidInfo = GUID_D3DCallbacks2;
- DriverInfo.lpvData = (PVOID)This->DirectDrawGlobal.lpD3DHALCallbacks2;
- DriverInfo.dwExpectedSize = sizeof(D3DHAL_CALLBACKS2);
- This->HalInfo.GetDriverInfo(&DriverInfo);
+
+ pbmiData = (UCHAR *) DxHeapMemAlloc(bmiSize);
+ pbmi = (BITMAPINFO*)pbmiData;
-
- /* Get the D3DCallbacks3 */
- This->DirectDrawGlobal.lpD3DHALCallbacks = (ULONG_PTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(D3DHAL_CALLBACKS3));
- DriverInfo.guidInfo = GUID_D3DCallbacks3;
- DriverInfo.lpvData = (PVOID)This->DirectDrawGlobal.lpD3DHALCallbacks;
- DriverInfo.dwExpectedSize = sizeof(D3DHAL_CALLBACKS3);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the misc callback */
- /* Problem with include files
- DriverInfo.guidInfo = GUID_D3DCaps;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
- */
+ if (pbmiData==NULL)
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ return DDERR_UNSUPPORTED;
+ }
- /* Get the D3DExtendedCaps */
-
- This->DirectDrawGlobal.lpD3DExtendedCaps = (ULONG_PTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(D3DHAL_D3DEXTENDEDCAPS));
- DriverInfo.guidInfo = GUID_D3DExtendedCaps;
- DriverInfo.lpvData = (PVOID) This->DirectDrawGlobal.lpD3DExtendedCaps;
- DriverInfo.dwExpectedSize = sizeof(D3DHAL_D3DEXTENDEDCAPS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the D3DParseUnknownCommandCallback */
- /* D3dDrawPrimitives2 callback where should it be fill in
- DriverInfo.guidInfo = GUID_D3DParseUnknownCommandCallback;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
- */
+ pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ pbmi->bmiHeader.biBitCount = (WORD)devmode.dmBitsPerPel;
+ pbmi->bmiHeader.biCompression = BI_BITFIELDS;
+ pbmi->bmiHeader.biWidth = 1;
+ pbmi->bmiHeader.biHeight = 1;
- /* Get the GetHeapAlignment */
- /* where should it be fill in
- DriverInfo.guidInfo = GUID_GetHeapAlignment;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
- */
-
- /* Get the KernelCallbacks */
- DriverInfo.guidInfo = GUID_KernelCallbacks;
- DriverInfo.lpvData = &This->DirectDrawGlobal.lpDDCBtmp->HALDDKernel;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDKERNELCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the KernelCaps */
- This->DirectDrawGlobal.lpDDKernelCaps = (LPDDKERNELCAPS)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DDHAL_DDKERNELCALLBACKS));
- DriverInfo.guidInfo = GUID_KernelCaps;
- DriverInfo.lpvData = (PVOID) This->DirectDrawGlobal.lpDDKernelCaps;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDKERNELCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the MiscellaneousCallbacks */
- DriverInfo.guidInfo = GUID_MiscellaneousCallbacks;
- DriverInfo.lpvData = &This->DirectDrawGlobal.lpDDCBtmp->HALDDMiscellaneous;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the Miscellaneous2Callbacks */
- /* Not in the DDRAWI_DIRECTDRAW_GBL we map it up as private
- Contain CreatesurfaceEx and other nice callbacks */
- DriverInfo.guidInfo = GUID_Miscellaneous2Callbacks;
- DriverInfo.lpvData = &This->Misc2Callback;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the MotionCompCallbacks */
- DriverInfo.guidInfo = GUID_MotionCompCallbacks;
- DriverInfo.lpvData = &This->DirectDrawGlobal.lpDDCBtmp->HALDDMotionComp;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDMOTIONCOMPCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the NonLocalVidMemCaps */
- This->DirectDrawGlobal.lpddNLVCaps = (LPDDNONLOCALVIDMEMCAPS)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DDNONLOCALVIDMEMCAPS));
- DriverInfo.guidInfo = GUID_NonLocalVidMemCaps;
- DriverInfo.lpvData = (PVOID)This->DirectDrawGlobal.lpddNLVCaps;
- DriverInfo.dwExpectedSize = sizeof(DDNONLOCALVIDMEMCAPS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the NTCallbacks */
- /* Fill in wher
- DriverInfo.guidInfo = GUID_NTCallbacks;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
+ 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];
+
+ DxHeapMemFree(pbmiData);
+
+ /*
+ prepare start up the DX Draw HAL interface now
*/
-
- /* Get the NTPrivateDriverCaps */
- /* Fill in wher
- DriverInfo.guidInfo = GUID_NTPrivateDriverCaps;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
+
+ memset(&This->mDDrawGlobal, 0, sizeof(DDRAWI_DIRECTDRAW_GBL));
+ memset(&This->mHALInfo, 0, sizeof(DDHALINFO));
+ memset(&This->mCallbacks, 0, sizeof(DDHAL_CALLBACKS));
+
+ /*
+ Startup DX HAL step one of three
*/
-
- /* Get the UpdateNonLocalHeap */
- /* Fill in where
- DriverInfo.guidInfo = GUID_UpdateNonLocalHeap;
- DriverInfo.lpvData = &misc;
- DriverInfo.dwExpectedSize = sizeof();
- This->HalInfo.GetDriverInfo( &DriverInfo);
+ if (!DdCreateDirectDrawObject(&This->mDDrawGlobal, This->hdc))
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ return DD_FALSE;
+ }
+
+ // Do not relase HDC it have been map in kernel mode
+ // DeleteDC(hdc);
+
+ if (!DdReenableDirectDrawObject(&This->mDDrawGlobal, &newmode))
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ return DD_FALSE;
+ }
+
+ /*
+ Setup the DirectDraw Local
*/
-
- /* Get the VideoPortCallbacks */
- DriverInfo.guidInfo = GUID_VideoPortCallbacks;
- DriverInfo.lpvData = &This->DirectDrawGlobal.lpDDCBtmp->HALDDVideoPort;
- DriverInfo.dwExpectedSize = sizeof(DDHAL_DDVIDEOPORTCALLBACKS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the VideoPortCaps */
- This->DirectDrawGlobal.lpDDVideoPortCaps = (LPDDVIDEOPORTCAPS)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DDVIDEOPORTCAPS));
- DriverInfo.guidInfo = GUID_VideoPortCaps;
- DriverInfo.lpvData = (PVOID)This->DirectDrawGlobal.lpDDVideoPortCaps;
- DriverInfo.dwExpectedSize = sizeof(DDVIDEOPORTCAPS);
- This->HalInfo.GetDriverInfo(&DriverInfo);
-
- /* Get the ZPixelFormats */
- /* take off this it until we figout how lpexluisev should be fild in
- This->DirectDrawGlobal.lpZPixelFormats = (LPDDPIXELFORMAT) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(DDPIXELFORMAT) * This->DirectDrawGlobal.dwNumZPixelFormats);
- DriverInfo.guidInfo = GUID_ZPixelFormats;
- DriverInfo.lpvData = (PVOID)This->DirectDrawGlobal.lpZPixelFormats;
- DriverInfo.dwExpectedSize = sizeof(DDPIXELFORMAT);
- This->HalInfo.GetDriverInfo(&DriverInfo);
- */
-
- /* Setup some info from the callbacks we got */
- DDHAL_GETAVAILDRIVERMEMORYDATA mem;
- mem.lpDD = &This->DirectDrawGlobal;
- This->DirectDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.GetAvailDriverMemory(&mem);
- This->DirectDrawGlobal.ddCaps.dwVidMemFree = mem.dwFree;
- This->DirectDrawGlobal.ddCaps.dwVidMemTotal = mem.dwTotal;
+
+ This->mDDrawLocal.lpDDCB = &This->mCallbacks;
+ This->mDDrawLocal.lpGbl = &This->mDDrawGlobal;
+ This->mDDrawLocal.dwProcessId = GetCurrentProcessId();
- BOOL dummy = TRUE;
- DdReenableDirectDrawObject(&This->DirectDrawGlobal, &dummy);
-
- /* Now all setup for HAL is done */
- return DD_OK;
-}
+ This->mDDrawGlobal.lpDDCBtmp = &This->mCallbacks;
+ This->mDDrawGlobal.lpExclusiveOwner = &This->mDDrawLocal;
+
+ /*
+ Startup DX HAL step two of three
+ */
-HRESULT Hal_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface)
-{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
+ if (!DdQueryDirectDrawObject(&This->mDDrawGlobal,
+ &This->mHALInfo,
+ &This->mCallbacks.HALDD,
+ &This->mCallbacks.HALDDSurface,
+ &This->mCallbacks.HALDDPalette,
+ &This->mD3dCallbacks,
+ &This->mD3dDriverData,
+ &This->mD3dBufferCallbacks,
+ NULL,
+ NULL,
+ NULL))
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
+ }
- DDHAL_SETEXCLUSIVEMODEDATA SetExclusiveMode;
+ This->mcvmList = This->mHALInfo.vmiData.dwNumHeaps;
+ This->mpvmList = (VIDMEM*) DxHeapMemAlloc(sizeof(VIDMEM) * This->mcvmList);
+ if (This->mpvmList == NULL)
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
+ }
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE))
+ This->mcFourCC = This->mHALInfo.ddCaps.dwNumFourCCCodes;
+ This->mpFourCC = (DWORD *) DxHeapMemAlloc(sizeof(DWORD) * This->mcFourCC);
+ if (This->mpFourCC == NULL)
{
- return DDERR_NODRIVERSUPPORT;
+ DxHeapMemFree(This->mpvmList);
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
}
- SetExclusiveMode.lpDD = &This->DirectDrawGlobal;
- SetExclusiveMode.ddRVal = DDERR_NOTPALETTIZED;
- SetExclusiveMode.dwEnterExcl = This->cooperative_level;
+ 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);
+ DeleteObject(hbmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
+ }
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.SetExclusiveMode(&SetExclusiveMode) != DDHAL_DRIVER_HANDLED)
+ This->mHALInfo.vmiData.pvmList = This->mpvmList;
+ This->mHALInfo.lpdwFourCC = This->mpFourCC;
+ This->mD3dDriverData.lpTextureFormats = This->mpTextures;
+
+ if (!DdQueryDirectDrawObject(
+ &This->mDDrawGlobal,
+ &This->mHALInfo,
+ &This->mCallbacks.HALDD,
+ &This->mCallbacks.HALDDSurface,
+ &This->mCallbacks.HALDDPalette,
+ &This->mD3dCallbacks,
+ &This->mD3dDriverData,
+ &This->mCallbacks.HALDDExeBuf,
+ This->mpTextures,
+ This->mpFourCC,
+ This->mpvmList))
+
{
- return DDERR_NODRIVERSUPPORT;
+ DxHeapMemFree(This->mpTextures);
+ DxHeapMemFree(This->mpFourCC);
+ DxHeapMemFree(This->mpvmList);
+ DxHeapMemFree(This->mpModeInfos);
+ DeleteDC(This->hdc);
+ DeleteObject(hbmp);
+ // FIXME Close DX fristcall and second call
+ return DD_FALSE;
}
- return SetExclusiveMode.ddRVal;
-}
+ /*
+ 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));
-VOID Hal_DirectDraw_Release (LPDIRECTDRAW7 iface)
+ 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;
+
+ DeleteObject(hbmp);
+ //DeleteDC(This->hdc);
+
+ return DD_OK;
+}
+
+VOID
+Hal_DirectDraw_Release (LPDIRECTDRAW7 iface)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- DdDeleteDirectDrawObject (&This->DirectDrawGlobal);
+ if (This->mDDrawGlobal.hDD != 0)
+ {
+ DdDeleteDirectDrawObject (&This->mDDrawGlobal);
+ }
+
+ if (This->mpTextures != NULL)
+ {
+ DxHeapMemFree(This->mpTextures);
+ }
+
+ if (This->mpFourCC != NULL)
+ {
+ DxHeapMemFree(This->mpFourCC);
+ }
+
+ if (This->mpvmList != NULL)
+ {
+ DxHeapMemFree(This->mpvmList);
+ }
+
+ if (This->mpModeInfos != NULL)
+ {
+ DxHeapMemFree(This->mpModeInfos);
+ }
+
+ if (This->hdc != NULL)
+ {
+ DeleteDC(This->hdc);
+ }
+
+}
- /*
- if(This->DirectDrawGlobal.lpDDKernelCaps)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpDDKernelCaps);
- if(This->DirectDrawGlobal.lpddNLVCaps)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpddNLVCaps);
- if(This->DirectDrawGlobal.lpDDVideoPortCaps)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpDDVideoPortCaps);
+HRESULT
+Hal_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface)
+{
+ IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- if(This->DirectDrawGlobal.lpdwFourCC)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpdwFourCC);
+ DDHAL_SETEXCLUSIVEMODEDATA SetExclusiveMode;
- if(This->DirectDrawGlobal.lpZPixelFormats)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpZPixelFormats);
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE))
+ {
+ return DDERR_NODRIVERSUPPORT;
+ }
- if(This->HalInfo.vmiData.pvmList)
- HeapFree(GetProcessHeap(), 0, This->HalInfo.vmiData.pvmList);
-
- if(((LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData)->lpTextureFormats)
- HeapFree(GetProcessHeap(), 0, ((LPD3DHAL_GLOBALDRIVERDATA)This->DirectDrawGlobal.lpD3DGlobalDriverData)->lpTextureFormats);
-
- if(This->DirectDrawGlobal.lpDDCBtmp)
- HeapFree(GetProcessHeap(), 0, This->DirectDrawGlobal.lpDDCBtmp);
-
- if(This->DirectDrawGlobal.lpD3DHALCallbacks)
- HeapFree(GetProcessHeap(), 0, (PVOID)This->DirectDrawGlobal.lpD3DHALCallbacks);
-
- if(This->DirectDrawGlobal.lpD3DGlobalDriverData)
- HeapFree(GetProcessHeap(), 0, (PVOID)This->DirectDrawGlobal.lpD3DGlobalDriverData);
- */
+ SetExclusiveMode.lpDD = &This->mDDrawGlobal;
+ SetExclusiveMode.ddRVal = DDERR_NOTPALETTIZED;
+ SetExclusiveMode.dwEnterExcl = This->cooperative_level;
+
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.SetExclusiveMode(&SetExclusiveMode) != DDHAL_DRIVER_HANDLED)
+ {
+ return DDERR_NODRIVERSUPPORT;
+ }
+
+ return SetExclusiveMode.ddRVal;
}
-HRESULT Hal_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps,
+
+HRESULT
+Hal_DirectDraw_GetAvailableVidMem(LPDIRECTDRAW7 iface, LPDDSCAPS2 ddscaps,
LPDWORD total, LPDWORD free)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
DDHAL_GETAVAILDRIVERMEMORYDATA mem;
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY))
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY))
{
return DDERR_NODRIVERSUPPORT;
}
- mem.lpDD = &This->DirectDrawGlobal;
+ mem.lpDD = &This->mDDrawGlobal;
mem.ddRVal = DDERR_NOTPALETTIZED;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.GetAvailDriverMemory(&mem) != DDHAL_DRIVER_HANDLED)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.GetAvailDriverMemory(&mem) != DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
DDHAL_WAITFORVERTICALBLANKDATA WaitVectorData;
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK))
{
return DDERR_NODRIVERSUPPORT;
}
- WaitVectorData.lpDD = &This->DirectDrawGlobal;
+ WaitVectorData.lpDD = &This->mDDrawGlobal;
WaitVectorData.dwFlags = dwFlags;
WaitVectorData.hEvent = (DWORD)h;
WaitVectorData.ddRVal = DDERR_NOTPALETTIZED;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.WaitForVerticalBlank(&WaitVectorData) != DDHAL_DRIVER_HANDLED)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.WaitForVerticalBlank(&WaitVectorData) != DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
DDHAL_GETSCANLINEDATA GetScan;
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_GETSCANLINE))
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_GETSCANLINE))
{
return DDERR_NODRIVERSUPPORT;
}
- GetScan.lpDD = &This->DirectDrawGlobal;
+ GetScan.lpDD = &This->mDDrawGlobal;
GetScan.ddRVal = DDERR_NOTPALETTIZED;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.GetScanLine(&GetScan) != DDHAL_DRIVER_HANDLED)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.GetScanLine(&GetScan) != DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
DDHAL_FLIPTOGDISURFACEDATA FlipGdi;
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_FLIPTOGDISURFACE))
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_FLIPTOGDISURFACE))
{
return DDERR_NODRIVERSUPPORT;
}
- FlipGdi.lpDD = &This->DirectDrawGlobal;
+ FlipGdi.lpDD = &This->mDDrawGlobal;
FlipGdi.ddRVal = DDERR_NOTPALETTIZED;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.FlipToGDISurface(&FlipGdi) != DDHAL_DRIVER_HANDLED)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.FlipToGDISurface(&FlipGdi) != DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
DDHAL_SETMODEDATA mode;
- if (!(This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETMODE))
+ if (!(This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETMODE))
{
return DDERR_NODRIVERSUPPORT;
}
- mode.lpDD = &This->DirectDrawGlobal;
+ mode.lpDD = &This->mDDrawGlobal;
mode.ddRVal = DDERR_NODRIVERSUPPORT;
+
+
// FIXME : add search for which mode.ModeIndex we should use
// FIXME : fill the mode.inexcl;
// FIXME : fill the mode.useRefreshRate;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.SetMode(&mode) != DDHAL_DRIVER_HANDLED)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.SetMode(&mode) != DDHAL_DRIVER_HANDLED)
{
return DDERR_NODRIVERSUPPORT;
}
#include "rosdraw.h"
-
-HRESULT WINAPI Main_DirectDraw_Initialize (LPDIRECTDRAW7 iface, LPGUID lpGUID)
+/*
+ * IMPLEMENT
+ * Status this api is finish and is 100% correct
+ */
+HRESULT
+WINAPI
+Main_DirectDraw_Initialize (LPDIRECTDRAW7 iface, LPGUID lpGUID)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
HRESULT ret;
+
+ if (iface==NULL)
+ {
+ return DDERR_NOTINITIALIZED;
+ }
+
if (This->InitializeDraw == TRUE)
+ {
return DDERR_ALREADYINITIALIZED;
+ }
+ else
+ {
+ This->InitializeDraw = TRUE;
+ }
- This->InitializeDraw = TRUE;
-
- RtlZeroMemory(&This->DirectDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
+ RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
-
/* cObsolete is undoc in msdn it being use in CreateDCA */
- RtlCopyMemory(&This->DirectDrawGlobal.cObsolete,&"DISPLAY",7);
- RtlCopyMemory(&This->DirectDrawGlobal.cDriverName,&"DISPLAY",7);
+ RtlCopyMemory(&This->mDDrawGlobal.cObsolete,&"DISPLAY",7);
+ RtlCopyMemory(&This->mDDrawGlobal.cDriverName,&"DISPLAY",7);
/* Setup the lpExclusiveOwner struct in msdn this struct member is undoc
I am using there name to figout which info it should be fild with
My hardware drv does not support call to SetExusive so I can not
debug it see how it should be fild
+ this part have been move to HAL
*/
-
- This->DirectDrawGlobal.lpExclusiveOwner = &This->ExclusiveOwner;
- memset(&This->ExclusiveOwner, 0, sizeof(DDRAWI_DIRECTDRAW_LCL));
-
- This->DirectDrawGlobal.lpExclusiveOwner->dwProcessId = GetCurrentProcessId();
- This->DirectDrawGlobal.lpExclusiveOwner->hDC = ((ULONG_PTR)GetWindowDC(GetDesktopWindow()));
- This->DirectDrawGlobal.lpExclusiveOwner->hWnd = ((ULONG_PTR)GetDesktopWindow());
- This->DirectDrawGlobal.lpExclusiveOwner->lpGbl = &This->DirectDrawGlobal;
-
- This->Height = GetDeviceCaps((HDC)This->DirectDrawGlobal.lpExclusiveOwner->hDC , VERTRES);
- This->Width = GetDeviceCaps((HDC)This->DirectDrawGlobal.lpExclusiveOwner->hDC , HORZRES);
- This->Bpp = GetDeviceCaps((HDC)This->DirectDrawGlobal.lpExclusiveOwner->hDC , BITSPIXEL);
-
+
+
// call software first
if((ret = Hal_DirectDraw_Initialize (iface)) != DD_OK)
return ret;
// ... then overwrite with hal
if((ret = Hel_DirectDraw_Initialize (iface)) != DD_OK)
return ret;
-
- /* Hack to set right freq */
-
- This->DirectDrawGlobal.dwMonitorFrequency = GetDeviceCaps((HDC)This->DirectDrawGlobal.lpExclusiveOwner->hDC , VREFRESH);
-
+
return DD_OK;
}
+/*
+ * IMPLEMENT
+ * Status this api is finish and is 100% correct
+ */
+ULONG
+WINAPI
+Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface)
+{
+ IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
+ ULONG ref=0;
+
+ if (iface!=NULL)
+ {
+ ref = InterlockedIncrement((PLONG)&This->mDDrawGlobal.dwRefCnt);
+ }
+ return ref;
+}
+
+/*
+ * IMPLEMENT
+ * Status
+ * not finish yet but is working fine
+ * it prevent memmory leaks at exit
+ */
+ULONG
+WINAPI
+Main_DirectDraw_Release (LPDIRECTDRAW7 iface)
+{
+ IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
+ ULONG ref=0;
+
+ if (iface!=NULL)
+ {
+ ref = InterlockedDecrement((PLONG)&This->mDDrawGlobal.dwRefCnt);
+
+ if (ref == 0)
+ {
+ // set resoltion back to the one in registry
+ if(This->cooperative_level & DDSCL_EXCLUSIVE)
+ {
+ ChangeDisplaySettings(NULL, 0);
+ }
+
+ Hal_DirectDraw_Release(iface);
+ //Hel_DirectDraw_Release(iface);
+ RtlZeroMemory(&This->mDDrawGlobal, sizeof(DDRAWI_DIRECTDRAW_GBL));
+ RtlZeroMemory(This, sizeof(IDirectDrawImpl));
+
+ HeapFree(GetProcessHeap(), 0, This);
+ }
+ }
+ return ref;
+}
+
+
+
+
+
+
HRESULT WINAPI Main_DirectDraw_SetCooperativeLevel (LPDIRECTDRAW7 iface, HWND hwnd, DWORD cooplevel)
{
// TODO:
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
// check the parameters
- if ((This->cooperative_level == cooplevel) && ((HWND)This->DirectDrawGlobal.lpExclusiveOwner->hWnd == hwnd))
+ if ((This->cooperative_level == cooplevel) && ((HWND)This->mDDrawGlobal.lpExclusiveOwner->hWnd == hwnd))
return DD_OK;
if (This->cooperative_level)
return DDERR_INVALIDPARAMS;
// set the data
- This->DirectDrawGlobal.lpExclusiveOwner->hWnd = (ULONG_PTR) hwnd;
- This->DirectDrawGlobal.lpExclusiveOwner->hDC = (ULONG_PTR)GetDC(hwnd);
+ This->mDDrawGlobal.lpExclusiveOwner->hWnd = (ULONG_PTR) hwnd;
+ This->mDDrawGlobal.lpExclusiveOwner->hDC = (ULONG_PTR)GetDC(hwnd);
+
+ /* FIXME : fill the mDDrawGlobal.lpExclusiveOwner->dwLocalFlags right */
+ //mDDrawGlobal.lpExclusiveOwner->dwLocalFlags
+
This->cooperative_level = cooplevel;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETEXCLUSIVEMODE)
{
return Hal_DirectDraw_SetCooperativeLevel (iface);
}
DWORD ret;
/* FIXME check the refresrate if it same if it not same do the mode switch */
- if ((This->DirectDrawGlobal.vmiData.dwDisplayHeight == dwHeight) &&
- (This->DirectDrawGlobal.vmiData.dwDisplayWidth == dwWidth) &&
- (This->DirectDrawGlobal.vmiData.ddpfDisplay.dwRGBBitCount == dwBPP))
+ if ((This->mDDrawGlobal.vmiData.dwDisplayHeight == dwHeight) &&
+ (This->mDDrawGlobal.vmiData.dwDisplayWidth == dwWidth) &&
+ (This->mDDrawGlobal.vmiData.ddpfDisplay.dwRGBBitCount == dwBPP))
{
return DD_OK;
}
/* Check use the Hal or Hel for SetMode */
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETMODE)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_SETMODE)
{
ret = Hal_DirectDraw_SetDisplayMode(iface, dwWidth, dwHeight, dwBPP, dwRefreshRate, dwFlags);
}
if (ret == DD_OK)
{
- DdReenableDirectDrawObject(&This->DirectDrawGlobal, &dummy);
+ DdReenableDirectDrawObject(&This->mDDrawGlobal, &dummy);
/* FIXME fill the This->DirectDrawGlobal.vmiData right */
}
return ret;
}
-ULONG WINAPI Main_DirectDraw_AddRef (LPDIRECTDRAW7 iface)
-{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- ULONG ref = InterlockedIncrement((PLONG)&This->DirectDrawGlobal.dwRefCnt);
-
- return ref;
-}
-
-ULONG WINAPI Main_DirectDraw_Release (LPDIRECTDRAW7 iface)
-{
- IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- ULONG ref = InterlockedDecrement((PLONG)&This->DirectDrawGlobal.dwRefCnt);
-
- if (ref == 0)
- {
- // set resoltion back to the one in registry
- if(This->cooperative_level & DDSCL_EXCLUSIVE)
- ChangeDisplaySettings(NULL, 0);
- HeapFree(GetProcessHeap(), 0, This);
- }
- return ref;
-}
-HRESULT WINAPI Main_DirectDraw_QueryInterface (
- LPDIRECTDRAW7 iface, REFIID id, LPVOID *obj )
+/*
+ * IMPLEMENT
+ * Status this api is finish and is 100% correct
+ */
+HRESULT
+WINAPI
+Main_DirectDraw_QueryInterface (LPDIRECTDRAW7 iface,
+ REFIID id,
+ LPVOID *obj)
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
That->lpVtbl = &DirectDrawSurface7_Vtable;
That->lpVtbl_v3 = &DDRAW_IDDS3_Thunk_VTable;
- This->DirectDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
+ This->mDDrawGlobal.dsList = (LPDDRAWI_DDRAWSURFACE_INT)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(DDRAWI_DDRAWSURFACE_INT));
That->owner = (IDirectDrawImpl *)This;
- That->owner->DirectDrawGlobal.dsList->dwIntRefCnt =1;
+ That->owner->mDDrawGlobal.dsList->dwIntRefCnt =1;
/* we alwasy set to use the DirectDrawSurface7_Vtable as internel */
- That->owner->DirectDrawGlobal.dsList->lpVtbl = (PVOID) &DirectDrawSurface7_Vtable;
+ That->owner->mDDrawGlobal.dsList->lpVtbl = (PVOID) &DirectDrawSurface7_Vtable;
*ppSurf = (LPDIRECTDRAWSURFACE7)That;
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_FLIPTOGDISURFACE)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_FLIPTOGDISURFACE)
{
return Hal_DirectDraw_FlipToGDISurface( iface);
}
if (pDriverCaps != NULL)
{
- RtlCopyMemory(pDriverCaps,&This->DirectDrawGlobal.ddCaps,sizeof(DDCORECAPS));
+ RtlCopyMemory(pDriverCaps,&This->mDDrawGlobal.ddCaps,sizeof(DDCORECAPS));
status = DD_OK;
}
if (pHELCaps != NULL)
{
- RtlCopyMemory(pDriverCaps,&This->DirectDrawGlobal.ddHELCaps,sizeof(DDCORECAPS));
+ RtlCopyMemory(pDriverCaps,&This->mDDrawGlobal.ddHELCaps,sizeof(DDCORECAPS));
status = DD_OK;
}
}
pDDSD->dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_PITCH | DDSD_PIXELFORMAT | DDSD_REFRESHRATE | DDSD_WIDTH;
- pDDSD->dwHeight = This->DirectDrawGlobal.vmiData.dwDisplayHeight;
- pDDSD->dwWidth = This->DirectDrawGlobal.vmiData.dwDisplayWidth;
- pDDSD->lPitch = This->DirectDrawGlobal.vmiData.lDisplayPitch;
- pDDSD->dwRefreshRate = This->DirectDrawGlobal.dwMonitorFrequency;
+ pDDSD->dwHeight = This->mDDrawGlobal.vmiData.dwDisplayHeight;
+ pDDSD->dwWidth = This->mDDrawGlobal.vmiData.dwDisplayWidth;
+ pDDSD->lPitch = This->mDDrawGlobal.vmiData.lDisplayPitch;
+ pDDSD->dwRefreshRate = This->mDDrawGlobal.dwMonitorFrequency;
- RtlCopyMemory(&pDDSD->ddpfPixelFormat,&This->DirectDrawGlobal.vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
- RtlCopyMemory(&pDDSD->ddsCaps,&This->DirectDrawGlobal.ddCaps,sizeof(DDCORECAPS));
+ RtlCopyMemory(&pDDSD->ddpfPixelFormat,&This->mDDrawGlobal.vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
+ RtlCopyMemory(&pDDSD->ddsCaps,&This->mDDrawGlobal.ddCaps,sizeof(DDCORECAPS));
/* have not check where I should get hold of this info yet
DWORD dwBackBufferCount;
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_WAITFORVERTICALBLANK)
{
return Hal_DirectDraw_WaitForVerticalBlank( iface, dwFlags, h);
}
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDDMiscellaneous.dwFlags & DDHAL_MISCCB32_GETAVAILDRIVERMEMORY)
{
return Hal_DirectDraw_GetAvailableVidMem (iface,ddscaps,total,free);
}
return DD_FALSE;
}
- *freq = This->DirectDrawGlobal.dwMonitorFrequency;
+ *freq = This->mDDrawGlobal.dwMonitorFrequency;
return DD_OK;
}
{
IDirectDrawImpl* This = (IDirectDrawImpl*)iface;
- if (This->DirectDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_GETSCANLINE)
+ if (This->mDDrawGlobal.lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_GETSCANLINE)
{
return Hal_DirectDraw_GetScanLine( iface, lpdwScanLine);
}
projects / reactos.git / commitdiff