code review 14930050: freetype/truetype: implement SPVTL, SFVTL, SHZ, SHPIX o...

freetype/truetype/hint.go

 // Copyright 2012 The Freetype-Go Authors. All rights reserved.
 // Use of this source code is governed by your choice of either the
 // FreeType License or the GNU General Public License version 2 (or
 // any later version), both of which can be found in the LICENSE file.
 
 package truetype
 
 // This file implements a Truetype bytecode interpreter.
 // The opcodes are described at https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html
 
 import (
         "errors"
+        "math"
 )
 
 const (
         twilightZone = 0
         glyphZone    = 1
         numZone      = 2
 )
 
 type pointType uint32
 
@@ skipping 116 matching lines @@
                 }
                 if len(f.fpgm) != 0 {
                         if err := h.run(f.fpgm, nil, nil, nil, nil); err != nil {
                                 return err
                         }
                 }
         }
 
         if rescale {
                 h.scale = scale
+                h.scaledCVTInitialized = false
 
                 h.defaultGS = globalDefaultGS
 
                 if len(f.prep) != 0 {
                         if err := h.run(f.prep, nil, nil, nil, nil); err != nil {
                                 return err
                         }
                         h.defaultGS = h.gs
                         // The MS rasterizer doesn't allow the following graphics state
                         // variables to be modified by the CVT program.
                         h.defaultGS.pv = globalDefaultGS.pv
                         h.defaultGS.fv = globalDefaultGS.fv
                         h.defaultGS.dv = globalDefaultGS.dv
                         h.defaultGS.rp = globalDefaultGS.rp
                         h.defaultGS.zp = globalDefaultGS.zp
                         h.defaultGS.loop = globalDefaultGS.loop
                 }
         }
         return nil
 }
 
 func (h *Hinter) run(program []byte, pCurrent, pUnhinted, pInFontUnits []Point, ends []int) error {
         h.gs = h.defaultGS
         h.points[glyphZone][current] = pCurrent
         h.points[glyphZone][unhinted] = pUnhinted
         h.points[glyphZone][inFontUnits] = pInFontUnits
         h.ends = ends
-        h.scaledCVTInitialized = false
 
         if len(program) > 50000 {
                 return errors.New("truetype: hinting: too many instructions")
         }
         var (
                 steps, pc, top int
                 opcode         uint8
 
                 callStack    [32]callStackEntry
                 callStackTop int
@@ skipping 30 matching lines @@
                 case opSPVTCA1:
                         h.gs.pv = [2]f2dot14{0x4000, 0}
                         h.gs.dv = [2]f2dot14{0x4000, 0}
 
                 case opSFVTCA0:
                         h.gs.fv = [2]f2dot14{0, 0x4000}
 
                 case opSFVTCA1:
                         h.gs.fv = [2]f2dot14{0x4000, 0}
 
+                case opSPVTL0, opSPVTL1, opSFVTL0, opSFVTL1:
+                        top -= 2
+                        p1 := h.point(0, current, h.stack[top+0])
+                        p2 := h.point(0, current, h.stack[top+1])
+                        if p1 == nil || p2 == nil {
+                                return errors.New("truetype: hinting: point out of range")
+                        }
+                        dx := f2dot14(p1.X - p2.X)
+                        dy := f2dot14(p1.Y - p2.Y)
+                        if dx == 0 && dy == 0 {
+                                dx = 0x4000
+                        } else if opcode&1 != 0 {
+                                // Counter-clockwise rotation.
+                                dx, dy = -dy, dx
+                        }
+                        v := normalize(dx, dy)
+                        if opcode < opSFVTL0 {
+                                h.gs.pv = v
+                                h.gs.dv = v
+                        } else {
+                                h.gs.fv = v
+                        }
+
                 case opSPVFS:
                         top -= 2
                         h.gs.pv[0] = f2dot14(h.stack[top+0])
                         h.gs.pv[1] = f2dot14(h.stack[top+1])
                         // TODO: normalize h.gs.pv ??
                         // TODO: h.gs.dv = h.gs.pv ??
 
                 case opSFVFS:
                         top -= 2
                         h.gs.fv[0] = f2dot14(h.stack[top+0])
@@ skipping 174 matching lines @@
                         p := h.point(0, current, i)
                         if p == nil {
                                 return errors.New("truetype: hinting: point out of range")
                         }
                         distance := f26dot6(0)
                         if opcode == opMDAP1 {
                                 distance = dotProduct(f26dot6(p.X), f26dot6(p.Y), h.gs.pv)
                                 // TODO: metrics compensation.
                                 distance = h.round(distance) - distance
                         }
-                        h.move(p, distance)
+                        h.move(p, distance, true)
                         h.gs.rp[0] = i
                         h.gs.rp[1] = i
 
                 case opIUP0, opIUP1:
                         iupY, mask := opcode == opIUP0, uint32(flagTouchedX)
                         if iupY {
                                 mask = flagTouchedY
                         }
                         prevEnd := 0
                         for _, end := range h.ends {
@@ skipping 17 matching lines @@
                                         } else {
                                                 h.iupInterp(iupY, curTouched+1, end-1, curTouched, firstTouched)
                                                 if firstTouched > 0 {
                                                         h.iupInterp(iupY, prevEnd, firstTouched-1, curTouched, firstTouched)
                                                 }
                                         }
                                 }
                                 prevEnd = end
                         }
 
