From: Geoffrey Allott <geoffrey@allott.email>
Date: Tue, 2 Aug 2022 07:42:03 +0000 (+0100)
Subject: remove bit_writer/reader machinery
X-Git-Url: https://git.pointlesshacks.com/?a=commitdiff_plain;h=8504031444bba14d6bf0853790bba5a9bd99ec0f;p=tANS.git

remove bit_writer/reader machinery
---

diff --git a/Makefile b/Makefile
index e25bfa5..cfcbe1a 100644
--- a/Makefile
+++ b/Makefile
@@ -16,16 +16,10 @@ all: $(OBJS)
 $(OBJS): %.o: %.h src/tans_constants.h
 $(TEST_OBJS): test/test.h $(OBJS)
 
-test/test_tans_bit_reader.o: src/tans_buf_bit_reader.h src/tans_file_bit_reader.h src/tans_bit_reader.h
-test/test_tans_bit_reader: src/tans_buf_bit_reader.o src/tans_file_bit_reader.o
-test/test_tans_bit_writer.o: src/tans_buf_bit_writer.h src/tans_bit_writer.h
-test/test_tans_bit_writer: src/tans_buf_bit_writer.o
-test/test_tans_bit_read_write.o: src/tans_buf_bit_writer.h src/tans_bit_writer.h src/tans_rev_buf_bit_reader.h src/tans_bit_reader.h src/tans_static_buf_bit_writer.h
-test/test_tans_bit_read_write: src/tans_buf_bit_writer.o src/tans_rev_buf_bit_reader.o src/tans_static_buf_bit_writer.o
-test/test_tans_encode_st.o: src/tans_buf_bit_writer.h src/tans_bit_writer.h src/tans_encode_st.h src/tans_symbol_tbl.h src/tans_freq_tbl.h
-test/test_tans_encode_st: src/tans_buf_bit_writer.o src/tans_encode_st.o src/tans_encode_tbl.o src/tans_symbol_tbl.o src/tans_freq_tbl.o
-test/test_tans_encode_decode.o: src/tans_rev_buf_bit_reader.h src/tans_bit_reader.h src/tans_decode_st.h src/tans_decode_tbl.h src/tans_buf_bit_writer.h src/tans_bit_writer.h src/tans_encode_st.h src/tans_encode_tbl.h src/tans_symbol_tbl.h src/tans_freq_tbl.h
-test/test_tans_encode_decode: src/tans_rev_buf_bit_reader.o src/tans_decode_st.o src/tans_decode_tbl.o src/tans_buf_bit_writer.o src/tans_encode_st.o src/tans_encode_tbl.o src/tans_symbol_tbl.o src/tans_freq_tbl.o
+test/test_tans_encode_st.o: src/tans_encode_st.h src/tans_symbol_tbl.h src/tans_freq_tbl.h
+test/test_tans_encode_st: src/tans_encode_st.o src/tans_encode_tbl.o src/tans_symbol_tbl.o src/tans_freq_tbl.o
+test/test_tans_encode_decode.o: src/tans_decode_st.h src/tans_decode_tbl.h src/tans_encode_st.h src/tans_encode_tbl.h src/tans_symbol_tbl.h src/tans_freq_tbl.h
+test/test_tans_encode_decode: src/tans_decode_st.o src/tans_decode_tbl.o src/tans_encode_st.o src/tans_encode_tbl.o src/tans_symbol_tbl.o src/tans_freq_tbl.o
 
 clean:
 	rm -f $(OBJS)
