From 14bb08c1df8db9ec6c8a05520d4eee67971235d9 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Thu, 27 Sep 2018 20:03:23 +0200 Subject: mod tidy --- vendor/golang.org/x/image/font/sfnt/cmap.go | 259 ---- vendor/golang.org/x/image/font/sfnt/data.go | 68 - vendor/golang.org/x/image/font/sfnt/gen.go | 321 ----- vendor/golang.org/x/image/font/sfnt/postscript.go | 1414 ------------------- vendor/golang.org/x/image/font/sfnt/sfnt.go | 1537 --------------------- vendor/golang.org/x/image/font/sfnt/truetype.go | 572 -------- 6 files changed, 4171 deletions(-) delete mode 100644 vendor/golang.org/x/image/font/sfnt/cmap.go delete mode 100644 vendor/golang.org/x/image/font/sfnt/data.go delete mode 100644 vendor/golang.org/x/image/font/sfnt/gen.go delete mode 100644 vendor/golang.org/x/image/font/sfnt/postscript.go delete mode 100644 vendor/golang.org/x/image/font/sfnt/sfnt.go delete mode 100644 vendor/golang.org/x/image/font/sfnt/truetype.go (limited to 'vendor/golang.org/x/image/font/sfnt') diff --git a/vendor/golang.org/x/image/font/sfnt/cmap.go b/vendor/golang.org/x/image/font/sfnt/cmap.go deleted file mode 100644 index 797e9d1..0000000 --- a/vendor/golang.org/x/image/font/sfnt/cmap.go +++ /dev/null @@ -1,259 +0,0 @@ -// Copyright 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package sfnt - -import ( - "golang.org/x/text/encoding/charmap" -) - -// Platform IDs and Platform Specific IDs as per -// https://www.microsoft.com/typography/otspec/name.htm -const ( - pidUnicode = 0 - pidMacintosh = 1 - pidWindows = 3 - - psidUnicode2BMPOnly = 3 - psidUnicode2FullRepertoire = 4 - // Note that FontForge may generate a bogus Platform Specific ID (value 10) - // for the Unicode Platform ID (value 0). See - // https://github.com/fontforge/fontforge/issues/2728 - - psidMacintoshRoman = 0 - - psidWindowsSymbol = 0 - psidWindowsUCS2 = 1 - psidWindowsUCS4 = 10 -) - -// platformEncodingWidth returns the number of bytes per character assumed by -// the given Platform ID and Platform Specific ID. -// -// Very old fonts, from before Unicode was widely adopted, assume only 1 byte -// per character: a character map. -// -// Old fonts, from when Unicode meant the Basic Multilingual Plane (BMP), -// assume that 2 bytes per character is sufficient. -// -// Recent fonts naturally support the full range of Unicode code points, which -// can take up to 4 bytes per character. Such fonts might still choose one of -// the legacy encodings if e.g. their repertoire is limited to the BMP, for -// greater compatibility with older software, or because the resultant file -// size can be smaller. -func platformEncodingWidth(pid, psid uint16) int { - switch pid { - case pidUnicode: - switch psid { - case psidUnicode2BMPOnly: - return 2 - case psidUnicode2FullRepertoire: - return 4 - } - - case pidMacintosh: - switch psid { - case psidMacintoshRoman: - return 1 - } - - case pidWindows: - switch psid { - case psidWindowsSymbol: - return 2 - case psidWindowsUCS2: - return 2 - case psidWindowsUCS4: - return 4 - } - } - return 0 -} - -// The various cmap formats are described at -// https://www.microsoft.com/typography/otspec/cmap.htm - -var supportedCmapFormat = func(format, pid, psid uint16) bool { - switch format { - case 0: - return pid == pidMacintosh && psid == psidMacintoshRoman - case 4: - return true - case 12: - return true - } - return false -} - -func (f *Font) makeCachedGlyphIndex(buf []byte, offset, length uint32, format uint16) ([]byte, glyphIndexFunc, error) { - switch format { - case 0: - return f.makeCachedGlyphIndexFormat0(buf, offset, length) - case 4: - return f.makeCachedGlyphIndexFormat4(buf, offset, length) - case 12: - return f.makeCachedGlyphIndexFormat12(buf, offset, length) - } - panic("unreachable") -} - -func (f *Font) makeCachedGlyphIndexFormat0(buf []byte, offset, length uint32) ([]byte, glyphIndexFunc, error) { - if length != 6+256 || offset+length > f.cmap.length { - return nil, nil, errInvalidCmapTable - } - var err error - buf, err = f.src.view(buf, int(f.cmap.offset+offset), int(length)) - if err != nil { - return nil, nil, err - } - var table [256]byte - copy(table[:], buf[6:]) - return buf, func(f *Font, b *Buffer, r rune) (GlyphIndex, error) { - x, ok := charmap.Macintosh.EncodeRune(r) - if !ok { - // The source rune r is not representable in the Macintosh-Roman encoding. - return 0, nil - } - return GlyphIndex(table[x]), nil - }, nil -} - -func (f *Font) makeCachedGlyphIndexFormat4(buf []byte, offset, length uint32) ([]byte, glyphIndexFunc, error) { - const headerSize = 14 - if offset+headerSize > f.cmap.length { - return nil, nil, errInvalidCmapTable - } - var err error - buf, err = f.src.view(buf, int(f.cmap.offset+offset), headerSize) - if err != nil { - return nil, nil, err - } - offset += headerSize - - segCount := u16(buf[6:]) - if segCount&1 != 0 { - return nil, nil, errInvalidCmapTable - } - segCount /= 2 - if segCount > maxCmapSegments { - return nil, nil, errUnsupportedNumberOfCmapSegments - } - - eLength := 8*uint32(segCount) + 2 - if offset+eLength > f.cmap.length { - return nil, nil, errInvalidCmapTable - } - buf, err = f.src.view(buf, int(f.cmap.offset+offset), int(eLength)) - if err != nil { - return nil, nil, err - } - offset += eLength - - entries := make([]cmapEntry16, segCount) - for i := range entries { - entries[i] = cmapEntry16{ - end: u16(buf[0*len(entries)+0+2*i:]), - start: u16(buf[2*len(entries)+2+2*i:]), - delta: u16(buf[4*len(entries)+2+2*i:]), - offset: u16(buf[6*len(entries)+2+2*i:]), - } - } - indexesBase := f.cmap.offset + offset - indexesLength := f.cmap.length - offset - - return buf, func(f *Font, b *Buffer, r rune) (GlyphIndex, error) { - if uint32(r) > 0xffff { - return 0, nil - } - - c := uint16(r) - for i, j := 0, len(entries); i < j; { - h := i + (j-i)/2 - entry := &entries[h] - if c < entry.start { - j = h - } else if entry.end < c { - i = h + 1 - } else if entry.offset == 0 { - return GlyphIndex(c + entry.delta), nil - } else { - offset := uint32(entry.offset) + 2*uint32(h-len(entries)+int(c-entry.start)) - if offset > indexesLength || offset+2 > indexesLength { - return 0, errInvalidCmapTable - } - x, err := b.view(&f.src, int(indexesBase+offset), 2) - if err != nil { - return 0, err - } - return GlyphIndex(u16(x)), nil - } - } - return 0, nil - }, nil -} - -func (f *Font) makeCachedGlyphIndexFormat12(buf []byte, offset, _ uint32) ([]byte, glyphIndexFunc, error) { - const headerSize = 16 - if offset+headerSize > f.cmap.length { - return nil, nil, errInvalidCmapTable - } - var err error - buf, err = f.src.view(buf, int(f.cmap.offset+offset), headerSize) - if err != nil { - return nil, nil, err - } - length := u32(buf[4:]) - if f.cmap.length < offset || length > f.cmap.length-offset { - return nil, nil, errInvalidCmapTable - } - offset += headerSize - - numGroups := u32(buf[12:]) - if numGroups > maxCmapSegments { - return nil, nil, errUnsupportedNumberOfCmapSegments - } - - eLength := 12 * numGroups - if headerSize+eLength != length { - return nil, nil, errInvalidCmapTable - } - buf, err = f.src.view(buf, int(f.cmap.offset+offset), int(eLength)) - if err != nil { - return nil, nil, err - } - offset += eLength - - entries := make([]cmapEntry32, numGroups) - for i := range entries { - entries[i] = cmapEntry32{ - start: u32(buf[0+12*i:]), - end: u32(buf[4+12*i:]), - delta: u32(buf[8+12*i:]), - } - } - - return buf, func(f *Font, b *Buffer, r rune) (GlyphIndex, error) { - c := uint32(r) - for i, j := 0, len(entries); i < j; { - h := i + (j-i)/2 - entry := &entries[h] - if c < entry.start { - j = h - } else if entry.end < c { - i = h + 1 - } else { - return GlyphIndex(c - entry.start + entry.delta), nil - } - } - return 0, nil - }, nil -} - -type cmapEntry16 struct { - end, start, delta, offset uint16 -} - -type cmapEntry32 struct { - start, end, delta uint32 -} diff --git a/vendor/golang.org/x/image/font/sfnt/data.go b/vendor/golang.org/x/image/font/sfnt/data.go deleted file mode 100644 index ad0c139..0000000 --- a/vendor/golang.org/x/image/font/sfnt/data.go +++ /dev/null @@ -1,68 +0,0 @@ -// generated by go run gen.go; DO NOT EDIT - -package sfnt - -const numBuiltInPostNames = 258 - -const builtInPostNamesData = "" + - ".notdef.nullnonmarkingreturnspaceexclamquotedblnumbersigndollarp" + - "ercentampersandquotesingleparenleftparenrightasteriskpluscommahy" + - "phenperiodslashzeroonetwothreefourfivesixseveneightninecolonsemi" + - "colonlessequalgreaterquestionatABCDEFGHIJKLMNOPQRSTUVWXYZbracket" + - "leftbackslashbracketrightasciicircumunderscoregraveabcdefghijklm" + - "nopqrstuvwxyzbraceleftbarbracerightasciitildeAdieresisAringCcedi" + - "llaEacuteNtildeOdieresisUdieresisaacuteagraveacircumflexadieresi" + - "satildearingccedillaeacuteegraveecircumflexedieresisiacuteigrave" + - "icircumflexidieresisntildeoacuteograveocircumflexodieresisotilde" + - "uacuteugraveucircumflexudieresisdaggerdegreecentsterlingsectionb" + - "ulletparagraphgermandblsregisteredcopyrighttrademarkacutedieresi" + - "snotequalAEOslashinfinityplusminuslessequalgreaterequalyenmupart" + - "ialdiffsummationproductpiintegralordfeminineordmasculineOmegaaeo" + - "slashquestiondownexclamdownlogicalnotradicalflorinapproxequalDel" + - "taguillemotleftguillemotrightellipsisnonbreakingspaceAgraveAtild" + - "eOtildeOEoeendashemdashquotedblleftquotedblrightquoteleftquoteri" + - "ghtdividelozengeydieresisYdieresisfractioncurrencyguilsinglleftg" + - "uilsinglrightfifldaggerdblperiodcenteredquotesinglbasequotedblba" + - "seperthousandAcircumflexEcircumflexAacuteEdieresisEgraveIacuteIc" + - "ircumflexIdieresisIgraveOacuteOcircumflexappleOgraveUacuteUcircu" + - "mflexUgravedotlessicircumflextildemacronbrevedotaccentringcedill" + - "ahungarumlautogonekcaronLslashlslashScaronscaronZcaronzcaronbrok" + - "enbarEthethYacuteyacuteThornthornminusmultiplyonesuperiortwosupe" + - "riorthreesuperioronehalfonequarterthreequartersfrancGbrevegbreve" + - "IdotaccentScedillascedillaCacutecacuteCcaronccarondcroat" - -var builtInPostNamesOffsets = [...]uint16{ - 0x0000, 0x0007, 0x000c, 0x001c, 0x0021, 0x0027, 0x002f, 0x0039, - 0x003f, 0x0046, 0x004f, 0x005a, 0x0063, 0x006d, 0x0075, 0x0079, - 0x007e, 0x0084, 0x008a, 0x008f, 0x0093, 0x0096, 0x0099, 0x009e, - 0x00a2, 0x00a6, 0x00a9, 0x00ae, 0x00b3, 0x00b7, 0x00bc, 0x00c5, - 0x00c9, 0x00ce, 0x00d5, 0x00dd, 0x00df, 0x00e0, 0x00e1, 0x00e2, - 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, - 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2, - 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x0104, - 0x010d, 0x0119, 0x0124, 0x012e, 0x0133, 0x0134, 0x0135, 0x0136, - 0x0137, 0x0138, 0x0139, 0x013a, 0x013b, 0x013c, 0x013d, 0x013e, - 0x013f, 0x0140, 0x0141, 0x0142, 0x0143, 0x0144, 0x0145, 0x0146, - 0x0147, 0x0148, 0x0149, 0x014a, 0x014b, 0x014c, 0x014d, 0x0156, - 0x0159, 0x0163, 0x016d, 0x0176, 0x017b, 0x0183, 0x0189, 0x018f, - 0x0198, 0x01a1, 0x01a7, 0x01ad, 0x01b8, 0x01c1, 0x01c7, 0x01cc, - 0x01d4, 0x01da, 0x01e0, 0x01eb, 0x01f4, 0x01fa, 0x0200, 0x020b, - 0x0214, 0x021a, 0x0220, 0x0226, 0x0231, 0x023a, 0x0240, 0x0246, - 0x024c, 0x0257, 0x0260, 0x0266, 0x026c, 0x0270, 0x0278, 0x027f, - 0x0285, 0x028e, 0x0298, 0x02a2, 0x02ab, 0x02b4, 0x02b9, 0x02c1, - 0x02c9, 0x02cb, 0x02d1, 0x02d9, 0x02e2, 0x02eb, 0x02f7, 0x02fa, - 0x02fc, 0x0307, 0x0310, 0x0317, 0x0319, 0x0321, 0x032c, 0x0338, - 0x033d, 0x033f, 0x0345, 0x0351, 0x035b, 0x0365, 0x036c, 0x0372, - 0x037d, 0x0382, 0x038f, 0x039d, 0x03a5, 0x03b5, 0x03bb, 0x03c1, - 0x03c7, 0x03c9, 0x03cb, 0x03d1, 0x03d7, 0x03e3, 0x03f0, 0x03f9, - 0x0403, 0x0409, 0x0410, 0x0419, 0x0422, 0x042a, 0x0432, 0x043f, - 0x044d, 0x044f, 0x0451, 0x045a, 0x0468, 0x0476, 0x0482, 0x048d, - 0x0498, 0x04a3, 0x04a9, 0x04b2, 0x04b8, 0x04be, 0x04c9, 0x04d2, - 0x04d8, 0x04de, 0x04e9, 0x04ee, 0x04f4, 0x04fa, 0x0505, 0x050b, - 0x0513, 0x051d, 0x0522, 0x0528, 0x052d, 0x0536, 0x053a, 0x0541, - 0x054d, 0x0553, 0x0558, 0x055e, 0x0564, 0x056a, 0x0570, 0x0576, - 0x057c, 0x0585, 0x0588, 0x058b, 0x0591, 0x0597, 0x059c, 0x05a1, - 0x05a6, 0x05ae, 0x05b9, 0x05c4, 0x05d1, 0x05d8, 0x05e2, 0x05ef, - 0x05f4, 0x05fa, 0x0600, 0x060a, 0x0612, 0x061a, 0x0620, 0x0626, - 0x062c, 0x0632, 0x0638, -} diff --git a/vendor/golang.org/x/image/font/sfnt/gen.go b/vendor/golang.org/x/image/font/sfnt/gen.go deleted file mode 100644 index 12587d4..0000000 --- a/vendor/golang.org/x/image/font/sfnt/gen.go +++ /dev/null @@ -1,321 +0,0 @@ -// Copyright 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build ignore - -package main - -import ( - "bytes" - "fmt" - "go/format" - "io/ioutil" - "log" -) - -func main() { - data, offsets := []byte(nil), []int{0} - for _, name := range names { - data = append(data, name...) - offsets = append(offsets, len(data)) - } - - b := new(bytes.Buffer) - fmt.Fprintf(b, "// generated by go run gen.go; DO NOT EDIT\n\n") - fmt.Fprintf(b, "package sfnt\n\n") - - fmt.Fprintf(b, "const numBuiltInPostNames = %d\n\n", len(names)) - - fmt.Fprintf(b, "const builtInPostNamesData = \"\" +\n") - for s := data; ; { - if len(s) <= 64 { - fmt.Fprintf(b, "%q\n", s) - break - } - fmt.Fprintf(b, "%q +\n", s[:64]) - s = s[64:] - } - fmt.Fprintf(b, "\n") - - fmt.Fprintf(b, "var builtInPostNamesOffsets = [...]uint16{\n") - for i, o := range offsets { - fmt.Fprintf(b, "%#04x,", o) - if i%8 == 7 { - fmt.Fprintf(b, "\n") - } - } - fmt.Fprintf(b, "\n}\n") - - dstUnformatted := b.Bytes() - dst, err := format.Source(dstUnformatted) - if err != nil { - log.Fatalf("format.Source: %v\n\n----\n%s\n----", err, dstUnformatted) - } - if err := ioutil.WriteFile("data.go", dst, 0666); err != nil { - log.Fatalf("ioutil.WriteFile: %v", err) - } -} - -// names is the built-in post table names listed at -// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html -var names = [258]string{ - ".notdef", - ".null", - "nonmarkingreturn", - "space", - "exclam", - "quotedbl", - "numbersign", - "dollar", - "percent", - "ampersand", - "quotesingle", - "parenleft", - "parenright", - "asterisk", - "plus", - "comma", - "hyphen", - "period", - "slash", - "zero", - "one", - "two", - "three", - "four", - "five", - "six", - "seven", - "eight", - "nine", - "colon", - "semicolon", - "less", - "equal", - "greater", - "question", - "at", - "A", - "B", - "C", - "D", - "E", - "F", - "G", - "H", - "I", - "J", - "K", - "L", - "M", - "N", - "O", - "P", - "Q", - "R", - "S", - "T", - "U", - "V", - "W", - "X", - "Y", - "Z", - "bracketleft", - "backslash", - "bracketright", - "asciicircum", - "underscore", - "grave", - "a", - "b", - "c", - "d", - "e", - "f", - "g", - "h", - "i", - "j", - "k", - "l", - "m", - "n", - "o", - "p", - "q", - "r", - "s", - "t", - "u", - "v", - "w", - "x", - "y", - "z", - "braceleft", - "bar", - "braceright", - "asciitilde", - "Adieresis", - "Aring", - "Ccedilla", - "Eacute", - "Ntilde", - "Odieresis", - "Udieresis", - "aacute", - "agrave", - "acircumflex", - "adieresis", - "atilde", - "aring", - "ccedilla", - "eacute", - "egrave", - "ecircumflex", - "edieresis", - "iacute", - "igrave", - "icircumflex", - "idieresis", - "ntilde", - "oacute", - "ograve", - "ocircumflex", - "odieresis", - "otilde", - "uacute", - "ugrave", - "ucircumflex", - "udieresis", - "dagger", - "degree", - "cent", - "sterling", - "section", - "bullet", - "paragraph", - "germandbls", - "registered", - "copyright", - "trademark", - "acute", - "dieresis", - "notequal", - "AE", - "Oslash", - "infinity", - "plusminus", - "lessequal", - "greaterequal", - "yen", - "mu", - "partialdiff", - "summation", - "product", - "pi", - "integral", - "ordfeminine", - "ordmasculine", - "Omega", - "ae", - "oslash", - "questiondown", - "exclamdown", - "logicalnot", - "radical", - "florin", - "approxequal", - "Delta", - "guillemotleft", - "guillemotright", - "ellipsis", - "nonbreakingspace", - "Agrave", - "Atilde", - "Otilde", - "OE", - "oe", - "endash", - "emdash", - "quotedblleft", - "quotedblright", - "quoteleft", - "quoteright", - "divide", - "lozenge", - "ydieresis", - "Ydieresis", - "fraction", - "currency", - "guilsinglleft", - "guilsinglright", - "fi", - "fl", - "daggerdbl", - "periodcentered", - "quotesinglbase", - "quotedblbase", - "perthousand", - "Acircumflex", - "Ecircumflex", - "Aacute", - "Edieresis", - "Egrave", - "Iacute", - "Icircumflex", - "Idieresis", - "Igrave", - "Oacute", - "Ocircumflex", - "apple", - "Ograve", - "Uacute", - "Ucircumflex", - "Ugrave", - "dotlessi", - "circumflex", - "tilde", - "macron", - "breve", - "dotaccent", - "ring", - "cedilla", - "hungarumlaut", - "ogonek", - "caron", - "Lslash", - "lslash", - "Scaron", - "scaron", - "Zcaron", - "zcaron", - "brokenbar", - "Eth", - "eth", - "Yacute", - "yacute", - "Thorn", - "thorn", - "minus", - "multiply", - "onesuperior", - "twosuperior", - "threesuperior", - "onehalf", - "onequarter", - "threequarters", - "franc", - "Gbreve", - "gbreve", - "Idotaccent", - "Scedilla", - "scedilla", - "Cacute", - "cacute", - "Ccaron", - "ccaron", - "dcroat", -} diff --git a/vendor/golang.org/x/image/font/sfnt/postscript.go b/vendor/golang.org/x/image/font/sfnt/postscript.go deleted file mode 100644 index b686e60..0000000 --- a/vendor/golang.org/x/image/font/sfnt/postscript.go +++ /dev/null @@ -1,1414 +0,0 @@ -// Copyright 2016 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package sfnt - -// Compact Font Format (CFF) fonts are written in PostScript, a stack-based -// programming language. -// -// A fundamental concept is a DICT, or a key-value map, expressed in reverse -// Polish notation. For example, this sequence of operations: -// - push the number 379 -// - version operator -// - push the number 392 -// - Notice operator -// - etc -// - push the number 100 -// - push the number 0 -// - push the number 500 -// - push the number 800 -// - FontBBox operator -// - etc -// defines a DICT that maps "version" to the String ID (SID) 379, "Notice" to -// the SID 392, "FontBBox" to the four numbers [100, 0, 500, 800], etc. -// -// The first 391 String IDs (starting at 0) are predefined as per the CFF spec -// Appendix A, in 5176.CFF.pdf referenced below. For example, 379 means -// "001.000". String ID 392 is not predefined, and is mapped by a separate -// structure, the "String INDEX", inside the CFF data. (String ID 391 is also -// not predefined. Specifically for ../testdata/CFFTest.otf, 391 means -// "uni4E2D", as this font contains a glyph for U+4E2D). -// -// The actual glyph vectors are similarly encoded (in PostScript), in a format -// called Type 2 Charstrings. The wire encoding is similar to but not exactly -// the same as CFF's. For example, the byte 0x05 means FontBBox for CFF DICTs, -// but means rlineto (relative line-to) for Type 2 Charstrings. See -// 5176.CFF.pdf Appendix H and 5177.Type2.pdf Appendix A in the PDF files -// referenced below. -// -// CFF is a stand-alone format, but CFF as used in SFNT fonts have further -// restrictions. For example, a stand-alone CFF can contain multiple fonts, but -// https://www.microsoft.com/typography/OTSPEC/cff.htm says that "The Name -// INDEX in the CFF must contain only one entry; that is, there must be only -// one font in the CFF FontSet". -// -// The relevant specifications are: -// - http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf -// - http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5177.Type2.pdf - -import ( - "fmt" - "math" - "strconv" - - "golang.org/x/image/math/fixed" -) - -const ( - // psArgStackSize is the argument stack size for a PostScript interpreter. - // 5176.CFF.pdf section 4 "DICT Data" says that "An operator may be - // preceded by up to a maximum of 48 operands". 5177.Type2.pdf Appendix B - // "Type 2 Charstring Implementation Limits" says that "Argument stack 48". - psArgStackSize = 48 - - // Similarly, Appendix B says "Subr nesting, stack limit 10". - psCallStackSize = 10 -) - -func bigEndian(b []byte) uint32 { - switch len(b) { - case 1: - return uint32(b[0]) - case 2: - return uint32(b[0])<<8 | uint32(b[1]) - case 3: - return uint32(b[0])<<16 | uint32(b[1])<<8 | uint32(b[2]) - case 4: - return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3]) - } - panic("unreachable") -} - -// fdSelect holds a CFF font's Font Dict Select data. -type fdSelect struct { - format uint8 - numRanges uint16 - offset int32 -} - -func (t *fdSelect) lookup(f *Font, b *Buffer, x GlyphIndex) (int, error) { - switch t.format { - case 0: - buf, err := b.view(&f.src, int(t.offset)+int(x), 1) - if err != nil { - return 0, err - } - return int(buf[0]), nil - case 3: - lo, hi := 0, int(t.numRanges) - for lo < hi { - i := (lo + hi) / 2 - buf, err := b.view(&f.src, int(t.offset)+3*i, 3+2) - if err != nil { - return 0, err - } - // buf holds the range [xlo, xhi). - if xlo := GlyphIndex(u16(buf[0:])); x < xlo { - hi = i - continue - } - if xhi := GlyphIndex(u16(buf[3:])); xhi <= x { - lo = i + 1 - continue - } - return int(buf[2]), nil - } - } - return 0, ErrNotFound -} - -// cffParser parses the CFF table from an SFNT font. -type cffParser struct { - src *source - base int - offset int - end int - err error - - buf []byte - locBuf [2]uint32 - - psi psInterpreter -} - -func (p *cffParser) parse(numGlyphs int32) (ret glyphData, err error) { - // Parse the header. - { - if !p.read(4) { - return glyphData{}, p.err - } - if p.buf[0] != 1 || p.buf[1] != 0 || p.buf[2] != 4 { - return glyphData{}, errUnsupportedCFFVersion - } - } - - // Parse the Name INDEX. - { - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - // https://www.microsoft.com/typography/OTSPEC/cff.htm says that "The - // Name INDEX in the CFF must contain only one entry". - if count != 1 { - return glyphData{}, errInvalidCFFTable - } - if !p.parseIndexLocations(p.locBuf[:2], count, offSize) { - return glyphData{}, p.err - } - p.offset = int(p.locBuf[1]) - } - - // Parse the Top DICT INDEX. - p.psi.topDict.initialize() - { - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - // 5176.CFF.pdf section 8 "Top DICT INDEX" says that the count here - // should match the count of the Name INDEX, which is 1. - if count != 1 { - return glyphData{}, errInvalidCFFTable - } - if !p.parseIndexLocations(p.locBuf[:2], count, offSize) { - return glyphData{}, p.err - } - if !p.read(int(p.locBuf[1] - p.locBuf[0])) { - return glyphData{}, p.err - } - if p.err = p.psi.run(psContextTopDict, p.buf, 0, 0); p.err != nil { - return glyphData{}, p.err - } - } - - // Skip the String INDEX. - { - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - if count != 0 { - // Read the last location. Locations are off by 1 byte. See the - // comment in parseIndexLocations. - if !p.skip(int(count * offSize)) { - return glyphData{}, p.err - } - if !p.read(int(offSize)) { - return glyphData{}, p.err - } - loc := bigEndian(p.buf) - 1 - // Check that locations are in bounds. - if uint32(p.end-p.offset) < loc { - return glyphData{}, errInvalidCFFTable - } - // Skip the index data. - if !p.skip(int(loc)) { - return glyphData{}, p.err - } - } - } - - // Parse the Global Subrs [Subroutines] INDEX. - { - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - if count != 0 { - if count > maxNumSubroutines { - return glyphData{}, errUnsupportedNumberOfSubroutines - } - ret.gsubrs = make([]uint32, count+1) - if !p.parseIndexLocations(ret.gsubrs, count, offSize) { - return glyphData{}, p.err - } - } - } - - // Parse the CharStrings INDEX, whose location was found in the Top DICT. - { - if !p.seekFromBase(p.psi.topDict.charStringsOffset) { - return glyphData{}, errInvalidCFFTable - } - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - if count == 0 || int32(count) != numGlyphs { - return glyphData{}, errInvalidCFFTable - } - ret.locations = make([]uint32, count+1) - if !p.parseIndexLocations(ret.locations, count, offSize) { - return glyphData{}, p.err - } - } - - if !p.psi.topDict.isCIDFont { - // Parse the Private DICT, whose location was found in the Top DICT. - ret.singleSubrs, err = p.parsePrivateDICT( - p.psi.topDict.privateDictOffset, - p.psi.topDict.privateDictLength, - ) - if err != nil { - return glyphData{}, err - } - - } else { - // Parse the Font Dict Select data, whose location was found in the Top - // DICT. - ret.fdSelect, err = p.parseFDSelect(p.psi.topDict.fdSelect, numGlyphs) - if err != nil { - return glyphData{}, err - } - - // Parse the Font Dicts. Each one contains its own Private DICT. - if !p.seekFromBase(p.psi.topDict.fdArray) { - return glyphData{}, errInvalidCFFTable - } - - count, offSize, ok := p.parseIndexHeader() - if !ok { - return glyphData{}, p.err - } - if count > maxNumFontDicts { - return glyphData{}, errUnsupportedNumberOfFontDicts - } - - fdLocations := make([]uint32, count+1) - if !p.parseIndexLocations(fdLocations, count, offSize) { - return glyphData{}, p.err - } - - privateDicts := make([]struct { - offset, length int32 - }, count) - - for i := range privateDicts { - length := fdLocations[i+1] - fdLocations[i] - if !p.read(int(length)) { - return glyphData{}, errInvalidCFFTable - } - p.psi.topDict.initialize() - if p.err = p.psi.run(psContextTopDict, p.buf, 0, 0); p.err != nil { - return glyphData{}, p.err - } - privateDicts[i].offset = p.psi.topDict.privateDictOffset - privateDicts[i].length = p.psi.topDict.privateDictLength - } - - ret.multiSubrs = make([][]uint32, count) - for i, pd := range privateDicts { - ret.multiSubrs[i], err = p.parsePrivateDICT(pd.offset, pd.length) - if err != nil { - return glyphData{}, err - } - } - } - - return ret, err -} - -// parseFDSelect parses the Font Dict Select data as per 5176.CFF.pdf section -// 19 "FDSelect". -func (p *cffParser) parseFDSelect(offset int32, numGlyphs int32) (ret fdSelect, err error) { - if !p.seekFromBase(p.psi.topDict.fdSelect) { - return fdSelect{}, errInvalidCFFTable - } - if !p.read(1) { - return fdSelect{}, p.err - } - ret.format = p.buf[0] - switch ret.format { - case 0: - if p.end-p.offset < int(numGlyphs) { - return fdSelect{}, errInvalidCFFTable - } - ret.offset = int32(p.offset) - return ret, nil - case 3: - if !p.read(2) { - return fdSelect{}, p.err - } - ret.numRanges = u16(p.buf) - if p.end-p.offset < 3*int(ret.numRanges)+2 { - return fdSelect{}, errInvalidCFFTable - } - ret.offset = int32(p.offset) - return ret, nil - } - return fdSelect{}, errUnsupportedCFFFDSelectTable -} - -func (p *cffParser) parsePrivateDICT(offset, length int32) (subrs []uint32, err error) { - p.psi.privateDict.initialize() - if length != 0 { - fullLength := int32(p.end - p.base) - if offset <= 0 || fullLength < offset || fullLength-offset < length || length < 0 { - return nil, errInvalidCFFTable - } - p.offset = p.base + int(offset) - if !p.read(int(length)) { - return nil, p.err - } - if p.err = p.psi.run(psContextPrivateDict, p.buf, 0, 0); p.err != nil { - return nil, p.err - } - } - - // Parse the Local Subrs [Subroutines] INDEX, whose location was found in - // the Private DICT. - if p.psi.privateDict.subrsOffset != 0 { - if !p.seekFromBase(offset + p.psi.privateDict.subrsOffset) { - return nil, errInvalidCFFTable - } - count, offSize, ok := p.parseIndexHeader() - if !ok { - return nil, p.err - } - if count != 0 { - if count > maxNumSubroutines { - return nil, errUnsupportedNumberOfSubroutines - } - subrs = make([]uint32, count+1) - if !p.parseIndexLocations(subrs, count, offSize) { - return nil, p.err - } - } - } - - return subrs, err -} - -// read sets p.buf to view the n bytes from p.offset to p.offset+n. It also -// advances p.offset by n. -// -// As per the source.view method, the caller should not modify the contents of -// p.buf after read returns, other than by calling read again. -// -// The caller should also avoid modifying the pointer / length / capacity of -// the p.buf slice, not just avoid modifying the slice's contents, in order to -// maximize the opportunity to re-use p.buf's allocated memory when viewing the -// underlying source data for subsequent read calls. -func (p *cffParser) read(n int) (ok bool) { - if n < 0 || p.end-p.offset < n { - p.err = errInvalidCFFTable - return false - } - p.buf, p.err = p.src.view(p.buf, p.offset, n) - // TODO: if p.err == io.EOF, change that to a different error?? - p.offset += n - return p.err == nil -} - -func (p *cffParser) skip(n int) (ok bool) { - if p.end-p.offset < n { - p.err = errInvalidCFFTable - return false - } - p.offset += n - return true -} - -func (p *cffParser) seekFromBase(offset int32) (ok bool) { - if offset < 0 || int32(p.end-p.base) < offset { - return false - } - p.offset = p.base + int(offset) - return true -} - -func (p *cffParser) parseIndexHeader() (count, offSize int32, ok bool) { - if !p.read(2) { - return 0, 0, false - } - count = int32(u16(p.buf[:2])) - // 5176.CFF.pdf section 5 "INDEX Data" says that "An empty INDEX is - // represented by a count field with a 0 value and no additional fields. - // Thus, the total size of an empty INDEX is 2 bytes". - if count == 0 { - return count, 0, true - } - if !p.read(1) { - return 0, 0, false - } - offSize = int32(p.buf[0]) - if offSize < 1 || 4 < offSize { - p.err = errInvalidCFFTable - return 0, 0, false - } - return count, offSize, true -} - -func (p *cffParser) parseIndexLocations(dst []uint32, count, offSize int32) (ok bool) { - if count == 0 { - return true - } - if len(dst) != int(count+1) { - panic("unreachable") - } - if !p.read(len(dst) * int(offSize)) { - return false - } - - buf, prev := p.buf, uint32(0) - for i := range dst { - loc := bigEndian(buf[:offSize]) - buf = buf[offSize:] - - // Locations are off by 1 byte. 5176.CFF.pdf section 5 "INDEX Data" - // says that "Offsets in the offset array are relative to the byte that - // precedes the object data... This ensures that every object has a - // corresponding offset which is always nonzero". - if loc == 0 { - p.err = errInvalidCFFTable - return false - } - loc-- - - // In the same paragraph, "Therefore the first element of the offset - // array is always 1" before correcting for the off-by-1. - if i == 0 { - if loc != 0 { - p.err = errInvalidCFFTable - break - } - } else if loc <= prev { // Check that locations are increasing. - p.err = errInvalidCFFTable - break - } - - // Check that locations are in bounds. - if uint32(p.end-p.offset) < loc { - p.err = errInvalidCFFTable - break - } - - dst[i] = uint32(p.offset) + loc - prev = loc - } - return p.err == nil -} - -type psCallStackEntry struct { - offset, length uint32 -} - -type psContext uint32 - -const ( - psContextTopDict psContext = iota - psContextPrivateDict - psContextType2Charstring -) - -// psTopDictData contains fields specific to the Top DICT context. -type psTopDictData struct { - charStringsOffset int32 - fdArray int32 - fdSelect int32 - isCIDFont bool - privateDictOffset int32 - privateDictLength int32 -} - -func (d *psTopDictData) initialize() { - *d = psTopDictData{} -} - -// psPrivateDictData contains fields specific to the Private DICT context. -type psPrivateDictData struct { - subrsOffset int32 -} - -func (d *psPrivateDictData) initialize() { - *d = psPrivateDictData{} -} - -// psType2CharstringsData contains fields specific to the Type 2 Charstrings -// context. -type psType2CharstringsData struct { - f *Font - b *Buffer - x int32 - y int32 - firstX int32 - firstY int32 - hintBits int32 - seenWidth bool - ended bool - glyphIndex GlyphIndex - // fdSelectIndexPlusOne is the result of the Font Dict Select lookup, plus - // one. That plus one lets us use the zero value to denote either unused - // (for CFF fonts with a single Font Dict) or lazily evaluated. - fdSelectIndexPlusOne int32 -} - -func (d *psType2CharstringsData) initialize(f *Font, b *Buffer, glyphIndex GlyphIndex) { - *d = psType2CharstringsData{ - f: f, - b: b, - glyphIndex: glyphIndex, - } -} - -func (d *psType2CharstringsData) closePath() { - if d.x != d.firstX || d.y != d.firstY { - d.b.segments = append(d.b.segments, Segment{ - Op: SegmentOpLineTo, - Args: [3]fixed.Point26_6{{ - X: fixed.Int26_6(d.firstX), - Y: fixed.Int26_6(d.firstY), - }}, - }) - } -} - -func (d *psType2CharstringsData) moveTo(dx, dy int32) { - d.closePath() - d.x += dx - d.y += dy - d.b.segments = append(d.b.segments, Segment{ - Op: SegmentOpMoveTo, - Args: [3]fixed.Point26_6{{ - X: fixed.Int26_6(d.x), - Y: fixed.Int26_6(d.y), - }}, - }) - d.firstX = d.x - d.firstY = d.y -} - -func (d *psType2CharstringsData) lineTo(dx, dy int32) { - d.x += dx - d.y += dy - d.b.segments = append(d.b.segments, Segment{ - Op: SegmentOpLineTo, - Args: [3]fixed.Point26_6{{ - X: fixed.Int26_6(d.x), - Y: fixed.Int26_6(d.y), - }}, - }) -} - -func (d *psType2CharstringsData) cubeTo(dxa, dya, dxb, dyb, dxc, dyc int32) { - d.x += dxa - d.y += dya - xa := fixed.Int26_6(d.x) - ya := fixed.Int26_6(d.y) - d.x += dxb - d.y += dyb - xb := fixed.Int26_6(d.x) - yb := fixed.Int26_6(d.y) - d.x += dxc - d.y += dyc - xc := fixed.Int26_6(d.x) - yc := fixed.Int26_6(d.y) - d.b.segments = append(d.b.segments, Segment{ - Op: SegmentOpCubeTo, - Args: [3]fixed.Point26_6{{X: xa, Y: ya}, {X: xb, Y: yb}, {X: xc, Y: yc}}, - }) -} - -// psInterpreter is a PostScript interpreter. -type psInterpreter struct { - ctx psContext - instructions []byte - instrOffset uint32 - instrLength uint32 - argStack struct { - a [psArgStackSize]int32 - top int32 - } - callStack struct { - a [psCallStackSize]psCallStackEntry - top int32 - } - parseNumberBuf [maxRealNumberStrLen]byte - - topDict psTopDictData - privateDict psPrivateDictData - type2Charstrings psType2CharstringsData -} - -func (p *psInterpreter) hasMoreInstructions() bool { - if len(p.instructions) != 0 { - return true - } - for i := int32(0); i < p.callStack.top; i++ { - if p.callStack.a[i].length != 0 { - return true - } - } - return false -} - -// run runs the instructions in the given PostScript context. For the -// psContextType2Charstring context, offset and length give the location of the -// instructions in p.type2Charstrings.f.src. -func (p *psInterpreter) run(ctx psContext, instructions []byte, offset, length uint32) error { - p.ctx = ctx - p.instructions = instructions - p.instrOffset = offset - p.instrLength = length - p.argStack.top = 0 - p.callStack.top = 0 - -loop: - for len(p.instructions) > 0 { - // Push a numeric operand on the stack, if applicable. - if hasResult, err := p.parseNumber(); hasResult { - if err != nil { - return err - } - continue - } - - // Otherwise, execute an operator. - b := p.instructions[0] - p.instructions = p.instructions[1:] - - for escaped, ops := false, psOperators[ctx][0]; ; { - if b == escapeByte && !escaped { - if len(p.instructions) <= 0 { - return errInvalidCFFTable - } - b = p.instructions[0] - p.instructions = p.instructions[1:] - escaped = true - ops = psOperators[ctx][1] - continue - } - - if int(b) < len(ops) { - if op := ops[b]; op.name != "" { - if p.argStack.top < op.numPop { - return errInvalidCFFTable - } - if op.run != nil { - if err := op.run(p); err != nil { - return err - } - } - if op.numPop < 0 { - p.argStack.top = 0 - } else { - p.argStack.top -= op.numPop - } - continue loop - } - } - - if escaped { - return fmt.Errorf("sfnt: unrecognized CFF 2-byte operator (12 %d)", b) - } else { - return fmt.Errorf("sfnt: unrecognized CFF 1-byte operator (%d)", b) - } - } - } - return nil -} - -// See 5176.CFF.pdf section 4 "DICT Data". -func (p *psInterpreter) parseNumber() (hasResult bool, err error) { - number := int32(0) - switch b := p.instructions[0]; { - case b == 28: - if len(p.instructions) < 3 { - return true, errInvalidCFFTable - } - number, hasResult = int32(int16(u16(p.instructions[1:]))), true - p.instructions = p.instructions[3:] - - case b == 29 && p.ctx != psContextType2Charstring: - if len(p.instructions) < 5 { - return true, errInvalidCFFTable - } - number, hasResult = int32(u32(p.instructions[1:])), true - p.instructions = p.instructions[5:] - - case b == 30 && p.ctx != psContextType2Charstring: - // Parse a real number. This isn't listed in 5176.CFF.pdf Table 3 - // "Operand Encoding" but that table lists integer encodings. Further - // down the page it says "A real number operand is provided in addition - // to integer operands. This operand begins with a byte value of 30 - // followed by a variable-length sequence of bytes." - - s := p.parseNumberBuf[:0] - p.instructions = p.instructions[1:] - loop: - for { - if len(p.instructions) == 0 { - return true, errInvalidCFFTable - } - b := p.instructions[0] - p.instructions = p.instructions[1:] - // Process b's two nibbles, high then low. - for i := 0; i < 2; i++ { - nib := b >> 4 - b = b << 4 - if nib == 0x0f { - f, err := strconv.ParseFloat(string(s), 32) - if err != nil { - return true, errInvalidCFFTable - } - number, hasResult = int32(math.Float32bits(float32(f))), true - break loop - } - if nib == 0x0d { - return true, errInvalidCFFTable - } - if len(s)+maxNibbleDefsLength > len(p.parseNumberBuf) { - return true, errUnsupportedRealNumberEncoding - } - s = append(s, nibbleDefs[nib]...) - } - } - - case b < 32: - // No-op. - - case b < 247: - p.instructions = p.instructions[1:] - number, hasResult = int32(b)-139, true - - case b < 251: - if len(p.instructions) < 2 { - return true, errInvalidCFFTable - } - b1 := p.instructions[1] - p.instructions = p.instructions[2:] - number, hasResult = +int32(b-247)*256+int32(b1)+108, true - - case b < 255: - if len(p.instructions) < 2 { - return true, errInvalidCFFTable - } - b1 := p.instructions[1] - p.instructions = p.instructions[2:] - number, hasResult = -int32(b-251)*256-int32(b1)-108, true - - case b == 255 && p.ctx == psContextType2Charstring: - if len(p.instructions) < 5 { - return true, errInvalidCFFTable - } - number, hasResult = int32(u32(p.instructions[1:])), true - p.instructions = p.instructions[5:] - } - - if hasResult { - if p.argStack.top == psArgStackSize { - return true, errInvalidCFFTable - } - p.argStack.a[p.argStack.top] = number - p.argStack.top++ - } - return hasResult, nil -} - -const maxNibbleDefsLength = len("E-") - -// nibbleDefs encodes 5176.CFF.pdf Table 5 "Nibble Definitions". -var nibbleDefs = [16]string{ - 0x00: "0", - 0x01: "1", - 0x02: "2", - 0x03: "3", - 0x04: "4", - 0x05: "5", - 0x06: "6", - 0x07: "7", - 0x08: "8", - 0x09: "9", - 0x0a: ".", - 0x0b: "E", - 0x0c: "E-", - 0x0d: "", - 0x0e: "-", - 0x0f: "", -} - -type psOperator struct { - // numPop is the number of stack values to pop. -1 means "array" and -2 - // means "delta" as per 5176.CFF.pdf Table 6 "Operand Types". - numPop int32 - // name is the operator name. An empty name (i.e. the zero value for the - // struct overall) means an unrecognized 1-byte operator. - name string - // run is the function that implements the operator. Nil means that we - // ignore the operator, other than popping its arguments off the stack. - run func(*psInterpreter) error -} - -// psOperators holds the 1-byte and 2-byte operators for PostScript interpreter -// contexts. -var psOperators = [...][2][]psOperator{ - // The Top DICT operators are defined by 5176.CFF.pdf Table 9 "Top DICT - // Operator Entries" and Table 10 "CIDFont Operator Extensions". - psContextTopDict: {{ - // 1-byte operators. - 0: {+1, "version", nil}, - 1: {+1, "Notice", nil}, - 2: {+1, "FullName", nil}, - 3: {+1, "FamilyName", nil}, - 4: {+1, "Weight", nil}, - 5: {-1, "FontBBox", nil}, - 13: {+1, "UniqueID", nil}, - 14: {-1, "XUID", nil}, - 15: {+1, "charset", nil}, - 16: {+1, "Encoding", nil}, - 17: {+1, "CharStrings", func(p *psInterpreter) error { - p.topDict.charStringsOffset = p.argStack.a[p.argStack.top-1] - return nil - }}, - 18: {+2, "Private", func(p *psInterpreter) error { - p.topDict.privateDictLength = p.argStack.a[p.argStack.top-2] - p.topDict.privateDictOffset = p.argStack.a[p.argStack.top-1] - return nil - }}, - }, { - // 2-byte operators. The first byte is the escape byte. - 0: {+1, "Copyright", nil}, - 1: {+1, "isFixedPitch", nil}, - 2: {+1, "ItalicAngle", nil}, - 3: {+1, "UnderlinePosition", nil}, - 4: {+1, "UnderlineThickness", nil}, - 5: {+1, "PaintType", nil}, - 6: {+1, "CharstringType", nil}, - 7: {-1, "FontMatrix", nil}, - 8: {+1, "StrokeWidth", nil}, - 20: {+1, "SyntheticBase", nil}, - 21: {+1, "PostScript", nil}, - 22: {+1, "BaseFontName", nil}, - 23: {-2, "BaseFontBlend", nil}, - 30: {+3, "ROS", func(p *psInterpreter) error { - p.topDict.isCIDFont = true - return nil - }}, - 31: {+1, "CIDFontVersion", nil}, - 32: {+1, "CIDFontRevision", nil}, - 33: {+1, "CIDFontType", nil}, - 34: {+1, "CIDCount", nil}, - 35: {+1, "UIDBase", nil}, - 36: {+1, "FDArray", func(p *psInterpreter) error { - p.topDict.fdArray = p.argStack.a[p.argStack.top-1] - return nil - }}, - 37: {+1, "FDSelect", func(p *psInterpreter) error { - p.topDict.fdSelect = p.argStack.a[p.argStack.top-1] - return nil - }}, - 38: {+1, "FontName", nil}, - }}, - - // The Private DICT operators are defined by 5176.CFF.pdf Table 23 "Private - // DICT Operators". - psContextPrivateDict: {{ - // 1-byte operators. - 6: {-2, "BlueValues", nil}, - 7: {-2, "OtherBlues", nil}, - 8: {-2, "FamilyBlues", nil}, - 9: {-2, "FamilyOtherBlues", nil}, - 10: {+1, "StdHW", nil}, - 11: {+1, "StdVW", nil}, - 19: {+1, "Subrs", func(p *psInterpreter) error { - p.privateDict.subrsOffset = p.argStack.a[p.argStack.top-1] - return nil - }}, - 20: {+1, "defaultWidthX", nil}, - 21: {+1, "nominalWidthX", nil}, - }, { - // 2-byte operators. The first byte is the escape byte. - 9: {+1, "BlueScale", nil}, - 10: {+1, "BlueShift", nil}, - 11: {+1, "BlueFuzz", nil}, - 12: {-2, "StemSnapH", nil}, - 13: {-2, "StemSnapV", nil}, - 14: {+1, "ForceBold", nil}, - 17: {+1, "LanguageGroup", nil}, - 18: {+1, "ExpansionFactor", nil}, - 19: {+1, "initialRandomSeed", nil}, - }}, - - // The Type 2 Charstring operators are defined by 5177.Type2.pdf Appendix A - // "Type 2 Charstring Command Codes". - psContextType2Charstring: {{ - // 1-byte operators. - 0: {}, // Reserved. - 1: {-1, "hstem", t2CStem}, - 2: {}, // Reserved. - 3: {-1, "vstem", t2CStem}, - 4: {-1, "vmoveto", t2CVmoveto}, - 5: {-1, "rlineto", t2CRlineto}, - 6: {-1, "hlineto", t2CHlineto}, - 7: {-1, "vlineto", t2CVlineto}, - 8: {-1, "rrcurveto", t2CRrcurveto}, - 9: {}, // Reserved. - 10: {+1, "callsubr", t2CCallsubr}, - 11: {+0, "return", t2CReturn}, - 12: {}, // escape. - 13: {}, // Reserved. - 14: {-1, "endchar", t2CEndchar}, - 15: {}, // Reserved. - 16: {}, // Reserved. - 17: {}, // Reserved. - 18: {-1, "hstemhm", t2CStem}, - 19: {-1, "hintmask", t2CMask}, - 20: {-1, "cntrmask", t2CMask}, - 21: {-1, "rmoveto", t2CRmoveto}, - 22: {-1, "hmoveto", t2CHmoveto}, - 23: {-1, "vstemhm", t2CStem}, - 24: {-1, "rcurveline", t2CRcurveline}, - 25: {-1, "rlinecurve", t2CRlinecurve}, - 26: {-1, "vvcurveto", t2CVvcurveto}, - 27: {-1, "hhcurveto", t2CHhcurveto}, - 28: {}, // shortint. - 29: {+1, "callgsubr", t2CCallgsubr}, - 30: {-1, "vhcurveto", t2CVhcurveto}, - 31: {-1, "hvcurveto", t2CHvcurveto}, - }, { - // 2-byte operators. The first byte is the escape byte. - 34: {+7, "hflex", t2CHflex}, - 36: {+9, "hflex1", t2CHflex1}, - // TODO: more operators. - }}, -} - -// 5176.CFF.pdf section 4 "DICT Data" says that "Two-byte operators have an -// initial escape byte of 12". -const escapeByte = 12 - -// t2CReadWidth reads the optional width adjustment. If present, it is on the -// bottom of the arg stack. nArgs is the expected number of arguments on the -// stack. A negative nArgs means a multiple of 2. -// -// 5177.Type2.pdf page 16 Note 4 says: "The first stack-clearing operator, -// which must be one of hstem, hstemhm, vstem, vstemhm, cntrmask, hintmask, -// hmoveto, vmoveto, rmoveto, or endchar, takes an additional argument — the -// width... which may be expressed as zero or one numeric argument." -func t2CReadWidth(p *psInterpreter, nArgs int32) { - if p.type2Charstrings.seenWidth { - return - } - p.type2Charstrings.seenWidth = true - if nArgs >= 0 { - if p.argStack.top != nArgs+1 { - return - } - } else if p.argStack.top&1 == 0 { - return - } - // When parsing a standalone CFF, we'd save the value of p.argStack.a[0] - // here as it defines the glyph's width (horizontal advance). Specifically, - // if present, it is a delta to the font-global nominalWidthX value found - // in the Private DICT. If absent, the glyph's width is the defaultWidthX - // value in that dict. See 5176.CFF.pdf section 15 "Private DICT Data". - // - // For a CFF embedded in an SFNT font (i.e. an OpenType font), glyph widths - // are already stored in the hmtx table, separate to the CFF table, and it - // is simpler to parse that table for all OpenType fonts (PostScript and - // TrueType). We therefore ignore the width value here, and just remove it - // from the bottom of the argStack. - copy(p.argStack.a[:p.argStack.top-1], p.argStack.a[1:p.argStack.top]) - p.argStack.top-- -} - -func t2CStem(p *psInterpreter) error { - t2CReadWidth(p, -1) - if p.argStack.top%2 != 0 { - return errInvalidCFFTable - } - // We update the number of hintBits need to parse hintmask and cntrmask - // instructions, but this Type 2 Charstring implementation otherwise - // ignores the stem hints. - p.type2Charstrings.hintBits += p.argStack.top / 2 - if p.type2Charstrings.hintBits > maxHintBits { - return errUnsupportedNumberOfHints - } - return nil -} - -func t2CMask(p *psInterpreter) error { - // 5176.CFF.pdf section 4.3 "Hint Operators" says that "If hstem and vstem - // hints are both declared at the beginning of a charstring, and this - // sequence is followed directly by the hintmask or cntrmask operators, the - // vstem hint operator need not be included." - // - // What we implement here is more permissive (but the same as what the - // FreeType implementation does, and simpler than tracking the previous - // operator and other hinting state): if a hintmask is given any arguments - // (i.e. the argStack is non-empty), we run an implicit vstem operator. - // - // Note that the vstem operator consumes from p.argStack, but the hintmask - // or cntrmask operators consume from p.instructions. - if p.argStack.top != 0 { - if err := t2CStem(p); err != nil { - return err - } - } else if !p.type2Charstrings.seenWidth { - p.type2Charstrings.seenWidth = true - } - - hintBytes := (p.type2Charstrings.hintBits + 7) / 8 - if len(p.instructions) < int(hintBytes) { - return errInvalidCFFTable - } - p.instructions = p.instructions[hintBytes:] - return nil -} - -func t2CHmoveto(p *psInterpreter) error { - t2CReadWidth(p, 1) - if p.argStack.top != 1 { - return errInvalidCFFTable - } - p.type2Charstrings.moveTo(p.argStack.a[0], 0) - return nil -} - -func t2CVmoveto(p *psInterpreter) error { - t2CReadWidth(p, 1) - if p.argStack.top != 1 { - return errInvalidCFFTable - } - p.type2Charstrings.moveTo(0, p.argStack.a[0]) - return nil -} - -func t2CRmoveto(p *psInterpreter) error { - t2CReadWidth(p, 2) - if p.argStack.top != 2 { - return errInvalidCFFTable - } - p.type2Charstrings.moveTo(p.argStack.a[0], p.argStack.a[1]) - return nil -} - -func t2CHlineto(p *psInterpreter) error { return t2CLineto(p, false) } -func t2CVlineto(p *psInterpreter) error { return t2CLineto(p, true) } - -func t2CLineto(p *psInterpreter, vertical bool) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 1 { - return errInvalidCFFTable - } - for i := int32(0); i < p.argStack.top; i, vertical = i+1, !vertical { - dx, dy := p.argStack.a[i], int32(0) - if vertical { - dx, dy = dy, dx - } - p.type2Charstrings.lineTo(dx, dy) - } - return nil -} - -func t2CRlineto(p *psInterpreter) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 2 || p.argStack.top%2 != 0 { - return errInvalidCFFTable - } - for i := int32(0); i < p.argStack.top; i += 2 { - p.type2Charstrings.lineTo(p.argStack.a[i], p.argStack.a[i+1]) - } - return nil -} - -// As per 5177.Type2.pdf section 4.1 "Path Construction Operators", -// -// rcurveline is: -// - {dxa dya dxb dyb dxc dyc}+ dxd dyd -// -// rlinecurve is: -// - {dxa dya}+ dxb dyb dxc dyc dxd dyd - -func t2CRcurveline(p *psInterpreter) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 8 || p.argStack.top%6 != 2 { - return errInvalidCFFTable - } - i := int32(0) - for iMax := p.argStack.top - 2; i < iMax; i += 6 { - p.type2Charstrings.cubeTo( - p.argStack.a[i+0], - p.argStack.a[i+1], - p.argStack.a[i+2], - p.argStack.a[i+3], - p.argStack.a[i+4], - p.argStack.a[i+5], - ) - } - p.type2Charstrings.lineTo(p.argStack.a[i], p.argStack.a[i+1]) - return nil -} - -func t2CRlinecurve(p *psInterpreter) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 8 || p.argStack.top%2 != 0 { - return errInvalidCFFTable - } - i := int32(0) - for iMax := p.argStack.top - 6; i < iMax; i += 2 { - p.type2Charstrings.lineTo(p.argStack.a[i], p.argStack.a[i+1]) - } - p.type2Charstrings.cubeTo( - p.argStack.a[i+0], - p.argStack.a[i+1], - p.argStack.a[i+2], - p.argStack.a[i+3], - p.argStack.a[i+4], - p.argStack.a[i+5], - ) - return nil -} - -// As per 5177.Type2.pdf section 4.1 "Path Construction Operators", -// -// hhcurveto is: -// - dy1 {dxa dxb dyb dxc}+ -// -// vvcurveto is: -// - dx1 {dya dxb dyb dyc}+ -// -// hvcurveto is one of: -// - dx1 dx2 dy2 dy3 {dya dxb dyb dxc dxd dxe dye dyf}* dxf? -// - {dxa dxb dyb dyc dyd dxe dye dxf}+ dyf? -// -// vhcurveto is one of: -// - dy1 dx2 dy2 dx3 {dxa dxb dyb dyc dyd dxe dye dxf}* dyf? -// - {dya dxb dyb dxc dxd dxe dye dyf}+ dxf? - -func t2CHhcurveto(p *psInterpreter) error { return t2CCurveto(p, false, false) } -func t2CVvcurveto(p *psInterpreter) error { return t2CCurveto(p, false, true) } -func t2CHvcurveto(p *psInterpreter) error { return t2CCurveto(p, true, false) } -func t2CVhcurveto(p *psInterpreter) error { return t2CCurveto(p, true, true) } - -// t2CCurveto implements the hh / vv / hv / vh xxcurveto operators. N relative -// cubic curve requires 6*N control points, but only 4*N+0 or 4*N+1 are used -// here: all (or all but one) of the piecewise cubic curve's tangents are -// implicitly horizontal or vertical. -// -// swap is whether that implicit horizontal / vertical constraint swaps as you -// move along the piecewise cubic curve. If swap is false, the constraints are -// either all horizontal or all vertical. If swap is true, it alternates. -// -// vertical is whether the first implicit constraint is vertical. -func t2CCurveto(p *psInterpreter, swap, vertical bool) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 4 { - return errInvalidCFFTable - } - - i := int32(0) - switch p.argStack.top & 3 { - case 0: - // No-op. - case 1: - if swap { - break - } - i = 1 - if vertical { - p.type2Charstrings.x += p.argStack.a[0] - } else { - p.type2Charstrings.y += p.argStack.a[0] - } - default: - return errInvalidCFFTable - } - - for i != p.argStack.top { - i = t2CCurveto4(p, swap, vertical, i) - if i < 0 { - return errInvalidCFFTable - } - if swap { - vertical = !vertical - } - } - return nil -} - -func t2CCurveto4(p *psInterpreter, swap bool, vertical bool, i int32) (j int32) { - if i+4 > p.argStack.top { - return -1 - } - dxa := p.argStack.a[i+0] - dya := int32(0) - dxb := p.argStack.a[i+1] - dyb := p.argStack.a[i+2] - dxc := p.argStack.a[i+3] - dyc := int32(0) - i += 4 - - if vertical { - dxa, dya = dya, dxa - } - - if swap { - if i+1 == p.argStack.top { - dyc = p.argStack.a[i] - i++ - } - } - - if swap != vertical { - dxc, dyc = dyc, dxc - } - - p.type2Charstrings.cubeTo(dxa, dya, dxb, dyb, dxc, dyc) - return i -} - -func t2CRrcurveto(p *psInterpreter) error { - if !p.type2Charstrings.seenWidth || p.argStack.top < 6 || p.argStack.top%6 != 0 { - return errInvalidCFFTable - } - for i := int32(0); i != p.argStack.top; i += 6 { - p.type2Charstrings.cubeTo( - p.argStack.a[i+0], - p.argStack.a[i+1], - p.argStack.a[i+2], - p.argStack.a[i+3], - p.argStack.a[i+4], - p.argStack.a[i+5], - ) - } - return nil -} - -// For the flex operators, we ignore the flex depth and always produce cubic -// segments, not linear segments. It's not obvious why the Type 2 Charstring -// format cares about switching behavior based on a metric in pixels, not in -// ideal font units. The Go vector rasterizer has no problems with almost -// linear cubic segments. - -func t2CHflex(p *psInterpreter) error { - p.type2Charstrings.cubeTo( - p.argStack.a[0], 0, - p.argStack.a[1], +p.argStack.a[2], - p.argStack.a[3], 0, - ) - p.type2Charstrings.cubeTo( - p.argStack.a[4], 0, - p.argStack.a[5], -p.argStack.a[2], - p.argStack.a[6], 0, - ) - return nil -} - -func t2CHflex1(p *psInterpreter) error { - dy1 := p.argStack.a[1] - dy2 := p.argStack.a[3] - dy5 := p.argStack.a[7] - dy6 := -dy1 - dy2 - dy5 - p.type2Charstrings.cubeTo( - p.argStack.a[0], dy1, - p.argStack.a[2], dy2, - p.argStack.a[4], 0, - ) - p.type2Charstrings.cubeTo( - p.argStack.a[5], 0, - p.argStack.a[6], dy5, - p.argStack.a[8], dy6, - ) - return nil -} - -// subrBias returns the subroutine index bias as per 5177.Type2.pdf section 4.7 -// "Subroutine Operators". -func subrBias(numSubroutines int) int32 { - if numSubroutines < 1240 { - return 107 - } - if numSubroutines < 33900 { - return 1131 - } - return 32768 -} - -func t2CCallgsubr(p *psInterpreter) error { - return t2CCall(p, p.type2Charstrings.f.cached.glyphData.gsubrs) -} - -func t2CCallsubr(p *psInterpreter) error { - t := &p.type2Charstrings - d := &t.f.cached.glyphData - subrs := d.singleSubrs - if d.multiSubrs != nil { - if t.fdSelectIndexPlusOne == 0 { - index, err := d.fdSelect.lookup(t.f, t.b, t.glyphIndex) - if err != nil { - return err - } - if index < 0 || len(d.multiSubrs) <= index { - return errInvalidCFFTable - } - t.fdSelectIndexPlusOne = int32(index + 1) - } - subrs = d.multiSubrs[t.fdSelectIndexPlusOne-1] - } - return t2CCall(p, subrs) -} - -func t2CCall(p *psInterpreter, subrs []uint32) error { - if p.callStack.top == psCallStackSize || len(subrs) == 0 { - return errInvalidCFFTable - } - length := uint32(len(p.instructions)) - p.callStack.a[p.callStack.top] = psCallStackEntry{ - offset: p.instrOffset + p.instrLength - length, - length: length, - } - p.callStack.top++ - - subrIndex := p.argStack.a[p.argStack.top-1] + subrBias(len(subrs)-1) - if subrIndex < 0 || int32(len(subrs)-1) <= subrIndex { - return errInvalidCFFTable - } - i := subrs[subrIndex+0] - j := subrs[subrIndex+1] - if j < i { - return errInvalidCFFTable - } - if j-i > maxGlyphDataLength { - return errUnsupportedGlyphDataLength - } - buf, err := p.type2Charstrings.b.view(&p.type2Charstrings.f.src, int(i), int(j-i)) - if err != nil { - return err - } - - p.instructions = buf - p.instrOffset = i - p.instrLength = j - i - return nil -} - -func t2CReturn(p *psInterpreter) error { - if p.callStack.top <= 0 { - return errInvalidCFFTable - } - p.callStack.top-- - o := p.callStack.a[p.callStack.top].offset - n := p.callStack.a[p.callStack.top].length - buf, err := p.type2Charstrings.b.view(&p.type2Charstrings.f.src, int(o), int(n)) - if err != nil { - return err - } - - p.instructions = buf - p.instrOffset = o - p.instrLength = n - return nil -} - -func t2CEndchar(p *psInterpreter) error { - t2CReadWidth(p, 0) - if p.argStack.top != 0 || p.hasMoreInstructions() { - if p.argStack.top == 4 { - // TODO: process the implicit "seac" command as per 5177.Type2.pdf - // Appendix C "Compatibility and Deprecated Operators". - return errUnsupportedType2Charstring - } - return errInvalidCFFTable - } - p.type2Charstrings.closePath() - p.type2Charstrings.ended = true - return nil -} diff --git a/vendor/golang.org/x/image/font/sfnt/sfnt.go b/vendor/golang.org/x/image/font/sfnt/sfnt.go deleted file mode 100644 index 21a7927..0000000 --- a/vendor/golang.org/x/image/font/sfnt/sfnt.go +++ /dev/null @@ -1,1537 +0,0 @@ -// Copyright 2016 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -//go:generate go run gen.go - -// Package sfnt implements a decoder for SFNT font file formats, including -// TrueType and OpenType. -package sfnt // import "golang.org/x/image/font/sfnt" - -// This implementation was written primarily to the -// https://www.microsoft.com/en-us/Typography/OpenTypeSpecification.aspx -// specification. Additional documentation is at -// http://developer.apple.com/fonts/TTRefMan/ -// -// The pyftinspect tool from https://github.com/fonttools/fonttools is useful -// for inspecting SFNT fonts. -// -// The ttfdump tool is also useful. For example: -// ttfdump -t cmap ../testdata/CFFTest.otf dump.txt - -import ( - "errors" - "io" - - "golang.org/x/image/font" - "golang.org/x/image/math/fixed" - "golang.org/x/text/encoding/charmap" -) - -// These constants are not part of the specifications, but are limitations used -// by this implementation. -const ( - // This value is arbitrary, but defends against parsing malicious font - // files causing excessive memory allocations. For reference, Adobe's - // SourceHanSansSC-Regular.otf has 65535 glyphs and: - // - its format-4 cmap table has 1581 segments. - // - its format-12 cmap table has 16498 segments. - // - // TODO: eliminate this constraint? If the cmap table is very large, load - // some or all of it lazily (at the time Font.GlyphIndex is called) instead - // of all of it eagerly (at the time Font.initialize is called), while - // keeping an upper bound on the memory used? This will make the code in - // cmap.go more complicated, considering that all of the Font methods are - // safe to call concurrently, as long as each call has a different *Buffer. - maxCmapSegments = 20000 - - // TODO: similarly, load subroutine locations lazily. Adobe's - // SourceHanSansSC-Regular.otf has up to 30000 subroutines. - maxNumSubroutines = 40000 - - maxCompoundRecursionDepth = 8 - maxCompoundStackSize = 64 - maxGlyphDataLength = 64 * 1024 - maxHintBits = 256 - maxNumFontDicts = 256 - maxNumFonts = 256 - maxNumTables = 256 - maxRealNumberStrLen = 64 // Maximum length in bytes of the "-123.456E-7" representation. - - // (maxTableOffset + maxTableLength) will not overflow an int32. - maxTableLength = 1 << 29 - maxTableOffset = 1 << 29 -) - -var ( - // ErrColoredGlyph indicates that the requested glyph is not a monochrome - // vector glyph, such as a colored (bitmap or vector) emoji glyph. - ErrColoredGlyph = errors.New("sfnt: colored glyph") - // ErrNotFound indicates that the requested value was not found. - ErrNotFound = errors.New("sfnt: not found") - - errInvalidBounds = errors.New("sfnt: invalid bounds") - errInvalidCFFTable = errors.New("sfnt: invalid CFF table") - errInvalidCmapTable = errors.New("sfnt: invalid cmap table") - errInvalidDfont = errors.New("sfnt: invalid dfont") - errInvalidFont = errors.New("sfnt: invalid font") - errInvalidFontCollection = errors.New("sfnt: invalid font collection") - errInvalidGlyphData = errors.New("sfnt: invalid glyph data") - errInvalidGlyphDataLength = errors.New("sfnt: invalid glyph data length") - errInvalidHeadTable = errors.New("sfnt: invalid head table") - errInvalidHheaTable = errors.New("sfnt: invalid hhea table") - errInvalidHmtxTable = errors.New("sfnt: invalid hmtx table") - errInvalidKernTable = errors.New("sfnt: invalid kern table") - errInvalidLocaTable = errors.New("sfnt: invalid loca table") - errInvalidLocationData = errors.New("sfnt: invalid location data") - errInvalidMaxpTable = errors.New("sfnt: invalid maxp table") - errInvalidNameTable = errors.New("sfnt: invalid name table") - errInvalidPostTable = errors.New("sfnt: invalid post table") - errInvalidSingleFont = errors.New("sfnt: invalid single font (data is a font collection)") - errInvalidSourceData = errors.New("sfnt: invalid source data") - errInvalidTableOffset = errors.New("sfnt: invalid table offset") - errInvalidTableTagOrder = errors.New("sfnt: invalid table tag order") - errInvalidUCS2String = errors.New("sfnt: invalid UCS-2 string") - - errUnsupportedCFFFDSelectTable = errors.New("sfnt: unsupported CFF FDSelect table") - errUnsupportedCFFVersion = errors.New("sfnt: unsupported CFF version") - errUnsupportedCmapEncodings = errors.New("sfnt: unsupported cmap encodings") - errUnsupportedCompoundGlyph = errors.New("sfnt: unsupported compound glyph") - errUnsupportedGlyphDataLength = errors.New("sfnt: unsupported glyph data length") - errUnsupportedKernTable = errors.New("sfnt: unsupported kern table") - errUnsupportedRealNumberEncoding = errors.New("sfnt: unsupported real number encoding") - errUnsupportedNumberOfCmapSegments = errors.New("sfnt: unsupported number of cmap segments") - errUnsupportedNumberOfFontDicts = errors.New("sfnt: unsupported number of font dicts") - errUnsupportedNumberOfFonts = errors.New("sfnt: unsupported number of fonts") - errUnsupportedNumberOfHints = errors.New("sfnt: unsupported number of hints") - errUnsupportedNumberOfSubroutines = errors.New("sfnt: unsupported number of subroutines") - errUnsupportedNumberOfTables = errors.New("sfnt: unsupported number of tables") - errUnsupportedPlatformEncoding = errors.New("sfnt: unsupported platform encoding") - errUnsupportedPostTable = errors.New("sfnt: unsupported post table") - errUnsupportedTableOffsetLength = errors.New("sfnt: unsupported table offset or length") - errUnsupportedType2Charstring = errors.New("sfnt: unsupported Type 2 Charstring") -) - -// GlyphIndex is a glyph index in a Font. -type GlyphIndex uint16 - -// NameID identifies a name table entry. -// -// See the "Name IDs" section of -// https://www.microsoft.com/typography/otspec/name.htm -type NameID uint16 - -const ( - NameIDCopyright NameID = 0 - NameIDFamily = 1 - NameIDSubfamily = 2 - NameIDUniqueIdentifier = 3 - NameIDFull = 4 - NameIDVersion = 5 - NameIDPostScript = 6 - NameIDTrademark = 7 - NameIDManufacturer = 8 - NameIDDesigner = 9 - NameIDDescription = 10 - NameIDVendorURL = 11 - NameIDDesignerURL = 12 - NameIDLicense = 13 - NameIDLicenseURL = 14 - NameIDTypographicFamily = 16 - NameIDTypographicSubfamily = 17 - NameIDCompatibleFull = 18 - NameIDSampleText = 19 - NameIDPostScriptCID = 20 - NameIDWWSFamily = 21 - NameIDWWSSubfamily = 22 - NameIDLightBackgroundPalette = 23 - NameIDDarkBackgroundPalette = 24 - NameIDVariationsPostScriptPrefix = 25 -) - -// Units are an integral number of abstract, scalable "font units". The em -// square is typically 1000 or 2048 "font units". This would map to a certain -// number (e.g. 30 pixels) of physical pixels, depending on things like the -// display resolution (DPI) and font size (e.g. a 12 point font). -type Units int32 - -// scale returns x divided by unitsPerEm, rounded to the nearest fixed.Int26_6 -// value (1/64th of a pixel). -func scale(x fixed.Int26_6, unitsPerEm Units) fixed.Int26_6 { - if x >= 0 { - x += fixed.Int26_6(unitsPerEm) / 2 - } else { - x -= fixed.Int26_6(unitsPerEm) / 2 - } - return x / fixed.Int26_6(unitsPerEm) -} - -func u16(b []byte) uint16 { - _ = b[1] // Bounds check hint to compiler. - return uint16(b[0])<<8 | uint16(b[1])<<0 -} - -func u32(b []byte) uint32 { - _ = b[3] // Bounds check hint to compiler. - return uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])<<0 -} - -// source is a source of byte data. Conceptually, it is like an io.ReaderAt, -// except that a common source of SFNT font data is in-memory instead of -// on-disk: a []byte containing the entire data, either as a global variable -// (e.g. "goregular.TTF") or the result of an ioutil.ReadFile call. In such -// cases, as an optimization, we skip the io.Reader / io.ReaderAt model of -// copying from the source to a caller-supplied buffer, and instead provide -// direct access to the underlying []byte data. -type source struct { - b []byte - r io.ReaderAt - - // TODO: add a caching layer, if we're using the io.ReaderAt? Note that - // this might make a source no longer safe to use concurrently. -} - -// valid returns whether exactly one of s.b and s.r is nil. -func (s *source) valid() bool { - return (s.b == nil) != (s.r == nil) -} - -// viewBufferWritable returns whether the []byte returned by source.view can be -// written to by the caller, including by passing it to the same method -// (source.view) on other receivers (i.e. different sources). -// -// In other words, it returns whether the source's underlying data is an -// io.ReaderAt, not a []byte. -func (s *source) viewBufferWritable() bool { - return s.b == nil -} - -// view returns the length bytes at the given offset. buf is an optional -// scratch buffer to reduce allocations when calling view multiple times. A nil -// buf is valid. The []byte returned may be a sub-slice of buf[:cap(buf)], or -// it may be an unrelated slice. In any case, the caller should not modify the -// contents of the returned []byte, other than passing that []byte back to this -// method on the same source s. -func (s *source) view(buf []byte, offset, length int) ([]byte, error) { - if 0 > offset || offset > offset+length { - return nil, errInvalidBounds - } - - // Try reading from the []byte. - if s.b != nil { - if offset+length > len(s.b) { - return nil, errInvalidBounds - } - return s.b[offset : offset+length], nil - } - - // Read from the io.ReaderAt. - if length <= cap(buf) { - buf = buf[:length] - } else { - // Round length up to the nearest KiB. The slack can lead to fewer - // allocations if the buffer is re-used for multiple source.view calls. - n := length - n += 1023 - n &^= 1023 - buf = make([]byte, length, n) - } - if n, err := s.r.ReadAt(buf, int64(offset)); n != length { - return nil, err - } - return buf, nil -} - -// u16 returns the uint16 in the table t at the relative offset i. -// -// buf is an optional scratch buffer as per the source.view method. -func (s *source) u16(buf []byte, t table, i int) (uint16, error) { - if i < 0 || uint(t.length) < uint(i+2) { - return 0, errInvalidBounds - } - buf, err := s.view(buf, int(t.offset)+i, 2) - if err != nil { - return 0, err - } - return u16(buf), nil -} - -// u32 returns the uint32 in the table t at the relative offset i. -// -// buf is an optional scratch buffer as per the source.view method. -func (s *source) u32(buf []byte, t table, i int) (uint32, error) { - if i < 0 || uint(t.length) < uint(i+4) { - return 0, errInvalidBounds - } - buf, err := s.view(buf, int(t.offset)+i, 4) - if err != nil { - return 0, err - } - return u32(buf), nil -} - -// table is a section of the font data. -type table struct { - offset, length uint32 -} - -// ParseCollection parses an SFNT font collection, such as TTC or OTC data, -// from a []byte data source. -// -// If passed data for a single font, a TTF or OTF instead of a TTC or OTC, it -// will return a collection containing 1 font. -func ParseCollection(src []byte) (*Collection, error) { - c := &Collection{src: source{b: src}} - if err := c.initialize(); err != nil { - return nil, err - } - return c, nil -} - -// ParseCollectionReaderAt parses an SFNT collection, such as TTC or OTC data, -// from an io.ReaderAt data source. -// -// If passed data for a single font, a TTF or OTF instead of a TTC or OTC, it -// will return a collection containing 1 font. -func ParseCollectionReaderAt(src io.ReaderAt) (*Collection, error) { - c := &Collection{src: source{r: src}} - if err := c.initialize(); err != nil { - return nil, err - } - return c, nil -} - -// Collection is a collection of one or more fonts. -// -// All of the Collection methods are safe to call concurrently. -type Collection struct { - src source - offsets []uint32 - isDfont bool -} - -// NumFonts returns the number of fonts in the collection. -func (c *Collection) NumFonts() int { return len(c.offsets) } - -func (c *Collection) initialize() error { - // The https://www.microsoft.com/typography/otspec/otff.htm "Font - // Collections" section describes the TTC header. - // - // https://github.com/kreativekorp/ksfl/wiki/Macintosh-Resource-File-Format - // describes the dfont header. - // - // 16 is the maximum of sizeof(TTCHeader) and sizeof(DfontHeader). - buf, err := c.src.view(nil, 0, 16) - if err != nil { - return err - } - // These cases match the switch statement in Font.initializeTables. - switch u32(buf) { - default: - return errInvalidFontCollection - case dfontResourceDataOffset: - return c.parseDfont(buf, u32(buf[4:]), u32(buf[12:])) - case 0x00010000, 0x4f54544f: - // Try parsing it as a single font instead of a collection. - c.offsets = []uint32{0} - case 0x74746366: // "ttcf". - numFonts := u32(buf[8:]) - if numFonts == 0 || numFonts > maxNumFonts { - return errUnsupportedNumberOfFonts - } - buf, err = c.src.view(nil, 12, int(4*numFonts)) - if err != nil { - return err - } - c.offsets = make([]uint32, numFonts) - for i := range c.offsets { - o := u32(buf[4*i:]) - if o > maxTableOffset { - return errUnsupportedTableOffsetLength - } - c.offsets[i] = o - } - } - return nil -} - -// dfontResourceDataOffset is the assumed value of a dfont file's resource data -// offset. -// -// https://github.com/kreativekorp/ksfl/wiki/Macintosh-Resource-File-Format -// says that "A Mac OS resource file... [starts with an] offset from start of -// file to start of resource data section... [usually] 0x0100". In theory, -// 0x00000100 isn't always a magic number for identifying dfont files. In -// practice, it seems to work. -const dfontResourceDataOffset = 0x00000100 - -// parseDfont parses a dfont resource map, as per -// https://github.com/kreativekorp/ksfl/wiki/Macintosh-Resource-File-Format -// -// That unofficial wiki page lists all of its fields as *signed* integers, -// which looks unusual. The actual file format might use *unsigned* integers in -// various places, but until we have either an official specification or an -// actual dfont file where this matters, we'll use signed integers and treat -// negative values as invalid. -func (c *Collection) parseDfont(buf []byte, resourceMapOffset, resourceMapLength uint32) error { - if resourceMapOffset > maxTableOffset || resourceMapLength > maxTableLength { - return errUnsupportedTableOffsetLength - } - - const headerSize = 28 - if resourceMapLength < headerSize { - return errInvalidDfont - } - buf, err := c.src.view(buf, int(resourceMapOffset+24), 2) - if err != nil { - return err - } - typeListOffset := int(int16(u16(buf))) - - if typeListOffset < headerSize || resourceMapLength < uint32(typeListOffset)+2 { - return errInvalidDfont - } - buf, err = c.src.view(buf, int(resourceMapOffset)+typeListOffset, 2) - if err != nil { - return err - } - typeCount := int(int16(u16(buf))) - - const tSize = 8 - if typeCount < 0 || tSize*uint32(typeCount) > resourceMapLength-uint32(typeListOffset)-2 { - return errInvalidDfont - } - buf, err = c.src.view(buf, int(resourceMapOffset)+typeListOffset+2, tSize*typeCount) - if err != nil { - return err - } - resourceCount, resourceListOffset := 0, 0 - for i := 0; i < typeCount; i++ { - if u32(buf[tSize*i:]) != 0x73666e74 { // "sfnt". - continue - } - - resourceCount = int(int16(u16(buf[tSize*i+4:]))) - if resourceCount < 0 { - return errInvalidDfont - } - // https://github.com/kreativekorp/ksfl/wiki/Macintosh-Resource-File-Format - // says that the value in the wire format is "the number of - // resources of this type, minus one." - resourceCount++ - - resourceListOffset = int(int16(u16(buf[tSize*i+6:]))) - if resourceListOffset < 0 { - return errInvalidDfont - } - break - } - if resourceCount == 0 { - return errInvalidDfont - } - if resourceCount > maxNumFonts { - return errUnsupportedNumberOfFonts - } - - const rSize = 12 - if o, n := uint32(typeListOffset+resourceListOffset), rSize*uint32(resourceCount); o > resourceMapLength || n > resourceMapLength-o { - return errInvalidDfont - } else { - buf, err = c.src.view(buf, int(resourceMapOffset+o), int(n)) - if err != nil { - return err - } - } - c.offsets = make([]uint32, resourceCount) - for i := range c.offsets { - o := 0xffffff & u32(buf[rSize*i+4:]) - // Offsets are relative to the resource data start, not the file start. - // A particular resource's data also starts with a 4-byte length, which - // we skip. - o += dfontResourceDataOffset + 4 - if o > maxTableOffset { - return errUnsupportedTableOffsetLength - } - c.offsets[i] = o - } - c.isDfont = true - return nil -} - -// Font returns the i'th font in the collection. -func (c *Collection) Font(i int) (*Font, error) { - if i < 0 || len(c.offsets) <= i { - return nil, ErrNotFound - } - f := &Font{src: c.src} - if err := f.initialize(int(c.offsets[i]), c.isDfont); err != nil { - return nil, err - } - return f, nil -} - -// Parse parses an SFNT font, such as TTF or OTF data, from a []byte data -// source. -func Parse(src []byte) (*Font, error) { - f := &Font{src: source{b: src}} - if err := f.initialize(0, false); err != nil { - return nil, err - } - return f, nil -} - -// ParseReaderAt parses an SFNT font, such as TTF or OTF data, from an -// io.ReaderAt data source. -func ParseReaderAt(src io.ReaderAt) (*Font, error) { - f := &Font{src: source{r: src}} - if err := f.initialize(0, false); err != nil { - return nil, err - } - return f, nil -} - -// Font is an SFNT font. -// -// Many of its methods take a *Buffer argument, as re-using buffers can reduce -// the total memory allocation of repeated Font method calls, such as measuring -// and rasterizing every unique glyph in a string of text. If efficiency is not -// a concern, passing a nil *Buffer is valid, and implies using a temporary -// buffer for a single call. -// -// It is valid to re-use a *Buffer with multiple Font method calls, even with -// different *Font receivers, as long as they are not concurrent calls. -// -// All of the Font methods are safe to call concurrently, as long as each call -// has a different *Buffer (or nil). -// -// The Font methods that don't take a *Buffer argument are always safe to call -// concurrently. -// -// Some methods provide lengths or coordinates, e.g. bounds, font metrics and -// control points. All of these methods take a ppem parameter, which is the -// number of pixels in 1 em, expressed as a 26.6 fixed point value. For -// example, if 1 em is 10 pixels then ppem is fixed.I(10), which equals -// fixed.Int26_6(10 << 6). -// -// To get those lengths or coordinates in terms of font units instead of -// pixels, use ppem = fixed.Int26_6(f.UnitsPerEm()) and if those methods take a -// font.Hinting parameter, use font.HintingNone. The return values will have -// type fixed.Int26_6, but those numbers can be converted back to Units with no -// further scaling necessary. -type Font struct { - src source - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Required Tables". - cmap table - head table - hhea table - hmtx table - maxp table - name table - os2 table - post table - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Tables Related to TrueType Outlines". - // - // This implementation does not support hinting, so it does not read the - // cvt, fpgm gasp or prep tables. - glyf table - loca table - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Tables Related to PostScript Outlines". - // - // TODO: cff2, vorg? - cff table - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Tables Related to Bitmap Glyphs". - // - // TODO: Others? - cblc table - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Advanced Typographic Tables". - // - // TODO: base, gdef, gpos, gsub, jstf, math? - - // https://www.microsoft.com/typography/otspec/otff.htm#otttables - // "Other OpenType Tables". - // - // TODO: hdmx, vmtx? Others? - kern table - - cached struct { - ascent int32 - glyphData glyphData - glyphIndex glyphIndexFunc - bounds [4]int16 - descent int32 - indexToLocFormat bool // false means short, true means long. - isColorBitmap bool - isPostScript bool - kernNumPairs int32 - kernOffset int32 - lineGap int32 - numHMetrics int32 - postTableVersion uint32 - unitsPerEm Units - } -} - -// NumGlyphs returns the number of glyphs in f. -func (f *Font) NumGlyphs() int { return len(f.cached.glyphData.locations) - 1 } - -// UnitsPerEm returns the number of units per em for f. -func (f *Font) UnitsPerEm() Units { return f.cached.unitsPerEm } - -func (f *Font) initialize(offset int, isDfont bool) error { - if !f.src.valid() { - return errInvalidSourceData - } - buf, isPostScript, err := f.initializeTables(offset, isDfont) - if err != nil { - return err - } - - // The order of these parseXxx calls matters. Later calls may depend on - // information parsed by earlier calls, such as the maxp table's numGlyphs. - // To enforce these dependencies, such information is passed and returned - // explicitly, and the f.cached fields are only set afterwards. - // - // When implementing new parseXxx methods, take care not to call methods - // such as Font.NumGlyphs that implicitly depend on f.cached fields. - - buf, bounds, indexToLocFormat, unitsPerEm, err := f.parseHead(buf) - if err != nil { - return err - } - buf, numGlyphs, err := f.parseMaxp(buf, isPostScript) - if err != nil { - return err - } - buf, glyphData, isColorBitmap, err := f.parseGlyphData(buf, numGlyphs, indexToLocFormat, isPostScript) - if err != nil { - return err - } - buf, glyphIndex, err := f.parseCmap(buf) - if err != nil { - return err - } - buf, kernNumPairs, kernOffset, err := f.parseKern(buf) - if err != nil { - return err - } - buf, ascent, descent, lineGap, numHMetrics, err := f.parseHhea(buf, numGlyphs) - if err != nil { - return err - } - buf, err = f.parseHmtx(buf, numGlyphs, numHMetrics) - if err != nil { - return err - } - buf, postTableVersion, err := f.parsePost(buf, numGlyphs) - if err != nil { - return err - } - - f.cached.ascent = ascent - f.cached.glyphData = glyphData - f.cached.glyphIndex = glyphIndex - f.cached.bounds = bounds - f.cached.descent = descent - f.cached.indexToLocFormat = indexToLocFormat - f.cached.isColorBitmap = isColorBitmap - f.cached.isPostScript = isPostScript - f.cached.kernNumPairs = kernNumPairs - f.cached.kernOffset = kernOffset - f.cached.lineGap = lineGap - f.cached.numHMetrics = numHMetrics - f.cached.postTableVersion = postTableVersion - f.cached.unitsPerEm = unitsPerEm - - return nil -} - -func (f *Font) initializeTables(offset int, isDfont bool) (buf1 []byte, isPostScript bool, err error) { - // https://www.microsoft.com/typography/otspec/otff.htm "Organization of an - // OpenType Font" says that "The OpenType font starts with the Offset - // Table", which is 12 bytes. - buf, err := f.src.view(nil, offset, 12) - if err != nil { - return nil, false, err - } - // When updating the cases in this switch statement, also update the - // Collection.initialize method. - switch u32(buf) { - default: - return nil, false, errInvalidFont - case dfontResourceDataOffset: - return nil, false, errInvalidSingleFont - case 0x00010000: - // No-op. - case 0x4f54544f: // "OTTO". - isPostScript = true - case 0x74746366: // "ttcf". - return nil, false, errInvalidSingleFont - } - numTables := int(u16(buf[4:])) - if numTables > maxNumTables { - return nil, false, errUnsupportedNumberOfTables - } - - // "The Offset Table is followed immediately by the Table Record entries... - // sorted in ascending order by tag", 16 bytes each. - buf, err = f.src.view(buf, offset+12, 16*numTables) - if err != nil { - return nil, false, err - } - for b, first, prevTag := buf, true, uint32(0); len(b) > 0; b = b[16:] { - tag := u32(b) - if first { - first = false - } else if tag <= prevTag { - return nil, false, errInvalidTableTagOrder - } - prevTag = tag - - o, n := u32(b[8:12]), u32(b[12:16]) - // For dfont files, the offset is relative to the resource, not the - // file. - if isDfont { - origO := o - o += uint32(offset) - if o < origO { - return nil, false, errUnsupportedTableOffsetLength - } - } - if o > maxTableOffset || n > maxTableLength { - return nil, false, errUnsupportedTableOffsetLength - } - // We ignore the checksums, but "all tables must begin on four byte - // boundries [sic]". - if o&3 != 0 { - return nil, false, errInvalidTableOffset - } - - // Match the 4-byte tag as a uint32. For example, "OS/2" is 0x4f532f32. - switch tag { - case 0x43424c43: - f.cblc = table{o, n} - case 0x43464620: - f.cff = table{o, n} - case 0x4f532f32: - f.os2 = table{o, n} - case 0x636d6170: - f.cmap = table{o, n} - case 0x676c7966: - f.glyf = table{o, n} - case 0x68656164: - f.head = table{o, n} - case 0x68686561: - f.hhea = table{o, n} - case 0x686d7478: - f.hmtx = table{o, n} - case 0x6b65726e: - f.kern = table{o, n} - case 0x6c6f6361: - f.loca = table{o, n} - case 0x6d617870: - f.maxp = table{o, n} - case 0x6e616d65: - f.name = table{o, n} - case 0x706f7374: - f.post = table{o, n} - } - } - return buf, isPostScript, nil -} - -func (f *Font) parseCmap(buf []byte) (buf1 []byte, glyphIndex glyphIndexFunc, err error) { - // https://www.microsoft.com/typography/OTSPEC/cmap.htm - - const headerSize, entrySize = 4, 8 - if f.cmap.length < headerSize { - return nil, nil, errInvalidCmapTable - } - u, err := f.src.u16(buf, f.cmap, 2) - if err != nil { - return nil, nil, err - } - numSubtables := int(u) - if f.cmap.length < headerSize+entrySize*uint32(numSubtables) { - return nil, nil, errInvalidCmapTable - } - - var ( - bestWidth int - bestOffset uint32 - bestLength uint32 - bestFormat uint16 - ) - - // Scan all of the subtables, picking the widest supported one. See the - // platformEncodingWidth comment for more discussion of width. - for i := 0; i < numSubtables; i++ { - buf, err = f.src.view(buf, int(f.cmap.offset)+headerSize+entrySize*i, entrySize) - if err != nil { - return nil, nil, err - } - pid := u16(buf) - psid := u16(buf[2:]) - width := platformEncodingWidth(pid, psid) - if width <= bestWidth { - continue - } - offset := u32(buf[4:]) - - if offset > f.cmap.length-4 { - return nil, nil, errInvalidCmapTable - } - buf, err = f.src.view(buf, int(f.cmap.offset+offset), 4) - if err != nil { - return nil, nil, err - } - format := u16(buf) - if !supportedCmapFormat(format, pid, psid) { - continue - } - length := uint32(u16(buf[2:])) - - bestWidth = width - bestOffset = offset - bestLength = length - bestFormat = format - } - - if bestWidth == 0 { - return nil, nil, errUnsupportedCmapEncodings - } - return f.makeCachedGlyphIndex(buf, bestOffset, bestLength, bestFormat) -} - -func (f *Font) parseHead(buf []byte) (buf1 []byte, bounds [4]int16, indexToLocFormat bool, unitsPerEm Units, err error) { - // https://www.microsoft.com/typography/otspec/head.htm - - if f.head.length != 54 { - return nil, [4]int16{}, false, 0, errInvalidHeadTable - } - - u, err := f.src.u16(buf, f.head, 18) - if err != nil { - return nil, [4]int16{}, false, 0, err - } - if u == 0 { - return nil, [4]int16{}, false, 0, errInvalidHeadTable - } - unitsPerEm = Units(u) - - for i := range bounds { - u, err := f.src.u16(buf, f.head, 36+2*i) - if err != nil { - return nil, [4]int16{}, false, 0, err - } - bounds[i] = int16(u) - } - - u, err = f.src.u16(buf, f.head, 50) - if err != nil { - return nil, [4]int16{}, false, 0, err - } - indexToLocFormat = u != 0 - return buf, bounds, indexToLocFormat, unitsPerEm, nil -} - -func (f *Font) parseHhea(buf []byte, numGlyphs int32) (buf1 []byte, ascent, descent, lineGap, numHMetrics int32, err error) { - // https://www.microsoft.com/typography/OTSPEC/hhea.htm - - if f.hhea.length != 36 { - return nil, 0, 0, 0, 0, errInvalidHheaTable - } - u, err := f.src.u16(buf, f.hhea, 34) - if err != nil { - return nil, 0, 0, 0, 0, err - } - if int32(u) > numGlyphs || u == 0 { - return nil, 0, 0, 0, 0, errInvalidHheaTable - } - a, err := f.src.u16(buf, f.hhea, 4) - if err != nil { - return nil, 0, 0, 0, 0, err - } - d, err := f.src.u16(buf, f.hhea, 6) - if err != nil { - return nil, 0, 0, 0, 0, err - } - l, err := f.src.u16(buf, f.hhea, 8) - if err != nil { - return nil, 0, 0, 0, 0, err - } - return buf, int32(int16(a)), int32(int16(d)), int32(int16(l)), int32(u), nil -} - -func (f *Font) parseHmtx(buf []byte, numGlyphs, numHMetrics int32) (buf1 []byte, err error) { - // https://www.microsoft.com/typography/OTSPEC/hmtx.htm - - if f.hmtx.length != uint32(2*numGlyphs+2*numHMetrics) { - return nil, errInvalidHmtxTable - } - return buf, nil -} - -func (f *Font) parseKern(buf []byte) (buf1 []byte, kernNumPairs, kernOffset int32, err error) { - // https://www.microsoft.com/typography/otspec/kern.htm - - if f.kern.length == 0 { - return buf, 0, 0, nil - } - const headerSize = 4 - if f.kern.length < headerSize { - return nil, 0, 0, errInvalidKernTable - } - buf, err = f.src.view(buf, int(f.kern.offset), headerSize) - if err != nil { - return nil, 0, 0, err - } - offset := int(f.kern.offset) + headerSize - length := int(f.kern.length) - headerSize - - switch version := u16(buf); version { - case 0: - if numTables := int(u16(buf[2:])); numTables == 0 { - return buf, 0, 0, nil - } else if numTables > 1 { - // TODO: support multiple subtables. For now, fall through and use - // only the first one. - } - return f.parseKernVersion0(buf, offset, length) - case 1: - if buf[2] != 0 || buf[3] != 0 { - return nil, 0, 0, errUnsupportedKernTable - } - // Microsoft's https://www.microsoft.com/typography/otspec/kern.htm - // says that "Apple has extended the definition of the 'kern' table to - // provide additional functionality. The Apple extensions are not - // supported on Windows." - // - // The format is relatively complicated, including encoding a state - // machine, but rarely seen. We follow Microsoft's and FreeType's - // behavior and simply ignore it. Theoretically, we could follow - // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6kern.html - // but it doesn't seem worth the effort. - return buf, 0, 0, nil - } - return nil, 0, 0, errUnsupportedKernTable -} - -func (f *Font) parseKernVersion0(buf []byte, offset, length int) (buf1 []byte, kernNumPairs, kernOffset int32, err error) { - const headerSize = 6 - if length < headerSize { - return nil, 0, 0, errInvalidKernTable - } - buf, err = f.src.view(buf, offset, headerSize) - if err != nil { - return nil, 0, 0, err - } - if version := u16(buf); version != 0 { - return nil, 0, 0, errUnsupportedKernTable - } - subtableLength := int(u16(buf[2:])) - if subtableLength < headerSize || length < subtableLength { - return nil, 0, 0, errInvalidKernTable - } - if coverageBits := buf[5]; coverageBits != 0x01 { - // We only support horizontal kerning. - return nil, 0, 0, errUnsupportedKernTable - } - offset += headerSize - length -= headerSize - subtableLength -= headerSize - - switch format := buf[4]; format { - case 0: - return f.parseKernFormat0(buf, offset, subtableLength) - case 2: - // If we could find such a font, we could write code to support it, but - // a comment in the equivalent FreeType code (sfnt/ttkern.c) says that - // they've never seen such a font. - } - return nil, 0, 0, errUnsupportedKernTable -} - -func (f *Font) parseKernFormat0(buf []byte, offset, length int) (buf1 []byte, kernNumPairs, kernOffset int32, err error) { - const headerSize, entrySize = 8, 6 - if length < headerSize { - return nil, 0, 0, errInvalidKernTable - } - buf, err = f.src.view(buf, offset, headerSize) - if err != nil { - return nil, 0, 0, err - } - kernNumPairs = int32(u16(buf)) - if length != headerSize+entrySize*int(kernNumPairs) { - return nil, 0, 0, errInvalidKernTable - } - return buf, kernNumPairs, int32(offset) + headerSize, nil -} - -func (f *Font) parseMaxp(buf []byte, isPostScript bool) (buf1 []byte, numGlyphs int32, err error) { - // https://www.microsoft.com/typography/otspec/maxp.htm - - if isPostScript { - if f.maxp.length != 6 { - return nil, 0, errInvalidMaxpTable - } - } else { - if f.maxp.length != 32 { - return nil, 0, errInvalidMaxpTable - } - } - u, err := f.src.u16(buf, f.maxp, 4) - if err != nil { - return nil, 0, err - } - return buf, int32(u), nil -} - -type glyphData struct { - // The glyph data for the i'th glyph index is in - // src[locations[i+0]:locations[i+1]]. - // - // The slice length equals 1 plus the number of glyphs. - locations []uint32 - - // For PostScript fonts, the bytecode for the i'th global or local - // subroutine is in src[x[i+0]:x[i+1]]. - // - // The []uint32 slice length equals 1 plus the number of subroutines - gsubrs []uint32 - singleSubrs []uint32 - multiSubrs [][]uint32 - - fdSelect fdSelect -} - -func (f *Font) parseGlyphData(buf []byte, numGlyphs int32, indexToLocFormat, isPostScript bool) (buf1 []byte, ret glyphData, isColorBitmap bool, err error) { - if isPostScript { - p := cffParser{ - src: &f.src, - base: int(f.cff.offset), - offset: int(f.cff.offset), - end: int(f.cff.offset + f.cff.length), - } - ret, err = p.parse(numGlyphs) - if err != nil { - return nil, glyphData{}, false, err - } - } else if f.loca.length != 0 { - ret.locations, err = parseLoca(&f.src, f.loca, f.glyf.offset, indexToLocFormat, numGlyphs) - if err != nil { - return nil, glyphData{}, false, err - } - } else if f.cblc.length != 0 { - isColorBitmap = true - // TODO: parse the CBLC (and CBDT) tables. For now, we return a font - // with empty glyphs. - ret.locations = make([]uint32, numGlyphs+1) - } - - if len(ret.locations) != int(numGlyphs+1) { - return nil, glyphData{}, false, errInvalidLocationData - } - - return buf, ret, isColorBitmap, nil -} - -func (f *Font) parsePost(buf []byte, numGlyphs int32) (buf1 []byte, postTableVersion uint32, err error) { - // https://www.microsoft.com/typography/otspec/post.htm - - const headerSize = 32 - if f.post.length < headerSize { - return nil, 0, errInvalidPostTable - } - u, err := f.src.u32(buf, f.post, 0) - if err != nil { - return nil, 0, err - } - switch u { - case 0x20000: - if f.post.length < headerSize+2+2*uint32(numGlyphs) { - return nil, 0, errInvalidPostTable - } - case 0x30000: - // No-op. - default: - return nil, 0, errUnsupportedPostTable - } - return buf, u, nil -} - -// Bounds returns the union of a Font's glyphs' bounds. -// -// In the returned Rectangle26_6's (x, y) coordinates, the Y axis increases -// down. -func (f *Font) Bounds(b *Buffer, ppem fixed.Int26_6, h font.Hinting) (fixed.Rectangle26_6, error) { - // The 0, 3, 2, 1 indices are to flip the Y coordinates. OpenType's Y axis - // increases up. Go's standard graphics libraries' Y axis increases down. - r := fixed.Rectangle26_6{ - Min: fixed.Point26_6{ - X: +scale(fixed.Int26_6(f.cached.bounds[0])*ppem, f.cached.unitsPerEm), - Y: -scale(fixed.Int26_6(f.cached.bounds[3])*ppem, f.cached.unitsPerEm), - }, - Max: fixed.Point26_6{ - X: +scale(fixed.Int26_6(f.cached.bounds[2])*ppem, f.cached.unitsPerEm), - Y: -scale(fixed.Int26_6(f.cached.bounds[1])*ppem, f.cached.unitsPerEm), - }, - } - if h == font.HintingFull { - // Quantize the Min down and Max up to a whole pixel. - r.Min.X = (r.Min.X + 0) &^ 63 - r.Min.Y = (r.Min.Y + 0) &^ 63 - r.Max.X = (r.Max.X + 63) &^ 63 - r.Max.Y = (r.Max.Y + 63) &^ 63 - } - return r, nil -} - -// TODO: API for looking up glyph variants?? For example, some fonts may -// provide both slashed and dotted zero glyphs ('0'), or regular and 'old -// style' numerals, and users can direct software to choose a variant. - -type glyphIndexFunc func(f *Font, b *Buffer, r rune) (GlyphIndex, error) - -// GlyphIndex returns the glyph index for the given rune. -// -// It returns (0, nil) if there is no glyph for r. -// https://www.microsoft.com/typography/OTSPEC/cmap.htm says that "Character -// codes that do not correspond to any glyph in the font should be mapped to -// glyph index 0. The glyph at this location must be a special glyph -// representing a missing character, commonly known as .notdef." -func (f *Font) GlyphIndex(b *Buffer, r rune) (GlyphIndex, error) { - return f.cached.glyphIndex(f, b, r) -} - -func (f *Font) viewGlyphData(b *Buffer, x GlyphIndex) (buf []byte, offset, length uint32, err error) { - xx := int(x) - if f.NumGlyphs() <= xx { - return nil, 0, 0, ErrNotFound - } - i := f.cached.glyphData.locations[xx+0] - j := f.cached.glyphData.locations[xx+1] - if j < i { - return nil, 0, 0, errInvalidGlyphDataLength - } - if j-i > maxGlyphDataLength { - return nil, 0, 0, errUnsupportedGlyphDataLength - } - buf, err = b.view(&f.src, int(i), int(j-i)) - return buf, i, j - i, err -} - -// LoadGlyphOptions are the options to the Font.LoadGlyph method. -type LoadGlyphOptions struct { - // TODO: transform / hinting. -} - -// LoadGlyph returns the vector segments for the x'th glyph. ppem is the number -// of pixels in 1 em. -// -// If b is non-nil, the segments become invalid to use once b is re-used. -// -// In the returned Segments' (x, y) coordinates, the Y axis increases down. -// -// It returns ErrNotFound if the glyph index is out of range. It returns -// ErrColoredGlyph if the glyph is not a monochrome vector glyph, such as a -// colored (bitmap or vector) emoji glyph. -func (f *Font) LoadGlyph(b *Buffer, x GlyphIndex, ppem fixed.Int26_6, opts *LoadGlyphOptions) ([]Segment, error) { - if b == nil { - b = &Buffer{} - } - - b.segments = b.segments[:0] - if f.cached.isColorBitmap { - return nil, ErrColoredGlyph - } - if f.cached.isPostScript { - buf, offset, length, err := f.viewGlyphData(b, x) - if err != nil { - return nil, err - } - b.psi.type2Charstrings.initialize(f, b, x) - if err := b.psi.run(psContextType2Charstring, buf, offset, length); err != nil { - return nil, err - } - if !b.psi.type2Charstrings.ended { - return nil, errInvalidCFFTable - } - } else if err := loadGlyf(f, b, x, 0, 0); err != nil { - return nil, err - } - - // Scale the segments. If we want to support hinting, we'll have to push - // the scaling computation into the PostScript / TrueType specific glyph - // loading code, such as the appendGlyfSegments body, since TrueType - // hinting bytecode works on the scaled glyph vectors. For now, though, - // it's simpler to scale as a post-processing step. - // - // We also flip the Y coordinates. OpenType's Y axis increases up. Go's - // standard graphics libraries' Y axis increases down. - for i := range b.segments { - a := &b.segments[i].Args - for j := range a { - a[j].X = +scale(a[j].X*ppem, f.cached.unitsPerEm) - a[j].Y = -scale(a[j].Y*ppem, f.cached.unitsPerEm) - } - } - - // TODO: look at opts to transform / hint the Buffer.segments. - - return b.segments, nil -} - -// GlyphName returns the name of the x'th glyph. -// -// Not every font contains glyph names. If not present, GlyphName will return -// ("", nil). -// -// If present, the glyph name, provided by the font, is assumed to follow the -// Adobe Glyph List Specification: -// https://github.com/adobe-type-tools/agl-specification/blob/master/README.md -// -// This is also known as the "Adobe Glyph Naming convention", the "Adobe -// document [for] Unicode and Glyph Names" or "PostScript glyph names". -// -// It returns ErrNotFound if the glyph index is out of range. -func (f *Font) GlyphName(b *Buffer, x GlyphIndex) (string, error) { - if int(x) >= f.NumGlyphs() { - return "", ErrNotFound - } - if f.cached.postTableVersion != 0x20000 { - return "", nil - } - if b == nil { - b = &Buffer{} - } - - // The wire format for a Version 2 post table is documented at: - // https://www.microsoft.com/typography/otspec/post.htm - const glyphNameIndexOffset = 34 - - buf, err := b.view(&f.src, int(f.post.offset)+glyphNameIndexOffset+2*int(x), 2) - if err != nil { - return "", err - } - u := u16(buf) - if u < numBuiltInPostNames { - i := builtInPostNamesOffsets[u+0] - j := builtInPostNamesOffsets[u+1] - return builtInPostNamesData[i:j], nil - } - // https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html - // says that "32768 through 65535 are reserved for future use". - if u > 32767 { - return "", errUnsupportedPostTable - } - u -= numBuiltInPostNames - - // Iterate through the list of Pascal-formatted strings. A linear scan is - // clearly O(u), which isn't great (as the obvious loop, calling - // Font.GlyphName, to get all of the glyph names in a font has quadratic - // complexity), but the wire format doesn't suggest a better alternative. - - offset := glyphNameIndexOffset + 2*f.NumGlyphs() - buf, err = b.view(&f.src, int(f.post.offset)+offset, int(f.post.length)-offset) - if err != nil { - return "", err - } - - for { - if len(buf) == 0 { - return "", errInvalidPostTable - } - n := 1 + int(buf[0]) - if len(buf) < n { - return "", errInvalidPostTable - } - if u == 0 { - return string(buf[1:n]), nil - } - buf = buf[n:] - u-- - } -} - -// GlyphAdvance returns the advance width for the x'th glyph. ppem is the -// number of pixels in 1 em. -// -// It returns ErrNotFound if the glyph index is out of range. -func (f *Font) GlyphAdvance(b *Buffer, x GlyphIndex, ppem fixed.Int26_6, h font.Hinting) (fixed.Int26_6, error) { - if int(x) >= f.NumGlyphs() { - return 0, ErrNotFound - } - if b == nil { - b = &Buffer{} - } - - // https://www.microsoft.com/typography/OTSPEC/hmtx.htm says that "As an - // optimization, the number of records can be less than the number of - // glyphs, in which case the advance width value of the last record applies - // to all remaining glyph IDs." - if n := GlyphIndex(f.cached.numHMetrics - 1); x > n { - x = n - } - - buf, err := b.view(&f.src, int(f.hmtx.offset)+int(4*x), 2) - if err != nil { - return 0, err - } - adv := fixed.Int26_6(u16(buf)) - adv = scale(adv*ppem, f.cached.unitsPerEm) - if h == font.HintingFull { - // Quantize the fixed.Int26_6 value to the nearest pixel. - adv = (adv + 32) &^ 63 - } - return adv, nil -} - -// Kern returns the horizontal adjustment for the kerning pair (x0, x1). A -// positive kern means to move the glyphs further apart. ppem is the number of -// pixels in 1 em. -// -// It returns ErrNotFound if either glyph index is out of range. -func (f *Font) Kern(b *Buffer, x0, x1 GlyphIndex, ppem fixed.Int26_6, h font.Hinting) (fixed.Int26_6, error) { - // TODO: how should this work with the GPOS table and CFF fonts? - // https://www.microsoft.com/typography/otspec/kern.htm says that - // "OpenType™ fonts containing CFF outlines are not supported by the 'kern' - // table and must use the 'GPOS' OpenType Layout table." - - if n := f.NumGlyphs(); int(x0) >= n || int(x1) >= n { - return 0, ErrNotFound - } - // Not every font has a kern table. If it doesn't, or if that table is - // ignored, there's no need to allocate a Buffer. - if f.cached.kernNumPairs == 0 { - return 0, nil - } - if b == nil { - b = &Buffer{} - } - - key := uint32(x0)<<16 | uint32(x1) - lo, hi := int32(0), f.cached.kernNumPairs - for lo < hi { - i := (lo + hi) / 2 - - // TODO: this view call inside the inner loop can lead to many small - // reads instead of fewer larger reads, which can be expensive. We - // should be able to do better, although we don't want to make (one) - // arbitrarily large read. Perhaps we should round up reads to 4K or 8K - // chunks. For reference, Arial.ttf's kern table is 5472 bytes. - // Times_New_Roman.ttf's kern table is 5220 bytes. - const entrySize = 6 - buf, err := b.view(&f.src, int(f.cached.kernOffset+i*entrySize), entrySize) - if err != nil { - return 0, err - } - - k := u32(buf) - if k < key { - lo = i + 1 - } else if k > key { - hi = i - } else { - kern := fixed.Int26_6(int16(u16(buf[4:]))) - kern = scale(kern*ppem, f.cached.unitsPerEm) - if h == font.HintingFull { - // Quantize the fixed.Int26_6 value to the nearest pixel. - kern = (kern + 32) &^ 63 - } - return kern, nil - } - } - return 0, nil -} - -// Metrics returns the metrics of this font. -func (f *Font) Metrics(b *Buffer, ppem fixed.Int26_6, h font.Hinting) (font.Metrics, error) { - m := font.Metrics{ - Height: scale(fixed.Int26_6(f.cached.ascent-f.cached.descent+f.cached.lineGap)*ppem, f.cached.unitsPerEm), - Ascent: +scale(fixed.Int26_6(f.cached.ascent)*ppem, f.cached.unitsPerEm), - Descent: -scale(fixed.Int26_6(f.cached.descent)*ppem, f.cached.unitsPerEm), - } - if h == font.HintingFull { - // Quantize up to a whole pixel. - m.Height = (m.Height + 63) &^ 63 - m.Ascent = (m.Ascent + 63) &^ 63 - m.Descent = (m.Descent + 63) &^ 63 - } - return m, nil -} - -// Name returns the name value keyed by the given NameID. -// -// It returns ErrNotFound if there is no value for that key. -func (f *Font) Name(b *Buffer, id NameID) (string, error) { - if b == nil { - b = &Buffer{} - } - - const headerSize, entrySize = 6, 12 - if f.name.length < headerSize { - return "", errInvalidNameTable - } - buf, err := b.view(&f.src, int(f.name.offset), headerSize) - if err != nil { - return "", err - } - numSubtables := u16(buf[2:]) - if f.name.length < headerSize+entrySize*uint32(numSubtables) { - return "", errInvalidNameTable - } - stringOffset := u16(buf[4:]) - - seen := false - for i, n := 0, int(numSubtables); i < n; i++ { - buf, err := b.view(&f.src, int(f.name.offset)+headerSize+entrySize*i, entrySize) - if err != nil { - return "", err - } - if u16(buf[6:]) != uint16(id) { - continue - } - seen = true - - var stringify func([]byte) (string, error) - switch u32(buf) { - default: - continue - case pidMacintosh<<16 | psidMacintoshRoman: - stringify = stringifyMacintosh - case pidWindows<<16 | psidWindowsUCS2: - stringify = stringifyUCS2 - } - - nameLength := u16(buf[8:]) - nameOffset := u16(buf[10:]) - buf, err = b.view(&f.src, int(f.name.offset)+int(nameOffset)+int(stringOffset), int(nameLength)) - if err != nil { - return "", err - } - return stringify(buf) - } - - if seen { - return "", errUnsupportedPlatformEncoding - } - return "", ErrNotFound -} - -func stringifyMacintosh(b []byte) (string, error) { - for _, c := range b { - if c >= 0x80 { - // b contains some non-ASCII bytes. - s, _ := charmap.Macintosh.NewDecoder().Bytes(b) - return string(s), nil - } - } - // b contains only ASCII bytes. - return string(b), nil -} - -func stringifyUCS2(b []byte) (string, error) { - if len(b)&1 != 0 { - return "", errInvalidUCS2String - } - r := make([]rune, len(b)/2) - for i := range r { - r[i] = rune(u16(b)) - b = b[2:] - } - return string(r), nil -} - -// Buffer holds re-usable buffers that can reduce the total memory allocation -// of repeated Font method calls. -// -// See the Font type's documentation comment for more details. -type Buffer struct { - // buf is a byte buffer for when a Font's source is an io.ReaderAt. - buf []byte - // segments holds glyph vector path segments. - segments []Segment - // compoundStack holds the components of a TrueType compound glyph. - compoundStack [maxCompoundStackSize]struct { - glyphIndex GlyphIndex - dx, dy int16 - hasTransform bool - transformXX int16 - transformXY int16 - transformYX int16 - transformYY int16 - } - // psi is a PostScript interpreter for when the Font is an OpenType/CFF - // font. - psi psInterpreter -} - -func (b *Buffer) view(src *source, offset, length int) ([]byte, error) { - buf, err := src.view(b.buf, offset, length) - if err != nil { - return nil, err - } - // Only update b.buf if it is safe to re-use buf. - if src.viewBufferWritable() { - b.buf = buf - } - return buf, nil -} - -// Segment is a segment of a vector path. -type Segment struct { - // Op is the operator. - Op SegmentOp - // Args is up to three (x, y) coordinates. The Y axis increases down. - Args [3]fixed.Point26_6 -} - -// SegmentOp is a vector path segment's operator. -type SegmentOp uint32 - -const ( - SegmentOpMoveTo SegmentOp = iota - SegmentOpLineTo - SegmentOpQuadTo - SegmentOpCubeTo -) - -// translateArgs applies a translation to args. -func translateArgs(args *[3]fixed.Point26_6, dx, dy fixed.Int26_6) { - args[0].X += dx - args[0].Y += dy - args[1].X += dx - args[1].Y += dy - args[2].X += dx - args[2].Y += dy -} - -// transformArgs applies an affine transformation to args. The t?? arguments -// are 2.14 fixed point values. -func transformArgs(args *[3]fixed.Point26_6, txx, txy, tyx, tyy int16, dx, dy fixed.Int26_6) { - args[0] = tform(txx, txy, tyx, tyy, dx, dy, args[0]) - args[1] = tform(txx, txy, tyx, tyy, dx, dy, args[1]) - args[2] = tform(txx, txy, tyx, tyy, dx, dy, args[2]) -} - -func tform(txx, txy, tyx, tyy int16, dx, dy fixed.Int26_6, p fixed.Point26_6) fixed.Point26_6 { - const half = 1 << 13 - return fixed.Point26_6{ - X: dx + - fixed.Int26_6((int64(p.X)*int64(txx)+half)>>14) + - fixed.Int26_6((int64(p.Y)*int64(tyx)+half)>>14), - Y: dy + - fixed.Int26_6((int64(p.X)*int64(txy)+half)>>14) + - fixed.Int26_6((int64(p.Y)*int64(tyy)+half)>>14), - } -} diff --git a/vendor/golang.org/x/image/font/sfnt/truetype.go b/vendor/golang.org/x/image/font/sfnt/truetype.go deleted file mode 100644 index ab27f5b..0000000 --- a/vendor/golang.org/x/image/font/sfnt/truetype.go +++ /dev/null @@ -1,572 +0,0 @@ -// Copyright 2017 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package sfnt - -import ( - "golang.org/x/image/math/fixed" -) - -// Flags for simple (non-compound) glyphs. -// -// See https://www.microsoft.com/typography/OTSPEC/glyf.htm -const ( - flagOnCurve = 1 << 0 // 0x0001 - flagXShortVector = 1 << 1 // 0x0002 - flagYShortVector = 1 << 2 // 0x0004 - flagRepeat = 1 << 3 // 0x0008 - - // The same flag bits are overloaded to have two meanings, dependent on the - // value of the flag{X,Y}ShortVector bits. - flagPositiveXShortVector = 1 << 4 // 0x0010 - flagThisXIsSame = 1 << 4 // 0x0010 - flagPositiveYShortVector = 1 << 5 // 0x0020 - flagThisYIsSame = 1 << 5 // 0x0020 -) - -// Flags for compound glyphs. -// -// See https://www.microsoft.com/typography/OTSPEC/glyf.htm -const ( - flagArg1And2AreWords = 1 << 0 // 0x0001 - flagArgsAreXYValues = 1 << 1 // 0x0002 - flagRoundXYToGrid = 1 << 2 // 0x0004 - flagWeHaveAScale = 1 << 3 // 0x0008 - flagReserved4 = 1 << 4 // 0x0010 - flagMoreComponents = 1 << 5 // 0x0020 - flagWeHaveAnXAndYScale = 1 << 6 // 0x0040 - flagWeHaveATwoByTwo = 1 << 7 // 0x0080 - flagWeHaveInstructions = 1 << 8 // 0x0100 - flagUseMyMetrics = 1 << 9 // 0x0200 - flagOverlapCompound = 1 << 10 // 0x0400 - flagScaledComponentOffset = 1 << 11 // 0x0800 - flagUnscaledComponentOffset = 1 << 12 // 0x1000 -) - -func midPoint(p, q fixed.Point26_6) fixed.Point26_6 { - return fixed.Point26_6{ - X: (p.X + q.X) / 2, - Y: (p.Y + q.Y) / 2, - } -} - -func parseLoca(src *source, loca table, glyfOffset uint32, indexToLocFormat bool, numGlyphs int32) (locations []uint32, err error) { - if indexToLocFormat { - if loca.length != 4*uint32(numGlyphs+1) { - return nil, errInvalidLocaTable - } - } else { - if loca.length != 2*uint32(numGlyphs+1) { - return nil, errInvalidLocaTable - } - } - - locations = make([]uint32, numGlyphs+1) - buf, err := src.view(nil, int(loca.offset), int(loca.length)) - if err != nil { - return nil, err - } - - if indexToLocFormat { - for i := range locations { - locations[i] = 1*uint32(u32(buf[4*i:])) + glyfOffset - } - } else { - for i := range locations { - locations[i] = 2*uint32(u16(buf[2*i:])) + glyfOffset - } - } - return locations, err -} - -// https://www.microsoft.com/typography/OTSPEC/glyf.htm says that "Each -// glyph begins with the following [10 byte] header". -const glyfHeaderLen = 10 - -func loadGlyf(f *Font, b *Buffer, x GlyphIndex, stackBottom, recursionDepth uint32) error { - data, _, _, err := f.viewGlyphData(b, x) - if err != nil { - return err - } - if len(data) == 0 { - return nil - } - if len(data) < glyfHeaderLen { - return errInvalidGlyphData - } - index := glyfHeaderLen - - numContours, numPoints := int16(u16(data)), 0 - switch { - case numContours == -1: - // We have a compound glyph. No-op. - case numContours == 0: - return nil - case numContours > 0: - // We have a simple (non-compound) glyph. - index += 2 * int(numContours) - if index > len(data) { - return errInvalidGlyphData - } - // The +1 for numPoints is because the value in the file format is - // inclusive, but Go's slice[:index] semantics are exclusive. - numPoints = 1 + int(u16(data[index-2:])) - default: - return errInvalidGlyphData - } - - if numContours < 0 { - return loadCompoundGlyf(f, b, data[glyfHeaderLen:], stackBottom, recursionDepth) - } - - // Skip the hinting instructions. - index += 2 - if index > len(data) { - return errInvalidGlyphData - } - hintsLength := int(u16(data[index-2:])) - index += hintsLength - if index > len(data) { - return errInvalidGlyphData - } - - // For simple (non-compound) glyphs, the remainder of the glyf data - // consists of (flags, x, y) points: the Bézier curve segments. These are - // stored in columns (all the flags first, then all the x coordinates, then - // all the y coordinates), not rows, as it compresses better. - // - // Decoding those points in row order involves two passes. The first pass - // determines the indexes (relative to the data slice) of where the flags, - // the x coordinates and the y coordinates each start. - flagIndex := int32(index) - xIndex, yIndex, ok := findXYIndexes(data, index, numPoints) - if !ok { - return errInvalidGlyphData - } - - // The second pass decodes each (flags, x, y) tuple in row order. - g := glyfIter{ - data: data, - flagIndex: flagIndex, - xIndex: xIndex, - yIndex: yIndex, - endIndex: glyfHeaderLen, - // The -1 is because the contour-end index in the file format is - // inclusive, but Go's slice[:index] semantics are exclusive. - prevEnd: -1, - numContours: int32(numContours), - } - for g.nextContour() { - for g.nextSegment() { - b.segments = append(b.segments, g.seg) - } - } - return g.err -} - -func findXYIndexes(data []byte, index, numPoints int) (xIndex, yIndex int32, ok bool) { - xDataLen := 0 - yDataLen := 0 - for i := 0; ; { - if i > numPoints { - return 0, 0, false - } - if i == numPoints { - break - } - - repeatCount := 1 - if index >= len(data) { - return 0, 0, false - } - flag := data[index] - index++ - if flag&flagRepeat != 0 { - if index >= len(data) { - return 0, 0, false - } - repeatCount += int(data[index]) - index++ - } - - xSize := 0 - if flag&flagXShortVector != 0 { - xSize = 1 - } else if flag&flagThisXIsSame == 0 { - xSize = 2 - } - xDataLen += xSize * repeatCount - - ySize := 0 - if flag&flagYShortVector != 0 { - ySize = 1 - } else if flag&flagThisYIsSame == 0 { - ySize = 2 - } - yDataLen += ySize * repeatCount - - i += repeatCount - } - if index+xDataLen+yDataLen > len(data) { - return 0, 0, false - } - return int32(index), int32(index + xDataLen), true -} - -func loadCompoundGlyf(f *Font, b *Buffer, data []byte, stackBottom, recursionDepth uint32) error { - if recursionDepth++; recursionDepth == maxCompoundRecursionDepth { - return errUnsupportedCompoundGlyph - } - - // Read and process the compound glyph's components. They are two separate - // for loops, since reading parses the elements of the data slice, and - // processing can overwrite the backing array. - - stackTop := stackBottom - for { - if stackTop >= maxCompoundStackSize { - return errUnsupportedCompoundGlyph - } - elem := &b.compoundStack[stackTop] - stackTop++ - - if len(data) < 4 { - return errInvalidGlyphData - } - flags := u16(data) - elem.glyphIndex = GlyphIndex(u16(data[2:])) - if flags&flagArg1And2AreWords == 0 { - if len(data) < 6 { - return errInvalidGlyphData - } - elem.dx = int16(int8(data[4])) - elem.dy = int16(int8(data[5])) - data = data[6:] - } else { - if len(data) < 8 { - return errInvalidGlyphData - } - elem.dx = int16(u16(data[4:])) - elem.dy = int16(u16(data[6:])) - data = data[8:] - } - - if flags&flagArgsAreXYValues == 0 { - return errUnsupportedCompoundGlyph - } - elem.hasTransform = flags&(flagWeHaveAScale|flagWeHaveAnXAndYScale|flagWeHaveATwoByTwo) != 0 - if elem.hasTransform { - switch { - case flags&flagWeHaveAScale != 0: - if len(data) < 2 { - return errInvalidGlyphData - } - elem.transformXX = int16(u16(data)) - elem.transformXY = 0 - elem.transformYX = 0 - elem.transformYY = elem.transformXX - data = data[2:] - case flags&flagWeHaveAnXAndYScale != 0: - if len(data) < 4 { - return errInvalidGlyphData - } - elem.transformXX = int16(u16(data[0:])) - elem.transformXY = 0 - elem.transformYX = 0 - elem.transformYY = int16(u16(data[2:])) - data = data[4:] - case flags&flagWeHaveATwoByTwo != 0: - if len(data) < 8 { - return errInvalidGlyphData - } - elem.transformXX = int16(u16(data[0:])) - elem.transformXY = int16(u16(data[2:])) - elem.transformYX = int16(u16(data[4:])) - elem.transformYY = int16(u16(data[6:])) - data = data[8:] - } - } - - if flags&flagMoreComponents == 0 { - break - } - } - - // To support hinting, we'd have to save the remaining bytes in data here - // and interpret them after the for loop below, since that for loop's - // loadGlyf calls can overwrite the backing array. - - for i := stackBottom; i < stackTop; i++ { - elem := &b.compoundStack[i] - base := len(b.segments) - if err := loadGlyf(f, b, elem.glyphIndex, stackTop, recursionDepth); err != nil { - return err - } - dx, dy := fixed.Int26_6(elem.dx), fixed.Int26_6(elem.dy) - segs := b.segments[base:] - if elem.hasTransform { - txx := elem.transformXX - txy := elem.transformXY - tyx := elem.transformYX - tyy := elem.transformYY - for j := range segs { - transformArgs(&segs[j].Args, txx, txy, tyx, tyy, dx, dy) - } - } else { - for j := range segs { - translateArgs(&segs[j].Args, dx, dy) - } - } - } - - return nil -} - -type glyfIter struct { - data []byte - err error - - // Various indices into the data slice. See the "Decoding those points in - // row order" comment above. - flagIndex int32 - xIndex int32 - yIndex int32 - - // endIndex points to the uint16 that is the inclusive point index of the - // current contour's end. prevEnd is the previous contour's end. - endIndex int32 - prevEnd int32 - - // c and p count the current contour and point, up to numContours and - // numPoints. - c, numContours int32 - p, nPoints int32 - - // The next two groups of fields track points and segments. Points are what - // the underlying file format provides. Bézier curve segments are what the - // rasterizer consumes. - // - // Points are either on-curve or off-curve. Two consecutive on-curve points - // define a linear curve segment between them. N off-curve points between - // on-curve points define N quadratic curve segments. The TrueType glyf - // format does not use cubic curves. If N is greater than 1, some of these - // segment end points are implicit, the midpoint of two off-curve points. - // Given the points A, B1, B2, ..., BN, C, where A and C are on-curve and - // all the Bs are off-curve, the segments are: - // - // - A, B1, midpoint(B1, B2) - // - midpoint(B1, B2), B2, midpoint(B2, B3) - // - midpoint(B2, B3), B3, midpoint(B3, B4) - // - ... - // - midpoint(BN-1, BN), BN, C - // - // Note that the sequence of Bs may wrap around from the last point in the - // glyf data to the first. A and C may also be the same point (the only - // explicit on-curve point), or there may be no explicit on-curve points at - // all (but still implicit ones between explicit off-curve points). - - // Points. - x, y int16 - on bool - flag uint8 - repeats uint8 - - // Segments. - closing bool - closed bool - firstOnCurveValid bool - firstOffCurveValid bool - lastOffCurveValid bool - firstOnCurve fixed.Point26_6 - firstOffCurve fixed.Point26_6 - lastOffCurve fixed.Point26_6 - seg Segment -} - -func (g *glyfIter) nextContour() (ok bool) { - if g.c == g.numContours { - return false - } - g.c++ - - end := int32(u16(g.data[g.endIndex:])) - g.endIndex += 2 - if end <= g.prevEnd { - g.err = errInvalidGlyphData - return false - } - g.nPoints = end - g.prevEnd - g.p = 0 - g.prevEnd = end - - g.closing = false - g.closed = false - g.firstOnCurveValid = false - g.firstOffCurveValid = false - g.lastOffCurveValid = false - - return true -} - -func (g *glyfIter) close() { - switch { - case !g.firstOffCurveValid && !g.lastOffCurveValid: - g.closed = true - g.seg = Segment{ - Op: SegmentOpLineTo, - Args: [3]fixed.Point26_6{g.firstOnCurve}, - } - case !g.firstOffCurveValid && g.lastOffCurveValid: - g.closed = true - g.seg = Segment{ - Op: SegmentOpQuadTo, - Args: [3]fixed.Point26_6{g.lastOffCurve, g.firstOnCurve}, - } - case g.firstOffCurveValid && !g.lastOffCurveValid: - g.closed = true - g.seg = Segment{ - Op: SegmentOpQuadTo, - Args: [3]fixed.Point26_6{g.firstOffCurve, g.firstOnCurve}, - } - case g.firstOffCurveValid && g.lastOffCurveValid: - g.lastOffCurveValid = false - g.seg = Segment{ - Op: SegmentOpQuadTo, - Args: [3]fixed.Point26_6{ - g.lastOffCurve, - midPoint(g.lastOffCurve, g.firstOffCurve), - }, - } - } -} - -func (g *glyfIter) nextSegment() (ok bool) { - for !g.closed { - if g.closing || !g.nextPoint() { - g.closing = true - g.close() - return true - } - - // Convert the tuple (g.x, g.y) to a fixed.Point26_6, since the latter - // is what's held in a Segment. The input (g.x, g.y) is a pair of int16 - // values, measured in font units, since that is what the underlying - // format provides. The output is a pair of fixed.Int26_6 values. A - // fixed.Int26_6 usually represents a 26.6 fixed number of pixels, but - // this here is just a straight numerical conversion, with no scaling - // factor. A later step scales the Segment.Args values by such a factor - // to convert e.g. 1792 font units to 10.5 pixels at 2048 font units - // per em and 12 ppem (pixels per em). - p := fixed.Point26_6{ - X: fixed.Int26_6(g.x), - Y: fixed.Int26_6(g.y), - } - - if !g.firstOnCurveValid { - if g.on { - g.firstOnCurve = p - g.firstOnCurveValid = true - g.seg = Segment{ - Op: SegmentOpMoveTo, - Args: [3]fixed.Point26_6{p}, - } - return true - } else if !g.firstOffCurveValid { - g.firstOffCurve = p - g.firstOffCurveValid = true - continue - } else { - g.firstOnCurve = midPoint(g.firstOffCurve, p) - g.firstOnCurveValid = true - g.lastOffCurve = p - g.lastOffCurveValid = true - g.seg = Segment{ - Op: SegmentOpMoveTo, - Args: [3]fixed.Point26_6{g.firstOnCurve}, - } - return true - } - - } else if !g.lastOffCurveValid { - if !g.on { - g.lastOffCurve = p - g.lastOffCurveValid = true - continue - } else { - g.seg = Segment{ - Op: SegmentOpLineTo, - Args: [3]fixed.Point26_6{p}, - } - return true - } - - } else { - if !g.on { - g.seg = Segment{ - Op: SegmentOpQuadTo, - Args: [3]fixed.Point26_6{ - g.lastOffCurve, - midPoint(g.lastOffCurve, p), - }, - } - g.lastOffCurve = p - g.lastOffCurveValid = true - return true - } else { - g.seg = Segment{ - Op: SegmentOpQuadTo, - Args: [3]fixed.Point26_6{g.lastOffCurve, p}, - } - g.lastOffCurveValid = false - return true - } - } - } - return false -} - -func (g *glyfIter) nextPoint() (ok bool) { - if g.p == g.nPoints { - return false - } - g.p++ - - if g.repeats > 0 { - g.repeats-- - } else { - g.flag = g.data[g.flagIndex] - g.flagIndex++ - if g.flag&flagRepeat != 0 { - g.repeats = g.data[g.flagIndex] - g.flagIndex++ - } - } - - if g.flag&flagXShortVector != 0 { - if g.flag&flagPositiveXShortVector != 0 { - g.x += int16(g.data[g.xIndex]) - } else { - g.x -= int16(g.data[g.xIndex]) - } - g.xIndex += 1 - } else if g.flag&flagThisXIsSame == 0 { - g.x += int16(u16(g.data[g.xIndex:])) - g.xIndex += 2 - } - - if g.flag&flagYShortVector != 0 { - if g.flag&flagPositiveYShortVector != 0 { - g.y += int16(g.data[g.yIndex]) - } else { - g.y -= int16(g.data[g.yIndex]) - } - g.yIndex += 1 - } else if g.flag&flagThisYIsSame == 0 { - g.y += int16(u16(g.data[g.yIndex:])) - g.yIndex += 2 - } - - g.on = g.flag&flagOnCurve != 0 - return true -} -- cgit v1.2.3