Sweden-Number/dlls/ddraw/ddraw_hal.c

/*	DirectDraw HAL driver
 *
 * Copyright 2001 TransGaming Technologies Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "config.h"

#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>

#include "wine/debug.h"
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "ddraw.h"
#include "ddrawi.h"
#include "d3dhal.h"

#include "ddraw_private.h"

WINE_DEFAULT_DEBUG_CHANNEL(ddraw);

static const IDirectDraw7Vtbl HAL_DirectDraw_VTable;

static DDVERSIONDATA hal_version;
static DD32BITDRIVERDATA hal_driverdata;
static HINSTANCE hal_instance;

static const DDDEVICEIDENTIFIER2 hal_device =
{
    "display",
    "DirectDraw HAL",
    { { 0x00010001, 0x00010001 } },
    0, 0, 0, 0,
    /* 40c1b248-9d7d-4a29-b7d7-4cd8109f3d5d */
    {0x40c1b248,0x9d7d,0x4a29,{0xd7,0xb7,0x4c,0xd8,0x10,0x9f,0x3d,0x5d}},
    0
};

HRESULT HAL_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface,
			      IUnknown* pUnkOuter, BOOL ex);
HRESULT HAL_DirectDraw_Initialize(IDirectDrawImpl*, const GUID*);

static const ddraw_driver hal_driver =
{
    &hal_device,
    100, /* we prefer the HAL */
    HAL_DirectDraw_Create,
    HAL_DirectDraw_Initialize
};

static DDHAL_CALLBACKS dd_cbs;
static DDRAWI_DIRECTDRAW_GBL dd_gbl;

static D3DHAL_GLOBALDRIVERDATA d3d_hal_data;
static D3DHAL_D3DEXTENDEDCAPS d3d_hal_extcaps;
static D3DHAL_CALLBACKS d3d_hal_cbs1;
static D3DHAL_CALLBACKS2 d3d_hal_cbs2;

