From 14bb08c1df8db9ec6c8a05520d4eee67971235d9 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Thu, 27 Sep 2018 20:03:23 +0200 Subject: mod tidy --- vendor/golang.org/x/image/vp8l/decode.go | 603 ---------------------------- vendor/golang.org/x/image/vp8l/huffman.go | 245 ----------- vendor/golang.org/x/image/vp8l/transform.go | 299 -------------- 3 files changed, 1147 deletions(-) delete mode 100644 vendor/golang.org/x/image/vp8l/decode.go delete mode 100644 vendor/golang.org/x/image/vp8l/huffman.go delete mode 100644 vendor/golang.org/x/image/vp8l/transform.go (limited to 'vendor/golang.org/x/image/vp8l') 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 - 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<>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)< 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 -} - -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) * 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) * 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) -} -- cgit v1.2.3