go-libwebp

webp_test.go (7001B)

---

 package webp
 
 import (
 	"bytes"
 	_ "embed"
 	"fmt"
 	"image"
 	"image/color"
 	"image/png"
 	"io"
 	"math/rand"
 	"os"
 	"path/filepath"
 	"testing"
 
 	stdwebp "golang.org/x/image/webp"
 )
 
 //go:embed testdata/golden-in.png
 var goldenIn []byte
 
 //go:embed testdata/golden-out.webp
 var goldenOut []byte
 
 func TestLossless(t *testing.T) {
 	t.Logf("selected backend: %q", Backend())
 
 	m, err := png.Decode(bytes.NewReader(goldenIn))
 	if err != nil {
 		t.Fatalf("decoding image: %v", err)
 	}
 
 	buf1 := bytes.NewBuffer(nil)
 	buf2 := bytes.NewBuffer(nil)
 
 	if err := Encode(io.MultiWriter(buf1, buf2), m, Lossless()); err != nil {
 		t.Fatalf("encoding webp: %v", err)
 	}
 
 	if err := os.WriteFile(filepath.Join("testdata", "golden-got.webp"), buf1.Bytes(), 0o644); err != nil {
 		t.Errorf("writing output png: %v", err)
 	}
 
 	t.Run("stdlib webp outupt", func(t *testing.T) {
 		assertOutput(t, m, buf1, stdwebp.Decode)
 	})
 
 	t.Run("round trip through selected backend", func(t *testing.T) {
 		assertOutput(t, m, buf2, Decode)
 	})
 }
 
 func BenchmarkDecode(b *testing.B) {
 	b.Run("stdwebp", func(b *testing.B) {
 		for ii := 0; ii < b.N; ii++ {
 			r := bytes.NewReader(goldenOut)
 			m, err := stdwebp.Decode(r)
 			if err != nil {
 				b.Fatalf("error: %v", err)
 			}
 			_ = m
 		}
 	})
 	b.Run(Backend(), func(b *testing.B) {
 		for ii := 0; ii < b.N; ii++ {
 			m, err := Decode(bytes.NewReader(goldenOut))
 			if err != nil {
 				b.Fatalf("error: %v", err)
 			}
 			_ = m
 		}
 	})
 }
 
 func assertOutput(t *testing.T, m image.Image, src io.Reader, decode func(io.Reader) (image.Image, error)) {
 	t.Helper()
 
 	out, err := decode(src)
 	if err != nil {
 		t.Fatalf("decoding webp: %v", err)
 	}
 
 	outb := out.Bounds()
 	for xx := outb.Min.X; xx < outb.Max.X; xx++ {
 		for yy := outb.Min.Y; yy < outb.Max.Y; yy++ {
 			if got, want := out.At(xx, yy), m.At(xx, yy); !colorEqual(got, want) {
 				save(t, fmt.Sprintf("got-%d_%d.webp", xx, yy), out)
 				save(t, fmt.Sprintf("want-%d_%d.webp", xx, yy), m)
 				t.Fatalf("color mismatch after lossless encode: Point = (%d, %d) Got = %v Want = %v Bounds= %d", xx, yy, got, want, outb)
 			}
 		}
 	}
 }
 
 // goldenNRGBA decodes the golden PNG as NRGBA, the form the backend entry
 // points take.
 func goldenNRGBA(t *testing.T) *image.NRGBA {
 	t.Helper()
 	m, err := png.Decode(bytes.NewReader(goldenIn))
 	if err != nil {
 		t.Fatalf("decoding golden image: %v", err)
 	}
 	return toNRGBA(m)
 }
 
 // encodeWith adapts a backend's encode entry point to the signature the
 // shared fuzz body expects.
 func encodeWith(fn func(io.Writer, *image.NRGBA, float32) error) func(io.Writer, image.Image, float32) error {
 	return func(w io.Writer, m image.Image, q float32) error {
 		return fn(w, toNRGBA(m), q)
 	}
 }
 
 // decodeReaderWith adapts a backend's byte-slice decoder to an io.Reader one.
 func decodeReaderWith(fn func([]byte) (image.Image, error)) func(io.Reader) (image.Image, error) {
 	return func(r io.Reader) (image.Image, error) {
 		by, err := io.ReadAll(r)
 		if err != nil {
 			return nil, err
 		}
 		return fn(by)
 	}
 }
 
 // assertLossyDecode encodes lossily and decodes the result through the same
 // backend, checking dimensions rather than pixels.
 //
 // This is the VP8 decode path, which is entirely separate from the VP8L path
 // the golden and the fuzz seeds exercise. A transpiled build that fell back
 // to inline-asm byte swapping passed every other test and aborted here.
 func assertLossyDecode(t *testing.T,
 	encode func(io.Writer, *image.NRGBA, float32) error,
 	decode func([]byte) (image.Image, error),
 ) {
 	t.Helper()
 	m := goldenNRGBA(t)
 	var buf bytes.Buffer
 	if err := encode(&buf, m, 0.75); err != nil {
 		t.Fatalf("lossy encode: %v", err)
 	}
 	got, err := decode(buf.Bytes())
 	if err != nil {
 		t.Fatalf("lossy decode: %v", err)
 	}
 	if got.Bounds() != m.Bounds() {
 		t.Fatalf("bounds: got %v want %v", got.Bounds(), m.Bounds())
 	}
 }
 
 func save(t *testing.T, name string, m image.Image) {
 	t.Helper()
 
 	if err := func() error {
 		f, err := os.Create(name)
 		if err != nil {
 			return err
 		}
 		defer f.Close()
 		defer f.Sync()
 		return Encode(f, m, Lossless())
 
 	}(); err != nil {
 		t.Error(err)
 	}
 }
 
 func colorEqual(left, right color.Color) bool {
 	lr, lg, lb, la := left.RGBA()
 	rr, rg, rb, ra := right.RGBA()
 	return lr == rr && lg == rg && lb == rb && la == ra
 }
 
 func FuzzEncode(f *testing.F) {
 	f.Add(uint16(000), uint16(000), int64(0), float32(0.00), true)
 	f.Add(uint16(000), uint16(000), int64(0), float32(0.00), false)
 	f.Add(uint16(001), uint16(001), int64(1), float32(1.00), true)
 	f.Add(uint16(001), uint16(001), int64(1), float32(1.00), false)
 	f.Add(uint16(001), uint16(001), int64(2), float32(0.50), true)
 	f.Add(uint16(001), uint16(001), int64(2), float32(0.50), false)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.75), true)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.75), false)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.90), true)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.90), false)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.95), true)
 	f.Add(uint16(100), uint16(100), int64(3), float32(0.95), false)
 	f.Add(uint16(100), uint16(100), int64(3), float32(1.00), true)
 	f.Add(uint16(100), uint16(100), int64(3), float32(1.00), false)
 
 	f.Fuzz(func(t *testing.T, x1, y1 uint16, seed int64, quality float32, lossless bool) {
 		encode := func(w io.Writer, m image.Image, q float32) error {
 			opts := []EncodeOption{Quality(q)}
 			if lossless {
 				opts = append(opts, Lossless())
 			}
 			return Encode(w, m, opts...)
 		}
 		fuzzEncode(t, x1, y1, seed, quality, lossless, encode, Decode)
 	})
 }
 
 // addEncodeSeeds mirrors the seed corpus of FuzzEncode.
 func addEncodeSeeds(f *testing.F) {
 	for _, q := range []float32{0.00, 1.00, 0.50, 0.75, 0.90, 0.95} {
 		for _, dim := range []uint16{0, 1, 100} {
 			for _, lossless := range []bool{true, false} {
 				f.Add(dim, dim, int64(dim), q, lossless)
 			}
 		}
 	}
 }
 
 func fuzzEncode(
 	t *testing.T,
 	x1, y1 uint16,
 	seed int64,
 	quality float32,
 	lossless bool,
 	encode func(io.Writer, image.Image, float32) error,
 	decode func(io.Reader) (image.Image, error),
 ) {
 	{
 		if quality <= 0 || quality > 1 {
 			t.Skip()
 			return
 		}
 
 		if int(x1) <= 0 || int(y1) <= 0 {
 			t.Skip()
 			return
 		}
 
 		t.Logf("(%d, %d), quality=%.2f, lossless=%v", x1, y1, quality, lossless)
 
 		rng := rand.New(rand.NewSource(seed))
 
 		m := image.NewNRGBA(image.Rect(0, 0, int(x1), int(y1)))
 
 		for x := uint16(0); x < x1; x += 1 {
 			for y := uint16(0); y < y1; y += 1 {
 				colors := rng.Uint32()
 				r := uint8(colors)
 				g := uint8(colors >> 8)
 				b := uint8(colors >> 16)
 				a := uint8(colors >> 24)
 				m.SetNRGBA(int(x), int(y), color.NRGBA{R: r, G: g, B: b, A: a})
 			}
 		}
 
 		if lossless {
 			quality = 1.0
 		}
 
 		buf := bytes.NewBuffer(nil)
 
 		if err := encode(buf, m, quality); err != nil {
 			t.Errorf("encode error: %v", err)
 		}
 
 		if lossless {
 			// If lossless, we can do a pixel-wise comparison between the original and the
 			// decoded image.
 			assertOutput(t, m, buf, decode)
 		}
 	}
 }