551 lines
16 KiB
Go
551 lines
16 KiB
Go
|
// Copyright 2019 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 (
|
||
|
|
"sort"
|
||
|
|
)
|
||
|
|
|
||
|
|
const (
|
||
|
|
hexScriptLatn = uint32(0x6c61746e) // latn
|
||
|
|
hexScriptDFLT = uint32(0x44464c54) // DFLT
|
||
|
|
hexFeatureKern = uint32(0x6b65726e) // kern
|
||
|
|
)
|
||
|
|
|
||
|
|
//kernFunc returns the unscaled kerning value for kerning pair a+b.
|
||
|
|
// Returns ErrNotFound if no kerning is specified for this pair.
|
||
|
|
type kernFunc func(a, b GlyphIndex) (int16, error)
|
||
|
|
|
||
|
|
func (f *Font) parseGPOSKern(buf []byte) ([]byte, []kernFunc, error) {
|
||
|
|
// https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
|
||
|
|
|
||
|
|
if f.gpos.length == 0 {
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
const headerSize = 10 // GPOS header v1.1 is 14 bytes, but we don't support FeatureVariations
|
||
|
|
if f.gpos.length < headerSize {
|
||
|
|
return buf, nil, errInvalidGPOSTable
|
||
|
|
}
|
||
|
|
|
||
|
|
buf, err := f.src.view(buf, int(f.gpos.offset), headerSize)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// check for version 1.0/1.1
|
||
|
|
if u16(buf) != 1 || u16(buf[2:]) > 1 {
|
||
|
|
return buf, nil, errUnsupportedGPOSTable
|
||
|
|
}
|
||
|
|
scriptListOffset := u16(buf[4:])
|
||
|
|
featureListOffset := u16(buf[6:])
|
||
|
|
lookupListOffset := u16(buf[8:])
|
||
|
|
|
||
|
|
// get all feature indices for latn script
|
||
|
|
buf, featureIdxs, err := f.parseGPOSScriptFeatures(buf, int(f.gpos.offset)+int(scriptListOffset), hexScriptLatn)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
if len(featureIdxs) == 0 {
|
||
|
|
// get all feature indices for DFLT script
|
||
|
|
buf, featureIdxs, err = f.parseGPOSScriptFeatures(buf, int(f.gpos.offset)+int(scriptListOffset), hexScriptDFLT)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
if len(featureIdxs) == 0 {
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// get all lookup indices for kern features
|
||
|
|
buf, lookupIdx, err := f.parseGPOSFeaturesLookup(buf, int(f.gpos.offset)+int(featureListOffset), featureIdxs, hexFeatureKern)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// LookupTableList: lookupCount,[]lookups
|
||
|
|
buf, numLookupTables, err := f.src.varLenView(buf, int(f.gpos.offset)+int(lookupListOffset), 2, 0, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
var kernFuncs []kernFunc
|
||
|
|
|
||
|
|
lookupTables:
|
||
|
|
for _, n := range lookupIdx {
|
||
|
|
if n > numLookupTables {
|
||
|
|
return buf, nil, errInvalidGPOSTable
|
||
|
|
}
|
||
|
|
tableOffset := int(f.gpos.offset) + int(lookupListOffset) + int(u16(buf[2+n*2:]))
|
||
|
|
|
||
|
|
// LookupTable: lookupType, lookupFlag, subTableCount, []subtableOffsets, markFilteringSet
|
||
|
|
buf, numSubTables, err := f.src.varLenView(buf, tableOffset, 8, 4, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
flags := u16(buf[2:])
|
||
|
|
|
||
|
|
subTableOffsets := make([]int, numSubTables)
|
||
|
|
for i := 0; i < int(numSubTables); i++ {
|
||
|
|
subTableOffsets[i] = int(tableOffset) + int(u16(buf[6+i*2:]))
|
||
|
|
}
|
||
|
|
|
||
|
|
switch lookupType := u16(buf); lookupType {
|
||
|
|
case 2: // PairPos table
|
||
|
|
case 9:
|
||
|
|
// Extension Positioning table defines an additional u32 offset
|
||
|
|
// to allow subtables to exceed the 16-bit limit.
|
||
|
|
for i := range subTableOffsets {
|
||
|
|
buf, err = f.src.view(buf, subTableOffsets[i], 8)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
if format := u16(buf); format != 1 {
|
||
|
|
return buf, nil, errUnsupportedExtensionPosFormat
|
||
|
|
}
|
||
|
|
if lookupType := u16(buf[2:]); lookupType != 2 {
|
||
|
|
continue lookupTables
|
||
|
|
}
|
||
|
|
subTableOffsets[i] += int(u32(buf[4:]))
|
||
|
|
}
|
||
|
|
default: // other types are not supported
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
if flags&0x0010 > 0 {
|
||
|
|
// useMarkFilteringSet enabled, skip as it is not supported
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, subTableOffset := range subTableOffsets {
|
||
|
|
buf, err = f.src.view(buf, int(subTableOffset), 4)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
format := u16(buf)
|
||
|
|
|
||
|
|
var lookupIndex indexLookupFunc
|
||
|
|
buf, lookupIndex, err = f.makeCachedCoverageLookup(buf, subTableOffset+int(u16(buf[2:])))
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
switch format {
|
||
|
|
case 1: // Adjustments for Glyph Pairs
|
||
|
|
buf, kern, err := f.parsePairPosFormat1(buf, subTableOffset, lookupIndex)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
if kern != nil {
|
||
|
|
kernFuncs = append(kernFuncs, kern)
|
||
|
|
}
|
||
|
|
case 2: // Class Pair Adjustment
|
||
|
|
buf, kern, err := f.parsePairPosFormat2(buf, subTableOffset, lookupIndex)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
if kern != nil {
|
||
|
|
kernFuncs = append(kernFuncs, kern)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return buf, kernFuncs, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (f *Font) parsePairPosFormat1(buf []byte, offset int, lookupIndex indexLookupFunc) ([]byte, kernFunc, error) {
|
||
|
|
// PairPos Format 1: posFormat, coverageOffset, valueFormat1,
|
||
|
|
// valueFormat2, pairSetCount, []pairSetOffsets
|
||
|
|
var err error
|
||
|
|
var nPairs int
|
||
|
|
buf, nPairs, err = f.src.varLenView(buf, offset, 10, 8, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
// check valueFormat1 and valueFormat2 flags
|
||
|
|
if u16(buf[4:]) != 0x04 || u16(buf[6:]) != 0x00 {
|
||
|
|
// we only support kerning with X_ADVANCE for first glyph
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// PairPos table contains an array of offsets to PairSet
|
||
|
|
// tables, which contains an array of PairValueRecords.
|
||
|
|
// Calculate length of complete PairPos table by jumping to
|
||
|
|
// last PairSet.
|
||
|
|
// We need to iterate all offsets to find the last pair as
|
||
|
|
// offsets are not sorted and can be repeated.
|
||
|
|
var lastPairSetOffset int
|
||
|
|
for n := 0; n < nPairs; n++ {
|
||
|
|
pairOffset := int(u16(buf[10+n*2:]))
|
||
|
|
if pairOffset > lastPairSetOffset {
|
||
|
|
lastPairSetOffset = pairOffset
|
||
|
|
}
|
||
|
|
}
|
||
|
|
buf, err = f.src.view(buf, offset+lastPairSetOffset, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
pairValueCount := int(u16(buf))
|
||
|
|
// Each PairSet contains the secondGlyph (u16) and one or more value records (all u16).
|
||
|
|
// We only support lookup tables with one value record (X_ADVANCE, see valueFormat1/2 above).
|
||
|
|
lastPairSetLength := 2 + pairValueCount*4
|
||
|
|
|
||
|
|
length := lastPairSetOffset + lastPairSetLength
|
||
|
|
buf, err = f.src.view(buf, offset, length)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
kern := makeCachedPairPosGlyph(lookupIndex, nPairs, buf)
|
||
|
|
return buf, kern, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (f *Font) parsePairPosFormat2(buf []byte, offset int, lookupIndex indexLookupFunc) ([]byte, kernFunc, error) {
|
||
|
|
// PairPos Format 2:
|
||
|
|
// posFormat, coverageOffset, valueFormat1, valueFormat2,
|
||
|
|
// classDef1Offset, classDef2Offset, class1Count, class2Count,
|
||
|
|
// []class1Records
|
||
|
|
var err error
|
||
|
|
buf, err = f.src.view(buf, offset, 16)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
// check valueFormat1 and valueFormat2 flags
|
||
|
|
if u16(buf[4:]) != 0x04 || u16(buf[6:]) != 0x00 {
|
||
|
|
// we only support kerning with X_ADVANCE for first glyph
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
numClass1 := int(u16(buf[12:]))
|
||
|
|
numClass2 := int(u16(buf[14:]))
|
||
|
|
cdef1Offset := offset + int(u16(buf[8:]))
|
||
|
|
cdef2Offset := offset + int(u16(buf[10:]))
|
||
|
|
var cdef1, cdef2 classLookupFunc
|
||
|
|
buf, cdef1, err = f.makeCachedClassLookup(buf, cdef1Offset)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
buf, cdef2, err = f.makeCachedClassLookup(buf, cdef2Offset)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
buf, err = f.src.view(buf, offset+16, numClass1*numClass2*2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
kern := makeCachedPairPosClass(
|
||
|
|
lookupIndex,
|
||
|
|
numClass1,
|
||
|
|
numClass2,
|
||
|
|
cdef1,
|
||
|
|
cdef2,
|
||
|
|
buf,
|
||
|
|
)
|
||
|
|
|
||
|
|
return buf, kern, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// parseGPOSScriptFeatures returns all indices of features in FeatureTable that
|
||
|
|
// are valid for the given script.
|
||
|
|
// Returns features from DefaultLangSys, different languages are not supported.
|
||
|
|
// However, all observed fonts either do not use different languages or use the
|
||
|
|
// same features as DefaultLangSys.
|
||
|
|
func (f *Font) parseGPOSScriptFeatures(buf []byte, offset int, script uint32) ([]byte, []int, error) {
|
||
|
|
// ScriptList table: scriptCount, []scriptRecords{scriptTag, scriptOffset}
|
||
|
|
buf, numScriptTables, err := f.src.varLenView(buf, offset, 2, 0, 6)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
// Search ScriptTables for script
|
||
|
|
var scriptTableOffset uint16
|
||
|
|
for i := 0; i < numScriptTables; i++ {
|
||
|
|
scriptTag := u32(buf[2+i*6:])
|
||
|
|
if scriptTag == script {
|
||
|
|
scriptTableOffset = u16(buf[2+i*6+4:])
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if scriptTableOffset == 0 {
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// Script table: defaultLangSys, langSysCount, []langSysRecords{langSysTag, langSysOffset}
|
||
|
|
buf, err = f.src.view(buf, offset+int(scriptTableOffset), 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
defaultLangSysOffset := u16(buf)
|
||
|
|
|
||
|
|
if defaultLangSysOffset == 0 {
|
||
|
|
return buf, nil, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// LangSys table: lookupOrder (reserved), requiredFeatureIndex, featureIndexCount, []featureIndices
|
||
|
|
buf, numFeatures, err := f.src.varLenView(buf, offset+int(scriptTableOffset)+int(defaultLangSysOffset), 6, 4, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
featureIdxs := make([]int, numFeatures)
|
||
|
|
for i := range featureIdxs {
|
||
|
|
featureIdxs[i] = int(u16(buf[6+i*2:]))
|
||
|
|
}
|
||
|
|
return buf, featureIdxs, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (f *Font) parseGPOSFeaturesLookup(buf []byte, offset int, featureIdxs []int, feature uint32) ([]byte, []int, error) {
|
||
|
|
// FeatureList table: featureCount, []featureRecords{featureTag, featureOffset}
|
||
|
|
buf, numFeatureTables, err := f.src.varLenView(buf, offset, 2, 0, 6)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
lookupIdx := make([]int, 0, 4)
|
||
|
|
|
||
|
|
for _, fidx := range featureIdxs {
|
||
|
|
if fidx > numFeatureTables {
|
||
|
|
return buf, nil, errInvalidGPOSTable
|
||
|
|
}
|
||
|
|
featureTag := u32(buf[2+fidx*6:])
|
||
|
|
if featureTag != feature {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
featureOffset := u16(buf[2+fidx*6+4:])
|
||
|
|
|
||
|
|
buf, numLookups, err := f.src.varLenView(nil, offset+int(featureOffset), 4, 2, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
|
||
|
|
for i := 0; i < numLookups; i++ {
|
||
|
|
lookupIdx = append(lookupIdx, int(u16(buf[4+i*2:])))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return buf, lookupIdx, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedPairPosGlyph(cov indexLookupFunc, num int, buf []byte) kernFunc {
|
||
|
|
glyphs := make([]byte, len(buf))
|
||
|
|
copy(glyphs, buf)
|
||
|
|
return func(a, b GlyphIndex) (int16, error) {
|
||
|
|
idx, found := cov(a)
|
||
|
|
if !found {
|
||
|
|
return 0, ErrNotFound
|
||
|
|
}
|
||
|
|
if idx >= num {
|
||
|
|
return 0, ErrNotFound
|
||
|
|
}
|
||
|
|
offset := int(u16(glyphs[10+idx*2:]))
|
||
|
|
if offset+1 >= len(glyphs) {
|
||
|
|
return 0, errInvalidGPOSTable
|
||
|
|
}
|
||
|
|
|
||
|
|
count := int(u16(glyphs[offset:]))
|
||
|
|
for i := 0; i < count; i++ {
|
||
|
|
secondGlyphIndex := GlyphIndex(int(u16(glyphs[offset+2+i*4:])))
|
||
|
|
if secondGlyphIndex == b {
|
||
|
|
return int16(u16(glyphs[offset+2+i*4+2:])), nil
|
||
|
|
}
|
||
|
|
if secondGlyphIndex > b {
|
||
|
|
return 0, ErrNotFound
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0, ErrNotFound
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedPairPosClass(cov indexLookupFunc, num1, num2 int, cdef1, cdef2 classLookupFunc, buf []byte) kernFunc {
|
||
|
|
glyphs := make([]byte, len(buf))
|
||
|
|
copy(glyphs, buf)
|
||
|
|
return func(a, b GlyphIndex) (int16, error) {
|
||
|
|
// check coverage to avoid selection of default class 0
|
||
|
|
_, found := cov(a)
|
||
|
|
if !found {
|
||
|
|
return 0, ErrNotFound
|
||
|
|
}
|
||
|
|
idxa := cdef1(a)
|
||
|
|
idxb := cdef2(b)
|
||
|
|
return int16(u16(glyphs[(idxb+idxa*num2)*2:])), nil
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// indexLookupFunc returns the index into a PairPos table for the provided glyph.
|
||
|
|
// Returns false if the glyph is not covered by this lookup.
|
||
|
|
type indexLookupFunc func(GlyphIndex) (int, bool)
|
||
|
|
|
||
|
|
func (f *Font) makeCachedCoverageLookup(buf []byte, offset int) ([]byte, indexLookupFunc, error) {
|
||
|
|
var err error
|
||
|
|
buf, err = f.src.view(buf, offset, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
switch u16(buf) {
|
||
|
|
case 1:
|
||
|
|
// Coverage Format 1: coverageFormat, glyphCount, []glyphArray
|
||
|
|
buf, _, err = f.src.varLenView(buf, offset, 4, 2, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
return buf, makeCachedCoverageList(buf[2:]), nil
|
||
|
|
case 2:
|
||
|
|
// Coverage Format 2: coverageFormat, rangeCount, []rangeRecords{startGlyphID, endGlyphID, startCoverageIndex}
|
||
|
|
buf, _, err = f.src.varLenView(buf, offset, 4, 2, 6)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
return buf, makeCachedCoverageRange(buf[2:]), nil
|
||
|
|
default:
|
||
|
|
return buf, nil, errUnsupportedCoverageFormat
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedCoverageList(buf []byte) indexLookupFunc {
|
||
|
|
num := int(u16(buf))
|
||
|
|
list := make([]byte, len(buf)-2)
|
||
|
|
copy(list, buf[2:])
|
||
|
|
return func(gi GlyphIndex) (int, bool) {
|
||
|
|
idx := sort.Search(num, func(i int) bool {
|
||
|
|
return gi <= GlyphIndex(u16(list[i*2:]))
|
||
|
|
})
|
||
|
|
if idx < num && GlyphIndex(u16(list[idx*2:])) == gi {
|
||
|
|
return idx, true
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0, false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedCoverageRange(buf []byte) indexLookupFunc {
|
||
|
|
num := int(u16(buf))
|
||
|
|
ranges := make([]byte, len(buf)-2)
|
||
|
|
copy(ranges, buf[2:])
|
||
|
|
return func(gi GlyphIndex) (int, bool) {
|
||
|
|
if num == 0 {
|
||
|
|
return 0, false
|
||
|
|
}
|
||
|
|
|
||
|
|
// ranges is an array of startGlyphID, endGlyphID and startCoverageIndex
|
||
|
|
// Ranges are non-overlapping.
|
||
|
|
// The following GlyphIDs/index pairs are stored as follows:
|
||
|
|
// pairs: 130=0, 131=1, 132=2, 133=3, 134=4, 135=5, 137=6
|
||
|
|
// ranges: 130, 135, 0 137, 137, 6
|
||
|
|
// startCoverageIndex is used to calculate the index without counting
|
||
|
|
// the length of the preceeding ranges
|
||
|
|
|
||
|
|
idx := sort.Search(num, func(i int) bool {
|
||
|
|
return gi <= GlyphIndex(u16(ranges[i*6:]))
|
||
|
|
})
|
||
|
|
// idx either points to a matching start, or to the next range (or idx==num)
|
||
|
|
// e.g. with the range example from above: 130 points to 130-135 range, 133 points to 137-137 range
|
||
|
|
|
||
|
|
// check if gi is the start of a range, but only if sort.Search returned a valid result
|
||
|
|
if idx < num {
|
||
|
|
if start := u16(ranges[idx*6:]); gi == GlyphIndex(start) {
|
||
|
|
return int(u16(ranges[idx*6+4:])), true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// check if gi is in previous range
|
||
|
|
if idx > 0 {
|
||
|
|
idx--
|
||
|
|
start, end := u16(ranges[idx*6:]), u16(ranges[idx*6+2:])
|
||
|
|
if gi >= GlyphIndex(start) && gi <= GlyphIndex(end) {
|
||
|
|
return int(u16(ranges[idx*6+4:]) + uint16(gi) - start), true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0, false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// classLookupFunc returns the class ID for the provided glyph. Returns 0
|
||
|
|
// (default class) for glyphs not covered by this lookup.
|
||
|
|
type classLookupFunc func(GlyphIndex) int
|
||
|
|
|
||
|
|
func (f *Font) makeCachedClassLookup(buf []byte, offset int) ([]byte, classLookupFunc, error) {
|
||
|
|
var err error
|
||
|
|
buf, err = f.src.view(buf, offset, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
switch u16(buf) {
|
||
|
|
case 1:
|
||
|
|
// ClassDefFormat 1: classFormat, startGlyphID, glyphCount, []classValueArray
|
||
|
|
buf, _, err = f.src.varLenView(buf, offset, 6, 4, 2)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
return buf, makeCachedClassLookupFormat1(buf), nil
|
||
|
|
case 2:
|
||
|
|
// ClassDefFormat 2: classFormat, classRangeCount, []classRangeRecords
|
||
|
|
buf, _, err = f.src.varLenView(buf, offset, 4, 2, 6)
|
||
|
|
if err != nil {
|
||
|
|
return buf, nil, err
|
||
|
|
}
|
||
|
|
return buf, makeCachedClassLookupFormat2(buf), nil
|
||
|
|
default:
|
||
|
|
return buf, nil, errUnsupportedClassDefFormat
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedClassLookupFormat1(buf []byte) classLookupFunc {
|
||
|
|
startGI := u16(buf[2:])
|
||
|
|
num := u16(buf[4:])
|
||
|
|
classIDs := make([]byte, len(buf)-4)
|
||
|
|
copy(classIDs, buf[6:])
|
||
|
|
|
||
|
|
return func(gi GlyphIndex) int {
|
||
|
|
// classIDs is an array of target class IDs. gi is the index into that array (minus startGI).
|
||
|
|
if gi < GlyphIndex(startGI) || gi >= GlyphIndex(startGI+num) {
|
||
|
|
// default to class 0
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
return int(u16(classIDs[(int(gi)-int(startGI))*2:]))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func makeCachedClassLookupFormat2(buf []byte) classLookupFunc {
|
||
|
|
num := int(u16(buf[2:]))
|
||
|
|
classRanges := make([]byte, len(buf)-2)
|
||
|
|
copy(classRanges, buf[4:])
|
||
|
|
|
||
|
|
return func(gi GlyphIndex) int {
|
||
|
|
if num == 0 {
|
||
|
|
return 0 // default to class 0
|
||
|
|
}
|
||
|
|
|
||
|
|
// classRange is an array of startGlyphID, endGlyphID and target class ID.
|
||
|
|
// Ranges are non-overlapping.
|
||
|
|
// E.g. 130, 135, 1 137, 137, 5 etc
|
||
|
|
|
||
|
|
idx := sort.Search(num, func(i int) bool {
|
||
|
|
return gi <= GlyphIndex(u16(classRanges[i*6:]))
|
||
|
|
})
|
||
|
|
// idx either points to a matching start, or to the next range (or idx==num)
|
||
|
|
// e.g. with the range example from above: 130 points to 130-135 range, 133 points to 137-137 range
|
||
|
|
|
||
|
|
// check if gi is the start of a range, but only if sort.Search returned a valid result
|
||
|
|
if idx < num {
|
||
|
|
if start := u16(classRanges[idx*6:]); gi == GlyphIndex(start) {
|
||
|
|
return int(u16(classRanges[idx*6+4:]))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// check if gi is in previous range
|
||
|
|
if idx > 0 {
|
||
|
|
idx--
|
||
|
|
start, end := u16(classRanges[idx*6:]), u16(classRanges[idx*6+2:])
|
||
|
|
if gi >= GlyphIndex(start) && gi <= GlyphIndex(end) {
|
||
|
|
return int(u16(classRanges[idx*6+4:]))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// default to class 0
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
}
|