convbdf.c

the embedded GUI for SamSung s3c2410 cpu based board.is microwindows0.90

/*
 * Convert BDF files to C source and/or Rockbox .fnt file format
 *
 * Copyright (c) 2002 by Greg Haerr <[e-mail]>
 *
 * What fun it is converting font data...
 *
 * 09/17/02	Version 1.0
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

/* BEGIN font.h*/
/* loadable font magic and version #*/
#define VERSION		"RB11"

/* MWIMAGEBITS helper macros*/
#define MWIMAGE_WORDS(x)	(((x)+15)/16)	/* image size in words*/
#define MWIMAGE_BYTES(x)	(MWIMAGE_WORDS(x)*sizeof(MWIMAGEBITS))
#define	MWIMAGE_BITSPERIMAGE (sizeof(MWIMAGEBITS) * 8)
#define	MWIMAGE_BITVALUE(n)	((MWIMAGEBITS) (((MWIMAGEBITS) 1) << (n)))
#define	MWIMAGE_FIRSTBIT	(MWIMAGE_BITVALUE(MWIMAGE_BITSPERIMAGE - 1))
#define	MWIMAGE_TESTBIT(m)	((m) & MWIMAGE_FIRSTBIT)
#define	MWIMAGE_SHIFTBIT(m)	((MWIMAGEBITS) ((m) << 1))

typedef unsigned short	MWIMAGEBITS;	/* bitmap image unit size*/

/* builtin C-based proportional/fixed font structure */
/* based on The Microwindows Project http://microwindows.org */
typedef struct {
	char *		name;		/* font name*/
	int		maxwidth;	/* max width in pixels*/
	int 		height;		/* height in pixels*/
	int		ascent;		/* ascent (baseline) height*/
	int		firstchar;	/* first character in bitmap*/
	int		size;		/* font size in glyphs*/
	MWIMAGEBITS *	bits;		/* 16-bit right-padded bitmap data*/
	unsigned long *	offset;		/* offsets into bitmap data*/
	unsigned char *	width;		/* character widths or NULL if fixed*/
	int		defaultchar;	/* default char (not glyph index)*/
	long		bits_size;	/* # words of MWIMAGEBITS bits*/

	/* unused by runtime system, read in by convbdf*/
	char *		facename;	/* facename of font*/
	char *		copyright;	/* copyright info for loadable fonts*/
	int		pixel_size;
	int		descent;
	int		fbbw, fbbh, fbbx, fbby;
} MWCFONT, *PMWCFONT;
/* END font.h*/

#define isprefix(buf,str)	(!strncmp(buf, str, strlen(str)))
#define	strequal(s1,s2)		(!strcmp(s1, s2))

#define EXTRA	300		/* # bytes extra allocation for buggy .bdf files*/

int gen_c = 0;
int gen_fnt = 0;
int gen_map = 1;
int start_char = 0;
int limit_char = 65535;
int oflag = 0;
char outfile[256];

void        usage(void);
void        getopts(int *pac, char ***pav);
int         convbdf(char *path);

void        free_font(PMWCFONT pf);
PMWCFONT    bdf_read_font(char *path);
int         bdf_read_header(FILE *fp, PMWCFONT pf);
int         bdf_read_bitmaps(FILE *fp, PMWCFONT pf);
char *      bdf_getline(FILE *fp, char *buf, int len);
MWIMAGEBITS bdf_hexval(unsigned char *buf, int ndx1, int ndx2);

int         gen_c_source(PMWCFONT pf, char *path);
int         gen_fnt_file(PMWCFONT pf, char *path);

void
usage(void)
{
	char help[] = {
	"Usage: convbdf [options] [input-files]\n"
	"       convbdf [options] [-o output-file] [single-input-file]\n"
	"Options:\n"
	"    -c     Convert .bdf to .c source file\n"
	"    -f     Convert .bdf to .fnt font file\n"
	"    -s N   Start output at character encodings >= N\n"
	"    -l N   Limit output to character encodings <= N\n"
	"    -n     Don't generate bitmaps as comments in .c file\n"
	};

	fprintf(stderr, help);
}

