fa54d6fa1c
name old time/op new time/op delta GlyphAlpha16Over-8 3.38µs ± 0% 3.36µs ± 0% -0.54% (p=0.000 n=10+10) GlyphAlpha16Src-8 3.28µs ± 0% 3.26µs ± 0% -0.69% (p=0.000 n=10+9) GlyphAlpha32Over-8 5.23µs ± 1% 5.20µs ± 0% -0.58% (p=0.000 n=10+8) GlyphAlpha32Src-8 4.83µs ± 0% 4.81µs ± 1% -0.46% (p=0.001 n=10+9) GlyphAlpha64Over-8 10.2µs ± 0% 10.2µs ± 0% -0.21% (p=0.003 n=10+9) GlyphAlpha64Src-8 8.68µs ± 1% 8.62µs ± 0% -0.70% (p=0.000 n=10+9) GlyphAlpha128Over-8 24.2µs ± 1% 24.1µs ± 0% -0.58% (p=0.001 n=10+9) GlyphAlpha128Src-8 18.0µs ± 1% 17.9µs ± 0% -0.61% (p=0.001 n=10+9) GlyphAlpha256Over-8 70.3µs ± 0% 70.1µs ± 0% -0.37% (p=0.019 n=10+10) GlyphAlpha256Src-8 45.4µs ± 0% 45.2µs ± 1% -0.38% (p=0.041 n=8+10) GlyphRGBA16Over-8 5.14µs ± 0% 5.12µs ± 0% -0.43% (p=0.000 n=9+10) GlyphRGBA16Src-8 4.59µs ± 0% 4.57µs ± 1% -0.43% (p=0.005 n=9+9) GlyphRGBA32Over-8 12.2µs ± 1% 12.1µs ± 0% -0.70% (p=0.000 n=10+10) GlyphRGBA32Src-8 10.0µs ± 0% 10.0µs ± 0% ~ (p=0.092 n=7+10) GlyphRGBA64Over-8 37.5µs ± 1% 37.2µs ± 0% -0.75% (p=0.000 n=10+9) GlyphRGBA64Src-8 29.1µs ± 0% 29.0µs ± 1% ~ (p=0.243 n=10+9) GlyphRGBA128Over-8 135µs ± 0% 134µs ± 1% -0.72% (p=0.000 n=9+9) GlyphRGBA128Src-8 101µs ± 1% 100µs ± 1% ~ (p=0.197 n=10+10) GlyphRGBA256Over-8 511µs ± 0% 506µs ± 0% -0.97% (p=0.000 n=10+10) GlyphRGBA256Src-8 374µs ± 0% 373µs ± 0% -0.29% (p=0.002 n=10+10) Change-Id: Ic05a900935cb59e55711374db1e62b055d75c8e3 Reviewed-on: https://go-review.googlesource.com/31116 Reviewed-by: David Crawshaw <crawshaw@golang.org>
345 lines
11 KiB
Go
345 lines
11 KiB
Go
// 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 vector
|
|
|
|
// This file contains a fixed point math implementation of the vector
|
|
// graphics rasterizer.
|
|
|
|
import (
|
|
"golang.org/x/image/math/f32"
|
|
)
|
|
|
|
const (
|
|
// ϕ is the number of binary digits after the fixed point.
|
|
//
|
|
// For example, if ϕ == 10 (and int1ϕ is based on the int32 type) then we
|
|
// are using 22.10 fixed point math.
|
|
//
|
|
// When changing this number, also change the assembly code (search for ϕ
|
|
// in the .s files).
|
|
//
|
|
// TODO: drop ϕ from 10 to 9, so that ±1<<(3*ϕ+3) doesn't overflow an int32
|
|
// and we can therefore use int32 math instead of the slower int64 math in
|
|
// Rasterizer.fixedLineTo below.
|
|
ϕ = 10
|
|
|
|
fxOne int1ϕ = 1 << ϕ
|
|
fxOneAndAHalf int1ϕ = 1<<ϕ + 1<<(ϕ-1)
|
|
fxOneMinusIota int1ϕ = 1<<ϕ - 1 // Used for rounding up.
|
|
)
|
|
|
|
// int1ϕ is a signed fixed-point number with 1*ϕ binary digits after the fixed
|
|
// point.
|
|
type int1ϕ int32
|
|
|
|
// int2ϕ is a signed fixed-point number with 2*ϕ binary digits after the fixed
|
|
// point.
|
|
//
|
|
// The Rasterizer's bufU32 field, nominally of type []uint32 (since that slice
|
|
// is also used by other code), can be thought of as a []int2ϕ during the
|
|
// fixedLineTo method. Lines of code that are actually like:
|
|
// buf[i] += uint32(etc) // buf has type []uint32.
|
|
// can be thought of as
|
|
// buf[i] += int2ϕ(etc) // buf has type []int2ϕ.
|
|
type int2ϕ int32
|
|
|
|
func fixedMax(x, y int1ϕ) int1ϕ {
|
|
if x > y {
|
|
return x
|
|
}
|
|
return y
|
|
}
|
|
|
|
func fixedMin(x, y int1ϕ) int1ϕ {
|
|
if x < y {
|
|
return x
|
|
}
|
|
return y
|
|
}
|
|
|
|
func fixedFloor(x int1ϕ) int32 { return int32(x >> ϕ) }
|
|
func fixedCeil(x int1ϕ) int32 { return int32((x + fxOneMinusIota) >> ϕ) }
|
|
|
|
func (z *Rasterizer) fixedLineTo(b f32.Vec2) {
|
|
a := z.pen
|
|
z.pen = b
|
|
dir := int1ϕ(1)
|
|
if a[1] > b[1] {
|
|
dir, a, b = -1, b, a
|
|
}
|
|
// Horizontal line segments yield no change in coverage. Almost horizontal
|
|
// segments would yield some change, in ideal math, but the computation
|
|
// further below, involving 1 / (b[1] - a[1]), is unstable in fixed point
|
|
// math, so we treat the segment as if it was perfectly horizontal.
|
|
if b[1]-a[1] <= 0.000001 {
|
|
return
|
|
}
|
|
dxdy := (b[0] - a[0]) / (b[1] - a[1])
|
|
|
|
ay := int1ϕ(a[1] * float32(fxOne))
|
|
by := int1ϕ(b[1] * float32(fxOne))
|
|
|
|
x := int1ϕ(a[0] * float32(fxOne))
|
|
y := fixedFloor(ay)
|
|
yMax := fixedCeil(by)
|
|
if yMax > int32(z.size.Y) {
|
|
yMax = int32(z.size.Y)
|
|
}
|
|
width := int32(z.size.X)
|
|
|
|
for ; y < yMax; y++ {
|
|
dy := fixedMin(int1ϕ(y+1)<<ϕ, by) - fixedMax(int1ϕ(y)<<ϕ, ay)
|
|
xNext := x + int1ϕ(float32(dy)*dxdy)
|
|
if y < 0 {
|
|
x = xNext
|
|
continue
|
|
}
|
|
buf := z.bufU32[y*width:]
|
|
d := dy * dir // d ranges up to ±1<<(1*ϕ).
|
|
x0, x1 := x, xNext
|
|
if x > xNext {
|
|
x0, x1 = x1, x0
|
|
}
|
|
x0i := fixedFloor(x0)
|
|
x0Floor := int1ϕ(x0i) << ϕ
|
|
x1i := fixedCeil(x1)
|
|
x1Ceil := int1ϕ(x1i) << ϕ
|
|
|
|
if x1i <= x0i+1 {
|
|
xmf := (x+xNext)>>1 - x0Floor
|
|
if i := clamp(x0i+0, width); i < uint(len(buf)) {
|
|
buf[i] += uint32(d * (fxOne - xmf))
|
|
}
|
|
if i := clamp(x0i+1, width); i < uint(len(buf)) {
|
|
buf[i] += uint32(d * xmf)
|
|
}
|
|
} else {
|
|
oneOverS := x1 - x0
|
|
twoOverS := 2 * oneOverS
|
|
x0f := x0 - x0Floor
|
|
oneMinusX0f := fxOne - x0f
|
|
oneMinusX0fSquared := oneMinusX0f * oneMinusX0f
|
|
x1f := x1 - x1Ceil + fxOne
|
|
x1fSquared := x1f * x1f
|
|
|
|
// These next two variables are unused, as rounding errors are
|
|
// minimized when we delay the division by oneOverS for as long as
|
|
// possible. These lines of code (and the "In ideal math" comments
|
|
// below) are commented out instead of deleted in order to aid the
|
|
// comparison with the floating point version of the rasterizer.
|
|
//
|
|
// a0 := ((oneMinusX0f * oneMinusX0f) >> 1) / oneOverS
|
|
// am := ((x1f * x1f) >> 1) / oneOverS
|
|
|
|
if i := clamp(x0i, width); i < uint(len(buf)) {
|
|
// In ideal math: buf[i] += uint32(d * a0)
|
|
D := oneMinusX0fSquared // D ranges up to ±1<<(1*ϕ).
|
|
D *= d // D ranges up to ±1<<(2*ϕ).
|
|
D /= twoOverS
|
|
buf[i] += uint32(D)
|
|
}
|
|
|
|
if x1i == x0i+2 {
|
|
if i := clamp(x0i+1, width); i < uint(len(buf)) {
|
|
// In ideal math: buf[i] += uint32(d * (fxOne - a0 - am))
|
|
//
|
|
// (x1i == x0i+2) and (twoOverS == 2 * (x1 - x0)) implies
|
|
// that int64(twoOverS) ranges up to +1<<(1*ϕ+2).
|
|
//
|
|
// Convert to int64 to avoid overflow. Without that,
|
|
// TestRasterize30Degrees fails.
|
|
D := int64(twoOverS<<ϕ - oneMinusX0fSquared - x1fSquared) // D ranges up to ±1<<(2*ϕ+2).
|
|
D *= int64(d) // D ranges up to ±1<<(3*ϕ+2).
|
|
D /= int64(twoOverS)
|
|
buf[i] += uint32(D)
|
|
}
|
|
} else {
|
|
// This is commented out for the same reason as a0 and am.
|
|
//
|
|
// a1 := ((fxOneAndAHalf - x0f) << ϕ) / oneOverS
|
|
|
|
if i := clamp(x0i+1, width); i < uint(len(buf)) {
|
|
// In ideal math:
|
|
// buf[i] += uint32(d * (a1 - a0))
|
|
// or equivalently (but better in non-ideal, integer math,
|
|
// with respect to rounding errors),
|
|
// buf[i] += uint32(A * d / twoOverS)
|
|
// where
|
|
// A = (a1 - a0) * twoOverS
|
|
// = a1*twoOverS - a0*twoOverS
|
|
// Noting that twoOverS/oneOverS equals 2, substituting for
|
|
// a0 and then a1, given above, yields:
|
|
// A = a1*twoOverS - oneMinusX0fSquared
|
|
// = (fxOneAndAHalf-x0f)<<(ϕ+1) - oneMinusX0fSquared
|
|
// = fxOneAndAHalf<<(ϕ+1) - x0f<<(ϕ+1) - oneMinusX0fSquared
|
|
//
|
|
// This is a positive number minus two non-negative
|
|
// numbers. For an upper bound on A, the positive number is
|
|
// P = fxOneAndAHalf<<(ϕ+1)
|
|
// < (2*fxOne)<<(ϕ+1)
|
|
// = fxOne<<(ϕ+2)
|
|
// = 1<<(2*ϕ+2)
|
|
//
|
|
// For a lower bound on A, the two non-negative numbers are
|
|
// N = x0f<<(ϕ+1) + oneMinusX0fSquared
|
|
// ≤ x0f<<(ϕ+1) + fxOne*fxOne
|
|
// = x0f<<(ϕ+1) + 1<<(2*ϕ)
|
|
// < x0f<<(ϕ+1) + 1<<(2*ϕ+1)
|
|
// ≤ fxOne<<(ϕ+1) + 1<<(2*ϕ+1)
|
|
// = 1<<(2*ϕ+1) + 1<<(2*ϕ+1)
|
|
// = 1<<(2*ϕ+2)
|
|
//
|
|
// Thus, A ranges up to ±1<<(2*ϕ+2). It is possible to
|
|
// derive a tighter bound, but this bound is sufficient to
|
|
// reason about overflow.
|
|
//
|
|
// Convert to int64 to avoid overflow. Without that,
|
|
// TestRasterizePolygon fails.
|
|
D := int64((fxOneAndAHalf-x0f)<<(ϕ+1) - oneMinusX0fSquared) // D ranges up to ±1<<(2*ϕ+2).
|
|
D *= int64(d) // D ranges up to ±1<<(3*ϕ+2).
|
|
D /= int64(twoOverS)
|
|
buf[i] += uint32(D)
|
|
}
|
|
dTimesS := uint32((d << (2 * ϕ)) / oneOverS)
|
|
for xi := x0i + 2; xi < x1i-1; xi++ {
|
|
if i := clamp(xi, width); i < uint(len(buf)) {
|
|
buf[i] += dTimesS
|
|
}
|
|
}
|
|
|
|
// This is commented out for the same reason as a0 and am.
|
|
//
|
|
// a2 := a1 + (int1ϕ(x1i-x0i-3)<<(2*ϕ))/oneOverS
|
|
|
|
if i := clamp(x1i-1, width); i < uint(len(buf)) {
|
|
// In ideal math:
|
|
// buf[i] += uint32(d * (fxOne - a2 - am))
|
|
// or equivalently (but better in non-ideal, integer math,
|
|
// with respect to rounding errors),
|
|
// buf[i] += uint32(A * d / twoOverS)
|
|
// where
|
|
// A = (fxOne - a2 - am) * twoOverS
|
|
// = twoOverS<<ϕ - a2*twoOverS - am*twoOverS
|
|
// Noting that twoOverS/oneOverS equals 2, substituting for
|
|
// am and then a2, given above, yields:
|
|
// A = twoOverS<<ϕ - a2*twoOverS - x1f*x1f
|
|
// = twoOverS<<ϕ - a1*twoOverS - (int1ϕ(x1i-x0i-3)<<(2*ϕ))*2 - x1f*x1f
|
|
// = twoOverS<<ϕ - a1*twoOverS - int1ϕ(x1i-x0i-3)<<(2*ϕ+1) - x1f*x1f
|
|
// Substituting for a1, given above, yields:
|
|
// A = twoOverS<<ϕ - ((fxOneAndAHalf-x0f)<<ϕ)*2 - int1ϕ(x1i-x0i-3)<<(2*ϕ+1) - x1f*x1f
|
|
// = twoOverS<<ϕ - (fxOneAndAHalf-x0f)<<(ϕ+1) - int1ϕ(x1i-x0i-3)<<(2*ϕ+1) - x1f*x1f
|
|
// = B<<ϕ - x1f*x1f
|
|
// where
|
|
// B = twoOverS - (fxOneAndAHalf-x0f)<<1 - int1ϕ(x1i-x0i-3)<<(ϕ+1)
|
|
// = (x1-x0)<<1 - (fxOneAndAHalf-x0f)<<1 - int1ϕ(x1i-x0i-3)<<(ϕ+1)
|
|
//
|
|
// Re-arranging the defintions given above:
|
|
// x0Floor := int1ϕ(x0i) << ϕ
|
|
// x0f := x0 - x0Floor
|
|
// x1Ceil := int1ϕ(x1i) << ϕ
|
|
// x1f := x1 - x1Ceil + fxOne
|
|
// combined with fxOne = 1<<ϕ yields:
|
|
// x0 = x0f + int1ϕ(x0i)<<ϕ
|
|
// x1 = x1f + int1ϕ(x1i-1)<<ϕ
|
|
// so that expanding (x1-x0) yields:
|
|
// B = (x1f-x0f + int1ϕ(x1i-x0i-1)<<ϕ)<<1 - (fxOneAndAHalf-x0f)<<1 - int1ϕ(x1i-x0i-3)<<(ϕ+1)
|
|
// = (x1f-x0f)<<1 + int1ϕ(x1i-x0i-1)<<(ϕ+1) - (fxOneAndAHalf-x0f)<<1 - int1ϕ(x1i-x0i-3)<<(ϕ+1)
|
|
// A large part of the second and fourth terms cancel:
|
|
// B = (x1f-x0f)<<1 - (fxOneAndAHalf-x0f)<<1 - int1ϕ(-2)<<(ϕ+1)
|
|
// = (x1f-x0f)<<1 - (fxOneAndAHalf-x0f)<<1 + 1<<(ϕ+2)
|
|
// = (x1f - fxOneAndAHalf)<<1 + 1<<(ϕ+2)
|
|
// The first term, (x1f - fxOneAndAHalf)<<1, is a negative
|
|
// number, bounded below by -fxOneAndAHalf<<1, which is
|
|
// greater than -fxOne<<2, or -1<<(ϕ+2). Thus, B ranges up
|
|
// to ±1<<(ϕ+2). One final simplification:
|
|
// B = x1f<<1 + (1<<(ϕ+2) - fxOneAndAHalf<<1)
|
|
//
|
|
// Convert to int64 to avoid overflow. Without that,
|
|
// TestRasterizePolygon fails.
|
|
const C = 1<<(ϕ+2) - fxOneAndAHalf<<1
|
|
D := int64(x1f<<1 + C) // D ranges up to ±1<<(1*ϕ+2).
|
|
D <<= ϕ // D ranges up to ±1<<(2*ϕ+2).
|
|
D -= int64(x1fSquared) // D ranges up to ±1<<(2*ϕ+3).
|
|
D *= int64(d) // D ranges up to ±1<<(3*ϕ+3).
|
|
D /= int64(twoOverS)
|
|
buf[i] += uint32(D)
|
|
}
|
|
}
|
|
|
|
if i := clamp(x1i, width); i < uint(len(buf)) {
|
|
// In ideal math: buf[i] += uint32(d * am)
|
|
D := x1fSquared // D ranges up to ±1<<(2*ϕ).
|
|
D *= d // D ranges up to ±1<<(3*ϕ).
|
|
D /= twoOverS
|
|
buf[i] += uint32(D)
|
|
}
|
|
}
|
|
|
|
x = xNext
|
|
}
|
|
}
|
|
|
|
func fixedAccumulateOpOver(dst []uint8, src []uint32) {
|
|
// Sanity check that len(dst) >= len(src).
|
|
if len(dst) < len(src) {
|
|
return
|
|
}
|
|
|
|
acc := int2ϕ(0)
|
|
for i, v := range src {
|
|
acc += int2ϕ(v)
|
|
a := acc
|
|
if a < 0 {
|
|
a = -a
|
|
}
|
|
a >>= 2*ϕ - 16
|
|
if a > 0xffff {
|
|
a = 0xffff
|
|
}
|
|
// This algorithm comes from the standard library's image/draw package.
|
|
dstA := uint32(dst[i]) * 0x101
|
|
maskA := uint32(a)
|
|
outA := dstA*(0xffff-maskA)/0xffff + maskA
|
|
dst[i] = uint8(outA >> 8)
|
|
}
|
|
}
|
|
|
|
func fixedAccumulateOpSrc(dst []uint8, src []uint32) {
|
|
// Sanity check that len(dst) >= len(src).
|
|
if len(dst) < len(src) {
|
|
return
|
|
}
|
|
|
|
acc := int2ϕ(0)
|
|
for i, v := range src {
|
|
acc += int2ϕ(v)
|
|
a := acc
|
|
if a < 0 {
|
|
a = -a
|
|
}
|
|
a >>= 2*ϕ - 8
|
|
if a > 0xff {
|
|
a = 0xff
|
|
}
|
|
dst[i] = uint8(a)
|
|
}
|
|
}
|
|
|
|
func fixedAccumulateMask(buf []uint32) {
|
|
acc := int2ϕ(0)
|
|
for i, v := range buf {
|
|
acc += int2ϕ(v)
|
|
a := acc
|
|
if a < 0 {
|
|
a = -a
|
|
}
|
|
a >>= 2*ϕ - 16
|
|
if a > 0xffff {
|
|
a = 0xffff
|
|
}
|
|
buf[i] = uint32(a)
|
|
}
|
|
}
|