#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <freetype/freetype.h>

#include "SDL.h"
#include "SDL_ttf.h"

/* Macro to convert a character to a Unicode value -- assume already Unicode */
#define UNICODE(c)	c

/* Round a float up to the nearest integeter and return that integer */
static int round(float x)
{
	int value;

	value = (int)x;
	if ( x > value ) {
		value = value + 1;
	} else
	if ( x < value ) {
		value = value - 1;
	}
	return value;
}

/* The structure used to hold glyph information (cached) */
struct glyph {
	int cached;
	TT_Raster_Map bitmap;
	TT_Raster_Map pixmap;
	int minx;
	int maxx;
	int miny;
	int maxy;
	int advance;
};

/* The structure used to hold internal font information */
struct _TTF_Font {
	TT_Face face;
	TT_Instance inst;
	TT_Glyph glyph;
	TT_CharMap map;

	/* Font metrics */
	int pointsize;
	int height;  /* ascent - descent */
	float ascent;
	float descent;
	float lineskip;

	/* The font style */
	int style;

	/* Extra width in glyph bounds for text styles */
	int glyph_overhang;
	float glyph_italics;

	/* For now, support Latin-1 character set caching */
	struct glyph *current;
	struct glyph cache[256];
	struct glyph scratch;
};

/* The FreeType font engine */
static TT_Engine engine;

int TTF_Init(void)
{
	int error;

	error = TT_Init_FreeType(&engine);
	if ( error ) {
		SDL_SetError("Couldn't init FreeType engine");
		return(-1);
	}
	return(0);
}

