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