46 const uint8_t *val_table,
int nb_codes,
47 int use_static,
int is_ac)
49 uint8_t huff_size[256];
50 uint16_t huff_code[256];
51 uint16_t huff_sym[256];
54 assert(nb_codes <= 256);
56 memset(huff_size, 0,
sizeof(huff_size));
59 for (i = 0; i < 256; i++)
60 huff_sym[i] = i + 16 * is_ac;
63 huff_sym[0] = 16 * 256;
66 huff_code, 2, 2, huff_sym, 2, 2, use_static);
104 #if FF_API_MJPEG_GLOBAL_OPTS
105 if (avctx->
flags & CODEC_FLAG_EXTERN_HUFF)
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;
165 uint8_t bits_table[17];
166 uint8_t val_table[256];
180 for (i = 1; i <= 16; i++) {
185 if (len < n || n > 256)
189 for (i = 0; i < n; i++) {
200 class, index, code_max + 1);
202 code_max + 1, 0,
class > 0) < 0)
208 code_max + 1, 0, 0) < 0)
245 if (nb_components <= 0 ||
248 if (s->
ls && !(s->
bits <= 8 || nb_components == 1)) {
250 "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
256 for (i = 0; i < nb_components; i++) {
276 "Subsampling in JPEG-LS is not supported.\n");
318 if (!(pix_fmt_id & 0xD0D0D0D0))
319 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
320 if (!(pix_fmt_id & 0x0D0D0D0D))
321 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
323 switch (pix_fmt_id) {
350 else if (s->
bits <= 8)
367 for (i = 0; i < 3; i++)
374 if (len != (8 + (3 * nb_components)))
380 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
381 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
401 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
402 0, dc_index, &s->
vlcs[0][dc_index]);
414 int dc_index,
int ac_index, int16_t *quant_matrix)
416 int code, i, j,
level, val;
424 val = val * quant_matrix[0] + s->
last_dc[component];
434 i += ((unsigned)code) >> 4;
442 int sign = (~cache) >> 31;
443 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
453 block[j] = level * quant_matrix[j];
462 int component,
int dc_index,
463 int16_t *quant_matrix,
int Al)
472 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
480 uint8_t *last_nnz,
int ac_index,
481 int16_t *quant_matrix,
482 int ss,
int se,
int Al,
int *EOBRUN)
493 for (i = ss; ; i++) {
497 run = ((unsigned) code) >> 4;
506 int sign = (~cache) >> 31;
507 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
515 block[j] = level * quant_matrix[j] << Al;
522 block[j] = level * quant_matrix[j] << Al;
551 #define REFINE_BIT(j) { \
552 UPDATE_CACHE(re, &s->gb); \
553 sign = block[j] >> 15; \
554 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
555 ((quant_matrix[j] ^ sign) - sign) << Al; \
556 LAST_SKIP_BITS(re, &s->gb, 1); \
564 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
569 j = s->scantable.permutated[i]; \
572 else if (run-- == 0) \
579 int ac_index, int16_t *quant_matrix,
580 int ss,
int se,
int Al,
int *EOBRUN)
582 int code, i = ss, j, sign, val,
run;
583 int last =
FFMIN(se, *last_nnz);
594 run = ((unsigned) code) >> 4;
601 block[j] = ((quant_matrix[j]^val) - val) << Al;
609 run = ((unsigned) code) >> 4;
630 for (; i <= last; i++) {
647 int left[3], top[3], topleft[3];
648 const int linesize = s->
linesize[0];
649 const int mask = (1 << s->
bits) - 1;
655 for (i = 0; i < 3; i++)
656 buffer[0][i] = 1 << (s->
bits + point_transform - 1);
658 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
659 const int modified_predictor = mb_y ? predictor : 1;
663 ptr += linesize >> 1;
665 for (i = 0; i < 3; i++)
666 top[i] = left[i] = topleft[i] =
buffer[0][i];
668 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
672 for (i = 0; i < 3; i++) {
678 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
680 left[i] =
buffer[mb_x][i] =
691 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
692 ptr[4 * mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
693 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
694 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
697 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
699 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
700 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
703 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
704 ptr[4 * mb_x + 0] =
buffer[mb_x][2];
705 ptr[4 * mb_x + 1] =
buffer[mb_x][1];
706 ptr[4 * mb_x + 2] =
buffer[mb_x][0];
717 const int nb_components = 3;
719 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
720 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
724 if (mb_x == 0 || mb_y == 0 || s->
interlaced) {
725 for (i = 0; i < nb_components; i++) {
727 int n, h,
v, x, y, c, j, linesize;
736 for (j = 0; j < n; j++) {
740 (linesize * (v * mb_y + y)) +
742 if (y == 0 && mb_y == 0) {
743 if (x == 0 && mb_x == 0)
744 pred = 128 << point_transform;
748 if (x == 0 && mb_x == 0)
749 pred = ptr[-linesize];
751 PREDICT(pred, ptr[-linesize - 1],
752 ptr[-linesize], ptr[-1], predictor);
756 ptr += linesize >> 1;
766 for (i = 0; i < nb_components; i++) {
768 int n, h,
v, x, y, c, j, linesize;
777 for (j = 0; j < n; j++) {
782 (linesize * (v * mb_y + y)) +
784 PREDICT(pred, ptr[-linesize - 1],
785 ptr[-linesize], ptr[-1], predictor);
807 case 0:
copy_block8(dst, src, linesize, linesize, 8);
809 case 1:
copy_block4(dst, src, linesize, linesize, 4);
811 case 2:
copy_block2(dst, src, linesize, linesize, 2);
819 int Al,
const uint8_t *mb_bitmask,
833 "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
837 for (i = 0; i < nb_components; i++) {
840 reference_data[c] = reference ? reference->
data[c] :
NULL;
845 int offset = (linesize[c] * (s->
v_scount[i] *
848 reference_data[c] += offset;
853 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
854 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
855 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
865 for (i = 0; i < nb_components; i++) {
867 int n, h,
v, x, y, c, j;
875 for (j = 0; j < n; j++) {
876 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
880 block_offset += linesize[c] >> 1;
881 ptr = data[c] + block_offset;
892 "error y=%d x=%d\n", mb_y, mb_x);
908 "error y=%d x=%d\n", mb_y, mb_x);
934 for (i = 0; i < nb_components; i++)
946 int se,
int Ah,
int Al,
947 const uint8_t *mb_bitmask,
954 const uint8_t *reference_data = reference ? reference->
data[c] :
NULL;
969 int offset = linesize >> 1;
971 reference_data += offset;
974 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
975 int block_offset = (mb_y * linesize * 8 >> s->
avctx->
lowres);
976 uint8_t *ptr = data + block_offset;
979 uint8_t *last_nnz = &s->
last_nnz[c][block_idx];
980 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
981 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
987 quant_matrix, ss, se, Al, &EOBRUN);
990 quant_matrix, ss, se, Al, &EOBRUN);
993 "error y=%d x=%d\n", mb_y, mb_x);
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 for (i = 0; i < nb_components; i++)
1074 if (nb_components > 1) {
1078 }
else if (!s->
ls) {
1081 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1090 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1091 predictor, point_transform, ilv, s->
bits,
1119 mb_bitmask, reference) < 0)
1123 mb_bitmask, reference) < 0)
1196 int t_w, t_h, v1, v2;
1207 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1216 if (len -10 - (t_w * t_h * 3) > 0)
1217 len -= t_w * t_h * 3;
1237 "Pegasus lossless jpeg header found\n");
1284 "mjpeg: error, decode_app parser read over the end\n");
1298 for (i = 0; i < len - 2; i++)
1300 if (i > 0 && cbuf[i - 1] ==
'\n')
1309 if (!strcmp(cbuf,
"AVID")) {
1313 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1315 else if ((len > 20 && !strncmp(cbuf,
"Intel(R) JPEG Library", 21)) ||
1316 (len > 19 && !strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1328 static int find_marker(
const uint8_t **pbuf_ptr,
const uint8_t *buf_end)
1330 const uint8_t *buf_ptr;
1337 buf_ptr = *pbuf_ptr;
1338 while (buf_ptr < buf_end) {
1341 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1351 av_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
1352 *pbuf_ptr = buf_ptr;
1357 const uint8_t **buf_ptr,
const uint8_t *buf_end,
1358 const uint8_t **unescaped_buf_ptr,
1359 int *unescaped_buf_size)
1369 "buffer too small, expanding to %d bytes\n", s->
buffer_size);
1373 if (start_code ==
SOS && !s->
ls) {
1374 const uint8_t *src = *buf_ptr;
1375 uint8_t *dst = s->
buffer;
1377 while (src < buf_end) {
1378 uint8_t x = *(src++);
1383 while (src < buf_end && x == 0xff)
1386 if (x >= 0xd0 && x <= 0xd7)
1393 *unescaped_buf_ptr = s->
buffer;
1394 *unescaped_buf_size = dst - s->
buffer;
1397 (buf_end - *buf_ptr) - (dst - s->
buffer));
1398 }
else if (start_code ==
SOS && s->
ls) {
1399 const uint8_t *src = *buf_ptr;
1400 uint8_t *dst = s->
buffer;
1408 while (src + t < buf_end) {
1409 uint8_t x = src[t++];
1411 while ((src + t < buf_end) && x == 0xff)
1424 uint8_t x = src[
b++];
1434 *unescaped_buf_ptr = dst;
1435 *unescaped_buf_size = (bit_count + 7) >> 3;
1437 *unescaped_buf_ptr = *buf_ptr;
1438 *unescaped_buf_size = buf_end - *buf_ptr;
1447 const uint8_t *buf = avpkt->
data;
1448 int buf_size = avpkt->
size;
1450 const uint8_t *buf_end, *buf_ptr;
1451 const uint8_t *unescaped_buf_ptr;
1452 int unescaped_buf_size;
1458 buf_end = buf + buf_size;
1459 while (buf_ptr < buf_end) {
1463 &unescaped_buf_size);
1465 if (start_code < 0) {
1467 }
else if (unescaped_buf_size > (1
U<<29)) {
1468 av_log(avctx,
AV_LOG_ERROR,
"MJPEG packet 0x%x too big (0x%x/0x%x), corrupt data?\n",
1469 start_code, unescaped_buf_ptr, buf_size);
1473 start_code, buf_end - buf_ptr);
1482 if (start_code >= 0xd0 && start_code <= 0xd7)
1484 "restart marker: %d\n", start_code & 0x0f);
1486 else if (start_code >=
APP0 && start_code <=
APP15)
1489 else if (start_code ==
COM)
1492 switch (start_code) {
1547 "Found EOI before any SOF, ignoring\n");
1566 (s->
width + 15) / 16);
1569 "QP: %d\n", picture->
quality);
1577 "Can not process SOS before SOF, skipping\n");
1602 "mjpeg: unsupported coding type (%x)\n", start_code);
1613 "marker parser used %d bytes (%d bits)\n",
1627 return buf_ptr - buf;
1643 for (i = 0; i < 3; i++) {
1644 for (j = 0; j < 4; j++)
1654 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1655 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1657 {
"extern_huff",
"Use external huffman table.",