fonttools 4.58.3__cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl

fontTools/ttLib/sfnt.py

@@ -0,0 +1,662 @@
+"""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)