TTF_Font *TTF_OpenFont(const char *file, int ptsize)
{
	TTF_Font *font;
	TT_Face_Properties properties;
	TT_Instance_Metrics imetrics;
	int i, n;
	TT_UShort platform, encoding;
	TT_Error error;

	font = (TTF_Font *)malloc(sizeof(*font));
	if ( font == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	memset(font, 0, sizeof(*font));

	/* Open the font and create ancillary data */
	error = TT_Open_Face(engine, file, &font->face);
	if ( error ) {
		SDL_SetError("Couldn't load font file");
		free(font);
		return(NULL);
	}
	error = TT_New_Glyph(font->face, &font->glyph);
	if ( error ) {
		SDL_SetError("Couldn't create glyph container");
		TTF_CloseFont(font);
		return(NULL);
	}
	error = TT_New_Instance(font->face, &font->inst);
	if ( error ) {
		SDL_SetError("Couldn't create font instance");
		TTF_CloseFont(font);
		return(NULL);
	}

	/* Set the display resolution */
	error = TT_Set_Instance_Resolutions(font->inst, 72, 72);
	if ( error ) {
		SDL_SetError("Couldn't set font resolution");
		TTF_CloseFont(font);
		return(NULL);
	}
	error = TT_Set_Instance_CharSize(font->inst, ptsize*64);
	if ( error ) {
		SDL_SetError("Couldn't set font size");
		TTF_CloseFont(font);
		return(NULL);
	}

	/* Get a Unicode mapping for this font */
	n = TT_Get_CharMap_Count(font->face);
	for ( i=0; i<n; ++i ) {
		TT_Get_CharMap_ID(font->face, i, &platform, &encoding);
		if ( ((platform == TT_PLATFORM_MICROSOFT) &&
		                  (encoding == TT_MS_ID_UNICODE_CS)) ||
		     ((platform == TT_PLATFORM_APPLE_UNICODE) &&
		                  (encoding == TT_APPLE_ID_DEFAULT)) ) {
			TT_Get_CharMap(font->face, i, &font->map);
			break;
		}
	}
	if ( i == n ) {
		SDL_SetError("Font doesn't have a Unicode mapping");
		TTF_CloseFont(font);
		return(NULL);
	}

	/* Get the font metrics for this font */
	TT_Get_Face_Properties(font->face, &properties );
	TT_Get_Instance_Metrics(font->inst, &imetrics);
	font->pointsize = imetrics.y_ppem;
	font->ascent = (float)properties.horizontal->Ascender /
	                properties.header->Units_Per_EM;
	font->ascent *= font->pointsize;
	font->descent = (float)properties.horizontal->Descender /
	                 properties.header->Units_Per_EM;
	font->descent *= font->pointsize;
	font->lineskip = (float)properties.horizontal->Line_Gap /
	                  properties.header->Units_Per_EM;
	font->lineskip *= font->pointsize;
	font->height = round(font->ascent - font->descent);

	/* Set the default font style */
	font->style = TTF_STYLE_NORMAL;
	font->glyph_overhang = font->pointsize/10;
	/* x offset = cos(((90.0-12)/360)*2*M_PI), or 12 degree angle */
	font->glyph_italics = 0.207;
	font->glyph_italics *= font->height;

	return(font);
}

static void Flush_Glyph(struct glyph *glyph)
{
	if ( glyph->bitmap.bitmap ) {
		free(glyph->bitmap.bitmap);
		glyph->bitmap.bitmap = 0;
	}
	if ( glyph->pixmap.bitmap ) {
		free(glyph->pixmap.bitmap);
		glyph->pixmap.bitmap = 0;
	}
	glyph->cached = 0;
}
	
static void Flush_Cache(TTF_Font *font)
{
	int i;

	for ( i=0; i<(sizeof font->cache)/(sizeof font->cache[0]); ++i ) {
		if ( font->cache[i].cached ) {
			Flush_Glyph(&font->cache[i]);
		}
	}
	if ( font->scratch.cached ) {
		Flush_Glyph(&font->scratch);
	}
}

static TT_Error Load_Glyph(TTF_Font *font, Uint16 ch, struct glyph *glyph)
{
	TT_UShort index;
	TT_Glyph_Metrics metrics;
	TT_Outline outline;
	int x_offset;
	int y_offset;
	TT_Error error;

	/* Load the glyph */
	index = TT_Char_Index(font->map, UNICODE(ch));
	error = TT_Load_Glyph(font->inst, font->glyph, index, TTLOAD_DEFAULT);
	if ( error ) return error;

	/* Get the bounding box */
	TT_Get_Glyph_Metrics(font->glyph, &metrics);
	glyph->minx = (metrics.bbox.xMin & -64) / 64;
	glyph->maxx = ((metrics.bbox.xMax + 63) & -64) / 64;
	glyph->miny = (metrics.bbox.yMin & -64) / 64;
	glyph->maxy = ((metrics.bbox.yMax + 63) & -64) / 64;
	glyph->advance = (metrics.advance & -64) / 64;

	/* Adjust for bold and italic text */
	if ( font->style & TTF_STYLE_BOLD ) {
		glyph->maxx += font->glyph_overhang;
	}
	if ( font->style & TTF_STYLE_ITALIC ) {
		glyph->maxx += round(font->glyph_italics);
	}

	/* Get the bitmap memory */
	glyph->bitmap.width = ((glyph->maxx - glyph->minx) + 7) & ~7;
	glyph->bitmap.rows = font->height;
	glyph->bitmap.cols = glyph->bitmap.width/8;
	glyph->bitmap.flow = TT_Flow_Down;
	glyph->bitmap.size = (glyph->bitmap.rows * glyph->bitmap.cols);
	if ( glyph->bitmap.size ) {
		glyph->bitmap.bitmap = malloc(glyph->bitmap.size);
		if ( ! glyph->bitmap.bitmap ) {
			error = TT_Err_Out_Of_Memory;
			goto was_error;
		}
		memset(glyph->bitmap.bitmap, 0, glyph->bitmap.size);
	} else {
		glyph->bitmap.bitmap = 0;
	}

	/* Get the pixmap memory */
	glyph->pixmap.width = ((glyph->maxx - glyph->minx) + 3) & ~3;
	glyph->pixmap.rows = font->height;
	glyph->pixmap.cols = glyph->pixmap.width;
	glyph->pixmap.flow = TT_Flow_Down;
	glyph->pixmap.size = (glyph->pixmap.rows * glyph->pixmap.cols);
	if ( glyph->pixmap.size ) {
		glyph->pixmap.bitmap = malloc(glyph->pixmap.size);
		if ( ! glyph->pixmap.bitmap ) {
			error = TT_Err_Out_Of_Memory;
			goto was_error;
		}
		memset(glyph->pixmap.bitmap, 0, glyph->pixmap.size);
	} else {
		glyph->pixmap.bitmap = 0;
	}

	/* Render the glyph into the bitmap and pixmap */
	error = TT_Get_Glyph_Outline(font->glyph, &outline);
	/* Handle the italic style */
	if ( font->style & TTF_STYLE_ITALIC ) {
		TT_Matrix shear;

		shear.xx = 1<<16;
		shear.xy = (int)(font->glyph_italics*(1<<16))/font->height;
		shear.yx = 0;
		shear.yy = 1<<16;
		TT_Transform_Outline(&outline, &shear);
	}
	x_offset = -glyph->minx * 64;
	y_offset = -round(font->descent) * 64;
	TT_Translate_Outline(&outline, x_offset, y_offset);
	error += TT_Get_Outline_Bitmap(engine, &outline, &glyph->bitmap);
	error += TT_Get_Outline_Pixmap(engine, &outline, &glyph->pixmap);
	/* Handle the bold style */
	if ( font->style & TTF_STYLE_BOLD ) {
		int row, col;
		int offset;
		int pixel;
		Uint8 *pixmap;

		/* The bitmap is easy, just render another copy */
		for ( offset=0; offset < font->glyph_overhang; ++offset ) {
			TT_Translate_Outline(&outline, 64, 0);
			error += TT_Get_Outline_Bitmap(engine,
			                               &outline,&glyph->bitmap);
		}
		x_offset += font->glyph_overhang*64;

		/* The pixmap is a little harder, we have to add and clamp */
		for ( row=glyph->pixmap.rows-1; row >= 0; --row ) {
			pixmap = (Uint8 *)glyph->pixmap.bitmap +
			                  row*glyph->pixmap.cols;
			for (offset=1; offset<=font->glyph_overhang; ++offset) {
				for (col=glyph->pixmap.cols-1; col > 0; --col) {
					pixel=(pixmap[col]+pixmap[col-1]);
					if ( pixel > 4 ) {
						pixel = 4;
					}
					pixmap[col] = (Uint8)pixel;
				}
			}
		}
	}
	TT_Translate_Outline(&outline, -x_offset, -y_offset);
was_error:
	if ( error ) {
		if ( glyph->bitmap.bitmap ) {
			free(glyph->bitmap.bitmap);
			glyph->bitmap.bitmap = 0;
		}
		if ( glyph->pixmap.bitmap ) {
			free(glyph->pixmap.bitmap);
			glyph->pixmap.bitmap = 0;
		}
		return error;
	}

	/* We're done, mark this glyph cached */
	glyph->cached = ch;
	return TT_Err_Ok;
}

static TT_Error Find_Glyph(TTF_Font *font, Uint16 ch)
{
	int retval;

	retval = 0;
	if ( ch < 256 ) {
		font->current = &font->cache[ch];
	} else {
		if ( font->scratch.cached != ch ) {
			Flush_Glyph(&font->scratch);
		}
		font->current = &font->scratch;
	}
	if ( ! font->current->cached ) {
		retval = Load_Glyph(font, ch, font->current);
	}
	return retval;
}

void TTF_CloseFont(TTF_Font *font)
{
	Flush_Cache(font);
	TT_Close_Face(font->face);
	free(font);
}

static Uint16 *ASCII_to_UNICODE(Uint16 *unicode, const char *text, int len)
{
	int i;

	for ( i=0; i < len; ++i ) {
		unicode[i] = ((const unsigned char *)text)[i];
	}
	unicode[i] = 0;

	return unicode;
}

static Uint16 *UTF8_to_UNICODE(Uint16 *unicode, const char *utf8, int len)
{
	int i, j;
	Uint16 ch;

	for ( i=0, j=0; i < len; ++i, ++j ) {
		ch = ((const unsigned char *)utf8)[i];
		if ( ch >= 0xF0 ) {
			ch  =  (Uint16)(utf8[i]&0x07) << 18;
			ch |=  (Uint16)(utf8[++i]&0x3F) << 12;
			ch |=  (Uint16)(utf8[++i]&0x3F) << 6;
			ch |=  (Uint16)(utf8[++i]&0x3F);
		} else
		if ( ch >= 0xE0 ) {
			ch  =  (Uint16)(utf8[i]&0x3F) << 12;
			ch |=  (Uint16)(utf8[++i]&0x3F) << 6;
			ch |=  (Uint16)(utf8[++i]&0x3F);
		} else
		if ( ch >= 0xC0 ) {
			ch  =  (Uint16)(utf8[i]&0x3F) << 6;
			ch |=  (Uint16)(utf8[++i]&0x3F);
		}
		unicode[j] = ch;
	}
	unicode[j] = 0;

	return unicode;
}

int TTF_FontHeight(TTF_Font *font)
{
	return(font->height);
}

int TTF_FontAscent(TTF_Font *font)
{
       return(round(font->ascent));
}

int TTF_FontDescent(TTF_Font *font)
{
	return(round(font->descent));
}

int TTF_FontLineSkip(TTF_Font *font)
{
	return(round(font->lineskip));
}

int TTF_GlyphMetrics(TTF_Font *font, Uint16 ch,
                     int* minx, int* maxx, int* miny, int* maxy, int* advance)
{
	TT_Error error;

	error = Find_Glyph(font, ch);

	if ( error ) {
		return -1;
	}

	if ( minx ) {
		*minx = font->current->minx;
	}
	if ( maxx ) {
		*maxx = font->current->maxx;
	}
	if ( miny ) {
		*miny = font->current->miny;
	}
	if ( maxy ) {
		*maxy = font->current->maxy;
	}
	if ( advance ) {
		*advance = font->current->advance;
	}
	return 0;
}

int TTF_SizeText(TTF_Font *font, const char *text, int *w, int *h)
{
	Uint16 *unicode_text;
	int unicode_len;
	int status;

	/* Copy the Latin-1 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return -1;
	}
	ASCII_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	status = TTF_SizeUNICODE(font, unicode_text, w, h);

	/* Free the text buffer and return */
	free(unicode_text);
	return status;
}

int TTF_SizeUTF8(TTF_Font *font, const char *text, int *w, int *h)
{
	Uint16 *unicode_text;
	int unicode_len;
	int status;

	/* Copy the UTF-8 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return -1;
	}
	UTF8_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	status = TTF_SizeUNICODE(font, unicode_text, w, h);

	/* Free the text buffer and return */
	free(unicode_text);
	return status;
}

int TTF_SizeUNICODE(TTF_Font *font, const Uint16 *text, int *w, int *h)
{
	int status;
	const Uint16 *ch;
	int x, z, minx, maxx;
	TT_Error error;

	/* Initialize everything to 0 */
	status = 0;
	minx = maxx = 0;

	/* Load each character and sum it's bounding box */
	x= 0;
	for ( ch=text; *ch; ++ch ) {
		error = Find_Glyph(font, *ch);
		if ( ! error ) {
			z = x + font->current->minx;
			if ( minx > z ) {
				minx = z;
			}
			if ( font->style & TTF_STYLE_BOLD ) {
				x += font->glyph_overhang;
			}
			if ( font->current->advance > font->current->maxx ) {
				z = x + font->current->advance;
			} else {
				z = x + font->current->maxx;
			}
			if ( maxx < z ) {
				maxx = z;
			}
			x += font->current->advance;
		}
	}

	/* Fill the bounds rectangle */
	if ( w ) {
		*w = (maxx - minx);
	}
	if ( h ) {
		*h = font->height;
	}
	return status;
}

/* Convert the Latin-1 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderText_Solid(TTF_Font *font,
				const char *text, SDL_Color fg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the Latin-1 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	ASCII_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Solid(font, unicode_text, fg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

/* Convert the UTF-8 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderUTF8_Solid(TTF_Font *font,
				const char *text, SDL_Color fg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the UTF-8 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	UTF8_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Solid(font, unicode_text, fg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

SDL_Surface *TTF_RenderUNICODE_Solid(TTF_Font *font,
				const Uint16 *text, SDL_Color fg)
{
	int xstart, width;
	int w, h;
	SDL_Surface *textbuf;
	SDL_Palette *palette;
	const Uint16 *ch;
	Uint8 *src, *dst;
	int row, col;
	TT_Error error;

	/* Get the dimensions of the text surface */
	if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) {
		TTF_SetError("Text has zero width");
		return(NULL);
	}

	/* Create the target surface */
	width = w;
	w = (w+7)&~7;
	textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 8, 0, 0, 0, 0);
	if ( textbuf == NULL ) {
		return(NULL);
	}

	/* Fill the palette with the foreground color */
	palette = textbuf->format->palette;
	palette->colors[0].r = 255-fg.r;
	palette->colors[0].g = 255-fg.g;
	palette->colors[0].b = 255-fg.b;
	palette->colors[1].r = fg.r;
	palette->colors[1].g = fg.g;
	palette->colors[1].b = fg.b;
	SDL_SetColorKey(textbuf, SDL_SRCCOLORKEY, 0);

	/* Load and render each character */
	xstart = 0;
	for ( ch=text; *ch; ++ch ) {
		error = Find_Glyph(font, *ch);
		if ( ! error ) {
			w = font->current->bitmap.width;
			src = (Uint8 *)font->current->bitmap.bitmap;
			for ( row = 0; row < h; ++row ) {
				dst = (Uint8 *)textbuf->pixels +
				               row * textbuf->pitch +
				               xstart + font->current->minx;
				for ( col = 0; col < w; col += 8 ) {
					Uint8 c = *src++;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
					c <<= 1;
					*dst++ |= (c&0x80)>>7;
				}
			}
			xstart += font->current->advance;
			if ( font->style & TTF_STYLE_BOLD ) {
				xstart += font->glyph_overhang;
			}
		}
	}
	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch,
								1, width);
	}
	return(textbuf);
}

