Bool
winAllocateFBShadowDDNL (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
HRESULT ddrval = DD_OK;
DDSURFACEDESC2 ddsdShadow;
char *lpSurface = NULL;
DDPIXELFORMAT ddpfPrimary;
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - w %d h %d d %d\n",
pScreenInfo->dwWidth, pScreenInfo->dwHeight, pScreenInfo->dwDepth);
#endif
/* Allocate memory for our shadow surface */
lpSurface = malloc (pScreenInfo->dwPaddedWidth * pScreenInfo->dwHeight);
if (lpSurface == NULL)
{
ErrorF ("winAllocateFBShadowDDNL - Could not allocate bits\n");
return FALSE;
}
/*
* Initialize the framebuffer memory so we don't get a
* strange display at startup
*/
ZeroMemory (lpSurface, pScreenInfo->dwPaddedWidth * pScreenInfo->dwHeight);
/* Create a clipper */
ddrval = (*g_fpDirectDrawCreateClipper) (0,
&pScreenPriv->pddcPrimary,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not attach clipper: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - Created a clipper\n");
#endif
/* Get a device context for the screen */
pScreenPriv->hdcScreen = GetDC (pScreenPriv->hwndScreen);
/* Attach the clipper to our display window */
ddrval = IDirectDrawClipper_SetHWnd (pScreenPriv->pddcPrimary,
0,
pScreenPriv->hwndScreen);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Clipper not attached "
"to window: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - Attached clipper to window\n");
#endif
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL,
(LPDIRECTDRAW*) &pScreenPriv->pdd,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not start "
"DirectDraw: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - Created and initialized DD\n");
#endif
/* Get a DirectDraw4 interface pointer */
ddrval = IDirectDraw_QueryInterface (pScreenPriv->pdd,
&IID_IDirectDraw4,
(LPVOID*) &pScreenPriv->pdd4);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Failed DD4 query: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
/* Are we full screen? */
if (pScreenInfo->fFullScreen)
{
DDSURFACEDESC2 ddsdCurrent;
DWORD dwRefreshRateCurrent = 0;
HDC hdc = NULL;
/* Set the cooperative level to full screen */
ddrval = IDirectDraw4_SetCooperativeLevel (pScreenPriv->pdd4,
pScreenPriv->hwndScreen,
DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not set "
"cooperative level: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
/*
* We only need to get the current refresh rate for comparison
* if a refresh rate has been passed on the command line.
*/
if (pScreenInfo->dwRefreshRate != 0)
{
ZeroMemory (&ddsdCurrent, sizeof (ddsdCurrent));
ddsdCurrent.dwSize = sizeof (ddsdCurrent);
/* Get information about current display settings */
ddrval = IDirectDraw4_GetDisplayMode (pScreenPriv->pdd4,
&ddsdCurrent);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not get current "
"refresh rate: %08x. Continuing.\n",
(unsigned int) ddrval);
dwRefreshRateCurrent = 0;
}
else
{
/* Grab the current refresh rate */
dwRefreshRateCurrent = ddsdCurrent.u2.dwRefreshRate;
}
}
/* Clean up the refresh rate */
if (dwRefreshRateCurrent == pScreenInfo->dwRefreshRate)
{
/*
* Refresh rate is non-specified or equal to current.
*/
pScreenInfo->dwRefreshRate = 0;
}
/* Grab a device context for the screen */
hdc = GetDC (NULL);
if (hdc == NULL)
{
ErrorF ("winAllocateFBShadowDDNL - GetDC () failed\n");
return FALSE;
}
/* Only change the video mode when different than current mode */
if (!pScreenInfo->fMultipleMonitors
&& (pScreenInfo->dwWidth != GetSystemMetrics (SM_CXSCREEN)
|| pScreenInfo->dwHeight != GetSystemMetrics (SM_CYSCREEN)
|| pScreenInfo->dwBPP != GetDeviceCaps (hdc, BITSPIXEL)
|| pScreenInfo->dwRefreshRate != 0))
{
winDebug ("winAllocateFBShadowDDNL - Changing video mode\n");
/* Change the video mode to the mode requested, and use the driver default refresh rate on failure */
ddrval = IDirectDraw4_SetDisplayMode (pScreenPriv->pdd4,
pScreenInfo->dwWidth,
pScreenInfo->dwHeight,
pScreenInfo->dwBPP,
pScreenInfo->dwRefreshRate,
0);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not set "
"full screen display mode: %08x\n",
(unsigned int) ddrval);
ErrorF ("winAllocateFBShadowDDNL - Using default driver refresh rate\n");
ddrval = IDirectDraw4_SetDisplayMode (pScreenPriv->pdd4,
pScreenInfo->dwWidth,
pScreenInfo->dwHeight,
pScreenInfo->dwBPP,
0,
0);
if (FAILED(ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not set default refresh rate "
"full screen display mode: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
}
}
else
{
winDebug ("winAllocateFBShadowDDNL - Not changing video mode\n");
}
/* Release our DC */
ReleaseDC (NULL, hdc);
hdc = NULL;
}
else
{
/* Set the cooperative level for windowed mode */
ddrval = IDirectDraw4_SetCooperativeLevel (pScreenPriv->pdd4,
pScreenPriv->hwndScreen,
DDSCL_NORMAL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not set "
"cooperative level: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
}
/* Create the primary surface */
if (!winCreatePrimarySurfaceShadowDDNL (pScreen))
{
ErrorF ("winAllocateFBShadowDDNL - winCreatePrimarySurfaceShadowDDNL "
"failed\n");
return FALSE;
}
/* Get primary surface's pixel format */
ZeroMemory (&ddpfPrimary, sizeof (ddpfPrimary));
ddpfPrimary.dwSize = sizeof (ddpfPrimary);
ddrval = IDirectDrawSurface4_GetPixelFormat (pScreenPriv->pddsPrimary4,
&ddpfPrimary);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not get primary "
"pixformat: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - Primary masks: %08x %08x %08x "
"dwRGBBitCount: %d\n",
ddpfPrimary.u2.dwRBitMask,
ddpfPrimary.u3.dwGBitMask,
ddpfPrimary.u4.dwBBitMask,
ddpfPrimary.u1.dwRGBBitCount);
#endif
/* Describe the shadow surface to be created */
/*
* NOTE: Do not use a DDSCAPS_VIDEOMEMORY surface,
* as drawing, locking, and unlocking take forever
* with video memory surfaces. In addition,
* video memory is a somewhat scarce resource,
* so you shouldn't be allocating video memory when
* you have the option of using system memory instead.
*/
ZeroMemory (&ddsdShadow, sizeof (ddsdShadow));
ddsdShadow.dwSize = sizeof (ddsdShadow);
ddsdShadow.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH
| DDSD_LPSURFACE | DDSD_PITCH | DDSD_PIXELFORMAT;
ddsdShadow.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
ddsdShadow.dwHeight = pScreenInfo->dwHeight;
ddsdShadow.dwWidth = pScreenInfo->dwWidth;
ddsdShadow.u1.lPitch = pScreenInfo->dwPaddedWidth;
ddsdShadow.lpSurface = lpSurface;
ddsdShadow.u4.ddpfPixelFormat = ddpfPrimary;
winDebug ("winAllocateFBShadowDDNL - lPitch: %d\n",
(int) pScreenInfo->dwPaddedWidth);
/* Create the shadow surface */
ddrval = IDirectDraw4_CreateSurface (pScreenPriv->pdd4,
&ddsdShadow,
&pScreenPriv->pddsShadow4,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDDNL - Could not create shadow "
"surface: %08x\n", (unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG || YES
winDebug ("winAllocateFBShadowDDNL - Created shadow pitch: %d\n",
(int) ddsdShadow.u1.lPitch);
#endif
/* Grab the pitch from the surface desc */
pScreenInfo->dwStride = (ddsdShadow.u1.lPitch * 8)
/ pScreenInfo->dwBPP;
#if CYGDEBUG || YES
winDebug ("winAllocateFBShadowDDNL - Created shadow stride: %d\n",
(int) pScreenInfo->dwStride);
#endif
/* Save the pointer to our surface memory */
pScreenInfo->pfb = lpSurface;
/* Grab the masks from the surface description */
pScreenPriv->dwRedMask = ddsdShadow.u4.ddpfPixelFormat.u2.dwRBitMask;
pScreenPriv->dwGreenMask = ddsdShadow.u4.ddpfPixelFormat.u3.dwGBitMask;
pScreenPriv->dwBlueMask = ddsdShadow.u4.ddpfPixelFormat.u4.dwBBitMask;
#if CYGDEBUG
winDebug ("winAllocateFBShadowDDNL - Returning\n");
#endif
return TRUE;
}
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);
}
static Bool
winCreatePrimarySurfaceShadowDDNL (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
HRESULT ddrval = DD_OK;
DDSURFACEDESC2 ddsd;
winDebug ("winCreatePrimarySurfaceShadowDDNL - Creating primary surface\n");
/* Describe the primary surface */
ZeroMemory (&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
/* Create the primary surface */
ddrval = IDirectDraw4_CreateSurface (pScreenPriv->pdd4,
&ddsd,
&pScreenPriv->pddsPrimary4,
NULL);
pScreenPriv->fRetryCreateSurface = FALSE;
if (FAILED (ddrval))
{
if (ddrval == DDERR_NOEXCLUSIVEMODE)
{
/* Recreating the surface failed. Mark screen to retry later */
pScreenPriv->fRetryCreateSurface = TRUE;
winDebug ("winCreatePrimarySurfaceShadowDDNL - Could not create "
"primary surface: DDERR_NOEXCLUSIVEMODE\n");
}
else
{
ErrorF ("winCreatePrimarySurfaceShadowDDNL - Could not create "
"primary surface: %08x\n", (unsigned int) ddrval);
}
return FALSE;
}
#if 1
winDebug ("winCreatePrimarySurfaceShadowDDNL - Created primary surface\n");
#endif
/* Attach our clipper to our primary surface handle */
ddrval = IDirectDrawSurface4_SetClipper (pScreenPriv->pddsPrimary4,
pScreenPriv->pddcPrimary);
if (FAILED (ddrval))
{
ErrorF ("winCreatePrimarySurfaceShadowDDNL - Primary attach clipper "
"failed: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if 1
winDebug ("winCreatePrimarySurfaceShadowDDNL - Attached clipper to primary "
"surface\n");
#endif
/* Everything was correct */
return TRUE;
}
static void test_surface_from_dc4(void)
{
IDirectDrawSurface4 *surf4;
IDirectDrawSurface *surf1;
DDSURFACEDESC2 ddsd2;
IUnknown *tmp, *tmp2;
IDirectDraw4 *dd4;
IDirectDraw *dd1;
DWORD priv, size;
HRESULT hr;
HDC dc;
dd1 = createDD();
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw4, (void **)&dd4);
if (hr == E_NOINTERFACE) {
win_skip("DirectDraw4 is not supported\n");
IDirectDraw_Release(dd1);
return;
}
ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed, hr %#x.\n", hr);
IDirectDraw_Release(dd1);
memset(&ddsd2, 0, sizeof(ddsd2));
ddsd2.dwSize = sizeof(ddsd2);
ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd2.dwWidth = 64;
ddsd2.dwHeight = 64;
ddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
hr = IDirectDraw4_CreateSurface(dd4, &ddsd2, &surf4, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
IDirectDraw3_Release(dd4);
return;
}
ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr);
hr = IDirectDrawSurface4_QueryInterface(surf4, &IID_IDirectDrawSurface, (void **)&surf1);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
priv = 0xdeadbeef;
size = sizeof(priv);
hr = IDirectDrawSurface4_SetPrivateData(surf4, &guid, &priv, size, 0);
ok(SUCCEEDED(hr), "SetPrivateData failed, hr %#x.\n", hr);
priv = 0;
hr = IDirectDrawSurface4_GetPrivateData(surf4, &guid, &priv, &size);
ok(SUCCEEDED(hr), "GetPrivateData failed, hr %#x.\n", hr);
ok(priv == 0xdeadbeef, "Expected private data 0xdeadbeef, got %#x.\n", priv);
hr = IDirectDrawSurface4_GetDC(surf4, &dc);
ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr);
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %#x.\n", hr);
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp);
ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr);
ok((IDirectDrawSurface4 *)tmp != surf4, "Expected surface != %p.\n", surf4);
hr = IUnknown_QueryInterface(tmp, &IID_IDirectDrawSurface, (void **)&tmp2);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
ok(tmp2 == tmp, "Expected %p, got %p.\n", tmp, tmp2);
ok((IDirectDrawSurface *)tmp2 != surf1, "Expected surface != %p.\n", surf1);
IUnknown_Release(tmp2);
hr = IUnknown_QueryInterface(tmp, &IID_IDirectDrawSurface4, (void **)&tmp2);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
ok((IDirectDrawSurface4 *)tmp2 != surf4, "Expected surface != %p.\n", surf4);
priv = 0;
hr = IDirectDrawSurface4_GetPrivateData((IDirectDrawSurface4 *)tmp2, &guid, &priv, &size);
ok(SUCCEEDED(hr), "GetPrivateData failed, hr %#x.\n", hr);
ok(priv == 0xdeadbeef, "Expected private data 0xdeadbeef, got %#x.\n", priv);
IUnknown_Release(tmp2);
IUnknown_Release(tmp);
hr = IDirectDrawSurface4_ReleaseDC(surf4, dc);
ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr);
dc = CreateCompatibleDC(NULL);
ok(!!dc, "CreateCompatibleDC failed.\n");
tmp = (IUnknown *)0xdeadbeef;
hr = IDirectDraw4_GetSurfaceFromDC(dd4, dc, (IDirectDrawSurface4 **)&tmp);
ok(hr == DDERR_NOTFOUND, "Expected DDERR_NOTFOUND, got %#x.\n", hr);
ok(!tmp, "Expected surface NULL, got %p.\n", tmp);
ok(DeleteDC(dc), "DeleteDC failed.\n");
tmp = (IUnknown *)0xdeadbeef;
hr = IDirectDraw4_GetSurfaceFromDC(dd4, NULL, (IDirectDrawSurface4 **)&tmp);
ok(hr == DDERR_NOTFOUND, "Expected DDERR_NOTFOUND, got %#x.\n", hr);
ok(!tmp, "Expected surface NULL, got %p.\n", tmp);
IDirectDrawSurface_Release(surf1);
IDirectDrawSurface4_Release(surf4);
IDirectDraw4_Release(dd4);
}
