1// Copyright 2014 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// Package riff implements the Resource Interchange File Format, used by media
6// formats such as AVI, WAVE and WEBP.
7//
8// A RIFF stream contains a sequence of chunks. Each chunk consists of an 8-byte
9// header (containing a 4-byte chunk type and a 4-byte chunk length), the chunk
10// data (presented as an io.Reader), and some padding bytes.
11//
12// A detailed description of the format is at
13// http://www.tactilemedia.com/info/MCI_Control_Info.html
14package riff // import "golang.org/x/image/riff"
15
16import (
17	"errors"
18	"io"
19	"io/ioutil"
20	"math"
21)
22
23var (
24	errMissingPaddingByte     = errors.New("riff: missing padding byte")
25	errMissingRIFFChunkHeader = errors.New("riff: missing RIFF chunk header")
26	errListSubchunkTooLong    = errors.New("riff: list subchunk too long")
27	errShortChunkData         = errors.New("riff: short chunk data")
28	errShortChunkHeader       = errors.New("riff: short chunk header")
29	errStaleReader            = errors.New("riff: stale reader")
30)
31
32// u32 decodes the first four bytes of b as a little-endian integer.
33func u32(b []byte) uint32 {
34	return uint32(b[0]) | uint32(b[1])<<8 | uint32(b[2])<<16 | uint32(b[3])<<24
35}
36
37const chunkHeaderSize = 8
38
39// FourCC is a four character code.
40type FourCC [4]byte
41
42// LIST is the "LIST" FourCC.
43var LIST = FourCC{'L', 'I', 'S', 'T'}
44
45// NewReader returns the RIFF stream's form type, such as "AVI " or "WAVE", and
46// its chunks as a *Reader.
47func NewReader(r io.Reader) (formType FourCC, data *Reader, err error) {
48	var buf [chunkHeaderSize]byte
49	if _, err := io.ReadFull(r, buf[:]); err != nil {
50		if err == io.EOF || err == io.ErrUnexpectedEOF {
51			err = errMissingRIFFChunkHeader
52		}
53		return FourCC{}, nil, err
54	}
55	if buf[0] != 'R' || buf[1] != 'I' || buf[2] != 'F' || buf[3] != 'F' {
56		return FourCC{}, nil, errMissingRIFFChunkHeader
57	}
58	return NewListReader(u32(buf[4:]), r)
59}
60
61// NewListReader returns a LIST chunk's list type, such as "movi" or "wavl",
62// and its chunks as a *Reader.
63func NewListReader(chunkLen uint32, chunkData io.Reader) (listType FourCC, data *Reader, err error) {
64	if chunkLen < 4 {
65		return FourCC{}, nil, errShortChunkData
66	}
67	z := &Reader{r: chunkData}
68	if _, err := io.ReadFull(chunkData, z.buf[:4]); err != nil {
69		if err == io.EOF || err == io.ErrUnexpectedEOF {
70			err = errShortChunkData
71		}
72		return FourCC{}, nil, err
73	}
74	z.totalLen = chunkLen - 4
75	return FourCC{z.buf[0], z.buf[1], z.buf[2], z.buf[3]}, z, nil
76}
77
78// Reader reads chunks from an underlying io.Reader.
79type Reader struct {
80	r   io.Reader
81	err error
82
83	totalLen uint32
84	chunkLen uint32
85
86	chunkReader *chunkReader
87	buf         [chunkHeaderSize]byte
88	padded      bool
89}
90
91// Next returns the next chunk's ID, length and data. It returns io.EOF if there
92// are no more chunks. The io.Reader returned becomes stale after the next Next
93// call, and should no longer be used.
94//
95// It is valid to call Next even if all of the previous chunk's data has not
96// been read.
97func (z *Reader) Next() (chunkID FourCC, chunkLen uint32, chunkData io.Reader, err error) {
98	if z.err != nil {
99		return FourCC{}, 0, nil, z.err
100	}
101
102	// Drain the rest of the previous chunk.
103	if z.chunkLen != 0 {
104		want := z.chunkLen
105		var got int64
106		got, z.err = io.Copy(ioutil.Discard, z.chunkReader)
107		if z.err == nil && uint32(got) != want {
108			z.err = errShortChunkData
109		}
110		if z.err != nil {
111			return FourCC{}, 0, nil, z.err
112		}
113	}
114	z.chunkReader = nil
115	if z.padded {
116		if z.totalLen == 0 {
117			z.err = errListSubchunkTooLong
118			return FourCC{}, 0, nil, z.err
119		}
120		z.totalLen--
121		_, z.err = io.ReadFull(z.r, z.buf[:1])
122		if z.err != nil {
123			if z.err == io.EOF {
124				z.err = errMissingPaddingByte
125			}
126			return FourCC{}, 0, nil, z.err
127		}
128	}
129
130	// We are done if we have no more data.
131	if z.totalLen == 0 {
132		z.err = io.EOF
133		return FourCC{}, 0, nil, z.err
134	}
135
136	// Read the next chunk header.
137	if z.totalLen < chunkHeaderSize {
138		z.err = errShortChunkHeader
139		return FourCC{}, 0, nil, z.err
140	}
141	z.totalLen -= chunkHeaderSize
142	if _, z.err = io.ReadFull(z.r, z.buf[:chunkHeaderSize]); z.err != nil {
143		if z.err == io.EOF || z.err == io.ErrUnexpectedEOF {
144			z.err = errShortChunkHeader
145		}
146		return FourCC{}, 0, nil, z.err
147	}
148	chunkID = FourCC{z.buf[0], z.buf[1], z.buf[2], z.buf[3]}
149	z.chunkLen = u32(z.buf[4:])
150	if z.chunkLen > z.totalLen {
151		z.err = errListSubchunkTooLong
152		return FourCC{}, 0, nil, z.err
153	}
154	z.padded = z.chunkLen&1 == 1
155	z.chunkReader = &chunkReader{z}
156	return chunkID, z.chunkLen, z.chunkReader, nil
157}
158
159type chunkReader struct {
160	z *Reader
161}
162
163func (c *chunkReader) Read(p []byte) (int, error) {
164	if c != c.z.chunkReader {
165		return 0, errStaleReader
166	}
167	z := c.z
168	if z.err != nil {
169		if z.err == io.EOF {
170			return 0, errStaleReader
171		}
172		return 0, z.err
173	}
174
175	n := int(z.chunkLen)
176	if n == 0 {
177		return 0, io.EOF
178	}
179	if n < 0 {
180		// Converting uint32 to int overflowed.
181		n = math.MaxInt32
182	}
183	if n > len(p) {
184		n = len(p)
185	}
186	n, err := z.r.Read(p[:n])
187	z.totalLen -= uint32(n)
188	z.chunkLen -= uint32(n)
189	if err != io.EOF {
190		z.err = err
191	}
192	return n, err
193}
194