SDL_Surface *TTF_RenderGlyph_Solid(TTF_Font *font, Uint16 ch, SDL_Color fg)
{
	SDL_Surface *textbuf;
	SDL_Palette *palette;
	Uint8 *src, *dst;
	int row, col;
	TT_Error error;
	struct glyph *glyph;

	/* Get the glyph itself */
	error = Find_Glyph(font, ch);
	if ( error ) {
		return(NULL);
	}
	glyph = font->current;

	/* Create the target surface */
	textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE,
	              glyph->bitmap.width, glyph->bitmap.rows, 8, 0, 0, 0, 0);
	if ( ! textbuf ) {
		return(NULL);
	}

	/* Fill the palette with the foreground color */
	palette = textbuf->format->palette;
	palette->colors[0].r = 255-fg.r;
	palette->colors[0].g = 255-fg.g;
	palette->colors[0].b = 255-fg.b;
	palette->colors[1].r = fg.r;
	palette->colors[1].g = fg.g;
	palette->colors[1].b = fg.b;
	SDL_SetColorKey(textbuf, SDL_SRCCOLORKEY, 0);

	/* Load and render each character */
	src = (Uint8 *)font->current->bitmap.bitmap;
	for ( row = 0; row < textbuf->h; ++row ) {
		dst = (Uint8 *)textbuf->pixels + row * textbuf->pitch;
		for ( col = 0; col < textbuf->w; col += 8 ) {
			Uint8 c = *src++;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
			c <<= 1;
			*dst++ |= (c&0x80)>>7;
		}
	}

	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch,
							1, textbuf->w);
	}
	return(textbuf);
}