diff --git a/src/tans_bit_reader.h b/src/tans_bit_reader.h
deleted file mode 100644
index dc139f8..0000000
--- a/src/tans_bit_reader.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-struct tans_bit_reader;
-
-struct tans_bit_reader_ops {
-    uint16_t (*read)(struct tans_bit_reader *self, uint8_t bits);
-};
-
-struct tans_bit_reader {
-    const struct tans_bit_reader_ops *vtable;
-};
diff --git a/src/tans_bit_writer.h b/src/tans_bit_writer.h
deleted file mode 100644
index e21e842..0000000
--- a/src/tans_bit_writer.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-struct tans_bit_writer;
-
-struct tans_bit_writer_ops {
-    uint16_t (*write)(struct tans_bit_writer *self, uint32_t value, uint8_t bits);
-};
-
-struct tans_bit_writer {
-    const struct tans_bit_writer_ops *vtable;
-};
diff --git a/src/tans_buf_bit_reader.c b/src/tans_buf_bit_reader.c
deleted file mode 100644
index a67f4e3..0000000
--- a/src/tans_buf_bit_reader.c
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "tans_buf_bit_reader.h"
-
-static uint16_t tans_buf_bit_reader_read(struct tans_bit_reader *reader, uint8_t bits)
-{
-    struct tans_buf_bit_reader *self = (struct tans_buf_bit_reader *) reader;
-    uint32_t bit = self->bit % 8;
-    uint32_t byte = self->bit / 8;
-    uint32_t value;
-
-    if (self->bit + bits > self->len * 8) {
-        return (uint16_t) -1;
-    }
-
-    self->bit += bits;
-
-    value = self->buf[byte];
-    if (bit + bits > 8) value |= (uint32_t) self->buf[byte+1] << 8;
-    if (bit + bits > 16) value |= (uint32_t) self->buf[byte+2] << 16;
-    value >>= bit;
-    value &= (uint16_t) ((1 << bits) - 1);
-
-    return (uint16_t) value;
-}
-
-static const struct tans_bit_reader_ops vtable = {
-    .read = tans_buf_bit_reader_read,
-};
-
-void tans_buf_bit_reader_init(struct tans_buf_bit_reader *self, const uint8_t *buf, uint32_t len)
-{
-    self->vtable = &vtable;
-    self->bit = 0;
-    self->len = len;
-    self->buf = buf;
-}
diff --git a/src/tans_buf_bit_reader.h b/src/tans_buf_bit_reader.h
deleted file mode 100644
index 71d7d07..0000000
--- a/src/tans_buf_bit_reader.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "tans_bit_reader.h"
-
-struct tans_buf_bit_reader {
-    const struct tans_bit_reader_ops *vtable;
-    uint32_t bit;
-    uint32_t len;
-    const uint8_t *buf;
-};
-
-void tans_buf_bit_reader_init(struct tans_buf_bit_reader *self, const uint8_t *buf, uint32_t len);
diff --git a/src/tans_buf_bit_writer.c b/src/tans_buf_bit_writer.c
deleted file mode 100644
index 48907a1..0000000
--- a/src/tans_buf_bit_writer.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "tans_buf_bit_writer.h"
-
-static uint16_t tans_buf_bit_writer_write(struct tans_bit_writer *writer, uint32_t value, uint8_t bits)
-{
-    struct tans_buf_bit_writer *self = (struct tans_buf_bit_writer *) writer;
-    uint32_t bit = self->bit % 8;
-    uint32_t byte = self->bit / 8;
-
-    if (self->bit + bits > self->len * 8) {
-        return (uint16_t) -1;
-    }
-
-    self->bit += bits;
-
-    value &= (uint16_t) ((1 << bits) - 1);
-    value <<= bit;
-    self->buf[byte] |= (uint8_t) value;
-    if (bit + bits > 8) self->buf[byte+1] |= (uint8_t) (value >> 8);
-    if (bit + bits > 16) self->buf[byte+2] |= (uint8_t) (value >> 16);
-
-    return bits;
-}
-
-static const struct tans_bit_writer_ops vtable = {
-    .write = tans_buf_bit_writer_write,
-};
-
-void tans_buf_bit_writer_init(struct tans_buf_bit_writer *self, uint8_t *buf, uint32_t len)
-{
-    self->vtable = &vtable;
-    self->bit = 0;
-    self->len = len;
-    self->buf = buf;
-}
diff --git a/src/tans_buf_bit_writer.h b/src/tans_buf_bit_writer.h
deleted file mode 100644
index 20d1488..0000000
--- a/src/tans_buf_bit_writer.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "tans_bit_writer.h"
-
-struct tans_buf_bit_writer {
-    const struct tans_bit_writer_ops *vtable;
-    uint32_t bit;
-    uint32_t len;
-    uint8_t *buf;
-};
-
-void tans_buf_bit_writer_init(struct tans_buf_bit_writer *self, uint8_t *buf, uint32_t len);
diff --git a/src/tans_decode_buf_st.h b/src/tans_decode_buf_st.h
deleted file mode 100644
index 59e515a..0000000
--- a/src/tans_decode_buf_st.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#include "tans_decode_tbl.h"
-
-#include <stddef.h>
-
-struct tans_decode_buf_st {
-    struct tans_decode_tbl decode_tbl;
-    uint16_t x;
-};
-
-void tans_decode_buf_st_init(struct tans_decode_buf_st *self, struct tans_symbol_tbl *symbol_tbl);
-uint16_t tans_decode_buf_st_next(struct tans_decode_buf_st *self, struct tans_bit_reader *bit_reader);
diff --git a/src/tans_decode_st.c b/src/tans_decode_st.c
index 285ab23..0f61ec8 100644
--- a/src/tans_decode_st.c
+++ b/src/tans_decode_st.c
@@ -6,31 +6,14 @@ void tans_decode_st_init(struct tans_decode_st *self, struct tans_symbol_tbl *sy
     self->x = 0;
 }
 
-uint16_t tans_decode_st_next(struct tans_decode_st *self, struct tans_bit_reader *bit_reader)
-{
-    uint8_t ret;
-    uint16_t read;
-    struct tans_decode_tbl_entry t = self->decode_tbl.entries[self->x];
-
-    read = bit_reader->vtable->read(bit_reader, t.nb_bits);
-    if (read == (uint16_t) -1) {
-        return (uint16_t) -1;
-    }
-
-    ret = t.symbol;
-    self->x = t.new_x + read;
-
-    return (uint16_t) ret;
-}
-
 static inline uint32_t get_uint32(uint8_t buf[const static 4])
 {
     return (uint32_t) buf[0] | (uint32_t) buf[1] << 8 | (uint32_t) buf[2] << 16 | (uint32_t) buf[3] << 24;
 }
 
