Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 1 | """ttLib/sfnt.py -- low-level module to deal with the sfnt file format. |
| 2 | |
| 3 | Defines two public classes: |
| 4 | SFNTReader |
| 5 | SFNTWriter |
| 6 | |
| 7 | (Normally you don't have to use these classes explicitly; they are |
| 8 | used automatically by ttLib.TTFont.) |
| 9 | |
| 10 | The reading and writing of sfnt files is separated in two distinct |
| 11 | classes, since whenever to number of tables changes or whenever |
| 12 | a table's length chages you need to rewrite the whole file anyway. |
| 13 | """ |
| 14 | |
Behdad Esfahbod | 1ae2959 | 2014-01-14 15:07:50 +0800 | [diff] [blame] | 15 | from __future__ import print_function, division, absolute_import |
Behdad Esfahbod | 7ed91ec | 2013-11-27 15:16:28 -0500 | [diff] [blame] | 16 | from fontTools.misc.py23 import * |
Behdad Esfahbod | 30e691e | 2013-11-27 17:27:45 -0500 | [diff] [blame] | 17 | from fontTools.misc import sstruct |
| 18 | import struct |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 19 | |
jvr | 04b3204 | 2002-05-14 12:09:10 +0000 | [diff] [blame] | 20 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 21 | class SFNTReader(object): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 22 | |
pabs3 | 7e91e77 | 2009-02-22 08:55:00 +0000 | [diff] [blame] | 23 | def __init__(self, file, checkChecksums=1, fontNumber=-1): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 24 | self.file = file |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 25 | self.checkChecksums = checkChecksums |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 26 | |
| 27 | self.flavor = None |
| 28 | self.flavorData = None |
| 29 | self.DirectoryEntry = SFNTDirectoryEntry |
| 30 | self.sfntVersion = self.file.read(4) |
| 31 | self.file.seek(0) |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 32 | if self.sfntVersion == b"ttcf": |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 33 | sstruct.unpack(ttcHeaderFormat, self.file.read(ttcHeaderSize), self) |
pabs3 | 7e91e77 | 2009-02-22 08:55:00 +0000 | [diff] [blame] | 34 | assert self.Version == 0x00010000 or self.Version == 0x00020000, "unrecognized TTC version 0x%08x" % self.Version |
| 35 | if not 0 <= fontNumber < self.numFonts: |
| 36 | from fontTools import ttLib |
Behdad Esfahbod | cd5aad9 | 2013-11-27 02:42:28 -0500 | [diff] [blame] | 37 | raise ttLib.TTLibError("specify a font number between 0 and %d (inclusive)" % (self.numFonts - 1)) |
pabs3 | 7e91e77 | 2009-02-22 08:55:00 +0000 | [diff] [blame] | 38 | offsetTable = struct.unpack(">%dL" % self.numFonts, self.file.read(self.numFonts * 4)) |
| 39 | if self.Version == 0x00020000: |
| 40 | pass # ignoring version 2.0 signatures |
| 41 | self.file.seek(offsetTable[fontNumber]) |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 42 | sstruct.unpack(sfntDirectoryFormat, self.file.read(sfntDirectorySize), self) |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 43 | elif self.sfntVersion == b"wOFF": |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 44 | self.flavor = "woff" |
| 45 | self.DirectoryEntry = WOFFDirectoryEntry |
| 46 | sstruct.unpack(woffDirectoryFormat, self.file.read(woffDirectorySize), self) |
| 47 | else: |
| 48 | sstruct.unpack(sfntDirectoryFormat, self.file.read(sfntDirectorySize), self) |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 49 | self.sfntVersion = Tag(self.sfntVersion) |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 50 | |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 51 | if self.sfntVersion not in ("\x00\x01\x00\x00", "OTTO", "true"): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 52 | from fontTools import ttLib |
Behdad Esfahbod | cd5aad9 | 2013-11-27 02:42:28 -0500 | [diff] [blame] | 53 | raise ttLib.TTLibError("Not a TrueType or OpenType font (bad sfntVersion)") |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 54 | self.tables = {} |
| 55 | for i in range(self.numTables): |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 56 | entry = self.DirectoryEntry() |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 57 | entry.fromFile(self.file) |
Behdad Esfahbod | 6338375 | 2014-01-30 16:48:11 -0500 | [diff] [blame] | 58 | self.tables[Tag(entry.tag)] = entry |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 59 | |
| 60 | # Load flavor data if any |
| 61 | if self.flavor == "woff": |
| 62 | self.flavorData = WOFFFlavorData(self) |
| 63 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 64 | def has_key(self, tag): |
Behdad Esfahbod | bc5e1cb | 2013-11-27 02:33:03 -0500 | [diff] [blame] | 65 | return tag in self.tables |
| 66 | |
| 67 | __contains__ = has_key |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 68 | |
| 69 | def keys(self): |
| 70 | return self.tables.keys() |
| 71 | |
| 72 | def __getitem__(self, tag): |
| 73 | """Fetch the raw table data.""" |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 74 | entry = self.tables[Tag(tag)] |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 75 | data = entry.loadData (self.file) |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 76 | if self.checkChecksums: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 77 | if tag == 'head': |
| 78 | # Beh: we have to special-case the 'head' table. |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 79 | checksum = calcChecksum(data[:8] + b'\0\0\0\0' + data[12:]) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 80 | else: |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 81 | checksum = calcChecksum(data) |
| 82 | if self.checkChecksums > 1: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 83 | # Be obnoxious, and barf when it's wrong |
| 84 | assert checksum == entry.checksum, "bad checksum for '%s' table" % tag |
Behdad Esfahbod | 180ace6 | 2013-11-27 02:40:30 -0500 | [diff] [blame] | 85 | elif checksum != entry.checkSum: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 86 | # Be friendly, and just print a warning. |
Behdad Esfahbod | 3ec6a25 | 2013-11-27 04:57:33 -0500 | [diff] [blame] | 87 | print("bad checksum for '%s' table" % tag) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 88 | return data |
| 89 | |
jvr | f707463 | 2002-05-04 22:04:02 +0000 | [diff] [blame] | 90 | def __delitem__(self, tag): |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 91 | del self.tables[Tag(tag)] |
jvr | f707463 | 2002-05-04 22:04:02 +0000 | [diff] [blame] | 92 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 93 | def close(self): |
| 94 | self.file.close() |
| 95 | |
| 96 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 97 | class SFNTWriter(object): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 98 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 99 | def __init__(self, file, numTables, sfntVersion="\000\001\000\000", |
| 100 | flavor=None, flavorData=None): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 101 | self.file = file |
| 102 | self.numTables = numTables |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 103 | self.sfntVersion = Tag(sfntVersion) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 104 | self.flavor = flavor |
| 105 | self.flavorData = flavorData |
| 106 | |
| 107 | if self.flavor == "woff": |
| 108 | self.directoryFormat = woffDirectoryFormat |
| 109 | self.directorySize = woffDirectorySize |
| 110 | self.DirectoryEntry = WOFFDirectoryEntry |
| 111 | |
| 112 | self.signature = "wOFF" |
| 113 | else: |
| 114 | assert not self.flavor, "Unknown flavor '%s'" % self.flavor |
| 115 | self.directoryFormat = sfntDirectoryFormat |
| 116 | self.directorySize = sfntDirectorySize |
| 117 | self.DirectoryEntry = SFNTDirectoryEntry |
| 118 | |
| 119 | self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(numTables) |
| 120 | |
| 121 | self.nextTableOffset = self.directorySize + numTables * self.DirectoryEntry.formatSize |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 122 | # clear out directory area |
| 123 | self.file.seek(self.nextTableOffset) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 124 | # make sure we're actually where we want to be. (old cStringIO bug) |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 125 | self.file.write(b'\0' * (self.nextTableOffset - self.file.tell())) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 126 | self.tables = {} |
| 127 | |
| 128 | def __setitem__(self, tag, data): |
| 129 | """Write raw table data to disk.""" |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 130 | reuse = False |
Behdad Esfahbod | bc5e1cb | 2013-11-27 02:33:03 -0500 | [diff] [blame] | 131 | if tag in self.tables: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 132 | # We've written this table to file before. If the length |
jvr | 04b3204 | 2002-05-14 12:09:10 +0000 | [diff] [blame] | 133 | # of the data is still the same, we allow overwriting it. |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 134 | entry = self.tables[tag] |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 135 | assert not hasattr(entry.__class__, 'encodeData') |
Behdad Esfahbod | 180ace6 | 2013-11-27 02:40:30 -0500 | [diff] [blame] | 136 | if len(data) != entry.length: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 137 | from fontTools import ttLib |
Behdad Esfahbod | cd5aad9 | 2013-11-27 02:42:28 -0500 | [diff] [blame] | 138 | raise ttLib.TTLibError("cannot rewrite '%s' table: length does not match directory entry" % tag) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 139 | reuse = True |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 140 | else: |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 141 | entry = self.DirectoryEntry() |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 142 | entry.tag = tag |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 143 | |
| 144 | if tag == 'head': |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 145 | entry.checkSum = calcChecksum(data[:8] + b'\0\0\0\0' + data[12:]) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 146 | self.headTable = data |
| 147 | entry.uncompressed = True |
| 148 | else: |
| 149 | entry.checkSum = calcChecksum(data) |
| 150 | |
| 151 | entry.offset = self.nextTableOffset |
| 152 | entry.saveData (self.file, data) |
| 153 | |
| 154 | if not reuse: |
| 155 | self.nextTableOffset = self.nextTableOffset + ((entry.length + 3) & ~3) |
| 156 | |
jvr | c63ac64 | 2008-06-17 20:41:15 +0000 | [diff] [blame] | 157 | # Add NUL bytes to pad the table data to a 4-byte boundary. |
| 158 | # Don't depend on f.seek() as we need to add the padding even if no |
| 159 | # subsequent write follows (seek is lazy), ie. after the final table |
| 160 | # in the font. |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 161 | self.file.write(b'\0' * (self.nextTableOffset - self.file.tell())) |
jvr | c63ac64 | 2008-06-17 20:41:15 +0000 | [diff] [blame] | 162 | assert self.nextTableOffset == self.file.tell() |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 163 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 164 | self.tables[tag] = entry |
| 165 | |
jvr | 28ae196 | 2004-11-16 10:37:59 +0000 | [diff] [blame] | 166 | def close(self): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 167 | """All tables must have been written to disk. Now write the |
| 168 | directory. |
| 169 | """ |
Behdad Esfahbod | ac1b435 | 2013-11-27 04:15:34 -0500 | [diff] [blame] | 170 | tables = sorted(self.tables.items()) |
Behdad Esfahbod | 180ace6 | 2013-11-27 02:40:30 -0500 | [diff] [blame] | 171 | if len(tables) != self.numTables: |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 172 | from fontTools import ttLib |
Behdad Esfahbod | cd5aad9 | 2013-11-27 02:42:28 -0500 | [diff] [blame] | 173 | raise ttLib.TTLibError("wrong number of tables; expected %d, found %d" % (self.numTables, len(tables))) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 174 | |
| 175 | if self.flavor == "woff": |
Behdad Esfahbod | ac4672e | 2013-11-27 16:44:53 -0500 | [diff] [blame] | 176 | self.signature = b"wOFF" |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 177 | self.reserved = 0 |
| 178 | |
| 179 | self.totalSfntSize = 12 |
| 180 | self.totalSfntSize += 16 * len(tables) |
| 181 | for tag, entry in tables: |
| 182 | self.totalSfntSize += (entry.origLength + 3) & ~3 |
| 183 | |
| 184 | data = self.flavorData if self.flavorData else WOFFFlavorData() |
Behdad Esfahbod | 9e6ef94 | 2013-12-04 16:31:44 -0500 | [diff] [blame] | 185 | if data.majorVersion is not None and data.minorVersion is not None: |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 186 | self.majorVersion = data.majorVersion |
| 187 | self.minorVersion = data.minorVersion |
| 188 | else: |
| 189 | if hasattr(self, 'headTable'): |
| 190 | self.majorVersion, self.minorVersion = struct.unpack(">HH", self.headTable[4:8]) |
| 191 | else: |
| 192 | self.majorVersion = self.minorVersion = 0 |
| 193 | if data.metaData: |
| 194 | self.metaOrigLength = len(data.metaData) |
| 195 | self.file.seek(0,2) |
| 196 | self.metaOffset = self.file.tell() |
Behdad Esfahbod | 153ec40 | 2013-12-04 01:15:46 -0500 | [diff] [blame] | 197 | import zlib |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 198 | compressedMetaData = zlib.compress(data.metaData) |
| 199 | self.metaLength = len(compressedMetaData) |
| 200 | self.file.write(compressedMetaData) |
| 201 | else: |
| 202 | self.metaOffset = self.metaLength = self.metaOrigLength = 0 |
| 203 | if data.privData: |
| 204 | self.file.seek(0,2) |
| 205 | off = self.file.tell() |
| 206 | paddedOff = (off + 3) & ~3 |
| 207 | self.file.write('\0' * (paddedOff - off)) |
| 208 | self.privOffset = self.file.tell() |
| 209 | self.privLength = len(data.privData) |
| 210 | self.file.write(data.privData) |
| 211 | else: |
| 212 | self.privOffset = self.privLength = 0 |
| 213 | |
| 214 | self.file.seek(0,2) |
| 215 | self.length = self.file.tell() |
| 216 | |
| 217 | else: |
| 218 | assert not self.flavor, "Unknown flavor '%s'" % self.flavor |
| 219 | pass |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 220 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 221 | directory = sstruct.pack(self.directoryFormat, self) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 222 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 223 | self.file.seek(self.directorySize) |
jvr | f509c0f | 2003-08-22 19:38:37 +0000 | [diff] [blame] | 224 | seenHead = 0 |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 225 | for tag, entry in tables: |
jvr | f509c0f | 2003-08-22 19:38:37 +0000 | [diff] [blame] | 226 | if tag == "head": |
| 227 | seenHead = 1 |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 228 | directory = directory + entry.toString() |
jvr | f509c0f | 2003-08-22 19:38:37 +0000 | [diff] [blame] | 229 | if seenHead: |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 230 | self.writeMasterChecksum(directory) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 231 | self.file.seek(0) |
| 232 | self.file.write(directory) |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 233 | |
| 234 | def _calcMasterChecksum(self, directory): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 235 | # calculate checkSumAdjustment |
Behdad Esfahbod | c2297cd | 2013-11-27 06:26:55 -0500 | [diff] [blame] | 236 | tags = list(self.tables.keys()) |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 237 | checksums = [] |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 238 | for i in range(len(tags)): |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 239 | checksums.append(self.tables[tags[i]].checkSum) |
| 240 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 241 | # TODO(behdad) I'm fairly sure the checksum for woff is not working correctly. |
| 242 | # Haven't debugged. |
| 243 | if self.DirectoryEntry != SFNTDirectoryEntry: |
| 244 | # Create a SFNT directory for checksum calculation purposes |
| 245 | self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(self.numTables) |
| 246 | directory = sstruct.pack(sfntDirectoryFormat, self) |
Behdad Esfahbod | ac1b435 | 2013-11-27 04:15:34 -0500 | [diff] [blame] | 247 | tables = sorted(self.tables.items()) |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 248 | for tag, entry in tables: |
| 249 | sfntEntry = SFNTDirectoryEntry() |
| 250 | for item in ['tag', 'checkSum', 'offset', 'length']: |
| 251 | setattr(sfntEntry, item, getattr(entry, item)) |
| 252 | directory = directory + sfntEntry.toString() |
| 253 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 254 | directory_end = sfntDirectorySize + len(self.tables) * sfntDirectoryEntrySize |
| 255 | assert directory_end == len(directory) |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 256 | |
| 257 | checksums.append(calcChecksum(directory)) |
| 258 | checksum = sum(checksums) & 0xffffffff |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 259 | # BiboAfba! |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 260 | checksumadjustment = (0xB1B0AFBA - checksum) & 0xffffffff |
| 261 | return checksumadjustment |
| 262 | |
| 263 | def writeMasterChecksum(self, directory): |
| 264 | checksumadjustment = self._calcMasterChecksum(directory) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 265 | # write the checksum to the file |
| 266 | self.file.seek(self.tables['head'].offset + 8) |
pabs3 | 0e2aece | 2009-03-24 09:42:15 +0000 | [diff] [blame] | 267 | self.file.write(struct.pack(">L", checksumadjustment)) |
jvr | 1ebda67 | 2008-03-08 20:29:30 +0000 | [diff] [blame] | 268 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 269 | |
| 270 | # -- sfnt directory helpers and cruft |
| 271 | |
pabs3 | 7e91e77 | 2009-02-22 08:55:00 +0000 | [diff] [blame] | 272 | ttcHeaderFormat = """ |
| 273 | > # big endian |
| 274 | TTCTag: 4s # "ttcf" |
| 275 | Version: L # 0x00010000 or 0x00020000 |
| 276 | numFonts: L # number of fonts |
| 277 | # OffsetTable[numFonts]: L # array with offsets from beginning of file |
| 278 | # ulDsigTag: L # version 2.0 only |
| 279 | # ulDsigLength: L # version 2.0 only |
| 280 | # ulDsigOffset: L # version 2.0 only |
| 281 | """ |
| 282 | |
| 283 | ttcHeaderSize = sstruct.calcsize(ttcHeaderFormat) |
| 284 | |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 285 | sfntDirectoryFormat = """ |
| 286 | > # big endian |
jvr | b0e5f29 | 2002-05-13 11:21:48 +0000 | [diff] [blame] | 287 | sfntVersion: 4s |
| 288 | numTables: H # number of tables |
| 289 | searchRange: H # (max2 <= numTables)*16 |
| 290 | entrySelector: H # log2(max2 <= numTables) |
| 291 | rangeShift: H # numTables*16-searchRange |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 292 | """ |
| 293 | |
| 294 | sfntDirectorySize = sstruct.calcsize(sfntDirectoryFormat) |
| 295 | |
| 296 | sfntDirectoryEntryFormat = """ |
| 297 | > # big endian |
jvr | b0e5f29 | 2002-05-13 11:21:48 +0000 | [diff] [blame] | 298 | tag: 4s |
pabs3 | 0e2aece | 2009-03-24 09:42:15 +0000 | [diff] [blame] | 299 | checkSum: L |
| 300 | offset: L |
| 301 | length: L |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 302 | """ |
| 303 | |
| 304 | sfntDirectoryEntrySize = sstruct.calcsize(sfntDirectoryEntryFormat) |
| 305 | |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 306 | woffDirectoryFormat = """ |
| 307 | > # big endian |
| 308 | signature: 4s # "wOFF" |
| 309 | sfntVersion: 4s |
| 310 | length: L # total woff file size |
| 311 | numTables: H # number of tables |
| 312 | reserved: H # set to 0 |
| 313 | totalSfntSize: L # uncompressed size |
| 314 | majorVersion: H # major version of WOFF file |
| 315 | minorVersion: H # minor version of WOFF file |
| 316 | metaOffset: L # offset to metadata block |
| 317 | metaLength: L # length of compressed metadata |
| 318 | metaOrigLength: L # length of uncompressed metadata |
| 319 | privOffset: L # offset to private data block |
| 320 | privLength: L # length of private data block |
| 321 | """ |
| 322 | |
| 323 | woffDirectorySize = sstruct.calcsize(woffDirectoryFormat) |
| 324 | |
| 325 | woffDirectoryEntryFormat = """ |
| 326 | > # big endian |
| 327 | tag: 4s |
| 328 | offset: L |
| 329 | length: L # compressed length |
| 330 | origLength: L # original length |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 331 | checkSum: L # original checksum |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 332 | """ |
| 333 | |
| 334 | woffDirectoryEntrySize = sstruct.calcsize(woffDirectoryEntryFormat) |
| 335 | |
| 336 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 337 | class DirectoryEntry(object): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 338 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 339 | def __init__(self): |
| 340 | self.uncompressed = False # if True, always embed entry raw |
| 341 | |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 342 | def fromFile(self, file): |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 343 | sstruct.unpack(self.format, file.read(self.formatSize), self) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 344 | |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 345 | def fromString(self, str): |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 346 | sstruct.unpack(self.format, str, self) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 347 | |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 348 | def toString(self): |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 349 | return sstruct.pack(self.format, self) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 350 | |
| 351 | def __repr__(self): |
| 352 | if hasattr(self, "tag"): |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 353 | return "<%s '%s' at %x>" % (self.__class__.__name__, self.tag, id(self)) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 354 | else: |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 355 | return "<%s at %x>" % (self.__class__.__name__, id(self)) |
| 356 | |
| 357 | def loadData(self, file): |
| 358 | file.seek(self.offset) |
| 359 | data = file.read(self.length) |
| 360 | assert len(data) == self.length |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 361 | if hasattr(self.__class__, 'decodeData'): |
| 362 | data = self.decodeData(data) |
| 363 | return data |
| 364 | |
| 365 | def saveData(self, file, data): |
| 366 | if hasattr(self.__class__, 'encodeData'): |
| 367 | data = self.encodeData(data) |
| 368 | self.length = len(data) |
| 369 | file.seek(self.offset) |
| 370 | file.write(data) |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 371 | |
| 372 | def decodeData(self, rawData): |
| 373 | return rawData |
| 374 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 375 | def encodeData(self, data): |
| 376 | return data |
| 377 | |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 378 | class SFNTDirectoryEntry(DirectoryEntry): |
| 379 | |
| 380 | format = sfntDirectoryEntryFormat |
| 381 | formatSize = sfntDirectoryEntrySize |
| 382 | |
| 383 | class WOFFDirectoryEntry(DirectoryEntry): |
| 384 | |
| 385 | format = woffDirectoryEntryFormat |
| 386 | formatSize = woffDirectoryEntrySize |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 387 | zlibCompressionLevel = 6 |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 388 | |
| 389 | def decodeData(self, rawData): |
| 390 | import zlib |
| 391 | if self.length == self.origLength: |
| 392 | data = rawData |
| 393 | else: |
| 394 | assert self.length < self.origLength |
| 395 | data = zlib.decompress(rawData) |
| 396 | assert len (data) == self.origLength |
| 397 | return data |
| 398 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 399 | def encodeData(self, data): |
| 400 | import zlib |
| 401 | self.origLength = len(data) |
| 402 | if not self.uncompressed: |
| 403 | compressedData = zlib.compress(data, self.zlibCompressionLevel) |
| 404 | if self.uncompressed or len(compressedData) >= self.origLength: |
| 405 | # Encode uncompressed |
| 406 | rawData = data |
| 407 | self.length = self.origLength |
| 408 | else: |
| 409 | rawData = compressedData |
| 410 | self.length = len(rawData) |
| 411 | return rawData |
| 412 | |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 413 | class WOFFFlavorData(): |
| 414 | |
Behdad Esfahbod | b0dc6df | 2013-08-15 17:39:16 -0400 | [diff] [blame] | 415 | Flavor = 'woff' |
| 416 | |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 417 | def __init__(self, reader=None): |
| 418 | self.majorVersion = None |
| 419 | self.minorVersion = None |
| 420 | self.metaData = None |
| 421 | self.privData = None |
| 422 | if reader: |
| 423 | self.majorVersion = reader.majorVersion |
| 424 | self.minorVersion = reader.minorVersion |
| 425 | if reader.metaLength: |
| 426 | reader.file.seek(reader.metaOffset) |
Behdad Esfahbod | 153ec40 | 2013-12-04 01:15:46 -0500 | [diff] [blame] | 427 | rawData = reader.file.read(reader.metaLength) |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 428 | assert len(rawData) == reader.metaLength |
Behdad Esfahbod | 153ec40 | 2013-12-04 01:15:46 -0500 | [diff] [blame] | 429 | import zlib |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 430 | data = zlib.decompress(rawData) |
| 431 | assert len(data) == reader.metaOrigLength |
| 432 | self.metaData = data |
| 433 | if reader.privLength: |
| 434 | reader.file.seek(reader.privOffset) |
Behdad Esfahbod | 153ec40 | 2013-12-04 01:15:46 -0500 | [diff] [blame] | 435 | data = reader.file.read(reader.privLength) |
Behdad Esfahbod | 58d7416 | 2013-08-15 15:30:55 -0400 | [diff] [blame] | 436 | assert len(data) == reader.privLength |
| 437 | self.privData = data |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 438 | |
| 439 | |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 440 | def calcChecksum(data): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 441 | """Calculate the checksum for an arbitrary block of data. |
| 442 | Optionally takes a 'start' argument, which allows you to |
| 443 | calculate a checksum in chunks by feeding it a previous |
| 444 | result. |
| 445 | |
| 446 | If the data length is not a multiple of four, it assumes |
| 447 | it is to be padded with null byte. |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 448 | |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 449 | >>> print calcChecksum(b"abcd") |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 450 | 1633837924 |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 451 | >>> print calcChecksum(b"abcdxyz") |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 452 | 3655064932 |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 453 | """ |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 454 | remainder = len(data) % 4 |
| 455 | if remainder: |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 456 | data += b"\0" * (4 - remainder) |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 457 | value = 0 |
| 458 | blockSize = 4096 |
| 459 | assert blockSize % 4 == 0 |
Behdad Esfahbod | 97dea0a | 2013-11-27 03:34:48 -0500 | [diff] [blame] | 460 | for i in range(0, len(data), blockSize): |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 461 | block = data[i:i+blockSize] |
| 462 | longs = struct.unpack(">%dL" % (len(block) // 4), block) |
| 463 | value = (value + sum(longs)) & 0xffffffff |
| 464 | return value |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 465 | |
| 466 | |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 467 | def maxPowerOfTwo(x): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 468 | """Return the highest exponent of two, so that |
| 469 | (2 ** exponent) <= x |
| 470 | """ |
| 471 | exponent = 0 |
| 472 | while x: |
| 473 | x = x >> 1 |
| 474 | exponent = exponent + 1 |
Just | fdea99d | 2000-08-23 12:34:44 +0000 | [diff] [blame] | 475 | return max(exponent - 1, 0) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 476 | |
| 477 | |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 478 | def getSearchRange(n): |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 479 | """Calculate searchRange, entrySelector, rangeShift for the |
| 480 | sfnt directory. 'n' is the number of tables. |
| 481 | """ |
| 482 | # This stuff needs to be stored in the file, because? |
jvr | ea9dfa9 | 2002-05-12 17:14:50 +0000 | [diff] [blame] | 483 | exponent = maxPowerOfTwo(n) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 484 | searchRange = (2 ** exponent) * 16 |
| 485 | entrySelector = exponent |
Behdad Esfahbod | 9fed952 | 2014-05-27 15:54:04 -0400 | [diff] [blame^] | 486 | rangeShift = max(0, n * 16 - searchRange) |
Just | 7842e56 | 1999-12-16 21:34:53 +0000 | [diff] [blame] | 487 | return searchRange, entrySelector, rangeShift |
| 488 | |
jvr | 91bca42 | 2012-10-18 12:49:22 +0000 | [diff] [blame] | 489 | |
| 490 | if __name__ == "__main__": |
| 491 | import doctest |
| 492 | doctest.testmod() |