diff options
author | Franklin Wei <git@fwei.tk> | 2017-01-21 15:18:31 -0500 |
---|---|---|
committer | Franklin Wei <git@fwei.tk> | 2017-12-23 21:01:26 -0500 |
commit | a855d6202536ff28e5aae4f22a0f31d8f5b325d0 (patch) | |
tree | 8c75f224dd64ed360505afa8843d016b0d75000b /apps/plugins/sdl/src/video/directfb | |
parent | 01c6dcf6c7b9bb1ad2fa0450f99bacc5f3d3e04b (diff) | |
download | rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.tar.gz rockbox-a855d6202536ff28e5aae4f22a0f31d8f5b325d0.zip |
Port of Duke Nukem 3D
This ports Fabien Sanglard's Chocolate Duke to run on a version of SDL
for Rockbox.
Change-Id: I8f2c4c78af19de10c1633ed7bb7a997b43256dd9
Diffstat (limited to 'apps/plugins/sdl/src/video/directfb')
7 files changed, 1944 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.c b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.c new file mode 100644 index 0000000000..246b75b176 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.c | |||
@@ -0,0 +1,219 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* Handle the event stream, converting DirectFB input events into SDL events */ | ||
25 | |||
26 | #include <sys/types.h> | ||
27 | #include <sys/time.h> | ||
28 | #include <unistd.h> | ||
29 | #include <fcntl.h> | ||
30 | #include <termios.h> | ||
31 | |||
32 | #include <directfb.h> | ||
33 | |||
34 | #include "SDL.h" | ||
35 | #include "../SDL_sysvideo.h" | ||
36 | #include "../../events/SDL_sysevents.h" | ||
37 | #include "../../events/SDL_events_c.h" | ||
38 | #include "SDL_DirectFB_video.h" | ||
39 | #include "SDL_DirectFB_events.h" | ||
40 | |||
41 | /* The translation tables from a DirectFB keycode to a SDL keysym */ | ||
42 | static SDLKey keymap[256]; | ||
43 | static SDL_keysym *DirectFB_TranslateKey (DFBInputEvent *ev, SDL_keysym *keysym); | ||
44 | static int DirectFB_TranslateButton (DFBInputEvent *ev); | ||
45 | |||
46 | static int posted = 0; | ||
47 | |||
48 | |||
49 | void DirectFB_PumpEvents (_THIS) | ||
50 | { | ||
51 | DFBInputEvent evt; | ||
52 | |||
53 | while (HIDDEN->eventbuffer->GetEvent (HIDDEN->eventbuffer, | ||
54 | DFB_EVENT (&evt)) == DFB_OK) | ||
55 | { | ||
56 | SDL_keysym keysym; | ||
57 | |||
58 | switch (evt.type) | ||
59 | { | ||
60 | case DIET_BUTTONPRESS: | ||
61 | posted += SDL_PrivateMouseButton(SDL_PRESSED, | ||
62 | DirectFB_TranslateButton (&evt), 0, 0); | ||
63 | break; | ||
64 | case DIET_BUTTONRELEASE: | ||
65 | posted += SDL_PrivateMouseButton(SDL_RELEASED, | ||
66 | DirectFB_TranslateButton (&evt), 0, 0); | ||
67 | break; | ||
68 | case DIET_KEYPRESS: | ||
69 | posted += SDL_PrivateKeyboard(SDL_PRESSED, DirectFB_TranslateKey(&evt, &keysym)); | ||
70 | break; | ||
71 | case DIET_KEYRELEASE: | ||
72 | posted += SDL_PrivateKeyboard(SDL_RELEASED, DirectFB_TranslateKey(&evt, &keysym)); | ||
73 | break; | ||
74 | case DIET_AXISMOTION: | ||
75 | if (evt.flags & DIEF_AXISREL) | ||
76 | { | ||
77 | if (evt.axis == DIAI_X) | ||
78 | posted += SDL_PrivateMouseMotion(0, 1, evt.axisrel, 0); | ||
79 | else if (evt.axis == DIAI_Y) | ||
80 | posted += SDL_PrivateMouseMotion(0, 1, 0, evt.axisrel); | ||
81 | } | ||
82 | else if (evt.flags & DIEF_AXISABS) | ||
83 | { | ||
84 | static int last_x, last_y; | ||
85 | if (evt.axis == DIAI_X) | ||
86 | last_x = evt.axisabs; | ||
87 | else if (evt.axis == DIAI_Y) | ||
88 | last_y = evt.axisabs; | ||
89 | posted += SDL_PrivateMouseMotion(0, 0, last_x, last_y); | ||
90 | } | ||
91 | break; | ||
92 | default: | ||
93 | ; | ||
94 | } | ||
95 | } | ||
96 | } | ||
97 | |||
98 | void DirectFB_InitOSKeymap (_THIS) | ||
99 | { | ||
100 | int i; | ||
101 | |||
102 | /* Initialize the DirectFB key translation table */ | ||
103 | for (i=0; i<SDL_arraysize(keymap); ++i) | ||
104 | keymap[i] = SDLK_UNKNOWN; | ||
105 | |||
106 | keymap[DIKI_A - DIKI_UNKNOWN] = SDLK_a; | ||
107 | keymap[DIKI_B - DIKI_UNKNOWN] = SDLK_b; | ||
108 | keymap[DIKI_C - DIKI_UNKNOWN] = SDLK_c; | ||
109 | keymap[DIKI_D - DIKI_UNKNOWN] = SDLK_d; | ||
110 | keymap[DIKI_E - DIKI_UNKNOWN] = SDLK_e; | ||
111 | keymap[DIKI_F - DIKI_UNKNOWN] = SDLK_f; | ||
112 | keymap[DIKI_G - DIKI_UNKNOWN] = SDLK_g; | ||
113 | keymap[DIKI_H - DIKI_UNKNOWN] = SDLK_h; | ||
114 | keymap[DIKI_I - DIKI_UNKNOWN] = SDLK_i; | ||
115 | keymap[DIKI_J - DIKI_UNKNOWN] = SDLK_j; | ||
116 | keymap[DIKI_K - DIKI_UNKNOWN] = SDLK_k; | ||
117 | keymap[DIKI_L - DIKI_UNKNOWN] = SDLK_l; | ||
118 | keymap[DIKI_M - DIKI_UNKNOWN] = SDLK_m; | ||
119 | keymap[DIKI_N - DIKI_UNKNOWN] = SDLK_n; | ||
120 | keymap[DIKI_O - DIKI_UNKNOWN] = SDLK_o; | ||
121 | keymap[DIKI_P - DIKI_UNKNOWN] = SDLK_p; | ||
122 | keymap[DIKI_Q - DIKI_UNKNOWN] = SDLK_q; | ||
123 | keymap[DIKI_R - DIKI_UNKNOWN] = SDLK_r; | ||
124 | keymap[DIKI_S - DIKI_UNKNOWN] = SDLK_s; | ||
125 | keymap[DIKI_T - DIKI_UNKNOWN] = SDLK_t; | ||
126 | keymap[DIKI_U - DIKI_UNKNOWN] = SDLK_u; | ||
127 | keymap[DIKI_V - DIKI_UNKNOWN] = SDLK_v; | ||
128 | keymap[DIKI_W - DIKI_UNKNOWN] = SDLK_w; | ||
129 | keymap[DIKI_X - DIKI_UNKNOWN] = SDLK_x; | ||
130 | keymap[DIKI_Y - DIKI_UNKNOWN] = SDLK_y; | ||
131 | keymap[DIKI_Z - DIKI_UNKNOWN] = SDLK_z; | ||
132 | |||
133 | keymap[DIKI_0 - DIKI_UNKNOWN] = SDLK_0; | ||
134 | keymap[DIKI_1 - DIKI_UNKNOWN] = SDLK_1; | ||
135 | keymap[DIKI_2 - DIKI_UNKNOWN] = SDLK_2; | ||
136 | keymap[DIKI_3 - DIKI_UNKNOWN] = SDLK_3; | ||
137 | keymap[DIKI_4 - DIKI_UNKNOWN] = SDLK_4; | ||
138 | keymap[DIKI_5 - DIKI_UNKNOWN] = SDLK_5; | ||
139 | keymap[DIKI_6 - DIKI_UNKNOWN] = SDLK_6; | ||
140 | keymap[DIKI_7 - DIKI_UNKNOWN] = SDLK_7; | ||
141 | keymap[DIKI_8 - DIKI_UNKNOWN] = SDLK_8; | ||
142 | keymap[DIKI_9 - DIKI_UNKNOWN] = SDLK_9; | ||
143 | |||
144 | keymap[DIKI_F1 - DIKI_UNKNOWN] = SDLK_F1; | ||
145 | keymap[DIKI_F2 - DIKI_UNKNOWN] = SDLK_F2; | ||
146 | keymap[DIKI_F3 - DIKI_UNKNOWN] = SDLK_F3; | ||
147 | keymap[DIKI_F4 - DIKI_UNKNOWN] = SDLK_F4; | ||
148 | keymap[DIKI_F5 - DIKI_UNKNOWN] = SDLK_F5; | ||
149 | keymap[DIKI_F6 - DIKI_UNKNOWN] = SDLK_F6; | ||
150 | keymap[DIKI_F7 - DIKI_UNKNOWN] = SDLK_F7; | ||
151 | keymap[DIKI_F8 - DIKI_UNKNOWN] = SDLK_F8; | ||
152 | keymap[DIKI_F9 - DIKI_UNKNOWN] = SDLK_F9; | ||
153 | keymap[DIKI_F10 - DIKI_UNKNOWN] = SDLK_F10; | ||
154 | keymap[DIKI_F11 - DIKI_UNKNOWN] = SDLK_F11; | ||
155 | keymap[DIKI_F12 - DIKI_UNKNOWN] = SDLK_F12; | ||
156 | |||
157 | keymap[DIKI_ESCAPE - DIKI_UNKNOWN] = SDLK_ESCAPE; | ||
158 | keymap[DIKI_LEFT - DIKI_UNKNOWN] = SDLK_LEFT; | ||
159 | keymap[DIKI_RIGHT - DIKI_UNKNOWN] = SDLK_RIGHT; | ||
160 | keymap[DIKI_UP - DIKI_UNKNOWN] = SDLK_UP; | ||
161 | keymap[DIKI_DOWN - DIKI_UNKNOWN] = SDLK_DOWN; | ||
162 | keymap[DIKI_CONTROL_L - DIKI_UNKNOWN] = SDLK_LCTRL; | ||
163 | keymap[DIKI_CONTROL_R - DIKI_UNKNOWN] = SDLK_RCTRL; | ||
164 | keymap[DIKI_SHIFT_L - DIKI_UNKNOWN] = SDLK_LSHIFT; | ||
165 | keymap[DIKI_SHIFT_R - DIKI_UNKNOWN] = SDLK_RSHIFT; | ||
166 | keymap[DIKI_ALT_L - DIKI_UNKNOWN] = SDLK_LALT; | ||
167 | keymap[DIKI_ALT_R - DIKI_UNKNOWN] = SDLK_RALT; | ||
168 | keymap[DIKI_TAB - DIKI_UNKNOWN] = SDLK_TAB; | ||
169 | keymap[DIKI_ENTER - DIKI_UNKNOWN] = SDLK_RETURN; | ||
170 | keymap[DIKI_SPACE - DIKI_UNKNOWN] = SDLK_SPACE; | ||
171 | keymap[DIKI_BACKSPACE - DIKI_UNKNOWN] = SDLK_BACKSPACE; | ||
172 | keymap[DIKI_INSERT - DIKI_UNKNOWN] = SDLK_INSERT; | ||
173 | keymap[DIKI_DELETE - DIKI_UNKNOWN] = SDLK_DELETE; | ||
174 | keymap[DIKI_HOME - DIKI_UNKNOWN] = SDLK_HOME; | ||
175 | keymap[DIKI_END - DIKI_UNKNOWN] = SDLK_END; | ||
176 | keymap[DIKI_PAGE_UP - DIKI_UNKNOWN] = SDLK_PAGEUP; | ||
177 | keymap[DIKI_PAGE_DOWN - DIKI_UNKNOWN] = SDLK_PAGEDOWN; | ||
178 | keymap[DIKI_CAPS_LOCK - DIKI_UNKNOWN] = SDLK_CAPSLOCK; | ||
179 | keymap[DIKI_NUM_LOCK - DIKI_UNKNOWN] = SDLK_NUMLOCK; | ||
180 | keymap[DIKI_SCROLL_LOCK - DIKI_UNKNOWN] = SDLK_SCROLLOCK; | ||
181 | keymap[DIKI_PRINT - DIKI_UNKNOWN] = SDLK_PRINT; | ||
182 | keymap[DIKI_PAUSE - DIKI_UNKNOWN] = SDLK_PAUSE; | ||
183 | keymap[DIKI_KP_DIV - DIKI_UNKNOWN] = SDLK_KP_DIVIDE; | ||
184 | keymap[DIKI_KP_MULT - DIKI_UNKNOWN] = SDLK_KP_MULTIPLY; | ||
185 | keymap[DIKI_KP_MINUS - DIKI_UNKNOWN] = SDLK_KP_MINUS; | ||
186 | keymap[DIKI_KP_PLUS - DIKI_UNKNOWN] = SDLK_KP_PLUS; | ||
187 | keymap[DIKI_KP_ENTER - DIKI_UNKNOWN] = SDLK_KP_ENTER; | ||
188 | } | ||
189 | |||
190 | |||
191 | static SDL_keysym *DirectFB_TranslateKey (DFBInputEvent *ev, SDL_keysym *keysym) | ||
192 | { | ||
193 | /* Set the keysym information */ | ||
194 | keysym->scancode = ev->key_id; | ||
195 | keysym->mod = KMOD_NONE; /* FIXME */ | ||
196 | keysym->unicode = (DFB_KEY_TYPE (ev->key_symbol) == DIKT_UNICODE) ? ev->key_symbol : 0; | ||
197 | |||
198 | if (ev->key_symbol > 0 && ev->key_symbol < 128) | ||
199 | keysym->sym = ev->key_symbol; | ||
200 | else | ||
201 | keysym->sym = keymap[ev->key_id - DIKI_UNKNOWN]; | ||
202 | |||
203 | return keysym; | ||
204 | } | ||
205 | |||
206 | static int DirectFB_TranslateButton (DFBInputEvent *ev) | ||
207 | { | ||
208 | switch (ev->button) | ||
209 | { | ||
210 | case DIBI_LEFT: | ||
211 | return 1; | ||
212 | case DIBI_MIDDLE: | ||
213 | return 2; | ||
214 | case DIBI_RIGHT: | ||
215 | return 3; | ||
216 | default: | ||
217 | return 0; | ||
218 | } | ||
219 | } | ||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.h b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.h new file mode 100644 index 0000000000..20f3967271 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_events.h | |||
@@ -0,0 +1,29 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #include "SDL_DirectFB_video.h" | ||
25 | |||
26 | /* Functions to be exported */ | ||
27 | extern void DirectFB_InitOSKeymap(_THIS); | ||
28 | extern void DirectFB_PumpEvents(_THIS); | ||
29 | |||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_keys.h b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_keys.h new file mode 100644 index 0000000000..2868ee6ffa --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_keys.h | |||
@@ -0,0 +1,135 @@ | |||
1 | |||
2 | #define SCANCODE_ESCAPE 1 | ||
3 | |||
4 | #define SCANCODE_1 2 | ||
5 | #define SCANCODE_2 3 | ||
6 | #define SCANCODE_3 4 | ||
7 | #define SCANCODE_4 5 | ||
8 | #define SCANCODE_5 6 | ||
9 | #define SCANCODE_6 7 | ||
10 | #define SCANCODE_7 8 | ||
11 | #define SCANCODE_8 9 | ||
12 | #define SCANCODE_9 10 | ||
13 | #define SCANCODE_0 11 | ||
14 | |||
15 | #define SCANCODE_MINUS 12 | ||
16 | #define SCANCODE_EQUAL 13 | ||
17 | |||
18 | #define SCANCODE_BACKSPACE 14 | ||
19 | #define SCANCODE_TAB 15 | ||
20 | |||
21 | #define SCANCODE_Q 16 | ||
22 | #define SCANCODE_W 17 | ||
23 | #define SCANCODE_E 18 | ||
24 | #define SCANCODE_R 19 | ||
25 | #define SCANCODE_T 20 | ||
26 | #define SCANCODE_Y 21 | ||
27 | #define SCANCODE_U 22 | ||
28 | #define SCANCODE_I 23 | ||
29 | #define SCANCODE_O 24 | ||
30 | #define SCANCODE_P 25 | ||
31 | #define SCANCODE_BRACKET_LEFT 26 | ||
32 | #define SCANCODE_BRACKET_RIGHT 27 | ||
33 | |||
34 | #define SCANCODE_ENTER 28 | ||
35 | |||
36 | #define SCANCODE_LEFTCONTROL 29 | ||
37 | |||
38 | #define SCANCODE_A 30 | ||
39 | #define SCANCODE_S 31 | ||
40 | #define SCANCODE_D 32 | ||
41 | #define SCANCODE_F 33 | ||
42 | #define SCANCODE_G 34 | ||
43 | #define SCANCODE_H 35 | ||
44 | #define SCANCODE_J 36 | ||
45 | #define SCANCODE_K 37 | ||
46 | #define SCANCODE_L 38 | ||
47 | #define SCANCODE_SEMICOLON 39 | ||
48 | #define SCANCODE_APOSTROPHE 40 | ||
49 | #define SCANCODE_GRAVE 41 | ||
50 | |||
51 | #define SCANCODE_LEFTSHIFT 42 | ||
52 | #define SCANCODE_BACKSLASH 43 | ||
53 | |||
54 | #define SCANCODE_Z 44 | ||
55 | #define SCANCODE_X 45 | ||
56 | #define SCANCODE_C 46 | ||
57 | #define SCANCODE_V 47 | ||
58 | #define SCANCODE_B 48 | ||
59 | #define SCANCODE_N 49 | ||
60 | #define SCANCODE_M 50 | ||
61 | #define SCANCODE_COMMA 51 | ||
62 | #define SCANCODE_PERIOD 52 | ||
63 | #define SCANCODE_SLASH 53 | ||
64 | |||
65 | #define SCANCODE_RIGHTSHIFT 54 | ||
66 | #define SCANCODE_KEYPADMULTIPLY 55 | ||
67 | |||
68 | #define SCANCODE_LEFTALT 56 | ||
69 | #define SCANCODE_SPACE 57 | ||
70 | #define SCANCODE_CAPSLOCK 58 | ||
71 | |||
72 | #define SCANCODE_F1 59 | ||
73 | #define SCANCODE_F2 60 | ||
74 | #define SCANCODE_F3 61 | ||
75 | #define SCANCODE_F4 62 | ||
76 | #define SCANCODE_F5 63 | ||
77 | #define SCANCODE_F6 64 | ||
78 | #define SCANCODE_F7 65 | ||
79 | #define SCANCODE_F8 66 | ||
80 | #define SCANCODE_F9 67 | ||
81 | #define SCANCODE_F10 68 | ||
82 | |||
83 | #define SCANCODE_NUMLOCK 69 | ||
84 | #define SCANCODE_SCROLLLOCK 70 | ||
85 | |||
86 | #define SCANCODE_KEYPAD7 71 | ||
87 | #define SCANCODE_CURSORUPLEFT 71 | ||
88 | #define SCANCODE_KEYPAD8 72 | ||
89 | #define SCANCODE_CURSORUP 72 | ||
90 | #define SCANCODE_KEYPAD9 73 | ||
91 | #define SCANCODE_CURSORUPRIGHT 73 | ||
92 | #define SCANCODE_KEYPADMINUS 74 | ||
93 | #define SCANCODE_KEYPAD4 75 | ||
94 | #define SCANCODE_CURSORLEFT 75 | ||
95 | #define SCANCODE_KEYPAD5 76 | ||
96 | #define SCANCODE_KEYPAD6 77 | ||
97 | #define SCANCODE_CURSORRIGHT 77 | ||
98 | #define SCANCODE_KEYPADPLUS 78 | ||
99 | #define SCANCODE_KEYPAD1 79 | ||
100 | #define SCANCODE_CURSORDOWNLEFT 79 | ||
101 | #define SCANCODE_KEYPAD2 80 | ||
102 | #define SCANCODE_CURSORDOWN 80 | ||
103 | #define SCANCODE_KEYPAD3 81 | ||
104 | #define SCANCODE_CURSORDOWNRIGHT 81 | ||
105 | #define SCANCODE_KEYPAD0 82 | ||
106 | #define SCANCODE_KEYPADPERIOD 83 | ||
107 | |||
108 | #define SCANCODE_LESS 86 | ||
109 | |||
110 | #define SCANCODE_F11 87 | ||
111 | #define SCANCODE_F12 88 | ||
112 | |||
113 | #define SCANCODE_KEYPADENTER 96 | ||
114 | #define SCANCODE_RIGHTCONTROL 97 | ||
115 | #define SCANCODE_CONTROL 97 | ||
116 | #define SCANCODE_KEYPADDIVIDE 98 | ||
117 | #define SCANCODE_PRINTSCREEN 99 | ||
118 | #define SCANCODE_RIGHTALT 100 | ||
119 | #define SCANCODE_BREAK 101 /* Beware: is 119 */ | ||
120 | #define SCANCODE_BREAK_ALTERNATIVE 119 /* on some keyboards! */ | ||
121 | |||
122 | #define SCANCODE_HOME 102 | ||
123 | #define SCANCODE_CURSORBLOCKUP 90 /* Cursor key block */ | ||
124 | #define SCANCODE_PAGEUP 104 | ||
125 | #define SCANCODE_CURSORBLOCKLEFT 92 /* Cursor key block */ | ||
126 | #define SCANCODE_CURSORBLOCKRIGHT 94 /* Cursor key block */ | ||
127 | #define SCANCODE_END 107 | ||
128 | #define SCANCODE_CURSORBLOCKDOWN 108 /* Cursor key block */ | ||
129 | #define SCANCODE_PAGEDOWN 109 | ||
130 | #define SCANCODE_INSERT 110 | ||
131 | #define SCANCODE_REMOVE 111 | ||
132 | |||
133 | #define SCANCODE_RIGHTWIN 126 | ||
134 | #define SCANCODE_LEFTWIN 125 | ||
135 | |||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.c b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.c new file mode 100644 index 0000000000..f665ec6825 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.c | |||
@@ -0,0 +1,1171 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | |||
22 | MGA CRTC2 support by Thomas Jarosch - tomj@simonv.com | ||
23 | CRTC2 support is inspired by mplayer's dfbmga driver | ||
24 | written by Ville Syrj��<syrjala@sci.fi> | ||
25 | */ | ||
26 | #include "SDL_config.h" | ||
27 | |||
28 | /* DirectFB video driver implementation. | ||
29 | */ | ||
30 | |||
31 | #include <fcntl.h> | ||
32 | #include <unistd.h> | ||
33 | #include <sys/mman.h> | ||
34 | |||
35 | #include <directfb.h> | ||
36 | #include <directfb_version.h> | ||
37 | |||
38 | #include "SDL_video.h" | ||
39 | #include "SDL_mouse.h" | ||
40 | #include "../SDL_sysvideo.h" | ||
41 | #include "../SDL_pixels_c.h" | ||
42 | #include "../../events/SDL_events_c.h" | ||
43 | #include "SDL_DirectFB_video.h" | ||
44 | #include "SDL_DirectFB_events.h" | ||
45 | #include "SDL_DirectFB_yuv.h" | ||
46 | |||
47 | /* The implementation dependent data for the window manager cursor */ | ||
48 | struct WMcursor { | ||
49 | int unused; | ||
50 | }; | ||
51 | |||
52 | |||
53 | /* Initialization/Query functions */ | ||
54 | static int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat); | ||
55 | static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | ||
56 | static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
57 | static int DirectFB_SetColors(_THIS, int firstcolor, int ncolors, | ||
58 | SDL_Color *colors); | ||
59 | static void DirectFB_VideoQuit(_THIS); | ||
60 | |||
61 | /* Hardware surface functions */ | ||
62 | static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface); | ||
63 | static int DirectFB_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color); | ||
64 | static int DirectFB_LockHWSurface(_THIS, SDL_Surface *surface); | ||
65 | static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface); | ||
66 | static void DirectFB_FreeHWSurface(_THIS, SDL_Surface *surface); | ||
67 | static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst); | ||
68 | static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
69 | SDL_Surface *dst, SDL_Rect *dstrect); | ||
70 | static int DirectFB_SetHWColorKey(_THIS, SDL_Surface *surface, Uint32 key); | ||
71 | static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha); | ||
72 | static int DirectFB_FlipHWSurface(_THIS, SDL_Surface *surface); | ||
73 | static int DirectFB_ShowWMCursor(_THIS, WMcursor *cursor); | ||
74 | |||
75 | /* Various screen update functions available */ | ||
76 | static void DirectFB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
77 | static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
78 | |||
79 | /* This is the rect EnumModes2 uses */ | ||
80 | struct DirectFBEnumRect { | ||
81 | SDL_Rect r; | ||
82 | struct DirectFBEnumRect* next; | ||
83 | }; | ||
84 | |||
85 | static struct DirectFBEnumRect *enumlist = NULL; | ||
86 | |||
87 | |||
88 | /* DirectFB driver bootstrap functions */ | ||
89 | |||
90 | static int DirectFB_Available(void) | ||
91 | { | ||
92 | return 1; | ||
93 | } | ||
94 | |||
95 | static void DirectFB_DeleteDevice(SDL_VideoDevice *device) | ||
96 | { | ||
97 | SDL_free(device->hidden); | ||
98 | SDL_free(device); | ||
99 | } | ||
100 | |||
101 | static SDL_VideoDevice *DirectFB_CreateDevice(int devindex) | ||
102 | { | ||
103 | SDL_VideoDevice *device; | ||
104 | |||
105 | /* Initialize all variables that we clean on shutdown */ | ||
106 | device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); | ||
107 | if (device) | ||
108 | { | ||
109 | SDL_memset (device, 0, (sizeof *device)); | ||
110 | device->hidden = (struct SDL_PrivateVideoData *) malloc (sizeof (*device->hidden)); | ||
111 | } | ||
112 | if (device == NULL || device->hidden == NULL) | ||
113 | { | ||
114 | SDL_OutOfMemory(); | ||
115 | if (device) | ||
116 | { | ||
117 | free (device); | ||
118 | } | ||
119 | return(0); | ||
120 | } | ||
121 | SDL_memset (device->hidden, 0, sizeof (*device->hidden)); | ||
122 | |||
123 | /* Set the function pointers */ | ||
124 | device->VideoInit = DirectFB_VideoInit; | ||
125 | device->ListModes = DirectFB_ListModes; | ||
126 | device->SetVideoMode = DirectFB_SetVideoMode; | ||
127 | device->SetColors = DirectFB_SetColors; | ||
128 | device->UpdateRects = NULL; | ||
129 | device->CreateYUVOverlay = DirectFB_CreateYUVOverlay; | ||
130 | device->VideoQuit = DirectFB_VideoQuit; | ||
131 | device->AllocHWSurface = DirectFB_AllocHWSurface; | ||
132 | device->CheckHWBlit = DirectFB_CheckHWBlit; | ||
133 | device->FillHWRect = DirectFB_FillHWRect; | ||
134 | device->SetHWColorKey = DirectFB_SetHWColorKey; | ||
135 | device->SetHWAlpha = DirectFB_SetHWAlpha; | ||
136 | device->LockHWSurface = DirectFB_LockHWSurface; | ||
137 | device->UnlockHWSurface = DirectFB_UnlockHWSurface; | ||
138 | device->FlipHWSurface = DirectFB_FlipHWSurface; | ||
139 | device->FreeHWSurface = DirectFB_FreeHWSurface; | ||
140 | device->ShowWMCursor = DirectFB_ShowWMCursor; | ||
141 | device->SetCaption = NULL; | ||
142 | device->SetIcon = NULL; | ||
143 | device->IconifyWindow = NULL; | ||
144 | device->GrabInput = NULL; | ||
145 | device->GetWMInfo = NULL; | ||
146 | device->InitOSKeymap = DirectFB_InitOSKeymap; | ||
147 | device->PumpEvents = DirectFB_PumpEvents; | ||
148 | |||
149 | device->free = DirectFB_DeleteDevice; | ||
150 | |||
151 | return device; | ||
152 | } | ||
153 | |||
154 | VideoBootStrap DirectFB_bootstrap = { | ||
155 | "directfb", "DirectFB", | ||
156 | DirectFB_Available, DirectFB_CreateDevice | ||
157 | }; | ||
158 | |||
159 | static DFBSurfacePixelFormat GetFormatForBpp (int bpp, IDirectFBDisplayLayer *layer) | ||
160 | { | ||
161 | DFBDisplayLayerConfig dlc; | ||
162 | int bytes = (bpp + 7) / 8; | ||
163 | |||
164 | layer->GetConfiguration (layer, &dlc); | ||
165 | |||
166 | if (bytes == DFB_BYTES_PER_PIXEL(dlc.pixelformat) && bytes > 1) | ||
167 | return dlc.pixelformat; | ||
168 | |||
169 | switch (bytes) | ||
170 | { | ||
171 | case 1: | ||
172 | return DSPF_LUT8; | ||
173 | case 2: | ||
174 | return DSPF_RGB16; | ||
175 | case 3: | ||
176 | return DSPF_RGB24; | ||
177 | case 4: | ||
178 | return DSPF_RGB32; | ||
179 | } | ||
180 | |||
181 | return DSPF_UNKNOWN; | ||
182 | } | ||
183 | |||
184 | static DFBEnumerationResult EnumModesCallback (int width, | ||
185 | int height, | ||
186 | int bpp, | ||
187 | void *data) | ||
188 | { | ||
189 | SDL_VideoDevice *this = (SDL_VideoDevice *)data; | ||
190 | struct DirectFBEnumRect *enumrect; | ||
191 | |||
192 | HIDDEN->nummodes++; | ||
193 | |||
194 | if (enumlist && enumlist->r.w == width && enumlist->r.h == height) | ||
195 | return DFENUM_OK; | ||
196 | |||
197 | enumrect = SDL_calloc(1, sizeof(struct DirectFBEnumRect)); | ||
198 | if (!enumrect) | ||
199 | { | ||
200 | SDL_OutOfMemory(); | ||
201 | return DFENUM_CANCEL; | ||
202 | } | ||
203 | |||
204 | enumrect->r.w = (Uint16)width; | ||
205 | enumrect->r.h = (Uint16)height; | ||
206 | enumrect->next = enumlist; | ||
207 | |||
208 | enumlist = enumrect; | ||
209 | |||
210 | return DFENUM_OK; | ||
211 | } | ||
212 | |||
213 | struct private_hwdata { | ||
214 | IDirectFBSurface *surface; | ||
215 | IDirectFBPalette *palette; | ||
216 | }; | ||
217 | |||
218 | void SetDirectFBerror (const char *function, DFBResult code) | ||
219 | { | ||
220 | const char *error = DirectFBErrorString (code); | ||
221 | |||
222 | if (error) | ||
223 | SDL_SetError("%s: %s", function, error); | ||
224 | else | ||
225 | SDL_SetError("Unknown error code from %s", function); | ||
226 | } | ||
227 | |||
228 | static DFBSurfacePixelFormat SDLToDFBPixelFormat (SDL_PixelFormat *format) | ||
229 | { | ||
230 | if (format->Rmask && format->Gmask && format->Bmask) | ||
231 | { | ||
232 | switch (format->BitsPerPixel) | ||
233 | { | ||
234 | case 8: | ||
235 | return DSPF_LUT8; | ||
236 | |||
237 | case 16: | ||
238 | if (format->Rmask == 0xF800 && | ||
239 | format->Gmask == 0x07E0 && | ||
240 | format->Bmask == 0x001F) | ||
241 | return DSPF_RGB16; | ||
242 | /* fall through */ | ||
243 | |||
244 | case 15: | ||
245 | if (format->Rmask == 0x7C00 && | ||
246 | format->Gmask == 0x03E0 && | ||
247 | format->Bmask == 0x001F) | ||
248 | return DSPF_ARGB1555; | ||
249 | break; | ||
250 | |||
251 | case 24: | ||
252 | if (format->Rmask == 0xFF0000 && | ||
253 | format->Gmask == 0x00FF00 && | ||
254 | format->Bmask == 0x0000FF) | ||
255 | return DSPF_RGB24; | ||
256 | break; | ||
257 | |||
258 | case 32: | ||
259 | if (format->Rmask == 0xFF0000 && | ||
260 | format->Gmask == 0x00FF00 && | ||
261 | format->Bmask == 0x0000FF) | ||
262 | { | ||
263 | if (format->Amask == 0xFF000000) | ||
264 | return DSPF_ARGB; | ||
265 | else | ||
266 | return DSPF_RGB32; | ||
267 | } | ||
268 | break; | ||
269 | } | ||
270 | } | ||
271 | else | ||
272 | { | ||
273 | switch (format->BitsPerPixel) | ||
274 | { | ||
275 | case 8: | ||
276 | return DSPF_LUT8; | ||
277 | case 15: | ||
278 | return DSPF_ARGB1555; | ||
279 | case 16: | ||
280 | return DSPF_RGB16; | ||
281 | case 24: | ||
282 | return DSPF_RGB24; | ||
283 | case 32: | ||
284 | return DSPF_RGB32; | ||
285 | } | ||
286 | } | ||
287 | |||
288 | return DSPF_UNKNOWN; | ||
289 | } | ||
290 | |||
291 | static SDL_Palette *AllocatePalette(int size) | ||
292 | { | ||
293 | SDL_Palette *palette; | ||
294 | SDL_Color *colors; | ||
295 | |||
296 | palette = SDL_calloc (1, sizeof(SDL_Palette)); | ||
297 | if (!palette) | ||
298 | { | ||
299 | SDL_OutOfMemory(); | ||
300 | return NULL; | ||
301 | } | ||
302 | |||
303 | colors = SDL_calloc (size, sizeof(SDL_Color)); | ||
304 | if (!colors) | ||
305 | { | ||
306 | SDL_OutOfMemory(); | ||
307 | return NULL; | ||
308 | } | ||
309 | |||
310 | palette->ncolors = size; | ||
311 | palette->colors = colors; | ||
312 | |||
313 | return palette; | ||
314 | } | ||
315 | |||
316 | static int DFBToSDLPixelFormat (DFBSurfacePixelFormat pixelformat, SDL_PixelFormat *format) | ||
317 | { | ||
318 | format->Amask = format->Rmask = format->Gmask = format->Bmask = 0; | ||
319 | format->BitsPerPixel = format->BytesPerPixel = 0; | ||
320 | |||
321 | switch (pixelformat) | ||
322 | { | ||
323 | case DSPF_A8: | ||
324 | format->Amask = 0x000000FF; | ||
325 | break; | ||
326 | |||
327 | case DSPF_ARGB1555: | ||
328 | format->Rmask = 0x00007C00; | ||
329 | format->Gmask = 0x000003E0; | ||
330 | format->Bmask = 0x0000001F; | ||
331 | break; | ||
332 | |||
333 | case DSPF_RGB16: | ||
334 | format->Rmask = 0x0000F800; | ||
335 | format->Gmask = 0x000007E0; | ||
336 | format->Bmask = 0x0000001F; | ||
337 | break; | ||
338 | |||
339 | case DSPF_ARGB: | ||
340 | format->Amask = 0; /* apps don't seem to like that: 0xFF000000; */ | ||
341 | /* fall through */ | ||
342 | case DSPF_RGB24: | ||
343 | case DSPF_RGB32: | ||
344 | format->Rmask = 0x00FF0000; | ||
345 | format->Gmask = 0x0000FF00; | ||
346 | format->Bmask = 0x000000FF; | ||
347 | break; | ||
348 | |||
349 | case DSPF_LUT8: | ||
350 | format->Rmask = 0x000000FF; | ||
351 | format->Gmask = 0x000000FF; | ||
352 | format->Bmask = 0x000000FF; | ||
353 | |||
354 | if (!format->palette) | ||
355 | format->palette = AllocatePalette(256); | ||
356 | break; | ||
357 | |||
358 | default: | ||
359 | fprintf (stderr, "SDL_DirectFB: Unsupported pixelformat (0x%08x)!\n", pixelformat); | ||
360 | return -1; | ||
361 | } | ||
362 | |||
363 | format->BitsPerPixel = DFB_BYTES_PER_PIXEL(pixelformat) * 8; | ||
364 | format->BytesPerPixel = DFB_BYTES_PER_PIXEL(pixelformat); | ||
365 | |||
366 | return 0; | ||
367 | } | ||
368 | |||
369 | |||
370 | int DirectFB_VideoInit(_THIS, SDL_PixelFormat *vformat) | ||
371 | { | ||
372 | int i; | ||
373 | DFBResult ret; | ||
374 | #if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23) | ||
375 | DFBCardCapabilities caps; | ||
376 | #else | ||
377 | DFBGraphicsDeviceDescription caps; | ||
378 | #endif | ||
379 | DFBDisplayLayerConfig dlc; | ||
380 | struct DirectFBEnumRect *rect; | ||
381 | IDirectFB *dfb = NULL; | ||
382 | IDirectFBDisplayLayer *layer = NULL; | ||
383 | IDirectFBEventBuffer *events = NULL; | ||
384 | |||
385 | HIDDEN->c2layer = NULL, HIDDEN->c2frame = NULL; | ||
386 | HIDDEN->enable_mga_crtc2 = 0; | ||
387 | HIDDEN->mga_crtc2_stretch_overscan = 1; | ||
388 | |||
389 | ret = DirectFBInit (NULL, NULL); | ||
390 | if (ret) | ||
391 | { | ||
392 | SetDirectFBerror ("DirectFBInit", ret); | ||
393 | goto error; | ||
394 | } | ||
395 | |||
396 | ret = DirectFBCreate (&dfb); | ||
397 | if (ret) | ||
398 | { | ||
399 | SetDirectFBerror ("DirectFBCreate", ret); | ||
400 | goto error; | ||
401 | } | ||
402 | |||
403 | ret = dfb->GetDisplayLayer (dfb, DLID_PRIMARY, &layer); | ||
404 | if (ret) | ||
405 | { | ||
406 | SetDirectFBerror ("dfb->GetDisplayLayer", ret); | ||
407 | goto error; | ||
408 | } | ||
409 | |||
410 | ret = dfb->CreateInputEventBuffer (dfb, DICAPS_ALL, DFB_FALSE, &events); | ||
411 | if (ret) | ||
412 | { | ||
413 | SetDirectFBerror ("dfb->CreateEventBuffer", ret); | ||
414 | goto error; | ||
415 | } | ||
416 | |||
417 | layer->EnableCursor (layer, 1); | ||
418 | |||
419 | /* Query layer configuration to determine the current mode and pixelformat */ | ||
420 | layer->GetConfiguration (layer, &dlc); | ||
421 | |||
422 | /* If current format is not supported use LUT8 as the default */ | ||
423 | if (DFBToSDLPixelFormat (dlc.pixelformat, vformat)) | ||
424 | DFBToSDLPixelFormat (DSPF_LUT8, vformat); | ||
425 | |||
426 | /* Enumerate the available fullscreen modes */ | ||
427 | ret = dfb->EnumVideoModes (dfb, EnumModesCallback, this); | ||
428 | if (ret) | ||
429 | { | ||
430 | SetDirectFBerror ("dfb->EnumVideoModes", ret); | ||
431 | goto error; | ||
432 | } | ||
433 | |||
434 | HIDDEN->modelist = SDL_calloc (HIDDEN->nummodes + 1, sizeof(SDL_Rect *)); | ||
435 | if (!HIDDEN->modelist) | ||
436 | { | ||
437 | SDL_OutOfMemory(); | ||
438 | goto error; | ||
439 | } | ||
440 | |||
441 | for (i = 0, rect = enumlist; rect; ++i, rect = rect->next ) | ||
442 | { | ||
443 | HIDDEN->modelist[i] = &rect->r; | ||
444 | } | ||
445 | |||
446 | HIDDEN->modelist[i] = NULL; | ||
447 | |||
448 | |||
449 | /* Query card capabilities to get the video memory size */ | ||
450 | #if (DIRECTFB_MAJOR_VERSION == 0) && (DIRECTFB_MINOR_VERSION == 9) && (DIRECTFB_MICRO_VERSION < 23) | ||
451 | dfb->GetCardCapabilities (dfb, &caps); | ||
452 | #else | ||
453 | dfb->GetDeviceDescription (dfb, &caps); | ||
454 | #endif | ||
455 | |||
456 | this->info.wm_available = 1; | ||
457 | this->info.hw_available = 1; | ||
458 | this->info.blit_hw = 1; | ||
459 | this->info.blit_hw_CC = 1; | ||
460 | this->info.blit_hw_A = 1; | ||
461 | this->info.blit_fill = 1; | ||
462 | this->info.video_mem = caps.video_memory / 1024; | ||
463 | this->info.current_w = dlc.width; | ||
464 | this->info.current_h = dlc.height; | ||
465 | |||
466 | HIDDEN->initialized = 1; | ||
467 | HIDDEN->dfb = dfb; | ||
468 | HIDDEN->layer = layer; | ||
469 | HIDDEN->eventbuffer = events; | ||
470 | |||
471 | if (SDL_getenv("SDL_DIRECTFB_MGA_CRTC2") != NULL) | ||
472 | HIDDEN->enable_mga_crtc2 = 1; | ||
473 | |||
474 | if (HIDDEN->enable_mga_crtc2) | ||
475 | { | ||
476 | DFBDisplayLayerConfig dlc; | ||
477 | DFBDisplayLayerConfigFlags failed; | ||
478 | |||
479 | ret = dfb->GetDisplayLayer (dfb, 2, &HIDDEN->c2layer); | ||
480 | if (ret) | ||
481 | { | ||
482 | SetDirectFBerror ("dfb->GetDisplayLayer(CRTC2)", ret); | ||
483 | goto error; | ||
484 | } | ||
485 | |||
486 | ret = HIDDEN->layer->SetCooperativeLevel(HIDDEN->layer, DLSCL_EXCLUSIVE); | ||
487 | if (ret) | ||
488 | { | ||
489 | SetDirectFBerror ("layer->SetCooperativeLevel(CRTC2, EXCLUSIVE)", ret); | ||
490 | goto error; | ||
491 | } | ||
492 | |||
493 | ret = HIDDEN->c2layer->SetCooperativeLevel(HIDDEN->c2layer, DLSCL_EXCLUSIVE); | ||
494 | if (ret) | ||
495 | { | ||
496 | SetDirectFBerror ("c2layer->SetCooperativeLevel(CRTC2, EXCLUSIVE)", ret); | ||
497 | goto error; | ||
498 | } | ||
499 | |||
500 | HIDDEN->c2layer->SetOpacity(HIDDEN->c2layer, 0x0); | ||
501 | |||
502 | /* Init the surface here as it got a fixed size */ | ||
503 | dlc.flags = DLCONF_PIXELFORMAT | DLCONF_BUFFERMODE; | ||
504 | dlc.buffermode = DLBM_BACKVIDEO; | ||
505 | dlc.pixelformat = DSPF_RGB32; | ||
506 | |||
507 | ret = HIDDEN->c2layer->TestConfiguration( HIDDEN->c2layer, &dlc, &failed ); | ||
508 | if (ret) | ||
509 | { | ||
510 | SetDirectFBerror ("c2layer->TestConfiguration", ret); | ||
511 | goto error; | ||
512 | } | ||
513 | |||
514 | ret = HIDDEN->c2layer->SetConfiguration( HIDDEN->c2layer, &dlc ); | ||
515 | if (ret) | ||
516 | { | ||
517 | SetDirectFBerror ("c2layer->SetConfiguration", ret); | ||
518 | goto error; | ||
519 | } | ||
520 | |||
521 | ret = HIDDEN->c2layer->GetSurface( HIDDEN->c2layer, &HIDDEN->c2frame ); | ||
522 | if (ret) | ||
523 | { | ||
524 | SetDirectFBerror ("c2layer->GetSurface", ret); | ||
525 | goto error; | ||
526 | } | ||
527 | |||
528 | HIDDEN->c2framesize.x = 0; | ||
529 | HIDDEN->c2framesize.y = 0; | ||
530 | HIDDEN->c2frame->GetSize( HIDDEN->c2frame, &HIDDEN->c2framesize.w, &HIDDEN->c2framesize.h); | ||
531 | |||
532 | HIDDEN->c2frame->SetBlittingFlags( HIDDEN->c2frame, DSBLIT_NOFX ); | ||
533 | HIDDEN->c2frame->SetColor( HIDDEN->c2frame, 0, 0, 0, 0xff ); | ||
534 | |||
535 | /* Clear CRTC2 */ | ||
536 | HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff ); | ||
537 | HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, 0 ); | ||
538 | HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff ); | ||
539 | HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, 0 ); | ||
540 | HIDDEN->c2frame->Clear(HIDDEN->c2frame, 0, 0, 0, 0xff ); | ||
541 | |||
542 | HIDDEN->c2layer->SetOpacity(HIDDEN->c2layer, 0xFF ); | ||
543 | |||
544 | /* Check if overscan is possibly set */ | ||
545 | if (SDL_getenv("SDL_DIRECTFB_MGA_OVERSCAN") != NULL) | ||
546 | { | ||
547 | float overscan = 0; | ||
548 | if (SDL_sscanf(SDL_getenv("SDL_DIRECTFB_MGA_OVERSCAN"), "%f", &overscan) == 1) | ||
549 | if (overscan > 0 && overscan < 2) | ||
550 | HIDDEN->mga_crtc2_stretch_overscan = overscan; | ||
551 | } | ||
552 | |||
553 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
554 | printf("CRTC2 overscan: %f\n", HIDDEN->mga_crtc2_stretch_overscan); | ||
555 | #endif | ||
556 | } | ||
557 | |||
558 | return 0; | ||
559 | |||
560 | error: | ||
561 | if (events) | ||
562 | events->Release (events); | ||
563 | |||
564 | if (HIDDEN->c2frame) | ||
565 | HIDDEN->c2frame->Release (HIDDEN->c2frame); | ||
566 | |||
567 | if (HIDDEN->c2layer) | ||
568 | HIDDEN->c2layer->Release (HIDDEN->c2layer); | ||
569 | |||
570 | if (layer) | ||
571 | layer->Release (layer); | ||
572 | |||
573 | if (dfb) | ||
574 | dfb->Release (dfb); | ||
575 | |||
576 | return -1; | ||
577 | } | ||
578 | |||
579 | static SDL_Rect **DirectFB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | ||
580 | { | ||
581 | if (flags & SDL_FULLSCREEN) | ||
582 | return HIDDEN->modelist; | ||
583 | else | ||
584 | if (SDLToDFBPixelFormat (format) != DSPF_UNKNOWN) | ||
585 | return (SDL_Rect**) -1; | ||
586 | |||
587 | return NULL; | ||
588 | } | ||
589 | |||
590 | static SDL_Surface *DirectFB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) | ||
591 | { | ||
592 | DFBResult ret; | ||
593 | DFBSurfaceDescription dsc; | ||
594 | DFBSurfacePixelFormat pixelformat; | ||
595 | IDirectFBSurface *surface; | ||
596 | |||
597 | fprintf (stderr, "SDL DirectFB_SetVideoMode: %dx%d@%d, flags: 0x%08x\n", | ||
598 | width, height, bpp, flags); | ||
599 | |||
600 | flags |= SDL_FULLSCREEN; | ||
601 | |||
602 | /* Release previous primary surface */ | ||
603 | if (current->hwdata && current->hwdata->surface) | ||
604 | { | ||
605 | current->hwdata->surface->Release (current->hwdata->surface); | ||
606 | current->hwdata->surface = NULL; | ||
607 | |||
608 | /* And its palette if present */ | ||
609 | if (current->hwdata->palette) | ||
610 | { | ||
611 | current->hwdata->palette->Release (current->hwdata->palette); | ||
612 | current->hwdata->palette = NULL; | ||
613 | } | ||
614 | } | ||
615 | else if (!current->hwdata) | ||
616 | { | ||
617 | /* Allocate the hardware acceleration data */ | ||
618 | current->hwdata = (struct private_hwdata *) SDL_calloc (1, sizeof(*current->hwdata)); | ||
619 | if (!current->hwdata) | ||
620 | { | ||
621 | SDL_OutOfMemory(); | ||
622 | return NULL; | ||
623 | } | ||
624 | } | ||
625 | |||
626 | /* Set cooperative level depending on flag SDL_FULLSCREEN */ | ||
627 | if (flags & SDL_FULLSCREEN) | ||
628 | { | ||
629 | ret = HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_FULLSCREEN); | ||
630 | if (ret && !HIDDEN->enable_mga_crtc2) | ||
631 | { | ||
632 | DirectFBError ("dfb->SetCooperativeLevel", ret); | ||
633 | flags &= ~SDL_FULLSCREEN; | ||
634 | } | ||
635 | } | ||
636 | else | ||
637 | HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_NORMAL); | ||
638 | |||
639 | /* Set video mode */ | ||
640 | ret = HIDDEN->dfb->SetVideoMode (HIDDEN->dfb, width, height, bpp); | ||
641 | if (ret) | ||
642 | { | ||
643 | if (flags & SDL_FULLSCREEN) | ||
644 | { | ||
645 | flags &= ~SDL_FULLSCREEN; | ||
646 | HIDDEN->dfb->SetCooperativeLevel (HIDDEN->dfb, DFSCL_NORMAL); | ||
647 | ret = HIDDEN->dfb->SetVideoMode (HIDDEN->dfb, width, height, bpp); | ||
648 | } | ||
649 | |||
650 | if (ret) | ||
651 | { | ||
652 | SetDirectFBerror ("dfb->SetVideoMode", ret); | ||
653 | return NULL; | ||
654 | } | ||
655 | } | ||
656 | |||
657 | /* Create primary surface */ | ||
658 | dsc.flags = DSDESC_CAPS | DSDESC_PIXELFORMAT; | ||
659 | dsc.caps = DSCAPS_PRIMARY | ((flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0); | ||
660 | dsc.pixelformat = GetFormatForBpp (bpp, HIDDEN->layer); | ||
661 | |||
662 | ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface); | ||
663 | if (ret && (flags & SDL_DOUBLEBUF)) | ||
664 | { | ||
665 | /* Try without double buffering */ | ||
666 | dsc.caps &= ~DSCAPS_FLIPPING; | ||
667 | ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface); | ||
668 | } | ||
669 | if (ret) | ||
670 | { | ||
671 | SetDirectFBerror ("dfb->CreateSurface", ret); | ||
672 | return NULL; | ||
673 | } | ||
674 | |||
675 | current->w = width; | ||
676 | current->h = height; | ||
677 | current->flags = SDL_HWSURFACE | SDL_PREALLOC; | ||
678 | |||
679 | if (flags & SDL_FULLSCREEN) | ||
680 | { | ||
681 | current->flags |= SDL_FULLSCREEN; | ||
682 | this->UpdateRects = DirectFB_DirectUpdate; | ||
683 | } | ||
684 | else | ||
685 | this->UpdateRects = DirectFB_WindowedUpdate; | ||
686 | |||
687 | if (dsc.caps & DSCAPS_FLIPPING) | ||
688 | current->flags |= SDL_DOUBLEBUF; | ||
689 | |||
690 | surface->GetPixelFormat (surface, &pixelformat); | ||
691 | |||
692 | DFBToSDLPixelFormat (pixelformat, current->format); | ||
693 | |||
694 | /* Get the surface palette (if supported) */ | ||
695 | if (DFB_PIXELFORMAT_IS_INDEXED( pixelformat )) | ||
696 | { | ||
697 | surface->GetPalette (surface, ¤t->hwdata->palette); | ||
698 | |||
699 | current->flags |= SDL_HWPALETTE; | ||
700 | } | ||
701 | |||
702 | current->hwdata->surface = surface; | ||
703 | |||
704 | /* MGA CRTC2 stuff */ | ||
705 | if (HIDDEN->enable_mga_crtc2) | ||
706 | { | ||
707 | /* no stretching if c2ssize == c2framesize */ | ||
708 | HIDDEN->c2ssize.x = 0, HIDDEN->c2ssize.y = 0; | ||
709 | HIDDEN->c2ssize.w = width; | ||
710 | HIDDEN->c2ssize.h = height; | ||
711 | |||
712 | HIDDEN->c2dsize.x = 0, HIDDEN->c2dsize.y = 0; | ||
713 | HIDDEN->c2dsize.w = width; | ||
714 | HIDDEN->c2dsize.h = height; | ||
715 | |||
716 | HIDDEN->mga_crtc2_stretch = 0; | ||
717 | |||
718 | if (SDL_getenv("SDL_DIRECTFB_MGA_STRETCH") != NULL) | ||
719 | { | ||
720 | /* Normally assume a picture aspect ratio of 4:3 */ | ||
721 | int zoom_aspect_x = 4, zoom_aspect_y = 3, i, j; | ||
722 | |||
723 | for (i = 1; i < 20; i++) | ||
724 | { | ||
725 | for (j = 1; j < 10; j++) | ||
726 | { | ||
727 | if ((float)width/(float)i*(float)j == height) | ||
728 | { | ||
729 | zoom_aspect_x = i; | ||
730 | zoom_aspect_y = j; | ||
731 | |||
732 | /* break the loop */ | ||
733 | i = 21; | ||
734 | break; | ||
735 | } | ||
736 | } | ||
737 | } | ||
738 | |||
739 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
740 | printf("Source resolution: X: %d, Y: %d, Aspect ratio: %d:%d\n", width, height, zoom_aspect_x, zoom_aspect_y); | ||
741 | printf("CRTC2 resolution: X: %d, Y: %d\n", HIDDEN->c2framesize.w, HIDDEN->c2framesize.h); | ||
742 | #endif | ||
743 | |||
744 | /* don't stretch only slightly smaller/larger images */ | ||
745 | if ((float)width < (float)HIDDEN->c2framesize.w*0.95 || (float)height < (float)HIDDEN->c2framesize.h*0.95) | ||
746 | { | ||
747 | while ((float)HIDDEN->c2dsize.w < (float)HIDDEN->c2framesize.w*HIDDEN->mga_crtc2_stretch_overscan && (float)HIDDEN->c2dsize.h < (float)HIDDEN->c2framesize.h*HIDDEN->mga_crtc2_stretch_overscan) | ||
748 | { | ||
749 | HIDDEN->c2dsize.w+=zoom_aspect_x; | ||
750 | HIDDEN->c2dsize.h+=zoom_aspect_y; | ||
751 | } | ||
752 | |||
753 | /* one step down */ | ||
754 | HIDDEN->c2dsize.w-=zoom_aspect_x; | ||
755 | HIDDEN->c2dsize.h-=zoom_aspect_y; | ||
756 | |||
757 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
758 | printf("Stretched resolution: X: %d, Y: %d\n", HIDDEN->c2dsize.w, HIDDEN->c2dsize.h); | ||
759 | #endif | ||
760 | |||
761 | HIDDEN->mga_crtc2_stretch = 1; | ||
762 | } | ||
763 | else if ((float)width > (float)HIDDEN->c2framesize.w*0.95 || (float)height > (float)HIDDEN->c2framesize.h*0.95) | ||
764 | { | ||
765 | while ((float)HIDDEN->c2dsize.w > (float)HIDDEN->c2framesize.w*HIDDEN->mga_crtc2_stretch_overscan || (float)HIDDEN->c2dsize.h > (float)HIDDEN->c2framesize.h*HIDDEN->mga_crtc2_stretch_overscan) | ||
766 | { | ||
767 | HIDDEN->c2dsize.w-=zoom_aspect_x; | ||
768 | HIDDEN->c2dsize.h-=zoom_aspect_y; | ||
769 | } | ||
770 | |||
771 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
772 | printf("Down-Stretched resolution: X: %d, Y: %d\n", HIDDEN->c2dsize.w, HIDDEN->c2dsize.h); | ||
773 | #endif | ||
774 | |||
775 | HIDDEN->mga_crtc2_stretch = 1; | ||
776 | } else { | ||
777 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
778 | printf("Not stretching image\n"); | ||
779 | #endif | ||
780 | } | ||
781 | |||
782 | /* Panning */ | ||
783 | if (HIDDEN->c2framesize.w > HIDDEN->c2dsize.w) | ||
784 | HIDDEN->c2dsize.x = (HIDDEN->c2framesize.w - HIDDEN->c2dsize.w) / 2; | ||
785 | else | ||
786 | HIDDEN->c2dsize.x = (HIDDEN->c2dsize.w - HIDDEN->c2framesize.w) / 2; | ||
787 | |||
788 | if (HIDDEN->c2framesize.h > HIDDEN->c2dsize.h) | ||
789 | HIDDEN->c2dsize.y = (HIDDEN->c2framesize.h - HIDDEN->c2dsize.h) / 2; | ||
790 | else | ||
791 | HIDDEN->c2dsize.y = (HIDDEN->c2dsize.h - HIDDEN->c2framesize.h) / 2; | ||
792 | |||
793 | #ifdef DIRECTFB_CRTC2_DEBUG | ||
794 | printf("CRTC2 position X: %d, Y: %d\n", HIDDEN->c2dsize.x, HIDDEN->c2dsize.y); | ||
795 | #endif | ||
796 | } | ||
797 | } | ||
798 | |||
799 | return current; | ||
800 | } | ||
801 | |||
802 | static int DirectFB_AllocHWSurface(_THIS, SDL_Surface *surface) | ||
803 | { | ||
804 | DFBResult ret; | ||
805 | DFBSurfaceDescription dsc; | ||
806 | |||
807 | /* fprintf(stderr, "SDL: DirectFB_AllocHWSurface (%dx%d@%d, flags: 0x%08x)\n", | ||
808 | surface->w, surface->h, surface->format->BitsPerPixel, surface->flags);*/ | ||
809 | |||
810 | if (surface->w < 8 || surface->h < 8) | ||
811 | return -1; | ||
812 | |||
813 | /* fill surface description */ | ||
814 | dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT | DSDESC_CAPS; | ||
815 | dsc.width = surface->w; | ||
816 | dsc.height = surface->h; | ||
817 | dsc.caps = (surface->flags & SDL_DOUBLEBUF) ? DSCAPS_FLIPPING : 0; | ||
818 | |||
819 | /* find the right pixelformat */ | ||
820 | dsc.pixelformat = SDLToDFBPixelFormat (surface->format); | ||
821 | if (dsc.pixelformat == DSPF_UNKNOWN) | ||
822 | return -1; | ||
823 | |||
824 | /* Allocate the hardware acceleration data */ | ||
825 | surface->hwdata = (struct private_hwdata *) SDL_calloc (1, sizeof(*surface->hwdata)); | ||
826 | if (surface->hwdata == NULL) | ||
827 | { | ||
828 | SDL_OutOfMemory(); | ||
829 | return -1; | ||
830 | } | ||
831 | |||
832 | /* Create the surface */ | ||
833 | ret = HIDDEN->dfb->CreateSurface (HIDDEN->dfb, &dsc, &surface->hwdata->surface); | ||
834 | if (ret) | ||
835 | { | ||
836 | SetDirectFBerror ("dfb->CreateSurface", ret); | ||
837 | free (surface->hwdata); | ||
838 | surface->hwdata = NULL; | ||
839 | return -1; | ||
840 | } | ||
841 | |||
842 | surface->flags |= SDL_HWSURFACE | SDL_PREALLOC; | ||
843 | |||
844 | return 0; | ||
845 | } | ||
846 | |||
847 | static void DirectFB_FreeHWSurface(_THIS, SDL_Surface *surface) | ||
848 | { | ||
849 | if (surface->hwdata && HIDDEN->initialized) | ||
850 | { | ||
851 | surface->hwdata->surface->Release (surface->hwdata->surface); | ||
852 | free (surface->hwdata); | ||
853 | surface->hwdata = NULL; | ||
854 | } | ||
855 | } | ||
856 | |||
857 | static int DirectFB_CheckHWBlit(_THIS, SDL_Surface *src, SDL_Surface *dst) | ||
858 | { | ||
859 | /* fprintf(stderr, "SDL: DirectFB_CheckHWBlit (src->hwdata: %p, dst->hwdata: %p)\n", | ||
860 | src->hwdata, dst->hwdata);*/ | ||
861 | |||
862 | if (!src->hwdata || !dst->hwdata) | ||
863 | return 0; | ||
864 | |||
865 | src->flags |= SDL_HWACCEL; | ||
866 | src->map->hw_blit = DirectFB_HWAccelBlit; | ||
867 | |||
868 | return 1; | ||
869 | } | ||
870 | |||
871 | static int DirectFB_HWAccelBlit(SDL_Surface *src, SDL_Rect *srcrect, | ||
872 | SDL_Surface *dst, SDL_Rect *dstrect) | ||
873 | { | ||
874 | DFBSurfaceBlittingFlags flags = DSBLIT_NOFX; | ||
875 | |||
876 | DFBRectangle sr = { srcrect->x, srcrect->y, srcrect->w, srcrect->h }; | ||
877 | DFBRectangle dr = { dstrect->x, dstrect->y, dstrect->w, dstrect->h }; | ||
878 | |||
879 | IDirectFBSurface *surface = dst->hwdata->surface; | ||
880 | |||
881 | if (src->flags & SDL_SRCCOLORKEY) | ||
882 | { | ||
883 | flags |= DSBLIT_SRC_COLORKEY; | ||
884 | DirectFB_SetHWColorKey (NULL, src, src->format->colorkey); | ||
885 | } | ||
886 | |||
887 | if (src->flags & SDL_SRCALPHA) | ||
888 | { | ||
889 | flags |= DSBLIT_BLEND_COLORALPHA; | ||
890 | surface->SetColor (surface, 0xff, 0xff, 0xff, src->format->alpha); | ||
891 | } | ||
892 | |||
893 | surface->SetBlittingFlags (surface, flags); | ||
894 | |||
895 | if (sr.w == dr.w && sr.h == dr.h) | ||
896 | surface->Blit (surface, src->hwdata->surface, &sr, dr.x, dr.y); | ||
897 | else | ||
898 | surface->StretchBlit (surface, src->hwdata->surface, &sr, &dr); | ||
899 | |||
900 | return 0; | ||
901 | } | ||
902 | |||
903 | static int DirectFB_FillHWRect(_THIS, SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color) | ||
904 | { | ||
905 | SDL_PixelFormat *fmt = dst->format; | ||
906 | IDirectFBSurface *surface = dst->hwdata->surface; | ||
907 | |||
908 | /* ugly */ | ||
909 | surface->SetColor (surface, | ||
910 | (color & fmt->Rmask) >> (fmt->Rshift - fmt->Rloss), | ||
911 | (color & fmt->Gmask) >> (fmt->Gshift - fmt->Gloss), | ||
912 | (color & fmt->Bmask) << (fmt->Bloss - fmt->Bshift), 0xFF); | ||
913 | surface->FillRectangle (surface, dstrect->x, dstrect->y, dstrect->w, dstrect->h); | ||
914 | |||
915 | return 0; | ||
916 | } | ||
917 | |||
918 | static int DirectFB_SetHWColorKey(_THIS, SDL_Surface *src, Uint32 key) | ||
919 | { | ||
920 | SDL_PixelFormat *fmt = src->format; | ||
921 | IDirectFBSurface *surface = src->hwdata->surface; | ||
922 | |||
923 | if (fmt->BitsPerPixel == 8) | ||
924 | surface->SetSrcColorKeyIndex (surface, key); | ||
925 | else | ||
926 | /* ugly */ | ||
927 | surface->SetSrcColorKey (surface, | ||
928 | (key & fmt->Rmask) >> (fmt->Rshift - fmt->Rloss), | ||
929 | (key & fmt->Gmask) >> (fmt->Gshift - fmt->Gloss), | ||
930 | (key & fmt->Bmask) << (fmt->Bloss - fmt->Bshift)); | ||
931 | |||
932 | return 0; | ||
933 | } | ||
934 | |||
935 | static int DirectFB_SetHWAlpha(_THIS, SDL_Surface *surface, Uint8 alpha) | ||
936 | { | ||
937 | return 0; | ||
938 | } | ||
939 | |||
940 | static int DirectFB_FlipHWSurface(_THIS, SDL_Surface *surface) | ||
941 | { | ||
942 | if (HIDDEN->enable_mga_crtc2) | ||
943 | { | ||
944 | int rtn = surface->hwdata->surface->Flip (surface->hwdata->surface, NULL, 0); | ||
945 | if (HIDDEN->mga_crtc2_stretch) | ||
946 | HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, surface->hwdata->surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize); | ||
947 | else | ||
948 | HIDDEN->c2frame->Blit(HIDDEN->c2frame, surface->hwdata->surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y); | ||
949 | |||
950 | HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC); | ||
951 | return rtn; | ||
952 | } | ||
953 | else | ||
954 | return surface->hwdata->surface->Flip (surface->hwdata->surface, NULL, DSFLIP_WAITFORSYNC); | ||
955 | } | ||
956 | |||
957 | static int DirectFB_LockHWSurface(_THIS, SDL_Surface *surface) | ||
958 | { | ||
959 | DFBResult ret; | ||
960 | void *data; | ||
961 | int pitch; | ||
962 | |||
963 | ret = surface->hwdata->surface->Lock (surface->hwdata->surface, | ||
964 | DSLF_WRITE, &data, &pitch); | ||
965 | if (ret) | ||
966 | { | ||
967 | SetDirectFBerror ("surface->Lock", ret); | ||
968 | return -1; | ||
969 | } | ||
970 | |||
971 | surface->pixels = data; | ||
972 | surface->pitch = pitch; | ||
973 | |||
974 | return 0; | ||
975 | } | ||
976 | |||
977 | static void DirectFB_UnlockHWSurface(_THIS, SDL_Surface *surface) | ||
978 | { | ||
979 | surface->hwdata->surface->Unlock (surface->hwdata->surface); | ||
980 | surface->pixels = NULL; | ||
981 | } | ||
982 | |||
983 | static void DirectFB_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) | ||
984 | { | ||
985 | if (HIDDEN->enable_mga_crtc2) | ||
986 | { | ||
987 | if (HIDDEN->mga_crtc2_stretch) | ||
988 | HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, this->screen->hwdata->surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize); | ||
989 | else | ||
990 | HIDDEN->c2frame->Blit(HIDDEN->c2frame, this->screen->hwdata->surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y); | ||
991 | |||
992 | HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC); | ||
993 | } | ||
994 | } | ||
995 | |||
996 | static void DirectFB_WindowedUpdate(_THIS, int numrects, SDL_Rect *rects) | ||
997 | { | ||
998 | DFBRegion region; | ||
999 | int i; | ||
1000 | int region_valid = 0; | ||
1001 | IDirectFBSurface *surface = this->screen->hwdata->surface; | ||
1002 | |||
1003 | for (i=0; i<numrects; ++i) | ||
1004 | { | ||
1005 | int x2, y2; | ||
1006 | |||
1007 | if ( ! rects[i].w ) /* Clipped? */ | ||
1008 | continue; | ||
1009 | |||
1010 | x2 = rects[i].x + rects[i].w - 1; | ||
1011 | y2 = rects[i].y + rects[i].h - 1; | ||
1012 | |||
1013 | if (region_valid) | ||
1014 | { | ||
1015 | if (rects[i].x < region.x1) | ||
1016 | region.x1 = rects[i].x; | ||
1017 | |||
1018 | if (rects[i].y < region.y1) | ||
1019 | region.y1 = rects[i].y; | ||
1020 | |||
1021 | if (x2 > region.x2) | ||
1022 | region.x2 = x2; | ||
1023 | |||
1024 | if (y2 > region.y2) | ||
1025 | region.y2 = y2; | ||
1026 | } | ||
1027 | else | ||
1028 | { | ||
1029 | region.x1 = rects[i].x; | ||
1030 | region.y1 = rects[i].y; | ||
1031 | region.x2 = x2; | ||
1032 | region.y2 = y2; | ||
1033 | |||
1034 | region_valid = 1; | ||
1035 | } | ||
1036 | } | ||
1037 | |||
1038 | if (region_valid) | ||
1039 | { | ||
1040 | if (HIDDEN->enable_mga_crtc2) | ||
1041 | { | ||
1042 | if (HIDDEN->mga_crtc2_stretch) | ||
1043 | HIDDEN->c2frame->StretchBlit(HIDDEN->c2frame, surface, &HIDDEN->c2ssize, &HIDDEN->c2dsize); | ||
1044 | else | ||
1045 | HIDDEN->c2frame->Blit(HIDDEN->c2frame, surface, NULL, HIDDEN->c2dsize.x, HIDDEN->c2dsize.y); | ||
1046 | |||
1047 | HIDDEN->c2frame->Flip(HIDDEN->c2frame, NULL, DSFLIP_WAITFORSYNC); | ||
1048 | } | ||
1049 | else | ||
1050 | surface->Flip (surface, ®ion, DSFLIP_WAITFORSYNC); | ||
1051 | } | ||
1052 | } | ||
1053 | |||
1054 | int DirectFB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | ||
1055 | { | ||
1056 | IDirectFBPalette *palette = this->screen->hwdata->palette; | ||
1057 | |||
1058 | if (!palette) | ||
1059 | return 0; | ||
1060 | |||
1061 | if (firstcolor > 255) | ||
1062 | return 0; | ||
1063 | |||
1064 | if (firstcolor + ncolors > 256) | ||
1065 | ncolors = 256 - firstcolor; | ||
1066 | |||
1067 | if (ncolors > 0) | ||
1068 | { | ||
1069 | int i; | ||
1070 | DFBColor entries[ncolors]; | ||
1071 | |||
1072 | for (i=0; i<ncolors; i++) | ||
1073 | { | ||
1074 | entries[i].a = 0xff; | ||
1075 | entries[i].r = colors[i].r; | ||
1076 | entries[i].g = colors[i].g; | ||
1077 | entries[i].b = colors[i].b; | ||
1078 | } | ||
1079 | |||
1080 | palette->SetEntries (palette, entries, ncolors, firstcolor); | ||
1081 | } | ||
1082 | |||
1083 | return 1; | ||
1084 | } | ||
1085 | |||
1086 | void DirectFB_VideoQuit(_THIS) | ||
1087 | { | ||
1088 | struct DirectFBEnumRect *rect = enumlist; | ||
1089 | |||
1090 | if (this->screen && this->screen->hwdata) | ||
1091 | { | ||
1092 | IDirectFBSurface *surface = this->screen->hwdata->surface; | ||
1093 | IDirectFBPalette *palette = this->screen->hwdata->palette; | ||
1094 | |||
1095 | if (palette) | ||
1096 | palette->Release (palette); | ||
1097 | |||
1098 | if (surface) | ||
1099 | surface->Release (surface); | ||
1100 | |||
1101 | this->screen->hwdata->surface = NULL; | ||
1102 | this->screen->hwdata->palette = NULL; | ||
1103 | } | ||
1104 | |||
1105 | if (HIDDEN->c2frame) | ||
1106 | { | ||
1107 | HIDDEN->c2frame->Release (HIDDEN->c2frame); | ||
1108 | HIDDEN->c2frame = NULL; | ||
1109 | } | ||
1110 | |||
1111 | if (HIDDEN->eventbuffer) | ||
1112 | { | ||
1113 | HIDDEN->eventbuffer->Release (HIDDEN->eventbuffer); | ||
1114 | HIDDEN->eventbuffer = NULL; | ||
1115 | } | ||
1116 | |||
1117 | if (HIDDEN->c2layer) | ||
1118 | { | ||
1119 | HIDDEN->c2layer->Release (HIDDEN->c2layer); | ||
1120 | HIDDEN->c2layer = NULL; | ||
1121 | } | ||
1122 | |||
1123 | if (HIDDEN->layer) | ||
1124 | { | ||
1125 | HIDDEN->layer->Release (HIDDEN->layer); | ||
1126 | HIDDEN->layer = NULL; | ||
1127 | } | ||
1128 | |||
1129 | if (HIDDEN->dfb) | ||
1130 | { | ||
1131 | HIDDEN->dfb->Release (HIDDEN->dfb); | ||
1132 | HIDDEN->dfb = NULL; | ||
1133 | } | ||
1134 | |||
1135 | /* Free video mode list */ | ||
1136 | if (HIDDEN->modelist) | ||
1137 | { | ||
1138 | free (HIDDEN->modelist); | ||
1139 | HIDDEN->modelist = NULL; | ||
1140 | } | ||
1141 | |||
1142 | /* Free mode enumeration list */ | ||
1143 | while (rect) | ||
1144 | { | ||
1145 | struct DirectFBEnumRect *next = rect->next; | ||
1146 | free (rect); | ||
1147 | rect = next; | ||
1148 | } | ||
1149 | enumlist = NULL; | ||
1150 | |||
1151 | HIDDEN->initialized = 0; | ||
1152 | } | ||
1153 | |||
1154 | |||
1155 | int DirectFB_ShowWMCursor(_THIS, WMcursor *cursor) | ||
1156 | { | ||
1157 | /* We can only hide or show the default cursor */ | ||
1158 | if ( cursor == NULL ) | ||
1159 | { | ||
1160 | HIDDEN->layer->SetCursorOpacity(HIDDEN->layer, 0x00); | ||
1161 | } | ||
1162 | else | ||
1163 | { | ||
1164 | HIDDEN->layer->SetCursorOpacity(HIDDEN->layer, 0xFF); | ||
1165 | } | ||
1166 | return 1; | ||
1167 | } | ||
1168 | |||
1169 | void DirectFB_FinalQuit(void) | ||
1170 | { | ||
1171 | } | ||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.h b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.h new file mode 100644 index 0000000000..e1fa12c268 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_video.h | |||
@@ -0,0 +1,62 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | #ifndef _SDL_DirectFB_video_h | ||
25 | #define _SDL_DirectFB_video_h | ||
26 | |||
27 | #include <directfb.h> | ||
28 | |||
29 | #include "SDL_mouse.h" | ||
30 | #include "../SDL_sysvideo.h" | ||
31 | |||
32 | #define _THIS SDL_VideoDevice *this | ||
33 | |||
34 | /* Private display data */ | ||
35 | |||
36 | struct SDL_PrivateVideoData | ||
37 | { | ||
38 | int initialized; | ||
39 | |||
40 | IDirectFB *dfb; | ||
41 | IDirectFBDisplayLayer *layer; | ||
42 | IDirectFBEventBuffer *eventbuffer; | ||
43 | |||
44 | int nummodes; | ||
45 | SDL_Rect **modelist; | ||
46 | |||
47 | /* MGA CRTC2 support */ | ||
48 | int enable_mga_crtc2; | ||
49 | int mga_crtc2_stretch; | ||
50 | float mga_crtc2_stretch_overscan; | ||
51 | IDirectFBDisplayLayer *c2layer; | ||
52 | IDirectFBSurface *c2frame; | ||
53 | DFBRectangle c2ssize; /* Real screen size */ | ||
54 | DFBRectangle c2dsize; /* Stretched screen size */ | ||
55 | DFBRectangle c2framesize; /* CRTC2 screen size */ | ||
56 | }; | ||
57 | |||
58 | #define HIDDEN (this->hidden) | ||
59 | |||
60 | void SetDirectFBerror (const char *function, DFBResult code); | ||
61 | |||
62 | #endif /* _SDL_DirectFB_video_h */ | ||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.c b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.c new file mode 100644 index 0000000000..fd0cef1180 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.c | |||
@@ -0,0 +1,290 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* This is the DirectFB implementation of YUV video overlays */ | ||
25 | |||
26 | #include "SDL_video.h" | ||
27 | #include "SDL_DirectFB_yuv.h" | ||
28 | #include "../SDL_yuvfuncs.h" | ||
29 | |||
30 | |||
31 | /* The functions used to manipulate software video overlays */ | ||
32 | static struct private_yuvhwfuncs directfb_yuvfuncs = { | ||
33 | DirectFB_LockYUVOverlay, | ||
34 | DirectFB_UnlockYUVOverlay, | ||
35 | DirectFB_DisplayYUVOverlay, | ||
36 | DirectFB_FreeYUVOverlay | ||
37 | }; | ||
38 | |||
39 | struct private_yuvhwdata { | ||
40 | DFBDisplayLayerID layer_id; | ||
41 | |||
42 | IDirectFBDisplayLayer *layer; | ||
43 | IDirectFBSurface *surface; | ||
44 | |||
45 | /* These are just so we don't have to allocate them separately */ | ||
46 | Uint16 pitches[3]; | ||
47 | Uint8 *planes[3]; | ||
48 | }; | ||
49 | |||
50 | static DFBEnumerationResult | ||
51 | enum_layers_callback( DFBDisplayLayerID id, | ||
52 | DFBDisplayLayerDescription desc, | ||
53 | void *data ) | ||
54 | { | ||
55 | struct private_yuvhwdata *hwdata = (struct private_yuvhwdata *) data; | ||
56 | |||
57 | /* we don't want the primary */ | ||
58 | if (id == DLID_PRIMARY) | ||
59 | return DFENUM_OK; | ||
60 | |||
61 | /* take the one with a surface for video */ | ||
62 | if ((desc.caps & DLCAPS_SURFACE) && (desc.type & DLTF_VIDEO)) | ||
63 | { | ||
64 | hwdata->layer_id = id; | ||
65 | |||
66 | return DFENUM_CANCEL; | ||
67 | } | ||
68 | |||
69 | return DFENUM_OK; | ||
70 | } | ||
71 | |||
72 | |||
73 | static DFBResult CreateYUVSurface(_THIS, struct private_yuvhwdata *hwdata, | ||
74 | int width, int height, Uint32 format) | ||
75 | { | ||
76 | DFBResult ret; | ||
77 | IDirectFB *dfb = HIDDEN->dfb; | ||
78 | IDirectFBDisplayLayer *layer; | ||
79 | DFBDisplayLayerConfig conf; | ||
80 | |||
81 | ret = dfb->EnumDisplayLayers (dfb, enum_layers_callback, hwdata); | ||
82 | if (ret) | ||
83 | { | ||
84 | SetDirectFBerror("IDirectFB::EnumDisplayLayers", ret); | ||
85 | return ret; | ||
86 | } | ||
87 | |||
88 | if (!hwdata->layer_id) | ||
89 | return DFB_UNSUPPORTED; | ||
90 | |||
91 | ret = dfb->GetDisplayLayer (dfb, hwdata->layer_id, &layer); | ||
92 | if (ret) | ||
93 | { | ||
94 | SetDirectFBerror("IDirectFB::GetDisplayLayer", ret); | ||
95 | return ret; | ||
96 | } | ||
97 | |||
98 | conf.flags = DLCONF_WIDTH | DLCONF_HEIGHT | DLCONF_PIXELFORMAT; | ||
99 | conf.width = width; | ||
100 | conf.height = height; | ||
101 | |||
102 | switch (format) | ||
103 | { | ||
104 | case SDL_YV12_OVERLAY: | ||
105 | conf.pixelformat = DSPF_YV12; | ||
106 | break; | ||
107 | case SDL_IYUV_OVERLAY: | ||
108 | conf.pixelformat = DSPF_I420; | ||
109 | break; | ||
110 | case SDL_YUY2_OVERLAY: | ||
111 | conf.pixelformat = DSPF_YUY2; | ||
112 | break; | ||
113 | case SDL_UYVY_OVERLAY: | ||
114 | conf.pixelformat = DSPF_UYVY; | ||
115 | break; | ||
116 | default: | ||
117 | fprintf (stderr, "SDL_DirectFB: Unsupported YUV format (0x%08x)!\n", format); | ||
118 | break; | ||
119 | } | ||
120 | |||
121 | /* Need to set coop level or newer DirectFB versions will fail here. */ | ||
122 | ret = layer->SetCooperativeLevel (layer, DLSCL_ADMINISTRATIVE); | ||
123 | if (ret) | ||
124 | { | ||
125 | SetDirectFBerror("IDirectFBDisplayLayer::SetCooperativeLevel() failed", ret); | ||
126 | layer->Release (layer); | ||
127 | return ret; | ||
128 | } | ||
129 | |||
130 | ret = layer->SetConfiguration (layer, &conf); | ||
131 | if (ret) | ||
132 | { | ||
133 | SetDirectFBerror("IDirectFBDisplayLayer::SetConfiguration", ret); | ||
134 | layer->Release (layer); | ||
135 | return ret; | ||
136 | } | ||
137 | |||
138 | ret = layer->GetSurface (layer, &hwdata->surface); | ||
139 | if (ret) | ||
140 | { | ||
141 | SetDirectFBerror("IDirectFBDisplayLayer::GetSurface", ret); | ||
142 | layer->Release (layer); | ||
143 | return ret; | ||
144 | } | ||
145 | |||
146 | hwdata->layer = layer; | ||
147 | |||
148 | return DFB_OK; | ||
149 | } | ||
150 | |||
151 | SDL_Overlay *DirectFB_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, SDL_Surface *display) | ||
152 | { | ||
153 | SDL_Overlay *overlay; | ||
154 | struct private_yuvhwdata *hwdata; | ||
155 | |||
156 | /* Create the overlay structure */ | ||
157 | overlay = SDL_calloc (1, sizeof(SDL_Overlay)); | ||
158 | if (!overlay) | ||
159 | { | ||
160 | SDL_OutOfMemory(); | ||
161 | return NULL; | ||
162 | } | ||
163 | |||
164 | /* Fill in the basic members */ | ||
165 | overlay->format = format; | ||
166 | overlay->w = width; | ||
167 | overlay->h = height; | ||
168 | |||
169 | /* Set up the YUV surface function structure */ | ||
170 | overlay->hwfuncs = &directfb_yuvfuncs; | ||
171 | |||
172 | /* Create the pixel data and lookup tables */ | ||
173 | hwdata = SDL_calloc(1, sizeof(struct private_yuvhwdata)); | ||
174 | overlay->hwdata = hwdata; | ||
175 | if (!hwdata) | ||
176 | { | ||
177 | SDL_OutOfMemory(); | ||
178 | SDL_FreeYUVOverlay (overlay); | ||
179 | return NULL; | ||
180 | } | ||
181 | |||
182 | if (CreateYUVSurface (this, hwdata, width, height, format)) | ||
183 | { | ||
184 | SDL_FreeYUVOverlay (overlay); | ||
185 | return NULL; | ||
186 | } | ||
187 | |||
188 | overlay->hw_overlay = 1; | ||
189 | |||
190 | /* Set up the plane pointers */ | ||
191 | overlay->pitches = hwdata->pitches; | ||
192 | overlay->pixels = hwdata->planes; | ||
193 | switch (format) | ||
194 | { | ||
195 | case SDL_YV12_OVERLAY: | ||
196 | case SDL_IYUV_OVERLAY: | ||
197 | overlay->planes = 3; | ||
198 | break; | ||
199 | default: | ||
200 | overlay->planes = 1; | ||
201 | break; | ||
202 | } | ||
203 | |||
204 | /* We're all done.. */ | ||
205 | return overlay; | ||
206 | } | ||
207 | |||
208 | int DirectFB_LockYUVOverlay(_THIS, SDL_Overlay *overlay) | ||
209 | { | ||
210 | DFBResult ret; | ||
211 | void *data; | ||
212 | int pitch; | ||
213 | IDirectFBSurface *surface = overlay->hwdata->surface; | ||
214 | |||
215 | ret = surface->Lock (surface, DSLF_READ | DSLF_WRITE, &data, &pitch); | ||
216 | if (ret) | ||
217 | { | ||
218 | SetDirectFBerror("IDirectFBSurface::Lock", ret); | ||
219 | return -1; | ||
220 | } | ||
221 | |||
222 | /* Find the pitch and offset values for the overlay */ | ||
223 | overlay->pitches[0] = (Uint16) pitch; | ||
224 | overlay->pixels[0] = (Uint8*) data; | ||
225 | |||
226 | switch (overlay->format) | ||
227 | { | ||
228 | case SDL_YV12_OVERLAY: | ||
229 | case SDL_IYUV_OVERLAY: | ||
230 | /* Add the two extra planes */ | ||
231 | overlay->pitches[1] = overlay->pitches[0] / 2; | ||
232 | overlay->pitches[2] = overlay->pitches[0] / 2; | ||
233 | overlay->pixels[1] = overlay->pixels[0] + overlay->pitches[0] * overlay->h; | ||
234 | overlay->pixels[2] = overlay->pixels[1] + overlay->pitches[1] * overlay->h / 2; | ||
235 | break; | ||
236 | default: | ||
237 | /* Only one plane, no worries */ | ||
238 | break; | ||
239 | } | ||
240 | |||
241 | return 0; | ||
242 | } | ||
243 | |||
244 | void DirectFB_UnlockYUVOverlay(_THIS, SDL_Overlay *overlay) | ||
245 | { | ||
246 | IDirectFBSurface *surface = overlay->hwdata->surface; | ||
247 | |||
248 | overlay->pixels[0] = overlay->pixels[1] = overlay->pixels[2] = NULL; | ||
249 | |||
250 | surface->Unlock (surface); | ||
251 | } | ||
252 | |||
253 | int DirectFB_DisplayYUVOverlay(_THIS, SDL_Overlay *overlay, SDL_Rect *src, SDL_Rect *dst) | ||
254 | { | ||
255 | DFBResult ret; | ||
256 | DFBDisplayLayerConfig conf; | ||
257 | IDirectFBDisplayLayer *primary = HIDDEN->layer; | ||
258 | IDirectFBDisplayLayer *layer = overlay->hwdata->layer; | ||
259 | |||
260 | primary->GetConfiguration (primary, &conf); | ||
261 | |||
262 | ret = layer->SetScreenLocation (layer, | ||
263 | dst->x / (float) conf.width, dst->y / (float) conf.height, | ||
264 | dst->w / (float) conf.width, dst->h / (float) conf.height ); | ||
265 | if (ret) | ||
266 | { | ||
267 | SetDirectFBerror("IDirectFBDisplayLayer::SetScreenLocation", ret); | ||
268 | return -1; | ||
269 | } | ||
270 | |||
271 | return 0; | ||
272 | } | ||
273 | |||
274 | void DirectFB_FreeYUVOverlay(_THIS, SDL_Overlay *overlay) | ||
275 | { | ||
276 | struct private_yuvhwdata *hwdata; | ||
277 | |||
278 | hwdata = overlay->hwdata; | ||
279 | if (hwdata) | ||
280 | { | ||
281 | if (hwdata->surface) | ||
282 | hwdata->surface->Release (hwdata->surface); | ||
283 | |||
284 | if (hwdata->layer) | ||
285 | hwdata->layer->Release (hwdata->layer); | ||
286 | |||
287 | free (hwdata); | ||
288 | } | ||
289 | } | ||
290 | |||
diff --git a/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.h b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.h new file mode 100644 index 0000000000..64bc86fa02 --- /dev/null +++ b/apps/plugins/sdl/src/video/directfb/SDL_DirectFB_yuv.h | |||
@@ -0,0 +1,38 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 Sam Lantinga | ||
4 | |||
5 | This library is free software; you can redistribute it and/or | ||
6 | modify it under the terms of the GNU Lesser General Public | ||
7 | License as published by the Free Software Foundation; either | ||
8 | version 2.1 of the License, or (at your option) any later version. | ||
9 | |||
10 | This library is distributed in the hope that it will be useful, | ||
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Lesser General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Lesser General Public | ||
16 | License along with this library; if not, write to the Free Software | ||
17 | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA | ||
18 | |||
19 | Sam Lantinga | ||
20 | slouken@libsdl.org | ||
21 | */ | ||
22 | #include "SDL_config.h" | ||
23 | |||
24 | /* This is the DirectFB implementation of YUV video overlays */ | ||
25 | |||
26 | #include "SDL_video.h" | ||
27 | #include "SDL_DirectFB_video.h" | ||
28 | |||
29 | extern SDL_Overlay *DirectFB_CreateYUVOverlay(_THIS, int width, int height, Uint32 format, SDL_Surface *display); | ||
30 | |||
31 | extern int DirectFB_LockYUVOverlay(_THIS, SDL_Overlay *overlay); | ||
32 | |||
33 | extern void DirectFB_UnlockYUVOverlay(_THIS, SDL_Overlay *overlay); | ||
34 | |||
35 | extern int DirectFB_DisplayYUVOverlay(_THIS, SDL_Overlay *overlay, SDL_Rect *src, SDL_Rect *dst); | ||
36 | |||
37 | extern void DirectFB_FreeYUVOverlay(_THIS, SDL_Overlay *overlay); | ||
38 | |||