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); }