Mercurial > sdl-ios-xcode

comparison src/video/vgl/SDL_vglvideo.c @ 1668:4da1ee79c9af SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
more tweaking indent options
author Sam Lantinga <slouken@libsdl.org>
date Mon, 29 May 2006 04:04:35 +0000
parents 782fd950bd46
children
comparison
equal deleted inserted replaced
1667:1fddae038bc8 1668:4da1ee79c9af
43 #include "SDL_vglevents_c.h" 43 #include "SDL_vglevents_c.h"
44 #include "SDL_vglmouse_c.h" 44 #include "SDL_vglmouse_c.h"
45 45
46 46
47 /* Initialization/Query functions */ 47 /* Initialization/Query functions */
48 static int VGL_VideoInit (_THIS, SDL_PixelFormat * vformat); 48 static int VGL_VideoInit(_THIS, SDL_PixelFormat * vformat);
49 static SDL_Rect **VGL_ListModes (_THIS, SDL_PixelFormat * format, 49 static SDL_Rect **VGL_ListModes(_THIS, SDL_PixelFormat * format,
50 Uint32 flags); 50 Uint32 flags);
51 static SDL_Surface *VGL_SetVideoMode (_THIS, SDL_Surface * current, int width, 51 static SDL_Surface *VGL_SetVideoMode(_THIS, SDL_Surface * current, int width,
52 int height, int bpp, Uint32 flags); 52 int height, int bpp, Uint32 flags);
53 static int VGL_SetColors (_THIS, int firstcolor, int ncolors, 53 static int VGL_SetColors(_THIS, int firstcolor, int ncolors,
54 SDL_Color * colors); 54 SDL_Color * colors);
55 static void VGL_VideoQuit (_THIS); 55 static void VGL_VideoQuit(_THIS);
56 56
57 /* Hardware surface functions */ 57 /* Hardware surface functions */
58 static int VGL_AllocHWSurface (_THIS, SDL_Surface * surface); 58 static int VGL_AllocHWSurface(_THIS, SDL_Surface * surface);
59 static int VGL_LockHWSurface (_THIS, SDL_Surface * surface); 59 static int VGL_LockHWSurface(_THIS, SDL_Surface * surface);
60 static int VGL_FlipHWSurface (_THIS, SDL_Surface * surface); 60 static int VGL_FlipHWSurface(_THIS, SDL_Surface * surface);
61 static void VGL_UnlockHWSurface (_THIS, SDL_Surface * surface); 61 static void VGL_UnlockHWSurface(_THIS, SDL_Surface * surface);
62 static void VGL_FreeHWSurface (_THIS, SDL_Surface * surface); 62 static void VGL_FreeHWSurface(_THIS, SDL_Surface * surface);
63 63
64 /* Misc function */ 64 /* Misc function */
65 static VGLMode **VGLListModes (int depth, int mem_model); 65 static VGLMode **VGLListModes(int depth, int mem_model);
66 static void VGLWaitRetrace (void); 66 static void VGLWaitRetrace(void);
67 67
68 /* VGL driver bootstrap functions */ 68 /* VGL driver bootstrap functions */
69 69
70 static int 70 static int
71 VGL_Available (void) 71 VGL_Available(void)
72 { 72 {
73 /* 73 /*
74 * Check to see if we are root and stdin is a 74 * Check to see if we are root and stdin is a
75 * virtual console. Also try to ensure that 75 * virtual console. Also try to ensure that
76 * modes other than 320x200 are available 76 * modes other than 320x200 are available
81 console = STDIN_FILENO; 81 console = STDIN_FILENO;
82 if (console >= 0) { 82 if (console >= 0) {
83 struct stat sb; 83 struct stat sb;
84 struct vt_mode dummy; 84 struct vt_mode dummy;
85 85
86 if ((fstat (console, &sb) < 0) || 86 if ((fstat(console, &sb) < 0) ||
87 (ioctl (console, VT_GETMODE, &dummy) < 0)) { 87 (ioctl(console, VT_GETMODE, &dummy) < 0)) {
88 console = -1; 88 console = -1;
89 } 89 }
90 } 90 }
91 if (geteuid () != 0 && console == -1) 91 if (geteuid() != 0 && console == -1)
92 return 0; 92 return 0;
93 93
94 modes = VGLListModes (8, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); 94 modes = VGLListModes(8, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
95 hires_available = 0; 95 hires_available = 0;
96 for (i = 0; modes[i] != NULL; i++) { 96 for (i = 0; modes[i] != NULL; i++) {
97 if ((modes[i]->ModeInfo.Xsize > 320) && 97 if ((modes[i]->ModeInfo.Xsize > 320) &&
98 (modes[i]->ModeInfo.Ysize > 200) && 98 (modes[i]->ModeInfo.Ysize > 200) &&
99 ((modes[i]->ModeInfo.Type == VIDBUF8) || 99 ((modes[i]->ModeInfo.Type == VIDBUF8) ||
105 } 105 }
106 return hires_available; 106 return hires_available;
107 } 107 }
108 108
109 static void 109 static void
110 VGL_DeleteDevice (SDL_VideoDevice * device) 110 VGL_DeleteDevice(SDL_VideoDevice * device)
111 { 111 {
112 SDL_free (device->hidden); 112 SDL_free(device->hidden);
113 SDL_free (device); 113 SDL_free(device);
114 } 114 }
115 115
116 static SDL_VideoDevice * 116 static SDL_VideoDevice *
117 VGL_CreateDevice (int devindex) 117 VGL_CreateDevice(int devindex)
118 { 118 {
119 SDL_VideoDevice *device; 119 SDL_VideoDevice *device;
120 120
121 /* Initialize all variables that we clean on shutdown */ 121 /* Initialize all variables that we clean on shutdown */
122 device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice)); 122 device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
123 if (device) { 123 if (device) {
124 SDL_memset (device, 0, (sizeof *device)); 124 SDL_memset(device, 0, (sizeof *device));
125 device->hidden = (struct SDL_PrivateVideoData *) 125 device->hidden = (struct SDL_PrivateVideoData *)
126 SDL_malloc ((sizeof *device->hidden)); 126 SDL_malloc((sizeof *device->hidden));
127 } 127 }
128 if ((device == NULL) || (device->hidden == NULL)) { 128 if ((device == NULL) || (device->hidden == NULL)) {
129 SDL_OutOfMemory (); 129 SDL_OutOfMemory();
130 if (device) { 130 if (device) {
131 SDL_free (device); 131 SDL_free(device);
132 } 132 }
133 return (0); 133 return (0);
134 } 134 }
135 SDL_memset (device->hidden, 0, (sizeof *device->hidden)); 135 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
136 136
137 /* Set the function pointers */ 137 /* Set the function pointers */
138 device->VideoInit = VGL_VideoInit; 138 device->VideoInit = VGL_VideoInit;
139 device->ListModes = VGL_ListModes; 139 device->ListModes = VGL_ListModes;
140 device->SetVideoMode = VGL_SetVideoMode; 140 device->SetVideoMode = VGL_SetVideoMode;
169 "vgl", "FreeBSD libVGL", 169 "vgl", "FreeBSD libVGL",
170 VGL_Available, VGL_CreateDevice 170 VGL_Available, VGL_CreateDevice
171 }; 171 };
172 172
173 static int 173 static int
174 VGL_AddMode (_THIS, VGLMode * inmode) 174 VGL_AddMode(_THIS, VGLMode * inmode)
175 { 175 {
176 SDL_Rect *mode; 176 SDL_Rect *mode;
177 177
178 int i, index; 178 int i, index;
179 int next_mode; 179 int next_mode;
189 (mode->h == inmode->ModeInfo.Ysize)) 189 (mode->h == inmode->ModeInfo.Ysize))
190 return 0; 190 return 0;
191 } 191 }
192 192
193 /* Set up the new video mode rectangle */ 193 /* Set up the new video mode rectangle */
194 mode = (SDL_Rect *) SDL_malloc (sizeof *mode); 194 mode = (SDL_Rect *) SDL_malloc(sizeof *mode);
195 if (mode == NULL) { 195 if (mode == NULL) {
196 SDL_OutOfMemory (); 196 SDL_OutOfMemory();
197 return -1; 197 return -1;
198 } 198 }
199 mode->x = 0; 199 mode->x = 0;
200 mode->y = 0; 200 mode->y = 0;
201 mode->w = inmode->ModeInfo.Xsize; 201 mode->w = inmode->ModeInfo.Xsize;
202 mode->h = inmode->ModeInfo.Ysize; 202 mode->h = inmode->ModeInfo.Ysize;
203 203
204 /* Allocate the new list of modes, and fill in the new mode */ 204 /* Allocate the new list of modes, and fill in the new mode */
205 next_mode = SDL_nummodes[index]; 205 next_mode = SDL_nummodes[index];
206 SDL_modelist[index] = (SDL_Rect **) 206 SDL_modelist[index] = (SDL_Rect **)
207 SDL_realloc (SDL_modelist[index], 207 SDL_realloc(SDL_modelist[index],
208 (1 + next_mode + 1) * sizeof (SDL_Rect *)); 208 (1 + next_mode + 1) * sizeof(SDL_Rect *));
209 if (SDL_modelist[index] == NULL) { 209 if (SDL_modelist[index] == NULL) {
210 SDL_OutOfMemory (); 210 SDL_OutOfMemory();
211 SDL_nummodes[index] = 0; 211 SDL_nummodes[index] = 0;
212 SDL_free (mode); 212 SDL_free(mode);
213 return -1; 213 return -1;
214 } 214 }
215 SDL_modelist[index][next_mode] = mode; 215 SDL_modelist[index][next_mode] = mode;
216 SDL_modelist[index][next_mode + 1] = NULL; 216 SDL_modelist[index][next_mode + 1] = NULL;
217 SDL_nummodes[index]++; 217 SDL_nummodes[index]++;
218 218
219 return 0; 219 return 0;
220 } 220 }
221 221
222 static void 222 static void
223 VGL_UpdateVideoInfo (_THIS) 223 VGL_UpdateVideoInfo(_THIS)
224 { 224 {
225 this->info.wm_available = 0; 225 this->info.wm_available = 0;
226 this->info.hw_available = 1; 226 this->info.hw_available = 1;
227 this->info.video_mem = 0; 227 this->info.video_mem = 0;
228 if (VGLCurMode == NULL) { 228 if (VGLCurMode == NULL) {
233 VGLCurMode->ModeInfo.Xsize * VGLCurMode->ModeInfo.Ysize; 233 VGLCurMode->ModeInfo.Xsize * VGLCurMode->ModeInfo.Ysize;
234 } 234 }
235 } 235 }
236 236
237 int 237 int
238 VGL_VideoInit (_THIS, SDL_PixelFormat * vformat) 238 VGL_VideoInit(_THIS, SDL_PixelFormat * vformat)
239 { 239 {
240 int i; 240 int i;
241 int total_modes; 241 int total_modes;
242 VGLMode **modes; 242 VGLMode **modes;
243 243
246 SDL_nummodes[i] = 0; 246 SDL_nummodes[i] = 0;
247 SDL_modelist[i] = NULL; 247 SDL_modelist[i] = NULL;
248 } 248 }
249 249
250 /* Enable mouse and keyboard support */ 250 /* Enable mouse and keyboard support */
251 if (SDL_getenv ("SDL_NO_RAWKBD") == NULL) { 251 if (SDL_getenv("SDL_NO_RAWKBD") == NULL) {
252 if (VGLKeyboardInit (VGL_CODEKEYS) != 0) { 252 if (VGLKeyboardInit(VGL_CODEKEYS) != 0) {
253 SDL_SetError ("Unable to initialize keyboard"); 253 SDL_SetError("Unable to initialize keyboard");
254 return -1; 254 return -1;
255 } 255 }
256 } else { 256 } else {
257 warnx ("Requiest to put keyboard into a raw mode ignored"); 257 warnx("Requiest to put keyboard into a raw mode ignored");
258 } 258 }
259 if (VGL_initkeymaps (STDIN_FILENO) != 0) { 259 if (VGL_initkeymaps(STDIN_FILENO) != 0) {
260 SDL_SetError ("Unable to initialize keymap"); 260 SDL_SetError("Unable to initialize keymap");
261 return -1; 261 return -1;
262 } 262 }
263 if (VGL_initmouse (STDIN_FILENO) != 0) { 263 if (VGL_initmouse(STDIN_FILENO) != 0) {
264 SDL_SetError ("Unable to initialize mouse"); 264 SDL_SetError("Unable to initialize mouse");
265 return -1; 265 return -1;
266 } 266 }
267 267
268 /* Determine the current screen size */ 268 /* Determine the current screen size */
269 if (VGLCurMode != NULL) { 269 if (VGLCurMode != NULL) {
277 else 277 else
278 vformat->BitsPerPixel = 16; /* Good default */ 278 vformat->BitsPerPixel = 16; /* Good default */
279 279
280 /* Query for the list of available video modes */ 280 /* Query for the list of available video modes */
281 total_modes = 0; 281 total_modes = 0;
282 modes = VGLListModes (-1, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); 282 modes = VGLListModes(-1, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
283 for (i = 0; modes[i] != NULL; i++) { 283 for (i = 0; modes[i] != NULL; i++) {
284 if ((modes[i]->ModeInfo.Type == VIDBUF8) || 284 if ((modes[i]->ModeInfo.Type == VIDBUF8) ||
285 (modes[i]->ModeInfo.Type == VIDBUF16) || 285 (modes[i]->ModeInfo.Type == VIDBUF16) ||
286 (modes[i]->ModeInfo.Type == VIDBUF32)) { 286 (modes[i]->ModeInfo.Type == VIDBUF32)) {
287 VGL_AddMode (this, modes[i]); 287 VGL_AddMode(this, modes[i]);
288 total_modes++; 288 total_modes++;
289 } 289 }
290 } 290 }
291 if (total_modes == 0) { 291 if (total_modes == 0) {
292 SDL_SetError ("No linear video modes available"); 292 SDL_SetError("No linear video modes available");
293 return -1; 293 return -1;
294 } 294 }
295 295
296 /* Fill in our hardware acceleration capabilities */ 296 /* Fill in our hardware acceleration capabilities */
297 VGL_UpdateVideoInfo (this); 297 VGL_UpdateVideoInfo(this);
298 298
299 /* Create the hardware surface lock mutex */ 299 /* Create the hardware surface lock mutex */
300 hw_lock = SDL_CreateMutex (); 300 hw_lock = SDL_CreateMutex();
301 if (hw_lock == NULL) { 301 if (hw_lock == NULL) {
302 SDL_SetError ("Unable to create lock mutex"); 302 SDL_SetError("Unable to create lock mutex");
303 VGL_VideoQuit (this); 303 VGL_VideoQuit(this);
304 return -1; 304 return -1;
305 } 305 }
306 306
307 /* We're done! */ 307 /* We're done! */
308 return 0; 308 return 0;
309 } 309 }
310 310
311 SDL_Rect ** 311 SDL_Rect **
312 VGL_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags) 312 VGL_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
313 { 313 {
314 return SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1]; 314 return SDL_modelist[((format->BitsPerPixel + 7) / 8) - 1];
315 } 315 }
316 316
317 /* Various screen update functions available */ 317 /* Various screen update functions available */
318 static void VGL_DirectUpdate (_THIS, int numrects, SDL_Rect * rects); 318 static void VGL_DirectUpdate(_THIS, int numrects, SDL_Rect * rects);
319 static void VGL_BankedUpdate (_THIS, int numrects, SDL_Rect * rects); 319 static void VGL_BankedUpdate(_THIS, int numrects, SDL_Rect * rects);
320 320
321 SDL_Surface * 321 SDL_Surface *
322 VGL_SetVideoMode (_THIS, SDL_Surface * current, 322 VGL_SetVideoMode(_THIS, SDL_Surface * current,
323 int width, int height, int bpp, Uint32 flags) 323 int width, int height, int bpp, Uint32 flags)
324 { 324 {
325 int mode_found; 325 int mode_found;
326 int i; 326 int i;
327 VGLMode **modes; 327 VGLMode **modes;
328 328
329 modes = VGLListModes (bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED); 329 modes = VGLListModes(bpp, V_INFO_MM_DIRECT | V_INFO_MM_PACKED);
330 mode_found = 0; 330 mode_found = 0;
331 for (i = 0; modes[i] != NULL; i++) { 331 for (i = 0; modes[i] != NULL; i++) {
332 if ((modes[i]->ModeInfo.Xsize == width) && 332 if ((modes[i]->ModeInfo.Xsize == width) &&
333 (modes[i]->ModeInfo.Ysize == height) && 333 (modes[i]->ModeInfo.Ysize == height) &&
334 ((modes[i]->ModeInfo.Type == VIDBUF8) || 334 ((modes[i]->ModeInfo.Type == VIDBUF8) ||
337 mode_found = 1; 337 mode_found = 1;
338 break; 338 break;
339 } 339 }
340 } 340 }
341 if (mode_found == 0) { 341 if (mode_found == 0) {
342 SDL_SetError ("No matching video mode found"); 342 SDL_SetError("No matching video mode found");
343 return NULL; 343 return NULL;
344 } 344 }
345 345
346 /* Shutdown previous videomode (if any) */ 346 /* Shutdown previous videomode (if any) */
347 if (VGLCurMode != NULL) 347 if (VGLCurMode != NULL)
348 VGLEnd (); 348 VGLEnd();
349 349
350 /* Try to set the requested linear video mode */ 350 /* Try to set the requested linear video mode */
351 if (VGLInit (modes[i]->ModeId) != 0) { 351 if (VGLInit(modes[i]->ModeId) != 0) {
352 SDL_SetError ("Unable to switch to requested mode"); 352 SDL_SetError("Unable to switch to requested mode");
353 return NULL; 353 return NULL;
354 } 354 }
355 355
356 VGLCurMode = SDL_realloc (VGLCurMode, sizeof (VGLMode)); 356 VGLCurMode = SDL_realloc(VGLCurMode, sizeof(VGLMode));
357 VGLCurMode->ModeInfo = *VGLDisplay; 357 VGLCurMode->ModeInfo = *VGLDisplay;
358 VGLCurMode->Depth = modes[i]->Depth; 358 VGLCurMode->Depth = modes[i]->Depth;
359 VGLCurMode->ModeId = modes[i]->ModeId; 359 VGLCurMode->ModeId = modes[i]->ModeId;
360 VGLCurMode->Rmask = modes[i]->Rmask; 360 VGLCurMode->Rmask = modes[i]->Rmask;
361 VGLCurMode->Gmask = modes[i]->Gmask; 361 VGLCurMode->Gmask = modes[i]->Gmask;
382 current->flags |= SDL_DOUBLEBUF; 382 current->flags |= SDL_DOUBLEBUF;
383 flip_page = 0; 383 flip_page = 0;
384 flip_address[0] = (byte *) current->pixels; 384 flip_address[0] = (byte *) current->pixels;
385 flip_address[1] = (byte *) current->pixels + 385 flip_address[1] = (byte *) current->pixels +
386 current->h * current->pitch; 386 current->h * current->pitch;
387 VGL_FlipHWSurface (this, current); 387 VGL_FlipHWSurface(this, current);
388 } 388 }
389 } 389 }
390 390
391 if (!SDL_ReallocFormat (current, modes[i]->Depth, VGLCurMode->Rmask, 391 if (!SDL_ReallocFormat(current, modes[i]->Depth, VGLCurMode->Rmask,
392 VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) { 392 VGLCurMode->Gmask, VGLCurMode->Bmask, 0)) {
393 return NULL; 393 return NULL;
394 } 394 }
395 395
396 /* Update hardware acceleration info */ 396 /* Update hardware acceleration info */
397 VGL_UpdateVideoInfo (this); 397 VGL_UpdateVideoInfo(this);
398 398
399 /* Set the blit function */ 399 /* Set the blit function */
400 this->UpdateRects = VGL_DirectUpdate; 400 this->UpdateRects = VGL_DirectUpdate;
401 401
402 /* We're done */ 402 /* We're done */
403 return current; 403 return current;
404 } 404 }
405 405
406 /* We don't actually allow hardware surfaces other than the main one */ 406 /* We don't actually allow hardware surfaces other than the main one */
407 static int 407 static int
408 VGL_AllocHWSurface (_THIS, SDL_Surface * surface) 408 VGL_AllocHWSurface(_THIS, SDL_Surface * surface)
409 { 409 {
410 return -1; 410 return -1;
411 } 411 }
412 static void 412 static void
413 VGL_FreeHWSurface (_THIS, SDL_Surface * surface) 413 VGL_FreeHWSurface(_THIS, SDL_Surface * surface)
414 { 414 {
415 return; 415 return;
416 } 416 }
417 417
418 /* We need to wait for vertical retrace on page flipped displays */ 418 /* We need to wait for vertical retrace on page flipped displays */
419 static int 419 static int
420 VGL_LockHWSurface (_THIS, SDL_Surface * surface) 420 VGL_LockHWSurface(_THIS, SDL_Surface * surface)
421 { 421 {
422 if (surface == SDL_VideoSurface) { 422 if (surface == SDL_VideoSurface) {
423 SDL_mutexP (hw_lock); 423 SDL_mutexP(hw_lock);
424 } 424 }
425 return 0; 425 return 0;
426 } 426 }
427 static void 427 static void
428 VGL_UnlockHWSurface (_THIS, SDL_Surface * surface) 428 VGL_UnlockHWSurface(_THIS, SDL_Surface * surface)
429 { 429 {
430 if (surface == SDL_VideoSurface) { 430 if (surface == SDL_VideoSurface) {
431 SDL_mutexV (hw_lock); 431 SDL_mutexV(hw_lock);
432 } 432 }
433 } 433 }
434 434
435 static int 435 static int
436 VGL_FlipHWSurface (_THIS, SDL_Surface * surface) 436 VGL_FlipHWSurface(_THIS, SDL_Surface * surface)
437 { 437 {
438 // VGLWaitRetrace(); 438 // VGLWaitRetrace();
439 if (VGLPanScreen (VGLDisplay, 0, flip_page * surface->h) < 0) { 439 if (VGLPanScreen(VGLDisplay, 0, flip_page * surface->h) < 0) {
440 SDL_SetError ("VGLPanSreen() failed"); 440 SDL_SetError("VGLPanSreen() failed");
441 return -1; 441 return -1;
442 } 442 }
443 443
444 flip_page = !flip_page; 444 flip_page = !flip_page;
445 surface->pixels = flip_address[flip_page]; 445 surface->pixels = flip_address[flip_page];
446 446
447 return 0; 447 return 0;
448 } 448 }
449 449
450 static void 450 static void
451 VGL_DirectUpdate (_THIS, int numrects, SDL_Rect * rects) 451 VGL_DirectUpdate(_THIS, int numrects, SDL_Rect * rects)
452 { 452 {
453 return; 453 return;
454 } 454 }
455 455
456 static void 456 static void
457 VGL_BankedUpdate (_THIS, int numrects, SDL_Rect * rects) 457 VGL_BankedUpdate(_THIS, int numrects, SDL_Rect * rects)
458 { 458 {
459 return; 459 return;
460 } 460 }
461 461
462 int 462 int
463 VGL_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) 463 VGL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
464 { 464 {
465 int i; 465 int i;
466 466
467 for (i = 0; i < ncolors; i++) { 467 for (i = 0; i < ncolors; i++) {
468 VGLSetPaletteIndex (firstcolor + i, 468 VGLSetPaletteIndex(firstcolor + i,
469 colors[i].r >> 2, 469 colors[i].r >> 2,
470 colors[i].g >> 2, colors[i].b >> 2); 470 colors[i].g >> 2, colors[i].b >> 2);
471 } 471 }
472 return 1; 472 return 1;
473 } 473 }
474 474
475 /* Note: If we are terminated, this could be called in the middle of 475 /* Note: If we are terminated, this could be called in the middle of
476 another SDL video routine -- notably UpdateRects. 476 another SDL video routine -- notably UpdateRects.
477 */ 477 */
478 void 478 void
479 VGL_VideoQuit (_THIS) 479 VGL_VideoQuit(_THIS)
480 { 480 {
481 int i, j; 481 int i, j;
482 482
483 /* Return the keyboard to the normal state */ 483 /* Return the keyboard to the normal state */
484 VGLKeyboardEnd (); 484 VGLKeyboardEnd();
485 485
486 /* Reset the console video mode if we actually initialised one */ 486 /* Reset the console video mode if we actually initialised one */
487 if (VGLCurMode != NULL) { 487 if (VGLCurMode != NULL) {
488 VGLEnd (); 488 VGLEnd();
489 SDL_free (VGLCurMode); 489 SDL_free(VGLCurMode);
490 VGLCurMode = NULL; 490 VGLCurMode = NULL;
491 } 491 }
492 492
493 /* Clear the lock mutex */ 493 /* Clear the lock mutex */
494 if (hw_lock != NULL) { 494 if (hw_lock != NULL) {
495 SDL_DestroyMutex (hw_lock); 495 SDL_DestroyMutex(hw_lock);
496 hw_lock = NULL; 496 hw_lock = NULL;
497 } 497 }
498 498
499 /* Free video mode lists */ 499 /* Free video mode lists */
500 for (i = 0; i < NUM_MODELISTS; i++) { 500 for (i = 0; i < NUM_MODELISTS; i++) {
501 if (SDL_modelist[i] != NULL) { 501 if (SDL_modelist[i] != NULL) {
502 for (j = 0; SDL_modelist[i][j] != NULL; ++j) { 502 for (j = 0; SDL_modelist[i][j] != NULL; ++j) {
503 SDL_free (SDL_modelist[i][j]); 503 SDL_free(SDL_modelist[i][j]);
504 } 504 }
505 SDL_free (SDL_modelist[i]); 505 SDL_free(SDL_modelist[i]);
506 SDL_modelist[i] = NULL; 506 SDL_modelist[i] = NULL;
507 } 507 }
508 } 508 }
509 509
510 if (this->screen && (this->screen->flags & SDL_HWSURFACE)) { 510 if (this->screen && (this->screen->flags & SDL_HWSURFACE)) {
516 #define VGL_RED_INDEX 0 516 #define VGL_RED_INDEX 0
517 #define VGL_GREEN_INDEX 1 517 #define VGL_GREEN_INDEX 1
518 #define VGL_BLUE_INDEX 2 518 #define VGL_BLUE_INDEX 2
519 519
520 static VGLMode ** 520 static VGLMode **
521 VGLListModes (int depth, int mem_model) 521 VGLListModes(int depth, int mem_model)
522 { 522 {
523 static VGLMode **modes = NULL; 523 static VGLMode **modes = NULL;
524 524
525 VGLBitmap *vminfop; 525 VGLBitmap *vminfop;
526 VGLMode **modesp, *modescp; 526 VGLMode **modesp, *modescp;
527 video_info_t minfo; 527 video_info_t minfo;
528 int adptype, i, modenum; 528 int adptype, i, modenum;
529 529
530 if (modes == NULL) { 530 if (modes == NULL) {
531 modes = SDL_malloc (sizeof (VGLMode *) * M_VESA_MODE_MAX); 531 modes = SDL_malloc(sizeof(VGLMode *) * M_VESA_MODE_MAX);
532 bzero (modes, sizeof (VGLMode *) * M_VESA_MODE_MAX); 532 bzero(modes, sizeof(VGLMode *) * M_VESA_MODE_MAX);
533 } 533 }
534 modesp = modes; 534 modesp = modes;
535 535
536 for (modenum = 0; modenum < M_VESA_MODE_MAX; modenum++) { 536 for (modenum = 0; modenum < M_VESA_MODE_MAX; modenum++) {
537 minfo.vi_mode = modenum; 537 minfo.vi_mode = modenum;
538 if (ioctl (0, CONS_MODEINFO, &minfo) 538 if (ioctl(0, CONS_MODEINFO, &minfo)
539 || ioctl (0, CONS_CURRENT, &adptype)) 539 || ioctl(0, CONS_CURRENT, &adptype))
540 continue; 540 continue;
541 if (minfo.vi_mode != modenum) 541 if (minfo.vi_mode != modenum)
542 continue; 542 continue;
543 if ((minfo.vi_flags & V_INFO_GRAPHICS) == 0) 543 if ((minfo.vi_flags & V_INFO_GRAPHICS) == 0)
544 continue; 544 continue;
546 continue; 546 continue;
547 if ((depth > 1) && (minfo.vi_depth != depth)) 547 if ((depth > 1) && (minfo.vi_depth != depth))
548 continue; 548 continue;
549 549
550 /* reallocf can fail */ 550 /* reallocf can fail */
551 if ((*modesp = reallocf (*modesp, sizeof (VGLMode))) == NULL) 551 if ((*modesp = reallocf(*modesp, sizeof(VGLMode))) == NULL)
552 return NULL; 552 return NULL;
553 modescp = *modesp; 553 modescp = *modesp;
554 554
555 vminfop = &(modescp->ModeInfo); 555 vminfop = &(modescp->ModeInfo);
556 bzero (vminfop, sizeof (VGLBitmap)); 556 bzero(vminfop, sizeof(VGLBitmap));
557 557
558 vminfop->Type = NOBUF; 558 vminfop->Type = NOBUF;
559 559
560 vminfop->PixelBytes = 1; /* Good default value */ 560 vminfop->PixelBytes = 1; /* Good default value */
561 switch (minfo.vi_mem_model) { 561 switch (minfo.vi_mem_model) {
620 vminfop->Ysize = minfo.vi_height; 620 vminfop->Ysize = minfo.vi_height;
621 modescp->Depth = minfo.vi_depth; 621 modescp->Depth = minfo.vi_depth;
622 622
623 /* XXX */ 623 /* XXX */
624 if (minfo.vi_mode >= M_VESA_BASE) 624 if (minfo.vi_mode >= M_VESA_BASE)
625 modescp->ModeId = _IO ('V', minfo.vi_mode - M_VESA_BASE); 625 modescp->ModeId = _IO('V', minfo.vi_mode - M_VESA_BASE);
626 else 626 else
627 modescp->ModeId = _IO ('S', minfo.vi_mode); 627 modescp->ModeId = _IO('S', minfo.vi_mode);
628 628
629 /* Sort list */ 629 /* Sort list */
630 for (i = 0; modes + i < modesp; i++) { 630 for (i = 0; modes + i < modesp; i++) {
631 if (modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize > 631 if (modes[i]->ModeInfo.Xsize * modes[i]->ModeInfo.Ysize >
632 vminfop->Xsize * modes[i]->ModeInfo.Ysize) 632 vminfop->Xsize * modes[i]->ModeInfo.Ysize)
643 643
644 modesp++; 644 modesp++;
645 } 645 }
646 646
647 if (*modesp != NULL) { 647 if (*modesp != NULL) {
648 SDL_free (*modesp); 648 SDL_free(*modesp);
649 *modesp = NULL; 649 *modesp = NULL;
650 } 650 }
651 651
652 return modes; 652 return modes;
653 } 653 }
654 654
655 static void 655 static void
656 VGLWaitRetrace (void) 656 VGLWaitRetrace(void)
657 { 657 {
658 while (!(inb (0x3DA) & 8)); 658 while (!(inb(0x3DA) & 8));
659 while (inb (0x3DA) & 8); 659 while (inb(0x3DA) & 8);
660 } 660 }
661 661
662 /* vi: set ts=4 sw=4 expandtab: */ 662 /* vi: set ts=4 sw=4 expandtab: */