rosdraw.h File Reference

#include <windows.h>
#include <stdio.h>
#include <ddraw.h>
#include <ddrawi.h>
#include <d3dhal.h>
#include <ddrawgdi.h>
#include <pseh/pseh.h>
#include <pseh/pseh2.h>
#include "Ddraw/ddraw.h"
#include "Surface/surface.h"
#include "Clipper/clipper.h"
#include "resource.h"

Include dependency graph for rosdraw.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	DDRAWI_DDCOLORCONTROL_INT
struct	_DDRAWI_DDGAMMACONTROL_INT
struct	_DDRAWI_DDKERNEL_INT
struct	_DDRAWI_DDKERNELSURFACE_INT

Macros
#define	DxHeapMemAlloc(p, m)
#define	DxHeapMemFree(p)
#define	HEL_GRAPHIC_MEMORY_MAX   67108864
#define	DX_STUB
#define	DX_STUB_DD_OK
#define	DX_STUB_str(x)
#define	DX_WINDBG_trace()
#define	DX_WINDBG_trace_res(width, height, bpp, freq)

Typedefs
typedef struct DDRAWI_DDCOLORCONTROL_INT	DDRAWI_DDCOLORCONTROL_INT
typedef struct DDRAWI_DDCOLORCONTROL_INT *	LPDDRAWI_DDCOLORCONTROL_INT
typedef struct _DDRAWI_DDGAMMACONTROL_INT	DDRAWI_DDGAMMACONTROL_INT
typedef struct _DDRAWI_DDGAMMACONTROL_INT *	LPDDRAWI_DDGAMMACONTROL_INT
typedef struct _DDRAWI_DDKERNEL_INT	DDRAWI_KERNEL_INT
typedef struct _DDRAWI_DDKERNEL_INT *	LPDDRAWI_KERNEL_INT
typedef struct _DDRAWI_DDKERNELSURFACE_INT	_DDRAWI_DDKERNELSURFACE_INT
typedef struct _DDRAWI_DDKERNELSURFACE_INT *	LPDDRAWI_DDKERNELSURFACE_INT

Functions
HRESULT WINAPI	StartDirectDraw (LPDIRECTDRAW iface, LPGUID pGUID, BOOL reenable)
HRESULT WINAPI	StartDirectDrawHal (LPDIRECTDRAW iface, BOOL reenable)
HRESULT WINAPI	StartDirectDrawHel (LPDIRECTDRAW iface, BOOL reenable)
HRESULT WINAPI	Create_DirectDraw (LPGUID pGUID, LPDIRECTDRAW *pIface, REFIID id, BOOL ex)
HRESULT WINAPI	ReCreateDirectDraw (LPDIRECTDRAW iface)
HRESULT	Internal_CreateSurface (LPDDRAWI_DIRECTDRAW_INT pDDraw, LPDDSURFACEDESC2 pDDSD, LPDDRAWI_DDRAWSURFACE_INT *ppSurf, IUnknown *pUnkOuter)
HRESULT	Internal_CreatePalette (LPDDRAWI_DIRECTDRAW_INT pDDraw, DWORD dwFlags, LPPALETTEENTRY palent, LPDIRECTDRAWPALETTE *ppPalette, LPUNKNOWN pUnkOuter)
void	CopyDDSurfDescToDDSurfDesc2 (LPDDSURFACEDESC2 dst_pDesc, LPDDSURFACEDESC src_pDesc)
VOID	Cleanup (LPDDRAWI_DIRECTDRAW_INT iface)
VOID WINAPI	AcquireDDThreadLock (VOID)
VOID WINAPI	ReleaseDDThreadLock (VOID)
ULONG WINAPI	DirectDrawClipper_AddRef (LPDIRECTDRAWCLIPPER iface)
HRESULT WINAPI	DirectDrawClipper_Initialize (LPDIRECTDRAWCLIPPER iface, LPDIRECTDRAW lpDD, DWORD dwFlags)
VOID	Hal_DirectDraw_Release (LPDIRECTDRAW7)

