GRAPHICS: Rework BDF font code.

1 files changed, 438 insertions, 616 deletions

diff --git a/graphics/fonts/bdf.cpp b/graphics/fonts/bdf.cpp
index 58c48ed877..2bc0582584 100644
--- a/graphics/fonts/bdf.cpp
+++ b/graphics/fonts/bdf.cpp
@@ -29,768 +29,590 @@
 
 namespace Graphics {
 
-void free_font(BdfFontData *pf);
+BdfFont::BdfFont(const BdfFontData &data, DisposeAfterUse::Flag dispose)
+	: _data(data), _dispose(dispose) {
+}
 
 BdfFont::~BdfFont() {
-	if (_font) {
-		free_font(_font);
+	if (_dispose == DisposeAfterUse::YES) {
+		for (int i = 0; i < _data.numCharacters; ++i)
+			delete[] _data.bitmaps[i];
+		delete[] _data.bitmaps;
+		delete[] _data.advances;
+		delete[] _data.boxes;
 	}
 }
 
 int BdfFont::getFontHeight() const {
-	return _desc.height;
+	return _data.height;
 }
 
 int BdfFont::getMaxCharWidth() const {
-	return _desc.maxwidth;
+	return _data.maxAdvance;
 }
 
 int BdfFont::getCharWidth(byte chr) const {
-	// If no width table is specified, return the maximum width
-	if (!_desc.width)
-		return _desc.maxwidth;
-	// If this character is not included in the font, use the default char.
-	if (chr < _desc.firstchar || _desc.firstchar + _desc.size < chr) {
-		chr = _desc.defaultchar;
-	}
-	return _desc.width[chr - _desc.firstchar];
+	// In case all font have the same advance value, we use the maximum.
+	if (!_data.advances)
+		return _data.maxAdvance;
+
+	const int ch = mapToIndex(chr);
+	// In case no mapping exists, we use the maximum advance.
+	if (ch < 0)
+		return _data.maxAdvance;
+	else
+		return _data.advances[ch];
 }
 
 
 template<typename PixelType>
-void drawCharIntern(byte *ptr, uint pitch, const bitmap_t *src, int h, int minX, int maxX, const PixelType color) {
-	const bitmap_t maxXMask = ~((1 << (16 - maxX)) - 1);
-	while (h-- > 0) {
-		bitmap_t buffer = READ_UINT16(src);
-		src++;
-
-		buffer &= maxXMask;
-		buffer <<= minX;
-		PixelType *tmp = (PixelType *)ptr;
-		while (buffer != 0) {
-			if ((buffer & 0x8000) != 0)
-				*tmp = color;
-			tmp++;
-			buffer <<= 1;
+void drawCharIntern(byte *ptr, uint pitch, const byte *src, int h, int width, int minX, int maxX, const PixelType color) {
+	byte data;
+	while (h--) {
+		PixelType *dst = (PixelType *)ptr;
+
+		for (int x = 0; x < width; ++x) {
+			if (!(x % 8))
+				data = *src++;
+
+			if (x >= minX && x <= maxX && (data & 0x80))
+				dst[x] = color;
+
+			data <<= 1;
 		}
 
 		ptr += pitch;
 	}
 }
 
+int BdfFont::mapToIndex(byte ch) const {
+	// Check whether the character is included
+	if (_data.firstCharacter <= ch && ch <= _data.firstCharacter + _data.numCharacters) {
+		if (_data.bitmaps[ch - _data.firstCharacter])
+			return ch - _data.firstCharacter;
+	}
+
+	return _data.defaultCharacter - _data.firstCharacter;
+}
+
 void BdfFont::drawChar(Surface *dst, byte chr, const int tx, const int ty, const uint32 color) const {
 	assert(dst != 0);
 
-	// asserting _desc.maxwidth <= 50: let the theme designer decide what looks best
-	assert(_desc.bits != 0 && _desc.maxwidth <= 50);
+	// TODO: Where is the relation between the max advance being smaller or
+	// equal to 50 and the decision of the theme designer?
+	// asserting _data.maxAdvance <= 50: let the theme designer decide what looks best
+	assert(_data.maxAdvance <= 50);
 	assert(dst->format.bytesPerPixel == 1 || dst->format.bytesPerPixel == 2);
 
-	// If this character is not included in the font, use the default char.
-	if (chr < _desc.firstchar || chr >= _desc.firstchar + _desc.size) {
-		chr = _desc.defaultchar;
-	}
-
-	chr -= _desc.firstchar;
+	const int idx = mapToIndex(chr);
+	if (idx < 0)
+		return;
 
-	int bbw, bbh, bbx, bby;
+	int width, height, xOffset, yOffset;
 
 	// Get the bounding box of the character
-	if (!_desc.bbx) {
-		bbw = _desc.fbbw;
-		bbh = _desc.fbbh;
-		bbx = _desc.fbbx;
-		bby = _desc.fbby;
+	if (!_data.boxes) {
+		width = _data.defaultBox.width;
+		height = _data.defaultBox.height;
+		xOffset = _data.defaultBox.xOffset;
+		yOffset = _data.defaultBox.yOffset;
 	} else {
-		bbw = _desc.bbx[chr].w;
-		bbh = _desc.bbx[chr].h;
-		bbx = _desc.bbx[chr].x;
-		bby = _desc.bbx[chr].y;
+		width = _data.boxes[idx].width;
+		height = _data.boxes[idx].height;
+		xOffset = _data.boxes[idx].xOffset;
+		yOffset = _data.boxes[idx].yOffset;
 	}
 
-	byte *ptr = (byte *)dst->getBasePtr(tx + bbx, ty + _desc.ascent - bby - bbh);
+	int y = ty + _data.ascent - yOffset - height;
+	int x = tx + xOffset;
 
-	const bitmap_t *tmp = _desc.bits + (_desc.offset ? _desc.offset[chr] : (chr * _desc.fbbh));
+	const byte *src = _data.bitmaps[idx];
 
-	int y = MIN(bbh, ty + _desc.ascent - bby);
-	tmp += bbh - y;
-	y -= MAX(0, ty + _desc.ascent - bby - dst->h);
+	const int bytesPerRow = (width + 7) / 8;
+	const int originalWidth = width;
 
-	if (dst->format.bytesPerPixel == 1)
-		drawCharIntern<byte>(ptr, dst->pitch, tmp, y, MAX(0, -(tx + bbx)), MIN(bbw, dst->w - tx - bbx), color);
-	else if (dst->format.bytesPerPixel == 2)
-		drawCharIntern<uint16>(ptr, dst->pitch, tmp, y, MAX(0, -(tx + bbx)), MIN(bbw, dst->w - tx - bbx), color);
-}
+	// Make sure we do not draw outside the surface
+	if (y < 0) {
+		src -= y * bytesPerRow;
+		height += y;
+		y = 0;
+	}
 
+	if (y + height > dst->h)
+		height = dst->h - y;
 
-#pragma mark -
-
-/* BEGIN font.h*/
-/* 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))
-
-/* builtin C-based proportional/fixed font structure */
-/* based on The Microwindows Project http://microwindows.org */
-struct BdfFontData {
-	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 */
-	BBX           *bbx;        /* character bounding box 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
-
-int start_char = 0;
-int limit_char = 255;
-
-BdfFontData *bdf_read_font(Common::SeekableReadStream &fp);
-int bdf_read_header(Common::SeekableReadStream &fp, BdfFontData *pf);
-int bdf_read_bitmaps(Common::SeekableReadStream &fp, BdfFontData *pf);
-char *bdf_getline(Common::SeekableReadStream &fp, char *buf, int len);
-bitmap_t bdf_hexval(unsigned char *buf);
-
-void free_font(BdfFontData *pf) {
-	if (!pf)
+	if (height <= 0)
 		return;
-	free(pf->name);
-	free(pf->facename);
-	free(pf->copyright);
-	free(pf->bits);
-	free(pf->offset);
-	free(pf->width);
-	free(pf->bbx);
-	free(pf);
-}
-
-/* build incore structure from .bdf file*/
-BdfFontData *bdf_read_font(Common::SeekableReadStream &fp) {
-	BdfFontData *pf;
-	uint32 pos = fp.pos();
 
-	pf = (BdfFontData *)calloc(1, sizeof(BdfFontData));
-	if (!pf)
-		goto errout;
-
-	if (!bdf_read_header(fp, pf)) {
-		warning("Error reading font header");
-		goto errout;
+	int xStart = 0;
+	if (x < 0) {
+		xStart = -x;
+		width += x;
+		x = 0;
 	}
 
-	fp.seek(pos, SEEK_SET);
+	if (x + width > dst->w)
+		width = dst->w - x;
 
-	if (!bdf_read_bitmaps(fp, pf)) {
-		warning("Error reading font bitmaps");
-		goto errout;
-	}
+	if (width <= 0)
+		return;
 
-	return pf;
+	const int xEnd = xStart + width - 1;
 
-errout:
-	free_font(pf);
-	return NULL;
+	byte *ptr = (byte *)dst->getBasePtr(x, y);
+
+	if (dst->format.bytesPerPixel == 1)
+		drawCharIntern<byte>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color);
+	else if (dst->format.bytesPerPixel == 2)
+		drawCharIntern<uint16>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color);
 }
 
-/* read bdf font header information, return 0 on error*/
-int bdf_read_header(Common::SeekableReadStream &fp, BdfFontData *pf) {
-	int encoding = 0;
-	int nchars = 0, maxwidth, maxheight;
-	int firstchar = 65535;
-	int lastchar = -1;
-	char buf[256];
-	char facename[256];
-	char copyright[256];
-	memset(facename, 0, sizeof(facename));
-	memset(copyright, 0, sizeof(copyright));
-
-	/* 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))) {
-			warning("Error: EOF on file");
-			return 0;
-		}
+namespace {
 
-		/* note: the way sscanf is used here ensures that a terminating null
-		   character is automatically added. Refer to:
-		   http://pubs.opengroup.org/onlinepubs/009695399/functions/fscanf.html */
+inline byte hexToInt(char c) {
+	if (c >= '0' && c <= '9')
+		return c - '0';
+	else if (c >= 'A' && c <= 'F')
+		return c - 'A' + 10;
+	else if (c >= 'a' && c <= 'f')
+		return c - 'a' + 10;
+	else
+		return 0;
+}
 
-		if (isprefix(buf, "FONT ")) {       /* not required*/
-			if (sscanf(buf, "FONT %[^\n]", facename) != 1) {
-				warning("Error: bad 'FONT'");
-				return 0;
-			}
+byte *loadCharacter(Common::SeekableReadStream &stream, int &encoding, int &advance, BdfBoundingBox &box) {
+	Common::String line;
+	byte *bitmap = 0;
 
-			pf->facename = strdup(facename);
-			continue;
+	while (true) {
+		line = stream.readLine();
+		if (stream.err() || stream.eos()) {
+			warning("BdfFont::loadCharacter: Premature end of file");
+			delete[] bitmap;
+			return 0;
 		}
-		if (isprefix(buf, "COPYRIGHT ")) {  /* not required*/
-			if (sscanf(buf, "COPYRIGHT \"%[^\"]", copyright) != 1) {
-				warning("Error: bad 'COPYRIGHT'");
-				return 0;
-			}
 
-			pf->copyright = strdup(copyright);
-			continue;
-		}
-		if (isprefix(buf, "DEFAULT_CHAR ")) {   /* not required*/
-			if (sscanf(buf, "DEFAULT_CHAR %d", &pf->defaultchar) != 1) {
-				warning("Error: bad 'DEFAULT_CHAR'");
+		if (line.hasPrefix("ENCODING ")) {
+			if (sscanf(line.c_str(), "ENCODING %d", &encoding) != 1) {
+				warning("BdfFont::loadCharacter: Invalid ENCODING");
+				delete[] bitmap;
 				return 0;
 			}
-		}
-		if (isprefix(buf, "FONT_DESCENT ")) {
-			if (sscanf(buf, "FONT_DESCENT %d", &pf->descent) != 1) {
-				warning("Error: bad 'FONT_DESCENT'");
+		} else if (line.hasPrefix("DWIDTH ")) {
+			int yAdvance;
+			if (sscanf(line.c_str(), "DWIDTH %d %d", &advance, &yAdvance) != 2) {
+				warning("BdfFont::loadCharacter: Invalid DWIDTH");
+				delete[] bitmap;
 				return 0;
 			}
-			continue;
-		}
-		if (isprefix(buf, "FONT_ASCENT ")) {
-			if (sscanf(buf, "FONT_ASCENT %d", &pf->ascent) != 1) {
-				warning("Error: bad 'FONT_ASCENT'");
+
+			if (yAdvance != 0) {
+				warning("BdfFont::loadCharacter: Character %d has an y advance of %d", encoding, yAdvance);
+				delete[] bitmap;
 				return 0;
 			}
-			continue;
-		}
-		if (isprefix(buf, "FONTBOUNDINGBOX ")) {
-			if (sscanf(buf, "FONTBOUNDINGBOX %d %d %d %d",
-			           &pf->fbbw, &pf->fbbh, &pf->fbbx, &pf->fbby) != 4) {
-				warning("Error: bad 'FONTBOUNDINGBOX'");
+
+			if (advance < 0) {
+				warning("BdfFont::loadCharacter: Character %d has an x advance of %d", encoding, advance);
+				delete[] bitmap;
 				return 0;
 			}
-			continue;
-		}
-		if (isprefix(buf, "CHARS ")) {
-			if (sscanf(buf, "CHARS %d", &nchars) != 1) {
-				warning("Error: bad 'CHARS'");
+		} else if (line.hasPrefix("BBX ")) {
+			int width, height, xOffset, yOffset;
+			if (sscanf(line.c_str(), "BBX %d %d %d %d",
+			           &width, &height, &xOffset, &yOffset) != 4) {
+				warning("BdfFont::loadCharacter: Invalid BBX");
+				delete[] bitmap;
 				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) {
-				warning("Error: bad 'ENCODING'");
-				return 0;
-			}
-			if (encoding >= 0 &&
-			        encoding <= limit_char &&
-			        encoding >= start_char) {
-
-				if (firstchar > encoding)
-					firstchar = encoding;
-				if (lastchar < encoding)
-					lastchar = encoding;
+			box.width = width;
+			box.height = height;
+			box.xOffset = xOffset;
+			box.yOffset = yOffset;
+		} else if (line == "BITMAP") {
+			const uint bytesPerRow = (box.width + 7) / 8;
+			byte *dst = bitmap = new byte[box.height * bytesPerRow];
+
+			for (int y = 0; y < box.height; ++y) {
+				line = stream.readLine();
+				if (stream.err() || stream.eos()) {
+					warning("BdfFont::loadCharacter: Premature end of file");
+					delete[] bitmap;
+					return 0;
+				}
+
+				if (line.size() != 2 * bytesPerRow) {
+					warning("BdfFont::loadCharacter: Pixel line has wrong size");
+					delete[] bitmap;
+					return 0;
+				}
+
+				for (uint x = 0; x < bytesPerRow; ++x) {
+					char nibble1 = line[x * 2 + 0];
+					char nibble2 = line[x * 2 + 1];
+					*dst++ = (hexToInt(nibble1) << 4) | hexToInt(nibble2);
+				}
 			}
-			continue;
+		} else if (line == "ENDCHAR") {
+			return bitmap;
 		}
-		if (strequal(buf, "ENDFONT"))
-			break;
 	}
 
-	/* calc font height*/
-	if (pf->ascent < 0 || pf->descent < 0 || firstchar < 0) {
-		warning("Error: Invalid BDF file, requires FONT_ASCENT/FONT_DESCENT/ENCODING");
-		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;
-	maxheight = pf->fbbh;
-
-	/* initially use font bounding box for bits allocation*/
-	pf->bits_size = nchars * BITMAP_WORDS(maxwidth) * maxheight;
-
-	/* 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));
-	pf->bbx = (BBX *)malloc(pf->size * sizeof(BBX));
-
-	if (!pf->bits || !pf->offset || !pf->width) {
-		warning("Error: no memory for font load");
-		return 0;
-	}
+	delete[] bitmap;
+	return 0;
+}
 
-	return 1;
+void freeBitmaps(byte **bitmaps, int size) {
+	for (int i = 0; i < size; ++i)
+		delete[] bitmaps[i];
 }
 
-/* read bdf font bitmaps, return 0 on error*/
-int bdf_read_bitmaps(Common::SeekableReadStream &fp, BdfFontData *pf) {
-	long ofs = 0;
-	int maxwidth = 0;
-	int i, k, encoding = 0, width = 0;
-	int bbw = 0, bbh = 0, bbx = 0, bby = 0;
-	int proportional = 0;
-	int need_bbx = 0;
-	int encodetable = 0;
-	long l;
-	char buf[256];
-
-	/* initially mark offsets as not used*/
-	for (i = 0; i < pf->size; ++i)
-		pf->offset[i] = (unsigned long)-1;
-
-	for (;;) {
-		if (!bdf_getline(fp, buf, sizeof(buf))) {
-			warning("Error: EOF on file");
+} // End of anonymous namespace
+
+BdfFont *BdfFont::loadFont(Common::SeekableReadStream &stream) {
+	BdfFontData font;
+	memset(&font, 0, sizeof(font));
+	font.ascent = -1;
+	font.defaultCharacter = -1;
+
+	// We only load the first 256 characters
+	font.numCharacters = 256;
+	byte **bitmaps = new byte *[font.numCharacters];
+	memset(bitmaps, 0, sizeof(byte *) * font.numCharacters);
+	byte *advances = new byte[font.numCharacters];
+	BdfBoundingBox *boxes = new BdfBoundingBox[font.numCharacters];
+
+	int descent = -1;
+
+	Common::String line;
+	while (true) {
+		line = stream.readLine();
+		if (stream.err() || stream.eos()) {
+			warning("BdfFont::loadFont: Premature end of file");
+			freeBitmaps(bitmaps, font.numCharacters);
+			delete[] bitmaps;
+			delete[] advances;
+			delete[] boxes;
 			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) {
-				warning("Error: bad 'ENCODING'");
+
+		// Only parse and handle declarations we actually need
+		if (line.hasPrefix("FONTBOUNDINGBOX ")) {
+			int width, height, xOffset, yOffset;
+			if (sscanf(line.c_str(), "FONTBOUNDINGBOX %d %d %d %d",
+			           &width, &height, &xOffset, &yOffset) != 4) {
+				warning("BdfFont::loadFont: Invalid FONTBOUNDINGBOX");
+				freeBitmaps(bitmaps, font.numCharacters);
+				delete[] bitmaps;
+				delete[] advances;
+				delete[] boxes;
 				return 0;
 			}
-			if (encoding < start_char || encoding > limit_char)
-				encoding = -1;
-			continue;
-		}
-		if (isprefix(buf, "DWIDTH ")) {
-			if (sscanf(buf, "DWIDTH %d", &width) != 1) {
-				warning("Error: bad 'DWIDTH'");
+
+			font.defaultBox.width = width;
+			font.defaultBox.height = height;
+			font.defaultBox.xOffset = xOffset;
+			font.defaultBox.yOffset = yOffset;
+		} else if (line.hasPrefix("FONT_ASCENT ")) {
+			if (sscanf(line.c_str(), "FONT_ASCENT %d", &font.ascent) != 1) {
+				warning("BdfFont::loadFont: Invalid FONT_ASCENT");
+				freeBitmaps(bitmaps, font.numCharacters);
+				delete[] bitmaps;
+				delete[] advances;
+				delete[] boxes;
 				return 0;
 			}
-			/* use font boundingbox width if DWIDTH <= 0*/
-			if (width <= 0)
-				width = pf->fbbw - pf->fbbx;
-			continue;
-		}
-		if (isprefix(buf, "BBX ")) {
-			if (sscanf(buf, "BBX %d %d %d %d", &bbw, &bbh, &bbx, &bby) != 4) {
-				warning("Error: bad 'BBX'");
+		} else if (line.hasPrefix("FONT_DESCENT ")) {
+			if (sscanf(line.c_str(), "FONT_DESCENT %d", &descent) != 1) {
+				warning("BdfFont::loadFont: Invalid FONT_DESCENT");
+				freeBitmaps(bitmaps, font.numCharacters);
+				delete[] bitmaps;
+				delete[] advances;
+				delete[] boxes;
 				return 0;
 			}
-			continue;
-		}
-		if (strequal(buf, "BITMAP")) {
-			bitmap_t *ch_bitmap = pf->bits + ofs;
-			int ch_words;
-
-			if (encoding < 0)
-				continue;
-
-			/* set bits offset in encode map*/
-			if (pf->offset[encoding - pf->firstchar] != (unsigned long)-1) {
-				warning("Error: duplicate encoding for character %d (0x%02x), ignoring duplicate",
-				        encoding, encoding);
-				continue;
+		} else if (line.hasPrefix("DEFAULT_CHAR ")) {
+			if (sscanf(line.c_str(), "DEFAULT_CHAR %d", &font.defaultCharacter) != 1) {
+				warning("BdfFont::loadFont: Invalid DEFAULT_CHAR");
+				freeBitmaps(bitmaps, font.numCharacters);
+				delete[] bitmaps;
+				delete[] advances;
+				delete[] boxes;
+				return 0;
+			}
+		} else if (line.hasPrefix("STARTCHAR ")) {
+			BdfBoundingBox box = font.defaultBox;
+			int encoding = -1;
+			int advance = -1;
+			byte *bitmap = loadCharacter(stream, encoding, advance, box);
+
+			// Ignore all characters above 255.
+			if (encoding < -1 || encoding >= font.numCharacters) {
+				delete[] bitmap;
+				encoding = -1;
 			}
-			pf->offset[encoding - pf->firstchar] = ofs;
-			pf->width[encoding - pf->firstchar] = width;
 
-			pf->bbx[encoding - pf->firstchar].w = bbw;
-			pf->bbx[encoding - pf->firstchar].h = bbh;
-			pf->bbx[encoding - pf->firstchar].x = bbx;
-			pf->bbx[encoding - pf->firstchar].y = bby;
+			// Calculate the max advance
+			if (encoding != -1 && advance > font.maxAdvance)
+				font.maxAdvance = advance;
 
-			if (width > maxwidth)
-				maxwidth = width;
+			if (!bitmap && encoding != -1) {
+				warning("BdfFont::loadFont: Character %d invalid", encoding);
+				freeBitmaps(bitmaps, font.numCharacters);
+				delete[] bitmaps;
+				delete[] advances;
+				delete[] boxes;
+				return 0;
+			}
 
-			/* clear bitmap*/
-			memset(ch_bitmap, 0, BITMAP_BYTES(bbw) * bbh);
+			if (encoding != -1) {
+				bitmaps[encoding] = bitmap;
+				advances[encoding] = advance;
+				boxes[encoding] = box;
+			}
+		} else if (line == "ENDFONT") {
+			break;
+		}
+	}
 
-			ch_words = BITMAP_WORDS(bbw);
+	if (font.ascent < 0 || descent < 0) {
+		warning("BdfFont::loadFont: Invalid ascent or descent");
+		freeBitmaps(bitmaps, font.numCharacters);
+		delete[] bitmaps;
+		delete[] advances;
+		delete[] boxes;
+		return 0;
+	}
 
-			/* read bitmaps*/
-			for (i = 0; i < bbh; ++i) {
-				if (!bdf_getline(fp, buf, sizeof(buf))) {
-					warning("Error: EOF reading BITMAP data");
-					return 0;
-				}
-				if (isprefix(buf, "ENDCHAR"))
-					break;
-
-				for (k = 0; k < ch_words; ++k) {
-					bitmap_t value;
-
-					value = bdf_hexval((unsigned char *)buf);
-					if (bbw > 8) {
-						WRITE_UINT16(ch_bitmap, value);
-					} else {
-						WRITE_UINT16(ch_bitmap, value << 8);
-					}
-					ch_bitmap++;
-				}
-			}
+	font.height = font.ascent + descent;
+
+	font.bitmaps = bitmaps;
+	font.advances = advances;
+	font.boxes = boxes;
+
+	int firstCharacter = font.numCharacters;
+	int lastCharacter = -1;
+	bool hasFixedBBox = true;
+	bool hasFixedAdvance = true;
 
-			ofs += ch_words * bbh;
+	for (int i = 0; i < font.numCharacters; ++i) {
+		if (!font.bitmaps[i])
 			continue;
-		}
-		if (strequal(buf, "ENDFONT"))
-			break;
-	}
 
-	/* set max width*/
-	pf->maxwidth = maxwidth;
+		if (i < firstCharacter)
+			firstCharacter = i;
 
-	/* change unused offset/width values to default char values*/
-	for (i = 0; i < pf->size; ++i) {
-		int defchar = pf->defaultchar - pf->firstchar;
+		if (i > lastCharacter)
+			lastCharacter = i;
 
-		if (pf->offset[i] == (unsigned long)-1) {
-			pf->offset[i] = pf->offset[defchar];
-			pf->width[i] = pf->width[defchar];
-			pf->bbx[i].w = pf->bbx[defchar].w;
-			pf->bbx[i].h = pf->bbx[defchar].h;
-			pf->bbx[i].x = pf->bbx[defchar].x;
-			pf->bbx[i].y = pf->bbx[defchar].y;
-		}
-	}
+		if (font.advances[i] != font.maxAdvance)
+			hasFixedAdvance = false;
 
-	/* determine whether font doesn't require encode table*/
-	l = 0;
-	for (i = 0; i < pf->size; ++i) {
-		if (pf->offset[i] != (unsigned long)l) {
-			encodetable = 1;
-			break;
-		}
-		l += BITMAP_WORDS(pf->bbx[i].w) * pf->bbx[i].h;
-	}
-	if (!encodetable) {
-		free(pf->offset);
-		pf->offset = NULL;
+		const BdfBoundingBox &bbox = font.boxes[i];
+		if (bbox.width != font.defaultBox.width
+		    || bbox.height != font.defaultBox.height
+		    || bbox.xOffset != font.defaultBox.xOffset
+		    || bbox.yOffset != font.defaultBox.yOffset)
+			hasFixedBBox = false;
 	}
 
-	/* determine whether font is fixed-width*/
-	for (i = 0; i < pf->size; ++i) {
-		if (pf->width[i] != maxwidth) {
-			proportional = 1;
-			break;
-		}
-	}
-	if (!proportional) {
-		free(pf->width);
-		pf->width = NULL;
+	if (lastCharacter == -1) {
+		warning("BdfFont::loadFont: No glyphs found");
+		delete[] font.bitmaps;
+		delete[] font.advances;
+		delete[] font.boxes;
+		return 0;
 	}
 
-	/* determine if the font needs a bbx table */
-	for (i = 0; i < pf->size; ++i) {
-		if (pf->bbx[i].w != pf->fbbw || pf->bbx[i].h != pf->fbbh || pf->bbx[i].x != pf->fbbx || pf->bbx[i].y != pf->fbby) {
-			need_bbx = 1;
-			break;
-		}
-	}
-	if (!need_bbx) {
-		free(pf->bbx);
-		pf->bbx = NULL;
+	// Free the advance table, in case all glyphs use the same advance
+	if (hasFixedAdvance) {
+		delete[] font.advances;
+		font.advances = 0;
 	}
 
-	/* reallocate bits array to actual bits used*/
-	if (ofs < pf->bits_size) {
-		bitmap_t *tmp = (bitmap_t *)realloc(pf->bits, ofs * sizeof(bitmap_t));
-		if (tmp != NULL || ofs == 0)
-			pf->bits = tmp;
-		else
-			error("bdf_read_bitmaps: Error while reallocating memory");
-		pf->bits_size = ofs;
-	} else {
-		if (ofs > pf->bits_size) {
-			warning("Warning: DWIDTH spec > max FONTBOUNDINGBOX");
-			if (ofs > pf->bits_size + EXTRA) {
-				warning("Error: Not enough bits initially allocated");
-				return 0;
-			}
-			pf->bits_size = ofs;
-		}
+	// Free the box table, in case all glyphs use the same box
+	if (hasFixedBBox) {
+		delete[] font.boxes;
+		font.boxes = 0;
 	}
 
-	return 1;
-}
+	// Adapt for the fact that we never use encoding 0.
+	if (font.defaultCharacter < firstCharacter
+	    || font.defaultCharacter > lastCharacter)
+		font.defaultCharacter = -1;
 
-/* read the next non-comment line, returns buf or NULL if EOF*/
-// TODO: Can we use SeekableReadStream::readLine instead?
-char *bdf_getline(Common::SeekableReadStream &fp, char *buf, int len) {
-	int c;
-	char *b;
-
-	for (;;) {
-		b = buf;
-		while (!fp.eos()) {
-			c = fp.readByte();
-			if (c == '\r')
-				continue;
-			if (c == '\n')
-				break;
-			if (b - buf >= (len - 1))
-				break;
-			*b++ = c;
+	font.firstCharacter = firstCharacter;
+
+	const int charsAvailable = lastCharacter - firstCharacter + 1;
+	// Try to compact the tables
+	if (charsAvailable < font.numCharacters) {
+		byte **newBitmaps = new byte *[charsAvailable];
+		boxes = 0;
+		advances = 0;
+		if (!hasFixedBBox)
+			boxes = new BdfBoundingBox[charsAvailable];
+		if (!hasFixedAdvance)
+			advances = new byte[charsAvailable];
+
+		for (int i = 0; i < charsAvailable; ++i) {
+			const int encoding = i + firstCharacter;
+			if (font.bitmaps[encoding]) {
+				newBitmaps[i] = bitmaps[encoding];
+
+				if (!hasFixedBBox)
+					boxes[i] = font.boxes[encoding];
+				if (!hasFixedAdvance)
+					advances[i] = font.advances[encoding];
+			} else {
+				newBitmaps[i] = 0;
+			}
 		}
-		*b = '\0';
-		if (fp.eos() && b == buf)
-			return NULL;
-		if (b != buf && !isprefix(buf, "COMMENT"))
-			break;
-	}
-	return buf;
-}
 
-/* return hex value of buffer */
-bitmap_t bdf_hexval(unsigned char *buf) {
-	bitmap_t val = 0;
-
-	for (unsigned char *ptr = buf; *ptr; ptr++) {
-		int c = *ptr;
-
-		if (c >= '0' && c <= '9')
-			c -= '0';
-		else if (c >= 'A' && c <= 'F')
-			c = c - 'A' + 10;
-		else if (c >= 'a' && c <= 'f')
-			c = c - 'a' + 10;
-		else
-			c = 0;
-		val = (val << 4) | c;
-	}
-	return val;
-}
+		delete[] font.bitmaps;
+		font.bitmaps = newBitmaps;
+		delete[] font.advances;
+		font.advances = advances;
+		delete[] font.boxes;
+		font.boxes = boxes;
 
-BdfFont *BdfFont::loadFont(Common::SeekableReadStream &stream) {
-	BdfFontData *data = bdf_read_font(stream);
-	if (!data || stream.err()) {
-		free_font(data);
-		return 0;
+		font.numCharacters = charsAvailable;
 	}
 
-	BdfFontDesc desc;
-	desc.name = data->name;
-	desc.maxwidth = data->maxwidth;
-	desc.height = data->height;
-	desc.fbbw = data->fbbw;
-	desc.fbbh = data->fbbh;
-	desc.fbbx = data->fbbx;
-	desc.fbby = data->fbby;
-	desc.ascent = data->ascent;
-	desc.firstchar = data->firstchar;
-	desc.size = data->size;
-	desc.bits = data->bits;
-	desc.offset = data->offset;
-	desc.width = data->width;
-	desc.bbx = data->bbx;
-	desc.defaultchar = data->defaultchar;
-	desc.bits_size = data->bits_size;
-
-	return new BdfFont(desc, data);
+	return new BdfFont(font, DisposeAfterUse::YES);
 }
 
 bool BdfFont::cacheFontData(const BdfFont &font, const Common::String &filename) {
 	Common::DumpFile cacheFile;
 	if (!cacheFile.open(filename)) {
-		warning("Couldn't open file '%s' for writing", filename.c_str());
+		warning("BdfFont::cacheFontData: Couldn't open file '%s' for writing", filename.c_str());
 		return false;
 	}
 
-	cacheFile.writeUint16BE(font._desc.maxwidth);
-	cacheFile.writeUint16BE(font._desc.height);
-	cacheFile.writeUint16BE(font._desc.fbbw);
-	cacheFile.writeUint16BE(font._desc.fbbh);
-	cacheFile.writeSint16BE(font._desc.fbbx);
-	cacheFile.writeSint16BE(font._desc.fbby);
-	cacheFile.writeUint16BE(font._desc.ascent);
-	cacheFile.writeUint16BE(font._desc.firstchar);
-	cacheFile.writeUint16BE(font._desc.size);
-	cacheFile.writeUint16BE(font._desc.defaultchar);
-	cacheFile.writeUint32BE(font._desc.bits_size);
-
-	for (long i = 0; i < font._desc.bits_size; ++i) {
-		cacheFile.writeUint16BE(font._desc.bits[i]);
-	}
-
-	if (font._desc.offset) {
-		cacheFile.writeByte(1);
-		for (int i = 0; i < font._desc.size; ++i) {
-			cacheFile.writeUint32BE(font._desc.offset[i]);
+	const BdfFontData &data = font._data;
+
+	cacheFile.writeUint32BE(MKTAG('S', 'V', 'F', 'C'));
+	cacheFile.writeUint32BE(1);
+	cacheFile.writeUint16BE(data.maxAdvance);
+	cacheFile.writeByte(data.height);
+	cacheFile.writeByte(data.defaultBox.width);
+	cacheFile.writeByte(data.defaultBox.height);
+	cacheFile.writeSByte(data.defaultBox.xOffset);
+	cacheFile.writeSByte(data.defaultBox.yOffset);
+	cacheFile.writeByte(data.ascent);
+	cacheFile.writeUint16BE(data.firstCharacter);
+	cacheFile.writeSint16BE(data.defaultCharacter);
+	cacheFile.writeUint16BE(data.numCharacters);
+
+	for (int i = 0; i < data.numCharacters; ++i) {
+		const BdfBoundingBox &box = data.boxes ? data.boxes[i] : data.defaultBox;
+		if (data.bitmaps[i]) {
+			const int bytes = ((box.width + 7) / 8) * box.height;
+			cacheFile.writeUint32BE(bytes);
+			cacheFile.write(data.bitmaps[i], bytes);
+		} else {
+			cacheFile.writeUint32BE(0);
 		}
-	} else {
-		cacheFile.writeByte(0);
 	}
 
-	if (font._desc.width) {
-		cacheFile.writeByte(1);
-		for (int i = 0; i < font._desc.size; ++i) {
-			cacheFile.writeByte(font._desc.width[i]);
-		}
+	if (data.advances) {
+		cacheFile.writeByte(0xFF);
+		cacheFile.write(data.advances, data.numCharacters);
 	} else {
-		cacheFile.writeByte(0);
+		cacheFile.writeByte(0x00);
 	}
 
-	if (font._desc.bbx) {
-		cacheFile.writeByte(1);
-		for (int i = 0; i < font._desc.size; ++i) {
-			cacheFile.writeByte(font._desc.bbx[i].w);
-			cacheFile.writeByte(font._desc.bbx[i].h);
-			cacheFile.writeByte(font._desc.bbx[i].x);
-			cacheFile.writeByte(font._desc.bbx[i].y);
+	if (data.boxes) {
+		cacheFile.writeByte(0xFF);
+
+		for (int i = 0; i < data.numCharacters; ++i) {
+			const BdfBoundingBox &box = data.boxes[i];
+			cacheFile.writeByte(box.width);
+			cacheFile.writeByte(box.height);
+			cacheFile.writeSByte(box.xOffset);
+			cacheFile.writeSByte(box.yOffset);
 		}
 	} else {
-		cacheFile.writeByte(0);
+		cacheFile.writeByte(0x00);
 	}
 
 	return !cacheFile.err();
 }
 
 BdfFont *BdfFont::loadFromCache(Common::SeekableReadStream &stream) {
-	BdfFont *font = 0;
-
-	BdfFontData *data = (BdfFontData *)malloc(sizeof(BdfFontData));
-	if (!data)
+	const uint32 magic = stream.readUint32BE();
+	if (magic != MKTAG('S', 'V', 'F', 'C'))
 		return 0;
 
-	memset(data, 0, sizeof(BdfFontData));
-
-	data->maxwidth = stream.readUint16BE();
-	data->height = stream.readUint16BE();
-	data->fbbw = stream.readUint16BE();
-	data->fbbh = stream.readUint16BE();
-	data->fbbx = stream.readSint16BE();
-	data->fbby = stream.readSint16BE();
-	data->ascent = stream.readUint16BE();
-	data->firstchar = stream.readUint16BE();
-	data->size = stream.readUint16BE();
-	data->defaultchar = stream.readUint16BE();
-	data->bits_size = stream.readUint32BE();
-
-	data->bits = (bitmap_t *)malloc(sizeof(bitmap_t) * data->bits_size);
-	if (!data->bits) {
-		free(data);
+	const uint32 version = stream.readUint32BE();
+	if (version != 1)
 		return 0;
-	}
 
-	for (long i = 0; i < data->bits_size; ++i) {
-		data->bits[i] = stream.readUint16BE();
-	}
+	BdfFontData data;
 
-	bool hasOffsetTable = (stream.readByte() != 0);
-	if (hasOffsetTable) {
-		data->offset = (unsigned long *)malloc(sizeof(unsigned long) * data->size);
-		if (!data->offset) {
-			free(data->bits);
-			free(data);
-			return 0;
-		}
+	data.maxAdvance = stream.readUint16BE();
+	data.height = stream.readByte();
+	data.defaultBox.width = stream.readByte();
+	data.defaultBox.height = stream.readByte();
+	data.defaultBox.xOffset = stream.readSByte();
+	data.defaultBox.yOffset = stream.readSByte();
+	data.ascent = stream.readByte();
+	data.firstCharacter = stream.readUint16BE();
+	data.defaultCharacter = stream.readSint16BE();
+	data.numCharacters = stream.readUint16BE();
 
-		for (int i = 0; i < data->size; ++i) {
-			data->offset[i] = stream.readUint32BE();
-		}
-	}
+	if (stream.err() || stream.eos())
+		return 0;
+
+	byte **bitmaps = new byte *[data.numCharacters];
+	byte *advances = 0;
+	BdfBoundingBox *boxes = 0;
+	for (int i = 0; i < data.numCharacters; ++i) {
+		uint32 size = stream.readUint32BE();
 
-	bool hasWidthTable = (stream.readByte() != 0);
-	if (hasWidthTable) {
-		data->width = (unsigned char *)malloc(sizeof(unsigned char) * data->size);
-		if (!data->width) {
-			free(data->bits);
-			free(data->offset);
-			free(data);
+		if (stream.err() || stream.eos()) {
+			for (int j = 0; j < i; ++j)
+				delete[] bitmaps[i];
+			delete[] bitmaps;
 			return 0;
 		}
 
-		for (int i = 0; i < data->size; ++i) {
-			data->width[i] = stream.readByte();
+		if (size) {
+			bitmaps[i] = new byte[size];
+			stream.read(bitmaps[i], size);
+		} else {
+			bitmaps[i] = 0;
 		}
 	}
 
-	bool hasBBXTable = (stream.readByte() != 0);
-	if (hasBBXTable) {
-		data->bbx = (BBX *)malloc(sizeof(BBX) * data->size);
-		if (!data->bbx) {
-			free(data->bits);
-			free(data->offset);
-			free(data->width);
-			free(data);
-			return 0;
-		}
 
-		for (int i = 0; i < data->size; ++i) {
-			data->bbx[i].w = (int8)stream.readByte();
-			data->bbx[i].h = (int8)stream.readByte();
-			data->bbx[i].x = (int8)stream.readByte();
-			data->bbx[i].y = (int8)stream.readByte();
-		}
+	if (stream.readByte() == 0xFF) {
+		advances = new byte[data.numCharacters];
+		stream.read(advances, data.numCharacters);
 	}
 
-	if (stream.err() || stream.eos()) {
-		free(data->bits);
-		free(data->offset);
-		free(data->width);
-		free(data);
-		return 0;
+	if (stream.readByte() == 0xFF) {
+		boxes = new BdfBoundingBox[data.numCharacters];
+		for (int i = 0; i < data.numCharacters; ++i) {
+			boxes[i].width = stream.readByte();
+			boxes[i].height = stream.readByte();
+			boxes[i].xOffset = stream.readSByte();
+			boxes[i].yOffset = stream.readSByte();
+		}
 	}
 
-	BdfFontDesc desc;
-	desc.name = data->name;
-	desc.maxwidth = data->maxwidth;
-	desc.height = data->height;
-	desc.fbbw = data->fbbw;
-	desc.fbbh = data->fbbh;
-	desc.fbbx = data->fbbx;
-	desc.fbby = data->fbby;
-	desc.ascent = data->ascent;
-	desc.firstchar = data->firstchar;
-	desc.size = data->size;
-	desc.bits = data->bits;
-	desc.offset = data->offset;
-	desc.width = data->width;
-	desc.bbx = data->bbx;
-	desc.defaultchar = data->defaultchar;
-	desc.bits_size = data->bits_size;
-
-	font = new BdfFont(desc, data);
-	if (!font) {
-		free(data->bits);
-		free(data->offset);
-		free(data->width);
-		free(data);
-		return 0;
+	if (stream.eos() || stream.err()) {
+		for (int i = 0; i < data.numCharacters; ++i)
+			delete[] bitmaps[i];
+		delete[] bitmaps;
+		delete[] advances;
+		delete[] boxes;
 	}
 
-	return font;
+	data.bitmaps = bitmaps;
+	data.advances = advances;
+	data.boxes = boxes;
+	return new BdfFont(data, DisposeAfterUse::YES);
 }
 
 } // End of namespace Graphics