xbios: preliminary video mode init
authorPatrice Mandin <patmandin@gmail.com>
Mon, 13 Nov 2006 19:59:28 +0000
changeset 2072 4b3f98a9a2c1
parent 2071 579abbb51f80
child 2073 790726541708
xbios: preliminary video mode init
src/video/xbios/SDL_xbios.c
src/video/xbios/SDL_xbios.h
src/video/xbios/SDL_xbiosmodes.c
--- a/src/video/xbios/SDL_xbios.c	Mon Nov 13 00:38:13 2006 +0000
+++ b/src/video/xbios/SDL_xbios.c	Mon Nov 13 19:59:28 2006 +0000
@@ -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 @@
     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 @@
     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 @@
     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);
-        }
+    /* Save screensaver settings */
 
-        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;
-
-    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 @@
 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;
+    /* Restore screensaver settings */
 
-    /* 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;
+    SDL_XBIOS_QuitModes(_this);
 }
-
-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;
-
-            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);
-}
-
-#endif
-#endif
-/* vi: set ts=4 sw=4 expandtab: */
--- a/src/video/xbios/SDL_xbios.h	Mon Nov 13 00:38:13 2006 +0000
+++ b/src/video/xbios/SDL_xbios.h	Mon Nov 13 19:59:28 2006 +0000
@@ -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 @@
 
     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 @@
 #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: */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/xbios/SDL_xbiosmodes.c	Mon Nov 13 19:59:28 2006 +0000
@@ -0,0 +1,177 @@
+/*
+    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: */