?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sync with en/mplayer.1 r28991
[mplayer/glamo.git] / libvo / x11_common.c
blob16a97d578c7e7a655241ec51362a1e2706c0525c
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 else if (vo_fs) {
1139 // if we are already in fullscreen do not switch back and forth, just
1140 // set the size values right.
1141 vo_dwidth = vo_screenwidth;
1142 vo_dheight = vo_screenheight;
1143 }
1144 final:
1145 if (vo_gc != None)
1146 XFreeGC(mDisplay, vo_gc);
1147 vo_gc = XCreateGC(mDisplay, vo_window, GCForeground, &xgcv);
1148 XSync(mDisplay, False);
1149 vo_mouse_autohide = 1;
1150 }
1151
1152 void vo_x11_clearwindow_part(Display * mDisplay, Window vo_window,
1153 int img_width, int img_height, int use_fs)
1154 {
1155 int u_dheight, u_dwidth, left_ov, left_ov2;
1156
1157 if (!f_gc)
1158 return;
1159
1160 u_dheight = use_fs ? vo_screenheight : vo_dheight;
1161 u_dwidth = use_fs ? vo_screenwidth : vo_dwidth;
1162 if ((u_dheight <= img_height) && (u_dwidth <= img_width))
1163 return;
1164
1165 left_ov = (u_dheight - img_height) / 2;
1166 left_ov2 = (u_dwidth - img_width) / 2;
1167
1168 XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, u_dwidth, left_ov);
1169 XFillRectangle(mDisplay, vo_window, f_gc, 0, u_dheight - left_ov - 1,
1170 u_dwidth, left_ov + 1);
1171
1172 if (u_dwidth > img_width)
1173 {
1174 XFillRectangle(mDisplay, vo_window, f_gc, 0, left_ov, left_ov2,
1175 img_height);
1176 XFillRectangle(mDisplay, vo_window, f_gc, u_dwidth - left_ov2 - 1,
1177 left_ov, left_ov2 + 1, img_height);
1178 }
1179
1180 XFlush(mDisplay);
1181 }
1182
1183 void vo_x11_clearwindow(Display * mDisplay, Window vo_window)
1184 {
1185 if (!f_gc)
1186 return;
1187 XFillRectangle(mDisplay, vo_window, f_gc, 0, 0, vo_screenwidth,
1188 vo_screenheight);
1189 //
1190 XFlush(mDisplay);
1191 }
1192
1193
1194 void vo_x11_setlayer(Display * mDisplay, Window vo_window, int layer)
1195 {
1196 if (WinID >= 0)
1197 return;
1198
1199 if (vo_fs_type & vo_wm_LAYER)
1200 {
1201 XClientMessageEvent xev;
1202
1203 if (!orig_layer)
1204 orig_layer = vo_x11_get_gnome_layer(mDisplay, vo_window);
1205
1206 memset(&xev, 0, sizeof(xev));
1207 xev.type = ClientMessage;
1208 xev.display = mDisplay;
1209 xev.window = vo_window;
1210 xev.message_type = XA_WIN_LAYER;
1211 xev.format = 32;
1212 xev.data.l[0] = layer ? fs_layer : orig_layer; // if not fullscreen, stay on default layer
1213 xev.data.l[1] = CurrentTime;
1214 mp_msg(MSGT_VO, MSGL_V,
1215 "[x11] Layered style stay on top (layer %ld).\n",
1216 xev.data.l[0]);
1217 XSendEvent(mDisplay, mRootWin, False, SubstructureNotifyMask,
1218 (XEvent *) & xev);
1219 } else if (vo_fs_type & vo_wm_NETWM)
1220 {
1221 XClientMessageEvent xev;
1222 char *state;
1223
1224 memset(&xev, 0, sizeof(xev));
1225 xev.type = ClientMessage;
1226 xev.message_type = XA_NET_WM_STATE;
1227 xev.display = mDisplay;
1228 xev.window = vo_window;
1229 xev.format = 32;
1230 xev.data.l[0] = layer;
1231
1232 if (vo_fs_type & vo_wm_STAYS_ON_TOP)
1233 xev.data.l[1] = XA_NET_WM_STATE_STAYS_ON_TOP;
1234 else if (vo_fs_type & vo_wm_ABOVE)
1235 xev.data.l[1] = XA_NET_WM_STATE_ABOVE;
1236 else if (vo_fs_type & vo_wm_FULLSCREEN)
1237 xev.data.l[1] = XA_NET_WM_STATE_FULLSCREEN;
1238 else if (vo_fs_type & vo_wm_BELOW)
1239 // This is not fallback. We can safely assume that the situation
1240 // where only NETWM_STATE_BELOW is supported doesn't exist.
1241 xev.data.l[1] = XA_NET_WM_STATE_BELOW;
1242
1243 XSendEvent(mDisplay, mRootWin, False, SubstructureRedirectMask,
1244 (XEvent *) & xev);
1245 state = XGetAtomName(mDisplay, xev.data.l[1]);
1246 mp_msg(MSGT_VO, MSGL_V,
1247 "[x11] NET style stay on top (layer %d). Using state %s.\n",
1248 layer, state);
1249 XFree(state);
1250 }
1251 }
1252
1253 static int vo_x11_get_fs_type(int supported)
1254 {
1255 int i;
1256 int type = supported;
1257
1258 if (vo_fstype_list)
1259 {
1260 i = 0;
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 return 0;
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 return depth <= INT_MAX ? depth : 0;
1339 }
1340
1341 void vo_x11_fullscreen(void)
1342 {
1343 int x, y, w, h;
1344
1345 if (WinID >= 0 || vo_fs_flip)
1346 return;
1347
1348 if (vo_fs)
1349 {
1350 // fs->win
1351 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1352 {
1353 x = vo_old_x;
1354 y = vo_old_y;
1355 w = vo_old_width;
1356 h = vo_old_height;
1357 }
1358
1359 vo_x11_ewmh_fullscreen(_NET_WM_STATE_REMOVE); // removes fullscreen state if wm supports EWMH
1360 vo_fs = VO_FALSE;
1361 } else
1362 {
1363 // win->fs
1364 vo_x11_ewmh_fullscreen(_NET_WM_STATE_ADD); // sends fullscreen state to be added if wm supports EWMH
1365
1366 vo_fs = VO_TRUE;
1367 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1368 {
1369 vo_old_x = vo_dx;
1370 vo_old_y = vo_dy;
1371 vo_old_width = vo_dwidth;
1372 vo_old_height = vo_dheight;
1373 }
1374 update_xinerama_info();
1375 x = xinerama_x;
1376 y = xinerama_y;
1377 w = vo_screenwidth;
1378 h = vo_screenheight;
1379 }
1380 {
1381 long dummy;
1382
1383 XGetWMNormalHints(mDisplay, vo_window, &vo_hint, &dummy);
1384 if (!(vo_hint.flags & PWinGravity))
1385 old_gravity = NorthWestGravity;
1386 else
1387 old_gravity = vo_hint.win_gravity;
1388 }
1389 if (vo_wm_type == 0 && !(vo_fsmode & 16))
1390 {
1391 XUnmapWindow(mDisplay, vo_window); // required for MWM
1392 XWithdrawWindow(mDisplay, vo_window, mScreen);
1393 vo_fs_flip = 1;
1394 }
1395
1396 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // not needed with EWMH fs
1397 {
1398 vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs);
1399 vo_x11_sizehint(x, y, w, h, 0);
1400 vo_x11_setlayer(mDisplay, vo_window, vo_fs);
1401
1402
1403 XMoveResizeWindow(mDisplay, vo_window, x, y, w, h);
1404 }
1405 /* some WMs lose ontop after fullscreen */
1406 if ((!(vo_fs)) & vo_ontop)
1407 vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
1408
1409 XMapRaised(mDisplay, vo_window);
1410 if ( ! (vo_fs_type & vo_wm_FULLSCREEN) ) // some WMs change window pos on map
1411 XMoveResizeWindow(mDisplay, vo_window, x, y, w, h);
1412 XRaiseWindow(mDisplay, vo_window);
1413 XFlush(mDisplay);
1414 }
1415
1416 void vo_x11_ontop(void)
1417 {
1418 vo_ontop = (!(vo_ontop));
1419
1420 vo_x11_setlayer(mDisplay, vo_window, vo_ontop);
1421 }
1422
1423 void vo_x11_border(void)
1424 {
1425 vo_border = !vo_border;
1426 vo_x11_decoration(mDisplay, vo_window, vo_border && !vo_fs);
1427 }
1428
1429 /*
1430 * XScreensaver stuff
1431 */
1432
1433 static int screensaver_off;
1434 static unsigned int time_last;
1435
1436 void xscreensaver_heartbeat(void)
1437 {
1438 unsigned int time = GetTimerMS();
1439
1440 if (mDisplay && screensaver_off && (time - time_last) > 30000)
1441 {
1442 time_last = time;
1443
1444 XResetScreenSaver(mDisplay);
1445 }
1446 }
1447
1448 static int xss_suspend(Bool suspend)
1449 {
1450 #ifndef CONFIG_XSS
1451 return 0;
1452 #else
1453 int event, error, major, minor;
1454 if (XScreenSaverQueryExtension(mDisplay, &event, &error) != True ||
1455 XScreenSaverQueryVersion(mDisplay, &major, &minor) != True)
1456 return 0;
1457 if (major < 1 || (major == 1 && minor < 1))
1458 return 0;
1459 XScreenSaverSuspend(mDisplay, suspend);
1460 return 1;
1461 #endif
1462 }
1463
1464 /*
1465 * End of XScreensaver stuff
1466 */
1467
1468 void saver_on(Display * mDisplay)
1469 {
1470
1471 if (!screensaver_off)
1472 return;
1473 screensaver_off = 0;
1474 if (xss_suspend(False))
1475 return;
1476 #ifdef CONFIG_XDPMS
1477 if (dpms_disabled)
1478 {
1479 int nothing;
1480 if (DPMSQueryExtension(mDisplay, &nothing, &nothing))
1481 {
1482 if (!DPMSEnable(mDisplay))
1483 { // restoring power saving settings
1484 mp_msg(MSGT_VO, MSGL_WARN, "DPMS not available?\n");
1485 } else
1486 {
1487 // DPMS does not seem to be enabled unless we call DPMSInfo
1488 BOOL onoff;
1489 CARD16 state;
1490
1491 DPMSForceLevel(mDisplay, DPMSModeOn);
1492 DPMSInfo(mDisplay, &state, &onoff);
1493 if (onoff)
1494 {
1495 mp_msg(MSGT_VO, MSGL_V,
1496 "Successfully enabled DPMS\n");
1497 } else
1498 {
1499 mp_msg(MSGT_VO, MSGL_WARN, "Could not enable DPMS\n");
1500 }
1501 }
1502 }
1503 dpms_disabled = 0;
1504 }
1505 #endif
1506 }
1507
1508 void saver_off(Display * mDisplay)
1509 {
1510 int nothing;
1511
1512 if (screensaver_off)
1513 return;
1514 screensaver_off = 1;
1515 if (xss_suspend(True))
1516 return;
1517 #ifdef CONFIG_XDPMS
1518 if (DPMSQueryExtension(mDisplay, &nothing, &nothing))
1519 {
1520 BOOL onoff;
1521 CARD16 state;
1522
1523 DPMSInfo(mDisplay, &state, &onoff);
1524 if (onoff)
1525 {
1526 Status stat;
1527
1528 mp_msg(MSGT_VO, MSGL_V, "Disabling DPMS\n");
1529 dpms_disabled = 1;
1530 stat = DPMSDisable(mDisplay); // monitor powersave off
1531 mp_msg(MSGT_VO, MSGL_V, "DPMSDisable stat: %d\n", stat);
1532 }
1533 }
1534 #endif
1535 }
1536
1537 static XErrorHandler old_handler = NULL;
1538 static int selectinput_err = 0;
1539 static int x11_selectinput_errorhandler(Display * display,
1540 XErrorEvent * event)
1541 {
1542 if (event->error_code == BadAccess)
1543 {
1544 selectinput_err = 1;
1545 mp_msg(MSGT_VO, MSGL_ERR,
1546 "X11 error: BadAccess during XSelectInput Call\n");
1547 mp_msg(MSGT_VO, MSGL_ERR,
1548 "X11 error: The 'ButtonPressMask' mask of specified window has probably already used by another appication (see man XSelectInput)\n");
1549 /* If you think MPlayer should shutdown with this error,
1550 * comment out the following line */
1551 return 0;
1552 }
1553 if (old_handler != NULL)
1554 old_handler(display, event);
1555 else
1556 x11_errorhandler(display, event);
1557 return 0;
1558 }
1559
1560 void vo_x11_selectinput_witherr(Display * display, Window w,
1561 long event_mask)
1562 {
1563 XSync(display, False);
1564 old_handler = XSetErrorHandler(x11_selectinput_errorhandler);
1565 selectinput_err = 0;
1566 if (vo_nomouse_input)
1567 {
1568 XSelectInput(display, w,
1569 event_mask &
1570 (~(ButtonPressMask | ButtonReleaseMask)));
1571 } else
1572 {
1573 XSelectInput(display, w, event_mask);
1574 }
1575 XSync(display, False);
1576 XSetErrorHandler(old_handler);
1577 if (selectinput_err)
1578 {
1579 mp_msg(MSGT_VO, MSGL_ERR,
1580 "X11 error: MPlayer discards mouse control (reconfiguring)\n");
1581 XSelectInput(display, w,
1582 event_mask &
1583 (~
1584 (ButtonPressMask | ButtonReleaseMask |
1585 PointerMotionMask)));
1586 }
1587 }
1588
1589 #ifdef CONFIG_XF86VM
1590 void vo_vm_switch(void)
1591 {
1592 int vm_event, vm_error;
1593 int vm_ver, vm_rev;
1594 int i, j, have_vm = 0;
1595 int X = vo_dwidth, Y = vo_dheight;
1596 int modeline_width, modeline_height;
1597
1598 int modecount;
1599
1600 if (XF86VidModeQueryExtension(mDisplay, &vm_event, &vm_error))
1601 {
1602 XF86VidModeQueryVersion(mDisplay, &vm_ver, &vm_rev);
1603 mp_msg(MSGT_VO, MSGL_V, "XF86VidMode extension v%i.%i\n", vm_ver,
1604 vm_rev);
1605 have_vm = 1;
1606 } else {
1607 mp_msg(MSGT_VO, MSGL_WARN,
1608 "XF86VidMode extension not available.\n");
1609 }
1610
1611 if (have_vm)
1612 {
1613 if (vidmodes == NULL)
1614 XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
1615 &vidmodes);
1616 j = 0;
1617 modeline_width = vidmodes[0]->hdisplay;
1618 modeline_height = vidmodes[0]->vdisplay;
1619
1620 for (i = 1; i < modecount; i++)
1621 if ((vidmodes[i]->hdisplay >= X)
1622 && (vidmodes[i]->vdisplay >= Y))
1623 if ((vidmodes[i]->hdisplay <= modeline_width)
1624 && (vidmodes[i]->vdisplay <= modeline_height))
1625 {
1626 modeline_width = vidmodes[i]->hdisplay;
1627 modeline_height = vidmodes[i]->vdisplay;
1628 j = i;
1629 }
1630
1631 mp_msg(MSGT_VO, MSGL_INFO, MSGTR_SelectedVideoMode,
1632 modeline_width, modeline_height, X, Y);
1633 XF86VidModeLockModeSwitch(mDisplay, mScreen, 0);
1634 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]);
1635 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[j]);
1636
1637 // FIXME: all this is more of a hack than proper solution
1638 X = (vo_screenwidth - modeline_width) / 2;
1639 Y = (vo_screenheight - modeline_height) / 2;
1640 XF86VidModeSetViewPort(mDisplay, mScreen, X, Y);
1641 vo_dx = X;
1642 vo_dy = Y;
1643 vo_dwidth = modeline_width;
1644 vo_dheight = modeline_height;
1645 aspect_save_screenres(modeline_width, modeline_height);
1646 }
1647 }
1648
1649 void vo_vm_close(void)
1650 {
1651 #ifdef CONFIG_GUI
1652 if (vidmodes != NULL && vo_window != None)
1653 #else
1654 if (vidmodes != NULL)
1655 #endif
1656 {
1657 int i, modecount;
1658
1659 free(vidmodes);
1660 vidmodes = NULL;
1661 XF86VidModeGetAllModeLines(mDisplay, mScreen, &modecount,
1662 &vidmodes);
1663 for (i = 0; i < modecount; i++)
1664 if ((vidmodes[i]->hdisplay == vo_screenwidth)
1665 && (vidmodes[i]->vdisplay == vo_screenheight))
1666 {
1667 mp_msg(MSGT_VO, MSGL_INFO,
1668 "Returning to original mode %dx%d\n",
1669 vo_screenwidth, vo_screenheight);
1670 break;
1671 }
1672
1673 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]);
1674 XF86VidModeSwitchToMode(mDisplay, mScreen, vidmodes[i]);
1675 free(vidmodes);
1676 vidmodes = NULL;
1677 }
1678 }
1679 #endif
1680
1681 #endif /* X11_FULLSCREEN */
1682
1683
1684 /*
1685 * Scan the available visuals on this Display/Screen. Try to find
1686 * the 'best' available TrueColor visual that has a decent color
1687 * depth (at least 15bit). If there are multiple visuals with depth
1688 * >= 15bit, we prefer visuals with a smaller color depth.
1689 */
1690 int vo_find_depth_from_visuals(Display * dpy, int screen,
1691 Visual ** visual_return)
1692 {
1693 XVisualInfo visual_tmpl;
1694 XVisualInfo *visuals;
1695 int nvisuals, i;
1696 int bestvisual = -1;
1697 int bestvisual_depth = -1;
1698
1699 visual_tmpl.screen = screen;
1700 visual_tmpl.class = TrueColor;
1701 visuals = XGetVisualInfo(dpy,
1702 VisualScreenMask | VisualClassMask,
1703 &visual_tmpl, &nvisuals);
1704 if (visuals != NULL)
1705 {
1706 for (i = 0; i < nvisuals; i++)
1707 {
1708 mp_msg(MSGT_VO, MSGL_V,
1709 "vo: X11 truecolor visual %#lx, depth %d, R:%lX G:%lX B:%lX\n",
1710 visuals[i].visualid, visuals[i].depth,
1711 visuals[i].red_mask, visuals[i].green_mask,
1712 visuals[i].blue_mask);
1713 /*
1714 * Save the visual index and its depth, if this is the first
1715 * truecolor visul, or a visual that is 'preferred' over the
1716 * previous 'best' visual.
1717 */
1718 if (bestvisual_depth == -1
1719 || (visuals[i].depth >= 15
1720 && (visuals[i].depth < bestvisual_depth
1721 || bestvisual_depth < 15)))
1722 {
1723 bestvisual = i;
1724 bestvisual_depth = visuals[i].depth;
1725 }
1726 }
1727
1728 if (bestvisual != -1 && visual_return != NULL)
1729 *visual_return = visuals[bestvisual].visual;
1730
1731 XFree(visuals);
1732 }
1733 return bestvisual_depth;
1734 }
1735
1736
1737 static Colormap cmap = None;
1738 static XColor cols[256];
1739 static int cm_size, red_mask, green_mask, blue_mask;
1740
1741
1742 Colormap vo_x11_create_colormap(XVisualInfo * vinfo)
1743 {
1744 unsigned k, r, g, b, ru, gu, bu, m, rv, gv, bv, rvu, gvu, bvu;
1745
1746 if (vinfo->class != DirectColor)
1747 return XCreateColormap(mDisplay, mRootWin, vinfo->visual,
1748 AllocNone);
1749
1750 /* can this function get called twice or more? */
1751 if (cmap)
1752 return cmap;
1753 cm_size = vinfo->colormap_size;
1754 red_mask = vinfo->red_mask;
1755 green_mask = vinfo->green_mask;
1756 blue_mask = vinfo->blue_mask;
1757 ru = (red_mask & (red_mask - 1)) ^ red_mask;
1758 gu = (green_mask & (green_mask - 1)) ^ green_mask;
1759 bu = (blue_mask & (blue_mask - 1)) ^ blue_mask;
1760 rvu = 65536ull * ru / (red_mask + ru);
1761 gvu = 65536ull * gu / (green_mask + gu);
1762 bvu = 65536ull * bu / (blue_mask + bu);
1763 r = g = b = 0;
1764 rv = gv = bv = 0;
1765 m = DoRed | DoGreen | DoBlue;
1766 for (k = 0; k < cm_size; k++)
1767 {
1768 int t;
1769
1770 cols[k].pixel = r | g | b;
1771 cols[k].red = rv;
1772 cols[k].green = gv;
1773 cols[k].blue = bv;
1774 cols[k].flags = m;
1775 t = (r + ru) & red_mask;
1776 if (t < r)
1777 m &= ~DoRed;
1778 r = t;
1779 t = (g + gu) & green_mask;
1780 if (t < g)
1781 m &= ~DoGreen;
1782 g = t;
1783 t = (b + bu) & blue_mask;
1784 if (t < b)
1785 m &= ~DoBlue;
1786 b = t;
1787 rv += rvu;
1788 gv += gvu;
1789 bv += bvu;
1790 }
1791 cmap = XCreateColormap(mDisplay, mRootWin, vinfo->visual, AllocAll);
1792 XStoreColors(mDisplay, cmap, cols, cm_size);
1793 return cmap;
1794 }
1795
1796 /*
1797 * Via colormaps/gamma ramps we can do gamma, brightness, contrast,
1798 * hue and red/green/blue intensity, but we cannot do saturation.
1799 * Currently only gamma, brightness and contrast are implemented.
1800 * Is there sufficient interest for hue and/or red/green/blue intensity?
1801 */
1802 /* these values have range [-100,100] and are initially 0 */
1803 static int vo_gamma = 0;
1804 static int vo_brightness = 0;
1805 static int vo_contrast = 0;
1806
1807 static int transform_color(float val,
1808 float brightness, float contrast, float gamma) {
1809 float s = pow(val, gamma);
1810 s = (s - 0.5) * contrast + 0.5;
1811 s += brightness;
1812 if (s < 0)
1813 s = 0;
1814 if (s > 1)
1815 s = 1;
1816 return (unsigned short) (s * 65535);
1817 }
1818
1819 uint32_t vo_x11_set_equalizer(char *name, int value)
1820 {
1821 float gamma, brightness, contrast;
1822 float rf, gf, bf;
1823 int k;
1824
1825 /*
1826 * IMPLEMENTME: consider using XF86VidModeSetGammaRamp in the case
1827 * of TrueColor-ed window but be careful:
1828 * Unlike the colormaps, which are private for the X client
1829 * who created them and thus automatically destroyed on client
1830 * disconnect, this gamma ramp is a system-wide (X-server-wide)
1831 * setting and _must_ be restored before the process exits.
1832 * Unforunately when the process crashes (or gets killed
1833 * for some reason) it is impossible to restore the setting,
1834 * and such behaviour could be rather annoying for the users.
1835 */
1836 if (cmap == None)
1837 return VO_NOTAVAIL;
1838
1839 if (!strcasecmp(name, "brightness"))
1840 vo_brightness = value;
1841 else if (!strcasecmp(name, "contrast"))
1842 vo_contrast = value;
1843 else if (!strcasecmp(name, "gamma"))
1844 vo_gamma = value;
1845 else
1846 return VO_NOTIMPL;
1847
1848 brightness = 0.01 * vo_brightness;
1849 contrast = tan(0.0095 * (vo_contrast + 100) * M_PI / 4);
1850 gamma = pow(2, -0.02 * vo_gamma);
1851
1852 rf = (float) ((red_mask & (red_mask - 1)) ^ red_mask) / red_mask;
1853 gf = (float) ((green_mask & (green_mask - 1)) ^ green_mask) /
1854 green_mask;
1855 bf = (float) ((blue_mask & (blue_mask - 1)) ^ blue_mask) / blue_mask;
1856
1857 /* now recalculate the colormap using the newly set value */
1858 for (k = 0; k < cm_size; k++)
1859 {
1860 cols[k].red = transform_color(rf * k, brightness, contrast, gamma);
1861 cols[k].green = transform_color(gf * k, brightness, contrast, gamma);
1862 cols[k].blue = transform_color(bf * k, brightness, contrast, gamma);
1863 }
1864
1865 XStoreColors(mDisplay, cmap, cols, cm_size);
1866 XFlush(mDisplay);
1867 return VO_TRUE;
1868 }
1869
1870 uint32_t vo_x11_get_equalizer(char *name, int *value)
1871 {
1872 if (cmap == None)
1873 return VO_NOTAVAIL;
1874 if (!strcasecmp(name, "brightness"))
1875 *value = vo_brightness;
1876 else if (!strcasecmp(name, "contrast"))
1877 *value = vo_contrast;
1878 else if (!strcasecmp(name, "gamma"))
1879 *value = vo_gamma;
1880 else
1881 return VO_NOTIMPL;
1882 return VO_TRUE;
1883 }
1884
1885 #ifdef CONFIG_XV
1886 int vo_xv_set_eq(uint32_t xv_port, char *name, int value)
1887 {
1888 XvAttribute *attributes;
1889 int i, howmany, xv_atom;
1890
1891 mp_dbg(MSGT_VO, MSGL_V, "xv_set_eq called! (%s, %d)\n", name, value);
1892
1893 /* get available attributes */
1894 attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
1895 for (i = 0; i < howmany && attributes; i++)
1896 if (attributes[i].flags & XvSettable)
1897 {
1898 xv_atom = XInternAtom(mDisplay, attributes[i].name, True);
1899 /* since we have SET_DEFAULTS first in our list, we can check if it's available
1900 then trigger it if it's ok so that the other values are at default upon query */
1901 if (xv_atom != None)
1902 {
1903 int hue = 0, port_value, port_min, port_max;
1904
1905 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") &&
1906 (!strcasecmp(name, "brightness")))
1907 port_value = value;
1908 else if (!strcmp(attributes[i].name, "XV_CONTRAST") &&
1909 (!strcasecmp(name, "contrast")))
1910 port_value = value;
1911 else if (!strcmp(attributes[i].name, "XV_SATURATION") &&
1912 (!strcasecmp(name, "saturation")))
1913 port_value = value;
1914 else if (!strcmp(attributes[i].name, "XV_HUE") &&
1915 (!strcasecmp(name, "hue")))
1916 {
1917 port_value = value;
1918 hue = 1;
1919 } else
1920 /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
1921 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") &&
1922 (!strcasecmp(name, "red_intensity")))
1923 port_value = value;
1924 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY")
1925 && (!strcasecmp(name, "green_intensity")))
1926 port_value = value;
1927 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY")
1928 && (!strcasecmp(name, "blue_intensity")))
1929 port_value = value;
1930 else
1931 continue;
1932
1933 port_min = attributes[i].min_value;
1934 port_max = attributes[i].max_value;
1935
1936 /* nvidia hue workaround */
1937 if (hue && port_min == 0 && port_max == 360)
1938 {
1939 port_value =
1940 (port_value >=
1941 0) ? (port_value - 100) : (port_value + 100);
1942 }
1943 // -100 -> min
1944 // 0 -> (max+min)/2
1945 // +100 -> max
1946 port_value =
1947 (port_value + 100) * (port_max - port_min) / 200 +
1948 port_min;
1949 XvSetPortAttribute(mDisplay, xv_port, xv_atom, port_value);
1950 return VO_TRUE;
1951 }
1952 }
1953 return VO_FALSE;
1954 }
1955
1956 int vo_xv_get_eq(uint32_t xv_port, char *name, int *value)
1957 {
1958
1959 XvAttribute *attributes;
1960 int i, howmany, xv_atom;
1961
1962 /* get available attributes */
1963 attributes = XvQueryPortAttributes(mDisplay, xv_port, &howmany);
1964 for (i = 0; i < howmany && attributes; i++)
1965 if (attributes[i].flags & XvGettable)
1966 {
1967 xv_atom = XInternAtom(mDisplay, attributes[i].name, True);
1968 /* since we have SET_DEFAULTS first in our list, we can check if it's available
1969 then trigger it if it's ok so that the other values are at default upon query */
1970 if (xv_atom != None)
1971 {
1972 int val, port_value = 0, port_min, port_max;
1973
1974 XvGetPortAttribute(mDisplay, xv_port, xv_atom,
1975 &port_value);
1976
1977 port_min = attributes[i].min_value;
1978 port_max = attributes[i].max_value;
1979 val =
1980 (port_value - port_min) * 200 / (port_max - port_min) -
1981 100;
1982
1983 if (!strcmp(attributes[i].name, "XV_BRIGHTNESS") &&
1984 (!strcasecmp(name, "brightness")))
1985 *value = val;
1986 else if (!strcmp(attributes[i].name, "XV_CONTRAST") &&
1987 (!strcasecmp(name, "contrast")))
1988 *value = val;
1989 else if (!strcmp(attributes[i].name, "XV_SATURATION") &&
1990 (!strcasecmp(name, "saturation")))
1991 *value = val;
1992 else if (!strcmp(attributes[i].name, "XV_HUE") &&
1993 (!strcasecmp(name, "hue")))
1994 {
1995 /* nasty nvidia detect */
1996 if (port_min == 0 && port_max == 360)
1997 *value = (val >= 0) ? (val - 100) : (val + 100);
1998 else
1999 *value = val;
2000 } else
2001 /* Note: since 22.01.2002 GATOS supports these attrs for radeons (NK) */
2002 if (!strcmp(attributes[i].name, "XV_RED_INTENSITY") &&
2003 (!strcasecmp(name, "red_intensity")))
2004 *value = val;
2005 else if (!strcmp(attributes[i].name, "XV_GREEN_INTENSITY")
2006 && (!strcasecmp(name, "green_intensity")))
2007 *value = val;
2008 else if (!strcmp(attributes[i].name, "XV_BLUE_INTENSITY")
2009 && (!strcasecmp(name, "blue_intensity")))
2010 *value = val;
2011 else
2012 continue;
2013
2014 mp_dbg(MSGT_VO, MSGL_V, "xv_get_eq called! (%s, %d)\n",
2015 name, *value);
2016 return VO_TRUE;
2017 }
2018 }
2019 return VO_FALSE;
2020 }
2021
2022 /** \brief contains flags changing the execution of the colorkeying code */
2023 xv_ck_info_t xv_ck_info = { CK_METHOD_MANUALFILL, CK_SRC_CUR };
2024 unsigned long xv_colorkey; ///< The color used for manual colorkeying.
2025 unsigned int xv_port; ///< The selected Xv port.
2026
2027 /**
2028 * \brief Interns the requested atom if it is available.
2029 *
2030 * \param atom_name String containing the name of the requested atom.
2031 *
2032 * \return Returns the atom if available, else None is returned.
2033 *
2034 */
2035 static Atom xv_intern_atom_if_exists( char const * atom_name )
2036 {
2037 XvAttribute * attributes;
2038 int attrib_count,i;
2039 Atom xv_atom = None;
2040
2041 attributes = XvQueryPortAttributes( mDisplay, xv_port, &attrib_count );
2042 if( attributes!=NULL )
2043 {
2044 for ( i = 0; i < attrib_count; ++i )
2045 {
2046 if ( strcmp(attributes[i].name, atom_name ) == 0 )
2047 {
2048 xv_atom = XInternAtom( mDisplay, atom_name, False );
2049 break; // found what we want, break out
2050 }
2051 }
2052 XFree( attributes );
2053 }
2054
2055 return xv_atom;
2056 }
2057
2058 /**
2059 * \brief Try to enable vsync for xv.
2060 * \return Returns -1 if not available, 0 on failure and 1 on success.
2061 */
2062 int vo_xv_enable_vsync(void)
2063 {
2064 Atom xv_atom = xv_intern_atom_if_exists("XV_SYNC_TO_VBLANK");
2065 if (xv_atom == None)
2066 return -1;
2067 return XvSetPortAttribute(mDisplay, xv_port, xv_atom, 1) == Success;
2068 }
2069
2070 /**
2071 * \brief Get maximum supported source image dimensions.
2072 *
2073 * This function does not set the variables pointed to by
2074 * width and height if the information could not be retrieved,
2075 * so the caller is reponsible for properly initializing them.
2076 *
2077 * \param width [out] The maximum width gets stored here.
2078 * \param height [out] The maximum height gets stored here.
2079 *
2080 */
2081 void vo_xv_get_max_img_dim( uint32_t * width, uint32_t * height )
2082 {
2083 XvEncodingInfo * encodings;
2084 //unsigned long num_encodings, idx; to int or too long?!
2085 unsigned int num_encodings, idx;
2086
2087 XvQueryEncodings( mDisplay, xv_port, &num_encodings, &encodings);
2088
2089 if ( encodings )
2090 {
2091 for ( idx = 0; idx < num_encodings; ++idx )
2092 {
2093 if ( strcmp( encodings[idx].name, "XV_IMAGE" ) == 0 )
2094 {
2095 *width = encodings[idx].width;
2096 *height = encodings[idx].height;
2097 break;
2098 }
2099 }
2100 }
2101
2102 mp_msg( MSGT_VO, MSGL_V,
2103 "[xv common] Maximum source image dimensions: %ux%u\n",
2104 *width, *height );
2105
2106 XvFreeEncodingInfo( encodings );
2107 }
2108
2109 /**
2110 * \brief Print information about the colorkey method and source.
2111 *
2112 * \param ck_handling Integer value containing the information about
2113 * colorkey handling (see x11_common.h).
2114 *
2115 * Outputs the content of |ck_handling| as a readable message.
2116 *
2117 */
2118 void vo_xv_print_ck_info(void)
2119 {
2120 mp_msg( MSGT_VO, MSGL_V, "[xv common] " );
2121
2122 switch ( xv_ck_info.method )
2123 {
2124 case CK_METHOD_NONE:
2125 mp_msg( MSGT_VO, MSGL_V, "Drawing no colorkey.\n" ); return;
2126 case CK_METHOD_AUTOPAINT:
2127 mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn by Xv." ); break;
2128 case CK_METHOD_MANUALFILL:
2129 mp_msg( MSGT_VO, MSGL_V, "Drawing colorkey manually." ); break;
2130 case CK_METHOD_BACKGROUND:
2131 mp_msg( MSGT_VO, MSGL_V, "Colorkey is drawn as window background." ); break;
2132 }
2133
2134 mp_msg( MSGT_VO, MSGL_V, "\n[xv common] " );
2135
2136 switch ( xv_ck_info.source )
2137 {
2138 case CK_SRC_CUR:
2139 mp_msg( MSGT_VO, MSGL_V, "Using colorkey from Xv (0x%06lx).\n",
2140 xv_colorkey );
2141 break;
2142 case CK_SRC_USE:
2143 if ( xv_ck_info.method == CK_METHOD_AUTOPAINT )
2144 {
2145 mp_msg( MSGT_VO, MSGL_V,
2146 "Ignoring colorkey from MPlayer (0x%06lx).\n",
2147 xv_colorkey );
2148 }
2149 else
2150 {
2151 mp_msg( MSGT_VO, MSGL_V,
2152 "Using colorkey from MPlayer (0x%06lx)."
2153 " Use -colorkey to change.\n",
2154 xv_colorkey );
2155 }
2156 break;
2157 case CK_SRC_SET:
2158 mp_msg( MSGT_VO, MSGL_V,
2159 "Setting and using colorkey from MPlayer (0x%06lx)."
2160 " Use -colorkey to change.\n",
2161 xv_colorkey );
2162 break;
2163 }
2164 }
2165 /**
2166 * \brief Init colorkey depending on the settings in xv_ck_info.
2167 *
2168 * \return Returns 0 on failure and 1 on success.
2169 *
2170 * Sets the colorkey variable according to the CK_SRC_* and CK_METHOD_*
2171 * flags in xv_ck_info.
2172 *
2173 * Possiblilities:
2174 * * Methods
2175 * - manual colorkey drawing ( CK_METHOD_MANUALFILL )
2176 * - set colorkey as window background ( CK_METHOD_BACKGROUND )
2177 * - let Xv paint the colorkey ( CK_METHOD_AUTOPAINT )
2178 * * Sources
2179 * - use currently set colorkey ( CK_SRC_CUR )
2180 * - use colorkey in vo_colorkey ( CK_SRC_USE )
2181 * - use and set colorkey in vo_colorkey ( CK_SRC_SET )
2182 *
2183 * NOTE: If vo_colorkey has bits set after the first 3 low order bytes
2184 * we don't draw anything as this means it was forced to off.
2185 */
2186 int vo_xv_init_colorkey(void)
2187 {
2188 Atom xv_atom;
2189 int rez;
2190
2191 /* check if colorkeying is needed */
2192 xv_atom = xv_intern_atom_if_exists( "XV_COLORKEY" );
2193
2194 /* if we have to deal with colorkeying ... */
2195 if( xv_atom != None && !(vo_colorkey & 0xFF000000) )
2196 {
2197 /* check if we should use the colorkey specified in vo_colorkey */
2198 if ( xv_ck_info.source != CK_SRC_CUR )
2199 {
2200 xv_colorkey = vo_colorkey;
2201
2202 /* check if we have to set the colorkey too */
2203 if ( xv_ck_info.source == CK_SRC_SET )
2204 {
2205 xv_atom = XInternAtom(mDisplay, "XV_COLORKEY",False);
2206
2207 rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, vo_colorkey );
2208 if ( rez != Success )
2209 {
2210 mp_msg( MSGT_VO, MSGL_FATAL,
2211 "[xv common] Couldn't set colorkey!\n" );
2212 return 0; // error setting colorkey
2213 }
2214 }
2215 }
2216 else
2217 {
2218 int colorkey_ret;
2219
2220 rez=XvGetPortAttribute(mDisplay,xv_port, xv_atom, &colorkey_ret);
2221 if ( rez == Success )
2222 {
2223 xv_colorkey = colorkey_ret;
2224 }
2225 else
2226 {
2227 mp_msg( MSGT_VO, MSGL_FATAL,
2228 "[xv common] Couldn't get colorkey!"
2229 "Maybe the selected Xv port has no overlay.\n" );
2230 return 0; // error getting colorkey
2231 }
2232 }
2233
2234 xv_atom = xv_intern_atom_if_exists( "XV_AUTOPAINT_COLORKEY" );
2235
2236 /* should we draw the colorkey ourselves or activate autopainting? */
2237 if ( xv_ck_info.method == CK_METHOD_AUTOPAINT )
2238 {
2239 rez = !Success; // reset rez to something different than Success
2240
2241 if ( xv_atom != None ) // autopaint is supported
2242 {
2243 rez = XvSetPortAttribute( mDisplay, xv_port, xv_atom, 1 );
2244 }
2245
2246 if ( rez != Success )
2247 {
2248 // fallback to manual colorkey drawing
2249 xv_ck_info.method = CK_METHOD_MANUALFILL;
2250 }
2251 }
2252 else // disable colorkey autopainting if supported
2253 {
2254 if ( xv_atom != None ) // we have autopaint attribute
2255 {
2256 XvSetPortAttribute( mDisplay, xv_port, xv_atom, 0 );
2257 }
2258 }
2259 }
2260 else // do no colorkey drawing at all
2261 {
2262 xv_ck_info.method = CK_METHOD_NONE;
2263 } /* end: should we draw colorkey */
2264
2265 /* output information about the current colorkey settings */
2266 vo_xv_print_ck_info();
2267
2268 return 1; // success
2269 }
2270
2271 /**
2272 * \brief Draw the colorkey on the video window.
2273 *
2274 * Draws the colorkey depending on the set method ( colorkey_handling ).
2275 *
2276 * Also draws the black bars ( when the video doesn't fit the display in
2277 * fullscreen ) separately, so they don't overlap with the video area.
2278 * It doesn't call XFlush.
2279 *
2280 */
2281 void vo_xv_draw_colorkey( int32_t x, int32_t y,
2282 int32_t w, int32_t h )
2283 {
2284 if( xv_ck_info.method == CK_METHOD_MANUALFILL ||
2285 xv_ck_info.method == CK_METHOD_BACKGROUND )//less tearing than XClearWindow()
2286 {
2287 XSetForeground( mDisplay, vo_gc, xv_colorkey );
2288 XFillRectangle( mDisplay, vo_window, vo_gc,
2289 x, y,
2290 w, h );
2291 }
2292
2293 /* draw black bars if needed */
2294 /* TODO! move this to vo_x11_clearwindow_part() */
2295 if ( vo_fs )
2296 {
2297 XSetForeground( mDisplay, vo_gc, 0 );
2298 /* making non-overlap fills, requires 8 checks instead of 4 */
2299 if ( y > 0 )
2300 XFillRectangle( mDisplay, vo_window, vo_gc,
2301 0, 0,
2302 vo_screenwidth, y);
2303 if (x > 0)
2304 XFillRectangle( mDisplay, vo_window, vo_gc,
2305 0, 0,
2306 x, vo_screenheight);
2307 if (x + w < vo_screenwidth)
2308 XFillRectangle( mDisplay, vo_window, vo_gc,
2309 x + w, 0,
2310 vo_screenwidth, vo_screenheight);
2311 if (y + h < vo_screenheight)
2312 XFillRectangle( mDisplay, vo_window, vo_gc,
2313 0, y + h,
2314 vo_screenwidth, vo_screenheight);
2315 }
2316 }
2317
2318 /** \brief Tests if a valid argument for the ck suboption was given. */
2319 int xv_test_ck( void * arg )
2320 {
2321 strarg_t * strarg = (strarg_t *)arg;
2322
2323 if ( strargcmp( strarg, "use" ) == 0 ||
2324 strargcmp( strarg, "set" ) == 0 ||
2325 strargcmp( strarg, "cur" ) == 0 )
2326 {
2327 return 1;
2328 }
2329
2330 return 0;
2331 }
2332 /** \brief Tests if a valid arguments for the ck-method suboption was given. */
2333 int xv_test_ckm( void * arg )
2334 {
2335 strarg_t * strarg = (strarg_t *)arg;
2336
2337 if ( strargcmp( strarg, "bg" ) == 0 ||
2338 strargcmp( strarg, "man" ) == 0 ||
2339 strargcmp( strarg, "auto" ) == 0 )
2340 {
2341 return 1;
2342 }
2343
2344 return 0;
2345 }
2346
2347 /**
2348 * \brief Modify the colorkey_handling var according to str
2349 *
2350 * Checks if a valid pointer ( not NULL ) to the string
2351 * was given. And in that case modifies the colorkey_handling
2352 * var to reflect the requested behaviour.
2353 * If nothing happens the content of colorkey_handling stays
2354 * the same.
2355 *
2356 * \param str Pointer to the string or NULL
2357 *
2358 */
2359 void xv_setup_colorkeyhandling( char const * ck_method_str,
2360 char const * ck_str )
2361 {
2362 /* check if a valid pointer to the string was passed */
2363 if ( ck_str )
2364 {
2365 if ( strncmp( ck_str, "use", 3 ) == 0 )
2366 {
2367 xv_ck_info.source = CK_SRC_USE;
2368 }
2369 else if ( strncmp( ck_str, "set", 3 ) == 0 )
2370 {
2371 xv_ck_info.source = CK_SRC_SET;
2372 }
2373 }
2374 /* check if a valid pointer to the string was passed */
2375 if ( ck_method_str )
2376 {
2377 if ( strncmp( ck_method_str, "bg", 2 ) == 0 )
2378 {
2379 xv_ck_info.method = CK_METHOD_BACKGROUND;
2380 }
2381 else if ( strncmp( ck_method_str, "man", 3 ) == 0 )
2382 {
2383 xv_ck_info.method = CK_METHOD_MANUALFILL;
2384 }
2385 else if ( strncmp( ck_method_str, "auto", 4 ) == 0 )
2386 {
2387 xv_ck_info.method = CK_METHOD_AUTOPAINT;
2388 }
2389 }
2390 }
2391
2392 #endif
mplayer with SMedia Glamo drivers