-size_t tans_decode_st_decode(struct tans_decode_st *self, uint8_t *data, size_t len, uint8_t *buf, uint32_t bits)
+uint32_t tans_decode_st_decode(struct tans_decode_st *self, uint8_t *data, uint32_t len, uint8_t *buf, uint32_t bits)
 {
-    size_t i;
+    uint32_t i;
     struct tans_decode_tbl_entry t;
     uint32_t bit, byte, value;
 
diff --git a/src/tans_decode_st.h b/src/tans_decode_st.h
index 238ab56..c4ccfbc 100644
--- a/src/tans_decode_st.h
+++ b/src/tans_decode_st.h
@@ -1,9 +1,6 @@
 #pragma once
 
 #include "tans_decode_tbl.h"
-#include "tans_bit_reader.h"
-
-#include <stddef.h>
 
 struct tans_decode_st {
     struct tans_decode_tbl decode_tbl;
@@ -11,5 +8,4 @@ struct tans_decode_st {
 };
 
 void tans_decode_st_init(struct tans_decode_st *self, struct tans_symbol_tbl *symbol_tbl);
-uint16_t tans_decode_st_next(struct tans_decode_st *self, struct tans_bit_reader *bit_reader);
-size_t tans_decode_st_decode(struct tans_decode_st *self, uint8_t *data, size_t len, uint8_t *buf, uint32_t bits);
+uint32_t tans_decode_st_decode(struct tans_decode_st *self, uint8_t *data, uint32_t len, uint8_t *buf, uint32_t bits);
diff --git a/src/tans_encode_st.c b/src/tans_encode_st.c
index 6c80a89..eab6a8e 100644
--- a/src/tans_encode_st.c
+++ b/src/tans_encode_st.c
@@ -7,23 +7,6 @@ void tans_encode_st_init(struct tans_encode_st *self, const struct tans_symbol_t
     self->x = self->encode_tbl.tblsz;
 }
 
-uint16_t tans_encode_st_next(struct tans_encode_st *self, struct tans_bit_writer *bit_writer, uint8_t symbol)
-{
-    uint8_t nb_bits;
-    uint16_t written;
-    uint16_t i;
-
-    nb_bits = (uint8_t) ((self->x + self->symbol_tbl.entries[symbol].nb) >> (self->symbol_tbl.log2_tblsz + 1));
-    written = bit_writer->vtable->write(bit_writer, self->x, nb_bits);
-    if (written != nb_bits) {
-        return (uint16_t) -1;
-    }
-    i = (uint16_t) (self->symbol_tbl.entries[symbol].start + (self->x >> nb_bits));
-    self->x = self->encode_tbl.entries[i].x;
-
-    return written;
-}
-
 static inline uint32_t get_uint32(uint8_t buf[const static 4])
 {
     return (uint32_t) buf[0] | (uint32_t) (buf[1] << 8) | (uint32_t) (buf[2] << 16) | (uint32_t) (buf[3] << 24);
diff --git a/src/tans_encode_st.h b/src/tans_encode_st.h
index 10ca6f3..4859be6 100644
--- a/src/tans_encode_st.h
+++ b/src/tans_encode_st.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "tans_encode_tbl.h"
-#include "tans_bit_writer.h"
 
 struct tans_encode_st {
     struct tans_symbol_tbl symbol_tbl;
@@ -10,5 +9,4 @@ struct tans_encode_st {
 };
 
 void tans_encode_st_init(struct tans_encode_st *self, const struct tans_symbol_tbl *symbol_tbl);
-uint16_t tans_encode_st_next(struct tans_encode_st *self, struct tans_bit_writer *bit_writer, uint8_t symbol);
 uint32_t tans_encode_st_encode(struct tans_encode_st *self, uint8_t *data, uint32_t len, uint8_t *buf);
diff --git a/src/tans_file_bit_reader.c b/src/tans_file_bit_reader.c
deleted file mode 100644
index a84a306..0000000
--- a/src/tans_file_bit_reader.c
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "tans_file_bit_reader.h"
-
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-
-static uint16_t tans_file_bit_reader_read(struct tans_bit_reader *reader, uint8_t bits)
-{
-    struct tans_file_bit_reader *self = (struct tans_file_bit_reader *) reader;
-    ssize_t bytes_read;
-    uint32_t bit = self->bit % 8;
-    uint32_t byte = self->bit / 8;
-
-    if (bits == 0) {
-        return 0;
-    }
-
-    while (self->len * 8 - self->bit < bits) {
-        memmove(self->buf, self->buf + byte, self->len - byte);
-        bytes_read = read(self->fd, self->buf + self->len, sizeof self->buf - self->len);
-        if (bytes_read <= 0) {
-            return (uint16_t) -1;
-        }
-        self->len += (uint32_t) bytes_read;
-    }
-
-    self->bit += bits;
-
-    if (bit + bits <= 8) {
-        return (uint16_t) (((1 << bits) - 1) & (self->buf[byte] >> bit));
-    } else if (bit + bits <= 16) {
-        return (uint16_t) (((1 << bits) - 1) & ((self->buf[byte] >> bit) | (self->buf[byte+1] << (8 - bit))));
-    } else if (bit + bits <= 24) {
-        return (uint16_t) (((1 << bits) - 1) & ((self->buf[byte] >> bit) | ((self->buf[byte+1] | (self->buf[byte+2] << 8)) << (8 - bit))));
-    } else {
-        return (uint16_t) -1;
-    }
-}
-
-static const struct tans_bit_reader_ops vtable = {
-    .read = tans_file_bit_reader_read,
-};
-
-int tans_file_bit_reader_init(struct tans_file_bit_reader *self, const char *filename)
-{
-    self->vtable = &vtable;
-    self->fd = open(filename, O_RDONLY | O_CLOEXEC);
-    self->bit = 0;
-    self->len = 0;
-
-    if (self->fd == -1) {
-        return -1;
-    }
-
-    return 0;
-}
diff --git a/src/tans_file_bit_reader.h b/src/tans_file_bit_reader.h
deleted file mode 100644
index 4e29dc3..0000000
--- a/src/tans_file_bit_reader.h
+++ /dev/null
@@ -1,15 +0,0 @@
-#pragma once
-
-#include "tans_bit_reader.h"
-
-#define TANS_FILE_BIT_READER_BUFSZ 1024
-
-struct tans_file_bit_reader {
-    const struct tans_bit_reader_ops *vtable;
-    int fd;
-    uint32_t bit;
-    uint32_t len;
-    uint8_t buf[TANS_FILE_BIT_READER_BUFSZ];
-};
-
-int tans_file_bit_reader_init(struct tans_file_bit_reader *self, const char *filename);
diff --git a/src/tans_rev_buf_bit_reader.c b/src/tans_rev_buf_bit_reader.c
deleted file mode 100644
index a0fe4a9..0000000
--- a/src/tans_rev_buf_bit_reader.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "tans_rev_buf_bit_reader.h"
-
-static uint16_t tans_rev_buf_bit_reader_read(struct tans_bit_reader *reader, uint8_t bits)
-{
-    struct tans_rev_buf_bit_reader *self = (struct tans_rev_buf_bit_reader *) reader;
-    uint32_t bit = self->bit % 8 + (uint32_t) 8 * (self->bit % 8 == 0);
-    uint32_t byte = (self->bit - 1) / 8;
-
-    if (bits == 0) {
-        return 0;
-    }
-
-    if (self->bit < bits) {
-        return (uint16_t) -1;
-    }
-
-    self->bit -= bits;
-
-    if (8 - bit + bits <= 8) {
-        return (uint16_t) (((1 << bits) - 1) & (self->buf[byte] >> (bit - bits)));
-    } else if (8 - bit + bits <= 16) {
-        return (uint16_t) (((1 << bits) - 1) & ((self->buf[byte-1] | (self->buf[byte] << 8)) >> (bit + 8 - bits)));
-    } else if (8 - bit + bits <= 24) {
-        return (uint16_t) (((1 << bits) - 1) & ((self->buf[byte-2] | (self->buf[byte-1] << 8) | (self->buf[byte] << 16)) >> (bit + 16 - bits)));
-    } else {
-        return (uint16_t) -1;
-    }
-}
-
-static const struct tans_bit_reader_ops vtable = {
-    .read = tans_rev_buf_bit_reader_read,
-};
-
-void tans_rev_buf_bit_reader_init(struct tans_rev_buf_bit_reader *self, const uint8_t *buf, uint32_t len)
-{
-    self->vtable = &vtable;
-    self->bit = len * 8;
-    self->len = len;
-    self->buf = buf;
-}
diff --git a/src/tans_rev_buf_bit_reader.h b/src/tans_rev_buf_bit_reader.h
deleted file mode 100644
index 93f8b2b..0000000
--- a/src/tans_rev_buf_bit_reader.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include "tans_bit_reader.h"
-
-struct tans_rev_buf_bit_reader {
-    const struct tans_bit_reader_ops *vtable;
-    uint32_t bit;
-    uint32_t len;
-    const uint8_t *buf;
-};
-
-void tans_rev_buf_bit_reader_init(struct tans_rev_buf_bit_reader *self, const uint8_t *buf, uint32_t len);
diff --git a/src/tans_static_buf_bit_writer.c b/src/tans_static_buf_bit_writer.c
deleted file mode 100644
index 6b05248..0000000
--- a/src/tans_static_buf_bit_writer.c
+++ /dev/null
@@ -1,44 +0,0 @@
-#include "tans_static_buf_bit_writer.h"
-
-static inline uint32_t get_uint32(uint8_t buf[const static 4])
-{
-    return (uint32_t) (buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24));
-}
-
-static inline void set_uint32(uint8_t buf[static 4], uint32_t value)
-{
-    buf[0] = (uint8_t) value;
-    buf[1] = (uint8_t) (value >> 8);
-    buf[2] = (uint8_t) (value >> 16);
-    buf[3] = (uint8_t) (value >> 24);
-}
-
-static uint16_t tans_static_buf_bit_writer_write(struct tans_bit_writer *writer, uint32_t value, uint8_t bits)
-{
-    struct tans_static_buf_bit_writer *self = (struct tans_static_buf_bit_writer *) writer;
-    uint32_t bit = self->bit % 8;
-    uint32_t byte = self->bit / 8;
-
-    if (self->bit + bits > TANS_STATIC_BUF_BIT_WRITER_BUFSZ * 8) {
-        return (uint16_t) -1;
-    }
-
-    self->bit += bits;
-
-    value &= (uint32_t) ((1 << bits) - 1);
-    value <<= bit;
-    value |= get_uint32(self->buf + byte);
-    set_uint32(self->buf + byte, value);
-
-    return bits;
-}
-
-static const struct tans_bit_writer_ops vtable = {
-    .write = tans_static_buf_bit_writer_write,
-};
-
-void tans_static_buf_bit_writer_init(struct tans_static_buf_bit_writer *self)
-{
-    self->vtable = &vtable;
-    self->bit = 0;
-}
diff --git a/src/tans_static_buf_bit_writer.h b/src/tans_static_buf_bit_writer.h
deleted file mode 100644
index da1b430..0000000
--- a/src/tans_static_buf_bit_writer.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-
-#include "tans_bit_writer.h"
-
-#define TANS_STATIC_BUF_BIT_WRITER_BUFSZ (256 * 1024)
-#define TANS_STATIC_BUF_BIT_WRITER_OVERFLOW 4
-
-struct tans_static_buf_bit_writer {
-    const struct tans_bit_writer_ops *vtable;
-    uint32_t bit;
-    uint8_t buf[TANS_STATIC_BUF_BIT_WRITER_BUFSZ + TANS_STATIC_BUF_BIT_WRITER_OVERFLOW];
-};
-
-void tans_static_buf_bit_writer_init(struct tans_static_buf_bit_writer *self);
diff --git a/test/test_tans_bit_read_write.c b/test/test_tans_bit_read_write.c
deleted file mode 100644
index cdc9396..0000000
--- a/test/test_tans_bit_read_write.c
+++ /dev/null
@@ -1,99 +0,0 @@
-#include "test.h"
-
-#include "tans_buf_bit_writer.h"
-#include "tans_rev_buf_bit_reader.h"
-#include "tans_static_buf_bit_writer.h"
-
-enum test_result test_tans_buf_bit_write_read_rev(void)
-{
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
-    uint8_t buf[8] = {0};
-
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, sizeof buf);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, sizeof buf);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 0), 0);
-
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 8), 8);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x2f, 6), 6);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 2), 2);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x3fe0, 16), 16);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xd0, 8), 8);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x0f, 7), 7);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 1), 1);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 3), 3);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x18, 5), 5);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 5), 0x18);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 3), 0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 1), 1);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 7), 0x0f);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 0xd0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 16), 0x3fe0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 2), 0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 6), 0x2f);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 1);
-
-    return TEST_SUCCESS;
-}
-
-enum test_result test_tans_static_buf_bit_write_read_rev(void)
-{
-    uint32_t i;
-    struct tans_static_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
-    uint8_t buf[64] = {0};
-
-    tans_static_buf_bit_writer_init(&buf_bit_writer);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, sizeof buf);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 0), 0);
-
-    for (i = 0; i < 8; ++i) {
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 8), 8);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x2f, 6), 6);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 2), 2);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x3fe0, 16), 16);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xd0, 8), 8);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x0f, 7), 7);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 1), 1);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 3), 3);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x18, 5), 5);
-        ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-    }
-
-    for (i = 0; i < 64; ++i) {
-        buf[i] = buf_bit_writer.buf[i];
-    }
-
-
-    for (i = 0; i < 8; ++i) {
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 5), 0x18);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 3), 0);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 1), 1);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 7), 0x0f);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 0xd0);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 16), 0x3fe0);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 2), 0);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 6), 0x2f);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 1);
-    }
-
-    return TEST_SUCCESS;
-}
-
-int main(void)
-{
-    RUN_TEST(test_tans_buf_bit_write_read_rev);
-    RUN_TEST(test_tans_static_buf_bit_write_read_rev);
-}
diff --git a/test/test_tans_bit_reader.c b/test/test_tans_bit_reader.c
deleted file mode 100644
index cc10851..0000000
--- a/test/test_tans_bit_reader.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "test.h"
-
-#include "tans_buf_bit_reader.h"
-#include "tans_file_bit_reader.h"
-
-enum test_result test_tans_buf_bit_reader(void)
-{
-    struct tans_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
-    uint8_t buf[8] = {0x01, 0xff, 0x02, 0xfe, 0x03, 0xfd, 0x08, 0xfc};
-
-    tans_buf_bit_reader_init(&buf_bit_reader, buf, sizeof buf);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 0), 0);
-
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 1);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 6), 0x2f);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 2), 0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 16), 0x3fe0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 8), 0xd0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 7), 0x0f);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 1), 1);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 3), 0);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 5), 0x18);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 4), 0xf);
-    ASSERT_EQ(bit_reader->vtable->read(bit_reader, 1), (uint16_t) -1);
-
-    return TEST_SUCCESS;
-}
-
-enum test_result test_tans_file_bit_reader(void)
-{
-    struct tans_file_bit_reader file_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &file_bit_reader;
-    uint8_t bits;
-
-    ASSERT_EQ(tans_file_bit_reader_init(&file_bit_reader, "/dev/zero"), 0);
-
-    for (bits = 0; bits <= 16; ++bits) {
-        ASSERT_EQ(bit_reader->vtable->read(bit_reader, bits), 0);
-    }
-
-    return TEST_SUCCESS;
-}
-
-int main(void)
-{
-    RUN_TEST(test_tans_buf_bit_reader);
-    RUN_TEST(test_tans_file_bit_reader);
-}
diff --git a/test/test_tans_bit_writer.c b/test/test_tans_bit_writer.c
deleted file mode 100644
index b31177b..0000000
--- a/test/test_tans_bit_writer.c
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "test.h"
-
-#include "tans_buf_bit_writer.h"
-
-enum test_result test_tans_buf_bit_writer(void)
-{
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
-    uint8_t buf[8] = {0};
-
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, sizeof buf);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 0), 0);
-
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 8), 8);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x2f, 6), 6);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 2), 2);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x3fe0, 16), 16);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xd0, 8), 8);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x0f, 7), 7);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 1, 1), 1);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 3), 3);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0x18, 5), 5);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0xf, 4), 4);
-    ASSERT_EQ(bit_writer->vtable->write(bit_writer, 0, 1), (uint16_t) -1);
-
-    ASSERT_EQ(buf[0], 0x01);
-    ASSERT_EQ(buf[1], 0xff);
-    ASSERT_EQ(buf[2], 0x02);
-    ASSERT_EQ(buf[3], 0xfe);
-    ASSERT_EQ(buf[4], 0x03);
-    ASSERT_EQ(buf[5], 0xfd);
-    ASSERT_EQ(buf[6], 0x08);
-    ASSERT_EQ(buf[7], 0xfc);
-
-    return TEST_SUCCESS;
-}
-
-int main(void)
-{
-    RUN_TEST(test_tans_buf_bit_writer);
-}
diff --git a/test/test_tans_encode_decode.c b/test/test_tans_encode_decode.c
index e7d15ff..b6f67be 100644
--- a/test/test_tans_encode_decode.c
+++ b/test/test_tans_encode_decode.c
@@ -1,24 +1,19 @@
 #include "test.h"
 
 #include "floor_log2.h"
