diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/vgl/SDL_vglvideo.c')
-rw-r--r-- | apps/plugins/sdl/src/video/vgl/SDL_vglvideo.c | 624 |
1 files changed, 0 insertions, 624 deletions
diff --git a/apps/plugins/sdl/src/video/vgl/SDL_vglvideo.c b/apps/plugins/sdl/src/video/vgl/SDL_vglvideo.c deleted file mode 100644 index 0b61615593..0000000000 --- a/apps/plugins/sdl/src/video/vgl/SDL_vglvideo.c +++ /dev/null | |||
@@ -1,624 +0,0 @@ | |||
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 | /* libvga based SDL video driver implementation. | ||
25 | */ | ||
26 | |||
27 | #include <err.h> | ||
28 | #include <osreldate.h> | ||
29 | #include <unistd.h> | ||
30 | #include <sys/stat.h> | ||
31 | |||
32 | #include <sys/fbio.h> | ||
33 | #include <sys/consio.h> | ||
34 | #include <sys/kbio.h> | ||
35 | #include <vgl.h> | ||
36 | |||
37 | #include "SDL_video.h" | ||
38 | #include "SDL_mouse.h" | ||
39 | #include "../SDL_sysvideo.h" | ||
40 | #include "../SDL_pixels_c.h" | ||
41 | #include "../../events/SDL_events_c.h" | ||
42 | #include "SDL_vglvideo.h" | ||
43 | #include "SDL_vglevents_c.h" | ||
44 | #include "SDL_vglmouse_c.h" | ||
45 | |||
46 | |||
47 | /* Initialization/Query functions */ | ||
48 | static int VGL_VideoInit(_THIS, SDL_PixelFormat *vformat); | ||
49 | static SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | ||
50 | static SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | ||
51 | static int VGL_SetColors(_THIS, int firstcolor, int ncolors, | ||
52 | SDL_Color *colors); | ||
53 | static void VGL_VideoQuit(_THIS); | ||
54 | |||
55 | /* Hardware surface functions */ | ||
56 | static int VGL_AllocHWSurface(_THIS, SDL_Surface *surface); | ||
57 | static int VGL_LockHWSurface(_THIS, SDL_Surface *surface); | ||
58 | static int VGL_FlipHWSurface(_THIS, SDL_Surface *surface); | ||
59 | static void VGL_UnlockHWSurface(_THIS, SDL_Surface *surface); | ||
60 | static void VGL_FreeHWSurface(_THIS, SDL_Surface *surface); | ||
61 | |||
62 | /* Misc function */ | ||
63 | static VGLMode ** VGLListModes(int depth, int mem_model); | ||
64 | |||
65 | /* VGL driver bootstrap functions */ | ||
66 | |||
67 | static int VGL_Available(void) | ||
68 | { | ||
69 | /* | ||
70 | * Check to see if we are root and stdin is a | ||
71 | * virtual console. Also try to ensure that | ||
72 | * modes other than 320x200 are available | ||
73 | */ | ||
74 | int console, hires_available, i; | ||
75 | VGLMode **modes; | ||
76 | |||
77 | console = STDIN_FILENO; | ||
78 | if ( console >= 0 ) { | ||
79 | struct stat sb; | ||
80 | struct vt_mode dummy; | ||
81 | |||
82 | if ( (fstat(console, &sb) < 0) || | ||
83 | (ioctl(console, VT_GETMODE, &dummy) < 0) ) { | ||
84 | console = -1; | ||
85 | } | ||
86 | } | ||
87 | if (geteuid() != 0 && console == -1) | ||
88 | return 0; | ||
89 | |||
90 | modes = VGLListModes(8, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); | ||
91 | hires_available = 0; | ||
92 | for (i = 0; modes[i] != NULL; i++) { | ||
93 | if ((modes[i]->ModeInfo.Xsize > 320) && | ||
94 | (modes[i]->ModeInfo.Ysize > 200) && | ||
95 | ((modes[i]->ModeInfo.Type == VIDBUF8) || | ||
96 | (modes[i]->ModeInfo.Type == VIDBUF16) || | ||
97 | (modes[i]->ModeInfo.Type == VIDBUF32))) { | ||
98 | hires_available = 1; | ||
99 | break; | ||
100 | } | ||
101 | } | ||
102 | return hires_available; | ||
103 | } | ||
104 | |||
105 | static void VGL_DeleteDevice(SDL_VideoDevice *device) | ||
106 | { | ||
107 | SDL_free(device->hidden); | ||
108 | SDL_free(device); | ||
109 | } | ||
110 | |||
111 | static SDL_VideoDevice *VGL_CreateDevice(int devindex) | ||
112 | { | ||
113 | SDL_VideoDevice *device; | ||
114 | |||
115 | /* Initialize all variables that we clean on shutdown */ | ||
116 | device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); | ||
117 | if ( device ) { | ||
118 | SDL_memset(device, 0, (sizeof *device)); | ||
119 | device->hidden = (struct SDL_PrivateVideoData *) | ||
120 | SDL_malloc((sizeof *device->hidden)); | ||
121 | } | ||
122 | if ( (device == NULL) || (device->hidden == NULL) ) { | ||
123 | SDL_OutOfMemory(); | ||
124 | if ( device ) { | ||
125 | SDL_free(device); | ||
126 | } | ||
127 | return(0); | ||
128 | } | ||
129 | SDL_memset(device->hidden, 0, (sizeof *device->hidden)); | ||
130 | |||
131 | /* Set the function pointers */ | ||
132 | device->VideoInit = VGL_VideoInit; | ||
133 | device->ListModes = VGL_ListModes; | ||
134 | device->SetVideoMode = VGL_SetVideoMode; | ||
135 | device->SetColors = VGL_SetColors; | ||
136 | device->UpdateRects = NULL; | ||
137 | device->VideoQuit = VGL_VideoQuit; | ||
138 | device->AllocHWSurface = VGL_AllocHWSurface; | ||
139 | device->CheckHWBlit = NULL; | ||
140 | device->FillHWRect = NULL; | ||
141 | device->SetHWColorKey = NULL; | ||
142 | device->SetHWAlpha = NULL; | ||
143 | device->LockHWSurface = VGL_LockHWSurface; | ||
144 | device->UnlockHWSurface = VGL_UnlockHWSurface; | ||
145 | device->FlipHWSurface = VGL_FlipHWSurface; | ||
146 | device->FreeHWSurface = VGL_FreeHWSurface; | ||
147 | device->SetIcon = NULL; | ||
148 | device->SetCaption = NULL; | ||
149 | device->GetWMInfo = NULL; | ||
150 | device->FreeWMCursor = VGL_FreeWMCursor; | ||
151 | device->CreateWMCursor = VGL_CreateWMCursor; | ||
152 | device->ShowWMCursor = VGL_ShowWMCursor; | ||
153 | device->WarpWMCursor = VGL_WarpWMCursor; | ||
154 | device->InitOSKeymap = VGL_InitOSKeymap; | ||
155 | device->PumpEvents = VGL_PumpEvents; | ||
156 | |||
157 | device->free = VGL_DeleteDevice; | ||
158 | |||
159 | return device; | ||
160 | } | ||
161 | |||
162 | VideoBootStrap VGL_bootstrap = { | ||
163 | "vgl", "FreeBSD libVGL", | ||
164 | VGL_Available, VGL_CreateDevice | ||
165 | }; | ||
166 | |||
167 | static int VGL_AddMode(_THIS, VGLMode *inmode) | ||
168 | { | ||
169 | SDL_Rect *mode; | ||
170 | |||
171 | int i, index; | ||
172 | int next_mode; | ||
173 | |||
174 | /* Check to see if we already have this mode */ | ||
175 | if (inmode->Depth < 8) { /* Not supported */ | ||
176 | return 0; | ||
177 | } | ||
178 | index = ((inmode->Depth + 7) / 8) - 1; | ||
179 | for (i=0; i<SDL_nummodes[index]; ++i) { | ||
180 | mode = SDL_modelist[index][i]; | ||
181 | if ((mode->w == inmode->ModeInfo.Xsize) && | ||
182 | (mode->h == inmode->ModeInfo.Ysize)) | ||
183 | return 0; | ||
184 | } | ||
185 | |||
186 | /* Set up the new video mode rectangle */ | ||
187 | mode = (SDL_Rect *)SDL_malloc(sizeof *mode); | ||
188 | if (mode == NULL) { | ||
189 | SDL_OutOfMemory(); | ||
190 | return -1; | ||
191 | } | ||
192 | mode->x = 0; | ||
193 | mode->y = 0; | ||
194 | mode->w = inmode->ModeInfo.Xsize; | ||
195 | mode->h = inmode->ModeInfo.Ysize; | ||
196 | |||
197 | /* Allocate the new list of modes, and fill in the new mode */ | ||
198 | next_mode = SDL_nummodes[index]; | ||
199 | SDL_modelist[index] = (SDL_Rect **) | ||
200 | SDL_realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); | ||
201 | if (SDL_modelist[index] == NULL) { | ||
202 | SDL_OutOfMemory(); | ||
203 | SDL_nummodes[index] = 0; | ||
204 | SDL_free(mode); | ||
205 | return -1; | ||
206 | } | ||
207 | SDL_modelist[index][next_mode] = mode; | ||
208 | SDL_modelist[index][next_mode+1] = NULL; | ||
209 | SDL_nummodes[index]++; | ||
210 | |||
211 | return 0; | ||
212 | } | ||
213 | |||
214 | static void VGL_UpdateVideoInfo(_THIS) | ||
215 | { | ||
216 | this->info.wm_available = 0; | ||
217 | this->info.hw_available = 1; | ||
218 | this->info.video_mem = 0; | ||
219 | if (VGLCurMode == NULL) { | ||
220 | return; | ||
221 | } | ||
222 | if (VGLCurMode->ModeInfo.PixelBytes > 0) { | ||
223 | this->info.video_mem = VGLCurMode->ModeInfo.PixelBytes * | ||
224 | VGLCurMode->ModeInfo.Xsize * | ||
225 | VGLCurMode->ModeInfo.Ysize; | ||
226 | } | ||
227 | } | ||
228 | |||
229 | int VGL_VideoInit(_THIS, SDL_PixelFormat *vformat) | ||
230 | { | ||
231 | int i; | ||
232 | int total_modes; | ||
233 | VGLMode **modes; | ||
234 | |||
235 | /* Initialize all variables that we clean on shutdown */ | ||
236 | for ( i=0; i<NUM_MODELISTS; ++i ) { | ||
237 | SDL_nummodes[i] = 0; | ||
238 | SDL_modelist[i] = NULL; | ||
239 | } | ||
240 | |||
241 | /* Enable mouse and keyboard support */ | ||
242 | if (SDL_getenv("SDL_NO_RAWKBD") == NULL) { | ||
243 | if (VGLKeyboardInit(VGL_CODEKEYS) != 0) { | ||
244 | SDL_SetError("Unable to initialize keyboard"); | ||
245 | return -1; | ||
246 | } | ||
247 | } else { | ||
248 | warnx("Requiest to put keyboard into a raw mode ignored"); | ||
249 | } | ||
250 | if (VGL_initkeymaps(STDIN_FILENO) != 0) { | ||
251 | SDL_SetError("Unable to initialize keymap"); | ||
252 | return -1; | ||
253 | } | ||
254 | if (VGL_initmouse(STDIN_FILENO) != 0) { | ||
255 | SDL_SetError("Unable to initialize mouse"); | ||
256 | return -1; | ||
257 | } | ||
258 | |||
259 | /* Determine the current screen size */ | ||
260 | if (VGLCurMode != NULL) { | ||
261 | this->info.current_w = VGLCurMode->ModeInfo.Xsize; | ||
262 | this->info.current_h = VGLCurMode->ModeInfo.Ysize; | ||
263 | } | ||
264 | |||
265 | /* Determine the screen depth */ | ||
266 | if (VGLCurMode != NULL) | ||
267 | vformat->BitsPerPixel = VGLCurMode->Depth; | ||
268 | else | ||
269 | vformat->BitsPerPixel = 16; /* Good default */ | ||
270 | |||
271 | /* Query for the list of available video modes */ | ||
272 | total_modes = 0; | ||
273 | modes = VGLListModes(-1, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); | ||
274 | for (i = 0; modes[i] != NULL; i++) { | ||
275 | if ((modes[i]->ModeInfo.Type == VIDBUF8) || | ||
276 | (modes[i]->ModeInfo.Type == VIDBUF16) || | ||
277 | (modes[i]->ModeInfo.Type == VIDBUF32)) { | ||
278 | VGL_AddMode(this, modes[i]); | ||
279 | total_modes++; | ||
280 | } | ||
281 | } | ||
282 | if (total_modes == 0) { | ||
283 | SDL_SetError("No linear video modes available"); | ||
284 | return -1; | ||
285 | } | ||
286 | |||
287 | /* Fill in our hardware acceleration capabilities */ | ||
288 | VGL_UpdateVideoInfo(this); | ||
289 | |||
290 | /* Create the hardware surface lock mutex */ | ||
291 | hw_lock = SDL_CreateMutex(); | ||
292 | if (hw_lock == NULL) { | ||
293 | SDL_SetError("Unable to create lock mutex"); | ||
294 | VGL_VideoQuit(this); | ||
295 | return -1; | ||
296 | } | ||
297 | |||
298 | /* We're done! */ | ||
299 | return 0; | ||
300 | } | ||
301 | |||
302 | SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | ||
303 | { | ||
304 | return SDL_modelist[((format->BitsPerPixel+7)/8)-1]; | ||
305 | } | ||
306 | |||
307 | /* Various screen update functions available */ | ||
308 | static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect *rects); | ||
309 | |||
310 | SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface *current, | ||
311 | int width, int height, int bpp, Uint32 flags) | ||
312 | { | ||
313 | int mode_found; | ||
314 | int i; | ||
315 | VGLMode **modes; | ||
316 | |||
317 | modes = VGLListModes(bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); | ||
318 | mode_found = 0; | ||
319 | for (i = 0; modes[i] != NULL; i++) { | ||
320 | if ((modes[i]->ModeInfo.Xsize == width) && | ||
321 | (modes[i]->ModeInfo.Ysize == height) && | ||
322 | ((modes[i]->ModeInfo.Type == VIDBUF8) || | ||
323 | (modes[i]->ModeInfo.Type == VIDBUF16) || | ||
324 | (modes[i]->ModeInfo.Type == VIDBUF32))) { | ||
325 | mode_found = 1; | ||
326 | break; | ||
327 | } | ||
328 | } | ||
329 | if (mode_found == 0) { | ||
330 | SDL_SetError("No matching video mode found"); | ||
331 | return NULL; | ||
332 | } | ||
333 | |||
334 | /* Shutdown previous videomode (if any) */ | ||
335 | if (VGLCurMode != NULL) | ||
336 | VGLEnd(); | ||
337 | |||
338 | /* Try to set the requested linear video mode */ | ||
339 | if (VGLInit(modes[i]->ModeId) != 0) { | ||
340 | SDL_SetError("Unable to switch to requested mode"); | ||
341 | return NULL; | ||
342 | } | ||
343 | |||
344 | VGLCurMode = SDL_realloc(VGLCurMode, sizeof(VGLMode)); | ||
345 | VGLCurMode->ModeInfo = *VGLDisplay; | ||
346 | VGLCurMode->Depth = modes[i]->Depth; | ||
347 | VGLCurMode->ModeId = modes[i]->ModeId; | ||
348 | VGLCurMode->Rmask = modes[i]->Rmask; | ||
349 | VGLCurMode->Gmask = modes[i]->Gmask; | ||
350 | VGLCurMode->Bmask = modes[i]->Bmask; | ||
351 | |||
352 | /* Workaround a bug in libvgl */ | ||
353 | if (VGLCurMode->ModeInfo.PixelBytes == 0) | ||
354 | (VGLCurMode->ModeInfo.PixelBytes = 1); | ||
355 | |||
356 | current->w = VGLCurMode->ModeInfo.Xsize; | ||
357 | current->h = VGLCurMode->ModeInfo.Ysize; | ||
358 | current->pixels = VGLCurMode->ModeInfo.Bitmap; | ||
359 | current->pitch = VGLCurMode->ModeInfo.Xsize * | ||
360 | VGLCurMode->ModeInfo.PixelBytes; | ||
361 | current->flags = (SDL_FULLSCREEN | SDL_HWSURFACE); | ||
362 | |||
363 | /* Check if we are in a pseudo-color mode */ | ||
364 | if (VGLCurMode->ModeInfo.Type == VIDBUF8) | ||
365 | current->flags |= SDL_HWPALETTE; | ||
366 | |||
367 | /* Check if we can do doublebuffering */ | ||
368 | if (flags & SDL_DOUBLEBUF) { | ||
369 | if (VGLCurMode->ModeInfo.Xsize * 2 <= | ||
370 | VGLCurMode->ModeInfo.VYsize) { | ||
371 | current->flags |= SDL_DOUBLEBUF; | ||
372 | flip_page = 0; | ||
373 | flip_address[0] = (byte *)current->pixels; | ||
374 | flip_address[1] = (byte *)current->pixels + | ||
375 | current->h * current->pitch; | ||
376 | VGL_FlipHWSurface(this, current); | ||
377 | } | ||
378 | } | ||
379 | |||
380 | if (! SDL_ReallocFormat(current, modes[i]->Depth, VGLCurMode->Rmask, | ||
381 | VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) { | ||
382 | return NULL; | ||
383 | } | ||
384 | |||
385 | /* Update hardware acceleration info */ | ||
386 | VGL_UpdateVideoInfo(this); | ||
387 | |||
388 | /* Set the blit function */ | ||
389 | this->UpdateRects = VGL_DirectUpdate; | ||
390 | |||
391 | /* We're done */ | ||
392 | return current; | ||
393 | } | ||
394 | |||
395 | /* We don't actually allow hardware surfaces other than the main one */ | ||
396 | static int VGL_AllocHWSurface(_THIS, SDL_Surface *surface) | ||
397 | { | ||
398 | return -1; | ||
399 | } | ||
400 | static void VGL_FreeHWSurface(_THIS, SDL_Surface *surface) | ||
401 | { | ||
402 | return; | ||
403 | } | ||
404 | |||
405 | /* We need to wait for vertical retrace on page flipped displays */ | ||
406 | static int VGL_LockHWSurface(_THIS, SDL_Surface *surface) | ||
407 | { | ||
408 | if (surface == SDL_VideoSurface) { | ||
409 | SDL_mutexP(hw_lock); | ||
410 | } | ||
411 | return 0; | ||
412 | } | ||
413 | static void VGL_UnlockHWSurface(_THIS, SDL_Surface *surface) | ||
414 | { | ||
415 | if (surface == SDL_VideoSurface) { | ||
416 | SDL_mutexV(hw_lock); | ||
417 | } | ||
418 | } | ||
419 | |||
420 | static int VGL_FlipHWSurface(_THIS, SDL_Surface *surface) | ||
421 | { | ||
422 | if (VGLPanScreen(VGLDisplay, 0, flip_page * surface->h) < 0) { | ||
423 | SDL_SetError("VGLPanSreen() failed"); | ||
424 | return -1; | ||
425 | } | ||
426 | |||
427 | flip_page = !flip_page; | ||
428 | surface->pixels = flip_address[flip_page]; | ||
429 | |||
430 | return 0; | ||
431 | } | ||
432 | |||
433 | static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect *rects) | ||
434 | { | ||
435 | return; | ||
436 | } | ||
437 | |||
438 | int VGL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) | ||
439 | { | ||
440 | int i; | ||
441 | |||
442 | for(i = 0; i < ncolors; i++) { | ||
443 | VGLSetPaletteIndex(firstcolor + i, | ||
444 | colors[i].r>>2, | ||
445 | colors[i].g>>2, | ||
446 | colors[i].b>>2); | ||
447 | } | ||
448 | return 1; | ||
449 | } | ||
450 | |||
451 | /* Note: If we are terminated, this could be called in the middle of | ||
452 | another SDL video routine -- notably UpdateRects. | ||
453 | */ | ||
454 | void VGL_VideoQuit(_THIS) | ||
455 | { | ||
456 | int i, j; | ||
457 | |||
458 | /* Return the keyboard to the normal state */ | ||
459 | VGLKeyboardEnd(); | ||
460 | |||
461 | /* Reset the console video mode if we actually initialised one */ | ||
462 | if (VGLCurMode != NULL) { | ||
463 | VGLEnd(); | ||
464 | SDL_free(VGLCurMode); | ||
465 | VGLCurMode = NULL; | ||
466 | } | ||
467 | |||
468 | /* Clear the lock mutex */ | ||
469 | if (hw_lock != NULL) { | ||
470 | SDL_DestroyMutex(hw_lock); | ||
471 | hw_lock = NULL; | ||
472 | } | ||
473 | |||
474 | /* Free video mode lists */ | ||
475 | for (i = 0; i < NUM_MODELISTS; i++) { | ||
476 | if (SDL_modelist[i] != NULL) { | ||
477 | for (j = 0; SDL_modelist[i][j] != NULL; ++j) { | ||
478 | SDL_free(SDL_modelist[i][j]); | ||
479 | } | ||
480 | SDL_free(SDL_modelist[i]); | ||
481 | SDL_modelist[i] = NULL; | ||
482 | } | ||
483 | } | ||
484 | |||
485 | if ( this->screen && (this->screen->flags & SDL_HWSURFACE) ) { | ||
486 | /* Direct screen access, not a memory buffer */ | ||
487 | this->screen->pixels = NULL; | ||
488 | } | ||
489 | } | ||
490 | |||
491 | #define VGL_RED_INDEX 0 | ||
492 | #define VGL_GREEN_INDEX 1 | ||
493 | #define VGL_BLUE_INDEX 2 | ||
494 | |||
495 | static VGLMode ** | ||
496 | VGLListModes(int depth, int mem_model) | ||
497 | { | ||
498 | static VGLMode **modes = NULL; | ||
499 | |||
500 | VGLBitmap *vminfop; | ||
501 | VGLMode **modesp, *modescp; | ||
502 | video_info_t minfo; | ||
503 | int adptype, i, modenum; | ||
504 | |||
505 | if (modes == NULL) { | ||
506 | modes = SDL_malloc(sizeof(VGLMode *) * M_VESA_MODE_MAX); | ||
507 | bzero(modes, sizeof(VGLMode *) * M_VESA_MODE_MAX); | ||
508 | } | ||
509 | modesp = modes; | ||
510 | |||
511 | for (modenum = 0; modenum < M_VESA_MODE_MAX; modenum++) { | ||
512 | minfo.vi_mode = modenum; | ||
513 | if (ioctl(0, CONS_MODEINFO, &minfo) || ioctl(0, CONS_CURRENT, &adptype)) | ||
514 | continue; | ||
515 | if (minfo.vi_mode != modenum) | ||
516 | continue; | ||
517 | if ((minfo.vi_flags & V_INFO_GRAPHICS) == 0) | ||
518 | continue; | ||
519 | if ((mem_model != -1) && ((minfo.vi_mem_model & mem_model) == 0)) | ||
520 | continue; | ||
521 | if ((depth > 1) && (minfo.vi_depth != depth)) | ||
522 | continue; | ||
523 | |||
524 | /* reallocf can fail */ | ||
525 | if ((*modesp = reallocf(*modesp, sizeof(VGLMode))) == NULL) | ||
526 | return NULL; | ||
527 | modescp = *modesp; | ||
528 | |||
529 | vminfop = &(modescp->ModeInfo); | ||
530 | bzero(vminfop, sizeof(VGLBitmap)); | ||
531 | |||
532 | vminfop->Type = NOBUF; | ||
533 | |||
534 | vminfop->PixelBytes = 1; /* Good default value */ | ||
535 | switch (minfo.vi_mem_model) { | ||
536 | case V_INFO_MM_PLANAR: | ||
537 | /* we can handle EGA/VGA planar modes only */ | ||
538 | if (!(minfo.vi_depth != 4 || minfo.vi_planes != 4 | ||
539 | || (adptype != KD_EGA && adptype != KD_VGA))) | ||
540 | vminfop->Type = VIDBUF4; | ||
541 | break; | ||
542 | case V_INFO_MM_PACKED: | ||
543 | /* we can do only 256 color packed modes */ | ||
544 | if (minfo.vi_depth == 8) | ||
545 | vminfop->Type = VIDBUF8; | ||
546 | break; | ||
547 | case V_INFO_MM_VGAX: | ||
548 | vminfop->Type = VIDBUF8X; | ||
549 | break; | ||
550 | #if defined(__FREEBSD__) && (defined(__DragonFly__) || __FreeBSD_version >= 500000) | ||
551 | case V_INFO_MM_DIRECT: | ||
552 | vminfop->PixelBytes = minfo.vi_pixel_size; | ||
553 | switch (vminfop->PixelBytes) { | ||
554 | case 2: | ||
555 | vminfop->Type = VIDBUF16; | ||
556 | break; | ||
557 | #if notyet | ||
558 | case 3: | ||
559 | vminfop->Type = VIDBUF24; | ||
560 | break; | ||
561 | #endif | ||
562 | case 4: | ||
563 | vminfop->Type = VIDBUF32; | ||
564 | break; | ||
565 | default: | ||
566 | break; | ||
567 | } | ||
568 | #endif | ||
569 | default: | ||
570 | break; | ||
571 | } | ||
572 | if (vminfop->Type == NOBUF) | ||
573 | continue; | ||
574 | |||
575 | switch (vminfop->Type) { | ||
576 | case VIDBUF16: | ||
577 | case VIDBUF32: | ||
578 | modescp->Rmask = ((1 << minfo.vi_pixel_fsizes[VGL_RED_INDEX]) - 1) << | ||
579 | minfo.vi_pixel_fields[VGL_RED_INDEX]; | ||
580 | modescp->Gmask = ((1 << minfo.vi_pixel_fsizes[VGL_GREEN_INDEX]) - 1) << | ||
581 | minfo.vi_pixel_fields[VGL_GREEN_INDEX]; | ||
582 | modescp->Bmask = ((1 << minfo.vi_pixel_fsizes[VGL_BLUE_INDEX]) - 1) << | ||
583 | minfo.vi_pixel_fields[VGL_BLUE_INDEX]; | ||
584 | break; | ||
585 | |||
586 | default: | ||
587 | break; | ||
588 | } | ||
589 | |||
590 | vminfop->Xsize = minfo.vi_width; | ||
591 | vminfop->Ysize = minfo.vi_height; | ||
592 | modescp->Depth = minfo.vi_depth; | ||
593 | |||
594 | /* XXX */ | ||
595 | if (minfo.vi_mode >= M_VESA_BASE) | ||
596 | modescp->ModeId = _IO('V', minfo.vi_mode - M_VESA_BASE); | ||
597 | else | ||
598 | modescp->ModeId = _IO('S', minfo.vi_mode); | ||
599 | |||
600 | /* Sort list */ | ||
601 | for (i = 0; modes + i < modesp ; i++) { | ||
602 | if (modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize > | ||
603 | vminfop->Xsize * modes[i]->ModeInfo.Ysize) | ||
604 | continue; | ||
605 | if ((modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize == | ||
606 | vminfop->Xsize * vminfop->Ysize) && | ||
607 | (modes[i]->Depth >= modescp->Depth)) | ||
608 | continue; | ||
609 | *modesp = modes[i]; | ||
610 | modes[i] = modescp; | ||
611 | modescp = *modesp; | ||
612 | vminfop = &(modescp->ModeInfo); | ||
613 | } | ||
614 | |||
615 | modesp++; | ||
616 | } | ||
617 | |||
618 | if (*modesp != NULL) { | ||
619 | SDL_free(*modesp); | ||
620 | *modesp = NULL; | ||
621 | } | ||
622 | |||
623 | return modes; | ||
624 | } | ||