Mercurial > sdl-ios-xcode
comparison src/video/xbios/SDL_xbios.c @ 1668:4da1ee79c9af SDL-1.3
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: */ |