go-libwebp

corpus.go (9145B)

---

 package main
 
 import (
 	"image"
 	"image/color"
 	"math"
 	"math/rand"
 	"runtime"
 	"sync"
 )
 
 // Corpus entries are chosen to exercise the code paths a WebP encoder
 // actually branches on: predictor effectiveness, palette/colour-cache
 // eligibility, the separate alpha plane, and the transform's response to
 // smooth versus high-frequency content.
 type Entry struct {
 	Name string
 	Desc string
 	Img  *image.NRGBA
 }
 
 func BuildCorpus() []Entry {
 	return []Entry{
 		{"flat-128", "solid colour, 128x128 — best case for every path",
 			flat(128, 128)},
 		{"gradient-512", "smooth 2D gradient, 512x384 — spatial predictors win",
 			gradient(512, 384)},
 		{"photo-512", "synthetic photographic fBm, 512x384 — realistic lossy load",
 			photo(512, 384, 1)},
 		{"photo-1280", "synthetic photographic fBm, 1280x720 — scaling check",
 			photo(1280, 720, 2)},
 		{"noise-512", "uniform random RGB, 512x384 — incompressible worst case",
 			noise(512, 384, 3)},
 		{"noise-128", "uniform random RGB, 128x128 — worst case, small",
 			noise(128, 128, 4)},
 		{"text-512", "sharp black-on-white line art, 512x384 — hard for lossy",
 			text(512, 384)},
 		{"palette-512", "16 distinct colours in flat regions, 512x384 — VP8L palette",
 			palette(512, 384, 5)},
 		{"alpha-512", "photographic RGB under a radial alpha ramp, 512x384",
 			alpha(512, 384, 6)},
 		{"stripes-512", "1px high-frequency periodic pattern, 512x384",
 			stripes(512, 384)},
 		{"mandelbrot-512", "escape-time fractal, 512x384 — flat interior, smooth bands, fractal edge",
 			mandelbrot(512, 384)},
 		{"photo-alpha-1280", "fBm with binary alpha cutout, 1280x720",
 			photoAlpha(1280, 720, 7)},
 		{"mandelbrot-3840", "escape-time fractal, 3840x2160 — very large, 8.3 MP",
 			mandelbrot(3840, 2160)},
 		{"photo-3840", "synthetic photographic fBm, 3840x2160 — very large, 8.3 MP",
 			photo(3840, 2160, 8)},
 	}
 }
 
 func newImg(w, h int) *image.NRGBA { return image.NewNRGBA(image.Rect(0, 0, w, h)) }
 
 // eachRow runs fn over every row, in parallel. Generators are pure functions
 // of (x, y) so the result does not depend on scheduling.
 func eachRow(h int, fn func(y int)) {
 	workers := runtime.NumCPU()
 	if workers > h {
 		workers = h
 	}
 	var wg sync.WaitGroup
 	for w := 0; w < workers; w++ {
 		wg.Add(1)
 		go func(start int) {
 			defer wg.Done()
 			for y := start; y < h; y += workers {
 				fn(y)
 			}
 		}(w)
 	}
 	wg.Wait()
 }
 
 // mandelbrot renders the classic view of the set with smooth (continuous)
 // escape-time colouring. It is a useful corpus entry because one image holds
 // three regimes at once: a large flat interior, wide smooth exterior bands
 // that spatial predictors handle well, and a boundary with detail at every
 // scale that they cannot.
 func mandelbrot(w, h int) *image.NRGBA {
 	const maxIter = 512
 	m := newImg(w, h)
 	// Full set, with the aspect ratio driven by the output size.
 	const cx, halfW = -0.7, 1.5
 	halfH := halfW * float64(h) / float64(w)
 
 	eachRow(h, func(py int) {
 		ci := (float64(py)/float64(h)*2 - 1) * halfH
 		for px := 0; px < w; px++ {
 			cr := cx + (float64(px)/float64(w)*2-1)*halfW
 			var zr, zi float64
 			n := 0
 			for ; n < maxIter; n++ {
 				zr2, zi2 := zr*zr, zi*zi
 				if zr2+zi2 > 4 {
 					break
 				}
 				zr, zi = zr2-zi2+cr, 2*zr*zi+ci
 			}
 			if n == maxIter {
 				m.SetNRGBA(px, py, color.NRGBA{A: 255}) // interior: flat black
 				continue
 			}
 			// Continuous escape time, so the bands are smooth ramps rather
 			// than posterised steps.
 			mag := math.Sqrt(zr*zr + zi*zi)
 			smooth := float64(n) + 1 - math.Log(math.Log(mag))/math.Ln2
 			t := smooth / maxIter
 			m.SetNRGBA(px, py, color.NRGBA{
 				R: uint8(clamp(255 * (0.5 + 0.5*math.Cos(3+t*20)))),
 				G: uint8(clamp(255 * (0.5 + 0.5*math.Cos(3+t*20+2.1)))),
 				B: uint8(clamp(255 * (0.5 + 0.5*math.Cos(3+t*20+4.2)))),
 				A: 255,
 			})
 		}
 	})
 	return m
 }
 
 func flat(w, h int) *image.NRGBA {
 	m := newImg(w, h)
 	for i := 0; i < len(m.Pix); i += 4 {
 		m.Pix[i], m.Pix[i+1], m.Pix[i+2], m.Pix[i+3] = 0x3a, 0x7b, 0xd5, 0xff
 	}
 	return m
 }
 
 func gradient(w, h int) *image.NRGBA {
 	m := newImg(w, h)
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			m.SetNRGBA(x, y, color.NRGBA{
 				R: uint8(255 * x / w),
 				G: uint8(255 * y / h),
 				B: uint8(255 * (x + y) / (w + h)),
 				A: 255,
 			})
 		}
 	}
 	return m
 }
 
 // fbm is value noise summed over octaves: smooth at low frequency with detail
 // at high frequency, which is what makes real photographs compress the way
 // they do.
 func fbm(x, y float64, seed int64) float64 {
 	var sum, amp, norm float64 = 0, 1, 0
 	freq := 1.0 / 64.0
 	for o := 0; o < 5; o++ {
 		sum += amp * valueNoise(x*freq, y*freq, seed+int64(o))
 		norm += amp
 		amp *= 0.5
 		freq *= 2
 	}
 	return sum / norm
 }
 
 func valueNoise(x, y float64, seed int64) float64 {
 	xi, yi := math.Floor(x), math.Floor(y)
 	xf, yf := x-xi, y-yi
 	sx := xf * xf * (3 - 2*xf) // smoothstep
 	sy := yf * yf * (3 - 2*yf)
 	n00 := hash2(int64(xi), int64(yi), seed)
 	n10 := hash2(int64(xi)+1, int64(yi), seed)
 	n01 := hash2(int64(xi), int64(yi)+1, seed)
 	n11 := hash2(int64(xi)+1, int64(yi)+1, seed)
 	return (n00*(1-sx)+n10*sx)*(1-sy) + (n01*(1-sx)+n11*sx)*sy
 }
 
 func hash2(x, y, seed int64) float64 {
 	n := x*374761393 + y*668265263 + seed*1442695040888963407
 	n = (n ^ (n >> 13)) * 1274126177
 	return float64(uint32(n^(n>>16))) / float64(math.MaxUint32)
 }
 
 func photo(w, h int, seed int64) *image.NRGBA {
 	m := newImg(w, h)
 	cx, cy := float64(w)/2, float64(h)/2
 	maxr := math.Hypot(cx, cy)
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			fx, fy := float64(x), float64(y)
 			// Vignette gives a large-scale luminance ramp on top of the
 			// detail, as in a real photo.
 			vig := 1 - 0.35*math.Hypot(fx-cx, fy-cy)/maxr
 			r := fbm(fx, fy, seed) * vig
 			g := fbm(fx+512, fy+512, seed) * vig
 			b := fbm(fx+1024, fy+1024, seed) * vig
 			m.SetNRGBA(x, y, color.NRGBA{
 				R: uint8(clamp(r * 255)), G: uint8(clamp(g * 255)),
 				B: uint8(clamp(b * 255)), A: 255,
 			})
 		}
 	}
 	return m
 }
 
 func clamp(v float64) float64 { return math.Max(0, math.Min(255, v)) }
 
 func noise(w, h int, seed int64) *image.NRGBA {
 	m := newImg(w, h)
 	rng := rand.New(rand.NewSource(seed))
 	for i := 0; i < len(m.Pix); i += 4 {
 		v := rng.Uint32()
 		m.Pix[i], m.Pix[i+1], m.Pix[i+2] = uint8(v), uint8(v>>8), uint8(v>>16)
 		m.Pix[i+3] = 0xff
 	}
 	return m
 }
 
 // text draws axis-aligned bars and diagonals: pure two-tone, hard edges. This
 // is the content class lossy WebP handles worst and lossless handles best.
 func text(w, h int) *image.NRGBA {
 	m := newImg(w, h)
 	for i := 0; i < len(m.Pix); i += 4 {
 		m.Pix[i], m.Pix[i+1], m.Pix[i+2], m.Pix[i+3] = 0xff, 0xff, 0xff, 0xff
 	}
 	ink := color.NRGBA{A: 255}
 	for row := 0; row < h/24; row++ {
 		y0 := row*24 + 6
 		for gl := 0; gl < w/16; gl++ {
 			x0 := gl * 16
 			// Vary the shape per cell so it is not one repeated motif.
 			switch (row*7 + gl*3) % 4 {
 			case 0:
 				fillRect(m, x0+2, y0, 8, 12, ink)
 			case 1:
 				fillRect(m, x0+2, y0, 2, 12, ink)
 				fillRect(m, x0+2, y0+5, 8, 2, ink)
 			case 2:
 				for d := 0; d < 12; d++ {
 					fillRect(m, x0+2+d/2, y0+d, 2, 1, ink)
 				}
 			case 3:
 				fillRect(m, x0+2, y0, 8, 2, ink)
 				fillRect(m, x0+6, y0, 2, 12, ink)
 			}
 		}
 	}
 	return m
 }
 
 func fillRect(m *image.NRGBA, x, y, w, h int, c color.NRGBA) {
 	b := m.Bounds()
 	for yy := y; yy < y+h && yy < b.Max.Y; yy++ {
 		for xx := x; xx < x+w && xx < b.Max.X; xx++ {
 			m.SetNRGBA(xx, yy, c)
 		}
 	}
 }
 
 // palette builds large flat regions drawn from a 16-entry colour set, which
 // is what makes VP8L take its palette / colour-cache path.
 func palette(w, h int, seed int64) *image.NRGBA {
 	rng := rand.New(rand.NewSource(seed))
 	var pal [16]color.NRGBA
 	for i := range pal {
 		pal[i] = color.NRGBA{
 			R: uint8(rng.Intn(256)), G: uint8(rng.Intn(256)),
 			B: uint8(rng.Intn(256)), A: 255,
 		}
 	}
 	m := newImg(w, h)
 	const cell = 17 // deliberately not a macroblock multiple
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			m.SetNRGBA(x, y, pal[((x/cell)*5+(y/cell)*3)%16])
 		}
 	}
 	return m
 }
 
 // alpha exercises the separate alpha-plane encoder with a smooth ramp.
 func alpha(w, h int, seed int64) *image.NRGBA {
 	m := photo(w, h, seed)
 	cx, cy := float64(w)/2, float64(h)/2
 	maxr := math.Hypot(cx, cy)
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			d := math.Hypot(float64(x)-cx, float64(y)-cy) / maxr
 			m.Pix[m.PixOffset(x, y)+3] = uint8(clamp(255 * (1 - d)))
 		}
 	}
 	return m
 }
 
 // photoAlpha uses a hard-edged alpha cutout rather than a ramp: the alpha
 // plane is then highly compressible while the colour plane is not.
 func photoAlpha(w, h int, seed int64) *image.NRGBA {
 	m := photo(w, h, seed)
 	cx, cy := float64(w)/2, float64(h)/2
 	r := math.Min(cx, cy) * 0.8
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			var a uint8
 			if math.Hypot(float64(x)-cx, float64(y)-cy) < r {
 				a = 255
 			}
 			m.Pix[m.PixOffset(x, y)+3] = a
 		}
 	}
 	return m
 }
 
 func stripes(w, h int) *image.NRGBA {
 	m := newImg(w, h)
 	for y := 0; y < h; y++ {
 		for x := 0; x < w; x++ {
 			v := uint8(0)
 			if (x+y)%2 == 0 {
 				v = 255
 			}
 			m.SetNRGBA(x, y, color.NRGBA{R: v, G: uint8(x % 256), B: 255 - v, A: 255})
 		}
 	}
 	return m
 }