/* in real windoze, these entry points are 16-bit, but we can work in 32-bit */
static BOOL WINAPI set_hal_info(LPDDHALINFO lpDDHalInfo, BOOL reset)
{
    dd_cbs.HALDD	= *lpDDHalInfo->lpDDCallbacks;
    dd_cbs.HALDDSurface	= *lpDDHalInfo->lpDDSurfaceCallbacks;
    dd_cbs.HALDDPalette	= *lpDDHalInfo->lpDDPaletteCallbacks;
    if (lpDDHalInfo->lpDDExeBufCallbacks)
	dd_cbs.HALDDExeBuf	= *lpDDHalInfo->lpDDExeBufCallbacks;

    dd_gbl.lpDDCBtmp = &dd_cbs;

    dd_gbl.ddCaps		 = lpDDHalInfo->ddCaps;
    dd_gbl.dwMonitorFrequency	 = lpDDHalInfo->dwMonitorFrequency;
    dd_gbl.vmiData		 = lpDDHalInfo->vmiData;
    dd_gbl.dwModeIndex		 = lpDDHalInfo->dwModeIndex;
    dd_gbl.dwNumFourCC	         = lpDDHalInfo->ddCaps.dwNumFourCCCodes;
    dd_gbl.lpdwFourCC		 = lpDDHalInfo->lpdwFourCC;
    dd_gbl.dwNumModes		 = lpDDHalInfo->dwNumModes;
    dd_gbl.lpModeInfo		 = lpDDHalInfo->lpModeInfo;
    /* FIXME: dwFlags */
    dd_gbl.dwPDevice		 = (DWORD)lpDDHalInfo->lpPDevice;
    dd_gbl.hInstance		 = lpDDHalInfo->hInstance;
    /* DirectX 2 */
    if (lpDDHalInfo->lpD3DGlobalDriverData)
	memcpy(&d3d_hal_data, (LPVOID)lpDDHalInfo->lpD3DGlobalDriverData, sizeof(D3DDEVICEDESC_V1));
    else
	memset(&d3d_hal_data, 0, sizeof(D3DDEVICEDESC_V1));
    dd_gbl.lpD3DGlobalDriverData = (ULONG_PTR)&d3d_hal_data;

    if (lpDDHalInfo->lpD3DHALCallbacks)
	memcpy(&d3d_hal_cbs1, (LPVOID)lpDDHalInfo->lpD3DHALCallbacks, sizeof(D3DHAL_CALLBACKS));
    else
	memset(&d3d_hal_cbs1, 0, sizeof(D3DHAL_CALLBACKS));
    dd_gbl.lpD3DHALCallbacks	 = (ULONG_PTR)&d3d_hal_cbs1;

    if (lpDDHalInfo->dwFlags & DDHALINFO_GETDRIVERINFOSET) {
	DDHAL_GETDRIVERINFODATA data;
	data.dwSize = sizeof(DDHAL_GETDRIVERINFODATA);
	data.dwFlags = 0; /* ? */
	data.dwContext = hal_driverdata.dwContext; /* ? */

	data.guidInfo = GUID_D3DExtendedCaps;
	data.dwExpectedSize = sizeof(D3DHAL_D3DEXTENDEDCAPS);
	data.lpvData = &d3d_hal_extcaps;
	data.dwActualSize = 0;
	data.ddRVal = 0;
	lpDDHalInfo->GetDriverInfo(&data);
	d3d_hal_extcaps.dwSize = data.dwActualSize;
	dd_gbl.lpD3DExtendedCaps = (ULONG_PTR)&d3d_hal_extcaps;

	data.guidInfo = GUID_D3DCallbacks2;
	data.dwExpectedSize = sizeof(D3DHAL_CALLBACKS2);
	data.lpvData = &d3d_hal_cbs2;
	data.dwActualSize = 0;
	data.ddRVal = 0;
	lpDDHalInfo->GetDriverInfo(&data);
	d3d_hal_cbs2.dwSize = data.dwActualSize;
	dd_gbl.lpD3DHALCallbacks2 = (ULONG_PTR)&d3d_hal_cbs2;
    }

    if( opengl_initialized && 
           (d3d_hal_data.hwCaps.dwFlags & D3DDD_WINE_OPENGL_DEVICE) ) {
        /*GL_DirectDraw_Init(&dd_gbl);*/
    }

    return FALSE;
}

static DDHALDDRAWFNS hal_funcs = {
    sizeof(DDHALDDRAWFNS),
    set_hal_info,
    NULL, /* VidMemAlloc */
    NULL  /* VidMemFree */
};

/* Called from DllInit, which is synchronised so there are no threading
 * concerns. */
static BOOL initialize(void)
{
    DCICMD cmd;
    INT ncmd = DCICOMMAND;
    BOOL ret;
    HDC dc = CreateDCA("DISPLAY", NULL, NULL, NULL);
    INT ver = Escape(dc, QUERYESCSUPPORT, sizeof(ncmd), (LPVOID)&ncmd, NULL);
    if (ver != DD_HAL_VERSION) {
	DeleteDC(dc);
	TRACE("DirectDraw HAL not available\n");
	return FALSE;
    }
    cmd.dwVersion = DD_VERSION;
    cmd.dwReserved = 0;

    /* the DDNEWCALLBACKFNS is supposed to give the 16-bit driver entry points
     * in ddraw16.dll, but since Wine doesn't have or use 16-bit display drivers,
     * we'll just work in 32-bit, who'll notice... */
    cmd.dwCommand = DDNEWCALLBACKFNS;
    cmd.dwParam1 = (DWORD)&hal_funcs;
    ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, 0, NULL);

    /* next, exchange version information */
    cmd.dwCommand = DDVERSIONINFO;
    cmd.dwParam1 = DD_RUNTIME_VERSION; /* not sure what should *really* go here */
    ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_version), (LPVOID)&hal_version);

    /* get 32-bit driver data (dll name and entry point) */
    cmd.dwCommand = DDGET32BITDRIVERNAME;
    ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_driverdata), (LPVOID)&hal_driverdata);
    /* we're supposed to load the DLL in hal_driverdata.szName, then GetProcAddress
     * the hal_driverdata.szEntryPoint, and call it with hal_driverdata.dwContext
     * as a parameter... but since this is only more remains from the 16-bit world,
     * we'll ignore it */

    /* finally, initialize the driver object */
    cmd.dwCommand = DDCREATEDRIVEROBJECT;
    ret = ExtEscape(dc, DCICOMMAND, sizeof(cmd), (LPVOID)&cmd, sizeof(hal_instance), (LPVOID)&hal_instance);
    if (ret) {
	/* the driver should have called our set_hal_info now */
	if (!dd_gbl.lpDDCBtmp) ret = FALSE;
    }

    /* init done */
    DeleteDC(dc);

    TRACE("%s DirectDraw HAL\n", ret ? "enabling" : "disabling");

    return ret;
}

