bitmaps_sbix.go

package truetype

import (
	"bytes"
	"encoding/binary"
	"errors"
	"image"
	"image/jpeg"
	"image/png"
	"math"

	"github.com/benoitkugler/textlayout/fonts"
	"golang.org/x/image/tiff"
)

// ---------------------------------------- sbix ----------------------------------------

type tableSbix struct {
	strikes      []bitmapStrike
	drawOutlines bool
}

func (t tableSbix) chooseStrike(xPpem, yPpem uint16) *bitmapStrike {
	if len(t.strikes) == 0 {
		return nil
	}

	request := maxu16(xPpem, yPpem)
	if request == 0 {
		request = math.MaxUint16 // choose largest strike
	}

	/* TODO Add DPI sensitivity as well? */
	var (
		bestIndex = 0
		bestPpem  = t.strikes[0].ppem
	)
	for i, s := range t.strikes {
		ppem := s.ppem
		if request <= ppem && ppem < bestPpem || request > bestPpem && ppem > bestPpem {
			bestIndex = i
			bestPpem = ppem
		}
	}
	return &t.strikes[bestIndex]
}

func parseTableSbix(data []byte, numGlyphs int) (out tableSbix, err error) {
	if len(data) < 8 {
		return out, errors.New("invalid 'sbix' table (EOF)")
	}
	flag := binary.BigEndian.Uint16(data[2:])
	numStrikes := int(binary.BigEndian.Uint32(data[4:]))

	out.drawOutlines = flag&0x02 != 0

	if len(data) < 8+8*numStrikes {
		return out, errors.New("invalid 'sbix' table (EOF)")
	}
	out.strikes = make([]bitmapStrike, numStrikes)
	for i := range out.strikes {
		offset := binary.BigEndian.Uint32(data[8+4*i:])
		out.strikes[i], err = parseBitmapStrike(data, offset, numGlyphs)
		if err != nil {
			return out, err
		}
	}

	return out, nil
}

type bitmapStrike struct {
	// length numGlyph; items may be empty (see isNil)
	glyphs    []bitmapGlyphData
	ppem, ppi uint16
}

func mulDiv(a, b, c uint16) uint16 {
	return uint16(uint32(a) * uint32(b) / uint32(c))
}

func (b *bitmapStrike) sizeMetrics(hori *TableHVhea, avgWidth, upem uint16) (out fonts.BitmapSize) {
	out.XPpem, out.YPpem = b.ppem, b.ppem
	out.Height = mulDiv(uint16(hori.Ascent-hori.Descent+hori.LineGap), b.ppem, upem)

	inferBitmapWidth(&out, avgWidth, upem)

	return out
}

// may return a zero value
func (b *bitmapStrike) getGlyph(glyph GID, recursionLevel int) bitmapGlyphData {
	const maxRecursionLevel = 8

	if int(glyph) >= len(b.glyphs) {
		return bitmapGlyphData{}
	}
	out := b.glyphs[glyph]
	if out.graphicType == MustNewTag("dupe") {
		if len(out.data) < 2 || recursionLevel > maxRecursionLevel {
			return bitmapGlyphData{}
		}
		glyph = GID(binary.BigEndian.Uint16(out.data))
		return b.getGlyph(glyph, recursionLevel+1)
	}
	return out
}

func parseBitmapStrike(data []byte, offset uint32, numGlyphs int) (out bitmapStrike, err error) {
	if len(data) < int(offset)+4+4*(numGlyphs+1) {
		return out, errors.New("invalud sbix bitmap strike (EOF)")
	}
	data = data[offset:]
	out.ppem = binary.BigEndian.Uint16(data)
	out.ppi = binary.BigEndian.Uint16(data[2:])

	offsets, _ := parseTableLoca(data[4:], numGlyphs, true)
	out.glyphs = make([]bitmapGlyphData, numGlyphs)
	for i := range out.glyphs {
		if offsets[i] == offsets[i+1] { // no data
			continue
		}

		out.glyphs[i], err = parseBitmapGlyphData(data, offsets[i], offsets[i+1])
		if err != nil {
			return out, err
		}
	}
	return out, nil
}

type bitmapGlyphData struct {
	data                         []byte
	originOffsetX, originOffsetY int16 // in font units
	graphicType                  Tag
}

func (b bitmapGlyphData) isNil() bool { return b.graphicType == 0 }

// return the extents computed from the data
// should only be called on valid, non nil glyph data
func (b bitmapGlyphData) glyphExtents() (out fonts.GlyphExtents, ok bool) {
	var (
		config image.Config
		err    error
	)
	switch b.graphicType {
	case MustNewTag("png "):
		config, err = png.DecodeConfig(bytes.NewReader(b.data))
	case MustNewTag("tiff"):
		config, err = tiff.DecodeConfig(bytes.NewReader(b.data))
	case MustNewTag("jpg "):
		config, err = jpeg.DecodeConfig(bytes.NewReader(b.data))
	default:
		return out, false
	}
	if err != nil {
		return out, false
	}
	out.XBearing = float32(b.originOffsetX)
	out.YBearing = float32(config.Height) + float32(b.originOffsetY)
	out.Width = float32(config.Width)
	out.Height = -float32(config.Height)
	return out, true
}

func parseBitmapGlyphData(data []byte, offsetStart, offsetNext uint32) (out bitmapGlyphData, err error) {
	if len(data) < int(offsetStart)+8 || offsetStart+8 > offsetNext {
		return out, errors.New("invalid 'sbix' bitmap glyph data (EOF)")
	}
	data = data[offsetStart:]
	out.originOffsetX = int16(binary.BigEndian.Uint16(data))
	out.originOffsetY = int16(binary.BigEndian.Uint16(data[2:]))
	out.graphicType = Tag(binary.BigEndian.Uint32(data[4:]))
	out.data = data[8 : offsetNext-offsetStart]

	if out.graphicType == 0 {
		return out, errors.New("invalid 'sbix' zero bitmap type")
	}
	return out, nil
}