-#include "tans_buf_bit_writer.h"
 #include "tans_decode_st.h"
 #include "tans_encode_st.h"
-#include "tans_rev_buf_bit_reader.h"
 
 enum test_result test_tans_encode_decode_equal_freq(void)
 {
     struct tans_freq_tbl freq_tbl;
     struct tans_symbol_tbl symbol_tbl;
     struct tans_encode_st encode_st;
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
     struct tans_decode_st decode_st;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
     uint8_t data[8] = {0x01, 0xfe, 0x32, 0x12, 0x06, 0x07, 0x88, 0x00};
     double p[256];
-    uint8_t buf[8] = {0};
+    uint8_t buf[4 + 8 + 4] = {0};
+    uint8_t rec[8] = {0};
     uint16_t i;
     uint16_t n_symbols = 256;
     uint16_t log2_tblsz = 10;
@@ -27,21 +22,15 @@ enum test_result test_tans_encode_decode_equal_freq(void)
     ASSERT_NE(tans_freq_tbl_init(&freq_tbl, n_symbols, p, log2_tblsz), -1);
     ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
     tans_encode_st_init(&encode_st, &symbol_tbl);
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, floor_log2(n_symbols));
     tans_decode_st_init(&decode_st, &symbol_tbl);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, floor_log2(n_symbols));
