libvo/vo_xv.c

   1 /* vo_xv.c, X11 Xv interface */
   2
   3 // Number of buffers _FOR_DOUBLEBUFFERING_MODE_
   4 // Use option -double to enable double buffering! (default: single buffer)
   5 #define NUM_BUFFERS 3
   6
   7 /*
   8 Buffer allocation:
   9
  10 -nodr:
  11   1: TEMP
  12   2: 2*TEMP
  13
  14 -dr:
  15   1: TEMP
  16   3: 2*STATIC+TEMP
  17 */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "config.h"
  24 #include "mp_msg.h"
  25 #include "help_mp.h"
  26 #include "video_out.h"
  27 #include "video_out_internal.h"
  28
  29
  30 #include <X11/Xlib.h>
  31 #include <X11/Xutil.h>
  32 #include <errno.h>
  33
  34 #include "x11_common.h"
  35
  36 #include "fastmemcpy.h"
  37 #include "sub.h"
  38 #include "aspect.h"
  39
  40 #include "subopt-helper.h"
  41
  42 #ifdef HAVE_NEW_GUI
  43 #include "Gui/interface.h"
  44 #endif
  45
  46 static vo_info_t info = {
  47     "X11/Xv",
  48     "xv",
  49     "Gerd Knorr <kraxel@goldbach.in-berlin.de> and others",
  50     ""
  51 };
  52
  53 LIBVO_EXTERN(xv)
  54 #ifdef HAVE_SHM
  55 #include <sys/ipc.h>
  56 #include <sys/shm.h>
  57 #include <X11/extensions/XShm.h>
  58 /* since it doesn't seem to be defined on some platforms */
  59 int XShmGetEventBase(Display *);
  60
  61 static XShmSegmentInfo Shminfo[NUM_BUFFERS];
  62 static int Shmem_Flag;
  63 #endif
  64
  65 // Note: depends on the inclusion of X11/extensions/XShm.h
  66 #include <X11/extensions/Xv.h>
  67 #include <X11/extensions/Xvlib.h>
  68
  69 // FIXME: dynamically allocate this stuff
  70 static void allocate_xvimage(int);
  71 static unsigned int ver, rel, req, ev, err;
  72 static unsigned int formats, adaptors, xv_format;
  73 static XvAdaptorInfo *ai = NULL;
  74 static XvImageFormatValues *fo=NULL;
  75
  76 static int current_buf = 0;
  77 static int current_ip_buf = 0;
  78 static int num_buffers = 1;     // default
  79 static int visible_buf = -1;    // -1 means: no buffer was drawn yet
  80 static XvImage *xvimage[NUM_BUFFERS];
  81
  82
  83 static uint32_t image_width;
  84 static uint32_t image_height;
  85 static uint32_t image_format;
  86 static int flip_flag;
  87
  88 static int int_pause;
  89
  90 static Window mRoot;
  91 static uint32_t drwX, drwY, drwBorderWidth, drwDepth;
  92 static uint32_t dwidth, dheight;
  93 static uint32_t max_width = 0, max_height = 0; // zero means: not set
  94
  95 static void (*draw_alpha_fnc) (int x0, int y0, int w, int h,
  96                                unsigned char *src, unsigned char *srca,
  97                                int stride);
  98
  99 static void draw_alpha_yv12(int x0, int y0, int w, int h,
 100                             unsigned char *src, unsigned char *srca,
 101                             int stride)
 102 {
 103     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
 104     vo_draw_alpha_yv12(w, h, src, srca, stride,
 105                        xvimage[current_buf]->data +
 106                        xvimage[current_buf]->offsets[0] +
 107                        xvimage[current_buf]->pitches[0] * y0 + x0,
 108                        xvimage[current_buf]->pitches[0]);
 109 }
 110
 111 static void draw_alpha_yuy2(int x0, int y0, int w, int h,
 112                             unsigned char *src, unsigned char *srca,
 113                             int stride)
 114 {
 115     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
 116     vo_draw_alpha_yuy2(w, h, src, srca, stride,
 117                        xvimage[current_buf]->data +
 118                        xvimage[current_buf]->offsets[0] +
 119                        xvimage[current_buf]->pitches[0] * y0 + 2 * x0,
 120                        xvimage[current_buf]->pitches[0]);
 121 }
 122
 123 static void draw_alpha_uyvy(int x0, int y0, int w, int h,
 124                             unsigned char *src, unsigned char *srca,
 125                             int stride)
 126 {
 127     x0 += image_width * (vo_panscan_x >> 1) / (vo_dwidth + vo_panscan_x);
 128     vo_draw_alpha_yuy2(w, h, src, srca, stride,
 129                        xvimage[current_buf]->data +
 130                        xvimage[current_buf]->offsets[0] +
 131                        xvimage[current_buf]->pitches[0] * y0 + 2 * x0 + 1,
 132                        xvimage[current_buf]->pitches[0]);
 133 }
 134
 135 static void draw_alpha_null(int x0, int y0, int w, int h,
 136                             unsigned char *src, unsigned char *srca,
 137                             int stride)
 138 {
 139 }
 140
 141
 142 static void deallocate_xvimage(int foo);
 143
 144 /*
 145  * connect to server, create and map window,
 146  * allocate colors and (shared) memory
 147  */
 148 static int config(uint32_t width, uint32_t height, uint32_t d_width,
 149                        uint32_t d_height, uint32_t flags, char *title,
 150                        uint32_t format)
 151 {
 152 // int screen;
 153     char *hello = (title == NULL) ? "Xv render" : title;
 154
 155 // char *name = ":0.0";
 156     XSizeHints hint;
 157     XVisualInfo vinfo;
 158     XGCValues xgcv;
 159     XSetWindowAttributes xswa;
 160     XWindowAttributes attribs;
 161     unsigned long xswamask;
 162     int depth;
 163
 164 #ifdef HAVE_XF86VM
 165     int vm = 0;
 166     unsigned int modeline_width, modeline_height;
 167     static uint32_t vm_width;
 168     static uint32_t vm_height;
 169 #endif
 170
 171     image_height = height;
 172     image_width = width;
 173     image_format = format;
 174
 175     if ((max_width != 0 && max_height != 0) &&
 176         (image_width > max_width || image_height > max_height))
 177     {
 178         mp_msg( MSGT_VO, MSGL_ERR, MSGTR_VO_XV_ImagedimTooHigh,
 179                 image_width, image_height, max_width, max_height);
 180         return -1;
 181     }
 182
 183     vo_mouse_autohide = 1;
 184
 185     int_pause = 0;
 186     visible_buf = -1;
 187
 188 #ifdef HAVE_XF86VM
 189     if (flags & VOFLAG_MODESWITCHING)
 190         vm = 1;
 191 #endif
 192     flip_flag = flags & VOFLAG_FLIPPING;
 193     num_buffers =
 194         vo_doublebuffering ? (vo_directrendering ? NUM_BUFFERS : 2) : 1;
 195
 196     /* check image formats */
 197     {
 198         unsigned int i;
 199
 200         xv_format = 0;
 201         for (i = 0; i < formats; i++)
 202         {
 203             mp_msg(MSGT_VO, MSGL_V,
 204                    "Xvideo image format: 0x%x (%4.4s) %s\n", fo[i].id,
 205                    (char *) &fo[i].id,
 206                    (fo[i].format == XvPacked) ? "packed" : "planar");
 207             if (fo[i].id == format)
 208                 xv_format = fo[i].id;
 209         }
 210         if (!xv_format)
 211             return -1;
 212     }
 213
 214 #ifdef HAVE_NEW_GUI
 215     if (use_gui)
 216         guiGetEvent(guiSetShVideo, 0);  // let the GUI to setup/resize our window
 217     else
 218 #endif
 219     {
 220         hint.x = vo_dx;
 221         hint.y = vo_dy;
 222         hint.width = d_width;
 223         hint.height = d_height;
 224 #ifdef HAVE_XF86VM
 225         if (vm)
 226         {
 227             if ((d_width == 0) && (d_height == 0))
 228             {
 229                 vm_width = image_width;
 230                 vm_height = image_height;
 231             } else
 232             {
 233                 vm_width = d_width;
 234                 vm_height = d_height;
 235             }
 236             vo_vm_switch(vm_width, vm_height, &modeline_width,
 237                          &modeline_height);
 238             hint.x = (vo_screenwidth - modeline_width) / 2;
 239             hint.y = (vo_screenheight - modeline_height) / 2;
 240             hint.width = modeline_width;
 241             hint.height = modeline_height;
 242             aspect_save_screenres(modeline_width, modeline_height);
 243         } else
 244 #endif
 245         if (vo_fs)
 246         {
 247 #ifdef X11_FULLSCREEN
 248             /* this code replaces X11_FULLSCREEN hack in mplayer.c
 249              * aspect() is available through aspect.h for all vos.
 250              * besides zooming should only be done with -zoom,
 251              * but I leave the old -fs behaviour so users don't get
 252              * irritated for now (and send lots o' mails ;) ::atmos
 253              */
 254
 255             aspect(&d_width, &d_height, A_ZOOM);
 256 #endif
 257
 258         }
 259 //   dwidth=d_width; dheight=d_height; //XXX: what are the copy vars used for?
 260         vo_dwidth = d_width;
 261         vo_dheight = d_height;
 262         hint.flags = PPosition | PSize /* | PBaseSize */ ;
 263         hint.base_width = hint.width;
 264         hint.base_height = hint.height;
 265         XGetWindowAttributes(mDisplay, DefaultRootWindow(mDisplay),
 266                              &attribs);
 267         depth = attribs.depth;
 268         if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
 269             depth = 24;
 270         XMatchVisualInfo(mDisplay, mScreen, depth, TrueColor, &vinfo);
 271
 272         xswa.background_pixel = 0;
 273         if (xv_ck_info.method == CK_METHOD_BACKGROUND)
 274         {
 275           xswa.background_pixel = xv_colorkey;
 276         }
 277         xswa.border_pixel = 0;
 278         xswamask = CWBackPixel | CWBorderPixel;
 279
 280         if (WinID >= 0)
 281         {
 282             vo_window = WinID ? ((Window) WinID) : mRootWin;
 283             if (WinID)
 284             {
 285                 XUnmapWindow(mDisplay, vo_window);
 286                 XChangeWindowAttributes(mDisplay, vo_window, xswamask,
 287                                         &xswa);
 288                 vo_x11_selectinput_witherr(mDisplay, vo_window,
 289                                            StructureNotifyMask |
 290                                            KeyPressMask |
 291                                            PropertyChangeMask |
 292                                            PointerMotionMask |
 293                                            ButtonPressMask |
 294                                            ButtonReleaseMask |
 295                                            ExposureMask);
 296                 XMapWindow(mDisplay, vo_window);
 297                 XGetGeometry(mDisplay, vo_window, &mRoot,
 298                              &drwX, &drwY, &vo_dwidth, &vo_dheight,
 299                              &drwBorderWidth, &drwDepth);
 300                 if (vo_dwidth <= 0) vo_dwidth = d_width;
 301                 if (vo_dheight <= 0) vo_dheight = d_height;
 302                 drwX = drwY = 0; // coordinates need to be local to the window
 303                 aspect_save_prescale(vo_dwidth, vo_dheight);
 304             } else
 305             {
 306                 drwX = vo_dx;
 307                 drwY = vo_dy;
 308             }
 309         } else if (vo_window == None)
 310         {
 311             vo_window =
 312                 vo_x11_create_smooth_window(mDisplay, mRootWin,
 313                                             vinfo.visual, hint.x, hint.y,
 314                                             hint.width, hint.height, depth,
 315                                             CopyFromParent);
 316             XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
 317
 318             vo_x11_classhint(mDisplay, vo_window, "xv");
 319             vo_hidecursor(mDisplay, vo_window);
 320
 321             vo_x11_selectinput_witherr(mDisplay, vo_window,
 322                                        StructureNotifyMask | KeyPressMask |
 323                                        PropertyChangeMask | ((WinID == 0) ?
 324                                                              0
 325                                                              :
 326                                                              (PointerMotionMask
 327                                                               |
 328                                                               ButtonPressMask
 329                                                               |
 330                                                               ButtonReleaseMask
 331                                                               |
 332                                                               ExposureMask)));
 333             XSetStandardProperties(mDisplay, vo_window, hello, hello, None,
 334                                    NULL, 0, &hint);
 335             vo_x11_sizehint(hint.x, hint.y, hint.width, hint.height, 0);
 336             XMapWindow(mDisplay, vo_window);
 337             vo_x11_nofs_sizepos(hint.x, hint.y, hint.width, hint.height);
 338             if (flags & VOFLAG_FULLSCREEN)
 339                 vo_x11_fullscreen();
 340         } else
 341         {
 342             // vo_fs set means we were already at fullscreen
 343             vo_x11_sizehint(hint.x, hint.y, hint.width, hint.height, 0);
 344             vo_x11_nofs_sizepos(hint.x, hint.y, hint.width, hint.height);
 345             if (flags & VOFLAG_FULLSCREEN && !vo_fs)
 346                 vo_x11_fullscreen();    // handle -fs on non-first file
 347         }
 348
 349 //    vo_x11_sizehint( hint.x, hint.y, hint.width, hint.height,0 );
 350
 351         if (vo_gc != None)
 352             XFreeGC(mDisplay, vo_gc);
 353         vo_gc = XCreateGC(mDisplay, vo_window, 0L, &xgcv);
 354         XSync(mDisplay, False);
 355 #ifdef HAVE_XF86VM
 356         if (vm)
 357         {
 358             /* Grab the mouse pointer in our window */
 359             if (vo_grabpointer)
 360                 XGrabPointer(mDisplay, vo_window, True, 0,
 361                              GrabModeAsync, GrabModeAsync,
 362                              vo_window, None, CurrentTime);
 363             XSetInputFocus(mDisplay, vo_window, RevertToNone, CurrentTime);
 364         }
 365 #endif
 366     }
 367
 368     mp_msg(MSGT_VO, MSGL_V, "using Xvideo port %d for hw scaling\n",
 369            xv_port);
 370
 371     switch (xv_format)
 372     {
 373         case IMGFMT_YV12:
 374         case IMGFMT_I420:
 375         case IMGFMT_IYUV:
 376             draw_alpha_fnc = draw_alpha_yv12;
 377             break;
 378         case IMGFMT_YUY2:
 379         case IMGFMT_YVYU:
 380             draw_alpha_fnc = draw_alpha_yuy2;
 381             break;
 382         case IMGFMT_UYVY:
 383             draw_alpha_fnc = draw_alpha_uyvy;
 384             break;
 385         default:
 386             draw_alpha_fnc = draw_alpha_null;
 387     }
 388
 389     if (vo_config_count)
 390         for (current_buf = 0; current_buf < num_buffers; ++current_buf)
 391             deallocate_xvimage(current_buf);
 392
 393     for (current_buf = 0; current_buf < num_buffers; ++current_buf)
 394         allocate_xvimage(current_buf);
 395
 396     current_buf = 0;
 397     current_ip_buf = 0;
 398
 399 #if 0
 400     set_gamma_correction();
 401 #endif
 402
 403     aspect(&vo_dwidth, &vo_dheight, A_NOZOOM);
 404     if (((flags & VOFLAG_FULLSCREEN) && (WinID <= 0)) || vo_fs)
 405     {
 406         aspect(&vo_dwidth, &vo_dheight, A_ZOOM);
 407         drwX =
 408             (vo_screenwidth -
 409              (vo_dwidth >
 410               vo_screenwidth ? vo_screenwidth : vo_dwidth)) / 2;
 411         drwY =
 412             (vo_screenheight -
 413              (vo_dheight >
 414               vo_screenheight ? vo_screenheight : vo_dheight)) / 2;
 415         vo_dwidth =
 416             (vo_dwidth > vo_screenwidth ? vo_screenwidth : vo_dwidth);
 417         vo_dheight =
 418             (vo_dheight > vo_screenheight ? vo_screenheight : vo_dheight);
 419         mp_msg(MSGT_VO, MSGL_V, "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n",
 420                drwX, drwY, vo_dwidth, vo_dheight);
 421     }
 422
 423     panscan_calc();
 424
 425     vo_xv_draw_colorkey(drwX - (vo_panscan_x >> 1),
 426                         drwY - (vo_panscan_y >> 1),
 427                         vo_dwidth + vo_panscan_x - 1,
 428                         vo_dheight + vo_panscan_y - 1);
 429
 430
 431 #if 0
 432 #ifdef HAVE_SHM
 433     if (Shmem_Flag)
 434     {
 435         XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
 436                       xvimage[current_buf], 0, 0, image_width,
 437                       image_height, drwX, drwY, 1, 1, False);
 438         XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
 439                       xvimage[current_buf], 0, 0, image_width,
 440                       image_height, drwX, drwY, vo_dwidth,
 441                       (vo_fs ? vo_dheight - 1 : vo_dheight), False);
 442     } else
 443 #endif
 444     {
 445         XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
 446                    xvimage[current_buf], 0, 0, image_width, image_height,
 447                    drwX, drwY, 1, 1);
 448         XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
 449                    xvimage[current_buf], 0, 0, image_width, image_height,
 450                    drwX, drwY, vo_dwidth,
 451                    (vo_fs ? vo_dheight - 1 : vo_dheight));
 452     }
 453 #endif
 454
 455     mp_msg(MSGT_VO, MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n", drwX,
 456            drwY, vo_dwidth, vo_dheight);
 457
 458     if (vo_ontop)
 459         vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
 460
 461     return 0;
 462 }
 463
 464 static void allocate_xvimage(int foo)
 465 {
 466     /*
 467      * allocate XvImages.  FIXME: no error checking, without
 468      * mit-shm this will bomb... trzing to fix ::atmos
 469      */
 470 #ifdef HAVE_SHM
 471     if (mLocalDisplay && XShmQueryExtension(mDisplay))
 472         Shmem_Flag = 1;
 473     else
 474     {
 475         Shmem_Flag = 0;
 476         mp_msg(MSGT_VO, MSGL_INFO,
 477                MSGTR_LIBVO_XV_SharedMemoryNotSupported);
 478     }
 479     if (Shmem_Flag)
 480     {
 481         xvimage[foo] =
 482             (XvImage *) XvShmCreateImage(mDisplay, xv_port, xv_format,
 483                                          NULL, image_width, image_height,
 484                                          &Shminfo[foo]);
 485
 486         Shminfo[foo].shmid =
 487             shmget(IPC_PRIVATE, xvimage[foo]->data_size, IPC_CREAT | 0777);
 488         Shminfo[foo].shmaddr = (char *) shmat(Shminfo[foo].shmid, 0, 0);
 489         Shminfo[foo].readOnly = False;
 490
 491         xvimage[foo]->data = Shminfo[foo].shmaddr;
 492         XShmAttach(mDisplay, &Shminfo[foo]);
 493         XSync(mDisplay, False);
 494         shmctl(Shminfo[foo].shmid, IPC_RMID, 0);
 495     } else
 496 #endif
 497     {
 498         xvimage[foo] =
 499             (XvImage *) XvCreateImage(mDisplay, xv_port, xv_format, NULL,
 500                                       image_width, image_height);
 501         xvimage[foo]->data = malloc(xvimage[foo]->data_size);
 502         XSync(mDisplay, False);
 503     }
 504     memset(xvimage[foo]->data, 128, xvimage[foo]->data_size);
 505     return;
 506 }
 507
 508 static void deallocate_xvimage(int foo)
 509 {
 510 #ifdef HAVE_SHM
 511     if (Shmem_Flag)
 512     {
 513         XShmDetach(mDisplay, &Shminfo[foo]);
 514         shmdt(Shminfo[foo].shmaddr);
 515     } else
 516 #endif
 517     {
 518         free(xvimage[foo]->data);
 519     }
 520     XFree(xvimage[foo]);
 521
 522     XSync(mDisplay, False);
 523     return;
 524 }
 525
 526 static inline void put_xvimage( XvImage * xvi )
 527 {
 528 #ifdef HAVE_SHM
 529     if (Shmem_Flag)
 530     {
 531         XvShmPutImage(mDisplay, xv_port, vo_window, vo_gc,
 532                       xvi, 0, 0, image_width,
 533                       image_height, drwX - (vo_panscan_x >> 1),
 534                       drwY - (vo_panscan_y >> 1), vo_dwidth + vo_panscan_x,
 535                       vo_dheight + vo_panscan_y,
 536                       False);
 537     } else
 538 #endif
 539     {
 540         XvPutImage(mDisplay, xv_port, vo_window, vo_gc,
 541                    xvi, 0, 0, image_width, image_height,
 542                    drwX - (vo_panscan_x >> 1), drwY - (vo_panscan_y >> 1),
 543                    vo_dwidth + vo_panscan_x,
 544                    vo_dheight + vo_panscan_y);
 545     }
 546 }
 547
 548 static void check_events(void)
 549 {
 550     int e = vo_x11_check_events(mDisplay);
 551
 552     if (e & VO_EVENT_RESIZE)
 553     {
 554         XGetGeometry(mDisplay, vo_window, &mRoot, &drwX, &drwY, &vo_dwidth,
 555                      &vo_dheight, &drwBorderWidth, &drwDepth);
 556         drwX = drwY = 0;
 557         mp_msg(MSGT_VO, MSGL_V, "[xv] dx: %d dy: %d dw: %d dh: %d\n", drwX,
 558                drwY, vo_dwidth, vo_dheight);
 559
 560         aspect(&dwidth, &dheight, A_NOZOOM);
 561         if (vo_fs)
 562         {
 563             aspect(&dwidth, &dheight, A_ZOOM);
 564             drwX =
 565                 (vo_screenwidth -
 566                  (dwidth > vo_screenwidth ? vo_screenwidth : dwidth)) / 2;
 567             drwY =
 568                 (vo_screenheight -
 569                  (dheight >
 570                   vo_screenheight ? vo_screenheight : dheight)) / 2;
 571             vo_dwidth =
 572                 (dwidth > vo_screenwidth ? vo_screenwidth : dwidth);
 573             vo_dheight =
 574                 (dheight > vo_screenheight ? vo_screenheight : dheight);
 575             mp_msg(MSGT_VO, MSGL_V,
 576                    "[xv-fs] dx: %d dy: %d dw: %d dh: %d\n", drwX, drwY,
 577                    vo_dwidth, vo_dheight);
 578         }
 579     }
 580
 581     if (e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE)
 582     {
 583         vo_xv_draw_colorkey(drwX - (vo_panscan_x >> 1),
 584                             drwY - (vo_panscan_y >> 1),
 585                             vo_dwidth + vo_panscan_x - 1,
 586                             vo_dheight + vo_panscan_y - 1);
 587     }
 588
 589     if ((e & VO_EVENT_EXPOSE || e & VO_EVENT_RESIZE) && int_pause)
 590     {
 591         /* did we already draw a buffer */
 592         if ( visible_buf != -1 )
 593         {
 594           /* redraw the last visible buffer */
 595           put_xvimage( xvimage[visible_buf] );
 596         }
 597     }
 598 }
 599
 600 static void draw_osd(void)
 601 {
 602     vo_draw_text(image_width -
 603                  image_width * vo_panscan_x / (vo_dwidth + vo_panscan_x),
 604                  image_height, draw_alpha_fnc);
 605 }
 606
 607 static void flip_page(void)
 608 {
 609     put_xvimage( xvimage[current_buf] );
 610
 611     /* remember the currently visible buffer */
 612     visible_buf = current_buf;
 613
 614     if (num_buffers > 1)
 615     {
 616         current_buf =
 617             vo_directrendering ? 0 : ((current_buf + 1) % num_buffers);
 618         XFlush(mDisplay);
 619     } else
 620         XSync(mDisplay, False);
 621     return;
 622 }
 623
 624 static int draw_slice(uint8_t * image[], int stride[], int w, int h,
 625                            int x, int y)
 626 {
 627     uint8_t *dst;
 628
 629     dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[0] +
 630         xvimage[current_buf]->pitches[0] * y + x;
 631     memcpy_pic(dst, image[0], w, h, xvimage[current_buf]->pitches[0],
 632                stride[0]);
 633
 634     x /= 2;
 635     y /= 2;
 636     w /= 2;
 637     h /= 2;
 638
 639     dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[1] +
 640         xvimage[current_buf]->pitches[1] * y + x;
 641     if (image_format != IMGFMT_YV12)
 642         memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
 643                    stride[1]);
 644     else
 645         memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
 646                    stride[2]);
 647
 648     dst = xvimage[current_buf]->data + xvimage[current_buf]->offsets[2] +
 649         xvimage[current_buf]->pitches[2] * y + x;
 650     if (image_format == IMGFMT_YV12)
 651         memcpy_pic(dst, image[1], w, h, xvimage[current_buf]->pitches[1],
 652                    stride[1]);
 653     else
 654         memcpy_pic(dst, image[2], w, h, xvimage[current_buf]->pitches[1],
 655                    stride[2]);
 656
 657     return 0;
 658 }
 659
 660 static int draw_frame(uint8_t * src[])
 661 {
 662     mp_msg(MSGT_VO,MSGL_INFO, MSGTR_LIBVO_XV_DrawFrameCalled);
 663     return -1;
 664 }
 665
 666 static uint32_t draw_image(mp_image_t * mpi)
 667 {
 668     if (mpi->flags & MP_IMGFLAG_DIRECT)
 669     {
 670         // direct rendering:
 671         current_buf = (int) (mpi->priv);        // hack!
 672         return VO_TRUE;
 673     }
 674     if (mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)
 675         return VO_TRUE;         // done
 676     if (mpi->flags & MP_IMGFLAG_PLANAR)
 677     {
 678         draw_slice(mpi->planes, mpi->stride, mpi->w, mpi->h, 0, 0);
 679         return VO_TRUE;
 680     }
 681     if (mpi->flags & MP_IMGFLAG_YUV)
 682     {
 683         // packed YUV:
 684         memcpy_pic(xvimage[current_buf]->data +
 685                    xvimage[current_buf]->offsets[0], mpi->planes[0],
 686                    mpi->w * (mpi->bpp / 8), mpi->h,
 687                    xvimage[current_buf]->pitches[0], mpi->stride[0]);
 688         return VO_TRUE;
 689     }
 690     return VO_FALSE;            // not (yet) supported
 691 }
 692
 693 static uint32_t get_image(mp_image_t * mpi)
 694 {
 695     int buf = current_buf;      // we shouldn't change current_buf unless we do DR!
 696
 697     if (mpi->type == MP_IMGTYPE_STATIC && num_buffers > 1)
 698         return VO_FALSE;        // it is not static
 699     if (mpi->imgfmt != image_format)
 700         return VO_FALSE;        // needs conversion :(
 701 //    if(mpi->flags&MP_IMGFLAG_READABLE) return VO_FALSE; // slow video ram
 702     if (mpi->flags & MP_IMGFLAG_READABLE &&
 703         (mpi->type == MP_IMGTYPE_IPB || mpi->type == MP_IMGTYPE_IP))
 704     {
 705         // reference (I/P) frame of IP or IPB:
 706         if (num_buffers < 2)
 707             return VO_FALSE;    // not enough
 708         current_ip_buf ^= 1;
 709         // for IPB with 2 buffers we can DR only one of the 2 P frames:
 710         if (mpi->type == MP_IMGTYPE_IPB && num_buffers < 3
 711             && current_ip_buf)
 712             return VO_FALSE;
 713         buf = current_ip_buf;
 714         if (mpi->type == MP_IMGTYPE_IPB)
 715             ++buf;              // preserve space for B
 716     }
 717     if (mpi->height > xvimage[buf]->height)
 718         return VO_FALSE;        //buffer to small
 719     if (mpi->width * (mpi->bpp / 8) > xvimage[buf]->pitches[0])
 720         return VO_FALSE;        //buffer to small
 721     if ((mpi->flags & (MP_IMGFLAG_ACCEPT_STRIDE | MP_IMGFLAG_ACCEPT_WIDTH))
 722         || (mpi->width * (mpi->bpp / 8) == xvimage[buf]->pitches[0]))
 723     {
 724         current_buf = buf;
 725         mpi->planes[0] =
 726             xvimage[current_buf]->data + xvimage[current_buf]->offsets[0];
 727         mpi->stride[0] = xvimage[current_buf]->pitches[0];
 728         mpi->width = mpi->stride[0] / (mpi->bpp / 8);
 729         if (mpi->flags & MP_IMGFLAG_PLANAR)
 730         {
 731             if (mpi->flags & MP_IMGFLAG_SWAPPED)
 732             {
 733                 // I420
 734                 mpi->planes[1] =
 735                     xvimage[current_buf]->data +
 736                     xvimage[current_buf]->offsets[1];
 737                 mpi->planes[2] =
 738                     xvimage[current_buf]->data +
 739                     xvimage[current_buf]->offsets[2];
 740                 mpi->stride[1] = xvimage[current_buf]->pitches[1];
 741                 mpi->stride[2] = xvimage[current_buf]->pitches[2];
 742             } else
 743             {
 744                 // YV12
 745                 mpi->planes[1] =
 746                     xvimage[current_buf]->data +
 747                     xvimage[current_buf]->offsets[2];
 748                 mpi->planes[2] =
 749                     xvimage[current_buf]->data +
 750                     xvimage[current_buf]->offsets[1];
 751                 mpi->stride[1] = xvimage[current_buf]->pitches[2];
 752                 mpi->stride[2] = xvimage[current_buf]->pitches[1];
 753             }
 754         }
 755         mpi->flags |= MP_IMGFLAG_DIRECT;
 756         mpi->priv = (void *) current_buf;
 757 //      printf("mga: get_image() SUCCESS -> Direct Rendering ENABLED\n");
 758         return VO_TRUE;
 759     }
 760     return VO_FALSE;
 761 }
 762
 763 static int query_format(uint32_t format)
 764 {
 765     uint32_t i;
 766     int flag = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_HWSCALE_UP | VFCAP_HWSCALE_DOWN | VFCAP_OSD | VFCAP_ACCEPT_STRIDE;       // FIXME! check for DOWN
 767
 768     /* check image formats */
 769     for (i = 0; i < formats; i++)
 770     {
 771         if (fo[i].id == format)
 772             return flag;        //xv_format = fo[i].id;
 773     }
 774     return 0;
 775 }
 776
 777 static void uninit(void)
 778 {
 779     int i;
 780
 781     if (!vo_config_count)
 782         return;
 783     visible_buf = -1;
 784     XvFreeAdaptorInfo(ai);
 785     ai = NULL;
 786     if(fo){
 787         XFree(fo);
 788         fo=NULL;
 789     }
 790     for (i = 0; i < num_buffers; i++)
 791         deallocate_xvimage(i);
 792 #ifdef HAVE_XF86VM
 793     vo_vm_close(mDisplay);
 794 #endif
 795     vo_x11_uninit();
 796 }
 797
 798 static int preinit(const char *arg)
 799 {
 800     XvPortID xv_p;
 801     int busy_ports = 0;
 802     unsigned int i;
 803     strarg_t ck_src_arg = { 0, NULL };
 804     strarg_t ck_method_arg = { 0, NULL };
 805
 806     opt_t subopts[] =
 807     {
 808       /* name         arg type     arg var         test */
 809       {  "port",      OPT_ARG_INT, &xv_port,       (opt_test_f)int_pos },
 810       {  "ck",        OPT_ARG_STR, &ck_src_arg,    xv_test_ck },
 811       {  "ck-method", OPT_ARG_STR, &ck_method_arg, xv_test_ckm },
 812       {  NULL }
 813     };
 814
 815     xv_port = 0;
 816
 817     /* parse suboptions */
 818     if ( subopt_parse( arg, subopts ) != 0 )
 819     {
 820       return -1;
 821     }
 822
 823     /* modify colorkey settings according to the given options */
 824     xv_setup_colorkeyhandling( ck_method_arg.str, ck_src_arg.str );
 825
 826     if (!vo_init())
 827         return -1;
 828
 829     /* check for Xvideo extension */
 830     if (Success != XvQueryExtension(mDisplay, &ver, &rel, &req, &ev, &err))
 831     {
 832         mp_msg(MSGT_VO, MSGL_ERR,
 833                MSGTR_LIBVO_XV_XvNotSupportedByX11);
 834         return -1;
 835     }
 836
 837     /* check for Xvideo support */
 838     if (Success !=
 839         XvQueryAdaptors(mDisplay, DefaultRootWindow(mDisplay), &adaptors,
 840                         &ai))
 841     {
 842         mp_msg(MSGT_VO, MSGL_ERR, MSGTR_LIBVO_XV_XvQueryAdaptorsFailed);
 843         return -1;
 844     }
 845
 846     /* check adaptors */
 847     if (xv_port)
 848     {
 849         int port_found;
 850
 851         for (port_found = 0, i = 0; !port_found && i < adaptors; i++)
 852         {
 853             if ((ai[i].type & XvInputMask) && (ai[i].type & XvImageMask))
 854             {
 855                 for (xv_p = ai[i].base_id;
 856                      xv_p < ai[i].base_id + ai[i].num_ports; ++xv_p)
 857                 {
 858                     if (xv_p == xv_port)
 859                     {
 860                         port_found = 1;
 861                         break;
 862                     }
 863                 }
 864             }
 865         }
 866         if (port_found)
 867         {
 868             if (XvGrabPort(mDisplay, xv_port, CurrentTime))
 869                 xv_port = 0;
 870         } else
 871         {
 872             mp_msg(MSGT_VO, MSGL_WARN,
 873                    MSGTR_LIBVO_XV_InvalidPortParameter);
 874             xv_port = 0;
 875         }
 876     }
 877
 878     for (i = 0; i < adaptors && xv_port == 0; i++)
 879     {
 880         if ((ai[i].type & XvInputMask) && (ai[i].type & XvImageMask))
 881         {
 882             for (xv_p = ai[i].base_id;
 883                  xv_p < ai[i].base_id + ai[i].num_ports; ++xv_p)
 884                 if (!XvGrabPort(mDisplay, xv_p, CurrentTime))
 885                 {
 886                     xv_port = xv_p;
 887                     break;
 888                 } else
 889                 {
 890                     mp_msg(MSGT_VO, MSGL_WARN,
 891                            MSGTR_LIBVO_XV_CouldNotGrabPort, (int) xv_p);
 892                     ++busy_ports;
 893                 }
 894         }
 895     }
 896     if (!xv_port)
 897     {
 898         if (busy_ports)
 899             mp_msg(MSGT_VO, MSGL_ERR,
 900                    MSGTR_LIBVO_XV_CouldNotFindFreePort);
 901         else
 902             mp_msg(MSGT_VO, MSGL_ERR,
 903                    MSGTR_LIBVO_XV_NoXvideoSupport);
 904         return -1;
 905     }
 906
 907     if ( !vo_xv_init_colorkey() )
 908     {
 909       return -1; // bail out, colorkey setup failed
 910     }
 911     vo_xv_enable_vsync();
 912     vo_xv_get_max_img_dim( &max_width, &max_height );
 913
 914     fo = XvListImageFormats(mDisplay, xv_port, (int *) &formats);
 915
 916     return 0;
 917 }
 918
 919 static int control(uint32_t request, void *data, ...)
 920 {
 921     switch (request)
 922     {
 923         case VOCTRL_PAUSE:
 924             return (int_pause = 1);
 925         case VOCTRL_RESUME:
 926             return (int_pause = 0);
 927         case VOCTRL_QUERY_FORMAT:
 928             return query_format(*((uint32_t *) data));
 929         case VOCTRL_GET_IMAGE:
 930             return get_image(data);
 931         case VOCTRL_DRAW_IMAGE:
 932             return draw_image(data);
 933         case VOCTRL_GUISUPPORT:
 934             return VO_TRUE;
 935         case VOCTRL_GET_PANSCAN:
 936             if (!vo_config_count || !vo_fs)
 937                 return VO_FALSE;
 938             return VO_TRUE;
 939         case VOCTRL_FULLSCREEN:
 940             vo_x11_fullscreen();
 941             /* indended, fallthrough to update panscan on fullscreen/windowed switch */
 942         case VOCTRL_SET_PANSCAN:
 943             if ((vo_fs && (vo_panscan != vo_panscan_amount))
 944                 || (!vo_fs && vo_panscan_amount))
 945             {
 946                 int old_y = vo_panscan_y;
 947
 948                 panscan_calc();
 949
 950                 if (old_y != vo_panscan_y)
 951                 {
 952                     vo_x11_clearwindow_part(mDisplay, vo_window,
 953                                             vo_dwidth + vo_panscan_x - 1,
 954                                             vo_dheight + vo_panscan_y - 1,
 955                                             1);
 956                     vo_xv_draw_colorkey(drwX - (vo_panscan_x >> 1),
 957                                         drwY - (vo_panscan_y >> 1),
 958                                         vo_dwidth + vo_panscan_x - 1,
 959                                         vo_dheight + vo_panscan_y - 1);
 960                     flip_page();
 961                 }
 962             }
 963             return VO_TRUE;
 964         case VOCTRL_SET_EQUALIZER:
 965             {
 966                 va_list ap;
 967                 int value;
 968
 969                 va_start(ap, data);
 970                 value = va_arg(ap, int);
 971
 972                 va_end(ap);
 973
 974                 return (vo_xv_set_eq(xv_port, data, value));
 975             }
 976         case VOCTRL_GET_EQUALIZER:
 977             {
 978                 va_list ap;
 979                 int *value;
 980
 981                 va_start(ap, data);
 982                 value = va_arg(ap, int *);
 983
 984                 va_end(ap);
 985
 986                 return (vo_xv_get_eq(xv_port, data, value));
 987             }
 988         case VOCTRL_ONTOP:
 989             vo_x11_ontop();
 990             return VO_TRUE;
 991         case VOCTRL_UPDATE_SCREENINFO:
 992             update_xinerama_info();
 993             return VO_TRUE;
 994     }
 995     return VO_NOTIMPL;
 996 }