Mercurial > sdl-ios-xcode

comparison src/video/xbios/SDL_xbios.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
63 #define DEBUG_PRINT(what) 63 #define DEBUG_PRINT(what)
64 #undef DEBUG_VIDEO_XBIOS 64 #undef DEBUG_VIDEO_XBIOS
65 #endif 65 #endif
66 66
67 /* Initialization/Query functions */ 67 /* Initialization/Query functions */
68 static int XBIOS_VideoInit (_THIS, SDL_PixelFormat * vformat); 68 static int XBIOS_VideoInit(_THIS, SDL_PixelFormat * vformat);
69 static SDL_Rect **XBIOS_ListModes (_THIS, SDL_PixelFormat * format, 69 static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat * format,
70 Uint32 flags); 70 Uint32 flags);
71 static SDL_Surface *XBIOS_SetVideoMode (_THIS, SDL_Surface * current, 71 static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface * current,
72 int width, int height, int bpp, 72 int width, int height, int bpp,
73 Uint32 flags); 73 Uint32 flags);
74 static int XBIOS_SetColors (_THIS, int firstcolor, int ncolors, 74 static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors,
75 SDL_Color * colors); 75 SDL_Color * colors);
76 static void XBIOS_VideoQuit (_THIS); 76 static void XBIOS_VideoQuit(_THIS);
77 77
78 /* Hardware surface functions */ 78 /* Hardware surface functions */
79 static int XBIOS_AllocHWSurface (_THIS, SDL_Surface * surface); 79 static int XBIOS_AllocHWSurface(_THIS, SDL_Surface * surface);
80 static int XBIOS_LockHWSurface (_THIS, SDL_Surface * surface); 80 static int XBIOS_LockHWSurface(_THIS, SDL_Surface * surface);
81 static int XBIOS_FlipHWSurface (_THIS, SDL_Surface * surface); 81 static int XBIOS_FlipHWSurface(_THIS, SDL_Surface * surface);
82 static void XBIOS_UnlockHWSurface (_THIS, SDL_Surface * surface); 82 static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface * surface);
83 static void XBIOS_FreeHWSurface (_THIS, SDL_Surface * surface); 83 static void XBIOS_FreeHWSurface(_THIS, SDL_Surface * surface);
84 static void XBIOS_UpdateRects (_THIS, int numrects, SDL_Rect * rects); 84 static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect * rects);
85 85
86 #if SDL_VIDEO_OPENGL 86 #if SDL_VIDEO_OPENGL
87 /* OpenGL functions */ 87 /* OpenGL functions */
88 static void XBIOS_GL_SwapBuffers (_THIS); 88 static void XBIOS_GL_SwapBuffers(_THIS);
89 #endif 89 #endif
90 90
91 /* To setup palette */ 91 /* To setup palette */
92 92
93 static unsigned short TT_palette[256]; 93 static unsigned short TT_palette[256];
94 static unsigned long F30_palette[256]; 94 static unsigned long F30_palette[256];
95 95
96 /* Xbios driver bootstrap functions */ 96 /* Xbios driver bootstrap functions */
97 97
98 static int 98 static int
99 XBIOS_Available (void) 99 XBIOS_Available(void)
100 { 100 {
101 unsigned long cookie_vdo, cookie_mil, cookie_hade, cookie_scpn; 101 unsigned long cookie_vdo, cookie_mil, cookie_hade, cookie_scpn;
102 102
103 /* Milan/Hades Atari clones do not have an Atari video chip */ 103 /* Milan/Hades Atari clones do not have an Atari video chip */
104 if ((Getcookie (C__MIL, &cookie_mil) == C_FOUND) || 104 if ((Getcookie(C__MIL, &cookie_mil) == C_FOUND) ||
105 (Getcookie (C_hade, &cookie_hade) == C_FOUND)) { 105 (Getcookie(C_hade, &cookie_hade) == C_FOUND)) {
106 return 0; 106 return 0;
107 } 107 }
108 108
109 /* Cookie _VDO present ? if not, assume ST machine */ 109 /* Cookie _VDO present ? if not, assume ST machine */
110 if (Getcookie (C__VDO, &cookie_vdo) != C_FOUND) { 110 if (Getcookie(C__VDO, &cookie_vdo) != C_FOUND) {
111 cookie_vdo = VDO_ST << 16; 111 cookie_vdo = VDO_ST << 16;
112 } 112 }
113 113
114 /* Test if we have a monochrome monitor plugged in */ 114 /* Test if we have a monochrome monitor plugged in */
115 switch (cookie_vdo >> 16) { 115 switch (cookie_vdo >> 16) {
116 case VDO_ST: 116 case VDO_ST:
117 case VDO_STE: 117 case VDO_STE:
118 if (Getrez () == (ST_HIGH >> 8)) 118 if (Getrez() == (ST_HIGH >> 8))
119 return 0; 119 return 0;
120 break; 120 break;
121 case VDO_TT: 121 case VDO_TT:
122 if ((EgetShift () & ES_MODE) == TT_HIGH) 122 if ((EgetShift() & ES_MODE) == TT_HIGH)
123 return 0; 123 return 0;
124 break; 124 break;
125 case VDO_F30: 125 case VDO_F30:
126 if (VgetMonitor () == MONITOR_MONO) 126 if (VgetMonitor() == MONITOR_MONO)
127 return 0; 127 return 0;
128 if (Getcookie (C_SCPN, &cookie_scpn) == C_FOUND) { 128 if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
129 if (!SDL_XBIOS_SB3Usable ((scpn_cookie_t *) cookie_scpn)) { 129 if (!SDL_XBIOS_SB3Usable((scpn_cookie_t *) cookie_scpn)) {
130 return 0; 130 return 0;
131 } 131 }
132 } 132 }
133 break; 133 break;
134 default: 134 default:
137 137
138 return 1; 138 return 1;
139 } 139 }
140 140
141 static void 141 static void
142 XBIOS_DeleteDevice (SDL_VideoDevice * device) 142 XBIOS_DeleteDevice(SDL_VideoDevice * device)
143 { 143 {
144 SDL_free (device->hidden); 144 SDL_free(device->hidden);
145 SDL_free (device); 145 SDL_free(device);
146 } 146 }
147 147
148 static SDL_VideoDevice * 148 static SDL_VideoDevice *
149 XBIOS_CreateDevice (int devindex) 149 XBIOS_CreateDevice(int devindex)
150 { 150 {
151 SDL_VideoDevice *device; 151 SDL_VideoDevice *device;
152 152
153 /* Initialize all variables that we clean on shutdown */ 153 /* Initialize all variables that we clean on shutdown */
154 device = (SDL_VideoDevice *) SDL_malloc (sizeof (SDL_VideoDevice)); 154 device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
155 if (device) { 155 if (device) {
156 SDL_memset (device, 0, (sizeof *device)); 156 SDL_memset(device, 0, (sizeof *device));
157 device->hidden = (struct SDL_PrivateVideoData *) 157 device->hidden = (struct SDL_PrivateVideoData *)
158 SDL_malloc ((sizeof *device->hidden)); 158 SDL_malloc((sizeof *device->hidden));
159 device->gl_data = (struct SDL_PrivateGLData *) 159 device->gl_data = (struct SDL_PrivateGLData *)
160 SDL_malloc ((sizeof *device->gl_data)); 160 SDL_malloc((sizeof *device->gl_data));
161 } 161 }
162 if ((device == NULL) || (device->hidden == NULL)) { 162 if ((device == NULL) || (device->hidden == NULL)) {
163 SDL_OutOfMemory (); 163 SDL_OutOfMemory();
164 if (device) { 164 if (device) {
165 SDL_free (device); 165 SDL_free(device);
166 } 166 }
167 return (0); 167 return (0);
168 } 168 }
169 SDL_memset (device->hidden, 0, (sizeof *device->hidden)); 169 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
170 SDL_memset (device->gl_data, 0, sizeof (*device->gl_data)); 170 SDL_memset(device->gl_data, 0, sizeof(*device->gl_data));
171 171
172 /* Video functions */ 172 /* Video functions */
173 device->VideoInit = XBIOS_VideoInit; 173 device->VideoInit = XBIOS_VideoInit;
174 device->ListModes = XBIOS_ListModes; 174 device->ListModes = XBIOS_ListModes;
175 device->SetVideoMode = XBIOS_SetVideoMode; 175 device->SetVideoMode = XBIOS_SetVideoMode;
204 XBIOS_VID_DRIVER_NAME, "Atari Xbios driver", 204 XBIOS_VID_DRIVER_NAME, "Atari Xbios driver",
205 XBIOS_Available, XBIOS_CreateDevice 205 XBIOS_Available, XBIOS_CreateDevice
206 }; 206 };
207 207
208 void 208 void
209 SDL_XBIOS_AddMode (_THIS, Uint16 modecode, Uint16 width, Uint16 height, 209 SDL_XBIOS_AddMode(_THIS, Uint16 modecode, Uint16 width, Uint16 height,
210 Uint16 depth, SDL_bool flags) 210 Uint16 depth, SDL_bool flags)
211 { 211 {
212 int i, curpos; 212 int i, curpos;
213 xbiosmode_t *current_mode; 213 xbiosmode_t *current_mode;
214 214
215 /* Check if mode already exists */ 215 /* Check if mode already exists */
226 } 226 }
227 } 227 }
228 228
229 ++XBIOS_nummodes; 229 ++XBIOS_nummodes;
230 XBIOS_modelist = 230 XBIOS_modelist =
231 (xbiosmode_t *) SDL_realloc (XBIOS_modelist, 231 (xbiosmode_t *) SDL_realloc(XBIOS_modelist,
232 XBIOS_nummodes * sizeof (xbiosmode_t)); 232 XBIOS_nummodes * sizeof(xbiosmode_t));
233 233
234 /* Keep the list sorted: bpp, width, height */ 234 /* Keep the list sorted: bpp, width, height */
235 curpos = 0; 235 curpos = 0;
236 236
237 for (i = 0; i < XBIOS_nummodes - 1; i++) { 237 for (i = 0; i < XBIOS_nummodes - 1; i++) {
247 curpos++; 247 curpos++;
248 } 248 }
249 249
250 /* Push remaining modes further */ 250 /* Push remaining modes further */
251 for (i = XBIOS_nummodes - 1; i > curpos; i--) { 251 for (i = XBIOS_nummodes - 1; i > curpos; i--) {
252 SDL_memcpy (&XBIOS_modelist[i], &XBIOS_modelist[i - 1], 252 SDL_memcpy(&XBIOS_modelist[i], &XBIOS_modelist[i - 1],
253 sizeof (xbiosmode_t)); 253 sizeof(xbiosmode_t));
254 } 254 }
255 255
256 XBIOS_modelist[curpos].number = modecode; 256 XBIOS_modelist[curpos].number = modecode;
257 XBIOS_modelist[curpos].width = width; 257 XBIOS_modelist[curpos].width = width;
258 XBIOS_modelist[curpos].height = height; 258 XBIOS_modelist[curpos].height = height;
259 XBIOS_modelist[curpos].depth = depth; 259 XBIOS_modelist[curpos].depth = depth;
260 XBIOS_modelist[curpos].doubleline = flags; 260 XBIOS_modelist[curpos].doubleline = flags;
261 } 261 }
262 262
263 static int 263 static int
264 XBIOS_VideoInit (_THIS, SDL_PixelFormat * vformat) 264 XBIOS_VideoInit(_THIS, SDL_PixelFormat * vformat)
265 { 265 {
266 int i, j8, j16; 266 int i, j8, j16;
267 xbiosmode_t *current_mode; 267 xbiosmode_t *current_mode;
268 unsigned long cookie_blow, cookie_scpn, cookie_cnts; 268 unsigned long cookie_blow, cookie_scpn, cookie_cnts;
269 269
270 /* Initialize all variables that we clean on shutdown */ 270 /* Initialize all variables that we clean on shutdown */
271 memset (SDL_modelist, 0, sizeof (SDL_modelist)); 271 memset(SDL_modelist, 0, sizeof(SDL_modelist));
272 272
273 /* Cookie _VDO present ? if not, assume ST machine */ 273 /* Cookie _VDO present ? if not, assume ST machine */
274 if (Getcookie (C__VDO, &XBIOS_cvdo) != C_FOUND) { 274 if (Getcookie(C__VDO, &XBIOS_cvdo) != C_FOUND) {
275 XBIOS_cvdo = VDO_ST << 16; 275 XBIOS_cvdo = VDO_ST << 16;
276 } 276 }
277 277
278 /* Allocate memory for old palette */ 278 /* Allocate memory for old palette */
279 XBIOS_oldpalette = (void *) SDL_malloc (256 * sizeof (long)); 279 XBIOS_oldpalette = (void *) SDL_malloc(256 * sizeof(long));
280 if (!XBIOS_oldpalette) { 280 if (!XBIOS_oldpalette) {
281 SDL_SetError ("Unable to allocate memory for old palette\n"); 281 SDL_SetError("Unable to allocate memory for old palette\n");
282 return (-1); 282 return (-1);
283 } 283 }
284 284
285 /* Initialize video mode list */ 285 /* Initialize video mode list */
286 /* and save current screen status (palette, screen address, video mode) */ 286 /* and save current screen status (palette, screen address, video mode) */
292 case VDO_ST: 292 case VDO_ST:
293 case VDO_STE: 293 case VDO_STE:
294 { 294 {
295 short *oldpalette; 295 short *oldpalette;
296 296
297 SDL_XBIOS_AddMode (this, ST_LOW >> 8, 320, 200, 4, SDL_FALSE); 297 SDL_XBIOS_AddMode(this, ST_LOW >> 8, 320, 200, 4, SDL_FALSE);
298 298
299 XBIOS_oldvbase = Physbase (); 299 XBIOS_oldvbase = Physbase();
300 XBIOS_oldvmode = Getrez (); 300 XBIOS_oldvmode = Getrez();
301 switch (XBIOS_oldvmode << 8) { 301 switch (XBIOS_oldvmode << 8) {
302 case ST_LOW: 302 case ST_LOW:
303 XBIOS_oldnumcol = 16; 303 XBIOS_oldnumcol = 16;
304 break; 304 break;
305 case ST_MED: 305 case ST_MED:
313 break; 313 break;
314 } 314 }
315 315
316 oldpalette = (short *) XBIOS_oldpalette; 316 oldpalette = (short *) XBIOS_oldpalette;
317 for (i = 0; i < XBIOS_oldnumcol; i++) { 317 for (i = 0; i < XBIOS_oldnumcol; i++) {
318 *oldpalette++ = Setcolor (i, -1); 318 *oldpalette++ = Setcolor(i, -1);
319 } 319 }
320 320
321 vformat->BitsPerPixel = 8; 321 vformat->BitsPerPixel = 8;
322 } 322 }
323 break; 323 break;
324 case VDO_TT: 324 case VDO_TT:
325 325
326 SDL_XBIOS_AddMode (this, TT_LOW, 320, 480, 8, SDL_FALSE); 326 SDL_XBIOS_AddMode(this, TT_LOW, 320, 480, 8, SDL_FALSE);
327 /* Software double-lined mode */ 327 /* Software double-lined mode */
328 SDL_XBIOS_AddMode (this, TT_LOW, 320, 240, 8, SDL_TRUE); 328 SDL_XBIOS_AddMode(this, TT_LOW, 320, 240, 8, SDL_TRUE);
329 329
330 XBIOS_oldvbase = Logbase (); 330 XBIOS_oldvbase = Logbase();
331 XBIOS_oldvmode = EgetShift (); 331 XBIOS_oldvmode = EgetShift();
332 332
333 switch (XBIOS_oldvmode & ES_MODE) { 333 switch (XBIOS_oldvmode & ES_MODE) {
334 case TT_LOW: 334 case TT_LOW:
335 XBIOS_oldnumcol = 256; 335 XBIOS_oldnumcol = 256;
336 break; 336 break;
348 default: 348 default:
349 XBIOS_oldnumcol = 0; 349 XBIOS_oldnumcol = 0;
350 break; 350 break;
351 } 351 }
352 if (XBIOS_oldnumcol) { 352 if (XBIOS_oldnumcol) {
353 EgetPalette (0, XBIOS_oldnumcol, XBIOS_oldpalette); 353 EgetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
354 } 354 }
355 355
356 vformat->BitsPerPixel = 8; 356 vformat->BitsPerPixel = 8;
357 break; 357 break;
358 case VDO_F30: 358 case VDO_F30:
359 switch (VgetMonitor ()) { 359 switch (VgetMonitor()) {
360 case MONITOR_MONO: 360 case MONITOR_MONO:
361 /* Not usable */ 361 /* Not usable */
362 break; 362 break;
363 case MONITOR_RGB: 363 case MONITOR_RGB:
364 case MONITOR_TV: 364 case MONITOR_TV:
365 SDL_XBIOS_AddMode (this, BPS16 | COL80 | OVERSCAN | VERTFLAG, 365 SDL_XBIOS_AddMode(this, BPS16 | COL80 | OVERSCAN | VERTFLAG,
366 768, 480, 16, SDL_FALSE); 366 768, 480, 16, SDL_FALSE);
367 SDL_XBIOS_AddMode (this, BPS16 | COL80 | OVERSCAN, 768, 240, 367 SDL_XBIOS_AddMode(this, BPS16 | COL80 | OVERSCAN, 768, 240,
368 16, SDL_FALSE); 368 16, SDL_FALSE);
369 SDL_XBIOS_AddMode (this, BPS16 | COL80 | VERTFLAG, 640, 400, 369 SDL_XBIOS_AddMode(this, BPS16 | COL80 | VERTFLAG, 640, 400,
370 16, SDL_FALSE); 370 16, SDL_FALSE);
371 SDL_XBIOS_AddMode (this, BPS16 | COL80, 640, 200, 16, SDL_FALSE); 371 SDL_XBIOS_AddMode(this, BPS16 | COL80, 640, 200, 16, SDL_FALSE);
372 SDL_XBIOS_AddMode (this, BPS16 | OVERSCAN | VERTFLAG, 384, 372 SDL_XBIOS_AddMode(this, BPS16 | OVERSCAN | VERTFLAG, 384,
373 480, 16, SDL_FALSE); 373 480, 16, SDL_FALSE);
374 SDL_XBIOS_AddMode (this, BPS16 | OVERSCAN, 384, 240, 16, 374 SDL_XBIOS_AddMode(this, BPS16 | OVERSCAN, 384, 240, 16,
375 SDL_FALSE); 375 SDL_FALSE);
376 SDL_XBIOS_AddMode (this, BPS16 | VERTFLAG, 320, 400, 16, 376 SDL_XBIOS_AddMode(this, BPS16 | VERTFLAG, 320, 400, 16,
377 SDL_FALSE); 377 SDL_FALSE);
378 SDL_XBIOS_AddMode (this, BPS16, 320, 200, 16, SDL_FALSE); 378 SDL_XBIOS_AddMode(this, BPS16, 320, 200, 16, SDL_FALSE);
379 SDL_XBIOS_AddMode (this, BPS8 | COL80 | OVERSCAN | VERTFLAG, 379 SDL_XBIOS_AddMode(this, BPS8 | COL80 | OVERSCAN | VERTFLAG,
380 768, 480, 8, SDL_FALSE); 380 768, 480, 8, SDL_FALSE);
381 SDL_XBIOS_AddMode (this, BPS8 | COL80 | OVERSCAN, 768, 240, 8, 381 SDL_XBIOS_AddMode(this, BPS8 | COL80 | OVERSCAN, 768, 240, 8,
382 SDL_FALSE); 382 SDL_FALSE);
383 SDL_XBIOS_AddMode (this, BPS8 | COL80 | VERTFLAG, 640, 400, 8, 383 SDL_XBIOS_AddMode(this, BPS8 | COL80 | VERTFLAG, 640, 400, 8,
384 SDL_FALSE); 384 SDL_FALSE);
385 SDL_XBIOS_AddMode (this, BPS8 | COL80, 640, 200, 8, SDL_FALSE); 385 SDL_XBIOS_AddMode(this, BPS8 | COL80, 640, 200, 8, SDL_FALSE);
386 SDL_XBIOS_AddMode (this, BPS8 | OVERSCAN | VERTFLAG, 384, 480, 386 SDL_XBIOS_AddMode(this, BPS8 | OVERSCAN | VERTFLAG, 384, 480,
387 8, SDL_FALSE); 387 8, SDL_FALSE);
388 SDL_XBIOS_AddMode (this, BPS8 | OVERSCAN, 384, 240, 8, SDL_FALSE); 388 SDL_XBIOS_AddMode(this, BPS8 | OVERSCAN, 384, 240, 8, SDL_FALSE);
389 SDL_XBIOS_AddMode (this, BPS8 | VERTFLAG, 320, 400, 8, SDL_FALSE); 389 SDL_XBIOS_AddMode(this, BPS8 | VERTFLAG, 320, 400, 8, SDL_FALSE);
390 SDL_XBIOS_AddMode (this, BPS8, 320, 200, 8, SDL_FALSE); 390 SDL_XBIOS_AddMode(this, BPS8, 320, 200, 8, SDL_FALSE);
391 break; 391 break;
392 case MONITOR_VGA: 392 case MONITOR_VGA:
393 SDL_XBIOS_AddMode (this, BPS16, 320, 480, 16, SDL_FALSE); 393 SDL_XBIOS_AddMode(this, BPS16, 320, 480, 16, SDL_FALSE);
394 SDL_XBIOS_AddMode (this, BPS16 | VERTFLAG, 320, 240, 16, 394 SDL_XBIOS_AddMode(this, BPS16 | VERTFLAG, 320, 240, 16,
395 SDL_FALSE); 395 SDL_FALSE);
396 SDL_XBIOS_AddMode (this, BPS8 | COL80, 640, 480, 8, SDL_FALSE); 396 SDL_XBIOS_AddMode(this, BPS8 | COL80, 640, 480, 8, SDL_FALSE);
397 SDL_XBIOS_AddMode (this, BPS8 | COL80 | VERTFLAG, 640, 240, 8, 397 SDL_XBIOS_AddMode(this, BPS8 | COL80 | VERTFLAG, 640, 240, 8,
398 SDL_FALSE); 398 SDL_FALSE);
399 SDL_XBIOS_AddMode (this, BPS8, 320, 480, 8, SDL_FALSE); 399 SDL_XBIOS_AddMode(this, BPS8, 320, 480, 8, SDL_FALSE);
400 SDL_XBIOS_AddMode (this, BPS8 | VERTFLAG, 320, 240, 8, SDL_FALSE); 400 SDL_XBIOS_AddMode(this, BPS8 | VERTFLAG, 320, 240, 8, SDL_FALSE);
401 break; 401 break;
402 } 402 }
403 XBIOS_oldvbase = Logbase (); 403 XBIOS_oldvbase = Logbase();
404 XBIOS_oldvmode = VsetMode (-1); 404 XBIOS_oldvmode = VsetMode(-1);
405 405
406 XBIOS_oldnumcol = 1 << (1 << (XBIOS_oldvmode & NUMCOLS)); 406 XBIOS_oldnumcol = 1 << (1 << (XBIOS_oldvmode & NUMCOLS));
407 if (XBIOS_oldnumcol > 256) { 407 if (XBIOS_oldnumcol > 256) {
408 XBIOS_oldnumcol = 0; 408 XBIOS_oldnumcol = 0;
409 } 409 }
410 if (XBIOS_oldnumcol) { 410 if (XBIOS_oldnumcol) {
411 VgetRGB (0, XBIOS_oldnumcol, XBIOS_oldpalette); 411 VgetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
412 } 412 }
413 413
414 vformat->BitsPerPixel = 16; 414 vformat->BitsPerPixel = 16;
415 415
416 /* Keep vga/rvb, and pal/ntsc bits */ 416 /* Keep vga/rvb, and pal/ntsc bits */
425 425
426 current_mode++; 426 current_mode++;
427 } 427 }
428 428
429 /* Initialize BlowUp/SB3/Centscreen stuff if present */ 429 /* Initialize BlowUp/SB3/Centscreen stuff if present */
430 if (Getcookie (C_BLOW, &cookie_blow) == C_FOUND) { 430 if (Getcookie(C_BLOW, &cookie_blow) == C_FOUND) {
431 SDL_XBIOS_BlowupInit (this, (blow_cookie_t *) cookie_blow); 431 SDL_XBIOS_BlowupInit(this, (blow_cookie_t *) cookie_blow);
432 } else if (Getcookie (C_SCPN, &cookie_scpn) == C_FOUND) { 432 } else if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
433 SDL_XBIOS_SB3Init (this, (scpn_cookie_t *) cookie_scpn); 433 SDL_XBIOS_SB3Init(this, (scpn_cookie_t *) cookie_scpn);
434 } else if (Getcookie (C_CNTS, &cookie_cnts) == C_FOUND) { 434 } else if (Getcookie(C_CNTS, &cookie_cnts) == C_FOUND) {
435 XBIOS_oldvmode = SDL_XBIOS_CentscreenInit (this); 435 XBIOS_oldvmode = SDL_XBIOS_CentscreenInit(this);
436 XBIOS_centscreen = SDL_TRUE; 436 XBIOS_centscreen = SDL_TRUE;
437 } 437 }
438 438
439 break; 439 break;
440 } 440 }
450 j8 = j16 = 0; 450 j8 = j16 = 0;
451 for (i = 0; i < XBIOS_nummodes; i++, current_mode++) { 451 for (i = 0; i < XBIOS_nummodes; i++, current_mode++) {
452 switch (current_mode->depth) { 452 switch (current_mode->depth) {
453 case 4: 453 case 4:
454 case 8: 454 case 8:
455 SDL_modelist[0][j8] = SDL_malloc (sizeof (SDL_Rect)); 455 SDL_modelist[0][j8] = SDL_malloc(sizeof(SDL_Rect));
456 SDL_modelist[0][j8]->x = SDL_modelist[0][j8]->y = 0; 456 SDL_modelist[0][j8]->x = SDL_modelist[0][j8]->y = 0;
457 SDL_modelist[0][j8]->w = current_mode->width; 457 SDL_modelist[0][j8]->w = current_mode->width;
458 SDL_modelist[0][j8]->h = current_mode->height; 458 SDL_modelist[0][j8]->h = current_mode->height;
459 XBIOS_videomodes[0][j8] = current_mode; 459 XBIOS_videomodes[0][j8] = current_mode;
460 j8++; 460 j8++;
461 break; 461 break;
462 case 16: 462 case 16:
463 SDL_modelist[1][j16] = SDL_malloc (sizeof (SDL_Rect)); 463 SDL_modelist[1][j16] = SDL_malloc(sizeof(SDL_Rect));
464 SDL_modelist[1][j16]->x = SDL_modelist[1][j16]->y = 0; 464 SDL_modelist[1][j16]->x = SDL_modelist[1][j16]->y = 0;
465 SDL_modelist[1][j16]->w = current_mode->width; 465 SDL_modelist[1][j16]->w = current_mode->width;
466 SDL_modelist[1][j16]->h = current_mode->height; 466 SDL_modelist[1][j16]->h = current_mode->height;
467 XBIOS_videomodes[1][j16] = current_mode; 467 XBIOS_videomodes[1][j16] = current_mode;
468 j16++; 468 j16++;
476 XBIOS_screens[1] = NULL; 476 XBIOS_screens[1] = NULL;
477 XBIOS_shadowscreen = NULL; 477 XBIOS_shadowscreen = NULL;
478 478
479 /* Update hardware info */ 479 /* Update hardware info */
480 this->info.hw_available = 1; 480 this->info.hw_available = 1;
481 this->info.video_mem = (Uint32) Atari_SysMalloc (-1L, MX_STRAM); 481 this->info.video_mem = (Uint32) Atari_SysMalloc(-1L, MX_STRAM);
482 482
483 /* Init chunky to planar routine */ 483 /* Init chunky to planar routine */
484 SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8; 484 SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8;
485 485
486 #if SDL_VIDEO_OPENGL 486 #if SDL_VIDEO_OPENGL
487 SDL_AtariGL_InitPointers (this); 487 SDL_AtariGL_InitPointers(this);
488 #endif 488 #endif
489 489
490 /* We're done! */ 490 /* We're done! */
491 return (0); 491 return (0);
492 } 492 }
493 493
494 static SDL_Rect ** 494 static SDL_Rect **
495 XBIOS_ListModes (_THIS, SDL_PixelFormat * format, Uint32 flags) 495 XBIOS_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
496 { 496 {
497 /* 8 bits -> list 0 */ 497 /* 8 bits -> list 0 */
498 /* 16 bits -> list 1 */ 498 /* 16 bits -> list 1 */
499 if ((format->BitsPerPixel != 8) && (format->BitsPerPixel != 16)) { 499 if ((format->BitsPerPixel != 8) && (format->BitsPerPixel != 16)) {
500 return NULL; 500 return NULL;
502 502
503 return (SDL_modelist[(format->BitsPerPixel) >> 4]); 503 return (SDL_modelist[(format->BitsPerPixel) >> 4]);
504 } 504 }
505 505
506 static void 506 static void
507 XBIOS_FreeBuffers (_THIS) 507 XBIOS_FreeBuffers(_THIS)
508 { 508 {
509 int i; 509 int i;
510 510
511 for (i = 0; i < 2; i++) { 511 for (i = 0; i < 2; i++) {
512 if (XBIOS_screensmem[i] != NULL) { 512 if (XBIOS_screensmem[i] != NULL) {
513 Mfree (XBIOS_screensmem[i]); 513 Mfree(XBIOS_screensmem[i]);
514 XBIOS_screensmem[i] = NULL; 514 XBIOS_screensmem[i] = NULL;
515 } 515 }
516 } 516 }
517 517
518 if (XBIOS_shadowscreen != NULL) { 518 if (XBIOS_shadowscreen != NULL) {
519 Mfree (XBIOS_shadowscreen); 519 Mfree(XBIOS_shadowscreen);
520 XBIOS_shadowscreen = NULL; 520 XBIOS_shadowscreen = NULL;
521 } 521 }
522 } 522 }
523 523
524 static SDL_Surface * 524 static SDL_Surface *
525 XBIOS_SetVideoMode (_THIS, SDL_Surface * current, 525 XBIOS_SetVideoMode(_THIS, SDL_Surface * current,
526 int width, int height, int bpp, Uint32 flags) 526 int width, int height, int bpp, Uint32 flags)
527 { 527 {
528 int mode, new_depth; 528 int mode, new_depth;
529 int i; 529 int i;
530 xbiosmode_t *new_video_mode; 530 xbiosmode_t *new_video_mode;
531 Uint32 new_screen_size; 531 Uint32 new_screen_size;
532 Uint32 modeflags; 532 Uint32 modeflags;
533 533
534 /* Free current buffers */ 534 /* Free current buffers */
535 XBIOS_FreeBuffers (this); 535 XBIOS_FreeBuffers(this);
536 536
537 /* Limit bpp */ 537 /* Limit bpp */
538 if (bpp > 16) { 538 if (bpp > 16) {
539 bpp = 16; 539 bpp = 16;
540 } 540 }
547 547
548 break; 548 break;
549 } 549 }
550 } 550 }
551 if (SDL_modelist[bpp][mode] == NULL) { 551 if (SDL_modelist[bpp][mode] == NULL) {
552 SDL_SetError ("Couldn't find requested mode in list"); 552 SDL_SetError("Couldn't find requested mode in list");
553 return (NULL); 553 return (NULL);
554 } 554 }
555 555
556 modeflags = SDL_FULLSCREEN | SDL_PREALLOC; 556 modeflags = SDL_FULLSCREEN | SDL_PREALLOC;
557 557
571 571
572 new_screen_size = width * height * ((new_depth) >> 3); 572 new_screen_size = width * height * ((new_depth) >> 3);
573 new_screen_size += 256; /* To align on a 256 byte adress */ 573 new_screen_size += 256; /* To align on a 256 byte adress */
574 574
575 if (new_depth == 8) { 575 if (new_depth == 8) {
576 XBIOS_shadowscreen = Atari_SysMalloc (new_screen_size, MX_PREFTTRAM); 576 XBIOS_shadowscreen = Atari_SysMalloc(new_screen_size, MX_PREFTTRAM);
577 577
578 if (XBIOS_shadowscreen == NULL) { 578 if (XBIOS_shadowscreen == NULL) {
579 SDL_SetError ("Can not allocate %d KB for shadow buffer", 579 SDL_SetError("Can not allocate %d KB for shadow buffer",
580 new_screen_size >> 10); 580 new_screen_size >> 10);
581 return (NULL); 581 return (NULL);
582 } 582 }
583 SDL_memset (XBIOS_shadowscreen, 0, new_screen_size); 583 SDL_memset(XBIOS_shadowscreen, 0, new_screen_size);
584 } 584 }
585 585
586 /* Output buffer needs to be twice in size for the software double-line mode */ 586 /* Output buffer needs to be twice in size for the software double-line mode */
587 XBIOS_doubleline = SDL_FALSE; 587 XBIOS_doubleline = SDL_FALSE;
588 if (new_video_mode->doubleline) { 588 if (new_video_mode->doubleline) {
589 new_screen_size <<= 1; 589 new_screen_size <<= 1;
590 XBIOS_doubleline = SDL_TRUE; 590 XBIOS_doubleline = SDL_TRUE;
591 } 591 }
592 592
593 XBIOS_screensmem[0] = Atari_SysMalloc (new_screen_size, MX_STRAM); 593 XBIOS_screensmem[0] = Atari_SysMalloc(new_screen_size, MX_STRAM);
594 594
595 if (XBIOS_screensmem[0] == NULL) { 595 if (XBIOS_screensmem[0] == NULL) {
596 XBIOS_FreeBuffers (this); 596 XBIOS_FreeBuffers(this);
597 SDL_SetError ("Can not allocate %d KB for frame buffer", 597 SDL_SetError("Can not allocate %d KB for frame buffer",
598 new_screen_size >> 10); 598 new_screen_size >> 10);
599 return (NULL); 599 return (NULL);
600 } 600 }
601 SDL_memset (XBIOS_screensmem[0], 0, new_screen_size); 601 SDL_memset(XBIOS_screensmem[0], 0, new_screen_size);
602 602
603 XBIOS_screens[0] = 603 XBIOS_screens[0] =
604 (void *) (((long) XBIOS_screensmem[0] + 256) & 0xFFFFFF00UL); 604 (void *) (((long) XBIOS_screensmem[0] + 256) & 0xFFFFFF00UL);
605 605
606 #if SDL_VIDEO_OPENGL 606 #if SDL_VIDEO_OPENGL
611 } 611 }
612 #endif 612 #endif
613 613
614 /* Double buffer ? */ 614 /* Double buffer ? */
615 if (flags & SDL_DOUBLEBUF) { 615 if (flags & SDL_DOUBLEBUF) {
616 XBIOS_screensmem[1] = Atari_SysMalloc (new_screen_size, MX_STRAM); 616 XBIOS_screensmem[1] = Atari_SysMalloc(new_screen_size, MX_STRAM);
617 617
618 if (XBIOS_screensmem[1] == NULL) { 618 if (XBIOS_screensmem[1] == NULL) {
619 XBIOS_FreeBuffers (this); 619 XBIOS_FreeBuffers(this);
620 SDL_SetError ("Can not allocate %d KB for double buffer", 620 SDL_SetError("Can not allocate %d KB for double buffer",
621 new_screen_size >> 10); 621 new_screen_size >> 10);
622 return (NULL); 622 return (NULL);
623 } 623 }
624 SDL_memset (XBIOS_screensmem[1], 0, new_screen_size); 624 SDL_memset(XBIOS_screensmem[1], 0, new_screen_size);
625 625
626 XBIOS_screens[1] = 626 XBIOS_screens[1] =
627 (void *) (((long) XBIOS_screensmem[1] + 256) & 0xFFFFFF00UL); 627 (void *) (((long) XBIOS_screensmem[1] + 256) & 0xFFFFFF00UL);
628 modeflags |= SDL_DOUBLEBUF; 628 modeflags |= SDL_DOUBLEBUF;
629 } 629 }
630 630
631 /* Allocate the new pixel format for the screen */ 631 /* Allocate the new pixel format for the screen */
632 if (!SDL_ReallocFormat (current, new_depth, 0, 0, 0, 0)) { 632 if (!SDL_ReallocFormat(current, new_depth, 0, 0, 0, 0)) {
633 XBIOS_FreeBuffers (this); 633 XBIOS_FreeBuffers(this);
634 SDL_SetError 634 SDL_SetError("Couldn't allocate new pixel format for requested mode");
635 ("Couldn't allocate new pixel format for requested mode");
636 return (NULL); 635 return (NULL);
637 } 636 }
638 637
639 current->w = XBIOS_width = width; 638 current->w = XBIOS_width = width;
640 current->h = XBIOS_height = height; 639 current->h = XBIOS_height = height;
650 649
651 XBIOS_fbnum = 0; 650 XBIOS_fbnum = 0;
652 651
653 #if SDL_VIDEO_OPENGL 652 #if SDL_VIDEO_OPENGL
654 if (flags & SDL_INTERNALOPENGL) { 653 if (flags & SDL_INTERNALOPENGL) {
655 if (!SDL_AtariGL_Init (this, current)) { 654 if (!SDL_AtariGL_Init(this, current)) {
656 XBIOS_FreeBuffers (this); 655 XBIOS_FreeBuffers(this);
657 SDL_SetError ("Can not create OpenGL context"); 656 SDL_SetError("Can not create OpenGL context");
658 return NULL; 657 return NULL;
659 } 658 }
660 659
661 modeflags |= SDL_INTERNALOPENGL; 660 modeflags |= SDL_INTERNALOPENGL;
662 } 661 }
664 663
665 current->flags = modeflags; 664 current->flags = modeflags;
666 665
667 /* Now set the video mode */ 666 /* Now set the video mode */
668 #ifndef DEBUG_VIDEO_XBIOS 667 #ifndef DEBUG_VIDEO_XBIOS
669 Setscreen (-1, XBIOS_screens[0], -1); 668 Setscreen(-1, XBIOS_screens[0], -1);
670 #endif 669 #endif
671 670
672 switch (XBIOS_cvdo >> 16) { 671 switch (XBIOS_cvdo >> 16) {
673 case VDO_ST: 672 case VDO_ST:
674 #ifndef DEBUG_VIDEO_XBIOS 673 #ifndef DEBUG_VIDEO_XBIOS
675 Setscreen (-1, -1, new_video_mode->number); 674 Setscreen(-1, -1, new_video_mode->number);
676 #endif 675 #endif
677 /* Reset palette */ 676 /* Reset palette */
678 for (i = 0; i < 16; i++) { 677 for (i = 0; i < 16; i++) {
679 TT_palette[i] = 678 TT_palette[i] =
680 ((i >> 1) << 8) | (((i * 8) / 17) << 4) | (i >> 1); 679 ((i >> 1) << 8) | (((i * 8) / 17) << 4) | (i >> 1);
681 } 680 }
682 #ifndef DEBUG_VIDEO_XBIOS 681 #ifndef DEBUG_VIDEO_XBIOS
683 Setpalette (TT_palette); 682 Setpalette(TT_palette);
684 #endif 683 #endif
685 break; 684 break;
686 case VDO_STE: 685 case VDO_STE:
687 #ifndef DEBUG_VIDEO_XBIOS 686 #ifndef DEBUG_VIDEO_XBIOS
688 Setscreen (-1, -1, new_video_mode->number); 687 Setscreen(-1, -1, new_video_mode->number);
689 #endif 688 #endif
690 /* Reset palette */ 689 /* Reset palette */
691 for (i = 0; i < 16; i++) { 690 for (i = 0; i < 16; i++) {
692 int c; 691 int c;
693 692
694 c = ((i & 1) << 3) | ((i >> 1) & 7); 693 c = ((i & 1) << 3) | ((i >> 1) & 7);
695 TT_palette[i] = (c << 8) | (c << 4) | c; 694 TT_palette[i] = (c << 8) | (c << 4) | c;
696 } 695 }
697 #ifndef DEBUG_VIDEO_XBIOS 696 #ifndef DEBUG_VIDEO_XBIOS
698 Setpalette (TT_palette); 697 Setpalette(TT_palette);
699 #endif 698 #endif
700 break; 699 break;
701 case VDO_TT: 700 case VDO_TT:
702 #ifndef DEBUG_VIDEO_XBIOS 701 #ifndef DEBUG_VIDEO_XBIOS
703 EsetShift (new_video_mode->number); 702 EsetShift(new_video_mode->number);
704 #endif 703 #endif
705 break; 704 break;
706 case VDO_F30: 705 case VDO_F30:
707 #ifndef DEBUG_VIDEO_XBIOS 706 #ifndef DEBUG_VIDEO_XBIOS
708 if (XBIOS_centscreen) { 707 if (XBIOS_centscreen) {
709 SDL_XBIOS_CentscreenSetmode (this, width, height, new_depth); 708 SDL_XBIOS_CentscreenSetmode(this, width, height, new_depth);
710 } else { 709 } else {
711 VsetMode (new_video_mode->number); 710 VsetMode(new_video_mode->number);
712 } 711 }
713 #endif 712 #endif
714 /* Set hardware palette to black in True Colour */ 713 /* Set hardware palette to black in True Colour */
715 if (new_depth == 16) { 714 if (new_depth == 16) {
716 SDL_memset (F30_palette, 0, sizeof (F30_palette)); 715 SDL_memset(F30_palette, 0, sizeof(F30_palette));
717 VsetRGB (0, 256, F30_palette); 716 VsetRGB(0, 256, F30_palette);
718 } 717 }
719 break; 718 break;
720 } 719 }
721 720
722 Vsync (); 721 Vsync();
723 722
724 this->UpdateRects = XBIOS_UpdateRects; 723 this->UpdateRects = XBIOS_UpdateRects;
725 724
726 return (current); 725 return (current);
727 } 726 }
728 727
729 /* We don't actually allow hardware surfaces other than the main one */ 728 /* We don't actually allow hardware surfaces other than the main one */
730 static int 729 static int
731 XBIOS_AllocHWSurface (_THIS, SDL_Surface * surface) 730 XBIOS_AllocHWSurface(_THIS, SDL_Surface * surface)
732 { 731 {
733 return (-1); 732 return (-1);
734 } 733 }
735 734
736 static void 735 static void
737 XBIOS_FreeHWSurface (_THIS, SDL_Surface * surface) 736 XBIOS_FreeHWSurface(_THIS, SDL_Surface * surface)
738 { 737 {
739 return; 738 return;
740 } 739 }
741 740
742 static int 741 static int
743 XBIOS_LockHWSurface (_THIS, SDL_Surface * surface) 742 XBIOS_LockHWSurface(_THIS, SDL_Surface * surface)
744 { 743 {
745 return (0); 744 return (0);
746 } 745 }
747 746
748 static void 747 static void
749 XBIOS_UnlockHWSurface (_THIS, SDL_Surface * surface) 748 XBIOS_UnlockHWSurface(_THIS, SDL_Surface * surface)
750 { 749 {
751 return; 750 return;
752 } 751 }
753 752
754 static void 753 static void
755 XBIOS_UpdateRects (_THIS, int numrects, SDL_Rect * rects) 754 XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect * rects)
756 { 755 {
757 SDL_Surface *surface; 756 SDL_Surface *surface;
758 757
759 surface = this->screen; 758 surface = this->screen;
760 759
778 destination = XBIOS_screens[XBIOS_fbnum]; 777 destination = XBIOS_screens[XBIOS_fbnum];
779 destination += XBIOS_pitch * rects[i].y; 778 destination += XBIOS_pitch * rects[i].y;
780 destination += x1; 779 destination += x1;
781 780
782 /* Convert chunky to planar screen */ 781 /* Convert chunky to planar screen */
783 SDL_Atari_C2pConvert (source, 782 SDL_Atari_C2pConvert(source,
784 destination, 783 destination,
785 x2 - x1, 784 x2 - x1,
786 rects[i].h, 785 rects[i].h,
787 XBIOS_doubleline, 786 XBIOS_doubleline,
788 surface->pitch, XBIOS_pitch); 787 surface->pitch, XBIOS_pitch);
789 } 788 }
790 } 789 }
791 #ifndef DEBUG_VIDEO_XBIOS 790 #ifndef DEBUG_VIDEO_XBIOS
792 Setscreen (-1, XBIOS_screens[XBIOS_fbnum], -1); 791 Setscreen(-1, XBIOS_screens[XBIOS_fbnum], -1);
793 #endif 792 #endif
794 Vsync (); 793 Vsync();
795 794
796 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) { 795 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
797 XBIOS_fbnum ^= 1; 796 XBIOS_fbnum ^= 1;
798 if ((surface->format->BitsPerPixel) > 8) { 797 if ((surface->format->BitsPerPixel) > 8) {
799 surface->pixels = XBIOS_screens[XBIOS_fbnum]; 798 surface->pixels = XBIOS_screens[XBIOS_fbnum];
800 } 799 }
801 } 800 }
802 } 801 }
803 802
804 static int 803 static int
805 XBIOS_FlipHWSurface (_THIS, SDL_Surface * surface) 804 XBIOS_FlipHWSurface(_THIS, SDL_Surface * surface)
806 { 805 {
807 if ((surface->format->BitsPerPixel) == 8) { 806 if ((surface->format->BitsPerPixel) == 8) {
808 void *destscr; 807 void *destscr;
809 int destx; 808 int destx;
810 809
814 destx = (XBIOS_width - surface->w) >> 1; 813 destx = (XBIOS_width - surface->w) >> 1;
815 destx &= ~15; 814 destx &= ~15;
816 destscr += destx; 815 destscr += destx;
817 816
818 /* Convert chunky to planar screen */ 817 /* Convert chunky to planar screen */
819 SDL_Atari_C2pConvert (surface->pixels, 818 SDL_Atari_C2pConvert(surface->pixels,
820 destscr, 819 destscr,
821 surface->w, 820 surface->w,
822 surface->h, 821 surface->h,
823 XBIOS_doubleline, surface->pitch, XBIOS_pitch); 822 XBIOS_doubleline, surface->pitch, XBIOS_pitch);
824 } 823 }
825 #ifndef DEBUG_VIDEO_XBIOS 824 #ifndef DEBUG_VIDEO_XBIOS
826 Setscreen (-1, XBIOS_screens[XBIOS_fbnum], -1); 825 Setscreen(-1, XBIOS_screens[XBIOS_fbnum], -1);
827 #endif 826 #endif
828 Vsync (); 827 Vsync();
829 828
830 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) { 829 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
831 XBIOS_fbnum ^= 1; 830 XBIOS_fbnum ^= 1;
832 if ((surface->format->BitsPerPixel) > 8) { 831 if ((surface->format->BitsPerPixel) > 8) {
833 surface->pixels = XBIOS_screens[XBIOS_fbnum]; 832 surface->pixels = XBIOS_screens[XBIOS_fbnum];
836 835
837 return (0); 836 return (0);
838 } 837 }
839 838
840 static int 839 static int
841 XBIOS_SetColors (_THIS, int firstcolor, int ncolors, SDL_Color * colors) 840 XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
842 { 841 {
843 int i; 842 int i;
844 int r, v, b; 843 int r, v, b;
845 844
846 switch (XBIOS_cvdo >> 16) { 845 switch (XBIOS_cvdo >> 16) {
852 b = colors[i].b; 851 b = colors[i].b;
853 852
854 TT_palette[firstcolor + i] = 853 TT_palette[firstcolor + i] =
855 ((r * 30) + (v * 59) + (b * 11)) / 100; 854 ((r * 30) + (v * 59) + (b * 11)) / 100;
856 } 855 }
857 SDL_Atari_C2pConvert4_pal (TT_palette); /* convert the lighting */ 856 SDL_Atari_C2pConvert4_pal(TT_palette); /* convert the lighting */
858 break; 857 break;
859 case VDO_TT: 858 case VDO_TT:
860 for (i = 0; i < ncolors; i++) { 859 for (i = 0; i < ncolors; i++) {
861 r = colors[i].r; 860 r = colors[i].r;
862 v = colors[i].g; 861 v = colors[i].g;
863 b = colors[i].b; 862 b = colors[i].b;
864 863
865 TT_palette[i] = ((r >> 4) << 8) | ((v >> 4) << 4) | (b >> 4); 864 TT_palette[i] = ((r >> 4) << 8) | ((v >> 4) << 4) | (b >> 4);
866 } 865 }
867 #ifndef DEBUG_VIDEO_XBIOS 866 #ifndef DEBUG_VIDEO_XBIOS
868 EsetPalette (firstcolor, ncolors, TT_palette); 867 EsetPalette(firstcolor, ncolors, TT_palette);
869 #endif 868 #endif
870 break; 869 break;
871 case VDO_F30: 870 case VDO_F30:
872 for (i = 0; i < ncolors; i++) { 871 for (i = 0; i < ncolors; i++) {
873 r = colors[i].r; 872 r = colors[i].r;
875 b = colors[i].b; 874 b = colors[i].b;
876 875
877 F30_palette[i] = (r << 16) | (v << 8) | b; 876 F30_palette[i] = (r << 16) | (v << 8) | b;
878 } 877 }
879 #ifndef DEBUG_VIDEO_XBIOS 878 #ifndef DEBUG_VIDEO_XBIOS
880 VsetRGB (firstcolor, ncolors, F30_palette); 879 VsetRGB(firstcolor, ncolors, F30_palette);
881 #endif 880 #endif
882 break; 881 break;
883 } 882 }
884 883
885 return (1); 884 return (1);
887 886
888 /* Note: If we are terminated, this could be called in the middle of 887 /* Note: If we are terminated, this could be called in the middle of
889 another SDL video routine -- notably UpdateRects. 888 another SDL video routine -- notably UpdateRects.
890 */ 889 */
891 static void 890 static void
892 XBIOS_VideoQuit (_THIS) 891 XBIOS_VideoQuit(_THIS)
893 { 892 {
894 int i, j; 893 int i, j;
895 894
896 Atari_ShutdownEvents (); 895 Atari_ShutdownEvents();
897 896
898 /* Restore video mode and palette */ 897 /* Restore video mode and palette */
899 #ifndef DEBUG_VIDEO_XBIOS 898 #ifndef DEBUG_VIDEO_XBIOS
900 switch (XBIOS_cvdo >> 16) { 899 switch (XBIOS_cvdo >> 16) {
901 case VDO_ST: 900 case VDO_ST:
902 case VDO_STE: 901 case VDO_STE:
903 Setscreen (-1, XBIOS_oldvbase, XBIOS_oldvmode); 902 Setscreen(-1, XBIOS_oldvbase, XBIOS_oldvmode);
904 if (XBIOS_oldnumcol) { 903 if (XBIOS_oldnumcol) {
905 Setpalette (XBIOS_oldpalette); 904 Setpalette(XBIOS_oldpalette);
906 } 905 }
907 break; 906 break;
908 case VDO_TT: 907 case VDO_TT:
909 Setscreen (-1, XBIOS_oldvbase, -1); 908 Setscreen(-1, XBIOS_oldvbase, -1);
910 EsetShift (XBIOS_oldvmode); 909 EsetShift(XBIOS_oldvmode);
911 if (XBIOS_oldnumcol) { 910 if (XBIOS_oldnumcol) {
912 EsetPalette (0, XBIOS_oldnumcol, XBIOS_oldpalette); 911 EsetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
913 } 912 }
914 break; 913 break;
915 case VDO_F30: 914 case VDO_F30:
916 Setscreen (-1, XBIOS_oldvbase, -1); 915 Setscreen(-1, XBIOS_oldvbase, -1);
917 if (XBIOS_centscreen) { 916 if (XBIOS_centscreen) {
918 SDL_XBIOS_CentscreenRestore (this, XBIOS_oldvmode); 917 SDL_XBIOS_CentscreenRestore(this, XBIOS_oldvmode);
919 } else { 918 } else {
920 VsetMode (XBIOS_oldvmode); 919 VsetMode(XBIOS_oldvmode);
921 } 920 }
922 if (XBIOS_oldnumcol) { 921 if (XBIOS_oldnumcol) {
923 VsetRGB (0, XBIOS_oldnumcol, XBIOS_oldpalette); 922 VsetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
924 } 923 }
925 break; 924 break;
926 } 925 }
927 Vsync (); 926 Vsync();
928 #endif 927 #endif
929 928
930 929
931 #if SDL_VIDEO_OPENGL 930 #if SDL_VIDEO_OPENGL
932 if (gl_active) { 931 if (gl_active) {
933 SDL_AtariGL_Quit (this, SDL_TRUE); 932 SDL_AtariGL_Quit(this, SDL_TRUE);
934 } 933 }
935 #endif 934 #endif
936 935
937 if (XBIOS_oldpalette) { 936 if (XBIOS_oldpalette) {
938 SDL_free (XBIOS_oldpalette); 937 SDL_free(XBIOS_oldpalette);
939 XBIOS_oldpalette = NULL; 938 XBIOS_oldpalette = NULL;
940 } 939 }
941 XBIOS_FreeBuffers (this); 940 XBIOS_FreeBuffers(this);
942 941
943 /* Free mode list */ 942 /* Free mode list */
944 for (j = 0; j < NUM_MODELISTS; j++) { 943 for (j = 0; j < NUM_MODELISTS; j++) {
945 for (i = 0; i < SDL_NUMMODES; i++) { 944 for (i = 0; i < SDL_NUMMODES; i++) {
946 if (SDL_modelist[j][i] != NULL) { 945 if (SDL_modelist[j][i] != NULL) {
947 SDL_free (SDL_modelist[j][i]); 946 SDL_free(SDL_modelist[j][i]);
948 SDL_modelist[j][i] = NULL; 947 SDL_modelist[j][i] = NULL;
949 } 948 }
950 } 949 }
951 } 950 }
952 951
953 if (XBIOS_modelist) { 952 if (XBIOS_modelist) {
954 SDL_free (XBIOS_modelist); 953 SDL_free(XBIOS_modelist);
955 XBIOS_nummodes = 0; 954 XBIOS_nummodes = 0;
956 XBIOS_modelist = NULL; 955 XBIOS_modelist = NULL;
957 } 956 }
958 957
959 this->screen->pixels = NULL; 958 this->screen->pixels = NULL;
960 } 959 }
961 960
962 #if SDL_VIDEO_OPENGL 961 #if SDL_VIDEO_OPENGL
963 962
964 static void 963 static void
965 XBIOS_GL_SwapBuffers (_THIS) 964 XBIOS_GL_SwapBuffers(_THIS)
966 { 965 {
967 SDL_AtariGL_SwapBuffers (this); 966 SDL_AtariGL_SwapBuffers(this);
968 XBIOS_FlipHWSurface (this, this->screen); 967 XBIOS_FlipHWSurface(this, this->screen);
969 SDL_AtariGL_MakeCurrent (this); 968 SDL_AtariGL_MakeCurrent(this);
970 } 969 }
971 970
972 #endif 971 #endif
973 /* vi: set ts=4 sw=4 expandtab: */ 972 /* vi: set ts=4 sw=4 expandtab: */