golang-image/webp/decode.go

215 lines
6.2 KiB
Go
Raw Normal View History

// 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 implements a decoder for WEBP images.
//
// WEBP is defined at:
// https://developers.google.com/speed/webp/docs/riff_container
package webp
import (
"bytes"
"errors"
"image"
"image/color"
"io"
"code.google.com/p/go.image/vp8"
"code.google.com/p/go.image/vp8l"
"code.google.com/p/go.image/webp/nycbcra"
)
// roundUp2 rounds u up to an even number.
// https://developers.google.com/speed/webp/docs/riff_container#riff_file_format
// says that "If Chunk Size is odd, a single padding byte... is added."
func roundUp2(u uint32) uint32 {
return u + u&1
}
const (
formatVP8 = 1
formatVP8L = 2
formatVP8X = 3
)
func decode(r io.Reader, configOnly bool) (image.Image, image.Config, error) {
var b [20]byte
if _, err := io.ReadFull(r, b[:]); err != nil {
return nil, image.Config{}, err
}
format := 0
switch string(b[8:16]) {
case "WEBPVP8 ":
format = formatVP8
case "WEBPVP8L":
format = formatVP8L
case "WEBPVP8X":
format = formatVP8X
}
if string(b[:4]) != "RIFF" || format == 0 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
riffLen := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24
dataLen := roundUp2(uint32(b[16]) | uint32(b[17])<<8 | uint32(b[18])<<16 | uint32(b[19])<<24)
if riffLen < dataLen+12 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
if dataLen == 0 || dataLen >= 1<<31 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
if format == formatVP8L {
r = &io.LimitedReader{R: r, N: int64(dataLen)}
if configOnly {
c, err := vp8l.DecodeConfig(r)
return nil, c, err
}
m, err := vp8l.Decode(r)
return m, image.Config{}, err
}
var (
alpha []byte
alphaStride int
)
if format == formatVP8X {
if dataLen != 10 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
if _, err := io.ReadFull(r, b[: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 b[0] != alphaBit {
return nil, image.Config{}, errors.New("webp: non-Alpha VP8X is not implemented")
}
widthMinusOne := uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16
heightMinusOne := uint32(b[7]) | uint32(b[8])<<8 | uint32(b[9])<<16
if configOnly {
return nil, image.Config{
ColorModel: nycbcra.ColorModel,
Width: int(widthMinusOne) + 1,
Height: int(heightMinusOne) + 1,
}, nil
}
// Read the 8-byte chunk header plus the mandatory PFC (Pre-processing,
// Filter, Compression) byte.
if _, err := io.ReadFull(r, b[:9]); err != nil {
return nil, image.Config{}, err
}
if b[0] != 'A' || b[1] != 'L' || b[2] != 'P' || b[3] != 'H' {
return nil, image.Config{}, errors.New("webp: invalid format")
}
chunkLen := roundUp2(uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24)
// Subtract one byte from chunkLen, since we've already read the PFC byte.
if chunkLen == 0 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
chunkLen--
filter := (b[8] >> 2) & 0x03
if filter != 0 {
return nil, image.Config{}, errors.New("webp: VP8X Alpha filtering != 0 is not implemented")
}
compression := b[8] & 0x03
if compression != 1 {
return nil, image.Config{}, errors.New("webp: VP8X Alpha compression != 1 is not implemented")
}
// 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, image.Config{}, errors.New("webp: invalid format")
}
b[0] = 0x2f // VP8L magic number.
b[1] = uint8(widthMinusOne)
b[2] = uint8(widthMinusOne>>8) | uint8(heightMinusOne<<6)
b[3] = uint8(heightMinusOne >> 2)
b[4] = uint8(heightMinusOne >> 10)
alphaImage, err := vp8l.Decode(io.MultiReader(
bytes.NewReader(b[:5]),
&io.LimitedReader{R: r, N: int64(chunkLen)},
))
if err != nil {
return nil, image.Config{}, 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]
}
alphaStride = int(widthMinusOne) + 1
// The rest of the image should be in the lossy format. Check the "VP8 "
// header and fall through.
if _, err := io.ReadFull(r, b[:8]); err != nil {
return nil, image.Config{}, err
}
if b[0] != 'V' || b[1] != 'P' || b[2] != '8' || b[3] != ' ' {
return nil, image.Config{}, errors.New("webp: invalid format")
}
dataLen = roundUp2(uint32(b[4]) | uint32(b[5])<<8 | uint32(b[6])<<16 | uint32(b[7])<<24)
if dataLen == 0 || dataLen >= 1<<31 {
return nil, image.Config{}, errors.New("webp: invalid format")
}
}
d := vp8.NewDecoder()
d.Init(r, int(dataLen))
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 &nycbcra.Image{
YCbCr: *m,
A: alpha,
AStride: alphaStride,
}, image.Config{}, nil
}
return m, image.Config{}, nil
}
// 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)
}