Variables
DDRAWI_DIRECTDRAW_GBL	ddgbl
DDRAWI_DDRAWSURFACE_GBL	ddSurfGbl
WCHAR	classname [128]
WNDCLASSW	wnd_class
CRITICAL_SECTION	ddcs
IDirectDraw7Vtbl	DirectDraw7_Vtable
IDirectDraw4Vtbl	DirectDraw4_Vtable
IDirectDraw2Vtbl	DirectDraw2_Vtable
IDirectDrawVtbl	DirectDraw_Vtable
IDirectDrawSurface7Vtbl	DirectDrawSurface7_Vtable
IDirectDrawSurface4Vtbl	DirectDrawSurface4_Vtable
IDirectDrawSurface3Vtbl	DirectDrawSurface3_Vtable
IDirectDrawSurface2Vtbl	DirectDrawSurface2_Vtable
IDirectDrawSurfaceVtbl	DirectDrawSurface_Vtable
const IDirectDrawPaletteVtbl	DirectDrawPalette_Vtable
IDirectDrawClipperVtbl	DirectDrawClipper_Vtable
IDirectDrawColorControlVtbl	DirectDrawColorControl_Vtable
IDirectDrawGammaControlVtbl	DirectDrawGammaControl_Vtable
IDirectDrawKernelVtbl	DirectDrawKernel_Vtable
IDirectDrawSurfaceKernelVtbl	DirectDrawSurfaceKernel_Vtable
IDirect3DVtbl	IDirect3D_Vtbl
IDirect3D2Vtbl	IDirect3D2_Vtbl
IDirect3D3Vtbl	IDirect3D3_Vtbl
IDirect3D7Vtbl	IDirect3D7_Vtbl

Macro Definition Documentation

DX_STUB

#define DX_STUB

Value:

{ \
    static BOOL firstcall = TRUE; \
    if (firstcall) \
    { \
        char buffer[1024]; \
        sprintf ( buffer, "Function %s is not implemented yet (%s:%d)\n", __FUNCTION__,__FILE__,__LINE__ ); \
        OutputDebugStringA(buffer); \
        firstcall = FALSE; \
    } \
} \
    return DDERR_UNSUPPORTED;

Definition at line 224 of file rosdraw.h.

DX_STUB_DD_OK

#define DX_STUB_DD_OK

Value:

{ \
    static BOOL firstcall = TRUE; \
    if (firstcall) \
    { \
        char buffer[1024]; \
        sprintf ( buffer, "Function %s is not implemented yet (%s:%d)\n", __FUNCTION__,__FILE__,__LINE__ ); \
        OutputDebugStringA(buffer); \
        firstcall = FALSE; \
    } \
} \
    return DD_OK;

Definition at line 239 of file rosdraw.h.

DX_STUB_str

#define DX_STUB_str

(

x

)

Value:

    { \
        char buffer[1024]; \
        sprintf ( buffer, "Function %s %s (%s:%d)\n", __FUNCTION__,x,__FILE__,__LINE__ ); \
        OutputDebugStringA(buffer); \
    }

Definition at line 254 of file rosdraw.h.

DX_WINDBG_trace

#define DX_WINDBG_trace

(

)

Value:

        static BOOL firstcallx = TRUE; \
        if (firstcallx) \
        { \
            char buffer[1024]; \
            sprintf ( buffer, "Enter Function %s (%s:%d)\n", __FUNCTION__,__FILE__,__LINE__ ); \
            OutputDebugStringA(buffer); \
            firstcallx = TRUE; \
        }

Definition at line 262 of file rosdraw.h.

DX_WINDBG_trace_res

#define DX_WINDBG_trace_res	(		width,
			height,
			bpp,
			freq
	)

Value:

    static BOOL firstcallxx = TRUE; \
    if (firstcallxx) \
    { \
        char buffer[1024]; \
        sprintf ( buffer, "Setmode have been req width=%ld, height=%ld bpp=%ld freq = %ld\n",width,height,bpp, freq); \
        OutputDebugStringA(buffer); \
        firstcallxx = TRUE; \
    }

Definition at line 273 of file rosdraw.h.

DxHeapMemAlloc

#define DxHeapMemAlloc	(		p,
			m
	)

Value:

                                { \
                                p = malloc(m); \
                                if (p != NULL) \
                                { \
                                    ZeroMemory(p,m); \
                                } \
                              }

Definition at line 113 of file rosdraw.h.

DxHeapMemFree

#define DxHeapMemFree

(

p

)

Value:

                             { \
                             free(p); \
                             p = NULL; \
                           }

Definition at line 120 of file rosdraw.h.

HEL_GRAPHIC_MEMORY_MAX

#define HEL_GRAPHIC_MEMORY_MAX   67108864

Definition at line 181 of file rosdraw.h.

Typedef Documentation

_DDRAWI_DDKERNELSURFACE_INT

