fw_builder/bootsplash/ttf.c

/* render true type fonts to fb0 
 *
 * (w) by stepan@suse.de, code reused from SDL_ttf
 *
 */

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

#include <freetype/freetype.h>
#include <freetype/ftoutln.h>
#include <freetype/ttnameid.h>

#include "ttf.h"

#define DEFAULT_PTSIZE  18


/* FIXME: Right now we assume the gray-scale renderer Freetype is using
 *    supports 256 shades of gray, but we should instead key off of num_grays
 *       in the result FT_Bitmap after the FT_Render_Glyph() call. */
#define NUM_GRAYS       256


extern unsigned int fbbytes, fbx, fby, fblinelen, alpha;
extern unsigned char *framebuffer;

extern unsigned int fbypos, fbxpos;

unsigned char *TTF_RenderUNICODE_Shaded(TTF_Font * font,
					const unsigned short *text,
					unsigned int fg, unsigned int bg);

/* Cached glyph information */
typedef struct cached_glyph {
	int stored;
	FT_UInt index;
	FT_Bitmap bitmap;
	FT_Bitmap pixmap;
	int minx;
	int maxx;
	int miny;
	int maxy;
	int yoffset;
	int advance;
	unsigned short cached;
} c_glyph;

struct _TTF_Font {
	/* Freetype2 maintains all sorts of useful info itself */
	FT_Face face;

	/* We'll cache these ourselves */
	int height;
	int ascent;
	int descent;
	int lineskip;

	/* The font style */
	int style;

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

	/* Information in the font for underlining */
	int underline_offset;
	int underline_height;

	/* Cache for style-transformed glyphs */
	c_glyph *current;
	c_glyph cache[256];
	c_glyph scratch;
};

static void Flush_Glyph(c_glyph * glyph);

static void Flush_Cache(TTF_Font * font)
{
	int i;
	int size = sizeof(font->cache) / sizeof(font->cache[0]);

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

	}
	if (font->scratch.cached) {
		Flush_Glyph(&font->scratch);
	}

}


/* character conversion */

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


static unsigned short *ASCII_to_UNICODE(unsigned short *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;
}

#if 0
static unsigned short *UTF8_to_UNICODE(unsigned short *unicode,
				       const char *utf8, int len)
{
	int i, j;
	unsigned short ch;

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

	return unicode;
}
#endif

/* TTF stuff */

static FT_Library library;
static int TTF_initialized = 0;

int TTF_Init(void)
{
	int status;
	FT_Error error;

	status = 0;
	error = FT_Init_FreeType(&library);
	if (error) {
		fprintf(stderr, "Couldn't init FreeType engine %d\n",
			error);
		status = -1;
	} else {
		TTF_initialized = 1;
	}
	return status;
}

void TTF_Quit(void)
{
	if (TTF_initialized) {
		FT_Done_FreeType(library);
	}
	TTF_initialized = 0;
}

#if 0
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) {
		TTF_SetError("Out of memory");
		return (NULL);
	}
	ASCII_to_UNICODE(unicode_text, text, unicode_len);

	RenderUnicode(font, unicode_text, fg);

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

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

unsigned char *TTF_RenderText_Shaded(TTF_Font * font, const char *text,
				     unsigned int fg, unsigned int bg)
{
	unsigned char *textbuf;
	unsigned short *unicode_text;
	int unicode_len;

	/* Copy the Latin-1 text to a UNICODE text buffer */
	unicode_len = strlen(text);
	unicode_text =
	    (unsigned short *) malloc((unicode_len + 1) *
				      (sizeof *unicode_text));
	if (unicode_text == NULL) {
		printf("Out of memory\n");
		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);
}


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

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


TTF_Font *TTF_OpenFontIndex(const char *file, int ptsize, long index)
{
	TTF_Font *font;
	FT_Error error;
	FT_Face face;
	FT_Fixed scale;

	extern int strict_font;

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

	/* Open the font and create ancillary data */
	error = FT_New_Face(library, file, 0, &font->face);

	if (error && !strict_font)
		error =
		    FT_New_Memory_Face(library,
				       (const FT_Byte *) luxisri_ttf,
				       LUXISRI_SIZE, 0, &font->face);

	if (error) {
		printf("Couldn't load font file\n");
		free(font);
		return NULL;
	}

	if (index != 0) {
		if (font->face->num_faces > index) {
			FT_Done_Face(font->face);
			error =
			    FT_New_Face(library, file, index, &font->face);
			if (error) {
				printf("Couldn't get font face\n");
				free(font);
				return NULL;
			}
		} else {
			fprintf(stderr, "No such font face\n");
			free(font);
			return NULL;
		}
	}
	face = font->face;

	/* Make sure that our font face is scalable (global metrics) */
	if (!FT_IS_SCALABLE(face)) {
		fprintf(stderr, "Font face is not scalable\n");
		TTF_CloseFont(font);
		return NULL;
	}
	/* Set the character size and use default DPI (72) */
	error = FT_Set_Char_Size(font->face, 0, ptsize * 64, 0, 0);
	if (error) {
		fprintf(stderr, "Couldn't set font size\n");
		TTF_CloseFont(font);
		return NULL;
	}

	/* Get the scalable font metrics for this font */
	scale = face->size->metrics.y_scale;
	font->ascent = FT_CEIL(FT_MulFix(face->bbox.yMax, scale));
	font->descent = FT_CEIL(FT_MulFix(face->bbox.yMin, scale));
	font->height = font->ascent - font->descent + /* baseline */ 1;
	font->lineskip = FT_CEIL(FT_MulFix(face->height, scale));
	font->underline_offset =
	    FT_FLOOR(FT_MulFix(face->underline_position, scale));
	font->underline_height =
	    FT_FLOOR(FT_MulFix(face->underline_thickness, scale));
	if (font->underline_height < 1) {
		font->underline_height = 1;
	}
#ifdef DEBUG_FONTS
	printf("Font metrics:\n");
	printf("\tascent = %d, descent = %d\n",
	       font->ascent, font->descent);
	printf("\theight = %d, lineskip = %d\n",
	       font->height, font->lineskip);
	printf("\tunderline_offset = %d, underline_height = %d\n",
	       font->underline_offset, font->underline_height);
#endif

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

	return font;
}


