1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#ifndef __RLE_H
#define __RLE_H
#include <string.h>
#include <assert.h>
#include "mem.h"
#include "bitcoder.h"
#include "golomb.h"
#if defined(RLECODER)
#define OUTPUT_BIT(rlecoder,bit) rlecoder_write_bit(rlecoder,bit)
#define INPUT_BIT(rlecoder) rlecoder_read_bit(rlecoder)
#define OUTPUT_BIT_DIRECT(coder,bit) bitcoder_write_bit(&(coder)->bitcoder,bit)
#define INPUT_BIT_DIRECT(rlecoder) bitcoder_read_bit(&(rlecoder)->bitcoder)
#define ENTROPY_CODER RLECoderState
#define ENTROPY_ENCODER_INIT(coder,limit) rlecoder_encoder_init(coder,limit)
#define ENTROPY_ENCODER_DONE(coder) rlecoder_encoder_done(coder)
#define ENTROPY_ENCODER_FLUSH(coder) rlecoder_encoder_flush(coder)
#define ENTROPY_DECODER_INIT(coder,bitstream,limit) \
rlecoder_decoder_init(coder,bitstream,limit)
#define ENTROPY_DECODER_DONE(coder) /* nothing to do ... */
#define ENTROPY_CODER_BITSTREAM(coder) ((coder)->bitcoder.bitstream)
#define ENTROPY_CODER_EOS(coder) ((coder)->bitcoder.eos)
#define ENTROPY_CODER_SYMBOL(coder) ((coder)->symbol)
#define ENTROPY_CODER_RUNLENGTH(coder) ((coder)->count)
#define ENTROPY_CODER_SKIP(coder,skip) do { (coder)->count -= skip; } while (0)
#endif
typedef struct
{
int symbol;
uint32_t count; /* have seen count symbol's */
BitCoderState bitcoder;
GolombAdaptiveCoderState golomb_state[2]; /* 2 states for 2 symbols... */
int have_seen_1;
} RLECoderState;
/*
* bit should be 0 or 1 !!!
*/
static inline void
rlecoder_write_bit (RLECoderState * s, int bit)
{
assert (bit == 0 || bit == 1);
if (s->symbol == -1) {
s->symbol = bit & 1;
s->count = 1;
s->have_seen_1 = bit;
bitcoder_write_bit (&s->bitcoder, bit);
}
if (s->symbol != bit) {
golombcoder_encode_number (&s->golomb_state[s->symbol],
&s->bitcoder, s->count);
s->symbol = ~s->symbol & 1;
s->have_seen_1 = 1;
s->count = 1;
} else
s->count++;
}
static inline int
rlecoder_read_bit (RLECoderState * s)
{
if (s->count == 0) {
s->symbol = ~s->symbol & 1;
s->count = golombcoder_decode_number (&s->golomb_state[s->symbol],
&s->bitcoder);
if (s->bitcoder.eos) {
s->symbol = 0;
s->count = ~0;
}
}
s->count--;
return (s->symbol);
}
int coder_id = 0;
FILE *file = NULL;
static inline void
rlecoder_encoder_init (RLECoderState * s, uint32_t limit)
{
bitcoder_encoder_init (&s->bitcoder, limit);
s->symbol = -1;
s->have_seen_1 = 0;
s->golomb_state[0].count = 0;
s->golomb_state[1].count = 0;
s->golomb_state[0].bits = 5 << 3;
s->golomb_state[1].bits = 5 << 3;
}
/**
* once you called this, you better should not encode any more symbols ...
*/
static inline uint32_t
rlecoder_encoder_flush (RLECoderState * s)
{
if (s->symbol == -1 || !s->have_seen_1)
return 0;
golombcoder_encode_number (&s->golomb_state[s->symbol],
&s->bitcoder, s->count);
return bitcoder_flush (&s->bitcoder);
}
static inline void
rlecoder_decoder_init (RLECoderState * s, uint8_t * bitstream, uint32_t limit)
{
bitcoder_decoder_init (&s->bitcoder, bitstream, limit);
s->golomb_state[0].count = 0;
s->golomb_state[1].count = 0;
s->golomb_state[0].bits = 5 << 3;
s->golomb_state[1].bits = 5 << 3;
s->symbol = bitcoder_read_bit (&s->bitcoder);
s->count = golombcoder_decode_number (&s->golomb_state[s->symbol],
&s->bitcoder) - 1;
if (s->bitcoder.eos) {
s->symbol = 0;
s->count = ~0;
}
}
static inline void
rlecoder_encoder_done (RLECoderState * s)
{
bitcoder_encoder_done (&s->bitcoder);
}
#endif
|