typedef struct _DDRAWI_DDKERNELSURFACE_INT _DDRAWI_DDKERNELSURFACE_INT

DDRAWI_DDCOLORCONTROL_INT

typedef struct DDRAWI_DDCOLORCONTROL_INT DDRAWI_DDCOLORCONTROL_INT

DDRAWI_DDGAMMACONTROL_INT

typedef struct _DDRAWI_DDGAMMACONTROL_INT DDRAWI_DDGAMMACONTROL_INT

DDRAWI_KERNEL_INT

typedef struct _DDRAWI_DDKERNEL_INT DDRAWI_KERNEL_INT

LPDDRAWI_DDCOLORCONTROL_INT

typedef struct DDRAWI_DDCOLORCONTROL_INT * LPDDRAWI_DDCOLORCONTROL_INT

LPDDRAWI_DDGAMMACONTROL_INT

typedef struct _DDRAWI_DDGAMMACONTROL_INT * LPDDRAWI_DDGAMMACONTROL_INT

LPDDRAWI_DDKERNELSURFACE_INT

typedef struct _DDRAWI_DDKERNELSURFACE_INT * LPDDRAWI_DDKERNELSURFACE_INT

LPDDRAWI_KERNEL_INT

typedef struct _DDRAWI_DDKERNEL_INT * LPDDRAWI_KERNEL_INT

Function Documentation

AcquireDDThreadLock()

VOID WINAPI AcquireDDThreadLock

(

VOID

)

Cleanup()

VOID Cleanup

(

LPDDRAWI_DIRECTDRAW_INT

iface

)

Definition at line 15 of file cleanup.c.

{
    DX_WINDBG_trace();
 
    if (ddgbl.lpDDCBtmp != NULL)
    {
        DxHeapMemFree(ddgbl.lpDDCBtmp);
    }
 
    if (ddgbl.lpdwFourCC != NULL)
    {
        DxHeapMemFree(ddgbl.lpdwFourCC);
    }
 
    if (ddgbl.lpModeInfo != NULL)
    {
        DxHeapMemFree(ddgbl.lpModeInfo);
    }
 
    DdDeleteDirectDrawObject(&ddgbl);
 
    /*
       anything else to release?
    */
 
    /* release the linked interface */
    //while (IsBadWritePtr( This->lpVtbl, sizeof( LPDDRAWI_DIRECTDRAW_INT )) )
    //{
    //    LPDDRAWI_DIRECTDRAW_INT newThis = This->lpVtbl;
    //    if (This->lpLcl != NULL)
    //    {
    //        DeleteDC(This->lpLcl->hDC);
    //        DxHeapMemFree(This->lpLcl);
    //    }
 
    //    DxHeapMemFree(This);
    //    This = newThis;
    //}
 
    /* release unlinked interface */
    if (This->lpLcl != NULL)
    {
        DxHeapMemFree(This->lpLcl);
    }
    //if (This != NULL)
    //{
    //    DxHeapMemFree(This);
    //}
 
}

CopyDDSurfDescToDDSurfDesc2()

void CopyDDSurfDescToDDSurfDesc2	(	LPDDSURFACEDESC2	dst_pDesc,
		LPDDSURFACEDESC	src_pDesc
	)

Definition at line 311 of file createsurface.c.

{
    RtlZeroMemory(dst_pDesc,sizeof(DDSURFACEDESC2));
    RtlCopyMemory(dst_pDesc,src_pDesc,sizeof(DDSURFACEDESC));
    dst_pDesc->dwSize =  sizeof(DDSURFACEDESC2);
}

Referenced by Main_DirectDraw_CreateSurface().

Create_DirectDraw()

HRESULT WINAPI Create_DirectDraw	(	LPGUID	pGUID,
		LPDIRECTDRAW *	pIface,
		REFIID	id,
		BOOL	ex
	)

Definition at line 20 of file startup.c.

{
    LPDDRAWI_DIRECTDRAW_INT This;
 
    DX_WINDBG_trace();
    BOOL linking = FALSE;
 
    if (pIface == NULL)
    {
        return DDERR_INVALIDPARAMS;
    }
 
    This = (LPDDRAWI_DIRECTDRAW_INT)*pIface;
 
    DX_STUB_str("Linking?\n")
 
    _SEH2_TRY
    {
        linking = This->lpLcl ? TRUE:FALSE;
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        linking = FALSE;
    }
    _SEH2_END;
 
    /* fixme linking too second link when we shall not doing it */
    if (!linking)
    {
        /* We do not have a DirectDraw interface, we need alloc it*/
        LPDDRAWI_DIRECTDRAW_INT memThis;
 
        DX_STUB_str("1. no linking\n");
 
        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
    {
        /* 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 link */
        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;
    }
 
    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))
    {
        /* DirectDraw Vtable */
        This->lpVtbl = &DirectDraw_Vtable;
        *pIface = (LPDIRECTDRAW)&This->lpVtbl;
        Main_DirectDraw_AddRef(This);
    }
 
    if ( This->lpVtbl != 0)
    {
        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;
        }
    }
 
    return DDERR_INVALIDPARAMS;
}

