Skip to content

GitLab

Commit 053ffc57 authored by Mathis Rosenhauer's avatar Mathis Rosenhauer
Browse files

support all data sizes and signedness

parent 92bd99e7
Hide whitespace changes
Inline Side-by-side
Showing with 187 additions and 87 deletions
src/Makefile
View file @ 053ffc57
......@@ -29,3 +29,6 @@ test: test_encode test_decode
./test_encode 1 1 < ../data/example_data > ../data/test.ae
./test_decode 1 1 < ../data/test.ae > ../data/test
diff ../data/test ../data/example_data
./test_encode 99 99 < ../data/example_data > ../data/test.ae
./test_decode 101 101 < ../data/test.ae > ../data/test
diff ../data/test ../data/example_data
src/aed.c
View file @ 053ffc57
......@@ -15,29 +15,29 @@
#define ROS 5
typedef struct internal_state {
const uint8_t *next_in;
uint32_t *next_out;
int id; /* option ID */
uint32_t id_len; /* bit length of code option identification key */
int id_len; /* bit length of code option identification key */
int *id_table; /* table maps IDs to states */
void (*put_sample)(ae_streamp, int64_t);
size_t ref_int; /* reference sample is every ref_int samples */
uint32_t last_out; /* previous output for post-processing */
int64_t last_out; /* previous output for post-processing */
int64_t xmin; /* minimum integer for post-processing */
int64_t xmax; /* maximum integer for post-processing */
int mode; /* current mode of FSM */
size_t in_blklen; /* length of uncompressed input block
int in_blklen; /* length of uncompressed input block
should be the longest possible block */
size_t n, i; /* counter for samples */
uint32_t *block; /* block buffer for split-sample options */
int n, i; /* counter for samples */
int64_t *block; /* block buffer for split-sample options */
int se; /* set if second extension option is selected */
uint64_t acc; /* accumulator for currently used bit sequence */
uint8_t bitp; /* bit pointer to the next unused bit in accumulator */
uint32_t fs; /* last fundamental sequence in accumulator */
int bitp; /* bit pointer to the next unused bit in accumulator */
int fs; /* last fundamental sequence in accumulator */
int ref; /* 1 if current block has reference sample */
int pp; /* 1 if postprocessor has to be used */
} decode_state;
/* decoding table for the second-extension option */
static const uint32_t second_extension[36][2] = {
static const int second_extension[36][2] = {
{0, 0},
{1, 1}, {1, 1},
{2, 3}, {2, 3}, {2, 3},
......@@ -64,13 +64,28 @@ enum
M_UNCOMP_COPY,
};
static inline void u_put(ae_streamp strm, uint32_t sample)
#define PUTF(type) static void put_##type(ae_streamp strm, int64_t data) \
{ \
strm->avail_out--; \
strm->total_out++; \
*(type##_t *)strm->next_out = data; \
strm->next_out += sizeof(type##_t); \
}
PUTF(uint8)
PUTF(int8)
PUTF(uint16)
PUTF(int16)
PUTF(uint32)
PUTF(int32)
static inline void u_put(ae_streamp strm, int64_t sample)
{
int64_t x, d, th, D;
decode_state *state;
state = strm->state;
if (strm->pp && (strm->total_out % state->ref_int != 0))
if (state->pp && (strm->total_out % state->ref_int != 0))
{
d = sample;
x = state->last_out;
......@@ -98,12 +113,11 @@ static inline void u_put(ae_streamp strm, uint32_t sample)
}
sample = x + D;
}
*state->next_out++ = state->last_out = sample;
strm->avail_out--;
strm->total_out++;
state->last_out = sample;
state->put_sample(strm, sample);
}
static inline uint32_t u_get(ae_streamp strm, unsigned int n)
static inline int64_t u_get(ae_streamp strm, unsigned int n)
{
/**
Unsafe get n bit from input stream
......@@ -118,14 +132,14 @@ static inline uint32_t u_get(ae_streamp strm, unsigned int n)
{
strm->avail_in--;
strm->total_in++;
state->acc = (state->acc << 8) + *state->next_in++;
state->acc = (state->acc << 8) | *strm->next_in++;
state->bitp += 8;
}
state->bitp -= n;
return (state->acc >> state->bitp) & ((1ULL << n) - 1);
}
static inline uint32_t u_get_fs(ae_streamp strm)
static inline int u_get_fs(ae_streamp strm)
{
/**
Interpret a Fundamental Sequence from the input buffer.
......@@ -134,7 +148,7 @@ static inline uint32_t u_get_fs(ae_streamp strm)
1 is encountered. TODO: faster version.
*/
uint32_t fs = 0;
int fs = 0;
while(u_get(strm, 1) == 0)
fs++;
......@@ -178,11 +192,11 @@ static inline void fast_zero(ae_streamp strm)
static inline void fast_se(ae_streamp strm)
{
int i;
uint32_t gamma, beta, ms, delta1;
int64_t gamma, beta, ms, delta1;
i = strm->state->ref;
while (i < strm->bit_per_sample)
while (i < strm->block_size)
{
gamma = u_get_fs(strm);
beta = second_extension[gamma][0];
......@@ -226,12 +240,41 @@ int ae_decode_init(ae_streamp strm)
}
strm->state = state;
if (16 < strm->bit_per_sample)
if (strm->bit_per_sample > 16)
{
state->id_len = 5;
else if (8 < strm->bit_per_sample)
if (strm->flags & AE_DATA_SIGNED)
state->put_sample = put_int32;
else
state->put_sample = put_uint32;
}
else if (strm->bit_per_sample > 8)
{
state->id_len = 4;
if (strm->flags & AE_DATA_SIGNED)
state->put_sample = put_int16;
else
state->put_sample = put_uint16;
}
else
{
state->id_len = 3;
if (strm->flags & AE_DATA_SIGNED)
state->put_sample = put_int8;
else
state->put_sample = put_uint8;
}
if (strm->flags & AE_DATA_SIGNED)
{
state->xmin = -(1ULL << (strm->bit_per_sample - 1));
state->xmax = (1ULL << (strm->bit_per_sample - 1)) - 1;
}
else
{
state->xmin = 0;
state->xmax = (1ULL << strm->bit_per_sample) - 1;
}
state->ref_int = strm->block_size * strm->segment_size;
state->in_blklen = (strm->block_size * strm->bit_per_sample
......@@ -250,17 +293,16 @@ int ae_decode_init(ae_streamp strm)
}
state->id_table[modi - 1] = M_UNCOMP;
state->block = (uint32_t *)malloc(strm->block_size * sizeof(uint32_t));
state->block = (int64_t *)malloc(strm->block_size * sizeof(int64_t));
if (state->block == NULL)
{
return AE_MEM_ERROR;
}
strm->total_in = 0;
strm->total_out = 0;
state->xmin = 0;
state->xmax = (1ULL << strm->bit_per_sample) - 1;
state->bitp = 0;
state->pp = strm->flags & AE_DATA_PREPROCESS;
state->mode = M_ID;
return AE_OK;
}
......@@ -273,7 +315,7 @@ int ae_decode_init(ae_streamp strm)
strm->avail_in--; \
strm->total_in++; \
state->acc <<= 8; \
state->acc |= (uint64_t)(*state->next_in++); \
state->acc |= *strm->next_in++; \
state->bitp += 8; \
} \
} while (0)
......@@ -324,20 +366,18 @@ int ae_decode(ae_streamp strm, int flush)
*/
size_t zero_blocks;
uint32_t gamma, beta, ms, delta1;
int64_t gamma, beta, ms, delta1;
int k;
decode_state *state;
state = strm->state;
state->next_in = strm->next_in;
state->next_out = strm->next_out;
for (;;)
{
switch(state->mode)
{
case M_ID:
if (strm->pp
if (state->pp
&& (strm->total_out / strm->block_size) % strm->segment_size == 0)
state->ref = 1;
else
......@@ -460,7 +500,7 @@ int ae_decode(ae_streamp strm, int flush)
state->i = state->ref;
case M_SE_DECODE:
while(state->i < strm->bit_per_sample)
while(state->i < strm->block_size)
{
ASKFS();
gamma = GETFS();
......@@ -507,7 +547,5 @@ int ae_decode(ae_streamp strm, int flush)
}
req_buffer:
strm->next_in = state->next_in;
strm->next_out = state->next_out;
return AE_OK;
}
src/aee.c
View file @ 053ffc57
......@@ -28,26 +28,45 @@ enum
};
typedef struct internal_state {
const uint32_t *next_in;
uint8_t *next_out;
uint32_t id_len; /* bit length of code option identification key */
uint32_t last_in; /* previous input for preprocessing */
int id_len; /* bit length of code option identification key */
int64_t last_in; /* previous input for preprocessing */
int64_t (*get_sample)(ae_streamp);
int64_t xmin; /* minimum integer for preprocessing */
int64_t xmax; /* maximum integer for preprocessing */
int mode; /* current mode of FSM */
size_t i; /* counter for samples */
uint32_t *block_in; /* input block buffer */
int i; /* counter for samples */
int64_t *block_in; /* input block buffer */
uint8_t *block_out; /* output block buffer */
uint8_t *bp_out; /* pointer to current output */
uint8_t bitp; /* bit pointer to the next unused bit in accumulator */
uint8_t block_deferred; /* there is a block in the input buffer
int bitp; /* bit pointer to the next unused bit in accumulator */
int block_deferred; /* there is a block in the input buffer
but we first have to emit a zero block */
uint8_t ref; /* current buffer has a reference sample */
uint8_t zero_ref; /* current zero block has a reference sample */
uint32_t zero_ref_sample; /* reference sample of zero block */
size_t zero_blocks; /* number of contiguous zero blocks */
int ref; /* length of reference sample in current block
i.e. 0 or 1 depending on whether the block has
a reference sample or not */
int zero_ref; /* current zero block has a reference sample */
int64_t zero_ref_sample;/* reference sample of zero block */
int zero_blocks; /* number of contiguous zero blocks */
} encode_state;
#define GETF(type) static int64_t get_##type(ae_streamp strm) \
{ \
int64_t data; \
strm->avail_in--; \
strm->total_in++; \
data = *(type##_t *)strm->next_in; \
strm->next_in += sizeof(type##_t); \
return data; \
}
GETF(uint8)
GETF(int8)
GETF(uint16)
GETF(int16)
GETF(uint32)
GETF(int32)
int ae_encode_init(ae_streamp strm)
{
int blklen;
......@@ -67,14 +86,43 @@ int ae_encode_init(ae_streamp strm)
}
strm->state = state;
if (16 < strm->bit_per_sample)
if (strm->bit_per_sample > 16)
{
state->id_len = 5;
else if (8 < strm->bit_per_sample)
if (strm->flags & AE_DATA_SIGNED)
state->get_sample = get_int32;
else
state->get_sample = get_uint32;
}
else if (strm->bit_per_sample > 8)
{
state->id_len = 4;
if (strm->flags & AE_DATA_SIGNED)
state->get_sample = get_int16;
else
state->get_sample = get_uint16;
}
else
{
state->id_len = 3;
if (strm->flags & AE_DATA_SIGNED)
state->get_sample = get_int8;
else
state->get_sample = get_uint8;
}
if (strm->flags & AE_DATA_SIGNED)
{
state->xmin = -(1ULL << (strm->bit_per_sample - 1));
state->xmax = (1ULL << (strm->bit_per_sample - 1)) - 1;
}
else
{
state->xmin = 0;
state->xmax = (1ULL << strm->bit_per_sample) - 1;
}
state->block_in = (uint32_t *)malloc(strm->block_size * sizeof(uint32_t));
state->block_in = (int64_t *)malloc(strm->block_size * sizeof(int64_t));
if (state->block_in == NULL)
{
return AE_MEM_ERROR;
......@@ -93,8 +141,6 @@ int ae_encode_init(ae_streamp strm)
strm->total_in = 0;
strm->total_out = 0;
state->xmin = 0;
state->xmax = (1ULL << strm->bit_per_sample) - 1;
state->mode = M_NEW_BLOCK;
......@@ -105,7 +151,7 @@ int ae_encode_init(ae_streamp strm)
return AE_OK;
}
static inline void emit(encode_state *state, uint32_t data, int bits)
static inline void emit(encode_state *state, int64_t data, int bits)
{
while(bits)
{
......@@ -127,7 +173,7 @@ static inline void emit(encode_state *state, uint32_t data, int bits)
}
}
static inline void emitfs(encode_state *state, uint32_t fs)
static inline void emitfs(encode_state *state, int fs)
{
emit(state, 0, fs);
emit(state, 1, 1);
......@@ -143,14 +189,12 @@ int ae_encode(ae_streamp strm, int flush)
int i, j, zb;
int k_len[strm->bit_per_sample - 2];
int k, k_min, se_len, blk_head;
uint32_t d;
int64_t d;
int64_t theta, Delta;
encode_state *state;
state = strm->state;
state->next_in = strm->next_in;
state->next_out = strm->next_out;
for (;;)
{
......@@ -194,7 +238,7 @@ int ae_encode(ae_streamp strm, int flush)
all input there is.
*/
emit(state, 0xff, state->bitp);
*state->next_out++ = *state->bp_out;
*strm->next_out++ = *state->bp_out;
strm->avail_out--;
strm->total_out++;
}
......@@ -203,15 +247,13 @@ int ae_encode(ae_streamp strm, int flush)
}
else
{
state->block_in[state->i] = *state->next_in++;
strm->avail_in--;
strm->total_in++;
state->block_in[state->i] = state->get_sample(strm);
}
}
while (++state->i < strm->block_size);
/* preprocess block if needed */
if (strm->pp)
if (strm->flags & AE_DATA_PREPROCESS)
{
/* If this is the first block in a segment
then we need to insert a reference sample.
......@@ -371,7 +413,7 @@ int ae_encode(ae_streamp strm, int flush)
if (strm->avail_out == 0)
goto req_buffer;
*state->next_out++ = state->block_out[state->i];
*strm->next_out++ = state->block_out[state->i];
strm->avail_out--;
strm->total_out++;
state->i++;
......@@ -388,7 +430,7 @@ int ae_encode(ae_streamp strm, int flush)
break;
case M_ENCODE_SE:
emit(state, 1, state->id_len + 1);
emit(state, 1, state->id_len + 1);
if (state->ref)
emit(state, state->block_in[0], strm->bit_per_sample);
......@@ -418,7 +460,5 @@ int ae_encode(ae_streamp strm, int flush)
}
req_buffer:
strm->next_in = state->next_in;
strm->next_out = state->next_out;
return AE_OK;
}
src/libae.h
View file @ 053ffc57
......@@ -7,25 +7,33 @@ struct internal_state;
typedef struct _ae_stream
{
const void *next_in;
size_t avail_in; /* number of bytes available at next_in */
size_t total_in; /* total number of input bytes read so far */
void *next_out;
size_t avail_out; /* remaining free space at next_out */
size_t total_out; /* total number of bytes output so far */
uint32_t bit_per_sample; /* resolution in bits per sample (n = 1,..., 32) */
uint32_t block_size; /* block size in samples (J = 8 or 16) */
uint32_t segment_size; /* set of blocks between consecutive reference
samples */
uint8_t pp; /* pre/post-processor used? */
const uint8_t *next_in;
size_t avail_in; /* number of bytes available at
* next_in */
size_t total_in; /* total number of input bytes read so
* far */
uint8_t *next_out;
size_t avail_out; /* remaining free space at next_out */
size_t total_out; /* total number of bytes output so far */
uint32_t bit_per_sample; /* resolution in bits per sample (n =
* 1,..., 32) */
uint32_t block_size; /* block size in samples (J = 8 or 16) */
uint32_t segment_size; /* set of blocks between consecutive
* reference samples */
uint32_t flags;
struct internal_state *state;
} ae_stream;
typedef ae_stream *ae_streamp;
/* Coder flags */
#define AE_DATA_UNSIGNED 0
#define AE_DATA_SIGNED 1
#define AE_DATA_PREPROCESS 2 /* Set if preprocessor should be used */
/* Return codes of library functions */
#define AE_OK 0
#define AE_STREAM_END 1
#define AE_ERRNO (-1)
......@@ -33,8 +41,19 @@ typedef ae_stream *ae_streamp;
#define AE_DATA_ERROR (-3)
#define AE_MEM_ERROR (-4)
#define AE_NO_FLUSH 0
#define AE_FLUSH 1
/* Options for flushing */
#define AE_NO_FLUSH 0 /* Do not enforce output flushing. More
* input may be provided with later
* calls. So far only relevant for
* encoding. */
#define AE_FLUSH 1 /* Flush output and end encoding. The last
* call to ae_encode() must set AE_FLUSH to
* drain all output.
*
* It is not possible to continue encoding
* of the same stream after it has been
* flushed because the last byte may be
* padded with fill bits. */
int ae_decode_init(ae_streamp strm);
int ae_decode(ae_streamp strm, int flush);
......
src/test_decode.c
View file @ 053ffc57
......@@ -31,10 +31,10 @@ int main(int argc, char *argv[])
if (in == NULL || out == NULL)
return 1;
strm.bit_per_sample = 8;
strm.bit_per_sample = 17;
strm.block_size = 8;
strm.segment_size = 2;
strm.pp = 1;
strm.flags = AE_DATA_SIGNED | AE_DATA_PREPROCESS;
if (ae_decode_init(&strm) != AE_OK)
return 1;
......@@ -42,7 +42,7 @@ int main(int argc, char *argv[])
total_out = 0;
strm.avail_in = 0;
strm.avail_out = chunk_out;
strm.next_out = out;
strm.next_out = (uint8_t *)out;
input_avail = 1;
output_avail = 1;
......@@ -75,7 +75,7 @@ int main(int argc, char *argv[])
}
total_out = strm.total_out;
output_avail = 1;
strm.next_out = out;
strm.next_out = (uint8_t *)out;
strm.avail_out = chunk_out;
}
else
......
src/test_encode.c
View file @ 053ffc57
......@@ -32,10 +32,10 @@ int main(int argc, char *argv[])
if (in == NULL || out == NULL)
return 1;
strm.bit_per_sample = 8;
strm.bit_per_sample = 17;
strm.block_size = 8;
strm.segment_size = 2;
strm.pp = 1;
strm.flags = AE_DATA_SIGNED | AE_DATA_PREPROCESS;
if (ae_encode_init(&strm) != AE_OK)
return 1;
......@@ -57,7 +57,7 @@ int main(int argc, char *argv[])
in[i++] = c;
strm.avail_in = i;
strm.next_in = in;
strm.next_in = (uint8_t *)in;
if (c == EOF)
input_avail = 0;
}
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment