← Back to branch summary

~oah-dev/oah/gst-plugins-bad

« back to all changes in this revision

Viewing changes to ext/tarkin/rle.h

  • Committer: Haakon Sporsheim
  • Date: 2009-03-12 13:52:03 UTC
  • Revision ID: haakon.sporsheim@tandberg.com-20090312135203-i5k294hgkushb0mt
Initial import of git repository: git://anongit.freedesktop.org/gstreamer/gst-plugins-bad (tag: RELEASE-0_10_10)

Show diffs side-by-side

added added

removed removed

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