reader.go

package manta

import (
	"encoding/binary"
	"fmt"
	"math"
)

// reader performs read operations against a buffer
type reader struct {
	buf      []byte
	size     uint32
	pos      uint32
	bitVal   uint64 // value of the remaining bits in the current byte
	bitCount uint32 // number of remaining bits in the current byte
}

// newReader creates a new reader object for the given buffer
func newReader(buf []byte) *reader {
	return &reader{buf, uint32(len(buf)), 0, 0, 0}
}

// reset reinitializes the reader to read from the given buffer, allowing a
// single reader to be reused across messages without allocating a new one.
func (r *reader) reset(buf []byte) {
	r.buf = buf
	r.size = uint32(len(buf))
	r.pos = 0
	r.bitVal = 0
	r.bitCount = 0
}

// remBits calculates the number of unread bits in the buffer
func (r *reader) remBits() uint32 {
	return r.remBytes() + r.bitCount
}

func (r *reader) position() string {
	// Logical bit position consumed so far. The word-at-a-time refill can buffer
	// many bits (not just the current byte), so derive byte.bit from pos*8 minus
	// the still-buffered bitCount rather than assuming bitCount <= 8.
	bits := r.pos*8 - r.bitCount
	if rem := bits % 8; rem != 0 {
		return fmt.Sprintf("%d.%d", bits/8, rem)
	}
	return fmt.Sprintf("%d", bits/8)
}

// remBytes calculates the number of unread bytes in the buffer
func (r *reader) remBytes() uint32 {
	return r.size - r.pos
}

// nextByte reads the next byte from the buffer
func (r *reader) nextByte() byte {
	r.pos += 1
	if r.pos > r.size {
		_panicf("nextByte: insufficient buffer (%d of %d)", r.pos, r.size)
	}
	return r.buf[r.pos-1]
}

// readBitMasks[k] is a bitmask of the low k bits. It is used instead of an
// inline (1<<k)-1 so that k == 64 (a full word) does not overflow the shift.
var readBitMasks = func() [65]uint64 {
	var m [65]uint64
	for i := 0; i < 64; i++ {
		m[i] = (uint64(1) << uint(i)) - 1
	}
	m[64] = ^uint64(0)
	return m
}()

// readBits returns the uint32 value for the given number of sequential bits.
//
// The accumulator is refilled a full 64-bit word at a time while at least 8
// bytes remain, falling back to byte-at-a-time only for the final bytes of the
// buffer. Every read is <= 32 bits (quantized float decoders are asserted to
// stay within that), so a single word refill always yields enough bits. The
// loaded word is masked to the whole bytes of headroom before being merged so
// no unclaimed (partial-byte) bits are left above bitCount.
func (r *reader) readBits(n uint32) uint32 {
	for n > r.bitCount && r.pos+8 <= r.size {
		w := binary.LittleEndian.Uint64(r.buf[r.pos:])
		free := (64 - r.bitCount) >> 3 // whole bytes of accumulator headroom
		bits := free * 8
		r.bitVal |= (w & readBitMasks[bits]) << r.bitCount
		r.pos += free
		r.bitCount += bits
	}
	for n > r.bitCount {
		r.bitVal |= uint64(r.nextByte()) << r.bitCount
		r.bitCount += 8
	}

	x := r.bitVal & readBitMasks[n]
	r.bitVal >>= n
	r.bitCount -= n

	return uint32(x)
}

// peekBits returns the next n (<= 32) bits without consuming them, refilling the
// accumulator as needed. If fewer than n bits remain in the buffer the missing
// high bits are returned as zero; the buffer is never over-read past its end.
// This is required by the field-path op lookup, which inspects a fixed window
// that can extend past the final op near the end of the stream.
func (r *reader) peekBits(n uint32) uint32 {
	for n > r.bitCount && r.pos+8 <= r.size {
		w := binary.LittleEndian.Uint64(r.buf[r.pos:])
		free := (64 - r.bitCount) >> 3
		bits := free * 8
		r.bitVal |= (w & readBitMasks[bits]) << r.bitCount
		r.pos += free
		r.bitCount += bits
	}
	for n > r.bitCount && r.pos < r.size {
		r.bitVal |= uint64(r.nextByte()) << r.bitCount
		r.bitCount += 8
	}

	return uint32(r.bitVal & readBitMasks[n])
}

