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