schrounpack

schrounpack

Synopsis

struct              SchroUnpack;
void                schro_unpack_byte_sync              (SchroUnpack *unpack);
void                schro_unpack_copy                   (SchroUnpack *dest,
                                                         SchroUnpack *src);
unsigned int        schro_unpack_decode_bit             (SchroUnpack *unpack);
unsigned int        schro_unpack_decode_bits            (SchroUnpack *unpack,
                                                         int n);
int                 schro_unpack_decode_sint            (SchroUnpack *unpack);
void                schro_unpack_decode_sint_s16        (int16_t *dest,
                                                         SchroUnpack *unpack,
                                                         int n);
int                 schro_unpack_decode_sint_slow       (SchroUnpack *unpack);
unsigned int        schro_unpack_decode_uint            (SchroUnpack *unpack);
int                 schro_unpack_get_bits_read          (SchroUnpack *unpack);
int                 schro_unpack_get_bits_remaining     (SchroUnpack *unpack);
void                schro_unpack_init_with_data         (SchroUnpack *unpack,
                                                         uint8_t *data,
                                                         int n_bytes,
                                                         unsigned int guard_bit);
void                schro_unpack_limit_bits_remaining   (SchroUnpack *unpack,
                                                         int n_bits);
void                schro_unpack_skip_bits              (SchroUnpack *unpack,
                                                         int n_bits);

Description

Details

struct SchroUnpack

struct SchroUnpack {
  /* pointer to data that haven't been shifted into the shift register */
  uint8_t *data;

  /* number of bits remaining that haven't been shifted into the shift
   * register */
  int n_bits_left;

  /* number of bits read by reader */
  int n_bits_read;

  /* chunk of bits we're currently frobbing, aligned to (1<<31) */
  uint32_t shift_register;
  int n_bits_in_shift_register;

  /* bit pattern used after an error */
  unsigned int guard_bit;

  /* unpacking has overrun the end of the buffer */
  int overrun;
};


schro_unpack_byte_sync ()

void                schro_unpack_byte_sync              (SchroUnpack *unpack);


schro_unpack_copy ()

void                schro_unpack_copy                   (SchroUnpack *dest,
                                                         SchroUnpack *src);


schro_unpack_decode_bit ()

unsigned int        schro_unpack_decode_bit             (SchroUnpack *unpack);


schro_unpack_decode_bits ()

unsigned int        schro_unpack_decode_bits            (SchroUnpack *unpack,
                                                         int n);


schro_unpack_decode_sint ()

int                 schro_unpack_decode_sint            (SchroUnpack *unpack);


schro_unpack_decode_sint_s16 ()

void                schro_unpack_decode_sint_s16        (int16_t *dest,
                                                         SchroUnpack *unpack,
                                                         int n);


schro_unpack_decode_sint_slow ()

int                 schro_unpack_decode_sint_slow       (SchroUnpack *unpack);


schro_unpack_decode_uint ()

unsigned int        schro_unpack_decode_uint            (SchroUnpack *unpack);


schro_unpack_get_bits_read ()

int                 schro_unpack_get_bits_read          (SchroUnpack *unpack);


schro_unpack_get_bits_remaining ()

int                 schro_unpack_get_bits_remaining     (SchroUnpack *unpack);


schro_unpack_init_with_data ()

void                schro_unpack_init_with_data         (SchroUnpack *unpack,
                                                         uint8_t *data,
                                                         int n_bytes,
                                                         unsigned int guard_bit);


schro_unpack_limit_bits_remaining ()

void                schro_unpack_limit_bits_remaining   (SchroUnpack *unpack,
                                                         int n_bits);


schro_unpack_skip_bits ()

void                schro_unpack_skip_bits              (SchroUnpack *unpack,
                                                         int n_bits);