Switch to Go modules and make other changes

3 files changed, 0 insertions, 1147 deletions

diff --git a/vendor/golang.org/x/image/vp8l/decode.go b/vendor/golang.org/x/image/vp8l/decode.go
deleted file mode 100644
index 4319487..0000000
--- a/vendor/golang.org/x/image/vp8l/decode.go
+++ /dev/null
@@ -1,603 +0,0 @@
-// Copyright 2014 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 vp8l implements a decoder for the VP8L lossless image format.
-//
-// The VP8L specification is at:
-// https://developers.google.com/speed/webp/docs/riff_container
-package vp8l // import "golang.org/x/image/vp8l"
-
-import (
-	"bufio"
-	"errors"
-	"image"
-	"image/color"
-	"io"
-)
-
-var (
-	errInvalidCodeLengths = errors.New("vp8l: invalid code lengths")
-	errInvalidHuffmanTree = errors.New("vp8l: invalid Huffman tree")
-)
-
-// colorCacheMultiplier is the multiplier used for the color cache hash
-// function, specified in section 4.2.3.
-const colorCacheMultiplier = 0x1e35a7bd
-
-// distanceMapTable is the look-up table for distanceMap.
-var distanceMapTable = [120]uint8{
-	0x18, 0x07, 0x17, 0x19, 0x28, 0x06, 0x27, 0x29, 0x16, 0x1a,
-	0x26, 0x2a, 0x38, 0x05, 0x37, 0x39, 0x15, 0x1b, 0x36, 0x3a,
-	0x25, 0x2b, 0x48, 0x04, 0x47, 0x49, 0x14, 0x1c, 0x35, 0x3b,
-	0x46, 0x4a, 0x24, 0x2c, 0x58, 0x45, 0x4b, 0x34, 0x3c, 0x03,
-	0x57, 0x59, 0x13, 0x1d, 0x56, 0x5a, 0x23, 0x2d, 0x44, 0x4c,
-	0x55, 0x5b, 0x33, 0x3d, 0x68, 0x02, 0x67, 0x69, 0x12, 0x1e,
-	0x66, 0x6a, 0x22, 0x2e, 0x54, 0x5c, 0x43, 0x4d, 0x65, 0x6b,
-	0x32, 0x3e, 0x78, 0x01, 0x77, 0x79, 0x53, 0x5d, 0x11, 0x1f,
-	0x64, 0x6c, 0x42, 0x4e, 0x76, 0x7a, 0x21, 0x2f, 0x75, 0x7b,
-	0x31, 0x3f, 0x63, 0x6d, 0x52, 0x5e, 0x00, 0x74, 0x7c, 0x41,
-	0x4f, 0x10, 0x20, 0x62, 0x6e, 0x30, 0x73, 0x7d, 0x51, 0x5f,
-	0x40, 0x72, 0x7e, 0x61, 0x6f, 0x50, 0x71, 0x7f, 0x60, 0x70,
-}
-
-// distanceMap maps a LZ77 backwards reference distance to a two-dimensional
-// pixel offset, specified in section 4.2.2.
-func distanceMap(w int32, code uint32) int32 {
-	if int32(code) > int32(len(distanceMapTable)) {
-		return int32(code) - int32(len(distanceMapTable))
-	}
-	distCode := int32(distanceMapTable[code-1])
-	yOffset := distCode >> 4
-	xOffset := 8 - distCode&0xf
-	if d := yOffset*w + xOffset; d >= 1 {
-		return d
-	}
-	return 1
-}
-
-// decoder holds the bit-stream for a VP8L image.
-type decoder struct {
-	r     io.ByteReader
-	bits  uint32
-	nBits uint32
-}
-
-// read reads the next n bits from the decoder's bit-stream.
-func (d *decoder) read(n uint32) (uint32, error) {
-	for d.nBits < n {
-		c, err := d.r.ReadByte()
-		if err != nil {
-			if err == io.EOF {
-				err = io.ErrUnexpectedEOF
-			}
-			return 0, err
-		}
-		d.bits |= uint32(c) << d.nBits
-		d.nBits += 8
-	}
-	u := d.bits & (1<<n - 1)
-	d.bits >>= n
-	d.nBits -= n
-	return u, nil
-}
-
-// decodeTransform decodes the next transform and the width of the image after
-// transformation (or equivalently, before inverse transformation), specified
-// in section 3.
-func (d *decoder) decodeTransform(w int32, h int32) (t transform, newWidth int32, err error) {
-	t.oldWidth = w
-	t.transformType, err = d.read(2)
-	if err != nil {
-		return transform{}, 0, err
-	}
-	switch t.transformType {
-	case transformTypePredictor, transformTypeCrossColor:
-		t.bits, err = d.read(3)
-		if err != nil {
-			return transform{}, 0, err
-		}
-		t.bits += 2
-		t.pix, err = d.decodePix(nTiles(w, t.bits), nTiles(h, t.bits), 0, false)
-		if err != nil {
-			return transform{}, 0, err
-		}
-	case transformTypeSubtractGreen:
-		// No-op.
-	case transformTypeColorIndexing:
-		nColors, err := d.read(8)
-		if err != nil {
-			return transform{}, 0, err
-		}
-		nColors++
-		t.bits = 0
-		switch {
-		case nColors <= 2:
-			t.bits = 3
-		case nColors <= 4:
-			t.bits = 2
-		case nColors <= 16:
-			t.bits = 1
-		}
-		w = nTiles(w, t.bits)
-		pix, err := d.decodePix(int32(nColors), 1, 4*256, false)
-		if err != nil {
-			return transform{}, 0, err
-		}
-		for p := 4; p < len(pix); p += 4 {
-			pix[p+0] += pix[p-4]
-			pix[p+1] += pix[p-3]
-			pix[p+2] += pix[p-2]
-			pix[p+3] += pix[p-1]
-		}
-		// The spec says that "if the index is equal or larger than color_table_size,
-		// the argb color value should be set to 0x00000000 (transparent black)."
-		// We re-slice up to 256 4-byte pixels.
-		t.pix = pix[:4*256]
-	}
-	return t, w, nil
-}
-
-// repeatsCodeLength is the minimum code length for repeated codes.
-const repeatsCodeLength = 16
-
-// These magic numbers are specified at the end of section 5.2.2.
-// The 3-length arrays apply to code lengths >= repeatsCodeLength.
-var (
-	codeLengthCodeOrder = [19]uint8{
-		17, 18, 0, 1, 2, 3, 4, 5, 16, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-	}
-	repeatBits    = [3]uint8{2, 3, 7}
-	repeatOffsets = [3]uint8{3, 3, 11}
-)
-
-// decodeCodeLengths decodes a Huffman tree's code lengths which are themselves
-// encoded via a Huffman tree, specified in section 5.2.2.
-func (d *decoder) decodeCodeLengths(dst []uint32, codeLengthCodeLengths []uint32) error {
-	h := hTree{}
-	if err := h.build(codeLengthCodeLengths); err != nil {
-		return err
-	}
-
-	maxSymbol := len(dst)
-	useLength, err := d.read(1)
-	if err != nil {
-		return err
-	}
-	if useLength != 0 {
-		n, err := d.read(3)
-		if err != nil {
-			return err
-		}
-		n = 2 + 2*n
-		ms, err := d.read(n)
-		if err != nil {
-			return err
-		}
-		maxSymbol = int(ms) + 2
-		if maxSymbol > len(dst) {
-			return errInvalidCodeLengths
-		}
-	}
-
-	// The spec says that "if code 16 [meaning repeat] is used before
-	// a non-zero value has been emitted, a value of 8 is repeated."
-	prevCodeLength := uint32(8)
-
-	for symbol := 0; symbol < len(dst); {
-		if maxSymbol == 0 {
-			break
-		}
-		maxSymbol--
-		codeLength, err := h.next(d)
-		if err != nil {
-			return err
-		}
-		if codeLength < repeatsCodeLength {
-			dst[symbol] = codeLength
-			symbol++
-			if codeLength != 0 {
-				prevCodeLength = codeLength
-			}
-			continue
-		}
-
-		repeat, err := d.read(uint32(repeatBits[codeLength-repeatsCodeLength]))
-		if err != nil {
-			return err
-		}
-		repeat += uint32(repeatOffsets[codeLength-repeatsCodeLength])
-		if symbol+int(repeat) > len(dst) {
-			return errInvalidCodeLengths
-		}
-		// A code length of 16 repeats the previous non-zero code.
-		// A code length of 17 or 18 repeats zeroes.
-		cl := uint32(0)
-		if codeLength == 16 {
-			cl = prevCodeLength
-		}
-		for ; repeat > 0; repeat-- {
-			dst[symbol] = cl
-			symbol++
-		}
-	}
-	return nil
-}
-
-// decodeHuffmanTree decodes a Huffman tree into h.
-func (d *decoder) decodeHuffmanTree(h *hTree, alphabetSize uint32) error {
-	useSimple, err := d.read(1)
-	if err != nil {
-		return err
-	}
-	if useSimple != 0 {
-		nSymbols, err := d.read(1)
-		if err != nil {
-			return err
-		}
-		nSymbols++
-		firstSymbolLengthCode, err := d.read(1)
-		if err != nil {
-			return err
-		}
-		firstSymbolLengthCode = 7*firstSymbolLengthCode + 1
-		var symbols [2]uint32
-		symbols[0], err = d.read(firstSymbolLengthCode)
-		if err != nil {
-			return err
-		}
-		if nSymbols == 2 {
-			symbols[1], err = d.read(8)
-			if err != nil {
-				return err
-			}
-		}
-		return h.buildSimple(nSymbols, symbols, alphabetSize)
-	}
-
-	nCodes, err := d.read(4)
-	if err != nil {
-		return err
-	}
-	nCodes += 4
-	if int(nCodes) > len(codeLengthCodeOrder) {
-		return errInvalidHuffmanTree
-	}
-	codeLengthCodeLengths := [len(codeLengthCodeOrder)]uint32{}
-	for i := uint32(0); i < nCodes; i++ {
-		codeLengthCodeLengths[codeLengthCodeOrder[i]], err = d.read(3)
-		if err != nil {
-			return err
-		}
-	}
-	codeLengths := make([]uint32, alphabetSize)
-	if err = d.decodeCodeLengths(codeLengths, codeLengthCodeLengths[:]); err != nil {
-		return err
-	}
-	return h.build(codeLengths)
-}
-
-const (
-	huffGreen    = 0
-	huffRed      = 1
-	huffBlue     = 2
-	huffAlpha    = 3
-	huffDistance = 4
-	nHuff        = 5
-)
-
-// hGroup is an array of 5 Huffman trees.
-type hGroup [nHuff]hTree
-
-// decodeHuffmanGroups decodes the one or more hGroups used to decode the pixel
-// data. If one hGroup is used for the entire image, then hPix and hBits will
-// be zero. If more than one hGroup is used, then hPix contains the meta-image
-// that maps tiles to hGroup index, and hBits contains the log-2 tile size.
-func (d *decoder) decodeHuffmanGroups(w int32, h int32, topLevel bool, ccBits uint32) (
-	hGroups []hGroup, hPix []byte, hBits uint32, err error) {
-
-	maxHGroupIndex := 0
-	if topLevel {
-		useMeta, err := d.read(1)
-		if err != nil {
-			return nil, nil, 0, err
-		}
-		if useMeta != 0 {
-			hBits, err = d.read(3)
-			if err != nil {
-				return nil, nil, 0, err
-			}
-			hBits += 2
-			hPix, err = d.decodePix(nTiles(w, hBits), nTiles(h, hBits), 0, false)
-			if err != nil {
-				return nil, nil, 0, err
-			}
-			for p := 0; p < len(hPix); p += 4 {
-				i := int(hPix[p])<<8 | int(hPix[p+1])
-				if maxHGroupIndex < i {
-					maxHGroupIndex = i
-				}
-			}
-		}
-	}
-	hGroups = make([]hGroup, maxHGroupIndex+1)
-	for i := range hGroups {
-		for j, alphabetSize := range alphabetSizes {
-			if j == 0 && ccBits > 0 {
-				alphabetSize += 1 << ccBits
-			}
-			if err := d.decodeHuffmanTree(&hGroups[i][j], alphabetSize); err != nil {
-				return nil, nil, 0, err
-			}
-		}
-	}
-	return hGroups, hPix, hBits, nil
-}
-
-const (
-	nLiteralCodes  = 256
-	nLengthCodes   = 24
-	nDistanceCodes = 40
-)
-
-var alphabetSizes = [nHuff]uint32{
-	nLiteralCodes + nLengthCodes,
-	nLiteralCodes,
-	nLiteralCodes,
-	nLiteralCodes,
-	nDistanceCodes,
-}
-
-// decodePix decodes pixel data, specified in section 5.2.2.
-func (d *decoder) decodePix(w int32, h int32, minCap int32, topLevel bool) ([]byte, error) {
-	// Decode the color cache parameters.
-	ccBits, ccShift, ccEntries := uint32(0), uint32(0), ([]uint32)(nil)
-	useColorCache, err := d.read(1)
-	if err != nil {
-		return nil, err
-	}
-	if useColorCache != 0 {
-		ccBits, err = d.read(4)
-		if err != nil {
-			return nil, err
-		}
-		if ccBits < 1 || 11 < ccBits {
-			return nil, errors.New("vp8l: invalid color cache parameters")
-		}
-		ccShift = 32 - ccBits
-		ccEntries = make([]uint32, 1<<ccBits)
-	}
-
-	// Decode the Huffman groups.
-	hGroups, hPix, hBits, err := d.decodeHuffmanGroups(w, h, topLevel, ccBits)
-	if err != nil {
-		return nil, err
-	}
-	hMask, tilesPerRow := int32(0), int32(0)
-	if hBits != 0 {
-		hMask, tilesPerRow = 1<<hBits-1, nTiles(w, hBits)
-	}
-
-	// Decode the pixels.
-	if minCap < 4*w*h {
-		minCap = 4 * w * h
-	}
-	pix := make([]byte, 4*w*h, minCap)
-	p, cachedP := 0, 0
-	x, y := int32(0), int32(0)
-	hg, lookupHG := &hGroups[0], hMask != 0
-	for p < len(pix) {
-		if lookupHG {
-			i := 4 * (tilesPerRow*(y>>hBits) + (x >> hBits))
-			hg = &hGroups[uint32(hPix[i])<<8|uint32(hPix[i+1])]
-		}
-
-		green, err := hg[huffGreen].next(d)
-		if err != nil {
-			return nil, err
-		}
-		switch {
-		case green < nLiteralCodes:
-			// We have a literal pixel.
-			red, err := hg[huffRed].next(d)
-			if err != nil {
-				return nil, err
-			}
-			blue, err := hg[huffBlue].next(d)
-			if err != nil {
-				return nil, err
-			}
-			alpha, err := hg[huffAlpha].next(d)
-			if err != nil {
-				return nil, err
-			}
-			pix[p+0] = uint8(red)
-			pix[p+1] = uint8(green)
-			pix[p+2] = uint8(blue)
-			pix[p+3] = uint8(alpha)
-			p += 4
-
-			x++
-			if x == w {
-				x, y = 0, y+1
-			}
-			lookupHG = hMask != 0 && x&hMask == 0
-
-		case green < nLiteralCodes+nLengthCodes:
-			// We have a LZ77 backwards reference.
-			length, err := d.lz77Param(green - nLiteralCodes)
-			if err != nil {
-				return nil, err
-			}
-			distSym, err := hg[huffDistance].next(d)
-			if err != nil {
-				return nil, err
-			}
-			distCode, err := d.lz77Param(distSym)
-			if err != nil {
-				return nil, err
-			}
-			dist := distanceMap(w, distCode)
-			pEnd := p + 4*int(length)
-			q := p - 4*int(dist)
-			qEnd := pEnd - 4*int(dist)
-			if p < 0 || len(pix) < pEnd || q < 0 || len(pix) < qEnd {
-				return nil, errors.New("vp8l: invalid LZ77 parameters")
-			}
-			for ; p < pEnd; p, q = p+1, q+1 {
-				pix[p] = pix[q]
-			}
-
-			x += int32(length)
-			for x >= w {
-				x, y = x-w, y+1
-			}
-			lookupHG = hMask != 0
-
-		default:
-			// We have a color cache lookup. First, insert previous pixels
-			// into the cache. Note that VP8L assumes ARGB order, but the
-			// Go image.RGBA type is in RGBA order.
-			for ; cachedP < p; cachedP += 4 {
-				argb := uint32(pix[cachedP+0])<<16 |
-					uint32(pix[cachedP+1])<<8 |
-					uint32(pix[cachedP+2])<<0 |
-					uint32(pix[cachedP+3])<<24
-				ccEntries[(argb*colorCacheMultiplier)>>ccShift] = argb
-			}
-			green -= nLiteralCodes + nLengthCodes
-			if int(green) >= len(ccEntries) {
-				return nil, errors.New("vp8l: invalid color cache index")
-			}
-			argb := ccEntries[green]
-			pix[p+0] = uint8(argb >> 16)
-			pix[p+1] = uint8(argb >> 8)
-			pix[p+2] = uint8(argb >> 0)
-			pix[p+3] = uint8(argb >> 24)
-			p += 4
-
-			x++
-			if x == w {
-				x, y = 0, y+1
-			}
-			lookupHG = hMask != 0 && x&hMask == 0
-		}
-	}
-	return pix, nil
-}
-
-// lz77Param returns the next LZ77 parameter: a length or a distance, specified
-// in section 4.2.2.
-func (d *decoder) lz77Param(symbol uint32) (uint32, error) {
-	if symbol < 4 {
-		return symbol + 1, nil
-	}
-	extraBits := (symbol - 2) >> 1
-	offset := (2 + symbol&1) << extraBits
-	n, err := d.read(extraBits)
-	if err != nil {
-		return 0, err
-	}
-	return offset + n + 1, nil
-}
-
-// decodeHeader decodes the VP8L header from r.
-func decodeHeader(r io.Reader) (d *decoder, w int32, h int32, err error) {
-	rr, ok := r.(io.ByteReader)
-	if !ok {
-		rr = bufio.NewReader(r)
-	}
-	d = &decoder{r: rr}
-	magic, err := d.read(8)
-	if err != nil {
-		return nil, 0, 0, err
-	}
-	if magic != 0x2f {
-		return nil, 0, 0, errors.New("vp8l: invalid header")
-	}
-	width, err := d.read(14)
-	if err != nil {
-		return nil, 0, 0, err
-	}
-	width++
-	height, err := d.read(14)
-	if err != nil {
-		return nil, 0, 0, err
-	}
-	height++
-	_, err = d.read(1) // Read and ignore the hasAlpha hint.
-	if err != nil {
-		return nil, 0, 0, err
-	}
-	version, err := d.read(3)
-	if err != nil {
-		return nil, 0, 0, err
-	}
-	if version != 0 {
-		return nil, 0, 0, errors.New("vp8l: invalid version")
-	}
-	return d, int32(width), int32(height), nil
-}
-
-// DecodeConfig decodes the color model and dimensions of a VP8L image from r.
-func DecodeConfig(r io.Reader) (image.Config, error) {
-	_, w, h, err := decodeHeader(r)
-	if err != nil {
-		return image.Config{}, err
-	}
-	return image.Config{
-		ColorModel: color.NRGBAModel,
-		Width:      int(w),
-		Height:     int(h),
-	}, nil
-}
-
-// Decode decodes a VP8L image from r.
-func Decode(r io.Reader) (image.Image, error) {
-	d, w, h, err := decodeHeader(r)
-	if err != nil {
-		return nil, err
-	}
-	// Decode the transforms.
-	var (
-		nTransforms    int
-		transforms     [nTransformTypes]transform
-		transformsSeen [nTransformTypes]bool
-		originalW      = w
-	)
-	for {
-		more, err := d.read(1)
-		if err != nil {
-			return nil, err
-		}
-		if more == 0 {
-			break
-		}
-		var t transform
-		t, w, err = d.decodeTransform(w, h)
-		if err != nil {
-			return nil, err
-		}
-		if transformsSeen[t.transformType] {
-			return nil, errors.New("vp8l: repeated transform")
-		}
-		transformsSeen[t.transformType] = true
-		transforms[nTransforms] = t
-		nTransforms++
-	}
-	// Decode the transformed pixels.
-	pix, err := d.decodePix(w, h, 0, true)
-	if err != nil {
-		return nil, err
-	}
-	// Apply the inverse transformations.
-	for i := nTransforms - 1; i >= 0; i-- {
-		t := &transforms[i]
-		pix = inverseTransforms[t.transformType](t, pix, h)
-	}
-	return &image.NRGBA{
-		Pix:    pix,
-		Stride: 4 * int(originalW),
-		Rect:   image.Rect(0, 0, int(originalW), int(h)),
-	}, nil
-}
diff --git a/vendor/golang.org/x/image/vp8l/huffman.go b/vendor/golang.org/x/image/vp8l/huffman.go
deleted file mode 100644
index 36368a8..0000000
--- a/vendor/golang.org/x/image/vp8l/huffman.go
+++ /dev/null
@@ -1,245 +0,0 @@
-// Copyright 2014 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 vp8l
-
-import (
-	"io"
-)
-
-// reverseBits reverses the bits in a byte.
-var reverseBits = [256]uint8{
-	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
-	0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
-	0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
-	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
-	0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
-	0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
-	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
-	0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
-	0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
-	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
-	0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
-	0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
-	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
-	0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
-	0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
-	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
-}
-
-// hNode is a node in a Huffman tree.
-type hNode struct {
-	// symbol is the symbol held by this node.
-	symbol uint32
-	// children, if positive, is the hTree.nodes index of the first of
-	// this node's two children. Zero means an uninitialized node,
-	// and -1 means a leaf node.
-	children int32
-}
-
-const leafNode = -1
-
-// lutSize is the log-2 size of an hTree's look-up table.
-const lutSize, lutMask = 7, 1<<7 - 1
-
-// hTree is a Huffman tree.
-type hTree struct {
-	// nodes are the nodes of the Huffman tree. During construction,
-	// len(nodes) grows from 1 up to cap(nodes) by steps of two.
-	// After construction, len(nodes) == cap(nodes), and both equal
-	// 2*theNumberOfSymbols - 1.
-	nodes []hNode
-	// lut is a look-up table for walking the nodes. The x in lut[x] is
-	// the next lutSize bits in the bit-stream. The low 8 bits of lut[x]
-	// equals 1 plus the number of bits in the next code, or 0 if the
-	// next code requires more than lutSize bits. The high 24 bits are:
-	//   - the symbol, if the code requires lutSize or fewer bits, or
-	//   - the hTree.nodes index to start the tree traversal from, if
-	//     the next code requires more than lutSize bits.
-	lut [1 << lutSize]uint32
-}
-
-// insert inserts into the hTree a symbol whose encoding is the least
-// significant codeLength bits of code.
-func (h *hTree) insert(symbol uint32, code uint32, codeLength uint32) error {
-	if symbol > 0xffff || codeLength > 0xfe {
-		return errInvalidHuffmanTree
-	}
-	baseCode := uint32(0)
-	if codeLength > lutSize {
-		baseCode = uint32(reverseBits[(code>>(codeLength-lutSize))&0xff]) >> (8 - lutSize)
-	} else {
-		baseCode = uint32(reverseBits[code&0xff]) >> (8 - codeLength)
-		for i := 0; i < 1<<(lutSize-codeLength); i++ {
-			h.lut[baseCode|uint32(i)<<codeLength] = symbol<<8 | (codeLength + 1)
-		}
-	}
-
-	n := uint32(0)
-	for jump := lutSize; codeLength > 0; {
-		codeLength--
-		if int(n) > len(h.nodes) {
-			return errInvalidHuffmanTree
-		}
-		switch h.nodes[n].children {
-		case leafNode:
-			return errInvalidHuffmanTree
-		case 0:
-			if len(h.nodes) == cap(h.nodes) {
-				return errInvalidHuffmanTree
-			}
-			// Create two empty child nodes.
-			h.nodes[n].children = int32(len(h.nodes))
-			h.nodes = h.nodes[:len(h.nodes)+2]
-		}
-		n = uint32(h.nodes[n].children) + 1&(code>>codeLength)
-		jump--
-		if jump == 0 && h.lut[baseCode] == 0 {
-			h.lut[baseCode] = n << 8
-		}
-	}
-
-	switch h.nodes[n].children {
-	case leafNode:
-		// No-op.
-	case 0:
-		// Turn the uninitialized node into a leaf.
-		h.nodes[n].children = leafNode
-	default:
-		return errInvalidHuffmanTree
-	}
-	h.nodes[n].symbol = symbol
-	return nil
-}
-
-// codeLengthsToCodes returns the canonical Huffman codes implied by the
-// sequence of code lengths.
-func codeLengthsToCodes(codeLengths []uint32) ([]uint32, error) {
-	maxCodeLength := uint32(0)
-	for _, cl := range codeLengths {
-		if maxCodeLength < cl {
-			maxCodeLength = cl
-		}
-	}
-	const maxAllowedCodeLength = 15
-	if len(codeLengths) == 0 || maxCodeLength > maxAllowedCodeLength {
-		return nil, errInvalidHuffmanTree
-	}
-	histogram := [maxAllowedCodeLength + 1]uint32{}
-	for _, cl := range codeLengths {
-		histogram[cl]++
-	}
-	currCode, nextCodes := uint32(0), [maxAllowedCodeLength + 1]uint32{}
-	for cl := 1; cl < len(nextCodes); cl++ {
-		currCode = (currCode + histogram[cl-1]) << 1
-		nextCodes[cl] = currCode
-	}
-	codes := make([]uint32, len(codeLengths))
-	for symbol, cl := range codeLengths {
-		if cl > 0 {
-			codes[symbol] = nextCodes[cl]
-			nextCodes[cl]++
-		}
-	}
-	return codes, nil
-}
-
-// build builds a canonical Huffman tree from the given code lengths.
-func (h *hTree) build(codeLengths []uint32) error {
-	// Calculate the number of symbols.
-	var nSymbols, lastSymbol uint32
-	for symbol, cl := range codeLengths {
-		if cl != 0 {
-			nSymbols++
-			lastSymbol = uint32(symbol)
-		}
-	}
-	if nSymbols == 0 {
-		return errInvalidHuffmanTree
-	}
-	h.nodes = make([]hNode, 1, 2*nSymbols-1)
-	// Handle the trivial case.
-	if nSymbols == 1 {
-		if len(codeLengths) <= int(lastSymbol) {
-			return errInvalidHuffmanTree
-		}
-		return h.insert(lastSymbol, 0, 0)
-	}
-	// Handle the non-trivial case.
-	codes, err := codeLengthsToCodes(codeLengths)
-	if err != nil {
-		return err
-	}
-	for symbol, cl := range codeLengths {
-		if cl > 0 {
-			if err := h.insert(uint32(symbol), codes[symbol], cl); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// buildSimple builds a Huffman tree with 1 or 2 symbols.
-func (h *hTree) buildSimple(nSymbols uint32, symbols [2]uint32, alphabetSize uint32) error {
-	h.nodes = make([]hNode, 1, 2*nSymbols-1)
-	for i := uint32(0); i < nSymbols; i++ {
-		if symbols[i] >= alphabetSize {
-			return errInvalidHuffmanTree
-		}
-		if err := h.insert(symbols[i], i, nSymbols-1); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// next returns the next Huffman-encoded symbol from the bit-stream d.
-func (h *hTree) next(d *decoder) (uint32, error) {
-	var n uint32
-	// Read enough bits so that we can use the look-up table.
-	if d.nBits < lutSize {
-		c, err := d.r.ReadByte()
-		if err != nil {
-			if err == io.EOF {
-				// There are no more bytes of data, but we may still be able
-				// to read the next symbol out of the previously read bits.
-				goto slowPath
-			}
-			return 0, err
-		}
-		d.bits |= uint32(c) << d.nBits
-		d.nBits += 8
-	}
-	// Use the look-up table.
-	n = h.lut[d.bits&lutMask]
-	if b := n & 0xff; b != 0 {
-		b--
-		d.bits >>= b
-		d.nBits -= b
-		return n >> 8, nil
-	}
-	n >>= 8
-	d.bits >>= lutSize
-	d.nBits -= lutSize
-
-slowPath:
-	for h.nodes[n].children != leafNode {
-		if d.nBits == 0 {
-			c, err := d.r.ReadByte()
-			if err != nil {
-				if err == io.EOF {
-					err = io.ErrUnexpectedEOF
-				}
-				return 0, err
-			}
-			d.bits = uint32(c)
-			d.nBits = 8
-		}
-		n = uint32(h.nodes[n].children) + 1&d.bits
-		d.bits >>= 1
-		d.nBits--
-	}
-	return h.nodes[n].symbol, nil
-}
diff --git a/vendor/golang.org/x/image/vp8l/transform.go b/vendor/golang.org/x/image/vp8l/transform.go
deleted file mode 100644
index 06543da..0000000
--- a/vendor/golang.org/x/image/vp8l/transform.go
+++ /dev/null
@@ -1,299 +0,0 @@
-// Copyright 2014 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 vp8l
-
-// This file deals with image transforms, specified in section 3.
-
-// nTiles returns the number of tiles needed to cover size pixels, where each
-// tile's side is 1<<bits pixels long.
-func nTiles(size int32, bits uint32) int32 {
-	return (size + 1<<bits - 1) >> bits
-}
-
-const (
-	transformTypePredictor     = 0
-	transformTypeCrossColor    = 1
-	transformTypeSubtractGreen = 2
-	transformTypeColorIndexing = 3
-	nTransformTypes            = 4
-)
-
-// transform holds the parameters for an invertible transform.
-type transform struct {
-	// transformType is the type of the transform.
-	transformType uint32
-	// oldWidth is the width of the image before transformation (or
-	// equivalently, after inverse transformation). The color-indexing
-	// transform can reduce the width. For example, a 50-pixel-wide
-	// image that only needs 4 bits (half a byte) per color index can
-	// be transformed into a 25-pixel-wide image.
-	oldWidth int32
-	// bits is the log-2 size of the transform's tiles, for the predictor
-	// and cross-color transforms. 8>>bits is the number of bits per
-	// color index, for the color-index transform.
-	bits uint32
-	// pix is the tile values, for the predictor and cross-color
-	// transforms, and the color palette, for the color-index transform.
-	pix []byte
-}
-
-var inverseTransforms = [nTransformTypes]func(*transform, []byte, int32) []byte{
-	transformTypePredictor:     inversePredictor,
-	transformTypeCrossColor:    inverseCrossColor,
-	transformTypeSubtractGreen: inverseSubtractGreen,
-	transformTypeColorIndexing: inverseColorIndexing,
-}
-
-func inversePredictor(t *transform, pix []byte, h int32) []byte {
-	if t.oldWidth == 0 || h == 0 {
-		return pix
-	}
-	// The first pixel's predictor is mode 0 (opaque black).
-	pix[3] += 0xff
-	p, mask := int32(4), int32(1)<<t.bits-1
-	for x := int32(1); x < t.oldWidth; x++ {
-		// The rest of the first row's predictor is mode 1 (L).
-		pix[p+0] += pix[p-4]
-		pix[p+1] += pix[p-3]
-		pix[p+2] += pix[p-2]
-		pix[p+3] += pix[p-1]
-		p += 4
-	}
-	top, tilesPerRow := 0, nTiles(t.oldWidth, t.bits)
-	for y := int32(1); y < h; y++ {
-		// The first column's predictor is mode 2 (T).
-		pix[p+0] += pix[top+0]
-		pix[p+1] += pix[top+1]
-		pix[p+2] += pix[top+2]
-		pix[p+3] += pix[top+3]
-		p, top = p+4, top+4
-
-		q := 4 * (y >> t.bits) * tilesPerRow
-		predictorMode := t.pix[q+1] & 0x0f
-		q += 4
-		for x := int32(1); x < t.oldWidth; x++ {
-			if x&mask == 0 {
-				predictorMode = t.pix[q+1] & 0x0f
-				q += 4
-			}
-			switch predictorMode {
-			case 0: // Opaque black.
-				pix[p+3] += 0xff
-
-			case 1: // L.
-				pix[p+0] += pix[p-4]
-				pix[p+1] += pix[p-3]
-				pix[p+2] += pix[p-2]
-				pix[p+3] += pix[p-1]
-
-			case 2: // T.
-				pix[p+0] += pix[top+0]
-				pix[p+1] += pix[top+1]
-				pix[p+2] += pix[top+2]
-				pix[p+3] += pix[top+3]
-
-			case 3: // TR.
-				pix[p+0] += pix[top+4]
-				pix[p+1] += pix[top+5]
-				pix[p+2] += pix[top+6]
-				pix[p+3] += pix[top+7]
-
-			case 4: // TL.
-				pix[p+0] += pix[top-4]
-				pix[p+1] += pix[top-3]
-				pix[p+2] += pix[top-2]
-				pix[p+3] += pix[top-1]
-
-			case 5: // Average2(Average2(L, TR), T).
-				pix[p+0] += avg2(avg2(pix[p-4], pix[top+4]), pix[top+0])
-				pix[p+1] += avg2(avg2(pix[p-3], pix[top+5]), pix[top+1])
-				pix[p+2] += avg2(avg2(pix[p-2], pix[top+6]), pix[top+2])
-				pix[p+3] += avg2(avg2(pix[p-1], pix[top+7]), pix[top+3])
-
-			case 6: // Average2(L, TL).
-				pix[p+0] += avg2(pix[p-4], pix[top-4])
-				pix[p+1] += avg2(pix[p-3], pix[top-3])
-				pix[p+2] += avg2(pix[p-2], pix[top-2])
-				pix[p+3] += avg2(pix[p-1], pix[top-1])
-
-			case 7: // Average2(L, T).
-				pix[p+0] += avg2(pix[p-4], pix[top+0])
-				pix[p+1] += avg2(pix[p-3], pix[top+1])
-				pix[p+2] += avg2(pix[p-2], pix[top+2])
-				pix[p+3] += avg2(pix[p-1], pix[top+3])
-
-			case 8: // Average2(TL, T).
-				pix[p+0] += avg2(pix[top-4], pix[top+0])
-				pix[p+1] += avg2(pix[top-3], pix[top+1])
-				pix[p+2] += avg2(pix[top-2], pix[top+2])
-				pix[p+3] += avg2(pix[top-1], pix[top+3])
-
-			case 9: // Average2(T, TR).
-				pix[p+0] += avg2(pix[top+0], pix[top+4])
-				pix[p+1] += avg2(pix[top+1], pix[top+5])
-				pix[p+2] += avg2(pix[top+2], pix[top+6])
-				pix[p+3] += avg2(pix[top+3], pix[top+7])
-
-			case 10: // Average2(Average2(L, TL), Average2(T, TR)).
-				pix[p+0] += avg2(avg2(pix[p-4], pix[top-4]), avg2(pix[top+0], pix[top+4]))
-				pix[p+1] += avg2(avg2(pix[p-3], pix[top-3]), avg2(pix[top+1], pix[top+5]))
-				pix[p+2] += avg2(avg2(pix[p-2], pix[top-2]), avg2(pix[top+2], pix[top+6]))
-				pix[p+3] += avg2(avg2(pix[p-1], pix[top-1]), avg2(pix[top+3], pix[top+7]))
-
-			case 11: // Select(L, T, TL).
-				l0 := int32(pix[p-4])
-				l1 := int32(pix[p-3])
-				l2 := int32(pix[p-2])
-				l3 := int32(pix[p-1])
-				c0 := int32(pix[top-4])
-				c1 := int32(pix[top-3])
-				c2 := int32(pix[top-2])
-				c3 := int32(pix[top-1])
-				t0 := int32(pix[top+0])
-				t1 := int32(pix[top+1])
-				t2 := int32(pix[top+2])
-				t3 := int32(pix[top+3])
-				l := abs(c0-t0) + abs(c1-t1) + abs(c2-t2) + abs(c3-t3)
-				t := abs(c0-l0) + abs(c1-l1) + abs(c2-l2) + abs(c3-l3)
-				if l < t {
-					pix[p+0] += uint8(l0)
-					pix[p+1] += uint8(l1)
-					pix[p+2] += uint8(l2)
-					pix[p+3] += uint8(l3)
-				} else {
-					pix[p+0] += uint8(t0)
-					pix[p+1] += uint8(t1)
-					pix[p+2] += uint8(t2)
-					pix[p+3] += uint8(t3)
-				}
-
-			case 12: // ClampAddSubtractFull(L, T, TL).
-				pix[p+0] += clampAddSubtractFull(pix[p-4], pix[top+0], pix[top-4])
-				pix[p+1] += clampAddSubtractFull(pix[p-3], pix[top+1], pix[top-3])
-				pix[p+2] += clampAddSubtractFull(pix[p-2], pix[top+2], pix[top-2])
-				pix[p+3] += clampAddSubtractFull(pix[p-1], pix[top+3], pix[top-1])
-
-			case 13: // ClampAddSubtractHalf(Average2(L, T), TL).
-				pix[p+0] += clampAddSubtractHalf(avg2(pix[p-4], pix[top+0]), pix[top-4])
-				pix[p+1] += clampAddSubtractHalf(avg2(pix[p-3], pix[top+1]), pix[top-3])
-				pix[p+2] += clampAddSubtractHalf(avg2(pix[p-2], pix[top+2]), pix[top-2])
-				pix[p+3] += clampAddSubtractHalf(avg2(pix[p-1], pix[top+3]), pix[top-1])
-			}
-			p, top = p+4, top+4
-		}
-	}
-	return pix
-}
-
-func inverseCrossColor(t *transform, pix []byte, h int32) []byte {
-	var greenToRed, greenToBlue, redToBlue int32
-	p, mask, tilesPerRow := int32(0), int32(1)<<t.bits-1, nTiles(t.oldWidth, t.bits)
-	for y := int32(0); y < h; y++ {
-		q := 4 * (y >> t.bits) * tilesPerRow
-		for x := int32(0); x < t.oldWidth; x++ {
-			if x&mask == 0 {
-				redToBlue = int32(int8(t.pix[q+0]))
-				greenToBlue = int32(int8(t.pix[q+1]))
-				greenToRed = int32(int8(t.pix[q+2]))
-				q += 4
-			}
-			red := pix[p+0]
-			green := pix[p+1]
-			blue := pix[p+2]
-			red += uint8(uint32(greenToRed*int32(int8(green))) >> 5)
-			blue += uint8(uint32(greenToBlue*int32(int8(green))) >> 5)
-			blue += uint8(uint32(redToBlue*int32(int8(red))) >> 5)
-			pix[p+0] = red
-			pix[p+2] = blue
-			p += 4
-		}
-	}
-	return pix
-}
-
-func inverseSubtractGreen(t *transform, pix []byte, h int32) []byte {
-	for p := 0; p < len(pix); p += 4 {
-		green := pix[p+1]
-		pix[p+0] += green
-		pix[p+2] += green
-	}
-	return pix
-}
-
-func inverseColorIndexing(t *transform, pix []byte, h int32) []byte {
-	if t.bits == 0 {
-		for p := 0; p < len(pix); p += 4 {
-			i := 4 * uint32(pix[p+1])
-			pix[p+0] = t.pix[i+0]
-			pix[p+1] = t.pix[i+1]
-			pix[p+2] = t.pix[i+2]
-			pix[p+3] = t.pix[i+3]
-		}
-		return pix
-	}
-
-	vMask, xMask, bitsPerPixel := uint32(0), int32(0), uint32(8>>t.bits)
-	switch t.bits {
-	case 1:
-		vMask, xMask = 0x0f, 0x01
-	case 2:
-		vMask, xMask = 0x03, 0x03
-	case 3:
-		vMask, xMask = 0x01, 0x07
-	}
-
-	d, p, v, dst := 0, 0, uint32(0), make([]byte, 4*t.oldWidth*h)
-	for y := int32(0); y < h; y++ {
-		for x := int32(0); x < t.oldWidth; x++ {
-			if x&xMask == 0 {
-				v = uint32(pix[p+1])
-				p += 4
-			}
-
-			i := 4 * (v & vMask)
-			dst[d+0] = t.pix[i+0]
-			dst[d+1] = t.pix[i+1]
-			dst[d+2] = t.pix[i+2]
-			dst[d+3] = t.pix[i+3]
-			d += 4
-
-			v >>= bitsPerPixel
-		}
-	}
-	return dst
-}
-
-func abs(x int32) int32 {
-	if x < 0 {
-		return -x
-	}
-	return x
-}
-
-func avg2(a, b uint8) uint8 {
-	return uint8((int32(a) + int32(b)) / 2)
-}
-
-func clampAddSubtractFull(a, b, c uint8) uint8 {
-	x := int32(a) + int32(b) - int32(c)
-	if x < 0 {
-		return 0
-	}
-	if x > 255 {
-		return 255
-	}
-	return uint8(x)
-}
-
-func clampAddSubtractHalf(a, b uint8) uint8 {
-	x := int32(a) + (int32(a)-int32(b))/2
-	if x < 0 {
-		return 0
-	}
-	if x > 255 {
-		return 255
-	}
-	return uint8(x)
-}