git.sesse.net Git - vlc/blob - modules/video_output/xcb/glx.c

   1 /**
   2  * @file glx.c
   3  * @brief GLX video output module for VLC media player
   4  */
   5 /*****************************************************************************
   6  * Copyright © 2004 the VideoLAN team
   7  * Copyright © 2009 Rémi Denis-Courmont
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  22  ****************************************************************************/
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include <stdlib.h>
  29 #include <assert.h>
  30
  31 #include <xcb/xcb.h>
  32 #include <X11/Xlib-xcb.h>
  33 #include <GL/glx.h>
  34
  35 #include <vlc_common.h>
  36 #include <vlc_plugin.h>
  37 #include <vlc_vout_display.h>
  38 #include <vlc_vout_opengl.h>
  39 #include "../opengl.h"
  40
  41 #include "xcb_vlc.h"
  42
  43 static int  Open (vlc_object_t *);
  44 static void Close (vlc_object_t *);
  45
  46 /*
  47  * Module descriptor
  48  */
  49 vlc_module_begin ()
  50     set_shortname (N_("GLX"))
  51     set_description (N_("GLX video output (XCB)"))
  52     set_category (CAT_VIDEO)
  53     set_subcategory (SUBCAT_VIDEO_VOUT)
  54     set_capability ("vout display", 20)
  55     set_callbacks (Open, Close)
  56
  57     add_shortcut ("xcb-glx")
  58     add_shortcut ("glx")
  59     add_shortcut ("opengl")
  60 vlc_module_end ()
  61
  62 struct vout_display_sys_t
  63 {
  64     Display *display; /* Xlib instance */
  65     vout_window_t *embed; /* VLC window (when windowed) */
  66
  67     xcb_cursor_t cursor; /* blank cursor */
  68     xcb_window_t window; /* drawable X window */
  69     xcb_window_t glwin; /* GLX window */
  70     bool visible; /* whether to draw */
  71     bool v1_3; /* whether GLX >= 1.3 is available */
  72
  73     GLXContext ctx;
  74     vout_opengl_t gl;
  75     vout_display_opengl_t vgl;
  76     picture_pool_t *pool; /* picture pool */
  77 };
  78
  79 static picture_pool_t *Pool (vout_display_t *, unsigned);
  80 static void PictureRender (vout_display_t *, picture_t *);
  81 static void PictureDisplay (vout_display_t *, picture_t *);
  82 static int Control (vout_display_t *, int, va_list);
  83 static void Manage (vout_display_t *);
  84
  85 static void SwapBuffers (vout_opengl_t *gl);
  86
  87 static vout_window_t *MakeWindow (vout_display_t *vd)
  88 {
  89     vout_window_cfg_t wnd_cfg;
  90
  91     memset (&wnd_cfg, 0, sizeof (wnd_cfg));
  92     wnd_cfg.type = VOUT_WINDOW_TYPE_XID;
  93     wnd_cfg.width  = vd->cfg->display.width;
  94     wnd_cfg.height = vd->cfg->display.height;
  95
  96     vout_window_t *wnd = vout_display_NewWindow (vd, &wnd_cfg);
  97     if (wnd == NULL)
  98         msg_Err (vd, "parent window not available");
  99     return wnd;
 100 }
 101
 102 static const xcb_screen_t *
 103 FindWindow (vout_display_t *vd, xcb_connection_t *conn,
 104             unsigned *restrict pnum, uint8_t *restrict pdepth,
 105             uint16_t *restrict pwidth, uint16_t *restrict pheight)
 106 {
 107     vout_display_sys_t *sys = vd->sys;
 108
 109     xcb_get_geometry_reply_t *geo =
 110         xcb_get_geometry_reply (conn,
 111             xcb_get_geometry (conn, sys->embed->handle.xid), NULL);
 112     if (geo == NULL)
 113     {
 114         msg_Err (vd, "parent window not valid");
 115         return NULL;
 116     }
 117
 118     xcb_window_t root = geo->root;
 119     *pdepth = geo->depth;
 120     *pwidth = geo->width;
 121     *pheight = geo->height;
 122     free (geo);
 123
 124     /* Find the selected screen */
 125     const xcb_setup_t *setup = xcb_get_setup (conn);
 126     const xcb_screen_t *screen = NULL;
 127     unsigned num = 0;
 128
 129     for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
 130          i.rem > 0;
 131          xcb_screen_next (&i))
 132     {
 133         if (i.data->root == root)
 134         {
 135             screen = i.data;
 136             break;
 137         }
 138         num++;
 139     }
 140
 141     if (screen == NULL)
 142     {
 143         msg_Err (vd, "parent window screen not found");
 144         return NULL;
 145     }
 146     msg_Dbg (vd, "using screen 0x%"PRIx32 " (number: %u)", root, num);
 147     *pnum = num;
 148     return screen;
 149 }
 150
 151 static bool CheckGLX (vout_display_t *vd, Display *dpy, bool *restrict pv13)
 152 {
 153     int major, minor;
 154     bool ok = false;
 155
 156     if (!glXQueryVersion (dpy, &major, &minor))
 157         msg_Dbg (vd, "GLX extension not available");
 158     else
 159     if (major != 1)
 160         msg_Dbg (vd, "GLX extension version %d.%d unknown", major, minor);
 161     else
 162     if (minor < 2)
 163         msg_Dbg (vd, "GLX extension version %d.%d too old", major, minor);
 164     else
 165     {
 166         msg_Dbg (vd, "using GLX extension version %d.%d", major, minor);
 167         ok = true;
 168         *pv13 = minor >= 3;
 169     }
 170     return ok;
 171 }
 172
 173 static int CreateWindow (vout_display_t *vd, xcb_connection_t *conn,
 174                          uint_fast8_t depth, xcb_visualid_t vid,
 175                          uint_fast16_t width, uint_fast16_t height)
 176 {
 177     vout_display_sys_t *sys = vd->sys;
 178     const uint32_t mask = XCB_CW_EVENT_MASK;
 179     const uint32_t values[] = {
 180         /* XCB_CW_EVENT_MASK */
 181         XCB_EVENT_MASK_VISIBILITY_CHANGE,
 182     };
 183     xcb_void_cookie_t cc, cm;
 184
 185     cc = xcb_create_window_checked (conn, depth, sys->window,
 186                                     sys->embed->handle.xid, 0, 0,
 187                                     width, height, 0,
 188                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
 189                                     vid, mask, values);
 190     cm = xcb_map_window_checked (conn, sys->window);
 191     if (CheckError (vd, conn, "cannot create X11 window", cc)
 192      || CheckError (vd, conn, "cannot map X11 window", cm))
 193         return VLC_EGENERIC;
 194
 195     msg_Dbg (vd, "using X11 window %08"PRIx32, sys->window);
 196     return VLC_SUCCESS;
 197 }
 198
 199 /**
 200  * Probe the X server.
 201  */
 202 static int Open (vlc_object_t *obj)
 203 {
 204     vout_display_t *vd = (vout_display_t *)obj;
 205     vout_display_sys_t *sys = malloc (sizeof (*sys));
 206
 207     if (sys == NULL)
 208         return VLC_ENOMEM;
 209
 210     vd->sys = sys;
 211     sys->pool = NULL;
 212     sys->gl.sys = NULL;
 213
 214     /* Get window */
 215     sys->embed = MakeWindow (vd);
 216     if (sys->embed == NULL)
 217     {
 218         free (sys);
 219         return VLC_EGENERIC;
 220     }
 221
 222     /* Connect to X server */
 223     Display *dpy = XOpenDisplay (sys->embed->x11_display);
 224     if (dpy == NULL)
 225     {
 226         vout_display_DeleteWindow (vd, sys->embed);
 227         free (sys);
 228         return VLC_EGENERIC;
 229     }
 230     sys->display = dpy;
 231     sys->ctx = NULL;
 232     XSetEventQueueOwner (dpy, XCBOwnsEventQueue);
 233
 234     if (!CheckGLX (vd, dpy, &sys->v1_3))
 235         goto error;
 236
 237     xcb_connection_t *conn = XGetXCBConnection (dpy);
 238     assert (conn);
 239     RegisterMouseEvents (obj, conn, sys->embed->handle.xid);
 240
 241     /* Find window parameters */
 242     unsigned snum;
 243     uint8_t depth;
 244     uint16_t width, height;
 245     const xcb_screen_t *scr = FindWindow (vd, conn, &snum, &depth,
 246                                           &width, &height);
 247     if (scr == NULL)
 248         goto error;
 249
 250     sys->window = xcb_generate_id (conn);
 251
 252     /* Determine our pixel format */
 253     if (sys->v1_3)
 254     {   /* GLX 1.3 */
 255         static const int attr[] = {
 256             GLX_RED_SIZE, 5,
 257             GLX_GREEN_SIZE, 5,
 258             GLX_BLUE_SIZE, 5,
 259             GLX_DOUBLEBUFFER, True,
 260             GLX_X_RENDERABLE, True,
 261             GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
 262             None };
 263
 264         xcb_get_window_attributes_reply_t *wa =
 265             xcb_get_window_attributes_reply (conn,
 266                 xcb_get_window_attributes (conn, sys->embed->handle.xid),
 267                 NULL);
 268         if (wa == NULL)
 269             goto error;
 270         xcb_visualid_t visual = wa->visual;
 271         free (wa);
 272
 273         int nelem;
 274         GLXFBConfig *confs = glXChooseFBConfig (dpy, snum, attr, &nelem);
 275         if (confs == NULL)
 276         {
 277             msg_Err (vd, "no GLX frame bufer configurations");
 278             goto error;
 279         }
 280
 281         GLXFBConfig conf;
 282         bool found = false;
 283
 284         for (int i = 0; i < nelem && !found; i++)
 285         {
 286             conf = confs[i];
 287
 288             XVisualInfo *vi = glXGetVisualFromFBConfig (dpy, conf);
 289             if (vi == NULL)
 290                 continue;
 291
 292             if (vi->visualid == visual)
 293                 found = true;
 294             XFree (vi);
 295         }
 296         XFree (confs);
 297
 298         if (!found)
 299         {
 300             msg_Err (vd, "no matching GLX frame buffer configuration");
 301             goto error;
 302         }
 303
 304         sys->glwin = None;
 305         if (!CreateWindow (vd, conn, depth, 0 /* ??? */, width, height))
 306             sys->glwin = glXCreateWindow (dpy, conf, sys->window, NULL );
 307         if (sys->glwin == None)
 308         {
 309             msg_Err (vd, "cannot create GLX window");
 310             goto error;
 311         }
 312
 313         /* Create an OpenGL context */
 314         sys->ctx = glXCreateNewContext (dpy, conf, GLX_RGBA_TYPE, NULL,
 315                                         True);
 316         if (sys->ctx == NULL)
 317         {
 318             msg_Err (vd, "cannot create GLX context");
 319             goto error;
 320         }
 321
 322         if (!glXMakeContextCurrent (dpy, sys->glwin, sys->glwin, sys->ctx))
 323             goto error;
 324     }
 325     else
 326     {   /* GLX 1.2 */
 327         int attr[] = {
 328             GLX_RGBA,
 329             GLX_RED_SIZE, 5,
 330             GLX_GREEN_SIZE, 5,
 331             GLX_BLUE_SIZE, 5,
 332             GLX_DOUBLEBUFFER,
 333             None };
 334
 335         XVisualInfo *vi = glXChooseVisual (dpy, snum, attr);
 336         if (vi == NULL)
 337         {
 338             msg_Err (vd, "cannot find GLX 1.2 visual" );
 339             goto error;
 340         }
 341         msg_Dbg (vd, "using GLX visual ID 0x%"PRIx32, (uint32_t)vi->visualid);
 342
 343         if (CreateWindow (vd, conn, depth, 0 /* ??? */, width, height) == 0)
 344             sys->ctx = glXCreateContext (dpy, vi, 0, True);
 345         XFree (vi);
 346         if (sys->ctx == NULL)
 347         {
 348             msg_Err (vd, "cannot create GLX context");
 349             goto error;
 350         }
 351
 352         if (glXMakeCurrent (dpy, sys->window, sys->ctx) == False)
 353             goto error;
 354         sys->glwin = sys->window;
 355     }
 356
 357     /* Initialize common OpenGL video display */
 358     sys->gl.lock = NULL;
 359     sys->gl.unlock = NULL;
 360     sys->gl.swap = SwapBuffers;
 361     sys->gl.sys = sys;
 362
 363     if (vout_display_opengl_Init (&sys->vgl, &vd->fmt, &sys->gl))
 364     {
 365         sys->gl.sys = NULL;
 366         goto error;
 367     }
 368
 369     sys->cursor = CreateBlankCursor (conn, scr);
 370     sys->visible = false;
 371
 372     /* */
 373     vout_display_info_t info = vd->info;
 374     info.has_pictures_invalid = false;
 375
 376     /* Setup vout_display_t once everything is fine */
 377     vd->info = info;
 378
 379     vd->pool = Pool;
 380     vd->prepare = PictureRender;
 381     vd->display = PictureDisplay;
 382     vd->control = Control;
 383     vd->manage = Manage;
 384
 385     /* */
 386     vout_display_SendEventFullscreen (vd, false);
 387     vout_display_SendEventDisplaySize (vd, width, height, false);
 388
 389     return VLC_SUCCESS;
 390
 391 error:
 392     Close (obj);
 393     return VLC_EGENERIC;
 394 }
 395
 396
 397 /**
 398  * Disconnect from the X server.
 399  */
 400 static void Close (vlc_object_t *obj)
 401 {
 402     vout_display_t *vd = (vout_display_t *)obj;
 403     vout_display_sys_t *sys = vd->sys;
 404     Display *dpy = sys->display;
 405
 406     if (sys->gl.sys != NULL)
 407         vout_display_opengl_Clean (&sys->vgl);
 408
 409     if (sys->ctx != NULL)
 410     {
 411         if (sys->v1_3)
 412         {
 413             glXMakeContextCurrent (dpy, None, None, NULL);
 414             glXDestroyWindow (dpy, sys->glwin);
 415         }
 416         else
 417             glXMakeCurrent (dpy, None, NULL);
 418         glXDestroyContext (dpy, sys->ctx);
 419     }
 420     XCloseDisplay (dpy);
 421     vout_display_DeleteWindow (vd, sys->embed);
 422     free (sys);
 423 }
 424
 425 static void SwapBuffers (vout_opengl_t *gl)
 426 {
 427     vout_display_sys_t *sys = gl->sys;
 428
 429     glXSwapBuffers (sys->display, sys->glwin);
 430 }
 431
 432 /**
 433  * Return a direct buffer
 434  */
 435 static picture_pool_t *Pool (vout_display_t *vd, unsigned requested_count)
 436 {
 437     vout_display_sys_t *sys = vd->sys;
 438     (void)requested_count;
 439
 440     if (!sys->pool)
 441         sys->pool = vout_display_opengl_GetPool (&sys->vgl);
 442     return sys->pool;
 443 }
 444
 445 static void PictureRender (vout_display_t *vd, picture_t *pic)
 446 {
 447    vout_display_sys_t *sys = vd->sys;
 448
 449     vout_display_opengl_Prepare (&sys->vgl, pic);
 450 }
 451
 452 static void PictureDisplay (vout_display_t *vd, picture_t *pic)
 453 {
 454     vout_display_sys_t *sys = vd->sys;
 455
 456     vout_display_opengl_Display (&sys->vgl, &vd->source);
 457     picture_Release (pic);
 458 }
 459
 460 static int Control (vout_display_t *vd, int query, va_list ap)
 461 {
 462     vout_display_sys_t *sys = vd->sys;
 463
 464     switch (query)
 465     {
 466     case VOUT_DISPLAY_CHANGE_FULLSCREEN:
 467     {
 468         const vout_display_cfg_t *c = va_arg (ap, const vout_display_cfg_t *);
 469         return vout_window_SetFullScreen (sys->embed, c->is_fullscreen);
 470     }
 471
 472     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
 473     {
 474         unsigned state = va_arg (ap, unsigned);
 475         return vout_window_SetState (sys->embed, state);
 476     }
 477
 478     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
 479     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
 480     case VOUT_DISPLAY_CHANGE_ZOOM:
 481     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
 482     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
 483     {
 484         xcb_connection_t *conn = XGetXCBConnection (sys->display);
 485         const vout_display_cfg_t *cfg;
 486         const video_format_t *source;
 487         bool is_forced = false;
 488
 489         if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT
 490          || query == VOUT_DISPLAY_CHANGE_SOURCE_CROP)
 491         {
 492             source = (const video_format_t *)va_arg (ap, const video_format_t *);
 493             cfg = vd->cfg;
 494         }
 495         else
 496         {
 497             source = &vd->source;
 498             cfg = (const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
 499             if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE)
 500                 is_forced = (bool)va_arg (ap, int);
 501         }
 502
 503         /* */
 504         if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE
 505          && is_forced
 506          && (cfg->display.width  != vd->cfg->display.width
 507            ||cfg->display.height != vd->cfg->display.height)
 508          && vout_window_SetSize (sys->embed,
 509                                  cfg->display.width, cfg->display.height))
 510             return VLC_EGENERIC;
 511
 512         vout_display_place_t place;
 513         vout_display_PlacePicture (&place, source, cfg, false);
 514
 515         /* Move the picture within the window */
 516         const uint32_t values[] = { place.x, place.y,
 517                                     place.width, place.height, };
 518         xcb_void_cookie_t ck =
 519             xcb_configure_window_checked (conn, sys->window,
 520                             XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y
 521                           | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
 522                               values);
 523         if (CheckError (vd, conn, "cannot resize X11 window", ck))
 524             return VLC_EGENERIC;
 525
 526         glViewport (0, 0, place.width, place.height);
 527         return VLC_SUCCESS;
 528     }
 529
 530     /* Hide the mouse. It will be send when
 531      * vout_display_t::info.b_hide_mouse is false */
 532     case VOUT_DISPLAY_HIDE_MOUSE:
 533         xcb_change_window_attributes (XGetXCBConnection (sys->display),
 534                                       sys->embed->handle.xid,
 535                                     XCB_CW_CURSOR, &(uint32_t){ sys->cursor });
 536         return VLC_SUCCESS;
 537
 538     case VOUT_DISPLAY_GET_OPENGL:
 539     {
 540         vout_opengl_t **gl = va_arg (ap, vout_opengl_t **);
 541         *gl = &sys->gl;
 542         return VLC_SUCCESS;
 543     }
 544
 545     case VOUT_DISPLAY_RESET_PICTURES:
 546         assert (0);
 547     default:
 548         msg_Err (vd, "Unknown request in XCB vout display");
 549         return VLC_EGENERIC;
 550     }
 551 }
 552
 553 static void Manage (vout_display_t *vd)
 554 {
 555     vout_display_sys_t *sys = vd->sys;
 556     xcb_connection_t *conn = XGetXCBConnection (sys->display);
 557
 558     ManageEvent (vd, conn, &sys->visible);
 559 }