/* * Convert BDF files to C source and/or Rockbox .fnt file format * * Copyright (c) 2002 by Greg Haerr <greg@censoft.com> * * 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"/* bitmap_t helper macros*/#define BITMAP_WORDS(x)         (((x)+15)/16)	/* image size in words*/#define BITMAP_BYTES(x)         (BITMAP_WORDS(x)*sizeof(bitmap_t))#define	BITMAP_BITSPERIMAGE     (sizeof(bitmap_t) * 8)#define	BITMAP_BITVALUE(n)      ((bitmap_t) (((bitmap_t) 1) << (n)))#define	BITMAP_FIRSTBIT         (BITMAP_BITVALUE(BITMAP_BITSPERIMAGE - 1))#define	BITMAP_TESTBIT(m)	((m) & BITMAP_FIRSTBIT)#define	BITMAP_SHIFTBIT(m)	((bitmap_t) ((m) << 1))typedef unsigned short bitmap_t; /* bitmap image unit size*//* builtin C-based proportional/fixed font structure *//* based on The Microwindows Project http://microwindows.org */struct font {    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*/    bitmap_t*	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 bitmap_t 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;};/* 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(struct font* pf);struct font* bdf_read_font(char *path);int bdf_read_header(FILE *fp, struct font* pf);int bdf_read_bitmaps(FILE *fp, struct font* pf);char * bdf_getline(FILE *fp, char *buf, int len);bitmap_t bdf_hexval(unsigned char *buf, int ndx1, int ndx2);int gen_c_source(struct font* pf, char *path);int gen_fnt_file(struct font* pf, char *path);voidusage(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){    struct font* 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(struct font* 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*/struct font* bdf_read_font(char *path){    FILE *fp;    struct font* pf;    fp = fopen(path, "rb");    if (!fp) {        fprintf(stderr, "Error opening file: %s\n", path);        return NULL;    }        pf = (struct font*)calloc(1, sizeof(struct font));    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, struct font* 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 * BITMAP_WORDS(maxwidth) * pf->height;    /* allocate bits, offset, and width arrays*/    pf->bits = (bitmap_t *)malloc(pf->bits_size * sizeof(bitmap_t) + 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, struct font* 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;        }