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];
53 assert(nb_codes <= 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);
113 "mjpeg: error using external huffman table\n");
146 for (i = 0; i < 64; i++) {
164 int len,
index, i,
class, n, v, code_max;
181 for (i = 1; i <= 16; i++) {
186 if (len < n || n > 256)
190 for (i = 0; i < n; i++) {
201 class, index, code_max + 1);
202 if ((ret =
build_vlc(&s->
vlcs[
class][index], bits_table, val_table,
203 code_max + 1, 0,
class > 0)) < 0)
208 if ((ret =
build_vlc(&s->
vlcs[2][index], bits_table, val_table,
209 code_max + 1, 0, 0)) < 0)
248 if (nb_components <= 0 ||
254 "nb_components changing in interlaced picture\n");
258 if (s->
ls && !(bits <= 8 || nb_components == 1)) {
260 "JPEG-LS that is not <= 8 "
261 "bits/component or 16-bit gray");
267 for (i = 0; i < nb_components; i++) {
273 if (h_count[i] > s->
h_max)
274 s->
h_max = h_count[i];
275 if (v_count[i] > s->
v_max)
276 s->
v_max = v_count[i];
280 if (!h_count[i] || !v_count[i]) {
282 "Invalid sampling factor in component %d %d:%d\n",
283 i, h_count[i], v_count[i]);
288 i, h_count[i], v_count[i],
302 memcmp(s->
h_count, h_count,
sizeof(h_count)) ||
303 memcmp(s->
v_count, v_count,
sizeof(v_count))) {
307 memcpy(s->
h_count, h_count,
sizeof(h_count));
308 memcpy(s->
v_count, v_count,
sizeof(v_count));
338 if (!(pix_fmt_id & 0xD0D0D0D0))
339 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
340 if (!(pix_fmt_id & 0x0D0D0D0D))
341 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
343 switch (pix_fmt_id) {
370 else if (s->
bits <= 8)
391 for (i = 0; i < 3; i++)
398 if (len != (8 + (3 * nb_components)))
404 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
405 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
425 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
426 0, dc_index, &s->
vlcs[0][dc_index]);
438 int dc_index,
int ac_index, int16_t *quant_matrix)
440 int code, i, j,
level, val;
448 val = val * quant_matrix[0] + s->
last_dc[component];
458 i += ((unsigned)code) >> 4;
466 int sign = (~cache) >> 31;
467 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
477 block[j] = level * quant_matrix[j];
486 int component,
int dc_index,
487 int16_t *quant_matrix,
int Al)
496 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
504 uint8_t *last_nnz,
int ac_index,
505 int16_t *quant_matrix,
506 int ss,
int se,
int Al,
int *EOBRUN)
517 for (i = ss; ; i++) {
521 run = ((unsigned) code) >> 4;
530 int sign = (~cache) >> 31;
531 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
539 block[j] = level * quant_matrix[j] << Al;
546 block[j] = level * quant_matrix[j] << Al;
575 #define REFINE_BIT(j) { \
576 UPDATE_CACHE(re, &s->gb); \
577 sign = block[j] >> 15; \
578 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
579 ((quant_matrix[j] ^ sign) - sign) << Al; \
580 LAST_SKIP_BITS(re, &s->gb, 1); \
588 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
593 j = s->scantable.permutated[i]; \
596 else if (run-- == 0) \
603 int ac_index, int16_t *quant_matrix,
604 int ss,
int se,
int Al,
int *EOBRUN)
606 int code, i = ss, j, sign, val,
run;
607 int last =
FFMIN(se, *last_nnz);
618 run = ((unsigned) code) >> 4;
625 block[j] = ((quant_matrix[j]^val) - val) << Al;
633 run = ((unsigned) code) >> 4;
654 for (; i <= last; i++) {
671 int left[3], top[3], topleft[3];
672 const int linesize = s->
linesize[0];
673 const int mask = (1 << s->
bits) - 1;
679 for (i = 0; i < 3; i++)
680 buffer[0][i] = 1 << (s->
bits + point_transform - 1);
682 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
683 const int modified_predictor = mb_y ? predictor : 1;
687 ptr += linesize >> 1;
689 for (i = 0; i < 3; i++)
690 top[i] = left[i] = topleft[i] =
buffer[0][i];
692 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
696 for (i = 0; i < 3; i++) {
702 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
704 left[i] =
buffer[mb_x][i] =
715 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
716 ptr[4 * mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
717 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
718 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
721 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
723 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
724 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
727 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
728 ptr[4 * mb_x + 0] =
buffer[mb_x][2];
729 ptr[4 * mb_x + 1] =
buffer[mb_x][1];
730 ptr[4 * mb_x + 2] =
buffer[mb_x][0];
738 int point_transform,
int nb_components)
742 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
743 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
747 if (mb_x == 0 || mb_y == 0 || s->
interlaced) {
748 for (i = 0; i < nb_components; i++) {
750 int n, h, v, x, y, c, j, linesize;
759 for (j = 0; j < n; j++) {
763 (linesize * (v * mb_y + y)) +
765 if (y == 0 && mb_y == 0) {
766 if (x == 0 && mb_x == 0)
767 pred = 128 << point_transform;
771 if (x == 0 && mb_x == 0)
772 pred = ptr[-linesize];
774 PREDICT(pred, ptr[-linesize - 1],
775 ptr[-linesize], ptr[-1], predictor);
779 ptr += linesize >> 1;
789 for (i = 0; i < nb_components; i++) {
791 int n, h, v, x, y, c, j, linesize;
800 for (j = 0; j < n; j++) {
805 (linesize * (v * mb_y + y)) +
807 PREDICT(pred, ptr[-linesize - 1],
808 ptr[-linesize], ptr[-1], predictor);
827 int Al,
const uint8_t *mb_bitmask,
839 for (i = 0; i < nb_components; i++) {
842 reference_data[c] = reference ? reference->
data[c] :
NULL;
847 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
848 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
849 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
859 for (i = 0; i < nb_components; i++) {
861 int n, h, v, x, y, c, j;
869 for (j = 0; j < n; j++) {
870 block_offset = ((linesize[c] * (v * mb_y + y) * 8) +
874 block_offset += linesize[c] >> 1;
875 ptr = data[c] + block_offset;
879 reference_data[c] + block_offset,
887 "error y=%d x=%d\n", mb_y, mb_x);
903 "error y=%d x=%d\n", mb_y, mb_x);
910 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
928 for (i = 0; i < nb_components; i++)
940 int se,
int Ah,
int Al,
954 if (ss < 0 || ss >= 64 ||
955 se < ss || se >= 64 ||
968 int offset = linesize >> 1;
970 reference_data += offset;
973 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
974 int block_offset = mb_y * linesize * 8;
975 uint8_t *ptr = data + block_offset;
979 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
980 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
986 quant_matrix, ss, se, Al, &EOBRUN);
989 quant_matrix, ss, se, Al, &EOBRUN);
992 "error y=%d x=%d\n", mb_y, mb_x);
1000 reference_data + block_offset,
1015 int len, nb_components, i, h, v, predictor, point_transform;
1017 const int block_size = s->
lossless ? 1 : 8;
1018 int ilv, prev_shift;
1025 "decode_sos: nb_components (%d) unsupported\n", nb_components);
1028 if (len != 6 + 2 * nb_components) {
1032 for (i = 0; i < nb_components; i++) {
1041 "decode_sos: index(%d) out of components\n", index);
1071 if (nb_components > 1) {
1075 }
else if (!s->
ls) {
1078 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1087 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1088 predictor, point_transform, ilv, s->
bits,
1097 for (i = 0; i < nb_components; i++)
1106 point_transform, ilv)) < 0)
1111 point_transform)) < 0)
1116 nb_components)) < 0)
1130 prev_shift, point_transform,
1131 mb_bitmask, reference)) < 0)
1142 av_dlog(s->
avctx,
"AVRn interlaced picture marker found\n");
1216 int t_w, t_h, v1, v2;
1227 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1236 if (len -10 - (t_w * t_h * 3) > 0)
1237 len -= t_w * t_h * 3;
1257 "Pegasus lossless jpeg header found\n");
1304 "mjpeg: error, decode_app parser read over the end\n");
1318 for (i = 0; i < len - 2; i++)
1320 if (i > 0 && cbuf[i - 1] ==
'\n')
1329 if (!strcmp(cbuf,
"AVID")) {
1331 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1333 else if ((len > 20 && !strncmp(cbuf,
"Intel(R) JPEG Library", 21)) ||
1334 (len > 19 && !strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1355 buf_ptr = *pbuf_ptr;
1356 while (buf_ptr < buf_end) {
1359 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1369 av_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
1370 *pbuf_ptr = buf_ptr;
1376 const uint8_t **unescaped_buf_ptr,
1377 int *unescaped_buf_size)
1387 if (start_code ==
SOS && !s->
ls) {
1388 const uint8_t *src = *buf_ptr;
1391 while (src < buf_end) {
1397 while (src < buf_end && x == 0xff)
1400 if (x >= 0xd0 && x <= 0xd7)
1407 *unescaped_buf_ptr = s->
buffer;
1408 *unescaped_buf_size = dst - s->
buffer;
1409 memset(s->
buffer + *unescaped_buf_size, 0,
1413 (buf_end - *buf_ptr) - (dst - s->
buffer));
1414 }
else if (start_code ==
SOS && s->
ls) {
1415 const uint8_t *src = *buf_ptr;
1424 while (src + t < buf_end) {
1427 while ((src + t < buf_end) && x == 0xff)
1450 *unescaped_buf_ptr = dst;
1451 *unescaped_buf_size = (bit_count + 7) >> 3;
1452 memset(s->
buffer + *unescaped_buf_size, 0,
1455 *unescaped_buf_ptr = *buf_ptr;
1456 *unescaped_buf_size = buf_end - *buf_ptr;
1467 int buf_size = avpkt->
size;
1469 const uint8_t *buf_end, *buf_ptr;
1470 const uint8_t *unescaped_buf_ptr;
1471 int unescaped_buf_size;
1477 buf_end = buf + buf_size;
1478 while (buf_ptr < buf_end) {
1482 &unescaped_buf_size);
1484 if (start_code < 0) {
1486 }
else if (unescaped_buf_size > INT_MAX / 8) {
1488 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
1489 start_code, unescaped_buf_size, buf_size);
1494 start_code, buf_end - buf_ptr);
1497 unescaped_buf_size * 8);
1506 if (start_code >= 0xd0 && start_code <= 0xd7)
1508 "restart marker: %d\n", start_code & 0x0f);
1510 else if (start_code >=
APP0 && start_code <=
APP15)
1513 else if (start_code ==
COM)
1517 (start_code ==
SOF48 || start_code ==
LSE)) {
1522 switch (start_code) {
1578 "Found EOI before any SOF, ignoring\n");
1591 for (i = 0; frame->
data[i]; i++) {
1592 int h = frame->
height >> ((i == 1 || i == 2) ?
1612 "Can not process SOS before SOF, skipping\n");
1637 "mjpeg: unsupported coding type (%x)\n", start_code);
1645 "marker parser used %d bytes (%d bits)\n",
1658 return buf_ptr - buf;
1676 for (i = 0; i < 3; i++) {
1677 for (j = 0; j < 4; j++)
1687 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1688 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1690 {
"extern_huff",
"Use external huffman table.",
1712 .priv_class = &mjpegdec_class,