Source file src/image/png/reader_test.go

Documentation: image/png

		 1  // Copyright 2009 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 png
		 6  
		 7  import (
		 8  	"bufio"
		 9  	"bytes"
		10  	"fmt"
		11  	"image"
		12  	"image/color"
		13  	"io"
		14  	"os"
		15  	"reflect"
		16  	"strings"
		17  	"testing"
		18  )
		19  
		20  var filenames = []string{
		21  	"basn0g01",
		22  	"basn0g01-30",
		23  	"basn0g02",
		24  	"basn0g02-29",
		25  	"basn0g04",
		26  	"basn0g04-31",
		27  	"basn0g08",
		28  	"basn0g16",
		29  	"basn2c08",
		30  	"basn2c16",
		31  	"basn3p01",
		32  	"basn3p02",
		33  	"basn3p04",
		34  	"basn3p04-31i",
		35  	"basn3p08",
		36  	"basn3p08-trns",
		37  	"basn4a08",
		38  	"basn4a16",
		39  	"basn6a08",
		40  	"basn6a16",
		41  	"ftbbn0g01",
		42  	"ftbbn0g02",
		43  	"ftbbn0g04",
		44  	"ftbbn2c16",
		45  	"ftbbn3p08",
		46  	"ftbgn2c16",
		47  	"ftbgn3p08",
		48  	"ftbrn2c08",
		49  	"ftbwn0g16",
		50  	"ftbwn3p08",
		51  	"ftbyn3p08",
		52  	"ftp0n0g08",
		53  	"ftp0n2c08",
		54  	"ftp0n3p08",
		55  	"ftp1n3p08",
		56  }
		57  
		58  var filenamesPaletted = []string{
		59  	"basn3p01",
		60  	"basn3p02",
		61  	"basn3p04",
		62  	"basn3p08",
		63  	"basn3p08-trns",
		64  }
		65  
		66  var filenamesShort = []string{
		67  	"basn0g01",
		68  	"basn0g04-31",
		69  	"basn6a16",
		70  }
		71  
		72  func readPNG(filename string) (image.Image, error) {
		73  	f, err := os.Open(filename)
		74  	if err != nil {
		75  		return nil, err
		76  	}
		77  	defer f.Close()
		78  	return Decode(f)
		79  }
		80  
		81  // fakebKGDs maps from filenames to fake bKGD chunks for our approximation to
		82  // the sng command-line tool. Package png doesn't keep that metadata when
		83  // png.Decode returns an image.Image.
		84  var fakebKGDs = map[string]string{
		85  	"ftbbn0g01": "bKGD {gray: 0;}\n",
		86  	"ftbbn0g02": "bKGD {gray: 0;}\n",
		87  	"ftbbn0g04": "bKGD {gray: 0;}\n",
		88  	"ftbbn2c16": "bKGD {red: 0;	green: 0;	blue: 65535;}\n",
		89  	"ftbbn3p08": "bKGD {index: 245}\n",
		90  	"ftbgn2c16": "bKGD {red: 0;	green: 65535;	blue: 0;}\n",
		91  	"ftbgn3p08": "bKGD {index: 245}\n",
		92  	"ftbrn2c08": "bKGD {red: 255;	green: 0;	blue: 0;}\n",
		93  	"ftbwn0g16": "bKGD {gray: 65535;}\n",
		94  	"ftbwn3p08": "bKGD {index: 0}\n",
		95  	"ftbyn3p08": "bKGD {index: 245}\n",
		96  }
		97  
		98  // fakegAMAs maps from filenames to fake gAMA chunks for our approximation to
		99  // the sng command-line tool. Package png doesn't keep that metadata when
	 100  // png.Decode returns an image.Image.
	 101  var fakegAMAs = map[string]string{
	 102  	"ftbbn0g01": "",
	 103  	"ftbbn0g02": "gAMA {0.45455}\n",
	 104  }
	 105  
	 106  // fakeIHDRUsings maps from filenames to fake IHDR "using" lines for our
	 107  // approximation to the sng command-line tool. The PNG model is that
	 108  // transparency (in the tRNS chunk) is separate to the color/grayscale/palette
	 109  // color model (in the IHDR chunk). The Go model is that the concrete
	 110  // image.Image type returned by png.Decode, such as image.RGBA (with all pixels
	 111  // having 100% alpha) or image.NRGBA, encapsulates whether or not the image has
	 112  // transparency. This map is a hack to work around the fact that the Go model
	 113  // can't otherwise discriminate PNG's "IHDR says color (with no alpha) but tRNS
	 114  // says alpha" and "IHDR says color with alpha".
	 115  var fakeIHDRUsings = map[string]string{
	 116  	"ftbbn0g01": "		using grayscale;\n",
	 117  	"ftbbn0g02": "		using grayscale;\n",
	 118  	"ftbbn0g04": "		using grayscale;\n",
	 119  	"ftbbn2c16": "		using color;\n",
	 120  	"ftbgn2c16": "		using color;\n",
	 121  	"ftbrn2c08": "		using color;\n",
	 122  	"ftbwn0g16": "		using grayscale;\n",
	 123  }
	 124  
	 125  // An approximation of the sng command-line tool.
	 126  func sng(w io.WriteCloser, filename string, png image.Image) {
	 127  	defer w.Close()
	 128  	bounds := png.Bounds()
	 129  	cm := png.ColorModel()
	 130  	var bitdepth int
	 131  	switch cm {
	 132  	case color.RGBAModel, color.NRGBAModel, color.AlphaModel, color.GrayModel:
	 133  		bitdepth = 8
	 134  	default:
	 135  		bitdepth = 16
	 136  	}
	 137  	cpm, _ := cm.(color.Palette)
	 138  	var paletted *image.Paletted
	 139  	if cpm != nil {
	 140  		switch {
	 141  		case len(cpm) <= 2:
	 142  			bitdepth = 1
	 143  		case len(cpm) <= 4:
	 144  			bitdepth = 2
	 145  		case len(cpm) <= 16:
	 146  			bitdepth = 4
	 147  		default:
	 148  			bitdepth = 8
	 149  		}
	 150  		paletted = png.(*image.Paletted)
	 151  	}
	 152  
	 153  	// Write the filename and IHDR.
	 154  	io.WriteString(w, "#SNG: from "+filename+".png\nIHDR {\n")
	 155  	fmt.Fprintf(w, "		width: %d; height: %d; bitdepth: %d;\n", bounds.Dx(), bounds.Dy(), bitdepth)
	 156  	if s, ok := fakeIHDRUsings[filename]; ok {
	 157  		io.WriteString(w, s)
	 158  	} else {
	 159  		switch {
	 160  		case cm == color.RGBAModel, cm == color.RGBA64Model:
	 161  			io.WriteString(w, "		using color;\n")
	 162  		case cm == color.NRGBAModel, cm == color.NRGBA64Model:
	 163  			io.WriteString(w, "		using color alpha;\n")
	 164  		case cm == color.GrayModel, cm == color.Gray16Model:
	 165  			io.WriteString(w, "		using grayscale;\n")
	 166  		case cpm != nil:
	 167  			io.WriteString(w, "		using color palette;\n")
	 168  		default:
	 169  			io.WriteString(w, "unknown PNG decoder color model\n")
	 170  		}
	 171  	}
	 172  	io.WriteString(w, "}\n")
	 173  
	 174  	// We fake a gAMA chunk. The test files have a gAMA chunk but the go PNG
	 175  	// parser ignores it (the PNG spec section 11.3 says "Ancillary chunks may
	 176  	// be ignored by a decoder").
	 177  	if s, ok := fakegAMAs[filename]; ok {
	 178  		io.WriteString(w, s)
	 179  	} else {
	 180  		io.WriteString(w, "gAMA {1.0000}\n")
	 181  	}
	 182  
	 183  	// Write the PLTE and tRNS (if applicable).
	 184  	useTransparent := false
	 185  	if cpm != nil {
	 186  		lastAlpha := -1
	 187  		io.WriteString(w, "PLTE {\n")
	 188  		for i, c := range cpm {
	 189  			var r, g, b, a uint8
	 190  			switch c := c.(type) {
	 191  			case color.RGBA:
	 192  				r, g, b, a = c.R, c.G, c.B, 0xff
	 193  			case color.NRGBA:
	 194  				r, g, b, a = c.R, c.G, c.B, c.A
	 195  			default:
	 196  				panic("unknown palette color type")
	 197  			}
	 198  			if a != 0xff {
	 199  				lastAlpha = i
	 200  			}
	 201  			fmt.Fprintf(w, "		(%3d,%3d,%3d)		 # rgb = (0x%02x,0x%02x,0x%02x)\n", r, g, b, r, g, b)
	 202  		}
	 203  		io.WriteString(w, "}\n")
	 204  		if s, ok := fakebKGDs[filename]; ok {
	 205  			io.WriteString(w, s)
	 206  		}
	 207  		if lastAlpha != -1 {
	 208  			io.WriteString(w, "tRNS {\n")
	 209  			for i := 0; i <= lastAlpha; i++ {
	 210  				_, _, _, a := cpm[i].RGBA()
	 211  				a >>= 8
	 212  				fmt.Fprintf(w, " %d", a)
	 213  			}
	 214  			io.WriteString(w, "}\n")
	 215  		}
	 216  	} else if strings.HasPrefix(filename, "ft") {
	 217  		if s, ok := fakebKGDs[filename]; ok {
	 218  			io.WriteString(w, s)
	 219  		}
	 220  		// We fake a tRNS chunk. The test files' grayscale and truecolor
	 221  		// transparent images all have their top left corner transparent.
	 222  		switch c := png.At(0, 0).(type) {
	 223  		case color.NRGBA:
	 224  			if c.A == 0 {
	 225  				useTransparent = true
	 226  				io.WriteString(w, "tRNS {\n")
	 227  				switch filename {
	 228  				case "ftbbn0g01", "ftbbn0g02", "ftbbn0g04":
	 229  					// The standard image package doesn't have a "gray with
	 230  					// alpha" type. Instead, we use an image.NRGBA.
	 231  					fmt.Fprintf(w, "		gray: %d;\n", c.R)
	 232  				default:
	 233  					fmt.Fprintf(w, "		red: %d; green: %d; blue: %d;\n", c.R, c.G, c.B)
	 234  				}
	 235  				io.WriteString(w, "}\n")
	 236  			}
	 237  		case color.NRGBA64:
	 238  			if c.A == 0 {
	 239  				useTransparent = true
	 240  				io.WriteString(w, "tRNS {\n")
	 241  				switch filename {
	 242  				case "ftbwn0g16":
	 243  					// The standard image package doesn't have a "gray16 with
	 244  					// alpha" type. Instead, we use an image.NRGBA64.
	 245  					fmt.Fprintf(w, "		gray: %d;\n", c.R)
	 246  				default:
	 247  					fmt.Fprintf(w, "		red: %d; green: %d; blue: %d;\n", c.R, c.G, c.B)
	 248  				}
	 249  				io.WriteString(w, "}\n")
	 250  			}
	 251  		}
	 252  	}
	 253  
	 254  	// Write the IMAGE.
	 255  	io.WriteString(w, "IMAGE {\n		pixels hex\n")
	 256  	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
	 257  		switch {
	 258  		case cm == color.GrayModel:
	 259  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 260  				gray := png.At(x, y).(color.Gray)
	 261  				fmt.Fprintf(w, "%02x", gray.Y)
	 262  			}
	 263  		case cm == color.Gray16Model:
	 264  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 265  				gray16 := png.At(x, y).(color.Gray16)
	 266  				fmt.Fprintf(w, "%04x ", gray16.Y)
	 267  			}
	 268  		case cm == color.RGBAModel:
	 269  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 270  				rgba := png.At(x, y).(color.RGBA)
	 271  				fmt.Fprintf(w, "%02x%02x%02x ", rgba.R, rgba.G, rgba.B)
	 272  			}
	 273  		case cm == color.RGBA64Model:
	 274  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 275  				rgba64 := png.At(x, y).(color.RGBA64)
	 276  				fmt.Fprintf(w, "%04x%04x%04x ", rgba64.R, rgba64.G, rgba64.B)
	 277  			}
	 278  		case cm == color.NRGBAModel:
	 279  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 280  				nrgba := png.At(x, y).(color.NRGBA)
	 281  				switch filename {
	 282  				case "ftbbn0g01", "ftbbn0g02", "ftbbn0g04":
	 283  					fmt.Fprintf(w, "%02x", nrgba.R)
	 284  				default:
	 285  					if useTransparent {
	 286  						fmt.Fprintf(w, "%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B)
	 287  					} else {
	 288  						fmt.Fprintf(w, "%02x%02x%02x%02x ", nrgba.R, nrgba.G, nrgba.B, nrgba.A)
	 289  					}
	 290  				}
	 291  			}
	 292  		case cm == color.NRGBA64Model:
	 293  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 294  				nrgba64 := png.At(x, y).(color.NRGBA64)
	 295  				switch filename {
	 296  				case "ftbwn0g16":
	 297  					fmt.Fprintf(w, "%04x ", nrgba64.R)
	 298  				default:
	 299  					if useTransparent {
	 300  						fmt.Fprintf(w, "%04x%04x%04x ", nrgba64.R, nrgba64.G, nrgba64.B)
	 301  					} else {
	 302  						fmt.Fprintf(w, "%04x%04x%04x%04x ", nrgba64.R, nrgba64.G, nrgba64.B, nrgba64.A)
	 303  					}
	 304  				}
	 305  			}
	 306  		case cpm != nil:
	 307  			var b, c int
	 308  			for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 309  				b = b<<uint(bitdepth) | int(paletted.ColorIndexAt(x, y))
	 310  				c++
	 311  				if c == 8/bitdepth {
	 312  					fmt.Fprintf(w, "%02x", b)
	 313  					b = 0
	 314  					c = 0
	 315  				}
	 316  			}
	 317  			if c != 0 {
	 318  				for c != 8/bitdepth {
	 319  					b = b << uint(bitdepth)
	 320  					c++
	 321  				}
	 322  				fmt.Fprintf(w, "%02x", b)
	 323  			}
	 324  		}
	 325  		io.WriteString(w, "\n")
	 326  	}
	 327  	io.WriteString(w, "}\n")
	 328  }
	 329  
	 330  func TestReader(t *testing.T) {
	 331  	names := filenames
	 332  	if testing.Short() {
	 333  		names = filenamesShort
	 334  	}
	 335  	for _, fn := range names {
	 336  		// Read the .png file.
	 337  		img, err := readPNG("testdata/pngsuite/" + fn + ".png")
	 338  		if err != nil {
	 339  			t.Error(fn, err)
	 340  			continue
	 341  		}
	 342  
	 343  		if fn == "basn4a16" {
	 344  			// basn4a16.sng is gray + alpha but sng() will produce true color + alpha
	 345  			// so we just check a single random pixel.
	 346  			c := img.At(2, 1).(color.NRGBA64)
	 347  			if c.R != 0x11a7 || c.G != 0x11a7 || c.B != 0x11a7 || c.A != 0x1085 {
	 348  				t.Error(fn, fmt.Errorf("wrong pixel value at (2, 1): %x", c))
	 349  			}
	 350  			continue
	 351  		}
	 352  
	 353  		piper, pipew := io.Pipe()
	 354  		pb := bufio.NewScanner(piper)
	 355  		go sng(pipew, fn, img)
	 356  		defer piper.Close()
	 357  
	 358  		// Read the .sng file.
	 359  		sf, err := os.Open("testdata/pngsuite/" + fn + ".sng")
	 360  		if err != nil {
	 361  			t.Error(fn, err)
	 362  			continue
	 363  		}
	 364  		defer sf.Close()
	 365  		sb := bufio.NewScanner(sf)
	 366  
	 367  		// Compare the two, in SNG format, line by line.
	 368  		for {
	 369  			pdone := !pb.Scan()
	 370  			sdone := !sb.Scan()
	 371  			if pdone && sdone {
	 372  				break
	 373  			}
	 374  			if pdone || sdone {
	 375  				t.Errorf("%s: Different sizes", fn)
	 376  				break
	 377  			}
	 378  			ps := pb.Text()
	 379  			ss := sb.Text()
	 380  
	 381  			// Newer versions of the sng command line tool append an optional
	 382  			// color name to the RGB tuple. For example:
	 383  			//	# rgb = (0xff,0xff,0xff) grey100
	 384  			//	# rgb = (0x00,0x00,0xff) blue1
	 385  			// instead of the older version's plainer:
	 386  			//	# rgb = (0xff,0xff,0xff)
	 387  			//	# rgb = (0x00,0x00,0xff)
	 388  			// We strip any such name.
	 389  			if strings.Contains(ss, "# rgb = (") && !strings.HasSuffix(ss, ")") {
	 390  				if i := strings.LastIndex(ss, ") "); i >= 0 {
	 391  					ss = ss[:i+1]
	 392  				}
	 393  			}
	 394  
	 395  			if ps != ss {
	 396  				t.Errorf("%s: Mismatch\n%s\nversus\n%s\n", fn, ps, ss)
	 397  				break
	 398  			}
	 399  		}
	 400  		if pb.Err() != nil {
	 401  			t.Error(fn, pb.Err())
	 402  		}
	 403  		if sb.Err() != nil {
	 404  			t.Error(fn, sb.Err())
	 405  		}
	 406  	}
	 407  }
	 408  
	 409  var readerErrors = []struct {
	 410  	file string
	 411  	err	string
	 412  }{
	 413  	{"invalid-zlib.png", "zlib: invalid checksum"},
	 414  	{"invalid-crc32.png", "invalid checksum"},
	 415  	{"invalid-noend.png", "unexpected EOF"},
	 416  	{"invalid-trunc.png", "unexpected EOF"},
	 417  }
	 418  
	 419  func TestReaderError(t *testing.T) {
	 420  	for _, tt := range readerErrors {
	 421  		img, err := readPNG("testdata/" + tt.file)
	 422  		if err == nil {
	 423  			t.Errorf("decoding %s: missing error", tt.file)
	 424  			continue
	 425  		}
	 426  		if !strings.Contains(err.Error(), tt.err) {
	 427  			t.Errorf("decoding %s: %s, want %s", tt.file, err, tt.err)
	 428  		}
	 429  		if img != nil {
	 430  			t.Errorf("decoding %s: have image + error", tt.file)
	 431  		}
	 432  	}
	 433  }
	 434  
	 435  func TestPalettedDecodeConfig(t *testing.T) {
	 436  	for _, fn := range filenamesPaletted {
	 437  		f, err := os.Open("testdata/pngsuite/" + fn + ".png")
	 438  		if err != nil {
	 439  			t.Errorf("%s: open failed: %v", fn, err)
	 440  			continue
	 441  		}
	 442  		defer f.Close()
	 443  		cfg, err := DecodeConfig(f)
	 444  		if err != nil {
	 445  			t.Errorf("%s: %v", fn, err)
	 446  			continue
	 447  		}
	 448  		pal, ok := cfg.ColorModel.(color.Palette)
	 449  		if !ok {
	 450  			t.Errorf("%s: expected paletted color model", fn)
	 451  			continue
	 452  		}
	 453  		if pal == nil {
	 454  			t.Errorf("%s: palette not initialized", fn)
	 455  			continue
	 456  		}
	 457  	}
	 458  }
	 459  
	 460  func TestInterlaced(t *testing.T) {
	 461  	a, err := readPNG("testdata/gray-gradient.png")
	 462  	if err != nil {
	 463  		t.Fatal(err)
	 464  	}
	 465  	b, err := readPNG("testdata/gray-gradient.interlaced.png")
	 466  	if err != nil {
	 467  		t.Fatal(err)
	 468  	}
	 469  	if !reflect.DeepEqual(a, b) {
	 470  		t.Fatalf("decodings differ:\nnon-interlaced:\n%#v\ninterlaced:\n%#v", a, b)
	 471  	}
	 472  }
	 473  
	 474  func TestIncompleteIDATOnRowBoundary(t *testing.T) {
	 475  	// The following is an invalid 1x2 grayscale PNG image. The header is OK,
	 476  	// but the zlib-compressed IDAT payload contains two bytes "\x02\x00",
	 477  	// which is only one row of data (the leading "\x02" is a row filter).
	 478  	const (
	 479  		ihdr = "\x00\x00\x00\x0dIHDR\x00\x00\x00\x01\x00\x00\x00\x02\x08\x00\x00\x00\x00\xbc\xea\xe9\xfb"
	 480  		idat = "\x00\x00\x00\x0eIDAT\x78\x9c\x62\x62\x00\x04\x00\x00\xff\xff\x00\x06\x00\x03\xfa\xd0\x59\xae"
	 481  		iend = "\x00\x00\x00\x00IEND\xae\x42\x60\x82"
	 482  	)
	 483  	_, err := Decode(strings.NewReader(pngHeader + ihdr + idat + iend))
	 484  	if err == nil {
	 485  		t.Fatal("got nil error, want non-nil")
	 486  	}
	 487  }
	 488  
	 489  func TestTrailingIDATChunks(t *testing.T) {
	 490  	// The following is a valid 1x1 PNG image containing color.Gray{255} and
	 491  	// a trailing zero-length IDAT chunk (see PNG specification section 12.9):
	 492  	const (
	 493  		ihdr			= "\x00\x00\x00\x0dIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x00\x00\x00\x00\x3a\x7e\x9b\x55"
	 494  		idatWhite = "\x00\x00\x00\x0eIDAT\x78\x9c\x62\xfa\x0f\x08\x00\x00\xff\xff\x01\x05\x01\x02\x5a\xdd\x39\xcd"
	 495  		idatZero	= "\x00\x00\x00\x00IDAT\x35\xaf\x06\x1e"
	 496  		iend			= "\x00\x00\x00\x00IEND\xae\x42\x60\x82"
	 497  	)
	 498  	_, err := Decode(strings.NewReader(pngHeader + ihdr + idatWhite + idatZero + iend))
	 499  	if err != nil {
	 500  		t.Fatalf("decoding valid image: %v", err)
	 501  	}
	 502  
	 503  	// Non-zero-length trailing IDAT chunks should be ignored (recoverable error).
	 504  	// The following chunk contains a single pixel with color.Gray{0}.
	 505  	const idatBlack = "\x00\x00\x00\x0eIDAT\x78\x9c\x62\x62\x00\x04\x00\x00\xff\xff\x00\x06\x00\x03\xfa\xd0\x59\xae"
	 506  
	 507  	img, err := Decode(strings.NewReader(pngHeader + ihdr + idatWhite + idatBlack + iend))
	 508  	if err != nil {
	 509  		t.Fatalf("trailing IDAT not ignored: %v", err)
	 510  	}
	 511  	if img.At(0, 0) == (color.Gray{0}) {
	 512  		t.Fatal("decoded image from trailing IDAT chunk")
	 513  	}
	 514  }
	 515  
	 516  func TestMultipletRNSChunks(t *testing.T) {
	 517  	/*
	 518  		The following is a valid 1x1 paletted PNG image with a 1-element palette
	 519  		containing color.NRGBA{0xff, 0x00, 0x00, 0x7f}:
	 520  			0000000: 8950 4e47 0d0a 1a0a 0000 000d 4948 4452	.PNG........IHDR
	 521  			0000010: 0000 0001 0000 0001 0803 0000 0028 cb34	.............(.4
	 522  			0000020: bb00 0000 0350 4c54 45ff 0000 19e2 0937	.....PLTE......7
	 523  			0000030: 0000 0001 7452 4e53 7f80 5cb4 cb00 0000	....tRNS..\.....
	 524  			0000040: 0e49 4441 5478 9c62 6200 0400 00ff ff00	.IDATx.bb.......
	 525  			0000050: 0600 03fa d059 ae00 0000 0049 454e 44ae	.....Y.....IEND.
	 526  			0000060: 4260 82																	B`.
	 527  		Dropping the tRNS chunk makes that color's alpha 0xff instead of 0x7f.
	 528  	*/
	 529  	const (
	 530  		ihdr = "\x00\x00\x00\x0dIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x03\x00\x00\x00\x28\xcb\x34\xbb"
	 531  		plte = "\x00\x00\x00\x03PLTE\xff\x00\x00\x19\xe2\x09\x37"
	 532  		trns = "\x00\x00\x00\x01tRNS\x7f\x80\x5c\xb4\xcb"
	 533  		idat = "\x00\x00\x00\x0eIDAT\x78\x9c\x62\x62\x00\x04\x00\x00\xff\xff\x00\x06\x00\x03\xfa\xd0\x59\xae"
	 534  		iend = "\x00\x00\x00\x00IEND\xae\x42\x60\x82"
	 535  	)
	 536  	for i := 0; i < 4; i++ {
	 537  		var b []byte
	 538  		b = append(b, pngHeader...)
	 539  		b = append(b, ihdr...)
	 540  		b = append(b, plte...)
	 541  		for j := 0; j < i; j++ {
	 542  			b = append(b, trns...)
	 543  		}
	 544  		b = append(b, idat...)
	 545  		b = append(b, iend...)
	 546  
	 547  		var want color.Color
	 548  		m, err := Decode(bytes.NewReader(b))
	 549  		switch i {
	 550  		case 0:
	 551  			if err != nil {
	 552  				t.Errorf("%d tRNS chunks: %v", i, err)
	 553  				continue
	 554  			}
	 555  			want = color.RGBA{0xff, 0x00, 0x00, 0xff}
	 556  		case 1:
	 557  			if err != nil {
	 558  				t.Errorf("%d tRNS chunks: %v", i, err)
	 559  				continue
	 560  			}
	 561  			want = color.NRGBA{0xff, 0x00, 0x00, 0x7f}
	 562  		default:
	 563  			if err == nil {
	 564  				t.Errorf("%d tRNS chunks: got nil error, want non-nil", i)
	 565  			}
	 566  			continue
	 567  		}
	 568  		if got := m.At(0, 0); got != want {
	 569  			t.Errorf("%d tRNS chunks: got %T %v, want %T %v", i, got, got, want, want)
	 570  		}
	 571  	}
	 572  }
	 573  
	 574  func TestUnknownChunkLengthUnderflow(t *testing.T) {
	 575  	data := []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0xff, 0xff,
	 576  		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x06, 0xf4, 0x7c, 0x55, 0x04, 0x1a,
	 577  		0xd3, 0x11, 0x9a, 0x73, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e, 0x00, 0x00,
	 578  		0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf4, 0x7c, 0x55, 0x04, 0x1a,
	 579  		0xd3}
	 580  	_, err := Decode(bytes.NewReader(data))
	 581  	if err == nil {
	 582  		t.Errorf("Didn't fail reading an unknown chunk with length 0xffffffff")
	 583  	}
	 584  }
	 585  
	 586  func TestPaletted8OutOfRangePixel(t *testing.T) {
	 587  	// IDAT contains a reference to a palette index that does not exist in the file.
	 588  	img, err := readPNG("testdata/invalid-palette.png")
	 589  	if err != nil {
	 590  		t.Errorf("decoding invalid-palette.png: unexpected error %v", err)
	 591  		return
	 592  	}
	 593  
	 594  	// Expect that the palette is extended with opaque black.
	 595  	want := color.RGBA{0x00, 0x00, 0x00, 0xff}
	 596  	if got := img.At(15, 15); got != want {
	 597  		t.Errorf("got %F %v, expected %T %v", got, got, want, want)
	 598  	}
	 599  }
	 600  
	 601  func TestGray8Transparent(t *testing.T) {
	 602  	// These bytes come from https://golang.org/issues/19553
	 603  	m, err := Decode(bytes.NewReader([]byte{
	 604  		0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
	 605  		0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x0b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x85, 0x2c, 0x88,
	 606  		0x80, 0x00, 0x00, 0x00, 0x02, 0x74, 0x52, 0x4e, 0x53, 0x00, 0xff, 0x5b, 0x91, 0x22, 0xb5, 0x00,
	 607  		0x00, 0x00, 0x02, 0x62, 0x4b, 0x47, 0x44, 0x00, 0xff, 0x87, 0x8f, 0xcc, 0xbf, 0x00, 0x00, 0x00,
	 608  		0x09, 0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x0a, 0xf0, 0x00, 0x00, 0x0a, 0xf0, 0x01, 0x42, 0xac,
	 609  		0x34, 0x98, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xd5, 0x04, 0x02, 0x12, 0x11,
	 610  		0x11, 0xf7, 0x65, 0x3d, 0x8b, 0x00, 0x00, 0x00, 0x4f, 0x49, 0x44, 0x41, 0x54, 0x08, 0xd7, 0x63,
	 611  		0xf8, 0xff, 0xff, 0xff, 0xb9, 0xbd, 0x70, 0xf0, 0x8c, 0x01, 0xc8, 0xaf, 0x6e, 0x99, 0x02, 0x05,
	 612  		0xd9, 0x7b, 0xc1, 0xfc, 0x6b, 0xff, 0xa1, 0xa0, 0x87, 0x30, 0xff, 0xd9, 0xde, 0xbd, 0xd5, 0x4b,
	 613  		0xf7, 0xee, 0xfd, 0x0e, 0xe3, 0xef, 0xcd, 0x06, 0x19, 0x14, 0xf5, 0x1e, 0xce, 0xef, 0x01, 0x31,
	 614  		0x92, 0xd7, 0x82, 0x41, 0x31, 0x9c, 0x3f, 0x07, 0x02, 0xee, 0xa1, 0xaa, 0xff, 0xff, 0x9f, 0xe1,
	 615  		0xd9, 0x56, 0x30, 0xf8, 0x0e, 0xe5, 0x03, 0x00, 0xa9, 0x42, 0x84, 0x3d, 0xdf, 0x8f, 0xa6, 0x8f,
	 616  		0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
	 617  	}))
	 618  	if err != nil {
	 619  		t.Fatalf("Decode: %v", err)
	 620  	}
	 621  
	 622  	const hex = "0123456789abcdef"
	 623  	var got []byte
	 624  	bounds := m.Bounds()
	 625  	for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
	 626  		for x := bounds.Min.X; x < bounds.Max.X; x++ {
	 627  			if r, _, _, a := m.At(x, y).RGBA(); a != 0 {
	 628  				got = append(got,
	 629  					hex[0x0f&(r>>12)],
	 630  					hex[0x0f&(r>>8)],
	 631  					' ',
	 632  				)
	 633  			} else {
	 634  				got = append(got,
	 635  					'.',
	 636  					'.',
	 637  					' ',
	 638  				)
	 639  			}
	 640  		}
	 641  		got = append(got, '\n')
	 642  	}
	 643  
	 644  	const want = "" +
	 645  		".. .. .. ce bd bd bd bd bd bd bd bd bd bd e6 \n" +
	 646  		".. .. .. 7b 84 94 94 94 94 94 94 94 94 6b bd \n" +
	 647  		".. .. .. 7b d6 .. .. .. .. .. .. .. .. 8c bd \n" +
	 648  		".. .. .. 7b d6 .. .. .. .. .. .. .. .. 8c bd \n" +
	 649  		".. .. .. 7b d6 .. .. .. .. .. .. .. .. 8c bd \n" +
	 650  		"e6 bd bd 7b a5 bd bd f7 .. .. .. .. .. 8c bd \n" +
	 651  		"bd 6b 94 94 94 94 5a ef .. .. .. .. .. 8c bd \n" +
	 652  		"bd 8c .. .. .. .. 63 ad ad ad ad ad ad 73 bd \n" +
	 653  		"bd 8c .. .. .. .. 63 9c 9c 9c 9c 9c 9c 9c de \n" +
	 654  		"bd 6b 94 94 94 94 5a ef .. .. .. .. .. .. .. \n" +
	 655  		"e6 b5 b5 b5 b5 b5 b5 f7 .. .. .. .. .. .. .. \n"
	 656  
	 657  	if string(got) != want {
	 658  		t.Errorf("got:\n%swant:\n%s", got, want)
	 659  	}
	 660  }
	 661  
	 662  func TestDimensionOverflow(t *testing.T) {
	 663  	maxInt32AsInt := int((1 << 31) - 1)
	 664  	have32BitInts := 0 > (1 + maxInt32AsInt)
	 665  
	 666  	testCases := []struct {
	 667  		src							 []byte
	 668  		unsupportedConfig bool
	 669  		width						 int
	 670  		height						int
	 671  	}{
	 672  		// These bytes come from https://golang.org/issues/22304
	 673  		//
	 674  		// It encodes a 2147483646 × 2147483646 (i.e. 0x7ffffffe × 0x7ffffffe)
	 675  		// NRGBA image. The (width × height) per se doesn't overflow an int64, but
	 676  		// (width × height × bytesPerPixel) will.
	 677  		{
	 678  			src: []byte{
	 679  				0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
	 680  				0x7f, 0xff, 0xff, 0xfe, 0x7f, 0xff, 0xff, 0xfe, 0x08, 0x06, 0x00, 0x00, 0x00, 0x30, 0x57, 0xb3,
	 681  				0xfd, 0x00, 0x00, 0x00, 0x15, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x62, 0x20, 0x12, 0x8c,
	 682  				0x2a, 0xa4, 0xb3, 0x42, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x13, 0x38, 0x00, 0x15, 0x2d, 0xef,
	 683  				0x5f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
	 684  			},
	 685  			// It's debatable whether DecodeConfig (which does not allocate a
	 686  			// pixel buffer, unlike Decode) should fail in this case. The Go
	 687  			// standard library has made its choice, and the standard library
	 688  			// has compatibility constraints.
	 689  			unsupportedConfig: true,
	 690  			width:						 0x7ffffffe,
	 691  			height:						0x7ffffffe,
	 692  		},
	 693  
	 694  		// The next three cases come from https://golang.org/issues/38435
	 695  
	 696  		{
	 697  			src: []byte{
	 698  				0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
	 699  				0x00, 0x00, 0xb5, 0x04, 0x00, 0x00, 0xb5, 0x04, 0x08, 0x06, 0x00, 0x00, 0x00, 0xf5, 0x60, 0x2c,
	 700  				0xb8, 0x00, 0x00, 0x00, 0x15, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x62, 0x20, 0x12, 0x8c,
	 701  				0x2a, 0xa4, 0xb3, 0x42, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x13, 0x38, 0x00, 0x15, 0x2d, 0xef,
	 702  				0x5f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
	 703  			},
	 704  			// Here, width * height = 0x7ffea810, just under MaxInt32, but at 4
	 705  			// bytes per pixel, the number of pixels overflows an int32.
	 706  			unsupportedConfig: have32BitInts,
	 707  			width:						 0x0000b504,
	 708  			height:						0x0000b504,
	 709  		},
	 710  
	 711  		{
	 712  			src: []byte{
	 713  				0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
	 714  				0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x30, 0x6e, 0xc5,
	 715  				0x21, 0x00, 0x00, 0x00, 0x15, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x62, 0x20, 0x12, 0x8c,
	 716  				0x2a, 0xa4, 0xb3, 0x42, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x13, 0x38, 0x00, 0x15, 0x2d, 0xef,
	 717  				0x5f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82,
	 718  			},
	 719  			unsupportedConfig: false,
	 720  			width:						 0x04000000,
	 721  			height:						0x00000001,
	 722  		},
	 723  
	 724  		{
	 725  			src: []byte{
	 726  				0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
	 727  				0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0xaa, 0xd4, 0x7c,
	 728  				0xda, 0x00, 0x00, 0x00, 0x15, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x66, 0x20, 0x12, 0x30,
	 729  				0x8d, 0x2a, 0xa4, 0xaf, 0x42, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x14, 0xd2, 0x00, 0x16, 0x00,
	 730  				0x00, 0x00,
	 731  			},
	 732  			unsupportedConfig: false,
	 733  			width:						 0x08000000,
	 734  			height:						0x00000001,
	 735  		},
	 736  	}
	 737  
	 738  	for i, tc := range testCases {
	 739  		cfg, err := DecodeConfig(bytes.NewReader(tc.src))
	 740  		if tc.unsupportedConfig {
	 741  			if err == nil {
	 742  				t.Errorf("i=%d: DecodeConfig: got nil error, want non-nil", i)
	 743  			} else if _, ok := err.(UnsupportedError); !ok {
	 744  				t.Fatalf("Decode: got %v (of type %T), want non-nil error (of type png.UnsupportedError)", err, err)
	 745  			}
	 746  			continue
	 747  		} else if err != nil {
	 748  			t.Errorf("i=%d: DecodeConfig: %v", i, err)
	 749  			continue
	 750  		} else if cfg.Width != tc.width {
	 751  			t.Errorf("i=%d: width: got %d, want %d", i, cfg.Width, tc.width)
	 752  			continue
	 753  		} else if cfg.Height != tc.height {
	 754  			t.Errorf("i=%d: height: got %d, want %d", i, cfg.Height, tc.height)
	 755  			continue
	 756  		}
	 757  
	 758  		if nPixels := int64(cfg.Width) * int64(cfg.Height); nPixels > 0x7f000000 {
	 759  			// In theory, calling Decode would succeed, given several gigabytes
	 760  			// of memory. In practice, trying to make a []uint8 big enough to
	 761  			// hold all of the pixels can often result in OOM (out of memory).
	 762  			// OOM is unrecoverable; we can't write a test that passes when OOM
	 763  			// happens. Instead we skip the Decode call (and its tests).
	 764  			continue
	 765  		} else if testing.Short() {
	 766  			// Even for smaller image dimensions, calling Decode might allocate
	 767  			// 1 GiB or more of memory. This is usually feasible, and we want
	 768  			// to check that calling Decode doesn't panic if there's enough
	 769  			// memory, but we provide a runtime switch (testing.Short) to skip
	 770  			// these if it would OOM. See also http://golang.org/issue/5050
	 771  			// "decoding... images can cause huge memory allocations".
	 772  			continue
	 773  		}
	 774  
	 775  		// Even if we don't panic, these aren't valid PNG images.
	 776  		if _, err := Decode(bytes.NewReader(tc.src)); err == nil {
	 777  			t.Errorf("i=%d: Decode: got nil error, want non-nil", i)
	 778  		}
	 779  	}
	 780  
	 781  	if testing.Short() {
	 782  		t.Skip("skipping tests which allocate large pixel buffers")
	 783  	}
	 784  }
	 785  
	 786  func benchmarkDecode(b *testing.B, filename string, bytesPerPixel int) {
	 787  	data, err := os.ReadFile(filename)
	 788  	if err != nil {
	 789  		b.Fatal(err)
	 790  	}
	 791  	cfg, err := DecodeConfig(bytes.NewReader(data))
	 792  	if err != nil {
	 793  		b.Fatal(err)
	 794  	}
	 795  	b.SetBytes(int64(cfg.Width * cfg.Height * bytesPerPixel))
	 796  	b.ReportAllocs()
	 797  	b.ResetTimer()
	 798  	for i := 0; i < b.N; i++ {
	 799  		Decode(bytes.NewReader(data))
	 800  	}
	 801  }
	 802  
	 803  func BenchmarkDecodeGray(b *testing.B) {
	 804  	benchmarkDecode(b, "testdata/benchGray.png", 1)
	 805  }
	 806  
	 807  func BenchmarkDecodeNRGBAGradient(b *testing.B) {
	 808  	benchmarkDecode(b, "testdata/benchNRGBA-gradient.png", 4)
	 809  }
	 810  
	 811  func BenchmarkDecodeNRGBAOpaque(b *testing.B) {
	 812  	benchmarkDecode(b, "testdata/benchNRGBA-opaque.png", 4)
	 813  }
	 814  
	 815  func BenchmarkDecodePaletted(b *testing.B) {
	 816  	benchmarkDecode(b, "testdata/benchPaletted.png", 1)
	 817  }
	 818  
	 819  func BenchmarkDecodeRGB(b *testing.B) {
	 820  	benchmarkDecode(b, "testdata/benchRGB.png", 4)
	 821  }
	 822  
	 823  func BenchmarkDecodeInterlacing(b *testing.B) {
	 824  	benchmarkDecode(b, "testdata/benchRGB-interlace.png", 4)
	 825  }
	 826  

View as plain text