From be8d6e29d5c6cd99446e4c50ef3eee989422b5c3 Mon Sep 17 00:00:00 2001 From: Cosimo Lupo Date: Wed, 13 Oct 2021 14:47:41 +0200 Subject: [PATCH 1/4] SVG: remove old deprecated version1 and embedded colorPalettes Fixes https://github.com/fonttools/fonttools/issues/2426 --- Lib/fontTools/ttLib/tables/S_V_G_.py | 282 +++------------------------ 1 file changed, 24 insertions(+), 258 deletions(-) diff --git a/Lib/fontTools/ttLib/tables/S_V_G_.py b/Lib/fontTools/ttLib/tables/S_V_G_.py index a59cc86594..5b71fee016 100644 --- a/Lib/fontTools/ttLib/tables/S_V_G_.py +++ b/Lib/fontTools/ttLib/tables/S_V_G_.py @@ -1,26 +1,6 @@ -from fontTools.misc.textTools import bytesjoin, strjoin, tobytes, tostr -from fontTools.misc import sstruct -from . import DefaultTable -try: - import xml.etree.cElementTree as ET -except ImportError: - import xml.etree.ElementTree as ET -from io import BytesIO -import struct -import logging - - -log = logging.getLogger(__name__) +"""Compiles/decompiles SVG table. - -__doc__=""" -Compiles/decompiles version 0 and 1 SVG tables from/to XML. - -Version 1 is the first SVG definition, implemented in Mozilla before Aug 2013, now deprecated. -This module will decompile this correctly, but will compile a version 1 table -only if you add the secret element "" to the SVG element in the TTF file. - -Version 0 is the joint Adobe-Mozilla proposal, which supports color palettes. +https://docs.microsoft.com/en-us/typography/opentype/spec/svg The XML format is: @@ -31,53 +11,29 @@ <complete SVG doc> ]] </svgDoc> - - <colorPalettes> - <colorParamUINameID>n</colorParamUINameID> - ... - <colorParamUINameID>m</colorParamUINameID> - <colorPalette uiNameID="n"> - <colorRecord red="<int>" green="<int>" blue="<int>" alpha="<int>" /> - ... - <colorRecord red="<int>" green="<int>" blue="<int>" alpha="<int>" /> - </colorPalette> - ... - <colorPalette uiNameID="m"> - <colorRecord red="<int> green="<int>" blue="<int>" alpha="<int>" /> - ... - <colorRecord red=<int>" green="<int>" blue="<int>" alpha="<int>" /> - </colorPalette> - </colorPalettes> </SVG> +""" -Color values must be less than 256. +from fontTools.misc.textTools import bytesjoin, strjoin, tobytes, tostr +from fontTools.misc import sstruct +from . import DefaultTable +from io import BytesIO +import struct +import logging -The number of color records in each </colorPalette> must be the same as -the number of <colorParamUINameID> elements. -""" +log = logging.getLogger(__name__) -XML = ET.XML -XMLElement = ET.Element -xmlToString = ET.tostring SVG_format_0 = """ > # big endian version: H offsetToSVGDocIndex: L - offsetToColorPalettes: L + reserved: L """ SVG_format_0Size = sstruct.calcsize(SVG_format_0) -SVG_format_1 = """ - > # big endian - version: H - numIndicies: H -""" - -SVG_format_1Size = sstruct.calcsize(SVG_format_1) - doc_index_entry_format_0 = """ > # big endian startGlyphID: H @@ -88,84 +44,26 @@ doc_index_entry_format_0Size = sstruct.calcsize(doc_index_entry_format_0) -colorRecord_format_0 = """ - red: B - green: B - blue: B - alpha: B -""" class table_S_V_G_(DefaultTable.DefaultTable): - def __init__(self, tag=None): - DefaultTable.DefaultTable.__init__(self, tag) - self.colorPalettes = None - def decompile(self, data, ttFont): - self.docList = None - self.colorPalettes = None - pos = 0 - self.version = struct.unpack(">H", data[pos:pos+2])[0] - - if self.version == 1: - # This is pre-standardization version of the table; and obsolete. But we decompile it for now. - # https://wiki.mozilla.org/SVGOpenTypeFonts - self.decompile_format_1(data, ttFont) - else: - if self.version != 0: - log.warning( - "Unknown SVG table version '%s'. Decompiling as version 0.", self.version) - # This is the standardized version of the table; and current. - # https://www.microsoft.com/typography/otspec/svg.htm - self.decompile_format_0(data, ttFont) - - def decompile_format_0(self, data, ttFont): - dummy, data2 = sstruct.unpack2(SVG_format_0, data, self) + self.docList = [] + # Version 0 is the standardized version of the table; and current. + # https://www.microsoft.com/typography/otspec/svg.htm + sstruct.unpack(SVG_format_0, data[:SVG_format_0Size], self) + if self.version != 0: + log.warning( + "Unknown SVG table version '%s'. Decompiling as version 0.", self.version) # read in SVG Documents Index - self.decompileEntryList(data) - - # read in colorPalettes table. - self.colorPalettes = colorPalettes = ColorPalettes() - pos = self.offsetToColorPalettes - if pos > 0: - colorPalettes.numColorParams = numColorParams = struct.unpack(">H", data[pos:pos+2])[0] - if numColorParams > 0: - colorPalettes.colorParamUINameIDs = colorParamUINameIDs = [] - pos = pos + 2 - for i in range(numColorParams): - nameID = struct.unpack(">H", data[pos:pos+2])[0] - colorParamUINameIDs.append(nameID) - pos = pos + 2 - - colorPalettes.numColorPalettes = numColorPalettes = struct.unpack(">H", data[pos:pos+2])[0] - pos = pos + 2 - if numColorPalettes > 0: - colorPalettes.colorPaletteList = colorPaletteList = [] - for i in range(numColorPalettes): - colorPalette = ColorPalette() - colorPaletteList.append(colorPalette) - colorPalette.uiNameID = struct.unpack(">H", data[pos:pos+2])[0] - pos = pos + 2 - colorPalette.paletteColors = paletteColors = [] - for j in range(numColorParams): - colorRecord, colorPaletteData = sstruct.unpack2(colorRecord_format_0, data[pos:], ColorRecord()) - paletteColors.append(colorRecord) - pos += 4 - - def decompile_format_1(self, data, ttFont): - self.offsetToSVGDocIndex = 2 - self.decompileEntryList(data) - - def decompileEntryList(self, data): # data starts with the first entry of the entry list. pos = subTableStart = self.offsetToSVGDocIndex - self.numEntries = numEntries = struct.unpack(">H", data[pos:pos+2])[0] + self.numEntries = struct.unpack(">H", data[pos:pos+2])[0] pos += 2 if self.numEntries > 0: data2 = data[pos:] - self.docList = [] - self.entries = entries = [] + entries = [] for i in range(self.numEntries): docIndexEntry, data2 = sstruct.unpack2(doc_index_entry_format_0, data2, DocumentIndexEntry()) entries.append(docIndexEntry) @@ -185,13 +83,6 @@ def decompileEntryList(self, data): self.docList.append( [doc, entry.startGlyphID, entry.endGlyphID] ) def compile(self, ttFont): - if hasattr(self, "version1"): - data = self.compileFormat1(ttFont) - else: - data = self.compileFormat0(ttFont) - return data - - def compileFormat0(self, ttFont): version = 0 offsetToSVGDocIndex = SVG_format_0Size # I start the SVGDocIndex right after the header. # get SGVDoc info. @@ -221,54 +112,12 @@ def compileFormat0(self, ttFont): entryList.extend(docList) svgDocData = bytesjoin(entryList) - # get colorpalette info. - if self.colorPalettes is None: - offsetToColorPalettes = 0 - palettesData = "" - else: - offsetToColorPalettes = SVG_format_0Size + len(svgDocData) - dataList = [] - numColorParams = len(self.colorPalettes.colorParamUINameIDs) - datum = struct.pack(">H", numColorParams) - dataList.append(datum) - for uiNameId in self.colorPalettes.colorParamUINameIDs: - datum = struct.pack(">H", uiNameId) - dataList.append(datum) - numColorPalettes = len(self.colorPalettes.colorPaletteList) - datum = struct.pack(">H", numColorPalettes) - dataList.append(datum) - for colorPalette in self.colorPalettes.colorPaletteList: - datum = struct.pack(">H", colorPalette.uiNameID) - dataList.append(datum) - for colorRecord in colorPalette.paletteColors: - data = struct.pack(">BBBB", colorRecord.red, colorRecord.green, colorRecord.blue, colorRecord.alpha) - dataList.append(data) - palettesData = bytesjoin(dataList) - - header = struct.pack(">HLL", version, offsetToSVGDocIndex, offsetToColorPalettes) - data = [header, svgDocData, palettesData] + reserved = 0 + header = struct.pack(">HLL", version, offsetToSVGDocIndex, reserved) + data = [header, svgDocData] data = bytesjoin(data) return data - def compileFormat1(self, ttFont): - version = 1 - numEntries = len(self.docList) - header = struct.pack(">HH", version, numEntries) - dataList = [header] - docList = [] - curOffset = SVG_format_1Size + doc_index_entry_format_0Size*numEntries - for doc, startGlyphID, endGlyphID in self.docList: - docOffset = curOffset - docBytes = tobytes(doc, encoding="utf_8") - docLength = len(docBytes) - curOffset += docLength - entry = struct.pack(">HHLL", startGlyphID, endGlyphID, docOffset, docLength) - dataList.append(entry) - docList.append(docBytes) - dataList.extend(docList) - data = bytesjoin(dataList) - return data - def toXML(self, writer, ttFont): writer.newline() for doc, startGID, endGID in self.docList: @@ -279,33 +128,6 @@ def toXML(self, writer, ttFont): writer.endtag("svgDoc") writer.newline() - if (self.colorPalettes is not None) and (self.colorPalettes.numColorParams is not None): - writer.begintag("colorPalettes") - writer.newline() - for uiNameID in self.colorPalettes.colorParamUINameIDs: - writer.begintag("colorParamUINameID") - writer._writeraw(str(uiNameID)) - writer.endtag("colorParamUINameID") - writer.newline() - for colorPalette in self.colorPalettes.colorPaletteList: - writer.begintag("colorPalette", [("uiNameID", str(colorPalette.uiNameID))]) - writer.newline() - for colorRecord in colorPalette.paletteColors: - colorAttributes = [ - ("red", hex(colorRecord.red)), - ("green", hex(colorRecord.green)), - ("blue", hex(colorRecord.blue)), - ("alpha", hex(colorRecord.alpha)), - ] - writer.begintag("colorRecord", colorAttributes) - writer.endtag("colorRecord") - writer.newline() - writer.endtag("colorPalette") - writer.newline() - - writer.endtag("colorPalettes") - writer.newline() - def fromXML(self, name, attrs, content, ttFont): if name == "svgDoc": if not hasattr(self, "docList"): @@ -315,14 +137,10 @@ def fromXML(self, name, attrs, content, ttFont): startGID = int(attrs["startGlyphID"]) endGID = int(attrs["endGlyphID"]) self.docList.append( [doc, startGID, endGID] ) - elif name == "colorPalettes": - self.colorPalettes = ColorPalettes() - self.colorPalettes.fromXML(name, attrs, content, ttFont) - if self.colorPalettes.numColorParams == 0: - self.colorPalettes = None else: log.warning("Unknown %s %s", name, content) + class DocumentIndexEntry(object): def __init__(self): self.startGlyphID = None # USHORT @@ -332,55 +150,3 @@ def __init__(self): def __repr__(self): return "startGlyphID: %s, endGlyphID: %s, svgDocOffset: %s, svgDocLength: %s" % (self.startGlyphID, self.endGlyphID, self.svgDocOffset, self.svgDocLength) - -class ColorPalettes(object): - def __init__(self): - self.numColorParams = None # USHORT - self.colorParamUINameIDs = [] # list of name table name ID values that provide UI description of each color palette. - self.numColorPalettes = None # USHORT - self.colorPaletteList = [] # list of ColorPalette records - - def fromXML(self, name, attrs, content, ttFont): - for element in content: - if not isinstance(element, tuple): - continue - name, attrib, content = element - if name == "colorParamUINameID": - uiNameID = int(content[0]) - self.colorParamUINameIDs.append(uiNameID) - elif name == "colorPalette": - colorPalette = ColorPalette() - self.colorPaletteList.append(colorPalette) - colorPalette.fromXML(name, attrib, content, ttFont) - - self.numColorParams = len(self.colorParamUINameIDs) - self.numColorPalettes = len(self.colorPaletteList) - for colorPalette in self.colorPaletteList: - if len(colorPalette.paletteColors) != self.numColorParams: - raise ValueError("Number of color records in a colorPalette ('%s') does not match the number of colorParamUINameIDs elements ('%s')." % (len(colorPalette.paletteColors), self.numColorParams)) - -class ColorPalette(object): - def __init__(self): - self.uiNameID = None # USHORT. name table ID that describes user interface strings associated with this color palette. - self.paletteColors = [] # list of ColorRecords - - def fromXML(self, name, attrs, content, ttFont): - self.uiNameID = int(attrs["uiNameID"]) - for element in content: - if isinstance(element, type("")): - continue - name, attrib, content = element - if name == "colorRecord": - colorRecord = ColorRecord() - self.paletteColors.append(colorRecord) - colorRecord.red = eval(attrib["red"]) - colorRecord.green = eval(attrib["green"]) - colorRecord.blue = eval(attrib["blue"]) - colorRecord.alpha = eval(attrib["alpha"]) - -class ColorRecord(object): - def __init__(self): - self.red = 255 # all are one byte values. - self.green = 255 - self.blue = 255 - self.alpha = 255 From 2967f18e357aec85abdc253c67e4ef082b9cc381 Mon Sep 17 00:00:00 2001 From: Cosimo Lupo <clupo@google.com> Date: Wed, 13 Oct 2021 14:50:08 +0200 Subject: [PATCH 2/4] SVG: on compile reuse offsets when doc bytes are same https://github.com/fonttools/fonttools/issues/534#issuecomment-934528761 --- Lib/fontTools/ttLib/tables/S_V_G_.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/Lib/fontTools/ttLib/tables/S_V_G_.py b/Lib/fontTools/ttLib/tables/S_V_G_.py index 5b71fee016..1c3f63db65 100644 --- a/Lib/fontTools/ttLib/tables/S_V_G_.py +++ b/Lib/fontTools/ttLib/tables/S_V_G_.py @@ -92,8 +92,8 @@ def compile(self, ttFont): datum = struct.pack(">H",numEntries) entryList.append(datum) curOffset = len(datum) + doc_index_entry_format_0Size*numEntries + seenDocs = {} for doc, startGlyphID, endGlyphID in self.docList: - docOffset = curOffset docBytes = tobytes(doc, encoding="utf_8") if getattr(self, "compressed", False) and not docBytes.startswith(b"\x1f\x8b"): import gzip @@ -105,10 +105,15 @@ def compile(self, ttFont): docBytes = gzipped del gzipped, bytesIO docLength = len(docBytes) - curOffset += docLength + if docBytes in seenDocs: + docOffset = seenDocs[docBytes] + else: + docOffset = curOffset + curOffset += docLength + seenDocs[docBytes] = docOffset + docList.append(docBytes) entry = struct.pack(">HHLL", startGlyphID, endGlyphID, docOffset, docLength) entryList.append(entry) - docList.append(docBytes) entryList.extend(docList) svgDocData = bytesjoin(entryList) From 11c98b04a59f6679720842914f9b92256a88c785 Mon Sep 17 00:00:00 2001 From: Cosimo Lupo <clupo@google.com> Date: Wed, 13 Oct 2021 14:51:42 +0200 Subject: [PATCH 3/4] SVG: don't write extra empty newline at beginning of SVG table it serves no purpose. --- Lib/fontTools/ttLib/tables/S_V_G_.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Lib/fontTools/ttLib/tables/S_V_G_.py b/Lib/fontTools/ttLib/tables/S_V_G_.py index 1c3f63db65..c6acee9b9e 100644 --- a/Lib/fontTools/ttLib/tables/S_V_G_.py +++ b/Lib/fontTools/ttLib/tables/S_V_G_.py @@ -124,7 +124,6 @@ def compile(self, ttFont): return data def toXML(self, writer, ttFont): - writer.newline() for doc, startGID, endGID in self.docList: writer.begintag("svgDoc", startGlyphID=startGID, endGlyphID=endGID) writer.newline() From e3bc036c7e2e45ee87e8577241b3ab0947ea9589 Mon Sep 17 00:00:00 2001 From: Cosimo Lupo <clupo@google.com> Date: Wed, 13 Oct 2021 14:53:00 +0200 Subject: [PATCH 4/4] Add tests for SVG table --- Tests/ttLib/tables/S_V_G__test.py | 131 ++++++++++++++++++++++++++++++ 1 file changed, 131 insertions(+) create mode 100644 Tests/ttLib/tables/S_V_G__test.py diff --git a/Tests/ttLib/tables/S_V_G__test.py b/Tests/ttLib/tables/S_V_G__test.py new file mode 100644 index 0000000000..91b0f23a6b --- /dev/null +++ b/Tests/ttLib/tables/S_V_G__test.py @@ -0,0 +1,131 @@ +import struct + +from fontTools.misc import etree +from fontTools.misc.testTools import getXML, parseXML +from fontTools.ttLib import TTFont +from fontTools.ttLib.tables.S_V_G_ import table_S_V_G_ + +import pytest + + +def dump(table, ttFont=None): + print("\n".join(getXML(table.toXML, ttFont))) + + +def strip_xml_whitespace(xml_string): + def strip_or_none(text): + text = text.strip() if text else None + return text if text else None + + tree = etree.fromstring(xml_string) + for e in tree.iter("*"): + e.text = strip_or_none(e.text) + e.tail = strip_or_none(e.tail) + return etree.tostring(tree, encoding="utf-8") + + +SVG_DOCS = [ + strip_xml_whitespace(svg) + for svg in ( + b"""\ + <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1"> + <defs> + <rect x="100" y="-200" width="300" height="400" id="p1"/> + </defs> + <g id="glyph1"> + <use xlink:href="#p1" fill="#red"/> + </g> + <g id="glyph2"> + <use xlink:href="#p1" fill="#blue"/> + </g> + <g id="glyph4"> + <use xlink:href="#p1" fill="#green"/> + </g> + </svg>""", + b"""\ + <svg xmlns="http://www.w3.org/2000/svg" version="1.1"> + <g id="glyph3"> + <path d="M0,0 L100,0 L50,100 Z"/> + </g> + </svg>""", + ) +] + + +OTSVG_DATA = b"".join( + [ + # SVG table header + b"\x00\x00" # version (0) + b"\x00\x00\x00\x0a" # offset to SVGDocumentList (10) + b"\x00\x00\x00\x00" # reserved (0) + # SVGDocumentList + b"\x00\x03" # number of SVGDocumentRecords (3) + # SVGDocumentRecord[0] + b"\x00\x01" # startGlyphID (1) + b"\x00\x02" # endGlyphID (2) + b"\x00\x00\x00\x26" # svgDocOffset (2 + 12*3 == 38 == 0x26) + + struct.pack(">L", len(SVG_DOCS[0])) # svgDocLength + # SVGDocumentRecord[1] + + b"\x00\x03" # startGlyphID (3) + b"\x00\x03" # endGlyphID (3) + + struct.pack(">L", 0x26 + len(SVG_DOCS[0])) # svgDocOffset + + struct.pack(">L", len(SVG_DOCS[1])) # svgDocLength + # SVGDocumentRecord[2] + + b"\x00\x04" # startGlyphID (4) + b"\x00\x04" # endGlyphID (4) + b"\x00\x00\x00\x26" # svgDocOffset (38); records 0 and 2 point to same SVG doc + + struct.pack(">L", len(SVG_DOCS[0])) # svgDocLength + ] + + SVG_DOCS +) + +OTSVG_TTX = [ + '<svgDoc endGlyphID="2" startGlyphID="1">', + f" <![CDATA[{SVG_DOCS[0].decode()}", + "", + '', + f" {SVG_DOCS[1].decode()}", + "", + '', + f" {SVG_DOCS[0].decode()}", + "", +] + + +@pytest.fixture +def font(): + font = TTFont() + font.setGlyphOrder([".notdef"] + ["glyph%05d" % i for i in range(1, 30)]) + return font + + +def test_decompile_and_compile(font): + table = table_S_V_G_() + table.decompile(OTSVG_DATA, font) + assert table.compile(font) == OTSVG_DATA + + +def test_decompile_and_dump_ttx(font): + table = table_S_V_G_() + table.decompile(OTSVG_DATA, font) + + dump(table, font) + assert getXML(table.toXML, font) == OTSVG_TTX + + +def test_load_from_ttx_and_compile(font): + table = table_S_V_G_() + for name, attrs, content in parseXML(OTSVG_TTX): + table.fromXML(name, attrs, content, font) + assert table.compile(font) == OTSVG_DATA + + +def test_round_trip_ttx(font): + table = table_S_V_G_() + for name, attrs, content in parseXML(OTSVG_TTX): + table.fromXML(name, attrs, content, font) + compiled = table.compile(font) + + table = table_S_V_G_() + table.decompile(compiled, font) + assert getXML(table.toXML, font) == OTSVG_TTX