diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/ggi/SDL_ggivideo.c')
-rw-r--r-- | apps/plugins/sdl/src/video/ggi/SDL_ggivideo.c | 378 |
1 files changed, 378 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/ggi/SDL_ggivideo.c b/apps/plugins/sdl/src/video/ggi/SDL_ggivideo.c new file mode 100644 index 0000000000..face49543e --- /dev/null +++ b/apps/plugins/sdl/src/video/ggi/SDL_ggivideo.c | |||
@@ -0,0 +1,378 @@ | |||
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 | /* GGI-based SDL video driver implementation. | ||
25 | */ | ||
26 | |||
27 | #include <fcntl.h> | ||
28 | #include <unistd.h> | ||
29 | #include <sys/mman.h> | ||
30 | |||
31 | #include <ggi/ggi.h> | ||
32 | #include <ggi/gii.h> | ||
33 | |||
34 | #include "SDL_video.h" | ||
35 | #include "SDL_mouse.h" | ||
36 | #include "../SDL_sysvideo.h" | ||
37 | #include "../SDL_pixels_c.h" | ||
38 | #include "../../events/SDL_events_c.h" | ||
39 | #include "SDL_ggivideo.h" | ||
40 | #include "SDL_ggimouse_c.h" | ||
41 | #include "SDL_ggievents_c.h" | ||
42 | |||
43 | |||
44 | struct private_hwdata | ||
45 | { | ||
46 | ggi_visual_t vis; | ||
47 | }; | ||
48 | |||
49 | ggi_visual_t VIS; | ||
50 | |||
51 | /* Initialization/Query functions */ | ||
52 | static int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat); | ||
53 | static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | ||
54 | static SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
55 | static int GGI_SetColors(_THIS, int firstcolor, int ncolors, | ||
56 | SDL_Color *colors); | ||
57 | static void GGI_VideoQuit(_THIS); | ||
58 | |||
59 | /* Hardware surface functions */ | ||
60 | static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface); | ||
61 | static int GGI_LockHWSurface(_THIS, SDL_Surface *surface); | ||
62 | static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface); | ||
63 | static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface); | ||
64 | |||
65 | /* GGI driver bootstrap functions */ | ||
66 | |||
67 | static int GGI_Available(void) | ||
68 | { | ||
69 | ggi_visual_t *vis; | ||
70 | |||
71 | vis = NULL; | ||
72 | if (ggiInit() == 0) { | ||
73 | vis = ggiOpen(NULL); | ||
74 | if (vis != NULL) { | ||
75 | ggiClose(vis); | ||
76 | } | ||
77 | } | ||
78 | return (vis != NULL); | ||
79 | } | ||
80 | |||
81 | static void GGI_DeleteDevice(SDL_VideoDevice *device) | ||
82 | { | ||
83 | SDL_free(device->hidden); | ||
84 | SDL_free(device); | ||
85 | } | ||
86 | |||
87 | static SDL_VideoDevice *GGI_CreateDevice(int devindex) | ||
88 | { | ||
89 | SDL_VideoDevice *device; | ||
90 | |||
91 | /* Initialize all variables that we clean on shutdown */ | ||
92 | device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); | ||
93 | if ( device ) { | ||
94 | SDL_memset(device, 0, (sizeof *device)); | ||
95 | device->hidden = (struct SDL_PrivateVideoData *) | ||
96 | SDL_malloc((sizeof *device->hidden)); | ||
97 | } | ||
98 | if ( (device == NULL) || (device->hidden == NULL) ) { | ||
99 | SDL_OutOfMemory(); | ||
100 | if ( device ) { | ||
101 | SDL_free(device); | ||
102 | } | ||
103 | return(0); | ||
104 | } | ||
105 | SDL_memset(device->hidden, 0, (sizeof *device->hidden)); | ||
106 | |||
107 | /* Set the function pointers */ | ||
108 | device->VideoInit = GGI_VideoInit; | ||
109 | device->ListModes = GGI_ListModes; | ||
110 | device->SetVideoMode = GGI_SetVideoMode; | ||
111 | device->SetColors = GGI_SetColors; | ||
112 | device->UpdateRects = NULL; | ||
113 | device->VideoQuit = GGI_VideoQuit; | ||
114 | device->AllocHWSurface = GGI_AllocHWSurface; | ||
115 | device->CheckHWBlit = NULL; | ||
116 | device->FillHWRect = NULL; | ||
117 | device->SetHWColorKey = NULL; | ||
118 | device->SetHWAlpha = NULL; | ||
119 | device->LockHWSurface = GGI_LockHWSurface; | ||
120 | device->UnlockHWSurface = GGI_UnlockHWSurface; | ||
121 | device->FlipHWSurface = NULL; | ||
122 | device->FreeHWSurface = GGI_FreeHWSurface; | ||
123 | device->SetCaption = NULL; | ||
124 | device->SetIcon = NULL; | ||
125 | device->IconifyWindow = NULL; | ||
126 | device->GrabInput = NULL; | ||
127 | device->GetWMInfo = NULL; | ||
128 | device->InitOSKeymap = GGI_InitOSKeymap; | ||
129 | device->PumpEvents = GGI_PumpEvents; | ||
130 | |||
131 | device->free = GGI_DeleteDevice; | ||
132 | |||
133 | return device; | ||
134 | } | ||
135 | |||
136 | VideoBootStrap GGI_bootstrap = { | ||
137 | "ggi", "General Graphics Interface (GGI)", | ||
138 | GGI_Available, GGI_CreateDevice | ||
139 | }; | ||
140 | |||
141 | |||
142 | static SDL_Rect video_mode; | ||
143 | static SDL_Rect *SDL_modelist[4] = { NULL, NULL, NULL, NULL }; | ||
144 | |||
145 | int GGI_VideoInit(_THIS, SDL_PixelFormat *vformat) | ||
146 | { | ||
147 | ggi_mode mode = | ||
148 | { | ||
149 | 1, | ||
150 | { GGI_AUTO, GGI_AUTO }, | ||
151 | { GGI_AUTO, GGI_AUTO }, | ||
152 | { 0, 0 }, | ||
153 | GT_AUTO, | ||
154 | { GGI_AUTO, GGI_AUTO } | ||
155 | }; | ||
156 | struct private_hwdata *priv; | ||
157 | ggi_color pal[256], map[256]; | ||
158 | const ggi_directbuffer *db; | ||
159 | int err, num_bufs; | ||
160 | ggi_pixel white, black; | ||
161 | |||
162 | priv = SDL_malloc(sizeof(struct private_hwdata)); | ||
163 | if (priv == NULL) | ||
164 | { | ||
165 | SDL_SetError("Unhandled GGI mode type!\n"); | ||
166 | GGI_VideoQuit(NULL); | ||
167 | } | ||
168 | |||
169 | if (ggiInit() != 0) | ||
170 | { | ||
171 | SDL_SetError("Unable to initialize GGI!\n"); | ||
172 | GGI_VideoQuit(NULL); | ||
173 | } | ||
174 | |||
175 | VIS = ggiOpen(NULL); | ||
176 | if (VIS == NULL) | ||
177 | { | ||
178 | SDL_SetError("Unable to open default GGI visual!\n"); | ||
179 | ggiExit(); | ||
180 | GGI_VideoQuit(NULL); | ||
181 | } | ||
182 | |||
183 | ggiSetFlags(VIS, GGIFLAG_ASYNC); | ||
184 | |||
185 | /* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */ | ||
186 | ggiCheckMode(VIS, &mode); | ||
187 | |||
188 | /* At this point we should have a valid mode - try to set it */ | ||
189 | err = ggiSetMode(VIS, &mode); | ||
190 | |||
191 | /* If we couldn't set _any_ modes, something is very wrong */ | ||
192 | if (err) | ||
193 | { | ||
194 | SDL_SetError("Can't set a mode!\n"); | ||
195 | ggiClose(VIS); | ||
196 | ggiExit(); | ||
197 | GGI_VideoQuit(NULL); | ||
198 | } | ||
199 | |||
200 | /* Determine the current screen size */ | ||
201 | this->info.current_w = mode.virt.x; | ||
202 | this->info.current_h = mode.virt.y; | ||
203 | |||
204 | /* Set a palette for palletized modes */ | ||
205 | if (GT_SCHEME(mode.graphtype) == GT_PALETTE) | ||
206 | { | ||
207 | ggiSetColorfulPalette(VIS); | ||
208 | ggiGetPalette(VIS, 0, 1 << vformat->BitsPerPixel, pal); | ||
209 | } | ||
210 | |||
211 | /* Now we try to get the DirectBuffer info, which determines whether | ||
212 | * SDL can access hardware surfaces directly. */ | ||
213 | |||
214 | num_bufs = ggiDBGetNumBuffers(VIS); | ||
215 | |||
216 | if (num_bufs > 0) | ||
217 | { | ||
218 | db = ggiDBGetBuffer(VIS, 0); /* Only handle one DB for now */ | ||
219 | |||
220 | vformat->BitsPerPixel = db->buffer.plb.pixelformat->depth; | ||
221 | |||
222 | vformat->Rmask = db->buffer.plb.pixelformat->red_mask; | ||
223 | vformat->Gmask = db->buffer.plb.pixelformat->green_mask; | ||
224 | vformat->Bmask = db->buffer.plb.pixelformat->blue_mask; | ||
225 | |||
226 | /* Fill in our hardware acceleration capabilities */ | ||
227 | |||
228 | this->info.wm_available = 0; | ||
229 | this->info.hw_available = 1; | ||
230 | this->info.video_mem = db->buffer.plb.stride * mode.virt.y; | ||
231 | } | ||
232 | |||
233 | video_mode.x = 0; | ||
234 | video_mode.y = 0; | ||
235 | video_mode.w = mode.virt.x; | ||
236 | video_mode.h = mode.virt.y; | ||
237 | SDL_modelist[((vformat->BitsPerPixel + 7) / 8) - 1] = &video_mode; | ||
238 | |||
239 | /* We're done! */ | ||
240 | return(0); | ||
241 | } | ||
242 | |||
243 | static SDL_Rect **GGI_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | ||
244 | { | ||
245 | return(&SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]); | ||
246 | } | ||
247 | |||
248 | /* Various screen update functions available */ | ||
249 | static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
250 | |||
251 | SDL_Surface *GGI_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags) | ||
252 | { | ||
253 | ggi_mode mode = | ||
254 | { | ||
255 | 1, | ||
256 | { GGI_AUTO, GGI_AUTO }, | ||
257 | { GGI_AUTO, GGI_AUTO }, | ||
258 | { 0, 0 }, | ||
259 | GT_AUTO, | ||
260 | { GGI_AUTO, GGI_AUTO } | ||
261 | }; | ||
262 | const ggi_directbuffer *db; | ||
263 | ggi_color pal[256]; | ||
264 | int err; | ||
265 | |||
266 | fprintf(stderr, "GGI_SetVideoMode()\n"); | ||
267 | |||
268 | mode.visible.x = mode.virt.x = width; | ||
269 | mode.visible.y = mode.virt.y = height; | ||
270 | |||
271 | /* Translate requested SDL bit depth into a GGI mode */ | ||
272 | switch (bpp) | ||
273 | { | ||
274 | case 1: mode.graphtype = GT_1BIT; break; | ||
275 | case 2: mode.graphtype = GT_2BIT; break; | ||
276 | case 4: mode.graphtype = GT_4BIT; break; | ||
277 | case 8: mode.graphtype = GT_8BIT; break; | ||
278 | case 15: mode.graphtype = GT_15BIT; break; | ||
279 | case 16: mode.graphtype = GT_16BIT; break; | ||
280 | case 24: mode.graphtype = GT_24BIT; break; | ||
281 | case 32: mode.graphtype = GT_32BIT; break; | ||
282 | default: | ||
283 | SDL_SetError("Unknown SDL bit depth, using GT_AUTO....\n"); | ||
284 | mode.graphtype = GT_AUTO; | ||
285 | } | ||
286 | |||
287 | /* Validate mode, autodetecting any GGI_AUTO or GT_AUTO fields */ | ||
288 | ggiCheckMode(VIS, &mode); | ||
289 | |||
290 | /* At this point we should have a valid mode - try to set it */ | ||
291 | err = ggiSetMode(VIS, &mode); | ||
292 | |||
293 | /* If we couldn't set _any_ modes, something is very wrong */ | ||
294 | if (err) | ||
295 | { | ||
296 | SDL_SetError("Can't set a mode!\n"); | ||
297 | ggiClose(VIS); | ||
298 | ggiExit(); | ||
299 | GGI_VideoQuit(NULL); | ||
300 | } | ||
301 | |||
302 | /* Set a palette for palletized modes */ | ||
303 | if (GT_SCHEME(mode.graphtype) == GT_PALETTE) | ||
304 | { | ||
305 | ggiSetColorfulPalette(VIS); | ||
306 | ggiGetPalette(VIS, 0, 1 << bpp, pal); | ||
307 | } | ||
308 | |||
309 | db = ggiDBGetBuffer(VIS, 0); | ||
310 | |||
311 | /* Set up the new mode framebuffer */ | ||
312 | current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE); | ||
313 | current->w = mode.virt.x; | ||
314 | current->h = mode.virt.y; | ||
315 | current->pitch = db->buffer.plb.stride; | ||
316 | current->pixels = db->read; | ||
317 | |||
318 | /* Set the blit function */ | ||
319 | this->UpdateRects = GGI_DirectUpdate; | ||
320 | |||
321 | /* We're done */ | ||
322 | return(current); | ||
323 | } | ||
324 | |||
325 | static int GGI_AllocHWSurface(_THIS, SDL_Surface *surface) | ||
326 | { | ||
327 | return(-1); | ||
328 | } | ||
329 | static void GGI_FreeHWSurface(_THIS, SDL_Surface *surface) | ||
330 | { | ||
331 | return; | ||
332 | } | ||
333 | static int GGI_LockHWSurface(_THIS, SDL_Surface *surface) | ||
334 | { | ||
335 | return(0); | ||
336 | } | ||
337 | static void GGI_UnlockHWSurface(_THIS, SDL_Surface *surface) | ||
338 | { | ||
339 | return; | ||
340 | } | ||
341 | |||
342 | static void GGI_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) | ||
343 | { | ||
344 | int i; | ||
345 | |||
346 | /* ggiFlush(VIS); */ | ||
347 | |||
348 | for (i = 0; i < numrects; i++) | ||
349 | { | ||
350 | ggiFlushRegion(VIS, rects[i].x, rects[i].y, rects[i].w, rects[i].h); | ||
351 | } | ||
352 | return; | ||
353 | } | ||
354 | |||
355 | int GGI_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | ||
356 | { | ||
357 | int i; | ||
358 | ggi_color pal[256]; | ||
359 | |||
360 | /* Set up the colormap */ | ||
361 | for (i = 0; i < ncolors; i++) | ||
362 | { | ||
363 | pal[i].r = (colors[i].r << 8) | colors[i].r; | ||
364 | pal[i].g = (colors[i].g << 8) | colors[i].g; | ||
365 | pal[i].b = (colors[i].b << 8) | colors[i].b; | ||
366 | } | ||
367 | |||
368 | ggiSetPalette(VIS, firstcolor, ncolors, pal); | ||
369 | |||
370 | return 1; | ||
371 | } | ||
372 | |||
373 | void GGI_VideoQuit(_THIS) | ||
374 | { | ||
375 | } | ||
376 | void GGI_FinalQuit(void) | ||
377 | { | ||
378 | } | ||