From 08b6f28d5476505ce62748f691e861fd7f9dd3e4 Mon Sep 17 00:00:00 2001 From: Johannes Schickel Date: Fri, 6 Jan 2012 14:52:58 +0100 Subject: GRAPHICS: Rework BDF font code. --- graphics/fonts/bdf.cpp | 1054 ++++++++++++++++++++---------------------------- 1 file changed, 438 insertions(+), 616 deletions(-) (limited to 'graphics/fonts/bdf.cpp') 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 -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(ptr, dst->pitch, tmp, y, MAX(0, -(tx + bbx)), MIN(bbw, dst->w - tx - bbx), color); - else if (dst->format.bytesPerPixel == 2) - drawCharIntern(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(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color); + else if (dst->format.bytesPerPixel == 2) + drawCharIntern(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 -- cgit v1.2.3