aboutsummaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/image/webp
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/webp
parent54eb169e8fc9bc0357139e7c259e977b184f8fbb (diff)
mod tidy
Diffstat (limited to 'vendor/golang.org/x/image/webp')
-rw-r--r--vendor/golang.org/x/image/webp/decode.go272
-rw-r--r--vendor/golang.org/x/image/webp/nycbcra/nycbcra.go194
-rw-r--r--vendor/golang.org/x/image/webp/webp.go30
3 files changed, 0 insertions, 496 deletions
diff --git a/vendor/golang.org/x/image/webp/decode.go b/vendor/golang.org/x/image/webp/decode.go
deleted file mode 100644
index 111f358..0000000
--- a/vendor/golang.org/x/image/webp/decode.go
+++ /dev/null
@@ -1,272 +0,0 @@
-// 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.
-
-// +build go1.6
-
-package webp
-
-import (
- "bytes"
- "errors"
- "image"
- "image/color"
- "io"
-
- "golang.org/x/image/riff"
- "golang.org/x/image/vp8"
- "golang.org/x/image/vp8l"
-)
-
-var errInvalidFormat = errors.New("webp: invalid format")
-
-var (
- fccALPH = riff.FourCC{'A', 'L', 'P', 'H'}
- fccVP8 = riff.FourCC{'V', 'P', '8', ' '}
- fccVP8L = riff.FourCC{'V', 'P', '8', 'L'}
- fccVP8X = riff.FourCC{'V', 'P', '8', 'X'}
- fccWEBP = riff.FourCC{'W', 'E', 'B', 'P'}
-)
-
-func decode(r io.Reader, configOnly bool) (image.Image, image.Config, error) {
- formType, riffReader, err := riff.NewReader(r)
- if err != nil {
- return nil, image.Config{}, err
- }
- if formType != fccWEBP {
- return nil, image.Config{}, errInvalidFormat
- }
-
- var (
- alpha []byte
- alphaStride int
- wantAlpha bool
- widthMinusOne uint32
- heightMinusOne uint32
- buf [10]byte
- )
- for {
- chunkID, chunkLen, chunkData, err := riffReader.Next()
- if err == io.EOF {
- err = errInvalidFormat
- }
- if err != nil {
- return nil, image.Config{}, err
- }
-
- switch chunkID {
- case fccALPH:
- if !wantAlpha {
- return nil, image.Config{}, errInvalidFormat
- }
- wantAlpha = false
- // Read the Pre-processing | Filter | Compression byte.
- if _, err := io.ReadFull(chunkData, buf[:1]); err != nil {
- if err == io.EOF {
- err = errInvalidFormat
- }
- return nil, image.Config{}, err
- }
- alpha, alphaStride, err = readAlpha(chunkData, widthMinusOne, heightMinusOne, buf[0]&0x03)
- if err != nil {
- return nil, image.Config{}, err
- }
- unfilterAlpha(alpha, alphaStride, (buf[0]>>2)&0x03)
-
- case fccVP8:
- if wantAlpha || int32(chunkLen) < 0 {
- return nil, image.Config{}, errInvalidFormat
- }
- d := vp8.NewDecoder()
- d.Init(chunkData, int(chunkLen))
- fh, err := d.DecodeFrameHeader()
- if err != nil {
- return nil, image.Config{}, err
- }
- if configOnly {
- return nil, image.Config{
- ColorModel: color.YCbCrModel,
- Width: fh.Width,
- Height: fh.Height,
- }, nil
- }
- m, err := d.DecodeFrame()
- if err != nil {
- return nil, image.Config{}, err
- }
- if alpha != nil {
- return &image.NYCbCrA{
- YCbCr: *m,
- A: alpha,
- AStride: alphaStride,
- }, image.Config{}, nil
- }
- return m, image.Config{}, nil
-
- case fccVP8L:
- if wantAlpha || alpha != nil {
- return nil, image.Config{}, errInvalidFormat
- }
- if configOnly {
- c, err := vp8l.DecodeConfig(chunkData)
- return nil, c, err
- }
- m, err := vp8l.Decode(chunkData)
- return m, image.Config{}, err
-
- case fccVP8X:
- if chunkLen != 10 {
- return nil, image.Config{}, errInvalidFormat
- }
- if _, err := io.ReadFull(chunkData, buf[:10]); err != nil {
- return nil, image.Config{}, err
- }
- const (
- animationBit = 1 << 1
- xmpMetadataBit = 1 << 2
- exifMetadataBit = 1 << 3
- alphaBit = 1 << 4
- iccProfileBit = 1 << 5
- )
- if buf[0] != alphaBit {
- return nil, image.Config{}, errors.New("webp: non-Alpha VP8X is not implemented")
- }
- widthMinusOne = uint32(buf[4]) | uint32(buf[5])<<8 | uint32(buf[6])<<16
- heightMinusOne = uint32(buf[7]) | uint32(buf[8])<<8 | uint32(buf[9])<<16
- if configOnly {
- return nil, image.Config{
- ColorModel: color.NYCbCrAModel,
- Width: int(widthMinusOne) + 1,
- Height: int(heightMinusOne) + 1,
- }, nil
- }
- wantAlpha = true
-
- default:
- return nil, image.Config{}, errInvalidFormat
- }
- }
-}
-
-func readAlpha(chunkData io.Reader, widthMinusOne, heightMinusOne uint32, compression byte) (
- alpha []byte, alphaStride int, err error) {
-
- switch compression {
- case 0:
- w := int(widthMinusOne) + 1
- h := int(heightMinusOne) + 1
- alpha = make([]byte, w*h)
- if _, err := io.ReadFull(chunkData, alpha); err != nil {
- return nil, 0, err
- }
- return alpha, w, nil
-
- case 1:
- // Read the VP8L-compressed alpha values. First, synthesize a 5-byte VP8L header:
- // a 1-byte magic number, a 14-bit widthMinusOne, a 14-bit heightMinusOne,
- // a 1-bit (ignored, zero) alphaIsUsed and a 3-bit (zero) version.
- // TODO(nigeltao): be more efficient than decoding an *image.NRGBA just to
- // extract the green values to a separately allocated []byte. Fixing this
- // will require changes to the vp8l package's API.
- if widthMinusOne > 0x3fff || heightMinusOne > 0x3fff {
- return nil, 0, errors.New("webp: invalid format")
- }
- alphaImage, err := vp8l.Decode(io.MultiReader(
- bytes.NewReader([]byte{
- 0x2f, // VP8L magic number.
- uint8(widthMinusOne),
- uint8(widthMinusOne>>8) | uint8(heightMinusOne<<6),
- uint8(heightMinusOne >> 2),
- uint8(heightMinusOne >> 10),
- }),
- chunkData,
- ))
- if err != nil {
- return nil, 0, err
- }
- // The green values of the inner NRGBA image are the alpha values of the
- // outer NYCbCrA image.
- pix := alphaImage.(*image.NRGBA).Pix
- alpha = make([]byte, len(pix)/4)
- for i := range alpha {
- alpha[i] = pix[4*i+1]
- }
- return alpha, int(widthMinusOne) + 1, nil
- }
- return nil, 0, errInvalidFormat
-}
-
-func unfilterAlpha(alpha []byte, alphaStride int, filter byte) {
- if len(alpha) == 0 || alphaStride == 0 {
- return
- }
- switch filter {
- case 1: // Horizontal filter.
- for i := 1; i < alphaStride; i++ {
- alpha[i] += alpha[i-1]
- }
- for i := alphaStride; i < len(alpha); i += alphaStride {
- // The first column is equivalent to the vertical filter.
- alpha[i] += alpha[i-alphaStride]
-
- for j := 1; j < alphaStride; j++ {
- alpha[i+j] += alpha[i+j-1]
- }
- }
-
- case 2: // Vertical filter.
- // The first row is equivalent to the horizontal filter.
- for i := 1; i < alphaStride; i++ {
- alpha[i] += alpha[i-1]
- }
-
- for i := alphaStride; i < len(alpha); i++ {
- alpha[i] += alpha[i-alphaStride]
- }
-
- case 3: // Gradient filter.
- // The first row is equivalent to the horizontal filter.
- for i := 1; i < alphaStride; i++ {
- alpha[i] += alpha[i-1]
- }
-
- for i := alphaStride; i < len(alpha); i += alphaStride {
- // The first column is equivalent to the vertical filter.
- alpha[i] += alpha[i-alphaStride]
-
- // The interior is predicted on the three top/left pixels.
- for j := 1; j < alphaStride; j++ {
- c := int(alpha[i+j-alphaStride-1])
- b := int(alpha[i+j-alphaStride])
- a := int(alpha[i+j-1])
- x := a + b - c
- if x < 0 {
- x = 0
- } else if x > 255 {
- x = 255
- }
- alpha[i+j] += uint8(x)
- }
- }
- }
-}
-
-// Decode reads a WEBP image from r and returns it as an image.Image.
-func Decode(r io.Reader) (image.Image, error) {
- m, _, err := decode(r, false)
- if err != nil {
- return nil, err
- }
- return m, err
-}
-
-// DecodeConfig returns the color model and dimensions of a WEBP image without
-// decoding the entire image.
-func DecodeConfig(r io.Reader) (image.Config, error) {
- _, c, err := decode(r, true)
- return c, err
-}
-
-func init() {
- image.RegisterFormat("webp", "RIFF????WEBPVP8", Decode, DecodeConfig)
-}
diff --git a/vendor/golang.org/x/image/webp/nycbcra/nycbcra.go b/vendor/golang.org/x/image/webp/nycbcra/nycbcra.go
deleted file mode 100644
index 101c41f..0000000
--- a/vendor/golang.org/x/image/webp/nycbcra/nycbcra.go
+++ /dev/null
@@ -1,194 +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 nycbcra provides non-alpha-premultiplied Y'CbCr-with-alpha image and
-// color types.
-//
-// Deprecated: as of Go 1.6. Use the standard image and image/color packages
-// instead.
-package nycbcra // import "golang.org/x/image/webp/nycbcra"
-
-import (
- "image"
- "image/color"
-)
-
-func init() {
- println("The golang.org/x/image/webp/nycbcra package is deprecated, as of Go 1.6. " +
- "Use the standard image and image/color packages instead.")
-}
-
-// TODO: move this to the standard image and image/color packages, so that the
-// image/draw package can have fast-path code. Moving would rename:
-// nycbcra.Color to color.NYCbCrA
-// nycbcra.ColorModel to color.NYCbCrAModel
-// nycbcra.Image to image.NYCbCrA
-
-// Color represents a non-alpha-premultiplied Y'CbCr-with-alpha color, having
-// 8 bits each for one luma, two chroma and one alpha component.
-type Color struct {
- color.YCbCr
- A uint8
-}
-
-func (c Color) RGBA() (r, g, b, a uint32) {
- r8, g8, b8 := color.YCbCrToRGB(c.Y, c.Cb, c.Cr)
- a = uint32(c.A) * 0x101
- r = uint32(r8) * 0x101 * a / 0xffff
- g = uint32(g8) * 0x101 * a / 0xffff
- b = uint32(b8) * 0x101 * a / 0xffff
- return
-}
-
-// ColorModel is the Model for non-alpha-premultiplied Y'CbCr-with-alpha colors.
-var ColorModel color.Model = color.ModelFunc(nYCbCrAModel)
-
-func nYCbCrAModel(c color.Color) color.Color {
- switch c := c.(type) {
- case Color:
- return c
- case color.YCbCr:
- return Color{c, 0xff}
- }
- r, g, b, a := c.RGBA()
-
- // Convert from alpha-premultiplied to non-alpha-premultiplied.
- if a != 0 {
- r = (r * 0xffff) / a
- g = (g * 0xffff) / a
- b = (b * 0xffff) / a
- }
-
- y, u, v := color.RGBToYCbCr(uint8(r>>8), uint8(g>>8), uint8(b>>8))
- return Color{color.YCbCr{Y: y, Cb: u, Cr: v}, uint8(a >> 8)}
-}
-
-// Image is an in-memory image of non-alpha-premultiplied Y'CbCr-with-alpha
-// colors. A and AStride are analogous to the Y and YStride fields of the
-// embedded YCbCr.
-type Image struct {
- image.YCbCr
- A []uint8
- AStride int
-}
-
-func (p *Image) ColorModel() color.Model {
- return ColorModel
-}
-
-func (p *Image) At(x, y int) color.Color {
- return p.NYCbCrAAt(x, y)
-}
-
-func (p *Image) NYCbCrAAt(x, y int) Color {
- if !(image.Point{X: x, Y: y}.In(p.Rect)) {
- return Color{}
- }
- yi := p.YOffset(x, y)
- ci := p.COffset(x, y)
- ai := p.AOffset(x, y)
- return Color{
- color.YCbCr{
- Y: p.Y[yi],
- Cb: p.Cb[ci],
- Cr: p.Cr[ci],
- },
- p.A[ai],
- }
-}
-
-// AOffset returns the index of the first element of A that corresponds to
-// the pixel at (x, y).
-func (p *Image) AOffset(x, y int) int {
- return (y-p.Rect.Min.Y)*p.AStride + (x - p.Rect.Min.X)
-}
-
-// SubImage returns an image representing the portion of the image p visible
-// through r. The returned value shares pixels with the original image.
-func (p *Image) SubImage(r image.Rectangle) image.Image {
- // TODO: share code with image.NewYCbCr when this type moves into the
- // standard image package.
- r = r.Intersect(p.Rect)
- // If r1 and r2 are Rectangles, r1.Intersect(r2) is not guaranteed to be inside
- // either r1 or r2 if the intersection is empty. Without explicitly checking for
- // this, the Pix[i:] expression below can panic.
- if r.Empty() {
- return &Image{
- YCbCr: image.YCbCr{
- SubsampleRatio: p.SubsampleRatio,
- },
- }
- }
- yi := p.YOffset(r.Min.X, r.Min.Y)
- ci := p.COffset(r.Min.X, r.Min.Y)
- ai := p.AOffset(r.Min.X, r.Min.Y)
- return &Image{
- YCbCr: image.YCbCr{
- Y: p.Y[yi:],
- Cb: p.Cb[ci:],
- Cr: p.Cr[ci:],
- SubsampleRatio: p.SubsampleRatio,
- YStride: p.YStride,
- CStride: p.CStride,
- Rect: r,
- },
- A: p.A[ai:],
- AStride: p.AStride,
- }
-}
-
-// Opaque scans the entire image and reports whether it is fully opaque.
-func (p *Image) Opaque() bool {
- if p.Rect.Empty() {
- return true
- }
- i0, i1 := 0, p.Rect.Dx()
- for y := p.Rect.Min.Y; y < p.Rect.Max.Y; y++ {
- for _, a := range p.A[i0:i1] {
- if a != 0xff {
- return false
- }
- }
- i0 += p.AStride
- i1 += p.AStride
- }
- return true
-}
-
-// New returns a new Image with the given bounds and subsample ratio.
-func New(r image.Rectangle, subsampleRatio image.YCbCrSubsampleRatio) *Image {
- // TODO: share code with image.NewYCbCr when this type moves into the
- // standard image package.
- w, h, cw, ch := r.Dx(), r.Dy(), 0, 0
- switch subsampleRatio {
- case image.YCbCrSubsampleRatio422:
- cw = (r.Max.X+1)/2 - r.Min.X/2
- ch = h
- case image.YCbCrSubsampleRatio420:
- cw = (r.Max.X+1)/2 - r.Min.X/2
- ch = (r.Max.Y+1)/2 - r.Min.Y/2
- case image.YCbCrSubsampleRatio440:
- cw = w
- ch = (r.Max.Y+1)/2 - r.Min.Y/2
- default:
- // Default to 4:4:4 subsampling.
- cw = w
- ch = h
- }
- b := make([]byte, 2*w*h+2*cw*ch)
- // TODO: use s[i:j:k] notation to set the cap.
- return &Image{
- YCbCr: image.YCbCr{
- Y: b[:w*h],
- Cb: b[w*h+0*cw*ch : w*h+1*cw*ch],
- Cr: b[w*h+1*cw*ch : w*h+2*cw*ch],
- SubsampleRatio: subsampleRatio,
- YStride: w,
- CStride: cw,
- Rect: r,
- },
- A: b[w*h+2*cw*ch:],
- AStride: w,
- }
-}
diff --git a/vendor/golang.org/x/image/webp/webp.go b/vendor/golang.org/x/image/webp/webp.go
deleted file mode 100644
index 850cdc8..0000000
--- a/vendor/golang.org/x/image/webp/webp.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2016 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 webp implements a decoder for WEBP images.
-//
-// WEBP is defined at:
-// https://developers.google.com/speed/webp/docs/riff_container
-//
-// It requires Go 1.6 or later.
-package webp // import "golang.org/x/image/webp"
-
-// This blank Go file, other than the package clause, exists so that this
-// package can be built for Go 1.5 and earlier. (The other files in this
-// package are all marked "+build go1.6" for the NYCbCrA types introduced in Go
-// 1.6). There is no functionality in a blank package, but some image
-// manipulation programs might still underscore import this package for the
-// side effect of registering the WEBP format with the standard library's
-// image.RegisterFormat and image.Decode functions. For example, that program
-// might contain:
-//
-// // Underscore imports to register some formats for image.Decode.
-// import _ "image/gif"
-// import _ "image/jpeg"
-// import _ "image/png"
-// import _ "golang.org/x/image/webp"
-//
-// Such a program will still compile for Go 1.5 (due to this placeholder Go
-// file). It will simply not be able to recognize and decode WEBP (but still
-// handle GIF, JPEG and PNG).