bdf2c/bdf2c.c

716 lines
21 KiB
C

///
/// @file bdf2c.c @brief BDF Font to C source convertor
///
/// Copyright (c) 2009, 2010 by Lutz Sammer. All Rights Reserved.
///
/// Contributor(s):
///
/// License: AGPLv3
///
/// This program is free software: you can redistribute it and/or modify
/// it under the terms of the GNU Affero General Public License as
/// published by the Free Software Foundation, either version 3 of the
/// License.
///
/// This program is distributed in the hope that it will be useful,
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
/// GNU Affero General Public License for more details.
///
/// $Id$
//////////////////////////////////////////////////////////////////////////////
///
/// @mainpage
/// bdf2c - converts bdf font files into C include files.
///
/// The Bitmap Distribution Format (BDF) is a file format for
/// storing bitmap fonts. The content is presented as a text file
/// that is intended to be human and computer readable.
///
/// BDF input:
/// @code
/// STARTCHAR A
/// ENCODING 65
/// SWIDTH 568 0
/// DWIDTH 8 0
/// BBX 8 13 0 -2
/// BITMAP
/// 00
/// 38
/// 7C
/// C6
/// C6
/// C6
/// FE
/// C6
/// C6
/// C6
/// C6
/// 00
/// 00
/// ENDCHAR
/// @endcode
///
/// The result looks like this:
/// @code
/// // 65 $41 'A'
/// // width 8, bbx 0, bby -2, bbw 8, bbh 13
/// ________,
/// __XXX___,
/// _XXXXX__,
/// XX___XX_,
/// XX___XX_,
/// XX___XX_,
/// XXXXXXX_,
/// XX___XX_,
/// XX___XX_,
/// XX___XX_,
/// XX___XX_,
/// ________,
/// ________,
/// @endcode
///
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#define VERSION "4" ///< version of this application
//////////////////////////////////////////////////////////////////////////////
int Outline; ///< true generate outlined font
int SmartMatrix; // modify output to be used in the SmartMatrix library
//////////////////////////////////////////////////////////////////////////////
///
/// Create our header file.
///
/// @param out file stream for output
///
void CreateFontHeaderFile(FILE * out)
{
register int i;
fprintf(out,
"// (c) 2009, 2010 Lutz Sammer, License: AGPLv3\n\n"
"\t/// bitmap font structure\n" "struct bitmap_font {\n"
"\tunsigned char Width;\t\t///< max. character width\n"
"\tunsigned char Height;\t\t///< character height\n"
"\tunsigned short Chars;\t\t///< number of characters in font\n"
"\tconst unsigned char *Widths;\t///< width of each character\n"
"\tconst unsigned short *Index;\t///< encoding to character index\n"
"\tconst unsigned char *Bitmap;\t///< bitmap of all characters\n"
"};\n\n");
fprintf(out, "\t/// @{ defines to have human readable font files\n");
for (i = 0; i < 256; ++i) {
fprintf(out, "#define %c%c%c%c%c%c%c%c 0x%02X\n",
(i & 0x80) ? 'X' : '_', (i & 0x40) ? 'X' : '_',
(i & 0x20) ? 'X' : '_', (i & 0x10) ? 'X' : '_',
(i & 0x08) ? 'X' : '_', (i & 0x04) ? 'X' : '_',
(i & 0x02) ? 'X' : '_', (i & 0x01) ? 'X' : '_', i);
}
fprintf(out, "\t/// @}\n");
}
//////////////////////////////////////////////////////////////////////////////
///
/// Print header for c file.
///
/// @param out file stream for output
/// @param name font variable name in C source file
///
void Header(FILE * out, const char *name)
{
char * headername;
if(!SmartMatrix)
headername = "font";
else
headername = "MatrixFontCommon";
fprintf(out,
"// Created from bdf2c Version %s, (c) 2009, 2010 by Lutz Sammer\n"
"//\tLicense AGPLv3: GNU Affero General Public License version 3\n"
"\n#include \"%s.h\"\n\n", VERSION, headername);
fprintf(out,
"\t/// character bitmap for each encoding\n"
"static const unsigned char __%s_bitmap__[] = {\n", name);
}
///
/// Print width table for c file
///
/// @param out file stream for output
/// @param name font variable name in C source file
/// @param width_table width table read from BDF file
/// @param chars number of characters in width table
///
void WidthTable(FILE * out, const char *name, const unsigned *width_table,
int chars)
{
fprintf(out, "};\n\n");
fprintf(out,
"\t/// character width for each encoding\n"
"static const unsigned char __%s_widths__[] = {\n", name);
while (chars--) {
fprintf(out, "\t%u,\n", *width_table++);
}
}
///
/// Print encoding table for c file
///
/// @param out file stream for output
/// @param name font variable name in C source file
/// @param encoding_table encoding table read from BDF file
/// @param chars number of characters in encoding table
///
void EncodingTable(FILE * out, const char *name,
const unsigned *encoding_table, int chars)
{
fprintf(out, "};\n\n");
fprintf(out,
"\t/// character encoding for each index entry\n"
"static const unsigned short __%s_index__[] = {\n", name);
while (chars--) {
fprintf(out, "\t%u,\n", *encoding_table++);
}
}
///
/// Print footer for c file.
///
/// @param out file stream for output
/// @param name font variable name in C source file
/// @param width character width of font
/// @param height character height of font
/// @param chars number of characters in font
///
void Footer(FILE * out, const char *name, int width, int height, int chars)
{
fprintf(out, "};\n\n");
fprintf(out,
"\t/// bitmap font structure\n" "const struct bitmap_font %s = {\n",
name);
fprintf(out, "\t.Width = %d, .Height = %d,\n", width, height);
fprintf(out, "\t.Chars = %d,\n", chars);
if(!SmartMatrix)
fprintf(out, "\t.Widths = __%s_widths__,\n", name);
else
fprintf(out, "\t.Widths = 0,\n");
fprintf(out, "\t.Index = __%s_index__,\n", name);
fprintf(out, "\t.Bitmap = __%s_bitmap__,\n", name);
fprintf(out, "};\n\n");
}
///
/// Dump character.
///
///
void DumpCharacter(FILE * out, unsigned char *bitmap, int fontwidth, int fontheight, int fontyoffset, int charheight, int charyoffset)
{
int x;
int y;
int c;
// how many rows from the top of the font bounding box is the top of this character?
int yoffset = fontheight - charheight + (fontyoffset - charyoffset);
for (y = 0; y < fontheight; ++y) {
fputc('\t', out);
for (x = 0; x < fontwidth; x += 8) {
// if current row is above or below the bitmap, output a blank row
if(y < yoffset || y > yoffset + charheight) {
c = 0;
} else {
c = bitmap[(y - yoffset) * ((fontwidth + 7) / 8) + x / 8];
//printf("%d = %d\n", y * ((width+7)/8) + x/8, c);
if (c & 0x80) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x40) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x20) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x10) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x08) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x04) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x02) {
fputc('X', out);
} else {
fputc('_', out);
}
if (c & 0x01) {
fputc('X', out);
} else {
fputc('_', out);
}
fputc(',', out);
}
}
fputc('\n', out);
}
}
///
/// Hex ascii to integer
///
/// @param p hex input character (0-9a-fA-F)
///
/// @returns converted integer
///
static inline int Hex2Int(const char *p)
{
if (*p <= '9') {
return *p - '0';
} else if (*p <= 'F') {
return *p - 'A' + 10;
} else {
return *p - 'a' + 10;
}
}
///
/// Rotate bitmap.
///
/// @param bitmap input bitmap
/// @param shift rotate counter (0-7)
/// @param width character width
/// @param height character height
///
void RotateBitmap(unsigned char *bitmap, int shift, int width, int height)
{
int x;
int y;
int c;
int o;
if (shift < 0 || shift > 7) {
fprintf(stderr, "This shift isn't supported\n");
exit(-1);
}
for (y = 0; y < height; ++y) {
o = 0;
for (x = 0; x < width; x += 8) {
c = bitmap[y * ((width + 7) / 8) + x / 8];
bitmap[y * ((width + 7) / 8) + x / 8] = c >> shift | o;
o = c << (8 - shift);
}
}
}
///
/// Outline character. Create an outline font from normal fonts.
///
/// @param bitmap input bitmap
/// @param width character width
/// @param height character height
///
void OutlineCharacter(unsigned char *bitmap, int width, int height)
{
int x;
int y;
unsigned char *outline;
outline = alloca(((width + 7) / 8) * height);
memset(outline, 0, ((width + 7) / 8) * height);
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
// Bit not set check surroundings
if (~bitmap[y * ((width + 7) / 8) + x / 8] & (0x80 >> x % 8)) {
// Upper row bit was set
if (y
&& bitmap[(y - 1) * ((width + 7) / 8) +
x / 8] & (0x80 >> x % 8)) {
outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
// Previous bit was set
} else if (x
&& bitmap[y * ((width + 7) / 8) + (x -
1) / 8] & (0x80 >> (x - 1) % 8)) {
outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
// Next bit was set
} else if (x < width - 1
&& bitmap[y * ((width + 7) / 8) + (x +
1) / 8] & (0x80 >> (x + 1) % 8)) {
outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
// below row was set
} else if (y < height - 1
&& bitmap[(y + 1) * ((width + 7) / 8) +
x / 8] & (0x80 >> x % 8)) {
outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
}
}
}
}
memcpy(bitmap, outline, ((width + 7) / 8) * height);
}
///
/// Read BDF font file.
///
/// @param bdf file stream for input (bdf file)
/// @param out file stream for output (C source file)
/// @param name font variable name in C source file
///
/// @todo bbx isn't used to correct character position in bitmap
///
void ReadBdf(FILE * bdf, FILE * out, const char *name)
{
char linebuf[1024];
char *s;
char *p;
int fontboundingbox_width;
int fontboundingbox_height;
// int fontboundingbox_xoff;
int fontboundingbox_yoff;
int chars;
int i;
int j;
int n;
int scanline;
char charname[1024];
int encoding;
int bbx;
int bby;
int bbw;
int bbh;
int width;
unsigned *width_table;
unsigned *encoding_table;
unsigned char *bitmap;
fontboundingbox_width = 0;
fontboundingbox_height = 0;
// fontboundingbox_xoff = 0;
fontboundingbox_yoff = 0;
chars = 0;
for (;;) {
if (!fgets(linebuf, sizeof(linebuf), bdf)) { // EOF
break;
}
if (!(s = strtok(linebuf, " \t\n\r"))) { // empty line
break;
}
// printf("token:%s\n", s);
if (!strcasecmp(s, "FONTBOUNDINGBOX")) {
p = strtok(NULL, " \t\n\r");
fontboundingbox_width = atoi(p);
p = strtok(NULL, " \t\n\r");
fontboundingbox_height = atoi(p);
p = strtok(NULL, " \t\n\r");
// fontboundingbox_xoff = atoi(p);
p = strtok(NULL, " \t\n\r");
fontboundingbox_yoff = atoi(p);
} else if (!strcasecmp(s, "CHARS")) {
p = strtok(NULL, " \t\n\r");
chars = atoi(p);
break;
}
}
/*
printf("%d * %dx%d\n", chars, fontboundingbox_width,
fontboundingbox_height);
*/
//
// Some checks.
//
if (fontboundingbox_width <= 0 || fontboundingbox_height <= 0) {
fprintf(stderr, "Need to know the character size\n");
exit(-1);
}
if (chars <= 0) {
fprintf(stderr, "Need to know the number of characters\n");
exit(-1);
}
if (Outline) { // Reserve space for outline border
fontboundingbox_width++;
fontboundingbox_height++;
}
//
// Allocate tables
//
width_table = malloc(chars * sizeof(*width_table));
if (!width_table) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
encoding_table = malloc(chars * sizeof(*encoding_table));
if (!encoding_table) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
/* FIXME: needed for proportional fonts.
offset_table = malloc(chars * sizeof(*offset_table));
if (!offset_table) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
*/
bitmap =
malloc(((fontboundingbox_width + 7) / 8) * fontboundingbox_height);
if (!bitmap) {
fprintf(stderr, "Out of memory\n");
exit(-1);
}
Header(out, name);
scanline = -1;
n = 0;
encoding = -1;
bbx = 0;
bby = 0;
bbw = 0;
bbh = 0;
width = INT_MIN;
strcpy(charname, "unknown character");
for (;;) {
if (!fgets(linebuf, sizeof(linebuf), bdf)) { // EOF
break;
}
if (!(s = strtok(linebuf, " \t\n\r"))) { // empty line
break;
}
// printf("token:%s\n", s);
if (!strcasecmp(s, "STARTCHAR")) {
p = strtok(NULL, " \t\n\r");
strcpy(charname, p);
} else if (!strcasecmp(s, "ENCODING")) {
p = strtok(NULL, " \t\n\r");
encoding = atoi(p);
} else if (!strcasecmp(s, "DWIDTH")) {
p = strtok(NULL, " \t\n\r");
width = atoi(p);
} else if (!strcasecmp(s, "BBX")) {
p = strtok(NULL, " \t\n\r");
bbw = atoi(p);
p = strtok(NULL, " \t\n\r");
bbh = atoi(p);
p = strtok(NULL, " \t\n\r");
bbx = atoi(p);
p = strtok(NULL, " \t\n\r");
bby = atoi(p);
} else if (!strcasecmp(s, "BITMAP")) {
fprintf(out, "// %3d $%02x '%s'\n", encoding, encoding, charname);
fprintf(out, "//\twidth %d, bbx %d, bby %d, bbw %d, bbh %d\n",
width, bbx, bby, bbw, bbh);
if (n == chars) {
fprintf(stderr, "Too many bitmaps for characters\n");
exit(-1);
}
if (width == INT_MIN) {
fprintf(stderr, "character width not specified\n");
exit(-1);
}
//
// Adjust width based on bounding box
//
if (bbx < 0) {
width -= bbx;
bbx = 0;
}
if (bbx + bbw > width) {
width = bbx + bbw;
}
if (Outline) { // Reserve space for outline border
++width;
}
width_table[n] = width;
encoding_table[n] = encoding;
++n;
if (Outline) { // Leave first row empty
scanline = 1;
} else {
scanline = 0;
}
memset(bitmap, 0,
((fontboundingbox_width + 7) / 8) * fontboundingbox_height);
} else if (!strcasecmp(s, "ENDCHAR")) {
if (bbx) {
RotateBitmap(bitmap, bbx, fontboundingbox_width,
fontboundingbox_height);
}
if (Outline) {
RotateBitmap(bitmap, 1, fontboundingbox_width,
fontboundingbox_height);
OutlineCharacter(bitmap, fontboundingbox_width,
fontboundingbox_height);
}
DumpCharacter(out, bitmap, fontboundingbox_width,
fontboundingbox_height, fontboundingbox_yoff, bbh, bby);
scanline = -1;
width = INT_MIN;
} else {
if (scanline >= 0) {
p = s;
j = 0;
while (*p) {
i = Hex2Int(p);
++p;
if (*p) {
i = Hex2Int(p) | i * 16;
} else {
bitmap[j + scanline * ((fontboundingbox_width +
7) / 8)] = i;
break;
}
/* printf("%d = %d\n",
j + scanline * ((fontboundingbox_width + 7)/8), i); */
bitmap[j + scanline * ((fontboundingbox_width + 7) / 8)] =
i;
++j;
++p;
}
++scanline;
}
}
}
// Output width table for proportional font.
if(!SmartMatrix)
WidthTable(out, name, width_table, chars);
// FIXME: Output offset table for proportional font.
// OffsetTable(out, name, offset_table, chars);
// Output encoding table for utf-8 support
EncodingTable(out, name, encoding_table, chars);
Footer(out, name, fontboundingbox_width, fontboundingbox_height, chars);
}
//////////////////////////////////////////////////////////////////////////////
///
/// Print version
///
void PrintVersion(void)
{
printf("bdf2c Version %s, (c) 2009, 2010 by Lutz Sammer\n"
"\tLicense AGPLv3: GNU Affero General Public License version 3\n",
VERSION);
}
///
/// Print usage
///
void PrintUsage(void)
{
printf("Usage: bdf2c [OPTIONs]\n"
"\t-h or -?\tPrints this short page on stdout\n"
"\t-b\tRead bdf file from stdin, write to stdout\n"
"\t-c\tCreate font header on stdout\n"
"\t-C file\tCreate font header file\n"
"\t-n name\tName of c font variable (place it before -b)\n"
"\t-O\tCreate outline for the font.\n");
printf("\n\tOnly idiots print usage on stderr\n");
}
///
/// Main test program for bdf2c.
///
///
/// @param argc number of arguments
/// @param argv arguments vector
///
int main(int argc, char *const argv[])
{
const char *name;
name = "font"; // default variable name
//
// Parse arguments.
//
for (;;) {
switch (getopt(argc, argv, "bcC:n:hOs?-")) {
case 'b': // bdf file name
ReadBdf(stdin, stdout, name);
continue;
case 'c': // create header file
CreateFontHeaderFile(stdout);
break;
case 'C': // create header file
{
FILE *out;
if (!(out = fopen(optarg, "w"))) {
fprintf(stderr, "Can't open file '%s': %s\n", optarg,
strerror(errno));
exit(-1);
}
CreateFontHeaderFile(out);
fclose(out);
}
continue;
case 'n':
name = optarg;
continue;
case 'O':
Outline = 1;
continue;
case 's':
SmartMatrix = 1;
continue;
case EOF:
break;
case '?':
case 'h': // help usage
PrintVersion();
PrintUsage();
exit(0);
case '-':
fprintf(stderr, "We need no long options\n");
PrintUsage();
exit(-1);
case ':':
PrintVersion();
fprintf(stderr, "Missing argument for option '%c'\n", optopt);
exit(-1);
default:
PrintVersion();
fprintf(stderr, "Unkown option '%c'\n", optopt);
exit(-1);
}
break;
}
while (optind < argc) {
fprintf(stderr, "Unhandled argument '%s'\n", argv[optind++]);
}
return 0;
}