libvo/vo_x11.c

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <signal.h>
   6
   7 #include "config.h"
   8 #include "video_out.h"
   9 #include "video_out_internal.h"
  10
  11
  12 #include <X11/Xlib.h>
  13 #include <X11/Xutil.h>
  14
  15 #ifdef HAVE_XF86VM
  16 #include <X11/extensions/xf86vmode.h>
  17 #endif
  18 #include <errno.h>
  19
  20 #include "x11_common.h"
  21
  22 #ifdef HAVE_SHM
  23 #include <sys/ipc.h>
  24 #include <sys/shm.h>
  25 #include <X11/extensions/XShm.h>
  26
  27 static int Shmem_Flag;
  28
  29 //static int Quiet_Flag;  Here also what is this for. It's used but isn't inited ?
  30 static XShmSegmentInfo Shminfo[1];
  31 static int gXErrorFlag;
  32 static int CompletionType = -1;
  33
  34 /* since it doesn't seem to be defined on some platforms */
  35 int XShmGetEventBase(Display *);
  36 #endif
  37
  38 #include "fastmemcpy.h"
  39 #include "sub.h"
  40
  41 #include "postproc/swscale.h"
  42 #include "postproc/swscale_internal.h"       //FIXME
  43 #include "postproc/rgb2rgb.h"
  44 #include "libmpcodecs/vf_scale.h"
  45
  46 #include "mp_msg.h"
  47 #include "help_mp.h"
  48
  49 #ifdef HAVE_NEW_GUI
  50 #include "Gui/interface.h"
  51 #include "mplayer.h"
  52 #endif
  53
  54 static vo_info_t info = {
  55     "X11 ( XImage/Shm )",
  56     "x11",
  57     "Aaron Holtzman <aholtzma@ess.engr.uvic.ca>",
  58     ""
  59 };
  60
  61 LIBVO_EXTERN(x11)
  62 /* private prototypes */
  63 static void Display_Image(XImage * myximage, unsigned char *ImageData);
  64 static void (*draw_alpha_fnc) (int x0, int y0, int w, int h,
  65                                unsigned char *src, unsigned char *srca,
  66                                int stride);
  67
  68 /* local data */
  69 static unsigned char *ImageData;
  70
  71 /* X11 related variables */
  72 static XImage *myximage = NULL;
  73 static int depth, bpp, mode;
  74 static XWindowAttributes attribs;
  75
  76 static int int_pause;
  77
  78 static int Flip_Flag;
  79 static int zoomFlag;
  80
  81
  82 static uint32_t image_width;
  83 static uint32_t image_height;
  84 static uint32_t in_format;
  85 static uint32_t out_format = 0;
  86 static int srcW = -1;
  87 static int srcH = -1;
  88 static int aspect;              // 1<<16 based fixed point aspect, so that the aspect stays correct during resizing
  89
  90 static int old_vo_dwidth = -1;
  91 static int old_vo_dheight = -1;
  92
  93 static void check_events()
  94 {
  95     int ret = vo_x11_check_events(mDisplay);
  96
  97     /* clear left over borders and redraw frame if we are paused */
  98     if (ret & VO_EVENT_EXPOSE && int_pause)
  99     {
 100         vo_x11_clearwindow_part(mDisplay, vo_window, myximage->width,
 101                                 myximage->height, 0);
 102         flip_page();
 103     } else if ((ret & VO_EVENT_RESIZE) || (ret & VO_EVENT_EXPOSE))
 104         vo_x11_clearwindow_part(mDisplay, vo_window, myximage->width,
 105                                 myximage->height, 0);
 106
 107 }
 108
 109 static void draw_alpha_32(int x0, int y0, int w, int h, unsigned char *src,
 110                           unsigned char *srca, int stride)
 111 {
 112     vo_draw_alpha_rgb32(w, h, src, srca, stride,
 113                         ImageData + 4 * (y0 * image_width + x0),
 114                         4 * image_width);
 115 }
 116
 117 static void draw_alpha_24(int x0, int y0, int w, int h, unsigned char *src,
 118                           unsigned char *srca, int stride)
 119 {
 120     vo_draw_alpha_rgb24(w, h, src, srca, stride,
 121                         ImageData + 3 * (y0 * image_width + x0),
 122                         3 * image_width);
 123 }
 124
 125 static void draw_alpha_16(int x0, int y0, int w, int h, unsigned char *src,
 126                           unsigned char *srca, int stride)
 127 {
 128     vo_draw_alpha_rgb16(w, h, src, srca, stride,
 129                         ImageData + 2 * (y0 * image_width + x0),
 130                         2 * image_width);
 131 }
 132
 133 static void draw_alpha_15(int x0, int y0, int w, int h, unsigned char *src,
 134                           unsigned char *srca, int stride)
 135 {
 136     vo_draw_alpha_rgb15(w, h, src, srca, stride,
 137                         ImageData + 2 * (y0 * image_width + x0),
 138                         2 * image_width);
 139 }
 140
 141 static void draw_alpha_null(int x0, int y0, int w, int h,
 142                             unsigned char *src, unsigned char *srca,
 143                             int stride)
 144 {
 145 }
 146
 147 static SwsContext *swsContext = NULL;
 148 extern int sws_flags;
 149
 150 static XVisualInfo vinfo;
 151
 152 static void getMyXImage(void)
 153 {
 154 #ifdef HAVE_SHM
 155     if (mLocalDisplay && XShmQueryExtension(mDisplay))
 156         Shmem_Flag = 1;
 157     else
 158     {
 159         Shmem_Flag = 0;
 160         mp_msg(MSGT_VO, MSGL_WARN,
 161                "Shared memory not supported\nReverting to normal Xlib\n");
 162     }
 163     if (Shmem_Flag)
 164         CompletionType = XShmGetEventBase(mDisplay) + ShmCompletion;
 165
 166     if (Shmem_Flag)
 167     {
 168         myximage =
 169             XShmCreateImage(mDisplay, vinfo.visual, depth, ZPixmap, NULL,
 170                             &Shminfo[0], image_width, image_height);
 171         if (myximage == NULL)
 172         {
 173             if (myximage != NULL)
 174                 XDestroyImage(myximage);
 175             mp_msg(MSGT_VO, MSGL_WARN,
 176                    "Shared memory error,disabling ( Ximage error )\n");
 177             goto shmemerror;
 178         }
 179         Shminfo[0].shmid = shmget(IPC_PRIVATE,
 180                                   myximage->bytes_per_line *
 181                                   myximage->height, IPC_CREAT | 0777);
 182         if (Shminfo[0].shmid < 0)
 183         {
 184             XDestroyImage(myximage);
 185             mp_msg(MSGT_VO, MSGL_V, "%s\n", strerror(errno));
 186             //perror( strerror( errno ) );
 187             mp_msg(MSGT_VO, MSGL_WARN,
 188                    "Shared memory error,disabling ( seg id error )\n");
 189             goto shmemerror;
 190         }
 191         Shminfo[0].shmaddr = (char *) shmat(Shminfo[0].shmid, 0, 0);
 192
 193         if (Shminfo[0].shmaddr == ((char *) -1))
 194         {
 195             XDestroyImage(myximage);
 196             if (Shminfo[0].shmaddr != ((char *) -1))
 197                 shmdt(Shminfo[0].shmaddr);
 198             mp_msg(MSGT_VO, MSGL_WARN,
 199                    "Shared memory error,disabling ( address error )\n");
 200             goto shmemerror;
 201         }
 202         myximage->data = Shminfo[0].shmaddr;
 203         ImageData = (unsigned char *) myximage->data;
 204         Shminfo[0].readOnly = False;
 205         XShmAttach(mDisplay, &Shminfo[0]);
 206
 207         XSync(mDisplay, False);
 208
 209         if (gXErrorFlag)
 210         {
 211             XDestroyImage(myximage);
 212             shmdt(Shminfo[0].shmaddr);
 213             mp_msg(MSGT_VO, MSGL_WARN, "Shared memory error,disabling.\n");
 214             gXErrorFlag = 0;
 215             goto shmemerror;
 216         } else
 217             shmctl(Shminfo[0].shmid, IPC_RMID, 0);
 218
 219         {
 220             static int firstTime = 1;
 221
 222             if (firstTime)
 223             {
 224                 mp_msg(MSGT_VO, MSGL_V, "Sharing memory.\n");
 225                 firstTime = 0;
 226             }
 227         }
 228     } else
 229     {
 230       shmemerror:
 231         Shmem_Flag = 0;
 232 #endif
 233         myximage = XGetImage(mDisplay, vo_window, 0, 0,
 234                              image_width, image_height, AllPlanes,
 235                              ZPixmap);
 236         ImageData = myximage->data;
 237 #ifdef HAVE_SHM
 238     }
 239 #endif
 240 }
 241
 242 static void freeMyXImage(void)
 243 {
 244 #ifdef HAVE_SHM
 245     if (Shmem_Flag)
 246     {
 247         XShmDetach(mDisplay, &Shminfo[0]);
 248         XDestroyImage(myximage);
 249         shmdt(Shminfo[0].shmaddr);
 250     } else
 251 #endif
 252     {
 253         XDestroyImage(myximage);
 254     }
 255     myximage = NULL;
 256 }
 257
 258 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 259                        uint32_t d_height, uint32_t flags, char *title,
 260                        uint32_t format)
 261 {
 262 // int screen;
 263     int fullscreen = 0;
 264     int vm = 0;
 265
 266 // int interval, prefer_blank, allow_exp, nothing;
 267     unsigned int fg, bg;
 268     XEvent xev;
 269     XGCValues xgcv;
 270     Colormap theCmap;
 271     XSetWindowAttributes xswa;
 272     unsigned long xswamask;
 273
 274 #ifdef HAVE_XF86VM
 275     unsigned int modeline_width, modeline_height;
 276     static uint32_t vm_width;
 277     static uint32_t vm_height;
 278 #endif
 279
 280     vo_mouse_autohide = 1;
 281     old_vo_dwidth = -1;
 282     old_vo_dheight = -1;
 283
 284     if (!title)
 285         title = "MPlayer X11 (XImage/Shm) render";
 286
 287     in_format = format;
 288     srcW = width;
 289     srcH = height;
 290     update_xinerama_info();
 291     vo_dx = (vo_screenwidth - d_width) / 2;
 292     vo_dy = (vo_screenheight - d_height) / 2;
 293     geometry(&vo_dx, &vo_dy, &d_width, &d_height, vo_screenwidth,
 294              vo_screenheight);
 295     vo_dx += xinerama_x;
 296     vo_dy += xinerama_y;
 297     vo_dwidth = d_width;
 298     vo_dheight = d_height;
 299
 300     if (flags & (VOFLAG_FULLSCREEN|VOFLAG_MODESWITCHING))
 301         fullscreen = 1;
 302     if (flags & VOFLAG_MODESWITCHING)
 303         vm = 1;
 304     if (flags & VOFLAG_FLIPPING)
 305         Flip_Flag = 1;
 306     zoomFlag = flags & VOFLAG_SWSCALE;
 307
 308     int_pause = 0;
 309 // if(!fullscreen) zoomFlag=1; //it makes no sense to avoid zooming on windowd mode
 310
 311 //printf( "w: %d h: %d\n\n",vo_dwidth,vo_dheight );
 312
 313     XGetWindowAttributes(mDisplay, mRootWin, &attribs);
 314     depth = attribs.depth;
 315
 316     if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
 317     {
 318         Visual *visual;
 319
 320         depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
 321     }
 322     if (!XMatchVisualInfo(mDisplay, mScreen, depth, DirectColor, &vinfo) ||
 323         (WinID > 0
 324          && vinfo.visualid != XVisualIDFromVisual(attribs.visual)))
 325         XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
 326
 327     /* set image size (which is indeed neither the input nor output size),
 328        if zoom is on it will be changed during draw_slice anyway so we don't duplicate the aspect code here
 329      */
 330     image_width = (width + 7) & (~7);
 331     image_height = height;
 332
 333     aspect = ((1 << 16) * d_width + d_height / 2) / d_height;
 334
 335 #ifdef HAVE_NEW_GUI
 336     if (use_gui)
 337         guiGetEvent(guiSetShVideo, 0);  // the GUI will set up / resize the window
 338     else
 339 #endif
 340     {
 341 #ifdef HAVE_XF86VM
 342         if (vm)
 343         {
 344             if ((d_width == 0) && (d_height == 0))
 345             {
 346                 vm_width = image_width;
 347                 vm_height = image_height;
 348             } else
 349             {
 350                 vm_width = d_width;
 351                 vm_height = d_height;
 352             }
 353             vo_vm_switch(vm_width, vm_height, &modeline_width,
 354                          &modeline_height);
 355             vo_dx = (vo_screenwidth - modeline_width) / 2;
 356             vo_dy = (vo_screenheight - modeline_height) / 2;
 357             vo_dwidth = modeline_width;
 358             vo_dheight = modeline_height;
 359         }
 360 #endif
 361         bg = WhitePixel(mDisplay, mScreen);
 362         fg = BlackPixel(mDisplay, mScreen);
 363
 364         theCmap = vo_x11_create_colormap(&vinfo);
 365
 366         xswa.background_pixel = 0;
 367         xswa.border_pixel = 0;
 368         xswa.colormap = theCmap;
 369         xswamask = CWBackPixel | CWBorderPixel | CWColormap;
 370
 371 #ifdef HAVE_XF86VM
 372         if (vm)
 373         {
 374             xswa.override_redirect = True;
 375             xswamask |= CWOverrideRedirect;
 376         }
 377 #endif
 378
 379         if (WinID >= 0)
 380         {
 381             vo_window = WinID ? ((Window) WinID) : mRootWin;
 382             if (WinID)
 383             {
 384                 int border;
 385                 Window win;
 386                 XUnmapWindow(mDisplay, vo_window);
 387                 XChangeWindowAttributes(mDisplay, vo_window, xswamask,
 388                                         &xswa);
 389                 vo_x11_selectinput_witherr(mDisplay, vo_window,
 390                                            StructureNotifyMask |
 391                                            KeyPressMask |
 392                                            PropertyChangeMask |
 393                                            PointerMotionMask |
 394                                            ButtonPressMask |
 395                                            ButtonReleaseMask |
 396                                            ExposureMask);
 397                 XMapWindow(mDisplay, vo_window);
 398                 XGetGeometry(mDisplay, vo_window, &mRootWin,
 399                              &vo_dx, &vo_dy, &vo_dwidth, &vo_dheight,
 400                              &border, &depth);
 401             } else
 402                 XSelectInput(mDisplay, vo_window, ExposureMask);
 403         } else
 404         {
 405             if (vo_window == None)
 406             {
 407                 vo_window =
 408                     vo_x11_create_smooth_window(mDisplay, mRootWin,
 409                                                 vinfo.visual, vo_dx, vo_dy,
 410                                                 vo_dwidth, vo_dheight,
 411                                                 depth, theCmap);
 412
 413                 vo_x11_classhint(mDisplay, vo_window, "x11");
 414                 vo_hidecursor(mDisplay, vo_window);
 415                 vo_x11_sizehint(vo_dx, vo_dy, vo_dwidth, vo_dheight, 0);
 416                 XSelectInput(mDisplay, vo_window, StructureNotifyMask);
 417                 XStoreName(mDisplay, vo_window, title);
 418                 XMapWindow(mDisplay, vo_window);
 419 //      if(WinID!=0)
 420                 do
 421                 {
 422                     XNextEvent(mDisplay, &xev);
 423                 }
 424                 while (xev.type != MapNotify
 425                        || xev.xmap.event != vo_window);
 426
 427                 if (fullscreen)
 428                     vo_x11_fullscreen();
 429             } else if (!fullscreen)
 430                 XMoveResizeWindow(mDisplay, vo_window, vo_dx, vo_dy,
 431                                   vo_dwidth, vo_dheight);
 432         }
 433
 434         XSync(mDisplay, False);
 435
 436         // we cannot grab mouse events on root window :(
 437         vo_x11_selectinput_witherr(mDisplay, vo_window,
 438                                    StructureNotifyMask | KeyPressMask |
 439                                    PropertyChangeMask | ExposureMask |
 440                                    ((WinID ==
 441                                      0) ? 0 : (ButtonPressMask |
 442                                                ButtonReleaseMask |
 443                                                PointerMotionMask)));
 444
 445 #ifdef HAVE_XF86VM
 446         if (vm)
 447         {
 448             /* Grab the mouse pointer in our window */
 449             if (vo_grabpointer)
 450                 XGrabPointer(mDisplay, vo_window, True, 0,
 451                              GrabModeAsync, GrabModeAsync,
 452                              vo_window, None, CurrentTime);
 453             XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
 454         }
 455 #endif
 456     }
 457
 458     if (vo_gc != None)
 459         XFreeGC(mDisplay, vo_gc);
 460     vo_gc = XCreateGC(mDisplay, vo_window, 0L, &xgcv);
 461
 462     if (myximage)
 463     {
 464         freeMyXImage();
 465         sws_freeContext(swsContext);
 466     }
 467     getMyXImage();
 468
 469     if (!WinID)
 470     {
 471         vo_dwidth = vo_screenwidth;
 472         vo_dheight = vo_screenheight;
 473     }
 474
 475     switch ((bpp = myximage->bits_per_pixel))
 476     {
 477         case 24:
 478             draw_alpha_fnc = draw_alpha_24;
 479             out_format = IMGFMT_BGR24;
 480             break;
 481         case 32:
 482             draw_alpha_fnc = draw_alpha_32;
 483             out_format = IMGFMT_BGR32;
 484             break;
 485         case 15:
 486         case 16:
 487             if (depth == 15)
 488             {
 489                 draw_alpha_fnc = draw_alpha_15;
 490                 out_format = IMGFMT_BGR15;
 491             } else
 492             {
 493                 draw_alpha_fnc = draw_alpha_16;
 494                 out_format = IMGFMT_BGR16;
 495             }
 496             break;
 497         case 8:
 498             draw_alpha_fnc = draw_alpha_null;
 499             out_format = IMGFMT_BGR8;
 500             break;
 501         default:
 502             draw_alpha_fnc = draw_alpha_null;
 503     }
 504
 505     /* always allocate swsContext as size could change between frames */
 506     swsContext =
 507         sws_getContextFromCmdLine(width, height, in_format, width, height,
 508                                   out_format);
 509     if (!swsContext)
 510         return -1;
 511
 512     //printf( "X11 bpp: %d  color mask:  R:%lX  G:%lX  B:%lX\n",bpp,myximage->red_mask,myximage->green_mask,myximage->blue_mask );
 513
 514     // If we have blue in the lowest bit then obviously RGB
 515     mode = ((myximage->blue_mask & 0x01) != 0) ? MODE_RGB : MODE_BGR;
 516 #ifdef WORDS_BIGENDIAN
 517     if (myximage->byte_order != MSBFirst)
 518 #else
 519     if (myximage->byte_order != LSBFirst)
 520 #endif
 521     {
 522         mode = ((myximage->blue_mask & 0x01) != 0) ? MODE_BGR : MODE_RGB;
 523 //   printf( "No support for non-native XImage byte order!\n" );
 524 //   return -1;
 525     }
 526 #ifdef WORDS_BIGENDIAN
 527     if (mode == MODE_BGR && bpp != 32)
 528     {
 529         mp_msg(MSGT_VO, MSGL_ERR,
 530                "BGR%d not supported, please contact the developers\n",
 531                bpp);
 532         return -1;
 533     }
 534 #else
 535     if (mode == MODE_BGR)
 536     {
 537         mp_msg(MSGT_VO, MSGL_ERR,
 538                "BGR not supported, please contact the developers\n");
 539         return -1;
 540     }
 541 #endif
 542
 543     if (vo_ontop)
 544         vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
 545
 546     return 0;
 547 }
 548
 549 static void Display_Image(XImage * myximage, uint8_t * ImageData)
 550 {
 551 #ifdef HAVE_SHM
 552     if (Shmem_Flag)
 553     {
 554         XShmPutImage(mDisplay, vo_window, vo_gc, myximage,
 555                      0, 0,
 556                      (vo_dwidth - swsContext->dstW) / 2,
 557                      (vo_dheight - myximage->height) / 2, swsContext->dstW,
 558                      myximage->height, True);
 559     } else
 560 #endif
 561     {
 562         XPutImage(mDisplay, vo_window, vo_gc, myximage,
 563                   0, 0,
 564                   (vo_dwidth - swsContext->dstW) / 2,
 565                   (vo_dheight - myximage->height) / 2, swsContext->dstW,
 566                   myximage->height);
 567     }
 568 }
 569
 570 static void draw_osd(void)
 571 {
 572     vo_draw_text(image_width, image_height, draw_alpha_fnc);
 573 }
 574
 575 static void flip_page(void)
 576 {
 577     Display_Image(myximage, ImageData);
 578     XSync(mDisplay, False);
 579 }
 580
 581 static int draw_slice(uint8_t * src[], int stride[], int w, int h,
 582                            int x, int y)
 583 {
 584     uint8_t *dst[3];
 585     int dstStride[3];
 586
 587     if ((old_vo_dwidth != vo_dwidth
 588          || old_vo_dheight != vo_dheight) /*&& y==0 */  && zoomFlag)
 589     {
 590         int newW = vo_dwidth;
 591         int newH = vo_dheight;
 592         int newAspect = (newW * (1 << 16) + (newH >> 1)) / newH;
 593         SwsContext *oldContext = swsContext;
 594
 595         if (newAspect > aspect)
 596             newW = (newH * aspect + (1 << 15)) >> 16;
 597         else
 598             newH = ((newW << 16) + (aspect >> 1)) / aspect;
 599
 600         old_vo_dwidth = vo_dwidth;
 601         old_vo_dheight = vo_dheight;
 602
 603         if (sws_flags == 0)
 604             newW &= (~31);      // not needed but, if the user wants the FAST_BILINEAR SCALER, then its needed
 605
 606         swsContext = sws_getContextFromCmdLine(srcW, srcH, in_format,
 607                                                newW, newH, out_format);
 608         if (swsContext)
 609         {
 610             image_width = (newW + 7) & (~7);
 611             image_height = newH;
 612
 613             freeMyXImage();
 614             getMyXImage();
 615             sws_freeContext(oldContext);
 616         } else
 617         {
 618             swsContext = oldContext;
 619         }
 620     }
 621     dstStride[1] = dstStride[2] = 0;
 622     dst[1] = dst[2] = NULL;
 623
 624     if (Flip_Flag)
 625     {
 626         dstStride[0] = -image_width * ((bpp + 7) / 8);
 627         dst[0] = ImageData - dstStride[0] * (image_height - 1);
 628         sws_scale_ordered(swsContext, src, stride, y, h, dst, dstStride);
 629     } else
 630     {
 631         dstStride[0] = image_width * ((bpp + 7) / 8);
 632         dst[0] = ImageData;
 633         sws_scale_ordered(swsContext, src, stride, y, h, dst, dstStride);
 634     }
 635     return 0;
 636 }
 637
 638 static int draw_frame(uint8_t * src[])
 639 {
 640 #if 0
 641     int stride[3] = { 0, 0, 0 };
 642
 643     if (in_format == IMGFMT_YUY2)
 644         stride[0] = srcW * 2;
 645     else if (in_format == IMGFMT_BGR8)
 646         stride[0] = srcW;
 647     else if (in_format == IMGFMT_BGR15)
 648         stride[0] = srcW * 2;
 649     else if (in_format == IMGFMT_BGR16)
 650         stride[0] = srcW * 2;
 651     else if (in_format == IMGFMT_BGR24)
 652         stride[0] = srcW * 3;
 653     else if (in_format == IMGFMT_BGR32)
 654         stride[0] = srcW * 4;
 655
 656     return draw_slice(src, stride, srcW, srcH, 0, 0);
 657 #else
 658     mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_X11_DrawFrameCalled);
 659     return -1;
 660 #endif
 661 }
 662
 663 static uint32_t get_image(mp_image_t * mpi)
 664 {
 665     if (zoomFlag ||
 666         !IMGFMT_IS_BGR(mpi->imgfmt) ||
 667         (IMGFMT_BGR_DEPTH(mpi->imgfmt) != vo_depthonscreen) ||
 668         ((mpi->type != MP_IMGTYPE_STATIC)
 669          && (mpi->type != MP_IMGTYPE_TEMP))
 670         || (mpi->flags & MP_IMGFLAG_PLANAR)
 671         || (mpi->flags & MP_IMGFLAG_YUV) || (mpi->width != image_width)
 672         || (mpi->height != image_height))
 673         return (VO_FALSE);
 674
 675     if (Flip_Flag)
 676     {
 677         mpi->stride[0] = -image_width * ((bpp + 7) / 8);
 678         mpi->planes[0] = ImageData - mpi->stride[0] * (image_height - 1);
 679     } else
 680     {
 681         mpi->stride[0] = image_width * ((bpp + 7) / 8);
 682         mpi->planes[0] = ImageData;
 683     }
 684     mpi->flags |= MP_IMGFLAG_DIRECT;
 685
 686     return (VO_TRUE);
 687 }
 688
 689 static int query_format(uint32_t format)
 690 {
 691     mp_msg(MSGT_VO, MSGL_DBG2,
 692            "vo_x11: query_format was called: %x (%s)\n", format,
 693            vo_format_name(format));
 694     if (IMGFMT_IS_BGR(format))
 695     {
 696         if (IMGFMT_BGR_DEPTH(format) <= 8)
 697             return 0;           // TODO 8bpp not yet fully implemented
 698         if (IMGFMT_BGR_DEPTH(format) == vo_depthonscreen)
 699             return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_FLIP |
 700                 VFCAP_ACCEPT_STRIDE;
 701         else
 702             return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_FLIP |
 703                 VFCAP_ACCEPT_STRIDE;
 704     }
 705
 706     switch (format)
 707     {
 708 //   case IMGFMT_BGR8:
 709 //   case IMGFMT_BGR15:
 710 //   case IMGFMT_BGR16:
 711 //   case IMGFMT_BGR24:
 712 //   case IMGFMT_BGR32:
 713 //    return 0x2;
 714 //   case IMGFMT_YUY2:
 715         case IMGFMT_I420:
 716         case IMGFMT_IYUV:
 717         case IMGFMT_YV12:
 718             return VFCAP_CSP_SUPPORTED | VFCAP_OSD | VFCAP_SWSCALE | VFCAP_ACCEPT_STRIDE;
 719     }
 720     return 0;
 721 }
 722
 723
 724 static void uninit(void)
 725 {
 726     if (!myximage)
 727         return;
 728
 729     freeMyXImage();
 730
 731 #ifdef HAVE_XF86VM
 732     vo_vm_close(mDisplay);
 733 #endif
 734
 735     zoomFlag = 0;
 736     vo_x11_uninit();
 737
 738     sws_freeContext(swsContext);
 739 }
 740
 741 static int preinit(const char *arg)
 742 {
 743     if (arg)
 744     {
 745         mp_msg(MSGT_VO, MSGL_ERR, "vo_x11: Unknown subdevice: %s\n", arg);
 746         return ENOSYS;
 747     }
 748
 749     if (!vo_init())
 750         return -1;              // Can't open X11
 751     return 0;
 752 }
 753
 754 static int control(uint32_t request, void *data, ...)
 755 {
 756     switch (request)
 757     {
 758         case VOCTRL_PAUSE:
 759             return (int_pause = 1);
 760         case VOCTRL_RESUME:
 761             return (int_pause = 0);
 762         case VOCTRL_QUERY_FORMAT:
 763             return query_format(*((uint32_t *) data));
 764         case VOCTRL_GUISUPPORT:
 765             return VO_TRUE;
 766         case VOCTRL_GET_IMAGE:
 767             return get_image(data);
 768         case VOCTRL_SET_EQUALIZER:
 769             {
 770                 va_list ap;
 771                 int value;
 772
 773                 va_start(ap, data);
 774                 value = va_arg(ap, int);
 775
 776                 va_end(ap);
 777                 return vo_x11_set_equalizer(data, value);
 778             }
 779         case VOCTRL_GET_EQUALIZER:
 780             {
 781                 va_list ap;
 782                 int *value;
 783
 784                 va_start(ap, data);
 785                 value = va_arg(ap, int *);
 786
 787                 va_end(ap);
 788                 return vo_x11_get_equalizer(data, value);
 789             }
 790         case VOCTRL_ONTOP:
 791             vo_x11_ontop();
 792             return VO_TRUE;
 793         case VOCTRL_FULLSCREEN:
 794             {
 795                 vo_x11_fullscreen();
 796                 vo_x11_clearwindow(mDisplay, vo_window);
 797             }
 798             return VO_TRUE;
 799     }
 800     return VO_NOTIMPL;
 801 }