| // 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 riff implements the Resource Interchange File Format, used by media |
| // formats such as AVI, WAVE and WEBP. |
| // |
| // A RIFF stream contains a sequence of chunks. Each chunk consists of an 8-byte |
| // header (containing a 4-byte chunk type and a 4-byte chunk length), the chunk |
| // data (presented as an io.Reader), and some padding bytes. |
| // |
| // A detailed description of the format is at |
| // http://www.tactilemedia.com/info/MCI_Control_Info.html |
| package riff // import "golang.org/x/image/riff" |
| |
| import ( |
| "errors" |
| "io" |
| "io/ioutil" |
| "math" |
| ) |
| |
| var ( |
| errMissingPaddingByte = errors.New("riff: missing padding byte") |
| errMissingRIFFChunkHeader = errors.New("riff: missing RIFF chunk header") |
| errListSubchunkTooLong = errors.New("riff: list subchunk too long") |
| errShortChunkData = errors.New("riff: short chunk data") |
| errShortChunkHeader = errors.New("riff: short chunk header") |
| errStaleReader = errors.New("riff: stale reader") |
| ) |
| |
| // u32 decodes the first four bytes of b as a little-endian integer. |
| func u32(b []byte) uint32 { |
| return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24 |
| } |
| |
| const chunkHeaderSize = 8 |
| |
| // FourCC is a four character code. |
| type FourCC [4]byte |
| |
| // LIST is the "LIST" FourCC. |
| var LIST = FourCC{'L', 'I', 'S', 'T'} |
| |
| // NewReader returns the RIFF stream's form type, such as "AVI " or "WAVE", and |
| // its chunks as a *Reader. |
| func NewReader(r io.Reader) (formType FourCC, data *Reader, err error) { |
| var buf [chunkHeaderSize]byte |
| if _, err := io.ReadFull(r, buf[:]); err != nil { |
| if err == io.EOF || err == io.ErrUnexpectedEOF { |
| err = errMissingRIFFChunkHeader |
| } |
| return FourCC{}, nil, err |
| } |
| if buf[0] != 'R' || buf[1] != 'I' || buf[2] != 'F' || buf[3] != 'F' { |
| return FourCC{}, nil, errMissingRIFFChunkHeader |
| } |
| return NewListReader(u32(buf[4:]), r) |
| } |
| |
| // NewListReader returns a LIST chunk's list type, such as "movi" or "wavl", |
| // and its chunks as a *Reader. |
| func NewListReader(chunkLen uint32, chunkData io.Reader) (listType FourCC, data *Reader, err error) { |
| if chunkLen < 4 { |
| return FourCC{}, nil, errShortChunkData |
| } |
| z := &Reader{r: chunkData} |
| if _, err := io.ReadFull(chunkData, z.buf[:4]); err != nil { |
| if err == io.EOF || err == io.ErrUnexpectedEOF { |
| err = errShortChunkData |
| } |
| return FourCC{}, nil, err |
| } |
| z.totalLen = chunkLen - 4 |
| return FourCC{z.buf[0], z.buf[1], z.buf[2], z.buf[3]}, z, nil |
| } |
| |
| // Reader reads chunks from an underlying io.Reader. |
| type Reader struct { |
| r io.Reader |
| err error |
| |
| totalLen uint32 |
| chunkLen uint32 |
| |
| chunkReader *chunkReader |
| buf [chunkHeaderSize]byte |
| padded bool |
| } |
| |
| // Next returns the next chunk's ID, length and data. It returns io.EOF if there |
| // are no more chunks. The io.Reader returned becomes stale after the next Next |
| // call, and should no longer be used. |
| // |
| // It is valid to call Next even if all of the previous chunk's data has not |
| // been read. |
| func (z *Reader) Next() (chunkID FourCC, chunkLen uint32, chunkData io.Reader, err error) { |
| if z.err != nil { |
| return FourCC{}, 0, nil, z.err |
| } |
| |
| // Drain the rest of the previous chunk. |
| if z.chunkLen != 0 { |
| want := z.chunkLen |
| var got int64 |
| got, z.err = io.Copy(ioutil.Discard, z.chunkReader) |
| if z.err == nil && uint32(got) != want { |
| z.err = errShortChunkData |
| } |
| if z.err != nil { |
| return FourCC{}, 0, nil, z.err |
| } |
| } |
| z.chunkReader = nil |
| if z.padded { |
| if z.totalLen == 0 { |
| z.err = errListSubchunkTooLong |
| return FourCC{}, 0, nil, z.err |
| } |
| z.totalLen-- |
| _, z.err = io.ReadFull(z.r, z.buf[:1]) |
| if z.err != nil { |
| if z.err == io.EOF { |
| z.err = errMissingPaddingByte |
| } |
| return FourCC{}, 0, nil, z.err |
| } |
| } |
| |
| // We are done if we have no more data. |
| if z.totalLen == 0 { |
| z.err = io.EOF |
| return FourCC{}, 0, nil, z.err |
| } |
| |
| // Read the next chunk header. |
| if z.totalLen < chunkHeaderSize { |
| z.err = errShortChunkHeader |
| return FourCC{}, 0, nil, z.err |
| } |
| z.totalLen -= chunkHeaderSize |
| if _, z.err = io.ReadFull(z.r, z.buf[:chunkHeaderSize]); z.err != nil { |
| if z.err == io.EOF || z.err == io.ErrUnexpectedEOF { |
| z.err = errShortChunkHeader |
| } |
| return FourCC{}, 0, nil, z.err |
| } |
| chunkID = FourCC{z.buf[0], z.buf[1], z.buf[2], z.buf[3]} |
| z.chunkLen = u32(z.buf[4:]) |
| if z.chunkLen > z.totalLen { |
| z.err = errListSubchunkTooLong |
| return FourCC{}, 0, nil, z.err |
| } |
| z.padded = z.chunkLen&1 == 1 |
| z.chunkReader = &chunkReader{z} |
| return chunkID, z.chunkLen, z.chunkReader, nil |
| } |
| |
| type chunkReader struct { |
| z *Reader |
| } |
| |
| func (c *chunkReader) Read(p []byte) (int, error) { |
| if c != c.z.chunkReader { |
| return 0, errStaleReader |
| } |
| z := c.z |
| if z.err != nil { |
| if z.err == io.EOF { |
| return 0, errStaleReader |
| } |
| return 0, z.err |
| } |
| |
| n := int(z.chunkLen) |
| if n == 0 { |
| return 0, io.EOF |
| } |
| if n < 0 { |
| // Converting uint32 to int overflowed. |
| n = math.MaxInt32 |
| } |
| if n > len(p) { |
| n = len(p) |
| } |
| n, err := z.r.Read(p[:n]) |
| z.totalLen -= uint32(n) |
| z.chunkLen -= uint32(n) |
| if err != io.EOF { |
| z.err = err |
| } |
| return n, err |
| } |