TTF_Font *TTF_OpenFont(const char *file, int ptsize)
{
	return TTF_OpenFontIndex(file, ptsize, 0);
}


static void Flush_Glyph(c_glyph * glyph)
{
	glyph->stored = 0;
	glyph->index = 0;
	if (glyph->bitmap.buffer) {
		free(glyph->bitmap.buffer);
		glyph->bitmap.buffer = 0;
	}
	if (glyph->pixmap.buffer) {
		free(glyph->pixmap.buffer);
		glyph->pixmap.buffer = 0;
	}
	glyph->cached = 0;
}

static FT_Error Load_Glyph(TTF_Font * font, unsigned short ch,
			   c_glyph * cached, int want)
{
	FT_Face face;
	FT_Error error;
	FT_GlyphSlot glyph;
	FT_Glyph_Metrics *metrics;
	FT_Outline *outline;

	assert(font);
	assert(font->face);

	face = font->face;

	/* Load the glyph */
	if (!cached->index) {
		cached->index = FT_Get_Char_Index(face, ch);
	}
	error = FT_Load_Glyph(face, cached->index, FT_LOAD_DEFAULT);
	if (error) {
		return error;
	}
	/* Get our glyph shortcuts */
	glyph = face->glyph;
	metrics = &glyph->metrics;
	outline = &glyph->outline;

	/* Get the glyph metrics if desired */
	if ((want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS)) {
		/* Get the bounding box */
		cached->minx = FT_FLOOR(metrics->horiBearingX);
		cached->maxx = cached->minx + FT_CEIL(metrics->width);
		cached->maxy = FT_FLOOR(metrics->horiBearingY);
		cached->miny = cached->maxy - FT_CEIL(metrics->height);
		cached->yoffset = font->ascent - cached->maxy;
		cached->advance = FT_CEIL(metrics->horiAdvance);

		/* Adjust for bold and italic text */
		if (font->style & TTF_STYLE_BOLD) {
			cached->maxx += font->glyph_overhang;
		}
		if (font->style & TTF_STYLE_ITALIC) {
			cached->maxx += (int) ceil(font->glyph_italics);
		}
		cached->stored |= CACHED_METRICS;
	}

	if (((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP))
	    || ((want & CACHED_PIXMAP)
		&& !(cached->stored & CACHED_PIXMAP))) {
		int mono = (want & CACHED_BITMAP);
		int i;
		FT_Bitmap *src;
		FT_Bitmap *dst;

		/* Handle the italic style */
		if (font->style & TTF_STYLE_ITALIC) {
			FT_Matrix shear;

			shear.xx = 1 << 16;
			shear.xy = (int) (font->glyph_italics * (1 << 16))
			    / font->height;
			shear.yx = 0;
			shear.yy = 1 << 16;

			FT_Outline_Transform(outline, &shear);
		}

		/* Render the glyph */
		if (mono) {
			error =
			    FT_Render_Glyph(glyph, ft_render_mode_mono);
		} else {
			error =
			    FT_Render_Glyph(glyph, ft_render_mode_normal);
		}
		if (error) {
			return error;
		}

		/* Copy over information to cache */
		src = &glyph->bitmap;
		if (mono) {
			dst = &cached->bitmap;
		} else {
			dst = &cached->pixmap;
		}
		memcpy(dst, src, sizeof(*dst));
		if (mono) {
			dst->pitch *= 8;
		}

		/* Adjust for bold and italic text */
		if (font->style & TTF_STYLE_BOLD) {
			int bump = font->glyph_overhang;
			dst->pitch += bump;
			dst->width += bump;
		}
		if (font->style & TTF_STYLE_ITALIC) {
			int bump = (int) ceil(font->glyph_italics);
			dst->pitch += bump;
			dst->width += bump;
		}

		if (dst->rows != 0) {
			dst->buffer = malloc(dst->pitch * dst->rows);
			if (!dst->buffer) {
				return FT_Err_Out_Of_Memory;
			}
			memset(dst->buffer, 0, dst->pitch * dst->rows);

			for (i = 0; i < src->rows; i++) {
				int soffset = i * src->pitch;
				int doffset = i * dst->pitch;
				if (mono) {
					unsigned char *srcp = src->buffer +
					    soffset;
					unsigned char *dstp = dst->buffer +
					    doffset;
					int j;
					for (j = 0; j < src->width; j += 8) {
						unsigned char ch = *srcp++;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
						ch <<= 1;
						*dstp++ = (ch & 0x80) >> 7;
					}
				} else {
					memcpy(dst->buffer + doffset,
					       src->buffer + soffset,
					       src->pitch);
				}
			}
		}

		/* Handle the bold style */
		if (font->style & TTF_STYLE_BOLD) {
			int row;
			int col;
			int offset;
			int pixel;
			unsigned char *pixmap;

			/* The pixmap is a little hard, we have to add and clamp */
			for (row = dst->rows - 1; row >= 0; --row) {
				pixmap =
				    (unsigned char *) dst->buffer +
				    row * dst->pitch;
				for (offset = 1;
				     offset <= font->glyph_overhang;
				     ++offset) {
					for (col = dst->width - 1; col > 0;
					     --col) {
						pixel =
						    (pixmap[col] +
						     pixmap[col - 1]);
						if (pixel > NUM_GRAYS - 1) {
							pixel =
							    NUM_GRAYS - 1;
						}
						pixmap[col] =
						    (unsigned char) pixel;
					}
				}
			}
		}

		/* Mark that we rendered this format */
		if (mono) {
			cached->stored |= CACHED_BITMAP;
		} else {
			cached->stored |= CACHED_PIXMAP;
		}
	}

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

	return 0;
}


