33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
48 const uint8_t *val_table,
int nb_codes,
49 int use_static,
int is_ac)
52 uint16_t huff_code[256];
53 uint16_t huff_sym[256];
60 for (i = 0; i < 256; i++)
61 huff_sym[i] = i + 16 * is_ac;
64 huff_sym[0] = 16 * 256;
67 huff_code, 2, 2, huff_sym, 2, 2, use_static);
113 "error using external huffman table, switching back to internal\n");
146 for (i = 0; i < 64; i++) {
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)
252 if (nb_components <= 0 ||
258 "nb_components changing in interlaced picture\n");
262 if (s->
ls && !(s->
bits <= 8 || nb_components == 1)) {
264 "JPEG-LS that is not <= 8 "
265 "bits/component or 16-bit gray");
271 memset(h_count, 0,
sizeof(h_count));
272 memset(v_count, 0,
sizeof(v_count));
273 for (i = 0; i < nb_components; i++) {
279 if (h_count[i] > s->
h_max)
280 s->
h_max = h_count[i];
281 if (v_count[i] > s->
v_max)
282 s->
v_max = v_count[i];
288 if (!h_count[i] || !v_count[i]) {
290 "Invalid sampling factor in component %d %d:%d\n",
291 i, h_count[i], v_count[i]);
296 i, h_count[i], v_count[i],
308 || memcmp(s->
h_count, h_count,
sizeof(h_count))
309 || memcmp(s->
v_count, v_count,
sizeof(v_count))) {
313 memcpy(s->
h_count, h_count,
sizeof(h_count));
314 memcpy(s->
v_count, v_count,
sizeof(v_count));
340 if (s->
v_max == 1 && s->
h_max == 1 && s->
lossless==1 && (nb_components==3 || nb_components==4))
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) {
388 s->
upscale_h = (pix_fmt_id == 0x22122100);
397 s->
upscale_v = (pix_fmt_id == 0x22211200);
431 s->
upscale_h = (pix_fmt_id == 0x22211100) * 2 + (pix_fmt_id == 0x22112100);
445 s->
upscale_v = (pix_fmt_id == 0x22121100) + 1;
471 else if (s->
bits <= 8)
484 for (i = 0; i < 3; i++)
491 if (len != (8 + (3 * nb_components)))
502 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
503 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
523 if (code < 0 || code > 16) {
525 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
526 0, dc_index, &s->
vlcs[0][dc_index]);
538 int dc_index,
int ac_index, int16_t *quant_matrix)
544 if (val == 0xfffff) {
548 val = val * quant_matrix[0] + s->
last_dc[component];
558 i += ((unsigned)code) >> 4;
566 int sign = (~cache) >> 31;
567 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
577 block[j] = level * quant_matrix[j];
586 int component,
int dc_index,
587 int16_t *quant_matrix,
int Al)
592 if (val == 0xfffff) {
596 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
604 uint8_t *last_nnz,
int ac_index,
605 int16_t *quant_matrix,
606 int ss,
int se,
int Al,
int *EOBRUN)
617 for (i = ss; ; i++) {
621 run = ((unsigned) code) >> 4;
630 int sign = (~cache) >> 31;
631 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
639 block[j] = level * quant_matrix[j] << Al;
646 block[j] = level * quant_matrix[j] << Al;
675 #define REFINE_BIT(j) { \
676 UPDATE_CACHE(re, &s->gb); \
677 sign = block[j] >> 15; \
678 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
679 ((quant_matrix[j] ^ sign) - sign) << Al; \
680 LAST_SKIP_BITS(re, &s->gb, 1); \
688 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
693 j = s->scantable.permutated[i]; \
696 else if (run-- == 0) \
703 int ac_index, int16_t *quant_matrix,
704 int ss,
int se,
int Al,
int *EOBRUN)
706 int code, i = ss, j, sign,
val,
run;
707 int last =
FFMIN(se, *last_nnz);
718 run = ((unsigned) code) >> 4;
725 block[j] = ((quant_matrix[j]^
val) - val) << Al;
733 run = ((unsigned) code) >> 4;
754 for (; i <= last; i++) {
775 for (i = 0; i < nb_components; i++)
789 for (i = 0; i < nb_components; i++)
804 int left[4], top[4], topleft[4];
805 const int linesize = s->
linesize[0];
806 const int mask = ((1 << s->
bits) - 1) << point_transform;
822 for (i = 0; i < 4; i++)
825 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
829 ptr += linesize >> 1;
831 for (i = 0; i < 4; i++)
832 top[i] = left[i] = topleft[i] =
buffer[0][i];
834 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
842 top[i] = left[i]= topleft[i]= 1 << (s->
bits - 1);
844 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
845 modified_predictor = 1;
847 for (i=0;i<nb_components;i++) {
853 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
859 left[i] =
buffer[mb_x][i] =
860 mask & (pred + (dc << point_transform));
869 for(i=0; i<nb_components; i++) {
872 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
873 ptr[4*mb_x+3-
c] =
buffer[mb_x][i];
875 }
else if(s->
bits == 9) {
878 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
879 ((uint16_t*)ptr)[4*mb_x+
c] =
buffer[mb_x][i];
884 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
885 ptr[3*mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
886 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
887 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
890 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
892 ptr[3*mb_x + 0] =
buffer[mb_x][1] + ptr[3*mb_x + 1];
893 ptr[3*mb_x + 2] =
buffer[mb_x][2] + ptr[3*mb_x + 1];
896 for(i=0; i<nb_components; i++) {
899 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
900 ptr[3*mb_x+2-
c] =
buffer[mb_x][i];
902 }
else if(s->
bits == 9) {
905 for(mb_x = 0; mb_x < s->
mb_width; mb_x++) {
906 ((uint16_t*)ptr)[3*mb_x+2-
c] =
buffer[mb_x][i];
916 int point_transform,
int nb_components)
918 int i, mb_x, mb_y,
mask;
923 point_transform += bits - s->
bits;
924 mask = ((1 << s->
bits) - 1) << point_transform;
926 av_assert0(nb_components>=1 && nb_components<=4);
928 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
929 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
936 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
937 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
938 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
939 for (i = 0; i < nb_components; i++) {
942 int n, h,
v, x,
y,
c, j, linesize;
951 if(bits>8) linesize /= 2;
960 ptr = s->
picture.
data[
c] + (linesize * (v * mb_y +
y)) + (h * mb_x + x);
963 pred= 1 << (bits - 1);
969 pred= ptr[-linesize];
971 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
976 ptr += linesize >> 1;
978 *ptr= pred + (dc << point_transform);
980 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
983 pred= 1 << (bits - 1);
989 pred= ptr16[-linesize];
991 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
996 ptr16 += linesize >> 1;
998 *ptr16= pred + (dc << point_transform);
1007 for (i = 0; i < nb_components; i++) {
1010 int n, h,
v, x,
y,
c, j, linesize,
dc;
1019 if(bits>8) linesize /= 2;
1021 for (j = 0; j <
n; j++) {
1029 (linesize * (v * mb_y +
y)) +
1031 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1034 *ptr = pred + (dc << point_transform);
1036 ptr16 = (uint16_t*)(s->
picture.
data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x));
1037 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1040 *ptr16= pred + (dc << point_transform);
1061 int linesize,
int lowres)
1066 case 1:
copy_block4(dst, src, linesize, linesize, 4);
1068 case 2:
copy_block2(dst, src, linesize, linesize, 2);
1070 case 3: *dst = *
src;
1077 int block_x, block_y;
1080 for (block_y=0; block_y<
size; block_y++)
1081 for (block_x=0; block_x<
size; block_x++)
1082 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->
bits;
1084 for (block_y=0; block_y<
size; block_y++)
1085 for (block_x=0; block_x<
size; block_x++)
1086 *(ptr + block_x + block_y*linesize) <<= 8 - s->
bits;
1091 int Al,
const uint8_t *mb_bitmask,
1099 int bytes_per_pixel = 1 + (s->
bits > 8);
1109 for (i = 0; i < nb_components; i++) {
1112 reference_data[
c] = reference ? reference->
data[
c] : NULL;
1125 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1126 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
1127 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
1137 for (i = 0; i < nb_components; i++) {
1139 int n, h,
v, x,
y,
c, j;
1147 for (j = 0; j <
n; j++) {
1148 block_offset = (((linesize[
c] * (v * mb_y +
y) * 8) +
1149 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->
avctx->
lowres);
1152 block_offset += linesize[
c] >> 1;
1153 ptr = data[
c] + block_offset;
1165 "error y=%d x=%d\n", mb_y, mb_x);
1183 "error y=%d x=%d\n", mb_y, mb_x);
1187 av_dlog(s->
avctx,
"mb: %d %d processed\n", mb_y, mb_x);
1190 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1205 int se,
int Ah,
int Al)
1214 int bytes_per_pixel = 1 + (s->
bits > 8);
1217 if (se < ss || se > 63) {
1228 data += linesize >> 1;
1232 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
1237 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
1244 quant_matrix, ss, se, Al, &EOBRUN);
1247 quant_matrix, ss, se, Al, &EOBRUN);
1250 "error y=%d x=%d\n", mb_y, mb_x);
1270 int len, nb_components, i, h,
v,
predictor, point_transform;
1272 const int block_size = s->
lossless ? 1 : 8;
1273 int ilv, prev_shift;
1277 "Can not process SOS before SOF, skipping\n");
1287 "decode_sos: nb_components (%d) unsupported\n", nb_components);
1290 if (len != 6 + 2 * nb_components) {
1294 for (i = 0; i < nb_components; i++) {
1303 "decode_sos: index(%d) out of components\n", index);
1319 index = (index+2)%3;
1339 prev_shift = point_transform = 0;
1341 if (nb_components > 1) {
1345 }
else if (!s->
ls) {
1348 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1357 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1367 for (i = 0; i < nb_components; i++)
1377 point_transform, ilv)) < 0)
1386 nb_components)) < 0)
1395 point_transform)) < 0)
1399 prev_shift, point_transform,
1400 mb_bitmask, reference)) < 0)
1481 int t_w, t_h, v1, v2;
1492 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1501 if (len -10 - (t_w * t_h * 3) > 0)
1502 len -= t_w * t_h * 3;
1522 "Pegasus lossless jpeg header found\n");
1542 if (
id ==
AV_RL32(
"colr") && len > 0) {
1549 if (
id ==
AV_RL32(
"xfrm") && len > 0) {
1560 int ret,
le, ifd_offset, bytes_read;
1619 "mjpeg: error, decode_app parser read over the end\n");
1633 for (i = 0; i < len - 2; i++)
1635 if (i > 0 && cbuf[i - 1] ==
'\n')
1644 if (!strncmp(cbuf,
"AVID", 4)) {
1646 if (len > 14 && cbuf[12] == 1)
1648 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1650 else if ((!strncmp(cbuf,
"Intel(R) JPEG Library, version 1", 32)) ||
1651 (!strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1670 buf_ptr = *pbuf_ptr;
1671 while (buf_end - buf_ptr > 1) {
1674 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1683 av_dlog(NULL,
"find_marker skipped %d bytes\n", skipped);
1684 *pbuf_ptr = buf_ptr;
1690 const uint8_t **unescaped_buf_ptr,
1691 int *unescaped_buf_size)
1701 if (start_code ==
SOS && !s->
ls) {
1705 while (src < buf_end) {
1711 while (src < buf_end && x == 0xff)
1714 if (x >= 0xd0 && x <= 0xd7)
1721 *unescaped_buf_ptr = s->
buffer;
1722 *unescaped_buf_size = dst - s->
buffer;
1723 memset(s->
buffer + *unescaped_buf_size, 0,
1727 (buf_end - *buf_ptr) - (dst - s->
buffer));
1728 }
else if (start_code ==
SOS && s->
ls) {
1738 while (src + t < buf_end) {
1741 while ((src + t < buf_end) && x == 0xff)
1764 *unescaped_buf_ptr = dst;
1765 *unescaped_buf_size = (bit_count + 7) >> 3;
1766 memset(s->
buffer + *unescaped_buf_size, 0,
1769 *unescaped_buf_ptr = *buf_ptr;
1770 *unescaped_buf_size = buf_end - *buf_ptr;
1780 int buf_size = avpkt->
size;
1782 const uint8_t *buf_end, *buf_ptr;
1783 const uint8_t *unescaped_buf_ptr;
1785 int unescaped_buf_size;
1793 buf_end = buf + buf_size;
1794 while (buf_ptr < buf_end) {
1798 &unescaped_buf_size);
1800 if (start_code < 0) {
1802 }
else if (unescaped_buf_size > INT_MAX / 8) {
1804 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
1805 start_code, unescaped_buf_size, buf_size);
1809 start_code, buf_end - buf_ptr);
1823 if (start_code >= 0xd0 && start_code <= 0xd7)
1825 "restart marker: %d\n", start_code & 0x0f);
1827 else if (start_code >=
APP0 && start_code <=
APP15)
1830 else if (start_code ==
COM)
1836 (start_code ==
SOF48 || start_code ==
LSE)) {
1841 switch (start_code) {
1895 "Found EOI before any SOF, ignoring\n");
1913 int qpw = (s->
width + 15) / 16;
1916 memset(qp_table_buf->
data, qp, qpw);
1944 "mjpeg: unsupported coding type (%x)\n", start_code);
1951 "marker parser used %d bytes (%d bits)\n",
1971 for (index = s->
width - 1; index; index--)
1972 line[
index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
1980 w = s->
width >> hshift;
1985 for (i = s->
height - 1; i; i--) {
1989 memcpy(dst, src1, w);
1991 for (index = 0; index < w; index++)
1992 dst[index] = (src1[index] + src2[index]) >> 1;
2000 for (index=0; index<4; index++) {
2004 if(index && index<3){
2010 for (i=0; i<h/2; i++) {
2012 FFSWAP(
int, dst[j], dst2[j]);
2026 return buf_ptr -
buf;
2045 for (i = 0; i < 3; i++) {
2046 for (j = 0; j < 4; j++)
2063 #if CONFIG_MJPEG_DECODER
2064 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2065 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2067 {
"extern_huff",
"Use external huffman table.",
2072 static const AVClass mjpegdec_class = {
2091 .priv_class = &mjpegdec_class,
2094 #if CONFIG_THP_DECODER
int block_stride[MAX_COMPONENTS]
#define AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_GBR24P
const char const char void * val
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
#define AVERROR_PATCHWELCOME
int v_count[MAX_COMPONENTS]
This structure describes decoded (raw) audio or video data.
the normal 2^n-1 "JPEG" YUV ranges
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.
#define LIBAVUTIL_VERSION_INT
static void skip_bits_long(GetBitContext *s, int n)
static av_cold int init(AVCodecContext *avctx)
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
int h_scount[MAX_COMPONENTS]
packed RGB 8:8:8, 24bpp, RGBRGB...
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
static int mjpeg_decode_com(MJpegDecodeContext *s)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
int qscale[4]
quantizer scale calculated from quant_matrixes
int av_frame_set_qp_table(AVFrame *f, AVBufferRef *buf, int stride, int type)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
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)
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional FF_INPUT_BUFFER_PADDING_SIZE at the end w...
int dc_index[MAX_COMPONENTS]
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
av_dlog(ac->avr,"%d samples - audio_convert: %s to %s (%s)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic?ac->func_descr_generic:ac->func_descr)
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
int linesize[MAX_COMPONENTS]
linesize << interlaced
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
MJPEG encoder and decoder.
int comp_index[MAX_COMPONENTS]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static void copy_block2(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
#define FF_QSCALE_TYPE_MPEG1
packed RGB 8:8:8, 24bpp, BGRBGR...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
const char * av_default_item_name(void *ctx)
Return the context name.
static int mjpeg_decode_dri(MJpegDecodeContext *s)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
uint16_t(* ljpeg_buffer)[4]
static const uint8_t offset[511][2]
unsigned int ljpeg_buffer_size
int16_t quant_matrixes[4][64]
const char * name
Name of the codec implementation.
int av_frame_ref(AVFrame *dst, AVFrame *src)
Setup a new reference to the data described by a given frame.
uint8_t * last_nnz[MAX_COMPONENTS]
#define FF_CEIL_RSHIFT(a, b)
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
int quant_sindex[MAX_COMPONENTS]
static int get_bits_count(const GetBitContext *s)
void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, const uint8_t *bits_table, const uint8_t *val_table)
int h_count[MAX_COMPONENTS]
uint8_t idct_permutation[64]
idct input permutation.
int interlaced_frame
The content of the picture is interlaced.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
#define AV_PIX_FMT_RGBA64
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference)
#define FFSWAP(type, a, b)
const OptionDef options[]
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
#define PREDICT(ret, topleft, top, left, predictor)
static void predictor(uint8_t *src, int size)
void av_dict_copy(AVDictionary **dst, AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
static int get_bits_left(GetBitContext *gb)
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define AV_PIX_FMT_GRAY16
AVDictionary * exif_metadata
#define UPDATE_CACHE(name, gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static int handle_rstn(MJpegDecodeContext *s, int nb_components)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
static const uint16_t mask[17]
int nb_blocks[MAX_COMPONENTS]
int ff_exif_decode_ifd(AVCodecContext *avctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
Recursively decodes all IFD's and adds included TAGS into the metadata dictionary.
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_...
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void av_dict_free(AVDictionary **m)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
#define FF_DEBUG_STARTCODE
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)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
#define CLOSE_READER(name, gb)
Libavcodec external API header.
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, int nb_codes, int use_static, int is_ac)
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, int16_t *quant_matrix, int Al)
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define AV_PIX_FMT_YUV444P16
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...
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.
uint8_t * data
The data buffer.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, int ac_index, int16_t *quant_matrix)
int component_id[MAX_COMPONENTS]
static int mjpeg_decode_app(MJpegDecodeContext *s)
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
void * av_malloc(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
const uint8_t avpriv_mjpeg_val_dc[12]
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
#define AV_PIX_FMT_GBRP16
#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 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.
void avcodec_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 SHOW_UBITS(name, gb, num)
static void flush(AVCodecContext *avctx)
static const float pred[4]
#define AV_PIX_FMT_YUVA444P16
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
static av_always_inline int bytestream2_tell(GetByteContext *g)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
#define AV_LOG_INFO
Standard information.
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
main external API structure.
static void close(AVCodecParserContext *s)
#define AV_EF_EXPLODE
abort decoding on minor error detection
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define OPEN_READER(name, gb)
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
static unsigned int get_bits1(GetBitContext *s)
BYTE int const BYTE int int int height
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
Describe the class of an AVClass context structure.
#define MKTAG(a, b, c, d)
static void skip_bits(GetBitContext *s, int n)
static int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
int ac_index[MAX_COMPONENTS]
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)
AVDictionary ** avpriv_frame_get_metadatap(AVFrame *frame)
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
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.
#define CONFIG_JPEGLS_DECODER
static const uint8_t start_code[]
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al)
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#define FF_DEBUG_PICT_INFO
#define AV_PIX_FMT_YUV420P16
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
const uint8_t avpriv_mjpeg_val_ac_luminance[]
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, const AVFrame *reference)
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform, int nb_components)
A reference to a data buffer.
#define CODEC_FLAG_EMU_EDGE
Don't draw edges.
common internal api header.
const uint8_t ff_zigzag_direct[64]
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
void(* clear_block)(int16_t *block)
static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
#define AVERROR_INVALIDDATA
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.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=av_sample_fmt_is_planar(in_fmt);out_planar=av_sample_fmt_is_planar(out_fmt);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);ff_audio_convert_init_arm(ac);ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
int16_t(*[MAX_COMPONENTS] blocks)[64]
intermediate sums (progressive mode)
static void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
VLC_TYPE(* table)[2]
code, bits
JPEG-LS extension parameters.
int key_frame
1 -> keyframe, 0-> not
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
int last_dc[MAX_COMPONENTS]
static const uint8_t * align_get_bits(GetBitContext *s)
static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
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 endianess in *le and the offset to the f...
the normal 219*2^(n-8) "MPEG" YUV ranges
enum AVFieldOrder field_order
Field order.
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
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)
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
This structure stores compressed data.
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.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...