Add a C file generator for TrueType fonts

In order to be able to optimize the output better, add my own TTF
generator. Fortunately, freetype-py handles all of the hard work.

The generator is not yet integrated.

.gitignore

@@ -2,4 +2,5 @@
 *.o
 *.bin
 *.elf
-build
+build
+*.pyc

gen/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (C) 2019  Max Regan
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.

gen/fixedfont-to-c.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2019  Max Regan
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import font
+import argparse
+import string
+
+def emit_license(output):
+    output.write(
+"""/*
+ * Copyright (C) 2019  Max Regan
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+""")
+
+def emit_include(output, header_dir):
+    if header_dir:
+        if header_dir[-1] == '/':
+            header_dir = header_dir[:-1]
+        header = header_dir + "/font.h"
+    else:
+        header = "font.h"
+
+    output.write(f"#include \"{header}\"\n\n")
+
+def ceildiv(num, den):
+    return (num + (den - 1)) // den
+
+def to_c_name(name):
+    return name.replace("-","_")
+
+def emit_bmp(output, font_name, char, bmp):
+
+    width_bytes = ceildiv(bmp.width, 8)
+    height_bytes = ceildiv(bmp.height, 8)
+
+    output.write(f"// Bitmap for '{char}'\n")
+
+    name = to_c_name(f"{font_name}_{ord(char)}")
+    output.write(f"static uint8_t {name}_bitmap[] {{\n")
+    byte = 0
+    for y in range(bmp.height):
+        output.write("    ")
+        for x in range(bmp.width):
+            bit_idx = 7 - (x % 8)
+            bit = bmp.pixels[y * bmp.width + x]
+            byte |= bit << bit_idx
+            if bit_idx == 0 or x == bmp.width - 1:
+                output.write('0x{:02x}, '.format(byte))
+                byte = 0
+
+        output.write("\n")
+
+    output.write("};\n\n")
+
+    output.write(f"// Glyph data for '{char}'\n")
+
+    output.write(f"static struct glyph {name}_glyph {{\n")
+    output.write(f"    .width = {bmp.width},\n")
+    output.write(f"    .width_bytes = {width_bytes},\n")
+    output.write(f"    .height = {bmp.height},\n")
+    output.write(f"    .height_bytes = {height_bytes},\n")
+    output.write(f"    .bitmap = {name}_bitmap,\n")
+    output.write("};\n\n")
+
+
+def emit_font(output, ff, font_name, chars):
+    c_font_name = to_c_name(font_name)
+    output.write(f"static struct font {c_font_name} {{\n")
+    output.write(f"    .name = \"{font_name}\",\n")
+    output.write(f"    .glypyhs = [\n")
+    for i in range(127):
+        if i in
+    output.write("};\n\n")
+
+
+def gen_c_font_file(ttf, output, charset, width=None, size=None, header_dir=None):
+
+    ff = font.FixedFont(ttf, size)
+    font_name = ff.face.postscript_name.decode('ASCII')
+    emit_license(output)
+    emit_include(output, header_dir)
+    width = None
+    for char in charset:
+        bmp = ff.render_character(char)
+        emit_bmp(output, font_name, char, bmp)
+        if width is None:
+            width = ceildiv(bmp.width, 8)
+    emit_font(output, ff, font_name)
+
+def gen_h_font_file(ttf, output, charset, width=None, size=None):
+    emit_license(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fixed-width TrueType C code generator")
+    parser.add_argument(dest="ttf", help="TrueType font file", action="store", type=str)
+    parser.add_argument(dest="output", help="Output C file", action="store", type=argparse.FileType('w'))
+    parser.add_argument("--chars", "-c", help="Character set. Defaults to all printable ASCII", action="store", type=str,
+                        default="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-=_+{}[]:\";'<>,.?/~!@#$%^&*()|\\")
+    parser.add_argument("--header-dir",  help="Directory of the font.h header", action="store", type=str)
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument("--size", "-s", help="Font pitch", action="store", type=int)
+    group.add_argument("--width", "-w", help="Font width", action="store", type=int)
+
+    args = parser.parse_args()
+    args.chars = list(set(args.chars))
+    args.chars.sort()
+
+    gen_c_font_file(args.ttf, args.output, args.chars, width=args.width, size=args.size, header_dir=args.header_dir)
+
+
+if __name__ == "__main__":
+    main()

gen/font.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Needs freetype-py>=1.0
+
+# For more info see:
+# http://dbader.org/blog/monochrome-font-rendering-with-freetype-and-python
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2013 Daniel Bader (http://dbader.org)
+# Copyright (c) 2019 Max Regan (http://git.maxregan.me)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import freetype
+
+
+class Bitmap(object):
+    """
+    A 2D bitmap image represented as a list of byte values. Each byte indicates the state
+    of a single pixel in the bitmap. A value of 0 indicates that the pixel is `off`
+    and any other value indicates that it is `on`.
+    """
+    def __init__(self, width, height, pixels=None):
+        self.width = width
+        self.height = height
+        self.pixels = pixels or bytearray(width * height)
+
+    def __repr__(self):
+        """Return a string representation of the bitmap's pixels."""
+        rows = ''
+        for y in range(self.height):
+            for x in range(self.width):
+                rows += '#' if self.pixels[y * self.width + x] else ' '
+            rows += '\n'
+        return rows
+
+    def bitblt(self, src, x, y):
+        """Copy all pixels from `src` into this bitmap"""
+        srcpixel = 0
+        dstpixel = y * self.width + x
+        row_offset = self.width - src.width
+
+        for sy in range(src.height):
+            for sx in range(src.width):
+                # Perform an OR operation on the destination pixel and the source pixel
+                # because glyph bitmaps may overlap if character kerning is applied, e.g.
+                # in the string "AVA", the "A" and "V" glyphs must be rendered with
+                # overlapping bounding boxes.
+                self.pixels[dstpixel] = self.pixels[dstpixel] or src.pixels[srcpixel]
+                srcpixel += 1
+                dstpixel += 1
+            dstpixel += row_offset
+
+
+class Glyph(object):
+    def __init__(self, pixels, width, height, top, advance_width):
+        self.bitmap = Bitmap(width, height, pixels)
+
+        # The glyph bitmap's top-side bearing, i.e. the vertical distance from the
+        # baseline to the bitmap's top-most scanline.
+        self.top = top
+
+        # Ascent and descent determine how many pixels the glyph extends
+        # above or below the baseline.
+        self.descent = max(0, self.height - self.top)
+        self.ascent = max(0, max(self.top, self.height) - self.descent)
+
+        # The advance width determines where to place the next character horizontally,
+        # that is, how many pixels we move to the right to draw the next glyph.
+        self.advance_width = advance_width
+
+    @property
+    def width(self):
+        return self.bitmap.width
+
+    @property
+    def height(self):
+        return self.bitmap.height
+
+    @staticmethod
+    def from_glyphslot(slot):
+        """Construct and return a Glyph object from a FreeType GlyphSlot."""
+        pixels = Glyph.unpack_mono_bitmap(slot.bitmap)
+        width, height = slot.bitmap.width, slot.bitmap.rows
+        top = slot.bitmap_top
+
+        # The advance width is given in FreeType's 26.6 fixed point format,
+        # which means that the pixel values are multiples of 64.
+        assert slot.advance.x % 64 == 0
+        advance_width = slot.advance.x // 64
+
+        return Glyph(pixels, width, height, top, advance_width)
+
+    @staticmethod
+    def unpack_mono_bitmap(bitmap):
+        """
+        Unpack a freetype FT_LOAD_TARGET_MONO glyph bitmap into a bytearray where each
+        pixel is represented by a single byte.
+        """
+        # Allocate a bytearray of sufficient size to hold the glyph bitmap.
+        data = bytearray(bitmap.rows * bitmap.width)
+
+        # Iterate over every byte in the glyph bitmap. Note that we're not
+        # iterating over every pixel in the resulting unpacked bitmap --
+        # we're iterating over the packed bytes in the input bitmap.
+        for y in range(bitmap.rows):
+            for byte_index in range(bitmap.pitch):
+
+                # Read the byte that contains the packed pixel data.
+                byte_value = bitmap.buffer[y * bitmap.pitch + byte_index]
+
+                # We've processed this many bits (=pixels) so far. This determines
+                # where we'll read the next batch of pixels from.
+                num_bits_done = byte_index * 8
+
+                # Pre-compute where to write the pixels that we're going
+                # to unpack from the current byte in the glyph bitmap.
+                rowstart = y * bitmap.width + byte_index * 8
+
+                # Iterate over every bit (=pixel) that's still a part of the
+                # output bitmap. Sometimes we're only unpacking a fraction of a byte
+                # because glyphs may not always fit on a byte boundary. So we make sure
+                # to stop if we unpack past the current row of pixels.
+                for bit_index in range(min(8, bitmap.width - num_bits_done)):
+
+                    # Unpack the next pixel from the current glyph byte.
+                    bit = byte_value & (1 << (7 - bit_index))
+
+                    # Write the pixel to the output bytearray. We ensure that `off`
+                    # pixels have a value of 0 and `on` pixels have a value of 1.
+                    data[rowstart + bit_index] = 1 if bit else 0
+
+        return data
+
+
+class FixedFont(object):
+    def __init__(self, filename, size):
+        self.face = freetype.Face(filename)
+        self.face.set_pixel_sizes(0, size)
+
+        if not self.face.is_fixed_width:
+            raise ValueError("Font is not fixed width")
+
+        self.face.load_char('A', freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO)
+        self.advance = self.face.glyph.advance.x // 64
+
+    def glyph_for_character(self, char):
+        # Let FreeType load the glyph for the given character and tell it to render
+        # a monochromatic bitmap representation.
+        self.face.load_char(char, freetype.FT_LOAD_RENDER | freetype.FT_LOAD_TARGET_MONO)
+        return Glyph.from_glyphslot(self.face.glyph)
+
+    def render_character(self, char):
+        glyph = self.glyph_for_character(char)
+        return glyph.bitmap
+
+    def text_dimensions(self, text):
+        """Return (width, height, baseline) of `text` rendered in the current font."""
+        width = 0
+        max_ascent = 0
+        max_descent = 0
+        previous_char = None
+
+        # For each character in the text string we get the glyph
+        # and update the overall dimensions of the resulting bitmap.
+        for char in text:
+            glyph = self.glyph_for_character(char)
+            max_ascent = max(max_ascent, glyph.ascent)
+            max_descent = max(max_descent, glyph.descent)
+
+            # With kerning, the advance width may be less than the width of the glyph's bitmap.
+            # Make sure we compute the total width so that all of the glyph's pixels
+            # fit into the returned dimensions.
+            width += self.advance
+
+            previous_char = char
+
+        height = max_ascent + max_descent
+        return (width, height, max_descent)
+
+    def render_text(self, text, width=None, height=None, baseline=None):
+        """
+        Render the given `text` into a Bitmap and return it.
+
+        If `width`, `height`, and `baseline` are not specified they are computed using
+        the `text_dimensions' method.
+        """
+        if None in (width, height, baseline):
+            width, height, baseline = self.text_dimensions(text)
+
+        x = 0
+        previous_char = None
+        outbuffer = Bitmap(width, height)
+
+        for char in text:
+            glyph = self.glyph_for_character(char)
+
+            # The vertical drawing position should place the glyph
+            # on the baseline as intended.
+            y = height - glyph.ascent - baseline
+
+            outbuffer.bitblt(glyph.bitmap, x, y)
+
+            x += glyph.advance_width
+            previous_char = char
+
+        return outbuffer
+
+if __name__ == '__main__':
+    # Be sure to place 'helvetica.ttf' (or any other ttf / otf font file) in the working directory.
+    fnt = FixedFont('/usr/share/fonts/truetype/ubuntu/UbuntuMono-R.ttf', 24)
+
+    print(repr(fnt.render_text('AV Wa')))