/* parse command line options*/
void
getopts(int *pac, char ***pav)
{
	char *p;
	char **av;
	int ac;

	ac = *pac;
	av = *pav;
	while (ac > 0 && av[0][0] == '-') {
		p = &av[0][1]; 
		while( *p)
			switch(*p++) {
		case ' ':			/* multiple -args on av[]*/
			while( *p && *p == ' ')
				p++;
			if( *p++ != '-')	/* next option must have dash*/
				p = "";
			break;			/* proceed to next option*/
		case 'c':			/* generate .c output*/
			gen_c = 1;
			break;
		case 'f':			/* generate .fnt output*/
			gen_fnt = 1;
			break;
		case 'n':			/* don't gen bitmap comments*/
			gen_map = 0;
			break;
		case 'o':			/* set output file*/
			oflag = 1;
			if (*p) {
				strcpy(outfile, p);
				while (*p && *p != ' ')
					p++;
			} else {
				av++; ac--;
				if (ac > 0)
					strcpy(outfile, av[0]);
			}
			break;
		case 'l':			/* set encoding limit*/
			if (*p) {
				limit_char = atoi(p);
				while (*p && *p != ' ')
					p++;
			} else {
				av++; ac--;
				if (ac > 0)
					limit_char = atoi(av[0]);
			}
			break;
		case 's':			/* set encoding start*/
			if (*p) {
				start_char = atoi(p);
				while (*p && *p != ' ')
					p++;
			} else {
				av++; ac--;
				if (ac > 0)
					start_char = atoi(av[0]);
			}
			break;
		default:
			fprintf(stderr, "Unknown option ignored: %c\r\n", *(p-1));
		}
		++av; --ac;
	}
	*pac = ac;
	*pav = av;
}

/* remove directory prefix and file suffix from full path*/
char *
basename(char *path)
{
	char *p, *b;
	static char base[256];

	/* remove prepended path and extension*/
	b = path;
	for (p=path; *p; ++p) {
		if (*p == '/')
			b = p + 1;
	}
	strcpy(base, b);
	for (p=base; *p; ++p) {
		if (*p == '.') {
			*p = 0;
			break;
		}
	}
	return base;
}

int
convbdf(char *path)
{
	PMWCFONT pf;
	int ret = 0;

	pf = bdf_read_font(path);
	if (!pf)
		exit(1);

	if (gen_c) {
		if (!oflag) {
			strcpy(outfile, basename(path));
			strcat(outfile, ".c");
		}
		ret |= gen_c_source(pf, outfile);
	}

	if (gen_fnt) {
		if (!oflag) {
			strcpy(outfile, basename(path));
			strcat(outfile, ".fnt");
		}
		ret |= gen_fnt_file(pf, outfile);
	}

	free_font(pf);
	return ret;
}

int
main(int ac, char **av)
{
	int ret = 0;

	++av; --ac;		/* skip av[0]*/
	getopts(&ac, &av);	/* read command line options*/

	if (ac < 1 || (!gen_c && !gen_fnt)) {
		usage();
		exit(1);
	}
	if (oflag) {
		if (ac > 1 || (gen_c && gen_fnt)) {
			usage();
			exit(1);
		}
	}

	while (ac > 0) {
		ret |= convbdf(av[0]);
		++av; --ac;
	}

	exit(ret);
}

/* free font structure*/
void
free_font(PMWCFONT pf)
{
	if (!pf)
		return;
	if (pf->name)
		free(pf->name);
	if (pf->facename)
		free(pf->facename);
	if (pf->bits)
		free(pf->bits);
	if (pf->offset)
		free(pf->offset);
	if (pf->width)
		free(pf->width);
	free(pf);
}

/* build incore structure from .bdf file*/
PMWCFONT
bdf_read_font(char *path)
{
	FILE *fp;
	PMWCFONT pf;

	fp = fopen(path, "rb");
	if (!fp) {
		fprintf(stderr, "Error opening file: %s\n", path);
		return NULL;
	}

	pf = (PMWCFONT)calloc(1, sizeof(MWCFONT));
	if (!pf)
		goto errout;
	
	pf->name = strdup(basename(path));

	if (!bdf_read_header(fp, pf)) {
		fprintf(stderr, "Error reading font header\n");
		goto errout;
	}

	if (!bdf_read_bitmaps(fp, pf)) {
		fprintf(stderr, "Error reading font bitmaps\n");
		goto errout;
	}

	fclose(fp);
	return pf;

errout:
	fclose(fp);
	free_font(pf);
	return NULL;
}