Referenced by DirectDrawCreate(), and DirectDrawCreateEx().

DirectDrawClipper_AddRef()

ULONG WINAPI DirectDrawClipper_AddRef

(

LPDIRECTDRAWCLIPPER

iface

)

Definition at line 75 of file clipper_main.c.

{
    LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
    if(!This)
        return DDERR_INVALIDOBJECT;
 
    DX_WINDBG_trace();
 
    if (iface!=NULL)
    {
        This->dwIntRefCnt++;
        This->lpLcl->dwLocalRefCnt++;
        if (This->lpLcl->lpGbl)
            This->lpLcl->lpGbl->dwRefCnt++;
    }
    return This->dwIntRefCnt;
}

DirectDrawClipper_Initialize()

HRESULT WINAPI DirectDrawClipper_Initialize	(	LPDIRECTDRAWCLIPPER	iface,
		LPDIRECTDRAW	lpDD,
		DWORD	dwFlags
	)

Definition at line 23 of file clipper_main.c.

{
    LPDDRAWI_DDRAWCLIPPER_INT This = (LPDDRAWI_DDRAWCLIPPER_INT)iface;
    LPDDRAWI_DIRECTDRAW_INT DDraw = (LPDDRAWI_DIRECTDRAW_INT)lpDD;
 
    DX_WINDBG_trace();
 
    if(!This)
        return DDERR_INVALIDOBJECT;
 
    if(This->dwIntRefCnt)
        return DDERR_ALREADYINITIALIZED;
 
    This->lpVtbl = (LPVOID)&DirectDrawClipper_Vtable;
    This->dwIntRefCnt = 1;
 
    DxHeapMemAlloc(This->lpLcl, sizeof(DDRAWI_DDRAWCLIPPER_LCL));
    //This->lpLcl->lpClipMore
    This->lpLcl->lpDD_int = DDraw;
    This->lpLcl->lpGbl->dwRefCnt = 1;
    This->lpLcl->pAddrefedThisOwner = (IUnknown*)DDraw;
 
    // FIXME: Implement Linking and share global object
    DxHeapMemAlloc(This->lpLcl->lpGbl, sizeof(DDRAWI_DDRAWCLIPPER_GBL));
    This->lpLcl->lpGbl->dwProcessId = GetCurrentProcessId();
 
    return DD_OK;
}

Hal_DirectDraw_Release()

VOID Hal_DirectDraw_Release

(

LPDIRECTDRAW7

)

Internal_CreatePalette()

HRESULT Internal_CreatePalette	(	LPDDRAWI_DIRECTDRAW_INT	pDDraw,
		DWORD	dwFlags,
		LPPALETTEENTRY	palent,
		LPDIRECTDRAWPALETTE *	ppPalette,
		LPUNKNOWN	pUnkOuter
	)

Definition at line 33 of file createpalette.c.

