# Copyright 2013 Google, Inc. All Rights Reserved. # # Google Author(s): Behdad Esfahbod """Python OpenType Layout Subsetter. Later grown into full OpenType subsetter, supporting all standard tables. """ from __future__ import print_function, division, absolute_import from fontTools.misc.py23 import * from fontTools import ttLib from fontTools.ttLib.tables import otTables from fontTools.misc import psCharStrings from fontTools.pens import basePen import sys import struct import time import array def _add_method(*clazzes): """Returns a decorator function that adds a new method to one or more classes.""" def wrapper(method): for clazz in clazzes: assert clazz.__name__ != 'DefaultTable', 'Oops, table class not found.' assert not hasattr(clazz, method.__name__), \ "Oops, class '%s' has method '%s'." % (clazz.__name__, method.__name__) setattr(clazz, method.__name__, method) return None return wrapper def _uniq_sort(l): return sorted(set(l)) def _set_update(s, *others): # Jython's set.update only takes one other argument. # Emulate real set.update... for other in others: s.update(other) @_add_method(otTables.Coverage) def intersect(self, glyphs): "Returns ascending list of matching coverage values." return [i for i,g in enumerate(self.glyphs) if g in glyphs] @_add_method(otTables.Coverage) def intersect_glyphs(self, glyphs): "Returns set of intersecting glyphs." return set(g for g in self.glyphs if g in glyphs) @_add_method(otTables.Coverage) def subset(self, glyphs): "Returns ascending list of remaining coverage values." indices = self.intersect(glyphs) self.glyphs = [g for g in self.glyphs if g in glyphs] return indices @_add_method(otTables.Coverage) def remap(self, coverage_map): "Remaps coverage." self.glyphs = [self.glyphs[i] for i in coverage_map] @_add_method(otTables.ClassDef) def intersect(self, glyphs): "Returns ascending list of matching class values." return _uniq_sort( ([0] if any(g not in self.classDefs for g in glyphs) else []) + [v for g,v in self.classDefs.items() if g in glyphs]) @_add_method(otTables.ClassDef) def intersect_class(self, glyphs, klass): "Returns set of glyphs matching class." if klass == 0: return set(g for g in glyphs if g not in self.classDefs) return set(g for g,v in self.classDefs.items() if v == klass and g in glyphs) @_add_method(otTables.ClassDef) def subset(self, glyphs, remap=False): "Returns ascending list of remaining classes." self.classDefs = dict((g,v) for g,v in self.classDefs.items() if g in glyphs) # Note: while class 0 has the special meaning of "not matched", # if no glyph will ever /not match/, we can optimize class 0 out too. indices = _uniq_sort( ([0] if any(g not in self.classDefs for g in glyphs) else []) + list(self.classDefs.values())) if remap: self.remap(indices) return indices @_add_method(otTables.ClassDef) def remap(self, class_map): "Remaps classes." self.classDefs = dict((g,class_map.index(v)) for g,v in self.classDefs.items()) @_add_method(otTables.SingleSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs s.glyphs.update(v for g,v in self.mapping.items() if g in cur_glyphs) @_add_method(otTables.SingleSubst) def subset_glyphs(self, s): self.mapping = dict((g,v) for g,v in self.mapping.items() if g in s.glyphs and v in s.glyphs) return bool(self.mapping) @_add_method(otTables.MultipleSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs indices = self.Coverage.intersect(cur_glyphs) _set_update(s.glyphs, *(self.Sequence[i].Substitute for i in indices)) @_add_method(otTables.MultipleSubst) def subset_glyphs(self, s): indices = self.Coverage.subset(s.glyphs) self.Sequence = [self.Sequence[i] for i in indices] # Now drop rules generating glyphs we don't want indices = [i for i,seq in enumerate(self.Sequence) if all(sub in s.glyphs for sub in seq.Substitute)] self.Sequence = [self.Sequence[i] for i in indices] self.Coverage.remap(indices) self.SequenceCount = len(self.Sequence) return bool(self.SequenceCount) @_add_method(otTables.AlternateSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs _set_update(s.glyphs, *(vlist for g,vlist in self.alternates.items() if g in cur_glyphs)) @_add_method(otTables.AlternateSubst) def subset_glyphs(self, s): self.alternates = dict((g,vlist) for g,vlist in self.alternates.items() if g in s.glyphs and all(v in s.glyphs for v in vlist)) return bool(self.alternates) @_add_method(otTables.LigatureSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs _set_update(s.glyphs, *([seq.LigGlyph for seq in seqs if all(c in s.glyphs for c in seq.Component)] for g,seqs in self.ligatures.items() if g in cur_glyphs)) @_add_method(otTables.LigatureSubst) def subset_glyphs(self, s): self.ligatures = dict((g,v) for g,v in self.ligatures.items() if g in s.glyphs) self.ligatures = dict((g,[seq for seq in seqs if seq.LigGlyph in s.glyphs and all(c in s.glyphs for c in seq.Component)]) for g,seqs in self.ligatures.items()) self.ligatures = dict((g,v) for g,v in self.ligatures.items() if v) return bool(self.ligatures) @_add_method(otTables.ReverseChainSingleSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs if self.Format == 1: indices = self.Coverage.intersect(cur_glyphs) if(not indices or not all(c.intersect(s.glyphs) for c in self.LookAheadCoverage + self.BacktrackCoverage)): return s.glyphs.update(self.Substitute[i] for i in indices) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ReverseChainSingleSubst) def subset_glyphs(self, s): if self.Format == 1: indices = self.Coverage.subset(s.glyphs) self.Substitute = [self.Substitute[i] for i in indices] # Now drop rules generating glyphs we don't want indices = [i for i,sub in enumerate(self.Substitute) if sub in s.glyphs] self.Substitute = [self.Substitute[i] for i in indices] self.Coverage.remap(indices) self.GlyphCount = len(self.Substitute) return bool(self.GlyphCount and all(c.subset(s.glyphs) for c in self.LookAheadCoverage+self.BacktrackCoverage)) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.SinglePos) def subset_glyphs(self, s): if self.Format == 1: return len(self.Coverage.subset(s.glyphs)) elif self.Format == 2: indices = self.Coverage.subset(s.glyphs) self.Value = [self.Value[i] for i in indices] self.ValueCount = len(self.Value) return bool(self.ValueCount) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.SinglePos) def prune_post_subset(self, options): if not options.hinting: # Drop device tables self.ValueFormat &= ~0x00F0 return True @_add_method(otTables.PairPos) def subset_glyphs(self, s): if self.Format == 1: indices = self.Coverage.subset(s.glyphs) self.PairSet = [self.PairSet[i] for i in indices] for p in self.PairSet: p.PairValueRecord = [r for r in p.PairValueRecord if r.SecondGlyph in s.glyphs] p.PairValueCount = len(p.PairValueRecord) # Remove empty pairsets indices = [i for i,p in enumerate(self.PairSet) if p.PairValueCount] self.Coverage.remap(indices) self.PairSet = [self.PairSet[i] for i in indices] self.PairSetCount = len(self.PairSet) return bool(self.PairSetCount) elif self.Format == 2: class1_map = self.ClassDef1.subset(s.glyphs, remap=True) class2_map = self.ClassDef2.subset(s.glyphs, remap=True) self.Class1Record = [self.Class1Record[i] for i in class1_map] for c in self.Class1Record: c.Class2Record = [c.Class2Record[i] for i in class2_map] self.Class1Count = len(class1_map) self.Class2Count = len(class2_map) return bool(self.Class1Count and self.Class2Count and self.Coverage.subset(s.glyphs)) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.PairPos) def prune_post_subset(self, options): if not options.hinting: # Drop device tables self.ValueFormat1 &= ~0x00F0 self.ValueFormat2 &= ~0x00F0 return True @_add_method(otTables.CursivePos) def subset_glyphs(self, s): if self.Format == 1: indices = self.Coverage.subset(s.glyphs) self.EntryExitRecord = [self.EntryExitRecord[i] for i in indices] self.EntryExitCount = len(self.EntryExitRecord) return bool(self.EntryExitCount) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.Anchor) def prune_hints(self): # Drop device tables / contour anchor point self.ensureDecompiled() self.Format = 1 @_add_method(otTables.CursivePos) def prune_post_subset(self, options): if not options.hinting: for rec in self.EntryExitRecord: if rec.EntryAnchor: rec.EntryAnchor.prune_hints() if rec.ExitAnchor: rec.ExitAnchor.prune_hints() return True @_add_method(otTables.MarkBasePos) def subset_glyphs(self, s): if self.Format == 1: mark_indices = self.MarkCoverage.subset(s.glyphs) self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i] for i in mark_indices] self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord) base_indices = self.BaseCoverage.subset(s.glyphs) self.BaseArray.BaseRecord = [self.BaseArray.BaseRecord[i] for i in base_indices] self.BaseArray.BaseCount = len(self.BaseArray.BaseRecord) # Prune empty classes class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord) self.ClassCount = len(class_indices) for m in self.MarkArray.MarkRecord: m.Class = class_indices.index(m.Class) for b in self.BaseArray.BaseRecord: b.BaseAnchor = [b.BaseAnchor[i] for i in class_indices] return bool(self.ClassCount and self.MarkArray.MarkCount and self.BaseArray.BaseCount) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.MarkBasePos) def prune_post_subset(self, options): if not options.hinting: for m in self.MarkArray.MarkRecord: if m.MarkAnchor: m.MarkAnchor.prune_hints() for b in self.BaseArray.BaseRecord: for a in b.BaseAnchor: if a: a.prune_hints() return True @_add_method(otTables.MarkLigPos) def subset_glyphs(self, s): if self.Format == 1: mark_indices = self.MarkCoverage.subset(s.glyphs) self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i] for i in mark_indices] self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord) ligature_indices = self.LigatureCoverage.subset(s.glyphs) self.LigatureArray.LigatureAttach = [self.LigatureArray.LigatureAttach[i] for i in ligature_indices] self.LigatureArray.LigatureCount = len(self.LigatureArray.LigatureAttach) # Prune empty classes class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord) self.ClassCount = len(class_indices) for m in self.MarkArray.MarkRecord: m.Class = class_indices.index(m.Class) for l in self.LigatureArray.LigatureAttach: for c in l.ComponentRecord: c.LigatureAnchor = [c.LigatureAnchor[i] for i in class_indices] return bool(self.ClassCount and self.MarkArray.MarkCount and self.LigatureArray.LigatureCount) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.MarkLigPos) def prune_post_subset(self, options): if not options.hinting: for m in self.MarkArray.MarkRecord: if m.MarkAnchor: m.MarkAnchor.prune_hints() for l in self.LigatureArray.LigatureAttach: for c in l.ComponentRecord: for a in c.LigatureAnchor: if a: a.prune_hints() return True @_add_method(otTables.MarkMarkPos) def subset_glyphs(self, s): if self.Format == 1: mark1_indices = self.Mark1Coverage.subset(s.glyphs) self.Mark1Array.MarkRecord = [self.Mark1Array.MarkRecord[i] for i in mark1_indices] self.Mark1Array.MarkCount = len(self.Mark1Array.MarkRecord) mark2_indices = self.Mark2Coverage.subset(s.glyphs) self.Mark2Array.Mark2Record = [self.Mark2Array.Mark2Record[i] for i in mark2_indices] self.Mark2Array.MarkCount = len(self.Mark2Array.Mark2Record) # Prune empty classes class_indices = _uniq_sort(v.Class for v in self.Mark1Array.MarkRecord) self.ClassCount = len(class_indices) for m in self.Mark1Array.MarkRecord: m.Class = class_indices.index(m.Class) for b in self.Mark2Array.Mark2Record: b.Mark2Anchor = [b.Mark2Anchor[i] for i in class_indices] return bool(self.ClassCount and self.Mark1Array.MarkCount and self.Mark2Array.MarkCount) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.MarkMarkPos) def prune_post_subset(self, options): if not options.hinting: # Drop device tables or contour anchor point for m in self.Mark1Array.MarkRecord: if m.MarkAnchor: m.MarkAnchor.prune_hints() for b in self.Mark2Array.Mark2Record: for m in b.Mark2Anchor: if m: m.prune_hints() return True @_add_method(otTables.SingleSubst, otTables.MultipleSubst, otTables.AlternateSubst, otTables.LigatureSubst, otTables.ReverseChainSingleSubst, otTables.SinglePos, otTables.PairPos, otTables.CursivePos, otTables.MarkBasePos, otTables.MarkLigPos, otTables.MarkMarkPos) def subset_lookups(self, lookup_indices): pass @_add_method(otTables.SingleSubst, otTables.MultipleSubst, otTables.AlternateSubst, otTables.LigatureSubst, otTables.ReverseChainSingleSubst, otTables.SinglePos, otTables.PairPos, otTables.CursivePos, otTables.MarkBasePos, otTables.MarkLigPos, otTables.MarkMarkPos) def collect_lookups(self): return [] @_add_method(otTables.SingleSubst, otTables.MultipleSubst, otTables.AlternateSubst, otTables.LigatureSubst, otTables.ContextSubst, otTables.ChainContextSubst, otTables.ReverseChainSingleSubst, otTables.SinglePos, otTables.PairPos, otTables.CursivePos, otTables.MarkBasePos, otTables.MarkLigPos, otTables.MarkMarkPos, otTables.ContextPos, otTables.ChainContextPos) def prune_pre_subset(self, options): return True @_add_method(otTables.SingleSubst, otTables.MultipleSubst, otTables.AlternateSubst, otTables.LigatureSubst, otTables.ReverseChainSingleSubst, otTables.ContextSubst, otTables.ChainContextSubst, otTables.ContextPos, otTables.ChainContextPos) def prune_post_subset(self, options): return True @_add_method(otTables.SingleSubst, otTables.AlternateSubst, otTables.ReverseChainSingleSubst) def may_have_non_1to1(self): return False @_add_method(otTables.MultipleSubst, otTables.LigatureSubst, otTables.ContextSubst, otTables.ChainContextSubst) def may_have_non_1to1(self): return True @_add_method(otTables.ContextSubst, otTables.ChainContextSubst, otTables.ContextPos, otTables.ChainContextPos) def __classify_context(self): class ContextHelper(object): def __init__(self, klass, Format): if klass.__name__.endswith('Subst'): Typ = 'Sub' Type = 'Subst' else: Typ = 'Pos' Type = 'Pos' if klass.__name__.startswith('Chain'): Chain = 'Chain' else: Chain = '' ChainTyp = Chain+Typ self.Typ = Typ self.Type = Type self.Chain = Chain self.ChainTyp = ChainTyp self.LookupRecord = Type+'LookupRecord' if Format == 1: Coverage = lambda r: r.Coverage ChainCoverage = lambda r: r.Coverage ContextData = lambda r:(None,) ChainContextData = lambda r:(None, None, None) RuleData = lambda r:(r.Input,) ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead) SetRuleData = None ChainSetRuleData = None elif Format == 2: Coverage = lambda r: r.Coverage ChainCoverage = lambda r: r.Coverage ContextData = lambda r:(r.ClassDef,) ChainContextData = lambda r:(r.LookAheadClassDef, r.InputClassDef, r.BacktrackClassDef) RuleData = lambda r:(r.Class,) ChainRuleData = lambda r:(r.LookAhead, r.Input, r.Backtrack) def SetRuleData(r, d):(r.Class,) = d def ChainSetRuleData(r, d):(r.LookAhead, r.Input, r.Backtrack) = d elif Format == 3: Coverage = lambda r: r.Coverage[0] ChainCoverage = lambda r: r.InputCoverage[0] ContextData = None ChainContextData = None RuleData = lambda r: r.Coverage ChainRuleData = lambda r:(r.LookAheadCoverage + r.InputCoverage + r.BacktrackCoverage) SetRuleData = None ChainSetRuleData = None else: assert 0, "unknown format: %s" % Format if Chain: self.Coverage = ChainCoverage self.ContextData = ChainContextData self.RuleData = ChainRuleData self.SetRuleData = ChainSetRuleData else: self.Coverage = Coverage self.ContextData = ContextData self.RuleData = RuleData self.SetRuleData = SetRuleData if Format == 1: self.Rule = ChainTyp+'Rule' self.RuleCount = ChainTyp+'RuleCount' self.RuleSet = ChainTyp+'RuleSet' self.RuleSetCount = ChainTyp+'RuleSetCount' self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else [] elif Format == 2: self.Rule = ChainTyp+'ClassRule' self.RuleCount = ChainTyp+'ClassRuleCount' self.RuleSet = ChainTyp+'ClassSet' self.RuleSetCount = ChainTyp+'ClassSetCount' self.Intersect = lambda glyphs, c, r: c.intersect_class(glyphs, r) self.ClassDef = 'InputClassDef' if Chain else 'ClassDef' self.ClassDefIndex = 1 if Chain else 0 self.Input = 'Input' if Chain else 'Class' if self.Format not in [1, 2, 3]: return None # Don't shoot the messenger; let it go if not hasattr(self.__class__, "__ContextHelpers"): self.__class__.__ContextHelpers = {} if self.Format not in self.__class__.__ContextHelpers: helper = ContextHelper(self.__class__, self.Format) self.__class__.__ContextHelpers[self.Format] = helper return self.__class__.__ContextHelpers[self.Format] @_add_method(otTables.ContextSubst, otTables.ChainContextSubst) def closure_glyphs(self, s, cur_glyphs=None): if cur_glyphs is None: cur_glyphs = s.glyphs c = self.__classify_context() indices = c.Coverage(self).intersect(s.glyphs) if not indices: return [] cur_glyphs = c.Coverage(self).intersect_glyphs(s.glyphs); if self.Format == 1: ContextData = c.ContextData(self) rss = getattr(self, c.RuleSet) rssCount = getattr(self, c.RuleSetCount) for i in indices: if i >= rssCount or not rss[i]: continue for r in getattr(rss[i], c.Rule): if not r: continue if all(all(c.Intersect(s.glyphs, cd, k) for k in klist) for cd,klist in zip(ContextData, c.RuleData(r))): chaos = False for ll in getattr(r, c.LookupRecord): if not ll: continue seqi = ll.SequenceIndex if chaos: pos_glyphs = s.glyphs else: if seqi == 0: pos_glyphs = set([c.Coverage(self).glyphs[i]]) else: pos_glyphs = set([r.Input[seqi - 1]]) lookup = s.table.LookupList.Lookup[ll.LookupListIndex] chaos = chaos or lookup.may_have_non_1to1() lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) elif self.Format == 2: ClassDef = getattr(self, c.ClassDef) indices = ClassDef.intersect(cur_glyphs) ContextData = c.ContextData(self) rss = getattr(self, c.RuleSet) rssCount = getattr(self, c.RuleSetCount) for i in indices: if i >= rssCount or not rss[i]: continue for r in getattr(rss[i], c.Rule): if not r: continue if all(all(c.Intersect(s.glyphs, cd, k) for k in klist) for cd,klist in zip(ContextData, c.RuleData(r))): chaos = False for ll in getattr(r, c.LookupRecord): if not ll: continue seqi = ll.SequenceIndex if chaos: pos_glyphs = s.glyphs else: if seqi == 0: pos_glyphs = ClassDef.intersect_class(cur_glyphs, i) else: pos_glyphs = ClassDef.intersect_class(s.glyphs, getattr(r, c.Input)[seqi - 1]) lookup = s.table.LookupList.Lookup[ll.LookupListIndex] chaos = chaos or lookup.may_have_non_1to1() lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) elif self.Format == 3: if not all(x.intersect(s.glyphs) for x in c.RuleData(self)): return [] r = self chaos = False for ll in getattr(r, c.LookupRecord): if not ll: continue seqi = ll.SequenceIndex if chaos: pos_glyphs = s.glyphs else: if seqi == 0: pos_glyphs = cur_glyphs else: pos_glyphs = r.InputCoverage[seqi].intersect_glyphs(s.glyphs) lookup = s.table.LookupList.Lookup[ll.LookupListIndex] chaos = chaos or lookup.may_have_non_1to1() lookup.closure_glyphs(s, cur_glyphs=pos_glyphs) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ContextSubst, otTables.ContextPos, otTables.ChainContextSubst, otTables.ChainContextPos) def subset_glyphs(self, s): c = self.__classify_context() if self.Format == 1: indices = self.Coverage.subset(s.glyphs) rss = getattr(self, c.RuleSet) rss = [rss[i] for i in indices] for rs in rss: if not rs: continue ss = getattr(rs, c.Rule) ss = [r for r in ss if r and all(all(g in s.glyphs for g in glist) for glist in c.RuleData(r))] setattr(rs, c.Rule, ss) setattr(rs, c.RuleCount, len(ss)) # Prune empty subrulesets rss = [rs for rs in rss if rs and getattr(rs, c.Rule)] setattr(self, c.RuleSet, rss) setattr(self, c.RuleSetCount, len(rss)) return bool(rss) elif self.Format == 2: if not self.Coverage.subset(s.glyphs): return False ContextData = c.ContextData(self) klass_maps = [x.subset(s.glyphs, remap=True) for x in ContextData] # Keep rulesets for class numbers that survived. indices = klass_maps[c.ClassDefIndex] rss = getattr(self, c.RuleSet) rssCount = getattr(self, c.RuleSetCount) rss = [rss[i] for i in indices if i < rssCount] del rssCount # Delete, but not renumber, unreachable rulesets. indices = getattr(self, c.ClassDef).intersect(self.Coverage.glyphs) rss = [rss if i in indices else None for i,rss in enumerate(rss)] while rss and rss[-1] is None: del rss[-1] for rs in rss: if not rs: continue ss = getattr(rs, c.Rule) ss = [r for r in ss if r and all(all(k in klass_map for k in klist) for klass_map,klist in zip(klass_maps, c.RuleData(r)))] setattr(rs, c.Rule, ss) setattr(rs, c.RuleCount, len(ss)) # Remap rule classes for r in ss: c.SetRuleData(r, [[klass_map.index(k) for k in klist] for klass_map,klist in zip(klass_maps, c.RuleData(r))]) return bool(rss) elif self.Format == 3: return all(x.subset(s.glyphs) for x in c.RuleData(self)) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ContextSubst, otTables.ChainContextSubst, otTables.ContextPos, otTables.ChainContextPos) def subset_lookups(self, lookup_indices): c = self.__classify_context() if self.Format in [1, 2]: for rs in getattr(self, c.RuleSet): if not rs: continue for r in getattr(rs, c.Rule): if not r: continue setattr(r, c.LookupRecord, [ll for ll in getattr(r, c.LookupRecord) if ll and ll.LookupListIndex in lookup_indices]) for ll in getattr(r, c.LookupRecord): if not ll: continue ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex) elif self.Format == 3: setattr(self, c.LookupRecord, [ll for ll in getattr(self, c.LookupRecord) if ll and ll.LookupListIndex in lookup_indices]) for ll in getattr(self, c.LookupRecord): if not ll: continue ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ContextSubst, otTables.ChainContextSubst, otTables.ContextPos, otTables.ChainContextPos) def collect_lookups(self): c = self.__classify_context() if self.Format in [1, 2]: return [ll.LookupListIndex for rs in getattr(self, c.RuleSet) if rs for r in getattr(rs, c.Rule) if r for ll in getattr(r, c.LookupRecord) if ll] elif self.Format == 3: return [ll.LookupListIndex for ll in getattr(self, c.LookupRecord) if ll] else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst) def closure_glyphs(self, s, cur_glyphs=None): if self.Format == 1: self.ExtSubTable.closure_glyphs(s, cur_glyphs) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst) def may_have_non_1to1(self): if self.Format == 1: return self.ExtSubTable.may_have_non_1to1() else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst, otTables.ExtensionPos) def prune_pre_subset(self, options): if self.Format == 1: return self.ExtSubTable.prune_pre_subset(options) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst, otTables.ExtensionPos) def subset_glyphs(self, s): if self.Format == 1: return self.ExtSubTable.subset_glyphs(s) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst, otTables.ExtensionPos) def prune_post_subset(self, options): if self.Format == 1: return self.ExtSubTable.prune_post_subset(options) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst, otTables.ExtensionPos) def subset_lookups(self, lookup_indices): if self.Format == 1: return self.ExtSubTable.subset_lookups(lookup_indices) else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.ExtensionSubst, otTables.ExtensionPos) def collect_lookups(self): if self.Format == 1: return self.ExtSubTable.collect_lookups() else: assert 0, "unknown format: %s" % self.Format @_add_method(otTables.Lookup) def closure_glyphs(self, s, cur_glyphs=None): for st in self.SubTable: if not st: continue st.closure_glyphs(s, cur_glyphs) @_add_method(otTables.Lookup) def prune_pre_subset(self, options): ret = False for st in self.SubTable: if not st: continue if st.prune_pre_subset(options): ret = True return ret @_add_method(otTables.Lookup) def subset_glyphs(self, s): self.SubTable = [st for st in self.SubTable if st and st.subset_glyphs(s)] self.SubTableCount = len(self.SubTable) return bool(self.SubTableCount) @_add_method(otTables.Lookup) def prune_post_subset(self, options): ret = False for st in self.SubTable: if not st: continue if st.prune_post_subset(options): ret = True return ret @_add_method(otTables.Lookup) def subset_lookups(self, lookup_indices): for s in self.SubTable: s.subset_lookups(lookup_indices) @_add_method(otTables.Lookup) def collect_lookups(self): return _uniq_sort(sum((st.collect_lookups() for st in self.SubTable if st), [])) @_add_method(otTables.Lookup) def may_have_non_1to1(self): return any(st.may_have_non_1to1() for st in self.SubTable if st) @_add_method(otTables.LookupList) def prune_pre_subset(self, options): ret = False for l in self.Lookup: if not l: continue if l.prune_pre_subset(options): ret = True return ret @_add_method(otTables.LookupList) def subset_glyphs(self, s): "Returns the indices of nonempty lookups." return [i for i,l in enumerate(self.Lookup) if l and l.subset_glyphs(s)] @_add_method(otTables.LookupList) def prune_post_subset(self, options): ret = False for l in self.Lookup: if not l: continue if l.prune_post_subset(options): ret = True return ret @_add_method(otTables.LookupList) def subset_lookups(self, lookup_indices): self.ensureDecompiled() self.Lookup = [self.Lookup[i] for i in lookup_indices if i < self.LookupCount] self.LookupCount = len(self.Lookup) for l in self.Lookup: l.subset_lookups(lookup_indices) @_add_method(otTables.LookupList) def closure_lookups(self, lookup_indices): lookup_indices = _uniq_sort(lookup_indices) recurse = lookup_indices while True: recurse_lookups = sum((self.Lookup[i].collect_lookups() for i in recurse if i < self.LookupCount), []) recurse_lookups = [l for l in recurse_lookups if l not in lookup_indices and l < self.LookupCount] if not recurse_lookups: return _uniq_sort(lookup_indices) recurse_lookups = _uniq_sort(recurse_lookups) lookup_indices.extend(recurse_lookups) recurse = recurse_lookups @_add_method(otTables.Feature) def subset_lookups(self, lookup_indices): self.LookupListIndex = [l for l in self.LookupListIndex if l in lookup_indices] # Now map them. self.LookupListIndex = [lookup_indices.index(l) for l in self.LookupListIndex] self.LookupCount = len(self.LookupListIndex) return self.LookupCount or self.FeatureParams @_add_method(otTables.Feature) def collect_lookups(self): return self.LookupListIndex[:] @_add_method(otTables.FeatureList) def subset_lookups(self, lookup_indices): "Returns the indices of nonempty features." # Note: Never ever drop feature 'pref', even if it's empty. # HarfBuzz chooses shaper for Khmer based on presence of this # feature. See thread at: # http://lists.freedesktop.org/archives/harfbuzz/2012-November/002660.html feature_indices = [i for i,f in enumerate(self.FeatureRecord) if (f.Feature.subset_lookups(lookup_indices) or f.FeatureTag == 'pref')] self.subset_features(feature_indices) return feature_indices @_add_method(otTables.FeatureList) def collect_lookups(self, feature_indices): return _uniq_sort(sum((self.FeatureRecord[i].Feature.collect_lookups() for i in feature_indices if i < self.FeatureCount), [])) @_add_method(otTables.FeatureList) def subset_features(self, feature_indices): self.ensureDecompiled() self.FeatureRecord = [self.FeatureRecord[i] for i in feature_indices] self.FeatureCount = len(self.FeatureRecord) return bool(self.FeatureCount) @_add_method(otTables.DefaultLangSys, otTables.LangSys) def subset_features(self, feature_indices): if self.ReqFeatureIndex in feature_indices: self.ReqFeatureIndex = feature_indices.index(self.ReqFeatureIndex) else: self.ReqFeatureIndex = 65535 self.FeatureIndex = [f for f in self.FeatureIndex if f in feature_indices] # Now map them. self.FeatureIndex = [feature_indices.index(f) for f in self.FeatureIndex if f in feature_indices] self.FeatureCount = len(self.FeatureIndex) return bool(self.FeatureCount or self.ReqFeatureIndex != 65535) @_add_method(otTables.DefaultLangSys, otTables.LangSys) def collect_features(self): feature_indices = self.FeatureIndex[:] if self.ReqFeatureIndex != 65535: feature_indices.append(self.ReqFeatureIndex) return _uniq_sort(feature_indices) @_add_method(otTables.Script) def subset_features(self, feature_indices): if(self.DefaultLangSys and not self.DefaultLangSys.subset_features(feature_indices)): self.DefaultLangSys = None self.LangSysRecord = [l for l in self.LangSysRecord if l.LangSys.subset_features(feature_indices)] self.LangSysCount = len(self.LangSysRecord) return bool(self.LangSysCount or self.DefaultLangSys) @_add_method(otTables.Script) def collect_features(self): feature_indices = [l.LangSys.collect_features() for l in self.LangSysRecord] if self.DefaultLangSys: feature_indices.append(self.DefaultLangSys.collect_features()) return _uniq_sort(sum(feature_indices, [])) @_add_method(otTables.ScriptList) def subset_features(self, feature_indices): self.ScriptRecord = [s for s in self.ScriptRecord if s.Script.subset_features(feature_indices)] self.ScriptCount = len(self.ScriptRecord) return bool(self.ScriptCount) @_add_method(otTables.ScriptList) def collect_features(self): return _uniq_sort(sum((s.Script.collect_features() for s in self.ScriptRecord), [])) @_add_method(ttLib.getTableClass('GSUB')) def closure_glyphs(self, s): s.table = self.table if self.table.ScriptList: feature_indices = self.table.ScriptList.collect_features() else: feature_indices = [] if self.table.FeatureList: lookup_indices = self.table.FeatureList.collect_lookups(feature_indices) else: lookup_indices = [] if self.table.LookupList: while True: orig_glyphs = s.glyphs.copy() for i in lookup_indices: if i >= self.table.LookupList.LookupCount: continue if not self.table.LookupList.Lookup[i]: continue self.table.LookupList.Lookup[i].closure_glyphs(s) if orig_glyphs == s.glyphs: break del s.table @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def subset_glyphs(self, s): s.glyphs = s.glyphs_gsubed if self.table.LookupList: lookup_indices = self.table.LookupList.subset_glyphs(s) else: lookup_indices = [] self.subset_lookups(lookup_indices) self.prune_lookups() return True @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def subset_lookups(self, lookup_indices): """Retains specified lookups, then removes empty features, language systems, and scripts.""" if self.table.LookupList: self.table.LookupList.subset_lookups(lookup_indices) if self.table.FeatureList: feature_indices = self.table.FeatureList.subset_lookups(lookup_indices) else: feature_indices = [] if self.table.ScriptList: self.table.ScriptList.subset_features(feature_indices) @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def prune_lookups(self): "Remove unreferenced lookups" if self.table.ScriptList: feature_indices = self.table.ScriptList.collect_features() else: feature_indices = [] if self.table.FeatureList: lookup_indices = self.table.FeatureList.collect_lookups(feature_indices) else: lookup_indices = [] if self.table.LookupList: lookup_indices = self.table.LookupList.closure_lookups(lookup_indices) else: lookup_indices = [] self.subset_lookups(lookup_indices) @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def subset_feature_tags(self, feature_tags): if self.table.FeatureList: feature_indices = [i for i,f in enumerate(self.table.FeatureList.FeatureRecord) if f.FeatureTag in feature_tags] self.table.FeatureList.subset_features(feature_indices) else: feature_indices = [] if self.table.ScriptList: self.table.ScriptList.subset_features(feature_indices) @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def prune_features(self): "Remove unreferenced featurs" if self.table.ScriptList: feature_indices = self.table.ScriptList.collect_features() else: feature_indices = [] if self.table.FeatureList: self.table.FeatureList.subset_features(feature_indices) if self.table.ScriptList: self.table.ScriptList.subset_features(feature_indices) @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def prune_pre_subset(self, options): # Drop undesired features if '*' not in options.layout_features: self.subset_feature_tags(options.layout_features) # Drop unreferenced lookups self.prune_lookups() # Prune lookups themselves if self.table.LookupList: self.table.LookupList.prune_pre_subset(options); return True @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def remove_redundant_langsys(self): table = self.table if not table.ScriptList or not table.FeatureList: return features = table.FeatureList.FeatureRecord for s in table.ScriptList.ScriptRecord: d = s.Script.DefaultLangSys if not d: continue for lr in s.Script.LangSysRecord[:]: l = lr.LangSys # Compare d and l if len(d.FeatureIndex) != len(l.FeatureIndex): continue if (d.ReqFeatureIndex == 65535) != (l.ReqFeatureIndex == 65535): continue if d.ReqFeatureIndex != 65535: if features[d.ReqFeatureIndex] != features[l.ReqFeatureIndex]: continue for i in range(len(d.FeatureIndex)): if features[d.FeatureIndex[i]] != features[l.FeatureIndex[i]]: break else: # LangSys and default are equal; delete LangSys s.Script.LangSysRecord.remove(lr) @_add_method(ttLib.getTableClass('GSUB'), ttLib.getTableClass('GPOS')) def prune_post_subset(self, options): table = self.table # LookupList looks good. Just prune lookups themselves if table.LookupList: table.LookupList.prune_post_subset(options); # XXX Next two lines disabled because OTS is stupid and # doesn't like NULL offsetse here. #if not table.LookupList.Lookup: # table.LookupList = None if not table.LookupList: table.FeatureList = None if table.FeatureList: self.remove_redundant_langsys() # Remove unreferenced features self.prune_features() # XXX Next two lines disabled because OTS is stupid and # doesn't like NULL offsetse here. #if table.FeatureList and not table.FeatureList.FeatureRecord: # table.FeatureList = None # Never drop scripts themselves as them just being available # holds semantic significance. # XXX Next two lines disabled because OTS is stupid and # doesn't like NULL offsetse here. #if table.ScriptList and not table.ScriptList.ScriptRecord: # table.ScriptList = None return True @_add_method(ttLib.getTableClass('GDEF')) def subset_glyphs(self, s): glyphs = s.glyphs_gsubed table = self.table if table.LigCaretList: indices = table.LigCaretList.Coverage.subset(glyphs) table.LigCaretList.LigGlyph = [table.LigCaretList.LigGlyph[i] for i in indices] table.LigCaretList.LigGlyphCount = len(table.LigCaretList.LigGlyph) if table.MarkAttachClassDef: table.MarkAttachClassDef.classDefs = dict((g,v) for g,v in table.MarkAttachClassDef. classDefs.items() if g in glyphs) if table.GlyphClassDef: table.GlyphClassDef.classDefs = dict((g,v) for g,v in table.GlyphClassDef. classDefs.items() if g in glyphs) if table.AttachList: indices = table.AttachList.Coverage.subset(glyphs) GlyphCount = table.AttachList.GlyphCount table.AttachList.AttachPoint = [table.AttachList.AttachPoint[i] for i in indices if i < GlyphCount] table.AttachList.GlyphCount = len(table.AttachList.AttachPoint) if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef: for coverage in table.MarkGlyphSetsDef.Coverage: coverage.subset(glyphs) # TODO: The following is disabled. If enabling, we need to go fixup all # lookups that use MarkFilteringSet and map their set. #indices = table.MarkGlyphSetsDef.Coverage = [c for c in table.MarkGlyphSetsDef.Coverage if c.glyphs] return True @_add_method(ttLib.getTableClass('GDEF')) def prune_post_subset(self, options): table = self.table # XXX check these against OTS if table.LigCaretList and not table.LigCaretList.LigGlyphCount: table.LigCaretList = None if table.MarkAttachClassDef and not table.MarkAttachClassDef.classDefs: table.MarkAttachClassDef = None if table.GlyphClassDef and not table.GlyphClassDef.classDefs: table.GlyphClassDef = None if table.AttachList and not table.AttachList.GlyphCount: table.AttachList = None if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef and not table.MarkGlyphSetsDef.Coverage: table.MarkGlyphSetsDef = None if table.Version == 0x00010002/0x10000: table.Version = 1.0 return bool(table.LigCaretList or table.MarkAttachClassDef or table.GlyphClassDef or table.AttachList or (table.Version >= 0x00010002/0x10000 and table.MarkGlyphSetsDef)) @_add_method(ttLib.getTableClass('kern')) def prune_pre_subset(self, options): # Prune unknown kern table types self.kernTables = [t for t in self.kernTables if hasattr(t, 'kernTable')] return bool(self.kernTables) @_add_method(ttLib.getTableClass('kern')) def subset_glyphs(self, s): glyphs = s.glyphs_gsubed for t in self.kernTables: t.kernTable = dict(((a,b),v) for (a,b),v in t.kernTable.items() if a in glyphs and b in glyphs) self.kernTables = [t for t in self.kernTables if t.kernTable] return bool(self.kernTables) @_add_method(ttLib.getTableClass('vmtx')) def subset_glyphs(self, s): self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs) return bool(self.metrics) @_add_method(ttLib.getTableClass('hmtx')) def subset_glyphs(self, s): self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs) return True # Required table @_add_method(ttLib.getTableClass('hdmx')) def subset_glyphs(self, s): self.hdmx = dict((sz,dict((g,v) for g,v in l.items() if g in s.glyphs)) for sz,l in self.hdmx.items()) return bool(self.hdmx) @_add_method(ttLib.getTableClass('VORG')) def subset_glyphs(self, s): self.VOriginRecords = dict((g,v) for g,v in self.VOriginRecords.items() if g in s.glyphs) self.numVertOriginYMetrics = len(self.VOriginRecords) return True # Never drop; has default metrics @_add_method(ttLib.getTableClass('post')) def prune_pre_subset(self, options): if not options.glyph_names: self.formatType = 3.0 return True # Required table @_add_method(ttLib.getTableClass('post')) def subset_glyphs(self, s): self.extraNames = [] # This seems to do it return True # Required table @_add_method(ttLib.getTableModule('glyf').Glyph) def remapComponentsFast(self, indices): if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0: return # Not composite data = array.array("B", self.data) i = 10 more = 1 while more: flags =(data[i] << 8) | data[i+1] glyphID =(data[i+2] << 8) | data[i+3] # Remap glyphID = indices.index(glyphID) data[i+2] = glyphID >> 8 data[i+3] = glyphID & 0xFF i += 4 flags = int(flags) if flags & 0x0001: i += 4 # ARG_1_AND_2_ARE_WORDS else: i += 2 if flags & 0x0008: i += 2 # WE_HAVE_A_SCALE elif flags & 0x0040: i += 4 # WE_HAVE_AN_X_AND_Y_SCALE elif flags & 0x0080: i += 8 # WE_HAVE_A_TWO_BY_TWO more = flags & 0x0020 # MORE_COMPONENTS self.data = data.tostring() @_add_method(ttLib.getTableClass('glyf')) def closure_glyphs(self, s): decompose = s.glyphs while True: components = set() for g in decompose: if g not in self.glyphs: continue gl = self.glyphs[g] for c in gl.getComponentNames(self): if c not in s.glyphs: components.add(c) components = set(c for c in components if c not in s.glyphs) if not components: break decompose = components s.glyphs.update(components) @_add_method(ttLib.getTableClass('glyf')) def prune_pre_subset(self, options): if options.notdef_glyph and not options.notdef_outline: g = self[self.glyphOrder[0]] # Yay, easy! g.__dict__.clear() g.data = "" return True @_add_method(ttLib.getTableClass('glyf')) def subset_glyphs(self, s): self.glyphs = dict((g,v) for g,v in self.glyphs.items() if g in s.glyphs) indices = [i for i,g in enumerate(self.glyphOrder) if g in s.glyphs] for v in self.glyphs.values(): if hasattr(v, "data"): v.remapComponentsFast(indices) else: pass # No need self.glyphOrder = [g for g in self.glyphOrder if g in s.glyphs] # Don't drop empty 'glyf' tables, otherwise 'loca' doesn't get subset. return True @_add_method(ttLib.getTableClass('glyf')) def prune_post_subset(self, options): if not options.hinting: for v in self.glyphs.values(): v.removeHinting() return True @_add_method(ttLib.getTableClass('CFF ')) def prune_pre_subset(self, options): cff = self.cff # CFF table must have one font only cff.fontNames = cff.fontNames[:1] if options.notdef_glyph and not options.notdef_outline: for fontname in cff.keys(): font = cff[fontname] c,_ = font.CharStrings.getItemAndSelector('.notdef') # XXX we should preserve the glyph width c.bytecode = '\x0e' # endchar c.program = None return True # bool(cff.fontNames) @_add_method(ttLib.getTableClass('CFF ')) def subset_glyphs(self, s): cff = self.cff for fontname in cff.keys(): font = cff[fontname] cs = font.CharStrings # Load all glyphs for g in font.charset: if g not in s.glyphs: continue c,sel = cs.getItemAndSelector(g) if cs.charStringsAreIndexed: indices = [i for i,g in enumerate(font.charset) if g in s.glyphs] csi = cs.charStringsIndex csi.items = [csi.items[i] for i in indices] csi.count = len(csi.items) del csi.file, csi.offsets if hasattr(font, "FDSelect"): sel = font.FDSelect sel.format = None sel.gidArray = [sel.gidArray[i] for i in indices] cs.charStrings = dict((g,indices.index(v)) for g,v in cs.charStrings.items() if g in s.glyphs) else: cs.charStrings = dict((g,v) for g,v in cs.charStrings.items() if g in s.glyphs) font.charset = [g for g in font.charset if g in s.glyphs] font.numGlyphs = len(font.charset) return True # any(cff[fontname].numGlyphs for fontname in cff.keys()) @_add_method(psCharStrings.T2CharString) def subset_subroutines(self, subrs, gsubrs): p = self.program assert len(p) for i in range(1, len(p)): if p[i] == 'callsubr': assert isinstance(p[i-1], int) p[i-1] = subrs._used.index(p[i-1] + subrs._old_bias) - subrs._new_bias elif p[i] == 'callgsubr': assert isinstance(p[i-1], int) p[i-1] = gsubrs._used.index(p[i-1] + gsubrs._old_bias) - gsubrs._new_bias @_add_method(psCharStrings.T2CharString) def drop_hints(self): hints = self._hints if hints.has_hint: self.program = self.program[hints.last_hint:] if hasattr(self, 'width'): # Insert width back if needed if self.width != self.private.defaultWidthX: self.program.insert(0, self.width - self.private.nominalWidthX) if hints.has_hintmask: i = 0 p = self.program while i < len(p): if p[i] in ['hintmask', 'cntrmask']: assert i + 1 <= len(p) del p[i:i+2] continue i += 1 # TODO: we currently don't drop calls to "empty" subroutines. assert len(self.program) del self._hints class _MarkingT2Decompiler(psCharStrings.SimpleT2Decompiler): def __init__(self, localSubrs, globalSubrs): psCharStrings.SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs) for subrs in [localSubrs, globalSubrs]: if subrs and not hasattr(subrs, "_used"): subrs._used = set() def op_callsubr(self, index): self.localSubrs._used.add(self.operandStack[-1]+self.localBias) psCharStrings.SimpleT2Decompiler.op_callsubr(self, index) def op_callgsubr(self, index): self.globalSubrs._used.add(self.operandStack[-1]+self.globalBias) psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index) class _DehintingT2Decompiler(psCharStrings.SimpleT2Decompiler): class Hints(object): def __init__(self): # Whether calling this charstring produces any hint stems self.has_hint = False # Index to start at to drop all hints self.last_hint = 0 # Index up to which we know more hints are possible. Only # relevant if status is 0 or 1. self.last_checked = 0 # The status means: # 0: after dropping hints, this charstring is empty # 1: after dropping hints, there may be more hints continuing after this # 2: no more hints possible after this charstring self.status = 0 # Has hintmask instructions; not recursive self.has_hintmask = False pass def __init__(self, css, localSubrs, globalSubrs): self._css = css psCharStrings.SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs) def execute(self, charString): old_hints = charString._hints if hasattr(charString, '_hints') else None charString._hints = self.Hints() psCharStrings.SimpleT2Decompiler.execute(self, charString) hints = charString._hints if hints.has_hint or hints.has_hintmask: self._css.add(charString) if hints.status != 2: # Check from last_check, make sure we didn't have any operators. for i in range(hints.last_checked, len(charString.program) - 1): if isinstance(charString.program[i], str): hints.status = 2 break; else: hints.status = 1 # There's *something* here hints.last_checked = len(charString.program) if old_hints: assert hints.__dict__ == old_hints.__dict__ def op_callsubr(self, index): subr = self.localSubrs[self.operandStack[-1]+self.localBias] psCharStrings.SimpleT2Decompiler.op_callsubr(self, index) self.processSubr(index, subr) def op_callgsubr(self, index): subr = self.globalSubrs[self.operandStack[-1]+self.globalBias] psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index) self.processSubr(index, subr) def op_hstem(self, index): psCharStrings.SimpleT2Decompiler.op_hstem(self, index) self.processHint(index) def op_vstem(self, index): psCharStrings.SimpleT2Decompiler.op_vstem(self, index) self.processHint(index) def op_hstemhm(self, index): psCharStrings.SimpleT2Decompiler.op_hstemhm(self, index) self.processHint(index) def op_vstemhm(self, index): psCharStrings.SimpleT2Decompiler.op_vstemhm(self, index) self.processHint(index) def op_hintmask(self, index): psCharStrings.SimpleT2Decompiler.op_hintmask(self, index) self.processHintmask(index) def op_cntrmask(self, index): psCharStrings.SimpleT2Decompiler.op_cntrmask(self, index) self.processHintmask(index) def processHintmask(self, index): cs = self.callingStack[-1] hints = cs._hints hints.has_hintmask = True if hints.status != 2 and hints.has_hint: # Check from last_check, see if we may be an implicit vstem for i in range(hints.last_checked, index - 1): if isinstance(cs.program[i], str): hints.status = 2 break; if hints.status != 2: # We are an implicit vstem hints.last_hint = index + 1 hints.status = 0 hints.last_checked = index + 1 def processHint(self, index): cs = self.callingStack[-1] hints = cs._hints hints.has_hint = True hints.last_hint = index hints.last_checked = index def processSubr(self, index, subr): cs = self.callingStack[-1] hints = cs._hints subr_hints = subr._hints if subr_hints.has_hint: if hints.status != 2: hints.has_hint = True hints.last_checked = index hints.status = subr_hints.status # Decide where to chop off from if subr_hints.status == 0: hints.last_hint = index else: hints.last_hint = index - 2 # Leave the subr call in else: # In my understanding, this is a font bug. Ie. it has hint stems # *after* path construction. I've seen this in widespread fonts. # Best to ignore the hints I suppose... pass #assert 0 else: hints.status = max(hints.status, subr_hints.status) if hints.status != 2: # Check from last_check, make sure we didn't have # any operators. for i in range(hints.last_checked, index - 1): if isinstance(cs.program[i], str): hints.status = 2 break; hints.last_checked = index if hints.status != 2: # Decide where to chop off from if subr_hints.status == 0: hints.last_hint = index else: hints.last_hint = index - 2 # Leave the subr call in @_add_method(ttLib.getTableClass('CFF ')) def prune_post_subset(self, options): cff = self.cff for fontname in cff.keys(): font = cff[fontname] cs = font.CharStrings # # Drop unused FontDictionaries # if hasattr(font, "FDSelect"): sel = font.FDSelect indices = _uniq_sort(sel.gidArray) sel.gidArray = [indices.index (ss) for ss in sel.gidArray] arr = font.FDArray arr.items = [arr[i] for i in indices] arr.count = len(arr.items) del arr.file, arr.offsets # # Drop hints if not needed # if not options.hinting: # # This can be tricky, but doesn't have to. What we do is: # # - Run all used glyph charstrings and recurse into subroutines, # - For each charstring (including subroutines), if it has any # of the hint stem operators, we mark it as such. Upon returning, # for each charstring we note all the subroutine calls it makes # that (recursively) contain a stem, # - Dropping hinting then consists of the following two ops: # * Drop the piece of the program in each charstring before the # last call to a stem op or a stem-calling subroutine, # * Drop all hintmask operations. # - It's trickier... A hintmask right after hints and a few numbers # will act as an implicit vstemhm. As such, we track whether # we have seen any non-hint operators so far and do the right # thing, recursively... Good luck understanding that :( # css = set() for g in font.charset: c,sel = cs.getItemAndSelector(g) # Make sure it's decompiled. We want our "decompiler" to walk # the program, not the bytecode. c.draw(basePen.NullPen()) subrs = getattr(c.private, "Subrs", []) decompiler = _DehintingT2Decompiler(css, subrs, c.globalSubrs) decompiler.execute(c) for charstring in css: charstring.drop_hints() # Drop font-wide hinting values all_privs = [] if hasattr(font, 'FDSelect'): all_privs.extend(fd.Private for fd in font.FDArray) else: all_privs.append(font.Private) for priv in all_privs: for k in ['BlueValues', 'OtherBlues', 'FamilyBlues', 'FamilyOtherBlues', 'BlueScale', 'BlueShift', 'BlueFuzz', 'StemSnapH', 'StemSnapV', 'StdHW', 'StdVW']: if hasattr(priv, k): setattr(priv, k, None) # # Renumber subroutines to remove unused ones # # Mark all used subroutines for g in font.charset: c,sel = cs.getItemAndSelector(g) subrs = getattr(c.private, "Subrs", []) decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs) decompiler.execute(c) all_subrs = [font.GlobalSubrs] if hasattr(font, 'FDSelect'): all_subrs.extend(fd.Private.Subrs for fd in font.FDArray if hasattr(fd.Private, 'Subrs') and fd.Private.Subrs) elif hasattr(font.Private, 'Subrs') and font.Private.Subrs: all_subrs.append(font.Private.Subrs) subrs = set(subrs) # Remove duplicates # Prepare for subrs in all_subrs: if not hasattr(subrs, '_used'): subrs._used = set() subrs._used = _uniq_sort(subrs._used) subrs._old_bias = psCharStrings.calcSubrBias(subrs) subrs._new_bias = psCharStrings.calcSubrBias(subrs._used) # Renumber glyph charstrings for g in font.charset: c,sel = cs.getItemAndSelector(g) subrs = getattr(c.private, "Subrs", []) c.subset_subroutines (subrs, font.GlobalSubrs) # Renumber subroutines themselves for subrs in all_subrs: if subrs == font.GlobalSubrs: if not hasattr(font, 'FDSelect') and hasattr(font.Private, 'Subrs'): local_subrs = font.Private.Subrs else: local_subrs = [] else: local_subrs = subrs subrs.items = [subrs.items[i] for i in subrs._used] subrs.count = len(subrs.items) del subrs.file if hasattr(subrs, 'offsets'): del subrs.offsets for i in range (subrs.count): subrs[i].subset_subroutines (local_subrs, font.GlobalSubrs) # Cleanup for subrs in all_subrs: del subrs._used, subrs._old_bias, subrs._new_bias return True @_add_method(ttLib.getTableClass('cmap')) def closure_glyphs(self, s): tables = [t for t in self.tables if t.isUnicode()] for u in s.unicodes_requested: found = False for table in tables: if table.format == 14: for l in table.uvsDict.values(): # TODO(behdad) Speed this up! gids = [g for uc,g in l if u == uc and g is not None] s.glyphs.update(gids) # Intentionally not setting found=True here. else: if u in table.cmap: s.glyphs.add(table.cmap[u]) found = True if not found: s.log("No default glyph for Unicode %04X found." % u) @_add_method(ttLib.getTableClass('cmap')) def prune_pre_subset(self, options): if not options.legacy_cmap: # Drop non-Unicode / non-Symbol cmaps self.tables = [t for t in self.tables if t.isUnicode() or t.isSymbol()] if not options.symbol_cmap: self.tables = [t for t in self.tables if not t.isSymbol()] # TODO(behdad) Only keep one subtable? # For now, drop format=0 which can't be subset_glyphs easily? self.tables = [t for t in self.tables if t.format != 0] self.numSubTables = len(self.tables) return True # Required table @_add_method(ttLib.getTableClass('cmap')) def subset_glyphs(self, s): s.glyphs = s.glyphs_cmaped for t in self.tables: # For reasons I don't understand I need this here # to force decompilation of the cmap format 14. try: getattr(t, "asdf") except AttributeError: pass if t.format == 14: # TODO(behdad) We drop all the default-UVS mappings for glyphs_requested. # I don't think we care about that... t.uvsDict = dict((v,[(u,g) for u,g in l if g in s.glyphs or u in s.unicodes_requested]) for v,l in t.uvsDict.items()) t.uvsDict = dict((v,l) for v,l in t.uvsDict.items() if l) elif t.isUnicode(): t.cmap = dict((u,g) for u,g in t.cmap.items() if g in s.glyphs_requested or u in s.unicodes_requested) else: t.cmap = dict((u,g) for u,g in t.cmap.items() if g in s.glyphs_requested) self.tables = [t for t in self.tables if (t.cmap if t.format != 14 else t.uvsDict)] self.numSubTables = len(self.tables) # TODO(behdad) Convert formats when needed. # In particular, if we have a format=12 without non-BMP # characters, either drop format=12 one or convert it # to format=4 if there's not one. return True # Required table @_add_method(ttLib.getTableClass('name')) def prune_pre_subset(self, options): if '*' not in options.name_IDs: self.names = [n for n in self.names if n.nameID in options.name_IDs] if not options.name_legacy: self.names = [n for n in self.names if n.isUnicode()] # TODO(behdad) Option to keep only one platform's if '*' not in options.name_languages: # TODO(behdad) This is Windows-platform specific! self.names = [n for n in self.names if n.langID in options.name_languages] return True # Required table # TODO(behdad) OS/2 ulUnicodeRange / ulCodePageRange? # TODO(behdad) Drop AAT tables. # TODO(behdad) Drop unneeded GSUB/GPOS Script/LangSys entries. # TODO(behdad) Drop empty GSUB/GPOS, and GDEF if no GSUB/GPOS left # TODO(behdad) Drop GDEF subitems if unused by lookups # TODO(behdad) Avoid recursing too much (in GSUB/GPOS and in CFF) # TODO(behdad) Text direction considerations. # TODO(behdad) Text script / language considerations. # TODO(behdad) Optionally drop 'kern' table if GPOS available # TODO(behdad) Implement --unicode='*' to choose all cmap'ed # TODO(behdad) Drop old-spec Indic scripts class Options(object): class UnknownOptionError(Exception): pass _drop_tables_default = ['BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC', 'EBSC', 'SVG ', 'PCLT', 'LTSH'] _drop_tables_default += ['Feat', 'Glat', 'Gloc', 'Silf', 'Sill'] # Graphite _drop_tables_default += ['CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL'] # Color _no_subset_tables_default = ['gasp', 'head', 'hhea', 'maxp', 'vhea', 'OS/2', 'loca', 'name', 'cvt ', 'fpgm', 'prep'] _hinting_tables_default = ['cvt ', 'fpgm', 'prep', 'hdmx', 'VDMX'] # Based on HarfBuzz shapers _layout_features_groups = { # Default shaper 'common': ['ccmp', 'liga', 'locl', 'mark', 'mkmk', 'rlig'], 'horizontal': ['calt', 'clig', 'curs', 'kern', 'rclt'], 'vertical': ['valt', 'vert', 'vkrn', 'vpal', 'vrt2'], 'ltr': ['ltra', 'ltrm'], 'rtl': ['rtla', 'rtlm'], # Complex shapers 'arabic': ['init', 'medi', 'fina', 'isol', 'med2', 'fin2', 'fin3', 'cswh', 'mset'], 'hangul': ['ljmo', 'vjmo', 'tjmo'], 'tibetan': ['abvs', 'blws', 'abvm', 'blwm'], 'indic': ['nukt', 'akhn', 'rphf', 'rkrf', 'pref', 'blwf', 'half', 'abvf', 'pstf', 'cfar', 'vatu', 'cjct', 'init', 'pres', 'abvs', 'blws', 'psts', 'haln', 'dist', 'abvm', 'blwm'], } _layout_features_default = _uniq_sort(sum( iter(_layout_features_groups.values()), [])) drop_tables = _drop_tables_default no_subset_tables = _no_subset_tables_default hinting_tables = _hinting_tables_default layout_features = _layout_features_default hinting = True glyph_names = False legacy_cmap = False symbol_cmap = False name_IDs = [1, 2] # Family and Style name_legacy = False name_languages = [0x0409] # English notdef_glyph = True # gid0 for TrueType / .notdef for CFF notdef_outline = False # No need for notdef to have an outline really recommended_glyphs = False # gid1, gid2, gid3 for TrueType recalc_bounds = False # Recalculate font bounding boxes recalc_timestamp = False # Recalculate font modified timestamp canonical_order = False # Order tables as recommended flavor = None # May be 'woff' def __init__(self, **kwargs): self.set(**kwargs) def set(self, **kwargs): for k,v in kwargs.items(): if not hasattr(self, k): raise self.UnknownOptionError("Unknown option '%s'" % k) setattr(self, k, v) def parse_opts(self, argv, ignore_unknown=False): ret = [] opts = {} for a in argv: orig_a = a if not a.startswith('--'): ret.append(a) continue a = a[2:] i = a.find('=') op = '=' if i == -1: if a.startswith("no-"): k = a[3:] v = False else: k = a v = True else: k = a[:i] if k[-1] in "-+": op = k[-1]+'=' # Ops is '-=' or '+=' now. k = k[:-1] v = a[i+1:] k = k.replace('-', '_') if not hasattr(self, k): if ignore_unknown is True or k in ignore_unknown: ret.append(orig_a) continue else: raise self.UnknownOptionError("Unknown option '%s'" % a) ov = getattr(self, k) if isinstance(ov, bool): v = bool(v) elif isinstance(ov, int): v = int(v) elif isinstance(ov, list): vv = v.split(',') if vv == ['']: vv = [] vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv] if op == '=': v = vv elif op == '+=': v = ov v.extend(vv) elif op == '-=': v = ov for x in vv: if x in v: v.remove(x) else: assert False opts[k] = v self.set(**opts) return ret class Subsetter(object): def __init__(self, options=None, log=None): if not log: log = Logger() if not options: options = Options() self.options = options self.log = log self.unicodes_requested = set() self.glyphs_requested = set() self.glyphs = set() def populate(self, glyphs=[], unicodes=[], text=""): self.unicodes_requested.update(unicodes) if isinstance(text, bytes): text = text.decode("utf8") for u in text: self.unicodes_requested.add(ord(u)) self.glyphs_requested.update(glyphs) self.glyphs.update(glyphs) def _prune_pre_subset(self, font): for tag in font.keys(): if tag == 'GlyphOrder': continue if(tag in self.options.drop_tables or (tag in self.options.hinting_tables and not self.options.hinting)): self.log(tag, "dropped") del font[tag] continue clazz = ttLib.getTableClass(tag) if hasattr(clazz, 'prune_pre_subset'): table = font[tag] self.log.lapse("load '%s'" % tag) retain = table.prune_pre_subset(self.options) self.log.lapse("prune '%s'" % tag) if not retain: self.log(tag, "pruned to empty; dropped") del font[tag] continue else: self.log(tag, "pruned") def _closure_glyphs(self, font): realGlyphs = set(font.getGlyphOrder()) self.glyphs = self.glyphs_requested.copy() if 'cmap' in font: font['cmap'].closure_glyphs(self) self.glyphs.intersection_update(realGlyphs) self.glyphs_cmaped = self.glyphs if self.options.notdef_glyph: if 'glyf' in font: self.glyphs.add(font.getGlyphName(0)) self.log("Added gid0 to subset") else: self.glyphs.add('.notdef') self.log("Added .notdef to subset") if self.options.recommended_glyphs: if 'glyf' in font: for i in range(min(4, len(font.getGlyphOrder()))): self.glyphs.add(font.getGlyphName(i)) self.log("Added first four glyphs to subset") if 'GSUB' in font: self.log("Closing glyph list over 'GSUB': %d glyphs before" % len(self.glyphs)) self.log.glyphs(self.glyphs, font=font) font['GSUB'].closure_glyphs(self) self.glyphs.intersection_update(realGlyphs) self.log("Closed glyph list over 'GSUB': %d glyphs after" % len(self.glyphs)) self.log.glyphs(self.glyphs, font=font) self.log.lapse("close glyph list over 'GSUB'") self.glyphs_gsubed = self.glyphs.copy() if 'glyf' in font: self.log("Closing glyph list over 'glyf': %d glyphs before" % len(self.glyphs)) self.log.glyphs(self.glyphs, font=font) font['glyf'].closure_glyphs(self) self.glyphs.intersection_update(realGlyphs) self.log("Closed glyph list over 'glyf': %d glyphs after" % len(self.glyphs)) self.log.glyphs(self.glyphs, font=font) self.log.lapse("close glyph list over 'glyf'") self.glyphs_glyfed = self.glyphs.copy() self.glyphs_all = self.glyphs.copy() self.log("Retaining %d glyphs: " % len(self.glyphs_all)) del self.glyphs def _subset_glyphs(self, font): for tag in font.keys(): if tag == 'GlyphOrder': continue clazz = ttLib.getTableClass(tag) if tag in self.options.no_subset_tables: self.log(tag, "subsetting not needed") elif hasattr(clazz, 'subset_glyphs'): table = font[tag] self.glyphs = self.glyphs_all retain = table.subset_glyphs(self) del self.glyphs self.log.lapse("subset '%s'" % tag) if not retain: self.log(tag, "subsetted to empty; dropped") del font[tag] else: self.log(tag, "subsetted") else: self.log(tag, "NOT subset; don't know how to subset; dropped") del font[tag] glyphOrder = font.getGlyphOrder() glyphOrder = [g for g in glyphOrder if g in self.glyphs_all] font.setGlyphOrder(glyphOrder) font._buildReverseGlyphOrderDict() self.log.lapse("subset GlyphOrder") def _prune_post_subset(self, font): for tag in font.keys(): if tag == 'GlyphOrder': continue clazz = ttLib.getTableClass(tag) if hasattr(clazz, 'prune_post_subset'): table = font[tag] retain = table.prune_post_subset(self.options) self.log.lapse("prune '%s'" % tag) if not retain: self.log(tag, "pruned to empty; dropped") del font[tag] else: self.log(tag, "pruned") def subset(self, font): self._prune_pre_subset(font) self._closure_glyphs(font) self._subset_glyphs(font) self._prune_post_subset(font) class Logger(object): def __init__(self, verbose=False, xml=False, timing=False): self.verbose = verbose self.xml = xml self.timing = timing self.last_time = self.start_time = time.time() def parse_opts(self, argv): argv = argv[:] for v in ['verbose', 'xml', 'timing']: if "--"+v in argv: setattr(self, v, True) argv.remove("--"+v) return argv def __call__(self, *things): if not self.verbose: return print(' '.join(str(x) for x in things)) def lapse(self, *things): if not self.timing: return new_time = time.time() print("Took %0.3fs to %s" %(new_time - self.last_time, ' '.join(str(x) for x in things))) self.last_time = new_time def glyphs(self, glyphs, font=None): if not self.verbose: return self("Names: ", sorted(glyphs)) if font: reverseGlyphMap = font.getReverseGlyphMap() self("Gids : ", sorted(reverseGlyphMap[g] for g in glyphs)) def font(self, font, file=sys.stdout): if not self.xml: return from fontTools.misc import xmlWriter writer = xmlWriter.XMLWriter(file) for tag in font.keys(): writer.begintag(tag) writer.newline() font[tag].toXML(writer, font) writer.endtag(tag) writer.newline() def load_font(fontFile, options, allowVID=False, checkChecksums=False, dontLoadGlyphNames=False, lazy=True): font = ttLib.TTFont(fontFile, allowVID=allowVID, checkChecksums=checkChecksums, recalcBBoxes=options.recalc_bounds, recalcTimestamp=options.recalc_timestamp, lazy=lazy) # Hack: # # If we don't need glyph names, change 'post' class to not try to # load them. It avoid lots of headache with broken fonts as well # as loading time. # # Ideally ttLib should provide a way to ask it to skip loading # glyph names. But it currently doesn't provide such a thing. # if dontLoadGlyphNames: post = ttLib.getTableClass('post') saved = post.decode_format_2_0 post.decode_format_2_0 = post.decode_format_3_0 f = font['post'] if f.formatType == 2.0: f.formatType = 3.0 post.decode_format_2_0 = saved return font def save_font(font, outfile, options): if options.flavor and not hasattr(font, 'flavor'): raise Exception("fonttools version does not support flavors.") font.flavor = options.flavor font.save(outfile, reorderTables=options.canonical_order) def main(args): log = Logger() args = log.parse_opts(args) options = Options() args = options.parse_opts(args, ignore_unknown=['text']) if len(args) < 2: print("usage: pyftsubset font-file glyph... [--text=ABC]... [--option=value]...", file=sys.stderr) sys.exit(1) fontfile = args[0] args = args[1:] dontLoadGlyphNames =(not options.glyph_names and all(any(g.startswith(p) for p in ['gid', 'glyph', 'uni', 'U+']) for g in args)) font = load_font(fontfile, options, dontLoadGlyphNames=dontLoadGlyphNames) log.lapse("load font") subsetter = Subsetter(options=options, log=log) names = font.getGlyphNames() log.lapse("loading glyph names") glyphs = [] unicodes = [] text = "" for g in args: if g == '*': glyphs.extend(font.getGlyphOrder()) continue if g in names: glyphs.append(g) continue if g.startswith('--text='): text += g[7:] continue if g.startswith('uni') or g.startswith('U+'): if g.startswith('uni') and len(g) > 3: g = g[3:] elif g.startswith('U+') and len(g) > 2: g = g[2:] u = int(g, 16) unicodes.append(u) continue if g.startswith('gid') or g.startswith('glyph'): if g.startswith('gid') and len(g) > 3: g = g[3:] elif g.startswith('glyph') and len(g) > 5: g = g[5:] try: glyphs.append(font.getGlyphName(int(g), requireReal=True)) except ValueError: raise Exception("Invalid glyph identifier: %s" % g) continue raise Exception("Invalid glyph identifier: %s" % g) log.lapse("compile glyph list") log("Unicodes:", unicodes) log("Glyphs:", glyphs) subsetter.populate(glyphs=glyphs, unicodes=unicodes, text=text) subsetter.subset(font) outfile = fontfile + '.subset' save_font (font, outfile, options) log.lapse("compile and save font") log.last_time = log.start_time log.lapse("make one with everything(TOTAL TIME)") if log.verbose: import os log("Input font: %d bytes" % os.path.getsize(fontfile)) log("Subset font: %d bytes" % os.path.getsize(outfile)) log.font(font) font.close() __all__ = [ 'Options', 'Subsetter', 'Logger', 'load_font', 'save_font', 'main' ] if __name__ == '__main__': main(sys.argv[1:])