pebble/tools/font/dump_font.py
2025-01-27 11:38:16 -08:00

314 lines
11 KiB
Python
Executable file

#!/usr/bin/env python
# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import argparse
import sys
import struct
import array
import pprint
import math
import json
import itertools
from PIL import Image
FONT_VERSION_1 = 1
FONT_VERSION_2 = 2
FONT_VERSION_3 = 3
# Features
FEATURE_OFFSET_16 = 0x01
FEATURE_RLE4 = 0x02
GLYPH_MD_STRUCT = 'BBbbb'
def dec_and_hex(i):
return "0x{:x} ({:d})".format(i, i)
def grouper(n, iterable, fillvalue=None):
"""grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"""
args = [iter(iterable)] * n
return itertools.izip_longest(fillvalue=fillvalue, *args)
def get_glyph(features, tbl, offset_bytes):
bitmap_offset_bytes = offset_bytes + struct.calcsize(GLYPH_MD_STRUCT)
header = tbl[offset_bytes: bitmap_offset_bytes]
(width, height, left, top, adv) = struct.unpack(GLYPH_MD_STRUCT, header)
if (features & FEATURE_RLE4):
bitmap_length_bytes = (height + 1) / 2 # RLE4 stores 2 rle_units per byte
else:
bitmap_length_bytes = ((height * width) + 7) / 8
bitmap_length_bytes_word_aligned = ((bitmap_length_bytes + 3) / 4) * 4
data = tbl[bitmap_offset_bytes: bitmap_offset_bytes + bitmap_length_bytes_word_aligned]
return {
'offset_bytes' : dec_and_hex(offset_bytes),
'top' : top,
'left' : left,
'height' : height,
'width' : width,
'advance' : adv,
'bitmap' : data
}, header
def hasher(codepoint, table_size):
return (codepoint % table_size)
def print_hash_table(hash_table):
print "index\tcount\toffset"
for idx, sz, off in hash_table:
print "%d\t%d\t%s" % (idx, sz, str(dec_and_hex(off)))
def print_glyph(features, glyph_table, offset, raw, show_image):
def decompress_glyph_RLE4(rle_stream, num_units, width):
bitmap = []
for b in array.array('B', rle_stream):
# There are two RLE4 units per byte. LSNibble first.
for i in range(2):
# Handle the padding by skipping whatever remains
if (num_units == 0):
break
num_units -= 1
# Each unit is <xyyy> where x is the symbol and yyy is (length - 1)
length = (b & 0x7) + 1
symbol = 1 if ((b >> 3) & 1) == 1 else 0
bitmap.extend([symbol]*length)
b >>= 4
# Correct the height, now that we know the decompressed size
height = len(bitmap)/width
return bitmap, height
def glyph_bitmap_to_bitlist(g):
height = g['height']
if not g['bitmap']:
return None, height
if (features & FEATURE_RLE4):
b, height = decompress_glyph_RLE4(g['bitmap'], height, g['width'])
else:
b = []
for w in array.array('I', g['bitmap']):
b.extend(((w & (1 << bit)) != 0 for bit in xrange(0, 32)))
return b, height
def draw_glyph_image(bitlist, width, height):
img = Image.new('RGB', (width, height), "black")
pixels = img.load()
for i in range(img.size[0]):
for j in range(img.size[1]):
pixels[i, j] = (0, 0, 0) if bitlist[j * width + i] else (255, 255, 255)
img.show()
def draw_glyph_ascii(bitlist, width, height):
for y in xrange(height):
for x in xrange(width):
if bitlist[y * width + x]:
sys.stdout.write('X')
else:
sys.stdout.write(' ')
print
def draw_glyph_raw(header, bitlist, width, height):
# Header:
for byte in header:
print '{:02x}'.format(ord(byte)),
print ' - ',
# Repack the glyph data. This is required because the glyph may have been compressed
for byte in xrange(height * width / 8):
w = 0
for bit in range(8):
if bitlist[byte * 8 + bit]:
w |= 1 << bit
print '{:02x}'.format(w),
print
g, header = get_glyph(features, glyph_table, offset)
# FEATURE_RLE4 uses the height field for # RLE Units!
bitlist, height = glyph_bitmap_to_bitlist(g)
if raw:
header_offset = offset + struct.calcsize(GLYPH_MD_STRUCT)
draw_glyph_raw(header, bitlist, g['width'], height)
else:
output = []
output.append("offset bytes: {}".format(g['offset_bytes']))
output.append("top: {}".format(g['top']))
output.append("left: {}".format(g['left']))
output.append("height: {}".format(height))
output.append("width: {}".format(g['width']))
output.append("advance: {}".format(g['advance']))
output.append("bitmap:")
print '\n'.join(output)
print
if bitlist:
if show_image:
draw_glyph_image(bitlist, g['width'], height)
else:
draw_glyph_ascii(bitlist, g['width'], height)
# Allow extended codepoint encoding for 'narrow Python builds'
def my_unichr(i):
try:
return unichr(i)
except ValueError:
return struct.pack('i', i).decode('utf-32')
# Attempt to print unicode characters. Do the best we can when redirecting output.
# (See PYTHONIOENCODING)
def print_glyph_header(codepoint, offset, raw=False):
if raw:
print '{:08X}:'.format(codepoint),
else:
print
print u'{}\t({})\t{}'.format(dec_and_hex(codepoint), my_unichr(codepoint),
dec_and_hex(offset)).encode('utf-8', 'replace')
print
def main(pfo_path, show_hash_table, offset_table, glyph, all_glyphs, show_image, raw):
with open(pfo_path, 'rb') as f:
font = f.read()
# Assume version 3 to start
version = 3
font_md_format = ['', '<BBHH', '<BBHHBB', '<BBHHBBBB']
font_md_size = struct.calcsize(font_md_format[version])
(version, max_height, num_glyphs, wildcard_cp, table_size, cp_bytes,
struct_size, features) = struct.unpack(font_md_format[version], font[:font_md_size])
if version == 3:
pass
elif version == 2:
# Set the defaults
font_md_size = struct.calcsize(font_md_format[version])
features = 0
else:
raise Exception('Error: Unexpected font file version {}'.format(version))
# Build up the offset entry struct
offset_table_format = '<'
offset_table_format += 'L' if cp_bytes == 4 else 'H'
offset_table_format += 'H' if features & FEATURE_OFFSET_16 else 'L'
offset_entry_size = struct.calcsize(offset_table_format)
hash_entry_format = '<BBH'
hash_entry_size = struct.calcsize(hash_entry_format)
def hash_iterator(tbl, num):
for i in xrange(0, num * hash_entry_size, hash_entry_size):
yield struct.unpack(hash_entry_format, tbl[i:i + hash_entry_size])
def offset_iterator(tbl, num):
for i in xrange(0, num * offset_entry_size, offset_entry_size):
yield struct.unpack(offset_table_format, tbl[i:i + offset_entry_size])
hash_table = [(a,b,c) for (a,b,c) in hash_iterator(font[font_md_size:], table_size)]
offset_tables_start = font_md_size + hash_entry_size * table_size
glyph_table_start = offset_tables_start + offset_entry_size * (num_glyphs)
glyph_table = font[glyph_table_start:]
if not raw:
print 'Font info'
pprint.pprint(
{'version': version,
'max_height': max_height,
'num_glyphs': num_glyphs,
'offset_table_size': num_glyphs * offset_entry_size,
'glyph_table_start': dec_and_hex(glyph_table_start),
'wildcard_cp': dec_and_hex(wildcard_cp),
'codepoint bytes': cp_bytes,
'hash_table_size': table_size,
'font_header_size': font_md_size,
'features': features,
'features - offset size': 16 if (features & FEATURE_OFFSET_16) else 32,
'features - RLE4': True if (features & FEATURE_RLE4) else False})
print
print 'Hash Table start: {}'.format(font_md_size)
print 'Offset Table start: {}'.format(offset_tables_start)
print 'Glyph Table start: {}'.format(glyph_table_start)
print '--------------------------'
if all_glyphs:
for _,sz,off in hash_table:
off_table = dict([x for x in offset_iterator(font[(offset_tables_start + off):], sz)])
for k,v in sorted(off_table.items()):
print_glyph_header(k, v, raw)
print_glyph(features, glyph_table, v, raw, False)
if not raw:
print
print
return
if show_hash_table:
print
print_hash_table(hash_table)
if offset_table:
offset_table = int(offset_table)
_,sz,off = hash_table[offset_table]
if not raw:
print 'Offset Table {} offset: {}'.format(offset_table, offset_tables_start + off)
off_table = dict([x for x in offset_iterator(font[(offset_tables_start + off):], sz)])
for k,v in sorted(off_table.items()):
print_glyph_header(k, v, raw)
print_glyph(features, glyph_table, v, raw, show_image)
if not raw:
print
print
if glyph:
codepoint = int(glyph, 16)
glyph_hash = hasher(codepoint, table_size)
_,sz,off = hash_table[glyph_hash]
off_table = dict([x for x in offset_iterator(font[(offset_tables_start + off):], sz)])
glyph_off = 0
for (cp, off) in off_table.items():
if cp == codepoint:
glyph_off = off_table[codepoint]
break
else:
print "{} not in font".format(codepoint)
return
print_glyph_header(codepoint, glyph_off, raw)
print_glyph(features, glyph_table, glyph_off, raw, show_image)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-o', '--offsets', help='print hash table')
parser.add_argument('-t', '--hashes', action='store_true', help='print hash table')
parser.add_argument('-g', '--glyph', help='draw glyph in external image viewer')
parser.add_argument('-G', '--ascii_glyph', help='draw glyph in ASCII')
parser.add_argument('-a', '--all_glyphs', action='store_true', help='print all glyphs')
parser.add_argument('-r', '--raw', action='store_true')
parser.add_argument('pebble_font')
args = parser.parse_args()
codepoint = args.ascii_glyph if args.ascii_glyph else args.glyph
main(args.pebble_font, args.hashes, args.offsets, codepoint, args.all_glyphs,
args.ascii_glyph is None, args.raw)