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 int build_vlc(VLC *vlc, const uint8_t *bits_table,
54 const uint8_t *val_table, int nb_codes,
55 int use_static, int is_ac)
57 uint8_t huff_size[256] = { 0 };
58 uint16_t huff_code[256];
59 uint16_t huff_sym[256];
62 av_assert0(nb_codes <= 256);
64 ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
66 for (i = 0; i < 256; i++)
67 huff_sym[i] = i + 16 * is_ac;
70 huff_sym[0] = 16 * 256;
72 return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
73 huff_code, 2, 2, huff_sym, 2, 2, use_static);
76 static int init_default_huffman_tables(MJpegDecodeContext *s)
82 const uint8_t *values;
86 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
87 avpriv_mjpeg_val_dc, 12, 12 },
88 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
89 avpriv_mjpeg_val_dc, 12, 12 },
90 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
91 avpriv_mjpeg_val_ac_luminance, 251, 162 },
92 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
93 avpriv_mjpeg_val_ac_chrominance, 251, 162 },
94 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
95 avpriv_mjpeg_val_ac_luminance, 251, 162 },
96 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
97 avpriv_mjpeg_val_ac_chrominance, 251, 162 },
101 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
102 ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
103 ht[i].bits, ht[i].values, ht[i].codes,
104 0, ht[i].class == 1);
108 if (ht[i].class < 2) {
109 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
111 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
112 ht[i].values, ht[i].length);
119 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
122 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
123 s->interlace_polarity = 1;
124 if (len > 14 && buf[12] == 2) /* 2 - PAL */
125 s->interlace_polarity = 0;
126 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
127 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
130 static void init_idct(AVCodecContext *avctx)
132 MJpegDecodeContext *s = avctx->priv_data;
134 ff_idctdsp_init(&s->idsp, avctx);
135 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
139 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
141 MJpegDecodeContext *s = avctx->priv_data;
144 if (!s->picture_ptr) {
145 s->picture = av_frame_alloc();
147 return AVERROR(ENOMEM);
148 s->picture_ptr = s->picture;
152 ff_blockdsp_init(&s->bdsp, avctx);
153 ff_hpeldsp_init(&s->hdsp, avctx->flags);
158 s->first_picture = 1;
160 s->org_height = avctx->coded_height;
161 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
162 avctx->colorspace = AVCOL_SPC_BT470BG;
163 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
165 if ((ret = init_default_huffman_tables(s)) < 0)
168 if (s->extern_huff) {
169 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
170 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
172 if (ff_mjpeg_decode_dht(s)) {
173 av_log(avctx, AV_LOG_ERROR,
174 "error using external huffman table, switching back to internal\n");
175 init_default_huffman_tables(s);
178 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
179 s->interlace_polarity = 1; /* bottom field first */
180 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
181 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
182 if (avctx->codec_tag == AV_RL32("MJPG"))
183 s->interlace_polarity = 1;
186 if ( avctx->extradata_size > 8
187 && AV_RL32(avctx->extradata) == 0x2C
188 && AV_RL32(avctx->extradata+4) == 0x18) {
189 parse_avid(s, avctx->extradata, avctx->extradata_size);
192 if (avctx->codec->id == AV_CODEC_ID_AMV)
199 /* quantize tables */
200 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
204 len = get_bits(&s->gb, 16) - 2;
206 if (8*len > get_bits_left(&s->gb)) {
207 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
208 return AVERROR_INVALIDDATA;
212 int pr = get_bits(&s->gb, 4);
214 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
215 return AVERROR_INVALIDDATA;
217 index = get_bits(&s->gb, 4);
220 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
221 /* read quant table */
222 for (i = 0; i < 64; i++) {
223 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
224 if (s->quant_matrixes[index][i] == 0) {
225 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
226 return AVERROR_INVALIDDATA;
230 // XXX FIXME fine-tune, and perhaps add dc too
231 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
232 s->quant_matrixes[index][8]) >> 1;
233 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
234 index, s->qscale[index]);
235 len -= 1 + 64 * (1+pr);
240 /* decode huffman tables and build VLC decoders */
241 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
243 int len, index, i, class, n, v, code_max;
244 uint8_t bits_table[17];
245 uint8_t val_table[256];
248 len = get_bits(&s->gb, 16) - 2;
250 if (8*len > get_bits_left(&s->gb)) {
251 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
252 return AVERROR_INVALIDDATA;
257 return AVERROR_INVALIDDATA;
258 class = get_bits(&s->gb, 4);
260 return AVERROR_INVALIDDATA;
261 index = get_bits(&s->gb, 4);
263 return AVERROR_INVALIDDATA;
265 for (i = 1; i <= 16; i++) {
266 bits_table[i] = get_bits(&s->gb, 8);
270 if (len < n || n > 256)
271 return AVERROR_INVALIDDATA;
274 for (i = 0; i < n; i++) {
275 v = get_bits(&s->gb, 8);
282 /* build VLC and flush previous vlc if present */
283 ff_free_vlc(&s->vlcs[class][index]);
284 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
285 class, index, code_max + 1);
286 if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
287 code_max + 1, 0, class > 0)) < 0)
291 ff_free_vlc(&s->vlcs[2][index]);
292 if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
293 code_max + 1, 0, 0)) < 0)
297 for (i = 0; i < 16; i++)
298 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
299 for (i = 0; i < 256; i++)
300 s->raw_huffman_values[class][index][i] = val_table[i];
305 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
307 int len, nb_components, i, width, height, bits, ret, size_change;
309 int h_count[MAX_COMPONENTS] = { 0 };
310 int v_count[MAX_COMPONENTS] = { 0 };
313 memset(s->upscale_h, 0, sizeof(s->upscale_h));
314 memset(s->upscale_v, 0, sizeof(s->upscale_v));
316 len = get_bits(&s->gb, 16);
317 bits = get_bits(&s->gb, 8);
319 if (bits > 16 || bits < 1) {
320 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
321 return AVERROR_INVALIDDATA;
324 if (s->avctx->bits_per_raw_sample != bits) {
325 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);
326 s->avctx->bits_per_raw_sample = bits;
331 if (bits == 9 && !s->pegasus_rct)
332 s->rct = 1; // FIXME ugly
334 if(s->lossless && s->avctx->lowres){
335 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
339 height = get_bits(&s->gb, 16);
340 width = get_bits(&s->gb, 16);
342 // HACK for odd_height.mov
343 if (s->interlaced && s->width == width && s->height == height + 1)
346 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
347 if (av_image_check_size(width, height, 0, s->avctx) < 0)
348 return AVERROR_INVALIDDATA;
349 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
350 return AVERROR_INVALIDDATA;
352 nb_components = get_bits(&s->gb, 8);
353 if (nb_components <= 0 ||
354 nb_components > MAX_COMPONENTS)
356 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
357 if (nb_components != s->nb_components) {
358 av_log(s->avctx, AV_LOG_ERROR,
359 "nb_components changing in interlaced picture\n");
360 return AVERROR_INVALIDDATA;
363 if (s->ls && !(bits <= 8 || nb_components == 1)) {
364 avpriv_report_missing_feature(s->avctx,
365 "JPEG-LS that is not <= 8 "
366 "bits/component or 16-bit gray");
367 return AVERROR_PATCHWELCOME;
369 if (len != 8 + 3 * nb_components) {
370 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
371 return AVERROR_INVALIDDATA;
374 s->nb_components = nb_components;
377 for (i = 0; i < nb_components; i++) {
379 s->component_id[i] = get_bits(&s->gb, 8) - 1;
380 h_count[i] = get_bits(&s->gb, 4);
381 v_count[i] = get_bits(&s->gb, 4);
382 /* compute hmax and vmax (only used in interleaved case) */
383 if (h_count[i] > s->h_max)
384 s->h_max = h_count[i];
385 if (v_count[i] > s->v_max)
386 s->v_max = v_count[i];
387 s->quant_index[i] = get_bits(&s->gb, 8);
388 if (s->quant_index[i] >= 4) {
389 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
390 return AVERROR_INVALIDDATA;
392 if (!h_count[i] || !v_count[i]) {
393 av_log(s->avctx, AV_LOG_ERROR,
394 "Invalid sampling factor in component %d %d:%d\n",
395 i, h_count[i], v_count[i]);
396 return AVERROR_INVALIDDATA;
399 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
400 i, h_count[i], v_count[i],
401 s->component_id[i], s->quant_index[i]);
403 if ( nb_components == 4
404 && s->component_id[0] == 'C' - 1
405 && s->component_id[1] == 'M' - 1
406 && s->component_id[2] == 'Y' - 1
407 && s->component_id[3] == 'K' - 1)
408 s->adobe_transform = 0;
410 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
411 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
412 return AVERROR_PATCHWELCOME;
416 if (nb_components == 2) {
417 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
418 width stored in their SOF3 markers is the width of each one. We only output
419 a single component, therefore we need to adjust the output image width. We
420 handle the deinterleaving (but not the debayering) in this file. */
423 /* They can also contain 1 component, which is double the width and half the height
424 of the final image (rows are interleaved). We don't handle the decoding in this
425 file, but leave that to the TIFF/DNG decoder. */
428 /* if different size, realloc/alloc picture */
429 if (width != s->width || height != s->height || bits != s->bits ||
430 memcmp(s->h_count, h_count, sizeof(h_count)) ||
431 memcmp(s->v_count, v_count, sizeof(v_count))) {
437 memcpy(s->h_count, h_count, sizeof(h_count));
438 memcpy(s->v_count, v_count, sizeof(v_count));
442 /* test interlaced mode */
443 if (s->first_picture &&
444 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
445 s->org_height != 0 &&
446 s->height < ((s->org_height * 3) / 4)) {
448 s->bottom_field = s->interlace_polarity;
449 s->picture_ptr->interlaced_frame = 1;
450 s->picture_ptr->top_field_first = !s->interlace_polarity;
454 ret = ff_set_dimensions(s->avctx, width, height);
458 s->first_picture = 0;
463 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
464 if (s->progressive) {
465 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
466 return AVERROR_INVALIDDATA;
469 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
471 else if (!s->lossless)
473 /* XXX: not complete test ! */
474 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
475 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
476 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
477 (s->h_count[3] << 4) | s->v_count[3];
478 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
479 /* NOTE we do not allocate pictures large enough for the possible
480 * padding of h/v_count being 4 */
481 if (!(pix_fmt_id & 0xD0D0D0D0))
482 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
483 if (!(pix_fmt_id & 0x0D0D0D0D))
484 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
486 for (i = 0; i < 8; i++) {
487 int j = 6 + (i&1) - (i&6);
488 int is = (pix_fmt_id >> (4*i)) & 0xF;
489 int js = (pix_fmt_id >> (4*j)) & 0xF;
491 if (is == 1 && js != 2 && (i < 2 || i > 5))
492 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
493 if (is == 1 && js != 2 && (i < 2 || i > 5))
494 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
496 if (is == 1 && js == 2) {
497 if (i & 1) s->upscale_h[j/2] = 1;
498 else s->upscale_v[j/2] = 1;
502 switch (pix_fmt_id) {
503 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
506 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
510 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
512 if ( s->adobe_transform == 0
513 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
514 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
516 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
517 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
518 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
521 av_assert0(s->nb_components == 3);
525 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
527 if (s->adobe_transform == 0 && s->bits <= 8) {
528 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
530 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
531 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
534 av_assert0(s->nb_components == 4);
538 if (s->adobe_transform == 0 && s->bits <= 8) {
539 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
540 s->upscale_v[1] = s->upscale_v[2] = 1;
541 s->upscale_h[1] = s->upscale_h[2] = 1;
542 } else if (s->adobe_transform == 2 && s->bits <= 8) {
543 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
544 s->upscale_v[1] = s->upscale_v[2] = 1;
545 s->upscale_h[1] = s->upscale_h[2] = 1;
546 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
548 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
549 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
550 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
552 av_assert0(s->nb_components == 4);
558 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
561 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
566 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
569 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
581 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
583 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
590 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
591 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
594 s->upscale_v[0] = s->upscale_v[1] = 1;
596 if (pix_fmt_id == 0x14111100)
597 s->upscale_v[1] = s->upscale_v[2] = 1;
598 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
601 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
605 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
606 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
609 s->upscale_h[0] = s->upscale_h[1] = 1;
611 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
612 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
613 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
619 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
620 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
621 s->upscale_h[1] = s->upscale_h[2] = 2;
625 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
628 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
634 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
635 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
636 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
637 if (pix_fmt_id == 0x42111100) {
640 s->upscale_h[1] = s->upscale_h[2] = 1;
641 } else if (pix_fmt_id == 0x24111100) {
644 s->upscale_v[1] = s->upscale_v[2] = 1;
645 } else if (pix_fmt_id == 0x23111100) {
648 s->upscale_v[1] = s->upscale_v[2] = 2;
652 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
655 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
659 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
660 memset(s->upscale_h, 0, sizeof(s->upscale_h));
661 memset(s->upscale_v, 0, sizeof(s->upscale_v));
662 return AVERROR_PATCHWELCOME;
664 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
665 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
666 return AVERROR_PATCHWELCOME;
668 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
669 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
670 return AVERROR_PATCHWELCOME;
673 memset(s->upscale_h, 0, sizeof(s->upscale_h));
674 memset(s->upscale_v, 0, sizeof(s->upscale_v));
675 if (s->nb_components == 3) {
676 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
677 } else if (s->nb_components != 1) {
678 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
679 return AVERROR_PATCHWELCOME;
680 } else if (s->palette_index && s->bits <= 8)
681 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
682 else if (s->bits <= 8)
683 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
685 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
688 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
690 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
694 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
695 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
697 enum AVPixelFormat pix_fmts[] = {
698 #if CONFIG_MJPEG_NVDEC_HWACCEL
701 #if CONFIG_MJPEG_VAAPI_HWACCEL
707 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
708 if (s->hwaccel_pix_fmt < 0)
709 return AVERROR(EINVAL);
711 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
712 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
715 if (s->avctx->skip_frame == AVDISCARD_ALL) {
716 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
717 s->picture_ptr->key_frame = 1;
722 av_frame_unref(s->picture_ptr);
723 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
725 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
726 s->picture_ptr->key_frame = 1;
729 for (i = 0; i < 4; i++)
730 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
732 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
733 s->width, s->height, s->linesize[0], s->linesize[1],
734 s->interlaced, s->avctx->height);
738 if ((s->rgb && !s->lossless && !s->ls) ||
739 (!s->rgb && s->ls && s->nb_components > 1) ||
740 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
742 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
743 return AVERROR_PATCHWELCOME;
746 /* totally blank picture as progressive JPEG will only add details to it */
747 if (s->progressive) {
748 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
749 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
750 for (i = 0; i < s->nb_components; i++) {
751 int size = bw * bh * s->h_count[i] * s->v_count[i];
752 av_freep(&s->blocks[i]);
753 av_freep(&s->last_nnz[i]);
754 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
755 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
756 if (!s->blocks[i] || !s->last_nnz[i])
757 return AVERROR(ENOMEM);
758 s->block_stride[i] = bw * s->h_count[i];
760 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
763 if (s->avctx->hwaccel) {
764 s->hwaccel_picture_private =
765 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
766 if (!s->hwaccel_picture_private)
767 return AVERROR(ENOMEM);
769 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
770 s->raw_image_buffer_size);
778 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
781 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
782 if (code < 0 || code > 16) {
783 av_log(s->avctx, AV_LOG_WARNING,
784 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
785 0, dc_index, &s->vlcs[0][dc_index]);
790 return get_xbits(&s->gb, code);
795 /* decode block and dequantize */
796 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
797 int dc_index, int ac_index, uint16_t *quant_matrix)
799 int code, i, j, level, val;
802 val = mjpeg_decode_dc(s, dc_index);
803 if (val == 0xfffff) {
804 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
805 return AVERROR_INVALIDDATA;
807 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
808 val = av_clip_int16(val);
809 s->last_dc[component] = val;
813 {OPEN_READER(re, &s->gb);
815 UPDATE_CACHE(re, &s->gb);
816 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
818 i += ((unsigned)code) >> 4;
821 if (code > MIN_CACHE_BITS - 16)
822 UPDATE_CACHE(re, &s->gb);
825 int cache = GET_CACHE(re, &s->gb);
826 int sign = (~cache) >> 31;
827 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
830 LAST_SKIP_BITS(re, &s->gb, code);
833 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
834 return AVERROR_INVALIDDATA;
836 j = s->scantable.permutated[i];
837 block[j] = level * quant_matrix[i];
840 CLOSE_READER(re, &s->gb);}
845 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
846 int component, int dc_index,
847 uint16_t *quant_matrix, int Al)
850 s->bdsp.clear_block(block);
851 val = mjpeg_decode_dc(s, dc_index);
852 if (val == 0xfffff) {
853 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
854 return AVERROR_INVALIDDATA;
856 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
857 s->last_dc[component] = val;
862 /* decode block and dequantize - progressive JPEG version */
863 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
864 uint8_t *last_nnz, int ac_index,
865 uint16_t *quant_matrix,
866 int ss, int se, int Al, int *EOBRUN)
868 int code, i, j, val, run;
877 OPEN_READER(re, &s->gb);
878 for (i = ss; ; i++) {
879 UPDATE_CACHE(re, &s->gb);
880 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
882 run = ((unsigned) code) >> 4;
886 if (code > MIN_CACHE_BITS - 16)
887 UPDATE_CACHE(re, &s->gb);
890 int cache = GET_CACHE(re, &s->gb);
891 int sign = (~cache) >> 31;
892 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
895 LAST_SKIP_BITS(re, &s->gb, code);
899 j = s->scantable.permutated[se];
900 block[j] = level * (quant_matrix[se] << Al);
903 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
904 return AVERROR_INVALIDDATA;
906 j = s->scantable.permutated[i];
907 block[j] = level * (quant_matrix[i] << Al);
909 if (run == 0xF) {// ZRL - skip 15 coefficients
912 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
913 return AVERROR_INVALIDDATA;
918 UPDATE_CACHE(re, &s->gb);
919 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
920 LAST_SKIP_BITS(re, &s->gb, run);
927 CLOSE_READER(re, &s->gb);
936 #define REFINE_BIT(j) { \
937 UPDATE_CACHE(re, &s->gb); \
938 sign = block[j] >> 15; \
939 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
940 ((quant_matrix[i] ^ sign) - sign) << Al; \
941 LAST_SKIP_BITS(re, &s->gb, 1); \
949 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
954 j = s->scantable.permutated[i]; \
957 else if (run-- == 0) \
961 /* decode block and dequantize - progressive JPEG refinement pass */
962 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
964 int ac_index, uint16_t *quant_matrix,
965 int ss, int se, int Al, int *EOBRUN)
967 int code, i = ss, j, sign, val, run;
968 int last = FFMIN(se, *last_nnz);
970 OPEN_READER(re, &s->gb);
975 UPDATE_CACHE(re, &s->gb);
976 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
979 run = ((unsigned) code) >> 4;
980 UPDATE_CACHE(re, &s->gb);
981 val = SHOW_UBITS(re, &s->gb, 1);
982 LAST_SKIP_BITS(re, &s->gb, 1);
984 j = s->scantable.permutated[i];
986 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
990 CLOSE_READER(re, &s->gb);
994 run = ((unsigned) code) >> 4;
1001 UPDATE_CACHE(re, &s->gb);
1002 run += SHOW_UBITS(re, &s->gb, val);
1003 LAST_SKIP_BITS(re, &s->gb, val);
1015 for (; i <= last; i++) {
1016 j = s->scantable.permutated[i];
1020 CLOSE_READER(re, &s->gb);
1027 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1032 if (s->restart_interval) {
1034 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1035 align_get_bits(&s->gb);
1036 for (i = 0; i < nb_components; i++) /* reset dc */
1037 s->last_dc[i] = (4 << s->bits);
1040 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1042 if (s->restart_count == 0) {
1043 if( show_bits(&s->gb, i) == (1 << i) - 1
1044 || show_bits(&s->gb, i) == 0xFF) {
1045 int pos = get_bits_count(&s->gb);
1046 align_get_bits(&s->gb);
1047 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1048 skip_bits(&s->gb, 8);
1049 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1050 for (i = 0; i < nb_components; i++) /* reset dc */
1051 s->last_dc[i] = (4 << s->bits);
1054 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1061 /* Handles 1 to 4 components */
1062 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1066 uint16_t (*buffer)[4];
1067 int left[4], top[4], topleft[4];
1068 const int linesize = s->linesize[0];
1069 const int mask = ((1 << s->bits) - 1) << point_transform;
1070 int resync_mb_y = 0;
1071 int resync_mb_x = 0;
1074 if (!s->bayer && s->nb_components < 3)
1075 return AVERROR_INVALIDDATA;
1076 if (s->bayer && s->nb_components > 2)
1077 return AVERROR_INVALIDDATA;
1078 if (s->nb_components <= 0 || s->nb_components > 4)
1079 return AVERROR_INVALIDDATA;
1080 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1081 return AVERROR_INVALIDDATA;
1084 s->restart_count = s->restart_interval;
1086 if (s->restart_interval == 0)
1087 s->restart_interval = INT_MAX;
1090 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1092 width = s->mb_width;
1094 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1095 if (!s->ljpeg_buffer)
1096 return AVERROR(ENOMEM);
1098 buffer = s->ljpeg_buffer;
1100 for (i = 0; i < 4; i++)
1101 buffer[0][i] = 1 << (s->bits - 1);
1103 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1104 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1106 if (s->interlaced && s->bottom_field)
1107 ptr += linesize >> 1;
1109 for (i = 0; i < 4; i++)
1110 top[i] = left[i] = topleft[i] = buffer[0][i];
1112 if ((mb_y * s->width) % s->restart_interval == 0) {
1113 for (i = 0; i < 6; i++)
1114 vpred[i] = 1 << (s->bits-1);
1117 for (mb_x = 0; mb_x < width; mb_x++) {
1118 int modified_predictor = predictor;
1120 if (get_bits_left(&s->gb) < 1) {
1121 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1122 return AVERROR_INVALIDDATA;
1125 if (s->restart_interval && !s->restart_count){
1126 s->restart_count = s->restart_interval;
1130 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1132 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1133 modified_predictor = 1;
1135 for (i=0;i<nb_components;i++) {
1138 topleft[i] = top[i];
1139 top[i] = buffer[mb_x][i];
1141 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1145 if (!s->bayer || mb_x) {
1147 } else { /* This path runs only for the first line in bayer images */
1149 pred = vpred[i] - dc;
1152 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1154 left[i] = buffer[mb_x][i] =
1155 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1158 if (s->restart_interval && !--s->restart_count) {
1159 align_get_bits(&s->gb);
1160 skip_bits(&s->gb, 16); /* skip RSTn */
1163 if (s->rct && s->nb_components == 4) {
1164 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1165 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1166 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1167 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1168 ptr[4*mb_x + 0] = buffer[mb_x][3];
1170 } else if (s->nb_components == 4) {
1171 for(i=0; i<nb_components; i++) {
1172 int c= s->comp_index[i];
1174 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1175 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1177 } else if(s->bits == 9) {
1178 return AVERROR_PATCHWELCOME;
1180 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1181 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1185 } else if (s->rct) {
1186 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1188 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1189 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1191 } else if (s->pegasus_rct) {
1192 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1193 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1194 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1195 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1197 } else if (s->bayer) {
1198 if (nb_components == 1) {
1199 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1200 for (mb_x = 0; mb_x < width; mb_x++)
1201 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1202 } else if (nb_components == 2) {
1203 for (mb_x = 0; mb_x < width; mb_x++) {
1204 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1205 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1209 for(i=0; i<nb_components; i++) {
1210 int c= s->comp_index[i];
1212 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1213 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1215 } else if(s->bits == 9) {
1216 return AVERROR_PATCHWELCOME;
1218 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1219 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1228 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1229 int point_transform, int nb_components)
1231 int i, mb_x, mb_y, mask;
1232 int bits= (s->bits+7)&~7;
1233 int resync_mb_y = 0;
1234 int resync_mb_x = 0;
1236 point_transform += bits - s->bits;
1237 mask = ((1 << s->bits) - 1) << point_transform;
1239 av_assert0(nb_components>=1 && nb_components<=4);
1241 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1242 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1243 if (get_bits_left(&s->gb) < 1) {
1244 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1245 return AVERROR_INVALIDDATA;
1247 if (s->restart_interval && !s->restart_count){
1248 s->restart_count = s->restart_interval;
1253 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1254 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1255 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1256 for (i = 0; i < nb_components; i++) {
1259 int n, h, v, x, y, c, j, linesize;
1260 n = s->nb_blocks[i];
1261 c = s->comp_index[i];
1266 linesize= s->linesize[c];
1268 if(bits>8) linesize /= 2;
1270 for(j=0; j<n; j++) {
1273 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1276 if ( h * mb_x + x >= s->width
1277 || v * mb_y + y >= s->height) {
1279 } else if (bits<=8) {
1280 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1282 if(x==0 && leftcol){
1283 pred= 1 << (bits - 1);
1288 if(x==0 && leftcol){
1289 pred= ptr[-linesize];
1291 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1295 if (s->interlaced && s->bottom_field)
1296 ptr += linesize >> 1;
1298 *ptr= pred + ((unsigned)dc << point_transform);
1300 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1302 if(x==0 && leftcol){
1303 pred= 1 << (bits - 1);
1308 if(x==0 && leftcol){
1309 pred= ptr16[-linesize];
1311 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1315 if (s->interlaced && s->bottom_field)
1316 ptr16 += linesize >> 1;
1318 *ptr16= pred + ((unsigned)dc << point_transform);
1327 for (i = 0; i < nb_components; i++) {
1330 int n, h, v, x, y, c, j, linesize, dc;
1331 n = s->nb_blocks[i];
1332 c = s->comp_index[i];
1337 linesize = s->linesize[c];
1339 if(bits>8) linesize /= 2;
1341 for (j = 0; j < n; j++) {
1344 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1347 if ( h * mb_x + x >= s->width
1348 || v * mb_y + y >= s->height) {
1350 } else if (bits<=8) {
1351 ptr = s->picture_ptr->data[c] +
1352 (linesize * (v * mb_y + y)) +
1353 (h * mb_x + x); //FIXME optimize this crap
1354 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1357 *ptr = pred + ((unsigned)dc << point_transform);
1359 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1360 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1363 *ptr16= pred + ((unsigned)dc << point_transform);
1373 if (s->restart_interval && !--s->restart_count) {
1374 align_get_bits(&s->gb);
1375 skip_bits(&s->gb, 16); /* skip RSTn */
1382 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1383 uint8_t *dst, const uint8_t *src,
1384 int linesize, int lowres)
1387 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1389 case 1: copy_block4(dst, src, linesize, linesize, 4);
1391 case 2: copy_block2(dst, src, linesize, linesize, 2);
1393 case 3: *dst = *src;
1398 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1400 int block_x, block_y;
1401 int size = 8 >> s->avctx->lowres;
1403 for (block_y=0; block_y<size; block_y++)
1404 for (block_x=0; block_x<size; block_x++)
1405 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1407 for (block_y=0; block_y<size; block_y++)
1408 for (block_x=0; block_x<size; block_x++)
1409 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1413 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1414 int Al, const uint8_t *mb_bitmask,
1415 int mb_bitmask_size,
1416 const AVFrame *reference)
1418 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1419 uint8_t *data[MAX_COMPONENTS];
1420 const uint8_t *reference_data[MAX_COMPONENTS];
1421 int linesize[MAX_COMPONENTS];
1422 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1423 int bytes_per_pixel = 1 + (s->bits > 8);
1426 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1427 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1428 return AVERROR_INVALIDDATA;
1430 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1433 s->restart_count = 0;
1435 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1437 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1438 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1440 for (i = 0; i < nb_components; i++) {
1441 int c = s->comp_index[i];
1442 data[c] = s->picture_ptr->data[c];
1443 reference_data[c] = reference ? reference->data[c] : NULL;
1444 linesize[c] = s->linesize[c];
1445 s->coefs_finished[c] |= 1;
1448 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1449 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1450 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1452 if (s->restart_interval && !s->restart_count)
1453 s->restart_count = s->restart_interval;
1455 if (get_bits_left(&s->gb) < 0) {
1456 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1457 -get_bits_left(&s->gb));
1458 return AVERROR_INVALIDDATA;
1460 for (i = 0; i < nb_components; i++) {
1462 int n, h, v, x, y, c, j;
1464 n = s->nb_blocks[i];
1465 c = s->comp_index[i];
1470 for (j = 0; j < n; j++) {
1471 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1472 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1474 if (s->interlaced && s->bottom_field)
1475 block_offset += linesize[c] >> 1;
1476 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1477 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1478 ptr = data[c] + block_offset;
1481 if (!s->progressive) {
1484 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1485 linesize[c], s->avctx->lowres);
1488 s->bdsp.clear_block(s->block);
1489 if (decode_block(s, s->block, i,
1490 s->dc_index[i], s->ac_index[i],
1491 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1492 av_log(s->avctx, AV_LOG_ERROR,
1493 "error y=%d x=%d\n", mb_y, mb_x);
1494 return AVERROR_INVALIDDATA;
1497 s->idsp.idct_put(ptr, linesize[c], s->block);
1499 shift_output(s, ptr, linesize[c]);
1503 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1505 int16_t *block = s->blocks[c][block_idx];
1507 block[0] += get_bits1(&s->gb) *
1508 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1509 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1510 s->quant_matrixes[s->quant_sindex[i]],
1512 av_log(s->avctx, AV_LOG_ERROR,
1513 "error y=%d x=%d\n", mb_y, mb_x);
1514 return AVERROR_INVALIDDATA;
1517 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1518 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1519 mb_x, mb_y, x, y, c, s->bottom_field,
1520 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1528 handle_rstn(s, nb_components);
1534 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1535 int se, int Ah, int Al)
1539 int c = s->comp_index[0];
1540 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1542 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1543 if (se < ss || se > 63) {
1544 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1545 return AVERROR_INVALIDDATA;
1548 // s->coefs_finished is a bitmask for coefficients coded
1549 // ss and se are parameters telling start and end coefficients
1550 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1552 s->restart_count = 0;
1554 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1555 int block_idx = mb_y * s->block_stride[c];
1556 int16_t (*block)[64] = &s->blocks[c][block_idx];
1557 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1558 if (get_bits_left(&s->gb) <= 0) {
1559 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1560 return AVERROR_INVALIDDATA;
1562 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1564 if (s->restart_interval && !s->restart_count)
1565 s->restart_count = s->restart_interval;
1568 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1569 quant_matrix, ss, se, Al, &EOBRUN);
1571 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1572 quant_matrix, ss, se, Al, &EOBRUN);
1574 av_log(s->avctx, AV_LOG_ERROR,
1575 "error y=%d x=%d\n", mb_y, mb_x);
1576 return AVERROR_INVALIDDATA;
1579 if (handle_rstn(s, 0))
1586 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1590 const int bytes_per_pixel = 1 + (s->bits > 8);
1591 const int block_size = s->lossless ? 1 : 8;
1593 for (c = 0; c < s->nb_components; c++) {
1594 uint8_t *data = s->picture_ptr->data[c];
1595 int linesize = s->linesize[c];
1596 int h = s->h_max / s->h_count[c];
1597 int v = s->v_max / s->v_count[c];
1598 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1599 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1601 if (~s->coefs_finished[c])
1602 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1604 if (s->interlaced && s->bottom_field)
1605 data += linesize >> 1;
1607 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1608 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1609 int block_idx = mb_y * s->block_stride[c];
1610 int16_t (*block)[64] = &s->blocks[c][block_idx];
1611 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1612 s->idsp.idct_put(ptr, linesize, *block);
1614 shift_output(s, ptr, linesize);
1615 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1621 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1622 int mb_bitmask_size, const AVFrame *reference)
1624 int len, nb_components, i, h, v, predictor, point_transform;
1626 const int block_size = s->lossless ? 1 : 8;
1627 int ilv, prev_shift;
1629 if (!s->got_picture) {
1630 av_log(s->avctx, AV_LOG_WARNING,
1631 "Can not process SOS before SOF, skipping\n");
1636 if (reference->width != s->picture_ptr->width ||
1637 reference->height != s->picture_ptr->height ||
1638 reference->format != s->picture_ptr->format) {
1639 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1640 return AVERROR_INVALIDDATA;
1644 /* XXX: verify len field validity */
1645 len = get_bits(&s->gb, 16);
1646 nb_components = get_bits(&s->gb, 8);
1647 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1648 avpriv_report_missing_feature(s->avctx,
1649 "decode_sos: nb_components (%d)",
1651 return AVERROR_PATCHWELCOME;
1653 if (len != 6 + 2 * nb_components) {
1654 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1655 return AVERROR_INVALIDDATA;
1657 for (i = 0; i < nb_components; i++) {
1658 id = get_bits(&s->gb, 8) - 1;
1659 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1660 /* find component index */
1661 for (index = 0; index < s->nb_components; index++)
1662 if (id == s->component_id[index])
1664 if (index == s->nb_components) {
1665 av_log(s->avctx, AV_LOG_ERROR,
1666 "decode_sos: index(%d) out of components\n", index);
1667 return AVERROR_INVALIDDATA;
1669 /* Metasoft MJPEG codec has Cb and Cr swapped */
1670 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1671 && nb_components == 3 && s->nb_components == 3 && i)
1674 s->quant_sindex[i] = s->quant_index[index];
1675 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1676 s->h_scount[i] = s->h_count[index];
1677 s->v_scount[i] = s->v_count[index];
1679 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1680 index = (index+2)%3;
1682 s->comp_index[i] = index;
1684 s->dc_index[i] = get_bits(&s->gb, 4);
1685 s->ac_index[i] = get_bits(&s->gb, 4);
1687 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1688 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1690 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))
1694 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1695 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1696 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1697 prev_shift = get_bits(&s->gb, 4); /* Ah */
1698 point_transform = get_bits(&s->gb, 4); /* Al */
1700 prev_shift = point_transform = 0;
1702 if (nb_components > 1) {
1703 /* interleaved stream */
1704 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1705 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1706 } else if (!s->ls) { /* skip this for JPEG-LS */
1707 h = s->h_max / s->h_scount[0];
1708 v = s->v_max / s->v_scount[0];
1709 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1710 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1711 s->nb_blocks[0] = 1;
1716 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1717 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1718 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1719 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1720 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1723 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1724 for (i = s->mjpb_skiptosod; i > 0; i--)
1725 skip_bits(&s->gb, 8);
1728 for (i = 0; i < nb_components; i++)
1729 s->last_dc[i] = (4 << s->bits);
1731 if (s->avctx->hwaccel) {
1732 int bytes_to_start = get_bits_count(&s->gb) / 8;
1733 av_assert0(bytes_to_start >= 0 &&
1734 s->raw_scan_buffer_size >= bytes_to_start);
1736 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1737 s->raw_scan_buffer + bytes_to_start,
1738 s->raw_scan_buffer_size - bytes_to_start);
1742 } else if (s->lossless) {
1743 av_assert0(s->picture_ptr == s->picture);
1744 if (CONFIG_JPEGLS_DECODER && s->ls) {
1746 // reset_ls_coding_parameters(s, 0);
1748 if ((ret = ff_jpegls_decode_picture(s, predictor,
1749 point_transform, ilv)) < 0)
1752 if (s->rgb || s->bayer) {
1753 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1756 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1758 nb_components)) < 0)
1763 if (s->progressive && predictor) {
1764 av_assert0(s->picture_ptr == s->picture);
1765 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1767 point_transform)) < 0)
1770 if ((ret = mjpeg_decode_scan(s, nb_components,
1771 prev_shift, point_transform,
1772 mb_bitmask, mb_bitmask_size, reference)) < 0)
1777 if (s->interlaced &&
1778 get_bits_left(&s->gb) > 32 &&
1779 show_bits(&s->gb, 8) == 0xFF) {
1780 GetBitContext bak = s->gb;
1781 align_get_bits(&bak);
1782 if (show_bits(&bak, 16) == 0xFFD1) {
1783 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1785 skip_bits(&s->gb, 16);
1786 s->bottom_field ^= 1;
1795 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1796 return AVERROR_INVALIDDATA;
1799 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1801 if (get_bits(&s->gb, 16) != 4)
1802 return AVERROR_INVALIDDATA;
1803 s->restart_interval = get_bits(&s->gb, 16);
1804 s->restart_count = 0;
1805 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1806 s->restart_interval);
1811 static int mjpeg_decode_app(MJpegDecodeContext *s)
1815 len = get_bits(&s->gb, 16);
1818 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1819 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1820 skip_bits(&s->gb, len);
1823 return AVERROR_INVALIDDATA;
1825 if (8 * len > get_bits_left(&s->gb))
1826 return AVERROR_INVALIDDATA;
1828 id = get_bits_long(&s->gb, 32);
1831 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1832 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1833 av_fourcc2str(av_bswap32(id)), id, len);
1835 /* Buggy AVID, it puts EOI only at every 10th frame. */
1836 /* Also, this fourcc is used by non-avid files too, it holds some
1837 information, but it's always present in AVID-created files. */
1838 if (id == AV_RB32("AVI1")) {
1844 4bytes field_size_less_padding
1847 i = get_bits(&s->gb, 8); len--;
1848 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1852 if (id == AV_RB32("JFIF")) {
1853 int t_w, t_h, v1, v2;
1856 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1857 v1 = get_bits(&s->gb, 8);
1858 v2 = get_bits(&s->gb, 8);
1859 skip_bits(&s->gb, 8);
1861 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1862 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1863 if ( s->avctx->sample_aspect_ratio.num <= 0
1864 || s->avctx->sample_aspect_ratio.den <= 0) {
1865 s->avctx->sample_aspect_ratio.num = 0;
1866 s->avctx->sample_aspect_ratio.den = 1;
1869 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1870 av_log(s->avctx, AV_LOG_INFO,
1871 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1873 s->avctx->sample_aspect_ratio.num,
1874 s->avctx->sample_aspect_ratio.den);
1878 t_w = get_bits(&s->gb, 8);
1879 t_h = get_bits(&s->gb, 8);
1881 /* skip thumbnail */
1882 if (len -10 - (t_w * t_h * 3) > 0)
1883 len -= t_w * t_h * 3;
1890 if ( id == AV_RB32("Adob")
1892 && show_bits(&s->gb, 8) == 'e'
1893 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1894 skip_bits(&s->gb, 8); /* 'e' */
1895 skip_bits(&s->gb, 16); /* version */
1896 skip_bits(&s->gb, 16); /* flags0 */
1897 skip_bits(&s->gb, 16); /* flags1 */
1898 s->adobe_transform = get_bits(&s->gb, 8);
1899 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1900 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1905 if (id == AV_RB32("LJIF")) {
1907 int pegasus_rct = s->pegasus_rct;
1908 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1909 av_log(s->avctx, AV_LOG_INFO,
1910 "Pegasus lossless jpeg header found\n");
1911 skip_bits(&s->gb, 16); /* version ? */
1912 skip_bits(&s->gb, 16); /* unknown always 0? */
1913 skip_bits(&s->gb, 16); /* unknown always 0? */
1914 skip_bits(&s->gb, 16); /* unknown always 0? */
1915 switch (i=get_bits(&s->gb, 8)) {
1925 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1930 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1931 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1936 s->pegasus_rct = pegasus_rct;
1940 if (id == AV_RL32("colr") && len > 0) {
1941 s->colr = get_bits(&s->gb, 8);
1942 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1943 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1947 if (id == AV_RL32("xfrm") && len > 0) {
1948 s->xfrm = get_bits(&s->gb, 8);
1949 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1950 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1955 /* JPS extension by VRex */
1956 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1957 int flags, layout, type;
1958 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1959 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1961 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1962 skip_bits(&s->gb, 16); len -= 2; /* block length */
1963 skip_bits(&s->gb, 8); /* reserved */
1964 flags = get_bits(&s->gb, 8);
1965 layout = get_bits(&s->gb, 8);
1966 type = get_bits(&s->gb, 8);
1969 av_freep(&s->stereo3d);
1970 s->stereo3d = av_stereo3d_alloc();
1975 s->stereo3d->type = AV_STEREO3D_2D;
1976 } else if (type == 1) {
1979 s->stereo3d->type = AV_STEREO3D_LINES;
1982 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1985 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1988 if (!(flags & 0x04)) {
1989 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1996 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1997 GetByteContext gbytes;
1998 int ret, le, ifd_offset, bytes_read;
1999 const uint8_t *aligned;
2001 skip_bits(&s->gb, 16); // skip padding
2004 // init byte wise reading
2005 aligned = align_get_bits(&s->gb);
2006 bytestream2_init(&gbytes, aligned, len);
2009 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2011 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2013 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2015 // read 0th IFD and store the metadata
2016 // (return values > 0 indicate the presence of subimage metadata)
2017 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2019 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2023 bytes_read = bytestream2_tell(&gbytes);
2024 skip_bits(&s->gb, bytes_read << 3);
2031 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2032 id = get_bits_long(&s->gb, 32);
2035 if (id == AV_RB32("mjpg")) {
2038 4bytes pad field size
2046 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2047 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2051 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2054 unsigned nummarkers;
2056 id = get_bits_long(&s->gb, 32);
2057 id2 = get_bits_long(&s->gb, 24);
2059 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2060 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2064 skip_bits(&s->gb, 8);
2065 seqno = get_bits(&s->gb, 8);
2068 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2072 nummarkers = get_bits(&s->gb, 8);
2074 if (nummarkers == 0) {
2075 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2077 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2078 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2080 } else if (seqno > nummarkers) {
2081 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2085 /* Allocate if this is the first APP2 we've seen. */
2086 if (s->iccnum == 0) {
2087 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2088 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2089 if (!s->iccdata || !s->iccdatalens) {
2090 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2091 return AVERROR(ENOMEM);
2093 s->iccnum = nummarkers;
2096 if (s->iccdata[seqno - 1]) {
2097 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2101 s->iccdatalens[seqno - 1] = len;
2102 s->iccdata[seqno - 1] = av_malloc(len);
2103 if (!s->iccdata[seqno - 1]) {
2104 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2105 return AVERROR(ENOMEM);
2108 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2109 skip_bits(&s->gb, len << 3);
2113 if (s->iccread > s->iccnum)
2114 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2118 /* slow but needed for extreme adobe jpegs */
2120 av_log(s->avctx, AV_LOG_ERROR,
2121 "mjpeg: error, decode_app parser read over the end\n");
2123 skip_bits(&s->gb, 8);
2128 static int mjpeg_decode_com(MJpegDecodeContext *s)
2130 int len = get_bits(&s->gb, 16);
2131 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2133 char *cbuf = av_malloc(len - 1);
2135 return AVERROR(ENOMEM);
2137 for (i = 0; i < len - 2; i++)
2138 cbuf[i] = get_bits(&s->gb, 8);
2139 if (i > 0 && cbuf[i - 1] == '\n')
2144 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2145 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2147 /* buggy avid, it puts EOI only at every 10th frame */
2148 if (!strncmp(cbuf, "AVID", 4)) {
2149 parse_avid(s, cbuf, len);
2150 } else if (!strcmp(cbuf, "CS=ITU601"))
2152 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2153 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2155 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2156 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2166 /* return the 8 bit start code value and update the search
2167 state. Return -1 if no start code found */
2168 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2170 const uint8_t *buf_ptr;
2175 buf_ptr = *pbuf_ptr;
2176 while (buf_end - buf_ptr > 1) {
2179 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2188 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2189 *pbuf_ptr = buf_ptr;
2193 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2194 const uint8_t **buf_ptr, const uint8_t *buf_end,
2195 const uint8_t **unescaped_buf_ptr,
2196 int *unescaped_buf_size)
2199 start_code = find_marker(buf_ptr, buf_end);
2201 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2203 return AVERROR(ENOMEM);
2205 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2206 if (start_code == SOS && !s->ls) {
2207 const uint8_t *src = *buf_ptr;
2208 const uint8_t *ptr = src;
2209 uint8_t *dst = s->buffer;
2211 #define copy_data_segment(skip) do { \
2212 ptrdiff_t length = (ptr - src) - (skip); \
2214 memcpy(dst, src, length); \
2220 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2222 copy_data_segment(0);
2224 while (ptr < buf_end) {
2225 uint8_t x = *(ptr++);
2229 while (ptr < buf_end && x == 0xff) {
2234 /* 0xFF, 0xFF, ... */
2236 copy_data_segment(skip);
2238 /* decrement src as it is equal to ptr after the
2239 * copy_data_segment macro and we might want to
2240 * copy the current value of x later on */
2244 if (x < RST0 || x > RST7) {
2245 copy_data_segment(1);
2252 copy_data_segment(0);
2254 #undef copy_data_segment
2256 *unescaped_buf_ptr = s->buffer;
2257 *unescaped_buf_size = dst - s->buffer;
2258 memset(s->buffer + *unescaped_buf_size, 0,
2259 AV_INPUT_BUFFER_PADDING_SIZE);
2261 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2262 (buf_end - *buf_ptr) - (dst - s->buffer));
2263 } else if (start_code == SOS && s->ls) {
2264 const uint8_t *src = *buf_ptr;
2265 uint8_t *dst = s->buffer;
2271 while (src + t < buf_end) {
2272 uint8_t x = src[t++];
2274 while ((src + t < buf_end) && x == 0xff)
2283 init_put_bits(&pb, dst, t);
2285 /* unescape bitstream */
2287 uint8_t x = src[b++];
2288 put_bits(&pb, 8, x);
2289 if (x == 0xFF && b < t) {
2292 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2295 put_bits(&pb, 7, x);
2299 flush_put_bits(&pb);
2301 *unescaped_buf_ptr = dst;
2302 *unescaped_buf_size = (bit_count + 7) >> 3;
2303 memset(s->buffer + *unescaped_buf_size, 0,
2304 AV_INPUT_BUFFER_PADDING_SIZE);
2306 *unescaped_buf_ptr = *buf_ptr;
2307 *unescaped_buf_size = buf_end - *buf_ptr;
2313 static void reset_icc_profile(MJpegDecodeContext *s)
2318 for (i = 0; i < s->iccnum; i++)
2319 av_freep(&s->iccdata[i]);
2320 av_freep(&s->iccdata);
2321 av_freep(&s->iccdatalens);
2327 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2330 AVFrame *frame = data;
2331 const uint8_t *buf = avpkt->data;
2332 int buf_size = avpkt->size;
2333 MJpegDecodeContext *s = avctx->priv_data;
2334 const uint8_t *buf_end, *buf_ptr;
2335 const uint8_t *unescaped_buf_ptr;
2337 int unescaped_buf_size;
2343 s->buf_size = buf_size;
2345 av_dict_free(&s->exif_metadata);
2346 av_freep(&s->stereo3d);
2347 s->adobe_transform = -1;
2350 reset_icc_profile(s);
2353 buf_end = buf + buf_size;
2354 while (buf_ptr < buf_end) {
2355 /* find start next marker */
2356 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2358 &unescaped_buf_size);
2360 if (start_code < 0) {
2362 } else if (unescaped_buf_size > INT_MAX / 8) {
2363 av_log(avctx, AV_LOG_ERROR,
2364 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2365 start_code, unescaped_buf_size, buf_size);
2366 return AVERROR_INVALIDDATA;
2368 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2369 start_code, buf_end - buf_ptr);
2371 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2374 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2378 s->start_code = start_code;
2379 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2380 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2382 /* process markers */
2383 if (start_code >= RST0 && start_code <= RST7) {
2384 av_log(avctx, AV_LOG_DEBUG,
2385 "restart marker: %d\n", start_code & 0x0f);
2387 } else if (start_code >= APP0 && start_code <= APP15) {
2388 if ((ret = mjpeg_decode_app(s)) < 0)
2389 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2392 } else if (start_code == COM) {
2393 ret = mjpeg_decode_com(s);
2396 } else if (start_code == DQT) {
2397 ret = ff_mjpeg_decode_dqt(s);
2404 if (!CONFIG_JPEGLS_DECODER &&
2405 (start_code == SOF48 || start_code == LSE)) {
2406 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2407 return AVERROR(ENOSYS);
2410 if (avctx->skip_frame == AVDISCARD_ALL) {
2411 switch(start_code) {
2426 switch (start_code) {
2428 s->restart_interval = 0;
2429 s->restart_count = 0;
2430 s->raw_image_buffer = buf_ptr;
2431 s->raw_image_buffer_size = buf_end - buf_ptr;
2432 /* nothing to do on SOI */
2435 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2436 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2442 if (start_code == SOF0)
2443 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2445 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2449 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2453 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2457 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2461 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2462 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2466 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2470 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2471 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2475 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2479 if (!CONFIG_JPEGLS_DECODER ||
2480 (ret = ff_jpegls_decode_lse(s)) < 0)
2485 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2486 s->progressive && s->cur_scan && s->got_picture)
2487 mjpeg_idct_scan_progressive_ac(s);
2489 if (!s->got_picture) {
2490 av_log(avctx, AV_LOG_WARNING,
2491 "Found EOI before any SOF, ignoring\n");
2494 if (s->interlaced) {
2495 s->bottom_field ^= 1;
2496 /* if not bottom field, do not output image yet */
2497 if (s->bottom_field == !s->interlace_polarity)
2500 if (avctx->skip_frame == AVDISCARD_ALL) {
2502 goto the_end_no_picture;
2504 if (s->avctx->hwaccel) {
2505 ret = s->avctx->hwaccel->end_frame(s->avctx);
2509 av_freep(&s->hwaccel_picture_private);
2511 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2517 int qp = FFMAX3(s->qscale[0],
2520 int qpw = (s->width + 15) / 16;
2521 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2523 memset(qp_table_buf->data, qp, qpw);
2524 av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2527 if(avctx->debug & FF_DEBUG_QP)
2528 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2533 s->raw_scan_buffer = buf_ptr;
2534 s->raw_scan_buffer_size = buf_end - buf_ptr;
2537 if (avctx->skip_frame == AVDISCARD_ALL) {
2538 skip_bits(&s->gb, get_bits_left(&s->gb));
2542 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2543 (avctx->err_recognition & AV_EF_EXPLODE))
2547 if ((ret = mjpeg_decode_dri(s)) < 0)
2560 av_log(avctx, AV_LOG_ERROR,
2561 "mjpeg: unsupported coding type (%x)\n", start_code);
2566 /* eof process start code */
2567 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2568 av_log(avctx, AV_LOG_DEBUG,
2569 "marker parser used %d bytes (%d bits)\n",
2570 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2572 if (s->got_picture && s->cur_scan) {
2573 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2576 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2577 return AVERROR_INVALIDDATA;
2583 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2585 if (AV_RB32(s->upscale_h)) {
2587 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2588 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2589 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2590 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2591 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2592 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2593 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2594 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2595 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2596 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2597 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2598 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2600 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2604 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2605 for (p = 0; p<s->nb_components; p++) {
2606 uint8_t *line = s->picture_ptr->data[p];
2609 if (!s->upscale_h[p])
2612 w = AV_CEIL_RSHIFT(w, hshift);
2613 h = AV_CEIL_RSHIFT(h, vshift);
2615 if (s->upscale_v[p] == 1)
2618 for (i = 0; i < h; i++) {
2619 if (s->upscale_h[p] == 1) {
2620 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2621 else line[w - 1] = line[(w - 1) / 2];
2622 for (index = w - 2; index > 0; index--) {
2624 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2626 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2628 } else if (s->upscale_h[p] == 2) {
2630 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2632 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2634 line[w - 1] = line[(w - 1) / 3];
2636 line[w - 2] = line[w - 1];
2638 for (index = w - 3; index > 0; index--) {
2639 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2642 line += s->linesize[p];
2646 if (AV_RB32(s->upscale_v)) {
2648 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2650 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2652 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2653 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2654 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2655 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2656 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2657 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2658 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2659 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2660 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2662 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2666 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2667 for (p = 0; p < s->nb_components; p++) {
2671 if (!s->upscale_v[p])
2674 w = AV_CEIL_RSHIFT(w, hshift);
2675 h = AV_CEIL_RSHIFT(h, vshift);
2677 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2678 for (i = h - 1; i; i--) {
2679 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2680 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2681 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2682 memcpy(dst, src1, w);
2684 for (index = 0; index < w; index++)
2685 dst[index] = (src1[index] + src2[index]) >> 1;
2687 dst -= s->linesize[p];
2691 if (s->flipped && !s->rgb) {
2693 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2697 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2698 for (index=0; index<s->nb_components; index++) {
2699 uint8_t *dst = s->picture_ptr->data[index];
2700 int w = s->picture_ptr->width;
2701 int h = s->picture_ptr->height;
2702 if(index && index<3){
2703 w = AV_CEIL_RSHIFT(w, hshift);
2704 h = AV_CEIL_RSHIFT(h, vshift);
2707 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2708 for (i=0; i<h/2; i++) {
2710 FFSWAP(int, dst[j], dst2[j]);
2711 dst += s->picture_ptr->linesize[index];
2712 dst2 -= s->picture_ptr->linesize[index];
2717 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2718 int w = s->picture_ptr->width;
2719 int h = s->picture_ptr->height;
2720 av_assert0(s->nb_components == 4);
2721 for (i=0; i<h; i++) {
2724 for (index=0; index<4; index++) {
2725 dst[index] = s->picture_ptr->data[index]
2726 + s->picture_ptr->linesize[index]*i;
2728 for (j=0; j<w; j++) {
2730 int r = dst[0][j] * k;
2731 int g = dst[1][j] * k;
2732 int b = dst[2][j] * k;
2733 dst[0][j] = g*257 >> 16;
2734 dst[1][j] = b*257 >> 16;
2735 dst[2][j] = r*257 >> 16;
2740 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2741 int w = s->picture_ptr->width;
2742 int h = s->picture_ptr->height;
2743 av_assert0(s->nb_components == 4);
2744 for (i=0; i<h; i++) {
2747 for (index=0; index<4; index++) {
2748 dst[index] = s->picture_ptr->data[index]
2749 + s->picture_ptr->linesize[index]*i;
2751 for (j=0; j<w; j++) {
2753 int r = (255 - dst[0][j]) * k;
2754 int g = (128 - dst[1][j]) * k;
2755 int b = (128 - dst[2][j]) * k;
2756 dst[0][j] = r*257 >> 16;
2757 dst[1][j] = (g*257 >> 16) + 128;
2758 dst[2][j] = (b*257 >> 16) + 128;
2765 AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2767 stereo->type = s->stereo3d->type;
2768 stereo->flags = s->stereo3d->flags;
2770 av_freep(&s->stereo3d);
2773 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2774 AVFrameSideData *sd;
2779 /* Sum size of all parts. */
2780 for (i = 0; i < s->iccnum; i++)
2781 total_size += s->iccdatalens[i];
2783 sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2785 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2786 return AVERROR(ENOMEM);
2789 /* Reassemble the parts, which are now in-order. */
2790 for (i = 0; i < s->iccnum; i++) {
2791 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2792 offset += s->iccdatalens[i];
2796 av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2797 av_dict_free(&s->exif_metadata);
2800 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2802 // return buf_end - buf_ptr;
2803 return buf_ptr - buf;
2806 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2808 MJpegDecodeContext *s = avctx->priv_data;
2811 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2812 av_log(avctx, AV_LOG_INFO, "Single field\n");
2816 av_frame_free(&s->picture);
2817 s->picture_ptr = NULL;
2818 } else if (s->picture_ptr)
2819 av_frame_unref(s->picture_ptr);
2821 av_freep(&s->buffer);
2822 av_freep(&s->stereo3d);
2823 av_freep(&s->ljpeg_buffer);
2824 s->ljpeg_buffer_size = 0;
2826 for (i = 0; i < 3; i++) {
2827 for (j = 0; j < 4; j++)
2828 ff_free_vlc(&s->vlcs[i][j]);
2830 for (i = 0; i < MAX_COMPONENTS; i++) {
2831 av_freep(&s->blocks[i]);
2832 av_freep(&s->last_nnz[i]);
2834 av_dict_free(&s->exif_metadata);
2836 reset_icc_profile(s);
2838 av_freep(&s->hwaccel_picture_private);
2843 static void decode_flush(AVCodecContext *avctx)
2845 MJpegDecodeContext *s = avctx->priv_data;
2849 #if CONFIG_MJPEG_DECODER
2850 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2851 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2852 static const AVOption options[] = {
2853 { "extern_huff", "Use external huffman table.",
2854 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2858 static const AVClass mjpegdec_class = {
2859 .class_name = "MJPEG decoder",
2860 .item_name = av_default_item_name,
2862 .version = LIBAVUTIL_VERSION_INT,
2865 AVCodec ff_mjpeg_decoder = {
2867 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2868 .type = AVMEDIA_TYPE_VIDEO,
2869 .id = AV_CODEC_ID_MJPEG,
2870 .priv_data_size = sizeof(MJpegDecodeContext),
2871 .init = ff_mjpeg_decode_init,
2872 .close = ff_mjpeg_decode_end,
2873 .decode = ff_mjpeg_decode_frame,
2874 .flush = decode_flush,
2875 .capabilities = AV_CODEC_CAP_DR1,
2877 .priv_class = &mjpegdec_class,
2878 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2879 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2880 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2881 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2882 #if CONFIG_MJPEG_NVDEC_HWACCEL
2883 HWACCEL_NVDEC(mjpeg),
2885 #if CONFIG_MJPEG_VAAPI_HWACCEL
2886 HWACCEL_VAAPI(mjpeg),
2892 #if CONFIG_THP_DECODER
2893 AVCodec ff_thp_decoder = {
2895 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2896 .type = AVMEDIA_TYPE_VIDEO,
2897 .id = AV_CODEC_ID_THP,
2898 .priv_data_size = sizeof(MJpegDecodeContext),
2899 .init = ff_mjpeg_decode_init,
2900 .close = ff_mjpeg_decode_end,
2901 .decode = ff_mjpeg_decode_frame,
2902 .flush = decode_flush,
2903 .capabilities = AV_CODEC_CAP_DR1,
2905 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,