[sdl_omap.git] / src / video / omapdss / main.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <sys/time.h>
#include <SDL/SDL.h>

#include "pmsdl.h"
#include "common/input.h"
#include "linux/fbdev.h"
#include "linux/oshide.h"

static SDL_Surface *g_screen;
static void *g_screen_fbp;
static Uint16 g_8bpp_pal[256];
static Uint32 g_start_ticks;

static inline int min(int v1, int v2)
{
	return v1 < v2 ? v1 : v2;
}

static SDL_Surface *alloc_surface(int w, int h, int bpp)
{
	// SDL has some pointer overuse, every surface has a format,
	// why make format accessible through pointer?
	struct {
		SDL_Surface s;
		SDL_PixelFormat f;
	} *ret;

	ret = calloc(1, sizeof(*ret));
	if (ret == NULL)
		return NULL;

	ret->s.format = &ret->f;
	ret->f.BitsPerPixel = bpp;
	ret->f.BytesPerPixel = (bpp + 7) / 8;

	ret->s.w = w;
	ret->s.h = h;
	ret->s.pitch = w * ret->f.BytesPerPixel;
	// XXX: more fields

	return &ret->s;
}

static char *sskip(char *p)
{
	while (*p && isspace(*p))
		p++;
	return p;
}

static char *nsskip(char *p)
{
	while (*p && !isspace(*p))
		p++;
	return p;
}

static int check_token(const char *p, const char *token)
{
	int tlen = strlen(token);
	return strncasecmp(p, token, tlen) == 0 && isspace(p[tlen]);
}

static void do_config(void)
{
	char buff[256];
	FILE *f;

	f = fopen("pmsdl.cfg", "r");
	if (f == NULL)
		return;

	while (!feof(f)) {
		char *p, *line = fgets(buff, sizeof(buff), f);
		if (line == NULL)
			break;
		p = line = sskip(line);
		if (*p == '#')
			continue;

		if (check_token(p, "bind")) {
			char *key, *key_end, *sdlkey, *sdlkey_end;
			key = sskip(p + 5);
			key_end = nsskip(key);
			p = sskip(key_end);
			if (*p != '=')
				goto bad;
			sdlkey = sskip(p + 1);
			sdlkey_end = nsskip(sdlkey);
			p = sskip(sdlkey_end);
			if (*key == 0 || *sdlkey == 0 || *p != 0)
				goto bad;
			*key_end = *sdlkey_end = 0;

			pmsdl_input_bind(key, sdlkey);
			continue;
		}

bad:
		err("config: failed to parse: %s", line);
	}
	fclose(f);
}

DECLSPEC int SDLCALL
SDL_Init(Uint32 flags)
{
	trace("%08x", flags);

	if (g_start_ticks == 0) {
		pmsdl_input_init();
		oshide_init();
		do_config();
	}

	g_start_ticks = 0;
	g_start_ticks = SDL_GetTicks();

	return 0;
}

DECLSPEC void SDLCALL
SDL_Quit(void)
{
	trace("");

	if (g_start_ticks != 0) {
		oshide_finish();
		g_start_ticks = 0;
	}
}

DECLSPEC int SDLCALL
SDL_InitSubSystem(Uint32 flags)
{
	trace("%08x", flags);
	return 0;
}

DECLSPEC void SDLCALL
SDL_QuitSubSystem(Uint32 flags)
{
	trace("%08x", flags);
}

DECLSPEC Uint32 SDLCALL
SDL_GetTicks(void)
{
	struct timeval tv;
	Uint32 ret;

	gettimeofday(&tv, NULL);
	ret = tv.tv_sec * 1000;
	ret += tv.tv_usec * 1048 >> 20;

	ret -= g_start_ticks;
	dbg(" SDL_GetTicks %d", ret);
	return ret;
}

DECLSPEC SDL_Surface * SDLCALL
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
	struct vout_fbdev *fbdev;

	trace("%d, %d, %d, %08x", width, height, bpp, flags);

	if (bpp == 0)
		bpp = 16;

	if (bpp != 8 && bpp != 16) {
		err("unsupported bpp: %d\n", bpp);
		return NULL;
	}

	// XXX: destroy old g_screen?

	g_screen = alloc_surface(width, height, bpp);
	if (g_screen == NULL)
		return NULL;

	fbdev = vout_fbdev_init("/dev/fb0", &width, &height, 0);
	if (fbdev == NULL)
		goto fail_fbdev_init;

	g_screen_fbp = vout_fbdev_flip(fbdev);
	if (bpp == 16)
		g_screen->pixels = g_screen_fbp;
	else
		// we have to fake this for now..
		g_screen->pixels = calloc(g_screen->pitch * height, 1);

	if (g_screen->pixels == NULL) {
		err("fb NULL");
		goto fail_pixels;
	}
	g_screen->hwdata = (void *)fbdev;

	dbg("returning %p", g_screen);
	return g_screen;

