45 const uint8_t *val_table,
int nb_codes,
46 int use_static,
int is_ac)
49 uint16_t huff_code[256];
50 uint16_t huff_sym[256];
57 for (i = 0; i < 256; i++)
58 huff_sym[i] = i + 16 * is_ac;
61 huff_sym[0] = 16 * 256;
64 huff_code, 2, 2, huff_sym, 2, 2, use_static);
109 "error using external huffman table, switching back to internal\n");
142 for (i = 0; i < 64; i++) {
160 int len,
index, i,
class, n, v, code_max;
177 for (i = 1; i <= 16; i++) {
182 if (len < n || n > 256)
186 for (i = 0; i < n; i++) {
197 class, index, code_max + 1);
198 if ((ret =
build_vlc(&s->
vlcs[
class][index], bits_table, val_table,
199 code_max + 1, 0,
class > 0)) < 0)
204 if ((ret =
build_vlc(&s->
vlcs[2][index], bits_table, val_table,
205 code_max + 1, 0, 0)) < 0)
252 if (nb_components <= 0 ||
261 if (s->
ls && !(s->
bits <= 8 || nb_components == 1)) {
263 "For JPEG-LS anything except <= 8 bits/component"
264 " or 16-bit gray", 0);
270 memset(h_count, 0,
sizeof(h_count));
271 memset(v_count, 0,
sizeof(v_count));
272 for (i = 0; i < nb_components; i++) {
278 if (h_count[i] > s->
h_max)
279 s->
h_max = h_count[i];
280 if (v_count[i] > s->
v_max)
281 s->
v_max = v_count[i];
282 if (!h_count[i] || !v_count[i]) {
292 i, h_count[i], v_count[i],
306 || memcmp(s->
h_count, h_count,
sizeof(h_count[0])*nb_components)
307 || memcmp(s->
v_count, v_count,
sizeof(v_count[0])*nb_components)) {
312 memcpy(s->
h_count, h_count,
sizeof(h_count));
313 memcpy(s->
v_count, v_count,
sizeof(v_count));
348 if (!(pix_fmt_id & 0xD0D0D0D0))
349 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
350 if (!(pix_fmt_id & 0x0D0D0D0D))
351 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
353 switch (pix_fmt_id) {
372 s->
upscale_h = (pix_fmt_id == 0x22122100);
379 s->
upscale_v = (pix_fmt_id == 0x22211200);
409 s->
upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);
420 s->
upscale_v = (pix_fmt_id == 0x22121100) + 1;
438 else if (s->
bits <= 8)
455 for (i = 0; i < 3; i++)
462 if (len != (8 + (3 * nb_components)))
468 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
469 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
489 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
490 0, dc_index, &s->
vlcs[0][dc_index]);
502 int dc_index,
int ac_index, int16_t *quant_matrix)
504 int code, i, j,
level, val;
512 val = val * quant_matrix[0] + s->
last_dc[component];
522 i += ((unsigned)code) >> 4;
530 int sign = (~cache) >> 31;
531 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
541 block[j] = level * quant_matrix[j];
551 int16_t *quant_matrix,
int Al)
560 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
568 uint8_t *last_nnz,
int ac_index,
569 int16_t *quant_matrix,
570 int ss,
int se,
int Al,
int *EOBRUN)
581 for (i = ss; ; i++) {
585 run = ((unsigned) code) >> 4;
594 int sign = (~cache) >> 31;
595 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
603 block[j] = level * quant_matrix[j] << Al;
610 block[j] = level * quant_matrix[j] << Al;
639 #define REFINE_BIT(j) { \
640 UPDATE_CACHE(re, &s->gb); \
641 sign = block[j] >> 15; \
642 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
643 ((quant_matrix[j] ^ sign) - sign) << Al; \
644 LAST_SKIP_BITS(re, &s->gb, 1); \
652 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
657 j = s->scantable.permutated[i]; \
660 else if (run-- == 0) \
667 int ac_index, int16_t *quant_matrix,
668 int ss,
int se,
int Al,
int *EOBRUN)
670 int code, i = ss, j, sign, val,
run;
671 int last =
FFMIN(se, *last_nnz);
682 run = ((unsigned) code) >> 4;
689 block[j] = ((quant_matrix[j]^val) - val) << Al;
697 run = ((unsigned) code) >> 4;
718 for (; i <= last; i++) {
737 for (i = 0; i < nb_components; i++)
751 for (i = 0; i < nb_components; i++)
764 int left[3], top[3], topleft[3];
765 const int linesize = s->
linesize[0];
766 const int mask = (1 << s->
bits) - 1;
776 for (i = 0; i < 3; i++)
779 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
783 ptr += linesize >> 1;
785 for (i = 0; i < 3; i++)
786 top[i] = left[i] = topleft[i] =
buffer[0][i];
788 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
796 top[i] = left[i]= topleft[i]= 1 << (s->
bits - 1);
798 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
799 modified_predictor = 1;
801 for (i=0;i<nb_components;i++) {
807 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
813 left[i] =
buffer[mb_x][i] =
814 mask & (pred + (dc << point_transform));
824 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
825 ptr[3*mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
826 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
827 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
830 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
832 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
833 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
836 for(i=0; i<nb_components; i++) {
838 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
839 ptr[3*mb_x+2-
c] =
buffer[mb_x][i];
856 point_transform += bits - s->
bits;
858 av_assert0(nb_components==1 || nb_components==3);
860 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
861 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
868 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
869 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
870 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
871 for (i = 0; i < nb_components; i++) {
874 int n, h, v, x, y,
c, j, linesize;
883 if(bits>8) linesize /= 2;
892 ptr = s->
picture.
data[
c] + (linesize * (v * mb_y + y)) + (h * mb_x + x);
895 pred= 1 << (bits - 1);
901 pred= ptr[-linesize];
903 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
908 ptr += linesize >> 1;
909 pred &= (-1)<<(8-s->
bits);
910 *ptr= pred + (dc << point_transform);
912 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
915 pred= 1 << (bits - 1);
921 pred= ptr16[-linesize];
923 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
928 ptr16 += linesize >> 1;
929 pred &= (-1)<<(16-s->
bits);
930 *ptr16= pred + (dc << point_transform);
939 for (i = 0; i < nb_components; i++) {
942 int n, h, v, x, y,
c, j, linesize, dc;
951 if(bits>8) linesize /= 2;
953 for (j = 0; j < n; j++) {
961 (linesize * (v * mb_y + y)) +
963 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
965 pred &= (-1)<<(8-s->
bits);
966 *ptr = pred + (dc << point_transform);
968 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
969 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
971 pred &= (-1)<<(16-s->
bits);
972 *ptr16= pred + (dc << point_transform);
995 case 0:
copy_block8(dst, src, linesize, linesize, 8);
997 case 1:
copy_block4(dst, src, linesize, linesize, 4);
999 case 2:
copy_block2(dst, src, linesize, linesize, 2);
1001 case 3: *dst = *src;
1007 int Al,
const uint8_t *mb_bitmask,
1024 for (i = 0; i < nb_components; i++) {
1027 reference_data[
c] = reference ? reference->
data[
c] :
NULL;
1040 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1041 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1042 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
1052 for (i = 0; i < nb_components; i++) {
1054 int n, h, v, x, y,
c, j;
1062 for (j = 0; j < n; j++) {
1063 block_offset = (((linesize[
c] * (v * mb_y + y) * 8) +
1067 block_offset += linesize[
c] >> 1;
1068 ptr = data[
c] + block_offset;
1079 "error y=%d x=%d\n", mb_y, mb_x);
1095 "error y=%d x=%d\n", mb_y, mb_x);
1099 av_dlog(s->
avctx,
"mb: %d %d processed\n", mb_y, mb_x);
1102 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1117 int se,
int Ah,
int Al)
1138 data += linesize >> 1;
1142 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1147 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
1154 quant_matrix, ss, se, Al, &EOBRUN);
1157 quant_matrix, ss, se, Al, &EOBRUN);
1160 "error y=%d x=%d\n", mb_y, mb_x);
1177 int len, nb_components, i, h, v,
predictor, point_transform;
1179 const int block_size = s->
lossless ? 1 : 8;
1180 int ilv, prev_shift;
1184 "Can not process SOS before SOF, skipping\n");
1194 "decode_sos: nb_components (%d) unsupported\n", nb_components);
1197 if (len != 6 + 2 * nb_components) {
1201 for (i = 0; i < nb_components; i++) {
1210 "decode_sos: index(%d) out of components\n", index);
1221 index = (index+2)%3;
1245 prev_shift = point_transform = 0;
1247 if (nb_components > 1) {
1251 }
else if (!s->
ls) {
1254 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1263 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1273 for (i = 0; i < nb_components; i++)
1278 if (CONFIG_JPEGLS_DECODER && s->
ls) {
1283 point_transform, ilv)) < 0)
1299 point_transform)) < 0)
1303 prev_shift, point_transform,
1304 mb_bitmask, reference)) < 0)
1386 int t_w, t_h, v1, v2;
1397 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1406 if (len -10 - (t_w * t_h * 3) > 0)
1407 len -= t_w * t_h * 3;
1427 "Pegasus lossless jpeg header found\n");
1474 "mjpeg: error, decode_app parser read over the end\n");
1488 for (i = 0; i < len - 2; i++)
1490 if (i > 0 && cbuf[i - 1] ==
'\n')
1499 if (!strcmp(cbuf,
"AVID")) {
1501 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1503 else if ((len > 31 && !strncmp(cbuf,
"Intel(R) JPEG Library, version 1", 32)) ||
1504 (len > 19 && !strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1523 buf_ptr = *pbuf_ptr;
1524 while (buf_ptr < buf_end) {
1527 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1535 av_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
1536 *pbuf_ptr = buf_ptr;
1542 const uint8_t **unescaped_buf_ptr,
1543 int *unescaped_buf_size)
1553 if (start_code ==
SOS && !s->
ls) {
1554 const uint8_t *src = *buf_ptr;
1557 while (src < buf_end) {
1563 while (src < buf_end && x == 0xff)
1566 if (x >= 0xd0 && x <= 0xd7)
1573 *unescaped_buf_ptr = s->
buffer;
1574 *unescaped_buf_size = dst - s->
buffer;
1575 memset(s->
buffer + *unescaped_buf_size, 0,
1579 (buf_end - *buf_ptr) - (dst - s->
buffer));
1580 }
else if (start_code ==
SOS && s->
ls) {
1581 const uint8_t *src = *buf_ptr;
1590 while (src + t < buf_end) {
1593 while ((src + t < buf_end) && x == 0xff)
1616 *unescaped_buf_ptr =
dst;
1617 *unescaped_buf_size = (bit_count + 7) >> 3;
1618 memset(s->
buffer + *unescaped_buf_size, 0,
1621 *unescaped_buf_ptr = *buf_ptr;
1622 *unescaped_buf_size = buf_end - *buf_ptr;
1632 int buf_size = avpkt->
size;
1634 const uint8_t *buf_end, *buf_ptr;
1635 const uint8_t *unescaped_buf_ptr;
1637 int unescaped_buf_size;
1644 buf_end = buf + buf_size;
1645 while (buf_ptr < buf_end) {
1649 &unescaped_buf_size);
1651 if (start_code < 0) {
1653 }
else if (unescaped_buf_size > (1
U<<28)) {
1654 av_log(avctx,
AV_LOG_ERROR,
"MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",
1655 start_code, unescaped_buf_size, buf_size);
1659 start_code, buf_end - buf_ptr);
1668 if (start_code >= 0xd0 && start_code <= 0xd7)
1670 "restart marker: %d\n", start_code & 0x0f);
1672 else if (start_code >=
APP0 && start_code <=
APP15)
1675 else if (start_code ==
COM)
1679 switch (start_code) {
1724 if (!CONFIG_JPEGLS_DECODER ||
1733 "Found EOI before any SOF, ignoring\n");
1753 (s->
width + 15) / 16);
1756 "QP: %d\n", picture->
quality);
1780 "mjpeg: unsupported coding type (%x)\n", start_code);
1787 "marker parser used %d bytes (%d bits)\n",
1808 for (index = s->
width - 1; index; index--)
1809 line[
index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
1817 w = s->
width >> hshift;
1822 for (i = s->
height - 1; i; i--) {
1826 memcpy(dst, src1, w);
1828 for (index = 0; index < w; index++)
1829 dst[index] = (src1[index] + src2[index]) >> 1;
1837 for (index=0; index<4; index++) {
1841 if(index && index<3){
1842 w = -((-w) >> hshift);
1843 h = -((-h) >> vshift);
1847 for (i=0; i<h/2; i++) {
1849 FFSWAP(
int, dst[j], dst2[j]);
1860 return buf_ptr - buf;
1876 for (i = 0; i < 3; i++) {
1877 for (j = 0; j < 4; j++)
1893 #if CONFIG_MJPEG_DECODER
1894 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1895 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1897 {
"extern_huff",
"Use external huffman table.",
1902 static const AVClass mjpegdec_class = {
1921 .priv_class = &mjpegdec_class,
1924 #if CONFIG_THP_DECODER