Initial commit

pkg/h264/golomb/golomb_reader.go

@@ -0,0 +1,87 @@
+package golomb
+
+import "bytes"
+
+type Reader struct {
+	r     *bytes.Reader
+	b     byte
+	shift byte
+}
+
+func NewReader(b []byte) *Reader {
+	return &Reader{
+		r: bytes.NewReader(b),
+	}
+}
+
+func (g *Reader) ReadBit() (b byte, err error) {
+	if g.shift == 0 {
+		if g.b, err = g.r.ReadByte(); err != nil {
+			return 0, err
+		}
+		g.shift = 7
+	} else {
+		g.shift--
+	}
+	b = (g.b >> g.shift) & 0b1
+	return
+}
+
+func (g *Reader) ReadBits(n byte) (res uint, err error) {
+	var b byte
+	for i := n - 1; i != 255; i-- {
+		if b, err = g.ReadBit(); err != nil {
+			return
+		}
+		res |= uint(b) << i
+	}
+	return
+}
+
+func (g *Reader) ReadUEGolomb() (res uint, err error) {
+	var b uint
+	var i byte
+	for i = 0; i < 32; i++ {
+		if b, err = g.ReadBits(1); err != nil {
+			return
+		}
+		if b != 0 {
+			break
+		}
+	}
+	if res, err = g.ReadBits(i); err != nil {
+		return
+	}
+	res += (1 << i) - 1
+	return
+}
+
+func (g *Reader) ReadSEGolomb() (res int, err error) {
+	var b uint
+	if b, err = g.ReadUEGolomb(); err != nil {
+		return
+	}
+	if b%2 == 0 {
+		res = -int(b >> 1)
+	} else {
+		res = int(b>>1)
+	}
+	return
+}
+
+func (g *Reader) ReadByte() (byte, error) {
+	return g.r.ReadByte()
+}
+
+func (g *Reader) End() bool {
+	// if only one bit in next byte left
+	if g.shift == 0 && g.r.Len() == 1 {
+		b, _ := g.r.ReadByte()
+		_ = g.r.UnreadByte()
+		return b == 0x80
+	}
+	if g.r.Len() == 0 {
+		//panic("not implemented")
+	}
+	return false
+}

pkg/h264/golomb/golomb_writer.go

@@ -0,0 +1,56 @@
+package golomb
+
+import "math/bits"
+
+type Writer struct {
+	buf   []byte
+	b     byte // last byte
+	i     int  // last byte index
+	shift byte
+}
+
+func NewWriter() *Writer {
+	return &Writer{i: -1}
+}
+
+func (g *Writer) WriteBit(b byte) {
+	if g.shift == 0 {
+		g.buf = append(g.buf, 0)
+		g.b = 0
+		g.i++
+		g.shift = 7
+	} else {
+		g.shift--
+	}
+	g.b |= b << g.shift
+	g.buf[g.i] = g.b
+}
+
+func (g *Writer) WriteBits(b, n byte) {
+	for i := n - 1; i != 255; i-- {
+		g.WriteBit((b >> i) & 0b1)
+	}
+}
+
+func (g *Writer) WriteByte(b byte) {
+	g.buf = append(g.buf, b)
+	g.i++
+}
+
+func (g *Writer) WriteUEGolomb(b byte) {
+	b++
+	n := uint8(bits.Len8(b))*2 - 1
+	g.WriteBits(b, n)
+}
+
+func (g *Writer) WriteSEGolomb(b int8) {
+	if b > 0 {
+		g.WriteUEGolomb(byte(b)*2 - 1)
+	} else {
+		g.WriteUEGolomb(byte(-b) * 2)
+	}
+}
+
+func (g *Writer) Bytes() []byte {
+	return g.buf
+}