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