BOOL bTestModes(void)
{
LPDIRECTDRAW pDD;
LPDIRECTDRAW4 g_pDD;
HRESULT (WINAPI *pDDrawCreateFn)(GUID *,LPDIRECTDRAW *,IUnknown *);
GUID FAR * guid=0;
int i;unsigned char * c=(unsigned char *)&guiDev;
for(i=0;i<sizeof(GUID);i++,c++)
{if(*c) {guid=&guiDev;break;}}
bDeviceOK=FALSE;
pDDrawCreateFn = (LPVOID)GetProcAddress(hDDrawDLL, "DirectDrawCreate");
if( pDDrawCreateFn == NULL || FAILED( pDDrawCreateFn(guid, &pDD, 0L ) ) )
{
return FALSE;
}
if(FAILED(IDirectDraw_QueryInterface(pDD, &IID_IDirectDraw4, (VOID**)&g_pDD)))
{
IDirectDraw_Release(pDD);
return FALSE;
}
IDirectDraw_Release(pDD);
IDirectDraw4_EnumDisplayModes(g_pDD,0,NULL,NULL,EnumDisplayModesCallback);
IDirectDraw4_Release(g_pDD);
return bDeviceOK;
}
static BOOL WINAPI DirectDrawEnumCallbackEx( GUID FAR* pGUID, LPSTR strDesc,
LPSTR strName, VOID* pV,
HMONITOR hMonitor )
{
// Use the GUID to create the DirectDraw object, so that information
// can be extracted from it.
LPDIRECTDRAW pDD;
LPDIRECTDRAW4 g_pDD;
LPDIRECT3D3 pD3D;
HRESULT (WINAPI *pDDrawCreateFn)(GUID *,LPDIRECTDRAW *,IUnknown *);
pDDrawCreateFn = (LPVOID)GetProcAddress( hDDrawDLL, "DirectDrawCreate" );
if( pDDrawCreateFn == NULL || FAILED( pDDrawCreateFn( pGUID, &pDD, 0L ) ) )
{
return D3DENUMRET_OK;
}
// Query the DirectDraw driver for access to Direct3D.
if( FAILED(IDirectDraw_QueryInterface(pDD, &IID_IDirectDraw4, (VOID**)&g_pDD)))
{
IDirectDraw_Release(pDD);
return D3DENUMRET_OK;
}
IDirectDraw_Release(pDD);
// Query the DirectDraw driver for access to Direct3D.
if( FAILED( IDirectDraw4_QueryInterface(g_pDD,&IID_IDirect3D3, (VOID**)&pD3D)))
{
IDirectDraw4_Release(g_pDD);
return D3DENUMRET_OK;
}
bDeviceOK=FALSE;
// Now, enumerate all the 3D devices
IDirect3D3_EnumDevices(pD3D,Enum3DDevicesCallback,NULL);
if(bDeviceOK)
{
HWND hWC=GetDlgItem(gHWND,IDC_DEVICE);
int i=ComboBox_AddString(hWC,strDesc);
GUID * g=(GUID *)malloc(sizeof(GUID));
if(NULL != pGUID) *g=*pGUID;
else memset(g,0,sizeof(GUID));
ComboBox_SetItemData(hWC,i,g);
}
IDirect3D3_Release(pD3D);
IDirectDraw4_Release(g_pDD);
return DDENUMRET_OK;
}
void
winDetectSupportedEngines(void)
{
/* Initialize the engine support flags */
g_dwEnginesSupported = WIN_SERVER_SHADOW_GDI;
/* Do we have DirectDraw? */
if (g_hmodDirectDraw != NULL) {
LPDIRECTDRAW lpdd = NULL;
LPDIRECTDRAW4 lpdd4 = NULL;
HRESULT ddrval;
/* Was the DirectDrawCreate function found? */
if (g_fpDirectDrawCreate == NULL) {
/* No DirectDraw support */
return;
}
/* DirectDrawCreate exists, try to call it */
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, (void **) &lpdd, NULL);
if (FAILED(ddrval)) {
/* No DirectDraw support */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw not installed\n");
return;
}
/* Try to query for DirectDraw4 interface */
ddrval = IDirectDraw_QueryInterface(lpdd,
&IID_IDirectDraw4,
(LPVOID *) &lpdd4);
if (SUCCEEDED(ddrval)) {
/* We have DirectDraw4 */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw4 installed, allowing ShadowDDNL\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DDNL;
}
/* Cleanup DirectDraw interfaces */
if (lpdd4 != NULL)
IDirectDraw_Release(lpdd4);
if (lpdd != NULL)
IDirectDraw_Release(lpdd);
}
winErrorFVerb(2,
"winDetectSupportedEngines - Returning, supported engines %08x\n",
(unsigned int) g_dwEnginesSupported);
}
static int InitializeDDraw(int fs)
{
//only init the palette the first time through
if(firstInitialize) {
firstInitialize = false;
color_palette = (PALETTEENTRY*)malloc(256 * sizeof(PALETTEENTRY));
}
//(disvaccel&(1<<(fs?1:0)))?(GUID FAR *)DDCREATE_EMULATIONONLY:
ddrval = DirectDrawCreate((disvaccel&(1<<(fs?1:0)))?(GUID FAR *)DDCREATE_EMULATIONONLY:NULL, &lpDD, NULL);
if (ddrval != DD_OK)
{
ShowDDErr("Error creating DirectDraw object.");
return 0;
}
//mbg merge 7/17/06 changed:
ddrval = IDirectDraw_QueryInterface(lpDD,IID_IDirectDraw7,(LPVOID *)&lpDD7);
//ddrval = IDirectDraw_QueryInterface(lpDD,&IID_IDirectDraw7,(LPVOID *)&lpDD7);
IDirectDraw_Release(lpDD);
if (ddrval != DD_OK)
{
ShowDDErr("Error querying interface.");
return 0;
}
caps.dwSize=sizeof(caps);
if(IDirectDraw7_GetCaps(lpDD7,&caps,0)!=DD_OK)
{
ShowDDErr("Error getting capabilities.");
return 0;
}
return 1;
}
void UninitDirectDraw(void)
{
if (lpDD) IDirectDraw_Release(lpDD);
lpDD = NULL;
if (hDDrawDLL) FreeLibrary(hDDrawDLL);
hDDrawDLL = NULL;
}
/* uninitialize DirectX */
static void DeInitDD(void)
{
if (captured)
ReleaseCapture(), captured = 0; // free mouse
// free DirectX objects
if (lpSurfaces[0])
IDirectDrawSurface_Release(lpSurfaces[0]);
lpSurfaces[0] = NULL;
if (BackSurface[0])
IDirectDrawSurface_Release(BackSurface[0]);
BackSurface[0] = NULL;
if (BackSurface[1])
IDirectDrawSurface_Release(BackSurface[1]);
BackSurface[1] = NULL;
if (dxPalette)
IDirectDrawPalette_Release(dxPalette);
dxPalette = NULL;
if (lpDD2)
IDirectDraw2_Release(lpDD2);
lpDD2 = NULL;
if (lpDD)
IDirectDraw_Release(lpDD);
lpDD = NULL;
DeInitWindow();
if (hModule != NULL)
FreeLibrary(hModule), hModule = NULL;
hWnd = NULL;
directX = 0;
}
EXPORT void CALL angrylionRomClosed (void)
{
rdp_close();
#ifdef HAVE_DIRECTDRAW
if (lpddsback)
{
IDirectDrawSurface_Release(lpddsback);
lpddsback = 0;
}
if (lpddsprimary)
{
IDirectDrawSurface_Release(lpddsprimary);
lpddsprimary = 0;
}
if (lpdd)
{
IDirectDraw_Release(lpdd);
lpdd = 0;
}
#else
if (blitter_buf)
free(blitter_buf);
#endif
SaveLoaded = 1;
command_counter = 0;
}
static void releasedirectdraw(void)
{
if( lpDD != NULL )
{
IDirectDraw_Release(lpDD);
lpDD = NULL;
}
}
static void WINAPI VGA_DoExit(ULONG_PTR arg)
{
VGA_DeinstallTimer();
IDirectDrawSurface_SetPalette(lpddsurf,NULL);
IDirectDrawSurface_Release(lpddsurf);
lpddsurf=NULL;
IDirectDrawPalette_Release(lpddpal);
lpddpal=NULL;
IDirectDraw_Release(lpddraw);
lpddraw=NULL;
}
void DDKill()
{
// Perform cleanup for full screen case and window case
DDKillScreen();
if (_lpDDPalette) IDirectDrawPalette_Release(_lpDDPalette);
if (_lpDD) IDirectDraw_Release(_lpDD);
_DDExclusive = _DDFullScreen = FALSE;
_DDNumModes = 0;
_DDLockCounter = 0;
_lpDD = NULL;
}
static int vo_dx_uninit(void)
{
if (NULL != g_lpddclipper) {
g_lpddclipper->lpVtbl->Release(g_lpddclipper);
}
g_lpddclipper = NULL;
av_log(NULL, AV_LOG_INFO, "vo_directx: clipper released\n");
if (NULL != g_lpddsBack) {
IDirectDrawSurface_Release(g_lpddsBack);
}
g_lpddsBack = NULL;
av_log(NULL, AV_LOG_INFO, "vo_directx: back surface released\n");
if (g_lpddsOverlay != NULL) {
IDirectDrawSurface_Release(g_lpddsOverlay);
}
g_lpddsOverlay = NULL;
av_log(NULL, AV_LOG_INFO, "vo_directx: overlay surface released\n");
if (g_lpddsPrimary != NULL) {
IDirectDrawSurface_Release(g_lpddsPrimary);
}
g_lpddsPrimary = NULL;
av_log(NULL, AV_LOG_INFO, "vo_directx: primary released\n");
if (g_fs_hwnd) {
DestroyWindow(g_fs_hwnd);
}
g_fs_hwnd = NULL;
if (g_hwnd) {
DestroyWindow(g_hwnd);
}
g_hwnd = NULL;
av_log(NULL, AV_LOG_INFO, "vo_directx: window destroyed\n");
UnregisterClass(WND_CLASSNAME, GetModuleHandle(NULL));
UnregisterClass(FS_CLASSNAME, GetModuleHandle(NULL));
if (g_lpdd != NULL) {
IDirectDraw_Release(g_lpdd);
g_lpdd = NULL;
}
if (hddraw_dll) {
FreeLibrary(hddraw_dll);
hddraw_dll = NULL;
}
return 0;
}
static void releasedirectdraw(void)
{
if( lpDD != NULL )
{
IDirectDraw_Release(lpDD);
lpDD = NULL;
SetRect(&rect_after_delete, 0, 0,
GetSystemMetrics(SM_CXSCREEN),
GetSystemMetrics(SM_CYSCREEN));
ok(EqualRect(&rect_before_create, &rect_after_delete) != 0,
"Original display mode was not restored\n");
}
}
void Destroy( win32_driver_t * win32_driver )
{
if( win32_driver->ddclipper )
IDirectDrawClipper_Release( win32_driver->ddclipper );
if( win32_driver->primary )
IDirectDrawSurface7_Release( win32_driver->primary );
if( win32_driver->secondary )
IDirectDrawSurface7_Release( win32_driver->secondary );
if( win32_driver->ddobj )
IDirectDraw_Release( win32_driver->ddobj );
free( win32_driver );
}
Err GE2DLibClose()
{
if (DDPrimary)
{
IDirectDrawSurface_Release(DDPrimary);
DDPrimary = NULL;
}
if (DD)
{
IDirectDraw_Release(DD);
DD = NULL;
}
if (Module)
FreeLibrary(Module);
return errNone;
}
static void Destroy( win32_driver_t * win32_driver )
{
if( win32_driver->ddclipper )
IDirectDrawClipper_Release( win32_driver->ddclipper );
if( win32_driver->primary )
IDirectDrawSurface_Release( win32_driver->primary );
if( win32_driver->secondary )
IDirectDrawSurface_Release( win32_driver->secondary );
if( win32_driver->ddobj )
IDirectDraw_Release( win32_driver->ddobj );
_x_alphablend_free(&win32_driver->alphablend_extra_data);
free( win32_driver );
}
static HRESULT WINAPI ddrawex_surface4_Initialize(IDirectDrawSurface4 *iface,
IDirectDraw *ddraw, DDSURFACEDESC2 *desc)
{
struct ddrawex_surface *surface = impl_from_IDirectDrawSurface4(iface);
IDirectDraw4 *outer_DD4;
IDirectDraw4 *inner_DD4;
IDirectDraw *inner_DD;
HRESULT hr;
TRACE("iface %p, ddraw %p, desc %p.\n", iface, ddraw, desc);
IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw4, (void **)&outer_DD4);
inner_DD4 = dd_get_inner(outer_DD4);
IDirectDraw4_Release(outer_DD4);
IDirectDraw4_QueryInterface(inner_DD4, &IID_IDirectDraw4, (void **)&inner_DD);
hr = IDirectDrawSurface4_Initialize(surface->parent, inner_DD, desc);
IDirectDraw_Release(inner_DD);
return hr;
}
static void
winFreeFBShadowDDNL(ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
/* Free the shadow surface, if there is one */
if (pScreenPriv->pddsShadow4)
{
IDirectDrawSurface4_Release (pScreenPriv->pddsShadow4);
free (pScreenInfo->pfb);
pScreenInfo->pfb = NULL;
pScreenPriv->pddsShadow4 = NULL;
}
/* Detach the clipper from the primary surface and release the primary surface, if there is one */
winReleasePrimarySurfaceShadowDDNL(pScreen);
/* Release the clipper object */
if (pScreenPriv->pddcPrimary)
{
IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
pScreenPriv->pddcPrimary = NULL;
}
/* Free the DirectDraw4 object, if there is one */
if (pScreenPriv->pdd4)
{
IDirectDraw4_RestoreDisplayMode (pScreenPriv->pdd4);
IDirectDraw4_Release (pScreenPriv->pdd4);
pScreenPriv->pdd4 = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd)
{
IDirectDraw_Release (pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
}
static void testddraw7(void)
{
IDirectDraw7 *dd7;
HRESULT hr;
DDDEVICEIDENTIFIER2 *pdddi2;
DWORD dddi2Bytes;
DWORD *pend;
hr = IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw7, (void **) &dd7);
if (hr==E_NOINTERFACE)
{
win_skip("DirectDraw7 is not supported\n");
return;
}
ok(hr==DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr);
if (hr==DD_OK)
{
dddi2Bytes = FIELD_OFFSET(DDDEVICEIDENTIFIER2, dwWHQLLevel) + sizeof(DWORD);
pdddi2 = HeapAlloc( GetProcessHeap(), 0, dddi2Bytes + 2*sizeof(DWORD) );
pend = (DWORD *)((char *)pdddi2 + dddi2Bytes);
pend[0] = 0xdeadbeef;
pend[1] = 0xdeadbeef;
hr = IDirectDraw7_GetDeviceIdentifier(dd7, pdddi2, 0);
ok(hr==DD_OK, "get device identifier failed with %08x\n", hr);
if (hr==DD_OK)
{
/* check how strings are copied into the structure */
ok(pdddi2->szDriver[MAX_DDDEVICEID_STRING - 1]==0, "szDriver not cleared\n");
ok(pdddi2->szDescription[MAX_DDDEVICEID_STRING - 1]==0, "szDescription not cleared\n");
/* verify that 8 byte structure size alignment will not overwrite memory */
ok(pend[0]==0xdeadbeef || broken(pend[0] != 0xdeadbeef), /* win2k */
"memory beyond DDDEVICEIDENTIFIER2 overwritten\n");
ok(pend[1]==0xdeadbeef, "memory beyond DDDEVICEIDENTIFIER2 overwritten\n");
}
IDirectDraw_Release(dd7);
HeapFree( GetProcessHeap(), 0, pdddi2 );
}
}
EXPORT void CALL RomClosed (void)
{
rdp_close();
if (lpddsback)
{
IDirectDrawSurface_Release(lpddsback);
lpddsback = 0;
}
if (lpddsprimary)
{
IDirectDrawSurface_Release(lpddsprimary);
lpddsprimary = 0;
}
if (lpdd)
{
IDirectDraw_Release(lpdd);
lpdd = 0;
}
SaveLoaded = 1;
command_counter = 0;
}
void d3drm_device_destroy(struct d3drm_device *device)
{
d3drm_object_cleanup((IDirect3DRMObject *)&device->IDirect3DRMDevice_iface, &device->obj);
if (device->device)
{
TRACE("Releasing attached ddraw interfaces.\n");
IDirect3DDevice_Release(device->device);
}
if (device->render_target)
IDirectDrawSurface_Release(device->render_target);
if (device->primary_surface)
{
TRACE("Releasing primary surface and attached clipper.\n");
IDirectDrawSurface_Release(device->primary_surface);
IDirectDrawClipper_Release(device->clipper);
}
if (device->ddraw)
{
IDirectDraw_Release(device->ddraw);
IDirect3DRM_Release(device->d3drm);
}
HeapFree(GetProcessHeap(), 0, device);
}
static void CapsTest(void)
{
DDSURFACEDESC ddsd;
IDirectDraw *dd1 = createDD();
IDirectDrawSurface *surf;
HRESULT hr;
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY | DDSCAPS_VIDEOMEMORY;
ddsd.dwWidth = 64;
ddsd.dwHeight = 64;
hr = IDirectDraw_CreateSurface(dd1, &ddsd, &surf, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
return;
}
ok(hr == DD_OK, "Creating a SYSMEM | VIDMEM surface returned 0x%08x, expected DD_OK\n", hr);
if(surf) IDirectDrawSurface_Release(surf);
IDirectDraw_Release(dd1);
}
static int create_directdraw(void)
{
HRESULT hr;
IDirectDraw* pdd = NULL;
DDSURFACEDESC2 ddsd;
hr = DirectDrawCreate(NULL, &pdd, NULL);
ok(hr==DD_OK, "DirectDrawCreate returned: %x\n", hr);
if (hr != DD_OK)
goto error;
hr = IDirectDraw_QueryInterface(pdd, &IID_IDirectDraw7, (LPVOID*)&pdd7);
ok(hr==DD_OK, "QueryInterface returned: %x\n", hr);
if (hr != DD_OK) goto error;
hr = IDirectDraw7_SetCooperativeLevel(pdd7, GetDesktopWindow(), DDSCL_NORMAL);
ok(hr==DD_OK, "SetCooperativeLevel returned: %x\n", hr);
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
hr = IDirectDraw7_CreateSurface(pdd7, &ddsd, &pdds7, NULL);
ok(hr==DD_OK, "CreateSurface returned: %x\n", hr);
return TRUE;
error:
if (pdds7)
IDirectDrawSurface7_Release(pdds7);
if (pdd7)
IDirectDraw7_Release(pdd7);
if (pdd)
IDirectDraw_Release(pdd);
return FALSE;
}
/*******************************************************************************
* IDirectDrawFactoryImpl_CreateDirectDraw
*******************************************************************************/
static HRESULT WINAPI
IDirectDrawFactoryImpl_CreateDirectDraw(IDirectDrawFactory* iface,
GUID * pGUID,
HWND hWnd,
DWORD dwCoopLevelFlags,
DWORD dwReserved,
IUnknown *pUnkOuter,
IDirectDraw **ppDirectDraw)
{
HRESULT hr;
TRACE("\n");
hr = DirectDrawCreateEx(pGUID, (void**)ppDirectDraw, &IID_IDirectDraw3, pUnkOuter);
if (FAILED(hr))
return hr;
hr = IDirectDraw_SetCooperativeLevel(*ppDirectDraw, hWnd, dwCoopLevelFlags);
if (FAILED(hr))
IDirectDraw_Release(*ppDirectDraw);
return hr;
}
//
// Create the DirectDraw object for later
//
BOOL CreateDirectDrawInstance (VOID)
{
HRESULT hr;
IDirectDraw* DDr;
IDirectDraw** rp = &DDr;
IDirectDraw2** rp2 = &DDr2;
LPVOID *tp = (LPVOID *)rp2;
if (!LoadDirectDraw())
return FALSE;
//
// create an instance of DirectDraw object
//
if (FAILED(hr = pfnDirectDrawCreate(NULL, rp, NULL)))
I_Error("DirectDrawCreate FAILED: %s", DXErrorToString(hr));
// change interface to IDirectDraw2
if (FAILED(hr = IDirectDraw_QueryInterface(DDr, &IID_IDirectDraw2, tp)))
I_Error("Failed to query DirectDraw2 interface: %s", DXErrorToString(hr));
// release the interface we don't need
IDirectDraw_Release (DDr);
return TRUE;
}
static Bool
winCloseScreenShadowDD (int nIndex, ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
Bool fReturn;
#if CYGDEBUG
winDebug ("winCloseScreenShadowDD - Freeing screen resources\n");
#endif
/* Flag that the screen is closed */
pScreenPriv->fClosed = TRUE;
pScreenPriv->fActive = FALSE;
/* Call the wrapped CloseScreen procedure */
WIN_UNWRAP(CloseScreen);
fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
/* Free the screen DC */
ReleaseDC (pScreenPriv->hwndScreen, pScreenPriv->hdcScreen);
/* Delete the window property */
RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
/* Free the shadow surface, if there is one */
if (pScreenPriv->pddsShadow)
{
IDirectDrawSurface2_Unlock (pScreenPriv->pddsShadow, NULL);
IDirectDrawSurface2_Release (pScreenPriv->pddsShadow);
pScreenPriv->pddsShadow = NULL;
}
/* Detach the clipper from the primary surface and release the clipper. */
if (pScreenPriv->pddcPrimary)
{
/* Detach the clipper */
IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,
NULL);
/* Release the clipper object */
IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
pScreenPriv->pddcPrimary = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary)
{
IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
pScreenPriv->pddsPrimary = NULL;
}
/* Free the DirectDraw2 object, if there is one */
if (pScreenPriv->pdd2)
{
IDirectDraw2_RestoreDisplayMode (pScreenPriv->pdd2);
IDirectDraw2_Release (pScreenPriv->pdd2);
pScreenPriv->pdd2 = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd)
{
IDirectDraw_Release (pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Delete tray icon, if we have one */
if (!pScreenInfo->fNoTrayIcon)
winDeleteNotifyIcon (pScreenPriv);
/* Free the exit confirmation dialog box, if it exists */
if (g_hDlgExit != NULL)
{
DestroyWindow (g_hDlgExit);
g_hDlgExit = NULL;
}
/* Kill our window */
if (pScreenPriv->hwndScreen)
{
DestroyWindow (pScreenPriv->hwndScreen);
pScreenPriv->hwndScreen = NULL;
}
#if defined(XWIN_CLIPBOARD) || defined(XWIN_MULTIWINDOW)
/* Destroy the thread startup mutex */
pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
#endif
/* Kill our screeninfo's pointer to the screen */
pScreenInfo->pScreen = NULL;
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
/* Free the screen privates for this screen */
free ((pointer) pScreenPriv);
return fReturn;
}
static int DirectXOpenDDraw(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
HRESULT hr;
/* */
HRESULT (WINAPI *OurDirectDrawCreate)(GUID *,LPDIRECTDRAW *,IUnknown *);
OurDirectDrawCreate =
(void *)GetProcAddress(sys->hddraw_dll, _T("DirectDrawCreate"));
if (!OurDirectDrawCreate) {
msg_Err(vd, "DirectXInitDDraw failed GetProcAddress");
return VLC_EGENERIC;
}
/* */
HRESULT (WINAPI *OurDirectDrawEnumerateEx)(LPDDENUMCALLBACKEXA, LPVOID, DWORD);
OurDirectDrawEnumerateEx =
(void *)GetProcAddress(sys->hddraw_dll, _T("DirectDrawEnumerateExA"));
if (OurDirectDrawEnumerateEx) {
char *device = var_GetString(vd, "directx-device");
if (device) {
msg_Dbg(vd, "directx-device: %s", device);
free(device);
}
sys->hmonitor = MonitorFromWindow(sys->hwnd, MONITOR_DEFAULTTONEAREST);
/* Enumerate displays */
OurDirectDrawEnumerateEx(DirectXOpenDDrawCallback,
vd, DDENUM_ATTACHEDSECONDARYDEVICES);
}
/* Initialize DirectDraw now */
LPDIRECTDRAW ddobject;
hr = OurDirectDrawCreate(sys->display_driver, &ddobject, NULL);
if (hr != DD_OK) {
msg_Err(vd, "DirectXInitDDraw cannot initialize DDraw");
return VLC_EGENERIC;
}
/* Get the IDirectDraw2 interface */
hr = IDirectDraw_QueryInterface(ddobject, &IID_IDirectDraw2,
&sys->ddobject);
/* Release the unused interface */
IDirectDraw_Release(ddobject);
if (hr != DD_OK) {
msg_Err(vd, "cannot get IDirectDraw2 interface");
sys->ddobject = NULL;
return VLC_EGENERIC;
}
/* Set DirectDraw Cooperative level, ie what control we want over Windows
* display */
hr = IDirectDraw2_SetCooperativeLevel(sys->ddobject, NULL, DDSCL_NORMAL);
if (hr != DD_OK) {
msg_Err(vd, "cannot set direct draw cooperative level");
return VLC_EGENERIC;
}
/* Get the size of the current display device */
if (sys->hmonitor) {
MONITORINFO monitor_info;
monitor_info.cbSize = sizeof(MONITORINFO);
GetMonitorInfoA(vd->sys->hmonitor, &monitor_info);
sys->rect_display = monitor_info.rcMonitor;
} else {
sys->rect_display.left = 0;
sys->rect_display.top = 0;
sys->rect_display.right = GetSystemMetrics(SM_CXSCREEN);
sys->rect_display.bottom = GetSystemMetrics(SM_CYSCREEN);
}
msg_Dbg(vd, "screen dimensions (%lix%li,%lix%li)",
sys->rect_display.left,
sys->rect_display.top,
sys->rect_display.right,
sys->rect_display.bottom);
/* Probe the capabilities of the hardware */
DirectXGetDDrawCaps(vd);
return VLC_SUCCESS;
}
static void test_IDirectDrawStreamSample(void)
{
DDSURFACEDESC desc = { sizeof(desc) };
IAMMultiMediaStream *pams;
HRESULT hr;
IMediaStream *pvidstream = NULL;
IDirectDrawMediaStream *pddstream = NULL;
IDirectDrawStreamSample *pddsample = NULL;
IDirectDrawSurface7 *surface7;
IDirectDrawSurface *surface, *surface2;
IDirectDraw *ddraw, *ddraw2;
IDirectDraw7 *ddraw7;
RECT rect;
if (!(pams = create_ammultimediastream()))
return;
if (!create_directdraw())
{
IAMMultiMediaStream_Release(pams);
return;
}
hr = IAMMultiMediaStream_Initialize(pams, STREAMTYPE_READ, 0, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IAMMultiMediaStream_AddMediaStream(pams, (IUnknown*)pdd7, &MSPID_PrimaryVideo, 0, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IAMMultiMediaStream_GetMediaStream(pams, &MSPID_PrimaryVideo, &pvidstream);
ok(hr == S_OK, "got 0x%08x\n", hr);
if (FAILED(hr)) goto error;
hr = IMediaStream_QueryInterface(pvidstream, &IID_IDirectDrawMediaStream, (LPVOID*)&pddstream);
ok(hr == S_OK, "got 0x%08x\n", hr);
if (FAILED(hr)) goto error;
hr = IDirectDrawMediaStream_GetDirectDraw(pddstream, &ddraw);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IDirectDrawMediaStream_GetDirectDraw(pddstream, &ddraw2);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(ddraw == ddraw2, "got %p, %p\n", ddraw, ddraw2);
hr = IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw7, (void**)&ddraw7);
ok(hr == S_OK, "got 0x%08x\n", hr);
IDirectDraw7_Release(ddraw7);
IDirectDraw_Release(ddraw2);
IDirectDraw_Release(ddraw);
hr = IDirectDrawMediaStream_CreateSample(pddstream, NULL, NULL, 0, &pddsample);
ok(hr == S_OK, "got 0x%08x\n", hr);
surface = NULL;
hr = IDirectDrawStreamSample_GetSurface(pddsample, &surface, &rect);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(surface != NULL, "got %p\n", surface);
hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirectDrawSurface7, (void**)&surface7);
ok(hr == S_OK, "got 0x%08x\n", hr);
IDirectDrawSurface7_Release(surface7);
hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(desc.dwWidth == 100, "width %d\n", desc.dwWidth);
ok(desc.dwHeight == 100, "height %d\n", desc.dwHeight);
ok(desc.ddpfPixelFormat.dwFlags == DDPF_RGB, "format flags %08x\n", desc.ddpfPixelFormat.dwFlags);
ok(desc.ddpfPixelFormat.dwRGBBitCount, "dwRGBBitCount %d\n", desc.ddpfPixelFormat.dwRGBBitCount);
IDirectDrawSurface_Release(surface);
IDirectDrawStreamSample_Release(pddsample);
hr = IDirectDrawSurface7_QueryInterface(pdds7, &IID_IDirectDrawSurface, (void**)&surface);
ok(hr == S_OK, "got 0x%08x\n", hr);
EXPECT_REF(surface, 1);
hr = IDirectDrawMediaStream_CreateSample(pddstream, surface, NULL, 0, &pddsample);
ok(hr == S_OK, "got 0x%08x\n", hr);
EXPECT_REF(surface, 2);
surface2 = NULL;
memset(&rect, 0, sizeof(rect));
hr = IDirectDrawStreamSample_GetSurface(pddsample, &surface2, &rect);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(surface == surface2, "got %p\n", surface2);
ok(rect.right > 0 && rect.bottom > 0, "got %d, %d\n", rect.right, rect.bottom);
EXPECT_REF(surface, 3);
IDirectDrawSurface_Release(surface2);
hr = IDirectDrawStreamSample_GetSurface(pddsample, NULL, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
IDirectDrawStreamSample_Release(pddsample);
IDirectDrawSurface_Release(surface);
error:
if (pddstream)
IDirectDrawMediaStream_Release(pddstream);
if (pvidstream)
IMediaStream_Release(pvidstream);
release_directdraw();
IAMMultiMediaStream_Release(pams);
}
BOOL DDInit(int mode)
{
LPDIRECTDRAW lpdd;
DDCAPS ddcaps, ddcaps2;
HRESULT ddresult;
int num;
DDWnd = GetLibraryWindow();
// Create Direct Draw Object (Use Emulation if Hardware is off)
if (!_lpDD) {
ddresult = DirectDrawCreate(NULL, &lpdd, NULL);
if (ddresult == DDERR_NODIRECTDRAWHW) {
ddresult = DirectDrawCreate( (LPVOID) DDCREATE_EMULATIONONLY, &lpdd, NULL );
if (!CheckDDResult(ddresult, "InitDD:DirectDrawCreate emulation"))
return FALSE;
DDUseEmulation = TRUE;
logentry("DirectDraw: forcing emulation.\n");
}
else if (ddresult != DD_OK) return FALSE;
logentry("DirectDraw: DirectX API hardware compliant.\n");
}
else return FALSE;
atexit(DDKill);
// Determine hardware caps
// Determine capture mode (fullscreen takes exclusive, window is normal)
if (mode == DDGR_FULLSCREEN) {
DWORD flags;
flags = DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN;
#ifndef NDEBUG
if (!FindArg("-nomodex")) flags |= DDSCL_ALLOWMODEX;
#else
flags |= DDSCL_ALLOWMODEX;
#endif
if (!FindArg("-disallowreboot")) flags |= DDSCL_ALLOWREBOOT;
ddresult = IDirectDraw_SetCooperativeLevel(lpdd, DDWnd, flags);
if (!CheckDDResult(ddresult, "DDInit::SetCooperativeLevel")) {
IDirectDraw_Release(lpdd);
return FALSE;
}
_DDExclusive = TRUE;
_DDFullScreen = TRUE;
}
else if (mode == DDGR_EXWINDOW) {
ddresult = IDirectDraw_SetCooperativeLevel(lpdd, DDWnd,
DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN);
if (!CheckDDResult(ddresult, "DDInit::SetCooperativeLevel"))
return FALSE;
_DDExclusive = TRUE;
_DDFullScreen = FALSE;
}
else if (mode == DDGR_WINDOW) {
ddresult = IDirectDraw_SetCooperativeLevel(lpdd, DDWnd,
DDSCL_NORMAL);
if (!CheckDDResult(ddresult, "DDInit::SetCooperativeLevel"))
return FALSE;
_DDExclusive = FALSE;
_DDFullScreen = FALSE;
}
else return FALSE;
// Get Display modes/Window Sizes
// Force invalidation of all modes for now
for (num = 0; num < 16; num++)
{
_DDModeList[num].rw = _DDModeList[num].w = -1;
_DDModeList[num].rh = _DDModeList[num].h = -1;
}
W95DisplayMode = SM95_640x480x8;
num = 0;
if (mode == DDGR_FULLSCREEN) {
ddresult = IDirectDraw_EnumDisplayModes(lpdd, 0, NULL, 0,
EnumDispModesCB);
if(!CheckDDResult(ddresult, "DDInit::EnumDisplayModes")) {
IDirectDraw_Release(lpdd);
return FALSE;
}
}
else if (mode == DDGR_EXWINDOW) {
_DDModeList[SM95_320x200x8X].rw = 320;
_DDModeList[SM95_320x200x8X].rh = 200;
_DDModeList[SM95_320x200x8X].w = 640;
_DDModeList[SM95_320x200x8X].h = 480;
_DDModeList[SM95_320x200x8X].emul = 1;
_DDModeList[SM95_320x200x8X].dbuf = 0;
_DDModeList[SM95_320x200x8X].modex = 0;
_DDModeList[SM95_320x200x8X].paged = 0;
_DDModeList[SM95_640x480x8].rw = 640;
_DDModeList[SM95_640x480x8].rh = 480;
_DDModeList[SM95_640x480x8].w = 640;
_DDModeList[SM95_640x480x8].h = 480;
_DDModeList[SM95_640x480x8].emul = 1;
_DDModeList[SM95_640x480x8].dbuf = 0;
_DDModeList[SM95_640x480x8].modex = 0;
_DDModeList[SM95_640x480x8].paged = 0;
_DDModeList[SM95_800x600x8].rw = 800;
_DDModeList[SM95_800x600x8].rh = 600;
_DDModeList[SM95_800x600x8].w = 640;
_DDModeList[SM95_800x600x8].h = 480;
_DDModeList[SM95_800x600x8].emul = 1;
_DDModeList[SM95_800x600x8].dbuf = 0;
_DDModeList[SM95_800x600x8].modex = 0;
_DDModeList[SM95_800x600x8].paged = 0;
_DDNumModes = 3;
}
else if (mode == DDGR_WINDOW) {
_DDModeList[SM95_320x200x8X].rw = 320;
_DDModeList[SM95_320x200x8X].rh = 200;
_DDModeList[SM95_320x200x8X].w = 640;
_DDModeList[SM95_320x200x8X].h = 480;
_DDModeList[SM95_320x200x8X].emul = 1;
_DDModeList[SM95_320x200x8X].dbuf = 0;
_DDModeList[SM95_320x200x8X].modex = 0;
_DDModeList[SM95_320x200x8X].paged = 0;
_DDModeList[SM95_640x480x8].rw = 640;
_DDModeList[SM95_640x480x8].rh = 480;
_DDModeList[SM95_640x480x8].w = 640;
_DDModeList[SM95_640x480x8].h = 480;
_DDModeList[SM95_640x480x8].emul = 1;
_DDModeList[SM95_640x480x8].dbuf = 0;
_DDModeList[SM95_640x480x8].modex = 0;
_DDModeList[SM95_640x480x8].paged = 0;
_DDModeList[SM95_800x600x8].rw = 800;
_DDModeList[SM95_800x600x8].rh = 600;
_DDModeList[SM95_800x600x8].w = 800;
_DDModeList[SM95_800x600x8].h = 600;
_DDModeList[SM95_800x600x8].emul = 1;
_DDModeList[SM95_800x600x8].dbuf = 0;
_DDModeList[SM95_800x600x8].modex = 0;
_DDModeList[SM95_800x600x8].paged = 0;
_DDNumModes = 3;
}
else return FALSE;
// Set appropriate display mode or window mode
_lpDD = lpdd;
memset(&ddcaps, 0, sizeof(ddcaps));
ddcaps.dwSize = sizeof(ddcaps);
ddcaps2.dwSize = sizeof(ddcaps);
ddresult = IDirectDraw_GetCaps(_lpDD, &ddcaps, NULL);
if (!CheckDDResult(ddresult, "InitDD::GetCaps"))
return FALSE;
logentry("DirectDraw: VRAM free: %d\n", ddcaps.dwVidMemFree);
logentry("DirectDraw: VRAM total: %d\n", ddcaps.dwVidMemTotal);
#ifndef NDEBUG
if (FindArg("-TsengDebug1")) {
IDirectDraw_Release(lpdd);
return FALSE;
}
#endif
DDSetDisplayMode(W95DisplayMode, 0);
#ifndef NDEBUG
if (FindArg("-TsengDebug2")) {
IDirectDraw_Release(lpdd);
return FALSE;
}
#endif
// If 'windowed' do this.
if (!_DDFullScreen)
{
ddresult = IDirectDraw_CreateClipper(_lpDD, 0, &_lpDDClipper, NULL);
if (!CheckDDResult(ddresult, "DDCreateScreen::CreateClipper"))
return FALSE;
ddresult = IDirectDrawClipper_SetHWnd(_lpDDClipper, 0, DDWnd);
if (!CheckDDResult(ddresult, "DDCreateScreen::SetHWnd"))
return FALSE;
ddresult = IDirectDrawSurface_SetClipper(_lpDDSPrimary, _lpDDClipper);
if (!CheckDDResult(ddresult, "DDCreateScreen::SetClipper"))
return FALSE;
}
// Register Optimizations
ddcaps.dwSize = sizeof(ddcaps);
ddcaps2.dwSize = sizeof(ddcaps);
ddresult = IDirectDraw_GetCaps(lpdd, &ddcaps, &ddcaps2);
if (!CheckDDResult(ddresult, "DDInit::GetCaps"))
return FALSE;
#ifndef NDEBUG
if (FindArg("-TsengDebug3")) {
IDirectDraw_Release(lpdd);
return FALSE;
}
#endif
if (FindArg("-vidram")) {
logentry("DirectDraw: Forcing VRAM rendering.\n");
_DDSysMemSurfacing = FALSE;
}
else if (FindArg("-sysram")) {
logentry("DirectDraw: Forcing SRAM rendering.\n");
_DDSysMemSurfacing = TRUE;
}
else if (ddcaps.dwCaps & DDCAPS_BANKSWITCHED) {
logentry("DirectDraw: Hardware is bank-switched. Using SRAM rendering.\n");
_DDSysMemSurfacing = TRUE;
}
else {
logentry("DirectDraw: Hardware is not bank-switched. Using VRAM rendering.\n");
_DDSysMemSurfacing = FALSE;
}
if (ddcaps.dwCaps & DDCAPS_COLORKEYHWASSIST)
ddDriverCaps.hwcolorkey = 1;
else
ddDriverCaps.hwcolorkey = 0;
if (ddcaps.dwCaps & DDCAPS_BLTSTRETCH)
ddDriverCaps.hwbltstretch = 1;
else
ddDriverCaps.hwbltstretch = 0;
//@@ mprintf((0, "DD::Hardware="));
//@@ if (ddcaps.dwCaps & DDCAPS_NOHARDWARE) mprintf((0, "Off\n"));
//@@ else mprintf((0, "On\n"));
//@@
//@@ mprintf((0, "DD::VideoMem=%u bytes\n", ddcaps.dwVidMemTotal));
//@@ mprintf((0, "DD::SrcColorKey="));
//@@ if (ddcaps.dwCKeyCaps & DDCKEYCAPS_SRCBLT) mprintf((0, "Hardware\n"));
//@@ else mprintf((0, "Emulation\n"));
return TRUE;
}
static HRESULT ddrawstreamsample_create(IDirectDrawMediaStream *parent, IDirectDrawSurface *surface,
const RECT *rect, IDirectDrawStreamSample **ddraw_stream_sample)
{
IDirectDrawStreamSampleImpl *object;
HRESULT hr;
TRACE("(%p)\n", ddraw_stream_sample);
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
if (!object)
return E_OUTOFMEMORY;
object->IDirectDrawStreamSample_iface.lpVtbl = &DirectDrawStreamSample_Vtbl;
object->ref = 1;
object->parent = (IMediaStream*)parent;
IMediaStream_AddRef(object->parent);
if (surface)
{
object->surface = surface;
IDirectDrawSurface_AddRef(surface);
}
else
{
DDSURFACEDESC desc;
IDirectDraw *ddraw;
hr = IDirectDrawMediaStream_GetDirectDraw(parent, &ddraw);
if (FAILED(hr))
{
IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
return hr;
}
desc.dwSize = sizeof(desc);
desc.dwFlags = DDSD_CAPS|DDSD_HEIGHT|DDSD_WIDTH|DDSD_PIXELFORMAT;
desc.dwHeight = 100;
desc.dwWidth = 100;
desc.ddpfPixelFormat.dwSize = sizeof(desc.ddpfPixelFormat);
desc.ddpfPixelFormat.dwFlags = DDPF_RGB;
desc.ddpfPixelFormat.dwRGBBitCount = 32;
desc.ddpfPixelFormat.dwRBitMask = 0xff0000;
desc.ddpfPixelFormat.dwGBitMask = 0x00ff00;
desc.ddpfPixelFormat.dwBBitMask = 0x0000ff;
desc.ddpfPixelFormat.dwRGBAlphaBitMask = 0;
desc.ddsCaps.dwCaps = DDSCAPS_SYSTEMMEMORY|DDSCAPS_OFFSCREENPLAIN;
desc.lpSurface = NULL;
hr = IDirectDraw_CreateSurface(ddraw, &desc, &object->surface, NULL);
IDirectDraw_Release(ddraw);
if (FAILED(hr))
{
ERR("failed to create surface, 0x%08x\n", hr);
IDirectDrawStreamSample_Release(&object->IDirectDrawStreamSample_iface);
return hr;
}
}
if (rect)
object->rect = *rect;
else if (object->surface)
{
DDSURFACEDESC desc = { sizeof(desc) };
hr = IDirectDrawSurface_GetSurfaceDesc(object->surface, &desc);
if (hr == S_OK)
{
object->rect.left = object->rect.top = 0;
object->rect.right = desc.dwWidth;
object->rect.bottom = desc.dwHeight;
}
}
*ddraw_stream_sample = &object->IDirectDrawStreamSample_iface;
return S_OK;
}
boolean CreatePrimary( win32_driver_t * win32_driver )
{
LPDIRECTDRAW ddobj;
DDSURFACEDESC2 ddsd;
HRESULT result;
// create direct draw object
result = DirectDrawCreate( 0, &ddobj, 0 );
if( result != DD_OK )
{
Error( 0, "DirectDrawCreate : error %i", result );
printf( "vo_out_directx : DirectDrawCreate : error %i\n", result );
return 0;
}
// set cooperative level
result = IDirectDraw_SetCooperativeLevel( ddobj, win32_driver->win32_visual->WndHnd, DDSCL_NORMAL );
if( result != DD_OK )
{
Error( 0, "SetCooperativeLevel : error %i", result );
return 0;
}
// try to get new interface
result = IDirectDraw_QueryInterface( ddobj, &IID_IDirectDraw7, (LPVOID *) &win32_driver->ddobj );
if( result != DD_OK )
{
Error( 0, "ddobj->QueryInterface : DirectX 7 or higher required" );
return 0;
}
// release our old interface
IDirectDraw_Release( ddobj );
// create primary_surface
memset( &ddsd, 0, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
result = IDirectDraw7_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->primary, 0 );
if( result != DD_OK )
{
Error( 0, "CreateSurface ( primary ) : error %i ", result );
return 0;
}
// create our clipper object
result = IDirectDraw7_CreateClipper( win32_driver->ddobj, 0, &win32_driver->ddclipper, 0 );
if( result != DD_OK )
{
Error( 0, "CreateClipper : error %i", result );
return 0;
}
// associate our clipper with our window
result = IDirectDrawClipper_SetHWnd( win32_driver->ddclipper, 0, win32_driver->win32_visual->WndHnd );
if( result != DD_OK )
{
Error( 0, "ddclipper->SetHWnd : error %i", result );
return 0;
}
// associate our primary surface with our clipper
result = IDirectDrawSurface7_SetClipper( win32_driver->primary, win32_driver->ddclipper );
if( result != DD_OK )
{
Error( 0, "ddclipper->SetHWnd : error %i", result );
return 0;
}
// store our objects in our visual struct
UpdateRect( win32_driver->win32_visual );
return 1;
}
