aboutsummaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/image/font/sfnt/cmap.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/image/font/sfnt/cmap.go')
-rw-r--r--vendor/golang.org/x/image/font/sfnt/cmap.go259
1 files changed, 0 insertions, 259 deletions
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
-}