| // Copyright 2011 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 tiff |
| |
| import ( |
| "bytes" |
| "compress/zlib" |
| "encoding/binary" |
| "encoding/hex" |
| "errors" |
| "fmt" |
| "image" |
| "io" |
| "io/ioutil" |
| "os" |
| "sort" |
| "strings" |
| "testing" |
| |
| _ "image/png" |
| ) |
| |
| const testdataDir = "../testdata/" |
| |
| // Read makes *buffer implements io.Reader, so that we can pass one to Decode. |
| func (*buffer) Read([]byte) (int, error) { |
| panic("unimplemented") |
| } |
| |
| func load(name string) (image.Image, error) { |
| f, err := os.Open(testdataDir + name) |
| if err != nil { |
| return nil, err |
| } |
| defer f.Close() |
| img, _, err := image.Decode(f) |
| if err != nil { |
| return nil, err |
| } |
| return img, nil |
| } |
| |
| // TestNoRPS tests decoding an image that has no RowsPerStrip tag. The tag is |
| // mandatory according to the spec but some software omits it in the case of a |
| // single strip. |
| func TestNoRPS(t *testing.T) { |
| _, err := load("no_rps.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // TestNoCompression tests decoding an image that has no Compression tag. This |
| // tag is mandatory, but most tools interpret a missing value as no |
| // compression. |
| func TestNoCompression(t *testing.T) { |
| _, err := load("no_compress.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| } |
| |
| // TestUnpackBits tests the decoding of PackBits-encoded data. |
| func TestUnpackBits(t *testing.T) { |
| var unpackBitsTests = []struct { |
| compressed string |
| uncompressed string |
| }{{ |
| // Example data from Wikipedia. |
| "\xfe\xaa\x02\x80\x00\x2a\xfd\xaa\x03\x80\x00\x2a\x22\xf7\xaa", |
| "\xaa\xaa\xaa\x80\x00\x2a\xaa\xaa\xaa\xaa\x80\x00\x2a\x22\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa", |
| }} |
| for _, u := range unpackBitsTests { |
| buf, err := unpackBits(strings.NewReader(u.compressed)) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if string(buf) != u.uncompressed { |
| t.Fatalf("unpackBits: want %x, got %x", u.uncompressed, buf) |
| } |
| } |
| } |
| |
| func TestShortBlockData(t *testing.T) { |
| b, err := ioutil.ReadFile("../testdata/bw-uncompressed.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| // The bw-uncompressed.tiff image is a 153x55 bi-level image. This is 1 bit |
| // per pixel, or 20 bytes per row, times 55 rows, or 1100 bytes of pixel |
| // data. 1100 in hex is 0x44c, or "\x4c\x04" in little-endian. We replace |
| // that byte count (StripByteCounts-tagged data) by something less than |
| // that, so that there is not enough pixel data. |
| old := []byte{0x4c, 0x04} |
| new := []byte{0x01, 0x01} |
| i := bytes.Index(b, old) |
| if i < 0 { |
| t.Fatal(`could not find "\x4c\x04" byte count`) |
| } |
| if bytes.Contains(b[i+len(old):], old) { |
| t.Fatal(`too many occurrences of "\x4c\x04"`) |
| } |
| b[i+0] = new[0] |
| b[i+1] = new[1] |
| if _, err = Decode(bytes.NewReader(b)); err == nil { |
| t.Fatal("got nil error, want non-nil") |
| } |
| } |
| |
| func TestDecodeInvalidDataType(t *testing.T) { |
| b, err := ioutil.ReadFile("../testdata/bw-uncompressed.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // off is the offset of the ImageWidth tag. It is the offset of the overall |
| // IFD block (0x00000454), plus 2 for the uint16 number of IFD entries, plus 12 |
| // to skip the first entry. |
| const off = 0x00000454 + 2 + 12*1 |
| |
| if v := binary.LittleEndian.Uint16(b[off : off+2]); v != tImageWidth { |
| t.Fatal(`could not find ImageWidth tag`) |
| } |
| binary.LittleEndian.PutUint16(b[off+2:], uint16(len(lengths))) // invalid datatype |
| |
| if _, err = Decode(bytes.NewReader(b)); err == nil { |
| t.Fatal("got nil error, want non-nil") |
| } |
| } |
| |
| func compare(t *testing.T, img0, img1 image.Image) { |
| t.Helper() |
| b0 := img0.Bounds() |
| b1 := img1.Bounds() |
| if b0.Dx() != b1.Dx() || b0.Dy() != b1.Dy() { |
| t.Fatalf("wrong image size: want %s, got %s", b0, b1) |
| } |
| x1 := b1.Min.X - b0.Min.X |
| y1 := b1.Min.Y - b0.Min.Y |
| for y := b0.Min.Y; y < b0.Max.Y; y++ { |
| for x := b0.Min.X; x < b0.Max.X; x++ { |
| c0 := img0.At(x, y) |
| c1 := img1.At(x+x1, y+y1) |
| r0, g0, b0, a0 := c0.RGBA() |
| r1, g1, b1, a1 := c1.RGBA() |
| if r0 != r1 || g0 != g1 || b0 != b1 || a0 != a1 { |
| t.Fatalf("pixel at (%d, %d) has wrong color: want %v, got %v", x, y, c0, c1) |
| } |
| } |
| } |
| } |
| |
| // TestDecode tests that decoding a PNG image and a TIFF image result in the |
| // same pixel data. |
| func TestDecode(t *testing.T) { |
| img0, err := load("video-001.png") |
| if err != nil { |
| t.Fatal(err) |
| } |
| img1, err := load("video-001.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| img2, err := load("video-001-strip-64.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| img3, err := load("video-001-tile-64x64.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| img4, err := load("video-001-16bit.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| compare(t, img0, img1) |
| compare(t, img0, img2) |
| compare(t, img0, img3) |
| compare(t, img0, img4) |
| } |
| |
| // TestDecodeLZW tests that decoding a PNG image and a LZW-compressed TIFF |
| // image result in the same pixel data. |
| func TestDecodeLZW(t *testing.T) { |
| img0, err := load("blue-purple-pink.png") |
| if err != nil { |
| t.Fatal(err) |
| } |
| img1, err := load("blue-purple-pink.lzwcompressed.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| compare(t, img0, img1) |
| } |
| |
| // TestEOF tests that decoding a TIFF image returns io.ErrUnexpectedEOF |
| // when there are no headers or data is empty |
| func TestEOF(t *testing.T) { |
| _, err := Decode(bytes.NewReader(nil)) |
| if err != io.ErrUnexpectedEOF { |
| t.Errorf("Error should be io.ErrUnexpectedEOF on nil but got %v", err) |
| } |
| } |
| |
| // TestDecodeCCITT tests that decoding a PNG image and a CCITT compressed TIFF |
| // image result in the same pixel data. |
| func TestDecodeCCITT(t *testing.T) { |
| // TODO Add more tests. |
| for _, fn := range []string{ |
| "bw-gopher", |
| } { |
| img0, err := load(fn + ".png") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| img1, err := load(fn + "_ccittGroup3.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| compare(t, img0, img1) |
| |
| img2, err := load(fn + "_ccittGroup4.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| compare(t, img0, img2) |
| } |
| } |
| |
| // TestDecodeTagOrder tests that a malformed image with unsorted IFD entries is |
| // correctly rejected. |
| func TestDecodeTagOrder(t *testing.T) { |
| data, err := ioutil.ReadFile("../testdata/video-001.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Swap the first two IFD entries. |
| ifdOffset := int64(binary.LittleEndian.Uint32(data[4:8])) |
| for i := ifdOffset + 2; i < ifdOffset+14; i++ { |
| data[i], data[i+12] = data[i+12], data[i] |
| } |
| if _, _, err := image.Decode(bytes.NewReader(data)); err == nil { |
| t.Fatal("got nil error, want non-nil") |
| } |
| } |
| |
| // TestDecompress tests that decoding some TIFF images that use different |
| // compression formats result in the same pixel data. |
| func TestDecompress(t *testing.T) { |
| var decompressTests = []string{ |
| "bw-uncompressed.tiff", |
| "bw-deflate.tiff", |
| "bw-packbits.tiff", |
| } |
| var img0 image.Image |
| for _, name := range decompressTests { |
| img1, err := load(name) |
| if err != nil { |
| t.Fatalf("decoding %s: %v", name, err) |
| } |
| if img0 == nil { |
| img0 = img1 |
| continue |
| } |
| compare(t, img0, img1) |
| } |
| } |
| |
| func replace(src []byte, find, repl string) ([]byte, error) { |
| removeSpaces := func(r rune) rune { |
| if r != ' ' { |
| return r |
| } |
| return -1 |
| } |
| |
| f, err := hex.DecodeString(strings.Map(removeSpaces, find)) |
| if err != nil { |
| return nil, err |
| } |
| r, err := hex.DecodeString(strings.Map(removeSpaces, repl)) |
| if err != nil { |
| return nil, err |
| } |
| dst := bytes.Replace(src, f, r, 1) |
| if bytes.Equal(dst, src) { |
| return nil, errors.New("replacement failed") |
| } |
| return dst, nil |
| } |
| |
| // TestZeroBitsPerSample tests that an IFD with a bitsPerSample of 0 does not |
| // cause a crash. |
| // Issue 10711. |
| func TestZeroBitsPerSample(t *testing.T) { |
| b0, err := ioutil.ReadFile(testdataDir + "bw-deflate.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Mutate the loaded image to have the problem. |
| // 02 01: tag number (tBitsPerSample) |
| // 03 00: data type (short, or uint16) |
| // 01 00 00 00: count |
| // ?? 00 00 00: value (1 -> 0) |
| b1, err := replace(b0, |
| "02 01 03 00 01 00 00 00 01 00 00 00", |
| "02 01 03 00 01 00 00 00 00 00 00 00", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| _, err = Decode(bytes.NewReader(b1)) |
| if err == nil { |
| t.Fatal("Decode with 0 bits per sample: got nil error, want non-nil") |
| } |
| } |
| |
| // TestTileTooBig tests that we do not panic when a tile is too big compared to |
| // the data available. |
| // Issue 10712 |
| func TestTileTooBig(t *testing.T) { |
| b0, err := ioutil.ReadFile(testdataDir + "video-001-tile-64x64.tiff") |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Mutate the loaded image to have the problem. |
| // |
| // 42 01: tag number (tTileWidth) |
| // 03 00: data type (short, or uint16) |
| // 01 00 00 00: count |
| // xx 00 00 00: value (0x40 -> 0x44: a wider tile consumes more data |
| // than is available) |
| b1, err := replace(b0, |
| "42 01 03 00 01 00 00 00 40 00 00 00", |
| "42 01 03 00 01 00 00 00 44 00 00 00", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| // Turn off the predictor, which makes it possible to hit the |
| // place with the defect. Without this patch to the image, we run |
| // out of data too early, and do not hit the part of the code where |
| // the original panic was. |
| // |
| // 3d 01: tag number (tPredictor) |
| // 03 00: data type (short, or uint16) |
| // 01 00 00 00: count |
| // xx 00 00 00: value (2 -> 1: 2 = horizontal, 1 = none) |
| b2, err := replace(b1, |
| "3d 01 03 00 01 00 00 00 02 00 00 00", |
| "3d 01 03 00 01 00 00 00 01 00 00 00", |
| ) |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| _, err = Decode(bytes.NewReader(b2)) |
| if err == nil { |
| t.Fatal("did not expect nil error") |
| } |
| } |
| |
| // TestZeroSizedImages tests that decoding does not panic when image dimensions |
| // are zero, and returns a zero-sized image instead. |
| // Issue 10393. |
| func TestZeroSizedImages(t *testing.T) { |
| testsizes := []struct { |
| w, h int |
| }{ |
| {0, 0}, |
| {1, 0}, |
| {0, 1}, |
| {1, 1}, |
| } |
| for _, r := range testsizes { |
| img := image.NewRGBA(image.Rect(0, 0, r.w, r.h)) |
| var buf bytes.Buffer |
| if err := Encode(&buf, img, nil); err != nil { |
| t.Errorf("encode w=%d h=%d: %v", r.w, r.h, err) |
| continue |
| } |
| if _, err := Decode(&buf); err != nil { |
| t.Errorf("decode w=%d h=%d: %v", r.w, r.h, err) |
| } |
| } |
| } |
| |
| // TestLargeIFDEntry tests that a large IFD entry does not cause Decode to |
| // panic. |
| // Issue 10596. |
| func TestLargeIFDEntry(t *testing.T) { |
| testdata := "II*\x00\x08\x00\x00\x00\f\x000000000000" + |
| "00000000000000000000" + |
| "00000000000000000000" + |
| "00000000000000000000" + |
| "00000000000000\x17\x01\x04\x00\x01\x00" + |
| "\x00\xc0000000000000000000" + |
| "00000000000000000000" + |
| "00000000000000000000" + |
| "000000" |
| _, err := Decode(strings.NewReader(testdata)) |
| if err == nil { |
| t.Fatal("Decode with large IFD entry: got nil error, want non-nil") |
| } |
| } |
| |
| // benchmarkDecode benchmarks the decoding of an image. |
| func benchmarkDecode(b *testing.B, filename string) { |
| b.Helper() |
| contents, err := ioutil.ReadFile(testdataDir + filename) |
| if err != nil { |
| b.Fatal(err) |
| } |
| benchmarkDecodeData(b, contents) |
| } |
| |
| func benchmarkDecodeData(b *testing.B, data []byte) { |
| b.Helper() |
| r := &buffer{buf: data} |
| b.ResetTimer() |
| for i := 0; i < b.N; i++ { |
| _, err := Decode(r) |
| if err != nil { |
| b.Fatal("Decode:", err) |
| } |
| } |
| } |
| |
| func BenchmarkDecodeCompressed(b *testing.B) { benchmarkDecode(b, "video-001.tiff") } |
| func BenchmarkDecodeUncompressed(b *testing.B) { benchmarkDecode(b, "video-001-uncompressed.tiff") } |
| |
| func BenchmarkZeroHeightTile(b *testing.B) { |
| enc := binary.BigEndian |
| data := newTIFF(enc) |
| data = appendIFD(data, enc, map[uint16]interface{}{ |
| tImageWidth: uint32(4294967295), |
| tImageLength: uint32(0), |
| tTileWidth: uint32(1), |
| tTileLength: uint32(0), |
| }) |
| benchmarkDecodeData(b, data) |
| } |
| |
| func BenchmarkRepeatedOversizedTileData(b *testing.B) { |
| const ( |
| imageWidth = 256 |
| imageHeight = 256 |
| tileWidth = 8 |
| tileLength = 8 |
| numTiles = (imageWidth * imageHeight) / (tileWidth * tileLength) |
| ) |
| |
| // Create a chunk of tile data that decompresses to a large size. |
| zdata := func() []byte { |
| var zbuf bytes.Buffer |
| zw := zlib.NewWriter(&zbuf) |
| zeros := make([]byte, 1024) |
| for i := 0; i < 1<<16; i++ { |
| zw.Write(zeros) |
| } |
| zw.Close() |
| return zbuf.Bytes() |
| }() |
| |
| enc := binary.BigEndian |
| data := newTIFF(enc) |
| |
| zoff := len(data) |
| data = append(data, zdata...) |
| |
| // Each tile refers to the same compressed data chunk. |
| var tileoffs []uint32 |
| var tilesizes []uint32 |
| for i := 0; i < numTiles; i++ { |
| tileoffs = append(tileoffs, uint32(zoff)) |
| tilesizes = append(tilesizes, uint32(len(zdata))) |
| } |
| |
| data = appendIFD(data, enc, map[uint16]interface{}{ |
| tImageWidth: uint32(imageWidth), |
| tImageLength: uint32(imageHeight), |
| tTileWidth: uint32(tileWidth), |
| tTileLength: uint32(tileLength), |
| tTileOffsets: tileoffs, |
| tTileByteCounts: tilesizes, |
| tCompression: uint16(cDeflate), |
| tBitsPerSample: []uint16{16, 16, 16}, |
| tPhotometricInterpretation: uint16(pRGB), |
| }) |
| benchmarkDecodeData(b, data) |
| } |
| |
| type byteOrder interface { |
| binary.ByteOrder |
| binary.AppendByteOrder |
| } |
| |
| // newTIFF returns the TIFF header. |
| func newTIFF(enc byteOrder) []byte { |
| b := []byte{0, 0, 0, 42, 0, 0, 0, 0} |
| switch enc.Uint16([]byte{1, 0}) { |
| case 0x1: |
| b[0], b[1] = 'I', 'I' |
| case 0x100: |
| b[0], b[1] = 'M', 'M' |
| default: |
| panic("odd byte order") |
| } |
| return b |
| } |
| |
| // appendIFD appends an IFD to the TIFF in b, |
| // updating the IFD location in the header. |
| func appendIFD(b []byte, enc byteOrder, entries map[uint16]interface{}) []byte { |
| var tags []uint16 |
| for tag := range entries { |
| tags = append(tags, tag) |
| } |
| sort.Slice(tags, func(i, j int) bool { |
| return tags[i] < tags[j] |
| }) |
| |
| var ifd []byte |
| for _, tag := range tags { |
| ifd = enc.AppendUint16(ifd, tag) |
| switch v := entries[tag].(type) { |
| case uint16: |
| ifd = enc.AppendUint16(ifd, dtShort) |
| ifd = enc.AppendUint32(ifd, 1) |
| ifd = enc.AppendUint16(ifd, v) |
| ifd = enc.AppendUint16(ifd, v) |
| case uint32: |
| ifd = enc.AppendUint16(ifd, dtLong) |
| ifd = enc.AppendUint32(ifd, 1) |
| ifd = enc.AppendUint32(ifd, v) |
| case []uint16: |
| ifd = enc.AppendUint16(ifd, dtShort) |
| ifd = enc.AppendUint32(ifd, uint32(len(v))) |
| switch len(v) { |
| case 0: |
| ifd = enc.AppendUint32(ifd, 0) |
| case 1: |
| ifd = enc.AppendUint16(ifd, v[0]) |
| ifd = enc.AppendUint16(ifd, v[1]) |
| default: |
| ifd = enc.AppendUint32(ifd, uint32(len(b))) |
| for _, e := range v { |
| b = enc.AppendUint16(b, e) |
| } |
| } |
| case []uint32: |
| ifd = enc.AppendUint16(ifd, dtLong) |
| ifd = enc.AppendUint32(ifd, uint32(len(v))) |
| switch len(v) { |
| case 0: |
| ifd = enc.AppendUint32(ifd, 0) |
| case 1: |
| ifd = enc.AppendUint32(ifd, v[0]) |
| default: |
| ifd = enc.AppendUint32(ifd, uint32(len(b))) |
| for _, e := range v { |
| b = enc.AppendUint32(b, e) |
| } |
| } |
| default: |
| panic(fmt.Errorf("unhandled type %T", v)) |
| } |
| } |
| |
| enc.PutUint32(b[4:8], uint32(len(b))) |
| b = enc.AppendUint16(b, uint16(len(entries))) |
| b = append(b, ifd...) |
| b = enc.AppendUint32(b, 0) |
| return b |
| } |