{
    DDHAL_CREATEPALETTEDATA mDdCreatePalette = { 0 };
 
    LPDDRAWI_DDRAWPALETTE_INT ThisPalInt = NULL;
    LPDDRAWI_DDRAWPALETTE_LCL ThisPalLcl = NULL;
    LPDDRAWI_DDRAWPALETTE_GBL ThisPalGbl = NULL;
 
    HRESULT ret;
 
    if(pUnkOuter)
    {
        return CLASS_E_NOAGGREGATION;
    }
 
    if(!(pDDraw->lpLcl->dwLocalFlags & DDRAWILCL_SETCOOPCALLED))
    {
        return DDERR_NOCOOPERATIVELEVELSET;
    }
 
 
    if (pDDraw->lpLcl->dwProcessId != GetCurrentProcessId() )
    {
        return DDERR_INVALIDOBJECT;
    }
 
    /* Allocate the palette interface and needed members */
    DxHeapMemAlloc(ThisPalInt,  sizeof( DDRAWI_DDRAWPALETTE_INT ) );
    if( ThisPalInt == NULL )
    {
        ret = DDERR_OUTOFMEMORY;
        goto cleanup;
    }
 
    DxHeapMemAlloc(ThisPalLcl,  sizeof( DDRAWI_DDRAWPALETTE_LCL ) );
    if( ThisPalLcl == NULL )
    {
        ret = DDERR_OUTOFMEMORY;
        goto cleanup;
    }
 
    DxHeapMemAlloc(ThisPalGbl,  sizeof( DDRAWI_DDRAWPALETTE_GBL ) );
    if( ThisPalGbl == NULL )
    {
        ret = DDERR_OUTOFMEMORY;
        goto cleanup;
    }
 
    /*Some initial setup*/
 
    ThisPalInt->lpLcl = ThisPalLcl;
    ThisPalLcl->lpGbl = ThisPalGbl;
 
    ThisPalLcl->lpDD_lcl = ThisPalGbl->lpDD_lcl = pDDraw->lpLcl;
    ThisPalGbl->dwFlags = ConvertPCapsFlags(dwFlags);
 
    ThisPalInt->lpVtbl = (PVOID)&DirectDrawPalette_Vtable;
    ThisPalGbl->dwProcessId = GetCurrentProcessId();
 
    mDdCreatePalette.lpDD = pDDraw->lpLcl->lpGbl;
    mDdCreatePalette.lpDDPalette = ThisPalGbl;
    if(pDDraw->lpLcl->lpGbl->lpDDCBtmp->HALDD.dwFlags & DDHAL_CB32_CREATEPALETTE) {
        mDdCreatePalette.CreatePalette = pDDraw->lpLcl->lpGbl->lpDDCBtmp->HALDD.CreatePalette;
        DX_STUB_str("Using HAL CreatePalette\n");
    }
    else {
        mDdCreatePalette.CreatePalette = pDDraw->lpLcl->lpGbl->lpDDCBtmp->HELDD.CreatePalette;
        DX_STUB_str("Using HEL CreatePalette\n");
    }
    mDdCreatePalette.ddRVal = DDERR_GENERIC;
    mDdCreatePalette.lpColorTable = palent;
 
    if (mDdCreatePalette.CreatePalette(&mDdCreatePalette) == DDHAL_DRIVER_NOTHANDLED)
    {
        DX_STUB_str("mDdCreateSurface failed with DDHAL_DRIVER_NOTHANDLED.");
        ret = DDERR_NOTINITIALIZED;
        goto cleanup;
    }
 
    if (mDdCreatePalette.ddRVal != DD_OK)
    {
        DX_STUB_str("mDdCreateSurface failed.");
        ret = mDdCreatePalette.ddRVal;
        goto cleanup;
    }
 
    *ppPalette = (LPDIRECTDRAWPALETTE)ThisPalInt;
    ThisPalInt->lpLink = pDDraw->lpLcl->lpGbl->palList;
    pDDraw->lpLcl->lpGbl->palList = ThisPalInt;
    ThisPalInt->lpLcl->dwReserved1 = (ULONG_PTR)pDDraw;
    IDirectDrawPalette_AddRef(*ppPalette);
 
    return DD_OK;
 
cleanup:
    if(ThisPalInt) DxHeapMemFree(ThisPalInt);
    if(ThisPalLcl) DxHeapMemFree(ThisPalLcl);
    if(ThisPalGbl) DxHeapMemFree(ThisPalGbl);
 
    return ret;
}

Referenced by Main_DirectDraw_CreatePalette().

Internal_CreateSurface()

HRESULT Internal_CreateSurface	(	LPDDRAWI_DIRECTDRAW_INT	pDDraw,
		LPDDSURFACEDESC2	pDDSD,
		LPDDRAWI_DDRAWSURFACE_INT *	ppSurf,
		IUnknown *	pUnkOuter
	)

Definition at line 18 of file createsurface.c.

{
    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;
}

Referenced by Main_DirectDraw_CreateSurface(), and Main_DirectDraw_CreateSurface4().

ReCreateDirectDraw()

HRESULT WINAPI ReCreateDirectDraw

(

LPDIRECTDRAW

iface

)

ReleaseDDThreadLock()

VOID WINAPI ReleaseDDThreadLock

(

VOID

)

StartDirectDraw()

HRESULT WINAPI StartDirectDraw	(	LPDIRECTDRAW	iface,
		LPGUID	pGUID,
		BOOL	reenable
	)