/* Convert the Latin-1 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderText_Shaded(TTF_Font *font,
				const char *text, SDL_Color fg, SDL_Color bg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the Latin-1 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	ASCII_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Shaded(font, unicode_text, fg, bg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

/* Convert the UTF-8 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderUTF8_Shaded(TTF_Font *font,
				const char *text, SDL_Color fg, SDL_Color bg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the UTF-8 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	UTF8_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Shaded(font, unicode_text, fg, bg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

SDL_Surface *TTF_RenderUNICODE_Shaded(TTF_Font *font,
				const Uint16 *text, SDL_Color fg, SDL_Color bg)
{
	int xstart, width;
	int w, h;
	SDL_Surface *textbuf;
	SDL_Palette *palette;
	int index;
	int rdiff, gdiff, bdiff;
	const Uint16 *ch;
	Uint8 *src, *dst;
	int row, col;
	TT_Error error;

	/* Get the dimensions of the text surface */
	if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) {
		TTF_SetError("Text has zero width");
		return(NULL);
	}

	/* Create the target surface */
	width = w;
	w = (w+3)&~3;
	textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 8, 0, 0, 0, 0);
	if ( textbuf == NULL ) {
		return(NULL);
	}

	/* Fill the palette with 5 levels of shading from bg to fg */
	palette = textbuf->format->palette;
	rdiff = fg.r - bg.r;
	gdiff = fg.g - bg.g;
	bdiff = fg.b - bg.b;
	for ( index=0; index<5; ++index ) {
		palette->colors[index].r = bg.r + (index*rdiff)/4;
		palette->colors[index].g = bg.g + (index*gdiff)/4;
		palette->colors[index].b = bg.b + (index*bdiff)/4;
	}
	/* The other 3 levels are used as overflow when ORing pixels */
	for ( ; index<8; ++index ) {
		palette->colors[index] = palette->colors[4];
	}

	/* Load and render each character */
	xstart = 0;
	for ( ch=text; *ch; ++ch ) {
		error = Find_Glyph(font, *ch);
		if ( ! error ) {
			w = font->current->pixmap.width;
			src = (Uint8 *)font->current->pixmap.bitmap;
			for ( row = 0; row < h; ++row ) {
				dst = (Uint8 *)textbuf->pixels +
				               row * textbuf->pitch +
				               xstart + font->current->minx;
				for ( col=w; col>0; col -= 4 ) {
					*dst++ |= *src++;
					*dst++ |= *src++;
					*dst++ |= *src++;
					*dst++ |= *src++;
				}
			}
			xstart += font->current->advance;
			if ( font->style & TTF_STYLE_BOLD ) {
				xstart += font->glyph_overhang;
			}
		}
	}
	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch,
								4, width);
	}
	return(textbuf);
}

