47 const uint8_t *val_table,
int nb_codes,
48 int use_static,
int is_ac)
51 uint16_t huff_code[256];
52 uint16_t huff_sym[256];
55 assert(nb_codes <= 256);
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);
110 "mjpeg: error using external huffman table\n");
143 for (i = 0; i < 64; i++) {
161 int len,
index, i,
class, n, v, code_max;
178 for (i = 1; i <= 16; i++) {
183 if (len < n || n > 256)
187 for (i = 0; i < n; i++) {
198 class, index, code_max + 1);
199 if ((ret =
build_vlc(&s->
vlcs[
class][index], bits_table, val_table,
200 code_max + 1, 0,
class > 0)) < 0)
205 if ((ret =
build_vlc(&s->
vlcs[2][index], bits_table, val_table,
206 code_max + 1, 0, 0)) < 0)
245 if (nb_components <= 0 ||
251 "nb_components changing in interlaced picture\n");
255 if (s->
ls && !(bits <= 8 || nb_components == 1)) {
257 "For JPEG-LS anything except <= 8 bits/component"
258 " or 16-bit gray", 0);
264 for (i = 0; i < nb_components; i++) {
270 if (h_count[i] > s->
h_max)
271 s->
h_max = h_count[i];
272 if (v_count[i] > s->
v_max)
273 s->
v_max = v_count[i];
277 if (!h_count[i] || !v_count[i]) {
279 "Invalid sampling factor in component %d %d:%d\n",
280 i, h_count[i], v_count[i]);
285 i, h_count[i], v_count[i],
299 memcmp(s->
h_count, h_count,
sizeof(h_count)) ||
300 memcmp(s->
v_count, v_count,
sizeof(v_count))) {
307 memcpy(s->
h_count, h_count,
sizeof(h_count));
308 memcpy(s->
v_count, v_count,
sizeof(v_count));
336 if (!(pix_fmt_id & 0xD0D0D0D0))
337 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
338 if (!(pix_fmt_id & 0x0D0D0D0D))
339 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
341 switch (pix_fmt_id) {
368 else if (s->
bits <= 8)
385 for (i = 0; i < 3; i++)
392 if (len != (8 + (3 * nb_components)))
398 int bw = (width + s->
h_max * 8 - 1) / (s->
h_max * 8);
399 int bh = (height + s->
v_max * 8 - 1) / (s->
v_max * 8);
419 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
420 0, dc_index, &s->
vlcs[0][dc_index]);
432 int dc_index,
int ac_index, int16_t *quant_matrix)
434 int code, i, j,
level, val;
442 val = val * quant_matrix[0] + s->
last_dc[component];
452 i += ((unsigned)code) >> 4;
460 int sign = (~cache) >> 31;
461 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
471 block[j] = level * quant_matrix[j];
480 int component,
int dc_index,
481 int16_t *quant_matrix,
int Al)
490 val = (val * quant_matrix[0] << Al) + s->
last_dc[component];
498 uint8_t *last_nnz,
int ac_index,
499 int16_t *quant_matrix,
500 int ss,
int se,
int Al,
int *EOBRUN)
511 for (i = ss; ; i++) {
515 run = ((unsigned) code) >> 4;
524 int sign = (~cache) >> 31;
525 level = (
NEG_USR32(sign ^ cache,code) ^ sign) - sign;
533 block[j] = level * quant_matrix[j] << Al;
540 block[j] = level * quant_matrix[j] << Al;
569 #define REFINE_BIT(j) { \
570 UPDATE_CACHE(re, &s->gb); \
571 sign = block[j] >> 15; \
572 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
573 ((quant_matrix[j] ^ sign) - sign) << Al; \
574 LAST_SKIP_BITS(re, &s->gb, 1); \
582 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
587 j = s->scantable.permutated[i]; \
590 else if (run-- == 0) \
597 int ac_index, int16_t *quant_matrix,
598 int ss,
int se,
int Al,
int *EOBRUN)
600 int code, i = ss, j, sign, val,
run;
601 int last =
FFMIN(se, *last_nnz);
612 run = ((unsigned) code) >> 4;
619 block[j] = ((quant_matrix[j]^val) - val) << Al;
627 run = ((unsigned) code) >> 4;
648 for (; i <= last; i++) {
665 int left[3], top[3], topleft[3];
666 const int linesize = s->
linesize[0];
667 const int mask = (1 << s->
bits) - 1;
673 for (i = 0; i < 3; i++)
674 buffer[0][i] = 1 << (s->
bits + point_transform - 1);
676 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
677 const int modified_predictor = mb_y ? predictor : 1;
681 ptr += linesize >> 1;
683 for (i = 0; i < 3; i++)
684 top[i] = left[i] = topleft[i] =
buffer[0][i];
686 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
690 for (i = 0; i < 3; i++) {
696 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
698 left[i] =
buffer[mb_x][i] =
709 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
710 ptr[4 * mb_x + 1] =
buffer[mb_x][0] - ((
buffer[mb_x][1] +
buffer[mb_x][2] - 0x200) >> 2);
711 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
712 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
715 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
717 ptr[4 * mb_x + 0] =
buffer[mb_x][1] + ptr[4 * mb_x + 1];
718 ptr[4 * mb_x + 2] =
buffer[mb_x][2] + ptr[4 * mb_x + 1];
721 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
722 ptr[4 * mb_x + 0] =
buffer[mb_x][2];
723 ptr[4 * mb_x + 1] =
buffer[mb_x][1];
724 ptr[4 * mb_x + 2] =
buffer[mb_x][0];
732 int point_transform,
int nb_components)
736 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
737 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
741 if (mb_x == 0 || mb_y == 0 || s->
interlaced) {
742 for (i = 0; i < nb_components; i++) {
744 int n, h, v, x, y, c, j, linesize;
753 for (j = 0; j < n; j++) {
757 (linesize * (v * mb_y + y)) +
759 if (y == 0 && mb_y == 0) {
760 if (x == 0 && mb_x == 0)
761 pred = 128 << point_transform;
765 if (x == 0 && mb_x == 0)
766 pred = ptr[-linesize];
768 PREDICT(pred, ptr[-linesize - 1],
769 ptr[-linesize], ptr[-1], predictor);
773 ptr += linesize >> 1;
783 for (i = 0; i < nb_components; i++) {
785 int n, h, v, x, y, c, j, linesize;
794 for (j = 0; j < n; j++) {
799 (linesize * (v * mb_y + y)) +
801 PREDICT(pred, ptr[-linesize - 1],
802 ptr[-linesize], ptr[-1], predictor);
821 int Al,
const uint8_t *mb_bitmask,
835 "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
839 for (i = 0; i < nb_components; i++) {
842 reference_data[c] = reference ? reference->
data[c] :
NULL;
847 int offset = (linesize[c] * (s->
v_scount[i] *
850 reference_data[c] += offset;
855 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
856 for (mb_x = 0; mb_x < s->
mb_width; mb_x++) {
857 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
867 for (i = 0; i < nb_components; i++) {
869 int n, h, v, x, y, c, j;
877 for (j = 0; j < n; j++) {
878 block_offset = ((linesize[c] * (v * mb_y + y) * 8) +
882 block_offset += linesize[c] >> 1;
883 ptr = data[c] + block_offset;
887 linesize[c], linesize[c], 8);
894 "error y=%d x=%d\n", mb_y, mb_x);
910 "error y=%d x=%d\n", mb_y, mb_x);
917 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
935 for (i = 0; i < nb_components; i++)
947 int se,
int Ah,
int Al,
961 if (ss < 0 || ss >= 64 ||
962 se < ss || se >= 64 ||
975 int offset = linesize >> 1;
977 reference_data += offset;
980 for (mb_y = 0; mb_y < s->
mb_height; mb_y++) {
981 int block_offset = mb_y * linesize * 8;
982 uint8_t *ptr = data + block_offset;
986 for (mb_x = 0; mb_x < s->
mb_width; mb_x++,
block++, last_nnz++) {
987 const int copy_mb = mb_bitmask && !
get_bits1(&mb_bitmask_gb);
993 quant_matrix, ss, se, Al, &EOBRUN);
996 quant_matrix, ss, se, Al, &EOBRUN);
999 "error y=%d x=%d\n", mb_y, mb_x);
1007 linesize, linesize, 8);
1021 int len, nb_components, i, h, v, predictor, point_transform;
1023 const int block_size = s->
lossless ? 1 : 8;
1024 int ilv, prev_shift;
1031 "decode_sos: nb_components (%d) unsupported\n", nb_components);
1034 if (len != 6 + 2 * nb_components) {
1038 for (i = 0; i < nb_components; i++) {
1047 "decode_sos: index(%d) out of components\n", index);
1077 if (nb_components > 1) {
1081 }
else if (!s->
ls) {
1084 s->
mb_width = (s->
width + h * block_size - 1) / (h * block_size);
1093 s->
lossless ?
"lossless" :
"sequential DCT", s->
rgb ?
"RGB" :
"",
1094 predictor, point_transform, ilv, s->
bits,
1103 for (i = 0; i < nb_components; i++)
1112 point_transform, ilv)) < 0)
1117 point_transform)) < 0)
1122 nb_components)) < 0)
1136 prev_shift, point_transform,
1137 mb_bitmask, reference)) < 0)
1148 av_dlog(s->
avctx,
"AVRn interlaced picture marker found\n");
1222 int t_w, t_h, v1, v2;
1233 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1242 if (len -10 - (t_w * t_h * 3) > 0)
1243 len -= t_w * t_h * 3;
1263 "Pegasus lossless jpeg header found\n");
1310 "mjpeg: error, decode_app parser read over the end\n");
1324 for (i = 0; i < len - 2; i++)
1326 if (i > 0 && cbuf[i - 1] ==
'\n')
1335 if (!strcmp(cbuf,
"AVID")) {
1337 }
else if (!strcmp(cbuf,
"CS=ITU601"))
1339 else if ((len > 20 && !strncmp(cbuf,
"Intel(R) JPEG Library", 21)) ||
1340 (len > 19 && !strncmp(cbuf,
"Metasoft MJPEG Codec", 20)))
1361 buf_ptr = *pbuf_ptr;
1362 while (buf_ptr < buf_end) {
1365 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1375 av_dlog(
NULL,
"find_marker skipped %d bytes\n", skipped);
1376 *pbuf_ptr = buf_ptr;
1382 const uint8_t **unescaped_buf_ptr,
1383 int *unescaped_buf_size)
1393 if (start_code ==
SOS && !s->
ls) {
1394 const uint8_t *src = *buf_ptr;
1397 while (src < buf_end) {
1403 while (src < buf_end && x == 0xff)
1406 if (x >= 0xd0 && x <= 0xd7)
1413 *unescaped_buf_ptr = s->
buffer;
1414 *unescaped_buf_size = dst - s->
buffer;
1415 memset(s->
buffer + *unescaped_buf_size, 0,
1419 (buf_end - *buf_ptr) - (dst - s->
buffer));
1420 }
else if (start_code ==
SOS && s->
ls) {
1421 const uint8_t *src = *buf_ptr;
1430 while (src + t < buf_end) {
1433 while ((src + t < buf_end) && x == 0xff)
1456 *unescaped_buf_ptr = dst;
1457 *unescaped_buf_size = (bit_count + 7) >> 3;
1458 memset(s->
buffer + *unescaped_buf_size, 0,
1461 *unescaped_buf_ptr = *buf_ptr;
1462 *unescaped_buf_size = buf_end - *buf_ptr;
1472 int buf_size = avpkt->
size;
1474 const uint8_t *buf_end, *buf_ptr;
1475 const uint8_t *unescaped_buf_ptr;
1476 int unescaped_buf_size;
1483 buf_end = buf + buf_size;
1484 while (buf_ptr < buf_end) {
1488 &unescaped_buf_size);
1490 if (start_code < 0) {
1492 }
else if (unescaped_buf_size > INT_MAX / 8) {
1494 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
1495 start_code, unescaped_buf_size, buf_size);
1499 start_code, buf_end - buf_ptr);
1502 unescaped_buf_size * 8);
1512 if (start_code >= 0xd0 && start_code <= 0xd7)
1514 "restart marker: %d\n", start_code & 0x0f);
1516 else if (start_code >=
APP0 && start_code <=
APP15)
1519 else if (start_code ==
COM)
1523 (start_code ==
SOF48 || start_code ==
LSE)) {
1528 switch (start_code) {
1584 "Found EOI before any SOF, ignoring\n");
1603 (s->
width + 15) / 16);
1606 "QP: %d\n", picture->
quality);
1614 "Can not process SOS before SOF, skipping\n");
1639 "mjpeg: unsupported coding type (%x)\n", start_code);
1647 "marker parser used %d bytes (%d bits)\n",
1661 return buf_ptr - buf;
1677 for (i = 0; i < 3; i++) {
1678 for (j = 0; j < 4; j++)
1688 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1689 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1691 {
"extern_huff",
"Use external huffman table.",
int block_stride[MAX_COMPONENTS]
const struct AVCodec * codec
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
int v_count[MAX_COMPONENTS]
const uint8_t ff_zigzag_direct[64]
This structure describes decoded (raw) audio or video data.
int qstride
QP store stride.
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
DCTELEM(*[MAX_COMPONENTS] blocks)[64]
intermediate sums (progressive mode)
packed RGB 8:8:8, 24bpp, RGBRGB...
static void skip_bits_long(GetBitContext *s, int n)
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
#define AV_PIX_FMT_GRAY16
static void align_get_bits(GetBitContext *s)
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
int h_scount[MAX_COMPONENTS]
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
static int mjpeg_decode_com(MJpegDecodeContext *s)
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
int qscale[4]
quantizer scale calculated from quant_matrixes
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 const AVClass mjpegdec_class
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer with padding, reusing the given one if large enough.
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
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
MJPEG encoder and decoder.
int comp_index[MAX_COMPONENTS]
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
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)
static int mjpeg_decode_dri(MJpegDecodeContext *s)
uint16_t(* ljpeg_buffer)[4]
unsigned int ljpeg_buffer_size
int16_t quant_matrixes[4][64]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
uint8_t * last_nnz[MAX_COMPONENTS]
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of PIX_FMT_YUV440P and setting color_range ...
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]
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
uint8_t idct_permutation[64]
idct input permutation.
#define MKTAG(a, b, c, d)
int interlaced_frame
The content of the picture is interlaced.
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference)
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
static int init(AVCodecParserContext *s)
#define PREDICT(ret, topleft, top, left, predictor)
static int get_bits_left(GetBitContext *gb)
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define UPDATE_CACHE(name, gb)
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
static const uint16_t mask[17]
int nb_blocks[MAX_COMPONENTS]
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
void(* idct_put)(uint8_t *dest, int line_size, DCTELEM *block)
block -> idct -> clip to unsigned 8 bit -> dest.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
#define FF_DEBUG_PICT_INFO
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
Decode LSE block with initialization parameters.
#define CODEC_FLAG_EMU_EDGE
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
#define CLOSE_READER(name, gb)
void(* clear_block)(DCTELEM *block)
static void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
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)
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
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...
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
enum AVPictureType pict_type
Picture type of the frame, see ?_TYPE below.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define CONFIG_JPEGLS_DECODER
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV420P and setting color_...
int component_id[MAX_COMPONENTS]
static int mjpeg_decode_app(MJpegDecodeContext *s)
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
const uint8_t avpriv_mjpeg_val_dc[12]
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
#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.
#define SHOW_UBITS(name, gb, num)
static const float pred[4]
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
main external API structure.
static void close(AVCodecParserContext *s)
static int get_xbits(GetBitContext *s, int n)
read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define OPEN_READER(name, gb)
static unsigned int get_bits1(GetBitContext *s)
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
Describe the class of an AVClass context structure.
struct MJpegDecodeContext MJpegDecodeContext
static void skip_bits(GetBitContext *s, int n)
static int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
int ac_index[MAX_COMPONENTS]
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define GET_CACHE(name, gb)
#define FF_INPUT_BUFFER_PADDING_SIZE
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.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int8_t * qscale_table
QP table.
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)
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
#define AVERROR_INVALIDDATA
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV444P and setting color_...
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
#define AVERROR_PATCHWELCOME
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al, const uint8_t *mb_bitmask, const AVFrame *reference)
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.
void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN)
VLC_TYPE(* table)[2]
code, bits
JPEG-LS extension parameters.
int key_frame
1 -> keyframe, 0-> not
int last_dc[MAX_COMPONENTS]
static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int component, int dc_index, int16_t *quant_matrix, int Al)
#define FF_DEBUG_STARTCODE
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
enum AVFieldOrder field_order
Field order.
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)
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, int component, int dc_index, int ac_index, int16_t *quant_matrix)
static const AVOption options[]
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
if(!(ptr_align%ac->ptr_align)&&samples_align >=aligned_len)