Definition at line 180 of file startup.c.

{
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
    DWORD hal_ret = DD_FALSE;
    DWORD hel_ret = DD_FALSE;
    DWORD devicetypes = 0;
    DWORD dwFlags = 0;
 
 
    DX_WINDBG_trace();
 
 
    /*
     * 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 memory\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 */
    This->lpLcl->lpDDCB = This->lpLcl->lpGbl->lpDDCBtmp;
    This->lpLcl->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);
              break;
    }
 
    if (hal_ret!=DD_OK)
    {
        if (hel_ret!=DD_OK)
        {
            DX_STUB_str("DDERR_NODIRECTDRAWSUPPORT\n");
            return DDERR_NODIRECTDRAWSUPPORT;
        }
        dwFlags |= DDRAWI_NOHARDWARE;
        DX_STUB_str("No hardware support\n");
    }
 
    if (hel_ret!=DD_OK)
    {
        dwFlags |= DDRAWI_NOEMULATION;
 
    }
    else
    {
        dwFlags |= DDRAWI_EMULATIONINITIALIZED;
    }
 
    /* 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;
}

Referenced by Create_DirectDraw(), Main_DirectDraw_RestoreDisplayMode(), and Main_DirectDraw_SetDisplayMode2().

StartDirectDrawHal()

HRESULT WINAPI StartDirectDrawHal	(	LPDIRECTDRAW	iface,
		BOOL	reenable
	)

Definition at line 458 of file startup.c.

{
    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(ddgbl.lpDDCBtmp);
       return DD_FALSE;
    }
 
    /* Some card disable the dx after it have been created so
     * we are force reenabling it
     */
    if (!DdReenableDirectDrawObject(This->lpLcl->lpGbl, &newmode))
    {
      DxHeapMemFree(ddgbl.lpDDCBtmp);
      return DD_FALSE;
    }
 
    if (!DdQueryDirectDrawObject(This->lpLcl->lpGbl,
                                 &mHALInfo,
                                 &ddgbl.lpDDCBtmp->HALDD,
                                 &ddgbl.lpDDCBtmp->HALDDSurface,
                                 &ddgbl.lpDDCBtmp->HALDDPalette,
                                 &mD3dCallbacks,
                                 &mD3dDriverData,
                                 &mD3dBufferCallbacks,
                                 NULL,
                                 mpFourCC,
                                 NULL))
    {
      DxHeapMemFree(This->lpLcl->lpGbl->lpModeInfo);
      DxHeapMemFree(ddgbl.lpDDCBtmp);
      // FIXME Close DX first and second call
      return DD_FALSE;
    }
 
    /* Alloc mpFourCC */
    if (This->lpLcl->lpGbl->lpdwFourCC != NULL)
    {
        DxHeapMemFree(This->lpLcl->lpGbl->lpdwFourCC);
    }
 
    if (mHALInfo.ddCaps.dwNumFourCCCodes > 0 )
    {
 
        DxHeapMemAlloc(mpFourCC, sizeof(DWORD) * (mHALInfo.ddCaps.dwNumFourCCCodes + 2));
 
        if (mpFourCC == NULL)
        {
            DxHeapMemFree(ddgbl.lpDDCBtmp);
            // FIXME Close DX first 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
        }
    }
 
    DX_STUB_str("2 Here\n");
 
#else
      mpTextures = NULL;
#endif
 
 
    /* Get all basic data from the driver */
    if (!DdQueryDirectDrawObject(
                                 This->lpLcl->lpGbl,
                                 &mHALInfo,
                                 &ddgbl.lpDDCBtmp->HALDD,
                                 &ddgbl.lpDDCBtmp->HALDDSurface,
                                 &ddgbl.lpDDCBtmp->HALDDPalette,
                                 &mD3dCallbacks,
                                 &mD3dDriverData,
                                 &ddgbl.lpDDCBtmp->HALDDExeBuf,
                                 (DDSURFACEDESC*)mpTextures,
                                 mpFourCC,
                                 NULL))
    {
        DxHeapMemFree(mpFourCC);
        DxHeapMemFree(mpTextures);
        DxHeapMemFree(ddgbl.lpDDCBtmp);
        // FIXME Close DX first and second call
        return DD_FALSE;
    }
 
    memcpy(&ddgbl.vmiData, &mHALInfo.vmiData,sizeof(VIDMEMINFO));
 
 
    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 according to 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)
    {
        This->lpLcl->lpGbl->dwFlags = This->lpLcl->lpGbl->dwFlags | DDRAWI_DRIVERINFO2;
    }
 
 
    return DD_OK;
}

