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