// 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
 }