qt: playlist: use item title if available
[vlc.git] / modules / video_output / xcb / xvideo.c
1 /**
2  * @file xvideo.c
3  * @brief X C Bindings video output 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
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 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 <stdlib.h>
28 #include <assert.h>
29
30 #include <xcb/xcb.h>
31 #include <xcb/shm.h>
32 #include <xcb/xv.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_vout_display.h>
37 #include <vlc_picture_pool.h>
38 #include <vlc_dialog.h>
39
40 #include "xcb_vlc.h"
41
42 #define ADAPTOR_TEXT N_("XVideo adaptor number")
43 #define ADAPTOR_LONGTEXT N_( \
44     "XVideo hardware adaptor to use. By default, VLC will " \
45     "use the first functional adaptor.")
46
47 #define FORMAT_TEXT N_("XVideo format id")
48 #define FORMAT_LONGTEXT N_( \
49     "XVideo image format id to use. By default, VLC will " \
50     "try to use the best match for the video being played.")
51
52 static int  Open (vlc_object_t *);
53 static void Close (vlc_object_t *);
54
55 /*
56  * Module descriptor
57  */
58 vlc_module_begin ()
59     set_shortname (N_("XVideo"))
60     set_description (N_("XVideo output (XCB)"))
61     set_category (CAT_VIDEO)
62     set_subcategory (SUBCAT_VIDEO_VOUT)
63     set_capability ("vout display", 200)
64     set_callbacks (Open, Close)
65
66     add_integer ("xvideo-adaptor", -1,
67                  ADAPTOR_TEXT, ADAPTOR_LONGTEXT, true)
68     add_integer ("xvideo-format-id", 0,
69                  FORMAT_TEXT, FORMAT_LONGTEXT, true)
70     add_obsolete_bool ("xvideo-shm") /* removed in 1.2.0 */
71     add_shortcut ("xcb-xv", "xv", "xvideo", "xid")
72 vlc_module_end ()
73
74 #define MAX_PICTURES (128)
75
76 struct vout_display_sys_t
77 {
78     xcb_connection_t *conn;
79     vout_window_t *embed;/* VLC window */
80
81     xcb_cursor_t cursor; /* blank cursor */
82     xcb_window_t window; /* drawable X window */
83     xcb_gcontext_t gc;   /* context to put images */
84     xcb_xv_port_t port;  /* XVideo port */
85     uint32_t id;         /* XVideo format */
86     uint16_t width;      /* display width */
87     uint16_t height;     /* display height */
88     uint32_t data_size;  /* picture byte size (for non-SHM) */
89     bool     swap_uv;    /* U/V pointer must be swapped in a picture */
90     bool shm;            /* whether to use MIT-SHM */
91     bool visible;        /* whether it makes sense to draw at all */
92
93     xcb_xv_query_image_attributes_reply_t *att;
94     picture_pool_t *pool; /* picture pool */
95     picture_resource_t resource[MAX_PICTURES];
96 };
97
98 static picture_pool_t *Pool (vout_display_t *, unsigned);
99 static void Display (vout_display_t *, picture_t *, subpicture_t *subpicture);
100 static int Control (vout_display_t *, int, va_list);
101 static void Manage (vout_display_t *);
102
103 /**
104  * Check that the X server supports the XVideo extension.
105  */
106 static bool CheckXVideo (vout_display_t *vd, xcb_connection_t *conn)
107 {
108     xcb_xv_query_extension_reply_t *r;
109     xcb_xv_query_extension_cookie_t ck = xcb_xv_query_extension (conn);
110     bool ok = false;
111
112     /* We need XVideo 2.2 for PutImage */
113     r = xcb_xv_query_extension_reply (conn, ck, NULL);
114     if (r == NULL)
115         msg_Dbg (vd, "XVideo extension not available");
116     else
117     if (r->major != 2)
118         msg_Dbg (vd, "XVideo extension v%"PRIu8".%"PRIu8" unknown",
119                  r->major, r->minor);
120     else
121     if (r->minor < 2)
122         msg_Dbg (vd, "XVideo extension v%"PRIu8".%"PRIu8" too old",
123                  r->major, r->minor);
124     else
125     {
126         msg_Dbg (vd, "using XVideo extension v%"PRIu8".%"PRIu8,
127                  r->major, r->minor);
128         ok = true;
129     }
130     free (r);
131     return ok;
132 }
133
134 static vlc_fourcc_t ParseFormat (vout_display_t *vd,
135                                  const xcb_xv_image_format_info_t *restrict f)
136 {
137     if (f->byte_order != ORDER && f->bpp != 8)
138         return 0; /* Argh! */
139
140     switch (f->type)
141     {
142       case XCB_XV_IMAGE_FORMAT_INFO_TYPE_RGB:
143         switch (f->num_planes)
144         {
145           case 1:
146             switch (popcount (f->red_mask | f->green_mask | f->blue_mask))
147             {
148               case 24:
149                 if (f->bpp == 32 && f->depth == 32)
150                     return VLC_CODEC_RGBA;
151                 if (f->bpp == 32 && f->depth == 24)
152                     return VLC_CODEC_RGB32;
153                 if (f->bpp == 24 && f->depth == 24)
154                     return VLC_CODEC_RGB24;
155                 break;
156               case 16:
157                 if (f->bpp == 16 && f->depth == 16)
158                     return VLC_CODEC_RGB16;
159                 break;
160               case 15:
161                 if (f->bpp == 16 && f->depth == 15)
162                     return VLC_CODEC_RGB15;
163                 break;
164               case 12:
165                 if (f->bpp == 16 && f->depth == 16)
166                     return VLC_CODEC_RGBA16;
167                 if (f->bpp == 16 && f->depth == 12)
168                     return VLC_CODEC_RGB12;
169               case 8:
170                 if (f->bpp == 8 && f->depth == 8)
171                     return VLC_CODEC_RGB8;
172                 break;
173             }
174             break;
175         }
176         msg_Err (vd, "unknown XVideo RGB format %"PRIx32" (%.4s)",
177                  f->id, f->guid);
178         msg_Dbg (vd, " %"PRIu8" planes, %"PRIu8" bits/pixel, "
179                  "depth %"PRIu8, f->num_planes, f->bpp, f->depth);
180         break;
181
182       case XCB_XV_IMAGE_FORMAT_INFO_TYPE_YUV:
183         if (f->u_sample_bits != f->v_sample_bits
184          || f->vhorz_u_period != f->vhorz_v_period
185          || f->vvert_u_period != f->vvert_v_period
186          || f->y_sample_bits != 8 || f->u_sample_bits != 8
187          || f->vhorz_y_period != 1 || f->vvert_y_period != 1)
188             goto bad;
189         switch (f->num_planes)
190         {
191           case 1:
192             switch (f->bpp)
193             {
194               /*untested: case 24:
195                 if (f->vhorz_u_period == 1 && f->vvert_u_period == 1)
196                     return VLC_CODEC_I444;
197                 break;*/
198               case 16:
199                 if (f->vhorz_u_period == 2 && f->vvert_u_period == 1)
200                 {
201                     if (!strcmp ((const char *)f->vcomp_order, "YUYV"))
202                         return VLC_CODEC_YUYV;
203                     if (!strcmp ((const char *)f->vcomp_order, "UYVY"))
204                         return VLC_CODEC_UYVY;
205                 }
206                 break;
207             }
208             break;
209           case 3:
210             switch (f->bpp)
211             {
212               case 12:
213                 if (f->vhorz_u_period == 2 && f->vvert_u_period == 2)
214                 {
215                     if (!strcmp ((const char *)f->vcomp_order, "YVU"))
216                         return VLC_CODEC_YV12;
217                     if (!strcmp ((const char *)f->vcomp_order, "YUV"))
218                         return VLC_CODEC_I420;
219                 }
220             }
221             break;
222         }
223     bad:
224         msg_Err (vd, "unknown XVideo YUV format %"PRIx32" (%.4s)", f->id,
225                  f->guid);
226         msg_Dbg (vd, " %"PRIu8" planes, %"PRIu32" bits/pixel, "
227                  "%"PRIu32"/%"PRIu32"/%"PRIu32" bits/sample", f->num_planes,
228                  f->bpp, f->y_sample_bits, f->u_sample_bits, f->v_sample_bits);
229         msg_Dbg (vd, " period: %"PRIu32"/%"PRIu32"/%"PRIu32"x"
230                  "%"PRIu32"/%"PRIu32"/%"PRIu32,
231                  f->vhorz_y_period, f->vhorz_u_period, f->vhorz_v_period,
232                  f->vvert_y_period, f->vvert_u_period, f->vvert_v_period);
233         msg_Warn (vd, " order: %.32s", f->vcomp_order);
234         break;
235     }
236     return 0;
237 }
238
239
240 static const xcb_xv_image_format_info_t *
241 FindFormat (vout_display_t *vd,
242             vlc_fourcc_t chroma, const video_format_t *fmt,
243             xcb_xv_port_t port,
244             const xcb_xv_list_image_formats_reply_t *list,
245             xcb_xv_query_image_attributes_reply_t **restrict pa)
246 {
247     xcb_connection_t *conn = vd->sys->conn;
248     const xcb_xv_image_format_info_t *f, *end;
249
250     f = xcb_xv_list_image_formats_format (list);
251     end = f + xcb_xv_list_image_formats_format_length (list);
252     for (; f < end; f++)
253     {
254         if (chroma != ParseFormat (vd, f))
255             continue;
256
257         /* VLC pads scanline to 16 pixels internally */
258         unsigned width = fmt->i_width;
259         unsigned height = fmt->i_height;
260         xcb_xv_query_image_attributes_reply_t *i;
261         i = xcb_xv_query_image_attributes_reply (conn,
262             xcb_xv_query_image_attributes (conn, port, f->id,
263                                            width, height), NULL);
264         if (i == NULL)
265             continue;
266
267         if (i->width != width || i->height != height)
268         {
269             msg_Warn (vd, "incompatible size %ux%u -> %"PRIu32"x%"PRIu32,
270                       fmt->i_width, fmt->i_height,
271                       i->width, i->height);
272             var_Create (vd->p_libvlc, "xvideo-resolution-error", VLC_VAR_BOOL);
273             if (!var_GetBool (vd->p_libvlc, "xvideo-resolution-error"))
274             {
275                 dialog_FatalWait (vd, _("Video acceleration not available"),
276                     _("Your video output acceleration driver does not support "
277                       "the required resolution: %ux%u pixels. The maximum "
278                       "supported resolution is %"PRIu32"x%"PRIu32".\n"
279                       "Video output acceleration will be disabled. However, "
280                       "rendering videos with overly large resolution "
281                       "may cause severe performance degration."),
282                                   width, height, i->width, i->height);
283                 var_SetBool (vd->p_libvlc, "xvideo-resolution-error", true);
284             }
285             free (i);
286             continue;
287         }
288         *pa = i;
289         return f;
290     }
291     return NULL;
292 }
293
294
295 /**
296  * Probe the X server.
297  */
298 static int Open (vlc_object_t *obj)
299 {
300     vout_display_t *vd = (vout_display_t *)obj;
301     vout_display_sys_t *p_sys = malloc (sizeof (*p_sys));
302
303     if (!var_InheritBool (obj, "overlay"))
304         return VLC_EGENERIC;
305     if (p_sys == NULL)
306         return VLC_ENOMEM;
307
308     vd->sys = p_sys;
309
310     /* Connect to X */
311     xcb_connection_t *conn;
312     const xcb_screen_t *screen;
313     uint8_t depth;
314     p_sys->embed = GetWindow (vd, &conn, &screen, &depth);
315     if (p_sys->embed == NULL)
316     {
317         free (p_sys);
318         return VLC_EGENERIC;
319     }
320
321     p_sys->conn = conn;
322     p_sys->att = NULL;
323     p_sys->pool = NULL;
324     p_sys->swap_uv = false;
325
326     if (!CheckXVideo (vd, conn))
327     {
328         msg_Warn (vd, "Please enable XVideo 2.2 for faster video display");
329         goto error;
330     }
331
332     p_sys->window = xcb_generate_id (conn);
333     xcb_pixmap_t pixmap = xcb_generate_id (conn);
334
335     /* Cache adaptors infos */
336     xcb_xv_query_adaptors_reply_t *adaptors =
337         xcb_xv_query_adaptors_reply (conn,
338             xcb_xv_query_adaptors (conn, p_sys->embed->handle.xid), NULL);
339     if (adaptors == NULL)
340         goto error;
341
342     int forced_adaptor = var_InheritInteger (obj, "xvideo-adaptor");
343
344     /* */
345     video_format_t fmt = vd->fmt;
346     p_sys->port = 0;
347
348     xcb_xv_adaptor_info_iterator_t it;
349     for (it = xcb_xv_query_adaptors_info_iterator (adaptors);
350          it.rem > 0;
351          xcb_xv_adaptor_info_next (&it))
352     {
353         const xcb_xv_adaptor_info_t *a = it.data;
354         char *name;
355
356         if (forced_adaptor != -1 && forced_adaptor != 0)
357         {
358             forced_adaptor--;
359             continue;
360         }
361
362         if (!(a->type & XCB_XV_TYPE_IMAGE_MASK))
363             continue;
364
365         xcb_xv_list_image_formats_reply_t *r =
366             xcb_xv_list_image_formats_reply (conn,
367                 xcb_xv_list_image_formats (conn, a->base_id), NULL);
368         if (r == NULL)
369             continue;
370
371         /* Look for an image format */
372         const xcb_xv_image_format_info_t *xfmt = NULL;
373         const vlc_fourcc_t *chromas, chromas_default[] = {
374             fmt.i_chroma,
375             VLC_CODEC_RGB32,
376             VLC_CODEC_RGB24,
377             VLC_CODEC_RGB16,
378             VLC_CODEC_RGB15,
379             VLC_CODEC_YUYV,
380             0
381         };
382         if (vlc_fourcc_IsYUV (fmt.i_chroma))
383             chromas = vlc_fourcc_GetYUVFallback (fmt.i_chroma);
384         else
385             chromas = chromas_default;
386
387         int forced_format_id = var_CreateGetInteger (obj, "xvideo-format-id");
388         vlc_fourcc_t chroma = forced_format_id;
389         xfmt = FindFormat (vd, chroma, &fmt, a->base_id, r, &p_sys->att);
390         for (size_t i = 0; !xfmt && chromas[i]; i++)
391         {
392             chroma = chromas[i];
393
394             /* Oink oink! */
395             if ((chroma == VLC_CODEC_I420 || chroma == VLC_CODEC_YV12)
396              && a->name_size >= 4
397              && !memcmp ("OMAP", xcb_xv_adaptor_info_name (a), 4))
398             {
399                 msg_Dbg (vd, "skipping slow I420 format");
400                 continue; /* OMAP framebuffer sucks at YUV 4:2:0 */
401             }
402
403             xfmt = FindFormat (vd, chroma, &fmt, a->base_id, r, &p_sys->att);
404         }
405         if (xfmt == NULL) /* No acceptable image formats */
406         {
407             free (r);
408             continue;
409         }
410
411         p_sys->id = xfmt->id;
412         p_sys->swap_uv = vlc_fourcc_AreUVPlanesSwapped (fmt.i_chroma, chroma);
413         if (!p_sys->swap_uv)
414             fmt.i_chroma = chroma;
415         if (xfmt->type == XCB_XV_IMAGE_FORMAT_INFO_TYPE_RGB)
416         {
417             fmt.i_rmask = xfmt->red_mask;
418             fmt.i_gmask = xfmt->green_mask;
419             fmt.i_bmask = xfmt->blue_mask;
420         }
421         free (r);
422
423         /* Grab a port */
424         for (unsigned i = 0; i < a->num_ports; i++)
425         {
426              xcb_xv_port_t port = a->base_id + i;
427              xcb_xv_grab_port_reply_t *gr =
428                  xcb_xv_grab_port_reply (conn,
429                      xcb_xv_grab_port (conn, port, XCB_CURRENT_TIME), NULL);
430              uint8_t result = gr ? gr->result : 0xff;
431
432              free (gr);
433              if (result == 0)
434              {
435                  p_sys->port = port;
436                  goto grabbed_port;
437              }
438              msg_Dbg (vd, "cannot grab port %"PRIu32": Xv error %"PRIu8, port,
439                       result);
440         }
441         continue; /* No usable port */
442
443     grabbed_port:
444         /* Found port - initialize selected format */
445         name = strndup (xcb_xv_adaptor_info_name (a), a->name_size);
446         if (name != NULL)
447         {
448             msg_Dbg (vd, "using adaptor %s", name);
449             free (name);
450         }
451         msg_Dbg (vd, "using port %"PRIu32, p_sys->port);
452         msg_Dbg (vd, "using image format 0x%"PRIx32, p_sys->id);
453
454         /* Look for an X11 visual, create a window */
455         xcb_xv_format_t *f = xcb_xv_adaptor_info_formats (a);
456         for (uint_fast16_t i = a->num_formats; i > 0; i--, f++)
457         {
458             if (f->depth != screen->root_depth)
459                 continue; /* this would fail anyway */
460
461             uint32_t mask =
462                 XCB_CW_BACK_PIXMAP |
463                 XCB_CW_BACK_PIXEL |
464                 XCB_CW_BORDER_PIXMAP |
465                 XCB_CW_BORDER_PIXEL |
466                 XCB_CW_EVENT_MASK |
467                 XCB_CW_COLORMAP;
468             const uint32_t list[] = {
469                 /* XCB_CW_BACK_PIXMAP */
470                 pixmap,
471                 /* XCB_CW_BACK_PIXEL */
472                 screen->black_pixel,
473                 /* XCB_CW_BORDER_PIXMAP */
474                 pixmap,
475                 /* XCB_CW_BORDER_PIXEL */
476                 screen->black_pixel,
477                 /* XCB_CW_EVENT_MASK */
478                 XCB_EVENT_MASK_VISIBILITY_CHANGE,
479                 /* XCB_CW_COLORMAP */
480                 screen->default_colormap,
481             };
482
483             xcb_void_cookie_t c;
484
485             xcb_create_pixmap (conn, f->depth, pixmap, screen->root, 1, 1);
486             c = xcb_create_window_checked (conn, f->depth, p_sys->window,
487                  p_sys->embed->handle.xid, 0, 0, 1, 1, 0,
488                  XCB_WINDOW_CLASS_INPUT_OUTPUT, f->visual, mask, list);
489
490             if (!CheckError (vd, conn, "cannot create X11 window", c))
491             {
492                 msg_Dbg (vd, "using X11 visual ID 0x%"PRIx32
493                          " (depth: %"PRIu8")", f->visual, f->depth);
494                 msg_Dbg (vd, "using X11 window 0x%08"PRIx32, p_sys->window);
495                 goto created_window;
496             }
497         }
498         xcb_xv_ungrab_port (conn, p_sys->port, XCB_CURRENT_TIME);
499         p_sys->port = 0;
500         msg_Dbg (vd, "no usable X11 visual");
501         continue; /* No workable XVideo format (visual/depth) */
502
503     created_window:
504         break;
505     }
506     free (adaptors);
507     if (!p_sys->port)
508     {
509         msg_Err (vd, "no available XVideo adaptor");
510         goto error;
511     }
512     else
513     {
514         xcb_map_window (conn, p_sys->window);
515
516         vout_display_place_t place;
517
518         vout_display_PlacePicture (&place, &vd->source, vd->cfg, false);
519         p_sys->width  = place.width;
520         p_sys->height = place.height;
521
522         /* */
523         const uint32_t values[] = {
524             place.x, place.y, place.width, place.height };
525         xcb_configure_window (conn, p_sys->window,
526                               XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
527                               XCB_CONFIG_WINDOW_WIDTH |
528                               XCB_CONFIG_WINDOW_HEIGHT,
529                               values);
530     }
531     p_sys->visible = false;
532
533     /* Create graphic context */
534     p_sys->gc = xcb_generate_id (conn);
535     xcb_create_gc (conn, p_sys->gc, p_sys->window, 0, NULL);
536     msg_Dbg (vd, "using X11 graphic context 0x%08"PRIx32, p_sys->gc);
537
538     /* Create cursor */
539     p_sys->cursor = CreateBlankCursor (conn, screen);
540
541     p_sys->shm = CheckSHM (obj, conn);
542
543     /* */
544     vout_display_info_t info = vd->info;
545     info.has_pictures_invalid = false;
546     info.has_event_thread = true;
547
548     /* Setup vout_display_t once everything is fine */
549     vd->fmt = fmt;
550     vd->info = info;
551
552     vd->pool = Pool;
553     vd->prepare = NULL;
554     vd->display = Display;
555     vd->control = Control;
556     vd->manage = Manage;
557
558     /* */
559     bool is_fullscreen = vd->cfg->is_fullscreen;
560     if (is_fullscreen && vout_window_SetFullScreen (p_sys->embed, true))
561         is_fullscreen = false;
562     vout_display_SendEventFullscreen (vd, is_fullscreen);
563     unsigned width, height;
564     if (!GetWindowSize (p_sys->embed, conn, &width, &height))
565         vout_display_SendEventDisplaySize (vd, width, height, is_fullscreen);
566
567     return VLC_SUCCESS;
568
569 error:
570     Close (obj);
571     return VLC_EGENERIC;
572 }
573
574
575 /**
576  * Disconnect from the X server.
577  */
578 static void Close (vlc_object_t *obj)
579 {
580     vout_display_t *vd = (vout_display_t *)obj;
581     vout_display_sys_t *p_sys = vd->sys;
582
583     if (p_sys->pool)
584     {
585         for (unsigned i = 0; i < MAX_PICTURES; i++)
586         {
587             picture_resource_t *res = &p_sys->resource[i];
588
589             if (!res->p->p_pixels)
590                 break;
591             PictureResourceFree (res, NULL);
592         }
593         picture_pool_Delete (p_sys->pool);
594     }
595
596     /* show the default cursor */
597     xcb_change_window_attributes (p_sys->conn, p_sys->embed->handle.xid, XCB_CW_CURSOR,
598                                   &(uint32_t) { XCB_CURSOR_NONE });
599     xcb_flush (p_sys->conn);
600
601     free (p_sys->att);
602     xcb_disconnect (p_sys->conn);
603     vout_display_DeleteWindow (vd, p_sys->embed);
604     free (p_sys);
605 }
606
607 static void PoolAlloc (vout_display_t *vd, unsigned requested_count)
608 {
609     vout_display_sys_t *p_sys = vd->sys;
610
611     memset (p_sys->resource, 0, sizeof(p_sys->resource));
612
613     const uint32_t *pitches= xcb_xv_query_image_attributes_pitches (p_sys->att);
614     const uint32_t *offsets= xcb_xv_query_image_attributes_offsets (p_sys->att);
615     const unsigned num_planes= __MIN(p_sys->att->num_planes, PICTURE_PLANE_MAX);
616     p_sys->data_size = p_sys->att->data_size;
617
618     picture_t *pic_array[MAX_PICTURES];
619     requested_count = __MIN(requested_count, MAX_PICTURES);
620
621     unsigned count;
622     for (count = 0; count < requested_count; count++)
623     {
624         picture_resource_t *res = &p_sys->resource[count];
625
626         for (unsigned i = 0; i < num_planes; i++)
627         {
628             uint32_t data_size;
629             data_size = (i < num_planes - 1) ? offsets[i+1] : p_sys->data_size;
630
631             res->p[i].i_lines = (data_size - offsets[i]) / pitches[i];
632             res->p[i].i_pitch = pitches[i];
633         }
634
635         if (PictureResourceAlloc (vd, res, p_sys->att->data_size,
636                                   p_sys->conn, p_sys->shm))
637             break;
638
639         /* Allocate further planes as specified by XVideo */
640         /* We assume that offsets[0] is zero */
641         for (unsigned i = 1; i < num_planes; i++)
642             res->p[i].p_pixels = res->p[0].p_pixels + offsets[i];
643
644         if (p_sys->swap_uv)
645         {   /* YVU: swap U and V planes */
646             uint8_t *buf = res->p[2].p_pixels;
647             res->p[2].p_pixels = res->p[1].p_pixels;
648             res->p[1].p_pixels = buf;
649         }
650
651         pic_array[count] = picture_NewFromResource (&vd->fmt, res);
652         if (!pic_array[count])
653         {
654             PictureResourceFree (res, p_sys->conn);
655             memset (res, 0, sizeof(*res));
656             break;
657         }
658     }
659
660     if (count == 0)
661         return;
662
663     p_sys->pool = picture_pool_New (count, pic_array);
664     /* TODO release picture resources if NULL */
665     xcb_flush (p_sys->conn);
666 }
667
668 /**
669  * Return a direct buffer
670  */
671 static picture_pool_t *Pool (vout_display_t *vd, unsigned requested_count)
672 {
673     vout_display_sys_t *p_sys = vd->sys;
674
675     if (!p_sys->pool)
676         PoolAlloc (vd, requested_count);
677
678     return p_sys->pool;
679 }
680
681 /**
682  * Sends an image to the X server.
683  */
684 static void Display (vout_display_t *vd, picture_t *pic, subpicture_t *subpicture)
685 {
686     vout_display_sys_t *p_sys = vd->sys;
687     xcb_shm_seg_t segment = pic->p_sys->segment;
688     xcb_void_cookie_t ck;
689
690     if (!p_sys->visible)
691         goto out;
692     if (segment)
693         ck = xcb_xv_shm_put_image_checked (p_sys->conn, p_sys->port,
694                               p_sys->window, p_sys->gc, segment, p_sys->id, 0,
695                    /* Src: */ vd->source.i_x_offset,
696                               vd->source.i_y_offset,
697                               vd->source.i_visible_width,
698                               vd->source.i_visible_height,
699                    /* Dst: */ 0, 0, p_sys->width, p_sys->height,
700                 /* Memory: */ pic->p->i_pitch / pic->p->i_pixel_pitch,
701                               pic->p->i_lines, false);
702     else
703         ck = xcb_xv_put_image_checked (p_sys->conn, p_sys->port, p_sys->window,
704                           p_sys->gc, p_sys->id,
705                           vd->source.i_x_offset,
706                           vd->source.i_y_offset,
707                           vd->source.i_visible_width,
708                           vd->source.i_visible_height,
709                           0, 0, p_sys->width, p_sys->height,
710                           pic->p->i_pitch / pic->p->i_pixel_pitch,
711                           pic->p->i_lines,
712                           p_sys->data_size, pic->p->p_pixels);
713
714     /* Wait for reply. See x11.c for rationale. */
715     xcb_generic_error_t *e = xcb_request_check (p_sys->conn, ck);
716     if (e != NULL)
717     {
718         msg_Dbg (vd, "%s: X11 error %d", "cannot put image", e->error_code);
719         free (e);
720     }
721 out:
722     picture_Release (pic);
723     (void)subpicture;
724 }
725
726 static int Control (vout_display_t *vd, int query, va_list ap)
727 {
728     vout_display_sys_t *p_sys = vd->sys;
729
730     switch (query)
731     {
732     case VOUT_DISPLAY_CHANGE_FULLSCREEN:
733     {
734         const vout_display_cfg_t *c = va_arg (ap, const vout_display_cfg_t *);
735         return vout_window_SetFullScreen (p_sys->embed, c->is_fullscreen);
736     }
737
738     case VOUT_DISPLAY_CHANGE_DISPLAY_SIZE:
739     case VOUT_DISPLAY_CHANGE_DISPLAY_FILLED:
740     case VOUT_DISPLAY_CHANGE_ZOOM:
741     case VOUT_DISPLAY_CHANGE_SOURCE_ASPECT:
742     case VOUT_DISPLAY_CHANGE_SOURCE_CROP:
743     {
744         const vout_display_cfg_t *cfg;
745         const video_format_t *source;
746         bool is_forced = false;
747
748         if (query == VOUT_DISPLAY_CHANGE_SOURCE_ASPECT
749          || query == VOUT_DISPLAY_CHANGE_SOURCE_CROP)
750         {
751             source = (const video_format_t *)va_arg (ap, const video_format_t *);
752             cfg = vd->cfg;
753         }
754         else
755         {
756             source = &vd->source;
757             cfg = (const vout_display_cfg_t*)va_arg (ap, const vout_display_cfg_t *);
758             if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE)
759                 is_forced = (bool)va_arg (ap, int);
760         }
761
762         /* */
763         if (query == VOUT_DISPLAY_CHANGE_DISPLAY_SIZE
764          && is_forced
765          && (cfg->display.width  != vd->cfg->display.width
766            ||cfg->display.height != vd->cfg->display.height)
767          && vout_window_SetSize (p_sys->embed,
768                                   cfg->display.width,
769                                   cfg->display.height))
770             return VLC_EGENERIC;
771
772         vout_display_place_t place;
773         vout_display_PlacePicture (&place, source, cfg, false);
774         p_sys->width  = place.width;
775         p_sys->height = place.height;
776
777         /* Move the picture within the window */
778         const uint32_t values[] = { place.x, place.y,
779                                     place.width, place.height, };
780         xcb_configure_window (p_sys->conn, p_sys->window,
781                               XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y
782                             | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,
783                               values);
784         xcb_flush (p_sys->conn);
785         return VLC_SUCCESS;
786     }
787     case VOUT_DISPLAY_CHANGE_WINDOW_STATE:
788     {
789         unsigned state = va_arg (ap, unsigned);
790         return vout_window_SetState (p_sys->embed, state);
791     }
792
793     /* Hide the mouse. It will be send when
794      * vout_display_t::info.b_hide_mouse is false */
795     case VOUT_DISPLAY_HIDE_MOUSE:
796         xcb_change_window_attributes (p_sys->conn, p_sys->embed->handle.xid,
797                                   XCB_CW_CURSOR, &(uint32_t){ p_sys->cursor });
798         return VLC_SUCCESS;
799     case VOUT_DISPLAY_RESET_PICTURES:
800         assert(0);
801     default:
802         msg_Err (vd, "Unknown request in XCB vout display");
803         return VLC_EGENERIC;
804     }
805 }
806
807 static void Manage (vout_display_t *vd)
808 {
809     vout_display_sys_t *p_sys = vd->sys;
810
811     ManageEvent (vd, p_sys->conn, &p_sys->visible);
812 }
813