SDL_Surface *TTF_RenderGlyph_Shaded(TTF_Font *font,
				Uint16 ch, SDL_Color fg, SDL_Color bg)
{
	SDL_Surface *textbuf;
	SDL_Palette *palette;
	int index;
	int rdiff, gdiff, bdiff;
	Uint8 *src, *dst;
	int row, col;
	TT_Error error;
	struct glyph *glyph;

	/* Get the glyph itself */
	error = Find_Glyph(font, ch);
	if ( error ) {
		return(NULL);
	}
	glyph = font->current;

	/* Create the target surface */
	textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE,
	              glyph->pixmap.width, glyph->pixmap.rows, 8, 0, 0, 0, 0);
	if ( ! textbuf ) {
		return(NULL);
	}

	/* Fill the palette with 5 levels of shading from bg to fg */
	palette = textbuf->format->palette;
	rdiff = fg.r - bg.r;
	gdiff = fg.g - bg.g;
	bdiff = fg.b - bg.b;
	for ( index=0; index<5; ++index ) {
		palette->colors[index].r = bg.r + (index*rdiff)/4;
		palette->colors[index].g = bg.g + (index*gdiff)/4;
		palette->colors[index].b = bg.b + (index*bdiff)/4;
	}

	/* Copy the character from the pixmap */
	for ( row=0; row<textbuf->h; ++row ) {
		src = glyph->pixmap.bitmap + row * glyph->pixmap.cols;
		dst = (Uint8 *)textbuf->pixels + row * textbuf->pitch;
		memcpy(dst, src, glyph->pixmap.cols);
	}

	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		memset((Uint8 *)textbuf->pixels+row_offset*textbuf->pitch,
							4, glyph->pixmap.cols);
	}
	return(textbuf);
}