fail_pixels:
	vout_fbdev_finish(fbdev);
fail_fbdev_init:
	free(g_screen);
	g_screen = NULL;
	return NULL;
}

DECLSPEC int SDLCALL
SDL_Flip(SDL_Surface *screen)
{
	struct vout_fbdev *fbdev;

	trace("%p", screen);

	if (screen != g_screen) {
		err("flip not on screen surface?");
		return -1;
	}

	if (screen->format->BitsPerPixel == 8) {
		int l = screen->pitch * screen->h;
#ifdef __arm__
		do_clut(g_screen_fbp, screen->pixels, g_8bpp_pal, l);
#else
		Uint16 *d = g_screen_fbp;
		Uint8 *s = screen->pixels;

		// XXX: perhaps optimize this sh*t
		for (; l > 0; d++, s++, l--)
			*d = g_8bpp_pal[*s];
#endif
	}

	fbdev = (void *)screen->hwdata;
	g_screen_fbp = vout_fbdev_flip(fbdev);

	if (screen->format->BitsPerPixel != 8)
		screen->pixels = g_screen_fbp;

	return 0;
}

static int do_rect_clip(const SDL_Surface *s, SDL_Rect *r)
{
	int x = r->x, y = r->y, w = r->w, h = r->h;

	if (x < 0) {
		w += x;
		if (w < 0)
			w = 0;
		x = 0;
	}
	if (y < 0) {
		h += y;
		if (h < 0)
			h = 0;
		y = 0;
	}
	if (x + w > s->w) {
		w = s->w - x;
		if (w < 0)
			w = 0;
	}
	if (y + h > s->h) {
		h = s->h - y;
		if (h < 0)
			h = 0;
	}

	r->x = x; r->y = y; r->w = w; r->h = h;
	return (w > 0 && h > 0) ? 0 : -1;
}

DECLSPEC int SDLCALL
SDL_UpperBlit(SDL_Surface *src, SDL_Rect *srcrect,
		SDL_Surface *dst, SDL_Rect *dstrect)
{
	int sx = 0, sy = 0, sw, sh;
	int dx = 0, dy = 0;
	SDL_Rect tmprect = { 0, };

	trace("%p, %p, %p, %p", src, srcrect, dst, dstrect);

	if (src == NULL || dst == NULL)
		return -1;

	if (srcrect != NULL) {
		// XXX: dst pos may need to be adjusted in some corner cases
		if (do_rect_clip(src, srcrect) < 0)
			return -1;
		sx = srcrect->x;
		sy = srcrect->y;
		sw = srcrect->w;
		sh = srcrect->h;
	} else {
		sw = src->w;
		sh = src->h;
	}

	if (dstrect == NULL)
		dstrect = &tmprect;

	// SDL just uses source w and h
	dstrect->w = sw;
	dstrect->h = sh;
	if (do_rect_clip(dst, dstrect) < 0)
		return -1;
	dx = dstrect->x;
	dy = dstrect->y;
	sw = dstrect->w;
	sh = dstrect->h;

	dbg("(%d %d %d %d) -> (%d %d %d %d)", sx, sy, sw, sh, dx, dy, sw, sh);

	if (src->format->BitsPerPixel == dst->format->BitsPerPixel) {
		int Bpp = src->format->BytesPerPixel;
		int dpitch = dst->pitch;
		int spitch = src->pitch;
		Uint8 *d = (Uint8 *)dst->pixels + dpitch * dy + dx * Bpp;
		Uint8 *s = (Uint8 *)src->pixels + spitch * sy + sx * Bpp;

		for (sw *= Bpp; sh > 0; d += dpitch, s += spitch, sh--)
			memcpy(d, s, sw);
	}
	else
		not_supported();

	return 0;
}

DECLSPEC SDL_Surface * SDLCALL
SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth,
		     Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
{
	SDL_Surface *ret;

	trace("%08x, %d, %d, %d, %04x, %04x, %04x, %04x",
		flags, width, height, depth, Rmask, Gmask, Bmask, Amask);

	ret = alloc_surface(width, height, depth);
	if (ret == NULL)
		return NULL;

	ret->pixels = calloc(ret->pitch * height, 1);
	if (ret->pixels == NULL)
		goto fail;

	dbg("returning %p", ret);
	return ret;

fail:
	free(ret);
	return NULL;
}

