/*

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

		}