aboutsummaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/image/riff
diff options
context:
space:
mode:
authorTulir Asokan <tulir@maunium.net>2019-01-11 23:28:47 +0200
committerTulir Asokan <tulir@maunium.net>2019-01-11 23:28:47 +0200
commit331597b9f8a7942cbcb233a328301e4d5bf94fb0 (patch)
tree5ec624585ebf66c63549a098acb6f7421f1193a7 /vendor/golang.org/x/image/riff
parent2fc3378b717f40f37f3a188b68407887242d9c06 (diff)
Switch to Go modules and make other changes
Diffstat (limited to 'vendor/golang.org/x/image/riff')
-rw-r--r--vendor/golang.org/x/image/riff/riff.go193
1 files changed, 0 insertions, 193 deletions
diff --git a/vendor/golang.org/x/image/riff/riff.go b/vendor/golang.org/x/image/riff/riff.go
deleted file mode 100644
index 38dc0e5..0000000
--- a/vendor/golang.org/x/image/riff/riff.go
+++ /dev/null
@@ -1,193 +0,0 @@
-// 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
-}