static void
winFreeFBPrimaryDD(ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
/* Free the offscreen surface, if there is one */
if (pScreenPriv->pddsOffscreen) {
IDirectDrawSurface2_Unlock(pScreenPriv->pddsOffscreen, NULL);
IDirectDrawSurface2_Release(pScreenPriv->pddsOffscreen);
pScreenPriv->pddsOffscreen = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary) {
IDirectDrawSurface2_Unlock(pScreenPriv->pddsPrimary, NULL);
IDirectDrawSurface2_Release(pScreenPriv->pddsPrimary);
pScreenPriv->pddsPrimary = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd) {
IDirectDraw2_RestoreDisplayMode(pScreenPriv->pdd);
IDirectDraw2_Release(pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
}
int directdraw_uninit(void)
{
if(!video_window) return 0;
if(!lpDDS) return 0;
KillTimer(video_window, 131);
if(lpDDS_secondary) IDirectDrawSurface2_Release(lpDDS_secondary);
if(lpDDS) IDirectDrawSurface2_Release(lpDDS);
if(surface_osd) IDirectDrawSurface2_Release(surface_osd);
if(lpDD) IDirectDraw2_RestoreDisplayMode(lpDD);
if(lpDD) IDirectDraw2_SetCooperativeLevel(lpDD, video_window, DDSCL_NORMAL);
if(lpDD) IDirectDraw2_Release(lpDD);
if(video_window) DestroyWindow(video_window);
if(library) FreeLibrary(library);
library = 0;
lpDD = 0;
lpDDS = 0;
lpDDS_secondary = 0;
surface_osd = 0;
video_window = 0;
return 1;
}
static Bool
winReleasePrimarySurfaceShadowDD (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
ErrorF ("winReleasePrimarySurfaceShadowDD - Hello\n");
/* Release the primary surface and clipper, if they exist */
if (pScreenPriv->pddsPrimary)
{
/*
* Detach the clipper from the primary surface.
* NOTE: We do this explicity for clarity. The Clipper is not released.
*/
IDirectDrawSurface2_SetClipper (pScreenPriv->pddsPrimary,
NULL);
ErrorF ("winReleasePrimarySurfaceShadowDD - Detached clipper\n");
/* Release the primary surface */
IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
pScreenPriv->pddsPrimary = NULL;
}
ErrorF ("winReleasePrimarySurfaceShadowDD - Released primary surface\n");
return TRUE;
}
static void DirectXCloseDisplay(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
if (sys->clipper != NULL)
IDirectDrawClipper_Release(sys->clipper);
if (sys->display != NULL)
IDirectDrawSurface2_Release(sys->display);
sys->clipper = NULL;
sys->display = NULL;
}
void
DDReleaseSurface ( LPDIRECTDRAWSURFACE *ppOldSurface1, LPDIRECTDRAWSURFACE2 *ppOldSurface2 )
{
Assert ( ppOldSurface1 != NULL );
Assert ( ppOldSurface2 != NULL );
Assert ( *ppOldSurface1 != NULL );
Assert ( *ppOldSurface2 != NULL );
ATTEMPT ( IDirectDrawSurface2_Release ( *ppOldSurface2 ) );
ATTEMPT ( IDirectDrawSurface_Release ( *ppOldSurface1 ) );
*ppOldSurface1 = NULL;
*ppOldSurface2 = NULL;
}
static void
winFreeFBShadowDD (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
/* 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 primary surface, if there is one */
winReleasePrimarySurfaceShadowDD(pScreen);
/* Release the clipper object */
if (pScreenPriv->pddcPrimary)
{
IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
pScreenPriv->pddcPrimary = 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;
}
/* Invalidate the ScreenInfo's fb pointer */
pScreenInfo->pfb = NULL;
}
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 void DirectXDestroySurface(LPDIRECTDRAWSURFACE2 surface)
{
IDirectDrawSurface2_Release(surface);
}
/**
* Create an YUV overlay or RGB surface for the video.
*
* The best method of display is with an YUV overlay because the YUV->RGB
* conversion is done in hardware.
* You can also create a plain RGB surface.
* (Maybe we could also try an RGB overlay surface, which could have hardware
* scaling and which would also be faster in window mode because you don't
* need to do any blitting to the main display...)
*/
static int DirectXCreateSurface(vout_display_t *vd,
LPDIRECTDRAWSURFACE2 *surface,
const video_format_t *fmt,
DWORD fourcc,
bool use_overlay,
bool use_sysmem,
int backbuffer_count)
{
vout_display_sys_t *sys = vd->sys;
DDSURFACEDESC ddsd;
ZeroMemory(&ddsd, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.ddpfPixelFormat.dwSize = sizeof(ddsd.ddpfPixelFormat);
ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;
ddsd.dwWidth = fmt->i_width;
ddsd.dwHeight = fmt->i_height;
if (fourcc) {
ddsd.dwFlags |= DDSD_PIXELFORMAT;
ddsd.ddpfPixelFormat.dwFlags = DDPF_FOURCC;
ddsd.ddpfPixelFormat.dwFourCC = fourcc;
}
if (use_overlay) {
ddsd.dwFlags |= DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
if (backbuffer_count > 0)
ddsd.ddsCaps.dwCaps |= DDSCAPS_COMPLEX | DDSCAPS_FLIP;
if (backbuffer_count > 0) {
ddsd.dwFlags |= DDSD_BACKBUFFERCOUNT;
ddsd.dwBackBufferCount = backbuffer_count;
}
} else {
ddsd.dwFlags |= DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
if (use_sysmem)
ddsd.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY;
else
ddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
}
/* Create the video surface */
LPDIRECTDRAWSURFACE surface_v1;
if (IDirectDraw2_CreateSurface(sys->ddobject, &ddsd, &surface_v1, NULL) != DD_OK)
return VLC_EGENERIC;
/* Now that the surface is created, try to get a newer DirectX interface */
HRESULT hr = IDirectDrawSurface_QueryInterface(surface_v1,
&IID_IDirectDrawSurface2,
(LPVOID *)surface);
IDirectDrawSurface_Release(surface_v1);
if (hr != DD_OK) {
msg_Err(vd, "cannot query IDirectDrawSurface2 interface (error %li)", hr);
return VLC_EGENERIC;
}
if (use_overlay) {
/* Check the overlay is useable as some graphics cards allow creating
* several overlays but only one can be used at one time. */
if (DirectXUpdateOverlay(vd, *surface)) {
IDirectDrawSurface2_Release(*surface);
msg_Err(vd, "overlay unuseable (might already be in use)");
return VLC_EGENERIC;
}
}
return VLC_SUCCESS;
}
Bool
winCloseScreenPrimaryDD (int nIndex, ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
Bool fReturn;
ErrorF ("winCloseScreenPrimaryDD - Freeing screen resources\n");
/* Flag that the screen is closed */
pScreenPriv->fClosed = TRUE;
pScreenPriv->fActive = FALSE;
/* Call the wrapped CloseScreen procedure */
pScreen->CloseScreen = pScreenPriv->CloseScreen;
fReturn = (*pScreen->CloseScreen) (nIndex, pScreen);
/* Delete the window property */
RemoveProp (pScreenPriv->hwndScreen, WIN_SCR_PROP);
/* Free the offscreen surface, if there is one */
if (pScreenPriv->pddsOffscreen)
{
IDirectDrawSurface2_Unlock (pScreenPriv->pddsOffscreen, NULL);
IDirectDrawSurface2_Release (pScreenPriv->pddsOffscreen);
pScreenPriv->pddsOffscreen = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary)
{
IDirectDrawSurface2_Unlock (pScreenPriv->pddsPrimary, NULL);
IDirectDrawSurface2_Release (pScreenPriv->pddsPrimary);
pScreenPriv->pddsPrimary = NULL;
}
/* Free the DirectDraw object, if there is one */
if (pScreenPriv->pdd)
{
IDirectDraw2_RestoreDisplayMode (pScreenPriv->pdd);
IDirectDraw2_Release (pScreenPriv->pdd);
pScreenPriv->pdd = NULL;
}
/* Kill our window */
if (pScreenPriv->hwndScreen)
{
DestroyWindow (pScreenPriv->hwndScreen);
pScreenPriv->hwndScreen = NULL;
}
/* 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;
}
int directdraw_draw(void *pic, int w, int h)
{
DDSURFACEDESC descriptor;
RECT rct;
HWND hwndp;
#define fourcc(a,b,c,d) (( ((uint32_t)a) | ( ((uint32_t)b) << 8 ) | ( ((uint32_t)c) << 16 ) | ( ((uint32_t)d) << 24 ) ))
int bh = h, bw = w;
//w = default_sw;
//h = default_sh;
vdata.getdata(get_window_video, 0, &hwndp, 0);
if(!hwndp) return 0;
if(video_window_parent != hwndp)
{
video_uninit();
video_init(hwndp);
video_window_parent = hwndp;
}
if(w != d_width || h != d_height)
{
if(size_in_list(w, h))size_is_ok = 1;
else size_is_ok = 0;
if(w && h)
{
d_width = w;
d_height = h;
if(lpDDS_secondary)
IDirectDrawSurface2_Release(lpDDS_secondary);
memset(&descriptor, 0, sizeof(descriptor));
descriptor.dwSize = sizeof(descriptor);
descriptor.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
descriptor.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
descriptor.dwWidth = d_width;
descriptor.dwHeight = d_height;
if(FAILED(IDirectDraw2_CreateSurface(lpDD, &descriptor, &lpDDS_secondary, 0))) return 0;
lpDDS_back = lpDDS_secondary;
}
}
if(use_osd_surface)
{
GetClientRect(video_window, &rct);
if(rct.right != window_w || rct.bottom != window_h || osd_created == 0)
{
window_w = rct.right;
window_h = rct.bottom;
if(surface_osd)
IDirectDrawSurface2_Release(surface_osd);
memset( &descriptor, 0, sizeof(descriptor));
descriptor.dwSize = sizeof(descriptor);
descriptor.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
descriptor.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
descriptor.dwWidth = window_w;
descriptor.dwHeight = window_h;
if(FAILED(IDirectDraw2_CreateSurface(lpDD, &descriptor, &surface_osd, 0))) return 0;
osd_created = 1;
}
}
IDirectDrawSurface2_Restore(lpDDS);
if(pic)
IDirectDrawSurface2_Restore(lpDDS_secondary);
memset(&descriptor, 0, sizeof(descriptor));
descriptor.dwSize = sizeof(descriptor);
if(pic)
{
HRESULT res;
if(size_is_ok)
{
res = IDirectDrawSurface2_Lock(lpDDS_back, 0, &descriptor, DDLOCK_WAIT | DDLOCK_WRITEONLY, 0);
if(FAILED(res)) return 0;
memcpy(descriptor.lpSurface, pic, w * h * 4);
IDirectDrawSurface2_Unlock(lpDDS_back, descriptor.lpSurface);
}else{
HBITMAP bmp;
HDC hdc, cdc;
bmp = CreateBitmap(w, h, 1, 32, pic);
if(!FAILED(IDirectDrawSurface2_GetDC(lpDDS_back, &hdc)))
{
cdc = CreateCompatibleDC(0);
SelectObject(cdc, bmp);
BitBlt(hdc, 0, 0, w, h, cdc, 0, 0, SRCCOPY);
IDirectDrawSurface2_ReleaseDC(lpDDS_back, hdc);
DeleteDC(cdc);
}
DeleteObject(bmp);
}
IDirectDrawSurface2_Flip(lpDDS, 0, DDFLIP_WAIT);
}
return 1;
}
/* recreate_flipping_chain:
* Destroys the previous flipping chain and creates a new one.
*/
static int recreate_flipping_chain(int n_pages)
{
int w, h, type, n_backbuffers;
DDSCAPS ddscaps;
HRESULT hr;
ASSERT(n_pages > 0);
/* set flipping chain characteristics */
w = gfx_directx_forefront_bitmap->w;
h = gfx_directx_forefront_bitmap->h;
type = flipping_page[0]->flags & DDRAW_SURFACE_TYPE_MASK;
n_backbuffers = n_pages - 1;
/* release existing flipping chain */
if (flipping_page[0]->id) {
hr = IDirectDrawSurface2_Release(flipping_page[0]->id);
if (FAILED(hr)) {
_TRACE(PREFIX_E "Unable to release the primary surface (%s)", dd_err(hr));
return -1;
}
}
/* create the new flipping chain with the specified characteristics */
flipping_page[0]->id = create_directdraw2_surface(w, h, ddpixel_format, type, n_backbuffers);
if (!flipping_page[0]->id)
return -1;
/* retrieve the backbuffers */
if (n_backbuffers > 0) {
memset(&ddscaps, 0, sizeof(DDSCAPS));
/* first backbuffer */
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
hr = IDirectDrawSurface2_GetAttachedSurface(flipping_page[0]->id, &ddscaps, &flipping_page[1]->id);
if (FAILED(hr)) {
_TRACE(PREFIX_E "Unable to retrieve the first backbuffer (%s)", dd_err(hr));
return -1;
}
flipping_page[1]->flags = flipping_page[0]->flags;
flipping_page[1]->lock_nesting = 0;
if (n_backbuffers > 1) {
/* second backbuffer */
ddscaps.dwCaps = DDSCAPS_FLIP;
hr = IDirectDrawSurface2_GetAttachedSurface(flipping_page[1]->id, &ddscaps, &flipping_page[2]->id);
if (FAILED(hr)) {
_TRACE(PREFIX_E "Unable to retrieve the second backbuffer (%s)", dd_err(hr));
return -1;
}
flipping_page[2]->flags = flipping_page[0]->flags;
flipping_page[2]->lock_nesting = 0;
}
}
/* attach the global palette if needed */
if (flipping_page[0]->flags & DDRAW_SURFACE_INDEXED) {
hr = IDirectDrawSurface2_SetPalette(flipping_page[0]->id, ddpalette);
if (FAILED(hr)) {
_TRACE(PREFIX_E "Unable to attach the global palette (%s)", dd_err(hr));
return -1;
}
}
return 0;
}
/* gfx_directx_destroy_surface:
* Destroys a DirectDraw surface.
*/
void gfx_directx_destroy_surface(DDRAW_SURFACE *surf)
{
IDirectDrawSurface2_Release(surf->id);
unregister_ddraw_surface(surf);
_AL_FREE(surf);
}
static void GetDCTest_main(DDSURFACEDESC *ddsd, DDSURFACEDESC2 *ddsd2, void (*testfunc)(IDirectDrawSurface *surf, int ddsdver))
{
IDirectDrawSurface *surf;
IDirectDrawSurface2 *surf2;
IDirectDrawSurface2 *surf3;
IDirectDrawSurface4 *surf4;
HRESULT hr;
IDirectDraw *dd1 = createDD();
IDirectDraw2 *dd2;
IDirectDraw3 *dd3;
IDirectDraw4 *dd4;
hr = IDirectDraw_CreateSurface(dd1, ddsd, &surf, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
return;
}
ok(hr == DD_OK, "IDirectDraw_CreateSurface failed: 0x%08x\n", hr);
testfunc(surf, 1);
IDirectDrawSurface_Release(surf);
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw2, (void **) &dd2);
ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
hr = IDirectDraw2_CreateSurface(dd2, ddsd, &surf, NULL);
ok(hr == DD_OK, "IDirectDraw2_CreateSurface failed: 0x%08x\n", hr);
testfunc(surf, 1);
hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface2, (void **) &surf2);
ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr);
testfunc((IDirectDrawSurface *) surf2, 1);
IDirectDrawSurface2_Release(surf2);
IDirectDrawSurface_Release(surf);
IDirectDraw2_Release(dd2);
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw3, (void **) &dd3);
ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
hr = IDirectDraw3_CreateSurface(dd3, ddsd, &surf, NULL);
ok(hr == DD_OK, "IDirectDraw3_CreateSurface failed: 0x%08x\n", hr);
testfunc(surf, 1);
hr = IDirectDrawSurface_QueryInterface(surf, &IID_IDirectDrawSurface3, (void **) &surf3);
ok(hr == DD_OK, "IDirectDrawSurface_QueryInterface failed: 0x%08x\n", hr);
testfunc((IDirectDrawSurface *) surf3, 1);
IDirectDrawSurface3_Release(surf3);
IDirectDrawSurface_Release(surf);
IDirectDraw3_Release(dd3);
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw4, (void **) &dd4);
ok(hr == DD_OK, "IDirectDraw_QueryInterface failed: 0x%08x\n", hr);
surf = NULL;
hr = IDirectDraw4_CreateSurface(dd4, ddsd2, &surf4, NULL);
ok(hr == DD_OK, "IDirectDraw4_CreateSurface failed: 0x%08x\n", hr);
testfunc((IDirectDrawSurface *) surf4, 2);
IDirectDrawSurface4_Release(surf4);
IDirectDraw4_Release(dd4);
IDirectDraw_Release(dd1);
}
