XCB: use var_Inherit*()
[vlc.git] / modules / access / screen / xcb.c
1 /**
2  * @file xcb.c
3  * @brief X11 C Bindings screen capture demux 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 Lesser General Public License
10  * as published by the Free Software Foundation; either version 2.1
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 #include <stdarg.h>
27 #include <assert.h>
28 #include <xcb/xcb.h>
29 #include <vlc_common.h>
30 #include <vlc_demux.h>
31 #include <vlc_plugin.h>
32
33 #define CACHING_TEXT N_("Caching value in ms")
34 #define CACHING_LONGTEXT N_( \
35     "Caching value for screen capture. " \
36     "This value should be set in milliseconds.")
37
38 #define FPS_TEXT N_("Frame rate")
39 #define FPS_LONGTEXT N_( \
40     "How many times the screen content should be refreshed per second.")
41
42 #define LEFT_TEXT N_("Region left column")
43 #define LEFT_LONGTEXT N_( \
44     "Abscissa of the capture reion in pixels.")
45
46 #define TOP_TEXT N_("Region top row")
47 #define TOP_LONGTEXT N_( \
48     "Ordinate of the capture region in pixels.")
49
50 #define WIDTH_TEXT N_("Capture region width")
51 #define WIDTH_LONGTEXT N_( \
52     "Pixel width of the capture region, or 0 for full width")
53
54 #define HEIGHT_TEXT N_("Capture region height")
55 #define HEIGHT_LONGTEXT N_( \
56     "Pixel height of the capture region, or 0 for full height")
57
58 #define FOLLOW_MOUSE_TEXT N_( "Follow the mouse" )
59 #define FOLLOW_MOUSE_LONGTEXT N_( \
60     "Follow the mouse when capturing a subscreen." )
61
62 static int  Open (vlc_object_t *);
63 static void Close (vlc_object_t *);
64
65 /*
66  * Module descriptor
67  */
68 vlc_module_begin ()
69     set_shortname (N_("Screen"))
70     set_description (N_("Screen capture (with X11/XCB)"))
71     set_category (CAT_INPUT)
72     set_subcategory (SUBCAT_INPUT_ACCESS)
73     set_capability ("access_demux", 0)
74     set_callbacks (Open, Close)
75
76     add_integer ("screen-caching", DEFAULT_PTS_DELAY * 1000 / CLOCK_FREQ,
77                  NULL, CACHING_TEXT, CACHING_LONGTEXT, true)
78     add_float ("screen-fps", 2.0, NULL, FPS_TEXT, FPS_LONGTEXT, true)
79     add_integer ("screen-left", 0, NULL, LEFT_TEXT, LEFT_LONGTEXT, true)
80         change_integer_range (-32768, 32767)
81         change_safe ()
82     add_integer ("screen-top", 0, NULL, LEFT_TEXT, LEFT_LONGTEXT, true)
83         change_integer_range (-32768, 32767)
84         change_safe ()
85     add_integer ("screen-width", 0, NULL, LEFT_TEXT, LEFT_LONGTEXT, true)
86         change_integer_range (0, 65535)
87         change_safe ()
88     add_integer ("screen-height", 0, NULL, LEFT_TEXT, LEFT_LONGTEXT, true)
89         change_integer_range (0, 65535)
90         change_safe ()
91     add_bool ("screen-follow-mouse", false, NULL, FOLLOW_MOUSE_TEXT,
92               FOLLOW_MOUSE_LONGTEXT, true)
93
94     add_shortcut ("screen", "window")
95 vlc_module_end ()
96
97 /*
98  * Local prototypes
99  */
100 static void Demux (void *);
101 static int Control (demux_t *, int, va_list);
102 static es_out_id_t *InitES (demux_t *, uint_fast16_t, uint_fast16_t,
103                             uint_fast8_t);
104
105 struct demux_sys_t
106 {
107     xcb_connection_t *conn;
108     es_out_id_t      *es;
109     mtime_t           pts, interval;
110     float             rate;
111     xcb_window_t      window;
112     int16_t           x, y;
113     uint16_t          w, h;
114     uint16_t          cur_w, cur_h;
115     bool              follow_mouse;
116     /* fmt, es and pts are protected by the lock. The rest is read-only. */
117     vlc_mutex_t       lock;
118     /* Timer does not use this, only input thread: */
119     vlc_timer_t       timer;
120 };
121
122 /**
123  * Probes and initializes.
124  */
125 static int Open (vlc_object_t *obj)
126 {
127     demux_t *demux = (demux_t *)obj;
128     demux_sys_t *p_sys = malloc (sizeof (*p_sys));
129
130     if (p_sys == NULL)
131         return VLC_ENOMEM;
132     demux->p_sys = p_sys;
133
134     /* Connect to X server */
135     char *display = var_InheritString (obj, "x11-display");
136     int snum;
137     xcb_connection_t *conn = xcb_connect (display, &snum);
138     free (display);
139     if (xcb_connection_has_error (conn))
140     {
141         free (p_sys);
142         return VLC_EGENERIC;
143     }
144     p_sys->conn = conn;
145
146    /* Find configured screen */
147     if (!strcmp (demux->psz_access, "screen"))
148     {
149         const xcb_setup_t *setup = xcb_get_setup (conn);
150         const xcb_screen_t *scr = NULL;
151         for (xcb_screen_iterator_t i = xcb_setup_roots_iterator (setup);
152              i.rem > 0; xcb_screen_next (&i))
153         {
154             if (snum == 0)
155             {
156                scr = i.data;
157                 break;
158             }
159             snum--;
160         }
161         if (scr == NULL)
162         {
163             msg_Err (obj, "bad X11 screen number");
164             goto error;
165         }
166         p_sys->window = scr->root;
167     }
168     else
169     /* Determine capture window */
170     if (!strcmp (demux->psz_access, "window"))
171     {
172         char *end;
173         unsigned long ul = strtoul (demux->psz_location, &end, 0);
174         if (*end || ul > 0xffffffff)
175         {
176             msg_Err (obj, "bad X11 drawable %s", demux->psz_location);
177             goto error;
178         }
179         p_sys->window = ul;
180     }
181     else
182         goto error;
183
184     /* Window properties */
185     p_sys->x = var_InheritInteger (obj, "screen-left");
186     p_sys->y = var_InheritInteger (obj, "screen-top");
187     p_sys->w = var_InheritInteger (obj, "screen-width");
188     p_sys->h = var_InheritInteger (obj, "screen-height");
189     p_sys->follow_mouse = var_InheritBool (obj, "screen-follow-mouse");
190
191     /* Initializes format */
192     p_sys->rate = var_InheritFloat (obj, "screen-fps");
193     if (!p_sys->rate)
194         goto error;
195     p_sys->interval = (float)CLOCK_FREQ / p_sys->rate;
196     if (!p_sys->interval)
197         goto error;
198     var_Create (obj, "screen-caching", VLC_VAR_INTEGER|VLC_VAR_DOINHERIT);
199
200     p_sys->cur_w = 0;
201     p_sys->cur_h = 0;
202     p_sys->es = NULL;
203     p_sys->pts = VLC_TS_INVALID;
204     vlc_mutex_init (&p_sys->lock);
205     if (vlc_timer_create (&p_sys->timer, Demux, demux))
206         goto error;
207     vlc_timer_schedule (p_sys->timer, false, 1, p_sys->interval);
208
209     /* Initializes demux */
210     demux->pf_demux   = NULL;
211     demux->pf_control = Control;
212     return VLC_SUCCESS;
213
214 error:
215     xcb_disconnect (p_sys->conn);
216     free (p_sys);
217     return VLC_EGENERIC;
218 }
219
220
221 /**
222  * Releases resources
223  */
224 static void Close (vlc_object_t *obj)
225 {
226     demux_t *demux = (demux_t *)obj;
227     demux_sys_t *p_sys = demux->p_sys;
228
229     vlc_timer_destroy (p_sys->timer);
230     vlc_mutex_destroy (&p_sys->lock);
231     xcb_disconnect (p_sys->conn);
232     free (p_sys);
233 }
234
235
236 /**
237  * Control callback
238  */
239 static int Control (demux_t *demux, int query, va_list args)
240 {
241     demux_sys_t *p_sys = demux->p_sys;
242
243     switch (query)
244     {
245         case DEMUX_GET_POSITION:
246         {
247             float *v = va_arg (args, float *);
248             *v = 0.;
249             return VLC_SUCCESS;
250         }
251
252         case DEMUX_GET_LENGTH:
253         case DEMUX_GET_TIME:
254         {
255             int64_t *v = va_arg (args, int64_t *);
256             *v = 0;
257             return VLC_SUCCESS;
258         }
259
260         /* TODO: get title info -> crawl visible windows */
261
262         case DEMUX_GET_PTS_DELAY:
263         {
264             int64_t *v = va_arg (args, int64_t *);
265             *v = var_GetInteger (demux, "screen-caching") * UINT64_C(1000);
266             return VLC_SUCCESS;
267         }
268
269         case DEMUX_CAN_PAUSE:
270         {
271             bool *v = (bool*)va_arg( args, bool * );
272             *v = true;
273             return VLC_SUCCESS;
274         }
275
276         case DEMUX_SET_PAUSE_STATE:
277         {
278             bool pausing = va_arg (args, int);
279
280             if (!pausing)
281             {
282                 vlc_mutex_lock (&p_sys->lock);
283                 p_sys->pts = VLC_TS_INVALID;
284                 es_out_Control (demux->out, ES_OUT_RESET_PCR);
285                 vlc_mutex_unlock (&p_sys->lock);
286             }
287             vlc_timer_schedule (p_sys->timer, false,
288                                 pausing ? 0 : 1, p_sys->interval);
289             return VLC_SUCCESS;
290         }
291
292         case DEMUX_CAN_CONTROL_PACE:
293         case DEMUX_CAN_CONTROL_RATE:
294         case DEMUX_CAN_SEEK:
295         {
296             bool *v = (bool*)va_arg( args, bool * );
297             *v = false;
298             return VLC_SUCCESS;
299         }
300     }
301
302     return VLC_EGENERIC;
303 }
304
305
306 /**
307  * Processing callback
308  */
309 static void Demux (void *data)
310 {
311     demux_t *demux = data;
312     demux_sys_t *p_sys = demux->p_sys;
313     xcb_connection_t *conn = p_sys->conn;
314
315     /* Update capture region (if needed) */
316
317     xcb_get_geometry_reply_t *geo =
318         xcb_get_geometry_reply (conn,
319             xcb_get_geometry (conn, p_sys->window), NULL);
320     if (geo == NULL)
321     {
322         msg_Err (demux, "bad X11 drawable 0x%08"PRIx32, p_sys->window);
323         return;
324     }
325
326     xcb_window_t root = geo->root;
327     int16_t x = p_sys->x, y = p_sys->y;
328     xcb_translate_coordinates_cookie_t tc;
329     xcb_query_pointer_cookie_t qc;
330
331     if (p_sys->window != root)
332         tc = xcb_translate_coordinates (conn, p_sys->window, root,
333                                         x, y);
334     if (p_sys->follow_mouse)
335         qc = xcb_query_pointer (conn, p_sys->window);
336
337     uint16_t ow = geo->width - x;
338     uint16_t oh = geo->height - y;
339     uint16_t w = p_sys->w;
340     uint16_t h = p_sys->h;
341     if (w == 0 || w > ow)
342         w = ow;
343     if (h == 0 || h > oh)
344         h = oh;
345     uint8_t depth = geo->depth;
346     free (geo);
347
348     if (p_sys->window != root)
349     {
350         xcb_translate_coordinates_reply_t *coords =
351              xcb_translate_coordinates_reply (conn, tc, NULL);
352         if (coords != NULL)
353         {
354             x = coords->dst_x;
355             y = coords->dst_y;
356             free (coords);
357         }
358     }
359
360     if (p_sys->follow_mouse)
361     {
362         xcb_query_pointer_reply_t *ptr =
363             xcb_query_pointer_reply (conn, qc, NULL);
364         if (ptr != NULL)
365         {
366             int16_t min_x = x + (w / 2);
367             int16_t min_y = y + (h / 2);
368             int16_t max_x = x + ow - ((w + 1) / 2);
369             int16_t max_y = y + oh - ((h + 1) / 2);
370
371             assert (max_x >= min_x); /* max_x - min_x = ow - w >= 0 */
372             if (ptr->root_x > max_x)
373                 x += ow - w;
374             else if (ptr->root_x > min_x)
375                 x += ptr->root_x - min_x;
376
377             assert (max_y >= min_y);
378             if (ptr->root_y > max_y)
379                 y += oh - h;
380             else if (ptr->root_y > min_y)
381                 y += ptr->root_y - min_y;
382         }
383     }
384
385     xcb_get_image_reply_t *img;
386     img = xcb_get_image_reply (conn,
387         xcb_get_image (conn, XCB_IMAGE_FORMAT_Z_PIXMAP, root,
388                        x, y, w, h, ~0), NULL);
389     if (img == NULL)
390         return;
391
392     /* Send block - zero copy */
393     block_t *block = block_heap_Alloc (img, xcb_get_image_data (img),
394                                        xcb_get_image_data_length (img));
395     if (block == NULL)
396         return;
397
398     vlc_mutex_lock (&p_sys->lock);
399     if (w != p_sys->cur_w || h != p_sys->cur_h)
400     {
401         if (p_sys->es != NULL)
402             es_out_Del (demux->out, p_sys->es);
403         p_sys->es = InitES (demux, w, h, depth);
404         if (p_sys->es != NULL)
405         {
406             p_sys->cur_w = w;
407             p_sys->cur_h = h;
408         }
409     }
410
411     /* Capture screen */
412     if (p_sys->es != NULL)
413     {
414         if (p_sys->pts == VLC_TS_INVALID)
415             p_sys->pts = mdate ();
416         block->i_pts = block->i_dts = p_sys->pts;
417
418         es_out_Control (demux->out, ES_OUT_SET_PCR, p_sys->pts);
419         es_out_Send (demux->out, p_sys->es, block);
420         p_sys->pts += p_sys->interval;
421     }
422     vlc_mutex_unlock (&p_sys->lock);
423 }
424
425 static es_out_id_t *InitES (demux_t *demux, uint_fast16_t width,
426                             uint_fast16_t height, uint_fast8_t depth)
427 {
428     demux_sys_t *p_sys = demux->p_sys;
429     const xcb_setup_t *setup = xcb_get_setup (p_sys->conn);
430     uint32_t chroma = 0;
431     uint8_t bpp;
432
433     for (const xcb_format_t *fmt = xcb_setup_pixmap_formats (setup),
434              *end = fmt + xcb_setup_pixmap_formats_length (setup);
435          fmt < end; fmt++)
436     {
437         if (fmt->depth != depth)
438             continue;
439         bpp = fmt->depth;
440         switch (fmt->depth)
441         {
442             case 32:
443                 if (fmt->bits_per_pixel == 32)
444                     chroma = VLC_CODEC_RGBA;
445                 break;
446             case 24:
447                 if (fmt->bits_per_pixel == 32)
448                 {
449                     chroma = VLC_CODEC_RGB32;
450                     bpp = 32;
451                 }
452                 else if (fmt->bits_per_pixel == 24)
453                     chroma = VLC_CODEC_RGB24;
454                 break;
455             case 16:
456                 if (fmt->bits_per_pixel == 16)
457                     chroma = VLC_CODEC_RGB16;
458                 break;
459             case 15:
460                 if (fmt->bits_per_pixel == 16)
461                     chroma = VLC_CODEC_RGB15;
462                 break;
463             case 8: /* XXX: screw grey scale! */
464                 if (fmt->bits_per_pixel == 8)
465                     chroma = VLC_CODEC_RGB8;
466                 break;
467         }
468         if (chroma != 0)
469             break;
470     }
471
472     if (!chroma)
473     {
474         msg_Err (demux, "unsupported pixmap formats");
475         return NULL;
476     }
477
478     es_format_t fmt;
479
480     es_format_Init (&fmt, VIDEO_ES, chroma);
481     fmt.video.i_chroma = chroma;
482     fmt.video.i_bits_per_pixel = bpp;
483     fmt.video.i_sar_num = fmt.video.i_sar_den = 1;
484     fmt.video.i_frame_rate = 1000 * p_sys->rate;
485     fmt.video.i_frame_rate_base = 1000;
486     fmt.video.i_visible_width = fmt.video.i_width = width;
487     fmt.video.i_visible_height = fmt.video.i_height = height;
488
489     return es_out_Add (demux->out, &fmt);
490 }