vout: use the new var_GetAddress.
[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     /* Obsolete since 1.1.0: */
72     add_obsolete_bool ("x11-altfullscreen")
73     add_obsolete_bool ("xvideo-altfullscreen")
74     add_obsolete_bool ("xvmc-altfullscreen")
75     add_obsolete_bool ("glx-altfullscreen")
76
77     add_submodule ()
78     set_shortname (N_("Drawable"))
79     set_description (N_("Embedded window video"))
80     set_category (CAT_VIDEO)
81     set_subcategory (SUBCAT_VIDEO_VOUT)
82     set_capability ("vout window xid", 70)
83     set_callbacks (EmOpen, EmClose)
84
85     add_integer ("drawable-xid", 0, NULL, XID_TEXT, XID_LONGTEXT, true)
86         change_unsaveable ()
87
88 vlc_module_end ()
89
90 static int Control (vout_window_t *, int, va_list ap);
91 static void *Thread (void *);
92
93 #define MATCHBOX_HACK 1 /* Matchbox focus hack */
94
95 struct vout_window_sys_t
96 {
97     xcb_connection_t *conn;
98     key_handler_t *keys;
99     vlc_thread_t thread;
100
101     xcb_window_t root;
102     xcb_atom_t wm_state;
103     xcb_atom_t wm_state_above;
104     xcb_atom_t wm_state_fullscreen;
105 #ifdef MATCHBOX_HACK
106     xcb_atom_t mb_current_app_window;
107 #endif
108 };
109
110 /** Set an X window property from a nul-terminated string */
111 static inline
112 void set_string (xcb_connection_t *conn, xcb_window_t window,
113                  xcb_atom_t type, xcb_atom_t atom, const char *str)
114 {
115     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, atom, type,
116                          /* format */ 8, strlen (str), str);
117 }
118
119 /** Set an X window string property */
120 static inline
121 void set_ascii_prop (xcb_connection_t *conn, xcb_window_t window,
122                      xcb_atom_t atom, const char *value)
123 {
124     set_string (conn, window, XA_STRING, atom, value);
125 }
126
127 static inline
128 void set_wm_hints (xcb_connection_t *conn, xcb_window_t window)
129 {
130     static const uint32_t wm_hints[8] = {
131         3, /* flags: Input, Initial state */
132         1, /* input: True */
133         1, /* initial state: Normal */
134         0, 0, 0, 0, 0, /* Icon */
135     };
136     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, XA_WM_HINTS,
137                          XA_WM_HINTS, 32, 8, wm_hints);
138 }
139
140 /** Set the Window ICCCM client machine property */
141 static inline
142 void set_hostname_prop (xcb_connection_t *conn, xcb_window_t window)
143 {
144     char* hostname;
145     long host_name_max = sysconf (_SC_HOST_NAME_MAX);
146     if (host_name_max <= 0) host_name_max = _POSIX_HOST_NAME_MAX;
147     hostname = malloc (host_name_max);
148     if(!hostname) return;
149
150     if (gethostname (hostname, host_name_max) == 0)
151     {
152         hostname[host_name_max - 1] = '\0';
153         set_ascii_prop (conn, window, XA_WM_CLIENT_MACHINE, hostname);
154     }
155     free(hostname);
156 }
157
158 /** Request the X11 server to internalize a string into an atom */
159 static inline
160 xcb_intern_atom_cookie_t intern_string (xcb_connection_t *c, const char *s)
161 {
162     return xcb_intern_atom (c, 0, strlen (s), s);
163 }
164
165 /** Extract the X11 atom from an intern request cookie */
166 static
167 xcb_atom_t get_atom (xcb_connection_t *conn, xcb_intern_atom_cookie_t ck)
168 {
169     xcb_intern_atom_reply_t *reply;
170     xcb_atom_t atom;
171
172     reply = xcb_intern_atom_reply (conn, ck, NULL);
173     if (reply == NULL)
174         return 0;
175
176     atom = reply->atom;
177     free (reply);
178     return atom;
179 }
180
181 #define NET_WM_STATE_REMOVE 0
182 #define NET_WM_STATE_ADD    1
183 #define NET_WM_STATE_TOGGLE 2
184
185 static void CacheAtoms (vout_window_sys_t *p_sys)
186 {
187     xcb_connection_t *conn = p_sys->conn;
188     xcb_intern_atom_cookie_t wm_state_ck, wm_state_above_ck, wm_state_fs_ck;
189
190     wm_state_ck = intern_string (conn, "_NET_WM_STATE");
191     wm_state_above_ck = intern_string (conn, "_NET_WM_STATE_ABOVE");
192     wm_state_fs_ck = intern_string (conn, "_NET_WM_STATE_FULLSCREEN");
193 #ifdef MATCHBOX_HACK
194     xcb_intern_atom_cookie_t mb_current_app_window;
195     mb_current_app_window = intern_string (conn, "_MB_CURRENT_APP_WINDOW");
196 #endif
197
198     p_sys->wm_state = get_atom (conn, wm_state_ck);
199     p_sys->wm_state_above = get_atom (conn, wm_state_above_ck);
200     p_sys->wm_state_fullscreen = get_atom (conn, wm_state_fs_ck);
201 #ifdef MATCHBOX_HACK
202     p_sys->mb_current_app_window = get_atom (conn, mb_current_app_window);
203 #endif
204 }
205
206 /**
207  * Create an X11 window.
208  */
209 static int Open (vlc_object_t *obj)
210 {
211     vout_window_t *wnd = (vout_window_t *)obj;
212     xcb_generic_error_t *err;
213     xcb_void_cookie_t ck;
214
215     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
216     if (p_sys == NULL)
217         return VLC_ENOMEM;
218
219     /* Connect to X */
220     char *display = var_CreateGetNonEmptyString (wnd, "x11-display");
221     int snum;
222
223     xcb_connection_t *conn = xcb_connect (display, &snum);
224     free (display);
225     if (xcb_connection_has_error (conn) /*== NULL*/)
226         goto error;
227
228     /* Find configured screen */
229     const xcb_setup_t *setup = xcb_get_setup (conn);
230     const xcb_screen_t *scr = NULL;
231     for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
232          i.rem > 0; xcb_screen_next (&i))
233     {
234         if (snum == 0)
235         {
236             scr = i.data;
237             break;
238         }
239         snum--;
240     }
241     if (scr == NULL)
242     {
243         msg_Err (wnd, "bad X11 screen number");
244         goto error;
245     }
246
247     /* Create window */
248     const uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
249     uint32_t values[2] = {
250         /* XCB_CW_BACK_PIXEL */
251         scr->black_pixel,
252         /* XCB_CW_EVENT_MASK */
253         XCB_EVENT_MASK_KEY_PRESS,
254     };
255
256     xcb_window_t window = xcb_generate_id (conn);
257     ck = xcb_create_window_checked (conn, scr->root_depth, window, scr->root,
258                                     0, 0, wnd->cfg->width, wnd->cfg->height, 0,
259                                     XCB_WINDOW_CLASS_INPUT_OUTPUT,
260                                     scr->root_visual, mask, values);
261     err = xcb_request_check (conn, ck);
262     if (err)
263     {
264         msg_Err (wnd, "creating window: X11 error %d", err->error_code);
265         free (err);
266         goto error;
267     }
268
269     wnd->handle.xid = window;
270     wnd->control = Control;
271     wnd->sys = p_sys;
272
273     p_sys->conn = conn;
274     p_sys->keys = CreateKeyHandler (obj, conn);
275     p_sys->root = scr->root;
276
277     /* ICCCM
278      * No cut&paste nor drag&drop, only Window Manager communication. */
279     /* Plain ASCII localization of VLC for ICCCM window name */
280     set_ascii_prop (conn, window, XA_WM_NAME,
281                   vlc_pgettext ("ASCII", "VLC media player"));
282     set_ascii_prop (conn, window, XA_WM_ICON_NAME,
283                     vlc_pgettext ("ASCII", "VLC"));
284     set_wm_hints (conn, window);
285     xcb_change_property (conn, XCB_PROP_MODE_REPLACE, window, XA_WM_CLASS,
286                          XA_STRING, 8, 8, "vlc\0Vlc");
287     set_hostname_prop (conn, window);
288
289     /* EWMH */
290     xcb_intern_atom_cookie_t utf8_string_ck
291         = intern_string (conn, "UTF8_STRING");;
292     xcb_intern_atom_cookie_t net_wm_name_ck
293         = intern_string (conn, "_NET_WM_NAME");
294     xcb_intern_atom_cookie_t net_wm_icon_name_ck
295         = intern_string (conn, "_NET_WM_ICON_NAME");
296     xcb_intern_atom_cookie_t wm_window_role_ck
297         = intern_string (conn, "WM_WINDOW_ROLE");
298
299     xcb_atom_t utf8 = get_atom (conn, utf8_string_ck);
300
301     xcb_atom_t net_wm_name = get_atom (conn, net_wm_name_ck);
302     char *title = var_CreateGetNonEmptyString (wnd, "video-title");
303     if (title)
304     {
305         set_string (conn, window, utf8, net_wm_name, title);
306         free (title);
307     }
308     else
309         set_string (conn, window, utf8, net_wm_name, _("VLC media player"));
310
311     xcb_atom_t net_wm_icon_name = get_atom (conn, net_wm_icon_name_ck);
312     set_string (conn, window, utf8, net_wm_icon_name, _("VLC"));
313
314     xcb_atom_t wm_window_role = get_atom (conn, wm_window_role_ck);
315     set_ascii_prop (conn, window, wm_window_role, "vlc-video");
316
317 #ifdef MATCHBOX_HACK
318     uint32_t value = XCB_EVENT_MASK_PROPERTY_CHANGE;
319     xcb_change_window_attributes (conn, scr->root,
320                                   XCB_CW_EVENT_MASK, &value);
321 #endif
322
323     /* Make the window visible */
324     xcb_map_window (conn, window);
325
326     /* Cache any EWMH atom we may need later */
327     CacheAtoms (p_sys);
328
329     /* Create the event thread. It will dequeue all events, so any checked
330      * request from this thread must be completed at this point. */
331     if ((p_sys->keys != NULL)
332      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
333         DestroyKeyHandler (p_sys->keys);
334
335 #ifdef MATCHBOX_HACK
336     xcb_set_input_focus (p_sys->conn, XCB_INPUT_FOCUS_POINTER_ROOT,
337                          wnd->handle.xid, XCB_CURRENT_TIME);
338 #endif
339     xcb_flush (conn); /* Make sure map_window is sent (should be useless) */
340     return VLC_SUCCESS;
341
342 error:
343     xcb_disconnect (conn);
344     free (p_sys);
345     return VLC_EGENERIC;
346 }
347
348
349 /**
350  * Destroys the X11 window.
351  */
352 static void Close (vlc_object_t *obj)
353 {
354     vout_window_t *wnd = (vout_window_t *)obj;
355     vout_window_sys_t *p_sys = wnd->sys;
356     xcb_connection_t *conn = p_sys->conn;
357
358     if (p_sys->keys)
359     {
360         vlc_cancel (p_sys->thread);
361         vlc_join (p_sys->thread, NULL);
362         DestroyKeyHandler (p_sys->keys);
363     }
364     xcb_disconnect (conn);
365     free (p_sys);
366 }
367
368
369 /** Background thread for X11 events handling */
370 static void *Thread (void *data)
371 {
372     vout_window_t *wnd = data;
373     vout_window_sys_t *p_sys = wnd->sys;
374     xcb_connection_t *conn = p_sys->conn;
375
376     int fd = xcb_get_file_descriptor (conn);
377     if (fd == -1)
378         return NULL;
379
380     for (;;)
381     {
382         xcb_generic_event_t *ev;
383         struct pollfd ufd = { .fd = fd, .events = POLLIN, };
384
385         poll (&ufd, 1, -1);
386
387         int canc = vlc_savecancel ();
388         while ((ev = xcb_poll_for_event (conn)) != NULL)
389         {
390             if (ProcessKeyEvent (p_sys->keys, ev) == 0)
391                 continue;
392 #ifdef MATCHBOX_HACK
393             if ((ev->response_type & 0x7f) == XCB_PROPERTY_NOTIFY)
394             {
395                 const xcb_property_notify_event_t *pne =
396                     (xcb_property_notify_event_t *)ev;
397                 if (pne->atom == p_sys->mb_current_app_window
398                  && pne->state == XCB_PROPERTY_NEW_VALUE)
399                 {
400                     xcb_get_property_reply_t *r =
401                         xcb_get_property_reply (conn,
402                             xcb_get_property (conn, 0, pne->window, pne->atom,
403                                               XA_WINDOW, 0, 4), NULL);
404                     if (r != NULL
405                      && !memcmp (xcb_get_property_value (r), &wnd->handle.xid,
406                                  4))
407                     {
408                         msg_Dbg (wnd, "asking Matchbox for input focus");
409                         xcb_set_input_focus (conn,
410                                              XCB_INPUT_FOCUS_POINTER_ROOT,
411                                              wnd->handle.xid, pne->time);
412                         xcb_flush (conn);
413                     }
414                     free (r);
415                 }
416             }
417             else
418 #endif
419                 msg_Dbg (wnd, "unhandled event: %"PRIu8, ev->response_type);
420             free (ev);
421         }
422         vlc_restorecancel (canc);
423
424         if (xcb_connection_has_error (conn))
425         {
426             msg_Err (wnd, "X server failure");
427             break;
428         }
429     }
430     return NULL;
431 }
432
433 /** Changes the EWMH state of the window */
434 static void set_wm_state (vout_window_t *wnd, bool on, xcb_atom_t state)
435 {
436     vout_window_sys_t *sys = wnd->sys;
437     /* From EWMH "_WM_STATE" */
438     xcb_client_message_event_t ev = {
439          .response_type = XCB_CLIENT_MESSAGE,
440          .format = 32,
441          .window = wnd->handle.xid,
442          .type = sys->wm_state,
443     };
444
445     ev.data.data32[0] = on ? NET_WM_STATE_ADD : NET_WM_STATE_REMOVE;
446     ev.data.data32[1] = state;
447     ev.data.data32[2] = 0;
448     ev.data.data32[3] = 1;
449
450     /* From ICCCM "Changing Window State" */
451     xcb_send_event (sys->conn, 0, sys->root,
452                     XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
453                     XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT,
454                     (const char *)&ev);
455 }
456
457
458 static int Control (vout_window_t *wnd, int cmd, va_list ap)
459 {
460     vout_window_sys_t *p_sys = wnd->sys;
461     xcb_connection_t *conn = p_sys->conn;
462
463     switch (cmd)
464     {
465         case VOUT_WINDOW_SET_SIZE:
466         {
467             unsigned width = va_arg (ap, unsigned);
468             unsigned height = va_arg (ap, unsigned);
469             const uint32_t values[] = { width, height, };
470
471             xcb_configure_window (conn, wnd->handle.xid,
472                                   XCB_CONFIG_WINDOW_WIDTH |
473                                   XCB_CONFIG_WINDOW_HEIGHT, values);
474             break;
475         }
476
477         case VOUT_WINDOW_SET_ON_TOP:
478             set_wm_state (wnd, va_arg (ap, int), p_sys->wm_state_above);
479             break;
480
481         case VOUT_WINDOW_SET_FULLSCREEN:
482             set_wm_state (wnd, va_arg (ap, int), p_sys->wm_state_fullscreen);
483             break;
484
485         default:
486             msg_Err (wnd, "request %d not implemented", cmd);
487             return VLC_EGENERIC;
488     }
489     xcb_flush (p_sys->conn);
490     return VLC_SUCCESS;
491 }
492
493 /*** Embedded drawable support ***/
494
495 static vlc_mutex_t serializer = VLC_STATIC_MUTEX;
496
497 /** Acquire a drawable */
498 static int AcquireDrawable (vlc_object_t *obj, xcb_window_t window)
499 {
500     xcb_window_t *used;
501     size_t n = 0;
502
503     if (var_Create (obj->p_libvlc, "xid-in-use", VLC_VAR_ADDRESS))
504         return VLC_ENOMEM;
505
506     /* Keep a list of busy drawables, so we don't overlap videos if there are
507      * more than one video track in the stream. */
508     vlc_mutex_lock (&serializer);
509     used = var_GetAddress (obj->p_libvlc, "xid-in-use");
510     if (used != NULL)
511     {
512         while (used[n])
513         {
514             if (used[n] == window)
515                 goto skip;
516             n++;
517         }
518     }
519
520     used = realloc (used, sizeof (*used) * (n + 2));
521     if (used != NULL)
522     {
523         used[n] = window;
524         used[n + 1] = 0;
525         var_SetAddress (obj->p_libvlc, "xid-in-use", used);
526     }
527     else
528     {
529 skip:
530         msg_Warn (obj, "X11 drawable 0x%08"PRIx8" is busy", window);
531         window = 0;
532     }
533     vlc_mutex_unlock (&serializer);
534
535     return (window == 0) ? VLC_EGENERIC : VLC_SUCCESS;
536 }
537
538 /** Remove this drawable from the list of busy ones */
539 static void ReleaseDrawable (vlc_object_t *obj, xcb_window_t window)
540 {
541     xcb_window_t *used;
542     size_t n = 0;
543
544     vlc_mutex_lock (&serializer);
545     used = var_GetAddress (obj->p_libvlc, "xid-in-use");
546     assert (used);
547     while (used[n] != window)
548     {
549         assert (used[n]);
550         n++;
551     }
552     do
553         used[n] = used[n + 1];
554     while (used[++n]);
555
556     if (n == 0)
557          var_SetAddress (obj->p_libvlc, "xid-in-use", NULL);
558     vlc_mutex_unlock (&serializer);
559
560     if (n == 0)
561         free (used);
562     /* Variables are reference-counted... */
563     var_Destroy (obj->p_libvlc, "xid-in-use");
564 }
565
566 /**
567  * Wrap an existing X11 window to embed the video.
568  */
569 static int EmOpen (vlc_object_t *obj)
570 {
571     vout_window_t *wnd = (vout_window_t *)obj;
572
573     xcb_window_t window = var_CreateGetInteger (obj, "drawable-xid");
574     if (window == 0)
575         return VLC_EGENERIC;
576     var_Destroy (obj, "drawable-xid");
577
578     if (AcquireDrawable (obj, window))
579         return VLC_EGENERIC;
580
581     vout_window_sys_t *p_sys = malloc (sizeof (*p_sys));
582     xcb_connection_t *conn = xcb_connect (NULL, NULL);
583     if (p_sys == NULL || xcb_connection_has_error (conn))
584         goto error;
585
586     wnd->handle.xid = window;
587     wnd->control = Control;
588     wnd->sys = p_sys;
589
590     p_sys->conn = conn;
591
592     xcb_get_geometry_reply_t *geo =
593         xcb_get_geometry_reply (conn, xcb_get_geometry (conn, window), NULL);
594     if (geo == NULL)
595     {
596         msg_Err (obj, "bad X11 window 0x%08"PRIx8, window);
597         goto error;
598     }
599     p_sys->root = geo->root;
600     free (geo);
601
602     if (var_CreateGetInteger (obj, "vout-event") != 3) /* FIXME: <- cleanup */
603     {
604         p_sys->keys = CreateKeyHandler (obj, conn);
605         if (p_sys->keys != NULL)
606         {
607             const uint32_t mask = XCB_CW_EVENT_MASK;
608             const uint32_t values[1] = {
609                 XCB_EVENT_MASK_KEY_PRESS,
610             };
611             xcb_change_window_attributes (conn, window, mask, values);
612         }
613     }
614
615     CacheAtoms (p_sys);
616     if ((p_sys->keys != NULL)
617      && vlc_clone (&p_sys->thread, Thread, wnd, VLC_THREAD_PRIORITY_LOW))
618         DestroyKeyHandler (p_sys->keys);
619
620     xcb_flush (conn);
621
622     return VLC_SUCCESS;
623
624 error:
625     xcb_disconnect (conn);
626     free (p_sys);
627     ReleaseDrawable (obj, window);
628     return VLC_EGENERIC;
629 }
630
631 static void EmClose (vlc_object_t *obj)
632 {
633     vout_window_t *wnd = (vout_window_t *)obj;
634     xcb_window_t window = wnd->handle.xid;
635
636     Close (obj);
637     ReleaseDrawable (obj, window);
638 }