DECLSPEC int SDLCALL
SDL_SetColors(SDL_Surface *surface, SDL_Color *colors, int firstcolor, int ncolors)
{
	int i, to;

	trace("%p, %p, %d, %d", surface, colors, firstcolor, ncolors);

	if (surface != g_screen)
		return 0;

	to = min(ARRAY_SIZE(g_8bpp_pal), firstcolor + ncolors);
	for (i = firstcolor; i < to; i++) {
		SDL_Color *c = &colors[i - firstcolor];
		int r = c->r, g = c->g, b = c->b;
		// noiz2sa gets a good deal darker that real SDL,
		// don't know what's going on there
/*
		if (r < 0xf8 && (r & 7) > 3) r += 8;
		if (g < 0xfc && (g & 3) > 1) g += 4;
		if (b < 0xf8 && (b & 7) > 3) b += 8;
*/
		g_8bpp_pal[i] = ((r << 8) & 0xf800) | ((g << 3) & 0x07e0) | (b >> 3);
//		g_8bpp_pal[i] += 0x0821;
	}

	return 0;
}

DECLSPEC int SDLCALL
SDL_FillRect(SDL_Surface *dst, SDL_Rect *dstrect, Uint32 color)
{
	trace("%p, %p, %04x", dst, dstrect, color);

	if (dst->format->BytesPerPixel != 1) {
		not_supported();
		return -1;
	}
	else
		memset(dst->pixels, color, dst->pitch * dst->h);

	return 0;
}

/*
DECLSPEC SDL_Surface * SDLCALL
SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch,
			 Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
{
}
*/

DECLSPEC SDL_RWops * SDLCALL
SDL_RWFromFile(const char *file, const char *mode)
{
	SDL_RWops *ret;
	FILE *f;

	trace("%s, %s", file, mode);

	f = fopen(file, mode);
	if (f == NULL)
		return NULL;

	ret = calloc(1, sizeof(*ret));
	if (ret == NULL) {
		fclose(f);
		return NULL;
	}
	ret->hidden.stdio.fp = f;

	return ret;
}

DECLSPEC void SDLCALL
SDL_FreeRW(SDL_RWops *area)
{
	if (area->hidden.stdio.fp) {
		fclose(area->hidden.stdio.fp);
		area->hidden.stdio.fp = NULL;
	}
	free(area);
}

DECLSPEC SDL_Surface * SDLCALL
SDL_LoadBMP_RW(SDL_RWops *src, int freesrc)
{
	struct bmp_dib_v3 {
		unsigned char magic[2];
		uint32_t filesz;
		uint16_t creator1;
		uint16_t creator2;
		uint32_t bmp_offset;
		uint32_t header_sz;
		int32_t width;
		int32_t height;
		uint16_t nplanes;
		uint16_t bitspp;
		uint32_t compress_type;
		uint32_t bmp_bytesz;
		int32_t hres;
		int32_t vres;
		uint32_t ncolors;
		uint32_t nimpcolors;
	} __attribute__((packed)) bmp;
	SDL_Surface *ret = NULL;
	int data_size, read_size;
	uint8_t *tmp_buf = NULL;
	int i, bytespp;
	FILE *f;

	trace("%p, %d", src, freesrc);

	f = src->hidden.stdio.fp;
	if (f == NULL)
		goto out;

	if (fread(&bmp, 1, sizeof(bmp), f) != sizeof(bmp)) {
		err("bmp read error");
		goto out;
	}

	if (bmp.magic[0] != 'B' || bmp.magic[1] != 'M' || bmp.header_sz != 40) {
		err("unhandled BMP format, sz=%d", bmp.header_sz);
		goto out;
	}

	if ((unsigned)bmp.width > 0xffff || (unsigned)bmp.height > 0xffff) {
		err("BMP size %dx%d out of range", bmp.width, bmp.height);
		goto out;
	}

	if (bmp.bitspp != 4) {
		err("BMP unhandled bpp: %d", bmp.bitspp);
		goto out;
	}

	bytespp = bmp.bitspp < 8 ? 1 : (bmp.bitspp + 7) / 8;
	data_size = bmp.width * bmp.height * bytespp;
	tmp_buf = malloc(data_size);
	if (tmp_buf == NULL)
		goto out;

	if (fseek(f, bmp.bmp_offset, SEEK_SET) != 0) {
		err("BMP seek error");
		goto out;
	}

	read_size = bmp.width * bmp.bitspp / 8;
	for (i = bmp.height - 1; i > 0; i--) {
		if (fread((char *)tmp_buf + i * read_size, 1, read_size, f) != read_size) {
			err("BMP read error");
			goto out;
		}
	}

	if (bmp.bitspp == 4) {
		// just convert to 8bpp now
		int c = bmp.width * bmp.height / 2;
		uint8_t *p = tmp_buf;
		for (i = c - 1; i >= 0; i--) {
			p[i * 2 + 1] = p[i] & 0xf;
			p[i * 2] = p[i] >> 4;
		}
	}

	ret = alloc_surface(bmp.width, bmp.height, 8);
	if (ret == NULL)
		goto out;

	ret->pixels = tmp_buf;
	tmp_buf = NULL;

out:
	if (tmp_buf != NULL)
		free(tmp_buf);
	if (freesrc)
		SDL_FreeRW(src);

	return ret;
}