/* read bdf font header information, return 0 on error*/
int
bdf_read_header(FILE *fp, PMWCFONT pf)
{
	int encoding;
	int nchars, maxwidth;
	int firstchar = 65535;
	int lastchar = -1;
	char buf[256];
	char facename[256];
	char copyright[256];

	/* set certain values to errors for later error checking*/
	pf->defaultchar = -1;
	pf->ascent = -1;
	pf->descent = -1;

	for (;;) {
		if (!bdf_getline(fp, buf, sizeof(buf))) {
			fprintf(stderr, "Error: EOF on file\n");
			return 0;
		}
		if (isprefix(buf, "FONT ")) {		/* not required*/
			if (sscanf(buf, "FONT %[^\n]", facename) != 1) {
				fprintf(stderr, "Error: bad 'FONT'\n");
				return 0;
			}
			pf->facename = strdup(facename);
			continue;
		}
		if (isprefix(buf, "COPYRIGHT ")) {	/* not required*/
			if (sscanf(buf, "COPYRIGHT \"%[^\"]", copyright) != 1) {
				fprintf(stderr, "Error: bad 'COPYRIGHT'\n");
				return 0;
			}
			pf->copyright = strdup(copyright);
			continue;
		}
		if (isprefix(buf, "DEFAULT_CHAR ")) {	/* not required*/
			if (sscanf(buf, "DEFAULT_CHAR %d", &pf->defaultchar) != 1) {
				fprintf(stderr, "Error: bad 'DEFAULT_CHAR'\n");
				return 0;
			}
		}
		if (isprefix(buf, "FONT_DESCENT ")) {
			if (sscanf(buf, "FONT_DESCENT %d", &pf->descent) != 1) {
				fprintf(stderr, "Error: bad 'FONT_DESCENT'\n");
				return 0;
			}
			continue;
		}
		if (isprefix(buf, "FONT_ASCENT ")) {
			if (sscanf(buf, "FONT_ASCENT %d", &pf->ascent) != 1) {
				fprintf(stderr, "Error: bad 'FONT_ASCENT'\n");
				return 0;
			}
			continue;
		}
		if (isprefix(buf, "FONTBOUNDINGBOX ")) {
			if (sscanf(buf, "FONTBOUNDINGBOX %d %d %d %d",
			    &pf->fbbw, &pf->fbbh, &pf->fbbx, &pf->fbby) != 4) {
				fprintf(stderr, "Error: bad 'FONTBOUNDINGBOX'\n");
				return 0;
			}
			continue;
		}
		if (isprefix(buf, "CHARS ")) {
			if (sscanf(buf, "CHARS %d", &nchars) != 1) {
				fprintf(stderr, "Error: bad 'CHARS'\n");
				return 0;
			}
			continue;
		}

		/*
		 * Reading ENCODING is necessary to get firstchar/lastchar
		 * which is needed to pre-calculate our offset and widths
		 * array sizes.
		 */
		if (isprefix(buf, "ENCODING ")) {
			if (sscanf(buf, "ENCODING %d", &encoding) != 1) {
				fprintf(stderr, "Error: bad 'ENCODING'\n");
				return 0;
			}
			if (encoding >= 0 && encoding <= limit_char && encoding >= start_char) {
				if (firstchar > encoding)
					firstchar = encoding;
				if (lastchar < encoding)
					lastchar = encoding;
			}
			continue;
		}
		if (strequal(buf, "ENDFONT"))
			break;
	}

	/* calc font height*/
	if (pf->ascent < 0 || pf->descent < 0 || firstchar < 0) {
		fprintf(stderr, "Error: Invalid BDF file, requires FONT_ASCENT/FONT_DESCENT/ENCODING\n");
		return 0;
	}
	pf->height = pf->ascent + pf->descent;

	/* calc default char*/
	if (pf->defaultchar < 0 || pf->defaultchar < firstchar ||
	    pf->defaultchar > limit_char)
		pf->defaultchar = firstchar;

	/* calc font size (offset/width entries)*/
	pf->firstchar = firstchar;
	pf->size = lastchar - firstchar + 1;
	
	/* use the font boundingbox to get initial maxwidth*/
	/*maxwidth = pf->fbbw - pf->fbbx;*/
	maxwidth = pf->fbbw;

	/* initially use font maxwidth * height for bits allocation*/
	pf->bits_size = nchars * MWIMAGE_WORDS(maxwidth) * pf->height;

	/* allocate bits, offset, and width arrays*/
	pf->bits = (MWIMAGEBITS *)malloc(pf->bits_size * sizeof(MWIMAGEBITS) + EXTRA);
	pf->offset = (unsigned long *)malloc(pf->size * sizeof(unsigned long));
	pf->width = (unsigned char *)malloc(pf->size * sizeof(unsigned char));
	
	if (!pf->bits || !pf->offset || !pf->width) {
		fprintf(stderr, "Error: no memory for font load\n");
		return 0;
	}

	return 1;
}

/* read bdf font bitmaps, return 0 on error*/
int
bdf_read_bitmaps(FILE *fp, PMWCFONT pf)
{
	long ofs = 0;
	int maxwidth = 0;
	int i, k, encoding, width;
	int bbw, bbh, bbx, bby;
	int proportional = 0;
	int encodetable = 0;
	long l;
	char buf[256];

	/* reset file pointer*/
	fseek(fp, 0L, SEEK_SET);

	/* initially mark offsets as not used*/
	for (i=0; i<pf->size; ++i)
		pf->offset[i] = -1;

	for (;;) {
		if (!bdf_getline(fp, buf, sizeof(buf))) {
			fprintf(stderr, "Error: EOF on file\n");
			return 0;
		}
		if (isprefix(buf, "STARTCHAR")) {
			encoding = width = bbw = bbh = bbx = bby = -1;
			continue;
		}
		if (isprefix(buf, "ENCODING ")) {
			if (sscanf(buf, "ENCODING %d", &encoding) != 1) {
				fprintf(stderr, "Error: bad 'ENCODING'\n");
				return 0;
			}
			if (encoding < start_char || encoding > limit_char)
				encoding = -1;
			continue;