w3d/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