118 ui32 val = 0xFFFFFFFF;
119 if (melp->
size > 4) {
124 else if (melp->
size > 0)
127 while (melp->
size > 1) {
129 ui32 m = ~(0xFFu << i);
130 val = (val & m) | (v << i);
137 ui32 m = ~(0xFFu << i);
138 val = (val & m) | (v << i);
150 bool unstuff = ((val & 0xFF) == 0xFF);
152 t = t << (8 - unstuff);
155 t |= (val>>8) & 0xFF;
156 unstuff = (((val >> 8) & 0xFF) == 0xFF);
158 t = t << (8 - unstuff);
160 t |= (val>>16) & 0xFF;
161 unstuff = (((val >> 16) & 0xFF) == 0xFF);
163 t = t << (8 - unstuff);
165 t |= (val>>24) & 0xFF;
166 melp->
unstuff = (((val >> 24) & 0xFF) == 0xFF);
170 melp->
tmp |= ((
ui64)t) << (64 - bits - melp->
bits);
192 static const int mel_exp[13] = {
193 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 4, 5
204 int eval = mel_exp[melp->
k];
206 if (melp->
tmp & (1ull<<63))
210 melp->
k = melp->
k + 1 < 12 ? melp->
k + 1 : 12;
217 run = (int)(melp->
tmp >> (63 - eval)) & ((1 << eval) - 1);
218 melp->
k = melp->
k - 1 > 0 ? melp->
k - 1 : 0;
219 melp->
tmp <<= eval + 1;
220 melp->
bits -= eval + 1;
221 run = (run << 1) + 1;
224 melp->
runs &= ~((
ui64)0x3F << eval);
243 melp->
data = bbuf + lcup - scup;
247 melp->
size = scup - 1;
255 int num = 4 - (int)(intptr_t(melp->
data) & 0x3);
256 for (
int i = 0; i < num; ++i) {
257 assert(melp->
unstuff ==
false || melp->
data[0] <= 0x8F);
260 if (melp->
size == 1) d |= 0xF;
263 int d_bits = 8 - melp->
unstuff;
264 melp->
tmp = (melp->
tmp << d_bits) | d;
265 melp->
bits += d_bits;
266 melp->
unstuff = ((d & 0xFF) == 0xFF);
269 melp->
tmp <<= (64 - melp->
bits);
285 int t = melp->
runs & 0x7F;
341 else if (vlcp->
size > 0)
344 while (vlcp->
size > 0) {
353 ui32 tmp = val >> 24;
357 bits = 8 - ((vlcp->
unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1 : 0);
358 bool unstuff = (val >> 24) > 0x8F;
360 tmp |= ((val >> 16) & 0xFF) << bits;
361 bits += 8 - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1 : 0);
362 unstuff = ((val >> 16) & 0xFF) > 0x8F;
364 tmp |= ((val >> 8) & 0xFF) << bits;
365 bits += 8 - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1 : 0);
366 unstuff = ((val >> 8) & 0xFF) > 0x8F;
368 tmp |= (val & 0xFF) << bits;
369 bits += 8 - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1 : 0);
370 unstuff = (val & 0xFF) > 0x8F;
395 vlcp->
data = data + lcup - 2;
398 vlcp->
size = scup - 2;
402 vlcp->
bits = 4 - ((vlcp->
tmp & 7) == 7);
403 vlcp->
unstuff = (d | 0xF) > 0x8F;
410 int num = 1 + (int)(intptr_t(vlcp->
data) & 0x3);
411 int tnum = num < vlcp->
size ? num : vlcp->
size;
412 for (
int i = 0; i < tnum; ++i) {
416 ui32 d_bits = 8 - ((vlcp->
unstuff && ((d & 0x7F) == 0x7F)) ? 1 : 0);
418 vlcp->
bits += d_bits;
451 assert(num_bits <= vlcp->bits);
452 vlcp->
tmp >>= num_bits;
453 vlcp->
bits -= num_bits;
480 else if (mrp->
size > 0)
483 while (mrp->
size > 0) {
492 ui32 bits, tmp = val >> 24;
495 bits = 8 - ((mrp->
unstuff && (((val >> 24) & 0x7F) == 0x7F)) ? 1 : 0);
496 bool unstuff = (val >> 24) > 0x8F;
499 tmp |= ((val >> 16) & 0xFF) << bits;
500 bits += 8 - ((unstuff && (((val >> 16) & 0x7F) == 0x7F)) ? 1 : 0);
501 unstuff = ((val >> 16) & 0xFF) > 0x8F;
503 tmp |= ((val >> 8) & 0xFF) << bits;
504 bits += 8 - ((unstuff && (((val >> 8) & 0x7F) == 0x7F)) ? 1 : 0);
505 unstuff = ((val >> 8) & 0xFF) > 0x8F;
507 tmp |= (val & 0xFF) << bits;
508 bits += 8 - ((unstuff && ((val & 0x7F) == 0x7F)) ? 1 : 0);
509 unstuff = (val & 0xFF) > 0x8F;
533 mrp->
data = data + lcup + len2 - 1;
543 int num = 1 + (int)(intptr_t(mrp->
data) & 0x3);
544 for (
int i = 0; i < num; ++i) {
547 d = (mrp->
size-- > 0) ? *mrp->
data-- : 0;
549 ui32 d_bits = 8 - ((mrp->
unstuff && ((d & 0x7F) == 0x7F)) ? 1 : 0);
583 assert(num_bits <= mrp->bits);
584 mrp->
tmp >>= num_bits;
585 mrp->
bits -= num_bits;
596 const bool debug =
false;
605 struct vlc_src_table {
int c_q, rho, u_off, e_k, e_1, cwd, cwd_len; };
607 vlc_src_table tbl0[] = {
611 size_t tbl0_size =
sizeof(tbl0) /
sizeof(vlc_src_table);
614 vlc_src_table tbl1[] = {
618 size_t tbl1_size =
sizeof(tbl1) /
sizeof(vlc_src_table);
625 for (
int i = 0; i < 1024; ++i)
631 for (
size_t j = 0; j < tbl0_size; ++j)
632 if (tbl0[j].c_q == c_q)
633 if (tbl0[j].cwd == (cwd & ((1 << tbl0[j].cwd_len) - 1)))
635 if (debug) assert(
vlc_tbl0[i] == 0);
637 vlc_tbl0[i] = (
ui16)((tbl0[j].rho << 4) | (tbl0[j].u_off << 3)
638 | (tbl0[j].e_k << 12) | (tbl0[j].e_1 << 8) | tbl0[j].cwd_len);
645 for (
int i = 0; i < 1024; ++i)
649 for (
size_t j = 0; j < tbl1_size; ++j)
650 if (tbl1[j].c_q == c_q)
651 if (tbl1[j].cwd == (cwd & ((1 << tbl1[j].cwd_len) - 1)))
653 if (debug) assert(
vlc_tbl1[i] == 0);
654 vlc_tbl1[i] = (
ui16)((tbl1[j].rho << 4) | (tbl1[j].u_off << 3)
655 | (tbl1[j].e_k << 12) | (tbl1[j].e_1 << 8) | tbl1[j].cwd_len);
681 static const ui8 dec[8] = {
682 3 | (5 << 2) | (5 << 5),
683 1 | (0 << 2) | (1 << 5),
684 2 | (0 << 2) | (2 << 5),
685 1 | (0 << 2) | (1 << 5),
686 3 | (1 << 2) | (3 << 5),
687 1 | (0 << 2) | (1 << 5),
688 2 | (0 << 2) | (2 << 5),
689 1 | (0 << 2) | (1 << 5)
692 ui32 consumed_bits = 0;
699 ui32 d = dec[vlc & 0x7];
701 consumed_bits += d & 0x3;
703 ui32 suffix_len = ((d >> 2) & 0x7);
704 consumed_bits += suffix_len;
706 d = (d >> 5) + (vlc & ((1U << suffix_len) - 1));
707 u[0] = (mode == 1) ? d + 1 : 1;
708 u[1] = (mode == 1) ? 1 : d + 1;
712 ui32 d1 = dec[vlc & 0x7];
714 consumed_bits += d1 & 0x3;
719 u[1] = (vlc & 1) + 1 + 1;
723 ui32 suffix_len = ((d1 >> 2) & 0x7);
724 consumed_bits += suffix_len;
725 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1));
730 ui32 d2 = dec[vlc & 0x7];
732 consumed_bits += d2 & 0x3;
734 ui32 suffix_len = ((d1 >> 2) & 0x7);
735 consumed_bits += suffix_len;
737 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1));
741 suffix_len = ((d2 >> 2) & 0x7);
742 consumed_bits += suffix_len;
744 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1));
750 ui32 d1 = dec[vlc & 0x7];
752 consumed_bits += d1 & 0x3;
754 ui32 d2 = dec[vlc & 0x7];
756 consumed_bits += d2 & 0x3;
758 ui32 suffix_len = ((d1 >> 2) & 0x7);
759 consumed_bits += suffix_len;
761 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1));
765 suffix_len = ((d2 >> 2) & 0x7);
766 consumed_bits += suffix_len;
768 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1));
771 return consumed_bits;
791 static const ui8 dec[8] = {
792 3 | (5 << 2) | (5 << 5),
793 1 | (0 << 2) | (1 << 5),
794 2 | (0 << 2) | (2 << 5),
795 1 | (0 << 2) | (1 << 5),
796 3 | (1 << 2) | (3 << 5),
797 1 | (0 << 2) | (1 << 5),
798 2 | (0 << 2) | (2 << 5),
799 1 | (0 << 2) | (1 << 5)
802 ui32 consumed_bits = 0;
809 ui32 d = dec[vlc & 0x7];
811 consumed_bits += d & 0x3;
813 ui32 suffix_len = ((d >> 2) & 0x7);
814 consumed_bits += suffix_len;
816 d = (d >> 5) + (vlc & ((1U << suffix_len) - 1));
817 u[0] = (mode == 1) ? d + 1 : 1;
818 u[1] = (mode == 1) ? 1 : d + 1;
822 ui32 d1 = dec[vlc & 0x7];
824 consumed_bits += d1 & 0x3;
826 ui32 d2 = dec[vlc & 0x7];
828 consumed_bits += d2 & 0x3;
830 ui32 suffix_len = ((d1 >> 2) & 0x7);
831 consumed_bits += suffix_len;
833 d1 = (d1 >> 5) + (vlc & ((1U << suffix_len) - 1));
837 suffix_len = ((d2 >> 2) & 0x7);
838 consumed_bits += suffix_len;
840 d2 = (d2 >> 5) + (vlc & ((1U << suffix_len) - 1));
843 return consumed_bits;
886 assert(msp->
bits <= 32);
894 else if (msp->
size > 0)
897 val = X != 0 ? 0xFFFFFFFFu : 0;
898 while (msp->
size > 0) {
900 ui32 m = ~(0xFFu << i);
901 val = (val & m) | (v << i);
907 val = X != 0 ? 0xFFFFFFFFu : 0;
912 bool unstuff = ((val & 0xFF) == 0xFF);
914 t |= ((val >> 8) & 0xFF) << bits;
916 unstuff = (((val >> 8) & 0xFF) == 0xFF);
918 t |= ((val >> 16) & 0xFF) << bits;
920 unstuff = (((val >> 16) & 0xFF) == 0xFF);
922 t |= ((val >> 24) & 0xFF) << bits;
924 msp->
unstuff = (((val >> 24) & 0xFF) == 0xFF);
952 int num = 4 - (int)(intptr_t(msp->
data) & 0x3);
953 for (
int i = 0; i < num; ++i)
957 d = msp->
size-- > 0 ? *msp->
data++ : X;
960 msp->
unstuff = ((d & 0xFF) == 0xFF);
973 assert(num_bits <= msp->bits);
974 msp->
tmp >>= num_bits;
975 msp->
bits -= num_bits;
1015 ui32 missing_msbs,
ui32 num_passes,
1020 static bool insufficient_precision =
false;
1021 static bool modify_code =
false;
1022 static bool truncate_spp_mrp =
false;
1036 ui32 sigma1[129] = { 0 }, sigma2[129] = { 0 };
1039 ui32 mbr1[129] = { 0 }, mbr2[129] = { 0 };
1044 if (num_passes > 1 && lengths2 == 0)
1046 OJPH_WARN(0x00010001,
"A malformed codeblock that has more than "
1047 "one coding pass, but zero length for "
1048 "2nd and potential 3rd pass.\n");
1054 OJPH_WARN(0x00010002,
"We do not support more than 3 coding passes; "
1055 "This codeblocks has %d passes.\n",
1060 if (missing_msbs > 30)
1062 if (insufficient_precision ==
false)
1064 insufficient_precision =
true;
1065 OJPH_WARN(0x00010003,
"32 bits are not enough to decode this "
1066 "codeblock. This message will not be "
1067 "displayed again.\n");
1071 else if (missing_msbs == 30)
1073 if (modify_code ==
false) {
1075 OJPH_WARN(0x00010004,
"Not enough precision to decode the cleanup "
1076 "pass. The code can be modified to support "
1077 "this case. This message will not be "
1078 "displayed again.\n");
1082 else if (missing_msbs == 29)
1084 if (num_passes > 1) {
1086 if (truncate_spp_mrp ==
false) {
1087 truncate_spp_mrp =
true;
1088 OJPH_WARN(0x00010005,
"Not enough precision to decode the SgnProp "
1089 "nor MagRef passes; both will be skipped. "
1090 "This message will not be displayed "
1095 ui32 p = 30 - missing_msbs;
1101 OJPH_WARN(0x00010006,
"Wrong codeblock length.\n");
1107 lcup = (int)lengths1;
1109 scup = (((int)coded_data[lcup-1]) << 4) + (coded_data[lcup-2] & 0xF);
1110 if (scup < 2 || scup > lcup || scup > 4079)
1115 mel_init(&mel, coded_data, lcup, scup);
1117 rev_init(&vlc, coded_data, lcup, scup);
1119 frwd_init<0xFF>(&magsgn, coded_data, lcup - scup);
1122 frwd_init<0>(&sigprop, coded_data + lengths1, (
int)lengths2);
1125 rev_init_mrp(&magref, coded_data, (
int)lengths1, (
int)lengths2);
1135 ui8 *lsp, line_state[514];
1145 ui32 qinf[2] = { 0 };
1147 ui32* sp = decoded_data;
1149 for (
ui32 x = 0; x < width; x += 4)
1163 qinf[0] =
vlc_tbl0[ (c_q << 7) | (vlc_val & 0x7F) ];
1172 qinf[0] = (run == -1) ? qinf[0] : 0;
1180 c_q = ((qinf[0] & 0x10) >> 4) | ((qinf[0] & 0xE0) >> 5);
1199 *sip |= (((qinf[0] & 0x30)>>4) | ((qinf[0] & 0xC0)>>2)) << sip_shift;
1206 qinf[1] =
vlc_tbl0[(c_q << 7) | (vlc_val & 0x7F)];
1214 qinf[1] = (run == -1) ? qinf[1] : 0;
1221 c_q = ((qinf[1] & 0x10) >> 4) | ((qinf[1] & 0xE0) >> 5);
1241 *sip |= (((qinf[1] & 0x30) | ((qinf[1] & 0xC0)<<2))) << (4+sip_shift);
1243 sip += x & 0x7 ? 1 : 0;
1251 ui32 uvlc_mode = ((qinf[0] & 0x8) >> 3) | ((qinf[1] & 0x8) >> 2);
1255 uvlc_mode += (run == -1) ? 1 : 0;
1261 if (U_q[0] > missing_msbs + 2 || U_q[1] > missing_msbs + 2)
1263 OJPH_WARN(0x00010007,
"Malformed codeblock bitstream. Uq is larger "
1264 "than missing_msbs + 2.\n");
1278 if (x + 4 > width) locs >>= (x + 4 - width) << 1;
1279 locs = height > 1 ? locs : (locs & 0x55);
1281 if ((((qinf[0] & 0xF0) >> 4) | (qinf[1] & 0xF0)) & ~locs)
1283 OJPH_WARN(0x00010008,
"Malformed codeblock bitstream. Decoded VLC "
1284 "code indicates that there are significant samples "
1285 "outside the codeblock area.\n");
1292 ms_val = frwd_fetch<0xFF>(&magsgn);
1293 m_n = U_q[0] - ((qinf[0] >> 12) & 1);
1296 ui32 val = ms_val << 31;
1297 v_n = ms_val & ((1U << m_n) - 1);
1298 v_n |= ((qinf[0] & 0x100) >> 8) << m_n;
1302 sp[0] = val | ((v_n + 2) << (p - 1));
1304 else if (locs & 0x1)
1309 ms_val = frwd_fetch<0xFF>(&magsgn);
1310 m_n = U_q[0] - ((qinf[0] >> 13) & 1);
1312 ui32 val = ms_val << 31;
1313 v_n = ms_val & ((1U << m_n) - 1);
1314 v_n |= ((qinf[0] & 0x200) >> 9) << m_n;
1318 sp[stride] = val | ((v_n + 2) << (p - 1));
1321 ui32 t = lsp[0] & 0x7F;
1323 lsp[0] = (
ui8)(0x80 | (t > v_n ? t : v_n));
1325 else if (locs & 0x2)
1334 ms_val = frwd_fetch<0xFF>(&magsgn);
1335 m_n = U_q[0] - ((qinf[0] >> 14) & 1);
1337 ui32 val = ms_val << 31;
1338 v_n = ms_val & ((1U << m_n) - 1);
1339 v_n |= (((qinf[0] & 0x400) >> 10) << m_n);
1341 sp[0] = val | ((v_n + 2) << (p - 1));
1343 else if (locs & 0x4)
1349 ms_val = frwd_fetch<0xFF>(&magsgn);
1350 m_n = U_q[0] - ((qinf[0] >> 15) & 1);
1352 ui32 val = ms_val << 31;
1353 v_n = ms_val & ((1U << m_n) - 1);
1354 v_n |= ((qinf[0] & 0x800) >> 11) << m_n;
1356 sp[stride] = val | ((v_n + 2) << (p - 1));
1361 else if (locs & 0x8)
1369 ms_val = frwd_fetch<0xFF>(&magsgn);
1370 m_n = U_q[1] - ((qinf[1] >> 12) & 1);
1372 ui32 val = ms_val << 31;
1373 v_n = ms_val & ((1U << m_n) - 1);
1374 v_n |= (((qinf[1] & 0x100) >> 8) << m_n);
1376 sp[0] = val | ((v_n + 2) << (p - 1));
1378 else if (locs & 0x10)
1383 ms_val = frwd_fetch<0xFF>(&magsgn);
1384 m_n = U_q[1] - ((qinf[1] >> 13) & 1);
1386 ui32 val = ms_val << 31;
1387 v_n = ms_val & ((1U << m_n) - 1);
1388 v_n |= (((qinf[1] & 0x200) >> 9) << m_n);
1390 sp[stride] = val | ((v_n + 2) << (p - 1));
1393 ui32 t = lsp[0] & 0x7F;
1395 lsp[0] = (
ui8)(0x80 | (t > v_n ? t : v_n));
1397 else if (locs & 0x20)
1405 ms_val = frwd_fetch<0xFF>(&magsgn);
1406 m_n = U_q[1] - ((qinf[1] >> 14) & 1);
1408 ui32 val = ms_val << 31;
1409 v_n = ms_val & ((1U << m_n) - 1);
1410 v_n |= (((qinf[1] & 0x400) >> 10) << m_n);
1412 sp[0] = val | ((v_n + 2) << (p - 1));
1414 else if (locs & 0x40)
1420 ms_val = frwd_fetch<0xFF>(&magsgn);
1421 m_n = U_q[1] - ((qinf[1] >> 15) & 1);
1423 ui32 val = ms_val << 31;
1424 v_n = ms_val & ((1U << m_n) - 1);
1425 v_n |= (((qinf[1] & 0x800) >> 11) << m_n);
1427 sp[stride] = val | ((v_n + 2) << (p - 1));
1432 else if (locs & 0x80)
1440 for (
ui32 y = 2; y < height; )
1443 sip_shift &= 0xFFFFFFEFU;
1444 ui32 *sip = y & 0x4 ? sigma2 : sigma1;
1449 sp = decoded_data + y * stride;
1451 for (
ui32 x = 0; x < width; x += 4)
1460 c_q |= (lsp[1] >> 5) & 0x4;
1465 qinf[0] =
vlc_tbl1[(c_q << 7) | (vlc_val & 0x7F)];
1469 qinf[0] = (run == -1) ? qinf[0] : 0;
1474 c_q = ((qinf[0] & 0x40) >> 5) | ((qinf[0] & 0x80) >> 6);
1488 *sip |= (((qinf[0]&0x30) >> 4) | ((qinf[0]&0xC0) >> 2)) << sip_shift;
1494 c_q |= (lsp[1] >> 7);
1495 c_q |= (lsp[2] >> 5) & 0x4;
1496 qinf[1] =
vlc_tbl1[(c_q << 7) | (vlc_val & 0x7F)];
1500 qinf[1] = (run == -1) ? qinf[1] : 0;
1505 c_q = ((qinf[1] & 0x40) >> 5) | ((qinf[1] & 0x80) >> 6);
1511 *sip |= (((qinf[1]&0x30) | ((qinf[1]&0xC0) << 2))) << (4+sip_shift);
1513 sip += x & 0x7 ? 1 : 0;
1519 ui32 uvlc_mode = ((qinf[0] & 0x8) >> 3) | ((qinf[1] & 0x8) >> 2);
1524 if ((qinf[0] & 0xF0) & ((qinf[0] & 0xF0) - 1))
1526 ui32 E = (ls0 & 0x7Fu);
1527 E = E > (lsp[1] & 0x7Fu) ? E : (lsp[1]&0x7Fu);
1529 U_q[0] += E > 2 ? E - 2 : 0;
1532 if ((qinf[1] & 0xF0) & ((qinf[1] & 0xF0) - 1))
1534 ui32 E = (lsp[1] & 0x7Fu);
1535 E = E > (lsp[2] & 0x7Fu) ? E : (lsp[2]&0x7Fu);
1537 U_q[1] += E > 2 ? E - 2 : 0;
1540 if (U_q[0] > missing_msbs + 2 || U_q[1] > missing_msbs + 2)
1542 OJPH_WARN(0x00010007,
"Malformed codeblock bitstream. Uq is "
1543 "larger than missing_msbs + 2\n");
1548 lsp[1] = lsp[2] = 0;
1557 if (x + 4 > width) locs >>= (x + 4 - width) << 1;
1558 locs = y + 2 <= height ? locs : (locs & 0x55);
1560 if ((((qinf[0] & 0xF0) >> 4) | (qinf[1] & 0xF0)) & ~locs)
1562 OJPH_WARN(0x00010008,
"Malformed codeblock bitstream. Decoded VLC "
1563 "code indicates that there are significant samples "
1564 "outside the codeblock area.\n");
1570 ms_val = frwd_fetch<0xFF>(&magsgn);
1571 m_n = U_q[0] - ((qinf[0] >> 12) & 1);
1573 ui32 val = ms_val << 31;
1574 v_n = ms_val & ((1U << m_n) - 1);
1575 v_n |= ((qinf[0] & 0x100) >> 8) << m_n;
1577 sp[0] = val | ((v_n + 2) << (p - 1));
1579 else if (locs & 0x1)
1584 ms_val = frwd_fetch<0xFF>(&magsgn);
1585 m_n = U_q[0] - ((qinf[0] >> 13) & 1);
1587 ui32 val = ms_val << 31;
1588 v_n = ms_val & ((1U << m_n) - 1);
1589 v_n |= ((qinf[0] & 0x200) >> 9) << m_n;
1591 sp[stride] = val | ((v_n + 2) << (p - 1));
1594 ui32 t = lsp[0] & 0x7F;
1596 lsp[0] = (
ui8)(0x80 | (t > v_n ? t : v_n));
1598 else if (locs & 0x2)
1606 ms_val = frwd_fetch<0xFF>(&magsgn);
1607 m_n = U_q[0] - ((qinf[0] >> 14) & 1);
1609 ui32 val = ms_val << 31;
1610 v_n = ms_val & ((1U << m_n) - 1);
1611 v_n |= (((qinf[0] & 0x400) >> 10) << m_n);
1613 sp[0] = val | ((v_n + 2) << (p - 1));
1615 else if (locs & 0x4)
1620 ms_val = frwd_fetch<0xFF>(&magsgn);
1621 m_n = U_q[0] - ((qinf[0] >> 15) & 1);
1623 ui32 val = ms_val << 31;
1624 v_n = ms_val & ((1U << m_n) - 1);
1625 v_n |= ((qinf[0] & 0x800) >> 11) << m_n;
1627 sp[stride] = val | ((v_n + 2) << (p - 1));
1632 else if (locs & 0x8)
1642 ms_val = frwd_fetch<0xFF>(&magsgn);
1643 m_n = U_q[1] - ((qinf[1] >> 12) & 1);
1645 ui32 val = ms_val << 31;
1646 v_n = ms_val & ((1U << m_n) - 1);
1647 v_n |= (((qinf[1] & 0x100) >> 8) << m_n);
1649 sp[0] = val | ((v_n + 2) << (p - 1));
1651 else if (locs & 0x10)
1656 ms_val = frwd_fetch<0xFF>(&magsgn);
1657 m_n = U_q[1] - ((qinf[1] >> 13) & 1);
1659 ui32 val = ms_val << 31;
1660 v_n = ms_val & ((1U << m_n) - 1);
1661 v_n |= (((qinf[1] & 0x200) >> 9) << m_n);
1663 sp[stride] = val | ((v_n + 2) << (p - 1));
1666 ui32 t = lsp[0] & 0x7F;
1668 lsp[0] = (
ui8)(0x80 | (t > v_n ? t : v_n));
1670 else if (locs & 0x20)
1678 ms_val = frwd_fetch<0xFF>(&magsgn);
1679 m_n = U_q[1] - ((qinf[1] >> 14) & 1);
1681 ui32 val = ms_val << 31;
1682 v_n = ms_val & ((1U << m_n) - 1);
1683 v_n |= (((qinf[1] & 0x400) >> 10) << m_n);
1685 sp[0] = val | ((v_n + 2) << (p - 1));
1687 else if (locs & 0x40)
1692 ms_val = frwd_fetch<0xFF>(&magsgn);
1693 m_n = U_q[1] - ((qinf[1] >> 15) & 1);
1695 ui32 val = ms_val << 31;
1696 v_n = ms_val & ((1U << m_n) - 1);
1697 v_n |= (((qinf[1] & 0x800) >> 11) << m_n);
1699 sp[stride] = val | ((v_n + 2) << (p - 1));
1704 else if (locs & 0x80)
1714 if (num_passes > 1 && (y & 3) == 0)
1720 ui32 *cur_sig = y & 0x4 ? sigma1 : sigma2;
1722 ui32 *dpp = decoded_data + (y - 4) * stride;
1723 ui32 half = 1 << (p - 2);
1724 for (
ui32 i = 0; i < width; i += 8)
1730 ui32 sig = *cur_sig++;
1731 ui32 col_mask = 0xFu;
1735 for (
int j = 0; j < 8; ++j, dp++)
1739 ui32 sample_mask = 0x11111111u & col_mask;
1741 if (sig & sample_mask)
1746 dp[0] ^= (1 - sym) << (p - 1);
1750 sample_mask += sample_mask;
1752 if (sig & sample_mask)
1754 assert(dp[stride] != 0);
1756 dp[stride] ^= (1 - sym) << (p - 1);
1760 sample_mask += sample_mask;
1762 if (sig & sample_mask)
1764 assert(dp[2 * stride] != 0);
1766 dp[2 * stride] ^= (1 - sym) << (p - 1);
1767 dp[2 * stride] |= half;
1770 sample_mask += sample_mask;
1772 if (sig & sample_mask)
1774 assert(dp[3 * stride] != 0);
1776 dp[3 * stride] ^= (1 - sym) << (p - 1);
1777 dp[3 * stride] |= half;
1780 sample_mask += sample_mask;
1793 ui32 *sig = y & 0x4 ? sigma1 : sigma2;
1794 ui32 *mbr = y & 0x4 ? mbr1 : mbr2;
1800 for (
ui32 i = 0; i < width; i += 8, mbr++, sig++)
1804 mbr[0] |= prev >> 28;
1805 mbr[0] |= sig[0] << 4;
1806 mbr[0] |= sig[0] >> 4;
1807 mbr[0] |= sig[1] << 28;
1811 ui32 t = mbr[0], z = mbr[0];
1812 z |= (t & 0x77777777) << 1;
1813 z |= (t & 0xEEEEEEEE) >> 1;
1814 mbr[0] = z & ~sig[0];
1820 ui32 *cur_sig, *cur_mbr, *nxt_sig, *nxt_mbr;
1823 cur_sig = y & 0x4 ? sigma2 : sigma1;
1824 cur_mbr = y & 0x4 ? mbr2 : mbr1;
1825 nxt_sig = y & 0x4 ? sigma1 : sigma2;
1827 for (
ui32 i = 0; i < width; i+=8, cur_mbr++, cur_sig++, nxt_sig++)
1829 ui32 t = nxt_sig[0];
1831 t |= nxt_sig[0] << 4;
1832 t |= nxt_sig[0] >> 4;
1833 t |= nxt_sig[1] << 28;
1836 if (stripe_causal ==
false)
1837 cur_mbr[0] |= (t & 0x11111111u) << 3;
1838 cur_mbr[0] &= ~cur_sig[0];
1842 cur_sig = y & 0x4 ? sigma2 : sigma1;
1843 cur_mbr = y & 0x4 ? mbr2 : mbr1;
1844 nxt_sig = y & 0x4 ? sigma1 : sigma2;
1845 nxt_mbr = y & 0x4 ? mbr1 : mbr2;
1846 ui32 val = 3u << (p - 2);
1848 for (
ui32 i = 0; i < width;
1849 i += 8, cur_sig++, cur_mbr++, nxt_sig++, nxt_mbr++)
1851 ui32 mbr = *cur_mbr;
1855 for (
ui32 n = 0; n < 8; n += 4)
1857 ui32 cwd = frwd_fetch<0>(&sigprop);
1860 ui32 *dp = decoded_data + (y - 8) * stride;
1863 ui32 col_mask = 0xFu << (4 * n);
1865 ui32 inv_sig = ~cur_sig[0];
1868 ui32 end = n + 4 + i < width ? n + 4 : width - i;
1870 for (
ui32 j = n; j < end; ++j, ++dp, col_mask <<= 4)
1872 if ((col_mask & mbr) == 0)
1876 ui32 sample_mask = 0x11111111u & col_mask;
1877 if (mbr & sample_mask)
1882 new_sig |= sample_mask;
1883 ui32 t = 0x32u << (j * 4);
1890 sample_mask += sample_mask;
1891 if (mbr & sample_mask)
1893 assert(dp[stride] == 0);
1896 new_sig |= sample_mask;
1897 ui32 t = 0x74u << (j * 4);
1903 sample_mask += sample_mask;
1904 if (mbr & sample_mask)
1906 assert(dp[2 * stride] == 0);
1909 new_sig |= sample_mask;
1910 ui32 t = 0xE8u << (j * 4);
1916 sample_mask += sample_mask;
1917 if (mbr & sample_mask)
1919 assert(dp[3 * stride] == 0);
1922 new_sig |= sample_mask;
1923 ui32 t = 0xC0u << (j * 4);
1931 if (new_sig & (0xFFFFu << (4 * n)))
1933 ui32 *dp = decoded_data + (y - 8) * stride;
1935 ui32 col_mask = 0xFu << (4 * n);
1937 for (
ui32 j = n; j < end; ++j, ++dp, col_mask <<= 4)
1939 if ((col_mask & new_sig) == 0)
1943 ui32 sample_mask = 0x11111111u & col_mask;
1944 if (new_sig & sample_mask)
1947 dp[0] |= ((cwd & 1) << 31) | val;
1952 sample_mask += sample_mask;
1953 if (new_sig & sample_mask)
1955 assert(dp[stride] == 0);
1956 dp[stride] |= ((cwd & 1) << 31) | val;
1960 sample_mask += sample_mask;
1961 if (new_sig & sample_mask)
1963 assert(dp[2 * stride] == 0);
1964 dp[2 * stride] |= ((cwd & 1) << 31) | val;
1968 sample_mask += sample_mask;
1969 if (new_sig & sample_mask)
1971 assert(dp[3 * stride] == 0);
1972 dp[3 * stride] |= ((cwd & 1) << 31) | val;
1985 ui32 t = new_sig >> 28;
1986 t |= ((t & 0xE) >> 1) | ((t & 7) << 1);
1987 cur_mbr[1] |= t & ~cur_sig[1];
1992 new_sig |= cur_sig[0];
1993 ui32 u = (new_sig & 0x88888888) >> 3;
1994 ui32 t = u | (u << 4) | (u >> 4);
1996 nxt_mbr[-1] |= (u << 28) & ~nxt_sig[-1];
1997 nxt_mbr[0] |= t & ~nxt_sig[0];
1998 nxt_mbr[1] |= (u >> 28) & ~nxt_sig[1];
2003 cur_sig = y & 0x4 ? sigma2 : sigma1;
2004 memset(cur_sig, 0, (((width + 7) >> 3) + 1) << 2);
2010 if (num_passes > 1) {
2012 if (num_passes > 2 && ((height & 3) == 1 || (height & 3) == 2))
2014 ui32 *cur_sig = height & 0x4 ? sigma2 : sigma1;
2015 ui32 *dpp = decoded_data + (height & 0xFFFFFFFCu) * stride;
2016 ui32 half = 1 << (p - 2);
2017 for (
ui32 i = 0; i < width; i += 8)
2020 ui32 sig = *cur_sig++;
2021 ui32 col_mask = 0xF;
2025 for (
int j = 0; j < 8; ++j, dp++)
2029 ui32 sample_mask = 0x11111111u & col_mask;
2031 if (sig & sample_mask)
2035 dp[0] ^= (1 - sym) << (p - 1);
2039 sample_mask += sample_mask;
2041 if (sig & sample_mask)
2043 assert(dp[stride] != 0);
2045 dp[stride] ^= (1 - sym) << (p - 1);
2049 sample_mask += sample_mask;
2051 if (sig & sample_mask)
2053 assert(dp[2 * stride] != 0);
2055 dp[2 * stride] ^= (1 - sym) << (p - 1);
2056 dp[2 * stride] |= half;
2059 sample_mask += sample_mask;
2061 if (sig & sample_mask)
2063 assert(dp[3 * stride] != 0);
2065 dp[3 * stride] ^= (1 - sym) << (p - 1);
2066 dp[3 * stride] |= half;
2069 sample_mask += sample_mask;
2081 if ((height & 3) == 1 || (height & 3) == 2)
2084 ui32 *sig = height & 0x4 ? sigma2 : sigma1;
2085 ui32 *mbr = height & 0x4 ? mbr2 : mbr1;
2088 for (
ui32 i = 0; i < width; i += 8, mbr++, sig++)
2091 mbr[0] |= prev >> 28;
2092 mbr[0] |= sig[0] << 4;
2093 mbr[0] |= sig[0] >> 4;
2094 mbr[0] |= sig[1] << 28;
2098 ui32 t = mbr[0], z = mbr[0];
2099 z |= (t & 0x77777777) << 1;
2100 z |= (t & 0xEEEEEEEE) >> 1;
2101 mbr[0] = z & ~sig[0];
2106 st -= height > 6 ? (((height + 1) & 3) + 3) : height;
2107 for (
ui32 y = st; y < height; y += 4)
2109 ui32 *cur_sig, *cur_mbr, *nxt_sig, *nxt_mbr;
2111 ui32 pattern = 0xFFFFFFFFu;
2112 if (height - y == 3)
2113 pattern = 0x77777777u;
2114 else if (height - y == 2)
2115 pattern = 0x33333333u;
2116 else if (height - y == 1)
2117 pattern = 0x11111111u;
2122 cur_sig = y & 0x4 ? sigma2 : sigma1;
2123 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2124 nxt_sig = y & 0x4 ? sigma1 : sigma2;
2126 for (
ui32 i = 0; i<width; i += 8, cur_mbr++, cur_sig++, nxt_sig++)
2128 ui32 t = nxt_sig[0];
2130 t |= nxt_sig[0] << 4;
2131 t |= nxt_sig[0] >> 4;
2132 t |= nxt_sig[1] << 28;
2135 if (stripe_causal ==
false)
2136 cur_mbr[0] |= (t & 0x11111111u) << 3;
2138 cur_mbr[0] &= ~cur_sig[0];
2143 cur_sig = y & 0x4 ? sigma2 : sigma1;
2144 cur_mbr = y & 0x4 ? mbr2 : mbr1;
2145 nxt_sig = y & 0x4 ? sigma1 : sigma2;
2146 nxt_mbr = y & 0x4 ? mbr1 : mbr2;
2147 ui32 val = 3u << (p - 2);
2148 for (
ui32 i = 0; i < width; i += 8,
2149 cur_sig++, cur_mbr++, nxt_sig++, nxt_mbr++)
2151 ui32 mbr = *cur_mbr & pattern;
2155 for (
ui32 n = 0; n < 8; n += 4)
2157 ui32 cwd = frwd_fetch<0>(&sigprop);
2160 ui32 *dp = decoded_data + y * stride;
2163 ui32 col_mask = 0xFu << (4 * n);
2165 ui32 inv_sig = ~cur_sig[0] & pattern;
2167 ui32 end = n + 4 + i < width ? n + 4 : width - i;
2168 for (
ui32 j = n; j < end; ++j, ++dp, col_mask <<= 4)
2170 if ((col_mask & mbr) == 0)
2174 ui32 sample_mask = 0x11111111u & col_mask;
2175 if (mbr & sample_mask)
2180 new_sig |= sample_mask;
2181 ui32 t = 0x32u << (j * 4);
2187 sample_mask += sample_mask;
2188 if (mbr & sample_mask)
2190 assert(dp[stride] == 0);
2193 new_sig |= sample_mask;
2194 ui32 t = 0x74u << (j * 4);
2200 sample_mask += sample_mask;
2201 if (mbr & sample_mask)
2203 assert(dp[2 * stride] == 0);
2206 new_sig |= sample_mask;
2207 ui32 t = 0xE8u << (j * 4);
2213 sample_mask += sample_mask;
2214 if (mbr & sample_mask)
2216 assert(dp[3 * stride] == 0);
2219 new_sig |= sample_mask;
2220 ui32 t = 0xC0u << (j * 4);
2228 if (new_sig & (0xFFFFu << (4 * n)))
2230 ui32 *dp = decoded_data + y * stride;
2232 ui32 col_mask = 0xFu << (4 * n);
2234 for (
ui32 j = n; j < end; ++j, ++dp, col_mask <<= 4)
2236 if ((col_mask & new_sig) == 0)
2240 ui32 sample_mask = 0x11111111u & col_mask;
2241 if (new_sig & sample_mask)
2244 dp[0] |= ((cwd & 1) << 31) | val;
2248 sample_mask += sample_mask;
2249 if (new_sig & sample_mask)
2251 assert(dp[stride] == 0);
2252 dp[stride] |= ((cwd & 1) << 31) | val;
2256 sample_mask += sample_mask;
2257 if (new_sig & sample_mask)
2259 assert(dp[2 * stride] == 0);
2260 dp[2 * stride] |= ((cwd & 1) << 31) | val;
2264 sample_mask += sample_mask;
2265 if (new_sig & sample_mask)
2267 assert(dp[3 * stride] == 0);
2268 dp[3 * stride] |= ((cwd & 1) << 31) | val;
2281 ui32 t = new_sig >> 28;
2282 t |= ((t & 0xE) >> 1) | ((t & 7) << 1);
2283 cur_mbr[1] |= t & ~cur_sig[1];
2288 new_sig |= cur_sig[0];
2289 ui32 u = (new_sig & 0x88888888) >> 3;
2290 ui32 t = u | (u << 4) | (u >> 4);
2292 nxt_mbr[-1] |= (u << 28) & ~nxt_sig[-1];
2293 nxt_mbr[0] |= t & ~nxt_sig[0];
2294 nxt_mbr[1] |= (u >> 28) & ~nxt_sig[1];
static bool vlc_tables_initialized
Initializes VLC tables vlc_tbl0 and vlc_tbl1.
static bool vlc_init_tables()
Initializes vlc_tbl0 and vlc_tbl1 tables, from table0.h and table1.h.
static ui16 vlc_tbl1[1024]
vlc_tbl1 contains decoding information for non-initial row of quads
static ui16 vlc_tbl0[1024]
vlc_tbl0 contains decoding information for initial row of quads
static void mel_read(dec_mel_st *melp)
Reads and unstuffs the MEL bitstream.
void frwd_advance(frwd_struct *msp, ui32 num_bits)
Consume num_bits bits from the bitstream of frwd_struct.
ui32 decode_init_uvlc(ui32 vlc, ui32 mode, ui32 *u)
Decode initial UVLC to get the u value (or u_q)
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.
ui32 frwd_fetch(frwd_struct *msp)
Fetches 32 bits from the frwd_struct bitstream.
void frwd_init(frwd_struct *msp, const ui8 *data, int size)
Initialize frwd_struct struct and reads some bytes.
ui32 rev_advance_mrp(rev_struct *mrp, ui32 num_bits)
Consumes num_bits from a rev_struct structure.
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.
ui32 rev_fetch(rev_struct *vlcp)
Retrieves 32 bits from the head of a rev_struct structure.
void rev_read_mrp(rev_struct *mrp)
Reads and unstuffs from rev_struct.
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...
ui32 decode_noninit_uvlc(ui32 vlc, ui32 mode, ui32 *u)
Decode non-initial UVLC to get the u value (or u_q)
ui32 rev_advance(rev_struct *vlcp, ui32 num_bits)
Consumes num_bits from a rev_struct structure.
void frwd_read(frwd_struct *msp)
Read and unstuffs 32 bits from forward-growing bitstream.
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...
void rev_read(rev_struct *vlcp)
Read and unstuff data from a backwardly-growing segment.
ui32 rev_fetch_mrp(rev_struct *mrp)
Retrieves 32 bits from the head of a rev_struct structure.
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_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
int k
state of MEL decoder
int bits
number of bits stored in tmp
ui8 * data
the address of data (or bitstream)
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...
ui64 tmp
temporary buffer of read data
ui32 bits
number of bits stored in tmp
bool unstuff
true if a bit needs to be unstuffed from next byte
const ui8 * data
pointer to bitstream
A structure for reading and unstuffing a segment that grows backward, such as VLC and MRP.
ui8 * data
pointer to where to read data
ui32 bits
number of bits stored in tmp
int size
number of bytes left
ui64 tmp
temporary buffer of read data