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 int init_default_huffman_tables(MJpegDecodeContext *s)
60 const uint8_t *values;
63 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
64 avpriv_mjpeg_val_dc, 12 },
65 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
66 avpriv_mjpeg_val_dc, 12 },
67 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
68 avpriv_mjpeg_val_ac_luminance, 162 },
69 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
70 avpriv_mjpeg_val_ac_chrominance, 162 },
71 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
72 avpriv_mjpeg_val_ac_luminance, 162 },
73 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
74 avpriv_mjpeg_val_ac_chrominance, 162 },
78 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
79 ff_free_vlc(&s->vlcs[ht[i].class][ht[i].index]);
80 ret = ff_mjpeg_build_vlc(&s->vlcs[ht[i].class][ht[i].index],
81 ht[i].bits, ht[i].values,
82 ht[i].class == 1, s->avctx);
86 if (ht[i].class < 2) {
87 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
89 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
90 ht[i].values, ht[i].length);
97 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
100 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
101 s->interlace_polarity = 1;
102 if (len > 14 && buf[12] == 2) /* 2 - PAL */
103 s->interlace_polarity = 0;
104 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
105 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
108 static void init_idct(AVCodecContext *avctx)
110 MJpegDecodeContext *s = avctx->priv_data;
112 ff_idctdsp_init(&s->idsp, avctx);
113 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
117 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
119 MJpegDecodeContext *s = avctx->priv_data;
122 if (!s->picture_ptr) {
123 s->picture = av_frame_alloc();
125 return AVERROR(ENOMEM);
126 s->picture_ptr = s->picture;
129 s->pkt = av_packet_alloc();
131 return AVERROR(ENOMEM);
134 ff_blockdsp_init(&s->bdsp, avctx);
135 ff_hpeldsp_init(&s->hdsp, avctx->flags);
140 s->first_picture = 1;
142 s->orig_height = avctx->coded_height;
143 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
144 avctx->colorspace = AVCOL_SPC_BT470BG;
145 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
147 if ((ret = init_default_huffman_tables(s)) < 0)
150 if (s->extern_huff) {
151 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
152 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
154 if (ff_mjpeg_decode_dht(s)) {
155 av_log(avctx, AV_LOG_ERROR,
156 "error using external huffman table, switching back to internal\n");
157 if ((ret = init_default_huffman_tables(s)) < 0)
161 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
162 s->interlace_polarity = 1; /* bottom field first */
163 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
164 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
165 if (avctx->codec_tag == AV_RL32("MJPG"))
166 s->interlace_polarity = 1;
169 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
170 if (avctx->extradata_size >= 4)
171 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
173 if (s->smv_frames_per_jpeg <= 0) {
174 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
175 return AVERROR_INVALIDDATA;
178 s->smv_frame = av_frame_alloc();
180 return AVERROR(ENOMEM);
181 } else if (avctx->extradata_size > 8
182 && AV_RL32(avctx->extradata) == 0x2C
183 && AV_RL32(avctx->extradata+4) == 0x18) {
184 parse_avid(s, avctx->extradata, avctx->extradata_size);
187 if (avctx->codec->id == AV_CODEC_ID_AMV)
194 /* quantize tables */
195 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
199 len = get_bits(&s->gb, 16) - 2;
201 if (8*len > get_bits_left(&s->gb)) {
202 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
203 return AVERROR_INVALIDDATA;
207 int pr = get_bits(&s->gb, 4);
209 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
210 return AVERROR_INVALIDDATA;
212 index = get_bits(&s->gb, 4);
215 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
216 /* read quant table */
217 for (i = 0; i < 64; i++) {
218 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
219 if (s->quant_matrixes[index][i] == 0) {
220 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
221 return AVERROR_INVALIDDATA;
225 // XXX FIXME fine-tune, and perhaps add dc too
226 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
227 s->quant_matrixes[index][8]) >> 1;
228 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
229 index, s->qscale[index]);
230 len -= 1 + 64 * (1+pr);
235 /* decode huffman tables and build VLC decoders */
236 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
238 int len, index, i, class, n, v;
239 uint8_t bits_table[17];
240 uint8_t val_table[256];
243 len = get_bits(&s->gb, 16) - 2;
245 if (8*len > get_bits_left(&s->gb)) {
246 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
247 return AVERROR_INVALIDDATA;
252 return AVERROR_INVALIDDATA;
253 class = get_bits(&s->gb, 4);
255 return AVERROR_INVALIDDATA;
256 index = get_bits(&s->gb, 4);
258 return AVERROR_INVALIDDATA;
260 for (i = 1; i <= 16; i++) {
261 bits_table[i] = get_bits(&s->gb, 8);
265 if (len < n || n > 256)
266 return AVERROR_INVALIDDATA;
268 for (i = 0; i < n; i++) {
269 v = get_bits(&s->gb, 8);
274 /* build VLC and flush previous vlc if present */
275 ff_free_vlc(&s->vlcs[class][index]);
276 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
278 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table,
279 val_table, class > 0, s->avctx)) < 0)
283 ff_free_vlc(&s->vlcs[2][index]);
284 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table,
285 val_table, 0, s->avctx)) < 0)
289 for (i = 0; i < 16; i++)
290 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
291 for (i = 0; i < 256; i++)
292 s->raw_huffman_values[class][index][i] = val_table[i];
297 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
299 int len, nb_components, i, width, height, bits, ret, size_change;
301 int h_count[MAX_COMPONENTS] = { 0 };
302 int v_count[MAX_COMPONENTS] = { 0 };
305 memset(s->upscale_h, 0, sizeof(s->upscale_h));
306 memset(s->upscale_v, 0, sizeof(s->upscale_v));
308 len = get_bits(&s->gb, 16);
309 bits = get_bits(&s->gb, 8);
311 if (bits > 16 || bits < 1) {
312 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
313 return AVERROR_INVALIDDATA;
316 if (s->avctx->bits_per_raw_sample != bits) {
317 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);
318 s->avctx->bits_per_raw_sample = bits;
323 if (bits == 9 && !s->pegasus_rct)
324 s->rct = 1; // FIXME ugly
326 if(s->lossless && s->avctx->lowres){
327 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
331 height = get_bits(&s->gb, 16);
332 width = get_bits(&s->gb, 16);
334 // HACK for odd_height.mov
335 if (s->interlaced && s->width == width && s->height == height + 1)
338 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
339 if (av_image_check_size(width, height, 0, s->avctx) < 0)
340 return AVERROR_INVALIDDATA;
341 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
342 return AVERROR_INVALIDDATA;
344 nb_components = get_bits(&s->gb, 8);
345 if (nb_components <= 0 ||
346 nb_components > MAX_COMPONENTS)
348 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
349 if (nb_components != s->nb_components) {
350 av_log(s->avctx, AV_LOG_ERROR,
351 "nb_components changing in interlaced picture\n");
352 return AVERROR_INVALIDDATA;
355 if (s->ls && !(bits <= 8 || nb_components == 1)) {
356 avpriv_report_missing_feature(s->avctx,
357 "JPEG-LS that is not <= 8 "
358 "bits/component or 16-bit gray");
359 return AVERROR_PATCHWELCOME;
361 if (len != 8 + 3 * nb_components) {
362 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
363 return AVERROR_INVALIDDATA;
366 s->nb_components = nb_components;
369 for (i = 0; i < nb_components; i++) {
371 s->component_id[i] = get_bits(&s->gb, 8) - 1;
372 h_count[i] = get_bits(&s->gb, 4);
373 v_count[i] = get_bits(&s->gb, 4);
374 /* compute hmax and vmax (only used in interleaved case) */
375 if (h_count[i] > s->h_max)
376 s->h_max = h_count[i];
377 if (v_count[i] > s->v_max)
378 s->v_max = v_count[i];
379 s->quant_index[i] = get_bits(&s->gb, 8);
380 if (s->quant_index[i] >= 4) {
381 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
382 return AVERROR_INVALIDDATA;
384 if (!h_count[i] || !v_count[i]) {
385 av_log(s->avctx, AV_LOG_ERROR,
386 "Invalid sampling factor in component %d %d:%d\n",
387 i, h_count[i], v_count[i]);
388 return AVERROR_INVALIDDATA;
391 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
392 i, h_count[i], v_count[i],
393 s->component_id[i], s->quant_index[i]);
395 if ( nb_components == 4
396 && s->component_id[0] == 'C' - 1
397 && s->component_id[1] == 'M' - 1
398 && s->component_id[2] == 'Y' - 1
399 && s->component_id[3] == 'K' - 1)
400 s->adobe_transform = 0;
402 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
403 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
404 return AVERROR_PATCHWELCOME;
408 if (nb_components == 2) {
409 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
410 width stored in their SOF3 markers is the width of each one. We only output
411 a single component, therefore we need to adjust the output image width. We
412 handle the deinterleaving (but not the debayering) in this file. */
415 /* They can also contain 1 component, which is double the width and half the height
416 of the final image (rows are interleaved). We don't handle the decoding in this
417 file, but leave that to the TIFF/DNG decoder. */
420 /* if different size, realloc/alloc picture */
421 if (width != s->width || height != s->height || bits != s->bits ||
422 memcmp(s->h_count, h_count, sizeof(h_count)) ||
423 memcmp(s->v_count, v_count, sizeof(v_count))) {
429 memcpy(s->h_count, h_count, sizeof(h_count));
430 memcpy(s->v_count, v_count, sizeof(v_count));
434 /* test interlaced mode */
435 if (s->first_picture &&
436 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
437 s->orig_height != 0 &&
438 s->height < ((s->orig_height * 3) / 4)) {
440 s->bottom_field = s->interlace_polarity;
441 s->picture_ptr->interlaced_frame = 1;
442 s->picture_ptr->top_field_first = !s->interlace_polarity;
446 ret = ff_set_dimensions(s->avctx, width, height);
450 if ((s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
451 s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
452 s->orig_height < height)
453 s->avctx->height = AV_CEIL_RSHIFT(s->orig_height, s->avctx->lowres);
455 s->first_picture = 0;
460 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
461 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
462 if (s->avctx->height <= 0)
463 return AVERROR_INVALIDDATA;
466 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
467 if (s->progressive) {
468 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
469 return AVERROR_INVALIDDATA;
472 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
474 else if (!s->lossless)
476 /* XXX: not complete test ! */
477 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
478 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
479 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
480 (s->h_count[3] << 4) | s->v_count[3];
481 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
482 /* NOTE we do not allocate pictures large enough for the possible
483 * padding of h/v_count being 4 */
484 if (!(pix_fmt_id & 0xD0D0D0D0))
485 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
486 if (!(pix_fmt_id & 0x0D0D0D0D))
487 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
489 for (i = 0; i < 8; i++) {
490 int j = 6 + (i&1) - (i&6);
491 int is = (pix_fmt_id >> (4*i)) & 0xF;
492 int js = (pix_fmt_id >> (4*j)) & 0xF;
494 if (is == 1 && js != 2 && (i < 2 || i > 5))
495 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
496 if (is == 1 && js != 2 && (i < 2 || i > 5))
497 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
499 if (is == 1 && js == 2) {
500 if (i & 1) s->upscale_h[j/2] = 1;
501 else s->upscale_v[j/2] = 1;
506 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
510 switch (pix_fmt_id) {
511 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
514 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
518 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
520 if ( s->adobe_transform == 0
521 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
522 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
524 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
525 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
526 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
529 av_assert0(s->nb_components == 3);
533 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
535 if (s->adobe_transform == 0 && s->bits <= 8) {
536 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
538 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
539 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
542 av_assert0(s->nb_components == 4);
546 if (s->adobe_transform == 0 && s->bits <= 8) {
547 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
548 s->upscale_v[1] = s->upscale_v[2] = 1;
549 s->upscale_h[1] = s->upscale_h[2] = 1;
550 } else if (s->adobe_transform == 2 && s->bits <= 8) {
551 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
552 s->upscale_v[1] = s->upscale_v[2] = 1;
553 s->upscale_h[1] = s->upscale_h[2] = 1;
554 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
556 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
557 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
558 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
560 av_assert0(s->nb_components == 4);
570 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
573 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
585 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
587 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
594 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
595 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
598 s->upscale_v[0] = s->upscale_v[1] = 1;
600 if (pix_fmt_id == 0x14111100)
601 s->upscale_v[1] = s->upscale_v[2] = 1;
602 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
605 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
609 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
610 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
613 s->upscale_h[0] = s->upscale_h[1] = 1;
615 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
616 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
617 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
623 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
624 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
625 s->upscale_h[1] = s->upscale_h[2] = 2;
629 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
632 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
638 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
639 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
640 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
641 if (pix_fmt_id == 0x42111100) {
644 s->upscale_h[1] = s->upscale_h[2] = 1;
645 } else if (pix_fmt_id == 0x24111100) {
648 s->upscale_v[1] = s->upscale_v[2] = 1;
649 } else if (pix_fmt_id == 0x23111100) {
652 s->upscale_v[1] = s->upscale_v[2] = 2;
656 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
659 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
663 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
664 memset(s->upscale_h, 0, sizeof(s->upscale_h));
665 memset(s->upscale_v, 0, sizeof(s->upscale_v));
666 return AVERROR_PATCHWELCOME;
668 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
669 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
670 return AVERROR_PATCHWELCOME;
672 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
673 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
674 return AVERROR_PATCHWELCOME;
677 memset(s->upscale_h, 0, sizeof(s->upscale_h));
678 memset(s->upscale_v, 0, sizeof(s->upscale_v));
679 if (s->nb_components == 3) {
680 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
681 } else if (s->nb_components != 1) {
682 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
683 return AVERROR_PATCHWELCOME;
684 } else if (s->palette_index && s->bits <= 8)
685 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
686 else if (s->bits <= 8)
687 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
689 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
692 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
694 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
698 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
699 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
701 enum AVPixelFormat pix_fmts[] = {
702 #if CONFIG_MJPEG_NVDEC_HWACCEL
705 #if CONFIG_MJPEG_VAAPI_HWACCEL
711 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
712 if (s->hwaccel_pix_fmt < 0)
713 return AVERROR(EINVAL);
715 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
716 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
719 if (s->avctx->skip_frame == AVDISCARD_ALL) {
720 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
721 s->picture_ptr->key_frame = 1;
726 av_frame_unref(s->picture_ptr);
727 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
729 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
730 s->picture_ptr->key_frame = 1;
733 for (i = 0; i < 4; i++)
734 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
736 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
737 s->width, s->height, s->linesize[0], s->linesize[1],
738 s->interlaced, s->avctx->height);
742 if ((s->rgb && !s->lossless && !s->ls) ||
743 (!s->rgb && s->ls && s->nb_components > 1) ||
744 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
746 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
747 return AVERROR_PATCHWELCOME;
750 /* totally blank picture as progressive JPEG will only add details to it */
751 if (s->progressive) {
752 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
753 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
754 for (i = 0; i < s->nb_components; i++) {
755 int size = bw * bh * s->h_count[i] * s->v_count[i];
756 av_freep(&s->blocks[i]);
757 av_freep(&s->last_nnz[i]);
758 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
759 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
760 if (!s->blocks[i] || !s->last_nnz[i])
761 return AVERROR(ENOMEM);
762 s->block_stride[i] = bw * s->h_count[i];
764 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
767 if (s->avctx->hwaccel) {
768 s->hwaccel_picture_private =
769 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
770 if (!s->hwaccel_picture_private)
771 return AVERROR(ENOMEM);
773 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
774 s->raw_image_buffer_size);
782 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
785 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
786 if (code < 0 || code > 16) {
787 av_log(s->avctx, AV_LOG_WARNING,
788 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
789 0, dc_index, &s->vlcs[0][dc_index]);
794 return get_xbits(&s->gb, code);
799 /* decode block and dequantize */
800 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
801 int dc_index, int ac_index, uint16_t *quant_matrix)
803 int code, i, j, level, val;
806 val = mjpeg_decode_dc(s, dc_index);
807 if (val == 0xfffff) {
808 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
809 return AVERROR_INVALIDDATA;
811 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
812 val = av_clip_int16(val);
813 s->last_dc[component] = val;
817 {OPEN_READER(re, &s->gb);
819 UPDATE_CACHE(re, &s->gb);
820 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
822 i += ((unsigned)code) >> 4;
825 if (code > MIN_CACHE_BITS - 16)
826 UPDATE_CACHE(re, &s->gb);
829 int cache = GET_CACHE(re, &s->gb);
830 int sign = (~cache) >> 31;
831 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
834 LAST_SKIP_BITS(re, &s->gb, code);
837 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
838 return AVERROR_INVALIDDATA;
840 j = s->scantable.permutated[i];
841 block[j] = level * quant_matrix[i];
844 CLOSE_READER(re, &s->gb);}
849 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
850 int component, int dc_index,
851 uint16_t *quant_matrix, int Al)
854 s->bdsp.clear_block(block);
855 val = mjpeg_decode_dc(s, dc_index);
856 if (val == 0xfffff) {
857 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
858 return AVERROR_INVALIDDATA;
860 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
861 s->last_dc[component] = val;
866 /* decode block and dequantize - progressive JPEG version */
867 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
868 uint8_t *last_nnz, int ac_index,
869 uint16_t *quant_matrix,
870 int ss, int se, int Al, int *EOBRUN)
872 int code, i, j, val, run;
881 OPEN_READER(re, &s->gb);
882 for (i = ss; ; i++) {
883 UPDATE_CACHE(re, &s->gb);
884 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
886 run = ((unsigned) code) >> 4;
890 if (code > MIN_CACHE_BITS - 16)
891 UPDATE_CACHE(re, &s->gb);
894 int cache = GET_CACHE(re, &s->gb);
895 int sign = (~cache) >> 31;
896 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
899 LAST_SKIP_BITS(re, &s->gb, code);
903 j = s->scantable.permutated[se];
904 block[j] = level * (quant_matrix[se] << Al);
907 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
908 return AVERROR_INVALIDDATA;
910 j = s->scantable.permutated[i];
911 block[j] = level * (quant_matrix[i] << Al);
913 if (run == 0xF) {// ZRL - skip 15 coefficients
916 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
917 return AVERROR_INVALIDDATA;
922 UPDATE_CACHE(re, &s->gb);
923 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
924 LAST_SKIP_BITS(re, &s->gb, run);
931 CLOSE_READER(re, &s->gb);
940 #define REFINE_BIT(j) { \
941 UPDATE_CACHE(re, &s->gb); \
942 sign = block[j] >> 15; \
943 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
944 ((quant_matrix[i] ^ sign) - sign) << Al; \
945 LAST_SKIP_BITS(re, &s->gb, 1); \
953 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
958 j = s->scantable.permutated[i]; \
961 else if (run-- == 0) \
965 /* decode block and dequantize - progressive JPEG refinement pass */
966 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
968 int ac_index, uint16_t *quant_matrix,
969 int ss, int se, int Al, int *EOBRUN)
971 int code, i = ss, j, sign, val, run;
972 int last = FFMIN(se, *last_nnz);
974 OPEN_READER(re, &s->gb);
979 UPDATE_CACHE(re, &s->gb);
980 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
983 run = ((unsigned) code) >> 4;
984 UPDATE_CACHE(re, &s->gb);
985 val = SHOW_UBITS(re, &s->gb, 1);
986 LAST_SKIP_BITS(re, &s->gb, 1);
988 j = s->scantable.permutated[i];
990 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
994 CLOSE_READER(re, &s->gb);
998 run = ((unsigned) code) >> 4;
1005 UPDATE_CACHE(re, &s->gb);
1006 run += SHOW_UBITS(re, &s->gb, val);
1007 LAST_SKIP_BITS(re, &s->gb, val);
1019 for (; i <= last; i++) {
1020 j = s->scantable.permutated[i];
1024 CLOSE_READER(re, &s->gb);
1031 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1036 if (s->restart_interval) {
1038 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1039 align_get_bits(&s->gb);
1040 for (i = 0; i < nb_components; i++) /* reset dc */
1041 s->last_dc[i] = (4 << s->bits);
1044 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1046 if (s->restart_count == 0) {
1047 if( show_bits(&s->gb, i) == (1 << i) - 1
1048 || show_bits(&s->gb, i) == 0xFF) {
1049 int pos = get_bits_count(&s->gb);
1050 align_get_bits(&s->gb);
1051 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1052 skip_bits(&s->gb, 8);
1053 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1054 for (i = 0; i < nb_components; i++) /* reset dc */
1055 s->last_dc[i] = (4 << s->bits);
1058 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1065 /* Handles 1 to 4 components */
1066 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1070 uint16_t (*buffer)[4];
1071 int left[4], top[4], topleft[4];
1072 const int linesize = s->linesize[0];
1073 const int mask = ((1 << s->bits) - 1) << point_transform;
1074 int resync_mb_y = 0;
1075 int resync_mb_x = 0;
1078 if (!s->bayer && s->nb_components < 3)
1079 return AVERROR_INVALIDDATA;
1080 if (s->bayer && s->nb_components > 2)
1081 return AVERROR_INVALIDDATA;
1082 if (s->nb_components <= 0 || s->nb_components > 4)
1083 return AVERROR_INVALIDDATA;
1084 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1085 return AVERROR_INVALIDDATA;
1088 s->restart_count = s->restart_interval;
1090 if (s->restart_interval == 0)
1091 s->restart_interval = INT_MAX;
1094 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1096 width = s->mb_width;
1098 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1099 if (!s->ljpeg_buffer)
1100 return AVERROR(ENOMEM);
1102 buffer = s->ljpeg_buffer;
1104 for (i = 0; i < 4; i++)
1105 buffer[0][i] = 1 << (s->bits - 1);
1107 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1108 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1110 if (s->interlaced && s->bottom_field)
1111 ptr += linesize >> 1;
1113 for (i = 0; i < 4; i++)
1114 top[i] = left[i] = topleft[i] = buffer[0][i];
1116 if ((mb_y * s->width) % s->restart_interval == 0) {
1117 for (i = 0; i < 6; i++)
1118 vpred[i] = 1 << (s->bits-1);
1121 for (mb_x = 0; mb_x < width; mb_x++) {
1122 int modified_predictor = predictor;
1124 if (get_bits_left(&s->gb) < 1) {
1125 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1126 return AVERROR_INVALIDDATA;
1129 if (s->restart_interval && !s->restart_count){
1130 s->restart_count = s->restart_interval;
1134 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1136 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1137 modified_predictor = 1;
1139 for (i=0;i<nb_components;i++) {
1142 topleft[i] = top[i];
1143 top[i] = buffer[mb_x][i];
1145 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1149 if (!s->bayer || mb_x) {
1151 } else { /* This path runs only for the first line in bayer images */
1153 pred = vpred[i] - dc;
1156 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1158 left[i] = buffer[mb_x][i] =
1159 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1162 if (s->restart_interval && !--s->restart_count) {
1163 align_get_bits(&s->gb);
1164 skip_bits(&s->gb, 16); /* skip RSTn */
1167 if (s->rct && s->nb_components == 4) {
1168 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1169 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1170 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1171 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1172 ptr[4*mb_x + 0] = buffer[mb_x][3];
1174 } else if (s->nb_components == 4) {
1175 for(i=0; i<nb_components; i++) {
1176 int c= s->comp_index[i];
1178 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1179 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1181 } else if(s->bits == 9) {
1182 return AVERROR_PATCHWELCOME;
1184 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1185 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1189 } else if (s->rct) {
1190 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1191 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1192 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1193 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1195 } else if (s->pegasus_rct) {
1196 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1197 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1198 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1199 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1201 } else if (s->bayer) {
1202 if (nb_components == 1) {
1203 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1204 for (mb_x = 0; mb_x < width; mb_x++)
1205 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1206 } else if (nb_components == 2) {
1207 for (mb_x = 0; mb_x < width; mb_x++) {
1208 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1209 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1213 for(i=0; i<nb_components; i++) {
1214 int c= s->comp_index[i];
1216 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1217 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1219 } else if(s->bits == 9) {
1220 return AVERROR_PATCHWELCOME;
1222 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1223 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1232 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1233 int point_transform, int nb_components)
1235 int i, mb_x, mb_y, mask;
1236 int bits= (s->bits+7)&~7;
1237 int resync_mb_y = 0;
1238 int resync_mb_x = 0;
1240 point_transform += bits - s->bits;
1241 mask = ((1 << s->bits) - 1) << point_transform;
1243 av_assert0(nb_components>=1 && nb_components<=4);
1245 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1246 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1247 if (get_bits_left(&s->gb) < 1) {
1248 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1249 return AVERROR_INVALIDDATA;
1251 if (s->restart_interval && !s->restart_count){
1252 s->restart_count = s->restart_interval;
1257 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1258 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1259 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1260 for (i = 0; i < nb_components; i++) {
1263 int n, h, v, x, y, c, j, linesize;
1264 n = s->nb_blocks[i];
1265 c = s->comp_index[i];
1270 linesize= s->linesize[c];
1272 if(bits>8) linesize /= 2;
1274 for(j=0; j<n; j++) {
1277 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1280 if ( h * mb_x + x >= s->width
1281 || v * mb_y + y >= s->height) {
1283 } else if (bits<=8) {
1284 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1286 if(x==0 && leftcol){
1287 pred= 1 << (bits - 1);
1292 if(x==0 && leftcol){
1293 pred= ptr[-linesize];
1295 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1299 if (s->interlaced && s->bottom_field)
1300 ptr += linesize >> 1;
1302 *ptr= pred + ((unsigned)dc << point_transform);
1304 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1306 if(x==0 && leftcol){
1307 pred= 1 << (bits - 1);
1312 if(x==0 && leftcol){
1313 pred= ptr16[-linesize];
1315 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1319 if (s->interlaced && s->bottom_field)
1320 ptr16 += linesize >> 1;
1322 *ptr16= pred + ((unsigned)dc << point_transform);
1331 for (i = 0; i < nb_components; i++) {
1334 int n, h, v, x, y, c, j, linesize, dc;
1335 n = s->nb_blocks[i];
1336 c = s->comp_index[i];
1341 linesize = s->linesize[c];
1343 if(bits>8) linesize /= 2;
1345 for (j = 0; j < n; j++) {
1348 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1351 if ( h * mb_x + x >= s->width
1352 || v * mb_y + y >= s->height) {
1354 } else if (bits<=8) {
1355 ptr = s->picture_ptr->data[c] +
1356 (linesize * (v * mb_y + y)) +
1357 (h * mb_x + x); //FIXME optimize this crap
1358 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1361 *ptr = pred + ((unsigned)dc << point_transform);
1363 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1364 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1367 *ptr16= pred + ((unsigned)dc << point_transform);
1377 if (s->restart_interval && !--s->restart_count) {
1378 align_get_bits(&s->gb);
1379 skip_bits(&s->gb, 16); /* skip RSTn */
1386 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1387 uint8_t *dst, const uint8_t *src,
1388 int linesize, int lowres)
1391 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1393 case 1: copy_block4(dst, src, linesize, linesize, 4);
1395 case 2: copy_block2(dst, src, linesize, linesize, 2);
1397 case 3: *dst = *src;
1402 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1404 int block_x, block_y;
1405 int size = 8 >> s->avctx->lowres;
1407 for (block_y=0; block_y<size; block_y++)
1408 for (block_x=0; block_x<size; block_x++)
1409 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1411 for (block_y=0; block_y<size; block_y++)
1412 for (block_x=0; block_x<size; block_x++)
1413 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1417 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1418 int Al, const uint8_t *mb_bitmask,
1419 int mb_bitmask_size,
1420 const AVFrame *reference)
1422 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1423 uint8_t *data[MAX_COMPONENTS];
1424 const uint8_t *reference_data[MAX_COMPONENTS];
1425 int linesize[MAX_COMPONENTS];
1426 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1427 int bytes_per_pixel = 1 + (s->bits > 8);
1430 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1431 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1432 return AVERROR_INVALIDDATA;
1434 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1437 s->restart_count = 0;
1439 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1441 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1442 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1444 for (i = 0; i < nb_components; i++) {
1445 int c = s->comp_index[i];
1446 data[c] = s->picture_ptr->data[c];
1447 reference_data[c] = reference ? reference->data[c] : NULL;
1448 linesize[c] = s->linesize[c];
1449 s->coefs_finished[c] |= 1;
1452 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1453 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1454 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1456 if (s->restart_interval && !s->restart_count)
1457 s->restart_count = s->restart_interval;
1459 if (get_bits_left(&s->gb) < 0) {
1460 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1461 -get_bits_left(&s->gb));
1462 return AVERROR_INVALIDDATA;
1464 for (i = 0; i < nb_components; i++) {
1466 int n, h, v, x, y, c, j;
1468 n = s->nb_blocks[i];
1469 c = s->comp_index[i];
1474 for (j = 0; j < n; j++) {
1475 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1476 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1478 if (s->interlaced && s->bottom_field)
1479 block_offset += linesize[c] >> 1;
1480 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1481 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1482 ptr = data[c] + block_offset;
1485 if (!s->progressive) {
1488 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1489 linesize[c], s->avctx->lowres);
1492 s->bdsp.clear_block(s->block);
1493 if (decode_block(s, s->block, i,
1494 s->dc_index[i], s->ac_index[i],
1495 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1496 av_log(s->avctx, AV_LOG_ERROR,
1497 "error y=%d x=%d\n", mb_y, mb_x);
1498 return AVERROR_INVALIDDATA;
1501 s->idsp.idct_put(ptr, linesize[c], s->block);
1503 shift_output(s, ptr, linesize[c]);
1507 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1509 int16_t *block = s->blocks[c][block_idx];
1511 block[0] += get_bits1(&s->gb) *
1512 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1513 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1514 s->quant_matrixes[s->quant_sindex[i]],
1516 av_log(s->avctx, AV_LOG_ERROR,
1517 "error y=%d x=%d\n", mb_y, mb_x);
1518 return AVERROR_INVALIDDATA;
1521 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1522 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1523 mb_x, mb_y, x, y, c, s->bottom_field,
1524 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1532 handle_rstn(s, nb_components);
1538 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1539 int se, int Ah, int Al)
1543 int c = s->comp_index[0];
1544 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1546 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1547 if (se < ss || se > 63) {
1548 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1549 return AVERROR_INVALIDDATA;
1552 // s->coefs_finished is a bitmask for coefficients coded
1553 // ss and se are parameters telling start and end coefficients
1554 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1556 s->restart_count = 0;
1558 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1559 int block_idx = mb_y * s->block_stride[c];
1560 int16_t (*block)[64] = &s->blocks[c][block_idx];
1561 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1562 if (get_bits_left(&s->gb) <= 0) {
1563 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1564 return AVERROR_INVALIDDATA;
1566 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1568 if (s->restart_interval && !s->restart_count)
1569 s->restart_count = s->restart_interval;
1572 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1573 quant_matrix, ss, se, Al, &EOBRUN);
1575 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1576 quant_matrix, ss, se, Al, &EOBRUN);
1578 av_log(s->avctx, AV_LOG_ERROR,
1579 "error y=%d x=%d\n", mb_y, mb_x);
1580 return AVERROR_INVALIDDATA;
1583 if (handle_rstn(s, 0))
1590 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1594 const int bytes_per_pixel = 1 + (s->bits > 8);
1595 const int block_size = s->lossless ? 1 : 8;
1597 for (c = 0; c < s->nb_components; c++) {
1598 uint8_t *data = s->picture_ptr->data[c];
1599 int linesize = s->linesize[c];
1600 int h = s->h_max / s->h_count[c];
1601 int v = s->v_max / s->v_count[c];
1602 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1603 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1605 if (~s->coefs_finished[c])
1606 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1608 if (s->interlaced && s->bottom_field)
1609 data += linesize >> 1;
1611 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1612 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1613 int block_idx = mb_y * s->block_stride[c];
1614 int16_t (*block)[64] = &s->blocks[c][block_idx];
1615 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1616 s->idsp.idct_put(ptr, linesize, *block);
1618 shift_output(s, ptr, linesize);
1619 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1625 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1626 int mb_bitmask_size, const AVFrame *reference)
1628 int len, nb_components, i, h, v, predictor, point_transform;
1630 const int block_size = s->lossless ? 1 : 8;
1631 int ilv, prev_shift;
1633 if (!s->got_picture) {
1634 av_log(s->avctx, AV_LOG_WARNING,
1635 "Can not process SOS before SOF, skipping\n");
1640 if (reference->width != s->picture_ptr->width ||
1641 reference->height != s->picture_ptr->height ||
1642 reference->format != s->picture_ptr->format) {
1643 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1644 return AVERROR_INVALIDDATA;
1648 /* XXX: verify len field validity */
1649 len = get_bits(&s->gb, 16);
1650 nb_components = get_bits(&s->gb, 8);
1651 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1652 avpriv_report_missing_feature(s->avctx,
1653 "decode_sos: nb_components (%d)",
1655 return AVERROR_PATCHWELCOME;
1657 if (len != 6 + 2 * nb_components) {
1658 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1659 return AVERROR_INVALIDDATA;
1661 for (i = 0; i < nb_components; i++) {
1662 id = get_bits(&s->gb, 8) - 1;
1663 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1664 /* find component index */
1665 for (index = 0; index < s->nb_components; index++)
1666 if (id == s->component_id[index])
1668 if (index == s->nb_components) {
1669 av_log(s->avctx, AV_LOG_ERROR,
1670 "decode_sos: index(%d) out of components\n", index);
1671 return AVERROR_INVALIDDATA;
1673 /* Metasoft MJPEG codec has Cb and Cr swapped */
1674 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1675 && nb_components == 3 && s->nb_components == 3 && i)
1678 s->quant_sindex[i] = s->quant_index[index];
1679 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1680 s->h_scount[i] = s->h_count[index];
1681 s->v_scount[i] = s->v_count[index];
1683 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1684 index = (index+2)%3;
1686 s->comp_index[i] = index;
1688 s->dc_index[i] = get_bits(&s->gb, 4);
1689 s->ac_index[i] = get_bits(&s->gb, 4);
1691 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1692 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1694 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))
1698 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1699 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1700 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1701 prev_shift = get_bits(&s->gb, 4); /* Ah */
1702 point_transform = get_bits(&s->gb, 4); /* Al */
1704 prev_shift = point_transform = 0;
1706 if (nb_components > 1) {
1707 /* interleaved stream */
1708 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1709 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1710 } else if (!s->ls) { /* skip this for JPEG-LS */
1711 h = s->h_max / s->h_scount[0];
1712 v = s->v_max / s->v_scount[0];
1713 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1714 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1715 s->nb_blocks[0] = 1;
1720 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1721 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1722 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1723 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1724 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1727 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1728 for (i = s->mjpb_skiptosod; i > 0; i--)
1729 skip_bits(&s->gb, 8);
1732 for (i = 0; i < nb_components; i++)
1733 s->last_dc[i] = (4 << s->bits);
1735 if (s->avctx->hwaccel) {
1736 int bytes_to_start = get_bits_count(&s->gb) / 8;
1737 av_assert0(bytes_to_start >= 0 &&
1738 s->raw_scan_buffer_size >= bytes_to_start);
1740 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1741 s->raw_scan_buffer + bytes_to_start,
1742 s->raw_scan_buffer_size - bytes_to_start);
1746 } else if (s->lossless) {
1747 av_assert0(s->picture_ptr == s->picture);
1748 if (CONFIG_JPEGLS_DECODER && s->ls) {
1750 // reset_ls_coding_parameters(s, 0);
1752 if ((ret = ff_jpegls_decode_picture(s, predictor,
1753 point_transform, ilv)) < 0)
1756 if (s->rgb || s->bayer) {
1757 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1760 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1762 nb_components)) < 0)
1767 if (s->progressive && predictor) {
1768 av_assert0(s->picture_ptr == s->picture);
1769 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1771 point_transform)) < 0)
1774 if ((ret = mjpeg_decode_scan(s, nb_components,
1775 prev_shift, point_transform,
1776 mb_bitmask, mb_bitmask_size, reference)) < 0)
1781 if (s->interlaced &&
1782 get_bits_left(&s->gb) > 32 &&
1783 show_bits(&s->gb, 8) == 0xFF) {
1784 GetBitContext bak = s->gb;
1785 align_get_bits(&bak);
1786 if (show_bits(&bak, 16) == 0xFFD1) {
1787 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1789 skip_bits(&s->gb, 16);
1790 s->bottom_field ^= 1;
1799 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1800 return AVERROR_INVALIDDATA;
1803 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1805 if (get_bits(&s->gb, 16) != 4)
1806 return AVERROR_INVALIDDATA;
1807 s->restart_interval = get_bits(&s->gb, 16);
1808 s->restart_count = 0;
1809 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1810 s->restart_interval);
1815 static int mjpeg_decode_app(MJpegDecodeContext *s)
1819 len = get_bits(&s->gb, 16);
1822 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1823 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1824 skip_bits(&s->gb, len);
1827 return AVERROR_INVALIDDATA;
1829 if (8 * len > get_bits_left(&s->gb))
1830 return AVERROR_INVALIDDATA;
1832 id = get_bits_long(&s->gb, 32);
1835 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1836 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1837 av_fourcc2str(av_bswap32(id)), id, len);
1839 /* Buggy AVID, it puts EOI only at every 10th frame. */
1840 /* Also, this fourcc is used by non-avid files too, it holds some
1841 information, but it's always present in AVID-created files. */
1842 if (id == AV_RB32("AVI1")) {
1848 4bytes field_size_less_padding
1851 i = get_bits(&s->gb, 8); len--;
1852 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1856 if (id == AV_RB32("JFIF")) {
1857 int t_w, t_h, v1, v2;
1860 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1861 v1 = get_bits(&s->gb, 8);
1862 v2 = get_bits(&s->gb, 8);
1863 skip_bits(&s->gb, 8);
1865 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1866 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1867 if ( s->avctx->sample_aspect_ratio.num <= 0
1868 || s->avctx->sample_aspect_ratio.den <= 0) {
1869 s->avctx->sample_aspect_ratio.num = 0;
1870 s->avctx->sample_aspect_ratio.den = 1;
1873 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1874 av_log(s->avctx, AV_LOG_INFO,
1875 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1877 s->avctx->sample_aspect_ratio.num,
1878 s->avctx->sample_aspect_ratio.den);
1882 t_w = get_bits(&s->gb, 8);
1883 t_h = get_bits(&s->gb, 8);
1885 /* skip thumbnail */
1886 if (len -10 - (t_w * t_h * 3) > 0)
1887 len -= t_w * t_h * 3;
1894 if ( id == AV_RB32("Adob")
1896 && show_bits(&s->gb, 8) == 'e'
1897 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1898 skip_bits(&s->gb, 8); /* 'e' */
1899 skip_bits(&s->gb, 16); /* version */
1900 skip_bits(&s->gb, 16); /* flags0 */
1901 skip_bits(&s->gb, 16); /* flags1 */
1902 s->adobe_transform = get_bits(&s->gb, 8);
1903 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1904 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1909 if (id == AV_RB32("LJIF")) {
1911 int pegasus_rct = s->pegasus_rct;
1912 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1913 av_log(s->avctx, AV_LOG_INFO,
1914 "Pegasus lossless jpeg header found\n");
1915 skip_bits(&s->gb, 16); /* version ? */
1916 skip_bits(&s->gb, 16); /* unknown always 0? */
1917 skip_bits(&s->gb, 16); /* unknown always 0? */
1918 skip_bits(&s->gb, 16); /* unknown always 0? */
1919 switch (i=get_bits(&s->gb, 8)) {
1929 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1934 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1935 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1940 s->pegasus_rct = pegasus_rct;
1944 if (id == AV_RL32("colr") && len > 0) {
1945 s->colr = get_bits(&s->gb, 8);
1946 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1947 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1951 if (id == AV_RL32("xfrm") && len > 0) {
1952 s->xfrm = get_bits(&s->gb, 8);
1953 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1954 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1959 /* JPS extension by VRex */
1960 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1961 int flags, layout, type;
1962 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1963 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1965 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1966 skip_bits(&s->gb, 16); len -= 2; /* block length */
1967 skip_bits(&s->gb, 8); /* reserved */
1968 flags = get_bits(&s->gb, 8);
1969 layout = get_bits(&s->gb, 8);
1970 type = get_bits(&s->gb, 8);
1973 av_freep(&s->stereo3d);
1974 s->stereo3d = av_stereo3d_alloc();
1979 s->stereo3d->type = AV_STEREO3D_2D;
1980 } else if (type == 1) {
1983 s->stereo3d->type = AV_STEREO3D_LINES;
1986 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1989 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1992 if (!(flags & 0x04)) {
1993 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2000 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2001 GetByteContext gbytes;
2002 int ret, le, ifd_offset, bytes_read;
2003 const uint8_t *aligned;
2005 skip_bits(&s->gb, 16); // skip padding
2008 // init byte wise reading
2009 aligned = align_get_bits(&s->gb);
2010 bytestream2_init(&gbytes, aligned, len);
2013 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2015 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2017 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2019 // read 0th IFD and store the metadata
2020 // (return values > 0 indicate the presence of subimage metadata)
2021 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2023 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2027 bytes_read = bytestream2_tell(&gbytes);
2028 skip_bits(&s->gb, bytes_read << 3);
2035 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2036 id = get_bits_long(&s->gb, 32);
2039 if (id == AV_RB32("mjpg")) {
2042 4bytes pad field size
2050 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2051 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2055 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2058 unsigned nummarkers;
2060 id = get_bits_long(&s->gb, 32);
2061 id2 = get_bits(&s->gb, 24);
2063 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2064 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2068 skip_bits(&s->gb, 8);
2069 seqno = get_bits(&s->gb, 8);
2072 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2076 nummarkers = get_bits(&s->gb, 8);
2078 if (nummarkers == 0) {
2079 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2081 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2082 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2084 } else if (seqno > nummarkers) {
2085 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2089 /* Allocate if this is the first APP2 we've seen. */
2090 if (s->iccnum == 0) {
2091 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2092 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2093 return AVERROR(ENOMEM);
2095 s->iccnum = nummarkers;
2098 if (s->iccentries[seqno - 1].data) {
2099 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2103 s->iccentries[seqno - 1].length = len;
2104 s->iccentries[seqno - 1].data = av_malloc(len);
2105 if (!s->iccentries[seqno - 1].data) {
2106 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2107 return AVERROR(ENOMEM);
2110 memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2111 skip_bits(&s->gb, len << 3);
2115 if (s->iccread > s->iccnum)
2116 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2120 /* slow but needed for extreme adobe jpegs */
2122 av_log(s->avctx, AV_LOG_ERROR,
2123 "mjpeg: error, decode_app parser read over the end\n");
2125 skip_bits(&s->gb, 8);
2130 static int mjpeg_decode_com(MJpegDecodeContext *s)
2132 int len = get_bits(&s->gb, 16);
2133 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2135 char *cbuf = av_malloc(len - 1);
2137 return AVERROR(ENOMEM);
2139 for (i = 0; i < len - 2; i++)
2140 cbuf[i] = get_bits(&s->gb, 8);
2141 if (i > 0 && cbuf[i - 1] == '\n')
2146 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2147 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2149 /* buggy avid, it puts EOI only at every 10th frame */
2150 if (!strncmp(cbuf, "AVID", 4)) {
2151 parse_avid(s, cbuf, len);
2152 } else if (!strcmp(cbuf, "CS=ITU601"))
2154 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2155 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2157 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2158 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2168 /* return the 8 bit start code value and update the search
2169 state. Return -1 if no start code found */
2170 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2172 const uint8_t *buf_ptr;
2177 buf_ptr = *pbuf_ptr;
2178 while (buf_end - buf_ptr > 1) {
2181 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2190 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2191 *pbuf_ptr = buf_ptr;
2195 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2196 const uint8_t **buf_ptr, const uint8_t *buf_end,
2197 const uint8_t **unescaped_buf_ptr,
2198 int *unescaped_buf_size)
2201 start_code = find_marker(buf_ptr, buf_end);
2203 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2205 return AVERROR(ENOMEM);
2207 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2208 if (start_code == SOS && !s->ls) {
2209 const uint8_t *src = *buf_ptr;
2210 const uint8_t *ptr = src;
2211 uint8_t *dst = s->buffer;
2213 #define copy_data_segment(skip) do { \
2214 ptrdiff_t length = (ptr - src) - (skip); \
2216 memcpy(dst, src, length); \
2222 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2224 copy_data_segment(0);
2226 while (ptr < buf_end) {
2227 uint8_t x = *(ptr++);
2231 while (ptr < buf_end && x == 0xff) {
2236 /* 0xFF, 0xFF, ... */
2238 copy_data_segment(skip);
2240 /* decrement src as it is equal to ptr after the
2241 * copy_data_segment macro and we might want to
2242 * copy the current value of x later on */
2246 if (x < RST0 || x > RST7) {
2247 copy_data_segment(1);
2254 copy_data_segment(0);
2256 #undef copy_data_segment
2258 *unescaped_buf_ptr = s->buffer;
2259 *unescaped_buf_size = dst - s->buffer;
2260 memset(s->buffer + *unescaped_buf_size, 0,
2261 AV_INPUT_BUFFER_PADDING_SIZE);
2263 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2264 (buf_end - *buf_ptr) - (dst - s->buffer));
2265 } else if (start_code == SOS && s->ls) {
2266 const uint8_t *src = *buf_ptr;
2267 uint8_t *dst = s->buffer;
2273 while (src + t < buf_end) {
2274 uint8_t x = src[t++];
2276 while ((src + t < buf_end) && x == 0xff)
2285 init_put_bits(&pb, dst, t);
2287 /* unescape bitstream */
2289 uint8_t x = src[b++];
2290 put_bits(&pb, 8, x);
2291 if (x == 0xFF && b < t) {
2294 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2297 put_bits(&pb, 7, x);
2301 flush_put_bits(&pb);
2303 *unescaped_buf_ptr = dst;
2304 *unescaped_buf_size = (bit_count + 7) >> 3;
2305 memset(s->buffer + *unescaped_buf_size, 0,
2306 AV_INPUT_BUFFER_PADDING_SIZE);
2308 *unescaped_buf_ptr = *buf_ptr;
2309 *unescaped_buf_size = buf_end - *buf_ptr;
2315 static void reset_icc_profile(MJpegDecodeContext *s)
2319 if (s->iccentries) {
2320 for (i = 0; i < s->iccnum; i++)
2321 av_freep(&s->iccentries[i].data);
2322 av_freep(&s->iccentries);
2329 // SMV JPEG just stacks several output frames into one JPEG picture
2330 // we handle that by setting up the cropping parameters appropriately
2331 static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2333 MJpegDecodeContext *s = avctx->priv_data;
2336 if (s->smv_next_frame > 0) {
2337 av_assert0(s->smv_frame->buf[0]);
2338 av_frame_unref(frame);
2339 ret = av_frame_ref(frame, s->smv_frame);
2343 av_assert0(frame->buf[0]);
2344 av_frame_unref(s->smv_frame);
2345 ret = av_frame_ref(s->smv_frame, frame);
2350 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2352 frame->width = avctx->coded_width;
2353 frame->height = avctx->coded_height;
2354 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2355 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2357 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2359 if (s->smv_next_frame == 0)
2360 av_frame_unref(s->smv_frame);
2365 static int mjpeg_get_packet(AVCodecContext *avctx)
2367 MJpegDecodeContext *s = avctx->priv_data;
2370 av_packet_unref(s->pkt);
2371 ret = ff_decode_get_packet(avctx, s->pkt);
2375 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2376 if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2377 avctx->codec_id == AV_CODEC_ID_AMV) {
2378 ret = ff_sp5x_process_packet(avctx, s->pkt);
2384 s->buf_size = s->pkt->size;
2389 int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2391 MJpegDecodeContext *s = avctx->priv_data;
2392 const uint8_t *buf_end, *buf_ptr;
2393 const uint8_t *unescaped_buf_ptr;
2395 int unescaped_buf_size;
2401 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2402 return smv_process_frame(avctx, frame);
2404 av_dict_free(&s->exif_metadata);
2405 av_freep(&s->stereo3d);
2406 s->adobe_transform = -1;
2409 reset_icc_profile(s);
2411 ret = mjpeg_get_packet(avctx);
2415 buf_ptr = s->pkt->data;
2416 buf_end = s->pkt->data + s->pkt->size;
2417 while (buf_ptr < buf_end) {
2418 /* find start next marker */
2419 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2421 &unescaped_buf_size);
2423 if (start_code < 0) {
2425 } else if (unescaped_buf_size > INT_MAX / 8) {
2426 av_log(avctx, AV_LOG_ERROR,
2427 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2428 start_code, unescaped_buf_size, s->pkt->size);
2429 return AVERROR_INVALIDDATA;
2431 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2432 start_code, buf_end - buf_ptr);
2434 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2437 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2441 s->start_code = start_code;
2442 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2443 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2445 /* process markers */
2446 if (start_code >= RST0 && start_code <= RST7) {
2447 av_log(avctx, AV_LOG_DEBUG,
2448 "restart marker: %d\n", start_code & 0x0f);
2450 } else if (start_code >= APP0 && start_code <= APP15) {
2451 if ((ret = mjpeg_decode_app(s)) < 0)
2452 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2455 } else if (start_code == COM) {
2456 ret = mjpeg_decode_com(s);
2459 } else if (start_code == DQT) {
2460 ret = ff_mjpeg_decode_dqt(s);
2467 if (!CONFIG_JPEGLS_DECODER &&
2468 (start_code == SOF48 || start_code == LSE)) {
2469 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2470 return AVERROR(ENOSYS);
2473 if (avctx->skip_frame == AVDISCARD_ALL) {
2474 switch(start_code) {
2489 switch (start_code) {
2491 s->restart_interval = 0;
2492 s->restart_count = 0;
2493 s->raw_image_buffer = buf_ptr;
2494 s->raw_image_buffer_size = buf_end - buf_ptr;
2495 /* nothing to do on SOI */
2498 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2499 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2505 if (start_code == SOF0)
2506 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2508 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2512 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2516 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2520 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2524 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2525 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2529 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2533 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2534 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2538 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2542 if (!CONFIG_JPEGLS_DECODER ||
2543 (ret = ff_jpegls_decode_lse(s)) < 0)
2548 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2549 s->progressive && s->cur_scan && s->got_picture)
2550 mjpeg_idct_scan_progressive_ac(s);
2552 if (!s->got_picture) {
2553 av_log(avctx, AV_LOG_WARNING,
2554 "Found EOI before any SOF, ignoring\n");
2557 if (s->interlaced) {
2558 s->bottom_field ^= 1;
2559 /* if not bottom field, do not output image yet */
2560 if (s->bottom_field == !s->interlace_polarity)
2563 if (avctx->skip_frame == AVDISCARD_ALL) {
2565 ret = AVERROR(EAGAIN);
2566 goto the_end_no_picture;
2568 if (s->avctx->hwaccel) {
2569 ret = s->avctx->hwaccel->end_frame(s->avctx);
2573 av_freep(&s->hwaccel_picture_private);
2575 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2579 frame->pkt_dts = s->pkt->dts;
2581 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2582 int qp = FFMAX3(s->qscale[0],
2586 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2591 s->raw_scan_buffer = buf_ptr;
2592 s->raw_scan_buffer_size = buf_end - buf_ptr;
2595 if (avctx->skip_frame == AVDISCARD_ALL) {
2596 skip_bits(&s->gb, get_bits_left(&s->gb));
2600 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2601 (avctx->err_recognition & AV_EF_EXPLODE))
2605 if ((ret = mjpeg_decode_dri(s)) < 0)
2618 av_log(avctx, AV_LOG_ERROR,
2619 "mjpeg: unsupported coding type (%x)\n", start_code);
2624 /* eof process start code */
2625 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2626 av_log(avctx, AV_LOG_DEBUG,
2627 "marker parser used %d bytes (%d bits)\n",
2628 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2630 if (s->got_picture && s->cur_scan) {
2631 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2634 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2635 return AVERROR_INVALIDDATA;
2641 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2643 if (AV_RB32(s->upscale_h)) {
2645 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2646 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2647 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2648 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2650 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2652 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2653 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2654 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2655 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2656 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2658 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2662 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2663 for (p = 0; p<s->nb_components; p++) {
2664 uint8_t *line = s->picture_ptr->data[p];
2667 if (!s->upscale_h[p])
2670 w = AV_CEIL_RSHIFT(w, hshift);
2671 h = AV_CEIL_RSHIFT(h, vshift);
2673 if (s->upscale_v[p] == 1)
2676 for (i = 0; i < h; i++) {
2677 if (s->upscale_h[p] == 1) {
2678 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2679 else line[w - 1] = line[(w - 1) / 2];
2680 for (index = w - 2; index > 0; index--) {
2682 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2684 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2686 } else if (s->upscale_h[p] == 2) {
2688 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2690 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2692 line[w - 1] = line[(w - 1) / 3];
2694 line[w - 2] = line[w - 1];
2696 for (index = w - 3; index > 0; index--) {
2697 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2700 line += s->linesize[p];
2704 if (AV_RB32(s->upscale_v)) {
2706 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2707 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2708 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2709 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2710 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2711 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2712 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2713 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2714 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2715 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2716 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2717 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2718 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2720 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2724 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2725 for (p = 0; p < s->nb_components; p++) {
2729 if (!s->upscale_v[p])
2732 w = AV_CEIL_RSHIFT(w, hshift);
2733 h = AV_CEIL_RSHIFT(h, vshift);
2735 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2736 for (i = h - 1; i; i--) {
2737 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2738 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2739 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2740 memcpy(dst, src1, w);
2742 for (index = 0; index < w; index++)
2743 dst[index] = (src1[index] + src2[index]) >> 1;
2745 dst -= s->linesize[p];
2749 if (s->flipped && !s->rgb) {
2751 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2755 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2756 for (index=0; index<s->nb_components; index++) {
2757 uint8_t *dst = s->picture_ptr->data[index];
2758 int w = s->picture_ptr->width;
2759 int h = s->picture_ptr->height;
2760 if(index && index<3){
2761 w = AV_CEIL_RSHIFT(w, hshift);
2762 h = AV_CEIL_RSHIFT(h, vshift);
2765 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2766 for (i=0; i<h/2; i++) {
2768 FFSWAP(int, dst[j], dst2[j]);
2769 dst += s->picture_ptr->linesize[index];
2770 dst2 -= s->picture_ptr->linesize[index];
2775 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2776 int w = s->picture_ptr->width;
2777 int h = s->picture_ptr->height;
2778 av_assert0(s->nb_components == 4);
2779 for (i=0; i<h; i++) {
2782 for (index=0; index<4; index++) {
2783 dst[index] = s->picture_ptr->data[index]
2784 + s->picture_ptr->linesize[index]*i;
2786 for (j=0; j<w; j++) {
2788 int r = dst[0][j] * k;
2789 int g = dst[1][j] * k;
2790 int b = dst[2][j] * k;
2791 dst[0][j] = g*257 >> 16;
2792 dst[1][j] = b*257 >> 16;
2793 dst[2][j] = r*257 >> 16;
2798 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2799 int w = s->picture_ptr->width;
2800 int h = s->picture_ptr->height;
2801 av_assert0(s->nb_components == 4);
2802 for (i=0; i<h; i++) {
2805 for (index=0; index<4; index++) {
2806 dst[index] = s->picture_ptr->data[index]
2807 + s->picture_ptr->linesize[index]*i;
2809 for (j=0; j<w; j++) {
2811 int r = (255 - dst[0][j]) * k;
2812 int g = (128 - dst[1][j]) * k;
2813 int b = (128 - dst[2][j]) * k;
2814 dst[0][j] = r*257 >> 16;
2815 dst[1][j] = (g*257 >> 16) + 128;
2816 dst[2][j] = (b*257 >> 16) + 128;
2823 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2825 stereo->type = s->stereo3d->type;
2826 stereo->flags = s->stereo3d->flags;
2828 av_freep(&s->stereo3d);
2831 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2832 AVFrameSideData *sd;
2837 /* Sum size of all parts. */
2838 for (i = 0; i < s->iccnum; i++)
2839 total_size += s->iccentries[i].length;
2841 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2843 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2844 return AVERROR(ENOMEM);
2847 /* Reassemble the parts, which are now in-order. */
2848 for (i = 0; i < s->iccnum; i++) {
2849 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2850 offset += s->iccentries[i].length;
2854 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2855 av_dict_free(&s->exif_metadata);
2857 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2858 ret = smv_process_frame(avctx, frame);
2860 av_frame_unref(frame);
2864 if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2865 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2866 avctx->coded_height > s->orig_height) {
2867 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2868 frame->crop_top = frame->height - avctx->height;
2874 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2880 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2881 * even without having called ff_mjpeg_decode_init(). */
2882 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2884 MJpegDecodeContext *s = avctx->priv_data;
2887 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2888 av_log(avctx, AV_LOG_INFO, "Single field\n");
2892 av_frame_free(&s->picture);
2893 s->picture_ptr = NULL;
2894 } else if (s->picture_ptr)
2895 av_frame_unref(s->picture_ptr);
2897 av_packet_free(&s->pkt);
2899 av_frame_free(&s->smv_frame);
2901 av_freep(&s->buffer);
2902 av_freep(&s->stereo3d);
2903 av_freep(&s->ljpeg_buffer);
2904 s->ljpeg_buffer_size = 0;
2906 for (i = 0; i < 3; i++) {
2907 for (j = 0; j < 4; j++)
2908 ff_free_vlc(&s->vlcs[i][j]);
2910 for (i = 0; i < MAX_COMPONENTS; i++) {
2911 av_freep(&s->blocks[i]);
2912 av_freep(&s->last_nnz[i]);
2914 av_dict_free(&s->exif_metadata);
2916 reset_icc_profile(s);
2918 av_freep(&s->hwaccel_picture_private);
2923 static void decode_flush(AVCodecContext *avctx)
2925 MJpegDecodeContext *s = avctx->priv_data;
2928 s->smv_next_frame = 0;
2929 av_frame_unref(s->smv_frame);
2932 #if CONFIG_MJPEG_DECODER
2933 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2934 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2935 static const AVOption options[] = {
2936 { "extern_huff", "Use external huffman table.",
2937 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2941 static const AVClass mjpegdec_class = {
2942 .class_name = "MJPEG decoder",
2943 .item_name = av_default_item_name,
2945 .version = LIBAVUTIL_VERSION_INT,
2948 AVCodec ff_mjpeg_decoder = {
2950 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2951 .type = AVMEDIA_TYPE_VIDEO,
2952 .id = AV_CODEC_ID_MJPEG,
2953 .priv_data_size = sizeof(MJpegDecodeContext),
2954 .init = ff_mjpeg_decode_init,
2955 .close = ff_mjpeg_decode_end,
2956 .receive_frame = ff_mjpeg_receive_frame,
2957 .flush = decode_flush,
2958 .capabilities = AV_CODEC_CAP_DR1,
2960 .priv_class = &mjpegdec_class,
2961 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2962 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2963 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2964 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2965 #if CONFIG_MJPEG_NVDEC_HWACCEL
2966 HWACCEL_NVDEC(mjpeg),
2968 #if CONFIG_MJPEG_VAAPI_HWACCEL
2969 HWACCEL_VAAPI(mjpeg),
2975 #if CONFIG_THP_DECODER
2976 AVCodec ff_thp_decoder = {
2978 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2979 .type = AVMEDIA_TYPE_VIDEO,
2980 .id = AV_CODEC_ID_THP,
2981 .priv_data_size = sizeof(MJpegDecodeContext),
2982 .init = ff_mjpeg_decode_init,
2983 .close = ff_mjpeg_decode_end,
2984 .receive_frame = ff_mjpeg_receive_frame,
2985 .flush = decode_flush,
2986 .capabilities = AV_CODEC_CAP_DR1,
2988 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2989 FF_CODEC_CAP_SETS_PKT_DTS,
2993 #if CONFIG_SMVJPEG_DECODER
2994 AVCodec ff_smvjpeg_decoder = {
2996 .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
2997 .type = AVMEDIA_TYPE_VIDEO,
2998 .id = AV_CODEC_ID_SMVJPEG,
2999 .priv_data_size = sizeof(MJpegDecodeContext),
3000 .init = ff_mjpeg_decode_init,
3001 .close = ff_mjpeg_decode_end,
3002 .receive_frame = ff_mjpeg_receive_frame,
3003 .flush = decode_flush,
3004 .capabilities = AV_CODEC_CAP_DR1,
3005 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3006 FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP,