Remove experimental flag to XCB window
[vlc.git] / modules / video_output / xcb / window.c
1 /**
2  * @file window.c
3  * @brief X C Bindings window provider module for VLC media player
4  */
5 /*****************************************************************************
6  * Copyright © 2009 Rémi Denis-Courmont
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2.0
11  * of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21  ****************************************************************************/
22
23 #ifdef HAVE_CONFIG_H
24 # include <config.h>
25 #endif
26
27 #include <stdarg.h>
28 #include <assert.h>
29 #include <poll.h>
30 #include <unistd.h> /* gethostname() and sysconf() */
31 #include <limits.h> /* _POSIX_HOST_NAME_MAX */
32
33 #include <xcb/xcb.h>
34 typedef xcb_atom_t Atom;
35 #include <X11/Xatom.h> /* XA_WM_NAME */
36
37 #include <vlc_common.h>
38 #include <vlc_plugin.h>
39 #include <vlc_vout_window.h>
40
41 #include "xcb_vlc.h"
42
43 #define DISPLAY_TEXT N_("X11 display")
44 #define DISPLAY_LONGTEXT N_( \
45     "X11 hardware display to use. By default VLC will " \
46     "use the value of the DISPLAY environment variable.")
47
48 #define XID_TEXT N_("ID of the video output X window")
49 #define XID_LONGTEXT N_( \
50     "VLC can embed its video output in an existing X11 window. " \
51     "This is the X identifier of that window (0 means none).")
52
53 static int  Open (vlc_object_t *);
54 static void Close (vlc_object_t *);
55 static int  EmOpen (vlc_object_t *);
56 static void EmClose (vlc_object_t *);
57
58 /*
59  * Module descriptor
60  */
61 vlc_module_begin ()
62     set_shortname (N_("X window"))
63     set_description (N_("X11 video window (XCB)"))
64     set_category (CAT_VIDEO)
65     set_subcategory (SUBCAT_VIDEO_VOUT)
66     set_capability ("vout window xid", 10)
67     set_callbacks (Open, Close)
68
69     add_string ("x11-display", NULL, NULL,
70                 DISPLAY_TEXT, DISPLAY_LONGTEXT, true)
71
72     add_submodule ()
73     set_shortname (N_("Drawable"))
74     set_description (N_("Embedded window video"))
75     set_category (CAT_VIDEO)
76     set_subcategory (SUBCAT_VIDEO_VOUT)
77     set_capability ("vout window xid", 70)
78     set_callbacks (EmOpen, EmClose)
79
80     add_integer ("drawable-xid", 0, NULL, XID_TEXT, XID_LONGTEXT, true)
81         change_unsaveable ()
82
83 vlc_module_end ()
84
85 static int Control (vout_window_t *, int, va_list ap);
86 static void *Thread (void *);
87
88 struct vout_window_sys_t
89 {
90     xcb_connection_t *conn;
91     key_handler_t *keys;
92     vlc_thread_t thread;
93
94     xcb_window_t root;
95     xcb_atom_t wm_state;
96     xcb_atom_t wm_state_above;
97     xcb_atom_t wm_state_fullscreen;
98 };
99
100 /** Set an X window property from a nul-terminated string */
101 static inline
102 void set_string (xcb_connection_t *conn, xcb_window_t window,
103                  xcb_atom_t type, xcb_atom_t atom, const char *str)
104 {
105     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, atom, type,
106                          /* format */ 8, strlen (str), str);
107 }
108
109 /** Set an X window string property */
110 static inline
111 void set_ascii_prop (xcb_connection_t *conn, xcb_window_t window,
112                      xcb_atom_t atom, const char *value)
113 {
114     set_string (conn, window, atom, XA_STRING, value);
115 }
116
117 /** Set the Window ICCCM client machine property */
118 static inline
119 void set_hostname_prop (xcb_connection_t *conn, xcb_window_t window)
120 {
121     char* hostname;
122     long host_name_max = sysconf (_SC_HOST_NAME_MAX);
123     if (host_name_max <= 0) host_name_max = _POSIX_HOST_NAME_MAX;
124     hostname = malloc (host_name_max);
125     if(!hostname) return;
126
127     if (gethostname (hostname, host_name_max) == 0)
128     {
129         hostname[host_name_max - 1] = '\0';
130         set_ascii_prop (conn, window, XA_WM_CLIENT_MACHINE, hostname);
131     }
132     free(hostname);
133 }
134
135 /** Request the X11 server to internalize a string into an atom */
136 static inline
137 xcb_intern_atom_cookie_t intern_string (xcb_connection_t *c, const char *s)
138 {
139     return xcb_intern_atom (c, 0, strlen (s), s);
140 }
141
142 /** Extract the X11 atom from an intern request cookie */
143 static
144 xcb_atom_t get_atom (xcb_connection_t *conn, xcb_intern_atom_cookie_t ck)
145 {
146     xcb_intern_atom_reply_t *reply;
147     xcb_atom_t atom;
148
149     reply = xcb_intern_atom_reply (conn, ck, NULL);
150     if (reply == NULL)
151         return 0;
152
153     atom = reply->atom;
154     free (reply);
155     return atom;
156 }
157
158 #define NET_WM_STATE_REMOVE 0
159 #define NET_WM_STATE_ADD    1
160 #define NET_WM_STATE_TOGGLE 2
161
162 static void CacheAtoms (vout_window_sys_t *p_sys)
163 {
164     xcb_connection_t *conn = p_sys->conn;
165     xcb_intern_atom_cookie_t wm_state_ck, wm_state_above_ck, wm_state_fs_ck;
166
167     wm_state_ck = intern_string (conn, "_NET_WM_STATE");
168     wm_state_above_ck = intern_string (conn, "_NET_WM_STATE_ABOVE");
169     wm_state_fs_ck = intern_string (conn, "_NET_WM_STATE_FULLSCREEN");
170
171     p_sys->wm_state = get_atom (conn, wm_state_ck);
172     p_sys->wm_state_above = get_atom (conn, wm_state_above_ck);
173     p_sys->wm_state_fullscreen = get_atom (conn, wm_state_fs_ck);
174 }
175
176 /**
177  * Create an X11 window.
178  */
179 static int Open (vlc_object_t *obj)
180 {
181     vout_window_t *wnd = (vout_window_t *)obj;
182     xcb_generic_error_t *err;
183     xcb_void_cookie_t ck;
184
185     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
186     if (p_sys == NULL)
187         return VLC_ENOMEM;
188
189     /* Connect to X */
190     char *display = var_CreateGetNonEmptyString (wnd, "x11-display");
191     int snum;
192
193     xcb_connection_t *conn = xcb_connect (display, &snum);
194     free (display);
195     if (xcb_connection_has_error (conn) /*== NULL*/)
196         goto error;
197
198     /* Find configured screen */
199     const xcb_setup_t *setup = xcb_get_setup (conn);
200     const xcb_screen_t *scr = NULL;
201     for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
202          i.rem > 0; xcb_screen_next (&i))
203     {
204         if (snum == 0)
205         {
206             scr = i.data;
207             break;
208         }
209         snum--;
210     }
211     if (scr == NULL)
212     {
213         msg_Err (wnd, "bad X11 screen number");
214         goto error;
215     }
216
217     /* Create window */
218     const uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
219     uint32_t values[2] = {
220         /* XCB_CW_BACK_PIXEL */
221         scr->black_pixel,
222         /* XCB_CW_EVENT_MASK */
223         XCB_EVENT_MASK_KEY_PRESS,
224     };
225
226     xcb_window_t window = xcb_generate_id (conn);
227     ck = xcb_create_window_checked (conn, scr->root_depth, window, scr->root,
228                                     0, 0, wnd->cfg->width, wnd->cfg->height, 0,
229                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
230                                     scr->root_visual, mask, values);
231     err = xcb_request_check (conn, ck);
232     if (err)
233     {
234         msg_Err (wnd, "creating window: X11 error %d", err->error_code);
235         goto error;
236     }
237
238     wnd->handle.xid = window;
239     wnd->control = Control;
240     wnd->sys = p_sys;
241
242     p_sys->conn = conn;
243     p_sys->keys = CreateKeyHandler (obj, conn);
244     p_sys->root = scr->root;
245
246     /* ICCCM
247      * No cut&paste nor drag&drop, only Window Manager communication. */
248     /* Plain ASCII localization of VLC for ICCCM window name */
249     set_ascii_prop (conn, window, XA_WM_NAME,
250                   vlc_pgettext ("ASCII", "VLC media player"));
251     set_ascii_prop (conn, window, XA_WM_ICON_NAME,
252                     vlc_pgettext ("ASCII", "VLC"));
253     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, XA_WM_CLASS,
254                          XA_STRING, 8, 8, "vlc\0Vlc");
255     set_hostname_prop (conn, window);
256
257     /* EWMH */
258     xcb_intern_atom_cookie_t utf8_string_ck
259         = intern_string (conn, "UTF8_STRING");;
260     xcb_intern_atom_cookie_t net_wm_name_ck
261         = intern_string (conn, "_NET_WM_NAME");
262     xcb_intern_atom_cookie_t net_wm_icon_name_ck
263         = intern_string (conn, "_NET_WM_ICON_NAME");
264
265     xcb_atom_t utf8 = get_atom (conn, utf8_string_ck);
266
267     xcb_atom_t net_wm_name = get_atom (conn, net_wm_name_ck);
268     char *title = var_CreateGetNonEmptyString (wnd, "video-title");
269     if (title)
270     {
271         set_string (conn, window, utf8, net_wm_name, title);
272         free (title);
273     }
274     else
275         set_string (conn, window, utf8, net_wm_name, _("VLC media player"));
276
277     xcb_atom_t net_wm_icon_name = get_atom (conn, net_wm_icon_name_ck);
278     set_string (conn, window, utf8, net_wm_icon_name, _("VLC"));
279
280     /* Make the window visible */
281     xcb_map_window (conn, window);
282
283     /* Cache any EWMH atom we may need later */
284     CacheAtoms (p_sys);
285
286     /* Create the event thread. It will dequeue all events, so any checked
287      * request from this thread must be completed at this point. */
288     if ((p_sys->keys != NULL)
289      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
290         DestroyKeyHandler (p_sys->keys);
291
292     xcb_flush (conn); /* Make sure map_window is sent (should be useless) */
293
294     return VLC_SUCCESS;
295
296 error:
297     xcb_disconnect (conn);
298     free (p_sys);
299     return VLC_EGENERIC;
300 }
301
302
303 /**
304  * Destroys the X11 window.
305  */
306 static void Close (vlc_object_t *obj)
307 {
308     vout_window_t *wnd = (vout_window_t *)obj;
309     vout_window_sys_t *p_sys = wnd->sys;
310     xcb_connection_t *conn = p_sys->conn;
311
312     if (p_sys->keys)
313     {
314         vlc_cancel (p_sys->thread);
315         vlc_join (p_sys->thread, NULL);
316         DestroyKeyHandler (p_sys->keys);
317     }
318     xcb_disconnect (conn);
319     free (p_sys);
320 }
321
322
323 /** Background thread for X11 events handling */
324 static void *Thread (void *data)
325 {
326     vout_window_t *wnd = data;
327     vout_window_sys_t *p_sys = wnd->sys;
328     xcb_connection_t *conn = p_sys->conn;
329
330     int fd = xcb_get_file_descriptor (conn);
331     if (fd == -1)
332         return NULL;
333
334     for (;;)
335     {
336         xcb_generic_event_t *ev;
337         struct pollfd ufd = { .fd = fd, .events = POLLIN, };
338
339         poll (&ufd, 1, -1);
340
341         int canc = vlc_savecancel ();
342         while ((ev = xcb_poll_for_event (conn)) != NULL)
343         {
344             if (ProcessKeyEvent (p_sys->keys, ev) == 0)
345                 continue;
346             msg_Dbg (wnd, "unhandled event: %"PRIu8, ev->response_type);
347             free (ev);
348         }
349         vlc_restorecancel (canc);
350
351         if (xcb_connection_has_error (conn))
352         {
353             msg_Err (wnd, "X server failure");
354             break;
355         }
356     }
357     return NULL;
358 }
359
360 /** Changes the EWMH state of the window */
361 static void set_wm_state (vout_window_t *wnd, bool on, xcb_atom_t state)
362 {
363     vout_window_sys_t *sys = wnd->sys;
364     /* From EWMH "_WM_STATE" */
365     xcb_client_message_event_t ev = {
366          .response_type = XCB_CLIENT_MESSAGE,
367          .format = 32,
368          .window = wnd->handle.xid,
369          .type = sys->wm_state,
370     };
371
372     ev.data.data32[0] = on ? NET_WM_STATE_ADD : NET_WM_STATE_REMOVE;
373     ev.data.data32[1] = state;
374     ev.data.data32[2] = 0;
375     ev.data.data32[3] = 1;
376
377     /* From ICCCM "Changing Window State" */
378     xcb_send_event (sys->conn, 0, sys->root,
379                     XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
380                     XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
381                     (const char *)&ev);
382 }
383
384
385 static int Control (vout_window_t *wnd, int cmd, va_list ap)
386 {
387     vout_window_sys_t *p_sys = wnd->sys;
388     xcb_connection_t *conn = p_sys->conn;
389
390     switch (cmd)
391     {
392         case VOUT_WINDOW_SET_SIZE:
393         {
394             unsigned width = va_arg (ap, unsigned);
395             unsigned height = va_arg (ap, unsigned);
396             const uint32_t values[] = { width, height, };
397
398             xcb_configure_window (conn, wnd->handle.xid,
399                                   XCB_CONFIG_WINDOW_WIDTH |
400                                   XCB_CONFIG_WINDOW_HEIGHT, values);
401             break;
402         }
403
404         case VOUT_WINDOW_SET_ON_TOP:
405             set_wm_state (wnd, va_arg (ap, int), p_sys->wm_state_above);
406             break;
407
408         case VOUT_WINDOW_SET_FULLSCREEN:
409             set_wm_state (wnd, va_arg (ap, int), p_sys->wm_state_fullscreen);
410             break;
411
412         default:
413             msg_Err (wnd, "request %d not implemented", cmd);
414             return VLC_EGENERIC;
415     }
416     xcb_flush (p_sys->conn);
417     return VLC_SUCCESS;
418 }
419
420 /*** Embedded drawable support ***/
421
422 static vlc_mutex_t serializer = VLC_STATIC_MUTEX;
423
424 /** Acquire a drawable */
425 static int AcquireDrawable (vlc_object_t *obj, xcb_window_t window)
426 {
427     vlc_value_t val;
428     xcb_window_t *used;
429     size_t n;
430
431     if (var_Create (obj->p_libvlc, "xid-in-use", VLC_VAR_ADDRESS))
432         return VLC_ENOMEM;
433
434     /* Keep a list of busy drawables, so we don't overlap videos if there are
435      * more than one video track in the stream. */
436     vlc_mutex_lock (&serializer);
437     var_Get (VLC_OBJECT (obj->p_libvlc), "xid-in-use", &val);
438     used = val.p_address;
439     if (used != NULL)
440     {
441         while (used[n])
442         {
443             if (used[n] == window)
444                 goto skip;
445             n++;
446         }
447     }
448
449     used = realloc (used, sizeof (*used) * (n + 2));
450     if (used != NULL)
451     {
452         used[n] = window;
453         used[n + 1] = 0;
454         val.p_address = used;
455         var_Set (obj->p_libvlc, "xid-in-use", val);
456     }
457     else
458     {
459 skip:
460         msg_Warn (obj, "X11 drawable 0x%08"PRIx8" is busy", window);
461         window = 0;
462     }
463     vlc_mutex_unlock (&serializer);
464
465     return (window == 0) ? VLC_EGENERIC : VLC_SUCCESS;
466 }
467
468 /** Remove this drawable from the list of busy ones */
469 static void ReleaseDrawable (vlc_object_t *obj, xcb_window_t window)
470 {
471     vlc_value_t val;
472     xcb_window_t *used;
473     size_t n = 0;
474
475     vlc_mutex_lock (&serializer);
476     var_Get (VLC_OBJECT (obj->p_libvlc), "xid-in-use", &val);
477     used = val.p_address;
478     assert (used);
479     while (used[n] != window)
480     {
481         assert (used[n]);
482         n++;
483     }
484     do
485         used[n] = used[n + 1];
486     while (used[++n]);
487
488     if (n == 0)
489          var_SetAddress (obj->p_libvlc, "xid-in-use", NULL);
490     vlc_mutex_unlock (&serializer);
491
492     if (n == 0)
493         free (used);
494     /* Variables are reference-counted... */
495     var_Destroy (obj->p_libvlc, "xid-in-use");
496 }
497
498 /**
499  * Wrap an existing X11 window to embed the video.
500  */
501 static int EmOpen (vlc_object_t *obj)
502 {
503     vout_window_t *wnd = (vout_window_t *)obj;
504
505     xcb_window_t window = var_CreateGetInteger (obj, "drawable-xid");
506     if (window == 0)
507         return VLC_EGENERIC;
508     var_Destroy (obj, "drawable-xid");
509
510     if (AcquireDrawable (obj, window))
511         return VLC_EGENERIC;
512
513     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
514     xcb_connection_t *conn = xcb_connect (NULL, NULL);
515     if (p_sys == NULL || xcb_connection_has_error (conn))
516         goto error;
517
518     wnd->handle.xid = window;
519     wnd->control = Control;
520     wnd->sys = p_sys;
521
522     p_sys->conn = conn;
523
524     xcb_get_geometry_reply_t *geo =
525         xcb_get_geometry_reply (conn, xcb_get_geometry (conn, window), NULL);
526     if (geo == NULL)
527     {
528         msg_Err (obj, "bad X11 window 0x%08"PRIx8, window);
529         goto error;
530     }
531     p_sys->root = geo->root;
532     free (geo);
533
534     if (var_CreateGetInteger (obj, "vout-event") != 3) /* FIXME: <- cleanup */
535     {
536         p_sys->keys = CreateKeyHandler (obj, conn);
537         if (p_sys->keys != NULL)
538         {
539             const uint32_t mask = XCB_CW_EVENT_MASK;
540             const uint32_t values[1] = {
541                 XCB_EVENT_MASK_KEY_PRESS,
542             };
543             xcb_change_window_attributes (conn, window, mask, values);
544         }
545     }
546
547     CacheAtoms (p_sys);
548     if ((p_sys->keys != NULL)
549      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
550         DestroyKeyHandler (p_sys->keys);
551
552     xcb_flush (conn);
553
554     return VLC_SUCCESS;
555
556 error:
557     xcb_disconnect (conn);
558     free (p_sys);
559     ReleaseDrawable (obj, window);
560     return VLC_EGENERIC;
561 }
562
563 static void EmClose (vlc_object_t *obj)
564 {
565     vout_window_t *wnd = (vout_window_t *)obj;
566     xcb_window_t window = wnd->handle.xid;
567
568     Close (obj);
569     ReleaseDrawable (obj, window);
570 }