summaryrefslogtreecommitdiff
path: root/apps/plugins/sdl/src/video/xbios/SDL_xbios.c
diff options
context:
space:
mode:
authorFranklin Wei <git@fwei.tk>2018-02-07 20:04:46 -0500
committerFranklin Wei <git@fwei.tk>2018-03-12 20:52:01 -0400
commit6039eb05ba6d82ef56f2868c96654c552d117bf9 (patch)
tree9db7016bcbf66cfdf7b9bc998d84c6eaff9c8378 /apps/plugins/sdl/src/video/xbios/SDL_xbios.c
parentef373c03b96b0be08babca581d9f10bccfd4931f (diff)
downloadrockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.tar.gz
rockbox-6039eb05ba6d82ef56f2868c96654c552d117bf9.zip
sdl: remove non-rockbox drivers
We never use any of these other drivers, so having them around just takes up space. Change-Id: Iced812162df1fef3fd55522b7e700acb6c3bcd41
Diffstat (limited to 'apps/plugins/sdl/src/video/xbios/SDL_xbios.c')
-rw-r--r--apps/plugins/sdl/src/video/xbios/SDL_xbios.c1116
1 files changed, 0 insertions, 1116 deletions
diff --git a/apps/plugins/sdl/src/video/xbios/SDL_xbios.c b/apps/plugins/sdl/src/video/xbios/SDL_xbios.c
deleted file mode 100644
index 56bf6abd6f..0000000000
--- a/apps/plugins/sdl/src/video/xbios/SDL_xbios.c
+++ /dev/null
@@ -1,1116 +0,0 @@
1/*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997-2012 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19 Sam Lantinga
20 slouken@libsdl.org
21*/
22#include "SDL_config.h"
23
24/*
25 * Xbios SDL video driver
26 *
27 * Patrice Mandin
28 */
29
30#include <sys/stat.h>
31#include <unistd.h>
32
33/* Mint includes */
34#include <mint/cookie.h>
35#include <mint/osbind.h>
36#include <mint/falcon.h>
37
38#include "SDL_video.h"
39#include "SDL_mouse.h"
40#include "../SDL_sysvideo.h"
41#include "../SDL_pixels_c.h"
42#include "../../events/SDL_events_c.h"
43
44#include "../ataricommon/SDL_ataric2p_s.h"
45#include "../ataricommon/SDL_atarievents_c.h"
46#include "../ataricommon/SDL_atarimxalloc_c.h"
47#include "../ataricommon/SDL_atarigl_c.h"
48#include "SDL_xbios.h"
49#include "SDL_xbios_blowup.h"
50#include "SDL_xbios_centscreen.h"
51#include "SDL_xbios_sb3.h"
52#include "SDL_xbios_tveille.h"
53#include "SDL_xbios_milan.h"
54
55#define XBIOS_VID_DRIVER_NAME "xbios"
56
57#ifndef C_fVDI
58#define C_fVDI 0x66564449L
59#endif
60
61/* Debug print info */
62#if 0
63#define DEBUG_PRINT(what) \
64 { \
65 printf what; \
66 }
67#define DEBUG_VIDEO_XBIOS 1
68#else
69#define DEBUG_PRINT(what)
70#undef DEBUG_VIDEO_XBIOS
71#endif
72
73/* Initialization/Query functions */
74static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat);
75static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
76static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
77static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
78static void XBIOS_VideoQuit(_THIS);
79
80/* Hardware surface functions */
81static int XBIOS_AllocHWSurface(_THIS, SDL_Surface *surface);
82static int XBIOS_LockHWSurface(_THIS, SDL_Surface *surface);
83static int XBIOS_FlipHWSurface(_THIS, SDL_Surface *surface);
84static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface *surface);
85static void XBIOS_FreeHWSurface(_THIS, SDL_Surface *surface);
86static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect *rects);
87
88#if SDL_VIDEO_OPENGL
89/* OpenGL functions */
90static void XBIOS_GL_SwapBuffers(_THIS);
91#endif
92
93/* To setup palette */
94
95static unsigned short TT_palette[256];
96static unsigned long F30_palette[256];
97
98/* Default list of video modes */
99
100static const xbiosmode_t stmodes[1]={
101 {ST_LOW>>8,320,200,4, XBIOSMODE_C2P}
102};
103
104static const xbiosmode_t ttmodes[2]={
105 {TT_LOW,320,480,8, XBIOSMODE_C2P},
106 {TT_LOW,320,240,8, XBIOSMODE_C2P|XBIOSMODE_DOUBLELINE}
107};
108
109static const xbiosmode_t falconrgbmodes[16]={
110 {BPS16|COL80|OVERSCAN|VERTFLAG,768,480,16,0},
111 {BPS16|COL80|OVERSCAN,768,240,16,0},
112 {BPS16|COL80|VERTFLAG,640,400,16,0},
113 {BPS16|COL80,640,200,16,0},
114 {BPS16|OVERSCAN|VERTFLAG,384,480,16,0},
115 {BPS16|OVERSCAN,384,240,16,0},
116 {BPS16|VERTFLAG,320,400,16,0},
117 {BPS16,320,200,16,0},
118 {BPS8|COL80|OVERSCAN|VERTFLAG,768,480,8,XBIOSMODE_C2P},
119 {BPS8|COL80|OVERSCAN,768,240,8,XBIOSMODE_C2P},
120 {BPS8|COL80|VERTFLAG,640,400,8,XBIOSMODE_C2P},
121 {BPS8|COL80,640,200,8,XBIOSMODE_C2P},
122 {BPS8|OVERSCAN|VERTFLAG,384,480,8,XBIOSMODE_C2P},
123 {BPS8|OVERSCAN,384,240,8,XBIOSMODE_C2P},
124 {BPS8|VERTFLAG,320,400,8,XBIOSMODE_C2P},
125 {BPS8,320,200,8,XBIOSMODE_C2P}
126};
127
128static const xbiosmode_t falconvgamodes[6]={
129 {BPS16,320,480,16,0},
130 {BPS16|VERTFLAG,320,240,16,0},
131 {BPS8|COL80,640,480,8,XBIOSMODE_C2P},
132 {BPS8|COL80|VERTFLAG,640,240,8,XBIOSMODE_C2P},
133 {BPS8,320,480,8,XBIOSMODE_C2P},
134 {BPS8|VERTFLAG,320,240,8,XBIOSMODE_C2P}
135};
136
137/* Xbios driver bootstrap functions */
138
139static int XBIOS_Available(void)
140{
141 long cookie_vdo, /*cookie_mil,*/ cookie_hade, cookie_scpn;
142 long cookie_fvdi;
143 const char *envr = SDL_getenv("SDL_VIDEODRIVER");
144
145 /* Milan/Hades Atari clones do not have an Atari video chip */
146 if ( /*(Getcookie(C__MIL, &cookie_mil) == C_FOUND) ||*/
147 (Getcookie(C_hade, &cookie_hade) == C_FOUND) ) {
148 return 0;
149 }
150
151 /* fVDI means graphic card, so no Xbios with it */
152 if (Getcookie(C_fVDI, &cookie_fvdi) == C_FOUND) {
153 if (!envr) {
154 return 0;
155 }
156 if (SDL_strcmp(envr, XBIOS_VID_DRIVER_NAME)!=0) {
157 return 0;
158 }
159 /* Except if we force Xbios usage, through env var */
160 }
161
162 /* Cookie _VDO present ? if not, assume ST machine */
163 if (Getcookie(C__VDO, &cookie_vdo) != C_FOUND) {
164 cookie_vdo = VDO_ST << 16;
165 }
166
167 /* Test if we have a monochrome monitor plugged in */
168 switch( cookie_vdo >>16) {
169 case VDO_ST:
170 case VDO_STE:
171 if ( Getrez() == (ST_HIGH>>8) )
172 return 0;
173 break;
174 case VDO_TT:
175 if ( (EgetShift() & ES_MODE) == TT_HIGH)
176 return 0;
177 break;
178 case VDO_F30:
179 if ( VgetMonitor() == MONITOR_MONO)
180 return 0;
181 if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
182 if (!SDL_XBIOS_SB3Usable((scpn_cookie_t *)cookie_scpn)) {
183 return 0;
184 }
185 }
186 break;
187 case VDO_MILAN:
188 break;
189 default:
190 return 0;
191 }
192
193 return 1;
194}
195
196static void XBIOS_DeleteDevice(SDL_VideoDevice *device)
197{
198 SDL_free(device->hidden);
199 SDL_free(device);
200}
201
202static SDL_VideoDevice *XBIOS_CreateDevice(int devindex)
203{
204 SDL_VideoDevice *device;
205
206 /* Initialize all variables that we clean on shutdown */
207 device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
208 if ( device ) {
209 SDL_memset(device, 0, (sizeof *device));
210 device->hidden = (struct SDL_PrivateVideoData *)
211 SDL_malloc((sizeof *device->hidden));
212 device->gl_data = (struct SDL_PrivateGLData *)
213 SDL_malloc((sizeof *device->gl_data));
214 }
215 if ( (device == NULL) || (device->hidden == NULL) ) {
216 SDL_OutOfMemory();
217 if ( device ) {
218 SDL_free(device);
219 }
220 return(0);
221 }
222 SDL_memset(device->hidden, 0, (sizeof *device->hidden));
223 SDL_memset(device->gl_data, 0, sizeof(*device->gl_data));
224
225 /* Video functions */
226 device->VideoInit = XBIOS_VideoInit;
227 device->ListModes = XBIOS_ListModes;
228 device->SetVideoMode = XBIOS_SetVideoMode;
229 device->SetColors = XBIOS_SetColors;
230 device->UpdateRects = NULL;
231 device->VideoQuit = XBIOS_VideoQuit;
232 device->AllocHWSurface = XBIOS_AllocHWSurface;
233 device->LockHWSurface = XBIOS_LockHWSurface;
234 device->UnlockHWSurface = XBIOS_UnlockHWSurface;
235 device->FlipHWSurface = XBIOS_FlipHWSurface;
236 device->FreeHWSurface = XBIOS_FreeHWSurface;
237
238#if SDL_VIDEO_OPENGL
239 /* OpenGL functions */
240 device->GL_LoadLibrary = SDL_AtariGL_LoadLibrary;
241 device->GL_GetProcAddress = SDL_AtariGL_GetProcAddress;
242 device->GL_GetAttribute = SDL_AtariGL_GetAttribute;
243 device->GL_MakeCurrent = SDL_AtariGL_MakeCurrent;
244 device->GL_SwapBuffers = XBIOS_GL_SwapBuffers;
245#endif
246
247 /* Events */
248 device->InitOSKeymap = Atari_InitOSKeymap;
249 device->PumpEvents = Atari_PumpEvents;
250
251 device->free = XBIOS_DeleteDevice;
252
253 return device;
254}
255
256VideoBootStrap XBIOS_bootstrap = {
257 XBIOS_VID_DRIVER_NAME, "Atari Xbios driver",
258 XBIOS_Available, XBIOS_CreateDevice
259};
260
261void SDL_XBIOS_AddMode(_THIS, int actually_add, const xbiosmode_t *modeinfo)
262{
263 int i = 0;
264
265 switch(modeinfo->depth) {
266 case 15:
267 case 16:
268 i = 1;
269 break;
270 case 24:
271 i = 2;
272 break;
273 case 32:
274 i = 3;
275 break;
276 }
277
278 if ( actually_add ) {
279 SDL_Rect saved_rect[2];
280 xbiosmode_t saved_mode[2];
281 int b, j;
282
283 /* Add the mode, sorted largest to smallest */
284 b = 0;
285 j = 0;
286 while ( (SDL_modelist[i][j]->w > modeinfo->width) ||
287 (SDL_modelist[i][j]->h > modeinfo->height) ) {
288 ++j;
289 }
290 /* Skip modes that are already in our list */
291 if ( (SDL_modelist[i][j]->w == modeinfo->width) &&
292 (SDL_modelist[i][j]->h == modeinfo->height) ) {
293 return;
294 }
295 /* Insert the new mode */
296 saved_rect[b] = *SDL_modelist[i][j];
297 SDL_memcpy(&saved_mode[b], SDL_xbiosmode[i][j], sizeof(xbiosmode_t));
298 SDL_modelist[i][j]->w = modeinfo->width;
299 SDL_modelist[i][j]->h = modeinfo->height;
300 SDL_memcpy(SDL_xbiosmode[i][j], modeinfo, sizeof(xbiosmode_t));
301 /* Everybody scoot down! */
302 if ( saved_rect[b].w && saved_rect[b].h ) {
303 for ( ++j; SDL_modelist[i][j]->w; ++j ) {
304 saved_rect[!b] = *SDL_modelist[i][j];
305 memcpy(&saved_mode[!b], SDL_xbiosmode[i][j], sizeof(xbiosmode_t));
306 *SDL_modelist[i][j] = saved_rect[b];
307 SDL_memcpy(SDL_xbiosmode[i][j], &saved_mode[b], sizeof(xbiosmode_t));
308 b = !b;
309 }
310 *SDL_modelist[i][j] = saved_rect[b];
311 SDL_memcpy(SDL_xbiosmode[i][j], &saved_mode[b], sizeof(xbiosmode_t));
312 }
313 } else {
314 ++SDL_nummodes[i];
315 }
316}
317
318static void XBIOS_ListSTModes(_THIS, int actually_add)
319{
320 SDL_XBIOS_AddMode(this, actually_add, &stmodes[0]);
321}
322
323static void XBIOS_ListTTModes(_THIS, int actually_add)
324{
325 int i;
326
327 for (i=0; i<2; i++) {
328 SDL_XBIOS_AddMode(this, actually_add, &ttmodes[i]);
329 }
330}
331
332static void XBIOS_ListFalconRgbModes(_THIS, int actually_add)
333{
334 int i;
335
336 for (i=0; i<16; i++) {
337 xbiosmode_t modeinfo;
338
339 SDL_memcpy(&modeinfo, &falconrgbmodes[i], sizeof(xbiosmode_t));
340 modeinfo.number &= ~(VGA|PAL);
341 modeinfo.number |= XBIOS_oldvmode & (VGA|PAL);
342
343 SDL_XBIOS_AddMode(this, actually_add, &modeinfo);
344 }
345}
346
347static void XBIOS_ListFalconVgaModes(_THIS, int actually_add)
348{
349 int i;
350
351 for (i=0; i<6; i++) {
352 xbiosmode_t modeinfo;
353
354 SDL_memcpy(&modeinfo, &falconvgamodes[i], sizeof(xbiosmode_t));
355 modeinfo.number &= ~(VGA|PAL);
356 modeinfo.number |= XBIOS_oldvmode & (VGA|PAL);
357
358 SDL_XBIOS_AddMode(this, actually_add, &modeinfo);
359 }
360}
361
362static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat)
363{
364 int i;
365 long cookie_blow, cookie_scpn, cookie_cnts;
366
367 /* Initialize all variables that we clean on shutdown */
368 for ( i=0; i<NUM_MODELISTS; ++i ) {
369 SDL_nummodes[i] = 0;
370 SDL_modelist[i] = NULL;
371 SDL_xbiosmode[i] = NULL;
372 }
373
374 /* Cookie _VDO present ? if not, assume ST machine */
375 if (Getcookie(C__VDO, &XBIOS_cvdo) != C_FOUND) {
376 XBIOS_cvdo = VDO_ST << 16;
377 }
378
379 /* Allocate memory for old palette */
380 XBIOS_oldpalette = (void *)SDL_malloc(256*sizeof(long));
381 if ( !XBIOS_oldpalette ) {
382 SDL_SetError("Unable to allocate memory for old palette\n");
383 return(-1);
384 }
385
386 /* Initialize video mode list */
387 /* and save current screen status (palette, screen address, video mode) */
388 XBIOS_centscreen = SDL_FALSE;
389 XBIOS_oldvbase = Physbase();
390
391 /* Determine the current screen size */
392 this->info.current_w = 0;
393 this->info.current_h = 0;
394
395 /* Determine the screen depth (use default 8-bit depth) */
396 vformat->BitsPerPixel = 8;
397
398 /* First allocate room for needed video modes */
399 switch (XBIOS_cvdo >>16) {
400 case VDO_ST:
401 case VDO_STE:
402 {
403 short *oldpalette;
404
405 XBIOS_oldvmode=Getrez();
406 switch(XBIOS_oldvmode << 8) {
407 case ST_LOW:
408 XBIOS_oldnumcol=16;
409 break;
410 case ST_MED:
411 XBIOS_oldnumcol=4;
412 break;
413 case ST_HIGH:
414 XBIOS_oldnumcol=2;
415 break;
416 }
417
418 oldpalette= (short *) XBIOS_oldpalette;
419 for (i=0;i<XBIOS_oldnumcol;i++) {
420 *oldpalette++=Setcolor(i,-1);
421 }
422
423 XBIOS_ListSTModes(this, 0);
424 }
425 break;
426 case VDO_TT:
427 XBIOS_oldvmode=EgetShift();
428
429 switch(XBIOS_oldvmode & ES_MODE) {
430 case TT_LOW:
431 XBIOS_oldnumcol=256;
432 break;
433 case ST_LOW:
434 case TT_MED:
435 XBIOS_oldnumcol=16;
436 break;
437 case ST_MED:
438 XBIOS_oldnumcol=4;
439 break;
440 case ST_HIGH:
441 case TT_HIGH:
442 XBIOS_oldnumcol=2;
443 break;
444 }
445 if (XBIOS_oldnumcol) {
446 EgetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
447 }
448
449 XBIOS_ListTTModes(this, 0);
450 break;
451 case VDO_F30:
452 XBIOS_oldvmode=VsetMode(-1);
453
454 XBIOS_oldnumcol= 1<< (1 << (XBIOS_oldvmode & NUMCOLS));
455 if (XBIOS_oldnumcol > 256) {
456 XBIOS_oldnumcol = 0;
457 }
458 if (XBIOS_oldnumcol) {
459 VgetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
460 }
461
462 vformat->BitsPerPixel = 16;
463
464 /* ScreenBlaster 3 ? */
465 if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
466 SDL_XBIOS_ListSB3Modes(this, 0, (scpn_cookie_t *)cookie_scpn);
467 } else
468 /* Centscreen ? */
469 if (Getcookie(C_CNTS, &cookie_cnts) == C_FOUND) {
470 XBIOS_oldvmode = SDL_XBIOS_ListCentscreenModes(this, 0);
471 XBIOS_centscreen = SDL_TRUE;
472 } else
473 /* Standard, with or without Blowup */
474 {
475 switch (VgetMonitor())
476 {
477 case MONITOR_RGB:
478 case MONITOR_TV:
479 XBIOS_ListFalconRgbModes(this, 0);
480 break;
481 case MONITOR_VGA:
482 XBIOS_ListFalconVgaModes(this, 0);
483 break;
484 }
485
486 if (Getcookie(C_BLOW, &cookie_blow) == C_FOUND) {
487 SDL_XBIOS_ListBlowupModes(this, 0, (blow_cookie_t *)cookie_blow);
488 }
489 }
490 break;
491 case VDO_MILAN:
492 {
493 SCREENINFO si;
494
495 /* Read infos about current mode */
496 VsetScreen(-1, &XBIOS_oldvmode, MI_MAGIC, CMD_GETMODE);
497
498 si.size = sizeof(SCREENINFO);
499 si.devID = XBIOS_oldvmode;
500 si.scrFlags = 0;
501 VsetScreen(-1, &si, MI_MAGIC, CMD_GETINFO);
502
503 this->info.current_w = si.scrWidth;
504 this->info.current_h = si.scrHeight;
505
506 XBIOS_oldnumcol = 0;
507 if (si.scrFlags & SCRINFO_OK) {
508 if (si.scrPlanes <= 8) {
509 XBIOS_oldnumcol = 1<<si.scrPlanes;
510 }
511 }
512 if (XBIOS_oldnumcol) {
513 VgetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
514 }
515
516 SDL_XBIOS_ListMilanModes(this, 0);
517 }
518 break;
519 }
520
521 for ( i=0; i<NUM_MODELISTS; ++i ) {
522 int j;
523
524 SDL_xbiosmode[i] = (xbiosmode_t **)
525 SDL_malloc((SDL_nummodes[i]+1)*sizeof(xbiosmode_t *));
526 if ( SDL_xbiosmode[i] == NULL ) {
527 SDL_OutOfMemory();
528 return(-1);
529 }
530 for ( j=0; j<SDL_nummodes[i]; ++j ) {
531 SDL_xbiosmode[i][j]=(xbiosmode_t *)SDL_malloc(sizeof(xbiosmode_t));
532 if ( SDL_xbiosmode[i][j] == NULL ) {
533 SDL_OutOfMemory();
534 return(-1);
535 }
536 SDL_memset(SDL_xbiosmode[i][j], 0, sizeof(xbiosmode_t));
537 }
538 SDL_xbiosmode[i][j] = NULL;
539
540 SDL_modelist[i] = (SDL_Rect **)
541 SDL_malloc((SDL_nummodes[i]+1)*sizeof(SDL_Rect *));
542 if ( SDL_modelist[i] == NULL ) {
543 SDL_OutOfMemory();
544 return(-1);
545 }
546 for ( j=0; j<SDL_nummodes[i]; ++j ) {
547 SDL_modelist[i][j]=(SDL_Rect *)SDL_malloc(sizeof(SDL_Rect));
548 if ( SDL_modelist[i][j] == NULL ) {
549 SDL_OutOfMemory();
550 return(-1);
551 }
552 SDL_memset(SDL_modelist[i][j], 0, sizeof(SDL_Rect));
553 }
554 SDL_modelist[i][j] = NULL;
555 }
556
557 /* Now fill the mode list */
558 switch (XBIOS_cvdo >>16) {
559 case VDO_ST:
560 case VDO_STE:
561 XBIOS_ListSTModes(this, 1);
562 break;
563 case VDO_TT:
564 XBIOS_ListTTModes(this, 1);
565 break;
566 case VDO_F30:
567 /* ScreenBlaster 3 ? */
568 if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
569 SDL_XBIOS_ListSB3Modes(this, 1, (scpn_cookie_t *)cookie_scpn);
570 } else
571 /* Centscreen ? */
572 if (Getcookie(C_CNTS, &cookie_cnts) == C_FOUND) {
573 XBIOS_oldvmode = SDL_XBIOS_ListCentscreenModes(this, 1);
574 XBIOS_centscreen = SDL_TRUE;
575 } else
576 /* Standard, with or without Blowup */
577 {
578 switch (VgetMonitor())
579 {
580 case MONITOR_RGB:
581 case MONITOR_TV:
582 XBIOS_ListFalconRgbModes(this, 1);
583 break;
584 case MONITOR_VGA:
585 XBIOS_ListFalconVgaModes(this, 1);
586 break;
587 }
588
589 if (Getcookie(C_BLOW, &cookie_blow) == C_FOUND) {
590 SDL_XBIOS_ListBlowupModes(this, 1, (blow_cookie_t *)cookie_blow);
591 }
592 }
593 break;
594 case VDO_MILAN:
595 SDL_XBIOS_ListMilanModes(this, 1);
596 break;
597 }
598
599 XBIOS_screens[0]=NULL;
600 XBIOS_screens[1]=NULL;
601 XBIOS_shadowscreen=NULL;
602
603 /* Update hardware info */
604 this->info.hw_available = 1;
605 this->info.video_mem = (Uint32) Atari_SysMalloc(-1L, MX_STRAM);
606
607 /* Init chunky to planar routine */
608 SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8;
609
610#if SDL_VIDEO_OPENGL
611 SDL_AtariGL_InitPointers(this);
612#endif
613
614 /* Disable screensavers */
615 if (SDL_XBIOS_TveillePresent(this)) {
616 SDL_XBIOS_TveilleDisable(this);
617 }
618
619 /* We're done! */
620 return(0);
621}
622
623static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
624{
625 return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]);
626}
627
628static void XBIOS_FreeBuffers(_THIS)
629{
630 int i;
631
632 for (i=0;i<2;i++) {
633 if (XBIOS_screensmem[i]!=NULL) {
634 if ((XBIOS_cvdo>>16) == VDO_MILAN) {
635 if (i==1) {
636 VsetScreen(-1, -1, MI_MAGIC, CMD_FREEPAGE);
637 }
638 } else {
639 Mfree(XBIOS_screensmem[i]);
640 }
641 XBIOS_screensmem[i]=NULL;
642 }
643 }
644
645 if (XBIOS_shadowscreen!=NULL) {
646 Mfree(XBIOS_shadowscreen);
647 XBIOS_shadowscreen=NULL;
648 }
649}
650
651static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface *current,
652 int width, int height, int bpp, Uint32 flags)
653{
654 int mode, new_depth;
655 int i, num_buffers;
656 xbiosmode_t *new_video_mode;
657 Uint32 new_screen_size;
658 Uint32 modeflags;
659
660 /* Free current buffers */
661 XBIOS_FreeBuffers(this);
662
663 /* Try to set the requested linear video mode */
664 bpp = (bpp+7)/8-1;
665 for ( mode=0; SDL_modelist[bpp][mode]; ++mode ) {
666 if ( (SDL_modelist[bpp][mode]->w == width) &&
667 (SDL_modelist[bpp][mode]->h == height) ) {
668 break;
669 }
670 }
671 if ( SDL_modelist[bpp][mode] == NULL ) {
672 SDL_SetError("Couldn't find requested mode in list");
673 return(NULL);
674 }
675 new_video_mode = SDL_xbiosmode[bpp][mode];
676
677 modeflags = SDL_FULLSCREEN | SDL_PREALLOC;
678
679 /* Allocate needed buffers: simple/double buffer and shadow surface */
680 new_depth = new_video_mode->depth;
681 if (new_depth == 4) {
682 SDL_Atari_C2pConvert = SDL_Atari_C2pConvert4;
683 new_depth=8;
684 modeflags |= SDL_SWSURFACE|SDL_HWPALETTE;
685 } else if (new_depth == 8) {
686 SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8;
687 modeflags |= SDL_SWSURFACE|SDL_HWPALETTE;
688 } else {
689 modeflags |= SDL_HWSURFACE;
690 }
691
692 new_screen_size = width * height * ((new_depth)>>3);
693 new_screen_size += 256; /* To align on a 256 byte adress */
694
695 if (new_video_mode->flags & XBIOSMODE_C2P) {
696 XBIOS_shadowscreen = Atari_SysMalloc(new_screen_size, MX_PREFTTRAM);
697
698 if (XBIOS_shadowscreen == NULL) {
699 SDL_SetError("Can not allocate %d KB for shadow buffer", new_screen_size>>10);
700 return (NULL);
701 }
702 SDL_memset(XBIOS_shadowscreen, 0, new_screen_size);
703 }
704
705 /* Output buffer needs to be twice in size for the software double-line mode */
706 if (new_video_mode->flags & XBIOSMODE_DOUBLELINE) {
707 new_screen_size <<= 1;
708 }
709
710 /* Double buffer ? */
711 num_buffers = 1;
712
713#if SDL_VIDEO_OPENGL
714 if (flags & SDL_OPENGL) {
715 if (this->gl_config.double_buffer) {
716 flags |= SDL_DOUBLEBUF;
717 }
718 }
719#endif
720 if ((flags & SDL_DOUBLEBUF) && ((XBIOS_cvdo>>16) != VDO_MILAN)) {
721 num_buffers = 2;
722 modeflags |= SDL_DOUBLEBUF;
723 }
724
725 /* Allocate buffers */
726 for (i=0; i<num_buffers; i++) {
727 if ((XBIOS_cvdo>>16) == VDO_MILAN) {
728 if (i==0) {
729 XBIOS_screensmem[i] = XBIOS_oldvbase;
730 } else {
731 VsetScreen(-1, &XBIOS_screensmem[i], MI_MAGIC, CMD_ALLOCPAGE);
732 }
733 } else {
734 XBIOS_screensmem[i] = Atari_SysMalloc(new_screen_size, MX_STRAM);
735 }
736
737 if (XBIOS_screensmem[i]==NULL) {
738 XBIOS_FreeBuffers(this);
739 SDL_SetError("Can not allocate %d KB for buffer %d", new_screen_size>>10, i);
740 return (NULL);
741 }
742 SDL_memset(XBIOS_screensmem[i], 0, new_screen_size);
743
744 XBIOS_screens[i]=(void *) (( (long) XBIOS_screensmem[i]+256) & 0xFFFFFF00UL);
745 }
746
747 /* Allocate the new pixel format for the screen */
748 if ( ! SDL_ReallocFormat(current, new_depth, 0, 0, 0, 0) ) {
749 XBIOS_FreeBuffers(this);
750 SDL_SetError("Couldn't allocate new pixel format for requested mode");
751 return(NULL);
752 }
753
754 XBIOS_current = new_video_mode;
755 current->w = width;
756 current->h = height;
757 current->pitch = (width * new_depth)>>3;
758
759 /* this is for C2P conversion */
760 XBIOS_pitch = (new_video_mode->width * new_video_mode->depth)>>3;
761
762 if (new_video_mode->flags & XBIOSMODE_C2P)
763 current->pixels = XBIOS_shadowscreen;
764 else
765 current->pixels = XBIOS_screens[0];
766
767 XBIOS_fbnum = 0;
768
769#if SDL_VIDEO_OPENGL
770 if (flags & SDL_OPENGL) {
771 if (!SDL_AtariGL_Init(this, current)) {
772 XBIOS_FreeBuffers(this);
773 SDL_SetError("Can not create OpenGL context");
774 return NULL;
775 }
776
777 modeflags |= SDL_OPENGL;
778 }
779#endif
780
781 current->flags = modeflags;
782
783#ifndef DEBUG_VIDEO_XBIOS
784 /* Now set the video mode */
785 if ((XBIOS_cvdo>>16) == VDO_MILAN) {
786 VsetScreen(-1, XBIOS_screens[0], MI_MAGIC, CMD_SETADR);
787 } else {
788 Setscreen(-1,XBIOS_screens[0],-1);
789 }
790
791 switch(XBIOS_cvdo >> 16) {
792 case VDO_ST:
793 Setscreen(-1,-1,new_video_mode->number);
794
795 /* Reset palette */
796 for (i=0;i<16;i++) {
797 TT_palette[i]= ((i>>1)<<8) | (((i*8)/17)<<4) | (i>>1);
798 }
799 Setpalette(TT_palette);
800 break;
801 case VDO_STE:
802 Setscreen(-1,-1,new_video_mode->number);
803
804 /* Reset palette */
805 for (i=0;i<16;i++)
806 {
807 int c;
808
809 c=((i&1)<<3)|((i>>1)&7);
810 TT_palette[i]=(c<<8)|(c<<4)|c;
811 }
812 Setpalette(TT_palette);
813 break;
814 case VDO_TT:
815 EsetShift(new_video_mode->number);
816 break;
817 case VDO_F30:
818 if (XBIOS_centscreen) {
819 SDL_XBIOS_CentscreenSetmode(this, width, height, new_depth);
820 } else {
821 VsetMode(new_video_mode->number);
822 }
823
824 /* Set hardware palette to black in True Colour */
825 if (new_depth > 8) {
826 SDL_memset(F30_palette, 0, sizeof(F30_palette));
827 VsetRGB(0,256,F30_palette);
828 }
829 break;
830 case VDO_MILAN:
831 VsetScreen(-1, new_video_mode->number, MI_MAGIC, CMD_SETMODE);
832
833 /* Set hardware palette to black in True Colour */
834 if (new_depth > 8) {
835 SDL_memset(F30_palette, 0, sizeof(F30_palette));
836 VsetRGB(0,256,F30_palette);
837 }
838 break;
839 }
840
841 Vsync();
842#endif
843
844 this->UpdateRects = XBIOS_UpdateRects;
845
846 return (current);
847}
848
849/* We don't actually allow hardware surfaces other than the main one */
850static int XBIOS_AllocHWSurface(_THIS, SDL_Surface *surface)
851{
852 return(-1);
853}
854
855static void XBIOS_FreeHWSurface(_THIS, SDL_Surface *surface)
856{
857 return;
858}
859
860static int XBIOS_LockHWSurface(_THIS, SDL_Surface *surface)
861{
862 return(0);
863}
864
865static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface *surface)
866{
867 return;
868}
869
870static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect *rects)
871{
872 SDL_Surface *surface;
873
874 surface = this->screen;
875
876 if (XBIOS_current->flags & XBIOSMODE_C2P) {
877 int i;
878 int doubleline = (XBIOS_current->flags & XBIOSMODE_DOUBLELINE ? 1 : 0);
879
880 for (i=0;i<numrects;i++) {
881 void *source,*destination;
882 int x1,x2;
883
884 x1 = rects[i].x & ~15;
885 x2 = rects[i].x+rects[i].w;
886 if (x2 & 15) {
887 x2 = (x2 | 15) +1;
888 }
889
890 source = surface->pixels;
891 source += surface->pitch * rects[i].y;
892 source += x1;
893
894 destination = XBIOS_screens[XBIOS_fbnum];
895 destination += XBIOS_pitch * rects[i].y;
896 destination += x1;
897
898 /* Convert chunky to planar screen */
899 SDL_Atari_C2pConvert(
900 source,
901 destination,
902 x2-x1,
903 rects[i].h,
904 doubleline,
905 surface->pitch,
906 XBIOS_pitch
907 );
908 }
909 }
910
911#ifndef DEBUG_VIDEO_XBIOS
912 if ((XBIOS_cvdo>>16) == VDO_MILAN) {
913 VsetScreen(-1, XBIOS_screens[XBIOS_fbnum], MI_MAGIC, CMD_SETADR);
914 } else {
915 Setscreen(-1,XBIOS_screens[XBIOS_fbnum],-1);
916 }
917
918 Vsync();
919#endif
920
921 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
922 XBIOS_fbnum ^= 1;
923 if ((XBIOS_current->flags & XBIOSMODE_C2P) == 0) {
924 surface->pixels=XBIOS_screens[XBIOS_fbnum];
925 }
926 }
927}
928
929static int XBIOS_FlipHWSurface(_THIS, SDL_Surface *surface)
930{
931 if (XBIOS_current->flags & XBIOSMODE_C2P) {
932 void *destscr;
933 int destx;
934 int doubleline = (XBIOS_current->flags & XBIOSMODE_DOUBLELINE ? 1 : 0);
935
936 /* Center on destination screen */
937 destscr = XBIOS_screens[XBIOS_fbnum];
938 destscr += XBIOS_pitch * ((XBIOS_current->height - surface->h) >> 1);
939 destx = (XBIOS_current->width - surface->w) >> 1;
940 destx &= ~15;
941 destscr += destx;
942
943 /* Convert chunky to planar screen */
944 SDL_Atari_C2pConvert(
945 surface->pixels,
946 destscr,
947 surface->w,
948 surface->h,
949 doubleline,
950 surface->pitch,
951 XBIOS_pitch
952 );
953 }
954
955#ifndef DEBUG_VIDEO_XBIOS
956 if ((XBIOS_cvdo>>16) == VDO_MILAN) {
957 VsetScreen(-1, XBIOS_screens[XBIOS_fbnum], MI_MAGIC, CMD_SETADR);
958 } else {
959 Setscreen(-1,XBIOS_screens[XBIOS_fbnum],-1);
960 }
961
962 Vsync();
963#endif
964
965 if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
966 XBIOS_fbnum ^= 1;
967 if ((XBIOS_current->flags & XBIOSMODE_C2P) == 0) {
968 surface->pixels=XBIOS_screens[XBIOS_fbnum];
969 }
970 }
971
972 return(0);
973}
974
975static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
976{
977#ifndef DEBUG_VIDEO_XBIOS
978 int i;
979 int r,v,b;
980
981 switch( XBIOS_cvdo >> 16) {
982 case VDO_ST:
983 case VDO_STE:
984 for (i=0;i<ncolors;i++)
985 {
986 r = colors[i].r;
987 v = colors[i].g;
988 b = colors[i].b;
989
990 TT_palette[firstcolor+i]=((r*30)+(v*59)+(b*11))/100;
991 }
992 SDL_Atari_C2pConvert4_pal(TT_palette); /* convert the lighting */
993 break;
994 case VDO_TT:
995 for(i = 0; i < ncolors; i++)
996 {
997 r = colors[i].r;
998 v = colors[i].g;
999 b = colors[i].b;
1000
1001 TT_palette[i]=((r>>4)<<8)|((v>>4)<<4)|(b>>4);
1002 }
1003 EsetPalette(firstcolor,ncolors,TT_palette);
1004 break;
1005 case VDO_F30:
1006 case VDO_MILAN:
1007 for(i = 0; i < ncolors; i++)
1008 {
1009 r = colors[i].r;
1010 v = colors[i].g;
1011 b = colors[i].b;
1012
1013 F30_palette[i]=(r<<16)|(v<<8)|b;
1014 }
1015 VsetRGB(firstcolor,ncolors,F30_palette);
1016 break;
1017 }
1018#endif
1019
1020 return(1);
1021}
1022
1023/* Note: If we are terminated, this could be called in the middle of
1024 another SDL video routine -- notably UpdateRects.
1025*/
1026static void XBIOS_VideoQuit(_THIS)
1027{
1028 int i,j;
1029
1030 Atari_ShutdownEvents();
1031
1032 /* Restore video mode and palette */
1033#ifndef DEBUG_VIDEO_XBIOS
1034 switch(XBIOS_cvdo >> 16) {
1035 case VDO_ST:
1036 case VDO_STE:
1037 Setscreen(-1,XBIOS_oldvbase,XBIOS_oldvmode);
1038 if (XBIOS_oldnumcol) {
1039 Setpalette(XBIOS_oldpalette);
1040 }
1041 break;
1042 case VDO_TT:
1043 Setscreen(-1,XBIOS_oldvbase,-1);
1044 EsetShift(XBIOS_oldvmode);
1045 if (XBIOS_oldnumcol) {
1046 EsetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
1047 }
1048 break;
1049 case VDO_F30:
1050 Setscreen(-1, XBIOS_oldvbase, -1);
1051 if (XBIOS_centscreen) {
1052 SDL_XBIOS_CentscreenRestore(this, XBIOS_oldvmode);
1053 } else {
1054 VsetMode(XBIOS_oldvmode);
1055 }
1056 if (XBIOS_oldnumcol) {
1057 VsetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
1058 }
1059 break;
1060 case VDO_MILAN:
1061 VsetScreen(-1, &XBIOS_oldvbase, MI_MAGIC, CMD_SETADR);
1062 VsetScreen(-1, &XBIOS_oldvmode, MI_MAGIC, CMD_SETMODE);
1063 if (XBIOS_oldnumcol) {
1064 VsetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
1065 }
1066 break;
1067 }
1068 Vsync();
1069#endif
1070
1071#if SDL_VIDEO_OPENGL
1072 if (gl_active) {
1073 SDL_AtariGL_Quit(this, SDL_TRUE);
1074 }
1075#endif
1076
1077 if (XBIOS_oldpalette) {
1078 SDL_free(XBIOS_oldpalette);
1079 XBIOS_oldpalette=NULL;
1080 }
1081 XBIOS_FreeBuffers(this);
1082
1083 /* Free mode list */
1084 for ( i=0; i<NUM_MODELISTS; ++i ) {
1085 if ( SDL_modelist[i] != NULL ) {
1086 for ( j=0; SDL_modelist[i][j]; ++j )
1087 SDL_free(SDL_modelist[i][j]);
1088 SDL_free(SDL_modelist[i]);
1089 SDL_modelist[i] = NULL;
1090 }
1091 if ( SDL_xbiosmode[i] != NULL ) {
1092 for ( j=0; SDL_xbiosmode[i][j]; ++j )
1093 SDL_free(SDL_xbiosmode[i][j]);
1094 SDL_free(SDL_xbiosmode[i]);
1095 SDL_xbiosmode[i] = NULL;
1096 }
1097 }
1098
1099 this->screen->pixels = NULL;
1100
1101 /* Restore screensavers */
1102 if (SDL_XBIOS_TveillePresent(this)) {
1103 SDL_XBIOS_TveilleEnable(this);
1104 }
1105}
1106
1107#if SDL_VIDEO_OPENGL
1108
1109static void XBIOS_GL_SwapBuffers(_THIS)
1110{
1111 SDL_AtariGL_SwapBuffers(this);
1112 XBIOS_FlipHWSurface(this, this->screen);
1113 SDL_AtariGL_MakeCurrent(this);
1114}
1115
1116#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-30 19:35:50 +0000