DECLSPEC SDL_Surface * SDLCALL
SDL_ConvertSurface(SDL_Surface *src, SDL_PixelFormat *fmt, Uint32 flags)
{
	SDL_Surface *ret;
	void *data;

	trace("%p, %p, %08x", src, fmt, flags);

	if (src->format->BitsPerPixel != fmt->BitsPerPixel) {
		err("convert: not implemented");
		return NULL;
	}

	data = malloc(src->pitch * src->h);
	if (data == NULL)
		return NULL;
	memcpy(data, src->pixels, src->pitch * src->h);

	ret = alloc_surface(src->w, src->h, fmt->BitsPerPixel);
	if (ret == NULL) {
		free(data);
		return NULL;
	}
	ret->pixels = data;
	return ret;
}

DECLSPEC int SDLCALL
SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key)
{
	trace("%p, %08x, %04x", surface, flag, key);
	return 0;
}

DECLSPEC void SDLCALL
SDL_WM_SetCaption(const char *title, const char *icon)
{
	trace("%s, %s", title, icon);
}

DECLSPEC int SDLCALL
SDL_ShowCursor(int toggle)
{
	trace("%d", toggle);
	return 0;
}

DECLSPEC char * SDLCALL
SDL_GetError(void)
{
	trace("");

	return "";
}
Commit	Line	Data
0ec348b9	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <string.h>
3cb98c5e	4	#include <strings.h>
3cb98c5e	5	#include <ctype.h>
0ec348b9	6	#include <sys/time.h>
	7	#include <SDL/SDL.h>
	8
	9	#include "pmsdl.h"
3cb98c5e	10	#include "common/input.h"
0ec348b9	11	#include "linux/fbdev.h"
3cb98c5e	12	#include "linux/oshide.h"
0ec348b9	13
	14	static SDL_Surface *g_screen;
	15	static void *g_screen_fbp;
	16	static Uint16 g_8bpp_pal[256];
	17	static Uint32 g_start_ticks;
0ec348b9	18
	19	static inline int min(int v1, int v2)
	20	{
	21	return v1 < v2 ? v1 : v2;
	22	}
	23
0ec348b9	24	static SDL_Surface *alloc_surface(int w, int h, int bpp)
	25	{
	26	// SDL has some pointer overuse, every surface has a format,
	27	// why make format accessible through pointer?
	28	struct {
	29	SDL_Surface s;
	30	SDL_PixelFormat f;
	31	} *ret;
	32
	33	ret = calloc(1, sizeof(*ret));
	34	if (ret == NULL)
	35	return NULL;
	36
	37	ret->s.format = &ret->f;
	38	ret->f.BitsPerPixel = bpp;
	39	ret->f.BytesPerPixel = (bpp + 7) / 8;
	40
	41	ret->s.w = w;
	42	ret->s.h = h;
	43	ret->s.pitch = w * ret->f.BytesPerPixel;
	44	// XXX: more fields
	45
	46	return &ret->s;
	47	}
	48
3cb98c5e	49	static char sskip(char p)
	50	{
	51	while (p && isspace(p))
	52	p++;
	53	return p;
	54	}
	55
	56	static char nsskip(char p)
	57	{
	58	while (p && !isspace(p))
	59	p++;
	60	return p;
	61	}
	62
	63	static int check_token(const char p, const char token)
	64	{
	65	int tlen = strlen(token);
	66	return strncasecmp(p, token, tlen) == 0 && isspace(p[tlen]);
	67	}
	68
	69	static void do_config(void)
	70	{
	71	char buff[256];
	72	FILE *f;
	73
	74	f = fopen("pmsdl.cfg", "r");
	75	if (f == NULL)
	76	return;
	77
	78	while (!feof(f)) {
	79	char p, line = fgets(buff, sizeof(buff), f);
	80	if (line == NULL)
	81	break;
	82	p = line = sskip(line);
	83	if (*p == '#')
	84	continue;
	85
	86	if (check_token(p, "bind")) {
	87	char key, key_end, sdlkey, sdlkey_end;
	88	key = sskip(p + 5);
	89	key_end = nsskip(key);
	90	p = sskip(key_end);
	91	if (*p != '=')
	92	goto bad;
	93	sdlkey = sskip(p + 1);
	94	sdlkey_end = nsskip(sdlkey);
	95	p = sskip(sdlkey_end);
	96	if (key == 0 \|\| sdlkey == 0 \|\| *p != 0)
	97	goto bad;
	98	key_end = sdlkey_end = 0;
	99
	100	pmsdl_input_bind(key, sdlkey);
	101	continue;
	102	}
	103
	104	bad:
	105	err("config: failed to parse: %s", line);
	106	}
	107	fclose(f);
	108	}
	109