static FT_Error Find_Glyph(TTF_Font * font, unsigned short ch, int want)
{
	int 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->stored & want) != want) {
		retval = Load_Glyph(font, ch, font->current, want);
	}
	return retval;
}

int TTF_SizeUNICODE(TTF_Font * font, const unsigned short *text, int *w,
		    int *h)
{
	int status;
	const unsigned short *ch;
	int x, z;
	int minx, maxx;
	int miny, maxy;
	c_glyph *glyph;
	FT_Error error;

	/* Initialize everything to 0 */
	if (!TTF_initialized) {
		return -1;
	}
	status = 0;
	minx = maxx = 0;
	miny = maxy = 0;

	/* Load each character and sum it's bounding box */
	x = 0;
	for (ch = text; *ch; ++ch) {
		error = Find_Glyph(font, *ch, CACHED_METRICS);
		if (error) {
			return -1;
		}
		glyph = font->current;

		z = x + glyph->minx;
		if (minx > z) {
			minx = z;
		}
		if (font->style & TTF_STYLE_BOLD) {
			x += font->glyph_overhang;
		}
		if (glyph->advance > glyph->maxx) {
			z = x + glyph->advance;
		} else {
			z = x + glyph->maxx;
		}
		if (maxx < z) {
			maxx = z;
		}
		x += glyph->advance;

		if (glyph->miny < miny) {
			miny = glyph->miny;
		}
		if (glyph->maxy > maxy) {
			maxy = glyph->maxy;
		}
	}

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

	return status;
}


unsigned char *TTF_RenderUNICODE_Shaded(TTF_Font * font,
					const unsigned short *text,
					unsigned int fg, unsigned int bg)
{
	int xstart;
	int width;
	int height;
	unsigned char *textbuf;
	int rdiff;
	int gdiff;
	int bdiff;
	unsigned short val, bgc;
	const unsigned short *ch;
	unsigned char *src;
	unsigned char *dst;
	int row, col;
	c_glyph *glyph;
	FT_Error error;

	/* Get the dimensions of the text surface */
	if ((TTF_SizeUNICODE(font, text, &width, NULL) < 0) || !width) {
		fprintf(stderr, "Text has zero width\n");
		return NULL;
	}
	height = font->height;

	/* Create the target surface */
	textbuf = malloc(width * height * fbbytes);

	if (textbuf == NULL) {
		return NULL;
	}

	/* Load and render each character */
	xstart = 0;
	for (ch = text; *ch; ++ch) {
		FT_Bitmap *current;

		error =
		    Find_Glyph(font, *ch, CACHED_METRICS | CACHED_PIXMAP);
		if (error) {
			free(textbuf);
			return NULL;
		}
		glyph = font->current;

		current = &glyph->pixmap;
		for (row = 0; row < current->rows; ++row) {
			dst = (unsigned char *) framebuffer +
			    (fbypos + row + glyph->yoffset) * fblinelen +
			    (xstart + glyph->minx + fbxpos) * fbbytes;
			src = current->buffer + row * current->pitch;
			for (col = current->width; col > 0; --col) {
				val = *src++;
				bgc = *(unsigned short *) dst;

				/* get color parts from real color */
				rdiff = (fg >> 16);
				gdiff = ((fg >> 8) & 0xff);
				bdiff = (fg & 0xff);

				val = alpha * val / 100;
				/* dim color down to current pixel value */
				rdiff = rdiff * val / 0xff;
				gdiff = gdiff * val / 0xff;
				bdiff = bdiff * val / 0xff;

#if 1
				/* do alpha transparency */
				//rdiff=(rdiff*alpha/100);
				rdiff +=
				    ((bgc) >> 8 & 0xf8) * (0xff -
							   val) / 0xff;

				//gdiff=(gdiff*alpha/100);
				gdiff +=
				    ((bgc >> 3) & 0xfc) * (0xff -
							   val) / 0xff;

				//bdiff=(bdiff*alpha/100);
				bdiff +=
				    ((bgc << 3) & 0xf8) * (0xff -
							   val) / 0xff;
#endif

				val =
				    ((rdiff & 0xf8) << 8) | ((gdiff & 0xfc)
							     << 3) | (bdiff
								      >>
								      3);
				//*dst++ = (val >>8);
				*dst++ = val & 0xff;
				*dst++ = (val >> 8);
			}
			//printf("\n");
		}

		xstart += glyph->advance;
		if (font->style & TTF_STYLE_BOLD) {
			xstart += font->glyph_overhang;
		}
	}

	/* Handle the underline style */
	if (font->style & TTF_STYLE_UNDERLINE) {
		row = font->ascent - font->underline_offset - 1;
		if (row >= fby) {
			row = (height - 1) - font->underline_height;
		}
		dst = (unsigned char *) textbuf + row * width * fbbytes;
		for (row = font->underline_height; row > 0; --row) {
			memset(dst, NUM_GRAYS - 1, width);
			dst += width * fbbytes;
		}
	}
	return textbuf;
}