+                case opSHZ0, opSHZ1:
+                        top--
+                        zonePointer, i, d, ok := h.displacement(opcode&1 == 0)
+                        if !ok {
+                                return errors.New("truetype: hinting: point out of range")
+                        }
+
+                        // As per C Freetype, SHZ doesn't move the phantom points, or mark
+                        // the points as touched.
+                        limit := int32(len(h.points[h.gs.zp[2]][current]))
+                        if h.gs.zp[2] == glyphZone {
+                                limit -= 4
+                        }
+                        for j := int32(0); j < limit; j++ {
+                                if i != j || h.gs.zp[zonePointer] != h.gs.zp[2] {
+                                        h.move(h.point(2, current, j), d, false)
+                                }
+                        }
+
+                case opSHPIX:
+                        top--
+                        d := f26dot6(h.stack[top])
+                        if top < int(h.gs.loop) {
+                                return errors.New("truetype: hinting: stack underflow")
+                        }
+                        for ; h.gs.loop != 0; h.gs.loop-- {
+                                top--
+                                p := h.point(2, current, h.stack[top])
+                                if p == nil {
+                                        return errors.New("truetype: hinting: point out of range")
+                                }
+                                h.move(p, d, true)
+                        }
+                        h.gs.loop = 1
+
                 case opIP:
                         if top < int(h.gs.loop) {
                                 return errors.New("truetype: hinting: stack underflow")
                         }
                         pointType := inFontUnits
                         twilight := h.gs.zp[0] == 0 || h.gs.zp[1] == 0 || h.gs.zp[2] == 0
                         if twilight {
                                 pointType = unhinted
                         }
                         p := h.point(1, pointType, h.gs.rp[2])
@@ skipping 21 matching lines @@
                                                 if x < 0 {
                                                         x -= int64(oldRange) / 2
                                                 } else {
                                                         x += int64(oldRange) / 2
                                                 }
                                                 newDist = f26dot6(x / int64(oldRange))
                                         } else {
                                                 newDist = -oldDist
                                         }
                                 }