-
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_NE(tans_encode_st_next(&encode_st, bit_writer, (uint8_t) (data[i] % n_symbols)), (uint16_t) -1);
-    }
-
-    ASSERT_EQ(buf_bit_writer.bit, buf_bit_writer.len * 8);
-    ASSERT_EQ(buf_bit_writer.bit, buf_bit_reader.bit);
 
+    ASSERT_EQ(tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4), 64);
     decode_st.x = (uint16_t) (encode_st.x - (1 << log2_tblsz));
 
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_EQ(tans_decode_st_next(&decode_st, bit_reader), data[sizeof data - 1 - i] % n_symbols);
+    ASSERT_EQ(tans_decode_st_decode(&decode_st, rec, sizeof rec, buf + 4, 64), 0);
+
+    for (i = 0; i < sizeof rec; ++i) {
+        ASSERT_EQ(data[i], rec[i]);
     }
 
     return TEST_SUCCESS;
@@ -52,92 +41,42 @@ enum test_result test_tans_encode_decode_high_zero_probability(void)
     struct tans_freq_tbl freq_tbl;
     struct tans_symbol_tbl symbol_tbl;
     struct tans_encode_st encode_st;
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
     struct tans_decode_st decode_st;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
     uint8_t data[8] = {0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x23};
     double p[256];
