56 for (
int i = 1, k = 0;
i <= 16;
i++) {
57 int nb = bits_table[
i];
58 for (
int j = 0; j < nb;j++) {
66 const uint8_t *val_table,
int nb_codes,
67 int is_ac,
void *logctx)
70 uint16_t huff_sym[256];
77 for (i = 0; i < nb_codes; i++) {
78 huff_sym[
i] = val_table[
i] + 16 * is_ac;
80 if (is_ac && !val_table[i])
81 huff_sym[
i] = 16 * 256;
85 huff_sym, 2, 2, 0, 0, logctx);
114 ht[i].
bits, ht[i].values, ht[i].length,
115 ht[i].class == 1, s->
avctx);
119 if (ht[i].
class < 2) {
123 ht[i].values, ht[i].length);
133 if (len > 14 && buf[12] == 1)
135 if (len > 14 && buf[12] == 2)
189 "error using external huffman table, switching back to internal\n");
249 for (i = 0; i < 64; i++) {
262 len -= 1 + 64 * (1+pr);
292 for (i = 1; i <= 16; i++) {
297 if (len < n || n > 256)
300 for (i = 0; i < n; i++) {
310 if ((ret =
build_vlc(&s->
vlcs[
class][index], bits_table, val_table,
311 n,
class > 0, s->
avctx)) < 0)
316 if ((ret =
build_vlc(&s->
vlcs[2][index], bits_table, val_table,
317 n, 0, s->
avctx)) < 0)
321 for (i = 0; i < 16; i++)
323 for (i = 0; i < 256; i++)
343 if (bits > 16 || bits < 1) {
373 if (s->
buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->
buf_size * 4LL)
377 if (nb_components <= 0 ||
383 "nb_components changing in interlaced picture\n");
387 if (s->
ls && !(bits <= 8 || nb_components == 1)) {
389 "JPEG-LS that is not <= 8 " 390 "bits/component or 16-bit gray");
393 if (len != 8 + 3 * nb_components) {
401 for (i = 0; i < nb_components; i++) {
407 if (h_count[i] > s->
h_max)
409 if (v_count[i] > s->
v_max)
416 if (!h_count[i] || !v_count[i]) {
418 "Invalid sampling factor in component %d %d:%d\n",
419 i, h_count[i], v_count[i]);
424 i, h_count[i], v_count[i],
427 if ( nb_components == 4
440 if (nb_components == 2) {
454 memcmp(s->
h_count, h_count,
sizeof(h_count)) ||
455 memcmp(s->
v_count, v_count,
sizeof(v_count))) {
461 memcpy(s->
h_count, h_count,
sizeof(h_count));
462 memcpy(s->
v_count, v_count,
sizeof(v_count));
499 if (s->
v_max == 1 && s->
h_max == 1 && s->
lossless==1 && (nb_components==3 || nb_components==4))
504 pix_fmt_id = ((unsigned)s->
h_count[0] << 28) | (s->
v_count[0] << 24) |
511 if (!(pix_fmt_id & 0xD0D0D0D0))
512 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
513 if (!(pix_fmt_id & 0x0D0D0D0D))
514 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
516 for (i = 0; i < 8; i++) {
517 int j = 6 + (i&1) - (i&6);
518 int is = (pix_fmt_id >> (4*
i)) & 0xF;
519 int js = (pix_fmt_id >> (4*j)) & 0xF;
521 if (is == 1 && js != 2 && (i < 2 || i > 5))
522 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
523 if (is == 1 && js != 2 && (i < 2 || i > 5))
524 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
526 if (is == 1 && js == 2) {
533 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
537 switch (pix_fmt_id) {
626 if (pix_fmt_id == 0x14111100)
667 if (pix_fmt_id == 0x42111100) {
671 }
else if (pix_fmt_id == 0x24111100) {
675 }
else if (pix_fmt_id == 0x23111100) {
712 else if (s->
bits <= 8)
728 #if CONFIG_MJPEG_NVDEC_HWACCEL 731 #if CONFIG_MJPEG_VAAPI_HWACCEL 759 for (i = 0; i < 4; i++)
778 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
779 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
812 if (code < 0 || code > 16) {
814 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
815 0, dc_index, &s->
vlcs[0][dc_index]);
827 int dc_index,
int ac_index, uint16_t *quant_matrix)
833 if (val == 0xfffff) {
837 val = val * (unsigned)quant_matrix[0] + s->
last_dc[component];
838 val = av_clip_int16(val);
848 i += ((unsigned)code) >> 4;
856 int sign = (~cache) >> 31;
857 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
867 block[j] = level * quant_matrix[
i];
876 int component,
int dc_index,
877 uint16_t *quant_matrix,
int Al)
882 if (val == 0xfffff) {
886 val = (val * (quant_matrix[0] << Al)) + s->
last_dc[component];
894 uint8_t *last_nnz,
int ac_index,
895 uint16_t *quant_matrix,
896 int ss,
int se,
int Al,
int *EOBRUN)
908 for (i = ss; ; i++) {
912 run = ((unsigned) code) >> 4;
921 int sign = (~cache) >> 31;
922 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
930 block[j] = level * (quant_matrix[
se] << Al);
937 block[j] = level * (quant_matrix[
i] << Al);
966 #define REFINE_BIT(j) { \ 967 UPDATE_CACHE(re, &s->gb); \ 968 sign = block[j] >> 15; \ 969 block[j] += SHOW_UBITS(re, &s->gb, 1) * \ 970 ((quant_matrix[i] ^ sign) - sign) << Al; \ 971 LAST_SKIP_BITS(re, &s->gb, 1); \ 979 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \ 984 j = s->scantable.permutated[i]; \ 987 else if (run-- == 0) \ 994 int ac_index, uint16_t *quant_matrix,
995 int ss,
int se,
int Al,
int *EOBRUN)
998 int last =
FFMIN(se, *last_nnz);
1009 run = ((unsigned) code) >> 4;
1016 block[j] = ((quant_matrix[
i] << Al) ^ val) -
val;
1024 run = ((unsigned) code) >> 4;
1045 for (; i <= last; i++) {
1066 for (i = 0; i < nb_components; i++)
1080 for (i = 0; i < nb_components; i++)
1097 int left[4], top[4], topleft[4];
1098 const int linesize = s->
linesize[0];
1099 const int mask = ((1 << s->
bits) - 1) << point_transform;
1100 int resync_mb_y = 0;
1101 int resync_mb_x = 0;
1120 width = s->
mb_width / nb_components;
1130 for (i = 0; i < 4; i++)
1133 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1137 ptr += linesize >> 1;
1139 for (i = 0; i < 4; i++)
1140 top[i] = left[i] = topleft[i] =
buffer[0][i];
1143 for (i = 0; i < 6; i++)
1144 vpred[i] = 1 << (s->
bits-1);
1147 for (mb_x = 0; mb_x <
width; mb_x++) {
1160 top[i] = left[i]= topleft[i]= 1 << (s->
bits - 1);
1162 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1163 modified_predictor = 1;
1165 for (i=0;i<nb_components;i++) {
1168 topleft[
i] = top[
i];
1175 if (!s->
bayer || mb_x) {
1179 pred = vpred[
i] -
dc;
1182 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1185 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1194 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1195 ptr[4*mb_x + 2] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
1196 ptr[4*mb_x + 1] =
buffer[mb_x][1] + ptr[4*mb_x + 2];
1197 ptr[4*mb_x + 3] =
buffer[mb_x][2] + ptr[4*mb_x + 2];
1198 ptr[4*mb_x + 0] =
buffer[mb_x][3];
1201 for(i=0; i<nb_components; i++) {
1204 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1207 }
else if(s->
bits == 9) {
1210 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1211 ((uint16_t*)ptr)[4*mb_x+
c] =
buffer[mb_x][
i];
1215 }
else if (s->
rct) {
1216 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1217 ptr[3*mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
1218 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
1219 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
1222 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1224 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
1225 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
1227 }
else if (s->
bayer) {
1228 if (nb_components == 1) {
1230 for (mb_x = 0; mb_x <
width; mb_x++)
1231 ((uint16_t*)ptr)[mb_x] =
buffer[mb_x][0];
1232 }
else if (nb_components == 2) {
1233 for (mb_x = 0; mb_x <
width; mb_x++) {
1234 ((uint16_t*)ptr)[2*mb_x + 0] =
buffer[mb_x][0];
1235 ((uint16_t*)ptr)[2*mb_x + 1] =
buffer[mb_x][1];
1239 for(i=0; i<nb_components; i++) {
1242 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1245 }
else if(s->
bits == 9) {
1248 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1249 ((uint16_t*)ptr)[3*mb_x+2-
c] =
buffer[mb_x][
i];
1259 int point_transform,
int nb_components)
1261 int i, mb_x, mb_y,
mask;
1263 int resync_mb_y = 0;
1264 int resync_mb_x = 0;
1266 point_transform += bits - s->
bits;
1267 mask = ((1 << s->
bits) - 1) << point_transform;
1269 av_assert0(nb_components>=1 && nb_components<=4);
1271 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1272 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1283 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->
interlaced){
1284 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1285 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1286 for (i = 0; i < nb_components; i++) {
1289 int n,
h, v, x, y,
c, j, linesize;
1298 if(bits>8) linesize /= 2;
1300 for(j=0; j<n; j++) {
1306 if ( h * mb_x + x >= s->
width 1307 || v * mb_y + y >= s->
height) {
1309 }
else if (bits<=8) {
1310 ptr = s->
picture_ptr->
data[
c] + (linesize * (v * mb_y + y)) + (h * mb_x + x);
1312 if(x==0 && leftcol){
1313 pred= 1 << (bits - 1);
1318 if(x==0 && leftcol){
1319 pred= ptr[-linesize];
1321 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1326 ptr += linesize >> 1;
1328 *ptr= pred + ((unsigned)dc << point_transform);
1330 ptr16 = (uint16_t*)(s->
picture_ptr->
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
1332 if(x==0 && leftcol){
1333 pred= 1 << (bits - 1);
1338 if(x==0 && leftcol){
1339 pred= ptr16[-linesize];
1341 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1346 ptr16 += linesize >> 1;
1348 *ptr16= pred + ((unsigned)dc << point_transform);
1357 for (i = 0; i < nb_components; i++) {
1360 int n,
h, v, x, y,
c, j, linesize,
dc;
1369 if(bits>8) linesize /= 2;
1371 for (j = 0; j < n; j++) {
1377 if ( h * mb_x + x >= s->
width 1378 || v * mb_y + y >= s->
height) {
1380 }
else if (bits<=8) {
1382 (linesize * (v * mb_y + y)) +
1384 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1387 *ptr = pred + ((unsigned)dc << point_transform);
1389 ptr16 = (uint16_t*)(s->
picture_ptr->
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
1390 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1393 *ptr16= pred + ((unsigned)dc << point_transform);
1414 int linesize,
int lowres)
1419 case 1:
copy_block4(dst, src, linesize, linesize, 4);
1421 case 2:
copy_block2(dst, src, linesize, linesize, 2);
1423 case 3: *dst = *
src;
1430 int block_x, block_y;
1433 for (block_y=0; block_y<
size; block_y++)
1434 for (block_x=0; block_x<
size; block_x++)
1435 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->
bits;
1437 for (block_y=0; block_y<
size; block_y++)
1438 for (block_x=0; block_x<
size; block_x++)
1439 *(ptr + block_x + block_y*linesize) <<= 8 - s->
bits;
1444 int Al,
const uint8_t *mb_bitmask,
1445 int mb_bitmask_size,
1448 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1453 int bytes_per_pixel = 1 + (s->
bits > 8);
1470 for (i = 0; i < nb_components; i++) {
1473 reference_data[
c] = reference ? reference->
data[
c] :
NULL;
1478 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1479 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1490 for (i = 0; i < nb_components; i++) {
1492 int n,
h, v, x, y,
c, j;
1500 for (j = 0; j < n; j++) {
1501 block_offset = (((linesize[
c] * (v * mb_y + y) * 8) +
1502 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->
avctx->
lowres);
1505 block_offset += linesize[
c] >> 1;
1506 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->
width)
1507 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->
height)) {
1508 ptr = data[
c] + block_offset;
1523 "error y=%d x=%d\n", mb_y, mb_x);
1543 "error y=%d x=%d\n", mb_y, mb_x);
1547 ff_dlog(s->
avctx,
"mb: %d %d processed\n", mb_y, mb_x);
1550 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1565 int se,
int Ah,
int Al)
1573 if (se < ss || se > 63) {
1584 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1592 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
1599 quant_matrix, ss, se, Al, &EOBRUN);
1602 quant_matrix, ss, se, Al, &EOBRUN);
1605 "error y=%d x=%d\n", mb_y, mb_x);
1620 const int bytes_per_pixel = 1 + (s->
bits > 8);
1621 const int block_size = s->
lossless ? 1 : 8;
1628 int mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1629 int mb_height = (s->
height + v * block_size - 1) / (v * block_size);
1635 data += linesize >> 1;
1637 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1641 for (mb_x = 0; mb_x < mb_width; mb_x++,
block++) {
1652 int mb_bitmask_size,
const AVFrame *reference)
1656 const int block_size = s->
lossless ? 1 : 8;
1657 int ilv, prev_shift;
1661 "Can not process SOS before SOF, skipping\n");
1679 "decode_sos: nb_components (%d)",
1683 if (len != 6 + 2 * nb_components) {
1687 for (i = 0; i < nb_components; i++) {
1696 "decode_sos: index(%d) out of components\n", index);
1710 index = (index+2)%3;
1730 prev_shift = point_transform = 0;
1732 if (nb_components > 1) {
1736 }
else if (!s->
ls) {
1739 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1748 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1758 for (i = 0; i < nb_components; i++)
1774 if (CONFIG_JPEGLS_DECODER && s->
ls) {
1779 point_transform, ilv)) < 0)
1788 nb_components)) < 0)
1797 point_transform)) < 0)
1801 prev_shift, point_transform,
1802 mb_bitmask, mb_bitmask_size, reference)) < 0)
1883 int t_w, t_h, v1, v2;
1901 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1912 if (len -10 - (t_w * t_h * 3) > 0)
1913 len -= t_w * t_h * 3;
1940 "Pegasus lossless jpeg header found\n");
1970 if (
id ==
AV_RL32(
"colr") && len > 0) {
1977 if (
id ==
AV_RL32(
"xfrm") && len > 0) {
2006 }
else if (type == 1) {
2018 if (!(flags & 0x04)) {
2028 int ret, le, ifd_offset, bytes_read;
2084 unsigned nummarkers;
2104 if (nummarkers == 0) {
2107 }
else if (s->
iccnum != 0 && nummarkers != s->
iccnum) {
2110 }
else if (seqno > nummarkers) {
2151 "mjpeg: error, decode_app parser read over the end\n");
2167 for (i = 0; i < len - 2; i++)
2169 if (i > 0 && cbuf[i - 1] ==
'\n')
2178 if (!strncmp(cbuf,
"AVID", 4)) {
2180 }
else if (!strcmp(cbuf,
"CS=ITU601"))
2182 else if ((!strncmp(cbuf,
"Intel(R) JPEG Library, version 1", 32) && s->
avctx->
codec_tag) ||
2183 (!strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
2185 else if (!strcmp(cbuf,
"MULTISCOPE II")) {
2205 buf_ptr = *pbuf_ptr;
2206 while (buf_end - buf_ptr > 1) {
2209 if ((v == 0xff) && (v2 >=
SOF0) && (v2 <=
COM) && buf_ptr < buf_end) {
2218 ff_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
2219 *pbuf_ptr = buf_ptr;
2225 const uint8_t **unescaped_buf_ptr,
2226 int *unescaped_buf_size)
2236 if (start_code ==
SOS && !s->
ls) {
2241 #define copy_data_segment(skip) do { \ 2242 ptrdiff_t length = (ptr - src) - (skip); \ 2244 memcpy(dst, src, length); \ 2254 while (ptr < buf_end) {
2259 while (ptr < buf_end && x == 0xff) {
2274 if (x < RST0 || x >
RST7) {
2284 #undef copy_data_segment 2286 *unescaped_buf_ptr = s->
buffer;
2287 *unescaped_buf_size = dst - s->
buffer;
2288 memset(s->
buffer + *unescaped_buf_size, 0,
2292 (buf_end - *buf_ptr) - (dst - s->
buffer));
2293 }
else if (start_code ==
SOS && s->
ls) {
2301 while (src + t < buf_end) {
2304 while ((src + t < buf_end) && x == 0xff)
2319 if (x == 0xFF &&
b < t) {
2331 *unescaped_buf_ptr = dst;
2332 *unescaped_buf_size = (bit_count + 7) >> 3;
2333 memset(s->
buffer + *unescaped_buf_size, 0,
2336 *unescaped_buf_ptr = *buf_ptr;
2337 *unescaped_buf_size = buf_end - *buf_ptr;
2348 for (i = 0; i < s->
iccnum; i++)
2403 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER 2420 const uint8_t *buf_end, *buf_ptr;
2421 const uint8_t *unescaped_buf_ptr;
2423 int unescaped_buf_size;
2445 while (buf_ptr < buf_end) {
2449 &unescaped_buf_size);
2451 if (start_code < 0) {
2453 }
else if (unescaped_buf_size > INT_MAX / 8) {
2455 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2456 start_code, unescaped_buf_size, s->
pkt->
size);
2460 start_code, buf_end - buf_ptr);
2474 if (start_code >=
RST0 && start_code <=
RST7) {
2476 "restart marker: %d\n", start_code & 0x0f);
2478 }
else if (start_code >=
APP0 && start_code <=
APP15) {
2483 }
else if (start_code ==
COM) {
2487 }
else if (start_code ==
DQT) {
2495 if (!CONFIG_JPEGLS_DECODER &&
2496 (start_code ==
SOF48 || start_code ==
LSE)) {
2502 switch(start_code) {
2517 switch (start_code) {
2533 if (start_code ==
SOF0)
2570 if (!CONFIG_JPEGLS_DECODER ||
2582 "Found EOI before any SOF, ignoring\n");
2594 goto the_end_no_picture;
2613 int qpw = (s->
width + 15) / 16;
2616 memset(qp_table_buf->
data, qp, qpw);
2654 "mjpeg: unsupported coding type (%x)\n", start_code);
2662 "marker parser used %d bytes (%d bits)\n",
2711 for (i = 0; i <
h; i++) {
2713 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2714 else line[w - 1] = line[(w - 1) / 2];
2715 for (index = w - 2; index > 0; index--) {
2717 ((uint16_t*)line)[
index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2719 line[
index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2723 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2725 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2727 line[w - 1] = line[(w - 1) / 3];
2729 line[w - 2] = line[w - 1];
2731 for (index = w - 3; index > 0; index--) {
2732 line[
index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2771 for (i = h - 1;
i; i--) {
2774 if (s->
upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2775 memcpy(dst, src1, w);
2777 for (index = 0; index <
w; index++)
2778 dst[index] = (src1[index] + src2[index]) >> 1;
2795 if(index && index<3){
2801 for (i=0; i<h/2; i++) {
2803 FFSWAP(
int, dst[j], dst2[j]);
2814 for (i=0; i<
h; i++) {
2817 for (index=0; index<4; index++) {
2821 for (j=0; j<
w; j++) {
2823 int r = dst[0][j] * k;
2824 int g = dst[1][j] * k;
2825 int b = dst[2][j] * k;
2826 dst[0][j] = g*257 >> 16;
2827 dst[1][j] = b*257 >> 16;
2828 dst[2][j] = r*257 >> 16;
2837 for (i=0; i<
h; i++) {
2840 for (index=0; index<4; index++) {
2844 for (j=0; j<
w; j++) {
2846 int r = (255 - dst[0][j]) * k;
2847 int g = (128 - dst[1][j]) * k;
2848 int b = (128 - dst[2][j]) * k;
2849 dst[0][j] = r*257 >> 16;
2850 dst[1][j] = (g*257 >> 16) + 128;
2851 dst[2][j] = (b*257 >> 16) + 128;
2873 for (i = 0; i < s->
iccnum; i++)
2883 for (i = 0; i < s->
iccnum; i++) {
2935 for (i = 0; i < 3; i++) {
2936 for (j = 0; j < 4; j++)
2961 #if CONFIG_MJPEG_DECODER 2962 #define OFFSET(x) offsetof(MJpegDecodeContext, x) 2963 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM 2965 {
"extern_huff",
"Use external huffman table.",
2970 static const AVClass mjpegdec_class = {
2989 .priv_class = &mjpegdec_class,
2994 #if CONFIG_MJPEG_NVDEC_HWACCEL 2997 #if CONFIG_MJPEG_VAAPI_HWACCEL 3004 #if CONFIG_THP_DECODER 3022 #if CONFIG_SMVJPEG_DECODER int block_stride[MAX_COMPONENTS]
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int qp_type)
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
const struct AVCodec * codec
const AVPixFmtDescriptor * pix_desc
!< stereoscopic information (cached, since it is read before frame allocation)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int v_count[MAX_COMPONENTS]
#define se(name, range_min, range_max)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
ptrdiff_t const GLvoid * data
static void flush(AVCodecContext *avctx)
enum AVPixelFormat hwaccel_sw_pix_fmt
int coded_width
Bitstream width / height, may be different from width/height e.g.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
#define LIBAVUTIL_VERSION_INT
packed RGB 8:8:8, 24bpp, RGBRGB...
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static av_cold int init(AVCodecContext *avctx)
#define AV_PIX_FMT_RGBA64
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
size_t raw_image_buffer_size
void(* clear_block)(int16_t *block)
#define avpriv_request_sample(...)
static int mjpeg_get_packet(AVCodecContext *avctx)
int h_scount[MAX_COMPONENTS]
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
static int mjpeg_decode_com(MJpegDecodeContext *s)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
TIFF constants & data structures.
#define HWACCEL_NVDEC(codec)
int qscale[4]
quantizer scale calculated from quant_matrixes
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
int ff_sp5x_process_packet(AVCodecContext *avctx, AVPacket *avpkt)
const char * av_default_item_name(void *ptr)
Return the context name.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define copy_data_segment(skip)
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
int dc_index[MAX_COMPONENTS]
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int linesize[MAX_COMPONENTS]
linesize << interlaced
Views are next to each other.
static CopyRet receive_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, int ac_index, uint16_t *quant_matrix)
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
MJPEG encoder and decoder.
#define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
int comp_index[MAX_COMPONENTS]
static void reset_icc_profile(MJpegDecodeContext *s)
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
#define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
enum AVDiscard skip_frame
Skip decoding for selected frames.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
const uint8_t * raw_image_buffer
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
The exact code depends on how similar the blocks are and how related they are to the block
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, int nb_codes, int is_ac, void *logctx)
static int mjpeg_decode_dri(MJpegDecodeContext *s)
8 bits with AV_PIX_FMT_RGB32 palette
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
#define FF_DEBUG_PICT_INFO
uint16_t(* ljpeg_buffer)[4]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
unsigned int ljpeg_buffer_size
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define FF_CODEC_PROPERTY_LOSSLESS
#define FF_PROFILE_MJPEG_JPEG_LS
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
uint8_t * last_nnz[MAX_COMPONENTS]
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Structure to hold side data for an AVFrame.
int quant_sindex[MAX_COMPONENTS]
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
static int get_bits_count(const GetBitContext *s)
#define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS
int h_count[MAX_COMPONENTS]
static void build_huffman_codes(uint8_t *huff_size, const uint8_t *bits_table)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
AVDictionary * metadata
metadata.
#define AV_PIX_FMT_YUV444P16
int interlaced_frame
The content of the picture is interlaced.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Video is not stereoscopic (and metadata has to be there).
#define AV_PIX_FMT_YUVA420P16
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
#define PREDICT(ret, topleft, top, left, predictor)
static int aligned(int val)
static int get_bits_left(GetBitContext *gb)
AVDictionary * exif_metadata
static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block, uint8_t *last_nnz, int ac_index, uint16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
#define UPDATE_CACHE(name, gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int flags
Additional information about the frame packing.
static int handle_rstn(MJpegDecodeContext *s, int nb_components)
static const uint16_t mask[17]
static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block, uint8_t *last_nnz, int ac_index, uint16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
#define PTRDIFF_SPECIFIER
int nb_blocks[MAX_COMPONENTS]
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
static void copy_mb(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Views are packed per line, as if interlaced.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
#define AV_PIX_FMT_YUVA444P16
#define av_fourcc2str(fourcc)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your local see the OFFSET() macro
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference)
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
Decode LSE block with initialization parameters.
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
#define CLOSE_READER(name, gb)
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
#define ss(width, name, subs,...)
static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s, uint8_t *dst, const uint8_t *src, int linesize, int lowres)
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
enum AVPictureType pict_type
Picture type of the frame.
#define AV_PIX_FMT_GBRP16
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define AV_PIX_FMT_GRAY16
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int component_id[MAX_COMPONENTS]
static int mjpeg_decode_app(MJpegDecodeContext *s)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
uint8_t raw_huffman_lengths[2][4][16]
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
#define LAST_SKIP_BITS(name, gb, num)
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
int v_scount[MAX_COMPONENTS]
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define GET_VLC(code, name, gb, table, bits, max_depth)
If the vlc code is invalid and max_depth=1, then no bits will be removed.
uint8_t idct_permutation[64]
IDCT input permutation.
packed RGB 8:8:8, 24bpp, BGRBGR...
AVCodec ff_smvjpeg_decoder
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
HW acceleration through CUDA.
#define SHOW_UBITS(name, gb, num)
#define FF_ARRAY_ELEMS(a)
static const float pred[4]
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AV_PIX_FMT_YUV420P16
static av_always_inline int bytestream2_tell(GetByteContext *g)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
enum AVStereo3DType type
How views are packed within the video.
#define AV_LOG_INFO
Standard information.
int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Libavcodec external API header.
Views are on top of each other.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
static void copy_block4(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff)*mv_scale Intra DC Prediction block[y][x] dc[1]
uint8_t * data
The data buffer.
static int get_xbits(GetBitContext *s, int n)
Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define OPEN_READER(name, gb)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
const uint8_t avpriv_mjpeg_val_dc[12]
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
static unsigned int get_bits1(GetBitContext *s)
static void init_idct(AVCodecContext *avctx)
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
Describe the class of an AVClass context structure.
static void skip_bits(GetBitContext *s, int n)
static const AVProfile profiles[]
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
static int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
int ac_index[MAX_COMPONENTS]
enum AVColorSpace colorspace
YUV colorspace type.
Rational number (pair of numerator and denominator).
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define GET_CACHE(name, gb)
static const SheerTable rgb[2]
const uint8_t ff_zigzag_direct[64]
uint64_t coefs_finished[MAX_COMPONENTS]
bitmask of which coefs have been completely decoded (progressive mode)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
enum AVPixelFormat hwaccel_pix_fmt
static enum AVPixelFormat pix_fmts[]
uint8_t raw_huffman_values[2][4][256]
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al)
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
JPEG-LS extension parameters.
#define flags(name, subs,...)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
size_t raw_scan_buffer_size
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference)
Narrow or limited range content.
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, uint16_t *quant_matrix, int Al)
const AVProfile ff_mjpeg_profiles[]
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform, int nb_components)
A reference to a data buffer.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
const OptionDef options[]
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
planar GBRA 4:4:4:4 32bpp
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
static void predictor(AVFilterContext *ctx, const void *src, ptrdiff_t src_stride, void *dst, const uint8_t *prescreen, int N, const PredictorCoefficients *const model, int use_q2)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
unsigned properties
Properties of the stream that gets decoded.
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
const uint8_t * raw_scan_buffer
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
static void copy_block2(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
#define FF_DEBUG_STARTCODE
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
int top_field_first
If the content is interlaced, is top field displayed first.
int got_picture
we found a SOF and picture is valid, too.
#define HWACCEL_VAAPI(codec)
const uint8_t avpriv_mjpeg_val_ac_luminance[]
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
int16_t(*[MAX_COMPONENTS] blocks)[64]
intermediate sums (progressive mode)
void * hwaccel_picture_private
VLC_TYPE(* table)[2]
code, bits
The official guide to swscale for confused that is
Y , 16bpp, little-endian.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
int key_frame
1 -> keyframe, 0-> not
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
int last_dc[MAX_COMPONENTS]
static const uint8_t * align_get_bits(GetBitContext *s)
static int init_default_huffman_tables(MJpegDecodeContext *s)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
static void decode_flush(AVCodecContext *avctx)
int frame_number
Frame counter, set by libavcodec.
int ff_tdecode_header(GetByteContext *gb, int *le, int *ifd_offset)
Decodes a TIFF header from the input bytestream and sets the endianness in *le and the offset to the ...
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
enum AVFieldOrder field_order
Field order.
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
#define FFSWAP(type, a, b)
int ff_mjpeg_find_marker(MJpegDecodeContext *s, const uint8_t **buf_ptr, const uint8_t *buf_end, const uint8_t **unescaped_buf_ptr, int *unescaped_buf_size)
#define FF_QSCALE_TYPE_MPEG1
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
uint16_t quant_matrixes[4][64]
void ff_free_vlc(VLC *vlc)
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
#define AV_PIX_FMT_YUV422P16
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
int step
Number of elements between 2 horizontally consecutive pixels.
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)