mirror of
https://github.com/mudler/luet.git
synced 2025-07-14 15:44:17 +00:00
4adc0dc9b9
Instead of using gox on one side and an action to release, we can merge them together with goreleaser which will build for extra targets (arm, mips if needed in the future) and it also takes care of creating checksums, a source archive, and a changelog and creating a release with all the artifacts. All binaries should respect the old naming convention, so any scripts out there should still work. Signed-off-by: Itxaka <igarcia@suse.com>
330 lines
8.0 KiB
Go
330 lines
8.0 KiB
Go
// Copyright 2018 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.
|
|
// Based on work Copyright (c) 2013, Yann Collet, released under BSD License.
|
|
|
|
package huff0
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"errors"
|
|
"io"
|
|
)
|
|
|
|
// bitReader reads a bitstream in reverse.
|
|
// The last set bit indicates the start of the stream and is used
|
|
// for aligning the input.
|
|
type bitReader struct {
|
|
in []byte
|
|
off uint // next byte to read is at in[off - 1]
|
|
value uint64
|
|
bitsRead uint8
|
|
}
|
|
|
|
// init initializes and resets the bit reader.
|
|
func (b *bitReader) init(in []byte) error {
|
|
if len(in) < 1 {
|
|
return errors.New("corrupt stream: too short")
|
|
}
|
|
b.in = in
|
|
b.off = uint(len(in))
|
|
// The highest bit of the last byte indicates where to start
|
|
v := in[len(in)-1]
|
|
if v == 0 {
|
|
return errors.New("corrupt stream, did not find end of stream")
|
|
}
|
|
b.bitsRead = 64
|
|
b.value = 0
|
|
if len(in) >= 8 {
|
|
b.fillFastStart()
|
|
} else {
|
|
b.fill()
|
|
b.fill()
|
|
}
|
|
b.bitsRead += 8 - uint8(highBit32(uint32(v)))
|
|
return nil
|
|
}
|
|
|
|
// peekBitsFast requires that at least one bit is requested every time.
|
|
// There are no checks if the buffer is filled.
|
|
func (b *bitReader) peekBitsFast(n uint8) uint16 {
|
|
const regMask = 64 - 1
|
|
v := uint16((b.value << (b.bitsRead & regMask)) >> ((regMask + 1 - n) & regMask))
|
|
return v
|
|
}
|
|
|
|
// fillFast() will make sure at least 32 bits are available.
|
|
// There must be at least 4 bytes available.
|
|
func (b *bitReader) fillFast() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
|
|
// 2 bounds checks.
|
|
v := b.in[b.off-4 : b.off]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value = (b.value << 32) | uint64(low)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
}
|
|
|
|
func (b *bitReader) advance(n uint8) {
|
|
b.bitsRead += n
|
|
}
|
|
|
|
// fillFastStart() assumes the bitreader is empty and there is at least 8 bytes to read.
|
|
func (b *bitReader) fillFastStart() {
|
|
// Do single re-slice to avoid bounds checks.
|
|
b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
|
|
b.bitsRead = 0
|
|
b.off -= 8
|
|
}
|
|
|
|
// fill() will make sure at least 32 bits are available.
|
|
func (b *bitReader) fill() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
if b.off > 4 {
|
|
v := b.in[b.off-4:]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value = (b.value << 32) | uint64(low)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
return
|
|
}
|
|
for b.off > 0 {
|
|
b.value = (b.value << 8) | uint64(b.in[b.off-1])
|
|
b.bitsRead -= 8
|
|
b.off--
|
|
}
|
|
}
|
|
|
|
// finished returns true if all bits have been read from the bit stream.
|
|
func (b *bitReader) finished() bool {
|
|
return b.off == 0 && b.bitsRead >= 64
|
|
}
|
|
|
|
// close the bitstream and returns an error if out-of-buffer reads occurred.
|
|
func (b *bitReader) close() error {
|
|
// Release reference.
|
|
b.in = nil
|
|
if b.bitsRead > 64 {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// bitReader reads a bitstream in reverse.
|
|
// The last set bit indicates the start of the stream and is used
|
|
// for aligning the input.
|
|
type bitReaderBytes struct {
|
|
in []byte
|
|
off uint // next byte to read is at in[off - 1]
|
|
value uint64
|
|
bitsRead uint8
|
|
}
|
|
|
|
// init initializes and resets the bit reader.
|
|
func (b *bitReaderBytes) init(in []byte) error {
|
|
if len(in) < 1 {
|
|
return errors.New("corrupt stream: too short")
|
|
}
|
|
b.in = in
|
|
b.off = uint(len(in))
|
|
// The highest bit of the last byte indicates where to start
|
|
v := in[len(in)-1]
|
|
if v == 0 {
|
|
return errors.New("corrupt stream, did not find end of stream")
|
|
}
|
|
b.bitsRead = 64
|
|
b.value = 0
|
|
if len(in) >= 8 {
|
|
b.fillFastStart()
|
|
} else {
|
|
b.fill()
|
|
b.fill()
|
|
}
|
|
b.advance(8 - uint8(highBit32(uint32(v))))
|
|
return nil
|
|
}
|
|
|
|
// peekBitsFast requires that at least one bit is requested every time.
|
|
// There are no checks if the buffer is filled.
|
|
func (b *bitReaderBytes) peekByteFast() uint8 {
|
|
got := uint8(b.value >> 56)
|
|
return got
|
|
}
|
|
|
|
func (b *bitReaderBytes) advance(n uint8) {
|
|
b.bitsRead += n
|
|
b.value <<= n & 63
|
|
}
|
|
|
|
// fillFast() will make sure at least 32 bits are available.
|
|
// There must be at least 4 bytes available.
|
|
func (b *bitReaderBytes) fillFast() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
|
|
// 2 bounds checks.
|
|
v := b.in[b.off-4 : b.off]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value |= uint64(low) << (b.bitsRead - 32)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
}
|
|
|
|
// fillFastStart() assumes the bitReaderBytes is empty and there is at least 8 bytes to read.
|
|
func (b *bitReaderBytes) fillFastStart() {
|
|
// Do single re-slice to avoid bounds checks.
|
|
b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
|
|
b.bitsRead = 0
|
|
b.off -= 8
|
|
}
|
|
|
|
// fill() will make sure at least 32 bits are available.
|
|
func (b *bitReaderBytes) fill() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
if b.off > 4 {
|
|
v := b.in[b.off-4:]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value |= uint64(low) << (b.bitsRead - 32)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
return
|
|
}
|
|
for b.off > 0 {
|
|
b.value |= uint64(b.in[b.off-1]) << (b.bitsRead - 8)
|
|
b.bitsRead -= 8
|
|
b.off--
|
|
}
|
|
}
|
|
|
|
// finished returns true if all bits have been read from the bit stream.
|
|
func (b *bitReaderBytes) finished() bool {
|
|
return b.off == 0 && b.bitsRead >= 64
|
|
}
|
|
|
|
// close the bitstream and returns an error if out-of-buffer reads occurred.
|
|
func (b *bitReaderBytes) close() error {
|
|
// Release reference.
|
|
b.in = nil
|
|
if b.bitsRead > 64 {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// bitReaderShifted reads a bitstream in reverse.
|
|
// The last set bit indicates the start of the stream and is used
|
|
// for aligning the input.
|
|
type bitReaderShifted struct {
|
|
in []byte
|
|
off uint // next byte to read is at in[off - 1]
|
|
value uint64
|
|
bitsRead uint8
|
|
}
|
|
|
|
// init initializes and resets the bit reader.
|
|
func (b *bitReaderShifted) init(in []byte) error {
|
|
if len(in) < 1 {
|
|
return errors.New("corrupt stream: too short")
|
|
}
|
|
b.in = in
|
|
b.off = uint(len(in))
|
|
// The highest bit of the last byte indicates where to start
|
|
v := in[len(in)-1]
|
|
if v == 0 {
|
|
return errors.New("corrupt stream, did not find end of stream")
|
|
}
|
|
b.bitsRead = 64
|
|
b.value = 0
|
|
if len(in) >= 8 {
|
|
b.fillFastStart()
|
|
} else {
|
|
b.fill()
|
|
b.fill()
|
|
}
|
|
b.advance(8 - uint8(highBit32(uint32(v))))
|
|
return nil
|
|
}
|
|
|
|
// peekBitsFast requires that at least one bit is requested every time.
|
|
// There are no checks if the buffer is filled.
|
|
func (b *bitReaderShifted) peekBitsFast(n uint8) uint16 {
|
|
return uint16(b.value >> ((64 - n) & 63))
|
|
}
|
|
|
|
func (b *bitReaderShifted) advance(n uint8) {
|
|
b.bitsRead += n
|
|
b.value <<= n & 63
|
|
}
|
|
|
|
// fillFast() will make sure at least 32 bits are available.
|
|
// There must be at least 4 bytes available.
|
|
func (b *bitReaderShifted) fillFast() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
|
|
// 2 bounds checks.
|
|
v := b.in[b.off-4 : b.off]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
}
|
|
|
|
// fillFastStart() assumes the bitReaderShifted is empty and there is at least 8 bytes to read.
|
|
func (b *bitReaderShifted) fillFastStart() {
|
|
// Do single re-slice to avoid bounds checks.
|
|
b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
|
|
b.bitsRead = 0
|
|
b.off -= 8
|
|
}
|
|
|
|
// fill() will make sure at least 32 bits are available.
|
|
func (b *bitReaderShifted) fill() {
|
|
if b.bitsRead < 32 {
|
|
return
|
|
}
|
|
if b.off > 4 {
|
|
v := b.in[b.off-4:]
|
|
v = v[:4]
|
|
low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
|
|
b.value |= uint64(low) << ((b.bitsRead - 32) & 63)
|
|
b.bitsRead -= 32
|
|
b.off -= 4
|
|
return
|
|
}
|
|
for b.off > 0 {
|
|
b.value |= uint64(b.in[b.off-1]) << ((b.bitsRead - 8) & 63)
|
|
b.bitsRead -= 8
|
|
b.off--
|
|
}
|
|
}
|
|
|
|
// finished returns true if all bits have been read from the bit stream.
|
|
func (b *bitReaderShifted) finished() bool {
|
|
return b.off == 0 && b.bitsRead >= 64
|
|
}
|
|
|
|
// close the bitstream and returns an error if out-of-buffer reads occurred.
|
|
func (b *bitReaderShifted) close() error {
|
|
// Release reference.
|
|
b.in = nil
|
|
if b.bitsRead > 64 {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|