M4Err GetDisplayMode(DDContext *dd)
{
if (dd->switch_res) {
HRESULT hr;
Bool temp_dd = 0;;
if (!dd->pDD) {
LPDIRECTDRAW ddraw;
DirectDrawCreate(NULL, &ddraw, NULL);
#ifdef USE_DX_3
IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw, (LPVOID *)&dd->pDD);
#else
IDirectDraw_QueryInterface(ddraw, &IID_IDirectDraw7, (LPVOID *)&dd->pDD);
#endif
temp_dd = 1;
}
//we start with a hugde res and downscale
dd->fs_width = dd->fs_height = 50000;
#ifdef USE_DX_3
hr = IDirectDraw_EnumDisplayModes(dd->pDD, 0L, NULL, dd, (LPDDENUMMODESCALLBACK) EnumDisplayModes);
#else
hr = IDirectDraw7_EnumDisplayModes(dd->pDD, 0L, NULL, dd, (LPDDENUMMODESCALLBACK2) EnumDisplayModes);
#endif
if (temp_dd) SAFE_DD_RELEASE(dd->pDD);
if (FAILED(hr)) return M4IOErr;
} else {
dd->fs_width = GetSystemMetrics(SM_CXSCREEN);
dd->fs_height = GetSystemMetrics(SM_CYSCREEN);
}
return M4OK;
}
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;
}
BOOL d3d_init(void)
{
HRESULT res;
GUID guid;
Assert(d3d_initialized == FALSE);
LOGINIT("d3d.log");
atexit(d3d_close);
// initialize Direct3d interface
res = IDirectDraw_QueryInterface(_lpDD, &IID_IDirect3D, &_lpD3D);
if (res != DD_OK)
return d3d_handle_error(res);
// enumerate all 3d devices useable by Direct3d
if (d3d_enum_devices(&guid)) return FALSE;
memcpy(&_3DGUID, &guid, sizeof(GUID));
d3d_initialized = TRUE;
return TRUE;
}
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;
}
static int
DDCreateWindow(struct ggi_visual *vis)
{
directx_priv *priv = GGIDIRECTX_PRIV(vis);
int w = 640, h = 480; /* default window size */
int ws_flags = WS_OVERLAPPEDWINDOW & ~WS_MAXIMIZEBOX;
/* toplevel flags */
if (priv->hParent) {
/* determine the parent window size */
RECT r;
GetWindowRect(priv->hParent, &r);
w = r.right - r.left;
h = r.bottom - r.top;
/* flags for a child window */
ws_flags = WS_CHILD;
} else if (priv->fullscreen)
ws_flags = WS_VISIBLE | WS_POPUP;
else {
/* adjust the window size to accommodate for
* the client area
*/
RECT r;
r.left = r.top = 0;
r.right = w;
r.bottom = h;
AdjustWindowRectEx(&r, ws_flags, 0, 0);
w = r.right - r.left;
h = r.bottom - r.top;
}
/* create the window */
priv->hWnd = CreateWindowEx(0, NAME, TITLE, ws_flags,
CW_USEDEFAULT, 0, w, h,
priv->hParent, NULL,
priv->hInstance, vis);
if (!priv->hWnd) {
if (priv->hCursor)
DestroyCursor(priv->hCursor);
priv->hCursor = NULL;
return 0;
}
/* make sure the window is initially hidden */
ShowWindow(priv->hWnd, SW_HIDE);
/* initialize the DirectDraw interface */
DirectDrawCreate(NULL, &priv->lpdd, NULL);
IDirectDraw_QueryInterface(priv->lpdd, &IID_IDirectDraw2,
(LPVOID *) & priv->lpddext);
return 1;
}
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 void testddraw3(void)
{
const GUID My_IID_IDirectDraw3 = {
0x618f8ad4,
0x8b7a,
0x11d0,
{ 0x8f,0xcc,0x0,0xc0,0x4f,0xd9,0x18,0x9d }
};
IDirectDraw3 *dd3;
HRESULT hr;
hr = IDirectDraw_QueryInterface(lpDD, &My_IID_IDirectDraw3, (void **) &dd3);
ok(hr == E_NOINTERFACE, "QueryInterface for IID_IDirectDraw3 returned 0x%08x, expected E_NOINTERFACE\n", hr);
if(SUCCEEDED(hr) && dd3) IDirectDraw3_Release(dd3);
}
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 );
}
}
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 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;
}
//
// 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;
}
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;
}
HRESULT d3drm_device_init(struct d3drm_device *device, UINT version, IDirectDraw *ddraw, IDirectDrawSurface *surface,
BOOL create_z_surface)
{
DDSCAPS caps = { DDSCAPS_ZBUFFER };
IDirectDrawSurface *ds = NULL;
IDirect3DDevice *device1 = NULL;
IDirect3DDevice2 *device2 = NULL;
IDirect3D2 *d3d2 = NULL;
DDSURFACEDESC desc, surface_desc;
HRESULT hr;
device->ddraw = ddraw;
IDirectDraw_AddRef(ddraw);
IDirect3DRM_AddRef(device->d3drm);
device->render_target = surface;
IDirectDrawSurface_AddRef(surface);
desc.dwSize = sizeof(desc);
hr = IDirectDrawSurface_GetSurfaceDesc(surface, &desc);
if (FAILED(hr))
return hr;
if (!(desc.ddsCaps.dwCaps & DDSCAPS_3DDEVICE))
return DDERR_INVALIDCAPS;
hr = IDirectDrawSurface_GetAttachedSurface(surface, &caps, &ds);
if (SUCCEEDED(hr))
{
create_z_surface = FALSE;
IDirectDrawSurface_Release(ds);
ds = NULL;
}
if (create_z_surface)
{
memset(&surface_desc, 0, sizeof(surface_desc));
surface_desc.dwSize = sizeof(surface_desc);
surface_desc.dwFlags = DDSD_CAPS | DDSD_ZBUFFERBITDEPTH | DDSD_WIDTH | DDSD_HEIGHT;
surface_desc.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
surface_desc.u2.dwZBufferBitDepth = 16;
surface_desc.dwWidth = desc.dwWidth;
surface_desc.dwHeight = desc.dwHeight;
hr = IDirectDraw_CreateSurface(ddraw, &surface_desc, &ds, NULL);
if (FAILED(hr))
return hr;
hr = IDirectDrawSurface_AddAttachedSurface(surface, ds);
IDirectDrawSurface_Release(ds);
if (FAILED(hr))
return hr;
}
if (version == 1)
hr = IDirectDrawSurface_QueryInterface(surface, &IID_IDirect3DRGBDevice, (void **)&device1);
else
{
IDirectDraw_QueryInterface(ddraw, &IID_IDirect3D2, (void**)&d3d2);
hr = IDirect3D2_CreateDevice(d3d2, &IID_IDirect3DRGBDevice, surface, &device2);
IDirect3D2_Release(d3d2);
}
if (FAILED(hr))
{
IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
return hr;
}
if (version != 1)
{
hr = IDirect3DDevice2_QueryInterface(device2, &IID_IDirect3DDevice, (void**)&device1);
IDirect3DDevice2_Release(device2);
if (FAILED(hr))
{
IDirectDrawSurface_DeleteAttachedSurface(surface, 0, ds);
return hr;
}
}
device->device = device1;
device->width = desc.dwWidth;
device->height = desc.dwHeight;
return hr;
}
/*
* D3DAppICreateDD
* Creates the DirectDraw device and saves the current palette. If a 3D
* capable DD driver is available, use it as the DD device, otherwise, use
* the HEL. It is assumed that a 3D capable DD hardware driver is not the
* primary device and hence cannot operate in a window (ie it's a fullscreen
* only device displaying on a second monitor). Valid flags:
* D3DAPP_ONLYDDEMULATION Always use the DirectDraw HEL
*/
BOOL
D3DAppICreateDD(DWORD flags)
{
HDC hdc;
int i;
LPDIRECTDRAW lpDD = NULL;
DDCAPS DriverCaps, HELCaps, ddcaps;
LPDIRECTDRAW4 pdd4 = NULL;
/*
* If we aren't forced to use the DirectDraw HEL, search for a 3D capable
* DirectDraw hardware driver and create it.
*/
if (!(flags & D3DAPP_ONLYDDEMULATION))
{
ddcount3d = 0;
LastError = DirectDrawEnumerate(D3DAppIDDEnumCallback, &lpDD);
if (LastError != DD_OK)
{
D3DAppISetErrorString("DirectDrawEnumerate failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
}
if (!lpDD)
{
/*
* If we haven't created a hardware DD device by now, resort to HEL
*/
d3dappi.bIsPrimary = TRUE;
LastError = DirectDrawCreate(NULL, &d3dappi.lpDD, NULL);
if (LastError != DD_OK)
{
D3DAppISetErrorString("DirectDrawCreate failed.\n%s",
D3DAppErrorToString(LastError));
return FALSE;
}
} else
{
d3dappi.lpDD = lpDD;
memset (&DriverCaps, 0, sizeof(DDCAPS));
DriverCaps.dwSize = sizeof(DDCAPS);
memset (&HELCaps, 0, sizeof(DDCAPS));
HELCaps.dwSize = sizeof(DDCAPS);
d3dappi.lpDD->lpVtbl->GetCaps(d3dappi.lpDD, &DriverCaps, &HELCaps);
if (!((DriverCaps.dwCaps & DDCAPS_BLTSTRETCH) || (HELCaps.dwCaps & DDCAPS_BLTSTRETCH)))
{
CanDoStrechBlt = FALSE;
}
}
// find out if current driver can do windowed mode ( need dx6 interface )
// query for IDirectDraw4 ptr
IDirectDraw_QueryInterface( d3dappi.lpDD, &IID_IDirectDraw4, (LPVOID *)&pdd4 );
if ( pdd4 )
{
// get caps
memset( &ddcaps, 0, sizeof( DDCAPS ) );
ddcaps.dwSize = sizeof( DDCAPS );
IDirectDraw4_GetCaps( pdd4, &ddcaps, NULL );
// can do windowed??
if( ddcaps.dwCaps2 & DDCAPS2_CANRENDERWINDOWED )
CanRenderWindowed = TRUE;
else
CanRenderWindowed = FALSE;
// release dd4 interface
IDirectDraw4_Release( pdd4 );
}
/*
* Save the original palette for when we are paused. Just in case we
* start in a fullscreen mode, put them in ppe.
*/
hdc = GetDC(NULL);
GetSystemPaletteEntries(hdc, 0, (1 << 8),
(LPPALETTEENTRY)(&Originalppe[0]));
for (i = 0; i < 256; i++)
ppe[i] = Originalppe[i];
ReleaseDC(NULL, hdc);
return TRUE;
}
static void test_iface_refcnt(void)
{
HRESULT hr;
IDirectDraw *DDraw1;
IDirectDraw2 *DDraw2;
IDirectDraw4 *DDraw4;
IDirectDraw7 *DDraw7;
IDirect3D7 *D3D7;
IDirect3D3 *D3D3;
IDirect3D2 *D3D2;
IDirect3D *D3D1;
long ref;
hr = pDirectDrawCreateEx(NULL, (void **) &DDraw7, &IID_IDirectDraw7, NULL);
ok(hr == DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", hr);
if(!DDraw7)
{
trace("Couldn't create DDraw interface, skipping tests\n");
return;
}
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 1, "Initial IDirectDraw7 reference count is %ld\n", ref);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw4, (void **) &DDraw4);
ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw2, (void **) &DDraw2);
ok(hr == DD_OK, "IDirectDraw7_QueryInterf&ace returned %08x\n", hr);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirectDraw, (void **) &DDraw1);
ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr);
/* All interfaces now have refcount 1! */
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 1, "IDirectDraw7 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 1, "IDirectDraw7 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 1, "IDirectDraw reference count is %ld\n", ref);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirect3D7, (void **) &D3D7);
ok(hr == DD_OK, "IDirectDraw7_QueryInterface returned %08x\n", hr);
/* Apparently IDirectDrawX and IDirect3DX are linked together */
ref = getRefcount( (IUnknown *) D3D7);
ok(ref == 2, "IDirect3D7 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 2, "IDirectDraw7 reference count is %ld\n", ref);
IDirectDraw7_AddRef(DDraw7);
ref = getRefcount( (IUnknown *) D3D7);
ok(ref == 3, "IDirect3D7 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 3, "IDirectDraw7 reference count is %ld\n", ref);
IDirect3D7_Release(D3D7);
ref = getRefcount( (IUnknown *) D3D7);
ok(ref == 2, "IDirect3D7 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 2, "IDirectDraw7 reference count is %ld\n", ref);
/* Can't get older d3d interfaces. WHY????? */
hr = IDirectDraw7_QueryInterface(DDraw4, &IID_IDirect3D3, (void **) &D3D3);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw7_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D3) IDirect3D3_Release(D3D3);
hr = IDirectDraw4_QueryInterface(DDraw4, &IID_IDirect3D3, (void **) &D3D3);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw4_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D3) IDirect3D3_Release(D3D3);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirect3D2, (void **) &D3D2);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw7_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D2) IDirect3D2_Release(D3D2);
hr = IDirectDraw2_QueryInterface(DDraw2, &IID_IDirect3D2, (void **) &D3D2);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw2_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D2) IDirect3D2_Release(D3D2);
hr = IDirectDraw7_QueryInterface(DDraw7, &IID_IDirect3D, (void **) &D3D1);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw7_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D1) IDirect3D_Release(D3D1);
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirect3D, (void **) &D3D1);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D1) IDirect3D_Release(D3D1);
hr = IDirect3D7_QueryInterface(D3D7, &IID_IDirect3D, (void **) &D3D1);
todo_wine ok(hr == E_NOINTERFACE, "IDirect3D7_QueryInterface returned %08x\n", hr);
if(hr == DD_OK && D3D1) IDirect3D_Release(D3D1);
/* Try an AddRef, it only affects the AddRefed interface */
IDirectDraw4_AddRef(DDraw4);
ref = getRefcount( (IUnknown *) DDraw7);
ok(ref == 2, "IDirectDraw7 reference count is %ld\n", ref); /* <-- From the d3d query */
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 2, "IDirectDraw4 reference count is %ld\n", ref); /* <-- The AddRef call */
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 1, "IDirectDraw reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) D3D7);
ok(ref == 2, "IDirect3D7 reference count is %ld\n", ref); /* <-- From the d3d query */
IDirectDraw4_Release(DDraw4);
/* Make sure that they are one object, not different ones */
hr = IDirectDraw4_SetCooperativeLevel(DDraw4, GetDesktopWindow(), DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
ok(hr == DD_OK, "IDirectDraw4::SetCooperativeLevel returned %08x\n", hr);
/* After an window has been set, DDSCL_SETFOCUSWINDOW should return DDERR_HWNDALREADYSET, see the mode test */
hr = IDirectDraw7_SetCooperativeLevel(DDraw7, NULL, DDSCL_SETFOCUSWINDOW);
ok(hr == DDERR_HWNDALREADYSET, "IDirectDraw7::SetCooperativeLevel returned %08x\n", hr);
/* All done, release all interfaces */
IDirectDraw7_Release(DDraw7);
IDirectDraw4_Release(DDraw4);
IDirectDraw2_Release(DDraw2);
IDirectDraw_Release(DDraw1);
IDirect3D7_Release(D3D7);
}
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);
}
/* init DirectX */
static int InitDD(int fullscreen)
{
HRESULT ddrval;
HDC hDC;
directX = fullscreen ? DXFULLSCREEN : DXWINDOWED;
if (!hModule)
hModule = LoadLibrary("ddraw");
if (!hModule) {
/*x_error ("Unable to load DirectX (ddraw.dll)"); */
return 0;
}
/* DirectDraw don't support 16 color modes. Don't even try to initialize
it then. Also avoid unsupported bit depths in the windowed driver */
hDC = CreateDC("DISPLAY", NULL, NULL, NULL);
bitDepth = GetDeviceCaps(hDC, BITSPIXEL);
DeleteDC(hDC);
if (!DXSUPPORTEDDEPTH(fullscreen, bitDepth))
return 0;
DirectDrawCreatePtr =
(ddrawcreateptr) GetProcAddress(hModule, "DirectDrawCreate");
if (!DirectDrawCreatePtr) {
x_error
("Unable to get hook DirectDrawCreate in ddraw.dll. Check your DirectX installation");
return 0;
}
lpDD = NULL;
lpDD2 = NULL;
lpSurfaces[0] = NULL;
lpSurfaces[1] = NULL;
buffer1 = buffer2 = NULL;
bitDepth = 8;
InitWindow();
UpdateWindow(hWnd);
SetFocus(hWnd);
/* contact DirectX */
ddrval = DirectDrawCreatePtr(NULL, &lpDD, NULL);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to create DirectDraw object");
return 0;
}
/* get IDirectDraw2 interface */
ddrval =
IDirectDraw_QueryInterface(lpDD, &IID_IDirectDraw2,
(LPVOID *) & lpDD2);
if (ddrval != DD_OK) {
DeInitDD();
x_error("Failed to get DirectDraw2 object");
return 0;
}
/* enumerate modes */
#ifdef DDRAW_DRIVER
if (!nresolutions && directX == DXFULLSCREEN)
IDirectDraw2_EnumDisplayModes(lpDD2, 0, NULL, NULL,
EnumModesCallback);
#endif
if (!ResizeDD(fullscreen))
return 0;
if (fullscreen) {
SetCapture(hWnd); // make sure no other windows get mouse messages
captured = 1;
}
return 1;
}
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);
}
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 boolean CreatePrimary( win32_driver_t * win32_driver )
{
LPDIRECTDRAW ddobj;
DDSURFACEDESC ddsd;
HRESULT result;
/* create direct draw object */
result = DirectDrawCreate( 0, &ddobj, 0 );
if( result != DD_OK )
{
Error( 0, "DirectDrawCreate : error %ld", result );
xprintf(win32_driver->xine, XINE_VERBOSITY_DEBUG, "vo_out_directx : DirectDrawCreate : error %ld\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 0x%lx", result );
return 0;
}
/* try to get new interface */
result = IDirectDraw_QueryInterface( ddobj, &IID_IDirectDraw, (LPVOID *) &win32_driver->ddobj );
if( result != DD_OK )
{
Error( 0, "ddobj->QueryInterface : DirectX 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 = IDirectDraw_CreateSurface( win32_driver->ddobj, &ddsd, &win32_driver->primary, 0 );
if( result != DD_OK )
{
Error( 0, "CreateSurface ( primary ) : error 0x%lx", result );
return 0;
}
/* create our clipper object */
result = IDirectDraw_CreateClipper( win32_driver->ddobj, 0, &win32_driver->ddclipper, 0 );
if( result != DD_OK )
{
Error( 0, "CreateClipper : error 0x%lx", 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 0x%lx", result );
return 0;
}
/* associate our primary surface with our clipper */
result = IDirectDrawSurface_SetClipper( win32_driver->primary, win32_driver->ddclipper );
if( result != DD_OK )
{
Error( 0, "ddclipper->SetHWnd : error 0x%lx", result );
return 0;
}
/* store our objects in our visual struct */
UpdateRect( win32_driver->win32_visual );
return 1;
}
void
winDetectSupportedEngines(void)
{
OSVERSIONINFO osvi;
/* Initialize the engine support flags */
g_dwEnginesSupported = WIN_SERVER_SHADOW_GDI;
#ifdef XWIN_NATIVEGDI
g_dwEnginesSupported |= WIN_SERVER_NATIVE_GDI;
#endif
/* Get operating system version information */
ZeroMemory(&osvi, sizeof(osvi));
osvi.dwOSVersionInfoSize = sizeof(osvi);
GetVersionEx(&osvi);
/* 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;
}
else {
/* We have DirectDraw */
winErrorFVerb(2,
"winDetectSupportedEngines - DirectDraw installed\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DD;
#ifdef XWIN_PRIMARYFB
/* Allow PrimaryDD engine if NT */
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
g_dwEnginesSupported |= WIN_SERVER_PRIMARY_DD;
winErrorFVerb(2,
"winDetectSupportedEngines - Allowing PrimaryDD\n");
}
#endif
}
/* 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\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);
}
void
winDetectSupportedEngines ()
{
OSVERSIONINFO osvi;
/* Initialize the engine support flags */
g_dwEnginesSupported = WIN_SERVER_SHADOW_GDI;
#if WIN_NATIVE_GDI_SUPPORT
g_dwEnginesSupported |= WIN_SERVER_NATIVE_GDI;
#endif
/* Get operating system version information */
ZeroMemory (&osvi, sizeof (osvi));
osvi.dwOSVersionInfoSize = sizeof (osvi);
GetVersionEx (&osvi);
/* Branch on platform ID */
switch (osvi.dwPlatformId)
{
case VER_PLATFORM_WIN32_NT:
/* Engine 4 is supported on NT only */
ErrorF ("winDetectSupportedEngines - Windows NT/2000/XP\n");
break;
case VER_PLATFORM_WIN32_WINDOWS:
/* Engine 4 is supported on NT only */
ErrorF ("winDetectSupportedEngines - Windows 95/98/Me\n");
break;
}
/* 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 */
ErrorF ("winDetectSupportedEngines - DirectDraw not installed\n");
return;
}
else
{
/* We have DirectDraw */
ErrorF ("winDetectSupportedEngines - DirectDraw installed\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DD;
/* Allow PrimaryDD engine if NT */
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
{
g_dwEnginesSupported |= WIN_SERVER_PRIMARY_DD;
ErrorF ("winDetectSupportedEngines - Allowing PrimaryDD\n");
}
}
/* Try to query for DirectDraw4 interface */
ddrval = IDirectDraw_QueryInterface (lpdd,
&IID_IDirectDraw4,
(LPVOID*) &lpdd4);
if (SUCCEEDED (ddrval))
{
/* We have DirectDraw4 */
ErrorF ("winDetectSupportedEngines - DirectDraw4 installed\n");
g_dwEnginesSupported |= WIN_SERVER_SHADOW_DDNL;
}
/* Cleanup DirectDraw interfaces */
if (lpdd4 != NULL)
IDirectDraw_Release (lpdd4);
if (lpdd != NULL)
IDirectDraw_Release (lpdd);
}
ErrorF ("winDetectSupportedEngines - Returning, supported engines %08x\n",
g_dwEnginesSupported);
}
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
/* Set the padded screen width */
pScreenInfo->dwPaddedWidth = PixmapBytePad (pScreenInfo->dwWidth,
pScreenInfo->dwBPP);
/* 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
/* 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;
}
/* get_dx_ver:
* returns the DirectX dx_version number:
*
* 0 no DirectX installed
* 0x100 DirectX 1 installed
* 0x200 DirectX 2 installed
* 0x300 DirectX 3 installed
* 0x500 at least DirectX 5 installed
* 0x600 at least DirectX 6 installed
* 0x700 at least DirectX 7 installed
*/
int get_dx_ver(void)
{
HRESULT hr;
HINSTANCE ddraw_hinst = NULL;
HINSTANCE dinput_hinst = NULL;
HINSTANCE dsetup_hinst = NULL;
LPDIRECTDRAW directdraw = NULL;
LPDIRECTDRAW2 directdraw2 = NULL;
DIRECTDRAWCREATE DirectDrawCreate = NULL;
DIRECTINPUTCREATE DirectInputCreate = NULL;
DSETUPCREATE DSetupCreate = NULL;
OSVERSIONINFO os_version;
LPDIRECTDRAWSURFACE ddraw_surf = NULL;
LPDIRECTDRAWSURFACE3 ddraw_surf3 = NULL;
DWORD dsetup_revision;
DWORD dsetup_version;
INT dsetup_result;
#if DIRECTX_SDK_VERSION >= 0x600
LPDIRECTDRAWSURFACE4 ddraw_surf4 = NULL;
#if DIRECTX_SDK_VERSION >= 0x700
LPDIRECTDRAWSURFACE7 ddraw_surf7 = NULL;
#endif
#endif
DDSURFACEDESC ddraw_surf_desc;
LPVOID temp;
int dx_version = 0;
/* first get the Windows platform */
os_version.dwOSVersionInfoSize = sizeof(os_version);
if (!GetVersionEx(&os_version))
return dx_version;
if (os_version.dwPlatformId == VER_PLATFORM_WIN32_NT) {
/* NT is easy... NT 4.0 is DX2, 4.0 SP3 is DX3, 5.0 is DX5 at least
* and no DX on earlier versions
*/
if (os_version.dwMajorVersion < 4) {
/* No DX on NT 3.51 or earlier */
return dx_version;
}
/* First check for DX 8 and 9 */
dsetup_hinst = LoadLibrary( "DSETUP.DLL" );
if ( dsetup_hinst ) {
DSetupCreate = (DSETUPCREATE)GetProcAddress(dsetup_hinst, "DirectXSetupGetVersion");
if ( DSetupCreate ) {
dsetup_result = DSetupCreate( &dsetup_version, &dsetup_revision ); // returns 0 on failure
if ( dsetup_result ) {
switch (dsetup_version) {
case 0x00040005:
dx_version = 0x500;
break;
case 0x00040006:
dx_version = 0x600;
break;
case 0x00040007:
dx_version = 0x700;
break;
case 0x00040008: /* v8.x */
dx_version = 0x800;
switch (dsetup_revision) {
case 0x0001032A:
case 0x00010371:
dx_version = 0x810; /* 8.1 */
dx_version = 0x810; /* 8.1 */
break;
case 0x00010385:
dx_version = 0x81a; /* 8.1a or b (stupid MS...) */
break;
case 0x00020386:
dx_version = 0x820; /* 8.2 */
break;
default:
dx_version = 0x800; /* 8.0 */
} /* switch (dsetup_revision) */
case 0x00040009:
switch (dsetup_revision) {
case 0x00000384:
dx_version = 0x900; /* 9.0 */
break;
case 0x00000385:
dx_version = 0x90a; /* 9.0a */
break;
case 0x00000386:
dx_version = 0x90b; /* 9.0b */
break;
case 0x00000387:
dx_version = 0x90b; /* 9.0(b or c) */
break;
case 0x00000388:
dx_version = 0x90c; /* 9.0c */
break;
default:
dx_version = 0x900;
} /* switch (dsetup_revision) */
} /* switch (dsetup_version) */
}
}
FreeLibrary( dsetup_hinst );
if ( dx_version )
return dx_version;
}
if (os_version.dwMajorVersion == 4) {
/* NT4 up to SP2 is DX2, and SP3 onwards is DX3, so we are at least DX2 */
dx_version = 0x200;
/* we are not supposed to be able to tell which SP we are on, so check for DInput */
dinput_hinst = LoadLibrary("DINPUT.DLL");
if (!dinput_hinst) {
/* no DInput... must be DX2 on NT 4 pre-SP3 */
OutputDebugString("Couldn't LoadLibrary DInput\r\n");
return dx_version;
}
DirectInputCreate = (DIRECTINPUTCREATE) GetProcAddress(dinput_hinst, "DirectInputCreateA");
FreeLibrary(dinput_hinst);
if (!DirectInputCreate) {
/* no DInput... must DX2 on NT 4 pre-SP3 */
return dx_version;
}
/* DX3 on NT4 SP3 or higher */
dx_version = 0x300;
return dx_version;
}
/* it's at least NT 5 and it's DX5a or higher:
* drop through to Win9x tests for a test of DDraw
*/
}
/* now we know we are in Windows 9x (or maybe 3.1), so anything's possible;
* first see if DDRAW.DLL even exists.
*/
ddraw_hinst = LoadLibrary("DDRAW.DLL");
if (!ddraw_hinst) {
dx_version = 0;
goto End;
}
/* see if we can create the DirectDraw object */
DirectDrawCreate = (DIRECTDRAWCREATE) GetProcAddress(ddraw_hinst, "DirectDrawCreate");
if (!DirectDrawCreate) {
dx_version = 0;
goto End;
}
hr = DirectDrawCreate(NULL, &directdraw, NULL);
if (FAILED(hr)) {
dx_version = 0;
goto End;
}
/* so DirectDraw exists, we are at least DX1 */
dx_version = 0x100;
/* let's see if IDirectDraw2 exists */
hr = IDirectDraw_QueryInterface(directdraw, &IID_IDirectDraw2, &temp);
if (FAILED(hr)) {
/* no IDirectDraw2 exists... must be DX1 */
goto End;
}
directdraw2 = temp;
/* IDirectDraw2 exists... must be at least DX2 */
IDirectDraw2_Release(directdraw2);
dx_version = 0x200;
/* see if we can create the DirectInput object */
dinput_hinst = LoadLibrary("DINPUT.DLL");
if (!dinput_hinst) {
/* no DInput... must be DX2 */
goto End;
}
DirectInputCreate = (DIRECTINPUTCREATE) GetProcAddress(dinput_hinst, "DirectInputCreateA");
FreeLibrary(dinput_hinst);
if (!DirectInputCreate) {
/* no DInput... must be DX2 */
goto End;
}
/* DirectInputCreate exists; that's enough to tell us that we are at least DX3 */
dx_version = 0x300;
/* we can tell if DX5 is present by checking for the existence of IDirectDrawSurface3;
* first we need a surface to QI off of
*/
memset(&ddraw_surf_desc, 0, sizeof(ddraw_surf_desc));
ddraw_surf_desc.dwSize = sizeof(ddraw_surf_desc);
ddraw_surf_desc.dwFlags = DDSD_CAPS;
ddraw_surf_desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
hr = IDirectDraw_SetCooperativeLevel(directdraw, NULL, DDSCL_NORMAL);
if (FAILED(hr)) {
/* failure: this means DDraw isn't properly installed */
dx_version = 0;
goto End;
}
hr = IDirectDraw_CreateSurface(directdraw, &ddraw_surf_desc, &ddraw_surf, NULL);
if (FAILED(hr)) {
/* failure: this means DDraw isn't properly installed */
dx_version = 0;
goto End;
}
/* try for the IDirectDrawSurface3 interface; if it works, we're on DX5 at least */
hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface3, &temp);
if (FAILED(hr))
goto End;
ddraw_surf3 = temp;
/* QI for IDirectDrawSurface3 succeeded; we must be at least DX5 */
dx_version = 0x500;
#if DIRECTX_SDK_VERSION >= 0x600
/* try for the IDirectDrawSurface4 interface; if it works, we're on DX6 at least */
hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface4, (LPVOID *) &ddraw_surf4);
if (FAILED(hr))
goto End;
/* QI for IDirectDrawSurface4 succeeded; we must be at least DX6 */
dx_version = 0x600;
#if DIRECTX_SDK_VERSION >= 0x700
/* try for the IDirectDrawSurface7 interface; if it works, we're on DX7 at least */
hr = IDirectDrawSurface_QueryInterface(ddraw_surf, &IID_IDirectDrawSurface7, (LPVOID *) &ddraw_surf7);
if (FAILED(hr))
goto End;
/* QI for IDirectDrawSurface7 succeeded; we must be at least DX7 */
dx_version = 0x700;
#endif
#endif
End:
if (directdraw)
IDirectDraw_Release(directdraw);
if (ddraw_hinst)
FreeLibrary(ddraw_hinst);
return dx_version;
}
Bool
winAllocateFBPrimaryDD (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
HRESULT ddrval = DD_OK;
DDSURFACEDESC ddsd;
DDSURFACEDESC *pddsdPrimary = NULL;
DDSURFACEDESC *pddsdOffscreen = NULL;
RECT rcClient;
ErrorF ("winAllocateFBPrimaryDD\n");
/* Get client area location in screen coords */
GetClientRect (pScreenPriv->hwndScreen, &rcClient);
MapWindowPoints (pScreenPriv->hwndScreen,
HWND_DESKTOP,
(LPPOINT)&rcClient, 2);
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL);
if (ddrval != DD_OK)
FatalError ("winAllocateFBPrimaryDD - Could not start DirectDraw\n");
/* Get a DirectDraw2 interface pointer */
ddrval = IDirectDraw_QueryInterface (pScreenPriv->pdd,
&IID_IDirectDraw2,
(LPVOID*) &pScreenPriv->pdd2);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Failed DD2 query: %08x\n",
ddrval);
return FALSE;
}
ErrorF ("winAllocateFBPrimaryDD - Created and initialized DD\n");
/* Are we windowed or fullscreen? */
if (pScreenInfo->fFullScreen)
{
/* Full screen mode */
ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
pScreenPriv->hwndScreen,
DDSCL_FULLSCREEN
| DDSCL_EXCLUSIVE);
if (FAILED (ddrval))
FatalError ("winAllocateFBPrimaryDD - Could not set "
"cooperative level\n");
/* Change the video mode to the mode requested */
ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,
pScreenInfo->dwWidth,
pScreenInfo->dwHeight,
pScreenInfo->dwBPP,
pScreenInfo->dwRefreshRate,
0);
if (FAILED (ddrval))
FatalError ("winAllocateFBPrimaryDD - Could not set "
"full screen display mode\n");
}
else
{
/* Windowed mode */
ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
pScreenPriv->hwndScreen,
DDSCL_NORMAL);
if (FAILED (ddrval))
FatalError ("winAllocateFBPrimaryDD - Could not set "
"cooperative level\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 = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,
&ddsd,
&pScreenPriv->pddsPrimary,
NULL);
if (FAILED (ddrval))
FatalError ("winAllocateFBPrimaryDD - Could not create primary "
"surface %08x\n", ddrval);
ErrorF ("winAllocateFBPrimaryDD - Created primary\n");
/* Allocate a DD surface description for our screen privates */
pddsdPrimary = pScreenPriv->pddsdPrimary
= malloc (sizeof (DDSURFACEDESC));
if (pddsdPrimary == NULL)
FatalError ("winAllocateFBPrimaryDD - Could not allocate surface "
"description memory\n");
ZeroMemory (pddsdPrimary, sizeof (*pddsdPrimary));
pddsdPrimary->dwSize = sizeof (*pddsdPrimary);
/* Describe the offscreen 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 (&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
ddsd.dwHeight = pScreenInfo->dwHeight;
ddsd.dwWidth = pScreenInfo->dwWidth;
/* Create the shadow surface */
ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,
&ddsd,
&pScreenPriv->pddsOffscreen,
NULL);
if (ddrval != DD_OK)
FatalError ("winAllocateFBPrimaryDD - Could not create shadow "
"surface\n");
ErrorF ("winAllocateFBPrimaryDD - Created offscreen\n");
/* Allocate a DD surface description for our screen privates */
pddsdOffscreen = pScreenPriv->pddsdOffscreen
= malloc (sizeof (DDSURFACEDESC));
if (pddsdOffscreen == NULL)
FatalError ("winAllocateFBPrimaryDD - Could not allocate surface "
"description memory\n");
ZeroMemory (pddsdOffscreen, sizeof (*pddsdOffscreen));
pddsdOffscreen->dwSize = sizeof (*pddsdOffscreen);
ErrorF ("winAllocateFBPrimaryDD - Locking primary\n");
/* Lock the primary surface */
ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsPrimary,
pScreenInfo->fFullScreen ? NULL:&rcClient,
pddsdPrimary,
DDLOCK_WAIT,
NULL);
if (ddrval != DD_OK || pddsdPrimary->lpSurface == NULL)
FatalError ("winAllocateFBPrimaryDD - Could not lock "
"primary surface\n");
ErrorF ("winAllocateFBPrimaryDD - Locked primary\n");
/* We don't know how to deal with anything other than RGB */
if (!(pddsdPrimary->ddpfPixelFormat.dwFlags & DDPF_RGB))
FatalError ("winAllocateFBPrimaryDD - Color format other than RGB\n");
/* Grab the pitch from the surface desc */
pScreenInfo->dwStride = (pddsdPrimary->u1.lPitch * 8)
/ pScreenInfo->dwBPP;
/* Save the pointer to our surface memory */
pScreenInfo->pfb = pddsdPrimary->lpSurface;
/* Grab the color depth and masks from the surface description */
pScreenPriv->dwRedMask = pddsdPrimary->ddpfPixelFormat.u2.dwRBitMask;
pScreenPriv->dwGreenMask = pddsdPrimary->ddpfPixelFormat.u3.dwGBitMask;
pScreenPriv->dwBlueMask = pddsdPrimary->ddpfPixelFormat.u4.dwBBitMask;
ErrorF ("winAllocateFBPrimaryDD - Returning\n");
return TRUE;
}
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);
}
static void test_d3d_ifaces(void)
{
IDirectDraw *DDraw1;
IDirectDraw2 *DDraw2;
IDirectDraw4 *DDraw4;
IDirect3D *D3D1;
IDirect3D2 *D3D2;
IDirect3D3 *D3D3;
IDirect3D7 *D3D7;
HRESULT hr;
long ref;
hr = DirectDrawCreate(NULL, &DDraw1, NULL);
ok(hr == DD_OK || hr==DDERR_NODIRECTDRAWSUPPORT, "DirectDrawCreateEx returned: %x\n", hr);
if(!DDraw1)
{
trace("DirectDrawCreate failed with %08x\n", hr);
return;
}
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirectDraw2, (void **) &DDraw2);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirectDraw4, (void **) &DDraw4);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 1, "IDirectDraw reference count is %ld\n", ref);
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirect3D, (void **) &D3D1);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 2, "IDirectDraw reference count is %ld\n", ref);
IDirect3D_Release(D3D1);
hr = IDirectDraw2_QueryInterface(DDraw2, &IID_IDirect3D2, (void **) &D3D2);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 2, "IDirectDraw reference count is %ld\n", ref);
IDirect3D2_Release(D3D2);
hr = IDirectDraw4_QueryInterface(DDraw4, &IID_IDirect3D3, (void **) &D3D3);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 2, "IDirectDraw reference count is %ld\n", ref);
IDirect3D3_Release(D3D3);
/* Try to AddRef the D3D3 interface that has been released already */
IDirect3D3_AddRef(D3D3);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 2, "IDirectDraw reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) D3D3);
ok(ref == 2, "IDirect3D3 reference count is %ld\n", ref);
/* The newer interfaces remain untouched */
ref = getRefcount( (IUnknown *) DDraw4);
ok(ref == 1, "IDirectDraw4 reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw2);
ok(ref == 1, "IDirectDraw2 reference count is %ld\n", ref);
IDirect3D3_Release(D3D3);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 1, "IDirectDraw reference count is %ld\n", ref);
ref = getRefcount( (IUnknown *) DDraw1);
ok(ref == 1, "IDirectDraw reference count is %ld\n", ref);
/* It is possible to query any IDirect3D interfaces from any IDirectDraw interface,
* Except IDirect3D7, it can only be returned by IDirectDraw7(which can't return older ifaces)
*/
hr = IDirectDraw_QueryInterface(DDraw2, &IID_IDirect3D, (void **) &D3D1);
ok(hr == DD_OK, "IDirectDraw2_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D1);
hr = IDirectDraw4_QueryInterface(DDraw4, &IID_IDirect3D, (void **) &D3D1);
ok(hr == DD_OK, "IDirectDraw4_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D1);
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirect3D2, (void **) &D3D2);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D2);
hr = IDirectDraw4_QueryInterface(DDraw4, &IID_IDirect3D2, (void **) &D3D2);
ok(hr == DD_OK, "IDirectDraw4_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D2);
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirect3D3, (void **) &D3D3);
ok(hr == DD_OK, "IDirectDraw_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D3);
hr = IDirectDraw2_QueryInterface(DDraw2, &IID_IDirect3D3, (void **) &D3D3);
ok(hr == DD_OK, "IDirectDraw2_QueryInterface returned %08x\n", hr);
IDirect3D_Release(D3D3);
/* This does NOT work */
hr = IDirectDraw_QueryInterface(DDraw1, &IID_IDirect3D7, (void **) &D3D7);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw_QueryInterface returned %08x\n", hr);
if(D3D7) IDirect3D_Release(D3D7);
hr = IDirectDraw2_QueryInterface(DDraw2, &IID_IDirect3D7, (void **) &D3D7);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw2_QueryInterface returned %08x\n", hr);
if(D3D7) IDirect3D_Release(D3D7);
hr = IDirectDraw4_QueryInterface(DDraw4, &IID_IDirect3D7, (void **) &D3D7);
todo_wine ok(hr == E_NOINTERFACE, "IDirectDraw4_QueryInterface returned %08x\n", hr);
if(D3D7) IDirect3D_Release(D3D7);
/* Release the interfaces */
IDirectDraw4_Release(DDraw4);
IDirectDraw2_Release(DDraw2);
IDirectDraw_Release(DDraw1);
}
static Bool
winAllocateFBShadowDD (ScreenPtr pScreen)
{
winScreenPriv(pScreen);
winScreenInfo *pScreenInfo = pScreenPriv->pScreenInfo;
HRESULT ddrval = DD_OK;
DDSURFACEDESC ddsd;
DDSURFACEDESC *pddsdShadow = NULL;
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD\n");
#endif
/* Create a clipper */
ddrval = (*g_fpDirectDrawCreateClipper) (0,
&pScreenPriv->pddcPrimary,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not create clipper: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - 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 ("winAllocateFBShadowDD - Clipper not attached to "
"window: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - Attached clipper to window\n");
#endif
/* Create a DirectDraw object, store the address at lpdd */
ddrval = (*g_fpDirectDrawCreate) (NULL, &pScreenPriv->pdd, NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not start DirectDraw: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD () - Created and initialized DD\n");
#endif
/* Get a DirectDraw2 interface pointer */
ddrval = IDirectDraw_QueryInterface (pScreenPriv->pdd,
&IID_IDirectDraw2,
(LPVOID*) &pScreenPriv->pdd2);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Failed DD2 query: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
/* Are we full screen? */
if (pScreenInfo->fFullScreen)
{
DDSURFACEDESC ddsdCurrent;
DWORD dwRefreshRateCurrent = 0;
HDC hdc = NULL;
/* Set the cooperative level to full screen */
ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
pScreenPriv->hwndScreen,
DDSCL_EXCLUSIVE
| DDSCL_FULLSCREEN);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - 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 = IDirectDraw2_GetDisplayMode (pScreenPriv->pdd2,
&ddsdCurrent);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - 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 ("winAllocateFBShadowDD - 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))
{
ErrorF ("winAllocateFBShadowDD - Changing video mode\n");
/* Change the video mode to the mode requested, and use the driver default refresh rate on failure */
ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,
pScreenInfo->dwWidth,
pScreenInfo->dwHeight,
pScreenInfo->dwBPP,
pScreenInfo->dwRefreshRate,
0);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not set "\
"full screen display mode: %08x\n",
(unsigned int) ddrval);
ErrorF ("winAllocateFBShadowDD - Using default driver refresh rate\n");
ddrval = IDirectDraw2_SetDisplayMode (pScreenPriv->pdd2,
pScreenInfo->dwWidth,
pScreenInfo->dwHeight,
pScreenInfo->dwBPP,
0,
0);
if (FAILED(ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not set default refresh rate "
"full screen display mode: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
}
}
else
{
ErrorF ("winAllocateFBShadowDD - Not changing video mode\n");
}
/* Release our DC */
ReleaseDC (NULL, hdc);
hdc = NULL;
}
else
{
/* Set the cooperative level for windowed mode */
ddrval = IDirectDraw2_SetCooperativeLevel (pScreenPriv->pdd2,
pScreenPriv->hwndScreen,
DDSCL_NORMAL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not set "\
"cooperative level: %08x\n",
(unsigned int) ddrval);
return FALSE;
}
}
/* Create the primary surface */
if (!winCreatePrimarySurfaceShadowDD (pScreen))
{
ErrorF ("winAllocateFBShadowDD - winCreatePrimarySurfaceShadowDD "
"failed\n");
return FALSE;
}
/* 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 (&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_SYSTEMMEMORY;
ddsd.dwHeight = pScreenInfo->dwHeight;
ddsd.dwWidth = pScreenInfo->dwWidth;
/* Create the shadow surface */
ddrval = IDirectDraw2_CreateSurface (pScreenPriv->pdd2,
&ddsd,
&pScreenPriv->pddsShadow,
NULL);
if (FAILED (ddrval))
{
ErrorF ("winAllocateFBShadowDD - Could not create shadow "\
"surface: %08x\n", (unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - Created shadow\n");
#endif
/* Allocate a DD surface description for our screen privates */
pddsdShadow = pScreenPriv->pddsdShadow = malloc (sizeof (DDSURFACEDESC));
if (pddsdShadow == NULL)
{
ErrorF ("winAllocateFBShadowDD - Could not allocate surface "\
"description memory\n");
return FALSE;
}
ZeroMemory (pddsdShadow, sizeof (*pddsdShadow));
pddsdShadow->dwSize = sizeof (*pddsdShadow);
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - Locking shadow\n");
#endif
/* Lock the shadow surface */
ddrval = IDirectDrawSurface2_Lock (pScreenPriv->pddsShadow,
NULL,
pddsdShadow,
DDLOCK_WAIT,
NULL);
if (FAILED (ddrval) || pddsdShadow->lpSurface == NULL)
{
ErrorF ("winAllocateFBShadowDD - Could not lock shadow "\
"surface: %08x\n", (unsigned int) ddrval);
return FALSE;
}
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - Locked shadow\n");
#endif
/* We don't know how to deal with anything other than RGB */
if (!(pddsdShadow->ddpfPixelFormat.dwFlags & DDPF_RGB))
{
ErrorF ("winAllocateFBShadowDD - Color format other than RGB\n");
return FALSE;
}
/* Grab the pitch from the surface desc */
pScreenInfo->dwStride = (pddsdShadow->u1.lPitch * 8)
/ pScreenInfo->dwBPP;
/* Save the pointer to our surface memory */
pScreenInfo->pfb = pddsdShadow->lpSurface;
/* Grab the color depth and masks from the surface description */
pScreenPriv->dwRedMask = pddsdShadow->ddpfPixelFormat.u2.dwRBitMask;
pScreenPriv->dwGreenMask = pddsdShadow->ddpfPixelFormat.u3.dwGBitMask;
pScreenPriv->dwBlueMask = pddsdShadow->ddpfPixelFormat.u4.dwBBitMask;
#if CYGDEBUG
winDebug ("winAllocateFBShadowDD - Returning\n");
#endif
return TRUE;
}
static void test_surface_from_dc3(void)
{
IDirectDrawSurface3 *surf3;
IDirectDrawSurface *surf1;
IDirectDrawSurface *tmp;
DDSURFACEDESC ddsd;
IDirectDraw3 *dd3;
IDirectDraw *dd1;
HRESULT hr;
HDC dc;
dd1 = createDD();
hr = IDirectDraw_QueryInterface(dd1, &IID_IDirectDraw3, (void **)&dd3);
ok(SUCCEEDED(hr), "IDirectDraw_QueryInterface failed, hr %#x.\n", hr);
IDirectDraw_Release(dd1);
memset(&ddsd, 0, sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.dwWidth = 64;
ddsd.dwHeight = 64;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN;
hr = IDirectDraw3_CreateSurface(dd3, &ddsd, &surf1, NULL);
if (hr == DDERR_UNSUPPORTEDMODE) {
win_skip("Unsupported mode\n");
IDirectDraw3_Release(dd3);
return;
}
ok(SUCCEEDED(hr), "CreateSurface failed, hr %#x.\n", hr);
hr = IDirectDrawSurface3_QueryInterface(surf1, &IID_IDirectDrawSurface, (void **)&surf3);
ok(SUCCEEDED(hr), "QueryInterface failed, hr %#x.\n", hr);
IDirectDrawSurface_Release(surf1);
hr = IDirectDrawSurface3_GetDC(surf3, &dc);
ok(SUCCEEDED(hr), "GetDC failed, hr %#x.\n", hr);
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, NULL);
ok(hr == E_POINTER, "Expected E_POINTER, got %#x.\n", hr);
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, &tmp);
ok(SUCCEEDED(hr), "GetSurfaceFromDC failed, hr %#x.\n", hr);
ok((IDirectDrawSurface3 *)tmp == surf3, "Expected surface != %p.\n", surf3);
IUnknown_Release(tmp);
hr = IDirectDrawSurface3_ReleaseDC(surf3, dc);
ok(SUCCEEDED(hr), "ReleaseDC failed, hr %#x.\n", hr);
dc = CreateCompatibleDC(NULL);
ok(!!dc, "CreateCompatibleDC failed.\n");
tmp = (IDirectDrawSurface *)0xdeadbeef;
hr = IDirectDraw3_GetSurfaceFromDC(dd3, dc, &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");
IDirectDrawSurface3_Release(surf3);
IDirectDraw3_Release(dd3);
}