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