blob: 9bd06ed371769abd66c9c6e1b56619cae8439512 [file] [log] [blame]
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright 2015 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Converts a font in bdf format into C source code."""
from __future__ import print_function
import re
import sys
class GlyphSet(object):
"""Collects glyph bitmap data and outputs it into C source code"""
def __init__(self, width, height):
self.glyph_map = {}
self.width = width
self.height = height
self.bits_per_pixel = 1
self.bytes_per_row = (self.bits_per_pixel * self.width + 7) // 8
self.glyph_size = self.bytes_per_row * self.height
def AddGlyph(self, code_point, data):
"""Adds a bitmap associated with the glyph identified by the code point.
A glyph can be added at most once.
code_point: a 32-bit unsigned integer identifying the code point of the
glyph bitmap
data: an array of unsigned bytes with a length of exactly self.glyph_size
Exception: the bitmap data is the wrong size or the code point was added
once before
if code_point in self.glyph_map:
raise Exception('code point %s already added' % code_point)
if len(data) != self.glyph_size:
raise Exception('given glyph is the wrong size, expected %s, got %s' %
(self.glyph_size, len(data)))
self.glyph_map[code_point] = data
def ToCSource(self, out_file):
"""Writes this GlyphSet's data into a C source file.
The data written includes:
- the global dimensions of the glyphs
- the glyph bitmaps, stored in an array
- a function to convert code points to the index of the glyph in the
bitmap array
The C source file outputs static data and methods and is intended to be
#include'd by a compilation unit.
out_file: the file to write the GlyphSet to
glyph_properties = {
'width': self.width,
'height': self.height,
'bpp': self.bytes_per_row
out_file.write("""/* This code is generated. Do not edit. */
#define GLYPH_WIDTH %(width)s
#define GLYPH_HEIGHT %(height)s
#define GLYPH_BYTES_PER_ROW %(bpp)s
""" % glyph_properties)
sorted_glyphs = sorted(self.glyph_map.items())
breaks = []
last_code_point = None
for glyph_index, (code_point, _) in enumerate(sorted_glyphs):
if last_code_point is None or (last_code_point + 1) != code_point:
breaks.append((code_point, glyph_index))
last_code_point = code_point
breaks.append((None, len(sorted_glyphs)))
out_file.write('static int32_t code_point_to_glyph_index(uint32_t cp)\n{\n')
for break_idx, (this_break_code_point,
this_break_glyph_index) in enumerate(breaks[:-1]):
this_break_code_point, this_break_glyph_index = breaks[break_idx]
next_break_glyph_index = breaks[break_idx + 1][1]
this_break_range = next_break_glyph_index - this_break_glyph_index
out_file.write(' if (cp < %s) {\n' %
(this_break_code_point + this_break_range))
if this_break_range == 1:
out_file.write(' if (cp == %s)\n' % this_break_code_point)
out_file.write(' return %s;\n' % this_break_glyph_index)
out_file.write(' if (cp >= %s)\n' % this_break_code_point)
out_file.write(' return cp - %s;\n' %
(this_break_code_point - this_break_glyph_index))
out_file.write(' else\n')
out_file.write(' return -1;\n')
out_file.write(' }\n')
out_file.write(' return -1;\n')
out_file.write('static const uint8_t glyphs[%s][%s] = {\n' %
(len(self.glyph_map), self.glyph_size))
for code_point, data in sorted_glyphs:
out_file.write(' {')
for data_idx in range(self.glyph_size):
out_file.write('0x{:02x}, '.format(data[data_idx]))
class BdfState(object):
"""Holds the state and output of the bdf parser.
This parses the input file on init. This BDF parser is very simple. It
basically does the minimum work to extract all the glyphs in the input file.
The only validation done is to check that each glyph has exactly the right
amount of data. This has only ever been tested on the normal Terminus font,
sizes 16 and 32.
def __init__(self, in_file):
# Simple algorithm, try to match each line of input against each regex.
# The first match that works gets passed to the handler in the tuples
# below. If there was no match, the line is dropped.
self.patterns = [
(re.compile(r'FONTBOUNDINGBOX +(\d+) +(\d+) +([+-]?\d+) +([+-]?\d+)$'),
(re.compile(r'ENCODING +(\d+)$'), self.HandleENCODING),
(re.compile(r'BITMAP$'), self.HandleBITMAP),
(re.compile(r'ENDCHAR$'), self.HandleENDCHAR),
(re.compile(r'([0-9a-fA-F]{2})+$'), self.HandleDataBITMAP),
self.out_glyph_set = None
self.current_code_point = None
self.current_glyph_data = None
self.current_glyph_data_index = None
for line in in_file:
def HandleLine(self, line):
"""Handles a single line of bdf file input.
The line is matched to a pattern and that match is passed to the
corresponding handler.
line = line.strip()
for pattern, handler in self.patterns:
match = pattern.match(line)
if match is not None:
def HandleFONTBOUNDINGBOX(self, match):
"""Constructs a GlyphSet with the given bitmap size."""
self.out_glyph_set = GlyphSet(int(, int(
def HandleENCODING(self, match):
"""Remembers the code point for a later call to AddGlyph"""
self.current_code_point = int(
def HandleBITMAP(self, _match):
"""Construct a blank pre-sized list of bitmap data."""
self.current_glyph_data = [0] * self.out_glyph_set.glyph_size
self.current_glyph_data_index = 0
def HandleDataBITMAP(self, match):
"""Adds data to the bitmap data."""
row =
for c_idx in range(len(row) // 2):
c = row[c_idx * 2:(c_idx + 1) * 2]
if self.current_glyph_data_index >= len(self.current_glyph_data):
raise Exception('too much glyph data, expected %s' %
self.current_glyph_data[self.current_glyph_data_index] = int(c, base=16)
self.current_glyph_data_index += 1
def HandleENDCHAR(self, _match):
"""Uses the most recent glyph data and adds it to the GlyphSet"""
if self.current_glyph_data_index != len(self.current_glyph_data):
raise Exception('too little glyph data, expected %s, got %s' %
self.current_code_point = None
self.current_glyph_data = None
self.current_glyph_data_index = None
def main(args):
if len(args) != 2:
print('Usage: %s [INPUT BDF PATH] [OUTPUT C PATH]' % sys.argv[0])
gs = BdfState(open(args[0], 'r')).out_glyph_set
gs.ToCSource(open(args[1], 'w'))
if __name__ == '__main__':