83 lines
1.7 KiB
Go
83 lines
1.7 KiB
Go
package common
|
|
|
|
type BitMuncher struct {
|
|
data []byte
|
|
Offset int
|
|
BitsRead int
|
|
}
|
|
|
|
func CreateBitMuncher(data []byte, offset int) *BitMuncher {
|
|
return &BitMuncher{
|
|
data: data,
|
|
Offset: offset,
|
|
BitsRead: 0,
|
|
}
|
|
}
|
|
|
|
func CopyBitMuncher(source *BitMuncher) *BitMuncher {
|
|
return &BitMuncher{
|
|
source.data,
|
|
source.Offset,
|
|
0,
|
|
}
|
|
}
|
|
|
|
func (v *BitMuncher) GetBit() uint32 {
|
|
result := uint32(v.data[v.Offset/8]>>uint(v.Offset%8)) & 0x01
|
|
v.Offset++
|
|
v.BitsRead++
|
|
return result
|
|
}
|
|
|
|
func (v *BitMuncher) SkipBits(bits int) {
|
|
v.Offset += bits
|
|
}
|
|
|
|
func (v *BitMuncher) GetByte() byte {
|
|
return byte(v.GetBits(8))
|
|
}
|
|
|
|
func (v *BitMuncher) GetInt32() int32 {
|
|
return v.MakeSigned(v.GetBits(32), 32)
|
|
}
|
|
|
|
func (v *BitMuncher) GetUInt32() uint32 {
|
|
return v.GetBits(32)
|
|
}
|
|
|
|
func (v *BitMuncher) GetBits(bits int) uint32 {
|
|
if bits == 0 {
|
|
return 0
|
|
}
|
|
result := uint32(0)
|
|
for i := 0; i < bits; i++ {
|
|
result |= v.GetBit() << uint(i)
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (v *BitMuncher) GetSignedBits(bits int) int {
|
|
return int(v.MakeSigned(v.GetBits(bits), bits))
|
|
}
|
|
|
|
func (v *BitMuncher) MakeSigned(value uint32, bits int) int32 {
|
|
if bits == 0 {
|
|
return 0
|
|
}
|
|
if bits == 1 { // If its a single bit, a value of 1 is -1 automagically
|
|
return -int32(value)
|
|
}
|
|
// If there is no sign bit, return the value as is
|
|
if (value & (1 << uint(bits-1))) == 0 {
|
|
return int32(value)
|
|
}
|
|
// We need to extend the signed bit out so that the negative value representation still works with the 2s compliment rule.
|
|
result := uint32(4294967295)
|
|
for i := byte(0); i < byte(bits); i++ {
|
|
if ((value >> uint(i)) & 1) == 0 {
|
|
result -= uint32(1 << uint(i))
|
|
}
|
|
}
|
|
return int32(result) // Force casting to a signed value
|
|
}
|