static void cleanup(void)
{
    DDHAL_DESTROYDRIVERDATA data;

    if (!dd_cbs.HALDD.DestroyDriver) return;

    data.lpDD = NULL;
    data.ddRVal = 0;
    data.DestroyDriver = dd_cbs.HALDD.DestroyDriver;
    data.DestroyDriver(&data);
}

static DWORD choose_mode(DWORD dwWidth, DWORD dwHeight, DWORD dwBPP,
			 DWORD dwRefreshRate, DWORD dwFlags)
{
    int best = -1;
    unsigned int i;

    if (!dd_gbl.dwNumModes) return 0;

/* let's support HALs that cannot switch depths (XVidMode),
 * these should return dwBPP == 0 for all their resolutions */
#define BPP_MATCH(dd, bpp) ((!(dd)) || ((dd) == bpp))

/* FIXME: we should try to match the refresh rate too */

    /* Choose the smallest mode that is large enough. */
    for (i=0; i < dd_gbl.dwNumModes; i++)
    {
	if (dd_gbl.lpModeInfo[i].dwWidth >= dwWidth &&
	    dd_gbl.lpModeInfo[i].dwHeight >= dwHeight &&
	    BPP_MATCH(dd_gbl.lpModeInfo[i].dwBPP, dwBPP))
	{
	    if (best == -1) best = i;
	    else
	    {
		if (dd_gbl.lpModeInfo[i].dwWidth < dd_gbl.lpModeInfo[best].dwWidth ||
		    dd_gbl.lpModeInfo[i].dwHeight < dd_gbl.lpModeInfo[best].dwHeight)
		    best = i;
	    }
	}
    }

    if (best == -1)
    {
	TRACE("all modes too small\n");
	/* ok, let's use the largest */

	for (i=0; i < dd_gbl.dwNumModes; i++)
	{
	    if (BPP_MATCH(dd_gbl.lpModeInfo[i].dwBPP, dwBPP))
	    {
		if (best == -1) best = i;
		else
		{
		    if (dd_gbl.lpModeInfo[i].dwWidth > dd_gbl.lpModeInfo[best].dwWidth ||
			dd_gbl.lpModeInfo[i].dwHeight > dd_gbl.lpModeInfo[best].dwHeight)
			best = i;
		}
	    }
	}
    }
#undef BPP_MATCH

    if (best == -1)
    {
	ERR("requested color depth (%ld) not available, try reconfiguring X server\n", dwBPP);
	return dd_gbl.dwModeIndex;
    }

    TRACE("using mode %d\n", best);

    return best;
}