// skipBits discards n bits already buffered in the accumulator. It panics if
// fewer than n bits are buffered, which happens only on a truncated or corrupt
// stream (a field-path op lookup resolving past the end of the buffer). The
// parser's top-level recover turns that into an error, rather than letting
// bitCount underflow and the field-path decode spin on garbage.
func (r *reader) skipBits(n uint32) {
	if n > r.bitCount {
		_panicf("skipBits: insufficient buffer (need %d, have %d bits)", n, r.bitCount)
	}
	r.bitVal >>= n
	r.bitCount -= n
}

// realign discards the whole bytes the word refill buffered in the accumulator
// by rewinding the read position, so byte-oriented reads can proceed directly
// from (and alias) the underlying buffer. Only valid when byte-aligned, i.e.
// bitCount is a multiple of 8.
func (r *reader) realign() {
	r.pos -= r.bitCount >> 3
	r.bitVal = 0
	r.bitCount = 0
}

// readByte reads a single byte
func (r *reader) readByte() byte {
	// Fast path if we're byte aligned
	if r.bitCount&7 == 0 {
		if r.bitCount != 0 {
			r.realign()
		}
		return r.nextByte()
	}

	return byte(r.readBits(8))
}

// readBytes reads the given number of bytes
func (r *reader) readBytes(n uint32) []byte {
	// Fast path if we're byte aligned
	if r.bitCount&7 == 0 {
		if r.bitCount != 0 {
			r.realign()
		}
		r.pos += n
		if r.pos > r.size {
			_panicf("readBytes: insufficient buffer (%d of %d)", r.pos, r.size)
		}
		return r.buf[r.pos-n : r.pos]
	}

	buf := make([]byte, n)
	r.readBytesInto(buf)
	return buf
}

// readBytesInto fills dst with the next len(dst) bytes of the stream. Unlike
// readBytes it never allocates: the caller provides the destination, and the
// unaligned path copies a 32-bit word at a time rather than byte by byte.
func (r *reader) readBytesInto(dst []byte) {
	n := uint32(len(dst))

	// Fast path if we're byte aligned
	if r.bitCount&7 == 0 {
		if r.bitCount != 0 {
			r.realign()
		}
		r.pos += n
		if r.pos > r.size {
			_panicf("readBytesInto: insufficient buffer (%d of %d)", r.pos, r.size)
		}
		copy(dst, r.buf[r.pos-n:r.pos])
		return
	}

	i := 0
	for int(n)-i >= 4 {
		binary.LittleEndian.PutUint32(dst[i:], r.readBits(32))
		i += 4
	}
	for ; i < int(n); i++ {
		dst[i] = byte(r.readBits(8))
	}
}

// readLeUint32 reads an little-endian uint32
func (r *reader) readLeUint32() uint32 {
	// Unaligned: read straight from the bit accumulator. Bits are consumed
	// LSB-first from little-endian bytes, so this equals the LE decode of the
	// next four stream bytes without the readBytes slow-path allocation. The
	// aligned path keeps the zero-copy readBytes fast path.
	if r.bitCount&7 != 0 {
		return r.readBits(32)
	}
	return binary.LittleEndian.Uint32(r.readBytes(4))
}

// readLeUint64 reads a little-endian uint64
func (r *reader) readLeUint64() uint64 {
	// See readLeUint32: two accumulator words replace the unaligned readBytes
	// allocation (readBits is capped at 32 bits per call).
	if r.bitCount&7 != 0 {
		lo := uint64(r.readBits(32))
		return lo | uint64(r.readBits(32))<<32
	}
	return binary.LittleEndian.Uint64(r.readBytes(8))
}

// readVarUint64 reads an unsigned 32-bit varint
func (r *reader) readVarUint32() uint32 {
	var x, s uint32
	for {
		b := uint32(r.readByte())
		x |= (b & 0x7F) << s
		s += 7
		if ((b & 0x80) == 0) || (s == 35) {
			break
		}
	}

	return x
}

// readVarInt64 reads a signed 32-bit varint
func (r *reader) readVarInt32() int32 {
	ux := r.readVarUint32()
	x := int32(ux >> 1)
	if ux&1 != 0 {
		x = ^x
	}
	return x
}

// readVarUint64 reads an unsigned 64-bit varint
func (r *reader) readVarUint64() uint64 {
	var x, s uint64
	for i := 0; ; i++ {
		b := r.readByte()
		if b < 0x80 {
			if i > 9 || i == 9 && b > 1 {
				_panicf("read overflow: varint overflows uint64")
			}
			return x | uint64(b)<<s
		}
		x |= uint64(b&0x7f) << s
		s += 7
	}
}

