98 ui32 val = 0xFFFFFFFF;
104 else if (melp->
size > 0)
107 while (melp->
size > 1) {
109 ui32 m = ~(0xFFu << i);
110 val = (val & m) | (v << i);
117 ui32 m = ~(0xFFu << i);
118 val = (val & m) | (v << i);
130 bool unstuff = ((val & 0xFF) == 0xFF);
132 t = t << (8 - unstuff);
135 t |= (val>>8) & 0xFF;
136 unstuff = (((val >> 8) & 0xFF) == 0xFF);
138 t = t << (8 - unstuff);
140 t |= (val>>16) & 0xFF;
141 unstuff = (((val >> 16) & 0xFF) == 0xFF);
143 t = t << (8 - unstuff);
145 t |= (val>>24) & 0xFF;
146 melp->
unstuff = (((val >> 24) & 0xFF) == 0xFF);
150 melp->
tmp |= ((
ui64)t) << (64 - bits - melp->
bits);
172 static const int mel_exp[13] = {
173 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5
184 int eval = mel_exp[melp->
k];
186 if (melp->
tmp & (1ull<<63))
190 melp->
k = melp->
k + 1 < 12 ? melp->
k + 1 : 12;
197 run = (int)(melp->
tmp >> (63 - eval)) & ((1 << eval) - 1);
198 melp->
k = melp->
k - 1 > 0 ? melp->
k - 1 : 0;
199 melp->
tmp <<= eval + 1;
200 melp->
bits -= eval + 1;
201 run = (run << 1) + 1;
204 melp->
runs &= ~((
ui64)0x3F << eval);
223 melp->
data = bbuf + lcup - scup;
227 melp->
size = scup - 1;
235 int num = 4 - (int)(intptr_t(melp->
data) & 0x3);
236 for (
int i = 0; i < num; ++i) {
237 assert(melp->
unstuff ==
false || melp->
data[0] <= 0x8F);
240 if (melp->
size == 1) d |= 0xF;
243 int d_bits = 8 - melp->
unstuff;
244 melp->
tmp = (melp->
tmp << d_bits) | d;
245 melp->
bits += d_bits;
246 melp->
unstuff = ((d & 0xFF) == 0xFF);
249 melp->
tmp <<= (64 - melp->
bits);
265 int t = melp->
runs & 0x7F;
322 else if (vlcp->
size > 0)
325 while (vlcp->
size > 0) {
334 ui32 tmp = val >> 24;
338 bits = 8 - ((vlcp->
unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1 : 0);
339 bool unstuff = (val >> 24) > 0x8F;
341 tmp |= ((val >> 16) & 0xFF) << bits;
342 bits += 8 - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1 : 0);
343 unstuff = ((val >> 16) & 0xFF) > 0x8F;
345 tmp |= ((val >> 8) & 0xFF) << bits;
346 bits += 8 - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1 : 0);
347 unstuff = ((val >> 8) & 0xFF) > 0x8F;
349 tmp |= (val & 0xFF) << bits;
350 bits += 8 - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1 : 0);
351 unstuff = (val & 0xFF) > 0x8F;
377 vlcp->
data = data + lcup - 2;
380 vlcp->
size = scup - 2;
384 vlcp->
bits = 4 - ((vlcp->
tmp & 7) == 7);
385 vlcp->
unstuff = (d | 0xF) > 0x8F;
392 int num = 1 + (int)(intptr_t(vlcp->
data) & 0x3);
393 int tnum = num < vlcp->
size ? num : vlcp->
size;
394 for (
int i = 0; i < tnum; ++i) {
398 ui32 d_bits = 8 - ((vlcp->
unstuff && ((d & 0x7F) == 0x7F)) ? 1 : 0);
400 vlcp->
bits += d_bits;
435 assert(num_bits <= vlcp->bits);
436 vlcp->
tmp >>= num_bits;
437 vlcp->
bits -= num_bits;
465 else if (mrp->
size > 0)
468 while (mrp->
size > 0) {
477 ui32 bits, tmp = val >> 24;
480 bits = 8 - ((mrp->
unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1 : 0);
481 bool unstuff = (val >> 24) > 0x8F;
484 tmp |= ((val >> 16) & 0xFF) << bits;
485 bits += 8 - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1 : 0);
486 unstuff = ((val >> 16) & 0xFF) > 0x8F;
488 tmp |= ((val >> 8) & 0xFF) << bits;
489 bits += 8 - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1 : 0);
490 unstuff = ((val >> 8) & 0xFF) > 0x8F;
492 tmp |= (val & 0xFF) << bits;
493 bits += 8 - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1 : 0);
494 unstuff = (val & 0xFF) > 0x8F;
519 mrp->
data = data + lcup + len2 - 1;
529 int num = 1 + (int)(intptr_t(mrp->
data) & 0x3);
530 for (
int i = 0; i < num; ++i) {
533 d = (mrp->
size-- > 0) ? *mrp->
data-- : 0;
535 ui32 d_bits = 8 - ((mrp->
unstuff && ((d & 0x7F) == 0x7F)) ? 1 : 0);
571 assert(num_bits <= mrp->bits);
572 mrp->
tmp >>= num_bits;
573 mrp->
bits -= num_bits;
611 assert(msp->
bits <= 32);
619 else if (msp->
size > 0)
622 val = X != 0 ? 0xFFFFFFFFu : 0;
623 while (msp->
size > 0) {
625 ui32 m = ~(0xFFu << i);
626 val = (val & m) | (v << i);
632 val = X != 0 ? 0xFFFFFFFFu : 0;
637 bool unstuff = ((val & 0xFF) == 0xFF);
639 t |= ((val >> 8) & 0xFF) << bits;
641 unstuff = (((val >> 8) & 0xFF) == 0xFF);
643 t |= ((val >> 16) & 0xFF) << bits;
645 unstuff = (((val >> 16) & 0xFF) == 0xFF);
647 t |= ((val >> 24) & 0xFF) << bits;
649 msp->
unstuff = (((val >> 24) & 0xFF) == 0xFF);
678 int num = 4 - (int)(intptr_t(msp->
data) & 0x3);
679 for (
int i = 0; i < num; ++i)
683 d = msp->
size-- > 0 ? *msp->
data++ : X;
686 msp->
unstuff = ((d & 0xFF) == 0xFF);
700 assert(num_bits <= msp->bits);
701 msp->
tmp >>= num_bits;
702 msp->
bits -= num_bits;
748 static bool insufficient_precision =
false;
749 static bool modify_code =
false;
750 static bool truncate_spp_mrp =
false;
752 if (num_passes > 1 && lengths2 == 0)
754 OJPH_WARN(0x00010001,
"A malformed codeblock that has more than "
755 "one coding pass, but zero length for "
756 "2nd and potential 3rd pass.\n");
762 OJPH_WARN(0x00010002,
"We do not support more than 3 coding passes; "
763 "This codeblocks has %d passes.\n",
768 if (missing_msbs > 30)
770 if (insufficient_precision ==
false)
772 insufficient_precision =
true;
773 OJPH_WARN(0x00010003,
"32 bits are not enough to decode this "
774 "codeblock. This message will not be "
775 "displayed again.\n");
779 else if (missing_msbs == 30)
781 if (modify_code ==
false) {
783 OJPH_WARN(0x00010004,
"Not enough precision to decode the cleanup "
784 "pass. The code can be modified to support "
785 "this case. This message will not be "
786 "displayed again.\n");
790 else if (missing_msbs == 29)
792 if (num_passes > 1) {
794 if (truncate_spp_mrp ==
false) {
795 truncate_spp_mrp =
true;
796 OJPH_WARN(0x00010005,
"Not enough precision to decode the SgnProp "
797 "nor MagRef passes; both will be skipped. "
798 "This message will not be displayed "
803 ui32 p = 30 - missing_msbs;
809 OJPH_WARN(0x00010006,
"Wrong codeblock length.\n");
815 lcup = (int)lengths1;
817 scup = (((int)coded_data[lcup-1]) << 4) + (coded_data[lcup-2] & 0xF);
818 if (scup < 2 || scup > lcup || scup > 4079)
836 ui16 scratch[8 * 513] = {0};
844 ui32 sstr = ((width + 2u) + 7u) & ~7u;
846 ui32 mmsbp2 = missing_msbs + 2;
858 mel_init(&mel, coded_data, lcup, scup);
860 rev_init(&vlc, coded_data, lcup, scup);
870 for (
ui32 x = 0; x < width; sp += 4)
889 t0 = (run == -1) ? t0 : 0;
903 c_q = ((t0 & 0x10U) << 3) | ((t0 & 0xE0U) << 2);
912 t1 =
vlc_tbl0[c_q + (vlc_val & 0x7F)];
915 if (c_q == 0 && x < width)
920 t1 = (run == -1) ? t1 : 0;
925 t1 = x < width ? t1 : 0;
934 c_q = ((t1 & 0x10U) << 3) | ((t1 & 0xE0U) << 2);
942 ui32 uvlc_mode = ((t0 & 0x8U) << 3) | ((t1 & 0x8U) << 4);
943 if (uvlc_mode == 0xc0)
947 uvlc_mode += (run == -1) ? 0x40 : 0;
964 ui32 len = uvlc_entry & 0xF;
965 ui32 tmp = vlc_val & ((1 << len) - 1);
969 len = uvlc_entry & 0x7;
971 ui16 u_q = (
ui16)(1 + (uvlc_entry&7) + (tmp&~(0xFFU<<len)));
973 u_q = (
ui16)(1 + (uvlc_entry >> 3) + (tmp >> len));
979 for (
ui32 y = 2; y < height; y += 2)
982 ui16 *sp = scratch + (y >> 1) * sstr;
984 for (
ui32 x = 0; x < width; sp += 4)
990 c_q |= ((sp[0 - (
si32)sstr] & 0xA0U) << 2);
991 c_q |= ((sp[2 - (
si32)sstr] & 0x20U) << 4);
1007 t0 = (run == -1) ? t0 : 0;
1022 c_q = ((t0 & 0x40U) << 2) | ((t0 & 0x80U) << 1);
1024 c_q |= sp[0 - (
si32)sstr] & 0x80;
1026 c_q |= ((sp[2 - (
si32)sstr] & 0xA0U) << 2);
1027 c_q |= ((sp[4 - (
si32)sstr] & 0x20U) << 4);
1036 t1 =
vlc_tbl1[ c_q + (vlc_val & 0x7F)];
1039 if (c_q == 0 && x < width)
1044 t1 = (run == -1) ? t1 : 0;
1049 t1 = x < width ? t1 : 0;
1059 c_q = ((t1 & 0x40U) << 2) | ((t1 & 0x80U) << 1);
1061 c_q |= sp[2 - (
si32)sstr] & 0x80;
1069 ui32 uvlc_mode = ((t0 & 0x8U) << 3) | ((t1 & 0x8U) << 4);
1075 ui32 len = uvlc_entry & 0xF;
1076 ui32 tmp = vlc_val & ((1 << len) - 1);
1080 len = uvlc_entry & 0x7;
1082 ui16 u_q = (
ui16)((uvlc_entry & 7) + (tmp & ~(0xFU << len)));
1084 u_q = (
ui16)((uvlc_entry >> 3) + (tmp >> len));
1099 const int v_n_size = 512 + 4;
1100 ui32 v_n_scratch[v_n_size] = {0};
1103 frwd_init<0xFF>(&magsgn, coded_data, lcup - scup);
1106 ui32 *vp = v_n_scratch;
1107 ui32 *dp = decoded_data;
1110 for (
ui32 x = 0; x < width; sp += 2, ++vp)
1120 if (inf & (1 << (4 + bit)))
1123 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1124 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1128 v_n = ms_val & ((1 << m_n) - 1);
1129 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1133 val |= (v_n + 2) << (p - 1);
1140 if (inf & (1 << (4 + bit)))
1143 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1144 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1148 v_n = ms_val & ((1 << m_n) - 1);
1149 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1153 val |= (v_n + 2) << (p - 1);
1156 vp[0] = prev_v_n | v_n;
1164 if (inf & (1 << (4 + bit)))
1167 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1168 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1172 v_n = ms_val & ((1 << m_n) - 1);
1173 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1177 val |= (v_n + 2) << (p - 1);
1184 if (inf & (1 << (4 + bit)))
1187 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1188 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1192 v_n = ms_val & ((1 << m_n) - 1);
1193 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1197 val |= (v_n + 2) << (p - 1);
1206 for (
ui32 y = 2; y < height; y += 2)
1208 ui16 *sp = scratch + (y >> 1) * sstr;
1209 ui32 *vp = v_n_scratch;
1210 ui32 *dp = decoded_data + y * stride;
1213 for (
ui32 x = 0; x < width; sp += 2, ++vp)
1218 ui32 gamma = inf & 0xF0; gamma &= gamma - 0x10;
1219 ui32 emax = vp[0] | vp[1];
1221 ui32 kappa = gamma ? emax : 1;
1223 ui32 U_q = u_q + kappa;
1230 if (inf & (1 << (4 + bit)))
1233 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1234 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1238 v_n = ms_val & ((1 << m_n) - 1);
1239 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1243 val |= (v_n + 2) << (p - 1);
1250 if (inf & (1 << (4 + bit)))
1253 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1254 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1258 v_n = ms_val & ((1 << m_n) - 1);
1259 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1263 val |= (v_n + 2) << (p - 1);
1266 vp[0] = prev_v_n | v_n;
1274 if (inf & (1 << (4 + bit)))
1277 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1278 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1282 v_n = ms_val & ((1 << m_n) - 1);
1283 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1287 val |= (v_n + 2) << (p - 1);
1294 if (inf & (1 << (4 + bit)))
1297 ui32 ms_val = frwd_fetch<0xFF>(&magsgn);
1298 ui32 m_n = U_q - ((inf >> (12 + bit)) & 1);
1302 v_n = ms_val & ((1 << m_n) - 1);
1303 v_n |= ((inf >> (8 + bit)) & 1) << m_n;
1307 val |= (v_n + 2) << (p - 1);
1324 ui16*
const sigma = scratch;
1326 ui32 mstr = (width + 3u) >> 2;
1328 mstr = ((mstr + 2u) + 7u) & ~7u;
1335 for (y = 0; y < height; y += 4)
1337 ui16* sp = scratch + (y >> 1) * sstr;
1338 ui16* dp = sigma + (y >> 2) * mstr;
1339 for (
ui32 x = 0; x < width; x += 4, sp += 4, ++dp) {
1340 ui32 t0 = 0, t1 = 0;
1341 t0 = ((sp[0 ] & 0x30u) >> 4) | ((sp[0 ] & 0xC0u) >> 2);
1342 t0 |= ((sp[2 ] & 0x30u) << 4) | ((sp[2 ] & 0xC0u) << 6);
1343 t1 = ((sp[0+sstr] & 0x30u) >> 2) | ((sp[0+sstr] & 0xC0u) );
1344 t1 |= ((sp[2+sstr] & 0x30u) << 6) | ((sp[2+sstr] & 0xC0u) << 8);
1345 dp[0] = (
ui16)(t0 | t1);
1351 ui16* dp = sigma + (y >> 2) * mstr;
1352 for (
ui32 x = 0; x < width; x += 4, ++dp)
1369 ui16 prev_row_sig[256 + 8] = {0};
1372 frwd_init<0>(&sigprop, coded_data + lengths1, (
int)lengths2);
1374 for (
ui32 y = 0; y < height; y += 4)
1376 ui32 pattern = 0xFFFFu;
1377 if (height - y < 4) {
1379 if (height - y < 3) {
1389 ui16 *prev_sig = prev_row_sig;
1390 ui16 *cur_sig = sigma + (y >> 2) * mstr;
1391 ui32 *dpp = decoded_data + y * stride;
1392 for (
ui32 x = 0; x < width; x += 4, ++cur_sig, ++prev_sig)
1397 pattern = pattern >> (s * 4);
1412 ui32 ns = *(
ui32*)(cur_sig + mstr);
1413 ui32 u = (ps & 0x88888888) >> 3;
1415 u |= (ns & 0x11111111) << 3;
1420 mbr |= (cs & 0x77777777) << 1;
1421 mbr |= (cs & 0xEEEEEEEE) >> 1;
1437 ui32 cwd = frwd_fetch<0>(&sigprop);
1440 ui32 col_mask = 0xFu;
1441 ui32 inv_sig = ~cs & pattern;
1442 for (
int i = 0; i < 16; i += 4, col_mask <<= 4)
1444 if ((col_mask & new_sig) == 0)
1448 ui32 sample_mask = 0x1111u & col_mask;
1449 if (new_sig & sample_mask)
1451 new_sig &= ~sample_mask;
1454 ui32 t = 0x33u << i;
1455 new_sig |= t & inv_sig;
1461 if (new_sig & sample_mask)
1463 new_sig &= ~sample_mask;
1466 ui32 t = 0x76u << i;
1467 new_sig |= t & inv_sig;
1473 if (new_sig & sample_mask)
1475 new_sig &= ~sample_mask;
1478 ui32 t = 0xECu << i;
1479 new_sig |= t & inv_sig;
1485 if (new_sig & sample_mask)
1487 new_sig &= ~sample_mask;
1490 ui32 t = 0xC8u << i;
1491 new_sig |= t & inv_sig;
1502 ui32 val = 3u << (p - 2);
1504 for (
int i = 0; i < 4; ++i, ++dp, col_mask <<= 4)
1506 if ((col_mask & new_sig) == 0)
1510 ui32 sample_mask = 0x1111u & col_mask;
1511 if (new_sig & sample_mask)
1514 dp[0] = (cwd << 31) | val;
1518 sample_mask += sample_mask;
1519 if (new_sig & sample_mask)
1521 assert(dp[stride] == 0);
1522 dp[stride] = (cwd << 31) | val;
1526 sample_mask += sample_mask;
1527 if (new_sig & sample_mask)
1529 assert(dp[2 * stride] == 0);
1530 dp[2 * stride] = (cwd << 31) | val;
1534 sample_mask += sample_mask;
1535 if (new_sig & sample_mask)
1537 assert(dp[3 * stride] == 0);
1538 dp[3 * stride] = (cwd << 31) | val;
1547 *prev_sig = (
ui16)(new_sig);
1551 new_sig |= (t & 0x7777) << 1;
1552 new_sig |= (t & 0xEEEE) >> 1;
1565 rev_init_mrp(&magref, coded_data, (
int)lengths1, (
int)lengths2);
1567 for (
ui32 y = 0; y < height; y += 4)
1569 ui32 *cur_sig = (
ui32*)(sigma + (y >> 2) * mstr);
1570 ui32 *dpp = decoded_data + y * stride;
1571 ui32 half = 1 << (p - 2);
1572 for (
ui32 i = 0; i < width; i += 8)
1578 ui32 sig = *cur_sig++;
1579 ui32 col_mask = 0xFu;
1582 for (
int j = 0; j < 8; ++j)
1586 ui32 *dp = dpp + i + j;
1587 ui32 sample_mask = 0x11111111u & col_mask;
1589 for (
int k = 0; k < 4; ++k) {
1590 if (sig & sample_mask)
1593 assert((dp[0] & half) == 0);
1595 sym = (1 - sym) << (p - 1);
1600 sample_mask += sample_mask;
ui16 uvlc_tbl0[256+64]
uvlc_tbl0 contains decoding information for initial row of quads
ui16 uvlc_tbl1[256]
uvlc_tbl1 contains decoding information for non-initial row of quads
ui16 vlc_tbl0[1024]
vlc_tbl0 contains decoding information for initial row of quads
ui16 vlc_tbl1[1024]
vlc_tbl1 contains decoding information for non-initial row of quads
static ui32 rev_fetch(rev_struct *vlcp)
Retrieves 32 bits from the head of a rev_struct structure.
static void rev_init_mrp(rev_struct *mrp, ui8 *data, int lcup, int len2)
Initialized rev_struct structure for MRP segment, and reads a number of bytes such that the next 32 b...
static void mel_read(dec_mel_st *melp)
Reads and unstuffs the MEL bitstream.
static void frwd_advance(frwd_struct *msp, ui32 num_bits)
Consume num_bits bits from the bitstream of frwd_struct.
static void rev_read_mrp(rev_struct *mrp)
Reads and unstuffs from rev_struct.
static ui32 rev_fetch_mrp(rev_struct *mrp)
Retrieves 32 bits from the head of a rev_struct structure.
static ui32 rev_advance_mrp(rev_struct *mrp, ui32 num_bits)
Consumes num_bits from a rev_struct structure.
static void rev_read(rev_struct *vlcp)
Read and unstuff data from a backwardly-growing segment.
static int mel_get_run(dec_mel_st *melp)
Retrieves one run from dec_mel_st; if there are no runs stored MEL segment is decoded.
static void rev_init(rev_struct *vlcp, ui8 *data, int lcup, int scup)
Initiates the rev_struct structure and reads a few bytes to move the read address to multiple of 4.
static void mel_init(dec_mel_st *melp, ui8 *bbuf, int lcup, int scup)
Initiates a dec_mel_st structure for MEL decoding and reads some bytes in order to get the read addre...
static ui32 rev_advance(rev_struct *vlcp, ui32 num_bits)
Consumes num_bits from a rev_struct structure.
static void frwd_read(frwd_struct *msp)
Read and unstuffs 32 bits from forward-growing bitstream.
static ui32 frwd_fetch(frwd_struct *msp)
Fetches 32 bits from the frwd_struct bitstream.
static void frwd_init(frwd_struct *msp, const ui8 *data, int size)
Initialize frwd_struct struct and reads some bytes.
bool ojph_decode_codeblock(ui8 *coded_data, ui32 *decoded_data, ui32 missing_msbs, ui32 num_passes, ui32 lengths1, ui32 lengths2, ui32 width, ui32 height, ui32 stride, bool stripe_causal)
Decodes one codeblock, processing the cleanup, siginificance propagation, and magnitude refinement pa...
static void mel_decode(dec_mel_st *melp)
Decodes unstuffed MEL segment bits stored in tmp to runs.
static ui32 population_count(ui32 val)
static ui32 count_leading_zeros(ui32 val)
MEL state structure for reading and decoding the MEL bitstream.
bool unstuff
true if the next bit needs to be unstuffed
int num_runs
number of decoded runs left in runs (maximum 8)
int size
number of bytes in MEL code
ui8 * data
the address of data (or bitstream)
int k
state of MEL decoder
int bits
number of bits stored in tmp
ui64 tmp
temporary buffer for read data
ui64 runs
runs of decoded MEL codewords (7 bits/run)
State structure for reading and unstuffing of forward-growing bitstreams; these are: MagSgn and SPP b...
const ui8 * data
pointer to bitstream
ui32 bits
number of bits stored in tmp
ui64 tmp
temporary buffer of read data
ui32 unstuff
1 if a bit needs to be unstuffed from next byte
A structure for reading and unstuffing a segment that grows backward, such as VLC and MRP.
ui32 bits
number of bits stored in tmp
int size
number of bytes left
ui8 * data
pointer to where to read data
ui64 tmp
temporary buffer of read data