Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / libvo / vo_x11.c
1 /*
2  * This file is part of MPlayer.
3  *
4  * MPlayer is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * MPlayer is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17  */
18
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include "config.h"
24 #include "video_out.h"
25 #include "video_out_internal.h"
26 #include "aspect.h"
27
28
29 #include <X11/Xlib.h>
30 #include <X11/Xutil.h>
31
32 #include <errno.h>
33
34 #include "x11_common.h"
35
36 #ifdef HAVE_SHM
37 #include <sys/ipc.h>
38 #include <sys/shm.h>
39 #include <X11/extensions/XShm.h>
40
41 static int Shmem_Flag;
42
43 //static int Quiet_Flag;  Here also what is this for. It's used but isn't initialized?
44 static XShmSegmentInfo Shminfo[1];
45 static int gXErrorFlag;
46 static int CompletionType = -1;
47 #endif
48
49 #include "sub.h"
50
51 #include "libswscale/swscale.h"
52 #include "libmpcodecs/vf_scale.h"
53 #define MODE_RGB  0x1
54 #define MODE_BGR  0x2
55
56 #include "mp_msg.h"
57 #include "help_mp.h"
58
59 #ifdef CONFIG_GUI
60 #include "gui/interface.h"
61 #include "mplayer.h"
62 #endif
63
64 static const vo_info_t info = {
65     "X11 ( XImage/Shm )",
66     "x11",
67     "Aaron Holtzman <aholtzma@ess.engr.uvic.ca>",
68     ""
69 };
70
71 const LIBVO_EXTERN(x11)
72 /* private prototypes */
73 static void (*draw_alpha_fnc) (int x0, int y0, int w, int h,
74                                unsigned char *src, unsigned char *srca,
75                                int stride);
76
77 /* local data */
78 static unsigned char *ImageData;
79 //! original unaligned pointer for free
80 static unsigned char *ImageDataOrig;
81
82 /* X11 related variables */
83 static XImage *myximage = NULL;
84 static int depth, bpp;
85 static XWindowAttributes attribs;
86
87 static int int_pause;
88
89 static int Flip_Flag;
90 static int zoomFlag;
91
92
93 static uint32_t image_width;
94 static uint32_t image_height;
95 static uint32_t in_format;
96 static uint32_t out_format = 0;
97 static int out_offset;
98 static int srcW = -1;
99 static int srcH = -1;
100
101 static int old_vo_dwidth = -1;
102 static int old_vo_dheight = -1;
103
104 static void check_events(void)
105 {
106     int ret = vo_x11_check_events(mDisplay);
107
108     if (ret & VO_EVENT_RESIZE)
109         vo_x11_clearwindow(mDisplay, vo_window);
110     else if (ret & VO_EVENT_EXPOSE)
111         vo_x11_clearwindow_part(mDisplay, vo_window, myximage->width,
112                                 myximage->height, 0);
113     if (ret & VO_EVENT_EXPOSE && int_pause)
114         flip_page();
115 }
116
117 static void draw_alpha_32(int x0, int y0, int w, int h, unsigned char *src,
118                           unsigned char *srca, int stride)
119 {
120     vo_draw_alpha_rgb32(w, h, src, srca, stride,
121                         ImageData + 4 * (y0 * image_width + x0),
122                         4 * image_width);
123 }
124
125 static void draw_alpha_24(int x0, int y0, int w, int h, unsigned char *src,
126                           unsigned char *srca, int stride)
127 {
128     vo_draw_alpha_rgb24(w, h, src, srca, stride,
129                         ImageData + 3 * (y0 * image_width + x0),
130                         3 * image_width);
131 }
132
133 static void draw_alpha_16(int x0, int y0, int w, int h, unsigned char *src,
134                           unsigned char *srca, int stride)
135 {
136     vo_draw_alpha_rgb16(w, h, src, srca, stride,
137                         ImageData + 2 * (y0 * image_width + x0),
138                         2 * image_width);
139 }
140
141 static void draw_alpha_15(int x0, int y0, int w, int h, unsigned char *src,
142                           unsigned char *srca, int stride)
143 {
144     vo_draw_alpha_rgb15(w, h, src, srca, stride,
145                         ImageData + 2 * (y0 * image_width + x0),
146                         2 * image_width);
147 }
148
149 static void draw_alpha_null(int x0, int y0, int w, int h,
150                             unsigned char *src, unsigned char *srca,
151                             int stride)
152 {
153 }
154
155 static struct SwsContext *swsContext = NULL;
156 static int dst_width;
157 extern int sws_flags;
158
159 static XVisualInfo vinfo;
160
161 static void getMyXImage(void)
162 {
163 #ifdef HAVE_SHM
164     if (mLocalDisplay && XShmQueryExtension(mDisplay))
165         Shmem_Flag = 1;
166     else
167     {
168         Shmem_Flag = 0;
169         mp_msg(MSGT_VO, MSGL_WARN,
170                "Shared memory not supported\nReverting to normal Xlib\n");
171     }
172     if (Shmem_Flag)
173         CompletionType = XShmGetEventBase(mDisplay) + ShmCompletion;
174
175     if (Shmem_Flag)
176     {
177         myximage =
178             XShmCreateImage(mDisplay, vinfo.visual, depth, ZPixmap, NULL,
179                             &Shminfo[0], image_width, image_height);
180         if (myximage == NULL)
181         {
182             mp_msg(MSGT_VO, MSGL_WARN,
183                    "Shared memory error,disabling ( Ximage error )\n");
184             goto shmemerror;
185         }
186         Shminfo[0].shmid = shmget(IPC_PRIVATE,
187                                   myximage->bytes_per_line *
188                                   myximage->height, IPC_CREAT | 0777);
189         if (Shminfo[0].shmid < 0)
190         {
191             XDestroyImage(myximage);
192             mp_msg(MSGT_VO, MSGL_V, "%s\n", strerror(errno));
193             //perror( strerror( errno ) );
194             mp_msg(MSGT_VO, MSGL_WARN,
195                    "Shared memory error,disabling ( seg id error )\n");
196             goto shmemerror;
197         }
198         Shminfo[0].shmaddr = (char *) shmat(Shminfo[0].shmid, 0, 0);
199
200         if (Shminfo[0].shmaddr == ((char *) -1))
201         {
202             XDestroyImage(myximage);
203             if (Shminfo[0].shmaddr != ((char *) -1))
204                 shmdt(Shminfo[0].shmaddr);
205             mp_msg(MSGT_VO, MSGL_WARN,
206                    "Shared memory error,disabling ( address error )\n");
207             goto shmemerror;
208         }
209         myximage->data = Shminfo[0].shmaddr;
210         ImageData = (unsigned char *) myximage->data;
211         Shminfo[0].readOnly = False;
212         XShmAttach(mDisplay, &Shminfo[0]);
213
214         XSync(mDisplay, False);
215
216         if (gXErrorFlag)
217         {
218             XDestroyImage(myximage);
219             shmdt(Shminfo[0].shmaddr);
220             mp_msg(MSGT_VO, MSGL_WARN, "Shared memory error,disabling.\n");
221             gXErrorFlag = 0;
222             goto shmemerror;
223         } else
224             shmctl(Shminfo[0].shmid, IPC_RMID, 0);
225
226         {
227             static int firstTime = 1;
228
229             if (firstTime)
230             {
231                 mp_msg(MSGT_VO, MSGL_V, "Sharing memory.\n");
232                 firstTime = 0;
233             }
234         }
235     } else
236     {
237       shmemerror:
238         Shmem_Flag = 0;
239 #endif
240         myximage = XCreateImage(mDisplay, vinfo.visual, depth, ZPixmap,
241                              0, NULL, image_width, image_height, 8, 0);
242         ImageDataOrig = malloc(myximage->bytes_per_line * image_height + 32);
243         myximage->data = ImageDataOrig + 16 - ((long)ImageDataOrig & 15);
244         memset(myximage->data, 0, myximage->bytes_per_line * image_height);
245         ImageData = myximage->data;
246 #ifdef HAVE_SHM
247     }
248 #endif
249 }
250
251 static void freeMyXImage(void)
252 {
253 #ifdef HAVE_SHM
254     if (Shmem_Flag)
255     {
256         XShmDetach(mDisplay, &Shminfo[0]);
257         XDestroyImage(myximage);
258         shmdt(Shminfo[0].shmaddr);
259     } else
260 #endif
261     {
262         myximage->data = ImageDataOrig;
263         XDestroyImage(myximage);
264         ImageDataOrig = NULL;
265     }
266     myximage = NULL;
267     ImageData = NULL;
268 }
269
270 #if HAVE_BIGENDIAN
271 #define BO_NATIVE    MSBFirst
272 #define BO_NONNATIVE LSBFirst
273 #else
274 #define BO_NATIVE    LSBFirst
275 #define BO_NONNATIVE MSBFirst
276 #endif
277 const struct fmt2Xfmtentry_s {
278   uint32_t mpfmt;
279   int byte_order;
280   unsigned red_mask;
281   unsigned green_mask;
282   unsigned blue_mask;
283 } fmt2Xfmt[] = {
284   {IMGFMT_RGB8,  BO_NATIVE,    0x00000007, 0x00000038, 0x000000C0},
285   {IMGFMT_RGB8,  BO_NONNATIVE, 0x00000007, 0x00000038, 0x000000C0},
286   {IMGFMT_BGR8,  BO_NATIVE,    0x000000E0, 0x0000001C, 0x00000003},
287   {IMGFMT_BGR8,  BO_NONNATIVE, 0x000000E0, 0x0000001C, 0x00000003},
288   {IMGFMT_RGB15, BO_NATIVE,    0x0000001F, 0x000003E0, 0x00007C00},
289   {IMGFMT_BGR15, BO_NATIVE,    0x00007C00, 0x000003E0, 0x0000001F},
290   {IMGFMT_RGB16, BO_NATIVE,    0x0000001F, 0x000007E0, 0x0000F800},
291   {IMGFMT_BGR16, BO_NATIVE,    0x0000F800, 0x000007E0, 0x0000001F},
292   {IMGFMT_RGB24, MSBFirst,     0x00FF0000, 0x0000FF00, 0x000000FF},
293   {IMGFMT_RGB24, LSBFirst,     0x000000FF, 0x0000FF00, 0x00FF0000},
294   {IMGFMT_BGR24, MSBFirst,     0x000000FF, 0x0000FF00, 0x00FF0000},
295   {IMGFMT_BGR24, LSBFirst,     0x00FF0000, 0x0000FF00, 0x000000FF},
296   {IMGFMT_RGB32, BO_NATIVE,    0x000000FF, 0x0000FF00, 0x00FF0000},
297   {IMGFMT_RGB32, BO_NONNATIVE, 0xFF000000, 0x00FF0000, 0x0000FF00},
298   {IMGFMT_BGR32, BO_NATIVE,    0x00FF0000, 0x0000FF00, 0x000000FF},
299   {IMGFMT_BGR32, BO_NONNATIVE, 0x0000FF00, 0x00FF0000, 0xFF000000},
300   {IMGFMT_ARGB,  MSBFirst,     0x00FF0000, 0x0000FF00, 0x000000FF},
301   {IMGFMT_ARGB,  LSBFirst,     0x0000FF00, 0x00FF0000, 0xFF000000},
302   {IMGFMT_ABGR,  MSBFirst,     0x000000FF, 0x0000FF00, 0x00FF0000},
303   {IMGFMT_ABGR,  LSBFirst,     0xFF000000, 0x00FF0000, 0x0000FF00},
304   {IMGFMT_RGBA,  MSBFirst,     0xFF000000, 0x00FF0000, 0x0000FF00},
305   {IMGFMT_RGBA,  LSBFirst,     0x000000FF, 0x0000FF00, 0x00FF0000},
306   {IMGFMT_BGRA,  MSBFirst,     0x0000FF00, 0x00FF0000, 0xFF000000},
307   {IMGFMT_BGRA,  LSBFirst,     0x00FF0000, 0x0000FF00, 0x000000FF},
308   {0, 0, 0, 0, 0}
309 };
310
311 static int config(uint32_t width, uint32_t height, uint32_t d_width,
312                        uint32_t d_height, uint32_t flags, char *title,
313                        uint32_t format)
314 {
315 // int screen;
316
317 // int interval, prefer_blank, allow_exp, nothing;
318     unsigned int fg, bg;
319     Colormap theCmap;
320     XSetWindowAttributes xswa;
321     unsigned long xswamask;
322     const struct fmt2Xfmtentry_s *fmte = fmt2Xfmt;
323
324 #ifdef CONFIG_XF86VM
325     int vm = flags & VOFLAG_MODESWITCHING;
326 #endif
327     Flip_Flag = flags & VOFLAG_FLIPPING;
328     zoomFlag = flags & VOFLAG_SWSCALE;
329
330     old_vo_dwidth = -1;
331     old_vo_dheight = -1;
332
333     int_pause = 0;
334     if (!title)
335         title = "MPlayer X11 (XImage/Shm) render";
336
337     in_format = format;
338     srcW = width;
339     srcH = height;
340
341     XGetWindowAttributes(mDisplay, mRootWin, &attribs);
342     depth = attribs.depth;
343
344     if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
345     {
346         Visual *visual;
347
348         depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
349     }
350     if (!XMatchVisualInfo(mDisplay, mScreen, depth, DirectColor, &vinfo) ||
351         (WinID > 0
352          && vinfo.visualid != XVisualIDFromVisual(attribs.visual)))
353         XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
354
355     /* set image size (which is indeed neither the input nor output size),
356        if zoom is on it will be changed during draw_slice anyway so we don't duplicate the aspect code here
357      */
358     image_width = (width + 7) & (~7);
359     image_height = height;
360
361 #ifdef CONFIG_GUI
362     if (use_gui)
363         guiGetEvent(guiSetShVideo, 0);  // the GUI will set up / resize the window
364     else
365 #endif
366     {
367 #ifdef CONFIG_XF86VM
368         if (vm)
369         {
370             vo_vm_switch();
371         }
372 #endif
373         bg = WhitePixel(mDisplay, mScreen);
374         fg = BlackPixel(mDisplay, mScreen);
375
376         theCmap = vo_x11_create_colormap(&vinfo);
377
378         xswa.background_pixel = 0;
379         xswa.border_pixel = 0;
380         xswa.colormap = theCmap;
381         xswamask = CWBackPixel | CWBorderPixel | CWColormap;
382
383 #ifdef CONFIG_XF86VM
384         if (vm)
385         {
386             xswa.override_redirect = True;
387             xswamask |= CWOverrideRedirect;
388         }
389 #endif
390
391             vo_x11_create_vo_window(&vinfo, vo_dx, vo_dy, vo_dwidth, vo_dheight,
392                     flags, theCmap, "x11", title);
393         if (WinID > 0)
394             depth = vo_x11_update_geometry();
395
396 #ifdef CONFIG_XF86VM
397         if (vm)
398         {
399             /* Grab the mouse pointer in our window */
400             if (vo_grabpointer)
401                 XGrabPointer(mDisplay, vo_window, True, 0,
402                              GrabModeAsync, GrabModeAsync,
403                              vo_window, None, CurrentTime);
404             XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
405         }
406 #endif
407     }
408
409     if (myximage)
410     {
411         freeMyXImage();
412         sws_freeContext(swsContext);
413     }
414     getMyXImage();
415
416     while (fmte->mpfmt) {
417       int depth = IMGFMT_RGB_DEPTH(fmte->mpfmt);
418       /* bits_per_pixel in X seems to be set to 16 for 15 bit formats
419          => force depth to 16 so that only the color masks are used for the format check */
420       if (depth == 15)
421           depth = 16;
422
423       if (depth            == myximage->bits_per_pixel &&
424           fmte->byte_order == myximage->byte_order &&
425           fmte->red_mask   == myximage->red_mask   &&
426           fmte->green_mask == myximage->green_mask &&
427           fmte->blue_mask  == myximage->blue_mask)
428         break;
429       fmte++;
430     }
431     if (!fmte->mpfmt) {
432       mp_msg(MSGT_VO, MSGL_ERR,
433              "X server image format not supported, please contact the developers\n");
434       return -1;
435     }
436     out_format = fmte->mpfmt;
437     switch ((bpp = myximage->bits_per_pixel))
438     {
439         case 24:
440             draw_alpha_fnc = draw_alpha_24;
441             break;
442         case 32:
443             draw_alpha_fnc = draw_alpha_32;
444             break;
445         case 15:
446         case 16:
447             if (depth == 15)
448                 draw_alpha_fnc = draw_alpha_15;
449             else
450                 draw_alpha_fnc = draw_alpha_16;
451             break;
452         default:
453             draw_alpha_fnc = draw_alpha_null;
454     }
455     out_offset = 0;
456     // for these formats conversion is currently not support and
457     // we can easily "emulate" them.
458     if (out_format & 64 && (IMGFMT_IS_RGB(out_format) || IMGFMT_IS_BGR(out_format))) {
459       out_format &= ~64;
460 #if HAVE_BIGENDIAN
461       out_offset = 1;
462 #else
463       out_offset = -1;
464 #endif
465     }
466
467     /* always allocate swsContext as size could change between frames */
468     swsContext =
469         sws_getContextFromCmdLine(width, height, in_format, width, height,
470                                   out_format);
471     if (!swsContext)
472         return -1;
473
474     dst_width = width;
475     //printf( "X11 bpp: %d  color mask:  R:%lX  G:%lX  B:%lX\n",bpp,myximage->red_mask,myximage->green_mask,myximage->blue_mask );
476
477     return 0;
478 }
479
480 static void Display_Image(XImage * myximage, uint8_t * ImageData)
481 {
482     int x = (vo_dwidth - dst_width) / 2;
483     int y = (vo_dheight - myximage->height) / 2;
484
485     // do not draw if the image needs rescaling
486     if ((old_vo_dwidth != vo_dwidth || old_vo_dheight != vo_dheight) && zoomFlag)
487       return;
488
489     if (WinID == 0) {
490       x = vo_dx;
491       y = vo_dy;
492     }
493     myximage->data += out_offset;
494 #ifdef HAVE_SHM
495     if (Shmem_Flag)
496     {
497         XShmPutImage(mDisplay, vo_window, vo_gc, myximage,
498                      0, 0,
499                      x, y, dst_width,
500                      myximage->height, True);
501     } else
502 #endif
503     {
504         XPutImage(mDisplay, vo_window, vo_gc, myximage,
505                   0, 0,
506                   x, y, dst_width,
507                   myximage->height);
508     }
509     myximage->data -= out_offset;
510 }
511
512 static void draw_osd(void)
513 {
514     vo_draw_text(image_width, image_height, draw_alpha_fnc);
515 }
516
517 static void flip_page(void)
518 {
519     Display_Image(myximage, ImageData);
520     XSync(mDisplay, False);
521 }
522
523 static int draw_slice(uint8_t * src[], int stride[], int w, int h,
524                            int x, int y)
525 {
526     uint8_t *dst[MP_MAX_PLANES] = {NULL};
527     int dstStride[MP_MAX_PLANES] = {0};
528
529     if ((old_vo_dwidth != vo_dwidth
530          || old_vo_dheight != vo_dheight) /*&& y==0 */  && zoomFlag)
531     {
532         int newW = vo_dwidth;
533         int newH = vo_dheight;
534         struct SwsContext *oldContext = swsContext;
535
536         old_vo_dwidth = vo_dwidth;
537         old_vo_dheight = vo_dheight;
538
539         if (vo_fs)
540             aspect(&newW, &newH, A_ZOOM);
541         if (sws_flags == 0)
542             newW &= (~31);      // not needed but, if the user wants the FAST_BILINEAR SCALER, then its needed
543
544         swsContext = sws_getContextFromCmdLine(srcW, srcH, in_format,
545                                                newW, newH, out_format);
546         if (swsContext)
547         {
548             image_width = (newW + 7) & (~7);
549             image_height = newH;
550
551             freeMyXImage();
552             getMyXImage();
553             sws_freeContext(oldContext);
554         } else
555         {
556             swsContext = oldContext;
557         }
558         dst_width = newW;
559     }
560
561     dstStride[0] = image_width * ((bpp + 7) / 8);
562     dst[0] = ImageData;
563     if (Flip_Flag)
564     {
565         dst[0] += dstStride[0] * (image_height - 1);
566         dstStride[0] = -dstStride[0];
567     }
568     sws_scale_ordered(swsContext, src, stride, y, h, dst, dstStride);
569     return 0;
570 }
571
572 static int draw_frame(uint8_t * src[])
573 {
574     return VO_ERROR;
575 }
576
577 static uint32_t get_image(mp_image_t * mpi)
578 {
579     if (zoomFlag ||
580         !IMGFMT_IS_BGR(mpi->imgfmt) ||
581         (IMGFMT_BGR_DEPTH(mpi->imgfmt) != vo_depthonscreen) ||
582         ((mpi->type != MP_IMGTYPE_STATIC)
583          && (mpi->type != MP_IMGTYPE_TEMP))
584         || (mpi->flags & MP_IMGFLAG_PLANAR)
585         || (mpi->flags & MP_IMGFLAG_YUV) || (mpi->width != image_width)
586         || (mpi->height != image_height))
587         return VO_FALSE;
588
589     if (Flip_Flag)
590     {
591         mpi->stride[0] = -image_width * ((bpp + 7) / 8);
592         mpi->planes[0] = ImageData - mpi->stride[0] * (image_height - 1);
593     } else
594     {
595         mpi->stride[0] = image_width * ((bpp + 7) / 8);
596         mpi->planes[0] = ImageData;
597     }
598     mpi->flags |= MP_IMGFLAG_DIRECT;
599
600     return VO_TRUE;
601 }
602
603 static int query_format(uint32_t format)
604 {
605     mp_msg(MSGT_VO, MSGL_DBG2,
606            "vo_x11: query_format was called: %x (%s)\n", format,
607            vo_format_name(format));
608     if (IMGFMT_IS_BGR(format))
609     {
610         if (IMGFMT_BGR_DEPTH(format) <= 8)
611             return 0;           // TODO 8bpp not yet fully implemented
612         if (IMGFMT_BGR_DEPTH(format) == vo_depthonscreen)
613             return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_FLIP |
614                 VFCAP_ACCEPT_STRIDE;
615         else
616             return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_FLIP |
617                 VFCAP_ACCEPT_STRIDE;
618     }
619
620     switch (format)
621     {
622 //   case IMGFMT_BGR8:
623 //   case IMGFMT_BGR15:
624 //   case IMGFMT_BGR16:
625 //   case IMGFMT_BGR24:
626 //   case IMGFMT_BGR32:
627 //    return 0x2;
628 //   case IMGFMT_YUY2:
629         case IMGFMT_I420:
630         case IMGFMT_IYUV:
631         case IMGFMT_YV12:
632             return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_ACCEPT_STRIDE;
633     }
634     return 0;
635 }
636
637
638 static void uninit(void)
639 {
640     if (!myximage)
641         return;
642
643     freeMyXImage();
644
645 #ifdef CONFIG_XF86VM
646     vo_vm_close();
647 #endif
648
649     zoomFlag = 0;
650     vo_x11_uninit();
651
652     sws_freeContext(swsContext);
653 }
654
655 static int preinit(const char *arg)
656 {
657     if (arg)
658     {
659         mp_msg(MSGT_VO, MSGL_ERR, "vo_x11: Unknown subdevice: %s\n", arg);
660         return ENOSYS;
661     }
662
663     if (!vo_init())
664         return -1;              // Can't open X11
665     return 0;
666 }
667
668 static int control(uint32_t request, void *data, ...)
669 {
670     switch (request)
671     {
672         case VOCTRL_PAUSE:
673             return int_pause = 1;
674         case VOCTRL_RESUME:
675             return int_pause = 0;
676         case VOCTRL_QUERY_FORMAT:
677             return query_format(*((uint32_t *) data));
678         case VOCTRL_GET_IMAGE:
679             return get_image(data);
680         case VOCTRL_GUISUPPORT:
681             return VO_TRUE;
682         case VOCTRL_FULLSCREEN:
683             vo_x11_fullscreen();
684             vo_x11_clearwindow(mDisplay, vo_window);
685             return VO_TRUE;
686         case VOCTRL_SET_EQUALIZER:
687             {
688                 va_list ap;
689                 int value;
690
691                 va_start(ap, data);
692                 value = va_arg(ap, int);
693
694                 va_end(ap);
695                 return vo_x11_set_equalizer(data, value);
696             }
697         case VOCTRL_GET_EQUALIZER:
698             {
699                 va_list ap;
700                 int *value;
701
702                 va_start(ap, data);
703                 value = va_arg(ap, int *);
704
705                 va_end(ap);
706                 return vo_x11_get_equalizer(data, value);
707             }
708         case VOCTRL_ONTOP:
709             vo_x11_ontop();
710             return VO_TRUE;
711         case VOCTRL_UPDATE_SCREENINFO:
712             update_xinerama_info();
713             return VO_TRUE;
714     }
715     return VO_NOTIMPL;
716 }