/* Convert the Latin-1 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderText_Blended(TTF_Font *font,
				const char *text, SDL_Color fg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the Latin-1 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	ASCII_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Blended(font, unicode_text, fg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

/* Convert the UTF-8 text to UNICODE and render it
*/
SDL_Surface *TTF_RenderUTF8_Blended(TTF_Font *font,
				const char *text, SDL_Color fg)
{
	SDL_Surface *textbuf;
	Uint16 *unicode_text;
	int unicode_len;

	/* Copy the UTF-8 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text = (Uint16 *)malloc((unicode_len+1)*(sizeof *unicode_text));
	if ( unicode_text == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	UTF8_to_UNICODE(unicode_text, text, unicode_len);

	/* Render the new text */
	textbuf = TTF_RenderUNICODE_Blended(font, unicode_text, fg);

	/* Free the text buffer and return */
	free(unicode_text);
	return(textbuf);
}

SDL_Surface *TTF_RenderUNICODE_Blended(TTF_Font *font,
				const Uint16 *text, SDL_Color fg)
{
	int xstart, width;
	int w, h;
	SDL_Surface *textbuf;
#if SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) >= \
    SDL_VERSIONNUM(1, 1, 5)			/* The great alpha flip */
	Uint32 alpha_table[] = {
		(0)<<24,      (255-128)<<24, (255-64)<<24, (255-32)<<24,
		(255)<<24,    (255)<<24,     (255)<<24,    (255)<<24
	};
#else
	Uint32 alpha_table[] = {
		(255<<24), (128<<24), (64<<24), (32<<24), 0, 0, 0, 0
	};
#endif
	Uint32 pixel;
	const Uint16 *ch;
	Uint8 *src;
	Uint32 *dst;
	int row, col;
	TT_Error error;

	/* Get the dimensions of the text surface */
	if ( (TTF_SizeUNICODE(font, text, &w, &h) < 0) || !w ) {
		TTF_SetError("Text has zero width");
		return(NULL);
	}

	/* Create the target surface, 32-bit ARGB format */
	width = w;
	w = (w+3)&~3;
	textbuf = SDL_AllocSurface(SDL_SWSURFACE, w, h, 32,
	                           0x00FF0000, 0x0000FF00, 0x000000FF,
	                           0xFF000000);
	if ( textbuf == NULL ) {
		return(NULL);
	}

	/* Load and render each character */
	xstart = 0;
	for ( ch=text; *ch; ++ch ) {
		error = Find_Glyph(font, *ch);
		if ( ! error ) {
			w = font->current->pixmap.width;
			src = (Uint8 *)font->current->pixmap.bitmap;
			for ( row = 0; row < h; ++row ) {
				dst = (Uint32 *)textbuf->pixels +
				               row * textbuf->pitch/4 +
				               xstart + font->current->minx;
				for ( col=w; col>0; col -= 4 ) {
					*dst++ |= *src++;
					*dst++ |= *src++;
					*dst++ |= *src++;
					*dst++ |= *src++;
				}
			}
			xstart += font->current->advance;
			if ( font->style & TTF_STYLE_BOLD ) {
				xstart += font->glyph_overhang;
			}
		}
	}

	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		dst = (Uint32 *)textbuf->pixels+row_offset*textbuf->pitch/4;
		for ( col=width; col > 0; ++col ) {
			*dst++ = 4;
		}
	}

	/* Build the alpha table */
	pixel = (fg.r<<16)|(fg.g<<8)|fg.b;
	for ( xstart = 0; xstart < 8; ++xstart ) {
		alpha_table[xstart] |= pixel;
	}

	/* Transform the alpha values */
	for ( row = 0; row < textbuf->h; ++row ) {
		dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4;
		for ( col=textbuf->w; col>0; col -= 4 ) {
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
		}
	}
	return(textbuf);
}

