libvo/x11_common.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 <math.h>
  22 #include <inttypes.h>
  23 #include <limits.h>
  24
  25 #include "config.h"
  26 #include "mp_msg.h"
  27 #include "mp_fifo.h"
  28 #include "libavutil/common.h"
  29 #include "x11_common.h"
  30
  31 #ifdef X11_FULLSCREEN
  32
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <assert.h>
  36
  37 #include "video_out.h"
  38 #include "aspect.h"
  39 #include "geometry.h"
  40 #include "help_mp.h"
  41 #include "osdep/timer.h"
  42
  43 #include <X11/Xmd.h>
  44 #include <X11/Xlib.h>
  45 #include <X11/Xutil.h>
  46 #include <X11/Xatom.h>
  47
  48 #ifdef CONFIG_XSS
  49 #include <X11/extensions/scrnsaver.h>
  50 #endif
  51
  52 #ifdef CONFIG_XDPMS
  53 #include <X11/extensions/dpms.h>
  54 #endif
  55
  56 #ifdef CONFIG_XINERAMA
  57 #include <X11/extensions/Xinerama.h>
  58 #endif
  59
  60 #ifdef CONFIG_XF86VM
  61 #include <X11/extensions/xf86vmode.h>
  62 #endif
  63
  64 #ifdef CONFIG_XF86XK
  65 #include <X11/XF86keysym.h>
  66 #endif
  67
  68 #ifdef CONFIG_XV
  69 #include <X11/extensions/Xv.h>
  70 #include <X11/extensions/Xvlib.h>
  71
  72 #include "subopt-helper.h"
  73 #endif
  74
  75 #include "input/input.h"
  76 #include "input/mouse.h"
  77
  78 #ifdef CONFIG_GUI
  79 #include "gui/interface.h"
  80 #include "mplayer.h"
  81 #endif
  82
  83 #define WIN_LAYER_ONBOTTOM               2
  84 #define WIN_LAYER_NORMAL                 4
  85 #define WIN_LAYER_ONTOP                  6
  86 #define WIN_LAYER_ABOVE_DOCK             10
  87
  88 extern int enable_mouse_movements;
  89 int fs_layer = WIN_LAYER_ABOVE_DOCK;
  90 static int orig_layer = 0;
  91 static int old_gravity = NorthWestGravity;
  92
  93 int stop_xscreensaver = 0;
  94
  95 static int dpms_disabled = 0;
  96
  97 char *mDisplayName = NULL;
  98 Display *mDisplay = NULL;
  99 Window mRootWin;
 100 int mScreen;
 101 int mLocalDisplay;
 102
 103 /* output window id */
 104 int vo_mouse_autohide = 0;
 105 int vo_wm_type = 0;
 106 int vo_fs_type = 0; // needs to be accessible for GUI X11 code
 107 static int vo_fs_flip = 0;
 108 char **vo_fstype_list;
 109
 110 /* 1 means that the WM is metacity (broken as hell) */
 111 int metacity_hack = 0;
 112
 113 static Atom XA_NET_SUPPORTED;
 114 static Atom XA_NET_WM_STATE;
 115 static Atom XA_NET_WM_STATE_FULLSCREEN;
 116 static Atom XA_NET_WM_STATE_ABOVE;
 117 static Atom XA_NET_WM_STATE_STAYS_ON_TOP;
 118 static Atom XA_NET_WM_STATE_BELOW;
 119 static Atom XA_NET_WM_PID;
 120 static Atom XA_WIN_PROTOCOLS;
 121 static Atom XA_WIN_LAYER;
 122 static Atom XA_WIN_HINTS;
 123 static Atom XAWM_PROTOCOLS;
 124 static Atom XAWM_DELETE_WINDOW;
 125
 126 #define XA_INIT(x) XA##x = XInternAtom(mDisplay, #x, False)
 127
 128 static int vo_old_x = 0;
 129 static int vo_old_y = 0;
 130 static int vo_old_width = 0;
 131 static int vo_old_height = 0;
 132
 133 #ifdef CONFIG_XF86VM
 134 XF86VidModeModeInfo **vidmodes = NULL;
 135 XF86VidModeModeLine modeline;
 136 #endif
 137
 138 static int vo_x11_get_fs_type(int supported);
 139
 140
 141 /*
 142  * Sends the EWMH fullscreen state event.
 143  *
 144  * action: could be one of _NET_WM_STATE_REMOVE -- remove state
 145  *                         _NET_WM_STATE_ADD    -- add state
 146  *                         _NET_WM_STATE_TOGGLE -- toggle
 147  */
 148 void vo_x11_ewmh_fullscreen(int action)
 149 {
 150     assert(action == _NET_WM_STATE_REMOVE ||
 151            action == _NET_WM_STATE_ADD || action == _NET_WM_STATE_TOGGLE);
 152
 153     if (vo_fs_type & vo_wm_FULLSCREEN)
 154     {
 155         XEvent xev;
 156
 157         /* init X event structure for _NET_WM_FULLSCREEN client message */
 158         xev.xclient.type = ClientMessage;
 159         xev.xclient.serial = 0;
 160         xev.xclient.send_event = True;
 161         xev.xclient.message_type = XA_NET_WM_STATE;
 162         xev.xclient.window = vo_window;
 163         xev.xclient.format = 32;
 164         xev.xclient.data.l[0] = action;
 165         xev.xclient.data.l[1] = XA_NET_WM_STATE_FULLSCREEN;
 166         xev.xclient.data.l[2] = 0;
 167         xev.xclient.data.l[3] = 0;
 168         xev.xclient.data.l[4] = 0;
 169
 170         /* finally send that damn thing */
 171         if (!XSendEvent(mDisplay, DefaultRootWindow(mDisplay), False,
 172                         SubstructureRedirectMask | SubstructureNotifyMask,
 173                         &xev))
 174         {
 175             mp_msg(MSGT_VO, MSGL_ERR, MSGTR_EwmhFullscreenStateFailed);
 176         }
 177     }
 178 }
 179
 180 void vo_hidecursor(Display * disp, Window win)
 181 {
 182     Cursor no_ptr;
 183     Pixmap bm_no;
 184     XColor black, dummy;
 185     Colormap colormap;
 186     static char bm_no_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
 187
 188     if (WinID == 0)
 189         return;                 // do not hide if playing on the root window
 190
 191     colormap = DefaultColormap(disp, DefaultScreen(disp));
 192     if ( !XAllocNamedColor(disp, colormap, "black", &black, &dummy) )
 193     {
 194       return; // color alloc failed, give up
 195     }
 196     bm_no = XCreateBitmapFromData(disp, win, bm_no_data, 8, 8);
 197     no_ptr = XCreatePixmapCursor(disp, bm_no, bm_no, &black, &black, 0, 0);
 198     XDefineCursor(disp, win, no_ptr);
 199     XFreeCursor(disp, no_ptr);
 200     if (bm_no != None)
 201         XFreePixmap(disp, bm_no);
 202     XFreeColors(disp,colormap,&black.pixel,1,0);
 203 }
 204
 205 void vo_showcursor(Display * disp, Window win)
 206 {
 207     if (WinID == 0)
 208         return;
 209     XDefineCursor(disp, win, 0);
 210 }
 211
 212 static int x11_errorhandler(Display * display, XErrorEvent * event)
 213 {
 214 #define MSGLEN 60
 215     char msg[MSGLEN];
 216
 217     XGetErrorText(display, event->error_code, (char *) &msg, MSGLEN);
 218
 219     mp_msg(MSGT_VO, MSGL_ERR, "X11 error: %s\n", msg);
 220
 221     mp_msg(MSGT_VO, MSGL_V,
 222            "Type: %x, display: %p, resourceid: %lx, serial: %lx\n",
 223            event->type, event->display, event->resourceid, event->serial);
 224     mp_msg(MSGT_VO, MSGL_V,
 225            "Error code: %x, request code: %x, minor code: %x\n",
 226            event->error_code, event->request_code, event->minor_code);
 227
 228 //    abort();
 229     //exit_player("X11 error");
 230     return 0;
 231 #undef MSGLEN
 232 }
 233
 234 void fstype_help(void)
 235 {
 236     mp_msg(MSGT_VO, MSGL_INFO, MSGTR_AvailableFsType);
 237     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_FULL_SCREEN_TYPES\n");
 238
 239     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "none",
 240            "don't set fullscreen window layer");
 241     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "layer",
 242            "use _WIN_LAYER hint with default layer");
 243     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "layer=<0..15>",
 244            "use _WIN_LAYER hint with a given layer number");
 245     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "netwm",
 246            "force NETWM style");
 247     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "above",
 248            "use _NETWM_STATE_ABOVE hint if available");
 249     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "below",
 250            "use _NETWM_STATE_BELOW hint if available");
 251     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "fullscreen",
 252            "use _NETWM_STATE_FULLSCREEN hint if availale");
 253     mp_msg(MSGT_VO, MSGL_INFO, "    %-15s %s\n", "stays_on_top",
 254            "use _NETWM_STATE_STAYS_ON_TOP hint if available");
 255     mp_msg(MSGT_VO, MSGL_INFO,
 256            "You can also negate the settings with simply putting '-' in the beginning");
 257     mp_msg(MSGT_VO, MSGL_INFO, "\n");
 258 }
 259
 260 static void fstype_dump(int fstype)
 261 {
 262     if (fstype)
 263     {
 264         mp_msg(MSGT_VO, MSGL_V, "[x11] Current fstype setting honours");
 265         if (fstype & vo_wm_LAYER)
 266             mp_msg(MSGT_VO, MSGL_V, " LAYER");
 267         if (fstype & vo_wm_FULLSCREEN)
 268             mp_msg(MSGT_VO, MSGL_V, " FULLSCREEN");
 269         if (fstype & vo_wm_STAYS_ON_TOP)
 270             mp_msg(MSGT_VO, MSGL_V, " STAYS_ON_TOP");
 271         if (fstype & vo_wm_ABOVE)
 272             mp_msg(MSGT_VO, MSGL_V, " ABOVE");
 273         if (fstype & vo_wm_BELOW)
 274             mp_msg(MSGT_VO, MSGL_V, " BELOW");
 275         mp_msg(MSGT_VO, MSGL_V, " X atoms\n");
 276     } else
 277         mp_msg(MSGT_VO, MSGL_V,
 278                "[x11] Current fstype setting doesn't honour any X atoms\n");
 279 }
 280
 281 static int net_wm_support_state_test(Atom atom)
 282 {
 283 #define NET_WM_STATE_TEST(x) { if (atom == XA_NET_WM_STATE_##x) { mp_msg( MSGT_VO,MSGL_V, "[x11] Detected wm supports " #x " state.\n" ); return vo_wm_##x; } }
 284
 285     NET_WM_STATE_TEST(FULLSCREEN);
 286     NET_WM_STATE_TEST(ABOVE);
 287     NET_WM_STATE_TEST(STAYS_ON_TOP);
 288     NET_WM_STATE_TEST(BELOW);
 289     return 0;
 290 }
 291
 292 static int x11_get_property(Atom type, Atom ** args, unsigned long *nitems)
 293 {
 294     int format;
 295     unsigned long bytesafter;
 296
 297     return  Success ==
 298             XGetWindowProperty(mDisplay, mRootWin, type, 0, 16384, False,
 299                                AnyPropertyType, &type, &format, nitems,
 300                                &bytesafter, (unsigned char **) args)
 301             && *nitems > 0;
 302 }
 303
 304 static int vo_wm_detect(void)
 305 {
 306     int i;
 307     int wm = 0;
 308     unsigned long nitems;
 309     Atom *args = NULL;
 310
 311     if (WinID >= 0)
 312         return 0;
 313
 314 // -- supports layers
 315     if (x11_get_property(XA_WIN_PROTOCOLS, &args, &nitems))
 316     {
 317         mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports layers.\n");
 318         for (i = 0; i < nitems; i++)
 319         {
 320             if (args[i] == XA_WIN_LAYER)
 321             {
 322                 wm |= vo_wm_LAYER;
 323                 metacity_hack |= 1;
 324             } else
 325                 /* metacity is the only window manager I know which reports
 326                  * supporting only the _WIN_LAYER hint in _WIN_PROTOCOLS.
 327                  * (what's more support for it is broken) */
 328                 metacity_hack |= 2;
 329         }
 330         XFree(args);
 331         if (wm && (metacity_hack == 1))
 332         {
 333             // metacity claims to support layers, but it is not the truth :-)
 334             wm ^= vo_wm_LAYER;
 335             mp_msg(MSGT_VO, MSGL_V,
 336                    "[x11] Using workaround for Metacity bugs.\n");
 337         }
 338     }
 339 // --- netwm
 340     if (x11_get_property(XA_NET_SUPPORTED, &args, &nitems))
 341     {
 342         mp_msg(MSGT_VO, MSGL_V, "[x11] Detected wm supports NetWM.\n");
 343         for (i = 0; i < nitems; i++)
 344             wm |= net_wm_support_state_test(args[i]);
 345         XFree(args);
 346     }
 347
 348     if (wm == 0)
 349         mp_msg(MSGT_VO, MSGL_V, "[x11] Unknown wm type...\n");
 350     return wm;
 351 }
 352
 353 static void init_atoms(void)
 354 {
 355     XA_INIT(_NET_SUPPORTED);
 356     XA_INIT(_NET_WM_STATE);
 357     XA_INIT(_NET_WM_STATE_FULLSCREEN);
 358     XA_INIT(_NET_WM_STATE_ABOVE);
 359     XA_INIT(_NET_WM_STATE_STAYS_ON_TOP);
 360     XA_INIT(_NET_WM_STATE_BELOW);
 361     XA_INIT(_NET_WM_PID);
 362     XA_INIT(_WIN_PROTOCOLS);
 363     XA_INIT(_WIN_LAYER);
 364     XA_INIT(_WIN_HINTS);
 365     XA_INIT(WM_PROTOCOLS);
 366     XA_INIT(WM_DELETE_WINDOW);
 367 }
 368
 369 void update_xinerama_info(void) {
 370     int screen = xinerama_screen;
 371     xinerama_x = xinerama_y = 0;
 372 #ifdef CONFIG_XINERAMA
 373     if (screen >= -1 && XineramaIsActive(mDisplay))
 374     {
 375         XineramaScreenInfo *screens;
 376         int num_screens;
 377
 378         screens = XineramaQueryScreens(mDisplay, &num_screens);
 379         if (screen >= num_screens)
 380             screen = num_screens - 1;
 381         if (screen == -1) {
 382             int x = vo_dx + vo_dwidth / 2;
 383             int y = vo_dy + vo_dheight / 2;
 384             for (screen = num_screens - 1; screen > 0; screen--) {
 385                int left = screens[screen].x_org;
 386                int right = left + screens[screen].width;
 387                int top = screens[screen].y_org;
 388                int bottom = top + screens[screen].height;
 389                if (left <= x && x <= right && top <= y && y <= bottom)
 390                    break;
 391             }
 392         }
 393         if (screen < 0)
 394             screen = 0;
 395         vo_screenwidth = screens[screen].width;
 396         vo_screenheight = screens[screen].height;
 397         xinerama_x = screens[screen].x_org;
 398         xinerama_y = screens[screen].y_org;
 399
 400         XFree(screens);
 401     }
 402 #endif
 403     aspect_save_screenres(vo_screenwidth, vo_screenheight);
 404 }
 405
 406 int vo_init(void)
 407 {
 408 // int       mScreen;
 409     int depth, bpp;
 410     unsigned int mask;
 411
 412 // char    * DisplayName = ":0.0";
 413 // Display * mDisplay;
 414     XImage *mXImage = NULL;
 415
 416 // Window    mRootWin;
 417     XWindowAttributes attribs;
 418     char *dispName;
 419
 420         if (vo_rootwin)
 421                 WinID = 0; // use root window
 422
 423     if (vo_depthonscreen)
 424     {
 425         saver_off(mDisplay);
 426         return 1;               // already called
 427     }
 428
 429     XSetErrorHandler(x11_errorhandler);
 430
 431 #if 0
 432     if (!mDisplayName)
 433         if (!(mDisplayName = getenv("DISPLAY")))
 434             mDisplayName = strdup(":0.0");
 435 #else
 436     dispName = XDisplayName(mDisplayName);
 437 #endif
 438
 439     mp_msg(MSGT_VO, MSGL_V, "X11 opening display: %s\n", dispName);
 440
 441     mDisplay = XOpenDisplay(dispName);
 442     if (!mDisplay)
 443     {
 444         mp_msg(MSGT_VO, MSGL_ERR,
 445                "vo: couldn't open the X11 display (%s)!\n", dispName);
 446         return 0;
 447     }
 448     mScreen = DefaultScreen(mDisplay);  // screen ID
 449     mRootWin = RootWindow(mDisplay, mScreen);   // root window ID
 450
 451     init_atoms();
 452
 453 #ifdef CONFIG_XF86VM
 454     {
 455         int clock;
 456
 457         XF86VidModeGetModeLine(mDisplay, mScreen, &clock, &modeline);
 458         if (!vo_screenwidth)
 459             vo_screenwidth = modeline.hdisplay;
 460         if (!vo_screenheight)
 461             vo_screenheight = modeline.vdisplay;
 462     }
 463 #endif
 464     {
 465         if (!vo_screenwidth)
 466             vo_screenwidth = DisplayWidth(mDisplay, mScreen);
 467         if (!vo_screenheight)
 468             vo_screenheight = DisplayHeight(mDisplay, mScreen);
 469     }
 470     // get color depth (from root window, or the best visual):
 471     XGetWindowAttributes(mDisplay, mRootWin, &attribs);
 472     depth = attribs.depth;
 473
 474     if (depth != 15 && depth != 16 && depth != 24 && depth != 32)
 475     {
 476         Visual *visual;
 477
 478         depth = vo_find_depth_from_visuals(mDisplay, mScreen, &visual);
 479         if (depth != -1)
 480             mXImage = XCreateImage(mDisplay, visual, depth, ZPixmap,
 481                                    0, NULL, 1, 1, 8, 1);
 482     } else
 483         mXImage =
 484             XGetImage(mDisplay, mRootWin, 0, 0, 1, 1, AllPlanes, ZPixmap);
 485
 486     vo_depthonscreen = depth;   // display depth on screen
 487
 488     // get bits/pixel from XImage structure:
 489     if (mXImage == NULL)
 490     {
 491         mask = 0;
 492     } else
 493     {
 494         /*
 495          * for the depth==24 case, the XImage structures might use
 496          * 24 or 32 bits of data per pixel.  The global variable
 497          * vo_depthonscreen stores the amount of data per pixel in the
 498          * XImage structure!
 499          *
 500          * Maybe we should rename vo_depthonscreen to (or add) vo_bpp?
 501          */
 502         bpp = mXImage->bits_per_pixel;
 503         if ((vo_depthonscreen + 7) / 8 != (bpp + 7) / 8)
 504             vo_depthonscreen = bpp;     // by A'rpi
 505         mask =
 506             mXImage->red_mask | mXImage->green_mask | mXImage->blue_mask;
 507         mp_msg(MSGT_VO, MSGL_V,
 508                "vo: X11 color mask:  %X  (R:%lX G:%lX B:%lX)\n", mask,
 509                mXImage->red_mask, mXImage->green_mask, mXImage->blue_mask);
 510         XDestroyImage(mXImage);
 511     }
 512     if (((vo_depthonscreen + 7) / 8) == 2)
 513     {
 514         if (mask == 0x7FFF)
 515             vo_depthonscreen = 15;
 516         else if (mask == 0xFFFF)
 517             vo_depthonscreen = 16;
 518     }
 519 // XCloseDisplay( mDisplay );
 520 /* slightly improved local display detection AST */
 521     if (strncmp(dispName, "unix:", 5) == 0)
 522         dispName += 4;
 523     else if (strncmp(dispName, "localhost:", 10) == 0)
 524         dispName += 9;
 525     if (*dispName == ':' && atoi(dispName + 1) < 10)
 526         mLocalDisplay = 1;
 527     else
 528         mLocalDisplay = 0;
 529     mp_msg(MSGT_VO, MSGL_V,
 530            "vo: X11 running at %dx%d with depth %d and %d bpp (\"%s\" => %s display)\n",
 531            vo_screenwidth, vo_screenheight, depth, vo_depthonscreen,
 532            dispName, mLocalDisplay ? "local" : "remote");
 533
 534     vo_wm_type = vo_wm_detect();
 535
 536     vo_fs_type = vo_x11_get_fs_type(vo_wm_type);
 537
 538     fstype_dump(vo_fs_type);
 539
 540     saver_off(mDisplay);
 541     return 1;
 542 }
 543
 544 void vo_uninit(void)
 545 {
 546     if (!mDisplay)
 547     {
 548         mp_msg(MSGT_VO, MSGL_V,
 549                "vo: x11 uninit called but X11 not initialized..\n");
 550         return;
 551     }
 552 // if( !vo_depthonscreen ) return;
 553     mp_msg(MSGT_VO, MSGL_V, "vo: uninit ...\n");
 554     XSetErrorHandler(NULL);
 555     XCloseDisplay(mDisplay);
 556     vo_depthonscreen = 0;
 557     mDisplay = NULL;
 558 }
 559
 560 #include "osdep/keycodes.h"
 561 #include "wskeys.h"
 562
 563 #ifdef XF86XK_AudioPause
 564 static const struct keymap keysym_map[] = {
 565     {XF86XK_MenuKB, KEY_MENU},
 566     {XF86XK_AudioPlay, KEY_PLAY}, {XF86XK_AudioPause, KEY_PAUSE}, {XF86XK_AudioStop, KEY_STOP},
 567     {XF86XK_AudioPrev, KEY_PREV}, {XF86XK_AudioNext, KEY_NEXT},
 568     {XF86XK_AudioMute, KEY_MUTE}, {XF86XK_AudioLowerVolume, KEY_VOLUME_DOWN}, {XF86XK_AudioRaiseVolume, KEY_VOLUME_UP},
 569     {0, 0}
 570 };
 571
 572 static void vo_x11_putkey_ext(int keysym)
 573 {
 574     int mpkey = lookup_keymap_table(keysym_map, keysym);
 575     if (mpkey)
 576         mplayer_put_key(mpkey);
 577 }
 578 #endif
 579
 580 static const struct keymap keymap[] = {
 581     // special keys
 582     {wsEscape, KEY_ESC}, {wsBackSpace, KEY_BS}, {wsTab, KEY_TAB}, {wsEnter, KEY_ENTER},
 583
 584     // cursor keys
 585     {wsLeft, KEY_LEFT}, {wsRight, KEY_RIGHT}, {wsUp, KEY_UP}, {wsDown, KEY_DOWN},
 586
 587     // navigation block
 588     {wsInsert, KEY_INSERT}, {wsDelete, KEY_DELETE}, {wsHome, KEY_HOME}, {wsEnd, KEY_END},
 589     {wsPageUp, KEY_PAGE_UP}, {wsPageDown, KEY_PAGE_DOWN},
 590
 591     // F-keys
 592     {wsF1, KEY_F+1}, {wsF2, KEY_F+2}, {wsF3, KEY_F+3}, {wsF4, KEY_F+4},
 593     {wsF5, KEY_F+5}, {wsF6, KEY_F+6}, {wsF7, KEY_F+7}, {wsF8, KEY_F+8},
 594     {wsF9, KEY_F+9}, {wsF10, KEY_F+10}, {wsF11, KEY_F+11}, {wsF12, KEY_F+12},
 595
 596     // numpad independent of numlock
 597     {wsGrayMinus, '-'}, {wsGrayPlus, '+'}, {wsGrayMul, '*'}, {wsGrayDiv, '/'},
 598     {wsGrayEnter, KEY_KPENTER},
 599
 600     // numpad with numlock
 601     {wsGray0, KEY_KP0}, {wsGray1, KEY_KP1}, {wsGray2, KEY_KP2},
 602     {wsGray3, KEY_KP3}, {wsGray4, KEY_KP4}, {wsGray5, KEY_KP5},
 603     {wsGray6, KEY_KP6}, {wsGray7, KEY_KP7}, {wsGray8, KEY_KP8},
 604     {wsGray9, KEY_KP9}, {wsGrayDecimal, KEY_KPDEC},
 605
 606     // numpad without numlock
 607     {wsGrayInsert, KEY_KPINS}, {wsGrayEnd, KEY_KP1}, {wsGrayDown, KEY_KP2},
 608     {wsGrayPgDn, KEY_KP3}, {wsGrayLeft, KEY_KP4}, {wsGray5Dup, KEY_KP5},
 609     {wsGrayRight, KEY_KP6}, {wsGrayHome, KEY_KP7}, {wsGrayUp, KEY_KP8},
 610     {wsGrayPgUp, KEY_KP9}, {wsGrayDelete, KEY_KPDEL},
 611
 612     {0, 0}
 613 };
 614
 615 void vo_x11_putkey(int key)
 616 {
 617     static const char *passthrough_keys = " -+*/<>`~!@#$%^&()_{}:;\"\',.?\\|=[]";
 618     int mpkey = 0;
 619     if ((key >= 'a' && key <= 'z') ||
 620         (key >= 'A' && key <= 'Z') ||
 621         (key >= '0' && key <= '9') ||
 622         (key >  0   && key <  256 && strchr(passthrough_keys, key)))
 623         mpkey = key;
 624
 625     if (!mpkey)
 626         mpkey = lookup_keymap_table(keymap, key);
 627
 628     if (mpkey)
 629         mplayer_put_key(mpkey);
 630 }
 631
 632
 633 // ----- Motif header: -------
 634
 635 #define MWM_HINTS_FUNCTIONS     (1L << 0)
 636 #define MWM_HINTS_DECORATIONS   (1L << 1)
 637 #define MWM_HINTS_INPUT_MODE    (1L << 2)
 638 #define MWM_HINTS_STATUS        (1L << 3)
 639
 640 #define MWM_FUNC_ALL            (1L << 0)
 641 #define MWM_FUNC_RESIZE         (1L << 1)
 642 #define MWM_FUNC_MOVE           (1L << 2)
 643 #define MWM_FUNC_MINIMIZE       (1L << 3)
 644 #define MWM_FUNC_MAXIMIZE       (1L << 4)
 645 #define MWM_FUNC_CLOSE          (1L << 5)
 646
 647 #define MWM_DECOR_ALL           (1L << 0)
 648 #define MWM_DECOR_BORDER        (1L << 1)
 649 #define MWM_DECOR_RESIZEH       (1L << 2)
 650 #define MWM_DECOR_TITLE         (1L << 3)
 651 #define MWM_DECOR_MENU          (1L << 4)
 652 #define MWM_DECOR_MINIMIZE      (1L << 5)
 653 #define MWM_DECOR_MAXIMIZE      (1L << 6)
 654
 655 #define MWM_INPUT_MODELESS 0
 656 #define MWM_INPUT_PRIMARY_APPLICATION_MODAL 1
 657 #define MWM_INPUT_SYSTEM_MODAL 2
 658 #define MWM_INPUT_FULL_APPLICATION_MODAL 3
 659 #define MWM_INPUT_APPLICATION_MODAL MWM_INPUT_PRIMARY_APPLICATION_MODAL
 660
 661 #define MWM_TEAROFF_WINDOW      (1L<<0)
 662
 663 typedef struct
 664 {
 665     long flags;
 666     long functions;
 667     long decorations;
 668     long input_mode;
 669     long state;
 670 } MotifWmHints;
 671
 672 static MotifWmHints vo_MotifWmHints;
 673 static Atom vo_MotifHints = None;
 674
 675 void vo_x11_decoration(Display * vo_Display, Window w, int d)
 676 {
 677     static unsigned int olddecor = MWM_DECOR_ALL;
 678     static unsigned int oldfuncs =
 679         MWM_FUNC_MOVE | MWM_FUNC_CLOSE | MWM_FUNC_MINIMIZE |
 680         MWM_FUNC_MAXIMIZE | MWM_FUNC_RESIZE;
 681     Atom mtype;
 682     int mformat;
 683     unsigned long mn, mb;
 684
 685     if (!WinID)
 686         return;
 687
 688     if (vo_fsmode & 8)
 689     {
 690         XSetTransientForHint(vo_Display, w,
 691                              RootWindow(vo_Display, mScreen));
 692     }
 693
 694     vo_MotifHints = XInternAtom(vo_Display, "_MOTIF_WM_HINTS", 0);
 695     if (vo_MotifHints != None)
 696     {
 697         if (!d)
 698         {
 699             MotifWmHints *mhints = NULL;
 700
 701             XGetWindowProperty(vo_Display, w, vo_MotifHints, 0, 20, False,
 702                                vo_MotifHints, &mtype, &mformat, &mn,
 703                                &mb, (unsigned char **) &mhints);
 704             if (mhints)
 705             {
 706                 if (mhints->flags & MWM_HINTS_DECORATIONS)
 707                     olddecor = mhints->decorations;
 708                 if (mhints->flags & MWM_HINTS_FUNCTIONS)
 709                     oldfuncs = mhints->functions;
 710                 XFree(mhints);
 711             }
 712         }
 713
 714         memset(&vo_MotifWmHints, 0, sizeof(MotifWmHints));
 715         vo_MotifWmHints.flags =
 716             MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
 717         if (d)
 718         {
 719             vo_MotifWmHints.functions = oldfuncs;
 720             d = olddecor;
 721         }
 722 #if 0
 723         vo_MotifWmHints.decorations =
 724             d | ((vo_fsmode & 2) ? 0 : MWM_DECOR_MENU);
 725 #else
 726         vo_MotifWmHints.decorations =
 727             d | ((vo_fsmode & 2) ? MWM_DECOR_MENU : 0);
 728 #endif
 729         XChangeProperty(vo_Display, w, vo_MotifHints, vo_MotifHints, 32,
 730                         PropModeReplace,
 731                         (unsigned char *) &vo_MotifWmHints,
 732                         (vo_fsmode & 4) ? 4 : 5);
 733     }
 734 }
 735
 736 void vo_x11_classhint(Display * display, Window window, char *name)
 737 {
 738     XClassHint wmClass;
 739     pid_t pid = getpid();
 740
 741     wmClass.res_name = name;
 742     wmClass.res_class = "MPlayer";
 743     XSetClassHint(display, window, &wmClass);
 744     XChangeProperty(display, window, XA_NET_WM_PID, XA_CARDINAL, 32,
 745                     PropModeReplace, (unsigned char *) &pid, 1);
 746 }
 747
 748 Window vo_window = None;
 749 GC vo_gc = NULL;
 750 GC f_gc = NULL;
 751 XSizeHints vo_hint;
 752
 753 #ifdef CONFIG_GUI
 754 void vo_setwindow(Window w, GC g)
 755 {
 756     vo_window = w;
 757     vo_gc = g;
 758 }
 759 #endif
 760
 761 void vo_x11_uninit(void)
 762 {
 763     saver_on(mDisplay);
 764     if (vo_window != None)
 765         vo_showcursor(mDisplay, vo_window);
 766
 767     if (f_gc)
 768     {
 769         XFreeGC(mDisplay, f_gc);
 770         f_gc = NULL;
 771     }
 772 #ifdef CONFIG_GUI
 773     /* destroy window only if it's not controlled by the GUI */
 774     if (!use_gui)
 775 #endif
 776     {
 777         if (vo_gc)
 778         {
 779             XSetBackground(mDisplay, vo_gc, 0);
 780             XFreeGC(mDisplay, vo_gc);
 781             vo_gc = NULL;
 782         }
 783         if (vo_window != None)
 784         {
 785             XClearWindow(mDisplay, vo_window);
 786             if (WinID < 0)
 787             {
 788                 XEvent xev;
 789
 790                 XUnmapWindow(mDisplay, vo_window);
 791                 XDestroyWindow(mDisplay, vo_window);
 792                 do
 793                 {
 794                     XNextEvent(mDisplay, &xev);
 795                 }
 796                 while (xev.type != DestroyNotify
 797                        || xev.xdestroywindow.event != vo_window);
 798             }
 799             vo_window = None;
 800         }
 801         vo_fs = 0;
 802         vo_old_width = vo_old_height = 0;
 803     }
 804 }
 805
 806 static unsigned int mouse_timer;
 807 static int mouse_waiting_hide;
 808
 809 int vo_x11_check_events(Display * mydisplay)
 810 {
 811     int ret = 0;
 812     XEvent Event;
 813     char buf[100];
 814     KeySym keySym;
 815     static XComposeStatus stat;
 816
 817 // unsigned long  vo_KeyTable[512];
 818
 819     if ((vo_mouse_autohide) && mouse_waiting_hide &&
 820                                  (GetTimerMS() - mouse_timer >= 1000)) {
 821         vo_hidecursor(mydisplay, vo_window);
 822         mouse_waiting_hide = 0;
 823     }
 824
 825     while (XPending(mydisplay))
 826     {
 827         XNextEvent(mydisplay, &Event);
 828 #ifdef CONFIG_GUI
 829         if (use_gui)
 830         {
 831             guiGetEvent(0, (char *) &Event);
 832             if (vo_window != Event.xany.window)
 833                 continue;
 834         }
 835 #endif
 836 //       printf("\rEvent.type=%X  \n",Event.type);
 837         switch (Event.type)
 838         {
 839             case Expose:
 840                 ret |= VO_EVENT_EXPOSE;
 841                 break;
 842             case ConfigureNotify:
 843 //         if (!vo_fs && (Event.xconfigure.width == vo_screenwidth || Event.xconfigure.height == vo_screenheight)) break;
 844 //         if (vo_fs && Event.xconfigure.width != vo_screenwidth && Event.xconfigure.height != vo_screenheight) break;
 845                 if (vo_window == None)
 846                     break;
 847                 {
 848                     int old_w = vo_dwidth, old_h = vo_dheight;
 849                     vo_x11_update_geometry();
 850                     if (vo_dwidth != old_w || vo_dheight != old_h)
 851                         ret |= VO_EVENT_RESIZE;
 852                 }
 853                 break;
 854             case KeyPress:
 855                 {
 856                     int key;
 857
 858 #ifdef CONFIG_GUI
 859                     if ( use_gui ) { break; }
 860 #endif
 861
 862                     XLookupString(&Event.xkey, buf, sizeof(buf), &keySym,
 863                                   &stat);
 864 #ifdef XF86XK_AudioPause
 865                     vo_x11_putkey_ext(keySym);
 866 #endif
 867                     key =
 868                         ((keySym & 0xff00) !=
 869                          0 ? ((keySym & 0x00ff) + 256) : (keySym));
 870                     vo_x11_putkey(key);
 871                     ret |= VO_EVENT_KEYPRESS;
 872                 }
 873                 break;
 874             case MotionNotify:
 875                 if(enable_mouse_movements)
 876                 {
 877                     char cmd_str[40];
 878                     sprintf(cmd_str,"set_mouse_pos %i %i",Event.xmotion.x, Event.xmotion.y);
 879                     mp_input_queue_cmd(mp_input_parse_cmd(cmd_str));
 880                 }
 881
 882                 if (vo_mouse_autohide)
 883                 {
 884                     vo_showcursor(mydisplay, vo_window);
 885                     mouse_waiting_hide = 1;
 886                     mouse_timer = GetTimerMS();
 887                 }
 888                 break;
 889             case ButtonPress:
 890                 if (vo_mouse_autohide)
 891                 {
 892                     vo_showcursor(mydisplay, vo_window);
 893                     mouse_waiting_hide = 1;
 894                     mouse_timer = GetTimerMS();
 895                 }
 896 #ifdef CONFIG_GUI
 897                 // Ignore mouse button 1-3 under GUI.
 898                 if (use_gui && (Event.xbutton.button >= 1)
 899                     && (Event.xbutton.button <= 3))
 900                     break;
 901 #endif
 902                 mplayer_put_key((MOUSE_BTN0 + Event.xbutton.button -
 903                                  1) | MP_KEY_DOWN);
 904                 break;
 905             case ButtonRelease:
 906                 if (vo_mouse_autohide)
 907                 {
 908                     vo_showcursor(mydisplay, vo_window);
 909                     mouse_waiting_hide = 1;
 910                     mouse_timer = GetTimerMS();
 911                 }
 912 #ifdef CONFIG_GUI
 913                 // Ignore mouse button 1-3 under GUI.
 914                 if (use_gui && (Event.xbutton.button >= 1)
 915                     && (Event.xbutton.button <= 3))
 916                     break;
 917 #endif
 918                 mplayer_put_key(MOUSE_BTN0 + Event.xbutton.button - 1);
 919                 break;
 920             case PropertyNotify:
 921                 {
 922                     char *name =
 923                         XGetAtomName(mydisplay, Event.xproperty.atom);
 924
 925                     if (!name)
 926                         break;
 927
 928 //          fprintf(stderr,"[ws] PropertyNotify ( 0x%x ) %s ( 0x%x )\n",vo_window,name,Event.xproperty.atom );
 929
 930                     XFree(name);
 931                 }
 932                 break;
 933             case MapNotify:
 934                 vo_hint.win_gravity = old_gravity;
 935                 XSetWMNormalHints(mDisplay, vo_window, &vo_hint);
 936                 vo_fs_flip = 0;
 937                 break;
 938             case ClientMessage:
 939                 if (Event.xclient.message_type == XAWM_PROTOCOLS &&
 940                     Event.xclient.data.l[0] == XAWM_DELETE_WINDOW)
 941                     mplayer_put_key(KEY_CLOSE_WIN);
 942                 break;
 943         }
 944     }
 945     return ret;
 946 }
 947
 948 /**
 949  * \brief sets the size and position of the non-fullscreen window.
 950  */
 951 void vo_x11_nofs_sizepos(int x, int y, int width, int height)
 952 {
 953   vo_x11_sizehint(x, y, width, height, 0);
 954   if (vo_fs) {
 955     vo_old_x = x;
 956     vo_old_y = y;
 957     vo_old_width = width;
 958     vo_old_height = height;
 959   }
 960   else
 961   {
 962    vo_dwidth = width;
 963    vo_dheight = height;
 964    XMoveResizeWindow(mDisplay, vo_window, x, y, width, height);
 965   }
 966 }
 967
 968 void vo_x11_sizehint(int x, int y, int width, int height, int max)
 969 {
 970     vo_hint.flags = 0;
 971     if (vo_keepaspect)
 972     {
 973         vo_hint.flags |= PAspect;
 974         vo_hint.min_aspect.x = width;
 975         vo_hint.min_aspect.y = height;
 976         vo_hint.max_aspect.x = width;
 977         vo_hint.max_aspect.y = height;
 978     }
 979
 980     vo_hint.flags |= PPosition | PSize;
 981     vo_hint.x = x;
 982     vo_hint.y = y;
 983     vo_hint.width = width;
 984     vo_hint.height = height;
 985     if (max)
 986     {
 987         vo_hint.flags |= PMaxSize;
 988         vo_hint.max_width = width;
 989         vo_hint.max_height = height;
 990     } else
 991     {
 992         vo_hint.max_width = 0;
 993         vo_hint.max_height = 0;
 994     }
 995
 996     // Set minimum height/width to 4 to avoid off-by-one errors
 997     // and because mga_vid requires a minimal size of 4 pixels.
 998     vo_hint.flags |= PMinSize;
 999     vo_hint.min_width = vo_hint.min_height = 4;
1000
1001     // Set the base size. A window manager might display the window
1002     // size to the user relative to this.
1003     // Setting these to width/height might be nice, but e.g. fluxbox can't handle it.
1004     vo_hint.flags |= PBaseSize;
1005     vo_hint.base_width = 0 /*width*/;
1006     vo_hint.base_height = 0 /*height*/;
1007
1008     vo_hint.flags |= PWinGravity;
1009     vo_hint.win_gravity = StaticGravity;
1010     XSetWMNormalHints(mDisplay, vo_window, &vo_hint);
1011 }
1012
1013 static int vo_x11_get_gnome_layer(Display * mDisplay, Window win)
1014 {
1015     Atom type;
1016     int format;
1017     unsigned long nitems;
1018     unsigned long bytesafter;
1019     unsigned short *args = NULL;
1020
1021     if (XGetWindowProperty(mDisplay, win, XA_WIN_LAYER, 0, 16384,
1022                            False, AnyPropertyType, &type, &format, &nitems,
1023                            &bytesafter,
1024                            (unsigned char **) &args) == Success
1025         && nitems > 0 && args)
1026     {
1027         mp_msg(MSGT_VO, MSGL_V, "[x11] original window layer is %d.\n",
1028                *args);
1029         return *args;
1030     }
1031     return WIN_LAYER_NORMAL;
1032 }
1033
1034 //
1035 Window vo_x11_create_smooth_window(Display * mDisplay, Window mRoot,
1036                                    Visual * vis, int x, int y,
1037                                    unsigned int width, unsigned int height,
1038                                    int depth, Colormap col_map)
1039 {
1040     unsigned long xswamask = CWBorderPixel;
1041     XSetWindowAttributes xswa;
1042     Window ret_win;
1043
1044     if (col_map != CopyFromParent)
1045     {
1046         xswa.colormap = col_map;
1047         xswamask |= CWColormap;
1048     }
1049     xswa.background_pixel = 0;
1050     xswa.border_pixel = 0;
1051     xswa.backing_store = NotUseful;
1052     xswa.bit_gravity = StaticGravity;
1053
1054     ret_win =
1055         XCreateWindow(mDisplay, mRootWin, x, y, width, height, 0, depth,
1056                       CopyFromParent, vis, xswamask, &xswa);
1057     XSetWMProtocols(mDisplay, ret_win, &XAWM_DELETE_WINDOW, 1);
1058     if (!f_gc)
1059         f_gc = XCreateGC(mDisplay, ret_win, 0, 0);
1060     XSetForeground(mDisplay, f_gc, 0);
1061
1062     return ret_win;
1063 }
1064
1065 /**
1066  * \brief create and setup a window suitable for display
1067  * \param vis Visual to use for creating the window
1068  * \param x x position of window
1069  * \param y y position of window
1070  * \param width width of window
1071  * \param height height of window
1072  * \param flags flags for window creation.
1073  *              Only VOFLAG_FULLSCREEN is supported so far.
1074  * \param col_map Colourmap for window or CopyFromParent if a specific colormap isn't needed
1075  * \param classname name to use for the classhint
1076  * \param title title for the window
1077  *
1078  * This also does the grunt-work like setting Window Manager hints etc.
1079  * If vo_window is already set it just moves and resizes it.
1080  */
1081 void vo_x11_create_vo_window(XVisualInfo *vis, int x, int y,
1082                              unsigned int width, unsigned int height, int flags,
1083                              Colormap col_map,
1084                              const char *classname, const char *title)
1085 {
1086   XGCValues xgcv;
1087   if (WinID >= 0) {
1088     vo_window = WinID ? (Window)WinID : mRootWin;
1089     if (col_map != CopyFromParent) {
1090       unsigned long xswamask = CWColormap;
1091       XSetWindowAttributes xswa;
1092       xswa.colormap = col_map;
1093       XUnmapWindow(mDisplay, vo_window);
1094       XChangeWindowAttributes(mDisplay, vo_window, xswamask, &xswa);
1095       XMapWindow(mDisplay, vo_window);
1096     }
1097     if (WinID) vo_x11_update_geometry();
1098     vo_x11_selectinput_witherr(mDisplay, vo_window,
1099           StructureNotifyMask | KeyPressMask | PointerMotionMask |
1100           ButtonPressMask | ButtonReleaseMask | ExposureMask);
1101     goto final;
1102   }
1103   if (vo_window == None) {
1104     XSizeHints hint;
1105     XEvent xev;
1106     vo_fs = 0;
1107     vo_dwidth = width;
1108     vo_dheight = height;
1109     vo_window = vo_x11_create_smooth_window(mDisplay, mRootWin, vis->visual,
1110                       x, y, width, height, vis->depth, col_map);
1111     vo_x11_classhint(mDisplay, vo_window, classname);
1112     XStoreName(mDisplay, vo_window, title);
1113     vo_hidecursor(mDisplay, vo_window);
1114     XSelectInput(mDisplay, vo_window, StructureNotifyMask);
1115     hint.x = x; hint.y = y;
1116     hint.width = width; hint.height = height;
1117     hint.flags = PPosition | PSize;
1118     XSetStandardProperties(mDisplay, vo_window, title, title, None, NULL, 0, &hint);
1119     vo_x11_sizehint(x, y, width, height, 0);
1120     if (!vo_border) vo_x11_decoration(mDisplay, vo_window, 0);
1121     // map window
1122     XMapWindow(mDisplay, vo_window);
1123     XClearWindow(mDisplay, vo_window);
1124     // wait for map
1125     do {
1126       XNextEvent(mDisplay, &xev);
1127     } while (xev.type != MapNotify || xev.xmap.event != vo_window);
1128     XSelectInput(mDisplay, vo_window, NoEventMask);
1129     XSync(mDisplay, False);
1130     vo_x11_selectinput_witherr(mDisplay, vo_window,
1131           StructureNotifyMask | KeyPressMask | PointerMotionMask |
1132           ButtonPressMask | ButtonReleaseMask | ExposureMask);
1133   }
1134   if (vo_ontop) vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
1135   vo_x11_nofs_sizepos(vo_dx, vo_dy, width, height);
1136   if (!!vo_fs != !!(flags & VOFLAG_FULLSCREEN))
1137     vo_x11_fullscreen();
1138 final:
1139   if (vo_gc != None)
1140     XFreeGC(mDisplay, vo_gc);
1141   vo_gc = XCreateGC(mDisplay, vo_window, GCForeground, &xgcv);
1142   XSync(mDisplay, False);
1143   vo_mouse_autohide = 1;
1144 }
1145
1146 void vo_x11_clearwindow_part(Display * mDisplay, Window vo_window,
1147                              int img_width, int img_height, int use_fs)
1148 {
1149     int u_dheight, u_dwidth, left_ov, left_ov2;
1150
1151     if (!f_gc)
1152         return;
1153
1154     u_dheight = use_fs ? vo_screenheight : vo_dheight;
1155     u_dwidth = use_fs ? vo_screenwidth : vo_dwidth;
1156     if ((u_dheight <= img_height) && (u_dwidth <= img_width))
1157         return;
1158
1159     left_ov = (u_dheight - img_height) / 2;
1160     left_ov2 = (u_dwidth - img_width) / 2;
1161
1162     XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, u_dwidth, left_ov);
1163     XFillRectangle(mDisplay, vo_window, f_gc, 0, u_dheight - left_ov - 1,
1164                    u_dwidth, left_ov + 1);
1165
1166     if (u_dwidth > img_width)
1167     {
1168         XFillRectangle(mDisplay, vo_window, f_gc, 0, left_ov, left_ov2,
1169                        img_height);
1170         XFillRectangle(mDisplay, vo_window, f_gc, u_dwidth - left_ov2 - 1,
1171                        left_ov, left_ov2 + 1, img_height);
1172     }
1173
1174     XFlush(mDisplay);
1175 }
1176
1177 void vo_x11_clearwindow(Display * mDisplay, Window vo_window)
1178 {
1179     if (!f_gc)
1180         return;
1181     XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, vo_screenwidth,
1182                    vo_screenheight);
1183     //
1184     XFlush(mDisplay);
1185 }
1186
1187
1188 void vo_x11_setlayer(Display * mDisplay, Window vo_window, int layer)
1189 {
1190     if (WinID >= 0)
1191         return;
1192
1193     if (vo_fs_type & vo_wm_LAYER)
1194     {
1195         XClientMessageEvent xev;
1196
1197         if (!orig_layer)
1198             orig_layer = vo_x11_get_gnome_layer(mDisplay, vo_window);
1199
1200         memset(&xev, 0, sizeof(xev));
1201         xev.type = ClientMessage;
1202         xev.display = mDisplay;
1203         xev.window = vo_window;
1204         xev.message_type = XA_WIN_LAYER;
1205         xev.format = 32;
1206         xev.data.l[0] = layer ? fs_layer : orig_layer;  // if not fullscreen, stay on default layer
1207         xev.data.l[1] = CurrentTime;
1208         mp_msg(MSGT_VO, MSGL_V,
1209                "[x11] Layered style stay on top (layer %ld).\n",
1210                xev.data.l[0]);
1211         XSendEvent(mDisplay, mRootWin, False, SubstructureNotifyMask,
1212                    (XEvent *) & xev);
1213     } else if (vo_fs_type & vo_wm_NETWM)
1214     {
1215         XClientMessageEvent xev;
1216         char *state;
1217
1218         memset(&xev, 0, sizeof(xev));
1219         xev.type = ClientMessage;
1220         xev.message_type = XA_NET_WM_STATE;
1221         xev.display = mDisplay;
1222         xev.window = vo_window;
1223         xev.format = 32;
1224         xev.data.l[0] = layer;
1225
1226         if (vo_fs_type & vo_wm_STAYS_ON_TOP)
1227             xev.data.l[1] = XA_NET_WM_STATE_STAYS_ON_TOP;
1228         else if (vo_fs_type & vo_wm_ABOVE)
1229             xev.data.l[1] = XA_NET_WM_STATE_ABOVE;
1230         else if (vo_fs_type & vo_wm_FULLSCREEN)
1231             xev.data.l[1] = XA_NET_WM_STATE_FULLSCREEN;
1232         else if (vo_fs_type & vo_wm_BELOW)
1233             // This is not fallback. We can safely assume that the situation
1234             // where only NETWM_STATE_BELOW is supported doesn't exist.
1235             xev.data.l[1] = XA_NET_WM_STATE_BELOW;
1236
1237         XSendEvent(mDisplay, mRootWin, False, SubstructureRedirectMask,
1238                    (XEvent *) & xev);
1239         state = XGetAtomName(mDisplay, xev.data.l[1]);
1240         mp_msg(MSGT_VO, MSGL_V,
1241                "[x11] NET style stay on top (layer %d). Using state %s.\n",
1242                layer, state);
1243         XFree(state);
1244     }
1245 }
1246
1247 static int vo_x11_get_fs_type(int supported)
1248 {
1249     int i;
1250     int type = supported;
1251
1252     if (vo_fstype_list)
1253     {
1254         i = 0;
1255         for (i = 0; vo_fstype_list[i]; i++)
1256         {
1257             int neg = 0;
1258             char *arg = vo_fstype_list[i];
1259
1260             if (vo_fstype_list[i][0] == '-')
1261             {
1262                 neg = 1;
1263                 arg = vo_fstype_list[i] + 1;
1264             }
1265
1266             if (!strncmp(arg, "layer", 5))
1267             {
1268                 if (!neg && (arg[5] == '='))
1269                 {
1270                     char *endptr = NULL;
1271                     int layer = strtol(vo_fstype_list[i] + 6, &endptr, 10);
1272
1273                     if (endptr && *endptr == '\0' && layer >= 0
1274                         && layer <= 15)
1275                         fs_layer = layer;
1276                 }
1277                 if (neg)
1278                     type &= ~vo_wm_LAYER;
1279                 else
1280                     type |= vo_wm_LAYER;
1281             } else if (!strcmp(arg, "above"))
1282             {
1283                 if (neg)
1284                     type &= ~vo_wm_ABOVE;
1285                 else
1286                     type |= vo_wm_ABOVE;
1287             } else if (!strcmp(arg, "fullscreen"))
1288             {
1289                 if (neg)
1290                     type &= ~vo_wm_FULLSCREEN;
1291                 else
1292                     type |= vo_wm_FULLSCREEN;
1293             } else if (!strcmp(arg, "stays_on_top"))
1294             {
1295                 if (neg)
1296                     type &= ~vo_wm_STAYS_ON_TOP;
1297                 else
1298                     type |= vo_wm_STAYS_ON_TOP;
1299             } else if (!strcmp(arg, "below"))
1300             {
1301                 if (neg)
1302                     type &= ~vo_wm_BELOW;
1303                 else
1304                     type |= vo_wm_BELOW;
1305             } else if (!strcmp(arg, "netwm"))
1306             {
1307                 if (neg)
1308                     type &= ~vo_wm_NETWM;
1309                 else
1310                     type |= vo_wm_NETWM;
1311             } else if (!strcmp(arg, "none"))
1312                 return 0;
1313         }
1314     }
1315
1316     return type;
1317 }
1318
1319 /**
1320  * \brief update vo_dx, vo_dy, vo_dwidth and vo_dheight with current values of vo_window
1321  * \return returns current color depth of vo_window
1322  */
1323 int vo_x11_update_geometry(void) {
1324     unsigned depth, w, h;
1325     int dummy_int;
1326     Window dummy_win;
1327     XGetGeometry(mDisplay, vo_window, &dummy_win, &dummy_int, &dummy_int,
1328                  &w, &h, &dummy_int, &depth);
1329     if (w <= INT_MAX && h <= INT_MAX) { vo_dwidth = w; vo_dheight = h; }
1330     XTranslateCoordinates(mDisplay, vo_window, mRootWin, 0, 0, &vo_dx, &vo_dy,
1331                           &dummy_win);
1332     return depth <= INT_MAX ? depth : 0;
1333 }
1334
1335 void vo_x11_fullscreen(void)
1336 {
1337     int x, y, w, h;
1338
1339     if (WinID >= 0 || vo_fs_flip)
1340         return;
1341
1342     if (vo_fs)
1343     {
1344         // fs->win
1345         if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1346         {
1347             x = vo_old_x;
1348             y = vo_old_y;
1349             w = vo_old_width;
1350             h = vo_old_height;
1351         }
1352
1353         vo_x11_ewmh_fullscreen(_NET_WM_STATE_REMOVE);   // removes fullscreen state if wm supports EWMH
1354         vo_fs = VO_FALSE;
1355     } else
1356     {
1357         // win->fs
1358         vo_x11_ewmh_fullscreen(_NET_WM_STATE_ADD);      // sends fullscreen state to be added if wm supports EWMH
1359
1360         vo_fs = VO_TRUE;
1361         if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1362         {
1363             vo_old_x = vo_dx;
1364             vo_old_y = vo_dy;
1365             vo_old_width = vo_dwidth;
1366             vo_old_height = vo_dheight;
1367         }
1368             update_xinerama_info();
1369             x = xinerama_x;
1370             y = xinerama_y;
1371             w = vo_screenwidth;
1372             h = vo_screenheight;
1373     }
1374     {
1375         long dummy;
1376
1377         XGetWMNormalHints(mDisplay, vo_window, &vo_hint, &dummy);
1378         if (!(vo_hint.flags & PWinGravity))
1379             old_gravity = NorthWestGravity;
1380         else
1381             old_gravity = vo_hint.win_gravity;
1382     }
1383     if (vo_wm_type == 0 && !(vo_fsmode & 16))
1384     {
1385         XUnmapWindow(mDisplay, vo_window);      // required for MWM
1386         XWithdrawWindow(mDisplay, vo_window, mScreen);
1387         vo_fs_flip = 1;
1388     }
1389
1390     if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1391     {
1392         vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs);
1393         vo_x11_sizehint(x, y, w, h, 0);
1394         vo_x11_setlayer(mDisplay, vo_window, vo_fs);
1395
1396
1397         XMoveResizeWindow(mDisplay, vo_window, x, y, w, h);
1398     }
1399     /* some WMs lose ontop after fullscreen */
1400     if ((!(vo_fs)) & vo_ontop)
1401         vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
1402
1403     XMapRaised(mDisplay, vo_window);
1404     if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // some WMs change window pos on map
1405         XMoveResizeWindow(mDisplay, vo_window, x, y, w, h);
1406     XRaiseWindow(mDisplay, vo_window);
1407     XFlush(mDisplay);
1408 }
1409
1410 void vo_x11_ontop(void)
1411 {
1412     vo_ontop = (!(vo_ontop));
1413
1414     vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
1415 }
1416
1417 void vo_x11_border(void)
1418 {
1419     vo_border = !vo_border;
1420     vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs);
1421 }
1422
1423 /*
1424  * XScreensaver stuff
1425  */
1426
1427 static int screensaver_off;
1428 static unsigned int time_last;
1429
1430 void xscreensaver_heartbeat(void)
1431 {
1432     unsigned int time = GetTimerMS();
1433
1434     if (mDisplay && screensaver_off && (time - time_last) > 30000)
1435     {
1436         time_last = time;
1437
1438         XResetScreenSaver(mDisplay);
1439     }
1440 }
1441
1442 static int xss_suspend(Bool suspend)
1443 {
1444 #ifndef CONFIG_XSS
1445     return 0;
1446 #else
1447     int event, error, major, minor;
1448     if (XScreenSaverQueryExtension(mDisplay, &event, &error) != True ||
1449         XScreenSaverQueryVersion(mDisplay, &major, &minor) != True)
1450         return 0;
1451     if (major < 1 || (major == 1 && minor < 1))
1452         return 0;
1453     XScreenSaverSuspend(mDisplay, suspend);
1454     return 1;
1455 #endif
1456 }
1457
1458 /*
1459  * End of XScreensaver stuff
1460  */
1461
1462 void saver_on(Display * mDisplay)
1463 {
1464
1465     if (!screensaver_off)
1466         return;
1467     screensaver_off = 0;
1468     if (xss_suspend(False))
1469         return;
1470 #ifdef CONFIG_XDPMS
1471     if (dpms_disabled)
1472     {
1473         int nothing;
1474         if (DPMSQueryExtension(mDisplay, &nothing, &nothing))
1475         {
1476             if (!DPMSEnable(mDisplay))
1477             {                   // restoring power saving settings
1478                 mp_msg(MSGT_VO, MSGL_WARN, "DPMS not available?\n");
1479             } else
1480             {
1481                 // DPMS does not seem to be enabled unless we call DPMSInfo
1482                 BOOL onoff;
1483                 CARD16 state;
1484
1485                 DPMSForceLevel(mDisplay, DPMSModeOn);
1486                 DPMSInfo(mDisplay, &state, &onoff);
1487                 if (onoff)
1488                 {
1489                     mp_msg(MSGT_VO, MSGL_V,
1490                            "Successfully enabled DPMS\n");
1491                 } else
1492                 {
1493                     mp_msg(MSGT_VO, MSGL_WARN, "Could not enable DPMS\n");
1494                 }
1495             }
1496         }
1497         dpms_disabled = 0;
1498     }
1499 #endif
1500 }
1501
1502 void saver_off(Display * mDisplay)
1503 {
1504     int nothing;
1505
1506     if (screensaver_off)
1507         return;
1508     screensaver_off = 1;
1509     if (xss_suspend(True))
1510         return;
1511 #ifdef CONFIG_XDPMS
1512     if (DPMSQueryExtension(mDisplay, &nothing, &nothing))
1513     {
1514         BOOL onoff;
1515         CARD16 state;
1516
1517         DPMSInfo(mDisplay, &state, &onoff);
1518         if (onoff)
1519         {
1520             Status stat;
1521
1522             mp_msg(MSGT_VO, MSGL_V, "Disabling DPMS\n");
1523             dpms_disabled = 1;
1524             stat = DPMSDisable(mDisplay);       // monitor powersave off
1525             mp_msg(MSGT_VO, MSGL_V, "DPMSDisable stat: %d\n", stat);
1526         }
1527     }
1528 #endif
1529 }
1530
1531 static XErrorHandler old_handler = NULL;
1532 static int selectinput_err = 0;
1533 static int x11_selectinput_errorhandler(Display * display,
1534                                         XErrorEvent * event)
1535 {
1536     if (event->error_code == BadAccess)
1537     {
1538         selectinput_err = 1;
1539         mp_msg(MSGT_VO, MSGL_ERR,
1540                "X11 error: BadAccess during XSelectInput Call\n");
1541         mp_msg(MSGT_VO, MSGL_ERR,
1542                "X11 error: The 'ButtonPressMask' mask of specified window has probably already used by another appication (see man XSelectInput)\n");
1543         /* If you think MPlayer should shutdown with this error,
1544          * comment out the following line */
1545         return 0;
1546     }
1547     if (old_handler != NULL)
1548         old_handler(display, event);
1549     else
1550         x11_errorhandler(display, event);
1551     return 0;
1552 }
1553
1554 void vo_x11_selectinput_witherr(Display * display, Window w,
1555                                 long event_mask)
1556 {
1557     XSync(display, False);
1558     old_handler = XSetErrorHandler(x11_selectinput_errorhandler);
1559     selectinput_err = 0;
1560     if (vo_nomouse_input)
1561     {
1562         XSelectInput(display, w,
1563                      event_mask &
1564                      (~(ButtonPressMask | ButtonReleaseMask)));
1565     } else
1566     {
1567         XSelectInput(display, w, event_mask);
1568     }
1569     XSync(display, False);
1570     XSetErrorHandler(old_handler);
1571     if (selectinput_err)
1572     {
1573         mp_msg(MSGT_VO, MSGL_ERR,
1574                "X11 error: MPlayer discards mouse control (reconfiguring)\n");
1575         XSelectInput(display, w,
1576                      event_mask &
1577                      (~
1578                       (ButtonPressMask | ButtonReleaseMask |
1579                        PointerMotionMask)));
1580     }
1581 }
1582
1583 #ifdef CONFIG_XF86VM
1584 void vo_vm_switch(void)
1585 {
1586     int vm_event, vm_error;
1587     int vm_ver, vm_rev;
1588     int i, j, have_vm = 0;
1589     int X = vo_dwidth, Y = vo_dheight;
1590     int modeline_width, modeline_height;
1591
1592     int modecount;
1593
1594     if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error))
1595     {
1596         XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev);
1597         mp_msg(MSGT_VO, MSGL_V, "XF86VidMode extension v%i.%i\n", vm_ver,
1598                vm_rev);
1599         have_vm = 1;
1600     } else {
1601         mp_msg(MSGT_VO, MSGL_WARN,
1602                "XF86VidMode extension not available.\n");
1603     }
1604
1605     if (have_vm)
1606     {
1607         if (vidmodes == NULL)
1608             XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
1609                                        &vidmodes);
1610         j = 0;
1611         modeline_width = vidmodes[0]->hdisplay;
1612         modeline_height = vidmodes[0]->vdisplay;
1613
1614         for (i = 1; i < modecount; i++)
1615             if ((vidmodes[i]->hdisplay >= X)
1616                 && (vidmodes[i]->vdisplay >= Y))
1617                 if ((vidmodes[i]->hdisplay <= modeline_width)
1618                     && (vidmodes[i]->vdisplay <= modeline_height))
1619                 {
1620                     modeline_width = vidmodes[i]->hdisplay;
1621                     modeline_height = vidmodes[i]->vdisplay;
1622                     j = i;
1623                 }
1624
1625         mp_msg(MSGT_VO, MSGL_INFO, MSGTR_SelectedVideoMode,
1626                modeline_width, modeline_height, X, Y);
1627         XF86VidModeLockModeSwitch(mDisplay, mScreen, 0);
1628         XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]);
1629         XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]);
1630
1631         // FIXME: all this is more of a hack than proper solution
1632         X = (vo_screenwidth - modeline_width) / 2;
1633         Y = (vo_screenheight - modeline_height) / 2;
1634         XF86VidModeSetViewPort(mDisplay, mScreen, X, Y);
1635         vo_dx = X;
1636         vo_dy = Y;
1637         vo_dwidth = modeline_width;
1638         vo_dheight = modeline_height;
1639         aspect_save_screenres(modeline_width, modeline_height);
1640     }
1641 }
1642
1643 void vo_vm_close(void)
1644 {
1645 #ifdef CONFIG_GUI
1646     if (vidmodes != NULL && vo_window != None)
1647 #else
1648     if (vidmodes != NULL)
1649 #endif
1650     {
1651         int i, modecount;
1652
1653         free(vidmodes);
1654         vidmodes = NULL;
1655         XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
1656                                    &vidmodes);
1657         for (i = 0; i < modecount; i++)
1658             if ((vidmodes[i]->hdisplay == vo_screenwidth)
1659                 && (vidmodes[i]->vdisplay == vo_screenheight))
1660             {
1661                 mp_msg(MSGT_VO, MSGL_INFO,
1662                        "Returning to original mode %dx%d\n",
1663                        vo_screenwidth, vo_screenheight);
1664                 break;
1665             }
1666
1667         XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]);
1668         XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]);
1669         free(vidmodes);
1670         vidmodes = NULL;
1671     }
1672 }
1673 #endif
1674
1675 #endif                          /* X11_FULLSCREEN */
1676
1677
1678 /*
1679  * Scan the available visuals on this Display/Screen.  Try to find
1680  * the 'best' available TrueColor visual that has a decent color
1681  * depth (at least 15bit).  If there are multiple visuals with depth
1682  * >= 15bit, we prefer visuals with a smaller color depth.
1683  */
1684 int vo_find_depth_from_visuals(Display * dpy, int screen,
1685                                Visual ** visual_return)
1686 {
1687     XVisualInfo visual_tmpl;
1688     XVisualInfo *visuals;
1689     int nvisuals, i;
1690     int bestvisual = -1;
1691     int bestvisual_depth = -1;
1692
1693     visual_tmpl.screen = screen;
1694     visual_tmpl.class = TrueColor;
1695     visuals = XGetVisualInfo(dpy,
1696                              VisualScreenMask | VisualClassMask,
1697                              &visual_tmpl, &nvisuals);
1698     if (visuals != NULL)
1699     {
1700         for (i = 0; i < nvisuals; i++)
1701         {
1702             mp_msg(MSGT_VO, MSGL_V,
1703                    "vo: X11 truecolor visual %#lx, depth %d, R:%lX G:%lX B:%lX\n",
1704                    visuals[i].visualid, visuals[i].depth,
1705                    visuals[i].red_mask, visuals[i].green_mask,
1706                    visuals[i].blue_mask);
1707             /*
1708              * Save the visual index and its depth, if this is the first
1709              * truecolor visul, or a visual that is 'preferred' over the
1710              * previous 'best' visual.
1711              */
1712             if (bestvisual_depth == -1
1713                 || (visuals[i].depth >= 15
1714                     && (visuals[i].depth < bestvisual_depth
1715                         || bestvisual_depth < 15)))
1716             {
1717                 bestvisual = i;
1718                 bestvisual_depth = visuals[i].depth;
1719             }
1720         }
1721
1722         if (bestvisual != -1 && visual_return != NULL)
1723             *visual_return = visuals[bestvisual].visual;
1724
1725         XFree(visuals);
1726     }
1727     return bestvisual_depth;
1728 }
1729
1730
1731 static Colormap cmap = None;
1732 static XColor cols[256];
1733 static int cm_size, red_mask, green_mask, blue_mask;
1734
1735
1736 Colormap vo_x11_create_colormap(XVisualInfo * vinfo)
1737 {
1738     unsigned k, r, g, b, ru, gu, bu, m, rv, gv, bv, rvu, gvu, bvu;
1739
1740     if (vinfo->class != DirectColor)
1741         return XCreateColormap(mDisplay, mRootWin, vinfo->visual,
1742                                AllocNone);
1743
1744     /* can this function get called twice or more? */
1745     if (cmap)
1746         return cmap;
1747     cm_size = vinfo->colormap_size;
1748     red_mask = vinfo->red_mask;
1749     green_mask = vinfo->green_mask;
1750     blue_mask = vinfo->blue_mask;
1751     ru = (red_mask & (red_mask - 1)) ^ red_mask;
1752     gu = (green_mask & (green_mask - 1)) ^ green_mask;
1753     bu = (blue_mask & (blue_mask - 1)) ^ blue_mask;
1754     rvu = 65536ull * ru / (red_mask + ru);
1755     gvu = 65536ull * gu / (green_mask + gu);
1756     bvu = 65536ull * bu / (blue_mask + bu);
1757     r = g = b = 0;
1758     rv = gv = bv = 0;
1759     m = DoRed | DoGreen | DoBlue;
1760     for (k = 0; k < cm_size; k++)
1761     {
1762         int t;
1763
1764         cols[k].pixel = r | g | b;
1765         cols[k].red = rv;
1766         cols[k].green = gv;
1767         cols[k].blue = bv;
1768         cols[k].flags = m;
1769         t = (r + ru) & red_mask;
1770         if (t < r)
1771             m &= ~DoRed;
1772         r = t;
1773         t = (g + gu) & green_mask;
1774         if (t < g)
1775             m &= ~DoGreen;
1776         g = t;
1777         t = (b + bu) & blue_mask;
1778         if (t < b)
1779             m &= ~DoBlue;
1780         b = t;
1781         rv += rvu;
1782         gv += gvu;
1783         bv += bvu;
1784     }
1785     cmap = XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocAll);
1786     XStoreColors(mDisplay, cmap, cols, cm_size);
1787     return cmap;
1788 }
1789
1790 /*
1791  * Via colormaps/gamma ramps we can do gamma, brightness, contrast,
1792  * hue and red/green/blue intensity, but we cannot do saturation.
1793  * Currently only gamma, brightness and contrast are implemented.
1794  * Is there sufficient interest for hue and/or red/green/blue intensity?
1795  */
1796 /* these values have range [-100,100] and are initially 0 */
1797 static int vo_gamma = 0;
1798 static int vo_brightness = 0;
1799 static int vo_contrast = 0;
1800
1801 static int transform_color(float val,
1802                            float brightness, float contrast, float gamma) {
1803     float s = pow(val, gamma);
1804     s = (s - 0.5) * contrast + 0.5;
1805     s += brightness;
1806     if (s < 0)
1807         s = 0;
1808     if (s > 1)
1809         s = 1;
1810     return (unsigned short) (s * 65535);
1811 }
1812
1813 uint32_t vo_x11_set_equalizer(char *name, int value)
1814 {
1815     float gamma, brightness, contrast;
1816     float rf, gf, bf;
1817     int k;
1818
1819     /*
1820      * IMPLEMENTME: consider using XF86VidModeSetGammaRamp in the case
1821      * of TrueColor-ed window but be careful:
1822      * Unlike the colormaps, which are private for the X client
1823      * who created them and thus automatically destroyed on client
1824      * disconnect, this gamma ramp is a system-wide (X-server-wide)
1825      * setting and _must_ be restored before the process exits.
1826      * Unforunately when the process crashes (or gets killed
1827      * for some reason) it is impossible to restore the setting,
1828      * and such behaviour could be rather annoying for the users.
1829      */
1830     if (cmap == None)
1831         return VO_NOTAVAIL;
1832
1833     if (!strcasecmp(name, "brightness"))
1834         vo_brightness = value;
1835     else if (!strcasecmp(name, "contrast"))
1836         vo_contrast = value;
1837     else if (!strcasecmp(name, "gamma"))
1838         vo_gamma = value;
1839     else
1840         return VO_NOTIMPL;
1841
1842     brightness = 0.01 * vo_brightness;
1843     contrast = tan(0.0095 * (vo_contrast + 100) * M_PI / 4);
1844     gamma = pow(2, -0.02 * vo_gamma);
1845
1846     rf = (float) ((red_mask & (red_mask - 1)) ^ red_mask) / red_mask;
1847     gf = (float) ((green_mask & (green_mask - 1)) ^ green_mask) /
1848         green_mask;
1849     bf = (float) ((blue_mask & (blue_mask - 1)) ^ blue_mask) / blue_mask;
1850
1851     /* now recalculate the colormap using the newly set value */
1852     for (k = 0; k < cm_size; k++)
1853     {
1854         cols[k].red   = transform_color(rf * k, brightness, contrast, gamma);
1855         cols[k].green = transform_color(gf * k, brightness, contrast, gamma);
1856         cols[k].blue  = transform_color(bf * k, brightness, contrast, gamma);
1857     }
1858
1859     XStoreColors(mDisplay, cmap, cols, cm_size);
1860     XFlush(mDisplay);
1861     return VO_TRUE;
1862 }
1863
1864 uint32_t vo_x11_get_equalizer(char *name, int *value)
1865 {
1866     if (cmap == None)
1867         return VO_NOTAVAIL;
1868     if (!strcasecmp(name, "brightness"))
1869         *value = vo_brightness;
1870     else if (!strcasecmp(name, "contrast"))
1871         *value = vo_contrast;
1872     else if (!strcasecmp(name, "gamma"))
1873         *value = vo_gamma;
1874     else
1875         return VO_NOTIMPL;
1876     return VO_TRUE;
1877 }
1878
1879 #ifdef CONFIG_XV
1880 int vo_xv_set_eq(uint32_t xv_port, char *name, int value)
1881 {
1882     XvAttribute *attributes;
1883     int i, howmany, xv_atom;
1884
1885     mp_dbg(MSGT_VO, MSGL_V, "xv_set_eq called! (%s, %d)\n", name, value);
1886
1887     /* get available attributes */
1888     attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
1889     for (i = 0; i < howmany && attributes; i++)
1890         if (attributes[i].flags & XvSettable)
1891         {
1892             xv_atom = XInternAtom(mDisplay, attributes[i].name, True);
1893 /* since we have SET_DEFAULTS first in our list, we can check if it's available
1894    then trigger it if it's ok so that the other values are at default upon query */
1895             if (xv_atom != None)
1896             {
1897                 int hue = 0, port_value, port_min, port_max;
1898
1899                 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") &&
1900                     (!strcasecmp(name, "brightness")))
1901                     port_value = value;
1902                 else if (!strcmp(attributes[i].name, "XV_CONTRAST") &&
1903                          (!strcasecmp(name, "contrast")))
1904                     port_value = value;
1905                 else if (!strcmp(attributes[i].name, "XV_SATURATION") &&
1906                          (!strcasecmp(name, "saturation")))
1907                     port_value = value;
1908                 else if (!strcmp(attributes[i].name, "XV_HUE") &&
1909                          (!strcasecmp(name, "hue")))
1910                 {
1911                     port_value = value;
1912                     hue = 1;
1913                 } else
1914                     /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
1915                 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") &&
1916                         (!strcasecmp(name, "red_intensity")))
1917                     port_value = value;
1918                 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY")
1919                          && (!strcasecmp(name, "green_intensity")))
1920                     port_value = value;
1921                 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY")
1922                          && (!strcasecmp(name, "blue_intensity")))
1923                     port_value = value;
1924                 else
1925                     continue;
1926
1927                 port_min = attributes[i].min_value;
1928                 port_max = attributes[i].max_value;
1929
1930                 /* nvidia hue workaround */
1931                 if (hue && port_min == 0 && port_max == 360)
1932                 {
1933                     port_value =
1934                         (port_value >=
1935                          0) ? (port_value - 100) : (port_value + 100);
1936                 }
1937                 // -100 -> min
1938                 //   0  -> (max+min)/2
1939                 // +100 -> max
1940                 port_value =
1941                     (port_value + 100) * (port_max - port_min) / 200 +
1942                     port_min;
1943                 XvSetPortAttribute(mDisplay, xv_port, xv_atom, port_value);
1944                 return VO_TRUE;
1945             }
1946         }
1947     return VO_FALSE;
1948 }
1949
1950 int vo_xv_get_eq(uint32_t xv_port, char *name, int *value)
1951 {
1952
1953     XvAttribute *attributes;
1954     int i, howmany, xv_atom;
1955
1956     /* get available attributes */
1957     attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
1958     for (i = 0; i < howmany && attributes; i++)
1959         if (attributes[i].flags & XvGettable)
1960         {
1961             xv_atom = XInternAtom(mDisplay, attributes[i].name, True);
1962 /* since we have SET_DEFAULTS first in our list, we can check if it's available
1963    then trigger it if it's ok so that the other values are at default upon query */
1964             if (xv_atom != None)
1965             {
1966                 int val, port_value = 0, port_min, port_max;
1967
1968                 XvGetPortAttribute(mDisplay, xv_port, xv_atom,
1969                                    &port_value);
1970
1971                 port_min = attributes[i].min_value;
1972                 port_max = attributes[i].max_value;
1973                 val =
1974                     (port_value - port_min) * 200 / (port_max - port_min) -
1975                     100;
1976
1977                 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") &&
1978                     (!strcasecmp(name, "brightness")))
1979                     *value = val;
1980                 else if (!strcmp(attributes[i].name, "XV_CONTRAST") &&
1981                          (!strcasecmp(name, "contrast")))
1982                     *value = val;
1983                 else if (!strcmp(attributes[i].name, "XV_SATURATION") &&
1984                          (!strcasecmp(name, "saturation")))
1985                     *value = val;
1986                 else if (!strcmp(attributes[i].name, "XV_HUE") &&
1987                          (!strcasecmp(name, "hue")))
1988                 {
1989                     /* nasty nvidia detect */
1990                     if (port_min == 0 && port_max == 360)
1991                         *value = (val >= 0) ? (val - 100) : (val + 100);
1992                     else
1993                         *value = val;
1994                 } else
1995                     /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
1996                 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") &&
1997                         (!strcasecmp(name, "red_intensity")))
1998                     *value = val;
1999                 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY")
2000                          && (!strcasecmp(name, "green_intensity")))
2001                     *value = val;
2002                 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY")
2003                          && (!strcasecmp(name, "blue_intensity")))
2004                     *value = val;
2005                 else
2006                     continue;
2007
2008                 mp_dbg(MSGT_VO, MSGL_V, "xv_get_eq called! (%s, %d)\n",
2009                        name, *value);
2010                 return VO_TRUE;
2011             }
2012         }
2013     return VO_FALSE;
2014 }
2015
2016 /** \brief contains flags changing the execution of the colorkeying code */
2017 xv_ck_info_t xv_ck_info = { CK_METHOD_MANUALFILL, CK_SRC_CUR };
2018 unsigned long xv_colorkey; ///< The color used for manual colorkeying.
2019 unsigned int xv_port; ///< The selected Xv port.
2020
2021 /**
2022  * \brief Interns the requested atom if it is available.
2023  *
2024  * \param atom_name String containing the name of the requested atom.
2025  *
2026  * \return Returns the atom if available, else None is returned.
2027  *
2028  */
2029 static Atom xv_intern_atom_if_exists( char const * atom_name )
2030 {
2031   XvAttribute * attributes;
2032   int attrib_count,i;
2033   Atom xv_atom = None;
2034
2035   attributes = XvQueryPortAttributes( mDisplay, xv_port, &attrib_count );
2036   if( attributes!=NULL )
2037   {
2038     for ( i = 0; i < attrib_count; ++i )
2039     {
2040       if ( strcmp(attributes[i].name, atom_name ) == 0 )
2041       {
2042         xv_atom = XInternAtom( mDisplay, atom_name, False );
2043         break; // found what we want, break out
2044       }
2045     }
2046     XFree( attributes );
2047   }
2048
2049   return xv_atom;
2050 }
2051
2052 /**
2053  * \brief Try to enable vsync for xv.
2054  * \return Returns -1 if not available, 0 on failure and 1 on success.
2055  */
2056 int vo_xv_enable_vsync(void)
2057 {
2058   Atom xv_atom = xv_intern_atom_if_exists("XV_SYNC_TO_VBLANK");
2059   if (xv_atom == None)
2060     return -1;
2061   return XvSetPortAttribute(mDisplay, xv_port, xv_atom, 1) == Success;
2062 }
2063
2064 /**
2065  * \brief Get maximum supported source image dimensions.
2066  *
2067  *   This function does not set the variables pointed to by
2068  * width and height if the information could not be retrieved,
2069  * so the caller is reponsible for properly initializing them.
2070  *
2071  * \param width [out] The maximum width gets stored here.
2072  * \param height [out] The maximum height gets stored here.
2073  *
2074  */
2075 void vo_xv_get_max_img_dim( uint32_t * width, uint32_t * height )
2076 {
2077   XvEncodingInfo * encodings;
2078   //unsigned long num_encodings, idx; to int or too long?!
2079   unsigned int num_encodings, idx;
2080
2081   XvQueryEncodings( mDisplay, xv_port, &num_encodings, &encodings);
2082
2083   if ( encodings )
2084   {
2085       for ( idx = 0; idx < num_encodings; ++idx )
2086       {
2087           if ( strcmp( encodings[idx].name, "XV_IMAGE" ) == 0 )
2088           {
2089               *width  = encodings[idx].width;
2090               *height = encodings[idx].height;
2091               break;
2092           }
2093       }
2094   }
2095
2096   mp_msg( MSGT_VO, MSGL_V,
2097           "[xv common] Maximum source image dimensions: %ux%u\n",
2098           *width, *height );
2099
2100   XvFreeEncodingInfo( encodings );
2101 }
2102
2103 /**
2104  * \brief Print information about the colorkey method and source.
2105  *
2106  * \param ck_handling Integer value containing the information about
2107  *                    colorkey handling (see x11_common.h).
2108  *
2109  * Outputs the content of |ck_handling| as a readable message.
2110  *
2111  */
2112 void vo_xv_print_ck_info(void)
2113 {
2114   mp_msg( MSGT_VO, MSGL_V, "[xv common] " );
2115
2116   switch ( xv_ck_info.method )
2117   {
2118     case CK_METHOD_NONE:
2119       mp_msg( MSGT_VO, MSGL_V, "Drawing no colorkey.\n" ); return;
2120     case CK_METHOD_AUTOPAINT:
2121       mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn by Xv." ); break;
2122     case CK_METHOD_MANUALFILL:
2123       mp_msg( MSGT_VO, MSGL_V, "Drawing colorkey manually." ); break;
2124     case CK_METHOD_BACKGROUND:
2125       mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn as window background." ); break;
2126   }
2127
2128   mp_msg( MSGT_VO, MSGL_V, "\n[xv common] " );
2129
2130   switch ( xv_ck_info.source )
2131   {
2132     case CK_SRC_CUR:
2133       mp_msg( MSGT_VO, MSGL_V, "Using colorkey from Xv (0x%06lx).\n",
2134               xv_colorkey );
2135       break;
2136     case CK_SRC_USE:
2137       if ( xv_ck_info.method == CK_METHOD_AUTOPAINT )
2138       {
2139         mp_msg( MSGT_VO, MSGL_V,
2140                 "Ignoring colorkey from MPlayer (0x%06lx).\n",
2141                 xv_colorkey );
2142       }
2143       else
2144       {
2145         mp_msg( MSGT_VO, MSGL_V,
2146                 "Using colorkey from MPlayer (0x%06lx)."
2147                 " Use -colorkey to change.\n",
2148                 xv_colorkey );
2149       }
2150       break;
2151     case CK_SRC_SET:
2152       mp_msg( MSGT_VO, MSGL_V,
2153               "Setting and using colorkey from MPlayer (0x%06lx)."
2154               " Use -colorkey to change.\n",
2155               xv_colorkey );
2156       break;
2157   }
2158 }
2159 /**
2160  * \brief Init colorkey depending on the settings in xv_ck_info.
2161  *
2162  * \return Returns 0 on failure and 1 on success.
2163  *
2164  * Sets the colorkey variable according to the CK_SRC_* and CK_METHOD_*
2165  * flags in xv_ck_info.
2166  *
2167  * Possiblilities:
2168  *   * Methods
2169  *     - manual colorkey drawing ( CK_METHOD_MANUALFILL )
2170  *     - set colorkey as window background ( CK_METHOD_BACKGROUND )
2171  *     - let Xv paint the colorkey ( CK_METHOD_AUTOPAINT )
2172  *   * Sources
2173  *     - use currently set colorkey ( CK_SRC_CUR )
2174  *     - use colorkey in vo_colorkey ( CK_SRC_USE )
2175  *     - use and set colorkey in vo_colorkey ( CK_SRC_SET )
2176  *
2177  * NOTE: If vo_colorkey has bits set after the first 3 low order bytes
2178  *       we don't draw anything as this means it was forced to off.
2179  */
2180 int vo_xv_init_colorkey(void)
2181 {
2182   Atom xv_atom;
2183   int rez;
2184
2185   /* check if colorkeying is needed */
2186   xv_atom = xv_intern_atom_if_exists( "XV_COLORKEY" );
2187
2188   /* if we have to deal with colorkeying ... */
2189   if( xv_atom != None && !(vo_colorkey & 0xFF000000) )
2190   {
2191     /* check if we should use the colorkey specified in vo_colorkey */
2192     if ( xv_ck_info.source != CK_SRC_CUR )
2193     {
2194       xv_colorkey = vo_colorkey;
2195
2196       /* check if we have to set the colorkey too */
2197       if ( xv_ck_info.source == CK_SRC_SET )
2198       {
2199         xv_atom = XInternAtom(mDisplay, "XV_COLORKEY",False);
2200
2201         rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, vo_colorkey );
2202         if ( rez != Success )
2203         {
2204           mp_msg( MSGT_VO, MSGL_FATAL,
2205                   "[xv common] Couldn't set colorkey!\n" );
2206           return 0; // error setting colorkey
2207         }
2208       }
2209     }
2210     else
2211     {
2212       int colorkey_ret;
2213
2214       rez=XvGetPortAttribute(mDisplay,xv_port, xv_atom, &colorkey_ret);
2215       if ( rez == Success )
2216       {
2217          xv_colorkey = colorkey_ret;
2218       }
2219       else
2220       {
2221         mp_msg( MSGT_VO, MSGL_FATAL,
2222                 "[xv common] Couldn't get colorkey!"
2223                 "Maybe the selected Xv port has no overlay.\n" );
2224         return 0; // error getting colorkey
2225       }
2226     }
2227
2228     xv_atom = xv_intern_atom_if_exists( "XV_AUTOPAINT_COLORKEY" );
2229
2230     /* should we draw the colorkey ourselves or activate autopainting? */
2231     if ( xv_ck_info.method == CK_METHOD_AUTOPAINT )
2232     {
2233       rez = !Success; // reset rez to something different than Success
2234
2235       if ( xv_atom != None ) // autopaint is supported
2236       {
2237         rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, 1 );
2238       }
2239
2240       if ( rez != Success )
2241       {
2242         // fallback to manual colorkey drawing
2243         xv_ck_info.method = CK_METHOD_MANUALFILL;
2244       }
2245     }
2246     else // disable colorkey autopainting if supported
2247     {
2248       if ( xv_atom != None ) // we have autopaint attribute
2249       {
2250         XvSetPortAttribute( mDisplay, xv_port, xv_atom, 0 );
2251       }
2252     }
2253   }
2254   else // do no colorkey drawing at all
2255   {
2256     xv_ck_info.method = CK_METHOD_NONE;
2257   } /* end: should we draw colorkey */
2258
2259   /* output information about the current colorkey settings */
2260   vo_xv_print_ck_info();
2261
2262   return 1; // success
2263 }
2264
2265 /**
2266  * \brief Draw the colorkey on the video window.
2267  *
2268  * Draws the colorkey depending on the set method ( colorkey_handling ).
2269  *
2270  * Also draws the black bars ( when the video doesn't fit the display in
2271  * fullscreen ) separately, so they don't overlap with the video area.
2272  * It doesn't call XFlush.
2273  *
2274  */
2275 void vo_xv_draw_colorkey(  int32_t x,  int32_t y,
2276                                   int32_t w,  int32_t h  )
2277 {
2278   if( xv_ck_info.method == CK_METHOD_MANUALFILL ||
2279       xv_ck_info.method == CK_METHOD_BACKGROUND   )//less tearing than XClearWindow()
2280   {
2281     XSetForeground( mDisplay, vo_gc, xv_colorkey );
2282     XFillRectangle( mDisplay, vo_window, vo_gc,
2283                     x, y,
2284                     w, h );
2285   }
2286
2287   /* draw black bars if needed */
2288   /* TODO! move this to vo_x11_clearwindow_part() */
2289   if ( vo_fs )
2290   {
2291     XSetForeground( mDisplay, vo_gc, 0 );
2292     /* making non-overlap fills, requires 8 checks instead of 4 */
2293     if ( y > 0 )
2294       XFillRectangle( mDisplay, vo_window, vo_gc,
2295                       0, 0,
2296                       vo_screenwidth, y);
2297     if (x > 0)
2298       XFillRectangle( mDisplay, vo_window, vo_gc,
2299                       0, 0,
2300                       x, vo_screenheight);
2301     if (x + w < vo_screenwidth)
2302       XFillRectangle( mDisplay, vo_window, vo_gc,
2303                       x + w, 0,
2304                       vo_screenwidth, vo_screenheight);
2305     if (y + h < vo_screenheight)
2306       XFillRectangle( mDisplay, vo_window, vo_gc,
2307                       0, y + h,
2308                       vo_screenwidth, vo_screenheight);
2309   }
2310 }
2311
2312 /** \brief Tests if a valid argument for the ck suboption was given. */
2313 int xv_test_ck( void * arg )
2314 {
2315   strarg_t * strarg = (strarg_t *)arg;
2316
2317   if ( strargcmp( strarg, "use" ) == 0 ||
2318        strargcmp( strarg, "set" ) == 0 ||
2319        strargcmp( strarg, "cur" ) == 0    )
2320   {
2321     return 1;
2322   }
2323
2324   return 0;
2325 }
2326 /** \brief Tests if a valid arguments for the ck-method suboption was given. */
2327 int xv_test_ckm( void * arg )
2328 {
2329   strarg_t * strarg = (strarg_t *)arg;
2330
2331   if ( strargcmp( strarg, "bg" ) == 0 ||
2332        strargcmp( strarg, "man" ) == 0 ||
2333        strargcmp( strarg, "auto" ) == 0    )
2334   {
2335     return 1;
2336   }
2337
2338   return 0;
2339 }
2340
2341 /**
2342  * \brief Modify the colorkey_handling var according to str
2343  *
2344  * Checks if a valid pointer ( not NULL ) to the string
2345  * was given. And in that case modifies the colorkey_handling
2346  * var to reflect the requested behaviour.
2347  * If nothing happens the content of colorkey_handling stays
2348  * the same.
2349  *
2350  * \param str Pointer to the string or NULL
2351  *
2352  */
2353 void xv_setup_colorkeyhandling( char const * ck_method_str,
2354                                 char const * ck_str )
2355 {
2356   /* check if a valid pointer to the string was passed */
2357   if ( ck_str )
2358   {
2359     if ( strncmp( ck_str, "use", 3 ) == 0 )
2360     {
2361       xv_ck_info.source = CK_SRC_USE;
2362     }
2363     else if ( strncmp( ck_str, "set", 3 ) == 0 )
2364     {
2365       xv_ck_info.source = CK_SRC_SET;
2366     }
2367   }
2368   /* check if a valid pointer to the string was passed */
2369   if ( ck_method_str )
2370   {
2371     if ( strncmp( ck_method_str, "bg", 2 ) == 0 )
2372     {
2373       xv_ck_info.method = CK_METHOD_BACKGROUND;
2374     }
2375     else if ( strncmp( ck_method_str, "man", 3 ) == 0 )
2376     {
2377       xv_ck_info.method = CK_METHOD_MANUALFILL;
2378     }
2379     else if ( strncmp( ck_method_str, "auto", 4 ) == 0 )
2380     {
2381       xv_ck_info.method = CK_METHOD_AUTOPAINT;
2382     }
2383   }
2384 }
2385
2386 #endif