Skip to content

L
libSDL
Commit d5cf1663 authored by Patrice Mandin's avatar Patrice Mandin
Browse files
Options

xbios: preliminary video mode init 

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402232
parent a39f5c21
Show whitespace changes
Inline Side-by-side
Showing with 190 additions and 844 deletions
src/video/xbios/SDL_xbios.c
View file @ d5cf1663
......@@ -46,9 +46,7 @@
#include "../ataricommon/SDL_atarimxalloc_c.h"
#include "../ataricommon/SDL_atarigl_c.h"
#include "SDL_xbios.h"
#include "SDL_xbios_blowup.h"
#include "SDL_xbios_centscreen.h"
#include "SDL_xbios_sb3.h"
#include "SDL_xbiosmodes.h"
/* Debug print info */
#if 0
......@@ -66,34 +64,6 @@
static int XBIOS_VideoInit(_THIS);
static void XBIOS_VideoQuit(_THIS);
#if 0
static SDL_Rect **XBIOS_ListModes(_THIS, SDL_PixelFormat * format,
Uint32 flags);
static SDL_Surface *XBIOS_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp,
Uint32 flags);
static int XBIOS_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color * colors);
/* Hardware surface functions */
static int XBIOS_AllocHWSurface(_THIS, SDL_Surface * surface);
static int XBIOS_LockHWSurface(_THIS, SDL_Surface * surface);
static int XBIOS_FlipHWSurface(_THIS, SDL_Surface * surface);
static void XBIOS_UnlockHWSurface(_THIS, SDL_Surface * surface);
static void XBIOS_FreeHWSurface(_THIS, SDL_Surface * surface);
static void XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect * rects);
#if SDL_VIDEO_OPENGL
/* OpenGL functions */
static void XBIOS_GL_SwapBuffers(_THIS);
#endif
/* To setup palette */
static unsigned short TT_palette[256];
static unsigned long F30_palette[256];
#endif
/* Xbios driver bootstrap functions */
static int
......@@ -126,11 +96,11 @@ XBIOS_Available(void)
case VDO_F30:
if (VgetMonitor() == MONITOR_MONO)
return 0;
if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
/*if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
if (!SDL_XBIOS_SB3Usable((scpn_cookie_t *) cookie_scpn)) {
return 0;
}
}
}*/
break;
default:
return 0;
......@@ -171,8 +141,8 @@ XBIOS_CreateDevice(int devindex)
device->VideoQuit = XBIOS_VideoQuit;
/* Modes */
device->GetDisplayModes = NULL /*XBIOS_GetDisplayModes */ ;
device->SetDisplayMode = NULL /*XBIOS_SetDisplayMode */ ;
device->GetDisplayModes = SDL_XBIOS_GetDisplayModes;
device->SetDisplayMode = SDL_XBIOS_SetDisplayMode;
/* Events */
device->PumpEvents = SDL_Atari_PumpEvents;
......@@ -199,294 +169,13 @@ VideoBootStrap XBIOS_bootstrap = {
XBIOS_Available, XBIOS_CreateDevice
};
#if 0
void
SDL_XBIOS_AddMode(_THIS, Uint16 modecode, Uint16 width, Uint16 height,
Uint16 depth, SDL_bool flags)
{
int i, curpos;
xbiosmode_t *current_mode;
/* Check if mode already exists */
if (XBIOS_modelist) {
current_mode = XBIOS_modelist;
for (i = 0; i < XBIOS_nummodes; i++, current_mode++) {
if (current_mode->width != width)
continue;
if (current_mode->height != height)
continue;
if (current_mode->depth != depth)
continue;
return;
}
}
++XBIOS_nummodes;
XBIOS_modelist =
(xbiosmode_t *) SDL_realloc(XBIOS_modelist,
XBIOS_nummodes * sizeof(xbiosmode_t));
/* Keep the list sorted: bpp, width, height */
curpos = 0;
for (i = 0; i < XBIOS_nummodes - 1; i++) {
if (XBIOS_modelist[i].depth <= depth) {
if (XBIOS_modelist[i].width < width) {
break;
} else if (XBIOS_modelist[i].width == width) {
if (XBIOS_modelist[i].height <= height) {
break;
}
}
}
curpos++;
}
/* Push remaining modes further */
for (i = XBIOS_nummodes - 1; i > curpos; i--) {
SDL_memcpy(&XBIOS_modelist[i], &XBIOS_modelist[i - 1],
sizeof(xbiosmode_t));
}
XBIOS_modelist[curpos].number = modecode;
XBIOS_modelist[curpos].width = width;
XBIOS_modelist[curpos].height = height;
XBIOS_modelist[curpos].depth = depth;
XBIOS_modelist[curpos].doubleline = flags;
}
#endif
static int
XBIOS_VideoInit(_THIS)
{
XBIOS_InitModes(_this);
#if 0
int i, j8, j16;
xbiosmode_t *current_mode;
unsigned long cookie_blow, cookie_scpn, cookie_cnts;
/* Initialize all variables that we clean on shutdown */
memset(SDL_modelist, 0, sizeof(SDL_modelist));
/* Cookie _VDO present ? if not, assume ST machine */
if (Getcookie(C__VDO, &XBIOS_cvdo) != C_FOUND) {
XBIOS_cvdo = VDO_ST << 16;
}
/* Allocate memory for old palette */
XBIOS_oldpalette = (void *) SDL_malloc(256 * sizeof(long));
if (!XBIOS_oldpalette) {
SDL_SetError("Unable to allocate memory for old palette\n");
return (-1);
}
/* Initialize video mode list */
/* and save current screen status (palette, screen address, video mode) */
XBIOS_nummodes = 0;
XBIOS_modelist = NULL;
XBIOS_centscreen = SDL_FALSE;
switch (XBIOS_cvdo >> 16) {
case VDO_ST:
case VDO_STE:
{
short *oldpalette;
SDL_XBIOS_AddMode(this, ST_LOW >> 8, 320, 200, 4, SDL_FALSE);
XBIOS_oldvbase = Physbase();
XBIOS_oldvmode = Getrez();
switch (XBIOS_oldvmode << 8) {
case ST_LOW:
XBIOS_oldnumcol = 16;
break;
case ST_MED:
XBIOS_oldnumcol = 4;
break;
case ST_HIGH:
XBIOS_oldnumcol = 2;
break;
default:
XBIOS_oldnumcol = 0;
break;
}
oldpalette = (short *) XBIOS_oldpalette;
for (i = 0; i < XBIOS_oldnumcol; i++) {
*oldpalette++ = Setcolor(i, -1);
}
vformat->BitsPerPixel = 8;
}
break;
case VDO_TT:
SDL_XBIOS_AddMode(this, TT_LOW, 320, 480, 8, SDL_FALSE);
/* Software double-lined mode */
SDL_XBIOS_AddMode(this, TT_LOW, 320, 240, 8, SDL_TRUE);
XBIOS_oldvbase = Logbase();
XBIOS_oldvmode = EgetShift();
switch (XBIOS_oldvmode & ES_MODE) {
case TT_LOW:
XBIOS_oldnumcol = 256;
break;
case ST_LOW:
case TT_MED:
XBIOS_oldnumcol = 16;
break;
case ST_MED:
XBIOS_oldnumcol = 4;
break;
case ST_HIGH:
case TT_HIGH:
XBIOS_oldnumcol = 2;
break;
default:
XBIOS_oldnumcol = 0;
break;
}
if (XBIOS_oldnumcol) {
EgetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
}
vformat->BitsPerPixel = 8;
break;
case VDO_F30:
switch (VgetMonitor()) {
case MONITOR_MONO:
/* Not usable */
break;
case MONITOR_RGB:
case MONITOR_TV:
SDL_XBIOS_AddMode(this, BPS16 | COL80 | OVERSCAN | VERTFLAG,
768, 480, 16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | COL80 | OVERSCAN, 768, 240,
16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | COL80 | VERTFLAG, 640, 400,
16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | COL80, 640, 200, 16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | OVERSCAN | VERTFLAG, 384,
480, 16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | OVERSCAN, 384, 240, 16,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | VERTFLAG, 320, 400, 16,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16, 320, 200, 16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80 | OVERSCAN | VERTFLAG,
768, 480, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80 | OVERSCAN, 768, 240, 8,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80 | VERTFLAG, 640, 400, 8,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80, 640, 200, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | OVERSCAN | VERTFLAG, 384, 480,
8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | OVERSCAN, 384, 240, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | VERTFLAG, 320, 400, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8, 320, 200, 8, SDL_FALSE);
break;
case MONITOR_VGA:
SDL_XBIOS_AddMode(this, BPS16, 320, 480, 16, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS16 | VERTFLAG, 320, 240, 16,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80, 640, 480, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | COL80 | VERTFLAG, 640, 240, 8,
SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8, 320, 480, 8, SDL_FALSE);
SDL_XBIOS_AddMode(this, BPS8 | VERTFLAG, 320, 240, 8, SDL_FALSE);
break;
}
XBIOS_oldvbase = Logbase();
XBIOS_oldvmode = VsetMode(-1);
XBIOS_oldnumcol = 1 << (1 << (XBIOS_oldvmode & NUMCOLS));
if (XBIOS_oldnumcol > 256) {
XBIOS_oldnumcol = 0;
}
if (XBIOS_oldnumcol) {
VgetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
}
vformat->BitsPerPixel = 16;
/* Keep vga/rvb, and pal/ntsc bits */
current_mode = XBIOS_modelist;
for (i = 0; i < XBIOS_nummodes; i++) {
Uint16 newvmode;
newvmode = current_mode->number;
newvmode &= ~(VGA | PAL);
newvmode |= XBIOS_oldvmode & (VGA | PAL);
current_mode->number = newvmode;
current_mode++;
}
/* Initialize BlowUp/SB3/Centscreen stuff if present */
if (Getcookie(C_BLOW, &cookie_blow) == C_FOUND) {
SDL_XBIOS_BlowupInit(this, (blow_cookie_t *) cookie_blow);
} else if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {
SDL_XBIOS_SB3Init(this, (scpn_cookie_t *) cookie_scpn);
} else if (Getcookie(C_CNTS, &cookie_cnts) == C_FOUND) {
XBIOS_oldvmode = SDL_XBIOS_CentscreenInit(this);
XBIOS_centscreen = SDL_TRUE;
}
break;
}
/* Determine the current screen size */
if (XBIOS_nummodes > 0) {
/* FIXME: parse video mode list to search for current mode */
this->info.current_w = XBIOS_modelist[0].width;
this->info.current_h = XBIOS_modelist[0].height;
}
current_mode = XBIOS_modelist;
j8 = j16 = 0;
for (i = 0; i < XBIOS_nummodes; i++, current_mode++) {
switch (current_mode->depth) {
case 4:
case 8:
SDL_modelist[0][j8] = SDL_malloc(sizeof(SDL_Rect));
SDL_modelist[0][j8]->x = SDL_modelist[0][j8]->y = 0;
SDL_modelist[0][j8]->w = current_mode->width;
SDL_modelist[0][j8]->h = current_mode->height;
XBIOS_videomodes[0][j8] = current_mode;
j8++;
break;
case 16:
SDL_modelist[1][j16] = SDL_malloc(sizeof(SDL_Rect));
SDL_modelist[1][j16]->x = SDL_modelist[1][j16]->y = 0;
SDL_modelist[1][j16]->w = current_mode->width;
SDL_modelist[1][j16]->h = current_mode->height;
XBIOS_videomodes[1][j16] = current_mode;
j16++;
break;
}
}
SDL_modelist[0][j8] = NULL;
SDL_modelist[1][j16] = NULL;
/* Save screensaver settings */
XBIOS_screens[0] = NULL;
XBIOS_screens[1] = NULL;
XBIOS_shadowscreen = NULL;
/* Update hardware info */
this->info.hw_available = 1;
this->info.video_mem = (Uint32) Atari_SysMalloc(-1L, MX_STRAM);
/* Init chunky to planar routine */
SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8;
#if SDL_VIDEO_OPENGL
SDL_AtariGL_InitPointers(this);
#endif
#endif
/* Init video mode list */
SDL_XBIOS_InitModes(_this);
return (0);
}
......@@ -494,487 +183,9 @@ XBIOS_VideoInit(_THIS)
static void
XBIOS_VideoQuit(_THIS)
{
/* int i, j;*/
XBIOS_QuitModes(_this);
Atari_ShutdownEvents();
#if 0
/* Restore video mode and palette */
#ifndef DEBUG_VIDEO_XBIOS
switch (XBIOS_cvdo >> 16) {
case VDO_ST:
case VDO_STE:
Setscreen(-1, XBIOS_oldvbase, XBIOS_oldvmode);
if (XBIOS_oldnumcol) {
Setpalette(XBIOS_oldpalette);
}
break;
case VDO_TT:
Setscreen(-1, XBIOS_oldvbase, -1);
EsetShift(XBIOS_oldvmode);
if (XBIOS_oldnumcol) {
EsetPalette(0, XBIOS_oldnumcol, XBIOS_oldpalette);
}
break;
case VDO_F30:
Setscreen(-1, XBIOS_oldvbase, -1);
if (XBIOS_centscreen) {
SDL_XBIOS_CentscreenRestore(this, XBIOS_oldvmode);
} else {
VsetMode(XBIOS_oldvmode);
}
if (XBIOS_oldnumcol) {
VsetRGB(0, XBIOS_oldnumcol, XBIOS_oldpalette);
}
break;
}
Vsync();
#endif
#if SDL_VIDEO_OPENGL
if (gl_active) {
SDL_AtariGL_Quit(this, SDL_TRUE);
}
#endif
if (XBIOS_oldpalette) {
SDL_free(XBIOS_oldpalette);
XBIOS_oldpalette = NULL;
}
XBIOS_FreeBuffers(this);
/* Free mode list */
for (j = 0; j < NUM_MODELISTS; j++) {
for (i = 0; i < SDL_NUMMODES; i++) {
if (SDL_modelist[j][i] != NULL) {
SDL_free(SDL_modelist[j][i]);
SDL_modelist[j][i] = NULL;
}
}
}
if (XBIOS_modelist) {
SDL_free(XBIOS_modelist);
XBIOS_nummodes = 0;
XBIOS_modelist = NULL;
}
this->screen->pixels = NULL;
#endif
}
#if 0
static SDL_Rect **
XBIOS_ListModes(_THIS, SDL_PixelFormat * format, Uint32 flags)
{
/* 8 bits -> list 0 */
/* 16 bits -> list 1 */
if ((format->BitsPerPixel != 8) && (format->BitsPerPixel != 16)) {
return NULL;
}
return (SDL_modelist[(format->BitsPerPixel) >> 4]);
}
static void
XBIOS_FreeBuffers(_THIS)
{
int i;
for (i = 0; i < 2; i++) {
if (XBIOS_screensmem[i] != NULL) {
Mfree(XBIOS_screensmem[i]);
XBIOS_screensmem[i] = NULL;
}
}
if (XBIOS_shadowscreen != NULL) {
Mfree(XBIOS_shadowscreen);
XBIOS_shadowscreen = NULL;
}
}
static SDL_Surface *
XBIOS_SetVideoMode(_THIS, SDL_Surface * current,
int width, int height, int bpp, Uint32 flags)
{
int mode, new_depth;
int i;
xbiosmode_t *new_video_mode;
Uint32 new_screen_size;
Uint32 modeflags;
/* Free current buffers */
XBIOS_FreeBuffers(this);
/* Limit bpp */
if (bpp > 16) {
bpp = 16;
}
bpp >>= 4;
/* Search if the mode exists (width, height, bpp) */
for (mode = 0; SDL_modelist[bpp][mode]; ++mode) {
if ((SDL_modelist[bpp][mode]->w == width) &&
(SDL_modelist[bpp][mode]->h == height)) {
break;
}
}
if (SDL_modelist[bpp][mode] == NULL) {
SDL_SetError("Couldn't find requested mode in list");
return (NULL);
}
modeflags = SDL_FULLSCREEN | SDL_PREALLOC;
/* Allocate needed buffers: simple/double buffer and shadow surface */
new_video_mode = XBIOS_videomodes[bpp][mode];
new_depth = new_video_mode->depth;
if (new_depth == 4) {
SDL_Atari_C2pConvert = SDL_Atari_C2pConvert4;
new_depth = 8;
modeflags |= SDL_SWSURFACE | SDL_HWPALETTE;
} else if (new_depth == 8) {
SDL_Atari_C2pConvert = SDL_Atari_C2pConvert8;
modeflags |= SDL_SWSURFACE | SDL_HWPALETTE;
} else {
modeflags |= SDL_HWSURFACE;
}
new_screen_size = width * height * ((new_depth) >> 3);
new_screen_size += 256; /* To align on a 256 byte adress */
if (new_depth == 8) {
XBIOS_shadowscreen = Atari_SysMalloc(new_screen_size, MX_PREFTTRAM);
if (XBIOS_shadowscreen == NULL) {
SDL_SetError("Can not allocate %d KB for shadow buffer",
new_screen_size >> 10);
return (NULL);
}
SDL_memset(XBIOS_shadowscreen, 0, new_screen_size);
}
/* Output buffer needs to be twice in size for the software double-line mode */
XBIOS_doubleline = SDL_FALSE;
if (new_video_mode->doubleline) {
new_screen_size <<= 1;
XBIOS_doubleline = SDL_TRUE;
}
XBIOS_screensmem[0] = Atari_SysMalloc(new_screen_size, MX_STRAM);
if (XBIOS_screensmem[0] == NULL) {
XBIOS_FreeBuffers(this);
SDL_SetError("Can not allocate %d KB for frame buffer",
new_screen_size >> 10);
return (NULL);
}
SDL_memset(XBIOS_screensmem[0], 0, new_screen_size);
XBIOS_screens[0] =
(void *) (((long) XBIOS_screensmem[0] + 256) & 0xFFFFFF00UL);
#if SDL_VIDEO_OPENGL
if (flags & SDL_INTERNALOPENGL) {
if (this->gl_config.double_buffer) {
flags |= SDL_DOUBLEBUF;
}
}
#endif
/* Double buffer ? */
if (flags & SDL_DOUBLEBUF) {
XBIOS_screensmem[1] = Atari_SysMalloc(new_screen_size, MX_STRAM);
if (XBIOS_screensmem[1] == NULL) {
XBIOS_FreeBuffers(this);
SDL_SetError("Can not allocate %d KB for double buffer",
new_screen_size >> 10);
return (NULL);
}
SDL_memset(XBIOS_screensmem[1], 0, new_screen_size);
XBIOS_screens[1] =
(void *) (((long) XBIOS_screensmem[1] + 256) & 0xFFFFFF00UL);
modeflags |= SDL_DOUBLEBUF;
}
/* Allocate the new pixel format for the screen */
if (!SDL_ReallocFormat(current, new_depth, 0, 0, 0, 0)) {
XBIOS_FreeBuffers(this);
SDL_SetError("Couldn't allocate new pixel format for requested mode");
return (NULL);
}
current->w = XBIOS_width = width;
current->h = XBIOS_height = height;
current->pitch = (width * new_depth) >> 3;
/* this is for C2P conversion */
XBIOS_pitch = (new_video_mode->width * new_video_mode->depth) >> 3;
if (new_depth == 8)
current->pixels = XBIOS_shadowscreen;
else
current->pixels = XBIOS_screens[0];
XBIOS_fbnum = 0;
#if SDL_VIDEO_OPENGL
if (flags & SDL_INTERNALOPENGL) {
if (!SDL_AtariGL_Init(this, current)) {
XBIOS_FreeBuffers(this);
SDL_SetError("Can not create OpenGL context");
return NULL;
}
modeflags |= SDL_INTERNALOPENGL;
}
#endif
current->flags = modeflags;
/* Now set the video mode */
#ifndef DEBUG_VIDEO_XBIOS
Setscreen(-1, XBIOS_screens[0], -1);
#endif
switch (XBIOS_cvdo >> 16) {
case VDO_ST:
#ifndef DEBUG_VIDEO_XBIOS
Setscreen(-1, -1, new_video_mode->number);
#endif
/* Reset palette */
for (i = 0; i < 16; i++) {
TT_palette[i] =
((i >> 1) << 8) | (((i * 8) / 17) << 4) | (i >> 1);
}
#ifndef DEBUG_VIDEO_XBIOS
Setpalette(TT_palette);
#endif
break;
case VDO_STE:
#ifndef DEBUG_VIDEO_XBIOS
Setscreen(-1, -1, new_video_mode->number);
#endif
/* Reset palette */
for (i = 0; i < 16; i++) {
int c;
c = ((i & 1) << 3) | ((i >> 1) & 7);
TT_palette[i] = (c << 8) | (c << 4) | c;
}
#ifndef DEBUG_VIDEO_XBIOS
Setpalette(TT_palette);
#endif
break;
case VDO_TT:
#ifndef DEBUG_VIDEO_XBIOS
EsetShift(new_video_mode->number);
#endif
break;
case VDO_F30:
#ifndef DEBUG_VIDEO_XBIOS
if (XBIOS_centscreen) {
SDL_XBIOS_CentscreenSetmode(this, width, height, new_depth);
} else {
VsetMode(new_video_mode->number);
}
#endif
/* Set hardware palette to black in True Colour */
if (new_depth == 16) {
SDL_memset(F30_palette, 0, sizeof(F30_palette));
VsetRGB(0, 256, F30_palette);
}
break;
}
Vsync();
this->UpdateRects = XBIOS_UpdateRects;
return (current);
}
/* We don't actually allow hardware surfaces other than the main one */
static int
XBIOS_AllocHWSurface(_THIS, SDL_Surface * surface)
{
return (-1);
}
static void
XBIOS_FreeHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static int
XBIOS_LockHWSurface(_THIS, SDL_Surface * surface)
{
return (0);
}
static void
XBIOS_UnlockHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
static void
XBIOS_UpdateRects(_THIS, int numrects, SDL_Rect * rects)
{
SDL_Surface *surface;
surface = this->screen;
if ((surface->format->BitsPerPixel) == 8) {
int i;
for (i = 0; i < numrects; i++) {
void *source, *destination;
int x1, x2;
x1 = rects[i].x & ~15;
x2 = rects[i].x + rects[i].w;
if (x2 & 15) {
x2 = (x2 | 15) + 1;
}
source = surface->pixels;
source += surface->pitch * rects[i].y;
source += x1;
destination = XBIOS_screens[XBIOS_fbnum];
destination += XBIOS_pitch * rects[i].y;
destination += x1;
/* Convert chunky to planar screen */
SDL_Atari_C2pConvert(source,
destination,
x2 - x1,
rects[i].h,
XBIOS_doubleline,
surface->pitch, XBIOS_pitch);
}
}
#ifndef DEBUG_VIDEO_XBIOS
Setscreen(-1, XBIOS_screens[XBIOS_fbnum], -1);
#endif
Vsync();
if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
XBIOS_fbnum ^= 1;
if ((surface->format->BitsPerPixel) > 8) {
surface->pixels = XBIOS_screens[XBIOS_fbnum];
}
}
}
static int
XBIOS_FlipHWSurface(_THIS, SDL_Surface * surface)
{
if ((surface->format->BitsPerPixel) == 8) {
void *destscr;
int destx;
/* Center on destination screen */
destscr = XBIOS_screens[XBIOS_fbnum];
destscr += XBIOS_pitch * ((XBIOS_height - surface->h) >> 1);
destx = (XBIOS_width - surface->w) >> 1;
destx &= ~15;
destscr += destx;
/* Convert chunky to planar screen */
SDL_Atari_C2pConvert(surface->pixels,
destscr,
surface->w,
surface->h,
XBIOS_doubleline, surface->pitch, XBIOS_pitch);
}
#ifndef DEBUG_VIDEO_XBIOS
Setscreen(-1, XBIOS_screens[XBIOS_fbnum], -1);
#endif
Vsync();
if ((surface->flags & SDL_DOUBLEBUF) == SDL_DOUBLEBUF) {
XBIOS_fbnum ^= 1;
if ((surface->format->BitsPerPixel) > 8) {
surface->pixels = XBIOS_screens[XBIOS_fbnum];
}
}
return (0);
}
static int
XBIOS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
int i;
int r, v, b;
switch (XBIOS_cvdo >> 16) {
case VDO_ST:
case VDO_STE:
for (i = 0; i < ncolors; i++) {
r = colors[i].r;
v = colors[i].g;
b = colors[i].b;
TT_palette[firstcolor + i] =
((r * 30) + (v * 59) + (b * 11)) / 100;
}
SDL_Atari_C2pConvert4_pal(TT_palette); /* convert the lighting */
break;
case VDO_TT:
for (i = 0; i < ncolors; i++) {
r = colors[i].r;
v = colors[i].g;
b = colors[i].b;
TT_palette[i] = ((r >> 4) << 8) | ((v >> 4) << 4) | (b >> 4);
}
#ifndef DEBUG_VIDEO_XBIOS
EsetPalette(firstcolor, ncolors, TT_palette);
#endif
break;
case VDO_F30:
for (i = 0; i < ncolors; i++) {
r = colors[i].r;
v = colors[i].g;
b = colors[i].b;
/* Restore screensaver settings */
F30_palette[i] = (r << 16) | (v << 8) | b;
}
#ifndef DEBUG_VIDEO_XBIOS
VsetRGB(firstcolor, ncolors, F30_palette);
#endif
break;
}
return (1);
}
#endif
/* Note: If we are terminated, this could be called in the middle of
another SDL video routine -- notably UpdateRects.
*/
#if 0
#if SDL_VIDEO_OPENGL
static void
XBIOS_GL_SwapBuffers(_THIS)
{
SDL_AtariGL_SwapBuffers(this);
XBIOS_FlipHWSurface(this, this->screen);
SDL_AtariGL_MakeCurrent(this);
SDL_XBIOS_QuitModes(_this);
}
#endif
#endif
/* vi: set ts=4 sw=4 expandtab: */
src/video/xbios/SDL_xbios.h
View file @ d5cf1663
......@@ -27,28 +27,11 @@
#include "SDL_stdinc.h"
#include "../SDL_sysvideo.h"
/* TT video modes: 2
Falcon RVB: 16 (could be *2 by adding PAL/NTSC modes)
Falcon VGA: 6
ST low: 1
*/
#define SDL_NUMMODES 16
typedef struct
{
Uint16 number; /* Video mode number */
Uint16 width; /* Size */
Uint16 height;
Uint16 depth; /* bits per plane */
SDL_bool doubleline; /* Double the lines ? */
} xbiosmode_t;
/* Private display data */
#define NUM_MODELISTS 2 /* 8 and 16 bits-per-pixel */
typedef struct SDL_VideoData
{
long cookie_vdo;
#if 0
int old_video_mode; /* Old video mode before entering SDL */
void *old_video_base; /* Old pointer to screen buffer */
void *old_palette; /* Old palette */
......@@ -68,6 +51,7 @@ typedef struct SDL_VideoData
SDL_Rect *SDL_modelist[NUM_MODELISTS][SDL_NUMMODES + 1];
xbiosmode_t *videomodes[NUM_MODELISTS][SDL_NUMMODES + 1];
#endif
} SDL_VideoData;
/* _VDO cookie values */
......@@ -102,31 +86,5 @@ enum
#define TT_MED 0x0300
#define TT_HIGH 0x0600
/* Hidden structure -> variables names */
#define SDL_modelist (_this->driverdata->SDL_modelist)
#define XBIOS_mutex (_this->driverdata->mutex)
#define XBIOS_cvdo (_this->driverdata->cookie_vdo)
#define XBIOS_oldpalette (_this->driverdata->old_palette)
#define XBIOS_oldnumcol (_this->driverdata->old_num_colors)
#define XBIOS_oldvbase (_this->driverdata->old_video_base)
#define XBIOS_oldvmode (_this->driverdata->old_video_mode)
#define XBIOS_nummodes (_this->driverdata->num_modes)
#define XBIOS_modelist (_this->driverdata->mode_list)
#define XBIOS_screens (_this->driverdata->screens)
#define XBIOS_screensmem (_this->driverdata->screensmem)
#define XBIOS_shadowscreen (_this->driverdata->shadowscreen)
#define XBIOS_videomodes (_this->driverdata->videomodes)
#define XBIOS_doubleline (_this->driverdata->doubleline)
#define XBIOS_fbnum (_this->driverdata->frame_number)
#define XBIOS_pitch (_this->driverdata->pitch)
#define XBIOS_width (_this->driverdata->width)
#define XBIOS_height (_this->driverdata->height)
#define XBIOS_centscreen (_this->driverdata->centscreen)
/*--- Functions prototypes ---*/
void SDL_XBIOS_AddMode(_THIS, Uint16 modecode, Uint16 width, Uint16 height,
Uint16 depth, SDL_bool flags);
#endif /* _SDL_xbios_h */
/* vi: set ts=4 sw=4 expandtab: */
src/video/xbios/SDL_xbiosmodes.c 0 → 100644
View file @ d5cf1663
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include <mint/osbind.h>
#include <mint/falcon.h>
#include "SDL_config.h"
#include "SDL_xbios.h"
#include "SDL_xbiosmodes.h"
typedef struct {
int width,height,bpp;
int modecode;
int doubleline;
} xbios_mode_t;
static xbios_mode_t falcon_rgb_modes[]={
{768, 480, 16, BPS16 | COL80 | OVERSCAN | VERTFLAG},
{768, 240, 16, BPS16 | COL80 | OVERSCAN},
{640, 400, 16, BPS16 | COL80 | VERTFLAG},
{640, 200, 16, BPS16 | COL80},
{384, 480, 16, BPS16 | OVERSCAN | VERTFLAG},
{384, 240, 16, BPS16 | OVERSCAN},
{320, 400, 16, BPS16 | VERTFLAG},
{320, 200, 16, BPS16},
{768, 480, 8, BPS8 | COL80 | OVERSCAN | VERTFLAG},
{768, 240, 8, BPS8 | COL80 | OVERSCAN},
{640, 400, 8, BPS8 | COL80 | VERTFLAG},
{640, 200, 8, BPS8 | COL80},
{384, 480, 8, BPS8 | OVERSCAN | VERTFLAG},
{384, 240, 8, BPS8 | OVERSCAN},
{320, 400, 8, BPS8 | VERTFLAG},
{320, 200, 8, BPS8}
};
static xbios_mode_t falcon_vga_modes[]={
{320, 480, 16, BPS16 },
{320, 240, 16, BPS16 | VERTFLAG},
{640, 480, 8, BPS8 | COL80},
{640, 240, 8, BPS8 | COL80 | VERTFLAG},
{320, 480, 8, BPS8 },
{320, 240, 8, BPS8 | VERTFLAG}
};
static void
SDL_XBIOS_AddMode(_THIS, int width, int height, int bpp, Uint16 modecode,
SDL_bool doubleline)
{
SDL_VideoDisplay display;
SDL_DisplayData *displaydata;
SDL_DisplayMode mode;
Uint32 Rmask, Gmask, Bmask, Amask;
int orig_bpp;
Rmask = Gmask = Bmask = Amask = 0;
if (bpp == 16) {
Rmask = 31<<11;
Gmask = 63<<5;
Bmask = 31;
}
/* Memorize for c2p4 operation */
orig_bpp = bpp;
if (bpp == 4) {
bpp = 8;
}
mode.format = SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask);
mode.w = width;
mode.h = height;
mode.refresh_rate = 0;
mode.driverdata = NULL;
displaydata = (SDL_DisplayData *) SDL_malloc(sizeof(*displaydata));
if (!displaydata) {
return;
}
displaydata->modecode = modecode;
displaydata->doubleline = doubleline;
displaydata->c2p4 = (orig_bpp == 4);
SDL_zero(display);
display.desktop_mode = mode;
display.current_mode = mode;
display.driverdata = displaydata;
SDL_AddVideoDisplay(&display);
}
void
SDL_XBIOS_InitModes(_THIS)
{
SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;
switch (data->cookie_vdo >> 16) {
case VDO_ST:
case VDO_STE:
{
SDL_XBIOS_AddMode(_this, 320, 200, 4, ST_LOW >> 8, SDL_FALSE);
}
break;
case VDO_TT:
{
SDL_XBIOS_AddMode(_this, 320, 480, 8, TT_LOW, SDL_FALSE);
/* Software double-lined mode */
SDL_XBIOS_AddMode(_this, 320, 240, 8, TT_LOW, SDL_TRUE);
}
break;
case VDO_F30:
{
Uint16 modecodemask = VsetMode(-1) & (VGA | PAL);
int i;
switch (VgetMonitor()) {
case MONITOR_MONO:
/* Not usable */
break;
case MONITOR_RGB:
case MONITOR_TV:
for (i=0; i<sizeof(falcon_rgb_modes)/sizeof(xbios_mode_t); i++) {
SDL_XBIOS_AddMode(_this, falcon_rgb_modes[i].width,
falcon_rgb_modes[i].height, falcon_rgb_modes[i].bpp,
falcon_rgb_modes[i].modecode & modecodemask, SDL_FALSE);
}
break;
case MONITOR_VGA:
for (i=0; i<sizeof(falcon_vga_modes)/sizeof(xbios_mode_t); i++) {
SDL_XBIOS_AddMode(_this, falcon_vga_modes[i].width,
falcon_vga_modes[i].height, falcon_vga_modes[i].bpp,
falcon_vga_modes[i].modecode & modecodemask, SDL_FALSE);
}
break;
}
}
break;
}
}
void
SDL_XBIOS_GetDisplayModes(_THIS)
{
SDL_DisplayData *data = (SDL_DisplayData *) SDL_CurrentDisplay.driverdata;
SDL_DisplayMode mode;
//SDL_AddDisplayMode(_this->current_display, &mode);
}
int
SDL_XBIOS_SetDisplayMode(_THIS, SDL_DisplayMode * mode)
{
//SDL_DisplayModeData *data = (SDL_DisplayModeData *) mode->driverdata;
return -1;
}
void
SDL_XBIOS_QuitModes(_THIS)
{
}
/* vi: set ts=4 sw=4 expandtab: */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment