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

/*
 * (C) Gražvydas "notaz" Ignotas, 2010
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING file in the top-level directory.
 */

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

#include "omapsdl.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;
}

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

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