...
Run Format

Source file src/image/gif/writer_test.go

Documentation: image/gif

  // Copyright 2013 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 gif
  
  import (
  	"bytes"
  	"image"
  	"image/color"
  	"image/color/palette"
  	_ "image/png"
  	"io/ioutil"
  	"math/rand"
  	"os"
  	"reflect"
  	"testing"
  )
  
  func readImg(filename string) (image.Image, error) {
  	f, err := os.Open(filename)
  	if err != nil {
  		return nil, err
  	}
  	defer f.Close()
  	m, _, err := image.Decode(f)
  	return m, err
  }
  
  func readGIF(filename string) (*GIF, error) {
  	f, err := os.Open(filename)
  	if err != nil {
  		return nil, err
  	}
  	defer f.Close()
  	return DecodeAll(f)
  }
  
  func delta(u0, u1 uint32) int64 {
  	d := int64(u0) - int64(u1)
  	if d < 0 {
  		return -d
  	}
  	return d
  }
  
  // averageDelta returns the average delta in RGB space. The two images must
  // have the same bounds.
  func averageDelta(m0, m1 image.Image) int64 {
  	b := m0.Bounds()
  	var sum, n int64
  	for y := b.Min.Y; y < b.Max.Y; y++ {
  		for x := b.Min.X; x < b.Max.X; x++ {
  			c0 := m0.At(x, y)
  			c1 := m1.At(x, y)
  			r0, g0, b0, _ := c0.RGBA()
  			r1, g1, b1, _ := c1.RGBA()
  			sum += delta(r0, r1)
  			sum += delta(g0, g1)
  			sum += delta(b0, b1)
  			n += 3
  		}
  	}
  	return sum / n
  }
  
  var testCase = []struct {
  	filename  string
  	tolerance int64
  }{
  	{"../testdata/video-001.png", 1 << 12},
  	{"../testdata/video-001.gif", 0},
  	{"../testdata/video-001.interlaced.gif", 0},
  }
  
  func TestWriter(t *testing.T) {
  	for _, tc := range testCase {
  		m0, err := readImg(tc.filename)
  		if err != nil {
  			t.Error(tc.filename, err)
  			continue
  		}
  		var buf bytes.Buffer
  		err = Encode(&buf, m0, nil)
  		if err != nil {
  			t.Error(tc.filename, err)
  			continue
  		}
  		m1, err := Decode(&buf)
  		if err != nil {
  			t.Error(tc.filename, err)
  			continue
  		}
  		if m0.Bounds() != m1.Bounds() {
  			t.Errorf("%s, bounds differ: %v and %v", tc.filename, m0.Bounds(), m1.Bounds())
  			continue
  		}
  		// Compare the average delta to the tolerance level.
  		avgDelta := averageDelta(m0, m1)
  		if avgDelta > tc.tolerance {
  			t.Errorf("%s: average delta is too high. expected: %d, got %d", tc.filename, tc.tolerance, avgDelta)
  			continue
  		}
  	}
  }
  
  func TestSubImage(t *testing.T) {
  	m0, err := readImg("../testdata/video-001.gif")
  	if err != nil {
  		t.Fatalf("readImg: %v", err)
  	}
  	m0 = m0.(*image.Paletted).SubImage(image.Rect(0, 0, 50, 30))
  	var buf bytes.Buffer
  	err = Encode(&buf, m0, nil)
  	if err != nil {
  		t.Fatalf("Encode: %v", err)
  	}
  	m1, err := Decode(&buf)
  	if err != nil {
  		t.Fatalf("Decode: %v", err)
  	}
  	if m0.Bounds() != m1.Bounds() {
  		t.Fatalf("bounds differ: %v and %v", m0.Bounds(), m1.Bounds())
  	}
  	if averageDelta(m0, m1) != 0 {
  		t.Fatalf("images differ")
  	}
  }
  
  // palettesEqual reports whether two color.Palette values are equal, ignoring
  // any trailing opaque-black palette entries.
  func palettesEqual(p, q color.Palette) bool {
  	n := len(p)
  	if n > len(q) {
  		n = len(q)
  	}
  	for i := 0; i < n; i++ {
  		if p[i] != q[i] {
  			return false
  		}
  	}
  	for i := n; i < len(p); i++ {
  		r, g, b, a := p[i].RGBA()
  		if r != 0 || g != 0 || b != 0 || a != 0xffff {
  			return false
  		}
  	}
  	for i := n; i < len(q); i++ {
  		r, g, b, a := q[i].RGBA()
  		if r != 0 || g != 0 || b != 0 || a != 0xffff {
  			return false
  		}
  	}
  	return true
  }
  
  var frames = []string{
  	"../testdata/video-001.gif",
  	"../testdata/video-005.gray.gif",
  }
  
  func testEncodeAll(t *testing.T, go1Dot5Fields bool, useGlobalColorModel bool) {
  	const width, height = 150, 103
  
  	g0 := &GIF{
  		Image:     make([]*image.Paletted, len(frames)),
  		Delay:     make([]int, len(frames)),
  		LoopCount: 5,
  	}
  	for i, f := range frames {
  		g, err := readGIF(f)
  		if err != nil {
  			t.Fatal(f, err)
  		}
  		m := g.Image[0]
  		if m.Bounds().Dx() != width || m.Bounds().Dy() != height {
  			t.Fatalf("frame %d had unexpected bounds: got %v, want width/height = %d/%d",
  				i, m.Bounds(), width, height)
  		}
  		g0.Image[i] = m
  	}
  	// The GIF.Disposal, GIF.Config and GIF.BackgroundIndex fields were added
  	// in Go 1.5. Valid Go 1.4 or earlier code should still produce valid GIFs.
  	//
  	// On the following line, color.Model is an interface type, and
  	// color.Palette is a concrete (slice) type.
  	globalColorModel, backgroundIndex := color.Model(color.Palette(nil)), uint8(0)
  	if useGlobalColorModel {
  		globalColorModel, backgroundIndex = color.Palette(palette.WebSafe), uint8(1)
  	}
  	if go1Dot5Fields {
  		g0.Disposal = make([]byte, len(g0.Image))
  		for i := range g0.Disposal {
  			g0.Disposal[i] = DisposalNone
  		}
  		g0.Config = image.Config{
  			ColorModel: globalColorModel,
  			Width:      width,
  			Height:     height,
  		}
  		g0.BackgroundIndex = backgroundIndex
  	}
  
  	var buf bytes.Buffer
  	if err := EncodeAll(&buf, g0); err != nil {
  		t.Fatal("EncodeAll:", err)
  	}
  	encoded := buf.Bytes()
  	config, err := DecodeConfig(bytes.NewReader(encoded))
  	if err != nil {
  		t.Fatal("DecodeConfig:", err)
  	}
  	g1, err := DecodeAll(bytes.NewReader(encoded))
  	if err != nil {
  		t.Fatal("DecodeAll:", err)
  	}
  
  	if !reflect.DeepEqual(config, g1.Config) {
  		t.Errorf("DecodeConfig inconsistent with DecodeAll")
  	}
  	if !palettesEqual(g1.Config.ColorModel.(color.Palette), globalColorModel.(color.Palette)) {
  		t.Errorf("unexpected global color model")
  	}
  	if w, h := g1.Config.Width, g1.Config.Height; w != width || h != height {
  		t.Errorf("got config width * height = %d * %d, want %d * %d", w, h, width, height)
  	}
  
  	if g0.LoopCount != g1.LoopCount {
  		t.Errorf("loop counts differ: %d and %d", g0.LoopCount, g1.LoopCount)
  	}
  	if backgroundIndex != g1.BackgroundIndex {
  		t.Errorf("background indexes differ: %d and %d", backgroundIndex, g1.BackgroundIndex)
  	}
  	if len(g0.Image) != len(g1.Image) {
  		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
  	}
  	if len(g1.Image) != len(g1.Delay) {
  		t.Fatalf("image and delay lengths differ: %d and %d", len(g1.Image), len(g1.Delay))
  	}
  	if len(g1.Image) != len(g1.Disposal) {
  		t.Fatalf("image and disposal lengths differ: %d and %d", len(g1.Image), len(g1.Disposal))
  	}
  
  	for i := range g0.Image {
  		m0, m1 := g0.Image[i], g1.Image[i]
  		if m0.Bounds() != m1.Bounds() {
  			t.Errorf("frame %d: bounds differ: %v and %v", i, m0.Bounds(), m1.Bounds())
  		}
  		d0, d1 := g0.Delay[i], g1.Delay[i]
  		if d0 != d1 {
  			t.Errorf("frame %d: delay values differ: %d and %d", i, d0, d1)
  		}
  		p0, p1 := uint8(0), g1.Disposal[i]
  		if go1Dot5Fields {
  			p0 = DisposalNone
  		}
  		if p0 != p1 {
  			t.Errorf("frame %d: disposal values differ: %d and %d", i, p0, p1)
  		}
  	}
  }
  
  func TestEncodeAllGo1Dot4(t *testing.T)                 { testEncodeAll(t, false, false) }
  func TestEncodeAllGo1Dot5(t *testing.T)                 { testEncodeAll(t, true, false) }
  func TestEncodeAllGo1Dot5GlobalColorModel(t *testing.T) { testEncodeAll(t, true, true) }
  
  func TestEncodeMismatchDelay(t *testing.T) {
  	images := make([]*image.Paletted, 2)
  	for i := range images {
  		images[i] = image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9)
  	}
  
  	g0 := &GIF{
  		Image: images,
  		Delay: make([]int, 1),
  	}
  	if err := EncodeAll(ioutil.Discard, g0); err == nil {
  		t.Error("expected error from mismatched delay and image slice lengths")
  	}
  
  	g1 := &GIF{
  		Image:    images,
  		Delay:    make([]int, len(images)),
  		Disposal: make([]byte, 1),
  	}
  	for i := range g1.Disposal {
  		g1.Disposal[i] = DisposalNone
  	}
  	if err := EncodeAll(ioutil.Discard, g1); err == nil {
  		t.Error("expected error from mismatched disposal and image slice lengths")
  	}
  }
  
  func TestEncodeZeroGIF(t *testing.T) {
  	if err := EncodeAll(ioutil.Discard, &GIF{}); err == nil {
  		t.Error("expected error from providing empty gif")
  	}
  }
  
  func TestEncodeAllFramesOutOfBounds(t *testing.T) {
  	images := []*image.Paletted{
  		image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9),
  		image.NewPaletted(image.Rect(2, 2, 8, 8), palette.Plan9),
  		image.NewPaletted(image.Rect(3, 3, 4, 4), palette.Plan9),
  	}
  	for _, upperBound := range []int{6, 10} {
  		g := &GIF{
  			Image:    images,
  			Delay:    make([]int, len(images)),
  			Disposal: make([]byte, len(images)),
  			Config: image.Config{
  				Width:  upperBound,
  				Height: upperBound,
  			},
  		}
  		err := EncodeAll(ioutil.Discard, g)
  		if upperBound >= 8 {
  			if err != nil {
  				t.Errorf("upperBound=%d: %v", upperBound, err)
  			}
  		} else {
  			if err == nil {
  				t.Errorf("upperBound=%d: got nil error, want non-nil", upperBound)
  			}
  		}
  	}
  }
  
  func TestEncodeNonZeroMinPoint(t *testing.T) {
  	points := []image.Point{
  		{-8, -9},
  		{-4, -4},
  		{-3, +3},
  		{+0, +0},
  		{+2, +2},
  	}
  	for _, p := range points {
  		src := image.NewPaletted(image.Rectangle{Min: p, Max: p.Add(image.Point{6, 6})}, palette.Plan9)
  		var buf bytes.Buffer
  		if err := Encode(&buf, src, nil); err != nil {
  			t.Errorf("p=%v: Encode: %v", p, err)
  			continue
  		}
  		m, err := Decode(&buf)
  		if err != nil {
  			t.Errorf("p=%v: Decode: %v", p, err)
  			continue
  		}
  		if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
  			t.Errorf("p=%v: got %v, want %v", p, got, want)
  		}
  	}
  }
  
  func TestEncodeImplicitConfigSize(t *testing.T) {
  	// For backwards compatibility for Go 1.4 and earlier code, the Config
  	// field is optional, and if zero, the width and height is implied by the
  	// first (and in this case only) frame's width and height.
  	//
  	// A Config only specifies a width and height (two integers) while an
  	// image.Image's Bounds method returns an image.Rectangle (four integers).
  	// For a gif.GIF, the overall bounds' top-left point is always implicitly
  	// (0, 0), and any frame whose bounds have a negative X or Y will be
  	// outside those overall bounds, so encoding should fail.
  	for _, lowerBound := range []int{-1, 0, 1} {
  		images := []*image.Paletted{
  			image.NewPaletted(image.Rect(lowerBound, lowerBound, 4, 4), palette.Plan9),
  		}
  		g := &GIF{
  			Image: images,
  			Delay: make([]int, len(images)),
  		}
  		err := EncodeAll(ioutil.Discard, g)
  		if lowerBound >= 0 {
  			if err != nil {
  				t.Errorf("lowerBound=%d: %v", lowerBound, err)
  			}
  		} else {
  			if err == nil {
  				t.Errorf("lowerBound=%d: got nil error, want non-nil", lowerBound)
  			}
  		}
  	}
  }
  
  func TestEncodePalettes(t *testing.T) {
  	const w, h = 5, 5
  	pals := []color.Palette{{
  		color.RGBA{0x00, 0x00, 0x00, 0xff},
  		color.RGBA{0x01, 0x00, 0x00, 0xff},
  		color.RGBA{0x02, 0x00, 0x00, 0xff},
  	}, {
  		color.RGBA{0x00, 0x00, 0x00, 0xff},
  		color.RGBA{0x00, 0x01, 0x00, 0xff},
  	}, {
  		color.RGBA{0x00, 0x00, 0x03, 0xff},
  		color.RGBA{0x00, 0x00, 0x02, 0xff},
  		color.RGBA{0x00, 0x00, 0x01, 0xff},
  		color.RGBA{0x00, 0x00, 0x00, 0xff},
  	}, {
  		color.RGBA{0x10, 0x07, 0xf0, 0xff},
  		color.RGBA{0x20, 0x07, 0xf0, 0xff},
  		color.RGBA{0x30, 0x07, 0xf0, 0xff},
  		color.RGBA{0x40, 0x07, 0xf0, 0xff},
  		color.RGBA{0x50, 0x07, 0xf0, 0xff},
  	}}
  	g0 := &GIF{
  		Image: []*image.Paletted{
  			image.NewPaletted(image.Rect(0, 0, w, h), pals[0]),
  			image.NewPaletted(image.Rect(0, 0, w, h), pals[1]),
  			image.NewPaletted(image.Rect(0, 0, w, h), pals[2]),
  			image.NewPaletted(image.Rect(0, 0, w, h), pals[3]),
  		},
  		Delay:    make([]int, len(pals)),
  		Disposal: make([]byte, len(pals)),
  		Config: image.Config{
  			ColorModel: pals[2],
  			Width:      w,
  			Height:     h,
  		},
  	}
  
  	var buf bytes.Buffer
  	if err := EncodeAll(&buf, g0); err != nil {
  		t.Fatalf("EncodeAll: %v", err)
  	}
  	g1, err := DecodeAll(&buf)
  	if err != nil {
  		t.Fatalf("DecodeAll: %v", err)
  	}
  	if len(g0.Image) != len(g1.Image) {
  		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
  	}
  	for i, m := range g1.Image {
  		if got, want := m.Palette, pals[i]; !palettesEqual(got, want) {
  			t.Errorf("frame %d:\ngot  %v\nwant %v", i, got, want)
  		}
  	}
  }
  
  func TestEncodeBadPalettes(t *testing.T) {
  	const w, h = 5, 5
  	for _, n := range []int{256, 257} {
  		for _, nilColors := range []bool{false, true} {
  			pal := make(color.Palette, n)
  			if !nilColors {
  				for i := range pal {
  					pal[i] = color.Black
  				}
  			}
  
  			err := EncodeAll(ioutil.Discard, &GIF{
  				Image: []*image.Paletted{
  					image.NewPaletted(image.Rect(0, 0, w, h), pal),
  				},
  				Delay:    make([]int, 1),
  				Disposal: make([]byte, 1),
  				Config: image.Config{
  					ColorModel: pal,
  					Width:      w,
  					Height:     h,
  				},
  			})
  
  			got := err != nil
  			want := n > 256 || nilColors
  			if got != want {
  				t.Errorf("n=%d, nilColors=%t: err != nil: got %t, want %t", n, nilColors, got, want)
  			}
  		}
  	}
  }
  
  func TestEncodeCroppedSubImages(t *testing.T) {
  	// This test means to ensure that Encode honors the Bounds and Strides of
  	// images correctly when encoding.
  	whole := image.NewPaletted(image.Rect(0, 0, 100, 100), palette.Plan9)
  	subImages := []image.Rectangle{
  		image.Rect(0, 0, 50, 50),
  		image.Rect(50, 0, 100, 50),
  		image.Rect(0, 50, 50, 50),
  		image.Rect(50, 50, 100, 100),
  		image.Rect(25, 25, 75, 75),
  		image.Rect(0, 0, 100, 50),
  		image.Rect(0, 50, 100, 100),
  		image.Rect(0, 0, 50, 100),
  		image.Rect(50, 0, 100, 100),
  	}
  	for _, sr := range subImages {
  		si := whole.SubImage(sr)
  		buf := bytes.NewBuffer(nil)
  		if err := Encode(buf, si, nil); err != nil {
  			t.Errorf("Encode: sr=%v: %v", sr, err)
  			continue
  		}
  		if _, err := Decode(buf); err != nil {
  			t.Errorf("Decode: sr=%v: %v", sr, err)
  		}
  	}
  }
  
  func BenchmarkEncode(b *testing.B) {
  	b.StopTimer()
  
  	bo := image.Rect(0, 0, 640, 480)
  	rnd := rand.New(rand.NewSource(123))
  
  	// Restrict to a 256-color paletted image to avoid quantization path.
  	palette := make(color.Palette, 256)
  	for i := range palette {
  		palette[i] = color.RGBA{
  			uint8(rnd.Intn(256)),
  			uint8(rnd.Intn(256)),
  			uint8(rnd.Intn(256)),
  			255,
  		}
  	}
  	img := image.NewPaletted(image.Rect(0, 0, 640, 480), palette)
  	for y := bo.Min.Y; y < bo.Max.Y; y++ {
  		for x := bo.Min.X; x < bo.Max.X; x++ {
  			img.Set(x, y, palette[rnd.Intn(256)])
  		}
  	}
  
  	b.SetBytes(640 * 480 * 4)
  	b.StartTimer()
  	for i := 0; i < b.N; i++ {
  		Encode(ioutil.Discard, img, nil)
  	}
  }
  
  func BenchmarkQuantizedEncode(b *testing.B) {
  	b.StopTimer()
  	img := image.NewRGBA(image.Rect(0, 0, 640, 480))
  	bo := img.Bounds()
  	rnd := rand.New(rand.NewSource(123))
  	for y := bo.Min.Y; y < bo.Max.Y; y++ {
  		for x := bo.Min.X; x < bo.Max.X; x++ {
  			img.SetRGBA(x, y, color.RGBA{
  				uint8(rnd.Intn(256)),
  				uint8(rnd.Intn(256)),
  				uint8(rnd.Intn(256)),
  				255,
  			})
  		}
  	}
  	b.SetBytes(640 * 480 * 4)
  	b.StartTimer()
  	for i := 0; i < b.N; i++ {
  		Encode(ioutil.Discard, img, nil)
  	}
  }
  

View as plain text