Source file src/image/gif/writer_test.go

Documentation: image/gif

		 1  // Copyright 2013 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package gif
		 6  
		 7  import (
		 8  	"bytes"
		 9  	"image"
		10  	"image/color"
		11  	"image/color/palette"
		12  	"image/draw"
		13  	_ "image/png"
		14  	"io"
		15  	"math/rand"
		16  	"os"
		17  	"reflect"
		18  	"testing"
		19  )
		20  
		21  func readImg(filename string) (image.Image, error) {
		22  	f, err := os.Open(filename)
		23  	if err != nil {
		24  		return nil, err
		25  	}
		26  	defer f.Close()
		27  	m, _, err := image.Decode(f)
		28  	return m, err
		29  }
		30  
		31  func readGIF(filename string) (*GIF, error) {
		32  	f, err := os.Open(filename)
		33  	if err != nil {
		34  		return nil, err
		35  	}
		36  	defer f.Close()
		37  	return DecodeAll(f)
		38  }
		39  
		40  func delta(u0, u1 uint32) int64 {
		41  	d := int64(u0) - int64(u1)
		42  	if d < 0 {
		43  		return -d
		44  	}
		45  	return d
		46  }
		47  
		48  // averageDelta returns the average delta in RGB space. The two images must
		49  // have the same bounds.
		50  func averageDelta(m0, m1 image.Image) int64 {
		51  	b := m0.Bounds()
		52  	return averageDeltaBound(m0, m1, b, b)
		53  }
		54  
		55  // averageDeltaBounds returns the average delta in RGB space. The average delta is
		56  // calculated in the specified bounds.
		57  func averageDeltaBound(m0, m1 image.Image, b0, b1 image.Rectangle) int64 {
		58  	var sum, n int64
		59  	for y := b0.Min.Y; y < b0.Max.Y; y++ {
		60  		for x := b0.Min.X; x < b0.Max.X; x++ {
		61  			c0 := m0.At(x, y)
		62  			c1 := m1.At(x-b0.Min.X+b1.Min.X, y-b0.Min.Y+b1.Min.Y)
		63  			r0, g0, b0, _ := c0.RGBA()
		64  			r1, g1, b1, _ := c1.RGBA()
		65  			sum += delta(r0, r1)
		66  			sum += delta(g0, g1)
		67  			sum += delta(b0, b1)
		68  			n += 3
		69  		}
		70  	}
		71  	return sum / n
		72  }
		73  
		74  // lzw.NewWriter wants an interface which is basically the same thing as gif's
		75  // writer interface.	This ensures we're compatible.
		76  var _ writer = blockWriter{}
		77  
		78  var testCase = []struct {
		79  	filename	string
		80  	tolerance int64
		81  }{
		82  	{"../testdata/video-001.png", 1 << 12},
		83  	{"../testdata/video-001.gif", 0},
		84  	{"../testdata/video-001.interlaced.gif", 0},
		85  }
		86  
		87  func TestWriter(t *testing.T) {
		88  	for _, tc := range testCase {
		89  		m0, err := readImg(tc.filename)
		90  		if err != nil {
		91  			t.Error(tc.filename, err)
		92  			continue
		93  		}
		94  		var buf bytes.Buffer
		95  		err = Encode(&buf, m0, nil)
		96  		if err != nil {
		97  			t.Error(tc.filename, err)
		98  			continue
		99  		}
	 100  		m1, err := Decode(&buf)
	 101  		if err != nil {
	 102  			t.Error(tc.filename, err)
	 103  			continue
	 104  		}
	 105  		if m0.Bounds() != m1.Bounds() {
	 106  			t.Errorf("%s, bounds differ: %v and %v", tc.filename, m0.Bounds(), m1.Bounds())
	 107  			continue
	 108  		}
	 109  		// Compare the average delta to the tolerance level.
	 110  		avgDelta := averageDelta(m0, m1)
	 111  		if avgDelta > tc.tolerance {
	 112  			t.Errorf("%s: average delta is too high. expected: %d, got %d", tc.filename, tc.tolerance, avgDelta)
	 113  			continue
	 114  		}
	 115  	}
	 116  }
	 117  
	 118  func TestSubImage(t *testing.T) {
	 119  	m0, err := readImg("../testdata/video-001.gif")
	 120  	if err != nil {
	 121  		t.Fatalf("readImg: %v", err)
	 122  	}
	 123  	m0 = m0.(*image.Paletted).SubImage(image.Rect(0, 0, 50, 30))
	 124  	var buf bytes.Buffer
	 125  	err = Encode(&buf, m0, nil)
	 126  	if err != nil {
	 127  		t.Fatalf("Encode: %v", err)
	 128  	}
	 129  	m1, err := Decode(&buf)
	 130  	if err != nil {
	 131  		t.Fatalf("Decode: %v", err)
	 132  	}
	 133  	if m0.Bounds() != m1.Bounds() {
	 134  		t.Fatalf("bounds differ: %v and %v", m0.Bounds(), m1.Bounds())
	 135  	}
	 136  	if averageDelta(m0, m1) != 0 {
	 137  		t.Fatalf("images differ")
	 138  	}
	 139  }
	 140  
	 141  // palettesEqual reports whether two color.Palette values are equal, ignoring
	 142  // any trailing opaque-black palette entries.
	 143  func palettesEqual(p, q color.Palette) bool {
	 144  	n := len(p)
	 145  	if n > len(q) {
	 146  		n = len(q)
	 147  	}
	 148  	for i := 0; i < n; i++ {
	 149  		if p[i] != q[i] {
	 150  			return false
	 151  		}
	 152  	}
	 153  	for i := n; i < len(p); i++ {
	 154  		r, g, b, a := p[i].RGBA()
	 155  		if r != 0 || g != 0 || b != 0 || a != 0xffff {
	 156  			return false
	 157  		}
	 158  	}
	 159  	for i := n; i < len(q); i++ {
	 160  		r, g, b, a := q[i].RGBA()
	 161  		if r != 0 || g != 0 || b != 0 || a != 0xffff {
	 162  			return false
	 163  		}
	 164  	}
	 165  	return true
	 166  }
	 167  
	 168  var frames = []string{
	 169  	"../testdata/video-001.gif",
	 170  	"../testdata/video-005.gray.gif",
	 171  }
	 172  
	 173  func testEncodeAll(t *testing.T, go1Dot5Fields bool, useGlobalColorModel bool) {
	 174  	const width, height = 150, 103
	 175  
	 176  	g0 := &GIF{
	 177  		Image:		 make([]*image.Paletted, len(frames)),
	 178  		Delay:		 make([]int, len(frames)),
	 179  		LoopCount: 5,
	 180  	}
	 181  	for i, f := range frames {
	 182  		g, err := readGIF(f)
	 183  		if err != nil {
	 184  			t.Fatal(f, err)
	 185  		}
	 186  		m := g.Image[0]
	 187  		if m.Bounds().Dx() != width || m.Bounds().Dy() != height {
	 188  			t.Fatalf("frame %d had unexpected bounds: got %v, want width/height = %d/%d",
	 189  				i, m.Bounds(), width, height)
	 190  		}
	 191  		g0.Image[i] = m
	 192  	}
	 193  	// The GIF.Disposal, GIF.Config and GIF.BackgroundIndex fields were added
	 194  	// in Go 1.5. Valid Go 1.4 or earlier code should still produce valid GIFs.
	 195  	//
	 196  	// On the following line, color.Model is an interface type, and
	 197  	// color.Palette is a concrete (slice) type.
	 198  	globalColorModel, backgroundIndex := color.Model(color.Palette(nil)), uint8(0)
	 199  	if useGlobalColorModel {
	 200  		globalColorModel, backgroundIndex = color.Palette(palette.WebSafe), uint8(1)
	 201  	}
	 202  	if go1Dot5Fields {
	 203  		g0.Disposal = make([]byte, len(g0.Image))
	 204  		for i := range g0.Disposal {
	 205  			g0.Disposal[i] = DisposalNone
	 206  		}
	 207  		g0.Config = image.Config{
	 208  			ColorModel: globalColorModel,
	 209  			Width:			width,
	 210  			Height:		 height,
	 211  		}
	 212  		g0.BackgroundIndex = backgroundIndex
	 213  	}
	 214  
	 215  	var buf bytes.Buffer
	 216  	if err := EncodeAll(&buf, g0); err != nil {
	 217  		t.Fatal("EncodeAll:", err)
	 218  	}
	 219  	encoded := buf.Bytes()
	 220  	config, err := DecodeConfig(bytes.NewReader(encoded))
	 221  	if err != nil {
	 222  		t.Fatal("DecodeConfig:", err)
	 223  	}
	 224  	g1, err := DecodeAll(bytes.NewReader(encoded))
	 225  	if err != nil {
	 226  		t.Fatal("DecodeAll:", err)
	 227  	}
	 228  
	 229  	if !reflect.DeepEqual(config, g1.Config) {
	 230  		t.Errorf("DecodeConfig inconsistent with DecodeAll")
	 231  	}
	 232  	if !palettesEqual(g1.Config.ColorModel.(color.Palette), globalColorModel.(color.Palette)) {
	 233  		t.Errorf("unexpected global color model")
	 234  	}
	 235  	if w, h := g1.Config.Width, g1.Config.Height; w != width || h != height {
	 236  		t.Errorf("got config width * height = %d * %d, want %d * %d", w, h, width, height)
	 237  	}
	 238  
	 239  	if g0.LoopCount != g1.LoopCount {
	 240  		t.Errorf("loop counts differ: %d and %d", g0.LoopCount, g1.LoopCount)
	 241  	}
	 242  	if backgroundIndex != g1.BackgroundIndex {
	 243  		t.Errorf("background indexes differ: %d and %d", backgroundIndex, g1.BackgroundIndex)
	 244  	}
	 245  	if len(g0.Image) != len(g1.Image) {
	 246  		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
	 247  	}
	 248  	if len(g1.Image) != len(g1.Delay) {
	 249  		t.Fatalf("image and delay lengths differ: %d and %d", len(g1.Image), len(g1.Delay))
	 250  	}
	 251  	if len(g1.Image) != len(g1.Disposal) {
	 252  		t.Fatalf("image and disposal lengths differ: %d and %d", len(g1.Image), len(g1.Disposal))
	 253  	}
	 254  
	 255  	for i := range g0.Image {
	 256  		m0, m1 := g0.Image[i], g1.Image[i]
	 257  		if m0.Bounds() != m1.Bounds() {
	 258  			t.Errorf("frame %d: bounds differ: %v and %v", i, m0.Bounds(), m1.Bounds())
	 259  		}
	 260  		d0, d1 := g0.Delay[i], g1.Delay[i]
	 261  		if d0 != d1 {
	 262  			t.Errorf("frame %d: delay values differ: %d and %d", i, d0, d1)
	 263  		}
	 264  		p0, p1 := uint8(0), g1.Disposal[i]
	 265  		if go1Dot5Fields {
	 266  			p0 = DisposalNone
	 267  		}
	 268  		if p0 != p1 {
	 269  			t.Errorf("frame %d: disposal values differ: %d and %d", i, p0, p1)
	 270  		}
	 271  	}
	 272  }
	 273  
	 274  func TestEncodeAllGo1Dot4(t *testing.T)								 { testEncodeAll(t, false, false) }
	 275  func TestEncodeAllGo1Dot5(t *testing.T)								 { testEncodeAll(t, true, false) }
	 276  func TestEncodeAllGo1Dot5GlobalColorModel(t *testing.T) { testEncodeAll(t, true, true) }
	 277  
	 278  func TestEncodeMismatchDelay(t *testing.T) {
	 279  	images := make([]*image.Paletted, 2)
	 280  	for i := range images {
	 281  		images[i] = image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9)
	 282  	}
	 283  
	 284  	g0 := &GIF{
	 285  		Image: images,
	 286  		Delay: make([]int, 1),
	 287  	}
	 288  	if err := EncodeAll(io.Discard, g0); err == nil {
	 289  		t.Error("expected error from mismatched delay and image slice lengths")
	 290  	}
	 291  
	 292  	g1 := &GIF{
	 293  		Image:		images,
	 294  		Delay:		make([]int, len(images)),
	 295  		Disposal: make([]byte, 1),
	 296  	}
	 297  	for i := range g1.Disposal {
	 298  		g1.Disposal[i] = DisposalNone
	 299  	}
	 300  	if err := EncodeAll(io.Discard, g1); err == nil {
	 301  		t.Error("expected error from mismatched disposal and image slice lengths")
	 302  	}
	 303  }
	 304  
	 305  func TestEncodeZeroGIF(t *testing.T) {
	 306  	if err := EncodeAll(io.Discard, &GIF{}); err == nil {
	 307  		t.Error("expected error from providing empty gif")
	 308  	}
	 309  }
	 310  
	 311  func TestEncodeAllFramesOutOfBounds(t *testing.T) {
	 312  	images := []*image.Paletted{
	 313  		image.NewPaletted(image.Rect(0, 0, 5, 5), palette.Plan9),
	 314  		image.NewPaletted(image.Rect(2, 2, 8, 8), palette.Plan9),
	 315  		image.NewPaletted(image.Rect(3, 3, 4, 4), palette.Plan9),
	 316  	}
	 317  	for _, upperBound := range []int{6, 10} {
	 318  		g := &GIF{
	 319  			Image:		images,
	 320  			Delay:		make([]int, len(images)),
	 321  			Disposal: make([]byte, len(images)),
	 322  			Config: image.Config{
	 323  				Width:	upperBound,
	 324  				Height: upperBound,
	 325  			},
	 326  		}
	 327  		err := EncodeAll(io.Discard, g)
	 328  		if upperBound >= 8 {
	 329  			if err != nil {
	 330  				t.Errorf("upperBound=%d: %v", upperBound, err)
	 331  			}
	 332  		} else {
	 333  			if err == nil {
	 334  				t.Errorf("upperBound=%d: got nil error, want non-nil", upperBound)
	 335  			}
	 336  		}
	 337  	}
	 338  }
	 339  
	 340  func TestEncodeNonZeroMinPoint(t *testing.T) {
	 341  	points := []image.Point{
	 342  		{-8, -9},
	 343  		{-4, -4},
	 344  		{-3, +3},
	 345  		{+0, +0},
	 346  		{+2, +2},
	 347  	}
	 348  	for _, p := range points {
	 349  		src := image.NewPaletted(image.Rectangle{
	 350  			Min: p,
	 351  			Max: p.Add(image.Point{6, 6}),
	 352  		}, palette.Plan9)
	 353  		var buf bytes.Buffer
	 354  		if err := Encode(&buf, src, nil); err != nil {
	 355  			t.Errorf("p=%v: Encode: %v", p, err)
	 356  			continue
	 357  		}
	 358  		m, err := Decode(&buf)
	 359  		if err != nil {
	 360  			t.Errorf("p=%v: Decode: %v", p, err)
	 361  			continue
	 362  		}
	 363  		if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
	 364  			t.Errorf("p=%v: got %v, want %v", p, got, want)
	 365  		}
	 366  	}
	 367  
	 368  	// Also test having a source image (gray on the diagonal) that has a
	 369  	// non-zero Bounds().Min, but isn't an image.Paletted.
	 370  	{
	 371  		p := image.Point{+2, +2}
	 372  		src := image.NewRGBA(image.Rectangle{
	 373  			Min: p,
	 374  			Max: p.Add(image.Point{6, 6}),
	 375  		})
	 376  		src.SetRGBA(2, 2, color.RGBA{0x22, 0x22, 0x22, 0xFF})
	 377  		src.SetRGBA(3, 3, color.RGBA{0x33, 0x33, 0x33, 0xFF})
	 378  		src.SetRGBA(4, 4, color.RGBA{0x44, 0x44, 0x44, 0xFF})
	 379  		src.SetRGBA(5, 5, color.RGBA{0x55, 0x55, 0x55, 0xFF})
	 380  		src.SetRGBA(6, 6, color.RGBA{0x66, 0x66, 0x66, 0xFF})
	 381  		src.SetRGBA(7, 7, color.RGBA{0x77, 0x77, 0x77, 0xFF})
	 382  
	 383  		var buf bytes.Buffer
	 384  		if err := Encode(&buf, src, nil); err != nil {
	 385  			t.Errorf("gray-diagonal: Encode: %v", err)
	 386  			return
	 387  		}
	 388  		m, err := Decode(&buf)
	 389  		if err != nil {
	 390  			t.Errorf("gray-diagonal: Decode: %v", err)
	 391  			return
	 392  		}
	 393  		if got, want := m.Bounds(), image.Rect(0, 0, 6, 6); got != want {
	 394  			t.Errorf("gray-diagonal: got %v, want %v", got, want)
	 395  			return
	 396  		}
	 397  
	 398  		rednessAt := func(x int, y int) uint32 {
	 399  			r, _, _, _ := m.At(x, y).RGBA()
	 400  			// Shift by 8 to convert from 16 bit color to 8 bit color.
	 401  			return r >> 8
	 402  		}
	 403  
	 404  		// Round-tripping a still (non-animated) image.Image through
	 405  		// Encode+Decode should shift the origin to (0, 0).
	 406  		if got, want := rednessAt(0, 0), uint32(0x22); got != want {
	 407  			t.Errorf("gray-diagonal: rednessAt(0, 0): got 0x%02x, want 0x%02x", got, want)
	 408  		}
	 409  		if got, want := rednessAt(5, 5), uint32(0x77); got != want {
	 410  			t.Errorf("gray-diagonal: rednessAt(5, 5): got 0x%02x, want 0x%02x", got, want)
	 411  		}
	 412  	}
	 413  }
	 414  
	 415  func TestEncodeImplicitConfigSize(t *testing.T) {
	 416  	// For backwards compatibility for Go 1.4 and earlier code, the Config
	 417  	// field is optional, and if zero, the width and height is implied by the
	 418  	// first (and in this case only) frame's width and height.
	 419  	//
	 420  	// A Config only specifies a width and height (two integers) while an
	 421  	// image.Image's Bounds method returns an image.Rectangle (four integers).
	 422  	// For a gif.GIF, the overall bounds' top-left point is always implicitly
	 423  	// (0, 0), and any frame whose bounds have a negative X or Y will be
	 424  	// outside those overall bounds, so encoding should fail.
	 425  	for _, lowerBound := range []int{-1, 0, 1} {
	 426  		images := []*image.Paletted{
	 427  			image.NewPaletted(image.Rect(lowerBound, lowerBound, 4, 4), palette.Plan9),
	 428  		}
	 429  		g := &GIF{
	 430  			Image: images,
	 431  			Delay: make([]int, len(images)),
	 432  		}
	 433  		err := EncodeAll(io.Discard, g)
	 434  		if lowerBound >= 0 {
	 435  			if err != nil {
	 436  				t.Errorf("lowerBound=%d: %v", lowerBound, err)
	 437  			}
	 438  		} else {
	 439  			if err == nil {
	 440  				t.Errorf("lowerBound=%d: got nil error, want non-nil", lowerBound)
	 441  			}
	 442  		}
	 443  	}
	 444  }
	 445  
	 446  func TestEncodePalettes(t *testing.T) {
	 447  	const w, h = 5, 5
	 448  	pals := []color.Palette{{
	 449  		color.RGBA{0x00, 0x00, 0x00, 0xff},
	 450  		color.RGBA{0x01, 0x00, 0x00, 0xff},
	 451  		color.RGBA{0x02, 0x00, 0x00, 0xff},
	 452  	}, {
	 453  		color.RGBA{0x00, 0x00, 0x00, 0xff},
	 454  		color.RGBA{0x00, 0x01, 0x00, 0xff},
	 455  	}, {
	 456  		color.RGBA{0x00, 0x00, 0x03, 0xff},
	 457  		color.RGBA{0x00, 0x00, 0x02, 0xff},
	 458  		color.RGBA{0x00, 0x00, 0x01, 0xff},
	 459  		color.RGBA{0x00, 0x00, 0x00, 0xff},
	 460  	}, {
	 461  		color.RGBA{0x10, 0x07, 0xf0, 0xff},
	 462  		color.RGBA{0x20, 0x07, 0xf0, 0xff},
	 463  		color.RGBA{0x30, 0x07, 0xf0, 0xff},
	 464  		color.RGBA{0x40, 0x07, 0xf0, 0xff},
	 465  		color.RGBA{0x50, 0x07, 0xf0, 0xff},
	 466  	}}
	 467  	g0 := &GIF{
	 468  		Image: []*image.Paletted{
	 469  			image.NewPaletted(image.Rect(0, 0, w, h), pals[0]),
	 470  			image.NewPaletted(image.Rect(0, 0, w, h), pals[1]),
	 471  			image.NewPaletted(image.Rect(0, 0, w, h), pals[2]),
	 472  			image.NewPaletted(image.Rect(0, 0, w, h), pals[3]),
	 473  		},
	 474  		Delay:		make([]int, len(pals)),
	 475  		Disposal: make([]byte, len(pals)),
	 476  		Config: image.Config{
	 477  			ColorModel: pals[2],
	 478  			Width:			w,
	 479  			Height:		 h,
	 480  		},
	 481  	}
	 482  
	 483  	var buf bytes.Buffer
	 484  	if err := EncodeAll(&buf, g0); err != nil {
	 485  		t.Fatalf("EncodeAll: %v", err)
	 486  	}
	 487  	g1, err := DecodeAll(&buf)
	 488  	if err != nil {
	 489  		t.Fatalf("DecodeAll: %v", err)
	 490  	}
	 491  	if len(g0.Image) != len(g1.Image) {
	 492  		t.Fatalf("image lengths differ: %d and %d", len(g0.Image), len(g1.Image))
	 493  	}
	 494  	for i, m := range g1.Image {
	 495  		if got, want := m.Palette, pals[i]; !palettesEqual(got, want) {
	 496  			t.Errorf("frame %d:\ngot	%v\nwant %v", i, got, want)
	 497  		}
	 498  	}
	 499  }
	 500  
	 501  func TestEncodeBadPalettes(t *testing.T) {
	 502  	const w, h = 5, 5
	 503  	for _, n := range []int{256, 257} {
	 504  		for _, nilColors := range []bool{false, true} {
	 505  			pal := make(color.Palette, n)
	 506  			if !nilColors {
	 507  				for i := range pal {
	 508  					pal[i] = color.Black
	 509  				}
	 510  			}
	 511  
	 512  			err := EncodeAll(io.Discard, &GIF{
	 513  				Image: []*image.Paletted{
	 514  					image.NewPaletted(image.Rect(0, 0, w, h), pal),
	 515  				},
	 516  				Delay:		make([]int, 1),
	 517  				Disposal: make([]byte, 1),
	 518  				Config: image.Config{
	 519  					ColorModel: pal,
	 520  					Width:			w,
	 521  					Height:		 h,
	 522  				},
	 523  			})
	 524  
	 525  			got := err != nil
	 526  			want := n > 256 || nilColors
	 527  			if got != want {
	 528  				t.Errorf("n=%d, nilColors=%t: err != nil: got %t, want %t", n, nilColors, got, want)
	 529  			}
	 530  		}
	 531  	}
	 532  }
	 533  
	 534  func TestColorTablesMatch(t *testing.T) {
	 535  	const trIdx = 100
	 536  	global := color.Palette(palette.Plan9)
	 537  	if rgb := global[trIdx].(color.RGBA); rgb.R == 0 && rgb.G == 0 && rgb.B == 0 {
	 538  		t.Fatalf("trIdx (%d) is already black", trIdx)
	 539  	}
	 540  
	 541  	// Make a copy of the palette, substituting trIdx's slot with transparent,
	 542  	// just like decoder.decode.
	 543  	local := append(color.Palette(nil), global...)
	 544  	local[trIdx] = color.RGBA{}
	 545  
	 546  	const testLen = 3 * 256
	 547  	const padded = 7
	 548  	e := new(encoder)
	 549  	if l, err := encodeColorTable(e.globalColorTable[:], global, padded); err != nil || l != testLen {
	 550  		t.Fatalf("Failed to encode global color table: got %d, %v; want nil, %d", l, err, testLen)
	 551  	}
	 552  	if l, err := encodeColorTable(e.localColorTable[:], local, padded); err != nil || l != testLen {
	 553  		t.Fatalf("Failed to encode local color table: got %d, %v; want nil, %d", l, err, testLen)
	 554  	}
	 555  	if bytes.Equal(e.globalColorTable[:testLen], e.localColorTable[:testLen]) {
	 556  		t.Fatal("Encoded color tables are equal, expected mismatch")
	 557  	}
	 558  	if !e.colorTablesMatch(len(local), trIdx) {
	 559  		t.Fatal("colorTablesMatch() == false, expected true")
	 560  	}
	 561  }
	 562  
	 563  func TestEncodeCroppedSubImages(t *testing.T) {
	 564  	// This test means to ensure that Encode honors the Bounds and Strides of
	 565  	// images correctly when encoding.
	 566  	whole := image.NewPaletted(image.Rect(0, 0, 100, 100), palette.Plan9)
	 567  	subImages := []image.Rectangle{
	 568  		image.Rect(0, 0, 50, 50),
	 569  		image.Rect(50, 0, 100, 50),
	 570  		image.Rect(0, 50, 50, 50),
	 571  		image.Rect(50, 50, 100, 100),
	 572  		image.Rect(25, 25, 75, 75),
	 573  		image.Rect(0, 0, 100, 50),
	 574  		image.Rect(0, 50, 100, 100),
	 575  		image.Rect(0, 0, 50, 100),
	 576  		image.Rect(50, 0, 100, 100),
	 577  	}
	 578  	for _, sr := range subImages {
	 579  		si := whole.SubImage(sr)
	 580  		buf := bytes.NewBuffer(nil)
	 581  		if err := Encode(buf, si, nil); err != nil {
	 582  			t.Errorf("Encode: sr=%v: %v", sr, err)
	 583  			continue
	 584  		}
	 585  		if _, err := Decode(buf); err != nil {
	 586  			t.Errorf("Decode: sr=%v: %v", sr, err)
	 587  		}
	 588  	}
	 589  }
	 590  
	 591  type offsetImage struct {
	 592  	image.Image
	 593  	Rect image.Rectangle
	 594  }
	 595  
	 596  func (i offsetImage) Bounds() image.Rectangle {
	 597  	return i.Rect
	 598  }
	 599  
	 600  func TestEncodeWrappedImage(t *testing.T) {
	 601  	m0, err := readImg("../testdata/video-001.gif")
	 602  	if err != nil {
	 603  		t.Fatalf("readImg: %v", err)
	 604  	}
	 605  
	 606  	// Case 1: Enocde a wrapped image.Image
	 607  	buf := new(bytes.Buffer)
	 608  	w0 := offsetImage{m0, m0.Bounds()}
	 609  	err = Encode(buf, w0, nil)
	 610  	if err != nil {
	 611  		t.Fatalf("Encode: %v", err)
	 612  	}
	 613  	w1, err := Decode(buf)
	 614  	if err != nil {
	 615  		t.Fatalf("Dencode: %v", err)
	 616  	}
	 617  	avgDelta := averageDelta(m0, w1)
	 618  	if avgDelta > 0 {
	 619  		t.Fatalf("Wrapped: average delta is too high. expected: 0, got %d", avgDelta)
	 620  	}
	 621  
	 622  	// Case 2: Enocde a wrapped image.Image with offset
	 623  	b0 := image.Rectangle{
	 624  		Min: image.Point{
	 625  			X: 128,
	 626  			Y: 64,
	 627  		},
	 628  		Max: image.Point{
	 629  			X: 256,
	 630  			Y: 128,
	 631  		},
	 632  	}
	 633  	w0 = offsetImage{m0, b0}
	 634  	buf = new(bytes.Buffer)
	 635  	err = Encode(buf, w0, nil)
	 636  	if err != nil {
	 637  		t.Fatalf("Encode: %v", err)
	 638  	}
	 639  	w1, err = Decode(buf)
	 640  	if err != nil {
	 641  		t.Fatalf("Dencode: %v", err)
	 642  	}
	 643  
	 644  	b1 := image.Rectangle{
	 645  		Min: image.Point{
	 646  			X: 0,
	 647  			Y: 0,
	 648  		},
	 649  		Max: image.Point{
	 650  			X: 128,
	 651  			Y: 64,
	 652  		},
	 653  	}
	 654  	avgDelta = averageDeltaBound(m0, w1, b0, b1)
	 655  	if avgDelta > 0 {
	 656  		t.Fatalf("Wrapped and offset: average delta is too high. expected: 0, got %d", avgDelta)
	 657  	}
	 658  }
	 659  
	 660  func BenchmarkEncodeRandomPaletted(b *testing.B) {
	 661  	paletted := image.NewPaletted(image.Rect(0, 0, 640, 480), palette.Plan9)
	 662  	rnd := rand.New(rand.NewSource(123))
	 663  	for i := range paletted.Pix {
	 664  		paletted.Pix[i] = uint8(rnd.Intn(256))
	 665  	}
	 666  
	 667  	b.SetBytes(640 * 480 * 1)
	 668  	b.ReportAllocs()
	 669  	b.ResetTimer()
	 670  	for i := 0; i < b.N; i++ {
	 671  		Encode(io.Discard, paletted, nil)
	 672  	}
	 673  }
	 674  
	 675  func BenchmarkEncodeRandomRGBA(b *testing.B) {
	 676  	rgba := image.NewRGBA(image.Rect(0, 0, 640, 480))
	 677  	bo := rgba.Bounds()
	 678  	rnd := rand.New(rand.NewSource(123))
	 679  	for y := bo.Min.Y; y < bo.Max.Y; y++ {
	 680  		for x := bo.Min.X; x < bo.Max.X; x++ {
	 681  			rgba.SetRGBA(x, y, color.RGBA{
	 682  				uint8(rnd.Intn(256)),
	 683  				uint8(rnd.Intn(256)),
	 684  				uint8(rnd.Intn(256)),
	 685  				255,
	 686  			})
	 687  		}
	 688  	}
	 689  
	 690  	b.SetBytes(640 * 480 * 4)
	 691  	b.ReportAllocs()
	 692  	b.ResetTimer()
	 693  	for i := 0; i < b.N; i++ {
	 694  		Encode(io.Discard, rgba, nil)
	 695  	}
	 696  }
	 697  
	 698  func BenchmarkEncodeRealisticPaletted(b *testing.B) {
	 699  	img, err := readImg("../testdata/video-001.png")
	 700  	if err != nil {
	 701  		b.Fatalf("readImg: %v", err)
	 702  	}
	 703  	bo := img.Bounds()
	 704  	paletted := image.NewPaletted(bo, palette.Plan9)
	 705  	draw.Draw(paletted, bo, img, bo.Min, draw.Src)
	 706  
	 707  	b.SetBytes(int64(bo.Dx() * bo.Dy() * 1))
	 708  	b.ReportAllocs()
	 709  	b.ResetTimer()
	 710  	for i := 0; i < b.N; i++ {
	 711  		Encode(io.Discard, paletted, nil)
	 712  	}
	 713  }
	 714  
	 715  func BenchmarkEncodeRealisticRGBA(b *testing.B) {
	 716  	img, err := readImg("../testdata/video-001.png")
	 717  	if err != nil {
	 718  		b.Fatalf("readImg: %v", err)
	 719  	}
	 720  	bo := img.Bounds()
	 721  	// Converting img to rgba is redundant for video-001.png, which is already
	 722  	// in the RGBA format, but for those copy/pasting this benchmark (but
	 723  	// changing the source image), the conversion ensures that we're still
	 724  	// benchmarking encoding an RGBA image.
	 725  	rgba := image.NewRGBA(bo)
	 726  	draw.Draw(rgba, bo, img, bo.Min, draw.Src)
	 727  
	 728  	b.SetBytes(int64(bo.Dx() * bo.Dy() * 4))
	 729  	b.ReportAllocs()
	 730  	b.ResetTimer()
	 731  	for i := 0; i < b.N; i++ {
	 732  		Encode(io.Discard, rgba, nil)
	 733  	}
	 734  }
	 735  

View as plain text