-    uint8_t buf[8] = {0};
+    uint8_t buf[4 + 8 + 4] = {0};
+    uint8_t rec[8];
     uint16_t i;
     uint16_t n_symbols = 256;
     uint16_t log2_tblsz = 12;
+    uint32_t bits;
 
     p[0] = 0.75;
     for (i = 1; i < n_symbols; ++i) p[i] = 0.25 / n_symbols;
     ASSERT_NE(tans_freq_tbl_init(&freq_tbl, n_symbols, p, log2_tblsz), -1);
     ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
     tans_encode_st_init(&encode_st, &symbol_tbl);
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, floor_log2(n_symbols));
     tans_decode_st_init(&decode_st, &symbol_tbl);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, floor_log2(n_symbols));
 
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_NE(tans_encode_st_next(&encode_st, bit_writer, (uint8_t) (data[i] % n_symbols)), (uint16_t) -1);
-    }
+    bits = tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4);
 
-    buf_bit_reader.bit = buf_bit_writer.bit;
     decode_st.x = (uint16_t) (encode_st.x - (1 << log2_tblsz));
 
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_EQ(tans_decode_st_next(&decode_st, bit_reader), data[sizeof data - 1 - i] % n_symbols);
-    }
+    ASSERT_EQ(tans_decode_st_decode(&decode_st, rec, sizeof rec, buf + 4, bits), 0);
 
