/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2004 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 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

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public

    License along with this library; if not, write to the Free

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#ifdef SAVE_RCSID

static char rcsid =

 "@(#) $Id$";

#endif

/*

 * Xbios SDL video driver

 * 

 * Patrice Mandin

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/stat.h>

#include <unistd.h>

/* Mint includes */

#include <mint/cookie.h>

#include <mint/osbind.h>

#include <mint/falcon.h>

#include "SDL.h"

#include "SDL_error.h"

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "SDL_sysvideo.h"

#include "SDL_pixels_c.h"

#include "SDL_events_c.h"

#include "SDL_ataric2p_s.h"

#include "SDL_atarievents_c.h"

#include "SDL_atarimxalloc_c.h"

#include "SDL_atarigl_c.h"

#include "SDL_xbios.h"

#include "SDL_xbios_blowup.h"

#include "SDL_xbios_centscreen.h"

#include "SDL_xbios_sb3.h"

#define XBIOS_VID_DRIVER_NAME "xbios"

/* Debug print info */

#if 0

#define DEBUG_PRINT(what) \

	{ \

		printf what; \

	}

#define DEBUG_VIDEO_XBIOS 1

#else

#define DEBUG_PRINT(what)

#undef DEBUG_VIDEO_XBIOS

#endif

/* Initialization/Query functions */

static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat);

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);

static void XBIOS_VideoQuit(_THIS);

/* 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);

#ifdef HAVE_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];

/* Xbios driver bootstrap functions */

static int XBIOS_Available(void)

{

	unsigned long cookie_vdo, cookie_mil, cookie_hade, cookie_scpn;

	/* Milan/Hades Atari clones do not have an Atari video chip */

	if ( (Getcookie(C__MIL, &cookie_mil) == C_FOUND) ||

		(Getcookie(C_hade, &cookie_hade) == C_FOUND) ) {

		return 0;

	}

	/* Cookie _VDO present ? if not, assume ST machine */

	if (Getcookie(C__VDO, &cookie_vdo) != C_FOUND) {

		cookie_vdo = VDO_ST << 16;

	}

	/* Test if we have a monochrome monitor plugged in */

	switch( cookie_vdo >>16) {

		case VDO_ST:

		case VDO_STE:

			if ( Getrez() == (ST_HIGH>>8) )

				return 0;

			break;

		case VDO_TT:

			if ( (EgetShift() & ES_MODE) == TT_HIGH)

				return 0;

			break;

		case VDO_F30:

			if ( Montype() == MONITOR_MONO)

				return 0;

			if (Getcookie(C_SCPN, &cookie_scpn) == C_FOUND) {

				if (!SDL_XBIOS_SB3Usable((scpn_cookie_t *)cookie_scpn)) {

					return 0;

				}

			}

			break;

		default:

			return 0;

	}

	return 1;

}

static void XBIOS_DeleteDevice(SDL_VideoDevice *device)

{

	free(device->hidden);

	free(device);

}

static SDL_VideoDevice *XBIOS_CreateDevice(int devindex)

{

	SDL_VideoDevice *device;

	/* Initialize all variables that we clean on shutdown */

	device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));

	if ( device ) {

		memset(device, 0, (sizeof *device));

		device->hidden = (struct SDL_PrivateVideoData *)

				malloc((sizeof *device->hidden));

		device->gl_data = (struct SDL_PrivateGLData *)

				malloc((sizeof *device->gl_data));

	}

	if ( (device == NULL) || (device->hidden == NULL) ) {

		SDL_OutOfMemory();

		if ( device ) {

			free(device);

		}

		return(0);

	}

	memset(device->hidden, 0, (sizeof *device->hidden));

	memset(device->gl_data, 0, sizeof(*device->gl_data));

	/* Video functions */

	device->VideoInit = XBIOS_VideoInit;

	device->ListModes = XBIOS_ListModes;

	device->SetVideoMode = XBIOS_SetVideoMode;

	device->SetColors = XBIOS_SetColors;

	device->UpdateRects = NULL;

	device->VideoQuit = XBIOS_VideoQuit;

	device->AllocHWSurface = XBIOS_AllocHWSurface;

	device->LockHWSurface = XBIOS_LockHWSurface;

	device->UnlockHWSurface = XBIOS_UnlockHWSurface;

	device->FlipHWSurface = XBIOS_FlipHWSurface;

	device->FreeHWSurface = XBIOS_FreeHWSurface;

#ifdef HAVE_OPENGL

	/* OpenGL functions */

	device->GL_LoadLibrary = SDL_AtariGL_LoadLibrary;

	device->GL_GetProcAddress = SDL_AtariGL_GetProcAddress;

	device->GL_GetAttribute = SDL_AtariGL_GetAttribute;

	device->GL_MakeCurrent = SDL_AtariGL_MakeCurrent;

	device->GL_SwapBuffers = XBIOS_GL_SwapBuffers;

#endif

	/* Events */

	device->InitOSKeymap = Atari_InitOSKeymap;

	device->PumpEvents = Atari_PumpEvents;

	device->free = XBIOS_DeleteDevice;

	return device;

}

VideoBootStrap XBIOS_bootstrap = {

	XBIOS_VID_DRIVER_NAME, "Atari Xbios driver",

	XBIOS_Available, XBIOS_CreateDevice

};

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 *) 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--) {

		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;

}

static int XBIOS_VideoInit(_THIS, SDL_PixelFormat *vformat)

{

	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 *)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 (Montype())

			{

				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;

	}

	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] = 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] = 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;

#ifdef HAVE_OPENGL

	SDL_AtariGL_InitPointers(this);

#endif

	/* We're done! */

	return(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);

		}

		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);

	}

	memset(XBIOS_screensmem[0], 0, new_screen_size);

	XBIOS_screens[0]=(void *) (( (long) XBIOS_screensmem[0]+256) & 0xFFFFFF00UL);

#ifdef HAVE_OPENGL

	if (flags & SDL_OPENGL) {

		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);

		}

		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;

#ifdef HAVE_OPENGL

	if (flags & SDL_OPENGL) {

		if (!SDL_AtariGL_Init(this, current)) {

			XBIOS_FreeBuffers(this);

			SDL_SetError("Can not create OpenGL context");

			return NULL;

		}

		modeflags |= SDL_OPENGL;

	}

#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) {

				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) {

		void *destscr;

		int destx;

		int i;

		/* 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;

		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 = destscr;

			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);

}

/* Note:  If we are terminated, this could be called in the middle of

   another SDL video routine -- notably UpdateRects.

*/

static void XBIOS_VideoQuit(_THIS)

{

	int i,j;

	Atari_ShutdownEvents();

	/* 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

#ifdef HAVE_OPENGL

	if (gl_active) {

		SDL_AtariGL_Quit(this, SDL_TRUE);

	}

#endif

	if (XBIOS_oldpalette) {

		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) {

				free(SDL_modelist[j][i]);

				SDL_modelist[j][i]=NULL;

			}

		}

	}

	if (XBIOS_modelist) {

		free(XBIOS_modelist);

		XBIOS_nummodes=0;

		XBIOS_modelist=NULL;

	}

	this->screen->pixels = NULL;	

}

#ifdef HAVE_OPENGL

static void XBIOS_GL_SwapBuffers(_THIS)

{

	SDL_AtariGL_SwapBuffers(this);

	XBIOS_FlipHWSurface(this, this->screen);

	SDL_AtariGL_MakeCurrent(this);

}

#endif