Referenced by StartDirectDraw().

StartDirectDrawHel()

HRESULT WINAPI StartDirectDrawHel	(	LPDIRECTDRAW	iface,
		BOOL	reenable
	)

Definition at line 368 of file startup.c.

{
    LPDDRAWI_DIRECTDRAW_INT This = (LPDDRAWI_DIRECTDRAW_INT)iface;
 
    if (reenable == FALSE)
    {
        if (ddgbl.lpDDCBtmp == NULL)
        {
            DxHeapMemAlloc(ddgbl.lpDDCBtmp, sizeof(DDHAL_CALLBACKS));
            if ( ddgbl.lpDDCBtmp == NULL)
            {
                return DD_FALSE;
            }
        }
    }
 
    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        |
                                          DDHAL_CB32_FLIPTOGDISURFACE     |
                                          DDHAL_CB32_GETSCANLINE          |
                                          DDHAL_CB32_SETCOLORKEY          |
                                          DDHAL_CB32_SETEXCLUSIVEMODE     |
                                          DDHAL_CB32_SETMODE              |
                                          DDHAL_CB32_WAITFORVERTICALBLANK ;
 
    ddgbl.lpDDCBtmp->HELDD.dwSize = sizeof(This->lpLcl->lpDDCB->HELDD);
 
    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               |
                                                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;
 
    ddgbl.lpDDCBtmp->HELDDSurface.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDSurface);
 
    /*
    This->lpLcl->lpDDCB->HELDDPalette.DestroyPalette  = HelDdPalDestroyPalette;
    This->lpLcl->lpDDCB->HELDDPalette.SetEntries = HelDdPalSetEntries;
    This->lpLcl->lpDDCB->HELDDPalette.dwSize = sizeof(This->lpLcl->lpDDCB->HELDDPalette);
    */
 
    /*
    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;
    */
 
    return DD_OK;
}

Referenced by StartDirectDraw().

Variable Documentation

classname

WCHAR classname[128]

extern

Definition at line 15 of file startup.c.

Referenced by ChildWindow::create(), create_monodata(), create_test_verb(), create_test_verb_dde(), d3drm_animation_create(), d3drm_device_create(), d3drm_face_create(), d3drm_frame_create(), d3drm_light_create(), d3drm_material_create(), d3drm_mesh_builder_create(), d3drm_mesh_create(), d3drm_object_init(), d3drm_texture_create(), d3drm_viewport_create(), d3drm_wrap_create(), delete_test_association(), delete_test_class(), find_window_class(), mi_create_window(), OleRegisterClientDoc(), SHELL_execute_class(), SHELL_FindExecutable(), SHELL_FindExecutableByVerb(), SHELL_FS_HideExtension(), SPY_GetMsgStuff(), START_TEST(), Test_Dim(), toolbarcheck(), and WindowClass::WindowClass().

ddcs

CRITICAL_SECTION ddcs

extern

Definition at line 14 of file main.c.

Referenced by AcquireDDThreadLock(), DllMain(), Main_DirectDraw_CreatePalette(), Main_DirectDraw_CreateSurface(), Main_DirectDraw_CreateSurface4(), Main_DirectDraw_GetCaps(), Main_DirectDraw_GetDeviceIdentifier7(), and ReleaseDDThreadLock().

ddgbl

DDRAWI_DIRECTDRAW_GBL ddgbl

extern

Definition at line 12 of file startup.c.

Referenced by Cleanup(), Create_DirectDraw(), StartDirectDraw(), StartDirectDrawHal(), and StartDirectDrawHel().

ddSurfGbl

DDRAWI_DDRAWSURFACE_GBL ddSurfGbl

extern

Definition at line 13 of file startup.c.

DirectDraw2_Vtable

IDirectDraw2Vtbl DirectDraw2_Vtable

extern

Definition at line 862 of file ddraw_thunk.c.

Referenced by Create_DirectDraw(), Internal_CreateSurface(), and Main_DirectDraw_QueryInterface().

DirectDraw4_Vtable

IDirectDraw4Vtbl DirectDraw4_Vtable

extern

Definition at line 890 of file ddraw_thunk.c.

Referenced by Create_DirectDraw(), DirectDrawPalette_Release(), Internal_CreateSurface(), Main_DirectDraw_CreatePalette(), and Main_DirectDraw_QueryInterface().