0ec348b9	110	DECLSPEC int SDLCALL
	111	SDL_Init(Uint32 flags)
	112	{
	113	trace("%08x", flags);
	114
3cb98c5e	115	if (g_start_ticks == 0) {
	116	pmsdl_input_init();
	117	oshide_init();
	118	do_config();
	119	}
	120
0ec348b9	121	g_start_ticks = 0;
	122	g_start_ticks = SDL_GetTicks();
	123
	124	return 0;
	125	}
	126
	127	DECLSPEC void SDLCALL
	128	SDL_Quit(void)
	129	{
	130	trace("");
3cb98c5e	131
	132	if (g_start_ticks != 0) {
	133	oshide_finish();
	134	g_start_ticks = 0;
	135	}
0ec348b9	136	}
	137
	138	DECLSPEC int SDLCALL
	139	SDL_InitSubSystem(Uint32 flags)
	140	{
	141	trace("%08x", flags);
	142	return 0;
	143	}
	144
	145	DECLSPEC void SDLCALL
	146	SDL_QuitSubSystem(Uint32 flags)
	147	{
	148	trace("%08x", flags);
	149	}
	150
	151	DECLSPEC Uint32 SDLCALL
	152	SDL_GetTicks(void)
	153	{
	154	struct timeval tv;
	155	Uint32 ret;
	156
	157	gettimeofday(&tv, NULL);
	158	ret = tv.tv_sec * 1000;
	159	ret += tv.tv_usec * 1048 >> 20;
	160
	161	ret -= g_start_ticks;
	162	dbg(" SDL_GetTicks %d", ret);
	163	return ret;
	164	}
	165
	166	DECLSPEC SDL_Surface * SDLCALL
	167	SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
	168	{
	169	struct vout_fbdev *fbdev;
	170
	171	trace("%d, %d, %d, %08x", width, height, bpp, flags);
	172
3cb98c5e	173	if (bpp == 0)
	174	bpp = 16;
	175
0ec348b9	176	if (bpp != 8 && bpp != 16) {
	177	err("unsupported bpp: %d\n", bpp);
	178	return NULL;
	179	}
	180
	181	// XXX: destroy old g_screen?
	182
	183	g_screen = alloc_surface(width, height, bpp);
	184	if (g_screen == NULL)
	185	return NULL;
	186
	187	fbdev = vout_fbdev_init("/dev/fb0", &width, &height, 0);
	188	if (fbdev == NULL)
	189	goto fail_fbdev_init;
	190
	191	g_screen_fbp = vout_fbdev_flip(fbdev);
	192	if (bpp == 16)
	193	g_screen->pixels = g_screen_fbp;
	194	else
	195	// we have to fake this for now..
	196	g_screen->pixels = calloc(g_screen->pitch * height, 1);
	197
	198	if (g_screen->pixels == NULL) {
	199	err("fb NULL");
	200	goto fail_pixels;
	201	}
	202	g_screen->hwdata = (void *)fbdev;
	203
	204	dbg("returning %p", g_screen);
	205	return g_screen;
	206
	207	fail_pixels:
	208	vout_fbdev_finish(fbdev);
	209	fail_fbdev_init:
	210	free(g_screen);
	211	g_screen = NULL;
	212	return NULL;
	213	}
	214
	215	DECLSPEC int SDLCALL
	216	SDL_Flip(SDL_Surface *screen)
	217	{
	218	struct vout_fbdev *fbdev;
	219
	220	trace("%p", screen);
	221
	222	if (screen != g_screen) {
	223	err("flip not on screen surface?");
	224	return -1;
	225	}
	226
	227	if (screen->format->BitsPerPixel == 8) {
	228	int l = screen->pitch * screen->h;
3cb98c5e	229	#ifdef __arm__
0ec348b9	230	do_clut(g_screen_fbp, screen->pixels, g_8bpp_pal, l);
	231	#else
	232	Uint16 *d = g_screen_fbp;
	233	Uint8 *s = screen->pixels;
	234
	235	// XXX: perhaps optimize this sh*t
	236	for (; l > 0; d++, s++, l--)
	237	d = g_8bpp_pal[s];
	238	#endif
	239	}
	240
	241	fbdev = (void *)screen->hwdata;
	242	g_screen_fbp = vout_fbdev_flip(fbdev);
	243
	244	if (screen->format->BitsPerPixel != 8)
	245	screen->pixels = g_screen_fbp;
	246
	247	return 0;
	248	}
	249
	250	static int do_rect_clip(const SDL_Surface s, SDL_Rect r)
	251	{
	252	int x = r->x, y = r->y, w = r->w, h = r->h;
	253
	254	if (x < 0) {
	255	w += x;
	256	if (w < 0)
	257	w = 0;
	258	x = 0;
	259	}
	260	if (y < 0) {
	261	h += y;
	262	if (h < 0)
	263	h = 0;
	264	y = 0;
	265	}
	266	if (x + w > s->w) {
	267	w = s->w - x;
	268	if (w < 0)
	269	w = 0;
	270	}
	271	if (y + h > s->h) {
	272	h = s->h - y;
	273	if (h < 0)
	274	h = 0;
	275	}
	276
	277	r->x = x; r->y = y; r->w = w; r->h = h;
	278	return (w > 0 && h > 0) ? 0 : -1;
	279	}
	280
	281	DECLSPEC int SDLCALL
	282	SDL_UpperBlit(SDL_Surface src, SDL_Rect srcrect,
	283	SDL_Surface dst, SDL_Rect dstrect)
	284	{
	285	int sx = 0, sy = 0, sw, sh;
	286	int dx = 0, dy = 0;
	287	SDL_Rect tmprect = { 0, };
	288
	289	trace("%p, %p, %p, %p", src, srcrect, dst, dstrect);
	290
	291	if (src == NULL \|\| dst == NULL)
	292	return -1;
	293
294	if (srcrect != NULL) {
295	// XXX: dst pos may need to be adjusted in some corner cases
296	if (do_rect_clip(src, srcrect) < 0)
297	return -1;
298	sx = srcrect->x;
299	sy = srcrect->y;
300	sw = srcrect->w;
301	sh = srcrect->h;
302	} else {
303	sw = src->w;
304	sh = src->h;
305	}
306
307	if (dstrect == NULL)
308	dstrect = &tmprect;
309
310	// SDL just uses source w and h
311	dstrect->w = sw;
312	dstrect->h = sh;
313	if (do_rect_clip(dst, dstrect) < 0)
314	return -1;
315	dx = dstrect->x;
316	dy = dstrect->y;
317	sw = dstrect->w;
318	sh = dstrect->h;
319
320	dbg("(%d %d %d %d) -> (%d %d %d %d)", sx, sy, sw, sh, dx, dy, sw, sh);
321
322	if (src->format->BitsPerPixel == dst->format->BitsPerPixel) {
323	int Bpp = src->format->BytesPerPixel;
324	int dpitch = dst->pitch;
325	int spitch = src->pitch;
326	Uint8 d = (Uint8 )dst->pixels + dpitch * dy + dx * Bpp;
327	Uint8 s = (Uint8 )src->pixels + spitch * sy + sx * Bpp;
328
329	for (sw *= Bpp; sh > 0; d += dpitch, s += spitch, sh--)
330	memcpy(d, s, sw);
331	}
3cb98c5e	332	else
3cb98c5e	333	not_supported();
0ec348b9	334
	335	return 0;
	336	}
	337
	338	DECLSPEC SDL_Surface * SDLCALL
	339	SDL_CreateRGBSurface(Uint32 flags, int width, int height, int depth,
	340	Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
	341	{
	342	SDL_Surface *ret;
	343
	344	trace("%08x, %d, %d, %d, %04x, %04x, %04x, %04x",
	345	flags, width, height, depth, Rmask, Gmask, Bmask, Amask);
	346
	347	ret = alloc_surface(width, height, depth);
	348	if (ret == NULL)
	349	return NULL;
	350
	351	ret->pixels = calloc(ret->pitch * height, 1);
	352	if (ret->pixels == NULL)
	353	goto fail;
	354
	355	dbg("returning %p", ret);
	356	return ret;
	357
	358	fail:
	359	free(ret);
	360	return NULL;
	361	}
	362
	363	DECLSPEC int SDLCALL
	364	SDL_SetColors(SDL_Surface surface, SDL_Color colors, int firstcolor, int ncolors)
	365	{
	366	int i, to;
	367
	368	trace("%p, %p, %d, %d", surface, colors, firstcolor, ncolors);
	369
	370	if (surface != g_screen)
	371	return 0;
	372
	373	to = min(ARRAY_SIZE(g_8bpp_pal), firstcolor + ncolors);
	374	for (i = firstcolor; i < to; i++) {
	375	SDL_Color *c = &colors[i - firstcolor];
	376	int r = c->r, g = c->g, b = c->b;
	377	// noiz2sa gets a good deal darker that real SDL,
	378	// don't know what's going on there
	379	/*
	380	if (r < 0xf8 && (r & 7) > 3) r += 8;
	381	if (g < 0xfc && (g & 3) > 1) g += 4;
	382	if (b < 0xf8 && (b & 7) > 3) b += 8;
	383	*/
	384	g_8bpp_pal[i] = ((r << 8) & 0xf800) \| ((g << 3) & 0x07e0) \| (b >> 3);
	385	// g_8bpp_pal[i] += 0x0821;
	386	}
	387
	388	return 0;
	389	}
	390
	391	DECLSPEC int SDLCALL
	392	SDL_FillRect(SDL_Surface dst, SDL_Rect dstrect, Uint32 color)
	393	{
	394	trace("%p, %p, %04x", dst, dstrect, color);
	395
3cb98c5e	396	if (dst->format->BytesPerPixel != 1) {
3cb98c5e	397	not_supported();
0ec348b9	398	return -1;
	399	}
	400	else
	401	memset(dst->pixels, color, dst->pitch * dst->h);
	402
	403	return 0;
	404	}
	405
	406	/*
	407	DECLSPEC SDL_Surface * SDLCALL
	408	SDL_CreateRGBSurfaceFrom(void *pixels, int width, int height, int depth, int pitch,
	409	Uint32 Rmask, Uint32 Gmask, Uint32 Bmask, Uint32 Amask)
	410	{
	411	}
	412	*/
	413
	414	DECLSPEC SDL_RWops * SDLCALL
	415	SDL_RWFromFile(const char file, const char mode)
	416	{
	417	SDL_RWops *ret;
	418	FILE *f;
	419
	420	trace("%s, %s", file, mode);
	421
	422	f = fopen(file, mode);
	423	if (f == NULL)
	424	return NULL;
	425
	426	ret = calloc(1, sizeof(*ret));
	427	if (ret == NULL) {
	428	fclose(f);
	429	return NULL;
	430	}
	431	ret->hidden.stdio.fp = f;
	432
	433	return ret;
	434	}
	435
	436	DECLSPEC void SDLCALL
	437	SDL_FreeRW(SDL_RWops *area)
	438	{
	439	if (area->hidden.stdio.fp) {
	440	fclose(area->hidden.stdio.fp);
	441	area->hidden.stdio.fp = NULL;
	442	}
	443	free(area);
	444	}
	445
	446	DECLSPEC SDL_Surface * SDLCALL
	447	SDL_LoadBMP_RW(SDL_RWops *src, int freesrc)
	448	{
	449	struct bmp_dib_v3 {
	450	unsigned char magic[2];
	451	uint32_t filesz;
	452	uint16_t creator1;
	453	uint16_t creator2;
	454	uint32_t bmp_offset;
	455	uint32_t header_sz;
	456	int32_t width;
	457	int32_t height;
	458	uint16_t nplanes;
	459	uint16_t bitspp;
	460	uint32_t compress_type;
	461	uint32_t bmp_bytesz;
462	int32_t hres;
463	int32_t vres;
464	uint32_t ncolors;
465	uint32_t nimpcolors;
466	} __attribute__((packed)) bmp;
467	SDL_Surface *ret = NULL;
468	int data_size, read_size;
3cb98c5e	469	uint8_t *tmp_buf = NULL;
0ec348b9	470	int i, bytespp;
	471	FILE *f;
	472
	473	trace("%p, %d", src, freesrc);
	474
	475	f = src->hidden.stdio.fp;
	476	if (f == NULL)
	477	goto out;
	478
	479	if (fread(&bmp, 1, sizeof(bmp), f) != sizeof(bmp)) {
	480	err("bmp read error");
	481	goto out;
	482	}
	483
	484	if (bmp.magic[0] != 'B' \|\| bmp.magic[1] != 'M' \|\| bmp.header_sz != 40) {
	485	err("unhandled BMP format, sz=%d", bmp.header_sz);
	486	goto out;
	487	}
	488
	489	if ((unsigned)bmp.width > 0xffff \|\| (unsigned)bmp.height > 0xffff) {
	490	err("BMP size %dx%d out of range", bmp.width, bmp.height);
	491	goto out;
	492	}
	493
	494	if (bmp.bitspp != 4) {
	495	err("BMP unhandled bpp: %d", bmp.bitspp);
	496	goto out;
	497	}
	498
	499	bytespp = bmp.bitspp < 8 ? 1 : (bmp.bitspp + 7) / 8;
	500	data_size = bmp.width * bmp.height * bytespp;
	501	tmp_buf = malloc(data_size);
	502	if (tmp_buf == NULL)
	503	goto out;
	504
	505	if (fseek(f, bmp.bmp_offset, SEEK_SET) != 0) {
	506	err("BMP seek error");
	507	goto out;
	508	}
	509
	510	read_size = bmp.width * bmp.bitspp / 8;
	511	for (i = bmp.height - 1; i > 0; i--) {
	512	if (fread((char )tmp_buf + i read_size, 1, read_size, f) != read_size) {
	513	err("BMP read error");
	514	goto out;
	515	}
	516	}
	517
	518	if (bmp.bitspp == 4) {
	519	// just convert to 8bpp now
	520	int c = bmp.width * bmp.height / 2;
	521	uint8_t *p = tmp_buf;
	522	for (i = c - 1; i >= 0; i--) {
	523	p[i * 2 + 1] = p[i] & 0xf;
	524	p[i * 2] = p[i] >> 4;
	525	}
	526	}
	527
	528	ret = alloc_surface(bmp.width, bmp.height, 8);
	529	if (ret == NULL)
	530	goto out;
	531
	532	ret->pixels = tmp_buf;
	533	tmp_buf = NULL;
534
535	out:
536	if (tmp_buf != NULL)
537	free(tmp_buf);
538	if (freesrc)
539	SDL_FreeRW(src);
540
541	return ret;
542	}
543
544	DECLSPEC SDL_Surface * SDLCALL
545	SDL_ConvertSurface(SDL_Surface src, SDL_PixelFormat fmt, Uint32 flags)
546	{
547	SDL_Surface *ret;
548	void *data;
549
550	trace("%p, %p, %08x", src, fmt, flags);
551
552	if (src->format->BitsPerPixel != fmt->BitsPerPixel) {
553	err("convert: not implemented");
554	return NULL;
555	}
556
557	data = malloc(src->pitch * src->h);
558	if (data == NULL)
559	return NULL;
560	memcpy(data, src->pixels, src->pitch * src->h);
561
562	ret = alloc_surface(src->w, src->h, fmt->BitsPerPixel);
563	if (ret == NULL) {
564	free(data);
565	return NULL;
566	}
567	ret->pixels = data;
568	return ret;
569	}
570
571	DECLSPEC int SDLCALL
572	SDL_SetColorKey(SDL_Surface *surface, Uint32 flag, Uint32 key)
573	{
574	trace("%p, %08x, %04x", surface, flag, key);
575	return 0;
576	}
577
0ec348b9	578	DECLSPEC void SDLCALL
	579	SDL_WM_SetCaption(const char title, const char icon)
	580	{
	581	trace("%s, %s", title, icon);
	582	}
	583
	584	DECLSPEC int SDLCALL
	585	SDL_ShowCursor(int toggle)
	586	{
	587	trace("%d", toggle);
	588	return 0;
	589	}
	590
	591	DECLSPEC char * SDLCALL
	592	SDL_GetError(void)
	593	{
	594	trace("");
	595
	596	return "";
	597	}
	598