void exit_display() { int i; glXMakeContextCurrent(display, None, None, NULL); glXDestroyContext(display, gl_context); glXDestroyWindow(display, gl_window); glXDestroyPbuffer(display, gl_pbuffer); #ifdef USE_NV_FENCE glDeleteFencesNV(1, &nvFence); #endif XDestroyWindow(display, window); for(i = 0; i < numsurfaces; i++) { XvMCDestroySurface(display, &surfaces[i]); } XvMCDestroyBlocks(display, &blocks); XvMCDestroyMacroBlocks(display, ¯o_blocks); XvMCDestroyContext(display, &context); XvUngrabPort(display, portNum, CurrentTime); XCloseDisplay(display); }
SceneOpenGL::~SceneOpenGL() { if (!init_ok) { // TODO this probably needs to clean up whatever has been created until the failure m_overlayWindow->destroy(); return; } foreach (Window * w, windows) delete w; // do cleanup after initBuffer() cleanupGL(); glXMakeCurrent(display(), None, NULL); glXDestroyContext(display(), ctxbuffer); if (m_overlayWindow->window()) { if (hasGLXVersion(1, 3)) glXDestroyWindow(display(), glxbuffer); XDestroyWindow(display(), buffer); m_overlayWindow->destroy(); } else { glXDestroyPixmap(display(), glxbuffer); XFreeGC(display(), gcroot); XFreePixmap(display(), buffer); } SceneOpenGL::EffectFrame::cleanup(); checkGLError("Cleanup"); }
static void clutter_stage_glx_unrealize (ClutterStageWindow *stage_window) { ClutterBackend *backend = clutter_get_default_backend (); ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (backend); ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window); ClutterStageGLX *stage_glx = CLUTTER_STAGE_GLX (stage_window); /* Note unrealize should free up any backend stage related resources */ CLUTTER_NOTE (BACKEND, "Unrealizing stage"); clutter_x11_trap_x_errors (); if (stage_glx->glxwin != None) { glXDestroyWindow (backend_x11->xdpy, stage_glx->glxwin); stage_glx->glxwin = None; } if (!stage_x11->is_foreign_xwin && stage_x11->xwin != None) { XDestroyWindow (backend_x11->xdpy, stage_x11->xwin); stage_x11->xwin = None; } else stage_x11->xwin = None; XSync (backend_x11->xdpy, False); clutter_x11_untrap_x_errors (); CLUTTER_MARK (); }
static void clutter_backend_glx_dispose (GObject *gobject) { ClutterBackendGLX *backend_glx = CLUTTER_BACKEND_GLX (gobject); ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (gobject); /* Unrealize all shaders, since the GL context is going away */ _clutter_shader_release_all (); if (backend_glx->gl_context) { glXMakeContextCurrent (backend_x11->xdpy, None, None, NULL); glXDestroyContext (backend_x11->xdpy, backend_glx->gl_context); backend_glx->gl_context = None; } if (backend_glx->dummy_glxwin) { glXDestroyWindow (backend_x11->xdpy, backend_glx->dummy_glxwin); backend_glx->dummy_glxwin = None; } if (backend_glx->dummy_xwin) { XDestroyWindow (backend_x11->xdpy, backend_glx->dummy_xwin); backend_glx->dummy_xwin = None; } G_OBJECT_CLASS (clutter_backend_glx_parent_class)->dispose (gobject); }
GlxBackend::~GlxBackend() { if (isFailed()) { m_overlayWindow->destroy(); } // TODO: cleanup in error case // do cleanup after initBuffer() cleanupGL(); doneCurrent(); gs_tripleBufferUndetected = true; gs_tripleBufferNeedsDetection = false; if (ctx) glXDestroyContext(display(), ctx); if (glxWindow) glXDestroyWindow(display(), glxWindow); if (window) XDestroyWindow(display(), window); overlayWindow()->destroy(); delete m_overlayWindow; }
~GlxDrawable() { if (pbuffer) { glXDestroyPbuffer(display, drawable); } else { glXDestroyWindow(display, drawable); XDestroyWindow(display, window); } }
X11Win::~X11Win(void) { glXDestroyWindow(_d, _glxWin); glXMakeCurrent(_d, 0, 0); glXDestroyContext(_d, _ctx); XDestroyWindow(_d, _w); XFreeColormap(_d, _cmap); XCloseDisplay(_d); }
void ephyr_glamor_glx_screen_fini(struct ephyr_glamor *glamor) { glXMakeCurrent(dpy, None, NULL); glXDestroyContext(dpy, glamor->ctx); glXDestroyWindow(dpy, glamor->glx_win); free(glamor); }
static void gfx_ctx_destroy(void) { if (g_dpy && g_ctx) { glXMakeContextCurrent(g_dpy, None, None, NULL); glXDestroyContext(g_dpy, g_ctx); g_ctx = NULL; } if (g_win) { glXDestroyWindow(g_dpy, g_glx_win); g_glx_win = 0; // Save last used monitor for later. #ifdef HAVE_XINERAMA XWindowAttributes target; Window child; int x = 0, y = 0; XGetWindowAttributes(g_dpy, g_win, &target); XTranslateCoordinates(g_dpy, g_win, DefaultRootWindow(g_dpy), target.x, target.y, &x, &y, &child); g_screen = x11_get_xinerama_monitor(g_dpy, x, y, target.width, target.height); RARCH_LOG("[GLX]: Saved monitor #%u.\n", g_screen); #endif XUnmapWindow(g_dpy, g_win); XDestroyWindow(g_dpy, g_win); g_win = None; } if (g_cmap) { XFreeColormap(g_dpy, g_cmap); g_cmap = None; } if (g_should_reset_mode) { x11_exit_fullscreen(g_dpy, &g_desktop_mode); g_should_reset_mode = false; } if (g_dpy) { XCloseDisplay(g_dpy); g_dpy = NULL; } g_inited = false; g_pglSwapInterval = NULL; }
static void Close (vlc_object_t *obj) { vlc_gl_t *gl = (vlc_gl_t *)obj; vlc_gl_sys_t *sys = gl->sys; Display *dpy = sys->display; glXDestroyContext (dpy, sys->ctx); glXDestroyWindow (dpy, sys->win); XCloseDisplay (dpy); free (sys); }
void WindowImpl::close() { // TODO make this work better if (dpy != nullptr) { glXMakeContextCurrent(dpy, None, None, nullptr); glXDestroyContext(dpy, ctx); glXDestroyWindow(dpy, xWin); XDestroyWindow(dpy, win); XFreeColormap(dpy, cmap); XCloseDisplay(dpy); dpy = nullptr; } }
static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx) { if (!glx) return; x11_input_ctx_destroy(); if (g_x11_dpy && glx->g_ctx) { glFinish(); glXMakeContextCurrent(g_x11_dpy, None, None, NULL); if (!video_driver_ctl(RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT, NULL)) { if (glx->g_hw_ctx) glXDestroyContext(g_x11_dpy, glx->g_hw_ctx); glXDestroyContext(g_x11_dpy, glx->g_ctx); glx->g_ctx = NULL; glx->g_hw_ctx = NULL; } } if (g_x11_win) { glXDestroyWindow(g_x11_dpy, glx->g_glx_win); glx->g_glx_win = 0; /* Save last used monitor for later. */ x11_save_last_used_monitor(DefaultRootWindow(g_x11_dpy)); x11_window_destroy(false); } x11_colormap_destroy(); if (glx->g_should_reset_mode) { x11_exit_fullscreen(g_x11_dpy, &glx->g_desktop_mode); glx->g_should_reset_mode = false; } if (!video_driver_ctl(RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT, NULL) && g_x11_dpy) { XCloseDisplay(g_x11_dpy); g_x11_dpy = NULL; } g_pglSwapInterval = NULL; g_pglSwapIntervalSGI = NULL; g_pglSwapIntervalEXT = NULL; g_major = g_minor = 0; glx->g_core_es = false; }
void GLX_ARB_create_context_teardown(void) { if (glxWin != None) { glXDestroyWindow(dpy, glxWin); glxWin = None; } XFree(visinfo); visinfo = NULL; XSetErrorHandler(old_handler); }
/***************************************************************************** * DestroyOpenGL: destroys an OpenGL provider *****************************************************************************/ static void DestroyOpenGL( vlc_object_t *p_this ) { vout_thread_t *p_vout = (vout_thread_t *)p_this; vout_sys_t *p_sys = p_vout->p_sys; glXDestroyContext( p_sys->p_display, p_sys->gwctx ); if( p_sys->b_glx13 ) { glXDestroyWindow( p_sys->p_display, p_sys->gwnd ); } E_(Deactivate)( p_this ); }
void GraphicsContext::releaseGLSystem() { glXMakeContextCurrent(m_display, None, None, NULL); if (m_context) glXDestroyContext(m_display, m_context); if (m_pbuffer) glXDestroyPbuffer(m_display, m_pbuffer); if (m_window) glXDestroyWindow(m_display, m_window); }
// Destroy the OpenGL context // static void destroyContextGLX(_GLFWwindow* window) { if (window->context.glx.window) { glXDestroyWindow(_glfw.x11.display, window->context.glx.window); window->context.glx.window = None; } if (window->context.glx.handle) { glXDestroyContext(_glfw.x11.display, window->context.glx.handle); window->context.glx.handle = NULL; } }
void window_impl_close(struct rtb_window *rwin) { struct xrtb_window *self = RTB_WINDOW_AS(rwin, xrtb_window); glXMakeContextCurrent(self->xrtb->dpy, None, None, NULL); glXDestroyWindow(self->xrtb->dpy, self->gl_win); xcb_destroy_window(self->xrtb->xcb_conn, self->xcb_win); glXDestroyContext(self->xrtb->dpy, self->gl_ctx); uv_mutex_unlock(&self->lock); uv_mutex_destroy(&self->lock); free(self); }
void GLWindow::destroy() { // hide window if (this->window != None) { XUnmapWindow(this->display, this->window); } // destroy opengl framebuffer if (this->glxWindow != None) { glXDestroyWindow(this->display, this->glxWindow); this->glxWindow = None; } // destroy window if (this->window != None) { XDestroyWindow(this->display, this->window); this->window = None; } // destroy colormap if (this->colormap != None) { XFreeColormap(this->display, this->colormap); this->colormap = None; } // destroy framebuffer configuration if (this->visualinfo != NULL) { XFree(this->visualinfo); this->visualinfo = NULL; } // destroy opengl context if (this->glxContext != NULL) { glXDestroyContext(this->display, this->glxContext); this->glxContext = NULL; } // free opengl framebuffer configurations if (this->glxConfigs != NULL) { XFree(this->glxConfigs); this->glxConfigs = NULL; } this->visible = false; this->x = this->y = 0; this->_width = this->_height = 0; this->mouse = false; this->mouseX = this->mouseY = 0; }
void XvMCTextures::DeInit(void) { VERBOSE(VB_IMPORTANT, LOC + "DeInit"); if (!XJ_disp) return; // already called X11L; glXMakeContextCurrent(XJ_disp, None, None, NULL); glXDestroyContext(XJ_disp, glx_context); glx_context = 0; glXDestroyWindow( XJ_disp, glx_window); glx_window = 0; glXDestroyPbuffer(XJ_disp, glx_pbuffer); glx_pbuffer = 0; XDestroyWindow( XJ_disp, gl_window); gl_window = 0; gl_vid_textures.clear(); gl_osd_textures.clear(); XJ_disp = NULL; X11U; }
void gl_platform_cleanup_swapchain(struct gs_swap_chain *swap) { Display *display = swap->wi->display; struct gl_windowinfo *info = swap->wi; if (!info) return; if (info->glxid) glXDestroyWindow(display, info->glxid); if (info->int_id) XDestroyWindow(display, info->int_id); info->glxid = 0; info->int_id = 0; }
void MFRenderer_DestroyDisplay(MFDisplay *pDisplay) { if(gpDeviceRenderTarget) MFRenderTarget_Release(gpDeviceRenderTarget); #if MF_DISPLAY == MF_DRIVER_X11 if(fbConfigs != NULL) { XFree(fbConfigs); fbConfigs = NULL; } if(glXContext != NULL) { glXDestroyContext(xdisplay, glXContext); glXContext = NULL; } if(glXWindow != 0) { glXDestroyWindow(xdisplay, glXWindow); glXWindow = 0; } #elif MF_DISPLAY == MF_DRIVER_WIN32 HWND hWnd = (HWND)MFWindow_GetSystemWindowHandle(pDisplay->settings.pWindow); if(hRC) { if(wglMakeCurrent(NULL, NULL)) { wglDeleteContext(hRC); } hRC = NULL; } if(hDC) { ReleaseDC(hWnd, hDC); hDC = NULL; } #elif MF_DISPLAY == MF_DRIVER_SDL2 SDL_GL_DeleteContext(glContext); #endif }
static void xdpy_destroy_display_hook_default(ALLEGRO_DISPLAY *d, bool is_last) { ALLEGRO_SYSTEM_XGLX *s = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver(); ALLEGRO_DISPLAY_XGLX *glx = (ALLEGRO_DISPLAY_XGLX *)d; (void)is_last; if (glx->context) { glXDestroyContext(s->gfxdisplay, glx->context); glx->context = NULL; ALLEGRO_DEBUG("destroy context.\n"); } if (glx->fbc) { al_free(glx->fbc); glx->fbc = NULL; XFree(glx->xvinfo); glx->xvinfo = NULL; } else if (glx->xvinfo) { al_free(glx->xvinfo); glx->xvinfo = NULL; } if ((glx->glxwindow) && (glx->glxwindow != glx->window)) { glXDestroyWindow(s->x11display, glx->glxwindow); glx->glxwindow = 0; ALLEGRO_DEBUG("destroy glx window\n"); } _al_cond_destroy(&glx->mapped); _al_cond_destroy(&glx->selectioned); ALLEGRO_DEBUG("destroy window.\n"); XDestroyWindow(s->x11display, glx->window); _al_xglx_unuse_adapter(s, glx->adapter); if (d->flags & ALLEGRO_FULLSCREEN) { restore_mode_if_last_fullscreen_display(s, glx); } }
DECLEXPORT(EGLBoolean) eglDestroySurface(EGLDisplay hDisplay, EGLSurface hSurface) { Display *pDisplay = (Display *)hDisplay; if (!VALID_PTR(hDisplay)) return setEGLError(EGL_NOT_INITIALIZED); switch ((GLXDrawable)hSurface & VBEGL_ANY_SURFACE) { case VBEGL_WINDOW_SURFACE: glXDestroyWindow(pDisplay, (GLXWindow)hSurface & ~VBEGL_WINDOW_SURFACE); return clearEGLError(); case VBEGL_PBUFFER_SURFACE: glXDestroyPbuffer(pDisplay, (GLXPbuffer)hSurface & ~VBEGL_PBUFFER_SURFACE); return clearEGLError(); case VBEGL_PIXMAP_SURFACE: glXDestroyPixmap(pDisplay, (GLXPixmap)hSurface & ~VBEGL_PIXMAP_SURFACE); return clearEGLError(); default: return setEGLError(EGL_BAD_SURFACE); } }
int main(int argc, char **argv) { XVisualInfo *visinfo; int i; for (i = 1; i < argc; ++i) { if (!strcmp(argv[i], "-auto")) piglit_automatic = 1; else fprintf(stderr, "Unknown option: %s\n", argv[i]); } dpy = XOpenDisplay(NULL); if (dpy == NULL) { fprintf(stderr, "couldn't open display\n"); piglit_report_result(PIGLIT_FAIL); } visinfo = piglit_get_glx_visual(dpy); win = piglit_get_glx_window(dpy, visinfo); XMapWindow(dpy, win); for (i = 0; i < num_contexts; i++) { ctx[i] = piglit_get_glx_context(dpy, visinfo); } glXMakeCurrent(dpy, win, ctx[0]); piglit_dispatch_default_init(PIGLIT_DISPATCH_GL); piglit_glx_event_loop(dpy, draw); XFree(visinfo); glXDestroyWindow(dpy, win); for (i = 0; i < num_contexts; i++) { glXDestroyContext(dpy, ctx[i]); } return 0; }
GlxBackend::~GlxBackend() { if (isFailed()) { m_overlayWindow->destroy(); } // TODO: cleanup in error case // do cleanup after initBuffer() cleanupGL(); checkGLError("Cleanup"); doneCurrent(); if (ctx) glXDestroyContext(display(), ctx); if (glxWindow) glXDestroyWindow(display(), glxWindow); if (window) XDestroyWindow(display(), window); overlayWindow()->destroy(); delete m_overlayWindow; }
static void clutter_stage_glx_unrealize (ClutterStageWindow *stage_window) { ClutterStageX11 *stage_x11 = CLUTTER_STAGE_X11 (stage_window); ClutterStageGLX *stage_glx = CLUTTER_STAGE_GLX (stage_window); ClutterBackendX11 *backend_x11 = stage_x11->backend; /* Note unrealize should free up any backend stage related resources */ CLUTTER_NOTE (BACKEND, "Unrealizing GLX stage [%p]", stage_glx); clutter_x11_trap_x_errors (); if (stage_glx->glxwin != None) { glXDestroyWindow (backend_x11->xdpy, stage_glx->glxwin); stage_glx->glxwin = None; } _clutter_stage_x11_destroy_window_untrapped (stage_x11); XSync (backend_x11->xdpy, False); clutter_x11_untrap_x_errors (); }
int setup_and_run(Display *display, xcb_connection_t *connection, int default_screen, xcb_screen_t *screen) { int visualID = 0; /*Query framebuffer configurations */ GLXFBConfig *fb_configs = 0; int num_fb_configs = 0; fb_configs = glXGetFBConfigs(display, default_screen, &num_fb_configs); if (!fb_configs || num_fb_configs == 0) { fprintf(stderr, "glXGetFBConfigs failed\n"); return -1; } /* Select first framebuffer config and query visualID */ GLXFBConfig fb_config = fb_configs[0]; glXGetFBConfigAttrib(display, fb_config, GLX_VISUAL_ID, &visualID); GLXContext context; /* Create OpenGL context */ context = glXCreateNewContext(display, fb_config, GLX_RGBA_TYPE, 0, True); if (!context) { fprintf(stderr, "glXCreateNewContext failed\n"); return -1; } /* Create XID's for colormap and window */ xcb_colormap_t colormap = xcb_generate_id(connection); xcb_window_t window = xcb_generate_id(connection); /* Create colormap */ xcb_create_colormap( connection, XCB_COLORMAP_ALLOC_NONE, colormap, screen->root, visualID); /* Create window */ uint32_t eventmask = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS; uint32_t valuelist[] = {eventmask, colormap, 0}; uint32_t valuemask = XCB_CW_EVENT_MASK | XCB_CW_COLORMAP; xcb_create_window( connection, XCB_COPY_FROM_PARENT, window, screen->root, 0, 0, window_width, window_height, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, visualID, valuemask, valuelist); /* NOTE: window must be mapped before glXMakeContextCurrent */ xcb_map_window(connection, window); /* Create GLX window */ GLXDrawable drawable = 0; GLXWindow glxwindow = glXCreateWindow(display, fb_config, window, 0); if (!glxwindow) { xcb_destroy_window(connection, window); glXDestroyContext(display, context); fprintf(stderr, "glXCreateWindow failed\n"); return -1; } drawable = glxwindow; /* make OpenGL context current */ #if 1 if (!glXMakeContextCurrent(display, drawable, drawable, context)) { xcb_destroy_window(connection, window); glXDestroyContext(display, context); fprintf(stderr, "glXMakeContextCurrent failed\n"); return -1; } #else if (!glXMakeCurrent(display, drawable, context)) { xcb_destroy_window(connection, window); glXDestroyContext(display, context); fprintf(stderr, "glXMakeContextCurrent failed\n"); return -1; } #endif /* run main loop */ int retval = main_loop (display, connection, screen, window, drawable); /* Cleanup */ glXDestroyWindow(display, glxwindow); xcb_destroy_window(connection, window); glXDestroyContext(display, context); return retval; }
static void gfx_ctx_x_destroy_resources(gfx_ctx_x_data_t *x) { x11_input_ctx_destroy(); if (g_x11_dpy) { switch (x_api) { case GFX_CTX_OPENGL_API: case GFX_CTX_OPENGL_ES_API: #ifdef HAVE_OPENGL if (x->g_ctx) { glFinish(); glXMakeContextCurrent(g_x11_dpy, None, None, NULL); if (!video_driver_ctl(RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT, NULL)) { if (x->g_hw_ctx) glXDestroyContext(g_x11_dpy, x->g_hw_ctx); if (x->g_ctx) glXDestroyContext(g_x11_dpy, x->g_ctx); x->g_ctx = NULL; x->g_hw_ctx = NULL; } } if (g_x11_win) { if (x->g_glx_win) glXDestroyWindow(g_x11_dpy, x->g_glx_win); x->g_glx_win = 0; } #endif break; case GFX_CTX_VULKAN_API: #ifdef HAVE_VULKAN vulkan_context_destroy(&x->vk, g_x11_win != 0); #endif break; case GFX_CTX_NONE: default: break; } } if (g_x11_win) { /* Save last used monitor for later. */ x11_save_last_used_monitor(DefaultRootWindow(g_x11_dpy)); x11_window_destroy(false); } x11_colormap_destroy(); if (x->g_should_reset_mode) { x11_exit_fullscreen(g_x11_dpy, &x->g_desktop_mode); x->g_should_reset_mode = false; } if (!video_driver_ctl(RARCH_DISPLAY_CTL_IS_VIDEO_CACHE_CONTEXT, NULL) && g_x11_dpy) { XCloseDisplay(g_x11_dpy); g_x11_dpy = NULL; } g_pglSwapInterval = NULL; g_pglSwapIntervalSGI = NULL; #ifdef HAVE_OPENGL g_pglSwapIntervalEXT = NULL; #endif g_major = 0; g_minor = 0; x->g_core_es = false; }
static int Open (vlc_object_t *obj) { vlc_gl_t *gl = (vlc_gl_t *)obj; if (gl->surface->type != VOUT_WINDOW_TYPE_XID || !vlc_xlib_init (obj)) return VLC_EGENERIC; /* Initialize GLX display */ Display *dpy = XOpenDisplay (gl->surface->display.x11); if (dpy == NULL) return VLC_EGENERIC; vlc_gl_sys_t *sys = malloc (sizeof (*sys)); if (unlikely(sys == NULL)) { XCloseDisplay (dpy); return VLC_ENOMEM; } gl->sys = sys; sys->display = dpy; if (!CheckGLX (obj, dpy)) goto error; /* Determine our pixel format */ XWindowAttributes wa; if (!XGetWindowAttributes (dpy, gl->surface->handle.xid, &wa)) goto error; const int snum = XScreenNumberOfScreen (wa.screen); const VisualID visual = XVisualIDFromVisual (wa.visual); static const int attr[] = { GLX_RED_SIZE, 5, GLX_GREEN_SIZE, 5, GLX_BLUE_SIZE, 5, GLX_DOUBLEBUFFER, True, GLX_X_RENDERABLE, True, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, None }; int nelem; GLXFBConfig *confs = glXChooseFBConfig (dpy, snum, attr, &nelem); if (confs == NULL) { msg_Err (obj, "cannot choose GLX frame buffer configurations"); goto error; } GLXFBConfig conf; bool found = false; for (int i = 0; i < nelem && !found; i++) { conf = confs[i]; XVisualInfo *vi = glXGetVisualFromFBConfig (dpy, conf); if (vi == NULL) continue; if (vi->visualid == visual) found = true; XFree (vi); } XFree (confs); if (!found) { msg_Err (obj, "cannot match GLX frame buffer configuration"); goto error; } /* Create a drawing surface */ sys->win = glXCreateWindow (dpy, conf, gl->surface->handle.xid, NULL); if (sys->win == None) { msg_Err (obj, "cannot create GLX window"); goto error; } /* Create an OpenGL context */ sys->ctx = glXCreateNewContext (dpy, conf, GLX_RGBA_TYPE, NULL, True); if (sys->ctx == NULL) { glXDestroyWindow (dpy, sys->win); msg_Err (obj, "cannot create GLX context"); goto error; } /* Initialize OpenGL callbacks */ gl->sys = sys; gl->makeCurrent = MakeCurrent; gl->releaseCurrent = ReleaseCurrent; gl->resize = NULL; gl->swap = SwapBuffers; gl->getProcAddress = GetSymbol; #ifdef GLX_ARB_get_proc_address bool is_swap_interval_set = false; MakeCurrent (gl); # ifdef GLX_SGI_swap_control if (!is_swap_interval_set && CheckGLXext (dpy, snum, "GLX_SGI_swap_control")) { PFNGLXSWAPINTERVALSGIPROC SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) glXGetProcAddressARB ((const GLubyte *)"glXSwapIntervalSGI"); assert (SwapIntervalSGI != NULL); is_swap_interval_set = !SwapIntervalSGI (1); } # endif # ifdef GLX_EXT_swap_control if (!is_swap_interval_set && CheckGLXext (dpy, snum, "GLX_EXT_swap_control")) { PFNGLXSWAPINTERVALEXTPROC SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) glXGetProcAddress ((const GLubyte *)"glXSwapIntervalEXT"); assert (SwapIntervalEXT != NULL); SwapIntervalEXT (dpy, sys->win, 1); is_swap_interval_set = true; } # endif ReleaseCurrent (gl); #endif return VLC_SUCCESS; error: XCloseDisplay (dpy); free (sys); return VLC_EGENERIC; }
static void ctx_glx_destroy_resources(gfx_ctx_glx_data_t *glx) { driver_t *driver = driver_get_ptr(); if (!glx) return; x11_destroy_input_context(&glx->g_xim, &glx->g_xic); if (glx->g_dpy && glx->g_ctx) { glFinish(); glXMakeContextCurrent(glx->g_dpy, None, None, NULL); if (!driver->video_cache_context) { if (glx->g_hw_ctx) glXDestroyContext(glx->g_dpy, glx->g_hw_ctx); glXDestroyContext(glx->g_dpy, glx->g_ctx); glx->g_ctx = NULL; glx->g_hw_ctx = NULL; } } if (glx->g_win) { glXDestroyWindow(glx->g_dpy, glx->g_glx_win); glx->g_glx_win = 0; /* Save last used monitor for later. */ #ifdef HAVE_XINERAMA XWindowAttributes target; Window child; int x = 0, y = 0; XGetWindowAttributes(glx->g_dpy, glx->g_win, &target); XTranslateCoordinates(glx->g_dpy, glx->g_win, DefaultRootWindow(glx->g_dpy), target.x, target.y, &x, &y, &child); glx->g_screen = x11_get_xinerama_monitor(glx->g_dpy, x, y, target.width, target.height); RARCH_LOG("[GLX]: Saved monitor #%u.\n", glx->g_screen); #endif XUnmapWindow(glx->g_dpy, glx->g_win); XDestroyWindow(glx->g_dpy, glx->g_win); glx->g_win = None; } if (glx->g_cmap) { XFreeColormap(glx->g_dpy, glx->g_cmap); glx->g_cmap = None; } if (glx->g_should_reset_mode) { x11_exit_fullscreen(glx->g_dpy, &glx->g_desktop_mode); glx->g_should_reset_mode = false; } if (!driver->video_cache_context && glx->g_dpy) { XCloseDisplay(glx->g_dpy); glx->g_dpy = NULL; } g_pglSwapInterval = NULL; g_pglSwapIntervalSGI = NULL; g_pglSwapIntervalEXT = NULL; g_major = g_minor = 0; glx->g_core_es = false; }