DirectDraw7_Vtable

IDirectDraw7Vtbl DirectDraw7_Vtable

extern

Definition at line 190 of file DirectDraw7_Vtable.c.

Referenced by Create_DirectDraw(), DirectDrawPalette_Release(), Internal_CreateSurface(), Main_DirectDraw_CreatePalette(), and Main_DirectDraw_QueryInterface().

DirectDraw_Vtable

IDirectDrawVtbl DirectDraw_Vtable

extern

Definition at line 835 of file ddraw_thunk.c.

Referenced by Create_DirectDraw(), Internal_CreateSurface(), and Main_DirectDraw_QueryInterface().

DirectDrawClipper_Vtable

IDirectDrawClipperVtbl DirectDrawClipper_Vtable

extern

Definition at line 131 of file clipper_main.c.

Referenced by DirectDrawClipper_Initialize().

DirectDrawColorControl_Vtable

IDirectDrawColorControlVtbl DirectDrawColorControl_Vtable

extern

Definition at line 58 of file color_stubs.c.

Referenced by Main_DDrawSurface_QueryInterface().

DirectDrawGammaControl_Vtable

IDirectDrawGammaControlVtbl DirectDrawGammaControl_Vtable

extern

Definition at line 60 of file gamma_stubs.c.

Referenced by Main_DDrawSurface_QueryInterface().

DirectDrawKernel_Vtable

IDirectDrawKernelVtbl DirectDrawKernel_Vtable

extern

Definition at line 114 of file kernel_stubs.c.

DirectDrawPalette_Vtable

const IDirectDrawPaletteVtbl DirectDrawPalette_Vtable

extern

Definition at line 147 of file palette.c.

Referenced by Internal_CreatePalette().

DirectDrawSurface2_Vtable

IDirectDrawSurface2Vtbl DirectDrawSurface2_Vtable

extern

Definition at line 62 of file DirectDrawSurface2_Vtable.c.

Referenced by Internal_CreateSurface(), and Main_DDrawSurface_QueryInterface().

DirectDrawSurface3_Vtable

IDirectDrawSurface3Vtbl DirectDrawSurface3_Vtable

extern

Definition at line 62 of file DirectDrawSurface3_Vtable.c.

Referenced by Main_DDrawSurface_QueryInterface().

DirectDrawSurface4_Vtable

IDirectDrawSurface4Vtbl DirectDrawSurface4_Vtable

extern

Definition at line 67 of file DirectDrawSurface4_Vtable.c.

Referenced by Internal_CreateSurface(), and Main_DDrawSurface_QueryInterface().

DirectDrawSurface7_Vtable

IDirectDrawSurface7Vtbl DirectDrawSurface7_Vtable

extern

Definition at line 71 of file DirectDrawSurface7_Vtable.c.

Referenced by Internal_CreateSurface(), and Main_DDrawSurface_QueryInterface().

DirectDrawSurface_Vtable

IDirectDrawSurfaceVtbl DirectDrawSurface_Vtable

extern

Definition at line 57 of file DirectDrawSurface_Vtable.c.

Referenced by Internal_CreateSurface(), and Main_DDrawSurface_QueryInterface().

DirectDrawSurfaceKernel_Vtable

IDirectDrawSurfaceKernelVtbl DirectDrawSurfaceKernel_Vtable

extern

Definition at line 123 of file kernel_stubs.c.

Referenced by Main_DDrawSurface_QueryInterface().

IDirect3D2_Vtbl

IDirect3D2Vtbl IDirect3D2_Vtbl

extern

Definition at line 28 of file DirectD3D2_Vtable.c.

Referenced by Main_DDrawSurface_QueryInterface().

IDirect3D3_Vtbl

IDirect3D3Vtbl IDirect3D3_Vtbl

extern

Definition at line 31 of file DirectD3D3_Vtable.c.

Referenced by Main_DDrawSurface_QueryInterface().

IDirect3D7_Vtbl

IDirect3D7Vtbl IDirect3D7_Vtbl

extern

Definition at line 27 of file DirectD3D7_Vtable.c.

Referenced by Main_DDrawSurface_QueryInterface().

IDirect3D_Vtbl

IDirect3DVtbl IDirect3D_Vtbl

extern

Definition at line 28 of file DirectD3D_Vtable.c.

Referenced by Main_DDrawSurface_QueryInterface().

wnd_class

WNDCLASSW wnd_class

extern

Definition at line 16 of file startup.c.

Referenced by test_IME().