// readVarInt64 reads a signed 64-bit varint
func (r *reader) readVarInt64() int64 {
	ux := r.readVarUint64()
	x := int64(ux >> 1)
	if ux&1 != 0 {
		x = ^x
	}
	return x
}

// readBoolean reads and interprets single bit as true or false
func (r *reader) readBoolean() bool {
	return r.readBits(1) == 1
}

// readFloat reads an IEEE 754 float
func (r *reader) readFloat() float32 {
	return math.Float32frombits(r.readLeUint32())
}

// readUBitVar reads a variable length uint32 with encoding in last to bits of 6 bit group
func (r *reader) readUBitVar() uint32 {
	ret := r.readBits(6)

	switch ret & 0x30 {
	case 16:
		ret = (ret & 15) | (r.readBits(4) << 4)
		break
	case 32:
		ret = (ret & 15) | (r.readBits(8) << 4)
		break
	case 48:
		ret = (ret & 15) | (r.readBits(28) << 4)
		break
	}

	return ret
}

// readUBitVarFP reads a variable length uint32 encoded using fieldpath encoding
func (r *reader) readUBitVarFP() uint32 {
	if r.readBoolean() {
		return r.readBits(2)
	}
	if r.readBoolean() {
		return r.readBits(4)
	}
	if r.readBoolean() {
		return r.readBits(10)
	}
	if r.readBoolean() {
		return r.readBits(17)
	}
	return r.readBits(31)
}

func (r *reader) readUBitVarFieldPath() int {
	return int(r.readUBitVarFP())
}

// readStringN reads a string of a given length
func (r *reader) readStringN(n uint32) string {
	return string(r.readBytes(n))
}

// readString reads a null terminated string
func (r *reader) readString() string {
	// Most strings here are short field/table keys; a small starting capacity
	// avoids the repeated growth of a cap-0 append chain.
	buf := make([]byte, 0, 32)
	for {
		b := r.readByte()
		if b == 0 {
			break
		}
		buf = append(buf, b)
	}

	return string(buf)
}

// readCoord reads a coord as a float32
func (r *reader) readCoord() float32 {
	value := float32(0.0)

	intval := r.readBits(1)
	fractval := r.readBits(1)
	signbit := false

	if intval != 0 || fractval != 0 {
		signbit = r.readBoolean()

		if intval != 0 {
			intval = r.readBits(14) + 1
		}

		if fractval != 0 {
			fractval = r.readBits(5)
		}

		value = float32(intval) + float32(fractval)*(1.0/(1<<5))

		// Fixup the sign if negative.
		if signbit {
			value = -value
		}
	}

	return value
}

// readAngle reads a bit angle of the given size
func (r *reader) readAngle(n uint32) float32 {
	return float32(r.readBits(n)) * 360.0 / float32(int(1<<n))
}

// readNormal reads a normalized float vector
func (r *reader) readNormal() float32 {
	isNeg := r.readBoolean()
	len := r.readBits(11)
	ret := float32(len) * float32(1.0/(float32(1<<11)-1.0))

	if isNeg {
		return -ret
	} else {
		return ret
	}
}

// read3BitNormal reads a normalized float vector
func (r *reader) read3BitNormal() []float32 {
	ret := []float32{0.0, 0.0, 0.0}

	hasX := r.readBoolean()
	haxY := r.readBoolean()

	if hasX {
		ret[0] = r.readNormal()
	}

	if haxY {
		ret[1] = r.readNormal()
	}

	negZ := r.readBoolean()
	prodsum := ret[0]*ret[0] + ret[1]*ret[1]

	if prodsum < 1.0 {
		ret[2] = float32(math.Sqrt(float64(1.0 - prodsum)))
	} else {
		ret[2] = 0.0
	}

	if negZ {
		ret[2] = -ret[2]
	}

	return ret
}

// readBitsAsBytes reads the given number of bits in groups of bytes
func (r *reader) readBitsAsBytes(n uint32) []byte {
	// Allocate the exact result size up front (the caller retains the slice, so
	// a fresh allocation is required) and fill a 32-bit word at a time instead
	// of growing a cap-0 slice byte by byte.
	tmp := make([]byte, (n+7)/8)
	i := 0
	for n >= 32 {
		binary.LittleEndian.PutUint32(tmp[i:], r.readBits(32))
		i += 4
		n -= 32
	}
	for n >= 8 {
		tmp[i] = r.readByte()
		i++
		n -= 8
	}
	if n > 0 {
		tmp[i] = byte(r.readBits(n))
	}
	return tmp
}