3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
11 * This file is part of FFmpeg.
13 * FFmpeg is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * FFmpeg is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with FFmpeg; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
38 #include "copy_block.h"
42 #include "jpegtables.h"
45 #include "jpeglsdec.h"
50 #include "bytestream.h"
53 static void build_huffman_codes(uint8_t *huff_size, const uint8_t *bits_table)
55 for (int i = 1, k = 0; i <= 16; i++) {
56 int nb = bits_table[i];
57 for (int j = 0; j < nb;j++) {
64 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
65 const uint8_t *val_table, int nb_codes,
66 int is_ac, void *logctx)
68 uint8_t huff_size[256];
69 uint16_t huff_sym[256];
72 av_assert0(nb_codes <= 256);
74 build_huffman_codes(huff_size, bits_table);
76 for (i = 0; i < nb_codes; i++) {
77 huff_sym[i] = val_table[i] + 16 * is_ac;
79 if (is_ac && !val_table[i])
80 huff_sym[i] = 16 * 256;
83 return ff_init_vlc_from_lengths(vlc, 9, nb_codes, huff_size, 1,
84 huff_sym, 2, 2, 0, 0, logctx);
87 static int init_default_huffman_tables(MJpegDecodeContext *s)
93 const uint8_t *values;
96 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
97 avpriv_mjpeg_val_dc, 12 },
98 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
99 avpriv_mjpeg_val_dc, 12 },
100 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
101 avpriv_mjpeg_val_ac_luminance, 162 },
102 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
103 avpriv_mjpeg_val_ac_chrominance, 162 },
104 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
105 avpriv_mjpeg_val_ac_luminance, 162 },
106 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
107 avpriv_mjpeg_val_ac_chrominance, 162 },
111 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
112 ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
113 ht[i].bits, ht[i].values, ht[i].length,
114 ht[i].class == 1, s->avctx);
118 if (ht[i].class < 2) {
119 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
121 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
122 ht[i].values, ht[i].length);
129 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
132 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
133 s->interlace_polarity = 1;
134 if (len > 14 && buf[12] == 2) /* 2 - PAL */
135 s->interlace_polarity = 0;
136 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
137 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
140 static void init_idct(AVCodecContext *avctx)
142 MJpegDecodeContext *s = avctx->priv_data;
144 ff_idctdsp_init(&s->idsp, avctx);
145 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
149 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
151 MJpegDecodeContext *s = avctx->priv_data;
154 if (!s->picture_ptr) {
155 s->picture = av_frame_alloc();
157 return AVERROR(ENOMEM);
158 s->picture_ptr = s->picture;
162 ff_blockdsp_init(&s->bdsp, avctx);
163 ff_hpeldsp_init(&s->hdsp, avctx->flags);
168 s->first_picture = 1;
170 s->org_height = avctx->coded_height;
171 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
172 avctx->colorspace = AVCOL_SPC_BT470BG;
173 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
175 if ((ret = init_default_huffman_tables(s)) < 0)
178 if (s->extern_huff) {
179 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
180 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
182 if (ff_mjpeg_decode_dht(s)) {
183 av_log(avctx, AV_LOG_ERROR,
184 "error using external huffman table, switching back to internal\n");
185 init_default_huffman_tables(s);
188 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
189 s->interlace_polarity = 1; /* bottom field first */
190 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
191 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
192 if (avctx->codec_tag == AV_RL32("MJPG"))
193 s->interlace_polarity = 1;
196 if ( avctx->extradata_size > 8
197 && AV_RL32(avctx->extradata) == 0x2C
198 && AV_RL32(avctx->extradata+4) == 0x18) {
199 parse_avid(s, avctx->extradata, avctx->extradata_size);
202 if (avctx->codec->id == AV_CODEC_ID_AMV)
209 /* quantize tables */
210 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
214 len = get_bits(&s->gb, 16) - 2;
216 if (8*len > get_bits_left(&s->gb)) {
217 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
218 return AVERROR_INVALIDDATA;
222 int pr = get_bits(&s->gb, 4);
224 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
225 return AVERROR_INVALIDDATA;
227 index = get_bits(&s->gb, 4);
230 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
231 /* read quant table */
232 for (i = 0; i < 64; i++) {
233 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
234 if (s->quant_matrixes[index][i] == 0) {
235 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
236 return AVERROR_INVALIDDATA;
240 // XXX FIXME fine-tune, and perhaps add dc too
241 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
242 s->quant_matrixes[index][8]) >> 1;
243 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
244 index, s->qscale[index]);
245 len -= 1 + 64 * (1+pr);
250 /* decode huffman tables and build VLC decoders */
251 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
253 int len, index, i, class, n, v;
254 uint8_t bits_table[17];
255 uint8_t val_table[256];
258 len = get_bits(&s->gb, 16) - 2;
260 if (8*len > get_bits_left(&s->gb)) {
261 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
262 return AVERROR_INVALIDDATA;
267 return AVERROR_INVALIDDATA;
268 class = get_bits(&s->gb, 4);
270 return AVERROR_INVALIDDATA;
271 index = get_bits(&s->gb, 4);
273 return AVERROR_INVALIDDATA;
275 for (i = 1; i <= 16; i++) {
276 bits_table[i] = get_bits(&s->gb, 8);
280 if (len < n || n > 256)
281 return AVERROR_INVALIDDATA;
283 for (i = 0; i < n; i++) {
284 v = get_bits(&s->gb, 8);
289 /* build VLC and flush previous vlc if present */
290 ff_free_vlc(&s->vlcs[class][index]);
291 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
293 if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
294 n, class > 0, s->avctx)) < 0)
298 ff_free_vlc(&s->vlcs[2][index]);
299 if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
300 n, 0, s->avctx)) < 0)
304 for (i = 0; i < 16; i++)
305 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
306 for (i = 0; i < 256; i++)
307 s->raw_huffman_values[class][index][i] = val_table[i];
312 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
314 int len, nb_components, i, width, height, bits, ret, size_change;
316 int h_count[MAX_COMPONENTS] = { 0 };
317 int v_count[MAX_COMPONENTS] = { 0 };
320 memset(s->upscale_h, 0, sizeof(s->upscale_h));
321 memset(s->upscale_v, 0, sizeof(s->upscale_v));
323 len = get_bits(&s->gb, 16);
324 bits = get_bits(&s->gb, 8);
326 if (bits > 16 || bits < 1) {
327 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
328 return AVERROR_INVALIDDATA;
331 if (s->avctx->bits_per_raw_sample != bits) {
332 av_log(s->avctx, s->avctx->bits_per_raw_sample > 0 ? AV_LOG_INFO : AV_LOG_DEBUG, "Changing bps from %d to %d\n", s->avctx->bits_per_raw_sample, bits);
333 s->avctx->bits_per_raw_sample = bits;
338 if (bits == 9 && !s->pegasus_rct)
339 s->rct = 1; // FIXME ugly
341 if(s->lossless && s->avctx->lowres){
342 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
346 height = get_bits(&s->gb, 16);
347 width = get_bits(&s->gb, 16);
349 // HACK for odd_height.mov
350 if (s->interlaced && s->width == width && s->height == height + 1)
353 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
354 if (av_image_check_size(width, height, 0, s->avctx) < 0)
355 return AVERROR_INVALIDDATA;
356 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
357 return AVERROR_INVALIDDATA;
359 nb_components = get_bits(&s->gb, 8);
360 if (nb_components <= 0 ||
361 nb_components > MAX_COMPONENTS)
363 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
364 if (nb_components != s->nb_components) {
365 av_log(s->avctx, AV_LOG_ERROR,
366 "nb_components changing in interlaced picture\n");
367 return AVERROR_INVALIDDATA;
370 if (s->ls && !(bits <= 8 || nb_components == 1)) {
371 avpriv_report_missing_feature(s->avctx,
372 "JPEG-LS that is not <= 8 "
373 "bits/component or 16-bit gray");
374 return AVERROR_PATCHWELCOME;
376 if (len != 8 + 3 * nb_components) {
377 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
378 return AVERROR_INVALIDDATA;
381 s->nb_components = nb_components;
384 for (i = 0; i < nb_components; i++) {
386 s->component_id[i] = get_bits(&s->gb, 8) - 1;
387 h_count[i] = get_bits(&s->gb, 4);
388 v_count[i] = get_bits(&s->gb, 4);
389 /* compute hmax and vmax (only used in interleaved case) */
390 if (h_count[i] > s->h_max)
391 s->h_max = h_count[i];
392 if (v_count[i] > s->v_max)
393 s->v_max = v_count[i];
394 s->quant_index[i] = get_bits(&s->gb, 8);
395 if (s->quant_index[i] >= 4) {
396 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
397 return AVERROR_INVALIDDATA;
399 if (!h_count[i] || !v_count[i]) {
400 av_log(s->avctx, AV_LOG_ERROR,
401 "Invalid sampling factor in component %d %d:%d\n",
402 i, h_count[i], v_count[i]);
403 return AVERROR_INVALIDDATA;
406 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
407 i, h_count[i], v_count[i],
408 s->component_id[i], s->quant_index[i]);
410 if ( nb_components == 4
411 && s->component_id[0] == 'C' - 1
412 && s->component_id[1] == 'M' - 1
413 && s->component_id[2] == 'Y' - 1
414 && s->component_id[3] == 'K' - 1)
415 s->adobe_transform = 0;
417 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
418 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
419 return AVERROR_PATCHWELCOME;
423 if (nb_components == 2) {
424 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
425 width stored in their SOF3 markers is the width of each one. We only output
426 a single component, therefore we need to adjust the output image width. We
427 handle the deinterleaving (but not the debayering) in this file. */
430 /* They can also contain 1 component, which is double the width and half the height
431 of the final image (rows are interleaved). We don't handle the decoding in this
432 file, but leave that to the TIFF/DNG decoder. */
435 /* if different size, realloc/alloc picture */
436 if (width != s->width || height != s->height || bits != s->bits ||
437 memcmp(s->h_count, h_count, sizeof(h_count)) ||
438 memcmp(s->v_count, v_count, sizeof(v_count))) {
444 memcpy(s->h_count, h_count, sizeof(h_count));
445 memcpy(s->v_count, v_count, sizeof(v_count));
449 /* test interlaced mode */
450 if (s->first_picture &&
451 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
452 s->org_height != 0 &&
453 s->height < ((s->org_height * 3) / 4)) {
455 s->bottom_field = s->interlace_polarity;
456 s->picture_ptr->interlaced_frame = 1;
457 s->picture_ptr->top_field_first = !s->interlace_polarity;
461 ret = ff_set_dimensions(s->avctx, width, height);
465 s->first_picture = 0;
470 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
471 if (s->progressive) {
472 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
473 return AVERROR_INVALIDDATA;
476 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
478 else if (!s->lossless)
480 /* XXX: not complete test ! */
481 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
482 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
483 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
484 (s->h_count[3] << 4) | s->v_count[3];
485 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
486 /* NOTE we do not allocate pictures large enough for the possible
487 * padding of h/v_count being 4 */
488 if (!(pix_fmt_id & 0xD0D0D0D0))
489 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
490 if (!(pix_fmt_id & 0x0D0D0D0D))
491 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
493 for (i = 0; i < 8; i++) {
494 int j = 6 + (i&1) - (i&6);
495 int is = (pix_fmt_id >> (4*i)) & 0xF;
496 int js = (pix_fmt_id >> (4*j)) & 0xF;
498 if (is == 1 && js != 2 && (i < 2 || i > 5))
499 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
500 if (is == 1 && js != 2 && (i < 2 || i > 5))
501 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
503 if (is == 1 && js == 2) {
504 if (i & 1) s->upscale_h[j/2] = 1;
505 else s->upscale_v[j/2] = 1;
510 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
514 switch (pix_fmt_id) {
515 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
518 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
522 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
524 if ( s->adobe_transform == 0
525 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
526 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
528 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
529 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
530 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
533 av_assert0(s->nb_components == 3);
537 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
539 if (s->adobe_transform == 0 && s->bits <= 8) {
540 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
542 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
543 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
546 av_assert0(s->nb_components == 4);
550 if (s->adobe_transform == 0 && s->bits <= 8) {
551 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
552 s->upscale_v[1] = s->upscale_v[2] = 1;
553 s->upscale_h[1] = s->upscale_h[2] = 1;
554 } else if (s->adobe_transform == 2 && s->bits <= 8) {
555 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
556 s->upscale_v[1] = s->upscale_v[2] = 1;
557 s->upscale_h[1] = s->upscale_h[2] = 1;
558 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
560 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
561 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
562 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
564 av_assert0(s->nb_components == 4);
573 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
576 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
588 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
590 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
597 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
598 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
601 s->upscale_v[0] = s->upscale_v[1] = 1;
603 if (pix_fmt_id == 0x14111100)
604 s->upscale_v[1] = s->upscale_v[2] = 1;
605 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
608 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
612 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
613 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
616 s->upscale_h[0] = s->upscale_h[1] = 1;
618 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
619 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
620 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
626 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
627 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
628 s->upscale_h[1] = s->upscale_h[2] = 2;
632 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
635 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
641 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
642 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
643 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
644 if (pix_fmt_id == 0x42111100) {
647 s->upscale_h[1] = s->upscale_h[2] = 1;
648 } else if (pix_fmt_id == 0x24111100) {
651 s->upscale_v[1] = s->upscale_v[2] = 1;
652 } else if (pix_fmt_id == 0x23111100) {
655 s->upscale_v[1] = s->upscale_v[2] = 2;
659 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
662 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
666 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
667 memset(s->upscale_h, 0, sizeof(s->upscale_h));
668 memset(s->upscale_v, 0, sizeof(s->upscale_v));
669 return AVERROR_PATCHWELCOME;
671 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
672 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
673 return AVERROR_PATCHWELCOME;
675 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
676 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
677 return AVERROR_PATCHWELCOME;
680 memset(s->upscale_h, 0, sizeof(s->upscale_h));
681 memset(s->upscale_v, 0, sizeof(s->upscale_v));
682 if (s->nb_components == 3) {
683 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
684 } else if (s->nb_components != 1) {
685 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
686 return AVERROR_PATCHWELCOME;
687 } else if (s->palette_index && s->bits <= 8)
688 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
689 else if (s->bits <= 8)
690 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
692 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
695 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
697 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
701 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
702 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
704 enum AVPixelFormat pix_fmts[] = {
705 #if CONFIG_MJPEG_NVDEC_HWACCEL
708 #if CONFIG_MJPEG_VAAPI_HWACCEL
714 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
715 if (s->hwaccel_pix_fmt < 0)
716 return AVERROR(EINVAL);
718 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
719 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
722 if (s->avctx->skip_frame == AVDISCARD_ALL) {
723 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
724 s->picture_ptr->key_frame = 1;
729 av_frame_unref(s->picture_ptr);
730 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
732 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
733 s->picture_ptr->key_frame = 1;
736 for (i = 0; i < 4; i++)
737 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
739 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
740 s->width, s->height, s->linesize[0], s->linesize[1],
741 s->interlaced, s->avctx->height);
745 if ((s->rgb && !s->lossless && !s->ls) ||
746 (!s->rgb && s->ls && s->nb_components > 1) ||
747 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
749 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
750 return AVERROR_PATCHWELCOME;
753 /* totally blank picture as progressive JPEG will only add details to it */
754 if (s->progressive) {
755 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
756 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
757 for (i = 0; i < s->nb_components; i++) {
758 int size = bw * bh * s->h_count[i] * s->v_count[i];
759 av_freep(&s->blocks[i]);
760 av_freep(&s->last_nnz[i]);
761 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
762 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
763 if (!s->blocks[i] || !s->last_nnz[i])
764 return AVERROR(ENOMEM);
765 s->block_stride[i] = bw * s->h_count[i];
767 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
770 if (s->avctx->hwaccel) {
771 s->hwaccel_picture_private =
772 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
773 if (!s->hwaccel_picture_private)
774 return AVERROR(ENOMEM);
776 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
777 s->raw_image_buffer_size);
785 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
788 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
789 if (code < 0 || code > 16) {
790 av_log(s->avctx, AV_LOG_WARNING,
791 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
792 0, dc_index, &s->vlcs[0][dc_index]);
797 return get_xbits(&s->gb, code);
802 /* decode block and dequantize */
803 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
804 int dc_index, int ac_index, uint16_t *quant_matrix)
806 int code, i, j, level, val;
809 val = mjpeg_decode_dc(s, dc_index);
810 if (val == 0xfffff) {
811 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
812 return AVERROR_INVALIDDATA;
814 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
815 val = av_clip_int16(val);
816 s->last_dc[component] = val;
820 {OPEN_READER(re, &s->gb);
822 UPDATE_CACHE(re, &s->gb);
823 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
825 i += ((unsigned)code) >> 4;
828 if (code > MIN_CACHE_BITS - 16)
829 UPDATE_CACHE(re, &s->gb);
832 int cache = GET_CACHE(re, &s->gb);
833 int sign = (~cache) >> 31;
834 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
837 LAST_SKIP_BITS(re, &s->gb, code);
840 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
841 return AVERROR_INVALIDDATA;
843 j = s->scantable.permutated[i];
844 block[j] = level * quant_matrix[i];
847 CLOSE_READER(re, &s->gb);}
852 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
853 int component, int dc_index,
854 uint16_t *quant_matrix, int Al)
857 s->bdsp.clear_block(block);
858 val = mjpeg_decode_dc(s, dc_index);
859 if (val == 0xfffff) {
860 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
861 return AVERROR_INVALIDDATA;
863 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
864 s->last_dc[component] = val;
869 /* decode block and dequantize - progressive JPEG version */
870 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
871 uint8_t *last_nnz, int ac_index,
872 uint16_t *quant_matrix,
873 int ss, int se, int Al, int *EOBRUN)
875 int code, i, j, val, run;
884 OPEN_READER(re, &s->gb);
885 for (i = ss; ; i++) {
886 UPDATE_CACHE(re, &s->gb);
887 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
889 run = ((unsigned) code) >> 4;
893 if (code > MIN_CACHE_BITS - 16)
894 UPDATE_CACHE(re, &s->gb);
897 int cache = GET_CACHE(re, &s->gb);
898 int sign = (~cache) >> 31;
899 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
902 LAST_SKIP_BITS(re, &s->gb, code);
906 j = s->scantable.permutated[se];
907 block[j] = level * (quant_matrix[se] << Al);
910 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
911 return AVERROR_INVALIDDATA;
913 j = s->scantable.permutated[i];
914 block[j] = level * (quant_matrix[i] << Al);
916 if (run == 0xF) {// ZRL - skip 15 coefficients
919 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
920 return AVERROR_INVALIDDATA;
925 UPDATE_CACHE(re, &s->gb);
926 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
927 LAST_SKIP_BITS(re, &s->gb, run);
934 CLOSE_READER(re, &s->gb);
943 #define REFINE_BIT(j) { \
944 UPDATE_CACHE(re, &s->gb); \
945 sign = block[j] >> 15; \
946 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
947 ((quant_matrix[i] ^ sign) - sign) << Al; \
948 LAST_SKIP_BITS(re, &s->gb, 1); \
956 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
961 j = s->scantable.permutated[i]; \
964 else if (run-- == 0) \
968 /* decode block and dequantize - progressive JPEG refinement pass */
969 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
971 int ac_index, uint16_t *quant_matrix,
972 int ss, int se, int Al, int *EOBRUN)
974 int code, i = ss, j, sign, val, run;
975 int last = FFMIN(se, *last_nnz);
977 OPEN_READER(re, &s->gb);
982 UPDATE_CACHE(re, &s->gb);
983 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
986 run = ((unsigned) code) >> 4;
987 UPDATE_CACHE(re, &s->gb);
988 val = SHOW_UBITS(re, &s->gb, 1);
989 LAST_SKIP_BITS(re, &s->gb, 1);
991 j = s->scantable.permutated[i];
993 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
997 CLOSE_READER(re, &s->gb);
1001 run = ((unsigned) code) >> 4;
1008 UPDATE_CACHE(re, &s->gb);
1009 run += SHOW_UBITS(re, &s->gb, val);
1010 LAST_SKIP_BITS(re, &s->gb, val);
1022 for (; i <= last; i++) {
1023 j = s->scantable.permutated[i];
1027 CLOSE_READER(re, &s->gb);
1034 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1039 if (s->restart_interval) {
1041 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1042 align_get_bits(&s->gb);
1043 for (i = 0; i < nb_components; i++) /* reset dc */
1044 s->last_dc[i] = (4 << s->bits);
1047 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1049 if (s->restart_count == 0) {
1050 if( show_bits(&s->gb, i) == (1 << i) - 1
1051 || show_bits(&s->gb, i) == 0xFF) {
1052 int pos = get_bits_count(&s->gb);
1053 align_get_bits(&s->gb);
1054 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1055 skip_bits(&s->gb, 8);
1056 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1057 for (i = 0; i < nb_components; i++) /* reset dc */
1058 s->last_dc[i] = (4 << s->bits);
1061 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1068 /* Handles 1 to 4 components */
1069 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1073 uint16_t (*buffer)[4];
1074 int left[4], top[4], topleft[4];
1075 const int linesize = s->linesize[0];
1076 const int mask = ((1 << s->bits) - 1) << point_transform;
1077 int resync_mb_y = 0;
1078 int resync_mb_x = 0;
1081 if (!s->bayer && s->nb_components < 3)
1082 return AVERROR_INVALIDDATA;
1083 if (s->bayer && s->nb_components > 2)
1084 return AVERROR_INVALIDDATA;
1085 if (s->nb_components <= 0 || s->nb_components > 4)
1086 return AVERROR_INVALIDDATA;
1087 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1088 return AVERROR_INVALIDDATA;
1091 s->restart_count = s->restart_interval;
1093 if (s->restart_interval == 0)
1094 s->restart_interval = INT_MAX;
1097 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1099 width = s->mb_width;
1101 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1102 if (!s->ljpeg_buffer)
1103 return AVERROR(ENOMEM);
1105 buffer = s->ljpeg_buffer;
1107 for (i = 0; i < 4; i++)
1108 buffer[0][i] = 1 << (s->bits - 1);
1110 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1111 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1113 if (s->interlaced && s->bottom_field)
1114 ptr += linesize >> 1;
1116 for (i = 0; i < 4; i++)
1117 top[i] = left[i] = topleft[i] = buffer[0][i];
1119 if ((mb_y * s->width) % s->restart_interval == 0) {
1120 for (i = 0; i < 6; i++)
1121 vpred[i] = 1 << (s->bits-1);
1124 for (mb_x = 0; mb_x < width; mb_x++) {
1125 int modified_predictor = predictor;
1127 if (get_bits_left(&s->gb) < 1) {
1128 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1129 return AVERROR_INVALIDDATA;
1132 if (s->restart_interval && !s->restart_count){
1133 s->restart_count = s->restart_interval;
1137 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1139 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1140 modified_predictor = 1;
1142 for (i=0;i<nb_components;i++) {
1145 topleft[i] = top[i];
1146 top[i] = buffer[mb_x][i];
1148 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1152 if (!s->bayer || mb_x) {
1154 } else { /* This path runs only for the first line in bayer images */
1156 pred = vpred[i] - dc;
1159 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1161 left[i] = buffer[mb_x][i] =
1162 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1165 if (s->restart_interval && !--s->restart_count) {
1166 align_get_bits(&s->gb);
1167 skip_bits(&s->gb, 16); /* skip RSTn */
1170 if (s->rct && s->nb_components == 4) {
1171 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1172 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1173 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1174 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1175 ptr[4*mb_x + 0] = buffer[mb_x][3];
1177 } else if (s->nb_components == 4) {
1178 for(i=0; i<nb_components; i++) {
1179 int c= s->comp_index[i];
1181 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1182 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1184 } else if(s->bits == 9) {
1185 return AVERROR_PATCHWELCOME;
1187 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1188 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1192 } else if (s->rct) {
1193 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1194 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1195 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1196 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1198 } else if (s->pegasus_rct) {
1199 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1200 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1201 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1202 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1204 } else if (s->bayer) {
1205 if (nb_components == 1) {
1206 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1207 for (mb_x = 0; mb_x < width; mb_x++)
1208 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1209 } else if (nb_components == 2) {
1210 for (mb_x = 0; mb_x < width; mb_x++) {
1211 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1212 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1216 for(i=0; i<nb_components; i++) {
1217 int c= s->comp_index[i];
1219 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1220 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1222 } else if(s->bits == 9) {
1223 return AVERROR_PATCHWELCOME;
1225 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1226 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1235 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1236 int point_transform, int nb_components)
1238 int i, mb_x, mb_y, mask;
1239 int bits= (s->bits+7)&~7;
1240 int resync_mb_y = 0;
1241 int resync_mb_x = 0;
1243 point_transform += bits - s->bits;
1244 mask = ((1 << s->bits) - 1) << point_transform;
1246 av_assert0(nb_components>=1 && nb_components<=4);
1248 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1249 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1250 if (get_bits_left(&s->gb) < 1) {
1251 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1252 return AVERROR_INVALIDDATA;
1254 if (s->restart_interval && !s->restart_count){
1255 s->restart_count = s->restart_interval;
1260 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1261 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1262 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1263 for (i = 0; i < nb_components; i++) {
1266 int n, h, v, x, y, c, j, linesize;
1267 n = s->nb_blocks[i];
1268 c = s->comp_index[i];
1273 linesize= s->linesize[c];
1275 if(bits>8) linesize /= 2;
1277 for(j=0; j<n; j++) {
1280 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1283 if ( h * mb_x + x >= s->width
1284 || v * mb_y + y >= s->height) {
1286 } else if (bits<=8) {
1287 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1289 if(x==0 && leftcol){
1290 pred= 1 << (bits - 1);
1295 if(x==0 && leftcol){
1296 pred= ptr[-linesize];
1298 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1302 if (s->interlaced && s->bottom_field)
1303 ptr += linesize >> 1;
1305 *ptr= pred + ((unsigned)dc << point_transform);
1307 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1309 if(x==0 && leftcol){
1310 pred= 1 << (bits - 1);
1315 if(x==0 && leftcol){
1316 pred= ptr16[-linesize];
1318 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1322 if (s->interlaced && s->bottom_field)
1323 ptr16 += linesize >> 1;
1325 *ptr16= pred + ((unsigned)dc << point_transform);
1334 for (i = 0; i < nb_components; i++) {
1337 int n, h, v, x, y, c, j, linesize, dc;
1338 n = s->nb_blocks[i];
1339 c = s->comp_index[i];
1344 linesize = s->linesize[c];
1346 if(bits>8) linesize /= 2;
1348 for (j = 0; j < n; j++) {
1351 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1354 if ( h * mb_x + x >= s->width
1355 || v * mb_y + y >= s->height) {
1357 } else if (bits<=8) {
1358 ptr = s->picture_ptr->data[c] +
1359 (linesize * (v * mb_y + y)) +
1360 (h * mb_x + x); //FIXME optimize this crap
1361 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1364 *ptr = pred + ((unsigned)dc << point_transform);
1366 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1367 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1370 *ptr16= pred + ((unsigned)dc << point_transform);
1380 if (s->restart_interval && !--s->restart_count) {
1381 align_get_bits(&s->gb);
1382 skip_bits(&s->gb, 16); /* skip RSTn */
1389 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1390 uint8_t *dst, const uint8_t *src,
1391 int linesize, int lowres)
1394 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1396 case 1: copy_block4(dst, src, linesize, linesize, 4);
1398 case 2: copy_block2(dst, src, linesize, linesize, 2);
1400 case 3: *dst = *src;
1405 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1407 int block_x, block_y;
1408 int size = 8 >> s->avctx->lowres;
1410 for (block_y=0; block_y<size; block_y++)
1411 for (block_x=0; block_x<size; block_x++)
1412 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1414 for (block_y=0; block_y<size; block_y++)
1415 for (block_x=0; block_x<size; block_x++)
1416 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1420 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1421 int Al, const uint8_t *mb_bitmask,
1422 int mb_bitmask_size,
1423 const AVFrame *reference)
1425 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1426 uint8_t *data[MAX_COMPONENTS];
1427 const uint8_t *reference_data[MAX_COMPONENTS];
1428 int linesize[MAX_COMPONENTS];
1429 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1430 int bytes_per_pixel = 1 + (s->bits > 8);
1433 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1434 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1435 return AVERROR_INVALIDDATA;
1437 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1440 s->restart_count = 0;
1442 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1444 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1445 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1447 for (i = 0; i < nb_components; i++) {
1448 int c = s->comp_index[i];
1449 data[c] = s->picture_ptr->data[c];
1450 reference_data[c] = reference ? reference->data[c] : NULL;
1451 linesize[c] = s->linesize[c];
1452 s->coefs_finished[c] |= 1;
1455 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1456 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1457 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1459 if (s->restart_interval && !s->restart_count)
1460 s->restart_count = s->restart_interval;
1462 if (get_bits_left(&s->gb) < 0) {
1463 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1464 -get_bits_left(&s->gb));
1465 return AVERROR_INVALIDDATA;
1467 for (i = 0; i < nb_components; i++) {
1469 int n, h, v, x, y, c, j;
1471 n = s->nb_blocks[i];
1472 c = s->comp_index[i];
1477 for (j = 0; j < n; j++) {
1478 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1479 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1481 if (s->interlaced && s->bottom_field)
1482 block_offset += linesize[c] >> 1;
1483 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1484 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1485 ptr = data[c] + block_offset;
1488 if (!s->progressive) {
1491 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1492 linesize[c], s->avctx->lowres);
1495 s->bdsp.clear_block(s->block);
1496 if (decode_block(s, s->block, i,
1497 s->dc_index[i], s->ac_index[i],
1498 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1499 av_log(s->avctx, AV_LOG_ERROR,
1500 "error y=%d x=%d\n", mb_y, mb_x);
1501 return AVERROR_INVALIDDATA;
1504 s->idsp.idct_put(ptr, linesize[c], s->block);
1506 shift_output(s, ptr, linesize[c]);
1510 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1512 int16_t *block = s->blocks[c][block_idx];
1514 block[0] += get_bits1(&s->gb) *
1515 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1516 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1517 s->quant_matrixes[s->quant_sindex[i]],
1519 av_log(s->avctx, AV_LOG_ERROR,
1520 "error y=%d x=%d\n", mb_y, mb_x);
1521 return AVERROR_INVALIDDATA;
1524 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1525 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1526 mb_x, mb_y, x, y, c, s->bottom_field,
1527 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1535 handle_rstn(s, nb_components);
1541 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1542 int se, int Ah, int Al)
1546 int c = s->comp_index[0];
1547 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1549 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1550 if (se < ss || se > 63) {
1551 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1552 return AVERROR_INVALIDDATA;
1555 // s->coefs_finished is a bitmask for coefficients coded
1556 // ss and se are parameters telling start and end coefficients
1557 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1559 s->restart_count = 0;
1561 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1562 int block_idx = mb_y * s->block_stride[c];
1563 int16_t (*block)[64] = &s->blocks[c][block_idx];
1564 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1565 if (get_bits_left(&s->gb) <= 0) {
1566 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1567 return AVERROR_INVALIDDATA;
1569 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1571 if (s->restart_interval && !s->restart_count)
1572 s->restart_count = s->restart_interval;
1575 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1576 quant_matrix, ss, se, Al, &EOBRUN);
1578 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1579 quant_matrix, ss, se, Al, &EOBRUN);
1581 av_log(s->avctx, AV_LOG_ERROR,
1582 "error y=%d x=%d\n", mb_y, mb_x);
1583 return AVERROR_INVALIDDATA;
1586 if (handle_rstn(s, 0))
1593 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1597 const int bytes_per_pixel = 1 + (s->bits > 8);
1598 const int block_size = s->lossless ? 1 : 8;
1600 for (c = 0; c < s->nb_components; c++) {
1601 uint8_t *data = s->picture_ptr->data[c];
1602 int linesize = s->linesize[c];
1603 int h = s->h_max / s->h_count[c];
1604 int v = s->v_max / s->v_count[c];
1605 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1606 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1608 if (~s->coefs_finished[c])
1609 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1611 if (s->interlaced && s->bottom_field)
1612 data += linesize >> 1;
1614 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1615 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1616 int block_idx = mb_y * s->block_stride[c];
1617 int16_t (*block)[64] = &s->blocks[c][block_idx];
1618 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1619 s->idsp.idct_put(ptr, linesize, *block);
1621 shift_output(s, ptr, linesize);
1622 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1628 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1629 int mb_bitmask_size, const AVFrame *reference)
1631 int len, nb_components, i, h, v, predictor, point_transform;
1633 const int block_size = s->lossless ? 1 : 8;
1634 int ilv, prev_shift;
1636 if (!s->got_picture) {
1637 av_log(s->avctx, AV_LOG_WARNING,
1638 "Can not process SOS before SOF, skipping\n");
1643 if (reference->width != s->picture_ptr->width ||
1644 reference->height != s->picture_ptr->height ||
1645 reference->format != s->picture_ptr->format) {
1646 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1647 return AVERROR_INVALIDDATA;
1651 /* XXX: verify len field validity */
1652 len = get_bits(&s->gb, 16);
1653 nb_components = get_bits(&s->gb, 8);
1654 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1655 avpriv_report_missing_feature(s->avctx,
1656 "decode_sos: nb_components (%d)",
1658 return AVERROR_PATCHWELCOME;
1660 if (len != 6 + 2 * nb_components) {
1661 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1662 return AVERROR_INVALIDDATA;
1664 for (i = 0; i < nb_components; i++) {
1665 id = get_bits(&s->gb, 8) - 1;
1666 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1667 /* find component index */
1668 for (index = 0; index < s->nb_components; index++)
1669 if (id == s->component_id[index])
1671 if (index == s->nb_components) {
1672 av_log(s->avctx, AV_LOG_ERROR,
1673 "decode_sos: index(%d) out of components\n", index);
1674 return AVERROR_INVALIDDATA;
1676 /* Metasoft MJPEG codec has Cb and Cr swapped */
1677 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1678 && nb_components == 3 && s->nb_components == 3 && i)
1681 s->quant_sindex[i] = s->quant_index[index];
1682 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1683 s->h_scount[i] = s->h_count[index];
1684 s->v_scount[i] = s->v_count[index];
1686 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1687 index = (index+2)%3;
1689 s->comp_index[i] = index;
1691 s->dc_index[i] = get_bits(&s->gb, 4);
1692 s->ac_index[i] = get_bits(&s->gb, 4);
1694 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1695 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1697 if (!s->vlcs[0][s->dc_index[i]].table || !(s->progressive ? s->vlcs[2][s->ac_index[0]].table : s->vlcs[1][s->ac_index[i]].table))
1701 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1702 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1703 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1704 prev_shift = get_bits(&s->gb, 4); /* Ah */
1705 point_transform = get_bits(&s->gb, 4); /* Al */
1707 prev_shift = point_transform = 0;
1709 if (nb_components > 1) {
1710 /* interleaved stream */
1711 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1712 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1713 } else if (!s->ls) { /* skip this for JPEG-LS */
1714 h = s->h_max / s->h_scount[0];
1715 v = s->v_max / s->v_scount[0];
1716 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1717 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1718 s->nb_blocks[0] = 1;
1723 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1724 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1725 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1726 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1727 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1730 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1731 for (i = s->mjpb_skiptosod; i > 0; i--)
1732 skip_bits(&s->gb, 8);
1735 for (i = 0; i < nb_components; i++)
1736 s->last_dc[i] = (4 << s->bits);
1738 if (s->avctx->hwaccel) {
1739 int bytes_to_start = get_bits_count(&s->gb) / 8;
1740 av_assert0(bytes_to_start >= 0 &&
1741 s->raw_scan_buffer_size >= bytes_to_start);
1743 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1744 s->raw_scan_buffer + bytes_to_start,
1745 s->raw_scan_buffer_size - bytes_to_start);
1749 } else if (s->lossless) {
1750 av_assert0(s->picture_ptr == s->picture);
1751 if (CONFIG_JPEGLS_DECODER && s->ls) {
1753 // reset_ls_coding_parameters(s, 0);
1755 if ((ret = ff_jpegls_decode_picture(s, predictor,
1756 point_transform, ilv)) < 0)
1759 if (s->rgb || s->bayer) {
1760 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1763 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1765 nb_components)) < 0)
1770 if (s->progressive && predictor) {
1771 av_assert0(s->picture_ptr == s->picture);
1772 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1774 point_transform)) < 0)
1777 if ((ret = mjpeg_decode_scan(s, nb_components,
1778 prev_shift, point_transform,
1779 mb_bitmask, mb_bitmask_size, reference)) < 0)
1784 if (s->interlaced &&
1785 get_bits_left(&s->gb) > 32 &&
1786 show_bits(&s->gb, 8) == 0xFF) {
1787 GetBitContext bak = s->gb;
1788 align_get_bits(&bak);
1789 if (show_bits(&bak, 16) == 0xFFD1) {
1790 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1792 skip_bits(&s->gb, 16);
1793 s->bottom_field ^= 1;
1802 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1803 return AVERROR_INVALIDDATA;
1806 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1808 if (get_bits(&s->gb, 16) != 4)
1809 return AVERROR_INVALIDDATA;
1810 s->restart_interval = get_bits(&s->gb, 16);
1811 s->restart_count = 0;
1812 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1813 s->restart_interval);
1818 static int mjpeg_decode_app(MJpegDecodeContext *s)
1822 len = get_bits(&s->gb, 16);
1825 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1826 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1827 skip_bits(&s->gb, len);
1830 return AVERROR_INVALIDDATA;
1832 if (8 * len > get_bits_left(&s->gb))
1833 return AVERROR_INVALIDDATA;
1835 id = get_bits_long(&s->gb, 32);
1838 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1839 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1840 av_fourcc2str(av_bswap32(id)), id, len);
1842 /* Buggy AVID, it puts EOI only at every 10th frame. */
1843 /* Also, this fourcc is used by non-avid files too, it holds some
1844 information, but it's always present in AVID-created files. */
1845 if (id == AV_RB32("AVI1")) {
1851 4bytes field_size_less_padding
1854 i = get_bits(&s->gb, 8); len--;
1855 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1859 if (id == AV_RB32("JFIF")) {
1860 int t_w, t_h, v1, v2;
1863 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1864 v1 = get_bits(&s->gb, 8);
1865 v2 = get_bits(&s->gb, 8);
1866 skip_bits(&s->gb, 8);
1868 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1869 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1870 if ( s->avctx->sample_aspect_ratio.num <= 0
1871 || s->avctx->sample_aspect_ratio.den <= 0) {
1872 s->avctx->sample_aspect_ratio.num = 0;
1873 s->avctx->sample_aspect_ratio.den = 1;
1876 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1877 av_log(s->avctx, AV_LOG_INFO,
1878 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1880 s->avctx->sample_aspect_ratio.num,
1881 s->avctx->sample_aspect_ratio.den);
1885 t_w = get_bits(&s->gb, 8);
1886 t_h = get_bits(&s->gb, 8);
1888 /* skip thumbnail */
1889 if (len -10 - (t_w * t_h * 3) > 0)
1890 len -= t_w * t_h * 3;
1897 if ( id == AV_RB32("Adob")
1899 && show_bits(&s->gb, 8) == 'e'
1900 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1901 skip_bits(&s->gb, 8); /* 'e' */
1902 skip_bits(&s->gb, 16); /* version */
1903 skip_bits(&s->gb, 16); /* flags0 */
1904 skip_bits(&s->gb, 16); /* flags1 */
1905 s->adobe_transform = get_bits(&s->gb, 8);
1906 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1907 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1912 if (id == AV_RB32("LJIF")) {
1914 int pegasus_rct = s->pegasus_rct;
1915 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1916 av_log(s->avctx, AV_LOG_INFO,
1917 "Pegasus lossless jpeg header found\n");
1918 skip_bits(&s->gb, 16); /* version ? */
1919 skip_bits(&s->gb, 16); /* unknown always 0? */
1920 skip_bits(&s->gb, 16); /* unknown always 0? */
1921 skip_bits(&s->gb, 16); /* unknown always 0? */
1922 switch (i=get_bits(&s->gb, 8)) {
1932 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1937 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1938 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1943 s->pegasus_rct = pegasus_rct;
1947 if (id == AV_RL32("colr") && len > 0) {
1948 s->colr = get_bits(&s->gb, 8);
1949 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1950 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1954 if (id == AV_RL32("xfrm") && len > 0) {
1955 s->xfrm = get_bits(&s->gb, 8);
1956 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1957 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1962 /* JPS extension by VRex */
1963 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1964 int flags, layout, type;
1965 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1966 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1968 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1969 skip_bits(&s->gb, 16); len -= 2; /* block length */
1970 skip_bits(&s->gb, 8); /* reserved */
1971 flags = get_bits(&s->gb, 8);
1972 layout = get_bits(&s->gb, 8);
1973 type = get_bits(&s->gb, 8);
1976 av_freep(&s->stereo3d);
1977 s->stereo3d = av_stereo3d_alloc();
1982 s->stereo3d->type = AV_STEREO3D_2D;
1983 } else if (type == 1) {
1986 s->stereo3d->type = AV_STEREO3D_LINES;
1989 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1992 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1995 if (!(flags & 0x04)) {
1996 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2003 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2004 GetByteContext gbytes;
2005 int ret, le, ifd_offset, bytes_read;
2006 const uint8_t *aligned;
2008 skip_bits(&s->gb, 16); // skip padding
2011 // init byte wise reading
2012 aligned = align_get_bits(&s->gb);
2013 bytestream2_init(&gbytes, aligned, len);
2016 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2018 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2020 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2022 // read 0th IFD and store the metadata
2023 // (return values > 0 indicate the presence of subimage metadata)
2024 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2026 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2030 bytes_read = bytestream2_tell(&gbytes);
2031 skip_bits(&s->gb, bytes_read << 3);
2038 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2039 id = get_bits_long(&s->gb, 32);
2042 if (id == AV_RB32("mjpg")) {
2045 4bytes pad field size
2053 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2054 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2058 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2061 unsigned nummarkers;
2063 id = get_bits_long(&s->gb, 32);
2064 id2 = get_bits(&s->gb, 24);
2066 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2067 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2071 skip_bits(&s->gb, 8);
2072 seqno = get_bits(&s->gb, 8);
2075 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2079 nummarkers = get_bits(&s->gb, 8);
2081 if (nummarkers == 0) {
2082 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2084 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2085 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2087 } else if (seqno > nummarkers) {
2088 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2092 /* Allocate if this is the first APP2 we've seen. */
2093 if (s->iccnum == 0) {
2094 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2095 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2096 if (!s->iccdata || !s->iccdatalens) {
2097 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2098 return AVERROR(ENOMEM);
2100 s->iccnum = nummarkers;
2103 if (s->iccdata[seqno - 1]) {
2104 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2108 s->iccdatalens[seqno - 1] = len;
2109 s->iccdata[seqno - 1] = av_malloc(len);
2110 if (!s->iccdata[seqno - 1]) {
2111 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2112 return AVERROR(ENOMEM);
2115 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2116 skip_bits(&s->gb, len << 3);
2120 if (s->iccread > s->iccnum)
2121 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2125 /* slow but needed for extreme adobe jpegs */
2127 av_log(s->avctx, AV_LOG_ERROR,
2128 "mjpeg: error, decode_app parser read over the end\n");
2130 skip_bits(&s->gb, 8);
2135 static int mjpeg_decode_com(MJpegDecodeContext *s)
2137 int len = get_bits(&s->gb, 16);
2138 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2140 char *cbuf = av_malloc(len - 1);
2142 return AVERROR(ENOMEM);
2144 for (i = 0; i < len - 2; i++)
2145 cbuf[i] = get_bits(&s->gb, 8);
2146 if (i > 0 && cbuf[i - 1] == '\n')
2151 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2152 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2154 /* buggy avid, it puts EOI only at every 10th frame */
2155 if (!strncmp(cbuf, "AVID", 4)) {
2156 parse_avid(s, cbuf, len);
2157 } else if (!strcmp(cbuf, "CS=ITU601"))
2159 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2160 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2162 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2163 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2173 /* return the 8 bit start code value and update the search
2174 state. Return -1 if no start code found */
2175 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2177 const uint8_t *buf_ptr;
2182 buf_ptr = *pbuf_ptr;
2183 while (buf_end - buf_ptr > 1) {
2186 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2195 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2196 *pbuf_ptr = buf_ptr;
2200 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2201 const uint8_t **buf_ptr, const uint8_t *buf_end,
2202 const uint8_t **unescaped_buf_ptr,
2203 int *unescaped_buf_size)
2206 start_code = find_marker(buf_ptr, buf_end);
2208 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2210 return AVERROR(ENOMEM);
2212 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2213 if (start_code == SOS && !s->ls) {
2214 const uint8_t *src = *buf_ptr;
2215 const uint8_t *ptr = src;
2216 uint8_t *dst = s->buffer;
2218 #define copy_data_segment(skip) do { \
2219 ptrdiff_t length = (ptr - src) - (skip); \
2221 memcpy(dst, src, length); \
2227 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2229 copy_data_segment(0);
2231 while (ptr < buf_end) {
2232 uint8_t x = *(ptr++);
2236 while (ptr < buf_end && x == 0xff) {
2241 /* 0xFF, 0xFF, ... */
2243 copy_data_segment(skip);
2245 /* decrement src as it is equal to ptr after the
2246 * copy_data_segment macro and we might want to
2247 * copy the current value of x later on */
2251 if (x < RST0 || x > RST7) {
2252 copy_data_segment(1);
2259 copy_data_segment(0);
2261 #undef copy_data_segment
2263 *unescaped_buf_ptr = s->buffer;
2264 *unescaped_buf_size = dst - s->buffer;
2265 memset(s->buffer + *unescaped_buf_size, 0,
2266 AV_INPUT_BUFFER_PADDING_SIZE);
2268 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2269 (buf_end - *buf_ptr) - (dst - s->buffer));
2270 } else if (start_code == SOS && s->ls) {
2271 const uint8_t *src = *buf_ptr;
2272 uint8_t *dst = s->buffer;
2278 while (src + t < buf_end) {
2279 uint8_t x = src[t++];
2281 while ((src + t < buf_end) && x == 0xff)
2290 init_put_bits(&pb, dst, t);
2292 /* unescape bitstream */
2294 uint8_t x = src[b++];
2295 put_bits(&pb, 8, x);
2296 if (x == 0xFF && b < t) {
2299 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2302 put_bits(&pb, 7, x);
2306 flush_put_bits(&pb);
2308 *unescaped_buf_ptr = dst;
2309 *unescaped_buf_size = (bit_count + 7) >> 3;
2310 memset(s->buffer + *unescaped_buf_size, 0,
2311 AV_INPUT_BUFFER_PADDING_SIZE);
2313 *unescaped_buf_ptr = *buf_ptr;
2314 *unescaped_buf_size = buf_end - *buf_ptr;
2320 static void reset_icc_profile(MJpegDecodeContext *s)
2325 for (i = 0; i < s->iccnum; i++)
2326 av_freep(&s->iccdata[i]);
2327 av_freep(&s->iccdata);
2328 av_freep(&s->iccdatalens);
2334 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2337 AVFrame *frame = data;
2338 const uint8_t *buf = avpkt->data;
2339 int buf_size = avpkt->size;
2340 MJpegDecodeContext *s = avctx->priv_data;
2341 const uint8_t *buf_end, *buf_ptr;
2342 const uint8_t *unescaped_buf_ptr;
2344 int unescaped_buf_size;
2350 s->buf_size = buf_size;
2352 av_dict_free(&s->exif_metadata);
2353 av_freep(&s->stereo3d);
2354 s->adobe_transform = -1;
2357 reset_icc_profile(s);
2360 buf_end = buf + buf_size;
2361 while (buf_ptr < buf_end) {
2362 /* find start next marker */
2363 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2365 &unescaped_buf_size);
2367 if (start_code < 0) {
2369 } else if (unescaped_buf_size > INT_MAX / 8) {
2370 av_log(avctx, AV_LOG_ERROR,
2371 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2372 start_code, unescaped_buf_size, buf_size);
2373 return AVERROR_INVALIDDATA;
2375 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2376 start_code, buf_end - buf_ptr);
2378 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2381 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2385 s->start_code = start_code;
2386 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2387 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2389 /* process markers */
2390 if (start_code >= RST0 && start_code <= RST7) {
2391 av_log(avctx, AV_LOG_DEBUG,
2392 "restart marker: %d\n", start_code & 0x0f);
2394 } else if (start_code >= APP0 && start_code <= APP15) {
2395 if ((ret = mjpeg_decode_app(s)) < 0)
2396 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2399 } else if (start_code == COM) {
2400 ret = mjpeg_decode_com(s);
2403 } else if (start_code == DQT) {
2404 ret = ff_mjpeg_decode_dqt(s);
2411 if (!CONFIG_JPEGLS_DECODER &&
2412 (start_code == SOF48 || start_code == LSE)) {
2413 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2414 return AVERROR(ENOSYS);
2417 if (avctx->skip_frame == AVDISCARD_ALL) {
2418 switch(start_code) {
2433 switch (start_code) {
2435 s->restart_interval = 0;
2436 s->restart_count = 0;
2437 s->raw_image_buffer = buf_ptr;
2438 s->raw_image_buffer_size = buf_end - buf_ptr;
2439 /* nothing to do on SOI */
2442 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2443 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2449 if (start_code == SOF0)
2450 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2452 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2456 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2460 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2464 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2468 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2469 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2473 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2477 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2478 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2482 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2486 if (!CONFIG_JPEGLS_DECODER ||
2487 (ret = ff_jpegls_decode_lse(s)) < 0)
2492 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2493 s->progressive && s->cur_scan && s->got_picture)
2494 mjpeg_idct_scan_progressive_ac(s);
2496 if (!s->got_picture) {
2497 av_log(avctx, AV_LOG_WARNING,
2498 "Found EOI before any SOF, ignoring\n");
2501 if (s->interlaced) {
2502 s->bottom_field ^= 1;
2503 /* if not bottom field, do not output image yet */
2504 if (s->bottom_field == !s->interlace_polarity)
2507 if (avctx->skip_frame == AVDISCARD_ALL) {
2509 goto the_end_no_picture;
2511 if (s->avctx->hwaccel) {
2512 ret = s->avctx->hwaccel->end_frame(s->avctx);
2516 av_freep(&s->hwaccel_picture_private);
2518 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2524 int qp = FFMAX3(s->qscale[0],
2527 int qpw = (s->width + 15) / 16;
2528 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2530 memset(qp_table_buf->data, qp, qpw);
2531 av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2534 if(avctx->debug & FF_DEBUG_QP)
2535 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2540 s->raw_scan_buffer = buf_ptr;
2541 s->raw_scan_buffer_size = buf_end - buf_ptr;
2544 if (avctx->skip_frame == AVDISCARD_ALL) {
2545 skip_bits(&s->gb, get_bits_left(&s->gb));
2549 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2550 (avctx->err_recognition & AV_EF_EXPLODE))
2554 if ((ret = mjpeg_decode_dri(s)) < 0)
2567 av_log(avctx, AV_LOG_ERROR,
2568 "mjpeg: unsupported coding type (%x)\n", start_code);
2573 /* eof process start code */
2574 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2575 av_log(avctx, AV_LOG_DEBUG,
2576 "marker parser used %d bytes (%d bits)\n",
2577 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2579 if (s->got_picture && s->cur_scan) {
2580 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2583 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2584 return AVERROR_INVALIDDATA;
2590 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2592 if (AV_RB32(s->upscale_h)) {
2594 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2595 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2596 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2597 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2598 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2599 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2600 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2601 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2602 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2603 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2604 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2605 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2607 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2611 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2612 for (p = 0; p<s->nb_components; p++) {
2613 uint8_t *line = s->picture_ptr->data[p];
2616 if (!s->upscale_h[p])
2619 w = AV_CEIL_RSHIFT(w, hshift);
2620 h = AV_CEIL_RSHIFT(h, vshift);
2622 if (s->upscale_v[p] == 1)
2625 for (i = 0; i < h; i++) {
2626 if (s->upscale_h[p] == 1) {
2627 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2628 else line[w - 1] = line[(w - 1) / 2];
2629 for (index = w - 2; index > 0; index--) {
2631 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2633 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2635 } else if (s->upscale_h[p] == 2) {
2637 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2639 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2641 line[w - 1] = line[(w - 1) / 3];
2643 line[w - 2] = line[w - 1];
2645 for (index = w - 3; index > 0; index--) {
2646 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2649 line += s->linesize[p];
2653 if (AV_RB32(s->upscale_v)) {
2655 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2656 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2657 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2658 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2659 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2660 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2661 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2662 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2663 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2664 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2665 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2666 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2667 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2669 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2673 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2674 for (p = 0; p < s->nb_components; p++) {
2678 if (!s->upscale_v[p])
2681 w = AV_CEIL_RSHIFT(w, hshift);
2682 h = AV_CEIL_RSHIFT(h, vshift);
2684 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2685 for (i = h - 1; i; i--) {
2686 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2687 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2688 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2689 memcpy(dst, src1, w);
2691 for (index = 0; index < w; index++)
2692 dst[index] = (src1[index] + src2[index]) >> 1;
2694 dst -= s->linesize[p];
2698 if (s->flipped && !s->rgb) {
2700 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2704 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2705 for (index=0; index<s->nb_components; index++) {
2706 uint8_t *dst = s->picture_ptr->data[index];
2707 int w = s->picture_ptr->width;
2708 int h = s->picture_ptr->height;
2709 if(index && index<3){
2710 w = AV_CEIL_RSHIFT(w, hshift);
2711 h = AV_CEIL_RSHIFT(h, vshift);
2714 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2715 for (i=0; i<h/2; i++) {
2717 FFSWAP(int, dst[j], dst2[j]);
2718 dst += s->picture_ptr->linesize[index];
2719 dst2 -= s->picture_ptr->linesize[index];
2724 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2725 int w = s->picture_ptr->width;
2726 int h = s->picture_ptr->height;
2727 av_assert0(s->nb_components == 4);
2728 for (i=0; i<h; i++) {
2731 for (index=0; index<4; index++) {
2732 dst[index] = s->picture_ptr->data[index]
2733 + s->picture_ptr->linesize[index]*i;
2735 for (j=0; j<w; j++) {
2737 int r = dst[0][j] * k;
2738 int g = dst[1][j] * k;
2739 int b = dst[2][j] * k;
2740 dst[0][j] = g*257 >> 16;
2741 dst[1][j] = b*257 >> 16;
2742 dst[2][j] = r*257 >> 16;
2747 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2748 int w = s->picture_ptr->width;
2749 int h = s->picture_ptr->height;
2750 av_assert0(s->nb_components == 4);
2751 for (i=0; i<h; i++) {
2754 for (index=0; index<4; index++) {
2755 dst[index] = s->picture_ptr->data[index]
2756 + s->picture_ptr->linesize[index]*i;
2758 for (j=0; j<w; j++) {
2760 int r = (255 - dst[0][j]) * k;
2761 int g = (128 - dst[1][j]) * k;
2762 int b = (128 - dst[2][j]) * k;
2763 dst[0][j] = r*257 >> 16;
2764 dst[1][j] = (g*257 >> 16) + 128;
2765 dst[2][j] = (b*257 >> 16) + 128;
2772 AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2774 stereo->type = s->stereo3d->type;
2775 stereo->flags = s->stereo3d->flags;
2777 av_freep(&s->stereo3d);
2780 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2781 AVFrameSideData *sd;
2786 /* Sum size of all parts. */
2787 for (i = 0; i < s->iccnum; i++)
2788 total_size += s->iccdatalens[i];
2790 sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2792 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2793 return AVERROR(ENOMEM);
2796 /* Reassemble the parts, which are now in-order. */
2797 for (i = 0; i < s->iccnum; i++) {
2798 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2799 offset += s->iccdatalens[i];
2803 av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2804 av_dict_free(&s->exif_metadata);
2807 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2809 // return buf_end - buf_ptr;
2810 return buf_ptr - buf;
2813 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2814 * even without having called ff_mjpeg_decode_init(). */
2815 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2817 MJpegDecodeContext *s = avctx->priv_data;
2820 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2821 av_log(avctx, AV_LOG_INFO, "Single field\n");
2825 av_frame_free(&s->picture);
2826 s->picture_ptr = NULL;
2827 } else if (s->picture_ptr)
2828 av_frame_unref(s->picture_ptr);
2830 av_freep(&s->buffer);
2831 av_freep(&s->stereo3d);
2832 av_freep(&s->ljpeg_buffer);
2833 s->ljpeg_buffer_size = 0;
2835 for (i = 0; i < 3; i++) {
2836 for (j = 0; j < 4; j++)
2837 ff_free_vlc(&s->vlcs[i][j]);
2839 for (i = 0; i < MAX_COMPONENTS; i++) {
2840 av_freep(&s->blocks[i]);
2841 av_freep(&s->last_nnz[i]);
2843 av_dict_free(&s->exif_metadata);
2845 reset_icc_profile(s);
2847 av_freep(&s->hwaccel_picture_private);
2852 static void decode_flush(AVCodecContext *avctx)
2854 MJpegDecodeContext *s = avctx->priv_data;
2858 #if CONFIG_MJPEG_DECODER
2859 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2860 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2861 static const AVOption options[] = {
2862 { "extern_huff", "Use external huffman table.",
2863 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2867 static const AVClass mjpegdec_class = {
2868 .class_name = "MJPEG decoder",
2869 .item_name = av_default_item_name,
2871 .version = LIBAVUTIL_VERSION_INT,
2874 AVCodec ff_mjpeg_decoder = {
2876 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2877 .type = AVMEDIA_TYPE_VIDEO,
2878 .id = AV_CODEC_ID_MJPEG,
2879 .priv_data_size = sizeof(MJpegDecodeContext),
2880 .init = ff_mjpeg_decode_init,
2881 .close = ff_mjpeg_decode_end,
2882 .decode = ff_mjpeg_decode_frame,
2883 .flush = decode_flush,
2884 .capabilities = AV_CODEC_CAP_DR1,
2886 .priv_class = &mjpegdec_class,
2887 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2888 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2889 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2890 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2891 #if CONFIG_MJPEG_NVDEC_HWACCEL
2892 HWACCEL_NVDEC(mjpeg),
2894 #if CONFIG_MJPEG_VAAPI_HWACCEL
2895 HWACCEL_VAAPI(mjpeg),
2901 #if CONFIG_THP_DECODER
2902 AVCodec ff_thp_decoder = {
2904 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2905 .type = AVMEDIA_TYPE_VIDEO,
2906 .id = AV_CODEC_ID_THP,
2907 .priv_data_size = sizeof(MJpegDecodeContext),
2908 .init = ff_mjpeg_decode_init,
2909 .close = ff_mjpeg_decode_end,
2910 .decode = ff_mjpeg_decode_frame,
2911 .flush = decode_flush,
2912 .capabilities = AV_CODEC_CAP_DR1,
2914 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,