static HRESULT set_mode(IDirectDrawImpl *This, DWORD dwMode)
{
    HRESULT hr = DD_OK;

    if (dwMode != dd_gbl.dwModeIndex)
    {
	DDHAL_SETMODEDATA data;
	data.lpDD = &dd_gbl;
	data.dwModeIndex = dwMode;
	data.ddRVal = 0;
	data.SetMode = dd_cbs.HALDD.SetMode;
	data.inexcl = 0;
	data.useRefreshRate = FALSE;
	if (data.SetMode)
	    data.SetMode(&data);
	hr = data.ddRVal;
	if (SUCCEEDED(hr))
	    dd_gbl.dwModeIndex = dwMode;
    }
    return hr;
}

static HRESULT set_exclusive_mode(IDirectDrawImpl *This, DWORD dwEnterExcl)
{
    DDHAL_SETEXCLUSIVEMODEDATA data;

    data.lpDD = &dd_gbl;
    data.dwEnterExcl = dwEnterExcl;
    data.dwReserved = 0;
    data.ddRVal = 0;
    data.SetExclusiveMode = dd_cbs.HALDD.SetExclusiveMode;
    if (data.SetExclusiveMode)
	data.SetExclusiveMode(&data);
    return data.ddRVal;
}

BOOL DDRAW_HAL_Init(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
{
    if (fdwReason == DLL_PROCESS_ATTACH)
    {
	if (initialize())
	    DDRAW_register_driver(&hal_driver);
    }
    else if (fdwReason == DLL_PROCESS_DETACH)
    {
	cleanup();
    }

    return TRUE;
}

/* Not called from the vtable. */
HRESULT HAL_DirectDraw_Construct(IDirectDrawImpl *This, BOOL ex)
{
    HRESULT hr;

    TRACE("(%p,%d)\n", This, ex);

    hr = User_DirectDraw_Construct(This, ex);
    if (FAILED(hr)) return hr;

    This->local.lpGbl = &dd_gbl;

    This->final_release = HAL_DirectDraw_final_release;
    This->set_exclusive_mode = set_exclusive_mode;

    This->create_palette = HAL_DirectDrawPalette_Create;

    This->create_primary    = HAL_DirectDraw_create_primary;
    This->create_backbuffer = HAL_DirectDraw_create_backbuffer;
    This->create_texture    = HAL_DirectDraw_create_texture;

    ICOM_INIT_INTERFACE(This, IDirectDraw7, HAL_DirectDraw_VTable);

    /* merge HAL caps */
    This->caps.dwCaps |= dd_gbl.ddCaps.dwCaps;
    This->caps.dwCaps2 |= dd_gbl.ddCaps.dwCaps2;
    This->caps.dwCKeyCaps |= dd_gbl.ddCaps.dwCKeyCaps;
    This->caps.dwFXCaps |= dd_gbl.ddCaps.dwFXCaps;
    This->caps.dwPalCaps |= dd_gbl.ddCaps.dwPalCaps;
    /* FIXME: merge more caps */
    This->caps.ddsCaps.dwCaps |= dd_gbl.ddCaps.ddsCaps.dwCaps;
    This->caps.ddsCaps.dwCaps2 |= dd_gbl.ddsCapsMore.dwCaps2;
    This->caps.ddsCaps.dwCaps3 |= dd_gbl.ddsCapsMore.dwCaps3;
    This->caps.ddsCaps.dwCaps4 |= dd_gbl.ddsCapsMore.dwCaps4;
    This->caps.ddsOldCaps.dwCaps = This->caps.ddsCaps.dwCaps;

    return S_OK;
}

/* This function is called from DirectDrawCreate(Ex) on the most-derived
 * class to start construction.
 * Not called from the vtable. */
HRESULT HAL_DirectDraw_Create(const GUID* pGUID, LPDIRECTDRAW7* pIface,
			      IUnknown* pUnkOuter, BOOL ex)
{
    HRESULT hr;
    IDirectDrawImpl* This;

    TRACE("\n");

    assert(pUnkOuter == NULL);

    This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
		     sizeof(IDirectDrawImpl)
		     + sizeof(HAL_DirectDrawImpl));
    if (This == NULL) return E_OUTOFMEMORY;

    /* Note that this relation does *not* hold true if the DD object was
     * CoCreateInstanced then Initialized. */
    This->private = (HAL_DirectDrawImpl *)(This+1);

    /* Initialize the DDCAPS structure */
    This->caps.dwSize = sizeof(This->caps);

    hr = HAL_DirectDraw_Construct(This, ex);
    if (FAILED(hr))
	HeapFree(GetProcessHeap(), 0, This);
    else
	*pIface = ICOM_INTERFACE(This, IDirectDraw7);

    return hr;
}

