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"
43 #include "jpegtables.h"
46 #include "jpeglsdec.h"
51 #include "bytestream.h"
54 static void build_huffman_codes(uint8_t *huff_size, const uint8_t *bits_table)
56 for (int i = 1, k = 0; i <= 16; i++) {
57 int nb = bits_table[i];
58 for (int j = 0; j < nb;j++) {
65 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
66 const uint8_t *val_table, int nb_codes,
67 int is_ac, void *logctx)
69 uint8_t huff_size[256];
70 uint16_t huff_sym[256];
73 av_assert0(nb_codes <= 256);
75 build_huffman_codes(huff_size, bits_table);
77 for (i = 0; i < nb_codes; i++) {
78 huff_sym[i] = val_table[i] + 16 * is_ac;
80 if (is_ac && !val_table[i])
81 huff_sym[i] = 16 * 256;
84 return ff_init_vlc_from_lengths(vlc, 9, nb_codes, huff_size, 1,
85 huff_sym, 2, 2, 0, 0, logctx);
88 static int init_default_huffman_tables(MJpegDecodeContext *s)
94 const uint8_t *values;
97 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
98 avpriv_mjpeg_val_dc, 12 },
99 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
100 avpriv_mjpeg_val_dc, 12 },
101 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
102 avpriv_mjpeg_val_ac_luminance, 162 },
103 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
104 avpriv_mjpeg_val_ac_chrominance, 162 },
105 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
106 avpriv_mjpeg_val_ac_luminance, 162 },
107 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
108 avpriv_mjpeg_val_ac_chrominance, 162 },
112 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
113 ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
114 ht[i].bits, ht[i].values, ht[i].length,
115 ht[i].class == 1, s->avctx);
119 if (ht[i].class < 2) {
120 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
122 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
123 ht[i].values, ht[i].length);
130 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
133 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
134 s->interlace_polarity = 1;
135 if (len > 14 && buf[12] == 2) /* 2 - PAL */
136 s->interlace_polarity = 0;
137 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
138 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
141 static void init_idct(AVCodecContext *avctx)
143 MJpegDecodeContext *s = avctx->priv_data;
145 ff_idctdsp_init(&s->idsp, avctx);
146 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
150 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
152 MJpegDecodeContext *s = avctx->priv_data;
155 if (!s->picture_ptr) {
156 s->picture = av_frame_alloc();
158 return AVERROR(ENOMEM);
159 s->picture_ptr = s->picture;
162 s->pkt = av_packet_alloc();
164 return AVERROR(ENOMEM);
167 ff_blockdsp_init(&s->bdsp, avctx);
168 ff_hpeldsp_init(&s->hdsp, avctx->flags);
173 s->first_picture = 1;
175 s->org_height = avctx->coded_height;
176 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
177 avctx->colorspace = AVCOL_SPC_BT470BG;
178 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
180 if ((ret = init_default_huffman_tables(s)) < 0)
183 if (s->extern_huff) {
184 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
185 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
187 if (ff_mjpeg_decode_dht(s)) {
188 av_log(avctx, AV_LOG_ERROR,
189 "error using external huffman table, switching back to internal\n");
190 init_default_huffman_tables(s);
193 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
194 s->interlace_polarity = 1; /* bottom field first */
195 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
196 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
197 if (avctx->codec_tag == AV_RL32("MJPG"))
198 s->interlace_polarity = 1;
201 if ( avctx->extradata_size > 8
202 && AV_RL32(avctx->extradata) == 0x2C
203 && AV_RL32(avctx->extradata+4) == 0x18) {
204 parse_avid(s, avctx->extradata, avctx->extradata_size);
207 if (avctx->codec->id == AV_CODEC_ID_AMV)
214 /* quantize tables */
215 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
219 len = get_bits(&s->gb, 16) - 2;
221 if (8*len > get_bits_left(&s->gb)) {
222 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
223 return AVERROR_INVALIDDATA;
227 int pr = get_bits(&s->gb, 4);
229 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
230 return AVERROR_INVALIDDATA;
232 index = get_bits(&s->gb, 4);
235 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
236 /* read quant table */
237 for (i = 0; i < 64; i++) {
238 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
239 if (s->quant_matrixes[index][i] == 0) {
240 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
241 return AVERROR_INVALIDDATA;
245 // XXX FIXME fine-tune, and perhaps add dc too
246 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
247 s->quant_matrixes[index][8]) >> 1;
248 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
249 index, s->qscale[index]);
250 len -= 1 + 64 * (1+pr);
255 /* decode huffman tables and build VLC decoders */
256 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
258 int len, index, i, class, n, v;
259 uint8_t bits_table[17];
260 uint8_t val_table[256];
263 len = get_bits(&s->gb, 16) - 2;
265 if (8*len > get_bits_left(&s->gb)) {
266 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
267 return AVERROR_INVALIDDATA;
272 return AVERROR_INVALIDDATA;
273 class = get_bits(&s->gb, 4);
275 return AVERROR_INVALIDDATA;
276 index = get_bits(&s->gb, 4);
278 return AVERROR_INVALIDDATA;
280 for (i = 1; i <= 16; i++) {
281 bits_table[i] = get_bits(&s->gb, 8);
285 if (len < n || n > 256)
286 return AVERROR_INVALIDDATA;
288 for (i = 0; i < n; i++) {
289 v = get_bits(&s->gb, 8);
294 /* build VLC and flush previous vlc if present */
295 ff_free_vlc(&s->vlcs[class][index]);
296 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
298 if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
299 n, class > 0, s->avctx)) < 0)
303 ff_free_vlc(&s->vlcs[2][index]);
304 if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
305 n, 0, s->avctx)) < 0)
309 for (i = 0; i < 16; i++)
310 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
311 for (i = 0; i < 256; i++)
312 s->raw_huffman_values[class][index][i] = val_table[i];
317 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
319 int len, nb_components, i, width, height, bits, ret, size_change;
321 int h_count[MAX_COMPONENTS] = { 0 };
322 int v_count[MAX_COMPONENTS] = { 0 };
325 memset(s->upscale_h, 0, sizeof(s->upscale_h));
326 memset(s->upscale_v, 0, sizeof(s->upscale_v));
328 len = get_bits(&s->gb, 16);
329 bits = get_bits(&s->gb, 8);
331 if (bits > 16 || bits < 1) {
332 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
333 return AVERROR_INVALIDDATA;
336 if (s->avctx->bits_per_raw_sample != bits) {
337 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);
338 s->avctx->bits_per_raw_sample = bits;
343 if (bits == 9 && !s->pegasus_rct)
344 s->rct = 1; // FIXME ugly
346 if(s->lossless && s->avctx->lowres){
347 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
351 height = get_bits(&s->gb, 16);
352 width = get_bits(&s->gb, 16);
354 // HACK for odd_height.mov
355 if (s->interlaced && s->width == width && s->height == height + 1)
358 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
359 if (av_image_check_size(width, height, 0, s->avctx) < 0)
360 return AVERROR_INVALIDDATA;
361 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
362 return AVERROR_INVALIDDATA;
364 nb_components = get_bits(&s->gb, 8);
365 if (nb_components <= 0 ||
366 nb_components > MAX_COMPONENTS)
368 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
369 if (nb_components != s->nb_components) {
370 av_log(s->avctx, AV_LOG_ERROR,
371 "nb_components changing in interlaced picture\n");
372 return AVERROR_INVALIDDATA;
375 if (s->ls && !(bits <= 8 || nb_components == 1)) {
376 avpriv_report_missing_feature(s->avctx,
377 "JPEG-LS that is not <= 8 "
378 "bits/component or 16-bit gray");
379 return AVERROR_PATCHWELCOME;
381 if (len != 8 + 3 * nb_components) {
382 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
383 return AVERROR_INVALIDDATA;
386 s->nb_components = nb_components;
389 for (i = 0; i < nb_components; i++) {
391 s->component_id[i] = get_bits(&s->gb, 8) - 1;
392 h_count[i] = get_bits(&s->gb, 4);
393 v_count[i] = get_bits(&s->gb, 4);
394 /* compute hmax and vmax (only used in interleaved case) */
395 if (h_count[i] > s->h_max)
396 s->h_max = h_count[i];
397 if (v_count[i] > s->v_max)
398 s->v_max = v_count[i];
399 s->quant_index[i] = get_bits(&s->gb, 8);
400 if (s->quant_index[i] >= 4) {
401 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
402 return AVERROR_INVALIDDATA;
404 if (!h_count[i] || !v_count[i]) {
405 av_log(s->avctx, AV_LOG_ERROR,
406 "Invalid sampling factor in component %d %d:%d\n",
407 i, h_count[i], v_count[i]);
408 return AVERROR_INVALIDDATA;
411 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
412 i, h_count[i], v_count[i],
413 s->component_id[i], s->quant_index[i]);
415 if ( nb_components == 4
416 && s->component_id[0] == 'C' - 1
417 && s->component_id[1] == 'M' - 1
418 && s->component_id[2] == 'Y' - 1
419 && s->component_id[3] == 'K' - 1)
420 s->adobe_transform = 0;
422 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
423 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
424 return AVERROR_PATCHWELCOME;
428 if (nb_components == 2) {
429 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
430 width stored in their SOF3 markers is the width of each one. We only output
431 a single component, therefore we need to adjust the output image width. We
432 handle the deinterleaving (but not the debayering) in this file. */
435 /* They can also contain 1 component, which is double the width and half the height
436 of the final image (rows are interleaved). We don't handle the decoding in this
437 file, but leave that to the TIFF/DNG decoder. */
440 /* if different size, realloc/alloc picture */
441 if (width != s->width || height != s->height || bits != s->bits ||
442 memcmp(s->h_count, h_count, sizeof(h_count)) ||
443 memcmp(s->v_count, v_count, sizeof(v_count))) {
449 memcpy(s->h_count, h_count, sizeof(h_count));
450 memcpy(s->v_count, v_count, sizeof(v_count));
454 /* test interlaced mode */
455 if (s->first_picture &&
456 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
457 s->org_height != 0 &&
458 s->height < ((s->org_height * 3) / 4)) {
460 s->bottom_field = s->interlace_polarity;
461 s->picture_ptr->interlaced_frame = 1;
462 s->picture_ptr->top_field_first = !s->interlace_polarity;
466 ret = ff_set_dimensions(s->avctx, width, height);
470 s->first_picture = 0;
475 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
476 if (s->progressive) {
477 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
478 return AVERROR_INVALIDDATA;
481 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
483 else if (!s->lossless)
485 /* XXX: not complete test ! */
486 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
487 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
488 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
489 (s->h_count[3] << 4) | s->v_count[3];
490 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
491 /* NOTE we do not allocate pictures large enough for the possible
492 * padding of h/v_count being 4 */
493 if (!(pix_fmt_id & 0xD0D0D0D0))
494 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
495 if (!(pix_fmt_id & 0x0D0D0D0D))
496 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
498 for (i = 0; i < 8; i++) {
499 int j = 6 + (i&1) - (i&6);
500 int is = (pix_fmt_id >> (4*i)) & 0xF;
501 int js = (pix_fmt_id >> (4*j)) & 0xF;
503 if (is == 1 && js != 2 && (i < 2 || i > 5))
504 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
505 if (is == 1 && js != 2 && (i < 2 || i > 5))
506 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
508 if (is == 1 && js == 2) {
509 if (i & 1) s->upscale_h[j/2] = 1;
510 else s->upscale_v[j/2] = 1;
515 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
519 switch (pix_fmt_id) {
520 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
523 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
527 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
529 if ( s->adobe_transform == 0
530 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
531 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
533 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
534 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
535 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
538 av_assert0(s->nb_components == 3);
542 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
544 if (s->adobe_transform == 0 && s->bits <= 8) {
545 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
547 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
548 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
551 av_assert0(s->nb_components == 4);
555 if (s->adobe_transform == 0 && s->bits <= 8) {
556 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
557 s->upscale_v[1] = s->upscale_v[2] = 1;
558 s->upscale_h[1] = s->upscale_h[2] = 1;
559 } else if (s->adobe_transform == 2 && s->bits <= 8) {
560 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
561 s->upscale_v[1] = s->upscale_v[2] = 1;
562 s->upscale_h[1] = s->upscale_h[2] = 1;
563 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
565 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
566 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
567 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
569 av_assert0(s->nb_components == 4);
578 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
581 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
593 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
595 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
602 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
603 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
606 s->upscale_v[0] = s->upscale_v[1] = 1;
608 if (pix_fmt_id == 0x14111100)
609 s->upscale_v[1] = s->upscale_v[2] = 1;
610 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
613 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
617 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
618 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
621 s->upscale_h[0] = s->upscale_h[1] = 1;
623 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
624 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
625 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
631 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
632 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
633 s->upscale_h[1] = s->upscale_h[2] = 2;
637 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
640 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
646 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
647 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
648 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
649 if (pix_fmt_id == 0x42111100) {
652 s->upscale_h[1] = s->upscale_h[2] = 1;
653 } else if (pix_fmt_id == 0x24111100) {
656 s->upscale_v[1] = s->upscale_v[2] = 1;
657 } else if (pix_fmt_id == 0x23111100) {
660 s->upscale_v[1] = s->upscale_v[2] = 2;
664 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
667 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
671 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
672 memset(s->upscale_h, 0, sizeof(s->upscale_h));
673 memset(s->upscale_v, 0, sizeof(s->upscale_v));
674 return AVERROR_PATCHWELCOME;
676 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
677 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
678 return AVERROR_PATCHWELCOME;
680 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
681 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
682 return AVERROR_PATCHWELCOME;
685 memset(s->upscale_h, 0, sizeof(s->upscale_h));
686 memset(s->upscale_v, 0, sizeof(s->upscale_v));
687 if (s->nb_components == 3) {
688 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
689 } else if (s->nb_components != 1) {
690 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
691 return AVERROR_PATCHWELCOME;
692 } else if (s->palette_index && s->bits <= 8)
693 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
694 else if (s->bits <= 8)
695 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
697 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
700 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
702 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
706 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
707 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
709 enum AVPixelFormat pix_fmts[] = {
710 #if CONFIG_MJPEG_NVDEC_HWACCEL
713 #if CONFIG_MJPEG_VAAPI_HWACCEL
719 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
720 if (s->hwaccel_pix_fmt < 0)
721 return AVERROR(EINVAL);
723 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
724 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
727 if (s->avctx->skip_frame == AVDISCARD_ALL) {
728 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
729 s->picture_ptr->key_frame = 1;
734 av_frame_unref(s->picture_ptr);
735 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
737 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
738 s->picture_ptr->key_frame = 1;
741 for (i = 0; i < 4; i++)
742 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
744 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
745 s->width, s->height, s->linesize[0], s->linesize[1],
746 s->interlaced, s->avctx->height);
750 if ((s->rgb && !s->lossless && !s->ls) ||
751 (!s->rgb && s->ls && s->nb_components > 1) ||
752 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
754 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
755 return AVERROR_PATCHWELCOME;
758 /* totally blank picture as progressive JPEG will only add details to it */
759 if (s->progressive) {
760 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
761 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
762 for (i = 0; i < s->nb_components; i++) {
763 int size = bw * bh * s->h_count[i] * s->v_count[i];
764 av_freep(&s->blocks[i]);
765 av_freep(&s->last_nnz[i]);
766 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
767 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
768 if (!s->blocks[i] || !s->last_nnz[i])
769 return AVERROR(ENOMEM);
770 s->block_stride[i] = bw * s->h_count[i];
772 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
775 if (s->avctx->hwaccel) {
776 s->hwaccel_picture_private =
777 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
778 if (!s->hwaccel_picture_private)
779 return AVERROR(ENOMEM);
781 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
782 s->raw_image_buffer_size);
790 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
793 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
794 if (code < 0 || code > 16) {
795 av_log(s->avctx, AV_LOG_WARNING,
796 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
797 0, dc_index, &s->vlcs[0][dc_index]);
802 return get_xbits(&s->gb, code);
807 /* decode block and dequantize */
808 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
809 int dc_index, int ac_index, uint16_t *quant_matrix)
811 int code, i, j, level, val;
814 val = mjpeg_decode_dc(s, dc_index);
815 if (val == 0xfffff) {
816 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
817 return AVERROR_INVALIDDATA;
819 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
820 val = av_clip_int16(val);
821 s->last_dc[component] = val;
825 {OPEN_READER(re, &s->gb);
827 UPDATE_CACHE(re, &s->gb);
828 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
830 i += ((unsigned)code) >> 4;
833 if (code > MIN_CACHE_BITS - 16)
834 UPDATE_CACHE(re, &s->gb);
837 int cache = GET_CACHE(re, &s->gb);
838 int sign = (~cache) >> 31;
839 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
842 LAST_SKIP_BITS(re, &s->gb, code);
845 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
846 return AVERROR_INVALIDDATA;
848 j = s->scantable.permutated[i];
849 block[j] = level * quant_matrix[i];
852 CLOSE_READER(re, &s->gb);}
857 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
858 int component, int dc_index,
859 uint16_t *quant_matrix, int Al)
862 s->bdsp.clear_block(block);
863 val = mjpeg_decode_dc(s, dc_index);
864 if (val == 0xfffff) {
865 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
866 return AVERROR_INVALIDDATA;
868 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
869 s->last_dc[component] = val;
874 /* decode block and dequantize - progressive JPEG version */
875 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
876 uint8_t *last_nnz, int ac_index,
877 uint16_t *quant_matrix,
878 int ss, int se, int Al, int *EOBRUN)
880 int code, i, j, val, run;
889 OPEN_READER(re, &s->gb);
890 for (i = ss; ; i++) {
891 UPDATE_CACHE(re, &s->gb);
892 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
894 run = ((unsigned) code) >> 4;
898 if (code > MIN_CACHE_BITS - 16)
899 UPDATE_CACHE(re, &s->gb);
902 int cache = GET_CACHE(re, &s->gb);
903 int sign = (~cache) >> 31;
904 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
907 LAST_SKIP_BITS(re, &s->gb, code);
911 j = s->scantable.permutated[se];
912 block[j] = level * (quant_matrix[se] << Al);
915 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
916 return AVERROR_INVALIDDATA;
918 j = s->scantable.permutated[i];
919 block[j] = level * (quant_matrix[i] << Al);
921 if (run == 0xF) {// ZRL - skip 15 coefficients
924 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
925 return AVERROR_INVALIDDATA;
930 UPDATE_CACHE(re, &s->gb);
931 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
932 LAST_SKIP_BITS(re, &s->gb, run);
939 CLOSE_READER(re, &s->gb);
948 #define REFINE_BIT(j) { \
949 UPDATE_CACHE(re, &s->gb); \
950 sign = block[j] >> 15; \
951 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
952 ((quant_matrix[i] ^ sign) - sign) << Al; \
953 LAST_SKIP_BITS(re, &s->gb, 1); \
961 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
966 j = s->scantable.permutated[i]; \
969 else if (run-- == 0) \
973 /* decode block and dequantize - progressive JPEG refinement pass */
974 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
976 int ac_index, uint16_t *quant_matrix,
977 int ss, int se, int Al, int *EOBRUN)
979 int code, i = ss, j, sign, val, run;
980 int last = FFMIN(se, *last_nnz);
982 OPEN_READER(re, &s->gb);
987 UPDATE_CACHE(re, &s->gb);
988 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
991 run = ((unsigned) code) >> 4;
992 UPDATE_CACHE(re, &s->gb);
993 val = SHOW_UBITS(re, &s->gb, 1);
994 LAST_SKIP_BITS(re, &s->gb, 1);
996 j = s->scantable.permutated[i];
998 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
1002 CLOSE_READER(re, &s->gb);
1006 run = ((unsigned) code) >> 4;
1013 UPDATE_CACHE(re, &s->gb);
1014 run += SHOW_UBITS(re, &s->gb, val);
1015 LAST_SKIP_BITS(re, &s->gb, val);
1027 for (; i <= last; i++) {
1028 j = s->scantable.permutated[i];
1032 CLOSE_READER(re, &s->gb);
1039 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1044 if (s->restart_interval) {
1046 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1047 align_get_bits(&s->gb);
1048 for (i = 0; i < nb_components; i++) /* reset dc */
1049 s->last_dc[i] = (4 << s->bits);
1052 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1054 if (s->restart_count == 0) {
1055 if( show_bits(&s->gb, i) == (1 << i) - 1
1056 || show_bits(&s->gb, i) == 0xFF) {
1057 int pos = get_bits_count(&s->gb);
1058 align_get_bits(&s->gb);
1059 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1060 skip_bits(&s->gb, 8);
1061 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1062 for (i = 0; i < nb_components; i++) /* reset dc */
1063 s->last_dc[i] = (4 << s->bits);
1066 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1073 /* Handles 1 to 4 components */
1074 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1078 uint16_t (*buffer)[4];
1079 int left[4], top[4], topleft[4];
1080 const int linesize = s->linesize[0];
1081 const int mask = ((1 << s->bits) - 1) << point_transform;
1082 int resync_mb_y = 0;
1083 int resync_mb_x = 0;
1086 if (!s->bayer && s->nb_components < 3)
1087 return AVERROR_INVALIDDATA;
1088 if (s->bayer && s->nb_components > 2)
1089 return AVERROR_INVALIDDATA;
1090 if (s->nb_components <= 0 || s->nb_components > 4)
1091 return AVERROR_INVALIDDATA;
1092 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1093 return AVERROR_INVALIDDATA;
1096 s->restart_count = s->restart_interval;
1098 if (s->restart_interval == 0)
1099 s->restart_interval = INT_MAX;
1102 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1104 width = s->mb_width;
1106 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1107 if (!s->ljpeg_buffer)
1108 return AVERROR(ENOMEM);
1110 buffer = s->ljpeg_buffer;
1112 for (i = 0; i < 4; i++)
1113 buffer[0][i] = 1 << (s->bits - 1);
1115 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1116 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1118 if (s->interlaced && s->bottom_field)
1119 ptr += linesize >> 1;
1121 for (i = 0; i < 4; i++)
1122 top[i] = left[i] = topleft[i] = buffer[0][i];
1124 if ((mb_y * s->width) % s->restart_interval == 0) {
1125 for (i = 0; i < 6; i++)
1126 vpred[i] = 1 << (s->bits-1);
1129 for (mb_x = 0; mb_x < width; mb_x++) {
1130 int modified_predictor = predictor;
1132 if (get_bits_left(&s->gb) < 1) {
1133 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1134 return AVERROR_INVALIDDATA;
1137 if (s->restart_interval && !s->restart_count){
1138 s->restart_count = s->restart_interval;
1142 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1144 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1145 modified_predictor = 1;
1147 for (i=0;i<nb_components;i++) {
1150 topleft[i] = top[i];
1151 top[i] = buffer[mb_x][i];
1153 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1157 if (!s->bayer || mb_x) {
1159 } else { /* This path runs only for the first line in bayer images */
1161 pred = vpred[i] - dc;
1164 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1166 left[i] = buffer[mb_x][i] =
1167 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1170 if (s->restart_interval && !--s->restart_count) {
1171 align_get_bits(&s->gb);
1172 skip_bits(&s->gb, 16); /* skip RSTn */
1175 if (s->rct && s->nb_components == 4) {
1176 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1177 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1178 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1179 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1180 ptr[4*mb_x + 0] = buffer[mb_x][3];
1182 } else if (s->nb_components == 4) {
1183 for(i=0; i<nb_components; i++) {
1184 int c= s->comp_index[i];
1186 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1189 } else if(s->bits == 9) {
1190 return AVERROR_PATCHWELCOME;
1192 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1193 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1197 } else if (s->rct) {
1198 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1199 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1200 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1201 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1203 } else if (s->pegasus_rct) {
1204 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1205 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1206 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1207 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1209 } else if (s->bayer) {
1210 if (nb_components == 1) {
1211 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1212 for (mb_x = 0; mb_x < width; mb_x++)
1213 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1214 } else if (nb_components == 2) {
1215 for (mb_x = 0; mb_x < width; mb_x++) {
1216 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1217 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1221 for(i=0; i<nb_components; i++) {
1222 int c= s->comp_index[i];
1224 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1225 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1227 } else if(s->bits == 9) {
1228 return AVERROR_PATCHWELCOME;
1230 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1231 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1240 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1241 int point_transform, int nb_components)
1243 int i, mb_x, mb_y, mask;
1244 int bits= (s->bits+7)&~7;
1245 int resync_mb_y = 0;
1246 int resync_mb_x = 0;
1248 point_transform += bits - s->bits;
1249 mask = ((1 << s->bits) - 1) << point_transform;
1251 av_assert0(nb_components>=1 && nb_components<=4);
1253 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1254 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1255 if (get_bits_left(&s->gb) < 1) {
1256 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1257 return AVERROR_INVALIDDATA;
1259 if (s->restart_interval && !s->restart_count){
1260 s->restart_count = s->restart_interval;
1265 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1266 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1267 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1268 for (i = 0; i < nb_components; i++) {
1271 int n, h, v, x, y, c, j, linesize;
1272 n = s->nb_blocks[i];
1273 c = s->comp_index[i];
1278 linesize= s->linesize[c];
1280 if(bits>8) linesize /= 2;
1282 for(j=0; j<n; j++) {
1285 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1288 if ( h * mb_x + x >= s->width
1289 || v * mb_y + y >= s->height) {
1291 } else if (bits<=8) {
1292 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1294 if(x==0 && leftcol){
1295 pred= 1 << (bits - 1);
1300 if(x==0 && leftcol){
1301 pred= ptr[-linesize];
1303 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1307 if (s->interlaced && s->bottom_field)
1308 ptr += linesize >> 1;
1310 *ptr= pred + ((unsigned)dc << point_transform);
1312 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1314 if(x==0 && leftcol){
1315 pred= 1 << (bits - 1);
1320 if(x==0 && leftcol){
1321 pred= ptr16[-linesize];
1323 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1327 if (s->interlaced && s->bottom_field)
1328 ptr16 += linesize >> 1;
1330 *ptr16= pred + ((unsigned)dc << point_transform);
1339 for (i = 0; i < nb_components; i++) {
1342 int n, h, v, x, y, c, j, linesize, dc;
1343 n = s->nb_blocks[i];
1344 c = s->comp_index[i];
1349 linesize = s->linesize[c];
1351 if(bits>8) linesize /= 2;
1353 for (j = 0; j < n; j++) {
1356 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1359 if ( h * mb_x + x >= s->width
1360 || v * mb_y + y >= s->height) {
1362 } else if (bits<=8) {
1363 ptr = s->picture_ptr->data[c] +
1364 (linesize * (v * mb_y + y)) +
1365 (h * mb_x + x); //FIXME optimize this crap
1366 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1369 *ptr = pred + ((unsigned)dc << point_transform);
1371 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1372 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1375 *ptr16= pred + ((unsigned)dc << point_transform);
1385 if (s->restart_interval && !--s->restart_count) {
1386 align_get_bits(&s->gb);
1387 skip_bits(&s->gb, 16); /* skip RSTn */
1394 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1395 uint8_t *dst, const uint8_t *src,
1396 int linesize, int lowres)
1399 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1401 case 1: copy_block4(dst, src, linesize, linesize, 4);
1403 case 2: copy_block2(dst, src, linesize, linesize, 2);
1405 case 3: *dst = *src;
1410 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1412 int block_x, block_y;
1413 int size = 8 >> s->avctx->lowres;
1415 for (block_y=0; block_y<size; block_y++)
1416 for (block_x=0; block_x<size; block_x++)
1417 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1419 for (block_y=0; block_y<size; block_y++)
1420 for (block_x=0; block_x<size; block_x++)
1421 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1425 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1426 int Al, const uint8_t *mb_bitmask,
1427 int mb_bitmask_size,
1428 const AVFrame *reference)
1430 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1431 uint8_t *data[MAX_COMPONENTS];
1432 const uint8_t *reference_data[MAX_COMPONENTS];
1433 int linesize[MAX_COMPONENTS];
1434 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1435 int bytes_per_pixel = 1 + (s->bits > 8);
1438 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1439 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1440 return AVERROR_INVALIDDATA;
1442 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1445 s->restart_count = 0;
1447 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1449 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1450 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1452 for (i = 0; i < nb_components; i++) {
1453 int c = s->comp_index[i];
1454 data[c] = s->picture_ptr->data[c];
1455 reference_data[c] = reference ? reference->data[c] : NULL;
1456 linesize[c] = s->linesize[c];
1457 s->coefs_finished[c] |= 1;
1460 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1461 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1462 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1464 if (s->restart_interval && !s->restart_count)
1465 s->restart_count = s->restart_interval;
1467 if (get_bits_left(&s->gb) < 0) {
1468 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1469 -get_bits_left(&s->gb));
1470 return AVERROR_INVALIDDATA;
1472 for (i = 0; i < nb_components; i++) {
1474 int n, h, v, x, y, c, j;
1476 n = s->nb_blocks[i];
1477 c = s->comp_index[i];
1482 for (j = 0; j < n; j++) {
1483 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1484 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1486 if (s->interlaced && s->bottom_field)
1487 block_offset += linesize[c] >> 1;
1488 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1489 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1490 ptr = data[c] + block_offset;
1493 if (!s->progressive) {
1496 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1497 linesize[c], s->avctx->lowres);
1500 s->bdsp.clear_block(s->block);
1501 if (decode_block(s, s->block, i,
1502 s->dc_index[i], s->ac_index[i],
1503 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1504 av_log(s->avctx, AV_LOG_ERROR,
1505 "error y=%d x=%d\n", mb_y, mb_x);
1506 return AVERROR_INVALIDDATA;
1509 s->idsp.idct_put(ptr, linesize[c], s->block);
1511 shift_output(s, ptr, linesize[c]);
1515 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1517 int16_t *block = s->blocks[c][block_idx];
1519 block[0] += get_bits1(&s->gb) *
1520 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1521 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1522 s->quant_matrixes[s->quant_sindex[i]],
1524 av_log(s->avctx, AV_LOG_ERROR,
1525 "error y=%d x=%d\n", mb_y, mb_x);
1526 return AVERROR_INVALIDDATA;
1529 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1530 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1531 mb_x, mb_y, x, y, c, s->bottom_field,
1532 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1540 handle_rstn(s, nb_components);
1546 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1547 int se, int Ah, int Al)
1551 int c = s->comp_index[0];
1552 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1554 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1555 if (se < ss || se > 63) {
1556 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1557 return AVERROR_INVALIDDATA;
1560 // s->coefs_finished is a bitmask for coefficients coded
1561 // ss and se are parameters telling start and end coefficients
1562 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1564 s->restart_count = 0;
1566 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1567 int block_idx = mb_y * s->block_stride[c];
1568 int16_t (*block)[64] = &s->blocks[c][block_idx];
1569 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1570 if (get_bits_left(&s->gb) <= 0) {
1571 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1572 return AVERROR_INVALIDDATA;
1574 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1576 if (s->restart_interval && !s->restart_count)
1577 s->restart_count = s->restart_interval;
1580 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1581 quant_matrix, ss, se, Al, &EOBRUN);
1583 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1584 quant_matrix, ss, se, Al, &EOBRUN);
1586 av_log(s->avctx, AV_LOG_ERROR,
1587 "error y=%d x=%d\n", mb_y, mb_x);
1588 return AVERROR_INVALIDDATA;
1591 if (handle_rstn(s, 0))
1598 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1602 const int bytes_per_pixel = 1 + (s->bits > 8);
1603 const int block_size = s->lossless ? 1 : 8;
1605 for (c = 0; c < s->nb_components; c++) {
1606 uint8_t *data = s->picture_ptr->data[c];
1607 int linesize = s->linesize[c];
1608 int h = s->h_max / s->h_count[c];
1609 int v = s->v_max / s->v_count[c];
1610 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1611 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1613 if (~s->coefs_finished[c])
1614 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1616 if (s->interlaced && s->bottom_field)
1617 data += linesize >> 1;
1619 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1620 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1621 int block_idx = mb_y * s->block_stride[c];
1622 int16_t (*block)[64] = &s->blocks[c][block_idx];
1623 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1624 s->idsp.idct_put(ptr, linesize, *block);
1626 shift_output(s, ptr, linesize);
1627 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1633 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1634 int mb_bitmask_size, const AVFrame *reference)
1636 int len, nb_components, i, h, v, predictor, point_transform;
1638 const int block_size = s->lossless ? 1 : 8;
1639 int ilv, prev_shift;
1641 if (!s->got_picture) {
1642 av_log(s->avctx, AV_LOG_WARNING,
1643 "Can not process SOS before SOF, skipping\n");
1648 if (reference->width != s->picture_ptr->width ||
1649 reference->height != s->picture_ptr->height ||
1650 reference->format != s->picture_ptr->format) {
1651 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1652 return AVERROR_INVALIDDATA;
1656 /* XXX: verify len field validity */
1657 len = get_bits(&s->gb, 16);
1658 nb_components = get_bits(&s->gb, 8);
1659 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1660 avpriv_report_missing_feature(s->avctx,
1661 "decode_sos: nb_components (%d)",
1663 return AVERROR_PATCHWELCOME;
1665 if (len != 6 + 2 * nb_components) {
1666 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1667 return AVERROR_INVALIDDATA;
1669 for (i = 0; i < nb_components; i++) {
1670 id = get_bits(&s->gb, 8) - 1;
1671 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1672 /* find component index */
1673 for (index = 0; index < s->nb_components; index++)
1674 if (id == s->component_id[index])
1676 if (index == s->nb_components) {
1677 av_log(s->avctx, AV_LOG_ERROR,
1678 "decode_sos: index(%d) out of components\n", index);
1679 return AVERROR_INVALIDDATA;
1681 /* Metasoft MJPEG codec has Cb and Cr swapped */
1682 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1683 && nb_components == 3 && s->nb_components == 3 && i)
1686 s->quant_sindex[i] = s->quant_index[index];
1687 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1688 s->h_scount[i] = s->h_count[index];
1689 s->v_scount[i] = s->v_count[index];
1691 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1692 index = (index+2)%3;
1694 s->comp_index[i] = index;
1696 s->dc_index[i] = get_bits(&s->gb, 4);
1697 s->ac_index[i] = get_bits(&s->gb, 4);
1699 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1700 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1702 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))
1706 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1707 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1708 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1709 prev_shift = get_bits(&s->gb, 4); /* Ah */
1710 point_transform = get_bits(&s->gb, 4); /* Al */
1712 prev_shift = point_transform = 0;
1714 if (nb_components > 1) {
1715 /* interleaved stream */
1716 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1717 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1718 } else if (!s->ls) { /* skip this for JPEG-LS */
1719 h = s->h_max / s->h_scount[0];
1720 v = s->v_max / s->v_scount[0];
1721 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1722 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1723 s->nb_blocks[0] = 1;
1728 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1729 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1730 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1731 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1732 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1735 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1736 for (i = s->mjpb_skiptosod; i > 0; i--)
1737 skip_bits(&s->gb, 8);
1740 for (i = 0; i < nb_components; i++)
1741 s->last_dc[i] = (4 << s->bits);
1743 if (s->avctx->hwaccel) {
1744 int bytes_to_start = get_bits_count(&s->gb) / 8;
1745 av_assert0(bytes_to_start >= 0 &&
1746 s->raw_scan_buffer_size >= bytes_to_start);
1748 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1749 s->raw_scan_buffer + bytes_to_start,
1750 s->raw_scan_buffer_size - bytes_to_start);
1754 } else if (s->lossless) {
1755 av_assert0(s->picture_ptr == s->picture);
1756 if (CONFIG_JPEGLS_DECODER && s->ls) {
1758 // reset_ls_coding_parameters(s, 0);
1760 if ((ret = ff_jpegls_decode_picture(s, predictor,
1761 point_transform, ilv)) < 0)
1764 if (s->rgb || s->bayer) {
1765 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1768 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1770 nb_components)) < 0)
1775 if (s->progressive && predictor) {
1776 av_assert0(s->picture_ptr == s->picture);
1777 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1779 point_transform)) < 0)
1782 if ((ret = mjpeg_decode_scan(s, nb_components,
1783 prev_shift, point_transform,
1784 mb_bitmask, mb_bitmask_size, reference)) < 0)
1789 if (s->interlaced &&
1790 get_bits_left(&s->gb) > 32 &&
1791 show_bits(&s->gb, 8) == 0xFF) {
1792 GetBitContext bak = s->gb;
1793 align_get_bits(&bak);
1794 if (show_bits(&bak, 16) == 0xFFD1) {
1795 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1797 skip_bits(&s->gb, 16);
1798 s->bottom_field ^= 1;
1807 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1808 return AVERROR_INVALIDDATA;
1811 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1813 if (get_bits(&s->gb, 16) != 4)
1814 return AVERROR_INVALIDDATA;
1815 s->restart_interval = get_bits(&s->gb, 16);
1816 s->restart_count = 0;
1817 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1818 s->restart_interval);
1823 static int mjpeg_decode_app(MJpegDecodeContext *s)
1827 len = get_bits(&s->gb, 16);
1830 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1831 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1832 skip_bits(&s->gb, len);
1835 return AVERROR_INVALIDDATA;
1837 if (8 * len > get_bits_left(&s->gb))
1838 return AVERROR_INVALIDDATA;
1840 id = get_bits_long(&s->gb, 32);
1843 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1844 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1845 av_fourcc2str(av_bswap32(id)), id, len);
1847 /* Buggy AVID, it puts EOI only at every 10th frame. */
1848 /* Also, this fourcc is used by non-avid files too, it holds some
1849 information, but it's always present in AVID-created files. */
1850 if (id == AV_RB32("AVI1")) {
1856 4bytes field_size_less_padding
1859 i = get_bits(&s->gb, 8); len--;
1860 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1864 if (id == AV_RB32("JFIF")) {
1865 int t_w, t_h, v1, v2;
1868 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1869 v1 = get_bits(&s->gb, 8);
1870 v2 = get_bits(&s->gb, 8);
1871 skip_bits(&s->gb, 8);
1873 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1874 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1875 if ( s->avctx->sample_aspect_ratio.num <= 0
1876 || s->avctx->sample_aspect_ratio.den <= 0) {
1877 s->avctx->sample_aspect_ratio.num = 0;
1878 s->avctx->sample_aspect_ratio.den = 1;
1881 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1882 av_log(s->avctx, AV_LOG_INFO,
1883 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1885 s->avctx->sample_aspect_ratio.num,
1886 s->avctx->sample_aspect_ratio.den);
1890 t_w = get_bits(&s->gb, 8);
1891 t_h = get_bits(&s->gb, 8);
1893 /* skip thumbnail */
1894 if (len -10 - (t_w * t_h * 3) > 0)
1895 len -= t_w * t_h * 3;
1902 if ( id == AV_RB32("Adob")
1904 && show_bits(&s->gb, 8) == 'e'
1905 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1906 skip_bits(&s->gb, 8); /* 'e' */
1907 skip_bits(&s->gb, 16); /* version */
1908 skip_bits(&s->gb, 16); /* flags0 */
1909 skip_bits(&s->gb, 16); /* flags1 */
1910 s->adobe_transform = get_bits(&s->gb, 8);
1911 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1912 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1917 if (id == AV_RB32("LJIF")) {
1919 int pegasus_rct = s->pegasus_rct;
1920 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1921 av_log(s->avctx, AV_LOG_INFO,
1922 "Pegasus lossless jpeg header found\n");
1923 skip_bits(&s->gb, 16); /* version ? */
1924 skip_bits(&s->gb, 16); /* unknown always 0? */
1925 skip_bits(&s->gb, 16); /* unknown always 0? */
1926 skip_bits(&s->gb, 16); /* unknown always 0? */
1927 switch (i=get_bits(&s->gb, 8)) {
1937 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1942 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1943 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1948 s->pegasus_rct = pegasus_rct;
1952 if (id == AV_RL32("colr") && len > 0) {
1953 s->colr = get_bits(&s->gb, 8);
1954 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1955 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1959 if (id == AV_RL32("xfrm") && len > 0) {
1960 s->xfrm = get_bits(&s->gb, 8);
1961 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1962 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1967 /* JPS extension by VRex */
1968 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1969 int flags, layout, type;
1970 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1971 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1973 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1974 skip_bits(&s->gb, 16); len -= 2; /* block length */
1975 skip_bits(&s->gb, 8); /* reserved */
1976 flags = get_bits(&s->gb, 8);
1977 layout = get_bits(&s->gb, 8);
1978 type = get_bits(&s->gb, 8);
1981 av_freep(&s->stereo3d);
1982 s->stereo3d = av_stereo3d_alloc();
1987 s->stereo3d->type = AV_STEREO3D_2D;
1988 } else if (type == 1) {
1991 s->stereo3d->type = AV_STEREO3D_LINES;
1994 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1997 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2000 if (!(flags & 0x04)) {
2001 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2008 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2009 GetByteContext gbytes;
2010 int ret, le, ifd_offset, bytes_read;
2011 const uint8_t *aligned;
2013 skip_bits(&s->gb, 16); // skip padding
2016 // init byte wise reading
2017 aligned = align_get_bits(&s->gb);
2018 bytestream2_init(&gbytes, aligned, len);
2021 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2023 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2025 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2027 // read 0th IFD and store the metadata
2028 // (return values > 0 indicate the presence of subimage metadata)
2029 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2031 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2035 bytes_read = bytestream2_tell(&gbytes);
2036 skip_bits(&s->gb, bytes_read << 3);
2043 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2044 id = get_bits_long(&s->gb, 32);
2047 if (id == AV_RB32("mjpg")) {
2050 4bytes pad field size
2058 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2059 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2063 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2066 unsigned nummarkers;
2068 id = get_bits_long(&s->gb, 32);
2069 id2 = get_bits(&s->gb, 24);
2071 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2072 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2076 skip_bits(&s->gb, 8);
2077 seqno = get_bits(&s->gb, 8);
2080 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2084 nummarkers = get_bits(&s->gb, 8);
2086 if (nummarkers == 0) {
2087 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2089 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2090 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2092 } else if (seqno > nummarkers) {
2093 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2097 /* Allocate if this is the first APP2 we've seen. */
2098 if (s->iccnum == 0) {
2099 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2100 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2101 if (!s->iccdata || !s->iccdatalens) {
2102 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2103 return AVERROR(ENOMEM);
2105 s->iccnum = nummarkers;
2108 if (s->iccdata[seqno - 1]) {
2109 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2113 s->iccdatalens[seqno - 1] = len;
2114 s->iccdata[seqno - 1] = av_malloc(len);
2115 if (!s->iccdata[seqno - 1]) {
2116 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2117 return AVERROR(ENOMEM);
2120 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2121 skip_bits(&s->gb, len << 3);
2125 if (s->iccread > s->iccnum)
2126 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2130 /* slow but needed for extreme adobe jpegs */
2132 av_log(s->avctx, AV_LOG_ERROR,
2133 "mjpeg: error, decode_app parser read over the end\n");
2135 skip_bits(&s->gb, 8);
2140 static int mjpeg_decode_com(MJpegDecodeContext *s)
2142 int len = get_bits(&s->gb, 16);
2143 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2145 char *cbuf = av_malloc(len - 1);
2147 return AVERROR(ENOMEM);
2149 for (i = 0; i < len - 2; i++)
2150 cbuf[i] = get_bits(&s->gb, 8);
2151 if (i > 0 && cbuf[i - 1] == '\n')
2156 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2157 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2159 /* buggy avid, it puts EOI only at every 10th frame */
2160 if (!strncmp(cbuf, "AVID", 4)) {
2161 parse_avid(s, cbuf, len);
2162 } else if (!strcmp(cbuf, "CS=ITU601"))
2164 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2165 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2167 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2168 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2178 /* return the 8 bit start code value and update the search
2179 state. Return -1 if no start code found */
2180 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2182 const uint8_t *buf_ptr;
2187 buf_ptr = *pbuf_ptr;
2188 while (buf_end - buf_ptr > 1) {
2191 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2200 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2201 *pbuf_ptr = buf_ptr;
2205 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2206 const uint8_t **buf_ptr, const uint8_t *buf_end,
2207 const uint8_t **unescaped_buf_ptr,
2208 int *unescaped_buf_size)
2211 start_code = find_marker(buf_ptr, buf_end);
2213 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2215 return AVERROR(ENOMEM);
2217 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2218 if (start_code == SOS && !s->ls) {
2219 const uint8_t *src = *buf_ptr;
2220 const uint8_t *ptr = src;
2221 uint8_t *dst = s->buffer;
2223 #define copy_data_segment(skip) do { \
2224 ptrdiff_t length = (ptr - src) - (skip); \
2226 memcpy(dst, src, length); \
2232 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2234 copy_data_segment(0);
2236 while (ptr < buf_end) {
2237 uint8_t x = *(ptr++);
2241 while (ptr < buf_end && x == 0xff) {
2246 /* 0xFF, 0xFF, ... */
2248 copy_data_segment(skip);
2250 /* decrement src as it is equal to ptr after the
2251 * copy_data_segment macro and we might want to
2252 * copy the current value of x later on */
2256 if (x < RST0 || x > RST7) {
2257 copy_data_segment(1);
2264 copy_data_segment(0);
2266 #undef copy_data_segment
2268 *unescaped_buf_ptr = s->buffer;
2269 *unescaped_buf_size = dst - s->buffer;
2270 memset(s->buffer + *unescaped_buf_size, 0,
2271 AV_INPUT_BUFFER_PADDING_SIZE);
2273 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2274 (buf_end - *buf_ptr) - (dst - s->buffer));
2275 } else if (start_code == SOS && s->ls) {
2276 const uint8_t *src = *buf_ptr;
2277 uint8_t *dst = s->buffer;
2283 while (src + t < buf_end) {
2284 uint8_t x = src[t++];
2286 while ((src + t < buf_end) && x == 0xff)
2295 init_put_bits(&pb, dst, t);
2297 /* unescape bitstream */
2299 uint8_t x = src[b++];
2300 put_bits(&pb, 8, x);
2301 if (x == 0xFF && b < t) {
2304 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2307 put_bits(&pb, 7, x);
2311 flush_put_bits(&pb);
2313 *unescaped_buf_ptr = dst;
2314 *unescaped_buf_size = (bit_count + 7) >> 3;
2315 memset(s->buffer + *unescaped_buf_size, 0,
2316 AV_INPUT_BUFFER_PADDING_SIZE);
2318 *unescaped_buf_ptr = *buf_ptr;
2319 *unescaped_buf_size = buf_end - *buf_ptr;
2325 static void reset_icc_profile(MJpegDecodeContext *s)
2330 for (i = 0; i < s->iccnum; i++)
2331 av_freep(&s->iccdata[i]);
2332 av_freep(&s->iccdata);
2333 av_freep(&s->iccdatalens);
2339 static int mjpeg_get_packet(AVCodecContext *avctx)
2341 MJpegDecodeContext *s = avctx->priv_data;
2344 av_packet_unref(s->pkt);
2345 ret = ff_decode_get_packet(avctx, s->pkt);
2349 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2350 if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2351 avctx->codec_id == AV_CODEC_ID_AMV) {
2352 ret = ff_sp5x_process_packet(avctx, s->pkt);
2358 s->buf_size = s->pkt->size;
2363 int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2365 MJpegDecodeContext *s = avctx->priv_data;
2366 const uint8_t *buf_end, *buf_ptr;
2367 const uint8_t *unescaped_buf_ptr;
2369 int unescaped_buf_size;
2375 av_dict_free(&s->exif_metadata);
2376 av_freep(&s->stereo3d);
2377 s->adobe_transform = -1;
2380 reset_icc_profile(s);
2382 ret = mjpeg_get_packet(avctx);
2386 buf_ptr = s->pkt->data;
2387 buf_end = s->pkt->data + s->pkt->size;
2388 while (buf_ptr < buf_end) {
2389 /* find start next marker */
2390 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2392 &unescaped_buf_size);
2394 if (start_code < 0) {
2396 } else if (unescaped_buf_size > INT_MAX / 8) {
2397 av_log(avctx, AV_LOG_ERROR,
2398 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2399 start_code, unescaped_buf_size, s->pkt->size);
2400 return AVERROR_INVALIDDATA;
2402 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2403 start_code, buf_end - buf_ptr);
2405 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2408 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2412 s->start_code = start_code;
2413 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2414 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2416 /* process markers */
2417 if (start_code >= RST0 && start_code <= RST7) {
2418 av_log(avctx, AV_LOG_DEBUG,
2419 "restart marker: %d\n", start_code & 0x0f);
2421 } else if (start_code >= APP0 && start_code <= APP15) {
2422 if ((ret = mjpeg_decode_app(s)) < 0)
2423 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2426 } else if (start_code == COM) {
2427 ret = mjpeg_decode_com(s);
2430 } else if (start_code == DQT) {
2431 ret = ff_mjpeg_decode_dqt(s);
2438 if (!CONFIG_JPEGLS_DECODER &&
2439 (start_code == SOF48 || start_code == LSE)) {
2440 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2441 return AVERROR(ENOSYS);
2444 if (avctx->skip_frame == AVDISCARD_ALL) {
2445 switch(start_code) {
2460 switch (start_code) {
2462 s->restart_interval = 0;
2463 s->restart_count = 0;
2464 s->raw_image_buffer = buf_ptr;
2465 s->raw_image_buffer_size = buf_end - buf_ptr;
2466 /* nothing to do on SOI */
2469 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2470 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2476 if (start_code == SOF0)
2477 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2479 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2483 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2487 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2491 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2495 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2496 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2500 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2504 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2505 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2509 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2513 if (!CONFIG_JPEGLS_DECODER ||
2514 (ret = ff_jpegls_decode_lse(s)) < 0)
2519 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2520 s->progressive && s->cur_scan && s->got_picture)
2521 mjpeg_idct_scan_progressive_ac(s);
2523 if (!s->got_picture) {
2524 av_log(avctx, AV_LOG_WARNING,
2525 "Found EOI before any SOF, ignoring\n");
2528 if (s->interlaced) {
2529 s->bottom_field ^= 1;
2530 /* if not bottom field, do not output image yet */
2531 if (s->bottom_field == !s->interlace_polarity)
2534 if (avctx->skip_frame == AVDISCARD_ALL) {
2536 ret = AVERROR(EAGAIN);
2537 goto the_end_no_picture;
2539 if (s->avctx->hwaccel) {
2540 ret = s->avctx->hwaccel->end_frame(s->avctx);
2544 av_freep(&s->hwaccel_picture_private);
2546 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2550 frame->pkt_dts = s->pkt->dts;
2551 frame->best_effort_timestamp = s->pkt->pts;
2554 int qp = FFMAX3(s->qscale[0],
2557 int qpw = (s->width + 15) / 16;
2558 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2560 memset(qp_table_buf->data, qp, qpw);
2561 av_frame_set_qp_table(frame, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2564 if(avctx->debug & FF_DEBUG_QP)
2565 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2570 s->raw_scan_buffer = buf_ptr;
2571 s->raw_scan_buffer_size = buf_end - buf_ptr;
2574 if (avctx->skip_frame == AVDISCARD_ALL) {
2575 skip_bits(&s->gb, get_bits_left(&s->gb));
2579 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2580 (avctx->err_recognition & AV_EF_EXPLODE))
2584 if ((ret = mjpeg_decode_dri(s)) < 0)
2597 av_log(avctx, AV_LOG_ERROR,
2598 "mjpeg: unsupported coding type (%x)\n", start_code);
2603 /* eof process start code */
2604 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2605 av_log(avctx, AV_LOG_DEBUG,
2606 "marker parser used %d bytes (%d bits)\n",
2607 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2609 if (s->got_picture && s->cur_scan) {
2610 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2613 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2614 return AVERROR_INVALIDDATA;
2620 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2622 if (AV_RB32(s->upscale_h)) {
2624 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2625 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2626 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2627 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2628 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2629 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2630 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2631 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2632 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2633 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2634 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2635 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2637 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2641 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2642 for (p = 0; p<s->nb_components; p++) {
2643 uint8_t *line = s->picture_ptr->data[p];
2646 if (!s->upscale_h[p])
2649 w = AV_CEIL_RSHIFT(w, hshift);
2650 h = AV_CEIL_RSHIFT(h, vshift);
2652 if (s->upscale_v[p] == 1)
2655 for (i = 0; i < h; i++) {
2656 if (s->upscale_h[p] == 1) {
2657 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2658 else line[w - 1] = line[(w - 1) / 2];
2659 for (index = w - 2; index > 0; index--) {
2661 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2663 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2665 } else if (s->upscale_h[p] == 2) {
2667 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2669 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2671 line[w - 1] = line[(w - 1) / 3];
2673 line[w - 2] = line[w - 1];
2675 for (index = w - 3; index > 0; index--) {
2676 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2679 line += s->linesize[p];
2683 if (AV_RB32(s->upscale_v)) {
2685 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2686 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2687 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2688 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2689 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2690 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2691 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2692 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2693 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2694 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2695 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2696 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2697 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2699 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2703 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2704 for (p = 0; p < s->nb_components; p++) {
2708 if (!s->upscale_v[p])
2711 w = AV_CEIL_RSHIFT(w, hshift);
2712 h = AV_CEIL_RSHIFT(h, vshift);
2714 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2715 for (i = h - 1; i; i--) {
2716 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2717 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2718 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2719 memcpy(dst, src1, w);
2721 for (index = 0; index < w; index++)
2722 dst[index] = (src1[index] + src2[index]) >> 1;
2724 dst -= s->linesize[p];
2728 if (s->flipped && !s->rgb) {
2730 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2734 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2735 for (index=0; index<s->nb_components; index++) {
2736 uint8_t *dst = s->picture_ptr->data[index];
2737 int w = s->picture_ptr->width;
2738 int h = s->picture_ptr->height;
2739 if(index && index<3){
2740 w = AV_CEIL_RSHIFT(w, hshift);
2741 h = AV_CEIL_RSHIFT(h, vshift);
2744 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2745 for (i=0; i<h/2; i++) {
2747 FFSWAP(int, dst[j], dst2[j]);
2748 dst += s->picture_ptr->linesize[index];
2749 dst2 -= s->picture_ptr->linesize[index];
2754 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2755 int w = s->picture_ptr->width;
2756 int h = s->picture_ptr->height;
2757 av_assert0(s->nb_components == 4);
2758 for (i=0; i<h; i++) {
2761 for (index=0; index<4; index++) {
2762 dst[index] = s->picture_ptr->data[index]
2763 + s->picture_ptr->linesize[index]*i;
2765 for (j=0; j<w; j++) {
2767 int r = dst[0][j] * k;
2768 int g = dst[1][j] * k;
2769 int b = dst[2][j] * k;
2770 dst[0][j] = g*257 >> 16;
2771 dst[1][j] = b*257 >> 16;
2772 dst[2][j] = r*257 >> 16;
2777 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2778 int w = s->picture_ptr->width;
2779 int h = s->picture_ptr->height;
2780 av_assert0(s->nb_components == 4);
2781 for (i=0; i<h; i++) {
2784 for (index=0; index<4; index++) {
2785 dst[index] = s->picture_ptr->data[index]
2786 + s->picture_ptr->linesize[index]*i;
2788 for (j=0; j<w; j++) {
2790 int r = (255 - dst[0][j]) * k;
2791 int g = (128 - dst[1][j]) * k;
2792 int b = (128 - dst[2][j]) * k;
2793 dst[0][j] = r*257 >> 16;
2794 dst[1][j] = (g*257 >> 16) + 128;
2795 dst[2][j] = (b*257 >> 16) + 128;
2802 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2804 stereo->type = s->stereo3d->type;
2805 stereo->flags = s->stereo3d->flags;
2807 av_freep(&s->stereo3d);
2810 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2811 AVFrameSideData *sd;
2816 /* Sum size of all parts. */
2817 for (i = 0; i < s->iccnum; i++)
2818 total_size += s->iccdatalens[i];
2820 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2822 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2823 return AVERROR(ENOMEM);
2826 /* Reassemble the parts, which are now in-order. */
2827 for (i = 0; i < s->iccnum; i++) {
2828 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2829 offset += s->iccdatalens[i];
2833 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2834 av_dict_free(&s->exif_metadata);
2839 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2845 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2846 * even without having called ff_mjpeg_decode_init(). */
2847 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2849 MJpegDecodeContext *s = avctx->priv_data;
2852 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2853 av_log(avctx, AV_LOG_INFO, "Single field\n");
2857 av_frame_free(&s->picture);
2858 s->picture_ptr = NULL;
2859 } else if (s->picture_ptr)
2860 av_frame_unref(s->picture_ptr);
2862 av_packet_free(&s->pkt);
2864 av_freep(&s->buffer);
2865 av_freep(&s->stereo3d);
2866 av_freep(&s->ljpeg_buffer);
2867 s->ljpeg_buffer_size = 0;
2869 for (i = 0; i < 3; i++) {
2870 for (j = 0; j < 4; j++)
2871 ff_free_vlc(&s->vlcs[i][j]);
2873 for (i = 0; i < MAX_COMPONENTS; i++) {
2874 av_freep(&s->blocks[i]);
2875 av_freep(&s->last_nnz[i]);
2877 av_dict_free(&s->exif_metadata);
2879 reset_icc_profile(s);
2881 av_freep(&s->hwaccel_picture_private);
2886 static void decode_flush(AVCodecContext *avctx)
2888 MJpegDecodeContext *s = avctx->priv_data;
2892 #if CONFIG_MJPEG_DECODER
2893 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2894 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2895 static const AVOption options[] = {
2896 { "extern_huff", "Use external huffman table.",
2897 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2901 static const AVClass mjpegdec_class = {
2902 .class_name = "MJPEG decoder",
2903 .item_name = av_default_item_name,
2905 .version = LIBAVUTIL_VERSION_INT,
2908 AVCodec ff_mjpeg_decoder = {
2910 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2911 .type = AVMEDIA_TYPE_VIDEO,
2912 .id = AV_CODEC_ID_MJPEG,
2913 .priv_data_size = sizeof(MJpegDecodeContext),
2914 .init = ff_mjpeg_decode_init,
2915 .close = ff_mjpeg_decode_end,
2916 .receive_frame = ff_mjpeg_receive_frame,
2917 .flush = decode_flush,
2918 .capabilities = AV_CODEC_CAP_DR1,
2920 .priv_class = &mjpegdec_class,
2921 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2922 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2923 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2924 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2925 #if CONFIG_MJPEG_NVDEC_HWACCEL
2926 HWACCEL_NVDEC(mjpeg),
2928 #if CONFIG_MJPEG_VAAPI_HWACCEL
2929 HWACCEL_VAAPI(mjpeg),
2935 #if CONFIG_THP_DECODER
2936 AVCodec ff_thp_decoder = {
2938 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2939 .type = AVMEDIA_TYPE_VIDEO,
2940 .id = AV_CODEC_ID_THP,
2941 .priv_data_size = sizeof(MJpegDecodeContext),
2942 .init = ff_mjpeg_decode_init,
2943 .close = ff_mjpeg_decode_end,
2944 .receive_frame = ff_mjpeg_receive_frame,
2945 .flush = decode_flush,
2946 .capabilities = AV_CODEC_CAP_DR1,
2948 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2949 FF_CODEC_CAP_SETS_PKT_DTS,