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);
561 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
564 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
576 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
578 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
585 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
586 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
589 s->upscale_v[0] = s->upscale_v[1] = 1;
591 if (pix_fmt_id == 0x14111100)
592 s->upscale_v[1] = s->upscale_v[2] = 1;
593 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
596 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
600 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
601 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
604 s->upscale_h[0] = s->upscale_h[1] = 1;
606 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
607 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
608 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
614 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
615 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
616 s->upscale_h[1] = s->upscale_h[2] = 2;
620 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
623 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
629 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
630 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
631 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
632 if (pix_fmt_id == 0x42111100) {
635 s->upscale_h[1] = s->upscale_h[2] = 1;
636 } else if (pix_fmt_id == 0x24111100) {
639 s->upscale_v[1] = s->upscale_v[2] = 1;
640 } else if (pix_fmt_id == 0x23111100) {
643 s->upscale_v[1] = s->upscale_v[2] = 2;
647 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
650 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
654 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
655 memset(s->upscale_h, 0, sizeof(s->upscale_h));
656 memset(s->upscale_v, 0, sizeof(s->upscale_v));
657 return AVERROR_PATCHWELCOME;
659 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
660 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
661 return AVERROR_PATCHWELCOME;
663 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
664 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
665 return AVERROR_PATCHWELCOME;
668 memset(s->upscale_h, 0, sizeof(s->upscale_h));
669 memset(s->upscale_v, 0, sizeof(s->upscale_v));
670 if (s->nb_components == 3) {
671 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
672 } else if (s->nb_components != 1) {
673 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
674 return AVERROR_PATCHWELCOME;
675 } else if (s->palette_index && s->bits <= 8)
676 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
677 else if (s->bits <= 8)
678 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
680 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
683 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
685 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
689 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
690 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
692 enum AVPixelFormat pix_fmts[] = {
693 #if CONFIG_MJPEG_NVDEC_HWACCEL
696 #if CONFIG_MJPEG_VAAPI_HWACCEL
702 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
703 if (s->hwaccel_pix_fmt < 0)
704 return AVERROR(EINVAL);
706 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
707 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
710 if (s->avctx->skip_frame == AVDISCARD_ALL) {
711 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
712 s->picture_ptr->key_frame = 1;
717 av_frame_unref(s->picture_ptr);
718 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
720 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
721 s->picture_ptr->key_frame = 1;
724 for (i = 0; i < 4; i++)
725 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
727 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
728 s->width, s->height, s->linesize[0], s->linesize[1],
729 s->interlaced, s->avctx->height);
733 if ((s->rgb && !s->lossless && !s->ls) ||
734 (!s->rgb && s->ls && s->nb_components > 1) ||
735 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
737 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
738 return AVERROR_PATCHWELCOME;
741 /* totally blank picture as progressive JPEG will only add details to it */
742 if (s->progressive) {
743 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
744 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
745 for (i = 0; i < s->nb_components; i++) {
746 int size = bw * bh * s->h_count[i] * s->v_count[i];
747 av_freep(&s->blocks[i]);
748 av_freep(&s->last_nnz[i]);
749 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
750 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
751 if (!s->blocks[i] || !s->last_nnz[i])
752 return AVERROR(ENOMEM);
753 s->block_stride[i] = bw * s->h_count[i];
755 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
758 if (s->avctx->hwaccel) {
759 s->hwaccel_picture_private =
760 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
761 if (!s->hwaccel_picture_private)
762 return AVERROR(ENOMEM);
764 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
765 s->raw_image_buffer_size);
773 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
776 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
777 if (code < 0 || code > 16) {
778 av_log(s->avctx, AV_LOG_WARNING,
779 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
780 0, dc_index, &s->vlcs[0][dc_index]);
785 return get_xbits(&s->gb, code);
790 /* decode block and dequantize */
791 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
792 int dc_index, int ac_index, uint16_t *quant_matrix)
794 int code, i, j, level, val;
797 val = mjpeg_decode_dc(s, dc_index);
798 if (val == 0xfffff) {
799 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
800 return AVERROR_INVALIDDATA;
802 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
803 val = av_clip_int16(val);
804 s->last_dc[component] = val;
808 {OPEN_READER(re, &s->gb);
810 UPDATE_CACHE(re, &s->gb);
811 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
813 i += ((unsigned)code) >> 4;
816 if (code > MIN_CACHE_BITS - 16)
817 UPDATE_CACHE(re, &s->gb);
820 int cache = GET_CACHE(re, &s->gb);
821 int sign = (~cache) >> 31;
822 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
825 LAST_SKIP_BITS(re, &s->gb, code);
828 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
829 return AVERROR_INVALIDDATA;
831 j = s->scantable.permutated[i];
832 block[j] = level * quant_matrix[i];
835 CLOSE_READER(re, &s->gb);}
840 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
841 int component, int dc_index,
842 uint16_t *quant_matrix, int Al)
845 s->bdsp.clear_block(block);
846 val = mjpeg_decode_dc(s, dc_index);
847 if (val == 0xfffff) {
848 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
849 return AVERROR_INVALIDDATA;
851 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
852 s->last_dc[component] = val;
857 /* decode block and dequantize - progressive JPEG version */
858 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
859 uint8_t *last_nnz, int ac_index,
860 uint16_t *quant_matrix,
861 int ss, int se, int Al, int *EOBRUN)
863 int code, i, j, val, run;
872 OPEN_READER(re, &s->gb);
873 for (i = ss; ; i++) {
874 UPDATE_CACHE(re, &s->gb);
875 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
877 run = ((unsigned) code) >> 4;
881 if (code > MIN_CACHE_BITS - 16)
882 UPDATE_CACHE(re, &s->gb);
885 int cache = GET_CACHE(re, &s->gb);
886 int sign = (~cache) >> 31;
887 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
890 LAST_SKIP_BITS(re, &s->gb, code);
894 j = s->scantable.permutated[se];
895 block[j] = level * (quant_matrix[se] << Al);
898 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
899 return AVERROR_INVALIDDATA;
901 j = s->scantable.permutated[i];
902 block[j] = level * (quant_matrix[i] << Al);
904 if (run == 0xF) {// ZRL - skip 15 coefficients
907 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
908 return AVERROR_INVALIDDATA;
913 UPDATE_CACHE(re, &s->gb);
914 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
915 LAST_SKIP_BITS(re, &s->gb, run);
922 CLOSE_READER(re, &s->gb);
931 #define REFINE_BIT(j) { \
932 UPDATE_CACHE(re, &s->gb); \
933 sign = block[j] >> 15; \
934 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
935 ((quant_matrix[i] ^ sign) - sign) << Al; \
936 LAST_SKIP_BITS(re, &s->gb, 1); \
944 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
949 j = s->scantable.permutated[i]; \
952 else if (run-- == 0) \
956 /* decode block and dequantize - progressive JPEG refinement pass */
957 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
959 int ac_index, uint16_t *quant_matrix,
960 int ss, int se, int Al, int *EOBRUN)
962 int code, i = ss, j, sign, val, run;
963 int last = FFMIN(se, *last_nnz);
965 OPEN_READER(re, &s->gb);
970 UPDATE_CACHE(re, &s->gb);
971 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
974 run = ((unsigned) code) >> 4;
975 UPDATE_CACHE(re, &s->gb);
976 val = SHOW_UBITS(re, &s->gb, 1);
977 LAST_SKIP_BITS(re, &s->gb, 1);
979 j = s->scantable.permutated[i];
981 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
985 CLOSE_READER(re, &s->gb);
989 run = ((unsigned) code) >> 4;
996 UPDATE_CACHE(re, &s->gb);
997 run += SHOW_UBITS(re, &s->gb, val);
998 LAST_SKIP_BITS(re, &s->gb, val);
1010 for (; i <= last; i++) {
1011 j = s->scantable.permutated[i];
1015 CLOSE_READER(re, &s->gb);
1022 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1027 if (s->restart_interval) {
1029 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1030 align_get_bits(&s->gb);
1031 for (i = 0; i < nb_components; i++) /* reset dc */
1032 s->last_dc[i] = (4 << s->bits);
1035 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1037 if (s->restart_count == 0) {
1038 if( show_bits(&s->gb, i) == (1 << i) - 1
1039 || show_bits(&s->gb, i) == 0xFF) {
1040 int pos = get_bits_count(&s->gb);
1041 align_get_bits(&s->gb);
1042 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1043 skip_bits(&s->gb, 8);
1044 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1045 for (i = 0; i < nb_components; i++) /* reset dc */
1046 s->last_dc[i] = (4 << s->bits);
1049 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1056 /* Handles 1 to 4 components */
1057 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1061 uint16_t (*buffer)[4];
1062 int left[4], top[4], topleft[4];
1063 const int linesize = s->linesize[0];
1064 const int mask = ((1 << s->bits) - 1) << point_transform;
1065 int resync_mb_y = 0;
1066 int resync_mb_x = 0;
1069 if (!s->bayer && s->nb_components < 3)
1070 return AVERROR_INVALIDDATA;
1071 if (s->bayer && s->nb_components > 2)
1072 return AVERROR_INVALIDDATA;
1073 if (s->nb_components <= 0 || s->nb_components > 4)
1074 return AVERROR_INVALIDDATA;
1075 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1076 return AVERROR_INVALIDDATA;
1079 s->restart_count = s->restart_interval;
1081 if (s->restart_interval == 0)
1082 s->restart_interval = INT_MAX;
1085 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1087 width = s->mb_width;
1089 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1090 if (!s->ljpeg_buffer)
1091 return AVERROR(ENOMEM);
1093 buffer = s->ljpeg_buffer;
1095 for (i = 0; i < 4; i++)
1096 buffer[0][i] = 1 << (s->bits - 1);
1098 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1099 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1101 if (s->interlaced && s->bottom_field)
1102 ptr += linesize >> 1;
1104 for (i = 0; i < 4; i++)
1105 top[i] = left[i] = topleft[i] = buffer[0][i];
1107 if ((mb_y * s->width) % s->restart_interval == 0) {
1108 for (i = 0; i < 6; i++)
1109 vpred[i] = 1 << (s->bits-1);
1112 for (mb_x = 0; mb_x < width; mb_x++) {
1113 int modified_predictor = predictor;
1115 if (get_bits_left(&s->gb) < 1) {
1116 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1117 return AVERROR_INVALIDDATA;
1120 if (s->restart_interval && !s->restart_count){
1121 s->restart_count = s->restart_interval;
1125 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1127 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1128 modified_predictor = 1;
1130 for (i=0;i<nb_components;i++) {
1133 topleft[i] = top[i];
1134 top[i] = buffer[mb_x][i];
1136 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1140 if (!s->bayer || mb_x) {
1142 } else { /* This path runs only for the first line in bayer images */
1144 pred = vpred[i] - dc;
1147 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1149 left[i] = buffer[mb_x][i] =
1150 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1153 if (s->restart_interval && !--s->restart_count) {
1154 align_get_bits(&s->gb);
1155 skip_bits(&s->gb, 16); /* skip RSTn */
1158 if (s->rct && s->nb_components == 4) {
1159 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1160 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1161 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1162 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1163 ptr[4*mb_x + 0] = buffer[mb_x][3];
1165 } else if (s->nb_components == 4) {
1166 for(i=0; i<nb_components; i++) {
1167 int c= s->comp_index[i];
1169 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1170 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1172 } else if(s->bits == 9) {
1173 return AVERROR_PATCHWELCOME;
1175 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1176 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1180 } else if (s->rct) {
1181 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1182 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1183 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1184 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1186 } else if (s->pegasus_rct) {
1187 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1188 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1189 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1190 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1192 } else if (s->bayer) {
1193 if (nb_components == 1) {
1194 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1195 for (mb_x = 0; mb_x < width; mb_x++)
1196 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1197 } else if (nb_components == 2) {
1198 for (mb_x = 0; mb_x < width; mb_x++) {
1199 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1200 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1204 for(i=0; i<nb_components; i++) {
1205 int c= s->comp_index[i];
1207 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1208 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1210 } else if(s->bits == 9) {
1211 return AVERROR_PATCHWELCOME;
1213 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1214 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1223 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1224 int point_transform, int nb_components)
1226 int i, mb_x, mb_y, mask;
1227 int bits= (s->bits+7)&~7;
1228 int resync_mb_y = 0;
1229 int resync_mb_x = 0;
1231 point_transform += bits - s->bits;
1232 mask = ((1 << s->bits) - 1) << point_transform;
1234 av_assert0(nb_components>=1 && nb_components<=4);
1236 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1237 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1238 if (get_bits_left(&s->gb) < 1) {
1239 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1240 return AVERROR_INVALIDDATA;
1242 if (s->restart_interval && !s->restart_count){
1243 s->restart_count = s->restart_interval;
1248 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1249 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1250 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1251 for (i = 0; i < nb_components; i++) {
1254 int n, h, v, x, y, c, j, linesize;
1255 n = s->nb_blocks[i];
1256 c = s->comp_index[i];
1261 linesize= s->linesize[c];
1263 if(bits>8) linesize /= 2;
1265 for(j=0; j<n; j++) {
1268 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1271 if ( h * mb_x + x >= s->width
1272 || v * mb_y + y >= s->height) {
1274 } else if (bits<=8) {
1275 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1277 if(x==0 && leftcol){
1278 pred= 1 << (bits - 1);
1283 if(x==0 && leftcol){
1284 pred= ptr[-linesize];
1286 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1290 if (s->interlaced && s->bottom_field)
1291 ptr += linesize >> 1;
1293 *ptr= pred + ((unsigned)dc << point_transform);
1295 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1297 if(x==0 && leftcol){
1298 pred= 1 << (bits - 1);
1303 if(x==0 && leftcol){
1304 pred= ptr16[-linesize];
1306 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1310 if (s->interlaced && s->bottom_field)
1311 ptr16 += linesize >> 1;
1313 *ptr16= pred + ((unsigned)dc << point_transform);
1322 for (i = 0; i < nb_components; i++) {
1325 int n, h, v, x, y, c, j, linesize, dc;
1326 n = s->nb_blocks[i];
1327 c = s->comp_index[i];
1332 linesize = s->linesize[c];
1334 if(bits>8) linesize /= 2;
1336 for (j = 0; j < n; j++) {
1339 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1342 if ( h * mb_x + x >= s->width
1343 || v * mb_y + y >= s->height) {
1345 } else if (bits<=8) {
1346 ptr = s->picture_ptr->data[c] +
1347 (linesize * (v * mb_y + y)) +
1348 (h * mb_x + x); //FIXME optimize this crap
1349 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1352 *ptr = pred + ((unsigned)dc << point_transform);
1354 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1355 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1358 *ptr16= pred + ((unsigned)dc << point_transform);
1368 if (s->restart_interval && !--s->restart_count) {
1369 align_get_bits(&s->gb);
1370 skip_bits(&s->gb, 16); /* skip RSTn */
1377 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1378 uint8_t *dst, const uint8_t *src,
1379 int linesize, int lowres)
1382 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1384 case 1: copy_block4(dst, src, linesize, linesize, 4);
1386 case 2: copy_block2(dst, src, linesize, linesize, 2);
1388 case 3: *dst = *src;
1393 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1395 int block_x, block_y;
1396 int size = 8 >> s->avctx->lowres;
1398 for (block_y=0; block_y<size; block_y++)
1399 for (block_x=0; block_x<size; block_x++)
1400 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1402 for (block_y=0; block_y<size; block_y++)
1403 for (block_x=0; block_x<size; block_x++)
1404 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1408 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1409 int Al, const uint8_t *mb_bitmask,
1410 int mb_bitmask_size,
1411 const AVFrame *reference)
1413 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1414 uint8_t *data[MAX_COMPONENTS];
1415 const uint8_t *reference_data[MAX_COMPONENTS];
1416 int linesize[MAX_COMPONENTS];
1417 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1418 int bytes_per_pixel = 1 + (s->bits > 8);
1421 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1422 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1423 return AVERROR_INVALIDDATA;
1425 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1428 s->restart_count = 0;
1430 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1432 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1433 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1435 for (i = 0; i < nb_components; i++) {
1436 int c = s->comp_index[i];
1437 data[c] = s->picture_ptr->data[c];
1438 reference_data[c] = reference ? reference->data[c] : NULL;
1439 linesize[c] = s->linesize[c];
1440 s->coefs_finished[c] |= 1;
1443 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1444 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1445 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1447 if (s->restart_interval && !s->restart_count)
1448 s->restart_count = s->restart_interval;
1450 if (get_bits_left(&s->gb) < 0) {
1451 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1452 -get_bits_left(&s->gb));
1453 return AVERROR_INVALIDDATA;
1455 for (i = 0; i < nb_components; i++) {
1457 int n, h, v, x, y, c, j;
1459 n = s->nb_blocks[i];
1460 c = s->comp_index[i];
1465 for (j = 0; j < n; j++) {
1466 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1467 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1469 if (s->interlaced && s->bottom_field)
1470 block_offset += linesize[c] >> 1;
1471 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1472 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1473 ptr = data[c] + block_offset;
1476 if (!s->progressive) {
1479 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1480 linesize[c], s->avctx->lowres);
1483 s->bdsp.clear_block(s->block);
1484 if (decode_block(s, s->block, i,
1485 s->dc_index[i], s->ac_index[i],
1486 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1487 av_log(s->avctx, AV_LOG_ERROR,
1488 "error y=%d x=%d\n", mb_y, mb_x);
1489 return AVERROR_INVALIDDATA;
1492 s->idsp.idct_put(ptr, linesize[c], s->block);
1494 shift_output(s, ptr, linesize[c]);
1498 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1500 int16_t *block = s->blocks[c][block_idx];
1502 block[0] += get_bits1(&s->gb) *
1503 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1504 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1505 s->quant_matrixes[s->quant_sindex[i]],
1507 av_log(s->avctx, AV_LOG_ERROR,
1508 "error y=%d x=%d\n", mb_y, mb_x);
1509 return AVERROR_INVALIDDATA;
1512 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1513 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1514 mb_x, mb_y, x, y, c, s->bottom_field,
1515 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1523 handle_rstn(s, nb_components);
1529 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1530 int se, int Ah, int Al)
1534 int c = s->comp_index[0];
1535 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1537 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1538 if (se < ss || se > 63) {
1539 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1540 return AVERROR_INVALIDDATA;
1543 // s->coefs_finished is a bitmask for coefficients coded
1544 // ss and se are parameters telling start and end coefficients
1545 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1547 s->restart_count = 0;
1549 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1550 int block_idx = mb_y * s->block_stride[c];
1551 int16_t (*block)[64] = &s->blocks[c][block_idx];
1552 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1553 if (get_bits_left(&s->gb) <= 0) {
1554 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1555 return AVERROR_INVALIDDATA;
1557 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1559 if (s->restart_interval && !s->restart_count)
1560 s->restart_count = s->restart_interval;
1563 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1564 quant_matrix, ss, se, Al, &EOBRUN);
1566 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1567 quant_matrix, ss, se, Al, &EOBRUN);
1569 av_log(s->avctx, AV_LOG_ERROR,
1570 "error y=%d x=%d\n", mb_y, mb_x);
1571 return AVERROR_INVALIDDATA;
1574 if (handle_rstn(s, 0))
1581 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1585 const int bytes_per_pixel = 1 + (s->bits > 8);
1586 const int block_size = s->lossless ? 1 : 8;
1588 for (c = 0; c < s->nb_components; c++) {
1589 uint8_t *data = s->picture_ptr->data[c];
1590 int linesize = s->linesize[c];
1591 int h = s->h_max / s->h_count[c];
1592 int v = s->v_max / s->v_count[c];
1593 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1594 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1596 if (~s->coefs_finished[c])
1597 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1599 if (s->interlaced && s->bottom_field)
1600 data += linesize >> 1;
1602 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1603 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1604 int block_idx = mb_y * s->block_stride[c];
1605 int16_t (*block)[64] = &s->blocks[c][block_idx];
1606 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1607 s->idsp.idct_put(ptr, linesize, *block);
1609 shift_output(s, ptr, linesize);
1610 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1616 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1617 int mb_bitmask_size, const AVFrame *reference)
1619 int len, nb_components, i, h, v, predictor, point_transform;
1621 const int block_size = s->lossless ? 1 : 8;
1622 int ilv, prev_shift;
1624 if (!s->got_picture) {
1625 av_log(s->avctx, AV_LOG_WARNING,
1626 "Can not process SOS before SOF, skipping\n");
1631 if (reference->width != s->picture_ptr->width ||
1632 reference->height != s->picture_ptr->height ||
1633 reference->format != s->picture_ptr->format) {
1634 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1635 return AVERROR_INVALIDDATA;
1639 /* XXX: verify len field validity */
1640 len = get_bits(&s->gb, 16);
1641 nb_components = get_bits(&s->gb, 8);
1642 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1643 avpriv_report_missing_feature(s->avctx,
1644 "decode_sos: nb_components (%d)",
1646 return AVERROR_PATCHWELCOME;
1648 if (len != 6 + 2 * nb_components) {
1649 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1650 return AVERROR_INVALIDDATA;
1652 for (i = 0; i < nb_components; i++) {
1653 id = get_bits(&s->gb, 8) - 1;
1654 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1655 /* find component index */
1656 for (index = 0; index < s->nb_components; index++)
1657 if (id == s->component_id[index])
1659 if (index == s->nb_components) {
1660 av_log(s->avctx, AV_LOG_ERROR,
1661 "decode_sos: index(%d) out of components\n", index);
1662 return AVERROR_INVALIDDATA;
1664 /* Metasoft MJPEG codec has Cb and Cr swapped */
1665 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1666 && nb_components == 3 && s->nb_components == 3 && i)
1669 s->quant_sindex[i] = s->quant_index[index];
1670 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1671 s->h_scount[i] = s->h_count[index];
1672 s->v_scount[i] = s->v_count[index];
1674 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1675 index = (index+2)%3;
1677 s->comp_index[i] = index;
1679 s->dc_index[i] = get_bits(&s->gb, 4);
1680 s->ac_index[i] = get_bits(&s->gb, 4);
1682 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1683 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1685 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))
1689 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1690 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1691 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1692 prev_shift = get_bits(&s->gb, 4); /* Ah */
1693 point_transform = get_bits(&s->gb, 4); /* Al */
1695 prev_shift = point_transform = 0;
1697 if (nb_components > 1) {
1698 /* interleaved stream */
1699 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1700 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1701 } else if (!s->ls) { /* skip this for JPEG-LS */
1702 h = s->h_max / s->h_scount[0];
1703 v = s->v_max / s->v_scount[0];
1704 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1705 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1706 s->nb_blocks[0] = 1;
1711 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1712 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1713 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1714 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1715 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1718 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1719 for (i = s->mjpb_skiptosod; i > 0; i--)
1720 skip_bits(&s->gb, 8);
1723 for (i = 0; i < nb_components; i++)
1724 s->last_dc[i] = (4 << s->bits);
1726 if (s->avctx->hwaccel) {
1727 int bytes_to_start = get_bits_count(&s->gb) / 8;
1728 av_assert0(bytes_to_start >= 0 &&
1729 s->raw_scan_buffer_size >= bytes_to_start);
1731 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1732 s->raw_scan_buffer + bytes_to_start,
1733 s->raw_scan_buffer_size - bytes_to_start);
1737 } else if (s->lossless) {
1738 av_assert0(s->picture_ptr == s->picture);
1739 if (CONFIG_JPEGLS_DECODER && s->ls) {
1741 // reset_ls_coding_parameters(s, 0);
1743 if ((ret = ff_jpegls_decode_picture(s, predictor,
1744 point_transform, ilv)) < 0)
1747 if (s->rgb || s->bayer) {
1748 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1751 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1753 nb_components)) < 0)
1758 if (s->progressive && predictor) {
1759 av_assert0(s->picture_ptr == s->picture);
1760 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1762 point_transform)) < 0)
1765 if ((ret = mjpeg_decode_scan(s, nb_components,
1766 prev_shift, point_transform,
1767 mb_bitmask, mb_bitmask_size, reference)) < 0)
1772 if (s->interlaced &&
1773 get_bits_left(&s->gb) > 32 &&
1774 show_bits(&s->gb, 8) == 0xFF) {
1775 GetBitContext bak = s->gb;
1776 align_get_bits(&bak);
1777 if (show_bits(&bak, 16) == 0xFFD1) {
1778 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1780 skip_bits(&s->gb, 16);
1781 s->bottom_field ^= 1;
1790 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1791 return AVERROR_INVALIDDATA;
1794 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1796 if (get_bits(&s->gb, 16) != 4)
1797 return AVERROR_INVALIDDATA;
1798 s->restart_interval = get_bits(&s->gb, 16);
1799 s->restart_count = 0;
1800 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1801 s->restart_interval);
1806 static int mjpeg_decode_app(MJpegDecodeContext *s)
1810 len = get_bits(&s->gb, 16);
1813 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1814 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1815 skip_bits(&s->gb, len);
1818 return AVERROR_INVALIDDATA;
1820 if (8 * len > get_bits_left(&s->gb))
1821 return AVERROR_INVALIDDATA;
1823 id = get_bits_long(&s->gb, 32);
1826 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1827 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1828 av_fourcc2str(av_bswap32(id)), id, len);
1830 /* Buggy AVID, it puts EOI only at every 10th frame. */
1831 /* Also, this fourcc is used by non-avid files too, it holds some
1832 information, but it's always present in AVID-created files. */
1833 if (id == AV_RB32("AVI1")) {
1839 4bytes field_size_less_padding
1842 i = get_bits(&s->gb, 8); len--;
1843 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1847 if (id == AV_RB32("JFIF")) {
1848 int t_w, t_h, v1, v2;
1851 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1852 v1 = get_bits(&s->gb, 8);
1853 v2 = get_bits(&s->gb, 8);
1854 skip_bits(&s->gb, 8);
1856 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1857 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1858 if ( s->avctx->sample_aspect_ratio.num <= 0
1859 || s->avctx->sample_aspect_ratio.den <= 0) {
1860 s->avctx->sample_aspect_ratio.num = 0;
1861 s->avctx->sample_aspect_ratio.den = 1;
1864 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1865 av_log(s->avctx, AV_LOG_INFO,
1866 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1868 s->avctx->sample_aspect_ratio.num,
1869 s->avctx->sample_aspect_ratio.den);
1873 t_w = get_bits(&s->gb, 8);
1874 t_h = get_bits(&s->gb, 8);
1876 /* skip thumbnail */
1877 if (len -10 - (t_w * t_h * 3) > 0)
1878 len -= t_w * t_h * 3;
1885 if ( id == AV_RB32("Adob")
1887 && show_bits(&s->gb, 8) == 'e'
1888 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1889 skip_bits(&s->gb, 8); /* 'e' */
1890 skip_bits(&s->gb, 16); /* version */
1891 skip_bits(&s->gb, 16); /* flags0 */
1892 skip_bits(&s->gb, 16); /* flags1 */
1893 s->adobe_transform = get_bits(&s->gb, 8);
1894 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1895 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1900 if (id == AV_RB32("LJIF")) {
1902 int pegasus_rct = s->pegasus_rct;
1903 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1904 av_log(s->avctx, AV_LOG_INFO,
1905 "Pegasus lossless jpeg header found\n");
1906 skip_bits(&s->gb, 16); /* version ? */
1907 skip_bits(&s->gb, 16); /* unknown always 0? */
1908 skip_bits(&s->gb, 16); /* unknown always 0? */
1909 skip_bits(&s->gb, 16); /* unknown always 0? */
1910 switch (i=get_bits(&s->gb, 8)) {
1920 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1925 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1926 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1931 s->pegasus_rct = pegasus_rct;
1935 if (id == AV_RL32("colr") && len > 0) {
1936 s->colr = get_bits(&s->gb, 8);
1937 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1938 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1942 if (id == AV_RL32("xfrm") && len > 0) {
1943 s->xfrm = get_bits(&s->gb, 8);
1944 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1945 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1950 /* JPS extension by VRex */
1951 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1952 int flags, layout, type;
1953 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1954 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1956 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1957 skip_bits(&s->gb, 16); len -= 2; /* block length */
1958 skip_bits(&s->gb, 8); /* reserved */
1959 flags = get_bits(&s->gb, 8);
1960 layout = get_bits(&s->gb, 8);
1961 type = get_bits(&s->gb, 8);
1964 av_freep(&s->stereo3d);
1965 s->stereo3d = av_stereo3d_alloc();
1970 s->stereo3d->type = AV_STEREO3D_2D;
1971 } else if (type == 1) {
1974 s->stereo3d->type = AV_STEREO3D_LINES;
1977 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1980 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1983 if (!(flags & 0x04)) {
1984 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1991 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1992 GetByteContext gbytes;
1993 int ret, le, ifd_offset, bytes_read;
1994 const uint8_t *aligned;
1996 skip_bits(&s->gb, 16); // skip padding
1999 // init byte wise reading
2000 aligned = align_get_bits(&s->gb);
2001 bytestream2_init(&gbytes, aligned, len);
2004 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2006 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2008 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2010 // read 0th IFD and store the metadata
2011 // (return values > 0 indicate the presence of subimage metadata)
2012 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2014 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2018 bytes_read = bytestream2_tell(&gbytes);
2019 skip_bits(&s->gb, bytes_read << 3);
2026 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2027 id = get_bits_long(&s->gb, 32);
2030 if (id == AV_RB32("mjpg")) {
2033 4bytes pad field size
2041 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2042 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2046 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2049 unsigned nummarkers;
2051 id = get_bits_long(&s->gb, 32);
2052 id2 = get_bits(&s->gb, 24);
2054 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2055 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2059 skip_bits(&s->gb, 8);
2060 seqno = get_bits(&s->gb, 8);
2063 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2067 nummarkers = get_bits(&s->gb, 8);
2069 if (nummarkers == 0) {
2070 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2072 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2073 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2075 } else if (seqno > nummarkers) {
2076 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2080 /* Allocate if this is the first APP2 we've seen. */
2081 if (s->iccnum == 0) {
2082 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2083 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2084 if (!s->iccdata || !s->iccdatalens) {
2085 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2086 return AVERROR(ENOMEM);
2088 s->iccnum = nummarkers;
2091 if (s->iccdata[seqno - 1]) {
2092 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2096 s->iccdatalens[seqno - 1] = len;
2097 s->iccdata[seqno - 1] = av_malloc(len);
2098 if (!s->iccdata[seqno - 1]) {
2099 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2100 return AVERROR(ENOMEM);
2103 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2104 skip_bits(&s->gb, len << 3);
2108 if (s->iccread > s->iccnum)
2109 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2113 /* slow but needed for extreme adobe jpegs */
2115 av_log(s->avctx, AV_LOG_ERROR,
2116 "mjpeg: error, decode_app parser read over the end\n");
2118 skip_bits(&s->gb, 8);
2123 static int mjpeg_decode_com(MJpegDecodeContext *s)
2125 int len = get_bits(&s->gb, 16);
2126 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2128 char *cbuf = av_malloc(len - 1);
2130 return AVERROR(ENOMEM);
2132 for (i = 0; i < len - 2; i++)
2133 cbuf[i] = get_bits(&s->gb, 8);
2134 if (i > 0 && cbuf[i - 1] == '\n')
2139 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2140 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2142 /* buggy avid, it puts EOI only at every 10th frame */
2143 if (!strncmp(cbuf, "AVID", 4)) {
2144 parse_avid(s, cbuf, len);
2145 } else if (!strcmp(cbuf, "CS=ITU601"))
2147 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2148 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2150 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2151 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2161 /* return the 8 bit start code value and update the search
2162 state. Return -1 if no start code found */
2163 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2165 const uint8_t *buf_ptr;
2170 buf_ptr = *pbuf_ptr;
2171 while (buf_end - buf_ptr > 1) {
2174 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2183 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2184 *pbuf_ptr = buf_ptr;
2188 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2189 const uint8_t **buf_ptr, const uint8_t *buf_end,
2190 const uint8_t **unescaped_buf_ptr,
2191 int *unescaped_buf_size)
2194 start_code = find_marker(buf_ptr, buf_end);
2196 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2198 return AVERROR(ENOMEM);
2200 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2201 if (start_code == SOS && !s->ls) {
2202 const uint8_t *src = *buf_ptr;
2203 const uint8_t *ptr = src;
2204 uint8_t *dst = s->buffer;
2206 #define copy_data_segment(skip) do { \
2207 ptrdiff_t length = (ptr - src) - (skip); \
2209 memcpy(dst, src, length); \
2215 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2217 copy_data_segment(0);
2219 while (ptr < buf_end) {
2220 uint8_t x = *(ptr++);
2224 while (ptr < buf_end && x == 0xff) {
2229 /* 0xFF, 0xFF, ... */
2231 copy_data_segment(skip);
2233 /* decrement src as it is equal to ptr after the
2234 * copy_data_segment macro and we might want to
2235 * copy the current value of x later on */
2239 if (x < RST0 || x > RST7) {
2240 copy_data_segment(1);
2247 copy_data_segment(0);
2249 #undef copy_data_segment
2251 *unescaped_buf_ptr = s->buffer;
2252 *unescaped_buf_size = dst - s->buffer;
2253 memset(s->buffer + *unescaped_buf_size, 0,
2254 AV_INPUT_BUFFER_PADDING_SIZE);
2256 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2257 (buf_end - *buf_ptr) - (dst - s->buffer));
2258 } else if (start_code == SOS && s->ls) {
2259 const uint8_t *src = *buf_ptr;
2260 uint8_t *dst = s->buffer;
2266 while (src + t < buf_end) {
2267 uint8_t x = src[t++];
2269 while ((src + t < buf_end) && x == 0xff)
2278 init_put_bits(&pb, dst, t);
2280 /* unescape bitstream */
2282 uint8_t x = src[b++];
2283 put_bits(&pb, 8, x);
2284 if (x == 0xFF && b < t) {
2287 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2290 put_bits(&pb, 7, x);
2294 flush_put_bits(&pb);
2296 *unescaped_buf_ptr = dst;
2297 *unescaped_buf_size = (bit_count + 7) >> 3;
2298 memset(s->buffer + *unescaped_buf_size, 0,
2299 AV_INPUT_BUFFER_PADDING_SIZE);
2301 *unescaped_buf_ptr = *buf_ptr;
2302 *unescaped_buf_size = buf_end - *buf_ptr;
2308 static void reset_icc_profile(MJpegDecodeContext *s)
2313 for (i = 0; i < s->iccnum; i++)
2314 av_freep(&s->iccdata[i]);
2315 av_freep(&s->iccdata);
2316 av_freep(&s->iccdatalens);
2322 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2325 AVFrame *frame = data;
2326 const uint8_t *buf = avpkt->data;
2327 int buf_size = avpkt->size;
2328 MJpegDecodeContext *s = avctx->priv_data;
2329 const uint8_t *buf_end, *buf_ptr;
2330 const uint8_t *unescaped_buf_ptr;
2332 int unescaped_buf_size;
2338 s->buf_size = buf_size;
2340 av_dict_free(&s->exif_metadata);
2341 av_freep(&s->stereo3d);
2342 s->adobe_transform = -1;
2345 reset_icc_profile(s);
2348 buf_end = buf + buf_size;
2349 while (buf_ptr < buf_end) {
2350 /* find start next marker */
2351 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2353 &unescaped_buf_size);
2355 if (start_code < 0) {
2357 } else if (unescaped_buf_size > INT_MAX / 8) {
2358 av_log(avctx, AV_LOG_ERROR,
2359 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2360 start_code, unescaped_buf_size, buf_size);
2361 return AVERROR_INVALIDDATA;
2363 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2364 start_code, buf_end - buf_ptr);
2366 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2369 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2373 s->start_code = start_code;
2374 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2375 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2377 /* process markers */
2378 if (start_code >= RST0 && start_code <= RST7) {
2379 av_log(avctx, AV_LOG_DEBUG,
2380 "restart marker: %d\n", start_code & 0x0f);
2382 } else if (start_code >= APP0 && start_code <= APP15) {
2383 if ((ret = mjpeg_decode_app(s)) < 0)
2384 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2387 } else if (start_code == COM) {
2388 ret = mjpeg_decode_com(s);
2391 } else if (start_code == DQT) {
2392 ret = ff_mjpeg_decode_dqt(s);
2399 if (!CONFIG_JPEGLS_DECODER &&
2400 (start_code == SOF48 || start_code == LSE)) {
2401 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2402 return AVERROR(ENOSYS);
2405 if (avctx->skip_frame == AVDISCARD_ALL) {
2406 switch(start_code) {
2421 switch (start_code) {
2423 s->restart_interval = 0;
2424 s->restart_count = 0;
2425 s->raw_image_buffer = buf_ptr;
2426 s->raw_image_buffer_size = buf_end - buf_ptr;
2427 /* nothing to do on SOI */
2430 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2431 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2437 if (start_code == SOF0)
2438 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2440 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2444 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2448 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2452 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2456 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2457 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2461 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2465 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2466 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2470 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2474 if (!CONFIG_JPEGLS_DECODER ||
2475 (ret = ff_jpegls_decode_lse(s)) < 0)
2480 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2481 s->progressive && s->cur_scan && s->got_picture)
2482 mjpeg_idct_scan_progressive_ac(s);
2484 if (!s->got_picture) {
2485 av_log(avctx, AV_LOG_WARNING,
2486 "Found EOI before any SOF, ignoring\n");
2489 if (s->interlaced) {
2490 s->bottom_field ^= 1;
2491 /* if not bottom field, do not output image yet */
2492 if (s->bottom_field == !s->interlace_polarity)
2495 if (avctx->skip_frame == AVDISCARD_ALL) {
2497 goto the_end_no_picture;
2499 if (s->avctx->hwaccel) {
2500 ret = s->avctx->hwaccel->end_frame(s->avctx);
2504 av_freep(&s->hwaccel_picture_private);
2506 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2512 int qp = FFMAX3(s->qscale[0],
2515 int qpw = (s->width + 15) / 16;
2516 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2518 memset(qp_table_buf->data, qp, qpw);
2519 av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2522 if(avctx->debug & FF_DEBUG_QP)
2523 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2528 s->raw_scan_buffer = buf_ptr;
2529 s->raw_scan_buffer_size = buf_end - buf_ptr;
2532 if (avctx->skip_frame == AVDISCARD_ALL) {
2533 skip_bits(&s->gb, get_bits_left(&s->gb));
2537 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2538 (avctx->err_recognition & AV_EF_EXPLODE))
2542 if ((ret = mjpeg_decode_dri(s)) < 0)
2555 av_log(avctx, AV_LOG_ERROR,
2556 "mjpeg: unsupported coding type (%x)\n", start_code);
2561 /* eof process start code */
2562 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2563 av_log(avctx, AV_LOG_DEBUG,
2564 "marker parser used %d bytes (%d bits)\n",
2565 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2567 if (s->got_picture && s->cur_scan) {
2568 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2571 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2572 return AVERROR_INVALIDDATA;
2578 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2580 if (AV_RB32(s->upscale_h)) {
2582 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2583 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2584 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2585 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2586 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2587 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2588 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2589 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2590 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2591 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2592 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2593 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2595 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2599 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2600 for (p = 0; p<s->nb_components; p++) {
2601 uint8_t *line = s->picture_ptr->data[p];
2604 if (!s->upscale_h[p])
2607 w = AV_CEIL_RSHIFT(w, hshift);
2608 h = AV_CEIL_RSHIFT(h, vshift);
2610 if (s->upscale_v[p] == 1)
2613 for (i = 0; i < h; i++) {
2614 if (s->upscale_h[p] == 1) {
2615 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2616 else line[w - 1] = line[(w - 1) / 2];
2617 for (index = w - 2; index > 0; index--) {
2619 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2621 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2623 } else if (s->upscale_h[p] == 2) {
2625 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2627 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2629 line[w - 1] = line[(w - 1) / 3];
2631 line[w - 2] = line[w - 1];
2633 for (index = w - 3; index > 0; index--) {
2634 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2637 line += s->linesize[p];
2641 if (AV_RB32(s->upscale_v)) {
2643 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2644 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2645 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2646 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2647 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2648 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2650 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2652 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2653 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2654 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2655 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2657 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2661 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2662 for (p = 0; p < s->nb_components; p++) {
2666 if (!s->upscale_v[p])
2669 w = AV_CEIL_RSHIFT(w, hshift);
2670 h = AV_CEIL_RSHIFT(h, vshift);
2672 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2673 for (i = h - 1; i; i--) {
2674 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2675 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2676 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2677 memcpy(dst, src1, w);
2679 for (index = 0; index < w; index++)
2680 dst[index] = (src1[index] + src2[index]) >> 1;
2682 dst -= s->linesize[p];
2686 if (s->flipped && !s->rgb) {
2688 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2692 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2693 for (index=0; index<s->nb_components; index++) {
2694 uint8_t *dst = s->picture_ptr->data[index];
2695 int w = s->picture_ptr->width;
2696 int h = s->picture_ptr->height;
2697 if(index && index<3){
2698 w = AV_CEIL_RSHIFT(w, hshift);
2699 h = AV_CEIL_RSHIFT(h, vshift);
2702 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2703 for (i=0; i<h/2; i++) {
2705 FFSWAP(int, dst[j], dst2[j]);
2706 dst += s->picture_ptr->linesize[index];
2707 dst2 -= s->picture_ptr->linesize[index];
2712 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2713 int w = s->picture_ptr->width;
2714 int h = s->picture_ptr->height;
2715 av_assert0(s->nb_components == 4);
2716 for (i=0; i<h; i++) {
2719 for (index=0; index<4; index++) {
2720 dst[index] = s->picture_ptr->data[index]
2721 + s->picture_ptr->linesize[index]*i;
2723 for (j=0; j<w; j++) {
2725 int r = dst[0][j] * k;
2726 int g = dst[1][j] * k;
2727 int b = dst[2][j] * k;
2728 dst[0][j] = g*257 >> 16;
2729 dst[1][j] = b*257 >> 16;
2730 dst[2][j] = r*257 >> 16;
2735 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2736 int w = s->picture_ptr->width;
2737 int h = s->picture_ptr->height;
2738 av_assert0(s->nb_components == 4);
2739 for (i=0; i<h; i++) {
2742 for (index=0; index<4; index++) {
2743 dst[index] = s->picture_ptr->data[index]
2744 + s->picture_ptr->linesize[index]*i;
2746 for (j=0; j<w; j++) {
2748 int r = (255 - dst[0][j]) * k;
2749 int g = (128 - dst[1][j]) * k;
2750 int b = (128 - dst[2][j]) * k;
2751 dst[0][j] = r*257 >> 16;
2752 dst[1][j] = (g*257 >> 16) + 128;
2753 dst[2][j] = (b*257 >> 16) + 128;
2760 AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2762 stereo->type = s->stereo3d->type;
2763 stereo->flags = s->stereo3d->flags;
2765 av_freep(&s->stereo3d);
2768 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2769 AVFrameSideData *sd;
2774 /* Sum size of all parts. */
2775 for (i = 0; i < s->iccnum; i++)
2776 total_size += s->iccdatalens[i];
2778 sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2780 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2781 return AVERROR(ENOMEM);
2784 /* Reassemble the parts, which are now in-order. */
2785 for (i = 0; i < s->iccnum; i++) {
2786 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2787 offset += s->iccdatalens[i];
2791 av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2792 av_dict_free(&s->exif_metadata);
2795 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2797 // return buf_end - buf_ptr;
2798 return buf_ptr - buf;
2801 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2803 MJpegDecodeContext *s = avctx->priv_data;
2806 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2807 av_log(avctx, AV_LOG_INFO, "Single field\n");
2811 av_frame_free(&s->picture);
2812 s->picture_ptr = NULL;
2813 } else if (s->picture_ptr)
2814 av_frame_unref(s->picture_ptr);
2816 av_freep(&s->buffer);
2817 av_freep(&s->stereo3d);
2818 av_freep(&s->ljpeg_buffer);
2819 s->ljpeg_buffer_size = 0;
2821 for (i = 0; i < 3; i++) {
2822 for (j = 0; j < 4; j++)
2823 ff_free_vlc(&s->vlcs[i][j]);
2825 for (i = 0; i < MAX_COMPONENTS; i++) {
2826 av_freep(&s->blocks[i]);
2827 av_freep(&s->last_nnz[i]);
2829 av_dict_free(&s->exif_metadata);
2831 reset_icc_profile(s);
2833 av_freep(&s->hwaccel_picture_private);
2838 static void decode_flush(AVCodecContext *avctx)
2840 MJpegDecodeContext *s = avctx->priv_data;
2844 #if CONFIG_MJPEG_DECODER
2845 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2846 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2847 static const AVOption options[] = {
2848 { "extern_huff", "Use external huffman table.",
2849 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2853 static const AVClass mjpegdec_class = {
2854 .class_name = "MJPEG decoder",
2855 .item_name = av_default_item_name,
2857 .version = LIBAVUTIL_VERSION_INT,
2860 AVCodec ff_mjpeg_decoder = {
2862 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2863 .type = AVMEDIA_TYPE_VIDEO,
2864 .id = AV_CODEC_ID_MJPEG,
2865 .priv_data_size = sizeof(MJpegDecodeContext),
2866 .init = ff_mjpeg_decode_init,
2867 .close = ff_mjpeg_decode_end,
2868 .decode = ff_mjpeg_decode_frame,
2869 .flush = decode_flush,
2870 .capabilities = AV_CODEC_CAP_DR1,
2872 .priv_class = &mjpegdec_class,
2873 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2874 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2875 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2876 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2877 #if CONFIG_MJPEG_NVDEC_HWACCEL
2878 HWACCEL_NVDEC(mjpeg),
2880 #if CONFIG_MJPEG_VAAPI_HWACCEL
2881 HWACCEL_VAAPI(mjpeg),
2887 #if CONFIG_THP_DECODER
2888 AVCodec ff_thp_decoder = {
2890 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2891 .type = AVMEDIA_TYPE_VIDEO,
2892 .id = AV_CODEC_ID_THP,
2893 .priv_data_size = sizeof(MJpegDecodeContext),
2894 .init = ff_mjpeg_decode_init,
2895 .close = ff_mjpeg_decode_end,
2896 .decode = ff_mjpeg_decode_frame,
2897 .flush = decode_flush,
2898 .capabilities = AV_CODEC_CAP_DR1,
2900 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,