/* This function is called from Uninit_DirectDraw_Initialize on the
 * most-derived-class to start initialization.
 * Not called from the vtable. */
HRESULT HAL_DirectDraw_Initialize(IDirectDrawImpl *This, const GUID* guid)
{
    HRESULT hr;

    TRACE("\n");

    This->private = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
			      sizeof(HAL_DirectDrawImpl));
    if (This->private == NULL) return E_OUTOFMEMORY;

    /* Initialize the DDCAPS structure */
    This->caps.dwSize = sizeof(This->caps);

    hr = HAL_DirectDraw_Construct(This, TRUE); /* XXX ex? */
    if (FAILED(hr))
    {
	HeapFree(GetProcessHeap(), 0, This->private);
	return hr;
    }

    return DD_OK;
}

/* Called from an internal function pointer. */
void HAL_DirectDraw_final_release(IDirectDrawImpl *This)
{
    if (dd_gbl.dwFlags & DDRAWI_MODECHANGED) set_mode(This, dd_gbl.dwModeIndexOrig);
    User_DirectDraw_final_release(This);
}

HRESULT HAL_DirectDraw_create_primary(IDirectDrawImpl* This,
				      const DDSURFACEDESC2* pDDSD,
				      LPDIRECTDRAWSURFACE7* ppSurf,
				      IUnknown* pUnkOuter)
{
    if (This->cooperative_level & DDSCL_EXCLUSIVE)
	return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
    else
	return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
}

HRESULT HAL_DirectDraw_create_backbuffer(IDirectDrawImpl* This,
					 const DDSURFACEDESC2* pDDSD,
					 LPDIRECTDRAWSURFACE7* ppSurf,
					 IUnknown* pUnkOuter,
					 IDirectDrawSurfaceImpl* primary)
{
    if (This->cooperative_level & DDSCL_EXCLUSIVE)
	return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
    else
	return User_DirectDrawSurface_Create(This, pDDSD, ppSurf, pUnkOuter);
}

HRESULT HAL_DirectDraw_create_texture(IDirectDrawImpl* This,
				      const DDSURFACEDESC2* pDDSD,
				      LPDIRECTDRAWSURFACE7* ppSurf,
				      LPUNKNOWN pOuter,
				      DWORD dwMipMapLevel)
{
    return HAL_DirectDrawSurface_Create(This, pDDSD, ppSurf, pOuter);
}

HRESULT WINAPI
HAL_DirectDraw_GetDeviceIdentifier(LPDIRECTDRAW7 iface,
				   LPDDDEVICEIDENTIFIER2 pDDDI,
				   DWORD dwFlags)
{
    *pDDDI = hal_device;
    return DD_OK;
}

HRESULT WINAPI
HAL_DirectDraw_RestoreDisplayMode(LPDIRECTDRAW7 iface)
{
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
    HRESULT hr;

    TRACE("(%p)\n", iface);

    if (!(dd_gbl.dwFlags & DDRAWI_MODECHANGED)) return DD_OK;

    hr = Main_DirectDraw_RestoreDisplayMode(iface);
    if (SUCCEEDED(hr)) {
	hr = set_mode(This, dd_gbl.dwModeIndexOrig);
	if (SUCCEEDED(hr)) dd_gbl.dwFlags &= ~DDRAWI_MODECHANGED;
    }

    return hr;
}

