$(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)
+++ /dev/null
-#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;
-};
+++ /dev/null
-#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;
-};
+++ /dev/null
-#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;
-}
+++ /dev/null
-#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);
+++ /dev/null
-#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;
-}
+++ /dev/null
-#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);
+++ /dev/null
-#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);
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;
#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;
};
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);
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);
#pragma once
#include "tans_encode_tbl.h"
-#include "tans_bit_writer.h"
struct tans_encode_st {
struct tans_symbol_tbl symbol_tbl;
};
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);
+++ /dev/null
-#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;
-}
+++ /dev/null
-#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);
+++ /dev/null
-#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;
-}
+++ /dev/null
-#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);
+++ /dev/null
-#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;
-}
+++ /dev/null
-#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);
+++ /dev/null
-#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);
-}
+++ /dev/null
-#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);
-}
+++ /dev/null
-#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);
-}
#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;
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;
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];
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;
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;
}
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);
}
#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)
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;
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;
}
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};
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;
}
projects / tANS.git / commitdiff