-                                h.move(p, newDist-curDist)
+                                h.move(p, newDist-curDist, true)
                         }
                         h.gs.loop = 1
 
                 case opALIGNRP:
                         if top < int(h.gs.loop) {
                                 return errors.New("truetype: hinting: stack underflow")
                         }
                         ref := h.point(0, current, h.gs.rp[0])
                         if ref == nil {
                                 return errors.New("truetype: hinting: point out of range")
                         }
                         for ; h.gs.loop != 0; h.gs.loop-- {
                                 top--
                                 p := h.point(1, current, h.stack[top])
                                 if p == nil {
                                         return errors.New("truetype: hinting: point out of range")
                                 }
-                                h.move(p, -dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.pv))
+                                h.move(p, -dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.pv), true)
                         }
                         h.gs.loop = 1
 
                 case opRTDG:
                         h.gs.roundPeriod = 1 << 5
                         h.gs.roundPhase = 0
                         h.gs.roundThreshold = 1 << 4
 
                 case opMIAP0, opMIAP1:
                         top -= 2
                         i := h.stack[top]
                         distance := h.getScaledCVT(h.stack[top+1])
                         if h.gs.zp[0] == 0 {
                                 p := h.point(0, unhinted, i)
                                 q := h.point(0, current, i)
                                 p.X = int32((int64(distance) * int64(h.gs.fv[0])) >> 14)
                                 p.Y = int32((int64(distance) * int64(h.gs.fv[1])) >> 14)
                                 *q = *p
                         }
                         p := h.point(0, current, i)
                         oldDist := dotProduct(f26dot6(p.X), f26dot6(p.Y), h.gs.pv)
                         if opcode == opMIAP1 {
                                 if (distance - oldDist).abs() > h.gs.controlValueCutIn {
                                         distance = oldDist
                                 }
                                 // TODO: metrics compensation.
                                 distance = h.round(distance)
                         }
-                        h.move(p, distance-oldDist)
+                        h.move(p, distance-oldDist, true)
                         h.gs.rp[0] = i
                         h.gs.rp[1] = i
 
                 case opNPUSHB:
                         opcode = 0
                         goto push
 
                 case opNPUSHW:
                         opcode = 0x80
                         goto push
@@ skipping 309 matching lines @@
 
                         // Set-RP0 bit.
                         if opcode&0x10 != 0 {
                                 h.gs.rp[0] = i
                         }
                         h.gs.rp[1] = h.gs.rp[0]
                         h.gs.rp[2] = i
 
                         // Move the point.
                         oldDist = dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.pv)
-                        h.move(p, distance-oldDist)
+                        h.move(p, distance-oldDist, true)
 
                 case opMIRP00000, opMIRP00001, opMIRP00010, opMIRP00011,
                         opMIRP00100, opMIRP00101, opMIRP00110, opMIRP00111,
                         opMIRP01000, opMIRP01001, opMIRP01010, opMIRP01011,
                         opMIRP01100, opMIRP01101, opMIRP01110, opMIRP01111,
                         opMIRP10000, opMIRP10001, opMIRP10010, opMIRP10011,
                         opMIRP10100, opMIRP10101, opMIRP10110, opMIRP10111,
                         opMIRP11000, opMIRP11001, opMIRP11010, opMIRP11011,
                         opMIRP11100, opMIRP11101, opMIRP11110, opMIRP11111:
 
@@ skipping 19 matching lines @@
                         if ref == nil || p == nil {
                                 return errors.New("truetype: hinting: point out of range")
                         }
                         oldDist := dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.dv)
 
                         ref = h.point(0, current, h.gs.rp[0])
                         p = h.point(1, current, i)
                         if ref == nil || p == nil {
                                 return errors.New("truetype: hinting: point out of range")
                         }
-                        curDist := dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.dv)
+                        curDist := dotProduct(f26dot6(p.X-ref.X), f26dot6(p.Y-ref.Y), h.gs.pv)
 
                         if h.gs.autoFlip && oldDist^cvtDist < 0 {
                                 cvtDist = -cvtDist
                         }
 
                         // Rounding bit.
                         // TODO: metrics compensation.
-                        distance := oldDist
+                        distance := cvtDist
                         if opcode&0x04 != 0 {
-                                distance = h.round(oldDist)
+                                distance = h.round(cvtDist)
                         }
 
                         // Minimum distance bit.
                         if opcode&0x08 != 0 {
                                 if oldDist >= 0 {
                                         if distance < h.gs.minDist {
                                                 distance = h.gs.minDist
                                         }
                                 } else {
                                         if distance > -h.gs.minDist {
                                                 distance = -h.gs.minDist
                                         }
                                 }
                         }
 
                         // Set-RP0 bit.
                         if opcode&0x10 != 0 {
                                 h.gs.rp[0] = i
                         }
                         h.gs.rp[1] = h.gs.rp[0]
                         h.gs.rp[2] = i
 
                         // Move the point.
