| // 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. |
| |
| 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 |
| ) |
| wantAlpha = (buf[0] & alphaBit) != 0 |
| 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 { |
| if wantAlpha { |
| return nil, image.Config{ |
| ColorModel: color.NYCbCrAModel, |
| Width: int(widthMinusOne) + 1, |
| Height: int(heightMinusOne) + 1, |
| }, nil |
| } |
| return nil, image.Config{ |
| ColorModel: color.YCbCrModel, |
| Width: int(widthMinusOne) + 1, |
| Height: int(heightMinusOne) + 1, |
| }, nil |
| } |
| } |
| } |
| } |
| |
| 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) |
| } |