gtsocial-umbx

reader.go (27028B)

---

 // Copyright 2011 The Snappy-Go Authors. All rights reserved.
 // Copyright (c) 2019+ Klaus Post. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package s2
 
 import (
 	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"math"
 	"runtime"
 	"sync"
 )
 
 // ErrCantSeek is returned if the stream cannot be seeked.
 type ErrCantSeek struct {
 	Reason string
 }
 
 // Error returns the error as string.
 func (e ErrCantSeek) Error() string {
 	return fmt.Sprintf("s2: Can't seek because %s", e.Reason)
 }
 
 // NewReader returns a new Reader that decompresses from r, using the framing
 // format described at
 // https://github.com/google/snappy/blob/master/framing_format.txt with S2 changes.
 func NewReader(r io.Reader, opts ...ReaderOption) *Reader {
 	nr := Reader{
 		r:        r,
 		maxBlock: maxBlockSize,
 	}
 	for _, opt := range opts {
 		if err := opt(&nr); err != nil {
 			nr.err = err
 			return &nr
 		}
 	}
 	nr.maxBufSize = MaxEncodedLen(nr.maxBlock) + checksumSize
 	if nr.lazyBuf > 0 {
 		nr.buf = make([]byte, MaxEncodedLen(nr.lazyBuf)+checksumSize)
 	} else {
 		nr.buf = make([]byte, MaxEncodedLen(defaultBlockSize)+checksumSize)
 	}
 	nr.readHeader = nr.ignoreStreamID
 	nr.paramsOK = true
 	return &nr
 }
 
 // ReaderOption is an option for creating a decoder.
 type ReaderOption func(*Reader) error
 
 // ReaderMaxBlockSize allows to control allocations if the stream
 // has been compressed with a smaller WriterBlockSize, or with the default 1MB.
 // Blocks must be this size or smaller to decompress,
 // otherwise the decoder will return ErrUnsupported.
 //
 // For streams compressed with Snappy this can safely be set to 64KB (64 << 10).
 //
 // Default is the maximum limit of 4MB.
 func ReaderMaxBlockSize(blockSize int) ReaderOption {
 	return func(r *Reader) error {
 		if blockSize > maxBlockSize || blockSize <= 0 {
 			return errors.New("s2: block size too large. Must be <= 4MB and > 0")
 		}
 		if r.lazyBuf == 0 && blockSize < defaultBlockSize {
 			r.lazyBuf = blockSize
 		}
 		r.maxBlock = blockSize
 		return nil
 	}
 }
 
 // ReaderAllocBlock allows to control upfront stream allocations
 // and not allocate for frames bigger than this initially.
 // If frames bigger than this is seen a bigger buffer will be allocated.
 //
 // Default is 1MB, which is default output size.
 func ReaderAllocBlock(blockSize int) ReaderOption {
 	return func(r *Reader) error {
 		if blockSize > maxBlockSize || blockSize < 1024 {
 			return errors.New("s2: invalid ReaderAllocBlock. Must be <= 4MB and >= 1024")
 		}
 		r.lazyBuf = blockSize
 		return nil
 	}
 }
 
 // ReaderIgnoreStreamIdentifier will make the reader skip the expected
 // stream identifier at the beginning of the stream.
 // This can be used when serving a stream that has been forwarded to a specific point.
 func ReaderIgnoreStreamIdentifier() ReaderOption {
 	return func(r *Reader) error {
 		r.ignoreStreamID = true
 		return nil
 	}
 }
 
 // ReaderSkippableCB will register a callback for chuncks with the specified ID.
 // ID must be a Reserved skippable chunks ID, 0x80-0xfd (inclusive).
 // For each chunk with the ID, the callback is called with the content.
 // Any returned non-nil error will abort decompression.
 // Only one callback per ID is supported, latest sent will be used.
 func ReaderSkippableCB(id uint8, fn func(r io.Reader) error) ReaderOption {
 	return func(r *Reader) error {
 		if id < 0x80 || id > 0xfd {
 			return fmt.Errorf("ReaderSkippableCB: Invalid id provided, must be 0x80-0xfd (inclusive)")
 		}
 		r.skippableCB[id] = fn
 		return nil
 	}
 }
 
 // ReaderIgnoreCRC will make the reader skip CRC calculation and checks.
 func ReaderIgnoreCRC() ReaderOption {
 	return func(r *Reader) error {
 		r.ignoreCRC = true
 		return nil
 	}
 }
 
 // Reader is an io.Reader that can read Snappy-compressed bytes.
 type Reader struct {
 	r           io.Reader
 	err         error
 	decoded     []byte
 	buf         []byte
 	skippableCB [0x80]func(r io.Reader) error
 	blockStart  int64 // Uncompressed offset at start of current.
 	index       *Index
 
 	// decoded[i:j] contains decoded bytes that have not yet been passed on.
 	i, j int
 	// maximum block size allowed.
 	maxBlock int
 	// maximum expected buffer size.
 	maxBufSize int
 	// alloc a buffer this size if > 0.
 	lazyBuf        int
 	readHeader     bool
 	paramsOK       bool
 	snappyFrame    bool
 	ignoreStreamID bool
 	ignoreCRC      bool
 }
 
 // ensureBufferSize will ensure that the buffer can take at least n bytes.
 // If false is returned the buffer exceeds maximum allowed size.
 func (r *Reader) ensureBufferSize(n int) bool {
 	if n > r.maxBufSize {
 		r.err = ErrCorrupt
 		return false
 	}
 	if cap(r.buf) >= n {
 		return true
 	}
 	// Realloc buffer.
 	r.buf = make([]byte, n)
 	return true
 }
 
 // Reset discards any buffered data, resets all state, and switches the Snappy
 // reader to read from r. This permits reusing a Reader rather than allocating
 // a new one.
 func (r *Reader) Reset(reader io.Reader) {
 	if !r.paramsOK {
 		return
 	}
 	r.index = nil
 	r.r = reader
 	r.err = nil
 	r.i = 0
 	r.j = 0
 	r.blockStart = 0
 	r.readHeader = r.ignoreStreamID
 }
 
 func (r *Reader) readFull(p []byte, allowEOF bool) (ok bool) {
 	if _, r.err = io.ReadFull(r.r, p); r.err != nil {
 		if r.err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
 			r.err = ErrCorrupt
 		}
 		return false
 	}
 	return true
 }
 
 // skippable will skip n bytes.
 // If the supplied reader supports seeking that is used.
 // tmp is used as a temporary buffer for reading.
 // The supplied slice does not need to be the size of the read.
 func (r *Reader) skippable(tmp []byte, n int, allowEOF bool, id uint8) (ok bool) {
 	if id < 0x80 {
 		r.err = fmt.Errorf("interbal error: skippable id < 0x80")
 		return false
 	}
 	if fn := r.skippableCB[id-0x80]; fn != nil {
 		rd := io.LimitReader(r.r, int64(n))
 		r.err = fn(rd)
 		if r.err != nil {
 			return false
 		}
 		_, r.err = io.CopyBuffer(ioutil.Discard, rd, tmp)
 		return r.err == nil
 	}
 	if rs, ok := r.r.(io.ReadSeeker); ok {
 		_, err := rs.Seek(int64(n), io.SeekCurrent)
 		if err == nil {
 			return true
 		}
 		if err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
 			r.err = ErrCorrupt
 			return false
 		}
 	}
 	for n > 0 {
 		if n < len(tmp) {
 			tmp = tmp[:n]
 		}
 		if _, r.err = io.ReadFull(r.r, tmp); r.err != nil {
 			if r.err == io.ErrUnexpectedEOF || (r.err == io.EOF && !allowEOF) {
 				r.err = ErrCorrupt
 			}
 			return false
 		}
 		n -= len(tmp)
 	}
 	return true
 }
 
 // Read satisfies the io.Reader interface.
 func (r *Reader) Read(p []byte) (int, error) {
 	if r.err != nil {
 		return 0, r.err
 	}
 	for {
 		if r.i < r.j {
 			n := copy(p, r.decoded[r.i:r.j])
 			r.i += n
 			return n, nil
 		}
 		if !r.readFull(r.buf[:4], true) {
 			return 0, r.err
 		}
 		chunkType := r.buf[0]
 		if !r.readHeader {
 			if chunkType != chunkTypeStreamIdentifier {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			r.readHeader = true
 		}
 		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
 
 		// The chunk types are specified at
 		// https://github.com/google/snappy/blob/master/framing_format.txt
 		switch chunkType {
 		case chunkTypeCompressedData:
 			r.blockStart += int64(r.j)
 			// Section 4.2. Compressed data (chunk type 0x00).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if !r.ensureBufferSize(chunkLen) {
 				if r.err == nil {
 					r.err = ErrUnsupported
 				}
 				return 0, r.err
 			}
 			buf := r.buf[:chunkLen]
 			if !r.readFull(buf, false) {
 				return 0, r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			buf = buf[checksumSize:]
 
 			n, err := DecodedLen(buf)
 			if err != nil {
 				r.err = err
 				return 0, r.err
 			}
 			if r.snappyFrame && n > maxSnappyBlockSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 
 			if n > len(r.decoded) {
 				if n > r.maxBlock {
 					r.err = ErrCorrupt
 					return 0, r.err
 				}
 				r.decoded = make([]byte, n)
 			}
 			if _, err := Decode(r.decoded, buf); err != nil {
 				r.err = err
 				return 0, r.err
 			}
 			if !r.ignoreCRC && crc(r.decoded[:n]) != checksum {
 				r.err = ErrCRC
 				return 0, r.err
 			}
 			r.i, r.j = 0, n
 			continue
 
 		case chunkTypeUncompressedData:
 			r.blockStart += int64(r.j)
 			// Section 4.3. Uncompressed data (chunk type 0x01).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if !r.ensureBufferSize(chunkLen) {
 				if r.err == nil {
 					r.err = ErrUnsupported
 				}
 				return 0, r.err
 			}
 			buf := r.buf[:checksumSize]
 			if !r.readFull(buf, false) {
 				return 0, r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			// Read directly into r.decoded instead of via r.buf.
 			n := chunkLen - checksumSize
 			if r.snappyFrame && n > maxSnappyBlockSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if n > len(r.decoded) {
 				if n > r.maxBlock {
 					r.err = ErrCorrupt
 					return 0, r.err
 				}
 				r.decoded = make([]byte, n)
 			}
 			if !r.readFull(r.decoded[:n], false) {
 				return 0, r.err
 			}
 			if !r.ignoreCRC && crc(r.decoded[:n]) != checksum {
 				r.err = ErrCRC
 				return 0, r.err
 			}
 			r.i, r.j = 0, n
 			continue
 
 		case chunkTypeStreamIdentifier:
 			// Section 4.1. Stream identifier (chunk type 0xff).
 			if chunkLen != len(magicBody) {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if !r.readFull(r.buf[:len(magicBody)], false) {
 				return 0, r.err
 			}
 			if string(r.buf[:len(magicBody)]) != magicBody {
 				if string(r.buf[:len(magicBody)]) != magicBodySnappy {
 					r.err = ErrCorrupt
 					return 0, r.err
 				} else {
 					r.snappyFrame = true
 				}
 			} else {
 				r.snappyFrame = false
 			}
 			continue
 		}
 
 		if chunkType <= 0x7f {
 			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
 			// fmt.Printf("ERR chunktype: 0x%x\n", chunkType)
 			r.err = ErrUnsupported
 			return 0, r.err
 		}
 		// Section 4.4 Padding (chunk type 0xfe).
 		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
 		if chunkLen > maxChunkSize {
 			// fmt.Printf("ERR chunkLen: 0x%x\n", chunkLen)
 			r.err = ErrUnsupported
 			return 0, r.err
 		}
 
 		// fmt.Printf("skippable: ID: 0x%x, len: 0x%x\n", chunkType, chunkLen)
 		if !r.skippable(r.buf, chunkLen, false, chunkType) {
 			return 0, r.err
 		}
 	}
 }
 
 // DecodeConcurrent will decode the full stream to w.
 // This function should not be combined with reading, seeking or other operations.
 // Up to 'concurrent' goroutines will be used.
 // If <= 0, runtime.NumCPU will be used.
 // On success the number of bytes decompressed nil and is returned.
 // This is mainly intended for bigger streams.
 func (r *Reader) DecodeConcurrent(w io.Writer, concurrent int) (written int64, err error) {
 	if r.i > 0 || r.j > 0 || r.blockStart > 0 {
 		return 0, errors.New("DecodeConcurrent called after ")
 	}
 	if concurrent <= 0 {
 		concurrent = runtime.NumCPU()
 	}
 
 	// Write to output
 	var errMu sync.Mutex
 	var aErr error
 	setErr := func(e error) (ok bool) {
 		errMu.Lock()
 		defer errMu.Unlock()
 		if e == nil {
 			return aErr == nil
 		}
 		if aErr == nil {
 			aErr = e
 		}
 		return false
 	}
 	hasErr := func() (ok bool) {
 		errMu.Lock()
 		v := aErr != nil
 		errMu.Unlock()
 		return v
 	}
 
 	var aWritten int64
 	toRead := make(chan []byte, concurrent)
 	writtenBlocks := make(chan []byte, concurrent)
 	queue := make(chan chan []byte, concurrent)
 	reUse := make(chan chan []byte, concurrent)
 	for i := 0; i < concurrent; i++ {
 		toRead <- make([]byte, 0, r.maxBufSize)
 		writtenBlocks <- make([]byte, 0, r.maxBufSize)
 		reUse <- make(chan []byte, 1)
 	}
 	// Writer
 	var wg sync.WaitGroup
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
 		for toWrite := range queue {
 			entry := <-toWrite
 			reUse <- toWrite
 			if hasErr() {
 				writtenBlocks <- entry
 				continue
 			}
 			n, err := w.Write(entry)
 			want := len(entry)
 			writtenBlocks <- entry
 			if err != nil {
 				setErr(err)
 				continue
 			}
 			if n != want {
 				setErr(io.ErrShortWrite)
 				continue
 			}
 			aWritten += int64(n)
 		}
 	}()
 
 	// Reader
 	defer func() {
 		close(queue)
 		if r.err != nil {
 			err = r.err
 			setErr(r.err)
 		}
 		wg.Wait()
 		if err == nil {
 			err = aErr
 		}
 		written = aWritten
 	}()
 
 	for !hasErr() {
 		if !r.readFull(r.buf[:4], true) {
 			if r.err == io.EOF {
 				r.err = nil
 			}
 			return 0, r.err
 		}
 		chunkType := r.buf[0]
 		if !r.readHeader {
 			if chunkType != chunkTypeStreamIdentifier {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			r.readHeader = true
 		}
 		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
 
 		// The chunk types are specified at
 		// https://github.com/google/snappy/blob/master/framing_format.txt
 		switch chunkType {
 		case chunkTypeCompressedData:
 			r.blockStart += int64(r.j)
 			// Section 4.2. Compressed data (chunk type 0x00).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if chunkLen > r.maxBufSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			orgBuf := <-toRead
 			buf := orgBuf[:chunkLen]
 
 			if !r.readFull(buf, false) {
 				return 0, r.err
 			}
 
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			buf = buf[checksumSize:]
 
 			n, err := DecodedLen(buf)
 			if err != nil {
 				r.err = err
 				return 0, r.err
 			}
 			if r.snappyFrame && n > maxSnappyBlockSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 
 			if n > r.maxBlock {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			wg.Add(1)
 
 			decoded := <-writtenBlocks
 			entry := <-reUse
 			queue <- entry
 			go func() {
 				defer wg.Done()
 				decoded = decoded[:n]
 				_, err := Decode(decoded, buf)
 				toRead <- orgBuf
 				if err != nil {
 					writtenBlocks <- decoded
 					setErr(err)
 					return
 				}
 				if !r.ignoreCRC && crc(decoded) != checksum {
 					writtenBlocks <- decoded
 					setErr(ErrCRC)
 					return
 				}
 				entry <- decoded
 			}()
 			continue
 
 		case chunkTypeUncompressedData:
 
 			// Section 4.3. Uncompressed data (chunk type 0x01).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if chunkLen > r.maxBufSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			// Grab write buffer
 			orgBuf := <-writtenBlocks
 			buf := orgBuf[:checksumSize]
 			if !r.readFull(buf, false) {
 				return 0, r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			// Read content.
 			n := chunkLen - checksumSize
 
 			if r.snappyFrame && n > maxSnappyBlockSize {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if n > r.maxBlock {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			// Read uncompressed
 			buf = orgBuf[:n]
 			if !r.readFull(buf, false) {
 				return 0, r.err
 			}
 
 			if !r.ignoreCRC && crc(buf) != checksum {
 				r.err = ErrCRC
 				return 0, r.err
 			}
 			entry := <-reUse
 			queue <- entry
 			entry <- buf
 			continue
 
 		case chunkTypeStreamIdentifier:
 			// Section 4.1. Stream identifier (chunk type 0xff).
 			if chunkLen != len(magicBody) {
 				r.err = ErrCorrupt
 				return 0, r.err
 			}
 			if !r.readFull(r.buf[:len(magicBody)], false) {
 				return 0, r.err
 			}
 			if string(r.buf[:len(magicBody)]) != magicBody {
 				if string(r.buf[:len(magicBody)]) != magicBodySnappy {
 					r.err = ErrCorrupt
 					return 0, r.err
 				} else {
 					r.snappyFrame = true
 				}
 			} else {
 				r.snappyFrame = false
 			}
 			continue
 		}
 
 		if chunkType <= 0x7f {
 			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
 			// fmt.Printf("ERR chunktype: 0x%x\n", chunkType)
 			r.err = ErrUnsupported
 			return 0, r.err
 		}
 		// Section 4.4 Padding (chunk type 0xfe).
 		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
 		if chunkLen > maxChunkSize {
 			// fmt.Printf("ERR chunkLen: 0x%x\n", chunkLen)
 			r.err = ErrUnsupported
 			return 0, r.err
 		}
 
 		// fmt.Printf("skippable: ID: 0x%x, len: 0x%x\n", chunkType, chunkLen)
 		if !r.skippable(r.buf, chunkLen, false, chunkType) {
 			return 0, r.err
 		}
 	}
 	return 0, r.err
 }
 
 // Skip will skip n bytes forward in the decompressed output.
 // For larger skips this consumes less CPU and is faster than reading output and discarding it.
 // CRC is not checked on skipped blocks.
 // io.ErrUnexpectedEOF is returned if the stream ends before all bytes have been skipped.
 // If a decoding error is encountered subsequent calls to Read will also fail.
 func (r *Reader) Skip(n int64) error {
 	if n < 0 {
 		return errors.New("attempted negative skip")
 	}
 	if r.err != nil {
 		return r.err
 	}
 
 	for n > 0 {
 		if r.i < r.j {
 			// Skip in buffer.
 			// decoded[i:j] contains decoded bytes that have not yet been passed on.
 			left := int64(r.j - r.i)
 			if left >= n {
 				tmp := int64(r.i) + n
 				if tmp > math.MaxInt32 {
 					return errors.New("s2: internal overflow in skip")
 				}
 				r.i = int(tmp)
 				return nil
 			}
 			n -= int64(r.j - r.i)
 			r.i = r.j
 		}
 
 		// Buffer empty; read blocks until we have content.
 		if !r.readFull(r.buf[:4], true) {
 			if r.err == io.EOF {
 				r.err = io.ErrUnexpectedEOF
 			}
 			return r.err
 		}
 		chunkType := r.buf[0]
 		if !r.readHeader {
 			if chunkType != chunkTypeStreamIdentifier {
 				r.err = ErrCorrupt
 				return r.err
 			}
 			r.readHeader = true
 		}
 		chunkLen := int(r.buf[1]) | int(r.buf[2])<<8 | int(r.buf[3])<<16
 
 		// The chunk types are specified at
 		// https://github.com/google/snappy/blob/master/framing_format.txt
 		switch chunkType {
 		case chunkTypeCompressedData:
 			r.blockStart += int64(r.j)
 			// Section 4.2. Compressed data (chunk type 0x00).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return r.err
 			}
 			if !r.ensureBufferSize(chunkLen) {
 				if r.err == nil {
 					r.err = ErrUnsupported
 				}
 				return r.err
 			}
 			buf := r.buf[:chunkLen]
 			if !r.readFull(buf, false) {
 				return r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			buf = buf[checksumSize:]
 
 			dLen, err := DecodedLen(buf)
 			if err != nil {
 				r.err = err
 				return r.err
 			}
 			if dLen > r.maxBlock {
 				r.err = ErrCorrupt
 				return r.err
 			}
 			// Check if destination is within this block
 			if int64(dLen) > n {
 				if len(r.decoded) < dLen {
 					r.decoded = make([]byte, dLen)
 				}
 				if _, err := Decode(r.decoded, buf); err != nil {
 					r.err = err
 					return r.err
 				}
 				if crc(r.decoded[:dLen]) != checksum {
 					r.err = ErrCorrupt
 					return r.err
 				}
 			} else {
 				// Skip block completely
 				n -= int64(dLen)
 				r.blockStart += int64(dLen)
 				dLen = 0
 			}
 			r.i, r.j = 0, dLen
 			continue
 		case chunkTypeUncompressedData:
 			r.blockStart += int64(r.j)
 			// Section 4.3. Uncompressed data (chunk type 0x01).
 			if chunkLen < checksumSize {
 				r.err = ErrCorrupt
 				return r.err
 			}
 			if !r.ensureBufferSize(chunkLen) {
 				if r.err != nil {
 					r.err = ErrUnsupported
 				}
 				return r.err
 			}
 			buf := r.buf[:checksumSize]
 			if !r.readFull(buf, false) {
 				return r.err
 			}
 			checksum := uint32(buf[0]) | uint32(buf[1])<<8 | uint32(buf[2])<<16 | uint32(buf[3])<<24
 			// Read directly into r.decoded instead of via r.buf.
 			n2 := chunkLen - checksumSize
 			if n2 > len(r.decoded) {
 				if n2 > r.maxBlock {
 					r.err = ErrCorrupt
 					return r.err
 				}
 				r.decoded = make([]byte, n2)
 			}
 			if !r.readFull(r.decoded[:n2], false) {
 				return r.err
 			}
 			if int64(n2) < n {
 				if crc(r.decoded[:n2]) != checksum {
 					r.err = ErrCorrupt
 					return r.err
 				}
 			}
 			r.i, r.j = 0, n2
 			continue
 		case chunkTypeStreamIdentifier:
 			// Section 4.1. Stream identifier (chunk type 0xff).
 			if chunkLen != len(magicBody) {
 				r.err = ErrCorrupt
 				return r.err
 			}
 			if !r.readFull(r.buf[:len(magicBody)], false) {
 				return r.err
 			}
 			if string(r.buf[:len(magicBody)]) != magicBody {
 				if string(r.buf[:len(magicBody)]) != magicBodySnappy {
 					r.err = ErrCorrupt
 					return r.err
 				}
 			}
 
 			continue
 		}
 
 		if chunkType <= 0x7f {
 			// Section 4.5. Reserved unskippable chunks (chunk types 0x02-0x7f).
 			r.err = ErrUnsupported
 			return r.err
 		}
 		if chunkLen > maxChunkSize {
 			r.err = ErrUnsupported
 			return r.err
 		}
 		// Section 4.4 Padding (chunk type 0xfe).
 		// Section 4.6. Reserved skippable chunks (chunk types 0x80-0xfd).
 		if !r.skippable(r.buf, chunkLen, false, chunkType) {
 			return r.err
 		}
 	}
 	return nil
 }
 
 // ReadSeeker provides random or forward seeking in compressed content.
 // See Reader.ReadSeeker
 type ReadSeeker struct {
 	*Reader
 	readAtMu sync.Mutex
 }
 
 // ReadSeeker will return an io.ReadSeeker and io.ReaderAt
 // compatible version of the reader.
 // If 'random' is specified the returned io.Seeker can be used for
 // random seeking, otherwise only forward seeking is supported.
 // Enabling random seeking requires the original input to support
 // the io.Seeker interface.
 // A custom index can be specified which will be used if supplied.
 // When using a custom index, it will not be read from the input stream.
 // The ReadAt position will affect regular reads and the current position of Seek.
 // So using Read after ReadAt will continue from where the ReadAt stopped.
 // No functions should be used concurrently.
 // The returned ReadSeeker contains a shallow reference to the existing Reader,
 // meaning changes performed to one is reflected in the other.
 func (r *Reader) ReadSeeker(random bool, index []byte) (*ReadSeeker, error) {
 	// Read index if provided.
 	if len(index) != 0 {
 		if r.index == nil {
 			r.index = &Index{}
 		}
 		if _, err := r.index.Load(index); err != nil {
 			return nil, ErrCantSeek{Reason: "loading index returned: " + err.Error()}
 		}
 	}
 
 	// Check if input is seekable
 	rs, ok := r.r.(io.ReadSeeker)
 	if !ok {
 		if !random {
 			return &ReadSeeker{Reader: r}, nil
 		}
 		return nil, ErrCantSeek{Reason: "input stream isn't seekable"}
 	}
 
 	if r.index != nil {
 		// Seekable and index, ok...
 		return &ReadSeeker{Reader: r}, nil
 	}
 
 	// Load from stream.
 	r.index = &Index{}
 
 	// Read current position.
 	pos, err := rs.Seek(0, io.SeekCurrent)
 	if err != nil {
 		return nil, ErrCantSeek{Reason: "seeking input returned: " + err.Error()}
 	}
 	err = r.index.LoadStream(rs)
 	if err != nil {
 		if err == ErrUnsupported {
 			// If we don't require random seeking, reset input and return.
 			if !random {
 				_, err = rs.Seek(pos, io.SeekStart)
 				if err != nil {
 					return nil, ErrCantSeek{Reason: "resetting stream returned: " + err.Error()}
 				}
 				r.index = nil
 				return &ReadSeeker{Reader: r}, nil
 			}
 			return nil, ErrCantSeek{Reason: "input stream does not contain an index"}
 		}
 		return nil, ErrCantSeek{Reason: "reading index returned: " + err.Error()}
 	}
 
 	// reset position.
 	_, err = rs.Seek(pos, io.SeekStart)
 	if err != nil {
 		return nil, ErrCantSeek{Reason: "seeking input returned: " + err.Error()}
 	}
 	return &ReadSeeker{Reader: r}, nil
 }
 
 // Seek allows seeking in compressed data.
 func (r *ReadSeeker) Seek(offset int64, whence int) (int64, error) {
 	if r.err != nil {
 		if !errors.Is(r.err, io.EOF) {
 			return 0, r.err
 		}
 		// Reset on EOF
 		r.err = nil
 	}
 
 	// Calculate absolute offset.
 	absOffset := offset
 
 	switch whence {
 	case io.SeekStart:
 	case io.SeekCurrent:
 		absOffset = r.blockStart + int64(r.i) + offset
 	case io.SeekEnd:
 		if r.index == nil {
 			return 0, ErrUnsupported
 		}
 		absOffset = r.index.TotalUncompressed + offset
 	default:
 		r.err = ErrUnsupported
 		return 0, r.err
 	}
 
 	if absOffset < 0 {
 		return 0, errors.New("seek before start of file")
 	}
 
 	if !r.readHeader {
 		// Make sure we read the header.
 		_, r.err = r.Read([]byte{})
 		if r.err != nil {
 			return 0, r.err
 		}
 	}
 
 	// If we are inside current block no need to seek.
 	// This includes no offset changes.
 	if absOffset >= r.blockStart && absOffset < r.blockStart+int64(r.j) {
 		r.i = int(absOffset - r.blockStart)
 		return r.blockStart + int64(r.i), nil
 	}
 
 	rs, ok := r.r.(io.ReadSeeker)
 	if r.index == nil || !ok {
 		currOffset := r.blockStart + int64(r.i)
 		if absOffset >= currOffset {
 			err := r.Skip(absOffset - currOffset)
 			return r.blockStart + int64(r.i), err
 		}
 		return 0, ErrUnsupported
 	}
 
 	// We can seek and we have an index.
 	c, u, err := r.index.Find(absOffset)
 	if err != nil {
 		return r.blockStart + int64(r.i), err
 	}
 
 	// Seek to next block
 	_, err = rs.Seek(c, io.SeekStart)
 	if err != nil {
 		return 0, err
 	}
 
 	r.i = r.j                     // Remove rest of current block.
 	r.blockStart = u - int64(r.j) // Adjust current block start for accounting.
 	if u < absOffset {
 		// Forward inside block
 		return absOffset, r.Skip(absOffset - u)
 	}
 	if u > absOffset {
 		return 0, fmt.Errorf("s2 seek: (internal error) u (%d) > absOffset (%d)", u, absOffset)
 	}
 	return absOffset, nil
 }
 
 // ReadAt reads len(p) bytes into p starting at offset off in the
 // underlying input source. It returns the number of bytes
 // read (0 <= n <= len(p)) and any error encountered.
 //
 // When ReadAt returns n < len(p), it returns a non-nil error
 // explaining why more bytes were not returned. In this respect,
 // ReadAt is stricter than Read.
 //
 // Even if ReadAt returns n < len(p), it may use all of p as scratch
 // space during the call. If some data is available but not len(p) bytes,
 // ReadAt blocks until either all the data is available or an error occurs.
 // In this respect ReadAt is different from Read.
 //
 // If the n = len(p) bytes returned by ReadAt are at the end of the
 // input source, ReadAt may return either err == EOF or err == nil.
 //
 // If ReadAt is reading from an input source with a seek offset,
 // ReadAt should not affect nor be affected by the underlying
 // seek offset.
 //
 // Clients of ReadAt can execute parallel ReadAt calls on the
 // same input source. This is however not recommended.
 func (r *ReadSeeker) ReadAt(p []byte, offset int64) (int, error) {
 	r.readAtMu.Lock()
 	defer r.readAtMu.Unlock()
 	_, err := r.Seek(offset, io.SeekStart)
 	if err != nil {
 		return 0, err
 	}
 	n := 0
 	for n < len(p) {
 		n2, err := r.Read(p[n:])
 		if err != nil {
 			// This will include io.EOF
 			return n + n2, err
 		}
 		n += n2
 	}
 	return n, nil
 }
 
 // ReadByte satisfies the io.ByteReader interface.
 func (r *Reader) ReadByte() (byte, error) {
 	if r.err != nil {
 		return 0, r.err
 	}
 	if r.i < r.j {
 		c := r.decoded[r.i]
 		r.i++
 		return c, nil
 	}
 	var tmp [1]byte
 	for i := 0; i < 10; i++ {
 		n, err := r.Read(tmp[:])
 		if err != nil {
 			return 0, err
 		}
 		if n == 1 {
 			return tmp[0], nil
 		}
 	}
 	return 0, io.ErrNoProgress
 }
 
 // SkippableCB will register a callback for chunks with the specified ID.
 // ID must be a Reserved skippable chunks ID, 0x80-0xfe (inclusive).
 // For each chunk with the ID, the callback is called with the content.
 // Any returned non-nil error will abort decompression.
 // Only one callback per ID is supported, latest sent will be used.
 // Sending a nil function will disable previous callbacks.
 func (r *Reader) SkippableCB(id uint8, fn func(r io.Reader) error) error {
 	if id < 0x80 || id > chunkTypePadding {
 		return fmt.Errorf("ReaderSkippableCB: Invalid id provided, must be 0x80-0xfe (inclusive)")
 	}
 	r.skippableCB[id] = fn
 	return nil
 }