...
Run Format

Source file src/image/gif/reader_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  	"compress/lzw"
    10  	"image"
    11  	"image/color"
    12  	"image/color/palette"
    13  	"io"
    14  	"io/ioutil"
    15  	"reflect"
    16  	"runtime"
    17  	"runtime/debug"
    18  	"strings"
    19  	"testing"
    20  )
    21  
    22  // header, palette and trailer are parts of a valid 2x1 GIF image.
    23  const (
    24  	headerStr = "GIF89a" +
    25  		"\x02\x00\x01\x00" + // width=2, height=1
    26  		"\x80\x00\x00" // headerFields=(a color table of 2 pixels), backgroundIndex, aspect
    27  	paletteStr = "\x10\x20\x30\x40\x50\x60" // the color table, also known as a palette
    28  	trailerStr = "\x3b"
    29  )
    30  
    31  // lzw.NewReader wants a io.ByteReader, this ensures we're compatible.
    32  var _ io.ByteReader = (*blockReader)(nil)
    33  
    34  // lzwEncode returns an LZW encoding (with 2-bit literals) of in.
    35  func lzwEncode(in []byte) []byte {
    36  	b := &bytes.Buffer{}
    37  	w := lzw.NewWriter(b, lzw.LSB, 2)
    38  	if _, err := w.Write(in); err != nil {
    39  		panic(err)
    40  	}
    41  	if err := w.Close(); err != nil {
    42  		panic(err)
    43  	}
    44  	return b.Bytes()
    45  }
    46  
    47  func TestDecode(t *testing.T) {
    48  	// extra contains superfluous bytes to inject into the GIF, either at the end
    49  	// of an existing data sub-block (past the LZW End of Information code) or in
    50  	// a separate data sub-block. The 0x02 values are arbitrary.
    51  	const extra = "\x02\x02\x02\x02"
    52  
    53  	testCases := []struct {
    54  		nPix int // The number of pixels in the image data.
    55  		// If non-zero, write this many extra bytes inside the data sub-block
    56  		// containing the LZW end code.
    57  		extraExisting int
    58  		// If non-zero, write an extra block of this many bytes.
    59  		extraSeparate int
    60  		wantErr       error
    61  	}{
    62  		{0, 0, 0, errNotEnough},
    63  		{1, 0, 0, errNotEnough},
    64  		{2, 0, 0, nil},
    65  		// An extra data sub-block after the compressed section with 1 byte which we
    66  		// silently skip.
    67  		{2, 0, 1, nil},
    68  		// An extra data sub-block after the compressed section with 2 bytes. In
    69  		// this case we complain that there is too much data.
    70  		{2, 0, 2, errTooMuch},
    71  		// Too much pixel data.
    72  		{3, 0, 0, errTooMuch},
    73  		// An extra byte after LZW data, but inside the same data sub-block.
    74  		{2, 1, 0, nil},
    75  		// Two extra bytes after LZW data, but inside the same data sub-block.
    76  		{2, 2, 0, nil},
    77  		// Extra data exists in the final sub-block with LZW data, AND there is
    78  		// a bogus sub-block following.
    79  		{2, 1, 1, errTooMuch},
    80  	}
    81  	for _, tc := range testCases {
    82  		b := &bytes.Buffer{}
    83  		b.WriteString(headerStr)
    84  		b.WriteString(paletteStr)
    85  		// Write an image with bounds 2x1 but tc.nPix pixels. If tc.nPix != 2
    86  		// then this should result in an invalid GIF image. First, write a
    87  		// magic 0x2c (image descriptor) byte, bounds=(0,0)-(2,1), a flags
    88  		// byte, and 2-bit LZW literals.
    89  		b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
    90  		if tc.nPix > 0 {
    91  			enc := lzwEncode(make([]byte, tc.nPix))
    92  			if len(enc)+tc.extraExisting > 0xff {
    93  				t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d: compressed length %d is too large",
    94  					tc.nPix, tc.extraExisting, tc.extraSeparate, len(enc))
    95  				continue
    96  			}
    97  
    98  			// Write the size of the data sub-block containing the LZW data.
    99  			b.WriteByte(byte(len(enc) + tc.extraExisting))
   100  
   101  			// Write the LZW data.
   102  			b.Write(enc)
   103  
   104  			// Write extra bytes inside the same data sub-block where LZW data
   105  			// ended. Each arbitrarily 0x02.
   106  			b.WriteString(extra[:tc.extraExisting])
   107  		}
   108  
   109  		if tc.extraSeparate > 0 {
   110  			// Data sub-block size. This indicates how many extra bytes follow.
   111  			b.WriteByte(byte(tc.extraSeparate))
   112  			b.WriteString(extra[:tc.extraSeparate])
   113  		}
   114  		b.WriteByte(0x00) // An empty block signifies the end of the image data.
   115  		b.WriteString(trailerStr)
   116  
   117  		got, err := Decode(b)
   118  		if err != tc.wantErr {
   119  			t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d\ngot  %v\nwant %v",
   120  				tc.nPix, tc.extraExisting, tc.extraSeparate, err, tc.wantErr)
   121  		}
   122  
   123  		if tc.wantErr != nil {
   124  			continue
   125  		}
   126  		want := &image.Paletted{
   127  			Pix:    []uint8{0, 0},
   128  			Stride: 2,
   129  			Rect:   image.Rect(0, 0, 2, 1),
   130  			Palette: color.Palette{
   131  				color.RGBA{0x10, 0x20, 0x30, 0xff},
   132  				color.RGBA{0x40, 0x50, 0x60, 0xff},
   133  			},
   134  		}
   135  		if !reflect.DeepEqual(got, want) {
   136  			t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d\ngot  %v\nwant %v",
   137  				tc.nPix, tc.extraExisting, tc.extraSeparate, got, want)
   138  		}
   139  	}
   140  }
   141  
   142  func TestTransparentIndex(t *testing.T) {
   143  	b := &bytes.Buffer{}
   144  	b.WriteString(headerStr)
   145  	b.WriteString(paletteStr)
   146  	for transparentIndex := 0; transparentIndex < 3; transparentIndex++ {
   147  		if transparentIndex < 2 {
   148  			// Write the graphic control for the transparent index.
   149  			b.WriteString("\x21\xf9\x04\x01\x00\x00")
   150  			b.WriteByte(byte(transparentIndex))
   151  			b.WriteByte(0)
   152  		}
   153  		// Write an image with bounds 2x1, as per TestDecode.
   154  		b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
   155  		enc := lzwEncode([]byte{0x00, 0x00})
   156  		if len(enc) > 0xff {
   157  			t.Fatalf("compressed length %d is too large", len(enc))
   158  		}
   159  		b.WriteByte(byte(len(enc)))
   160  		b.Write(enc)
   161  		b.WriteByte(0x00)
   162  	}
   163  	b.WriteString(trailerStr)
   164  
   165  	g, err := DecodeAll(b)
   166  	if err != nil {
   167  		t.Fatalf("DecodeAll: %v", err)
   168  	}
   169  	c0 := color.RGBA{paletteStr[0], paletteStr[1], paletteStr[2], 0xff}
   170  	c1 := color.RGBA{paletteStr[3], paletteStr[4], paletteStr[5], 0xff}
   171  	cz := color.RGBA{}
   172  	wants := []color.Palette{
   173  		{cz, c1},
   174  		{c0, cz},
   175  		{c0, c1},
   176  	}
   177  	if len(g.Image) != len(wants) {
   178  		t.Fatalf("got %d images, want %d", len(g.Image), len(wants))
   179  	}
   180  	for i, want := range wants {
   181  		got := g.Image[i].Palette
   182  		if !reflect.DeepEqual(got, want) {
   183  			t.Errorf("palette #%d:\ngot  %v\nwant %v", i, got, want)
   184  		}
   185  	}
   186  }
   187  
   188  // testGIF is a simple GIF that we can modify to test different scenarios.
   189  var testGIF = []byte{
   190  	'G', 'I', 'F', '8', '9', 'a',
   191  	1, 0, 1, 0, // w=1, h=1 (6)
   192  	128, 0, 0, // headerFields, bg, aspect (10)
   193  	0, 0, 0, 1, 1, 1, // color table and graphics control (13)
   194  	0x21, 0xf9, 0x04, 0x00, 0x00, 0x00, 0xff, 0x00, // (19)
   195  	// frame 1 (0,0 - 1,1)
   196  	0x2c,
   197  	0x00, 0x00, 0x00, 0x00,
   198  	0x01, 0x00, 0x01, 0x00, // (32)
   199  	0x00,
   200  	0x02, 0x02, 0x4c, 0x01, 0x00, // lzw pixels
   201  	// trailer
   202  	0x3b,
   203  }
   204  
   205  func try(t *testing.T, b []byte, want string) {
   206  	_, err := DecodeAll(bytes.NewReader(b))
   207  	var got string
   208  	if err != nil {
   209  		got = err.Error()
   210  	}
   211  	if got != want {
   212  		t.Fatalf("got %v, want %v", got, want)
   213  	}
   214  }
   215  
   216  func TestBounds(t *testing.T) {
   217  	// Make a local copy of testGIF.
   218  	gif := make([]byte, len(testGIF))
   219  	copy(gif, testGIF)
   220  	// Make the bounds too big, just by one.
   221  	gif[32] = 2
   222  	want := "gif: frame bounds larger than image bounds"
   223  	try(t, gif, want)
   224  
   225  	// Make the bounds too small; does not trigger bounds
   226  	// check, but now there's too much data.
   227  	gif[32] = 0
   228  	want = "gif: too much image data"
   229  	try(t, gif, want)
   230  	gif[32] = 1
   231  
   232  	// Make the bounds really big, expect an error.
   233  	want = "gif: frame bounds larger than image bounds"
   234  	for i := 0; i < 4; i++ {
   235  		gif[32+i] = 0xff
   236  	}
   237  	try(t, gif, want)
   238  }
   239  
   240  func TestNoPalette(t *testing.T) {
   241  	b := &bytes.Buffer{}
   242  
   243  	// Manufacture a GIF with no palette, so any pixel at all
   244  	// will be invalid.
   245  	b.WriteString(headerStr[:len(headerStr)-3])
   246  	b.WriteString("\x00\x00\x00") // No global palette.
   247  
   248  	// Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
   249  	b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
   250  
   251  	// Encode the pixels: neither is in range, because there is no palette.
   252  	enc := lzwEncode([]byte{0x00, 0x03})
   253  	b.WriteByte(byte(len(enc)))
   254  	b.Write(enc)
   255  	b.WriteByte(0x00) // An empty block signifies the end of the image data.
   256  
   257  	b.WriteString(trailerStr)
   258  
   259  	try(t, b.Bytes(), "gif: no color table")
   260  }
   261  
   262  func TestPixelOutsidePaletteRange(t *testing.T) {
   263  	for _, pval := range []byte{0, 1, 2, 3} {
   264  		b := &bytes.Buffer{}
   265  
   266  		// Manufacture a GIF with a 2 color palette.
   267  		b.WriteString(headerStr)
   268  		b.WriteString(paletteStr)
   269  
   270  		// Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
   271  		b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
   272  
   273  		// Encode the pixels; some pvals trigger the expected error.
   274  		enc := lzwEncode([]byte{pval, pval})
   275  		b.WriteByte(byte(len(enc)))
   276  		b.Write(enc)
   277  		b.WriteByte(0x00) // An empty block signifies the end of the image data.
   278  
   279  		b.WriteString(trailerStr)
   280  
   281  		// No error expected, unless the pixels are beyond the 2 color palette.
   282  		want := ""
   283  		if pval >= 2 {
   284  			want = "gif: invalid pixel value"
   285  		}
   286  		try(t, b.Bytes(), want)
   287  	}
   288  }
   289  
   290  func TestTransparentPixelOutsidePaletteRange(t *testing.T) {
   291  	b := &bytes.Buffer{}
   292  
   293  	// Manufacture a GIF with a 2 color palette.
   294  	b.WriteString(headerStr)
   295  	b.WriteString(paletteStr)
   296  
   297  	// Graphic Control Extension: transparency, transparent color index = 3.
   298  	//
   299  	// This index, 3, is out of range of the global palette and there is no
   300  	// local palette in the subsequent image descriptor. This is an error
   301  	// according to the spec, but Firefox and Google Chrome seem OK with this.
   302  	//
   303  	// See golang.org/issue/15059.
   304  	b.WriteString("\x21\xf9\x04\x01\x00\x00\x03\x00")
   305  
   306  	// Image descriptor: 2x1, no local palette, and 2-bit LZW literals.
   307  	b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
   308  
   309  	// Encode the pixels.
   310  	enc := lzwEncode([]byte{0x03, 0x03})
   311  	b.WriteByte(byte(len(enc)))
   312  	b.Write(enc)
   313  	b.WriteByte(0x00) // An empty block signifies the end of the image data.
   314  
   315  	b.WriteString(trailerStr)
   316  
   317  	try(t, b.Bytes(), "")
   318  }
   319  
   320  func TestLoopCount(t *testing.T) {
   321  	data := []byte("GIF89a000\x00000,0\x00\x00\x00\n\x00" +
   322  		"\n\x00\x80000000\x02\b\xf01u\xb9\xfdal\x05\x00;")
   323  	img, err := DecodeAll(bytes.NewReader(data))
   324  	if err != nil {
   325  		t.Fatal("DecodeAll:", err)
   326  	}
   327  	w := new(bytes.Buffer)
   328  	err = EncodeAll(w, img)
   329  	if err != nil {
   330  		t.Fatal("EncodeAll:", err)
   331  	}
   332  	img1, err := DecodeAll(w)
   333  	if err != nil {
   334  		t.Fatal("DecodeAll:", err)
   335  	}
   336  	if img.LoopCount != img1.LoopCount {
   337  		t.Errorf("loop count mismatch: %d vs %d", img.LoopCount, img1.LoopCount)
   338  	}
   339  }
   340  
   341  func TestUnexpectedEOF(t *testing.T) {
   342  	for i := len(testGIF) - 1; i >= 0; i-- {
   343  		_, err := Decode(bytes.NewReader(testGIF[:i]))
   344  		if err == errNotEnough {
   345  			continue
   346  		}
   347  		text := ""
   348  		if err != nil {
   349  			text = err.Error()
   350  		}
   351  		if !strings.HasPrefix(text, "gif:") || !strings.HasSuffix(text, ": unexpected EOF") {
   352  			t.Errorf("Decode(testGIF[:%d]) = %v, want gif: ...: unexpected EOF", i, err)
   353  		}
   354  	}
   355  }
   356  
   357  // See golang.org/issue/22237
   358  func TestDecodeMemoryConsumption(t *testing.T) {
   359  	const frames = 3000
   360  	img := image.NewPaletted(image.Rectangle{Max: image.Point{1, 1}}, palette.WebSafe)
   361  	hugeGIF := &GIF{
   362  		Image:    make([]*image.Paletted, frames),
   363  		Delay:    make([]int, frames),
   364  		Disposal: make([]byte, frames),
   365  	}
   366  	for i := 0; i < frames; i++ {
   367  		hugeGIF.Image[i] = img
   368  		hugeGIF.Delay[i] = 60
   369  	}
   370  	buf := new(bytes.Buffer)
   371  	if err := EncodeAll(buf, hugeGIF); err != nil {
   372  		t.Fatal("EncodeAll:", err)
   373  	}
   374  	s0, s1 := new(runtime.MemStats), new(runtime.MemStats)
   375  	runtime.GC()
   376  	defer debug.SetGCPercent(debug.SetGCPercent(5))
   377  	runtime.ReadMemStats(s0)
   378  	if _, err := Decode(buf); err != nil {
   379  		t.Fatal("Decode:", err)
   380  	}
   381  	runtime.ReadMemStats(s1)
   382  	if heapDiff := int64(s1.HeapAlloc - s0.HeapAlloc); heapDiff > 30<<20 {
   383  		t.Fatalf("Decode of %d frames increased heap by %dMB", frames, heapDiff>>20)
   384  	}
   385  }
   386  
   387  func BenchmarkDecode(b *testing.B) {
   388  	data, err := ioutil.ReadFile("../testdata/video-001.gif")
   389  	if err != nil {
   390  		b.Fatal(err)
   391  	}
   392  	cfg, err := DecodeConfig(bytes.NewReader(data))
   393  	if err != nil {
   394  		b.Fatal(err)
   395  	}
   396  	b.SetBytes(int64(cfg.Width * cfg.Height))
   397  	b.ReportAllocs()
   398  	b.ResetTimer()
   399  	for i := 0; i < b.N; i++ {
   400  		Decode(bytes.NewReader(data))
   401  	}
   402  }
   403  

View as plain text