HRESULT WINAPI
HAL_DirectDraw_SetDisplayMode(LPDIRECTDRAW7 iface, DWORD dwWidth,
			      DWORD dwHeight, DWORD dwBPP,
			      DWORD dwRefreshRate, DWORD dwFlags)
{
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;

    HRESULT hr;

    TRACE("(%p)->(%ldx%ldx%ld,%ld Hz,%08lx)\n",This,dwWidth,dwHeight,dwBPP,dwRefreshRate,dwFlags);
    hr = User_DirectDraw_SetDisplayMode(iface, dwWidth, dwHeight, dwBPP,
					dwRefreshRate, dwFlags);

    if (SUCCEEDED(hr)) {
	if (!(dd_gbl.dwFlags & DDRAWI_MODECHANGED)) dd_gbl.dwModeIndexOrig = dd_gbl.dwModeIndex;
	hr = set_mode(This, choose_mode(dwWidth, dwHeight, dwBPP, dwRefreshRate, dwFlags));
	if (SUCCEEDED(hr)) dd_gbl.dwFlags |= DDRAWI_MODECHANGED;
    }

    return hr;
}

HRESULT WINAPI
HAL_DirectDraw_GetFourCCCodes(LPDIRECTDRAW7 iface, LPDWORD pNumCodes,
			       LPDWORD pCodes)
{
    unsigned int i;
    IDirectDrawImpl *This = (IDirectDrawImpl *)iface;
    if (*pNumCodes)
	*pNumCodes=dd_gbl.dwNumFourCC;
    if (pCodes && dd_gbl.dwNumFourCC)
	memcpy(pCodes,dd_gbl.lpdwFourCC,sizeof(pCodes[0])*dd_gbl.dwNumFourCC);
    FIXME("(%p,%p,%p)\n",This,pNumCodes,pCodes);
    if (dd_gbl.dwNumFourCC) {
	if (pCodes && FIXME_ON(ddraw)) {
	    FIXME("returning: ");
	    for (i=0;i<dd_gbl.dwNumFourCC;i++) {
		MESSAGE("%c%c%c%c,",
			((LPBYTE)(pCodes+i))[0],
			((LPBYTE)(pCodes+i))[1],
			((LPBYTE)(pCodes+i))[2],
			((LPBYTE)(pCodes+i))[3]
		);
	    }
	    MESSAGE("\n");
	}
    }
    return DD_OK;
}


static const IDirectDraw7Vtbl HAL_DirectDraw_VTable =
{
    Main_DirectDraw_QueryInterface,
    Main_DirectDraw_AddRef,
    Main_DirectDraw_Release,
    Main_DirectDraw_Compact,
    Main_DirectDraw_CreateClipper,
    Main_DirectDraw_CreatePalette,
    Main_DirectDraw_CreateSurface,
    Main_DirectDraw_DuplicateSurface,
    User_DirectDraw_EnumDisplayModes,
    Main_DirectDraw_EnumSurfaces,
    Main_DirectDraw_FlipToGDISurface,
    Main_DirectDraw_GetCaps,
    Main_DirectDraw_GetDisplayMode,
    HAL_DirectDraw_GetFourCCCodes,
    Main_DirectDraw_GetGDISurface,
    Main_DirectDraw_GetMonitorFrequency,
    Main_DirectDraw_GetScanLine,
    Main_DirectDraw_GetVerticalBlankStatus,
    Main_DirectDraw_Initialize,
    HAL_DirectDraw_RestoreDisplayMode,
    Main_DirectDraw_SetCooperativeLevel,
    HAL_DirectDraw_SetDisplayMode,
    Main_DirectDraw_WaitForVerticalBlank,
    Main_DirectDraw_GetAvailableVidMem,
    Main_DirectDraw_GetSurfaceFromDC,
    Main_DirectDraw_RestoreAllSurfaces,
    Main_DirectDraw_TestCooperativeLevel,
    HAL_DirectDraw_GetDeviceIdentifier,
    Main_DirectDraw_StartModeTest,
    Main_DirectDraw_EvaluateMode
};