text: /*
      SDL - Simple DirectMedia Layer
      Copyright (C) 1997-2009 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 "SDL_config.h"
  
  /* Framebuffer console based SDL video driver implementation.
  */
  
  #include <fcntl.h>
  #include <unistd.h>
  #include <sys/ioctl.h>
  #include <sys/mman.h>
  
  #include "SDL_video.h"
  #include "SDL_mouse.h"
  #include "../SDL_sysvideo.h"
  #include "../SDL_pixels_c.h"
  #include "../../events/SDL_events_c.h"
  #include "../SDL_cursor_c.h"
  #include "SDL_gsvideo.h"
  #include "SDL_gsmouse_c.h"
  #include "SDL_gsevents_c.h"
  #include "SDL_gsyuv_c.h"
  
  
  /* Initialization/Query functions */
  static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat);
  static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags);
  static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);
  static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);
  static void GS_VideoQuit(_THIS);
  
  /* Hardware surface functions */
  static int GS_AllocHWSurface(_THIS, SDL_Surface *surface);
  static int GS_LockHWSurface(_THIS, SDL_Surface *surface);
  static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface);
  static void GS_FreeHWSurface(_THIS, SDL_Surface *surface);
  
  /* GS driver bootstrap functions */
  
  static int GS_Available(void)
  {
  	int console, memory;
  
  	console = open(PS2_DEV_GS, O_RDWR, 0);
  	if ( console >= 0 ) {
  		close(console);
  	}
  	memory = open(PS2_DEV_MEM, O_RDWR, 0);
  	if ( memory >= 0 ) {
  		close(memory);
  	}
  	return((console >= 0) && (memory >= 0));
  }
  
  static void GS_DeleteDevice(SDL_VideoDevice *device)
  {
  	SDL_free(device->hidden);
  	SDL_free(device);
  }
  
  static SDL_VideoDevice *GS_CreateDevice(int devindex)
  {
  	SDL_VideoDevice *this;
  
  	/* Initialize all variables that we clean on shutdown */
  	this = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice));
  	if ( this ) {
  		SDL_memset(this, 0, (sizeof *this));
  		this->hidden = (struct SDL_PrivateVideoData *)
  				SDL_malloc((sizeof *this->hidden));
  	}
  	if ( (this == NULL) || (this->hidden == NULL) ) {
  		SDL_OutOfMemory();
  		if ( this ) {
  			SDL_free(this);
  		}
  		return(0);
  	}
  	SDL_memset(this->hidden, 0, (sizeof *this->hidden));
  	mouse_fd = -1;
  	keyboard_fd = -1;
  
  	/* Set the function pointers */
  	this->VideoInit = GS_VideoInit;
  	this->ListModes = GS_ListModes;
  	this->SetVideoMode = GS_SetVideoMode;
  	this->CreateYUVOverlay = GS_CreateYUVOverlay;
  	this->SetColors = GS_SetColors;
  	this->UpdateRects = NULL;
  	this->VideoQuit = GS_VideoQuit;
  	this->AllocHWSurface = GS_AllocHWSurface;
  	this->CheckHWBlit = NULL;
  	this->FillHWRect = NULL;
  	this->SetHWColorKey = NULL;
  	this->SetHWAlpha = NULL;
  	this->LockHWSurface = GS_LockHWSurface;
  	this->UnlockHWSurface = GS_UnlockHWSurface;
  	this->FlipHWSurface = NULL;
  	this->FreeHWSurface = GS_FreeHWSurface;
  	this->SetIcon = NULL;
  	this->SetCaption = NULL;
  	this->GetWMInfo = NULL;
  	this->FreeWMCursor = GS_FreeWMCursor;
  	this->CreateWMCursor = GS_CreateWMCursor;
  	this->ShowWMCursor = GS_ShowWMCursor;
  	this->MoveWMCursor = GS_MoveWMCursor;
  	this->InitOSKeymap = GS_InitOSKeymap;
  	this->PumpEvents = GS_PumpEvents;
  
  	this->free = GS_DeleteDevice;
  
  	return this;
  }
  
  VideoBootStrap PS2GS_bootstrap = {
  	"ps2gs", "PlayStation 2 Graphics Synthesizer",
  	GS_Available, GS_CreateDevice
  };
  
  /* These are the pixel formats for the 32, 24, and 16 bit video modes */
  static struct {
  	int bpp;
  	Uint32 r;
  	Uint32 g;
  	Uint32 b;
  } GS_pixelmasks[] = {
  	{ 32, 0x000000FF,	/* RGB little-endian */
  	      0x0000FF00,
  	      0x00FF0000 },
  	{ 24, 0x000000FF,	/* RGB little-endian */
  	      0x0000FF00,
  	      0x00FF0000 },
  	{ 16, 0x0000001f,	/* RGB little-endian */
  	      0x000003e0,
  	      0x00007c00 },
  };
  /* This is a mapping from SDL bytes-per-pixel to GS pixel format */
  static int GS_formatmap[] = {
  	-1,		/* 0 bpp, not a legal value */
  	-1,		/* 8 bpp, not supported (yet?) */
  	PS2_GS_PSMCT16,	/* 16 bpp */
  	PS2_GS_PSMCT24,	/* 24 bpp */
  	PS2_GS_PSMCT32	/* 32 bpp */
  };
  
  static unsigned long long head_tags[] __attribute__((aligned(16))) = {
  	4 | (1LL << 60),	/* GIFtag */
  	0x0e,			/* A+D */
  	0,			/* 2 */
  	PS2_GS_BITBLTBUF,
  	0,			/* 4 */
  	PS2_GS_TRXPOS,
  	0,			/* 6 */
  	PS2_GS_TRXREG,
  	0,			/* 8 */
  	PS2_GS_TRXDIR
  };
  
  #define MAXIMG		(32767 * 16)
  #define MAXTAGS		8
  
  static inline int loadimage_nonblock(int fd, struct ps2_image *image, int size,
                                       unsigned long long *hm,
                                       unsigned long long *im)
  {
  	struct ps2_plist plist;
  	struct ps2_packet packet[1 + MAXTAGS * 2];
  	int isize;
  	int pnum, it, eop;
  	char *data;
  
  	/* initialize the variables */
  	data = (char *)image->ptr;
  	pnum = it = eop = 0;
  	plist.packet = packet;
  
  	/* make BITBLT packet */
  	packet[pnum].ptr = hm;
  	packet[pnum].len = sizeof(head_tags);
  	pnum++;
  	hm[2] = ((unsigned long long)image->fbp << 32) |
  	        ((unsigned long long)image->fbw << 48) |
  	        ((unsigned long long)image->psm << 56);
  	hm[4] = ((unsigned long long)image->x << 32) |
  	        ((unsigned long long)image->y << 48);
  	hm[6] = (unsigned long long)image->w |
  	        ((unsigned long long)image->h << 32);
  
  	/* make image mode tags */
  	while (!eop) {
  		isize = size > MAXIMG ? MAXIMG : size;
  		size -= isize;
  		eop = (size == 0);
  
  		packet[pnum].ptr = &im[it];
  		packet[pnum].len = sizeof(unsigned long long) * 2;
  		pnum++;
  		im[it++] = (isize >> 4) | (eop ? (1 << 15) : 0) | (2LL << 58);
  		im[it++] = 0;
  
  		packet[pnum].ptr = (void *)data;
  		packet[pnum].len = isize;
  		pnum++;
  		data += isize;
  	}
  	plist.num = pnum;
  
  	return ioctl(fd, PS2IOC_SENDL, &plist);
  }
  
  static unsigned long long tex_tags[] __attribute__((aligned(16))) = {
  	3 | (1LL << 60),	/* GIFtag */
  	0x0e,			/* A+D */
  	0,			/* 2 */
  	PS2_GS_TEX0_1,
  	(1 << 5) + (1 << 6),
  	PS2_GS_TEX1_1,
  	0,
  	PS2_GS_TEXFLUSH
  };
  static unsigned long long scale_tags[] __attribute__((aligned(16))) = {
  	5 | (1LL << 60),	/* GIFtag */
  	0x0e,			/* A+D */
  	6 + (1 << 4) + (1 << 8),
  	PS2_GS_PRIM,
  	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
  	PS2_GS_UV,
  	((unsigned long long)0 * 16) + (((unsigned long long)0 * 16) << 16),
  	PS2_GS_XYZ2,
  	0,			/* 8 */
  	PS2_GS_UV,
  	0,			/* 10 */
  	PS2_GS_XYZ2
  };
  
  
  int scaleimage_nonblock(int fd, unsigned long long *tm, unsigned long long *sm)
  {
  	struct ps2_plist plist;
  	struct ps2_packet packet[2];
  
  	/* initialize the variables */
  	plist.num = 2;
  	plist.packet = packet;
  
  	packet[0].ptr = tm;
  	packet[0].len = sizeof(tex_tags);
  	packet[1].ptr = sm;
  	packet[1].len = sizeof(scale_tags);
  
  	return ioctl(fd, PS2IOC_SENDL, &plist);
  }
  
  static int power_of_2(int value)
  {
  	int shift;
  
  	for ( shift = 0; (1<<shift) < value; ++shift ) {
  		/* Keep looking */ ;
  	}
  	return(shift);
  }
  
  static int GS_VideoInit(_THIS, SDL_PixelFormat *vformat)
  {
  	struct ps2_screeninfo vinfo;
  
  	/* Initialize the library */
  	console_fd = open(PS2_DEV_GS, O_RDWR, 0);
  	if ( console_fd < 0 ) {
  		SDL_SetError("Unable to open %s", PS2_DEV_GS);
  		return(-1);
  	}
  	memory_fd = open(PS2_DEV_MEM, O_RDWR, 0);
  	if ( memory_fd < 0 ) {
  		close(console_fd);
  		console_fd = -1;
  		SDL_SetError("Unable to open %s", PS2_DEV_MEM);
  		return(-1);
  	}
  
  	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
  		close(memory_fd);
  		close(console_fd);
  		console_fd = -1;
  		SDL_SetError("Couldn't get console pixel format");
  		return(-1);
  	}
  
  	/* Determine the current screen size */
  	this->info.current_w = vinfo.w;
  	this->info.current_h = vinfo.h;
  
  	/* Determine the current screen depth */
  	switch (vinfo.psm) {
  	    /* Supported pixel formats */
  	    case PS2_GS_PSMCT32:
  	    case PS2_GS_PSMCT24:
  	    case PS2_GS_PSMCT16:
  		break;
  	    default:
  		GS_VideoQuit(this);
  		SDL_SetError("Unknown console pixel format: %d", vinfo.psm);
  		return(-1);
  	}
  	vformat->BitsPerPixel = GS_pixelmasks[vinfo.psm].bpp;
  	vformat->Rmask = GS_pixelmasks[vinfo.psm].r;
  	vformat->Gmask = GS_pixelmasks[vinfo.psm].g;
  	vformat->Bmask = GS_pixelmasks[vinfo.psm].b;
  	saved_vinfo = vinfo;
  
  	/* Enable mouse and keyboard support */
  	if ( GS_OpenKeyboard(this) < 0 ) {
  		GS_VideoQuit(this);
  		SDL_SetError("Unable to open keyboard");
  		return(-1);
  	}
  	if ( GS_OpenMouse(this) < 0 ) {
  		const char *sdl_nomouse;
  
  		sdl_nomouse = SDL_getenv("SDL_NOMOUSE");
  		if ( ! sdl_nomouse ) {
  			GS_VideoQuit(this);
  			SDL_SetError("Unable to open mouse");
  			return(-1);
  		}
  	}
  
  	/* We're done! */
  	return(0);
  }
  
  static SDL_Rect **GS_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags)
  {
  	static SDL_Rect GS_vesa_mode_list[] = {
  		{ 0, 0, 1280, 1024 },
  		{ 0, 0, 1024, 768 },
  		{ 0, 0, 800, 600 },
  		{ 0, 0, 640, 480 }
  	};
  	static SDL_Rect *GS_vesa_modes[] = {
  		&GS_vesa_mode_list[0],
  		&GS_vesa_mode_list[1],
  		&GS_vesa_mode_list[2],
  		&GS_vesa_mode_list[3],
  		NULL
  	};
  	static SDL_Rect GS_tvout_stretch;
  	static SDL_Rect GS_tvout_mode;
  	static SDL_Rect *GS_tvout_modes[3];
  	SDL_Rect **modes = NULL;
  
  	switch (format->BitsPerPixel) {
  	    case 16:
  	    case 24:
  	    case 32:
  		if ( saved_vinfo.mode == PS2_GS_VESA ) {
  			modes = GS_vesa_modes;
  		} else {
  			int i, j = 0;
  
  // FIXME - what's wrong with the stretch code at 16 bpp?
  if ( format->BitsPerPixel != 32 ) break;
  			/* Add a mode that we could possibly stretch to */
  			for ( i=0; GS_vesa_modes[i]; ++i ) {
  				if ( (GS_vesa_modes[i]->w == saved_vinfo.w) &&
  				     (GS_vesa_modes[i]->h != saved_vinfo.h) ) {
  					GS_tvout_stretch.w=GS_vesa_modes[i]->w;
  					GS_tvout_stretch.h=GS_vesa_modes[i]->h;
  					GS_tvout_modes[j++] = &GS_tvout_stretch;
  					break;
  				}
  			}
  			/* Add the current TV video mode */
  			GS_tvout_mode.w = saved_vinfo.w;
  			GS_tvout_mode.h = saved_vinfo.h;
  			GS_tvout_modes[j++] = &GS_tvout_mode;
  			GS_tvout_modes[j++] = NULL;
  
  			/* Return the created list of modes */
  			modes = GS_tvout_modes;
  		}
  		break;
  	    default:
  		break;
  	}
  	return(modes);
  }
  
  /* Various screen update functions available */
  static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects);
  
  static SDL_Surface *GS_SetVideoMode(_THIS, SDL_Surface *current,
  				int width, int height, int bpp, Uint32 flags)
  {
  	struct ps2_screeninfo vinfo;
  
  	/* Set the terminal into graphics mode */
  	if ( GS_EnterGraphicsMode(this) < 0 ) {
  		return(NULL);
  	}
  
  	/* Set the video mode and get the final screen format */
  	if ( ioctl(console_fd, PS2IOC_GSCREENINFO, &vinfo) < 0 ) {
  		SDL_SetError("Couldn't get console screen info");
  		return(NULL);
  	}
  	if ( (vinfo.w != width) || (vinfo.h != height) ||
  	     (GS_pixelmasks[vinfo.psm].bpp != bpp) ) {
  		/* If we're not in VESA mode, we have to scale resolution */
  		if ( saved_vinfo.mode == PS2_GS_VESA ) {
  			switch (width) {
  			    case 640:
  				vinfo.res = PS2_GS_640x480;
  				break;
  			    case 800:
  				vinfo.res = PS2_GS_800x600;
  				break;
  			    case 1024:
  				vinfo.res = PS2_GS_1024x768;
  				break;
  			    case 1280:
  				vinfo.res = PS2_GS_1280x1024;
  				break;
  			    default:
  				SDL_SetError("Unsupported resolution: %dx%d\n",
  					     width, height);
  				return(NULL);
  			}
  			vinfo.res |= (PS2_GS_75Hz << 8);
  			vinfo.w = width;
  			vinfo.h = height;
  		}
  		vinfo.fbp = 0;
  		vinfo.psm = GS_formatmap[bpp/8];
  		if ( vinfo.psm < 0 ) {
  			SDL_SetError("Unsupported depth: %d bpp\n", bpp);
  			return(NULL);
  		}
  		if ( ioctl(console_fd, PS2IOC_SSCREENINFO, &vinfo) < 0 ) {
  			SDL_SetError("Couldn't set console screen info");
  			return(NULL);
  		}
  
  		/* Unmap the previous DMA buffer */
  		if ( mapped_mem ) {
  			munmap(mapped_mem, mapped_len);
  			mapped_mem = NULL;
  		}
  	}
  	if ( ! SDL_ReallocFormat(current, GS_pixelmasks[vinfo.psm].bpp,
  	                                  GS_pixelmasks[vinfo.psm].r,
  	                                  GS_pixelmasks[vinfo.psm].g,
  	                                  GS_pixelmasks[vinfo.psm].b, 0) ) {
  		return(NULL);
  	}
  
  	/* Set up the new mode framebuffer */
  	current->flags = SDL_FULLSCREEN;
  	current->w = width;
  	current->h = height;
  	current->pitch = SDL_CalculatePitch(current);
  
  	/* Memory map the DMA area for block memory transfer */
  	if ( ! mapped_mem ) {
  		pixels_len = height * current->pitch;
  		mapped_len = pixels_len +
  		             /* Screen update DMA command area */
  		             sizeof(head_tags) + ((2 * MAXTAGS) * 16);
  		if ( saved_vinfo.mode != PS2_GS_VESA ) {
  			mapped_len += sizeof(tex_tags) + sizeof(scale_tags);
  		}
  		mapped_mem = mmap(0, mapped_len, PROT_READ|PROT_WRITE,
  		                  MAP_SHARED, memory_fd, 0);
  		if ( mapped_mem == MAP_FAILED ) {
  			SDL_SetError("Unable to map %d bytes for DMA",
  			             mapped_len);
  			mapped_mem = NULL;
  			return(NULL);
  		}
  
  		/* Set up the entire screen for DMA transfer */
  		screen_image.ptr = mapped_mem;
  		screen_image.fbp = 0;
  		screen_image.fbw = (vinfo.w + 63) / 64;
  		screen_image.psm = vinfo.psm;
  		screen_image.x = 0;
  		if ( vinfo.h == height ) {
  			screen_image.y = 0;
  		} else {
  			/* Put image offscreen and scale to screen height */
  			screen_image.y = vinfo.h;
  		}
  		screen_image.w = current->w;
  		screen_image.h = current->h;
  
  		/* get screen image data size (qword aligned) */
  		screen_image_size = (screen_image.w * screen_image.h);
  		switch (screen_image.psm) {
  		    case PS2_GS_PSMCT32:
  			screen_image_size *= 4;
  			break;
  		    case PS2_GS_PSMCT24:
  			screen_image_size *= 3;
  			break;
  		    case PS2_GS_PSMCT16:
  			screen_image_size *= 2;
  			break;
  		}
  		screen_image_size = (screen_image_size + 15) & ~15;
  
  		/* Set up the memory for screen update DMA commands */
  		head_tags_mem = (unsigned long long *)
  		                (mapped_mem + pixels_len);
  		image_tags_mem = (unsigned long long *)
  		                 ((caddr_t)head_tags_mem + sizeof(head_tags));
  		SDL_memcpy(head_tags_mem, head_tags, sizeof(head_tags));
  		if ( saved_vinfo.mode != PS2_GS_VESA ) {
  			tex_tags_mem = (unsigned long long *)
  		                 ((caddr_t)image_tags_mem + ((2*MAXTAGS)*16));
  			scale_tags_mem = (unsigned long long *)
  		                 ((caddr_t)tex_tags_mem + sizeof(tex_tags));
  			SDL_memcpy(tex_tags_mem, tex_tags, sizeof(tex_tags));
  			tex_tags_mem[2] = 
  				(vinfo.h * vinfo.w) / 64 +
  	          		((unsigned long long)screen_image.fbw << 14) +
  	          		((unsigned long long)screen_image.psm << 20) +
  	          		((unsigned long long)power_of_2(screen_image.w) << 26) +
  	          		((unsigned long long)power_of_2(screen_image.h) << 30) +
  	          		((unsigned long long)1 << 34) +
  	          		((unsigned long long)1 << 35);
  			SDL_memcpy(scale_tags_mem, scale_tags, sizeof(scale_tags));
  			scale_tags_mem[8] =
  				((unsigned long long)screen_image.w * 16) +
  			         (((unsigned long long)screen_image.h * 16) << 16);
  			scale_tags_mem[10] =
  				((unsigned long long)vinfo.w * 16) +
  			         (((unsigned long long)vinfo.h * 16) << 16);
  		}
  	}
  	current->pixels = NULL;
  	if ( SDL_getenv("SDL_FULLSCREEN_UPDATE") ) {
  		/* Correct semantics */
  		current->flags |= SDL_ASYNCBLIT;
  	} else {
  		/* We lie here - the screen memory isn't really the visible
  		   display memory and still requires an update, but this
  		   has the desired effect for most applications.
  		 */
  		current->flags |= SDL_HWSURFACE;
  	}
  
  	/* Set the update rectangle function */
  	this->UpdateRects = GS_DMAFullUpdate;
  
  	/* We're done */
  	return(current);
  }
  
  /* We don't support hardware surfaces yet */
  static int GS_AllocHWSurface(_THIS, SDL_Surface *surface)
  {
  	return(-1);
  }
  static void GS_FreeHWSurface(_THIS, SDL_Surface *surface)
  {
  	return;
  }
  static int GS_LockHWSurface(_THIS, SDL_Surface *surface)
  {
  	if ( surface == this->screen ) {
  		/* Since mouse motion affects 'pixels', lock it */
  		SDL_LockCursor();
  
  		/* Make sure any pending DMA has completed */
  		if ( dma_pending ) {
  			ioctl(console_fd, PS2IOC_SENDQCT, 1);
  			dma_pending = 0;
  		}
  
  		/* If the cursor is drawn on the DMA area, remove it */
  		if ( cursor_drawn ) {
  			surface->pixels = mapped_mem + surface->offset;
  			SDL_EraseCursorNoLock(this->screen);
  			cursor_drawn = 0;
  		}
  
  		/* Set the surface pixels to the base of the DMA area */
  		surface->pixels = mapped_mem;
  
  		/* We're finished! */
  		SDL_UnlockCursor();
  	}
  	return(0);
  }
  static void GS_UnlockHWSurface(_THIS, SDL_Surface *surface)
  {
  	if ( surface == this->screen ) {
  		/* Since mouse motion affects 'pixels', lock it */
  		SDL_LockCursor();
  		surface->pixels = NULL;
  		SDL_UnlockCursor();
  	}
  }
  
  static void GS_DMAFullUpdate(_THIS, int numrects, SDL_Rect *rects)
  {
  	/* Lock so we aren't interrupted by a mouse update */
  	SDL_LockCursor();
  
  	/* Make sure any pending DMA has completed */
  	if ( dma_pending ) {
  		ioctl(console_fd, PS2IOC_SENDQCT, 1);
  		dma_pending = 0;
  	}
  
  	/* If the mouse is visible, draw it on the DMA area */
  	if ( (SDL_cursorstate & CURSOR_VISIBLE) && !cursor_drawn ) {
  		this->screen->pixels = mapped_mem + this->screen->offset;
  		SDL_DrawCursorNoLock(this->screen);
  		this->screen->pixels = NULL;
  		cursor_drawn = 1;
  	}
  
  	/* Put the image onto the screen */
  	loadimage_nonblock(console_fd,
  	                   &screen_image, screen_image_size,
  	                   head_tags_mem, image_tags_mem);
  	if ( screen_image.y > 0 ) {
  		/* Need to scale offscreen image to TV output */
  		ioctl(console_fd, PS2IOC_SENDQCT, 1);
  		dma_pending = 0;
  		scaleimage_nonblock(console_fd, tex_tags_mem, scale_tags_mem);
  	} else {
  		dma_pending = 1;
  	}
  
  	/* We're finished! */
  	SDL_UnlockCursor();
  }
  
  static int GS_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors)
  {
  	return(0);
  }
  
  static void GS_VideoQuit(_THIS)
  {
  	/* Close console and input file descriptors */
  	if ( console_fd > 0 ) {
  		/* Unmap the video framebuffer */
  		if ( mapped_mem ) {
  			/* Unmap the video framebuffer */
  			munmap(mapped_mem, mapped_len);
  			mapped_mem = NULL;
  		}
  		close(memory_fd);
  
  		/* Restore the original video mode */
  		if ( GS_InGraphicsMode(this) ) {
  			ioctl(console_fd, PS2IOC_SSCREENINFO, &saved_vinfo);
  		}
  
  		/* We're all done with the graphics device */
  		close(console_fd);
  		console_fd = -1;
  	}
  	GS_CloseMouse(this);
  	GS_CloseKeyboard(this);
  }
  