-                        h.move(p, distance-curDist)
+                        h.move(p, distance-curDist, true)
 
                 default:
                         return errors.New("truetype: hinting: unrecognized instruction")
                 }
                 pc++
                 continue
 
         ifelse:
                 // Skip past bytecode until the next ELSE (if opcode == 0) or the
                 // next EIF (for all opcodes). Opcode == 0 means that we have come
@@ skipping 108 matching lines @@
 }
 
 func (h *Hinter) point(zonePointer uint32, pt pointType, i int32) *Point {
         points := h.points[h.gs.zp[zonePointer]][pt]
         if i < 0 || len(points) <= int(i) {
                 return nil
         }
         return &points[i]
 }
 
-func (h *Hinter) move(p *Point, distance f26dot6) {
-        if h.gs.fv[0] == 0 {
-                p.Y += int32(distance)
-                p.Flags |= flagTouchedY
+func (h *Hinter) move(p *Point, distance f26dot6, touch bool) {
+        fvx := int64(h.gs.fv[0])
+        pvx := int64(h.gs.pv[0])
+        if fvx == 0x4000 && pvx == 0x4000 {
+                p.X += int32(distance)
+                if touch {
+                        p.Flags |= flagTouchedX
+                }
                 return
         }
-        if h.gs.fv[1] == 0 {
-                p.X += int32(distance)
-                p.Flags |= flagTouchedX
+
+        fvy := int64(h.gs.fv[1])
+        pvy := int64(h.gs.pv[1])
+        if fvy == 0x4000 && pvy == 0x4000 {
+                p.Y += int32(distance)
+                if touch {
+                        p.Flags |= flagTouchedY
+                }
                 return
         }
-        fvx := int64(h.gs.fv[0])
-        fvy := int64(h.gs.fv[1])
-        pvx := int64(h.gs.pv[0])
-        pvy := int64(h.gs.pv[1])
+
         fvDotPv := (fvx*pvx + fvy*pvy) >> 14
-        p.X += int32(int64(distance) * fvx / fvDotPv)
-        p.Y += int32(int64(distance) * fvy / fvDotPv)
-        p.Flags |= flagTouchedX | flagTouchedY
+
+        if fvx != 0 {
+                numer, denom := fvx*int64(distance), fvDotPv
+                if denom < 0 {

[bsiegert, 2013/10/23 11:43:32]

How about a helper function for the rounding?

+                        numer, denom = -numer, -denom
+                }
+                if numer >= 0 {
+                        numer += denom / 2
+                } else {
+                        numer -= denom / 2
+                }
+                p.X += int32(numer / denom)
+                if touch {
+                        p.Flags |= flagTouchedX
+                }
+        }
+
+        if fvy != 0 {
+                numer, denom := fvy*int64(distance), fvDotPv
+                if denom < 0 {
+                        numer, denom = -numer, -denom
+                }
+                if numer >= 0 {
+                        numer += denom / 2
+                } else {
+                        numer -= denom / 2
+                }
+                p.Y += int32(numer / denom)
+                if touch {
+                        p.Flags |= flagTouchedY
+                }
+        }
 }
 
 func (h *Hinter) iupInterp(interpY bool, p1, p2, ref1, ref2 int) {
         if p1 > p2 {
                 return
         }
         if ref1 >= len(h.points[glyphZone][current]) ||
                 ref2 >= len(h.points[glyphZone][current]) {
                 return
         }
@@ skipping 106 matching lines @@
                         continue
                 }
                 if interpY {
                         h.points[glyphZone][current][i].Y += delta
                 } else {
                         h.points[glyphZone][current][i].X += delta
                 }
         }
 }
 
+func (h *Hinter) displacement(useZP1 bool) (zonePointer uint32, i int32, d f26dot6, ok bool) {
+        zonePointer, i = uint32(0), h.gs.rp[1]
+        if useZP1 {
+                zonePointer, i = 1, h.gs.rp[2]
+        }
+        p := h.point(zonePointer, current, i)
+        q := h.point(zonePointer, unhinted, i)
+        if p == nil || q == nil {
+                return 0, 0, 0, false
+        }
+        d = dotProduct(f26dot6(p.X-q.X), f26dot6(p.Y-q.Y), h.gs.pv)
+        return zonePointer, i, d, true
+}
+
 // skipInstructionPayload increments pc by the extra data that follows a
 // variable length PUSHB or PUSHW instruction.
 func skipInstructionPayload(program []byte, pc int) (newPC int, ok bool) {
         switch program[pc] {
         case opNPUSHB:
                 pc++
                 if pc >= len(program) {
                         return 0, false
                 }
                 pc += int(program[pc])
         case opNPUSHW:
                 pc++
                 if pc >= len(program) {
                         return 0, false
                 }
                 pc += 2 * int(program[pc])
         case opPUSHB000, opPUSHB001, opPUSHB010, opPUSHB011,
                 opPUSHB100, opPUSHB101, opPUSHB110, opPUSHB111:
                 pc += int(program[pc] - (opPUSHB000 - 1))
         case opPUSHW000, opPUSHW001, opPUSHW010, opPUSHW011,
                 opPUSHW100, opPUSHW101, opPUSHW110, opPUSHW111:
                 pc += 2 * int(program[pc]-(opPUSHW000-1))
         }
         return pc, true
 }
 
 // f2dot14 is a 2.14 fixed point number.
 type f2dot14 int16
 
+func normalize(x, y f2dot14) [2]f2dot14 {
+        fx, fy := float64(x), float64(y)
+        l := math.Sqrt(fx*fx + fy*fy)

[bsiegert, 2013/10/23 11:43:32]

math.Hypot(fx, fy)

+        fx /= l
+        fy /= l
+        return [2]f2dot14{
+                f2dot14(fx * 0x4000),
+                f2dot14(fy * 0x4000),
+        }
+}
+
 // f26dot6 is a 26.6 fixed point number.
 type f26dot6 int32
 
 // abs returns abs(x) in 26.6 fixed point arithmetic.
 func (x f26dot6) abs() f26dot6 {
         if x < 0 {
                 return -x
         }
         return x
 }
 
 // div returns x/y in 26.6 fixed point arithmetic.
 func (x f26dot6) div(y f26dot6) f26dot6 {
         return f26dot6((int64(x) << 6) / int64(y))
 }
 
 // mul returns x*y in 26.6 fixed point arithmetic.
 func (x f26dot6) mul(y f26dot6) f26dot6 {
         return f26dot6(int64(x) * int64(y) >> 6)
 }
 
 func dotProduct(x, y f26dot6, q [2]f2dot14) f26dot6 {
         px := int64(x)
         py := int64(y)
         qx := int64(q[0])
         qy := int64(q[1])
-        return f26dot6((px*qx + py*qy) >> 14)
+        return f26dot6((px*qx + py*qy + 1<<13) >> 14)
 }
 
 // round rounds the given number. The rounding algorithm is described at
 // https://developer.apple.com/fonts/TTRefMan/RM02/Chap2.html#rounding
 func (h *Hinter) round(x f26dot6) f26dot6 {
         if h.gs.roundPeriod == 0 {
                 // Rounding is off.
                 return x
         }
         if x >= 0 {
                 ret := (x - h.gs.roundPhase + h.gs.roundThreshold) & -h.gs.roundPeriod
                 if x != 0 && ret < 0 {
                         ret = 0
                 }
                 return ret + h.gs.roundPhase
         }
         ret := -((-x - h.gs.roundPhase + h.gs.roundThreshold) & -h.gs.roundPeriod)
         if ret > 0 {
                 ret = 0
         }
         return ret - h.gs.roundPhase
 }
 
 func bool2int32(b bool) int32 {
         if b {
                 return 1
         }
         return 0
 }