int rendertext(char *text, char *fontname, unsigned int ptsize,
	       unsigned int forecol)
{
	TTF_Font *font;
	int renderstyle = 0;

	enum {
		RENDER_LATIN1,
		RENDER_UTF8,
		RENDER_UNICODE
	} rendertype;


	/* Initialize the TTF library */
	if (TTF_Init() < 0) {
		fprintf(stderr, "Couldn't initialize TTF.\n");
		return (2);
	}
	atexit(TTF_Quit);

	/* Open the font file with the requested point size */
	font = TTF_OpenFont(fontname, ptsize);
	if (font == NULL) {
		fprintf(stderr, "Couldn't load %d pt font from %s\n",
			ptsize, fontname);
		return (2);
	}

	renderstyle = TTF_STYLE_NORMAL;
	rendertype = RENDER_LATIN1;

	TTF_SetFontStyle(font, renderstyle);
	text = TTF_RenderText_Shaded(font, text, forecol, 0);

	return 0;
}
1	/* render true type fonts to fb0
2	*
3	* (w) by stepan@suse.de, code reused from SDL_ttf
4	*
5	*/
6
7	#include <math.h>
8	#include <stdio.h>
9	#include <stdlib.h>
10	#include <string.h>
11	#include <assert.h>
12
13	#include <freetype/freetype.h>
14	#include <freetype/ftoutln.h>
15	#include <freetype/ttnameid.h>
16
17	#include "ttf.h"
18
19	#define DEFAULT_PTSIZE 18
20
21
22	/* FIXME: Right now we assume the gray-scale renderer Freetype is using
23	* supports 256 shades of gray, but we should instead key off of num_grays
24	* in the result FT_Bitmap after the FT_Render_Glyph() call. */
25	#define NUM_GRAYS 256
26
27
28	extern unsigned int fbbytes, fbx, fby, fblinelen, alpha;
29	extern unsigned char *framebuffer;
30
31	extern unsigned int fbypos, fbxpos;
32
33	unsigned char TTF_RenderUNICODE_Shaded(TTF_Font font,
34	const unsigned short *text,
35	unsigned int fg, unsigned int bg);
36
37	/* Cached glyph information */
38	typedef struct cached_glyph {
39	int stored;
40	FT_UInt index;
41	FT_Bitmap bitmap;
42	FT_Bitmap pixmap;
43	int minx;
44	int maxx;
45	int miny;
46	int maxy;
47	int yoffset;
48	int advance;
49	unsigned short cached;
50	} c_glyph;
51
52	struct _TTF_Font {
53	/* Freetype2 maintains all sorts of useful info itself */
54	FT_Face face;
55
56	/* We'll cache these ourselves */
57	int height;
58	int ascent;
59	int descent;
60	int lineskip;
61
62	/* The font style */
63	int style;
64
65	/* Extra width in glyph bounds for text styles */
66	int glyph_overhang;
67	float glyph_italics;
68
69	/* Information in the font for underlining */
70	int underline_offset;
71	int underline_height;
72
73	/* Cache for style-transformed glyphs */
74	c_glyph *current;
75	c_glyph cache[256];
76	c_glyph scratch;
77	};
78
79	static void Flush_Glyph(c_glyph * glyph);
80
81	static void Flush_Cache(TTF_Font * font)
82	{
83	int i;
84	int size = sizeof(font->cache) / sizeof(font->cache[0]);
85
86	for (i = 0; i < size; ++i) {
87	if (font->cache[i].cached) {
88	Flush_Glyph(&font->cache[i]);
89	}
90
91	}
92	if (font->scratch.cached) {
93	Flush_Glyph(&font->scratch);
94	}
95
96	}
97
98
99	/* character conversion */
100
101	/* Macro to convert a character to a Unicode value -- assume already Unicode */
102	#define UNICODE(c) c
103
104
105
106	static unsigned short ASCII_to_UNICODE(unsigned short unicode,
107	const char *text, int len)
108	{
109	int i;
110
111	for (i = 0; i < len; ++i) {
112	unicode[i] = ((const unsigned char *) text)[i];
113	}
114	unicode[i] = 0;
115
116	return unicode;
117	}
118
119	#if 0
120	static unsigned short UTF8_to_UNICODE(unsigned short unicode,
121	const char *utf8, int len)
122	{
123	int i, j;
124	unsigned short ch;
125
126	for (i = 0, j = 0; i < len; ++i, ++j) {
127	ch = ((const unsigned char *) utf8)[i];
128	if (ch >= 0xF0) {
129	ch = (unsigned short) (utf8[i] & 0x07) << 18;
130	ch \|= (unsigned short) (utf8[++i] & 0x3F) << 12;
131	ch \|= (unsigned short) (utf8[++i] & 0x3F) << 6;
132	ch \|= (unsigned short) (utf8[++i] & 0x3F);
133	} else if (ch >= 0xE0) {
134	ch = (unsigned short) (utf8[i] & 0x3F) << 12;
135	ch \|= (unsigned short) (utf8[++i] & 0x3F) << 6;
136	ch \|= (unsigned short) (utf8[++i] & 0x3F);
137	} else if (ch >= 0xC0) {
138	ch = (unsigned short) (utf8[i] & 0x3F) << 6;
139	ch \|= (unsigned short) (utf8[++i] & 0x3F);
140	}
141	unicode[j] = ch;
142	}
143	unicode[j] = 0;
144
145	return unicode;
146	}
147	#endif
148
149	/* TTF stuff */
150
151	static FT_Library library;
152	static int TTF_initialized = 0;
153
154	int TTF_Init(void)
155	{
156	int status;
157	FT_Error error;
158
159	status = 0;
160	error = FT_Init_FreeType(&library);
161	if (error) {
162	fprintf(stderr, "Couldn't init FreeType engine %d\n",
163	error);
164	status = -1;
165	} else {
166	TTF_initialized = 1;
167	}
168	return status;
169	}
170
171	void TTF_Quit(void)
172	{
173	if (TTF_initialized) {
174	FT_Done_FreeType(library);
175	}
176	TTF_initialized = 0;
177	}
178
179	#if 0
180	SDL_Surface TTF_RenderText_Solid(TTF_Font font,
181	const char *text, SDL_Color fg)
182	{
183	SDL_Surface *textbuf;
184	Uint16 *unicode_text;
185	int unicode_len;
186
187	/* Copy the Latin-1 text to a UNICODE text buffer */
188	unicode_len = strlen(text);
189	unicode_text =
190	(Uint16 ) malloc((unicode_len + 1) (sizeof *unicode_text));
191	if (unicode_text == NULL) {
192	TTF_SetError("Out of memory");
193	return (NULL);
194	}
195	ASCII_to_UNICODE(unicode_text, text, unicode_len);
196
197	RenderUnicode(font, unicode_text, fg);
198
199	/* Render the new text */
200	textbuf = TTF_RenderUNICODE_Solid(font, unicode_text, fg);
201
202	/* Free the text buffer and return */
203	free(unicode_text);
204	return (textbuf);
205	}
206	#endif
207
208	unsigned char TTF_RenderText_Shaded(TTF_Font font, const char *text,
209	unsigned int fg, unsigned int bg)
210	{
211	unsigned char *textbuf;
212	unsigned short *unicode_text;
213	int unicode_len;
214
215	/* Copy the Latin-1 text to a UNICODE text buffer */
216	unicode_len = strlen(text);
217	unicode_text =
218	(unsigned short ) malloc((unicode_len + 1)
219	(sizeof *unicode_text));
220	if (unicode_text == NULL) {
221	printf("Out of memory\n");
222	return (NULL);
223	}
224	ASCII_to_UNICODE(unicode_text, text, unicode_len);
225
226	/* Render the new text */
227	textbuf = TTF_RenderUNICODE_Shaded(font, unicode_text, fg, bg);
228
229	/* Free the text buffer and return */
230	free(unicode_text);
231	return (textbuf);
232	}
233
234
235
236	void TTF_CloseFont(TTF_Font * font)
237	{
238	Flush_Cache(font);
239	FT_Done_Face(font->face);
240	free(font);
241	}
242
243	void TTF_SetFontStyle(TTF_Font * font, int style)
244	{
245	font->style = style;
246	Flush_Cache(font);
247	}
248
249
250
251	TTF_Font TTF_OpenFontIndex(const char file, int ptsize, long index)
252	{
253	TTF_Font *font;
254	FT_Error error;
255	FT_Face face;
256	FT_Fixed scale;
257
258	extern int strict_font;
259
260	font = (TTF_Font ) malloc(sizeof font);
261	if (font == NULL) {
262	fprintf(stderr, "Out of memory\n");
263	return NULL;
264	}
265	memset(font, 0, sizeof(*font));
266
267	/* Open the font and create ancillary data */
268	error = FT_New_Face(library, file, 0, &font->face);
269
270	if (error && !strict_font)
271	error =
272	FT_New_Memory_Face(library,
273	(const FT_Byte *) luxisri_ttf,
274	LUXISRI_SIZE, 0, &font->face);
275
276	if (error) {
277	printf("Couldn't load font file\n");
278	free(font);
279	return NULL;
280	}
281
282	if (index != 0) {
283	if (font->face->num_faces > index) {
284	FT_Done_Face(font->face);
285	error =
286	FT_New_Face(library, file, index, &font->face);
287	if (error) {
288	printf("Couldn't get font face\n");
289	free(font);
290	return NULL;
291	}
292	} else {
293	fprintf(stderr, "No such font face\n");
294	free(font);
295	return NULL;
296	}
297	}
298	face = font->face;
299
300	/* Make sure that our font face is scalable (global metrics) */
301	if (!FT_IS_SCALABLE(face)) {
302	fprintf(stderr, "Font face is not scalable\n");
303	TTF_CloseFont(font);
304	return NULL;
305	}
306	/* Set the character size and use default DPI (72) */
307	error = FT_Set_Char_Size(font->face, 0, ptsize * 64, 0, 0);
308	if (error) {
309	fprintf(stderr, "Couldn't set font size\n");
310	TTF_CloseFont(font);
311	return NULL;
312	}
313
314	/* Get the scalable font metrics for this font */
315	scale = face->size->metrics.y_scale;
316	font->ascent = FT_CEIL(FT_MulFix(face->bbox.yMax, scale));
317	font->descent = FT_CEIL(FT_MulFix(face->bbox.yMin, scale));
318	font->height = font->ascent - font->descent + /* baseline */ 1;
319	font->lineskip = FT_CEIL(FT_MulFix(face->height, scale));
320	font->underline_offset =
321	FT_FLOOR(FT_MulFix(face->underline_position, scale));
322	font->underline_height =
323	FT_FLOOR(FT_MulFix(face->underline_thickness, scale));
324	if (font->underline_height < 1) {
325	font->underline_height = 1;
326	}
327	#ifdef DEBUG_FONTS
328	printf("Font metrics:\n");
329	printf("\tascent = %d, descent = %d\n",
330	font->ascent, font->descent);
331	printf("\theight = %d, lineskip = %d\n",
332	font->height, font->lineskip);
333	printf("\tunderline_offset = %d, underline_height = %d\n",
334	font->underline_offset, font->underline_height);
335	#endif
336
337	/* Set the default font style */
338	font->style = TTF_STYLE_NORMAL;
339	font->glyph_overhang = face->size->metrics.y_ppem / 10;
340	/* x offset = cos(((90.0-12)/360)2M_PI), or 12 degree angle */
341	font->glyph_italics = 0.207f;
342	font->glyph_italics *= font->height;
343
344	return font;
345	}
346
347
348
349	TTF_Font TTF_OpenFont(const char file, int ptsize)
350	{
351	return TTF_OpenFontIndex(file, ptsize, 0);
352	}
353
354
355
356	static void Flush_Glyph(c_glyph * glyph)
357	{
358	glyph->stored = 0;
359	glyph->index = 0;
360	if (glyph->bitmap.buffer) {
361	free(glyph->bitmap.buffer);
362	glyph->bitmap.buffer = 0;
363	}
364	if (glyph->pixmap.buffer) {
365	free(glyph->pixmap.buffer);
366	glyph->pixmap.buffer = 0;
367	}
368	glyph->cached = 0;
369	}
370
371	static FT_Error Load_Glyph(TTF_Font * font, unsigned short ch,
372	c_glyph * cached, int want)
373	{
374	FT_Face face;
375	FT_Error error;
376	FT_GlyphSlot glyph;
377	FT_Glyph_Metrics *metrics;
378	FT_Outline *outline;
379
380	assert(font);
381	assert(font->face);
382
383	face = font->face;
384
385	/* Load the glyph */
386	if (!cached->index) {
387	cached->index = FT_Get_Char_Index(face, ch);
388	}
389	error = FT_Load_Glyph(face, cached->index, FT_LOAD_DEFAULT);
390	if (error) {
391	return error;
392	}
393	/* Get our glyph shortcuts */
394	glyph = face->glyph;
395	metrics = &glyph->metrics;
396	outline = &glyph->outline;
397
398	/* Get the glyph metrics if desired */
399	if ((want & CACHED_METRICS) && !(cached->stored & CACHED_METRICS)) {
400	/* Get the bounding box */
401	cached->minx = FT_FLOOR(metrics->horiBearingX);
402	cached->maxx = cached->minx + FT_CEIL(metrics->width);
403	cached->maxy = FT_FLOOR(metrics->horiBearingY);
404	cached->miny = cached->maxy - FT_CEIL(metrics->height);
405	cached->yoffset = font->ascent - cached->maxy;
406	cached->advance = FT_CEIL(metrics->horiAdvance);
407
408	/* Adjust for bold and italic text */
409	if (font->style & TTF_STYLE_BOLD) {
410	cached->maxx += font->glyph_overhang;
411	}
412	if (font->style & TTF_STYLE_ITALIC) {
413	cached->maxx += (int) ceil(font->glyph_italics);
414	}
415	cached->stored \|= CACHED_METRICS;
416	}
417
418	if (((want & CACHED_BITMAP) && !(cached->stored & CACHED_BITMAP))
419	\|\| ((want & CACHED_PIXMAP)
420	&& !(cached->stored & CACHED_PIXMAP))) {
421	int mono = (want & CACHED_BITMAP);
422	int i;
423	FT_Bitmap *src;
424	FT_Bitmap *dst;
425
426	/* Handle the italic style */
427	if (font->style & TTF_STYLE_ITALIC) {
428	FT_Matrix shear;
429
430	shear.xx = 1 << 16;
431	shear.xy = (int) (font->glyph_italics * (1 << 16))
432	/ font->height;
433	shear.yx = 0;
434	shear.yy = 1 << 16;
435
436	FT_Outline_Transform(outline, &shear);
437	}
438
439	/* Render the glyph */
440	if (mono) {
441	error =
442	FT_Render_Glyph(glyph, ft_render_mode_mono);
443	} else {
444	error =
445	FT_Render_Glyph(glyph, ft_render_mode_normal);
446	}
447	if (error) {
448	return error;
449	}
450
451	/* Copy over information to cache */
452	src = &glyph->bitmap;
453	if (mono) {
454	dst = &cached->bitmap;
455	} else {
456	dst = &cached->pixmap;
457	}
458	memcpy(dst, src, sizeof(*dst));
459	if (mono) {
460	dst->pitch *= 8;
461	}
462
463	/* Adjust for bold and italic text */
464	if (font->style & TTF_STYLE_BOLD) {
465	int bump = font->glyph_overhang;
466	dst->pitch += bump;
467	dst->width += bump;
468	}
469	if (font->style & TTF_STYLE_ITALIC) {
470	int bump = (int) ceil(font->glyph_italics);
471	dst->pitch += bump;
472	dst->width += bump;
473	}
474
475	if (dst->rows != 0) {
476	dst->buffer = malloc(dst->pitch * dst->rows);
477	if (!dst->buffer) {
478	return FT_Err_Out_Of_Memory;
479	}
480	memset(dst->buffer, 0, dst->pitch * dst->rows);
481
482	for (i = 0; i < src->rows; i++) {
483	int soffset = i * src->pitch;
484	int doffset = i * dst->pitch;
485	if (mono) {
486	unsigned char *srcp = src->buffer +
487	soffset;
488	unsigned char *dstp = dst->buffer +
489	doffset;
490	int j;
491	for (j = 0; j < src->width; j += 8) {
492	unsigned char ch = *srcp++;
493	*dstp++ = (ch & 0x80) >> 7;
494	ch <<= 1;
495	*dstp++ = (ch & 0x80) >> 7;
496	ch <<= 1;
497	*dstp++ = (ch & 0x80) >> 7;
498	ch <<= 1;
499	*dstp++ = (ch & 0x80) >> 7;
500	ch <<= 1;
501	*dstp++ = (ch & 0x80) >> 7;
502	ch <<= 1;
503	*dstp++ = (ch & 0x80) >> 7;
504	ch <<= 1;
505	*dstp++ = (ch & 0x80) >> 7;
506	ch <<= 1;
507	*dstp++ = (ch & 0x80) >> 7;
508	}
509	} else {
510	memcpy(dst->buffer + doffset,
511	src->buffer + soffset,
512	src->pitch);
513	}
514	}
515	}
516
517	/* Handle the bold style */
518	if (font->style & TTF_STYLE_BOLD) {
519	int row;
520	int col;
521	int offset;
522	int pixel;
523	unsigned char *pixmap;
524
525	/* The pixmap is a little hard, we have to add and clamp */
526	for (row = dst->rows - 1; row >= 0; --row) {
527	pixmap =
528	(unsigned char *) dst->buffer +
529	row * dst->pitch;
530	for (offset = 1;
531	offset <= font->glyph_overhang;
532	++offset) {
533	for (col = dst->width - 1; col > 0;
534	--col) {
535	pixel =
536	(pixmap[col] +
537	pixmap[col - 1]);
538	if (pixel > NUM_GRAYS - 1) {
539	pixel =
540	NUM_GRAYS - 1;
541	}
542	pixmap[col] =
543	(unsigned char) pixel;
544	}
545	}
546	}
547	}
548
549	/* Mark that we rendered this format */
550	if (mono) {
551	cached->stored \|= CACHED_BITMAP;
552	} else {
553	cached->stored \|= CACHED_PIXMAP;
554	}
555	}
556
557	/* We're done, mark this glyph cached */
558	cached->cached = ch;
559
560	return 0;
561	}
562
563
564
565
566
567
568
569	static FT_Error Find_Glyph(TTF_Font * font, unsigned short ch, int want)
570	{
571	int retval = 0;
572
573	if (ch < 256) {
574	font->current = &font->cache[ch];
575	} else {
576	if (font->scratch.cached != ch) {
577	Flush_Glyph(&font->scratch);
578	}
579	font->current = &font->scratch;
580	}
581	if ((font->current->stored & want) != want) {
582	retval = Load_Glyph(font, ch, font->current, want);
583	}
584	return retval;
585	}
586
587	int TTF_SizeUNICODE(TTF_Font * font, const unsigned short text, int w,
588	int *h)
589	{
590	int status;
591	const unsigned short *ch;
592	int x, z;
593	int minx, maxx;
594	int miny, maxy;
595	c_glyph *glyph;
596	FT_Error error;
597
598	/* Initialize everything to 0 */
599	if (!TTF_initialized) {
600	return -1;
601	}
602	status = 0;
603	minx = maxx = 0;
604	miny = maxy = 0;
605
606	/* Load each character and sum it's bounding box */
607	x = 0;
608	for (ch = text; *ch; ++ch) {
609	error = Find_Glyph(font, *ch, CACHED_METRICS);
610	if (error) {
611	return -1;
612	}
613	glyph = font->current;
614
615	z = x + glyph->minx;
616	if (minx > z) {
617	minx = z;
618	}
619	if (font->style & TTF_STYLE_BOLD) {
620	x += font->glyph_overhang;
621	}
622	if (glyph->advance > glyph->maxx) {
623	z = x + glyph->advance;
624	} else {
625	z = x + glyph->maxx;
626	}
627	if (maxx < z) {
628	maxx = z;
629	}
630	x += glyph->advance;
631
632	if (glyph->miny < miny) {
633	miny = glyph->miny;
634	}
635	if (glyph->maxy > maxy) {
636	maxy = glyph->maxy;
637	}
638	}
639
640	/* Fill the bounds rectangle */
641	if (w) {
642	*w = (maxx - minx);
643	}
644	if (h)
645	*h = font->height;
646
647	return status;
648	}
649
650
651	unsigned char TTF_RenderUNICODE_Shaded(TTF_Font font,
652	const unsigned short *text,
653	unsigned int fg, unsigned int bg)
654	{
655	int xstart;
656	int width;
657	int height;
658	unsigned char *textbuf;
659	int rdiff;
660	int gdiff;
661	int bdiff;
662	unsigned short val, bgc;
663	const unsigned short *ch;
664	unsigned char *src;
665	unsigned char *dst;
666	int row, col;
667	c_glyph *glyph;
668	FT_Error error;
669
670	/* Get the dimensions of the text surface */
671	if ((TTF_SizeUNICODE(font, text, &width, NULL) < 0) \|\| !width) {
672	fprintf(stderr, "Text has zero width\n");
673	return NULL;
674	}
675	height = font->height;
676
677	/* Create the target surface */
678	textbuf = malloc(width * height * fbbytes);
679
680	if (textbuf == NULL) {
681	return NULL;
682	}
683
684	/* Load and render each character */
685	xstart = 0;
686	for (ch = text; *ch; ++ch) {
687	FT_Bitmap *current;
688
689	error =
690	Find_Glyph(font, *ch, CACHED_METRICS \| CACHED_PIXMAP);
691	if (error) {
692	free(textbuf);
693	return NULL;
694	}
695	glyph = font->current;
696
697	current = &glyph->pixmap;
698	for (row = 0; row < current->rows; ++row) {
699	dst = (unsigned char *) framebuffer +
700	(fbypos + row + glyph->yoffset) * fblinelen +
701	(xstart + glyph->minx + fbxpos) * fbbytes;
702	src = current->buffer + row * current->pitch;
703	for (col = current->width; col > 0; --col) {
704	val = *src++;
705	bgc = (unsigned short ) dst;
706
707	/* get color parts from real color */
708	rdiff = (fg >> 16);
709	gdiff = ((fg >> 8) & 0xff);
710	bdiff = (fg & 0xff);
711
712	val = alpha * val / 100;
713	/* dim color down to current pixel value */
714	rdiff = rdiff * val / 0xff;
715	gdiff = gdiff * val / 0xff;
716	bdiff = bdiff * val / 0xff;
717
718	#if 1
719	/* do alpha transparency */
720	//rdiff=(rdiff*alpha/100);
721	rdiff +=
722	((bgc) >> 8 & 0xf8) * (0xff -
723	val) / 0xff;
724
725	//gdiff=(gdiff*alpha/100);
726	gdiff +=
727	((bgc >> 3) & 0xfc) * (0xff -
728	val) / 0xff;
729
730	//bdiff=(bdiff*alpha/100);
731	bdiff +=
732	((bgc << 3) & 0xf8) * (0xff -
733	val) / 0xff;
734	#endif
735
736	val =
737	((rdiff & 0xf8) << 8) \| ((gdiff & 0xfc)
738	<< 3) \| (bdiff
739	>>
740	3);
741	//*dst++ = (val >>8);
742	*dst++ = val & 0xff;
743	*dst++ = (val >> 8);
744	}
745	//printf("\n");
746	}
747
748	xstart += glyph->advance;
749	if (font->style & TTF_STYLE_BOLD) {
750	xstart += font->glyph_overhang;
751	}
752	}
753
754	/* Handle the underline style */
755	if (font->style & TTF_STYLE_UNDERLINE) {
756	row = font->ascent - font->underline_offset - 1;
757	if (row >= fby) {
758	row = (height - 1) - font->underline_height;
759	}
760	dst = (unsigned char ) textbuf + row width * fbbytes;
761	for (row = font->underline_height; row > 0; --row) {
762	memset(dst, NUM_GRAYS - 1, width);
763	dst += width * fbbytes;
764	}
765	}
766	return textbuf;
767	}
768
769
770	int rendertext(char text, char fontname, unsigned int ptsize,
771	unsigned int forecol)
772	{
773	TTF_Font *font;
774	int renderstyle = 0;
775
776	enum {
777	RENDER_LATIN1,
778	RENDER_UTF8,
779	RENDER_UNICODE
780	} rendertype;
781
782
783	/* Initialize the TTF library */
784	if (TTF_Init() < 0) {
785	fprintf(stderr, "Couldn't initialize TTF.\n");
786	return (2);
787	}
788	atexit(TTF_Quit);
789
790	/* Open the font file with the requested point size */
791	font = TTF_OpenFont(fontname, ptsize);
792	if (font == NULL) {
793	fprintf(stderr, "Couldn't load %d pt font from %s\n",
794	ptsize, fontname);
795	return (2);
796	}
797
798	renderstyle = TTF_STYLE_NORMAL;
799	rendertype = RENDER_LATIN1;
800
801	TTF_SetFontStyle(font, renderstyle);
802	text = TTF_RenderText_Shaded(font, text, forecol, 0);
803
804	return 0;
805	}