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