SDL_Surface *TTF_RenderGlyph_Blended(TTF_Font *font, Uint16 ch, SDL_Color fg)
{
	SDL_Surface *textbuf;
#if SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL) >= \
    SDL_VERSIONNUM(1, 1, 5)			/* The great alpha flip */
	Uint32 alpha_table[] = {
		(0)<<24,      (255-128)<<24, (255-64)<<24, (255-32)<<24,
		(255)<<24,    (255)<<24,     (255)<<24,    (255)<<24
	};
#else
	Uint32 alpha_table[] = {
		(255<<24), (128<<24), (64<<24), (32<<24), 0, 0, 0, 0
	};
#endif
	Uint32 pixel;
	Uint8 *src;
	Uint32 *dst;
	int row, col;
	TT_Error error;
	struct glyph *glyph;

	/* Get the glyph itself */
	error = Find_Glyph(font, ch);
	if ( error ) {
		return(NULL);
	}
	glyph = font->current;

	/* Create the target surface, 32-bit ARGB format */
	textbuf = SDL_CreateRGBSurface(SDL_SWSURFACE,
	              glyph->pixmap.width, glyph->pixmap.rows, 32,
	              0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000);
	if ( ! textbuf ) {
		return(NULL);
	}

	/* Copy the character from the pixmap */
	for ( row=0; row<textbuf->h; ++row ) {
		src = glyph->pixmap.bitmap + row * glyph->pixmap.cols;
		dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4;
		for ( col=0; col<glyph->pixmap.cols; ++col ) {
			*dst++ = *src++;
		}
	}

	/* Handle the underline style */
	if ( font->style & TTF_STYLE_UNDERLINE ) {
		int row_offset;

		row_offset = round(font->ascent) + 1;
		if ( row_offset > font->height ) {
			row_offset = font->height-1;
		}
		dst = (Uint32 *)textbuf->pixels+row_offset*textbuf->pitch/4;
		for ( col=glyph->pixmap.cols; col > 0; ++col ) {
			*dst++ = 4;
		}
	}

	/* Build the alpha table */
	pixel = (fg.r<<16)|(fg.g<<8)|fg.b;
	for ( col = 0; col < 8; ++col ) {
		alpha_table[col] |= pixel;
	}

	/* Transform the alpha values */
	for ( row = 0; row < textbuf->h; ++row ) {
		dst = (Uint32 *)textbuf->pixels + row * textbuf->pitch/4;
		for ( col=textbuf->w; col>0; col -= 4 ) {
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
			*dst = alpha_table[*dst];
			++dst;
		}
	}
	return(textbuf);
}

void TTF_SetFontStyle(TTF_Font *font, int style)
{
	font->style = style;
	Flush_Cache(font);
}

int TTF_GetFontStyle(TTF_Font *font)
{
	return(font->style);
}

void TTF_Quit(void)
{
	TT_Done_FreeType(engine);
}