| """ttLib/sfnt.py -- low-level module to deal with the sfnt file format. |
| |
| Defines two public classes: |
| SFNTReader |
| SFNTWriter |
| |
| (Normally you don't have to use these classes explicitly; they are |
| used automatically by ttLib.TTFont.) |
| |
| The reading and writing of sfnt files is separated in two distinct |
| classes, since whenever the number of tables changes or whenever |
| a table's length changes you need to rewrite the whole file anyway. |
| """ |
| |
| from io import BytesIO |
| from types import SimpleNamespace |
| from fontTools.misc.textTools import Tag |
| from fontTools.misc import sstruct |
| from fontTools.ttLib import TTLibError, TTLibFileIsCollectionError |
| import struct |
| from collections import OrderedDict |
| import logging |
| |
| |
| log = logging.getLogger(__name__) |
| |
| |
| class SFNTReader(object): |
| def __new__(cls, *args, **kwargs): |
| """Return an instance of the SFNTReader sub-class which is compatible |
| with the input file type. |
| """ |
| if args and cls is SFNTReader: |
| infile = args[0] |
| infile.seek(0) |
| sfntVersion = Tag(infile.read(4)) |
| infile.seek(0) |
| if sfntVersion == "wOF2": |
| # return new WOFF2Reader object |
| from fontTools.ttLib.woff2 import WOFF2Reader |
| |
| return object.__new__(WOFF2Reader) |
| # return default object |
| return object.__new__(cls) |
| |
| def __init__(self, file, checkChecksums=0, fontNumber=-1): |
| self.file = file |
| self.checkChecksums = checkChecksums |
| |
| self.flavor = None |
| self.flavorData = None |
| self.DirectoryEntry = SFNTDirectoryEntry |
| self.file.seek(0) |
| self.sfntVersion = self.file.read(4) |
| self.file.seek(0) |
| if self.sfntVersion == b"ttcf": |
| header = readTTCHeader(self.file) |
| numFonts = header.numFonts |
| if not 0 <= fontNumber < numFonts: |
| raise TTLibFileIsCollectionError( |
| "specify a font number between 0 and %d (inclusive)" |
| % (numFonts - 1) |
| ) |
| self.numFonts = numFonts |
| self.file.seek(header.offsetTable[fontNumber]) |
| data = self.file.read(sfntDirectorySize) |
| if len(data) != sfntDirectorySize: |
| raise TTLibError("Not a Font Collection (not enough data)") |
| sstruct.unpack(sfntDirectoryFormat, data, self) |
| elif self.sfntVersion == b"wOFF": |
| self.flavor = "woff" |
| self.DirectoryEntry = WOFFDirectoryEntry |
| data = self.file.read(woffDirectorySize) |
| if len(data) != woffDirectorySize: |
| raise TTLibError("Not a WOFF font (not enough data)") |
| sstruct.unpack(woffDirectoryFormat, data, self) |
| else: |
| data = self.file.read(sfntDirectorySize) |
| if len(data) != sfntDirectorySize: |
| raise TTLibError("Not a TrueType or OpenType font (not enough data)") |
| sstruct.unpack(sfntDirectoryFormat, data, self) |
| self.sfntVersion = Tag(self.sfntVersion) |
| |
| if self.sfntVersion not in ("\x00\x01\x00\x00", "OTTO", "true"): |
| raise TTLibError("Not a TrueType or OpenType font (bad sfntVersion)") |
| tables = {} |
| for i in range(self.numTables): |
| entry = self.DirectoryEntry() |
| entry.fromFile(self.file) |
| tag = Tag(entry.tag) |
| tables[tag] = entry |
| self.tables = OrderedDict(sorted(tables.items(), key=lambda i: i[1].offset)) |
| |
| # Load flavor data if any |
| if self.flavor == "woff": |
| self.flavorData = WOFFFlavorData(self) |
| |
| def has_key(self, tag): |
| return tag in self.tables |
| |
| __contains__ = has_key |
| |
| def keys(self): |
| return self.tables.keys() |
| |
| def __getitem__(self, tag): |
| """Fetch the raw table data.""" |
| entry = self.tables[Tag(tag)] |
| data = entry.loadData(self.file) |
| if self.checkChecksums: |
| if tag == "head": |
| # Beh: we have to special-case the 'head' table. |
| checksum = calcChecksum(data[:8] + b"\0\0\0\0" + data[12:]) |
| else: |
| checksum = calcChecksum(data) |
| if self.checkChecksums > 1: |
| # Be obnoxious, and barf when it's wrong |
| assert checksum == entry.checkSum, "bad checksum for '%s' table" % tag |
| elif checksum != entry.checkSum: |
| # Be friendly, and just log a warning. |
| log.warning("bad checksum for '%s' table", tag) |
| return data |
| |
| def __delitem__(self, tag): |
| del self.tables[Tag(tag)] |
| |
| def close(self): |
| self.file.close() |
| |
| # We define custom __getstate__ and __setstate__ to make SFNTReader pickle-able |
| # and deepcopy-able. When a TTFont is loaded as lazy=True, SFNTReader holds a |
| # reference to an external file object which is not pickleable. So in __getstate__ |
| # we store the file name and current position, and in __setstate__ we reopen the |
| # same named file after unpickling. |
| |
| def __getstate__(self): |
| if isinstance(self.file, BytesIO): |
| # BytesIO is already pickleable, return the state unmodified |
| return self.__dict__ |
| |
| # remove unpickleable file attribute, and only store its name and pos |
| state = self.__dict__.copy() |
| del state["file"] |
| state["_filename"] = self.file.name |
| state["_filepos"] = self.file.tell() |
| return state |
| |
| def __setstate__(self, state): |
| if "file" not in state: |
| self.file = open(state.pop("_filename"), "rb") |
| self.file.seek(state.pop("_filepos")) |
| self.__dict__.update(state) |
| |
| |
| # default compression level for WOFF 1.0 tables and metadata |
| ZLIB_COMPRESSION_LEVEL = 6 |
| |
| # if set to True, use zopfli instead of zlib for compressing WOFF 1.0. |
| # The Python bindings are available at https://pypi.python.org/pypi/zopfli |
| USE_ZOPFLI = False |
| |
| # mapping between zlib's compression levels and zopfli's 'numiterations'. |
| # Use lower values for files over several MB in size or it will be too slow |
| ZOPFLI_LEVELS = { |
| # 0: 0, # can't do 0 iterations... |
| 1: 1, |
| 2: 3, |
| 3: 5, |
| 4: 8, |
| 5: 10, |
| 6: 15, |
| 7: 25, |
| 8: 50, |
| 9: 100, |
| } |
| |
| |
| def compress(data, level=ZLIB_COMPRESSION_LEVEL): |
| """Compress 'data' to Zlib format. If 'USE_ZOPFLI' variable is True, |
| zopfli is used instead of the zlib module. |
| The compression 'level' must be between 0 and 9. 1 gives best speed, |
| 9 gives best compression (0 gives no compression at all). |
| The default value is a compromise between speed and compression (6). |
| """ |
| if not (0 <= level <= 9): |
| raise ValueError("Bad compression level: %s" % level) |
| if not USE_ZOPFLI or level == 0: |
| from zlib import compress |
| |
| return compress(data, level) |
| else: |
| from zopfli.zlib import compress |
| |
| return compress(data, numiterations=ZOPFLI_LEVELS[level]) |
| |
| |
| class SFNTWriter(object): |
| def __new__(cls, *args, **kwargs): |
| """Return an instance of the SFNTWriter sub-class which is compatible |
| with the specified 'flavor'. |
| """ |
| flavor = None |
| if kwargs and "flavor" in kwargs: |
| flavor = kwargs["flavor"] |
| elif args and len(args) > 3: |
| flavor = args[3] |
| if cls is SFNTWriter: |
| if flavor == "woff2": |
| # return new WOFF2Writer object |
| from fontTools.ttLib.woff2 import WOFF2Writer |
| |
| return object.__new__(WOFF2Writer) |
| # return default object |
| return object.__new__(cls) |
| |
| def __init__( |
| self, |
| file, |
| numTables, |
| sfntVersion="\000\001\000\000", |
| flavor=None, |
| flavorData=None, |
| ): |
| self.file = file |
| self.numTables = numTables |
| self.sfntVersion = Tag(sfntVersion) |
| self.flavor = flavor |
| self.flavorData = flavorData |
| |
| if self.flavor == "woff": |
| self.directoryFormat = woffDirectoryFormat |
| self.directorySize = woffDirectorySize |
| self.DirectoryEntry = WOFFDirectoryEntry |
| |
| self.signature = "wOFF" |
| |
| # to calculate WOFF checksum adjustment, we also need the original SFNT offsets |
| self.origNextTableOffset = ( |
| sfntDirectorySize + numTables * sfntDirectoryEntrySize |
| ) |
| else: |
| assert not self.flavor, "Unknown flavor '%s'" % self.flavor |
| self.directoryFormat = sfntDirectoryFormat |
| self.directorySize = sfntDirectorySize |
| self.DirectoryEntry = SFNTDirectoryEntry |
| |
| from fontTools.ttLib import getSearchRange |
| |
| self.searchRange, self.entrySelector, self.rangeShift = getSearchRange( |
| numTables, 16 |
| ) |
| |
| self.directoryOffset = self.file.tell() |
| self.nextTableOffset = ( |
| self.directoryOffset |
| + self.directorySize |
| + numTables * self.DirectoryEntry.formatSize |
| ) |
| # clear out directory area |
| self.file.seek(self.nextTableOffset) |
| # make sure we're actually where we want to be. (old cStringIO bug) |
| self.file.write(b"\0" * (self.nextTableOffset - self.file.tell())) |
| self.tables = OrderedDict() |
| |
| def setEntry(self, tag, entry): |
| if tag in self.tables: |
| raise TTLibError("cannot rewrite '%s' table" % tag) |
| |
| self.tables[tag] = entry |
| |
| def __setitem__(self, tag, data): |
| """Write raw table data to disk.""" |
| if tag in self.tables: |
| raise TTLibError("cannot rewrite '%s' table" % tag) |
| |
| entry = self.DirectoryEntry() |
| entry.tag = tag |
| entry.offset = self.nextTableOffset |
| if tag == "head": |
| entry.checkSum = calcChecksum(data[:8] + b"\0\0\0\0" + data[12:]) |
| self.headTable = data |
| entry.uncompressed = True |
| else: |
| entry.checkSum = calcChecksum(data) |
| entry.saveData(self.file, data) |
| |
| if self.flavor == "woff": |
| entry.origOffset = self.origNextTableOffset |
| self.origNextTableOffset += (entry.origLength + 3) & ~3 |
| |
| self.nextTableOffset = self.nextTableOffset + ((entry.length + 3) & ~3) |
| # Add NUL bytes to pad the table data to a 4-byte boundary. |
| # Don't depend on f.seek() as we need to add the padding even if no |
| # subsequent write follows (seek is lazy), ie. after the final table |
| # in the font. |
| self.file.write(b"\0" * (self.nextTableOffset - self.file.tell())) |
| assert self.nextTableOffset == self.file.tell() |
| |
| self.setEntry(tag, entry) |
| |
| def __getitem__(self, tag): |
| return self.tables[tag] |
| |
| def close(self): |
| """All tables must have been written to disk. Now write the |
| directory. |
| """ |
| tables = sorted(self.tables.items()) |
| if len(tables) != self.numTables: |
| raise TTLibError( |
| "wrong number of tables; expected %d, found %d" |
| % (self.numTables, len(tables)) |
| ) |
| |
| if self.flavor == "woff": |
| self.signature = b"wOFF" |
| self.reserved = 0 |
| |
| self.totalSfntSize = 12 |
| self.totalSfntSize += 16 * len(tables) |
| for tag, entry in tables: |
| self.totalSfntSize += (entry.origLength + 3) & ~3 |
| |
| data = self.flavorData if self.flavorData else WOFFFlavorData() |
| if data.majorVersion is not None and data.minorVersion is not None: |
| self.majorVersion = data.majorVersion |
| self.minorVersion = data.minorVersion |
| else: |
| if hasattr(self, "headTable"): |
| self.majorVersion, self.minorVersion = struct.unpack( |
| ">HH", self.headTable[4:8] |
| ) |
| else: |
| self.majorVersion = self.minorVersion = 0 |
| if data.metaData: |
| self.metaOrigLength = len(data.metaData) |
| self.file.seek(0, 2) |
| self.metaOffset = self.file.tell() |
| compressedMetaData = compress(data.metaData) |
| self.metaLength = len(compressedMetaData) |
| self.file.write(compressedMetaData) |
| else: |
| self.metaOffset = self.metaLength = self.metaOrigLength = 0 |
| if data.privData: |
| self.file.seek(0, 2) |
| off = self.file.tell() |
| paddedOff = (off + 3) & ~3 |
| self.file.write(b"\0" * (paddedOff - off)) |
| self.privOffset = self.file.tell() |
| self.privLength = len(data.privData) |
| self.file.write(data.privData) |
| else: |
| self.privOffset = self.privLength = 0 |
| |
| self.file.seek(0, 2) |
| self.length = self.file.tell() |
| |
| else: |
| assert not self.flavor, "Unknown flavor '%s'" % self.flavor |
| pass |
| |
| directory = sstruct.pack(self.directoryFormat, self) |
| |
| self.file.seek(self.directoryOffset + self.directorySize) |
| seenHead = 0 |
| for tag, entry in tables: |
| if tag == "head": |
| seenHead = 1 |
| directory = directory + entry.toString() |
| if seenHead: |
| self.writeMasterChecksum(directory) |
| self.file.seek(self.directoryOffset) |
| self.file.write(directory) |
| |
| def _calcMasterChecksum(self, directory): |
| # calculate checkSumAdjustment |
| tags = list(self.tables.keys()) |
| checksums = [] |
| for i in range(len(tags)): |
| checksums.append(self.tables[tags[i]].checkSum) |
| |
| if self.DirectoryEntry != SFNTDirectoryEntry: |
| # Create a SFNT directory for checksum calculation purposes |
| from fontTools.ttLib import getSearchRange |
| |
| self.searchRange, self.entrySelector, self.rangeShift = getSearchRange( |
| self.numTables, 16 |
| ) |
| directory = sstruct.pack(sfntDirectoryFormat, self) |
| tables = sorted(self.tables.items()) |
| for tag, entry in tables: |
| sfntEntry = SFNTDirectoryEntry() |
| sfntEntry.tag = entry.tag |
| sfntEntry.checkSum = entry.checkSum |
| sfntEntry.offset = entry.origOffset |
| sfntEntry.length = entry.origLength |
| directory = directory + sfntEntry.toString() |
| |
| directory_end = sfntDirectorySize + len(self.tables) * sfntDirectoryEntrySize |
| assert directory_end == len(directory) |
| |
| checksums.append(calcChecksum(directory)) |
| checksum = sum(checksums) & 0xFFFFFFFF |
| # BiboAfba! |
| checksumadjustment = (0xB1B0AFBA - checksum) & 0xFFFFFFFF |
| return checksumadjustment |
| |
| def writeMasterChecksum(self, directory): |
| checksumadjustment = self._calcMasterChecksum(directory) |
| # write the checksum to the file |
| self.file.seek(self.tables["head"].offset + 8) |
| self.file.write(struct.pack(">L", checksumadjustment)) |
| |
| def reordersTables(self): |
| return False |
| |
| |
| # -- sfnt directory helpers and cruft |
| |
| ttcHeaderFormat = """ |
| > # big endian |
| TTCTag: 4s # "ttcf" |
| Version: L # 0x00010000 or 0x00020000 |
| numFonts: L # number of fonts |
| # OffsetTable[numFonts]: L # array with offsets from beginning of file |
| # ulDsigTag: L # version 2.0 only |
| # ulDsigLength: L # version 2.0 only |
| # ulDsigOffset: L # version 2.0 only |
| """ |
| |
| ttcHeaderSize = sstruct.calcsize(ttcHeaderFormat) |
| |
| sfntDirectoryFormat = """ |
| > # big endian |
| sfntVersion: 4s |
| numTables: H # number of tables |
| searchRange: H # (max2 <= numTables)*16 |
| entrySelector: H # log2(max2 <= numTables) |
| rangeShift: H # numTables*16-searchRange |
| """ |
| |
| sfntDirectorySize = sstruct.calcsize(sfntDirectoryFormat) |
| |
| sfntDirectoryEntryFormat = """ |
| > # big endian |
| tag: 4s |
| checkSum: L |
| offset: L |
| length: L |
| """ |
| |
| sfntDirectoryEntrySize = sstruct.calcsize(sfntDirectoryEntryFormat) |
| |
| woffDirectoryFormat = """ |
| > # big endian |
| signature: 4s # "wOFF" |
| sfntVersion: 4s |
| length: L # total woff file size |
| numTables: H # number of tables |
| reserved: H # set to 0 |
| totalSfntSize: L # uncompressed size |
| majorVersion: H # major version of WOFF file |
| minorVersion: H # minor version of WOFF file |
| metaOffset: L # offset to metadata block |
| metaLength: L # length of compressed metadata |
| metaOrigLength: L # length of uncompressed metadata |
| privOffset: L # offset to private data block |
| privLength: L # length of private data block |
| """ |
| |
| woffDirectorySize = sstruct.calcsize(woffDirectoryFormat) |
| |
| woffDirectoryEntryFormat = """ |
| > # big endian |
| tag: 4s |
| offset: L |
| length: L # compressed length |
| origLength: L # original length |
| checkSum: L # original checksum |
| """ |
| |
| woffDirectoryEntrySize = sstruct.calcsize(woffDirectoryEntryFormat) |
| |
| |
| class DirectoryEntry(object): |
| def __init__(self): |
| self.uncompressed = False # if True, always embed entry raw |
| |
| def fromFile(self, file): |
| sstruct.unpack(self.format, file.read(self.formatSize), self) |
| |
| def fromString(self, str): |
| sstruct.unpack(self.format, str, self) |
| |
| def toString(self): |
| return sstruct.pack(self.format, self) |
| |
| def __repr__(self): |
| if hasattr(self, "tag"): |
| return "<%s '%s' at %x>" % (self.__class__.__name__, self.tag, id(self)) |
| else: |
| return "<%s at %x>" % (self.__class__.__name__, id(self)) |
| |
| def loadData(self, file): |
| file.seek(self.offset) |
| data = file.read(self.length) |
| assert len(data) == self.length |
| if hasattr(self.__class__, "decodeData"): |
| data = self.decodeData(data) |
| return data |
| |
| def saveData(self, file, data): |
| if hasattr(self.__class__, "encodeData"): |
| data = self.encodeData(data) |
| self.length = len(data) |
| file.seek(self.offset) |
| file.write(data) |
| |
| def decodeData(self, rawData): |
| return rawData |
| |
| def encodeData(self, data): |
| return data |
| |
| |
| class SFNTDirectoryEntry(DirectoryEntry): |
| format = sfntDirectoryEntryFormat |
| formatSize = sfntDirectoryEntrySize |
| |
| |
| class WOFFDirectoryEntry(DirectoryEntry): |
| format = woffDirectoryEntryFormat |
| formatSize = woffDirectoryEntrySize |
| |
| def __init__(self): |
| super(WOFFDirectoryEntry, self).__init__() |
| # With fonttools<=3.1.2, the only way to set a different zlib |
| # compression level for WOFF directory entries was to set the class |
| # attribute 'zlibCompressionLevel'. This is now replaced by a globally |
| # defined `ZLIB_COMPRESSION_LEVEL`, which is also applied when |
| # compressing the metadata. For backward compatibility, we still |
| # use the class attribute if it was already set. |
| if not hasattr(WOFFDirectoryEntry, "zlibCompressionLevel"): |
| self.zlibCompressionLevel = ZLIB_COMPRESSION_LEVEL |
| |
| def decodeData(self, rawData): |
| import zlib |
| |
| if self.length == self.origLength: |
| data = rawData |
| else: |
| assert self.length < self.origLength |
| data = zlib.decompress(rawData) |
| assert len(data) == self.origLength |
| return data |
| |
| def encodeData(self, data): |
| self.origLength = len(data) |
| if not self.uncompressed: |
| compressedData = compress(data, self.zlibCompressionLevel) |
| if self.uncompressed or len(compressedData) >= self.origLength: |
| # Encode uncompressed |
| rawData = data |
| self.length = self.origLength |
| else: |
| rawData = compressedData |
| self.length = len(rawData) |
| return rawData |
| |
| |
| class WOFFFlavorData: |
| Flavor = "woff" |
| |
| def __init__(self, reader=None): |
| self.majorVersion = None |
| self.minorVersion = None |
| self.metaData = None |
| self.privData = None |
| if reader: |
| self.majorVersion = reader.majorVersion |
| self.minorVersion = reader.minorVersion |
| if reader.metaLength: |
| reader.file.seek(reader.metaOffset) |
| rawData = reader.file.read(reader.metaLength) |
| assert len(rawData) == reader.metaLength |
| data = self._decompress(rawData) |
| assert len(data) == reader.metaOrigLength |
| self.metaData = data |
| if reader.privLength: |
| reader.file.seek(reader.privOffset) |
| data = reader.file.read(reader.privLength) |
| assert len(data) == reader.privLength |
| self.privData = data |
| |
| def _decompress(self, rawData): |
| import zlib |
| |
| return zlib.decompress(rawData) |
| |
| |
| def calcChecksum(data): |
| """Calculate the checksum for an arbitrary block of data. |
| |
| If the data length is not a multiple of four, it assumes |
| it is to be padded with null byte. |
| |
| >>> print(calcChecksum(b"abcd")) |
| 1633837924 |
| >>> print(calcChecksum(b"abcdxyz")) |
| 3655064932 |
| """ |
| remainder = len(data) % 4 |
| if remainder: |
| data += b"\0" * (4 - remainder) |
| value = 0 |
| blockSize = 4096 |
| assert blockSize % 4 == 0 |
| for i in range(0, len(data), blockSize): |
| block = data[i : i + blockSize] |
| longs = struct.unpack(">%dL" % (len(block) // 4), block) |
| value = (value + sum(longs)) & 0xFFFFFFFF |
| return value |
| |
| |
| def readTTCHeader(file): |
| file.seek(0) |
| data = file.read(ttcHeaderSize) |
| if len(data) != ttcHeaderSize: |
| raise TTLibError("Not a Font Collection (not enough data)") |
| self = SimpleNamespace() |
| sstruct.unpack(ttcHeaderFormat, data, self) |
| if self.TTCTag != "ttcf": |
| raise TTLibError("Not a Font Collection") |
| assert self.Version == 0x00010000 or self.Version == 0x00020000, ( |
| "unrecognized TTC version 0x%08x" % self.Version |
| ) |
| self.offsetTable = struct.unpack( |
| ">%dL" % self.numFonts, file.read(self.numFonts * 4) |
| ) |
| if self.Version == 0x00020000: |
| pass # ignoring version 2.0 signatures |
| return self |
| |
| |
| def writeTTCHeader(file, numFonts): |
| self = SimpleNamespace() |
| self.TTCTag = "ttcf" |
| self.Version = 0x00010000 |
| self.numFonts = numFonts |
| file.seek(0) |
| file.write(sstruct.pack(ttcHeaderFormat, self)) |
| offset = file.tell() |
| file.write(struct.pack(">%dL" % self.numFonts, *([0] * self.numFonts))) |
| return offset |
| |
| |
| if __name__ == "__main__": |
| import sys |
| import doctest |
| |
| sys.exit(doctest.testmod().failed) |
