//
// Release DirectDraw stuff before display mode change
//
VOID ReleaseChtuff (VOID)
{
if (!DDr2)
return;
if (windclip)
{
IDirectDrawClipper_Release(windclip);
windclip = NULL;
}
if (DDPalette)
{
IDirectDrawPalette_Release(DDPalette);
DDPalette = NULL;
}
// If the app is fullscreen, the back buffer is attached to the
// primary. Releasing the primary buffer will also release any
// attached buffers, so explicitly releasing the back buffer is not
// necessary.
if (!bAppFullScreen && ScreenVirtual)
{
IDirectDrawSurface_Release(ScreenVirtual); // release hidden surface
ScreenVirtual = NULL;
}
if (ScreenReal)
{
IDirectDrawSurface_Release(ScreenReal); // and attached backbuffers for bAppFullScreen mode
ScreenReal = NULL;
}
}
void DDKillScreen()
{
if (_lpDDClipper) IDirectDrawClipper_Release(_lpDDClipper);
if (_lpDDPalette) IDirectDrawPalette_Release(_lpDDPalette);
if (_lpDDSBack) IDirectDrawSurface_Release(_lpDDSBack);
if (_lpDDSPrimary) {
if (!GRMODEINFO(modex)) {
DDBLTFX ddbltfx;
HRESULT ddresult;
memset(&ddbltfx, 0, sizeof(DDBLTFX));
ddbltfx.dwSize = sizeof( ddbltfx );
ddbltfx.dwFillColor = (WORD)(BM_XRGB(0,0,0));
ddresult = IDirectDrawSurface_Blt(
_lpDDSPrimary, // dest surface
NULL, // dest rect
NULL, // src surface
NULL, // src rect
DDBLT_COLORFILL | DDBLT_WAIT,
&ddbltfx);
}
IDirectDrawSurface_Release(_lpDDSPrimary);
}
_lpDDClipper = NULL;
_lpDDPalette = NULL;
_lpDDSBack = NULL;
_lpDDSPrimary = NULL;
}
/**
* Create a clipper that will be used when blitting the RGB surface to the main display.
*
* This clipper prevents us to modify by mistake anything on the screen
* which doesn't belong to our window. For example when a part of our video
* window is hidden by another window.
*/
static void DirectXCreateClipper(vout_display_t *vd)
{
vout_display_sys_t *sys = vd->sys;
HRESULT hr;
/* Create the clipper */
hr = IDirectDraw2_CreateClipper(sys->ddobject, 0, &sys->clipper, NULL);
if (hr != DD_OK) {
msg_Warn(vd, "cannot create clipper (error %li)", hr);
goto error;
}
/* Associate the clipper to the window */
hr = IDirectDrawClipper_SetHWnd(sys->clipper, 0, sys->hvideownd);
if (hr != DD_OK) {
msg_Warn(vd, "cannot attach clipper to window (error %li)", hr);
goto error;
}
/* associate the clipper with the surface */
hr = IDirectDrawSurface_SetClipper(sys->display, sys->clipper);
if (hr != DD_OK)
{
msg_Warn(vd, "cannot attach clipper to surface (error %li)", hr);
goto error;
}
return;
error:
if (sys->clipper)
IDirectDrawClipper_Release(sys->clipper);
sys->clipper = NULL;
}
static void ddraw_delete_surfaces(win_window_info *window)
{
dd_info *dd = window->drawdata;
// release the gamma control
if (dd->gamma != NULL)
IDirectDrawGammaControl_Release(dd->gamma);
dd->gamma = NULL;
// release the clipper
if (dd->clipper != NULL)
IDirectDrawClipper_Release(dd->clipper);
dd->clipper = NULL;
// free the memory buffer
if (dd->membuffer != NULL)
free(dd->membuffer);
dd->membuffer = NULL;
dd->membuffersize = 0;
// release the blit surface
if (dd->blit != NULL)
IDirectDrawSurface7_Release(dd->blit);
dd->blit = NULL;
// release the back surface
if (dd->back != NULL)
IDirectDrawSurface7_Release(dd->back);
dd->back = NULL;
// release the primary surface
if (dd->primary != NULL)
IDirectDrawSurface7_Release(dd->primary);
dd->primary = NULL;
}
// 删除表面
void DDrawSurfaceRelease(CSURFACE *surface)
{
assert(surface);
if (surface->clip) {
IDirectDrawClipper_Release(surface->clip);
surface->clip = NULL;
}
if (surface->lpDDS) {
if (surface->lock) {
IDirectDrawSurface7_Unlock(surface->lpDDS, NULL);
surface->lock = 0;
}
if (IDirectDrawSurface7_IsLost(surface->lpDDS) != DD_OK) {
IDirectDrawSurface7_Restore(surface->lpDDS);
}
IDirectDrawSurface7_Release(surface->lpDDS);
surface->lpDDS = NULL;
hSurfaceCounter--;
}
if (surface->primary) {
if (lpDirectDraw7 && hFullScreenMode) {
IDirectDraw7_RestoreDisplayMode(lpDirectDraw7);
}
hFullScreenMode = 0;
}
memset(surface, 0, sizeof(CSURFACE));
free(surface);
assert(hSurfaceCounter >= 0);
}
void renderer_dd::ddraw_delete_surfaces()
{
// release the gamma control
if (gamma != NULL)
IDirectDrawGammaControl_Release(gamma);
gamma = NULL;
// release the clipper
if (clipper != NULL)
IDirectDrawClipper_Release(clipper);
clipper = NULL;
// free the memory buffer
global_free_array(membuffer);
membuffer = NULL;
membuffersize = 0;
// release the blit surface
if (blit != NULL)
IDirectDrawSurface7_Release(blit);
blit = NULL;
// release the back surface
if (back != NULL)
IDirectDrawSurface7_Release(back);
back = NULL;
// release the primary surface
if (primary != NULL)
IDirectDrawSurface7_Release(primary);
primary = NULL;
}
static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level)
{
IDirect3DDevice7 *device = NULL;
IDirectDrawSurface7 *surface;
DDSURFACEDESC2 surface_desc;
IDirectDraw7 *ddraw;
IDirect3D7 *d3d7;
HRESULT hr;
if (!(ddraw = create_ddraw()))
return NULL;
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, coop_level);
ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
surface_desc.dwWidth = 640;
surface_desc.dwHeight = 480;
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &surface, NULL);
ok(SUCCEEDED(hr), "Failed to create surface, hr %#x.\n", hr);
if (coop_level & DDSCL_NORMAL)
{
IDirectDrawClipper *clipper;
hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawSurface7_SetClipper(surface, clipper);
ok(SUCCEEDED(hr), "Failed to set surface clipper, hr %#x.\n", hr);
IDirectDrawClipper_Release(clipper);
}
hr = IDirectDraw7_QueryInterface(ddraw, &IID_IDirect3D7, (void **)&d3d7);
IDirectDraw7_Release(ddraw);
if (FAILED(hr))
{
IDirectDrawSurface7_Release(surface);
return NULL;
}
hr = IDirect3D7_CreateDevice(d3d7, &IID_IDirect3DTnLHalDevice, surface, &device);
IDirect3D7_Release(d3d7);
IDirectDrawSurface7_Release(surface);
if (FAILED(hr))
return NULL;
return device;
}
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 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 );
}
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 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;
}
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 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
_directdraw_init (HWND window,
LPDIRECTDRAW *object,
LPDIRECTDRAWSURFACE *surface_primary,
LPDIRECTDRAWSURFACE *surface_back,
int *depth,
int width,
int height)
{
DDSURFACEDESC2 surface_desc;
DDPIXELFORMAT pixel_format;
LPDIRECTDRAWCLIPPER clipper;
LPDIRECTDRAW o;
DDSURFACEDESC2 *sd;
HRESULT res;
res = DirectDrawCreateEx (NULL, (void **)&o, &IID_IDirectDraw7, NULL);
if (FAILED(res))
return 0;
res = IDirectDraw7_SetCooperativeLevel (o, window, DDSCL_NORMAL);
if (FAILED(res))
{
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDraw7_CreateClipper (o, 0, &clipper, NULL);
if (FAILED(res))
{
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDrawClipper_SetHWnd (clipper, 0, window);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDraw7_Release (o);
return 0;
}
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS;
surface_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
sd=&surface_desc;
res = IDirectDraw7_CreateSurface (o, &surface_desc,
surface_primary, NULL);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDraw7_Release (o);
return 0;
}
res = IDirectDrawSurface7_SetClipper (*surface_primary, clipper);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDrawSurface7_Release (*surface_primary);
IDirectDraw7_Release (o);
return 0;
}
memset (&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
surface_desc.dwWidth = width;
surface_desc.dwHeight = height;
sd=&surface_desc;
res = IDirectDraw7_CreateSurface (o, (DDSURFACEDESC *)sd,
surface_back, NULL);
if (FAILED(res))
{
IDirectDrawClipper_Release (clipper);
IDirectDrawSurface7_Release (*surface_primary);
IDirectDraw7_Release (o);
return 0;
}
ZeroMemory(&pixel_format, sizeof(pixel_format));
pixel_format.dwSize = sizeof(pixel_format);
IDirectDrawSurface7_GetPixelFormat(*surface_primary, &pixel_format);
*object = o;
*depth = pixel_format.dwRGBBitCount;
return 1;
}
Bool
winCloseScreenShadowDDNL (int nIndex, ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
Bool fReturn;
#if CYGDEBUG
ErrorF ("winCloseScreenShadowDDNL - Freeing screen resources\n");
#endif
/* 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);
/* 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->pddsShadow4)
{
IDirectDrawSurface4_Release (pScreenPriv->pddsShadow4);
free (pScreenInfo->pfb);
pScreenInfo->pfb = NULL;
pScreenPriv->pddsShadow4 = NULL;
}
/* Detach the clipper from the primary surface and release the clipper. */
if (pScreenPriv->pddcPrimary)
{
/* Detach the clipper */
IDirectDrawSurface4_SetClipper (pScreenPriv->pddsPrimary4,
NULL);
/* Release the clipper object */
IDirectDrawClipper_Release (pScreenPriv->pddcPrimary);
pScreenPriv->pddcPrimary = NULL;
}
/* Release the primary surface, if there is one */
if (pScreenPriv->pddsPrimary4)
{
IDirectDrawSurface4_Release (pScreenPriv->pddsPrimary4);
pScreenPriv->pddsPrimary4 = 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;
}
/* Kill our window */
if (pScreenPriv->hwndScreen)
{
DestroyWindow (pScreenPriv->hwndScreen);
pScreenPriv->hwndScreen = NULL;
}
/* Destroy the thread startup mutex */
pthread_mutex_destroy (&pScreenPriv->pmServerStarted);
/* 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 test_clipper_blt(void)
{
IDirectDrawSurface7 *src_surface, *dst_surface;
RECT client_rect, src_rect, *rect;
IDirectDrawClipper *clipper;
DDSURFACEDESC2 surface_desc;
unsigned int i, j, x, y;
IDirectDraw7 *ddraw;
RGNDATA *rgn_data;
D3DCOLOR color;
HRGN r1, r2;
HWND window;
DDBLTFX fx;
HRESULT hr;
DWORD ret;
static const D3DCOLOR expected1[] =
{
0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
0x000000ff, 0x0000ff00, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
0x00000000, 0x00000000, 0x00ff0000, 0x00ffffff,
};
static const D3DCOLOR expected2[] =
{
0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
0x000000ff, 0x000000ff, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
0x00000000, 0x00000000, 0x000000ff, 0x000000ff,
};
window = CreateWindowA("static", "ddraw_test", WS_OVERLAPPEDWINDOW,
10, 10, 640, 480, 0, 0, 0, 0);
ShowWindow(window, SW_SHOW);
if (!(ddraw = create_ddraw()))
{
skip("Failed to create a ddraw object, skipping test.\n");
DestroyWindow(window);
return;
}
ret = GetClientRect(window, &client_rect);
ok(ret, "Failed to get client rect.\n");
ret = MapWindowPoints(window, NULL, (POINT *)&client_rect, 2);
ok(ret, "Failed to map client rect.\n");
hr = IDirectDraw7_SetCooperativeLevel(ddraw, window, DDSCL_NORMAL);
ok(SUCCEEDED(hr), "Failed to set cooperative level, hr %#x.\n", hr);
hr = IDirectDraw7_CreateClipper(ddraw, 0, &clipper, NULL);
ok(SUCCEEDED(hr), "Failed to create clipper, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, rgn_data, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list, hr %#x.\n", hr);
ok(rgn_data->rdh.dwSize == sizeof(rgn_data->rdh), "Got unexpected structure size %#x.\n", rgn_data->rdh.dwSize);
ok(rgn_data->rdh.iType == RDH_RECTANGLES, "Got unexpected type %#x.\n", rgn_data->rdh.iType);
ok(rgn_data->rdh.nCount == 1, "Got unexpected count %u.\n", rgn_data->rdh.nCount);
ok(rgn_data->rdh.nRgnSize == 16, "Got unexpected region size %u.\n", rgn_data->rdh.nRgnSize);
ok(EqualRect(&rgn_data->rdh.rcBound, &client_rect),
"Got unexpected bounding rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
rgn_data->rdh.rcBound.left, rgn_data->rdh.rcBound.top,
rgn_data->rdh.rcBound.right, rgn_data->rdh.rcBound.bottom,
client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
rect = (RECT *)&rgn_data->Buffer[0];
ok(EqualRect(rect, &client_rect),
"Got unexpected clip rect {%d, %d, %d, %d}, expected {%d, %d, %d, %d}.\n",
rect->left, rect->top, rect->right, rect->bottom,
client_rect.left, client_rect.top, client_rect.right, client_rect.bottom);
HeapFree(GetProcessHeap(), 0, rgn_data);
r1 = CreateRectRgn(0, 0, 320, 240);
ok(!!r1, "Failed to create region.\n");
r2 = CreateRectRgn(320, 240, 640, 480);
ok(!!r2, "Failed to create region.\n");
CombineRgn(r1, r1, r2, RGN_OR);
ret = GetRegionData(r1, 0, NULL);
rgn_data = HeapAlloc(GetProcessHeap(), 0, ret);
ret = GetRegionData(r1, ret, rgn_data);
ok(!!ret, "Failed to get region data.\n");
DeleteObject(r2);
DeleteObject(r1);
hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
ok(hr == DDERR_CLIPPERISUSINGHWND, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetClipList(clipper, rgn_data, 0);
ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
HeapFree(GetProcessHeap(), 0, rgn_data);
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
surface_desc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
surface_desc.dwWidth = 640;
surface_desc.dwHeight = 480;
U4(surface_desc).ddpfPixelFormat.dwSize = sizeof(U4(surface_desc).ddpfPixelFormat);
U4(surface_desc).ddpfPixelFormat.dwFlags = DDPF_RGB;
U1(U4(surface_desc).ddpfPixelFormat).dwRGBBitCount = 32;
U2(U4(surface_desc).ddpfPixelFormat).dwRBitMask = 0x00ff0000;
U3(U4(surface_desc).ddpfPixelFormat).dwGBitMask = 0x0000ff00;
U4(U4(surface_desc).ddpfPixelFormat).dwBBitMask = 0x000000ff;
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &src_surface, NULL);
ok(SUCCEEDED(hr), "Failed to create source surface, hr %#x.\n", hr);
hr = IDirectDraw7_CreateSurface(ddraw, &surface_desc, &dst_surface, NULL);
ok(SUCCEEDED(hr), "Failed to create destination surface, hr %#x.\n", hr);
memset(&fx, 0, sizeof(fx));
fx.dwSize = sizeof(fx);
hr = IDirectDrawSurface7_Blt(src_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear source surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_Lock(src_surface, NULL, &surface_desc, 0, NULL);
ok(SUCCEEDED(hr), "Failed to lock source surface, hr %#x.\n", hr);
((DWORD *)surface_desc.lpSurface)[0] = 0xff0000ff;
((DWORD *)surface_desc.lpSurface)[1] = 0xff00ff00;
((DWORD *)surface_desc.lpSurface)[2] = 0xffff0000;
((DWORD *)surface_desc.lpSurface)[3] = 0xffffffff;
hr = IDirectDrawSurface7_Unlock(src_surface, NULL);
ok(SUCCEEDED(hr), "Failed to unlock source surface, hr %#x.\n", hr);
hr = IDirectDrawSurface7_SetClipper(dst_surface, clipper);
ok(SUCCEEDED(hr), "Failed to set clipper, hr %#x.\n", hr);
SetRect(&src_rect, 0, 0, 4, 1);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, src_surface, &src_rect, DDBLT_WAIT, NULL);
ok(SUCCEEDED(hr), "Failed to blit, hr %#x.\n", hr);
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
x = 80 * ((2 * j) + 1);
y = 60 * ((2 * i) + 1);
color = get_surface_color(dst_surface, x, y);
ok(compare_color(color, expected1[i * 4 + j], 1),
"Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected1[i * 4 + j], x, y, color);
}
}
U5(fx).dwFillColor = 0xff0000ff;
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(SUCCEEDED(hr), "Failed to clear destination surface, hr %#x.\n", hr);
for (i = 0; i < 4; ++i)
{
for (j = 0; j < 4; ++j)
{
x = 80 * ((2 * j) + 1);
y = 60 * ((2 * i) + 1);
color = get_surface_color(dst_surface, x, y);
ok(compare_color(color, expected2[i * 4 + j], 1),
"Expected color 0x%08x at %u,%u, got 0x%08x.\n", expected2[i * 4 + j], x, y, color);
}
}
hr = IDirectDrawSurface7_BltFast(dst_surface, 0, 0, src_surface, NULL, DDBLTFAST_WAIT);
ok(hr == DDERR_BLTFASTCANTCLIP, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, window);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
DestroyWindow(window);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawClipper_SetHWnd(clipper, 0, NULL);
ok(SUCCEEDED(hr), "Failed to set clipper window, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(SUCCEEDED(hr), "Failed to get clip list size, hr %#x.\n", hr);
hr = IDirectDrawClipper_SetClipList(clipper, NULL, 0);
ok(SUCCEEDED(hr), "Failed to set clip list, hr %#x.\n", hr);
hr = IDirectDrawClipper_GetClipList(clipper, NULL, NULL, &ret);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
hr = IDirectDrawSurface7_Blt(dst_surface, NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &fx);
ok(hr == DDERR_NOCLIPLIST, "Got unexpected hr %#x.\n", hr);
IDirectDrawSurface7_Release(dst_surface);
IDirectDrawSurface7_Release(src_surface);
IDirectDrawClipper_Release(clipper);
IDirectDraw7_Release(ddraw);
}
void DDReleaseClipper( LPDIRECTDRAWCLIPPER pDDClipper )
{
Assert( pDDClipper != NULL );
ATTEMPT( IDirectDrawClipper_Release( pDDClipper ) );
}
static int ResizeDD(int fullscreen)
{
HRESULT ddrval;
DDSURFACEDESC ddsd;
/*DDCAPS2 ddscaps; */
LPDIRECTDRAWCLIPPER pClipper;
int dxwidth;
int dxheight;
int dxbpp;
// free DirectX objects
if (lpSurfaces[0])
IDirectDrawSurface_Release(lpSurfaces[0]);
lpSurfaces[0] = NULL;
if (dxPalette)
IDirectDrawPalette_Release(dxPalette);
dxPalette = NULL;
/* Set cooperative level */
ddrval = IDirectDraw2_SetCooperativeLevel(lpDD2, hWnd,
fullscreen
? (DDSCL_FULLSCREEN |
DDSCL_EXCLUSIVE |
DDSCL_ALLOWREBOOT)
: DDSCL_NORMAL);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to set cooperative level");
return 0;
}
if (fullscreen) {
if (sscanf(dxsize, "%ix%ix%i", &dxwidth, &dxheight, &dxbpp) != 3) {
dxwidth = DXWIDTH;
dxheight = DXHEIGHT;
dxbpp = DXBPP;
}
displayX = dxwidth;
displayY = dxheight;
bitDepth = dxbpp;
if (bitDepth < 10)
bitDepth = 8;
if (bitDepth >= 10 && bitDepth < 20)
bitDepth = 16;
if (bitDepth >= 20 && bitDepth < 28)
bitDepth = 24;
if (bitDepth >= 32 && bitDepth < 32)
bitDepth = 32;
/* set resolution and bit depth */
ddrval =
IDirectDraw2_SetDisplayMode(lpDD2, displayX, displayY,
bitDepth, 0, 0);
if (ddrval != DD_OK) {
/* The display mode cannot be changed.
The mode is either not supported or
another application has exclusive mode.
Try 320x200x256 and 640x480x256 modes before giving up */
displayX = 320;
displayY = 200;
bitDepth = 8;
ddrval =
IDirectDraw2_SetDisplayMode(lpDD2, displayX, displayY,
bitDepth, 0, 0);
if (ddrval != DD_OK) {
displayY = 240;
if (ddrval != DD_OK) {
displayX = 640;
displayY = 480;
ddrval =
IDirectDraw2_SetDisplayMode(lpDD2, displayX,
displayY, bitDepth, 0,
0);
if (ddrval != DD_OK) {
/* Bad luck... give up. */
DeInitDD();
return 0;
}
}
}
}
SetRect(&rcViewport, 0, 0, displayX, displayY);
rcScreen = rcViewport;
} else {
/* Get the dimensions of the viewport and screen bounds */
GetClientRect(hWnd, &rcViewport);
GetClientRect(hWnd, &rcScreen);
ClientToScreen(hWnd, (POINT *) & rcScreen.left);
ClientToScreen(hWnd, (POINT *) & rcScreen.right);
/*bitDepth = GetDeviceCaps (hDC, BITSPIXEL); */
/* Create clipper object for window */
ddrval = IDirectDraw_CreateClipper(lpDD, 0, &pClipper, NULL);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to create clipper object");
return 0;
}
/* Asociate it */
IDirectDrawClipper_SetHWnd(pClipper, 0, hWnd);
}
/* Create the primary surface with one back buffer */
CalculateBITMAPINFO(); // calculate BITMAPINFO structure
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
ddrval = IDirectDraw_CreateSurface(lpDD, &ddsd, &lpSurfaces[0], NULL);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to create flipping surface");
return 0;
}
if (!fullscreen) {
IDirectDrawSurface_SetClipper(lpSurfaces[0], pClipper);
IDirectDrawClipper_Release(pClipper);
if (IDirectDrawSurface_GetSurfaceDesc(lpSurfaces[0], &ddsd) !=
DD_OK) {
DeInitDD();
x_error("Failed to get pixel format");
return 0;
}
bitDepth = ddsd.ddpfPixelFormat.u1.dwRGBBitCount;
}
if (bitDepth == 8) {
/* create palette */
ddrval =
IDirectDraw_CreatePalette(lpDD, DDPCAPS_8BIT,
(LPPALETTEENTRY) bmp->bmiColors,
&dxPalette, NULL);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to create palette");
return 0;
}
/* set palette */
IDirectDrawSurface_SetPalette(lpSurfaces[0], dxPalette);
}
if (fullscreen)
SetCursor(NULL);
needredraw = 1;
return 1;
}
static int
DDCreateSurface(directx_priv *priv, ggi_mode *mode)
{
HRESULT hr;
LPDIRECTDRAWCLIPPER pClipper;
DDSURFACEDESC pddsd, bddsd;
int i;
if (!priv->fullscreen)
IDirectDraw2_SetCooperativeLevel(priv->lpddext, priv->hWnd,
DDSCL_NORMAL);
else {
/* Only the thread that has excluse access (Cooperative level)
* may restore the surfaces when they are lost. Therefore
* let the helper thread get exclusive access so that it can
* later do restores.
*/
directx_fullscreen dxfull;
dxfull.priv = priv;
dxfull.mode = mode;
dxfull.event = CreateEvent(NULL, FALSE, FALSE, NULL);
PostThreadMessage(priv->nThreadID,
WM_DDFULLSCREEN, 0, (long)&dxfull);
WaitForSingleObject(dxfull.event, INFINITE);
CloseHandle(dxfull.event);
}
/* create the primary surface */
memset(&pddsd, 0, sizeof(pddsd));
pddsd.dwSize = sizeof(pddsd);
pddsd.dwFlags = DDSD_CAPS;
pddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if (priv->fullscreen)
pddsd.ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY;
hr = IDirectDraw2_CreateSurface(priv->lpddext, &pddsd,
&priv->lppdds, NULL);
if (hr != 0) {
fprintf(stderr,
"Init Primary Surface Failed RC = %lx. Exiting\n",
hr);
exit(-1);
}
IDirectDraw2_CreateClipper(priv->lpddext, 0, &pClipper, NULL);
IDirectDrawClipper_SetHWnd(pClipper, 0, priv->hWnd);
IDirectDrawSurface_SetClipper(priv->lppdds, pClipper);
IDirectDrawClipper_Release(pClipper);
pddsd.dwSize = sizeof(pddsd);
IDirectDrawSurface_GetSurfaceDesc(priv->lppdds, &pddsd);
DPRINT_MISC("DDraw pixel format:\n");
DPRINT_MISC(" Size %u\n", pddsd.ddpfPixelFormat.dwSize);
DPRINT_MISC(" Flags %08x\n", pddsd.ddpfPixelFormat.dwFlags);
DPRINT_MISC(" FourCC %08x\n", pddsd.ddpfPixelFormat.dwFourCC);
DPRINT_MISC(" Count %u\n", pddsd.ddpfPixelFormat.dwRGBBitCount);
DPRINT_MISC(" R-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwRBitMask);
DPRINT_MISC(" G-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwGBitMask);
DPRINT_MISC(" B-Mask(etc) %08x\n", pddsd.ddpfPixelFormat.dwBBitMask);
DPRINT_MISC(" Z-Mask(etc) %08x\n",
pddsd.ddpfPixelFormat.dwRGBZBitMask);
/* create the back storages */
for (i = 0; i < mode->frames; ++i) {
memset(&bddsd, 0, sizeof(bddsd));
bddsd.dwSize = sizeof(bddsd);
bddsd.dwFlags =
DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
bddsd.ddsCaps.dwCaps =
DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
bddsd.dwWidth = mode->virt.x;
bddsd.dwHeight = mode->virt.y;
/* set up the pixel format */
ZeroMemory(&bddsd.ddpfPixelFormat, sizeof(DDPIXELFORMAT));
bddsd.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT);
bddsd.ddpfPixelFormat.dwFlags =
pddsd.ddpfPixelFormat.dwFlags;
bddsd.ddpfPixelFormat.dwFourCC =
pddsd.ddpfPixelFormat.dwFourCC;
bddsd.ddpfPixelFormat.dwRGBBitCount =
pddsd.ddpfPixelFormat.dwRGBBitCount;
bddsd.ddpfPixelFormat.dwRBitMask =
pddsd.ddpfPixelFormat.dwRBitMask;
bddsd.ddpfPixelFormat.dwGBitMask =
pddsd.ddpfPixelFormat.dwGBitMask;
bddsd.ddpfPixelFormat.dwBBitMask =
pddsd.ddpfPixelFormat.dwBBitMask;
bddsd.ddpfPixelFormat.dwRGBAlphaBitMask =
pddsd.ddpfPixelFormat.dwRGBAlphaBitMask;
hr = IDirectDraw2_CreateSurface(priv->lpddext,
&bddsd, &priv->lpbdds[i],
NULL);
if (hr) {
fprintf(stderr,
"Init Backup Failed RC = %lx. Exiting\n", hr);
exit(-1);
}
IDirectDrawSurface2_Lock(priv->lpbdds[i], NULL, &bddsd,
DDLOCK_SURFACEMEMORYPTR, NULL);
priv->lpSurfaceAdd[i] = (char *) bddsd.lpSurface;
IDirectDrawSurface2_Unlock(priv->lpbdds[i],
bddsd.lpSurface);
}
/* set private mode parameters */
priv->maxX = mode->virt.x;
priv->maxY = mode->virt.y;
priv->ColorDepth = pddsd.ddpfPixelFormat.dwRGBBitCount;
priv->pitch = bddsd.lPitch;
if (pddsd.ddpfPixelFormat.dwFlags & DDPF_PALETTEINDEXED8) {
static PALETTEENTRY pal[256];
/* todo fill in pal */
hr = IDirectDraw_CreatePalette(priv->lpddext,
DDPCAPS_8BIT|DDPCAPS_ALLOW256,
pal, &priv->lpddp, NULL);
if (hr) {
fprintf(stderr,
"Init Palette failed RC = %lx. Exiting\n",
hr);
exit(-1);
}
hr = IDirectDrawSurface_SetPalette(priv->lppdds, priv->lpddp);
if (hr) {
fprintf(stderr,
"Install Palette failed RC = %lx. Exiting\n",
hr);
exit(-1);
}
}
return 1;
}