-    return TEST_SUCCESS;
-}
-
-enum test_result test_tans_encode_decode_long_stream(void)
-{
-    struct tans_freq_tbl freq_tbl;
-    struct tans_symbol_tbl symbol_tbl;
-    struct tans_encode_st encode_st;
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
-    struct tans_decode_st decode_st;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
-    struct tans_bit_reader *bit_reader = (struct tans_bit_reader *) &buf_bit_reader;
-    uint8_t data[65536];
-    double p[256];
-    uint8_t buf[32768] = {0};
-    uint16_t n_symbols = 256;
-    uint16_t log2_tblsz = 10;
-    uint32_t i;
-
-    p[0] = 0.75;
-    for (i = 1; i < n_symbols; ++i) p[i] = 0.25 / n_symbols;
-    ASSERT_NE(tans_freq_tbl_init(&freq_tbl, n_symbols, p, log2_tblsz), -1);
-    ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
-    tans_encode_st_init(&encode_st, &symbol_tbl);
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, sizeof buf);
-    tans_decode_st_init(&decode_st, &symbol_tbl);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, sizeof buf);
-
-    for (i = 0; i < 65536; ++i) {
-        data[i] = (uint8_t) (i % 4 == 3 ? i / 4 : 0);
-    }
-
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_NE(tans_encode_st_next(&encode_st, bit_writer, (uint8_t) (data[i] % n_symbols)), (uint16_t) -1);
-    }
-
-    buf_bit_reader.bit = buf_bit_writer.bit;
-    decode_st.x = (uint16_t) (encode_st.x - (1 << log2_tblsz));
-
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_EQ(tans_decode_st_next(&decode_st, bit_reader), data[sizeof data - 1 - i] % n_symbols);
+    for (i = 0; i < sizeof rec; ++i) {
+        ASSERT_EQ(data[i], rec[i]);
     }
 
     return TEST_SUCCESS;
 }
 
-enum test_result test_tans_encode_decode_long_stream_bulk(void)
+enum test_result test_tans_encode_decode_long_stream(void)
 {
     struct tans_freq_tbl freq_tbl;
     struct tans_symbol_tbl symbol_tbl;
     struct tans_encode_st encode_st;
     struct tans_decode_st decode_st;
-    struct tans_rev_buf_bit_reader buf_bit_reader;
     uint8_t data[65536];
     double p[256];
     uint8_t rec[65536];
@@ -145,6 +84,7 @@ enum test_result test_tans_encode_decode_long_stream_bulk(void)
     uint16_t n_symbols = 256;
     uint16_t log2_tblsz = 10;
     uint32_t i;
+    uint32_t bits;
 
     p[0] = 0.75;
     for (i = 1; i < n_symbols; ++i) p[i] = 0.25 / n_symbols;
@@ -152,16 +92,19 @@ enum test_result test_tans_encode_decode_long_stream_bulk(void)
     ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
     tans_encode_st_init(&encode_st, &symbol_tbl);
     tans_decode_st_init(&decode_st, &symbol_tbl);
-    tans_rev_buf_bit_reader_init(&buf_bit_reader, buf, sizeof buf);
 
     for (i = 0; i < 65536; ++i) {
         data[i] = (uint8_t) (i % 4 == 3 ? i / 4 : 0);
     }
 
-    buf_bit_reader.bit = (uint32_t) tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4);
+    bits = (uint32_t) tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4);
     decode_st.x = (uint16_t) (encode_st.x - (1 << log2_tblsz));
 
