aboutsummaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/image/vp8l/transform.go
diff options
context:
space:
mode:
authorDimitri Sokolyuk <demon@dim13.org>2018-09-27 20:03:23 +0200
committerDimitri Sokolyuk <demon@dim13.org>2018-09-27 20:03:23 +0200
commit14bb08c1df8db9ec6c8a05520d4eee67971235d9 (patch)
treefc820e59c26ed4c5e87e65737909b47959f0faa5 /vendor/golang.org/x/image/vp8l/transform.go
parent54eb169e8fc9bc0357139e7c259e977b184f8fbb (diff)
mod tidy
Diffstat (limited to 'vendor/golang.org/x/image/vp8l/transform.go')
-rw-r--r--vendor/golang.org/x/image/vp8l/transform.go299
1 files changed, 0 insertions, 299 deletions
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)
-}