33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
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 && !(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],
305 || memcmp(s->
h_count, h_count,
sizeof(h_count))
306 || memcmp(s->
v_count, v_count,
sizeof(v_count))) {
312 memcpy(s->
h_count, h_count,
sizeof(h_count));
313 memcpy(s->
v_count, v_count,
sizeof(v_count));
352 if (!(pix_fmt_id & 0xD0D0D0D0))
353 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
354 if (!(pix_fmt_id & 0x0D0D0D0D))
355 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
357 switch (pix_fmt_id) {
376 s->
upscale_h = (pix_fmt_id == 0x22122100);
383 s->
upscale_v = (pix_fmt_id == 0x22211200);
413 s->
upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);
424 s->
upscale_v = (pix_fmt_id == 0x22121100) + 1;
445 }
else if (s->
bits <= 8)
462 for (i = 0; i < 3; i++)
469 if (len != (8 + (3 * nb_components)))
480 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
481 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
501 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
502 0, dc_index, &s->
vlcs[0][dc_index]);
514 int dc_index,
int ac_index, int16_t *quant_matrix)
516 int code, i, j,
level, val;
524 val = val * quant_matrix[0] + s->
last_dc[component];
534 i += ((unsigned)code) >> 4;
542 int sign = (~cache) >> 31;
543 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
553 block[j] = level * quant_matrix[j];
562 int component,
int dc_index,
563 int16_t *quant_matrix,
int Al)
572 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
580 uint8_t *last_nnz,
int ac_index,
581 int16_t *quant_matrix,
582 int ss,
int se,
int Al,
int *EOBRUN)
593 for (i = ss; ; i++) {
597 run = ((unsigned) code) >> 4;
606 int sign = (~cache) >> 31;
607 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
615 block[j] = level * quant_matrix[j] << Al;
622 block[j] = level * quant_matrix[j] << Al;
651 #define REFINE_BIT(j) { \
652 UPDATE_CACHE(re, &s->gb); \
653 sign = block[j] >> 15; \
654 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
655 ((quant_matrix[j] ^ sign) - sign) << Al; \
656 LAST_SKIP_BITS(re, &s->gb, 1); \
664 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
669 j = s->scantable.permutated[i]; \
672 else if (run-- == 0) \
679 int ac_index, int16_t *quant_matrix,
680 int ss,
int se,
int Al,
int *EOBRUN)
682 int code, i = ss, j, sign, val,
run;
683 int last =
FFMIN(se, *last_nnz);
694 run = ((unsigned) code) >> 4;
701 block[j] = ((quant_matrix[j]^val) - val) << Al;
709 run = ((unsigned) code) >> 4;
730 for (; i <= last; i++) {
749 for (i = 0; i < nb_components; i++)
763 for (i = 0; i < nb_components; i++)
776 int left[3], top[3], topleft[3];
777 const int linesize = s->
linesize[0];
778 const int mask = (1 << s->
bits) - 1;
794 for (i = 0; i < 3; i++)
797 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
801 ptr += linesize >> 1;
803 for (i = 0; i < 3; i++)
804 top[i] = left[i] = topleft[i] =
buffer[0][i];
806 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
814 top[i] = left[i]= topleft[i]= 1 << (s->
bits - 1);
816 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
817 modified_predictor = 1;
819 for (i=0;i<nb_components;i++) {
825 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
831 left[i] =
buffer[mb_x][i] =
832 mask & (pred + (dc << point_transform));
842 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
843 ptr[3*mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
844 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
845 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
848 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
850 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
851 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
854 for(i=0; i<nb_components; i++) {
856 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
857 ptr[3*mb_x+2-
c] =
buffer[mb_x][i];
873 point_transform += bits - s->
bits;
875 av_assert0(nb_components>=1 && nb_components<=3);
877 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
878 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
885 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
886 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
887 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
888 for (i = 0; i < nb_components; i++) {
891 int n, h,
v, x,
y,
c, j, linesize;
900 if(bits>8) linesize /= 2;
909 ptr = s->
picture.
data[
c] + (linesize * (v * mb_y +
y)) + (h * mb_x + x);
912 pred= 1 << (bits - 1);
918 pred= ptr[-linesize];
920 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
925 ptr += linesize >> 1;
926 pred &= (-1)<<(8-s->
bits);
927 *ptr= pred + (dc << point_transform);
929 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
932 pred= 1 << (bits - 1);
938 pred= ptr16[-linesize];
940 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
945 ptr16 += linesize >> 1;
946 pred &= (-1)<<(16-s->
bits);
947 *ptr16= pred + (dc << point_transform);
956 for (i = 0; i < nb_components; i++) {
959 int n, h,
v, x,
y,
c, j, linesize,
dc;
968 if(bits>8) linesize /= 2;
970 for (j = 0; j < n; j++) {
978 (linesize * (v * mb_y +
y)) +
980 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
982 pred &= (-1)<<(8-s->
bits);
983 *ptr = pred + (dc << point_transform);
985 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
986 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
988 pred &= (-1)<<(16-s->
bits);
989 *ptr16= pred + (dc << point_transform);
1010 int linesize,
int lowres)
1015 case 1:
copy_block4(dst, src, linesize, linesize, 4);
1017 case 2:
copy_block2(dst, src, linesize, linesize, 2);
1019 case 3: *dst = *src;
1025 int Al,
const uint8_t *mb_bitmask,
1042 for (i = 0; i < nb_components; i++) {
1045 reference_data[
c] = reference ? reference->
data[
c] :
NULL;
1058 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1059 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1060 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
1070 for (i = 0; i < nb_components; i++) {
1072 int n, h,
v, x,
y,
c, j;
1080 for (j = 0; j < n; j++) {
1081 block_offset = (((linesize[
c] * (v * mb_y +
y) * 8) +
1085 block_offset += linesize[
c] >> 1;
1086 if ( 8*(h * mb_x + x) < s->
width
1087 && 8*(v * mb_y +
y) < s->
height) {
1088 ptr = data[
c] + block_offset;
1103 "error y=%d x=%d\n", mb_y, mb_x);
1121 "error y=%d x=%d\n", mb_y, mb_x);
1125 av_dlog(s->
avctx,
"mb: %d %d processed\n", mb_y, mb_x);
1128 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1143 int se,
int Ah,
int Al)
1164 data += linesize >> 1;
1168 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1173 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
1180 quant_matrix, ss, se, Al, &EOBRUN);
1183 quant_matrix, ss, se, Al, &EOBRUN);
1186 "error y=%d x=%d\n", mb_y, mb_x);
1203 int len, nb_components, i, h,
v,
predictor, point_transform;
1205 const int block_size = s->
lossless ? 1 : 8;
1206 int ilv, prev_shift;
1210 "Can not process SOS before SOF, skipping\n");
1220 "decode_sos: nb_components (%d) unsupported\n", nb_components);
1223 if (len != 6 + 2 * nb_components) {
1227 for (i = 0; i < nb_components; i++) {
1236 "decode_sos: index(%d) out of components\n", index);
1247 index = (index+2)%3;
1271 prev_shift = point_transform = 0;
1273 if (nb_components > 1) {
1277 }
else if (!s->
ls) {
1280 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1289 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1299 for (i = 0; i < nb_components; i++)
1309 point_transform, ilv)) < 0)
1325 point_transform)) < 0)
1329 prev_shift, point_transform,
1330 mb_bitmask, reference)) < 0)
1411 int t_w, t_h, v1, v2;
1422 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1431 if (len -10 - (t_w * t_h * 3) > 0)
1432 len -= t_w * t_h * 3;
1454 "Pegasus lossless jpeg header found\n");
1510 "mjpeg: error, decode_app parser read over the end\n");
1524 for (i = 0; i < len - 2; i++)
1526 if (i > 0 && cbuf[i - 1] ==
'\n')
1535 if (!strcmp(cbuf,
"AVID")) {
1537 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1539 else if ((len > 31 && !strncmp(cbuf,
"Intel(R) JPEG Library, version 1", 32)) ||
1540 (len > 19 && !strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1559 buf_ptr = *pbuf_ptr;
1560 while (buf_ptr < buf_end) {
1563 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1571 av_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
1572 *pbuf_ptr = buf_ptr;
1578 const uint8_t **unescaped_buf_ptr,
1579 int *unescaped_buf_size)
1589 if (start_code ==
SOS && !s->
ls) {
1590 const uint8_t *src = *buf_ptr;
1593 while (src < buf_end) {
1599 while (src < buf_end && x == 0xff)
1602 if (x >= 0xd0 && x <= 0xd7)
1609 *unescaped_buf_ptr = s->
buffer;
1610 *unescaped_buf_size = dst - s->
buffer;
1611 memset(s->
buffer + *unescaped_buf_size, 0,
1615 (buf_end - *buf_ptr) - (dst - s->
buffer));
1616 }
else if (start_code ==
SOS && s->
ls) {
1617 const uint8_t *src = *buf_ptr;
1624 while (src + t < buf_end) {
1627 while ((src + t < buf_end) && x == 0xff)
1654 *unescaped_buf_ptr =
dst;
1655 *unescaped_buf_size = (bit_count + 7) >> 3;
1656 memset(s->
buffer + *unescaped_buf_size, 0,
1659 *unescaped_buf_ptr = *buf_ptr;
1660 *unescaped_buf_size = buf_end - *buf_ptr;
1670 int buf_size = avpkt->
size;
1672 const uint8_t *buf_end, *buf_ptr;
1673 const uint8_t *unescaped_buf_ptr;
1675 int unescaped_buf_size;
1682 buf_end = buf + buf_size;
1683 while (buf_ptr < buf_end) {
1687 &unescaped_buf_size);
1689 if (start_code < 0) {
1691 }
else if (unescaped_buf_size > (1
U<<28)) {
1692 av_log(avctx,
AV_LOG_ERROR,
"MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",
1693 start_code, unescaped_buf_size, buf_size);
1697 start_code, buf_end - buf_ptr);
1706 if (start_code >= 0xd0 && start_code <= 0xd7)
1708 "restart marker: %d\n", start_code & 0x0f);
1710 else if (start_code >=
APP0 && start_code <=
APP15)
1713 else if (start_code ==
COM)
1717 switch (start_code) {
1771 "Found EOI before any SOF, ignoring\n");
1791 (s->
width + 15) / 16);
1794 "QP: %d\n", picture->
quality);
1819 "mjpeg: unsupported coding type (%x)\n", start_code);
1826 "marker parser used %d bytes (%d bits)\n",
1847 for (index = s->
width - 1; index; index--)
1848 line[
index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
1856 w = s->
width >> hshift;
1861 for (i = s->
height - 1; i; i--) {
1865 memcpy(dst, src1, w);
1867 for (index = 0; index < w; index++)
1868 dst[index] = (src1[index] + src2[index]) >> 1;
1876 for (index=0; index<4; index++) {
1880 if(index && index<3){
1881 w = -((-w) >> hshift);
1882 h = -((-h) >> vshift);
1886 for (i=0; i<h/2; i++) {
1888 FFSWAP(
int, dst[j], dst2[j]);
1899 return buf_ptr - buf;
1915 for (i = 0; i < 3; i++) {
1916 for (j = 0; j < 4; j++)
1932 #if CONFIG_MJPEG_DECODER
1933 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1934 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1936 {
"extern_huff",
"Use external huffman table.",
1941 static const AVClass mjpegdec_class = {
1960 .priv_class = &mjpegdec_class,
1963 #if CONFIG_THP_DECODER