-    ASSERT_EQ(tans_decode_st_decode(&decode_st, rec, sizeof rec, buf + 4, buf_bit_reader.bit), 0);
+    ASSERT_EQ(tans_decode_st_decode(&decode_st, rec, sizeof rec, buf + 4, bits), 0);
+
+    for (i = 0; i < sizeof rec; ++i) {
+        ASSERT_EQ(data[i], rec[i]);
+    }
 
     return TEST_SUCCESS;
 }
@@ -171,5 +114,4 @@ int main(void)
     RUN_TEST(test_tans_encode_decode_equal_freq);
     RUN_TEST(test_tans_encode_decode_high_zero_probability);
     RUN_TEST(test_tans_encode_decode_long_stream);
-    RUN_TEST(test_tans_encode_decode_long_stream_bulk);
 }
diff --git a/test/test_tans_encode_st.c b/test/test_tans_encode_st.c
index d4665b4..d0e81eb 100644
--- a/test/test_tans_encode_st.c
+++ b/test/test_tans_encode_st.c
@@ -1,7 +1,6 @@
 #include "test.h"
 
 #include "floor_log2.h"
-#include "tans_buf_bit_writer.h"
 #include "tans_encode_st.h"
 
 enum test_result test_tans_encode_st_equal_freq(void)
@@ -9,11 +8,9 @@ enum test_result test_tans_encode_st_equal_freq(void)
     struct tans_freq_tbl freq_tbl;
     struct tans_symbol_tbl symbol_tbl;
     struct tans_encode_st encode_st;
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
     uint8_t data[8] = {0x01, 0xfe, 0x32, 0x12, 0x06, 0x07, 0x88, 0x00};
     double p[256];
-    uint8_t buf[8] = {0};
+    uint8_t buf[4 + 8 + 4] = {0};
     uint16_t i;
     uint16_t n_symbols = 256;
     uint16_t log2_tblsz = 10;
@@ -22,14 +19,9 @@ enum test_result test_tans_encode_st_equal_freq(void)
     ASSERT_NE(tans_freq_tbl_init(&freq_tbl, n_symbols, p, log2_tblsz), -1);
     ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
     tans_encode_st_init(&encode_st, &symbol_tbl);
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, floor_log2(n_symbols));
 
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_NE(tans_encode_st_next(&encode_st, bit_writer, (uint8_t) (data[i] % n_symbols)), (uint16_t) -1);
-    }
+    ASSERT_EQ(tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4), sizeof data * 8);
 
-    ASSERT_EQ(buf_bit_writer.bit, buf_bit_writer.len * 8);
-    ASSERT_EQ(tans_encode_st_next(&encode_st, bit_writer, 0), (uint16_t) -1);
 
     return TEST_SUCCESS;
 }
@@ -39,8 +31,6 @@ enum test_result test_tans_encode_st_high_zero_probability(void)
     struct tans_freq_tbl freq_tbl;
     struct tans_symbol_tbl symbol_tbl;
     struct tans_encode_st encode_st;
-    struct tans_buf_bit_writer buf_bit_writer;
-    struct tans_bit_writer *bit_writer = (struct tans_bit_writer *) &buf_bit_writer;
     uint8_t data[8] = {0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x23};
     double p[256];
     uint8_t buf[16] = {0};
@@ -53,13 +43,8 @@ enum test_result test_tans_encode_st_high_zero_probability(void)
     ASSERT_NE(tans_freq_tbl_init(&freq_tbl, n_symbols, p, log2_tblsz), -1);
     ASSERT_EQ(tans_symbol_tbl_init(&symbol_tbl, &freq_tbl), 0);
     tans_encode_st_init(&encode_st, &symbol_tbl);
-    tans_buf_bit_writer_init(&buf_bit_writer, buf, sizeof buf);
 
-    for (i = 0; i < sizeof data; ++i) {
-        ASSERT_NE(tans_encode_st_next(&encode_st, bit_writer, (uint8_t) (data[i] % n_symbols)), (uint16_t) -1);
-    }
-
-    ASSERT_LT(buf_bit_writer.bit, 24);
+    ASSERT_LT(tans_encode_st_encode(&encode_st, data, sizeof data, buf + 4), 24);
 
     return TEST_SUCCESS;
 }