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 ret = ff_mjpeg_build_vlc(&s->vlcs[ht[i].class][ht[i].index],
80 ht[i].bits, ht[i].values,
81 ht[i].class == 1, s->avctx);
85 if (ht[i].class < 2) {
86 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
88 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
89 ht[i].values, ht[i].length);
96 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
99 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
100 s->interlace_polarity = 1;
101 if (len > 14 && buf[12] == 2) /* 2 - PAL */
102 s->interlace_polarity = 0;
103 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
104 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
107 static void init_idct(AVCodecContext *avctx)
109 MJpegDecodeContext *s = avctx->priv_data;
111 ff_idctdsp_init(&s->idsp, avctx);
112 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
116 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
118 MJpegDecodeContext *s = avctx->priv_data;
121 if (!s->picture_ptr) {
122 s->picture = av_frame_alloc();
124 return AVERROR(ENOMEM);
125 s->picture_ptr = s->picture;
128 s->pkt = av_packet_alloc();
130 return AVERROR(ENOMEM);
133 ff_blockdsp_init(&s->bdsp, avctx);
134 ff_hpeldsp_init(&s->hdsp, avctx->flags);
139 s->first_picture = 1;
141 s->orig_height = avctx->coded_height;
142 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
143 avctx->colorspace = AVCOL_SPC_BT470BG;
144 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
146 if ((ret = init_default_huffman_tables(s)) < 0)
149 if (s->extern_huff) {
150 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
151 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
153 if (ff_mjpeg_decode_dht(s)) {
154 av_log(avctx, AV_LOG_ERROR,
155 "error using external huffman table, switching back to internal\n");
156 init_default_huffman_tables(s);
159 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
160 s->interlace_polarity = 1; /* bottom field first */
161 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
162 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
163 if (avctx->codec_tag == AV_RL32("MJPG"))
164 s->interlace_polarity = 1;
167 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
168 if (avctx->extradata_size >= 4)
169 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
171 if (s->smv_frames_per_jpeg <= 0) {
172 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
173 return AVERROR_INVALIDDATA;
176 s->smv_frame = av_frame_alloc();
178 return AVERROR(ENOMEM);
179 } else if (avctx->extradata_size > 8
180 && AV_RL32(avctx->extradata) == 0x2C
181 && AV_RL32(avctx->extradata+4) == 0x18) {
182 parse_avid(s, avctx->extradata, avctx->extradata_size);
185 if (avctx->codec->id == AV_CODEC_ID_AMV)
192 /* quantize tables */
193 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
197 len = get_bits(&s->gb, 16) - 2;
199 if (8*len > get_bits_left(&s->gb)) {
200 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
201 return AVERROR_INVALIDDATA;
205 int pr = get_bits(&s->gb, 4);
207 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
208 return AVERROR_INVALIDDATA;
210 index = get_bits(&s->gb, 4);
213 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
214 /* read quant table */
215 for (i = 0; i < 64; i++) {
216 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
217 if (s->quant_matrixes[index][i] == 0) {
218 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
219 return AVERROR_INVALIDDATA;
223 // XXX FIXME fine-tune, and perhaps add dc too
224 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
225 s->quant_matrixes[index][8]) >> 1;
226 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
227 index, s->qscale[index]);
228 len -= 1 + 64 * (1+pr);
233 /* decode huffman tables and build VLC decoders */
234 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
236 int len, index, i, class, n, v;
237 uint8_t bits_table[17];
238 uint8_t val_table[256];
241 len = get_bits(&s->gb, 16) - 2;
243 if (8*len > get_bits_left(&s->gb)) {
244 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
245 return AVERROR_INVALIDDATA;
250 return AVERROR_INVALIDDATA;
251 class = get_bits(&s->gb, 4);
253 return AVERROR_INVALIDDATA;
254 index = get_bits(&s->gb, 4);
256 return AVERROR_INVALIDDATA;
258 for (i = 1; i <= 16; i++) {
259 bits_table[i] = get_bits(&s->gb, 8);
263 if (len < n || n > 256)
264 return AVERROR_INVALIDDATA;
266 for (i = 0; i < n; i++) {
267 v = get_bits(&s->gb, 8);
272 /* build VLC and flush previous vlc if present */
273 ff_free_vlc(&s->vlcs[class][index]);
274 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
276 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table,
277 val_table, class > 0, s->avctx)) < 0)
281 ff_free_vlc(&s->vlcs[2][index]);
282 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table,
283 val_table, 0, s->avctx)) < 0)
287 for (i = 0; i < 16; i++)
288 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
289 for (i = 0; i < 256; i++)
290 s->raw_huffman_values[class][index][i] = val_table[i];
295 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
297 int len, nb_components, i, width, height, bits, ret, size_change;
299 int h_count[MAX_COMPONENTS] = { 0 };
300 int v_count[MAX_COMPONENTS] = { 0 };
303 memset(s->upscale_h, 0, sizeof(s->upscale_h));
304 memset(s->upscale_v, 0, sizeof(s->upscale_v));
306 len = get_bits(&s->gb, 16);
307 bits = get_bits(&s->gb, 8);
309 if (bits > 16 || bits < 1) {
310 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
311 return AVERROR_INVALIDDATA;
314 if (s->avctx->bits_per_raw_sample != bits) {
315 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);
316 s->avctx->bits_per_raw_sample = bits;
321 if (bits == 9 && !s->pegasus_rct)
322 s->rct = 1; // FIXME ugly
324 if(s->lossless && s->avctx->lowres){
325 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
329 height = get_bits(&s->gb, 16);
330 width = get_bits(&s->gb, 16);
332 // HACK for odd_height.mov
333 if (s->interlaced && s->width == width && s->height == height + 1)
336 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
337 if (av_image_check_size(width, height, 0, s->avctx) < 0)
338 return AVERROR_INVALIDDATA;
339 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
340 return AVERROR_INVALIDDATA;
342 nb_components = get_bits(&s->gb, 8);
343 if (nb_components <= 0 ||
344 nb_components > MAX_COMPONENTS)
346 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
347 if (nb_components != s->nb_components) {
348 av_log(s->avctx, AV_LOG_ERROR,
349 "nb_components changing in interlaced picture\n");
350 return AVERROR_INVALIDDATA;
353 if (s->ls && !(bits <= 8 || nb_components == 1)) {
354 avpriv_report_missing_feature(s->avctx,
355 "JPEG-LS that is not <= 8 "
356 "bits/component or 16-bit gray");
357 return AVERROR_PATCHWELCOME;
359 if (len != 8 + 3 * nb_components) {
360 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
361 return AVERROR_INVALIDDATA;
364 s->nb_components = nb_components;
367 for (i = 0; i < nb_components; i++) {
369 s->component_id[i] = get_bits(&s->gb, 8) - 1;
370 h_count[i] = get_bits(&s->gb, 4);
371 v_count[i] = get_bits(&s->gb, 4);
372 /* compute hmax and vmax (only used in interleaved case) */
373 if (h_count[i] > s->h_max)
374 s->h_max = h_count[i];
375 if (v_count[i] > s->v_max)
376 s->v_max = v_count[i];
377 s->quant_index[i] = get_bits(&s->gb, 8);
378 if (s->quant_index[i] >= 4) {
379 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
380 return AVERROR_INVALIDDATA;
382 if (!h_count[i] || !v_count[i]) {
383 av_log(s->avctx, AV_LOG_ERROR,
384 "Invalid sampling factor in component %d %d:%d\n",
385 i, h_count[i], v_count[i]);
386 return AVERROR_INVALIDDATA;
389 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
390 i, h_count[i], v_count[i],
391 s->component_id[i], s->quant_index[i]);
393 if ( nb_components == 4
394 && s->component_id[0] == 'C' - 1
395 && s->component_id[1] == 'M' - 1
396 && s->component_id[2] == 'Y' - 1
397 && s->component_id[3] == 'K' - 1)
398 s->adobe_transform = 0;
400 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
401 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
402 return AVERROR_PATCHWELCOME;
406 if (nb_components == 2) {
407 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
408 width stored in their SOF3 markers is the width of each one. We only output
409 a single component, therefore we need to adjust the output image width. We
410 handle the deinterleaving (but not the debayering) in this file. */
413 /* They can also contain 1 component, which is double the width and half the height
414 of the final image (rows are interleaved). We don't handle the decoding in this
415 file, but leave that to the TIFF/DNG decoder. */
418 /* if different size, realloc/alloc picture */
419 if (width != s->width || height != s->height || bits != s->bits ||
420 memcmp(s->h_count, h_count, sizeof(h_count)) ||
421 memcmp(s->v_count, v_count, sizeof(v_count))) {
427 memcpy(s->h_count, h_count, sizeof(h_count));
428 memcpy(s->v_count, v_count, sizeof(v_count));
432 /* test interlaced mode */
433 if (s->first_picture &&
434 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
435 s->orig_height != 0 &&
436 s->height < ((s->orig_height * 3) / 4)) {
438 s->bottom_field = s->interlace_polarity;
439 s->picture_ptr->interlaced_frame = 1;
440 s->picture_ptr->top_field_first = !s->interlace_polarity;
444 ret = ff_set_dimensions(s->avctx, width, height);
448 s->first_picture = 0;
453 if ((s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
454 s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
455 s->orig_height < s->avctx->height)
456 s->avctx->height = s->orig_height;
458 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
459 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
460 if (s->avctx->height <= 0)
461 return AVERROR_INVALIDDATA;
464 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
465 if (s->progressive) {
466 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
467 return AVERROR_INVALIDDATA;
470 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
472 else if (!s->lossless)
474 /* XXX: not complete test ! */
475 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
476 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
477 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
478 (s->h_count[3] << 4) | s->v_count[3];
479 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
480 /* NOTE we do not allocate pictures large enough for the possible
481 * padding of h/v_count being 4 */
482 if (!(pix_fmt_id & 0xD0D0D0D0))
483 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
484 if (!(pix_fmt_id & 0x0D0D0D0D))
485 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
487 for (i = 0; i < 8; i++) {
488 int j = 6 + (i&1) - (i&6);
489 int is = (pix_fmt_id >> (4*i)) & 0xF;
490 int js = (pix_fmt_id >> (4*j)) & 0xF;
492 if (is == 1 && js != 2 && (i < 2 || i > 5))
493 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
494 if (is == 1 && js != 2 && (i < 2 || i > 5))
495 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
497 if (is == 1 && js == 2) {
498 if (i & 1) s->upscale_h[j/2] = 1;
499 else s->upscale_v[j/2] = 1;
504 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
508 switch (pix_fmt_id) {
509 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
512 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
516 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
518 if ( s->adobe_transform == 0
519 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
520 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
522 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
523 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
524 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
527 av_assert0(s->nb_components == 3);
531 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
533 if (s->adobe_transform == 0 && s->bits <= 8) {
534 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
536 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
537 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
540 av_assert0(s->nb_components == 4);
544 if (s->adobe_transform == 0 && s->bits <= 8) {
545 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
546 s->upscale_v[1] = s->upscale_v[2] = 1;
547 s->upscale_h[1] = s->upscale_h[2] = 1;
548 } else if (s->adobe_transform == 2 && s->bits <= 8) {
549 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
550 s->upscale_v[1] = s->upscale_v[2] = 1;
551 s->upscale_h[1] = s->upscale_h[2] = 1;
552 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
554 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
555 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
556 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
558 av_assert0(s->nb_components == 4);
567 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
570 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
582 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
584 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
591 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
592 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
595 s->upscale_v[0] = s->upscale_v[1] = 1;
597 if (pix_fmt_id == 0x14111100)
598 s->upscale_v[1] = s->upscale_v[2] = 1;
599 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
602 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
606 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
607 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
610 s->upscale_h[0] = s->upscale_h[1] = 1;
612 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
613 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
614 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
620 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
621 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
622 s->upscale_h[1] = s->upscale_h[2] = 2;
626 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
629 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
635 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
636 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
637 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
638 if (pix_fmt_id == 0x42111100) {
641 s->upscale_h[1] = s->upscale_h[2] = 1;
642 } else if (pix_fmt_id == 0x24111100) {
645 s->upscale_v[1] = s->upscale_v[2] = 1;
646 } else if (pix_fmt_id == 0x23111100) {
649 s->upscale_v[1] = s->upscale_v[2] = 2;
653 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
656 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
660 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
661 memset(s->upscale_h, 0, sizeof(s->upscale_h));
662 memset(s->upscale_v, 0, sizeof(s->upscale_v));
663 return AVERROR_PATCHWELCOME;
665 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
666 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
667 return AVERROR_PATCHWELCOME;
669 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
670 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
671 return AVERROR_PATCHWELCOME;
674 memset(s->upscale_h, 0, sizeof(s->upscale_h));
675 memset(s->upscale_v, 0, sizeof(s->upscale_v));
676 if (s->nb_components == 3) {
677 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
678 } else if (s->nb_components != 1) {
679 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
680 return AVERROR_PATCHWELCOME;
681 } else if (s->palette_index && s->bits <= 8)
682 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
683 else if (s->bits <= 8)
684 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
686 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
689 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
691 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
695 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
696 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
698 enum AVPixelFormat pix_fmts[] = {
699 #if CONFIG_MJPEG_NVDEC_HWACCEL
702 #if CONFIG_MJPEG_VAAPI_HWACCEL
708 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
709 if (s->hwaccel_pix_fmt < 0)
710 return AVERROR(EINVAL);
712 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
713 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
716 if (s->avctx->skip_frame == AVDISCARD_ALL) {
717 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
718 s->picture_ptr->key_frame = 1;
723 av_frame_unref(s->picture_ptr);
724 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
726 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
727 s->picture_ptr->key_frame = 1;
730 for (i = 0; i < 4; i++)
731 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
733 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
734 s->width, s->height, s->linesize[0], s->linesize[1],
735 s->interlaced, s->avctx->height);
739 if ((s->rgb && !s->lossless && !s->ls) ||
740 (!s->rgb && s->ls && s->nb_components > 1) ||
741 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
743 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
744 return AVERROR_PATCHWELCOME;
747 /* totally blank picture as progressive JPEG will only add details to it */
748 if (s->progressive) {
749 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
750 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
751 for (i = 0; i < s->nb_components; i++) {
752 int size = bw * bh * s->h_count[i] * s->v_count[i];
753 av_freep(&s->blocks[i]);
754 av_freep(&s->last_nnz[i]);
755 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
756 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
757 if (!s->blocks[i] || !s->last_nnz[i])
758 return AVERROR(ENOMEM);
759 s->block_stride[i] = bw * s->h_count[i];
761 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
764 if (s->avctx->hwaccel) {
765 s->hwaccel_picture_private =
766 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
767 if (!s->hwaccel_picture_private)
768 return AVERROR(ENOMEM);
770 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
771 s->raw_image_buffer_size);
779 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
782 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
783 if (code < 0 || code > 16) {
784 av_log(s->avctx, AV_LOG_WARNING,
785 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
786 0, dc_index, &s->vlcs[0][dc_index]);
791 return get_xbits(&s->gb, code);
796 /* decode block and dequantize */
797 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
798 int dc_index, int ac_index, uint16_t *quant_matrix)
800 int code, i, j, level, val;
803 val = mjpeg_decode_dc(s, dc_index);
804 if (val == 0xfffff) {
805 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
806 return AVERROR_INVALIDDATA;
808 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
809 val = av_clip_int16(val);
810 s->last_dc[component] = val;
814 {OPEN_READER(re, &s->gb);
816 UPDATE_CACHE(re, &s->gb);
817 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
819 i += ((unsigned)code) >> 4;
822 if (code > MIN_CACHE_BITS - 16)
823 UPDATE_CACHE(re, &s->gb);
826 int cache = GET_CACHE(re, &s->gb);
827 int sign = (~cache) >> 31;
828 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
831 LAST_SKIP_BITS(re, &s->gb, code);
834 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
835 return AVERROR_INVALIDDATA;
837 j = s->scantable.permutated[i];
838 block[j] = level * quant_matrix[i];
841 CLOSE_READER(re, &s->gb);}
846 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
847 int component, int dc_index,
848 uint16_t *quant_matrix, int Al)
851 s->bdsp.clear_block(block);
852 val = mjpeg_decode_dc(s, dc_index);
853 if (val == 0xfffff) {
854 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
855 return AVERROR_INVALIDDATA;
857 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
858 s->last_dc[component] = val;
863 /* decode block and dequantize - progressive JPEG version */
864 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
865 uint8_t *last_nnz, int ac_index,
866 uint16_t *quant_matrix,
867 int ss, int se, int Al, int *EOBRUN)
869 int code, i, j, val, run;
878 OPEN_READER(re, &s->gb);
879 for (i = ss; ; i++) {
880 UPDATE_CACHE(re, &s->gb);
881 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
883 run = ((unsigned) code) >> 4;
887 if (code > MIN_CACHE_BITS - 16)
888 UPDATE_CACHE(re, &s->gb);
891 int cache = GET_CACHE(re, &s->gb);
892 int sign = (~cache) >> 31;
893 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
896 LAST_SKIP_BITS(re, &s->gb, code);
900 j = s->scantable.permutated[se];
901 block[j] = level * (quant_matrix[se] << Al);
904 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
905 return AVERROR_INVALIDDATA;
907 j = s->scantable.permutated[i];
908 block[j] = level * (quant_matrix[i] << Al);
910 if (run == 0xF) {// ZRL - skip 15 coefficients
913 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
914 return AVERROR_INVALIDDATA;
919 UPDATE_CACHE(re, &s->gb);
920 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
921 LAST_SKIP_BITS(re, &s->gb, run);
928 CLOSE_READER(re, &s->gb);
937 #define REFINE_BIT(j) { \
938 UPDATE_CACHE(re, &s->gb); \
939 sign = block[j] >> 15; \
940 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
941 ((quant_matrix[i] ^ sign) - sign) << Al; \
942 LAST_SKIP_BITS(re, &s->gb, 1); \
950 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
955 j = s->scantable.permutated[i]; \
958 else if (run-- == 0) \
962 /* decode block and dequantize - progressive JPEG refinement pass */
963 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
965 int ac_index, uint16_t *quant_matrix,
966 int ss, int se, int Al, int *EOBRUN)
968 int code, i = ss, j, sign, val, run;
969 int last = FFMIN(se, *last_nnz);
971 OPEN_READER(re, &s->gb);
976 UPDATE_CACHE(re, &s->gb);
977 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
980 run = ((unsigned) code) >> 4;
981 UPDATE_CACHE(re, &s->gb);
982 val = SHOW_UBITS(re, &s->gb, 1);
983 LAST_SKIP_BITS(re, &s->gb, 1);
985 j = s->scantable.permutated[i];
987 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
991 CLOSE_READER(re, &s->gb);
995 run = ((unsigned) code) >> 4;
1002 UPDATE_CACHE(re, &s->gb);
1003 run += SHOW_UBITS(re, &s->gb, val);
1004 LAST_SKIP_BITS(re, &s->gb, val);
1016 for (; i <= last; i++) {
1017 j = s->scantable.permutated[i];
1021 CLOSE_READER(re, &s->gb);
1028 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1033 if (s->restart_interval) {
1035 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1036 align_get_bits(&s->gb);
1037 for (i = 0; i < nb_components; i++) /* reset dc */
1038 s->last_dc[i] = (4 << s->bits);
1041 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1043 if (s->restart_count == 0) {
1044 if( show_bits(&s->gb, i) == (1 << i) - 1
1045 || show_bits(&s->gb, i) == 0xFF) {
1046 int pos = get_bits_count(&s->gb);
1047 align_get_bits(&s->gb);
1048 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1049 skip_bits(&s->gb, 8);
1050 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1051 for (i = 0; i < nb_components; i++) /* reset dc */
1052 s->last_dc[i] = (4 << s->bits);
1055 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1062 /* Handles 1 to 4 components */
1063 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1067 uint16_t (*buffer)[4];
1068 int left[4], top[4], topleft[4];
1069 const int linesize = s->linesize[0];
1070 const int mask = ((1 << s->bits) - 1) << point_transform;
1071 int resync_mb_y = 0;
1072 int resync_mb_x = 0;
1075 if (!s->bayer && s->nb_components < 3)
1076 return AVERROR_INVALIDDATA;
1077 if (s->bayer && s->nb_components > 2)
1078 return AVERROR_INVALIDDATA;
1079 if (s->nb_components <= 0 || s->nb_components > 4)
1080 return AVERROR_INVALIDDATA;
1081 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1082 return AVERROR_INVALIDDATA;
1085 s->restart_count = s->restart_interval;
1087 if (s->restart_interval == 0)
1088 s->restart_interval = INT_MAX;
1091 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1093 width = s->mb_width;
1095 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1096 if (!s->ljpeg_buffer)
1097 return AVERROR(ENOMEM);
1099 buffer = s->ljpeg_buffer;
1101 for (i = 0; i < 4; i++)
1102 buffer[0][i] = 1 << (s->bits - 1);
1104 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1105 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1107 if (s->interlaced && s->bottom_field)
1108 ptr += linesize >> 1;
1110 for (i = 0; i < 4; i++)
1111 top[i] = left[i] = topleft[i] = buffer[0][i];
1113 if ((mb_y * s->width) % s->restart_interval == 0) {
1114 for (i = 0; i < 6; i++)
1115 vpred[i] = 1 << (s->bits-1);
1118 for (mb_x = 0; mb_x < width; mb_x++) {
1119 int modified_predictor = predictor;
1121 if (get_bits_left(&s->gb) < 1) {
1122 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1123 return AVERROR_INVALIDDATA;
1126 if (s->restart_interval && !s->restart_count){
1127 s->restart_count = s->restart_interval;
1131 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1133 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1134 modified_predictor = 1;
1136 for (i=0;i<nb_components;i++) {
1139 topleft[i] = top[i];
1140 top[i] = buffer[mb_x][i];
1142 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1146 if (!s->bayer || mb_x) {
1148 } else { /* This path runs only for the first line in bayer images */
1150 pred = vpred[i] - dc;
1153 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1155 left[i] = buffer[mb_x][i] =
1156 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1159 if (s->restart_interval && !--s->restart_count) {
1160 align_get_bits(&s->gb);
1161 skip_bits(&s->gb, 16); /* skip RSTn */
1164 if (s->rct && s->nb_components == 4) {
1165 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1166 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1167 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1168 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1169 ptr[4*mb_x + 0] = buffer[mb_x][3];
1171 } else if (s->nb_components == 4) {
1172 for(i=0; i<nb_components; i++) {
1173 int c= s->comp_index[i];
1175 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1176 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1178 } else if(s->bits == 9) {
1179 return AVERROR_PATCHWELCOME;
1181 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1182 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1186 } else if (s->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] - 0x200) >> 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->pegasus_rct) {
1193 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1194 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1195 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1196 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1198 } else if (s->bayer) {
1199 if (nb_components == 1) {
1200 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1201 for (mb_x = 0; mb_x < width; mb_x++)
1202 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1203 } else if (nb_components == 2) {
1204 for (mb_x = 0; mb_x < width; mb_x++) {
1205 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1206 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1210 for(i=0; i<nb_components; i++) {
1211 int c= s->comp_index[i];
1213 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1214 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1216 } else if(s->bits == 9) {
1217 return AVERROR_PATCHWELCOME;
1219 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1220 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1229 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1230 int point_transform, int nb_components)
1232 int i, mb_x, mb_y, mask;
1233 int bits= (s->bits+7)&~7;
1234 int resync_mb_y = 0;
1235 int resync_mb_x = 0;
1237 point_transform += bits - s->bits;
1238 mask = ((1 << s->bits) - 1) << point_transform;
1240 av_assert0(nb_components>=1 && nb_components<=4);
1242 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1243 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1244 if (get_bits_left(&s->gb) < 1) {
1245 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1246 return AVERROR_INVALIDDATA;
1248 if (s->restart_interval && !s->restart_count){
1249 s->restart_count = s->restart_interval;
1254 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1255 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1256 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1257 for (i = 0; i < nb_components; i++) {
1260 int n, h, v, x, y, c, j, linesize;
1261 n = s->nb_blocks[i];
1262 c = s->comp_index[i];
1267 linesize= s->linesize[c];
1269 if(bits>8) linesize /= 2;
1271 for(j=0; j<n; j++) {
1274 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1277 if ( h * mb_x + x >= s->width
1278 || v * mb_y + y >= s->height) {
1280 } else if (bits<=8) {
1281 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1283 if(x==0 && leftcol){
1284 pred= 1 << (bits - 1);
1289 if(x==0 && leftcol){
1290 pred= ptr[-linesize];
1292 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296 if (s->interlaced && s->bottom_field)
1297 ptr += linesize >> 1;
1299 *ptr= pred + ((unsigned)dc << point_transform);
1301 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1303 if(x==0 && leftcol){
1304 pred= 1 << (bits - 1);
1309 if(x==0 && leftcol){
1310 pred= ptr16[-linesize];
1312 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1316 if (s->interlaced && s->bottom_field)
1317 ptr16 += linesize >> 1;
1319 *ptr16= pred + ((unsigned)dc << point_transform);
1328 for (i = 0; i < nb_components; i++) {
1331 int n, h, v, x, y, c, j, linesize, dc;
1332 n = s->nb_blocks[i];
1333 c = s->comp_index[i];
1338 linesize = s->linesize[c];
1340 if(bits>8) linesize /= 2;
1342 for (j = 0; j < n; j++) {
1345 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1348 if ( h * mb_x + x >= s->width
1349 || v * mb_y + y >= s->height) {
1351 } else if (bits<=8) {
1352 ptr = s->picture_ptr->data[c] +
1353 (linesize * (v * mb_y + y)) +
1354 (h * mb_x + x); //FIXME optimize this crap
1355 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1358 *ptr = pred + ((unsigned)dc << point_transform);
1360 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1361 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1364 *ptr16= pred + ((unsigned)dc << point_transform);
1374 if (s->restart_interval && !--s->restart_count) {
1375 align_get_bits(&s->gb);
1376 skip_bits(&s->gb, 16); /* skip RSTn */
1383 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1384 uint8_t *dst, const uint8_t *src,
1385 int linesize, int lowres)
1388 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1390 case 1: copy_block4(dst, src, linesize, linesize, 4);
1392 case 2: copy_block2(dst, src, linesize, linesize, 2);
1394 case 3: *dst = *src;
1399 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1401 int block_x, block_y;
1402 int size = 8 >> s->avctx->lowres;
1404 for (block_y=0; block_y<size; block_y++)
1405 for (block_x=0; block_x<size; block_x++)
1406 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1408 for (block_y=0; block_y<size; block_y++)
1409 for (block_x=0; block_x<size; block_x++)
1410 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1414 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1415 int Al, const uint8_t *mb_bitmask,
1416 int mb_bitmask_size,
1417 const AVFrame *reference)
1419 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1420 uint8_t *data[MAX_COMPONENTS];
1421 const uint8_t *reference_data[MAX_COMPONENTS];
1422 int linesize[MAX_COMPONENTS];
1423 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1424 int bytes_per_pixel = 1 + (s->bits > 8);
1427 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1428 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1429 return AVERROR_INVALIDDATA;
1431 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1434 s->restart_count = 0;
1436 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1438 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1439 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1441 for (i = 0; i < nb_components; i++) {
1442 int c = s->comp_index[i];
1443 data[c] = s->picture_ptr->data[c];
1444 reference_data[c] = reference ? reference->data[c] : NULL;
1445 linesize[c] = s->linesize[c];
1446 s->coefs_finished[c] |= 1;
1449 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1450 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1451 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1453 if (s->restart_interval && !s->restart_count)
1454 s->restart_count = s->restart_interval;
1456 if (get_bits_left(&s->gb) < 0) {
1457 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1458 -get_bits_left(&s->gb));
1459 return AVERROR_INVALIDDATA;
1461 for (i = 0; i < nb_components; i++) {
1463 int n, h, v, x, y, c, j;
1465 n = s->nb_blocks[i];
1466 c = s->comp_index[i];
1471 for (j = 0; j < n; j++) {
1472 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1473 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1475 if (s->interlaced && s->bottom_field)
1476 block_offset += linesize[c] >> 1;
1477 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1478 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1479 ptr = data[c] + block_offset;
1482 if (!s->progressive) {
1485 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1486 linesize[c], s->avctx->lowres);
1489 s->bdsp.clear_block(s->block);
1490 if (decode_block(s, s->block, i,
1491 s->dc_index[i], s->ac_index[i],
1492 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1493 av_log(s->avctx, AV_LOG_ERROR,
1494 "error y=%d x=%d\n", mb_y, mb_x);
1495 return AVERROR_INVALIDDATA;
1498 s->idsp.idct_put(ptr, linesize[c], s->block);
1500 shift_output(s, ptr, linesize[c]);
1504 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1506 int16_t *block = s->blocks[c][block_idx];
1508 block[0] += get_bits1(&s->gb) *
1509 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1510 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1511 s->quant_matrixes[s->quant_sindex[i]],
1513 av_log(s->avctx, AV_LOG_ERROR,
1514 "error y=%d x=%d\n", mb_y, mb_x);
1515 return AVERROR_INVALIDDATA;
1518 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1519 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1520 mb_x, mb_y, x, y, c, s->bottom_field,
1521 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1529 handle_rstn(s, nb_components);
1535 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1536 int se, int Ah, int Al)
1540 int c = s->comp_index[0];
1541 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1543 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1544 if (se < ss || se > 63) {
1545 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1546 return AVERROR_INVALIDDATA;
1549 // s->coefs_finished is a bitmask for coefficients coded
1550 // ss and se are parameters telling start and end coefficients
1551 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1553 s->restart_count = 0;
1555 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1556 int block_idx = mb_y * s->block_stride[c];
1557 int16_t (*block)[64] = &s->blocks[c][block_idx];
1558 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1559 if (get_bits_left(&s->gb) <= 0) {
1560 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1561 return AVERROR_INVALIDDATA;
1563 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1565 if (s->restart_interval && !s->restart_count)
1566 s->restart_count = s->restart_interval;
1569 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1570 quant_matrix, ss, se, Al, &EOBRUN);
1572 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1573 quant_matrix, ss, se, Al, &EOBRUN);
1575 av_log(s->avctx, AV_LOG_ERROR,
1576 "error y=%d x=%d\n", mb_y, mb_x);
1577 return AVERROR_INVALIDDATA;
1580 if (handle_rstn(s, 0))
1587 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1591 const int bytes_per_pixel = 1 + (s->bits > 8);
1592 const int block_size = s->lossless ? 1 : 8;
1594 for (c = 0; c < s->nb_components; c++) {
1595 uint8_t *data = s->picture_ptr->data[c];
1596 int linesize = s->linesize[c];
1597 int h = s->h_max / s->h_count[c];
1598 int v = s->v_max / s->v_count[c];
1599 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1600 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1602 if (~s->coefs_finished[c])
1603 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1605 if (s->interlaced && s->bottom_field)
1606 data += linesize >> 1;
1608 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1609 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1610 int block_idx = mb_y * s->block_stride[c];
1611 int16_t (*block)[64] = &s->blocks[c][block_idx];
1612 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1613 s->idsp.idct_put(ptr, linesize, *block);
1615 shift_output(s, ptr, linesize);
1616 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1622 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1623 int mb_bitmask_size, const AVFrame *reference)
1625 int len, nb_components, i, h, v, predictor, point_transform;
1627 const int block_size = s->lossless ? 1 : 8;
1628 int ilv, prev_shift;
1630 if (!s->got_picture) {
1631 av_log(s->avctx, AV_LOG_WARNING,
1632 "Can not process SOS before SOF, skipping\n");
1637 if (reference->width != s->picture_ptr->width ||
1638 reference->height != s->picture_ptr->height ||
1639 reference->format != s->picture_ptr->format) {
1640 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1641 return AVERROR_INVALIDDATA;
1645 /* XXX: verify len field validity */
1646 len = get_bits(&s->gb, 16);
1647 nb_components = get_bits(&s->gb, 8);
1648 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1649 avpriv_report_missing_feature(s->avctx,
1650 "decode_sos: nb_components (%d)",
1652 return AVERROR_PATCHWELCOME;
1654 if (len != 6 + 2 * nb_components) {
1655 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1656 return AVERROR_INVALIDDATA;
1658 for (i = 0; i < nb_components; i++) {
1659 id = get_bits(&s->gb, 8) - 1;
1660 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1661 /* find component index */
1662 for (index = 0; index < s->nb_components; index++)
1663 if (id == s->component_id[index])
1665 if (index == s->nb_components) {
1666 av_log(s->avctx, AV_LOG_ERROR,
1667 "decode_sos: index(%d) out of components\n", index);
1668 return AVERROR_INVALIDDATA;
1670 /* Metasoft MJPEG codec has Cb and Cr swapped */
1671 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1672 && nb_components == 3 && s->nb_components == 3 && i)
1675 s->quant_sindex[i] = s->quant_index[index];
1676 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1677 s->h_scount[i] = s->h_count[index];
1678 s->v_scount[i] = s->v_count[index];
1680 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1681 index = (index+2)%3;
1683 s->comp_index[i] = index;
1685 s->dc_index[i] = get_bits(&s->gb, 4);
1686 s->ac_index[i] = get_bits(&s->gb, 4);
1688 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1689 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1691 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))
1695 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1696 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1697 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1698 prev_shift = get_bits(&s->gb, 4); /* Ah */
1699 point_transform = get_bits(&s->gb, 4); /* Al */
1701 prev_shift = point_transform = 0;
1703 if (nb_components > 1) {
1704 /* interleaved stream */
1705 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1706 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1707 } else if (!s->ls) { /* skip this for JPEG-LS */
1708 h = s->h_max / s->h_scount[0];
1709 v = s->v_max / s->v_scount[0];
1710 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1711 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1712 s->nb_blocks[0] = 1;
1717 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1719 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1720 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1721 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1724 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1725 for (i = s->mjpb_skiptosod; i > 0; i--)
1726 skip_bits(&s->gb, 8);
1729 for (i = 0; i < nb_components; i++)
1730 s->last_dc[i] = (4 << s->bits);
1732 if (s->avctx->hwaccel) {
1733 int bytes_to_start = get_bits_count(&s->gb) / 8;
1734 av_assert0(bytes_to_start >= 0 &&
1735 s->raw_scan_buffer_size >= bytes_to_start);
1737 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1738 s->raw_scan_buffer + bytes_to_start,
1739 s->raw_scan_buffer_size - bytes_to_start);
1743 } else if (s->lossless) {
1744 av_assert0(s->picture_ptr == s->picture);
1745 if (CONFIG_JPEGLS_DECODER && s->ls) {
1747 // reset_ls_coding_parameters(s, 0);
1749 if ((ret = ff_jpegls_decode_picture(s, predictor,
1750 point_transform, ilv)) < 0)
1753 if (s->rgb || s->bayer) {
1754 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1757 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1759 nb_components)) < 0)
1764 if (s->progressive && predictor) {
1765 av_assert0(s->picture_ptr == s->picture);
1766 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1768 point_transform)) < 0)
1771 if ((ret = mjpeg_decode_scan(s, nb_components,
1772 prev_shift, point_transform,
1773 mb_bitmask, mb_bitmask_size, reference)) < 0)
1778 if (s->interlaced &&
1779 get_bits_left(&s->gb) > 32 &&
1780 show_bits(&s->gb, 8) == 0xFF) {
1781 GetBitContext bak = s->gb;
1782 align_get_bits(&bak);
1783 if (show_bits(&bak, 16) == 0xFFD1) {
1784 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1786 skip_bits(&s->gb, 16);
1787 s->bottom_field ^= 1;
1796 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1797 return AVERROR_INVALIDDATA;
1800 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1802 if (get_bits(&s->gb, 16) != 4)
1803 return AVERROR_INVALIDDATA;
1804 s->restart_interval = get_bits(&s->gb, 16);
1805 s->restart_count = 0;
1806 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1807 s->restart_interval);
1812 static int mjpeg_decode_app(MJpegDecodeContext *s)
1816 len = get_bits(&s->gb, 16);
1819 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1820 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1821 skip_bits(&s->gb, len);
1824 return AVERROR_INVALIDDATA;
1826 if (8 * len > get_bits_left(&s->gb))
1827 return AVERROR_INVALIDDATA;
1829 id = get_bits_long(&s->gb, 32);
1832 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1833 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1834 av_fourcc2str(av_bswap32(id)), id, len);
1836 /* Buggy AVID, it puts EOI only at every 10th frame. */
1837 /* Also, this fourcc is used by non-avid files too, it holds some
1838 information, but it's always present in AVID-created files. */
1839 if (id == AV_RB32("AVI1")) {
1845 4bytes field_size_less_padding
1848 i = get_bits(&s->gb, 8); len--;
1849 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1853 if (id == AV_RB32("JFIF")) {
1854 int t_w, t_h, v1, v2;
1857 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1858 v1 = get_bits(&s->gb, 8);
1859 v2 = get_bits(&s->gb, 8);
1860 skip_bits(&s->gb, 8);
1862 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1863 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1864 if ( s->avctx->sample_aspect_ratio.num <= 0
1865 || s->avctx->sample_aspect_ratio.den <= 0) {
1866 s->avctx->sample_aspect_ratio.num = 0;
1867 s->avctx->sample_aspect_ratio.den = 1;
1870 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1871 av_log(s->avctx, AV_LOG_INFO,
1872 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1874 s->avctx->sample_aspect_ratio.num,
1875 s->avctx->sample_aspect_ratio.den);
1879 t_w = get_bits(&s->gb, 8);
1880 t_h = get_bits(&s->gb, 8);
1882 /* skip thumbnail */
1883 if (len -10 - (t_w * t_h * 3) > 0)
1884 len -= t_w * t_h * 3;
1891 if ( id == AV_RB32("Adob")
1893 && show_bits(&s->gb, 8) == 'e'
1894 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1895 skip_bits(&s->gb, 8); /* 'e' */
1896 skip_bits(&s->gb, 16); /* version */
1897 skip_bits(&s->gb, 16); /* flags0 */
1898 skip_bits(&s->gb, 16); /* flags1 */
1899 s->adobe_transform = get_bits(&s->gb, 8);
1900 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1901 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1906 if (id == AV_RB32("LJIF")) {
1908 int pegasus_rct = s->pegasus_rct;
1909 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1910 av_log(s->avctx, AV_LOG_INFO,
1911 "Pegasus lossless jpeg header found\n");
1912 skip_bits(&s->gb, 16); /* version ? */
1913 skip_bits(&s->gb, 16); /* unknown always 0? */
1914 skip_bits(&s->gb, 16); /* unknown always 0? */
1915 skip_bits(&s->gb, 16); /* unknown always 0? */
1916 switch (i=get_bits(&s->gb, 8)) {
1926 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1931 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1932 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1937 s->pegasus_rct = pegasus_rct;
1941 if (id == AV_RL32("colr") && len > 0) {
1942 s->colr = get_bits(&s->gb, 8);
1943 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1944 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1948 if (id == AV_RL32("xfrm") && len > 0) {
1949 s->xfrm = get_bits(&s->gb, 8);
1950 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1951 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1956 /* JPS extension by VRex */
1957 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1958 int flags, layout, type;
1959 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1960 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1962 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1963 skip_bits(&s->gb, 16); len -= 2; /* block length */
1964 skip_bits(&s->gb, 8); /* reserved */
1965 flags = get_bits(&s->gb, 8);
1966 layout = get_bits(&s->gb, 8);
1967 type = get_bits(&s->gb, 8);
1970 av_freep(&s->stereo3d);
1971 s->stereo3d = av_stereo3d_alloc();
1976 s->stereo3d->type = AV_STEREO3D_2D;
1977 } else if (type == 1) {
1980 s->stereo3d->type = AV_STEREO3D_LINES;
1983 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1986 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1989 if (!(flags & 0x04)) {
1990 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1997 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1998 GetByteContext gbytes;
1999 int ret, le, ifd_offset, bytes_read;
2000 const uint8_t *aligned;
2002 skip_bits(&s->gb, 16); // skip padding
2005 // init byte wise reading
2006 aligned = align_get_bits(&s->gb);
2007 bytestream2_init(&gbytes, aligned, len);
2010 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2012 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2014 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2016 // read 0th IFD and store the metadata
2017 // (return values > 0 indicate the presence of subimage metadata)
2018 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2020 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2024 bytes_read = bytestream2_tell(&gbytes);
2025 skip_bits(&s->gb, bytes_read << 3);
2032 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2033 id = get_bits_long(&s->gb, 32);
2036 if (id == AV_RB32("mjpg")) {
2039 4bytes pad field size
2047 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2048 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2052 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2055 unsigned nummarkers;
2057 id = get_bits_long(&s->gb, 32);
2058 id2 = get_bits(&s->gb, 24);
2060 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2061 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2065 skip_bits(&s->gb, 8);
2066 seqno = get_bits(&s->gb, 8);
2069 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2073 nummarkers = get_bits(&s->gb, 8);
2075 if (nummarkers == 0) {
2076 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2078 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2079 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2081 } else if (seqno > nummarkers) {
2082 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2086 /* Allocate if this is the first APP2 we've seen. */
2087 if (s->iccnum == 0) {
2088 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2089 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2090 if (!s->iccdata || !s->iccdatalens) {
2091 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2092 return AVERROR(ENOMEM);
2094 s->iccnum = nummarkers;
2097 if (s->iccdata[seqno - 1]) {
2098 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2102 s->iccdatalens[seqno - 1] = len;
2103 s->iccdata[seqno - 1] = av_malloc(len);
2104 if (!s->iccdata[seqno - 1]) {
2105 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2106 return AVERROR(ENOMEM);
2109 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2110 skip_bits(&s->gb, len << 3);
2114 if (s->iccread > s->iccnum)
2115 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2119 /* slow but needed for extreme adobe jpegs */
2121 av_log(s->avctx, AV_LOG_ERROR,
2122 "mjpeg: error, decode_app parser read over the end\n");
2124 skip_bits(&s->gb, 8);
2129 static int mjpeg_decode_com(MJpegDecodeContext *s)
2131 int len = get_bits(&s->gb, 16);
2132 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2134 char *cbuf = av_malloc(len - 1);
2136 return AVERROR(ENOMEM);
2138 for (i = 0; i < len - 2; i++)
2139 cbuf[i] = get_bits(&s->gb, 8);
2140 if (i > 0 && cbuf[i - 1] == '\n')
2145 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2146 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2148 /* buggy avid, it puts EOI only at every 10th frame */
2149 if (!strncmp(cbuf, "AVID", 4)) {
2150 parse_avid(s, cbuf, len);
2151 } else if (!strcmp(cbuf, "CS=ITU601"))
2153 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2154 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2156 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2157 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2167 /* return the 8 bit start code value and update the search
2168 state. Return -1 if no start code found */
2169 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2171 const uint8_t *buf_ptr;
2176 buf_ptr = *pbuf_ptr;
2177 while (buf_end - buf_ptr > 1) {
2180 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2189 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2190 *pbuf_ptr = buf_ptr;
2194 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2195 const uint8_t **buf_ptr, const uint8_t *buf_end,
2196 const uint8_t **unescaped_buf_ptr,
2197 int *unescaped_buf_size)
2200 start_code = find_marker(buf_ptr, buf_end);
2202 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2204 return AVERROR(ENOMEM);
2206 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2207 if (start_code == SOS && !s->ls) {
2208 const uint8_t *src = *buf_ptr;
2209 const uint8_t *ptr = src;
2210 uint8_t *dst = s->buffer;
2212 #define copy_data_segment(skip) do { \
2213 ptrdiff_t length = (ptr - src) - (skip); \
2215 memcpy(dst, src, length); \
2221 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2223 copy_data_segment(0);
2225 while (ptr < buf_end) {
2226 uint8_t x = *(ptr++);
2230 while (ptr < buf_end && x == 0xff) {
2235 /* 0xFF, 0xFF, ... */
2237 copy_data_segment(skip);
2239 /* decrement src as it is equal to ptr after the
2240 * copy_data_segment macro and we might want to
2241 * copy the current value of x later on */
2245 if (x < RST0 || x > RST7) {
2246 copy_data_segment(1);
2253 copy_data_segment(0);
2255 #undef copy_data_segment
2257 *unescaped_buf_ptr = s->buffer;
2258 *unescaped_buf_size = dst - s->buffer;
2259 memset(s->buffer + *unescaped_buf_size, 0,
2260 AV_INPUT_BUFFER_PADDING_SIZE);
2262 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2263 (buf_end - *buf_ptr) - (dst - s->buffer));
2264 } else if (start_code == SOS && s->ls) {
2265 const uint8_t *src = *buf_ptr;
2266 uint8_t *dst = s->buffer;
2272 while (src + t < buf_end) {
2273 uint8_t x = src[t++];
2275 while ((src + t < buf_end) && x == 0xff)
2284 init_put_bits(&pb, dst, t);
2286 /* unescape bitstream */
2288 uint8_t x = src[b++];
2289 put_bits(&pb, 8, x);
2290 if (x == 0xFF && b < t) {
2293 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2296 put_bits(&pb, 7, x);
2300 flush_put_bits(&pb);
2302 *unescaped_buf_ptr = dst;
2303 *unescaped_buf_size = (bit_count + 7) >> 3;
2304 memset(s->buffer + *unescaped_buf_size, 0,
2305 AV_INPUT_BUFFER_PADDING_SIZE);
2307 *unescaped_buf_ptr = *buf_ptr;
2308 *unescaped_buf_size = buf_end - *buf_ptr;
2314 static void reset_icc_profile(MJpegDecodeContext *s)
2319 for (i = 0; i < s->iccnum; i++)
2320 av_freep(&s->iccdata[i]);
2321 av_freep(&s->iccdata);
2322 av_freep(&s->iccdatalens);
2328 // SMV JPEG just stacks several output frames into one JPEG picture
2329 // we handle that by setting up the cropping parameters appropriately
2330 static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2332 MJpegDecodeContext *s = avctx->priv_data;
2335 if (s->smv_next_frame > 0) {
2336 av_assert0(s->smv_frame->buf[0]);
2337 av_frame_unref(frame);
2338 ret = av_frame_ref(frame, s->smv_frame);
2342 av_assert0(frame->buf[0]);
2343 av_frame_unref(s->smv_frame);
2344 ret = av_frame_ref(s->smv_frame, frame);
2349 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2351 frame->width = avctx->coded_width;
2352 frame->height = avctx->coded_height;
2353 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2354 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2356 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2358 if (s->smv_next_frame == 0)
2359 av_frame_unref(s->smv_frame);
2364 static int mjpeg_get_packet(AVCodecContext *avctx)
2366 MJpegDecodeContext *s = avctx->priv_data;
2369 av_packet_unref(s->pkt);
2370 ret = ff_decode_get_packet(avctx, s->pkt);
2374 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2375 if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2376 avctx->codec_id == AV_CODEC_ID_AMV) {
2377 ret = ff_sp5x_process_packet(avctx, s->pkt);
2383 s->buf_size = s->pkt->size;
2388 int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2390 MJpegDecodeContext *s = avctx->priv_data;
2391 const uint8_t *buf_end, *buf_ptr;
2392 const uint8_t *unescaped_buf_ptr;
2394 int unescaped_buf_size;
2400 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2401 return smv_process_frame(avctx, frame);
2403 av_dict_free(&s->exif_metadata);
2404 av_freep(&s->stereo3d);
2405 s->adobe_transform = -1;
2408 reset_icc_profile(s);
2410 ret = mjpeg_get_packet(avctx);
2414 buf_ptr = s->pkt->data;
2415 buf_end = s->pkt->data + s->pkt->size;
2416 while (buf_ptr < buf_end) {
2417 /* find start next marker */
2418 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2420 &unescaped_buf_size);
2422 if (start_code < 0) {
2424 } else if (unescaped_buf_size > INT_MAX / 8) {
2425 av_log(avctx, AV_LOG_ERROR,
2426 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2427 start_code, unescaped_buf_size, s->pkt->size);
2428 return AVERROR_INVALIDDATA;
2430 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2431 start_code, buf_end - buf_ptr);
2433 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2436 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2440 s->start_code = start_code;
2441 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2442 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2444 /* process markers */
2445 if (start_code >= RST0 && start_code <= RST7) {
2446 av_log(avctx, AV_LOG_DEBUG,
2447 "restart marker: %d\n", start_code & 0x0f);
2449 } else if (start_code >= APP0 && start_code <= APP15) {
2450 if ((ret = mjpeg_decode_app(s)) < 0)
2451 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2454 } else if (start_code == COM) {
2455 ret = mjpeg_decode_com(s);
2458 } else if (start_code == DQT) {
2459 ret = ff_mjpeg_decode_dqt(s);
2466 if (!CONFIG_JPEGLS_DECODER &&
2467 (start_code == SOF48 || start_code == LSE)) {
2468 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2469 return AVERROR(ENOSYS);
2472 if (avctx->skip_frame == AVDISCARD_ALL) {
2473 switch(start_code) {
2488 switch (start_code) {
2490 s->restart_interval = 0;
2491 s->restart_count = 0;
2492 s->raw_image_buffer = buf_ptr;
2493 s->raw_image_buffer_size = buf_end - buf_ptr;
2494 /* nothing to do on SOI */
2497 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2498 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2504 if (start_code == SOF0)
2505 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2507 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2511 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2515 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2519 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2523 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2524 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2528 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2532 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2533 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2537 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2541 if (!CONFIG_JPEGLS_DECODER ||
2542 (ret = ff_jpegls_decode_lse(s)) < 0)
2547 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2548 s->progressive && s->cur_scan && s->got_picture)
2549 mjpeg_idct_scan_progressive_ac(s);
2551 if (!s->got_picture) {
2552 av_log(avctx, AV_LOG_WARNING,
2553 "Found EOI before any SOF, ignoring\n");
2556 if (s->interlaced) {
2557 s->bottom_field ^= 1;
2558 /* if not bottom field, do not output image yet */
2559 if (s->bottom_field == !s->interlace_polarity)
2562 if (avctx->skip_frame == AVDISCARD_ALL) {
2564 ret = AVERROR(EAGAIN);
2565 goto the_end_no_picture;
2567 if (s->avctx->hwaccel) {
2568 ret = s->avctx->hwaccel->end_frame(s->avctx);
2572 av_freep(&s->hwaccel_picture_private);
2574 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2578 frame->pkt_dts = s->pkt->dts;
2580 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2581 int qp = FFMAX3(s->qscale[0],
2585 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2590 s->raw_scan_buffer = buf_ptr;
2591 s->raw_scan_buffer_size = buf_end - buf_ptr;
2594 if (avctx->skip_frame == AVDISCARD_ALL) {
2595 skip_bits(&s->gb, get_bits_left(&s->gb));
2599 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2600 (avctx->err_recognition & AV_EF_EXPLODE))
2604 if ((ret = mjpeg_decode_dri(s)) < 0)
2617 av_log(avctx, AV_LOG_ERROR,
2618 "mjpeg: unsupported coding type (%x)\n", start_code);
2623 /* eof process start code */
2624 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2625 av_log(avctx, AV_LOG_DEBUG,
2626 "marker parser used %d bytes (%d bits)\n",
2627 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2629 if (s->got_picture && s->cur_scan) {
2630 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2633 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2634 return AVERROR_INVALIDDATA;
2640 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2642 if (AV_RB32(s->upscale_h)) {
2644 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2645 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2646 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2647 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2648 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2650 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
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++) {
2663 uint8_t *line = s->picture_ptr->data[p];
2666 if (!s->upscale_h[p])
2669 w = AV_CEIL_RSHIFT(w, hshift);
2670 h = AV_CEIL_RSHIFT(h, vshift);
2672 if (s->upscale_v[p] == 1)
2675 for (i = 0; i < h; i++) {
2676 if (s->upscale_h[p] == 1) {
2677 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2678 else line[w - 1] = line[(w - 1) / 2];
2679 for (index = w - 2; index > 0; index--) {
2681 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2683 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2685 } else if (s->upscale_h[p] == 2) {
2687 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2689 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2691 line[w - 1] = line[(w - 1) / 3];
2693 line[w - 2] = line[w - 1];
2695 for (index = w - 3; index > 0; index--) {
2696 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2699 line += s->linesize[p];
2703 if (AV_RB32(s->upscale_v)) {
2705 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2706 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2707 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2708 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2709 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2710 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2711 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2712 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2713 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2714 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2715 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2716 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2717 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2719 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2723 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2724 for (p = 0; p < s->nb_components; p++) {
2728 if (!s->upscale_v[p])
2731 w = AV_CEIL_RSHIFT(w, hshift);
2732 h = AV_CEIL_RSHIFT(h, vshift);
2734 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2735 for (i = h - 1; i; i--) {
2736 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2737 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2738 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2739 memcpy(dst, src1, w);
2741 for (index = 0; index < w; index++)
2742 dst[index] = (src1[index] + src2[index]) >> 1;
2744 dst -= s->linesize[p];
2748 if (s->flipped && !s->rgb) {
2750 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2754 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2755 for (index=0; index<s->nb_components; index++) {
2756 uint8_t *dst = s->picture_ptr->data[index];
2757 int w = s->picture_ptr->width;
2758 int h = s->picture_ptr->height;
2759 if(index && index<3){
2760 w = AV_CEIL_RSHIFT(w, hshift);
2761 h = AV_CEIL_RSHIFT(h, vshift);
2764 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2765 for (i=0; i<h/2; i++) {
2767 FFSWAP(int, dst[j], dst2[j]);
2768 dst += s->picture_ptr->linesize[index];
2769 dst2 -= s->picture_ptr->linesize[index];
2774 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2775 int w = s->picture_ptr->width;
2776 int h = s->picture_ptr->height;
2777 av_assert0(s->nb_components == 4);
2778 for (i=0; i<h; i++) {
2781 for (index=0; index<4; index++) {
2782 dst[index] = s->picture_ptr->data[index]
2783 + s->picture_ptr->linesize[index]*i;
2785 for (j=0; j<w; j++) {
2787 int r = dst[0][j] * k;
2788 int g = dst[1][j] * k;
2789 int b = dst[2][j] * k;
2790 dst[0][j] = g*257 >> 16;
2791 dst[1][j] = b*257 >> 16;
2792 dst[2][j] = r*257 >> 16;
2797 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2798 int w = s->picture_ptr->width;
2799 int h = s->picture_ptr->height;
2800 av_assert0(s->nb_components == 4);
2801 for (i=0; i<h; i++) {
2804 for (index=0; index<4; index++) {
2805 dst[index] = s->picture_ptr->data[index]
2806 + s->picture_ptr->linesize[index]*i;
2808 for (j=0; j<w; j++) {
2810 int r = (255 - dst[0][j]) * k;
2811 int g = (128 - dst[1][j]) * k;
2812 int b = (128 - dst[2][j]) * k;
2813 dst[0][j] = r*257 >> 16;
2814 dst[1][j] = (g*257 >> 16) + 128;
2815 dst[2][j] = (b*257 >> 16) + 128;
2822 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2824 stereo->type = s->stereo3d->type;
2825 stereo->flags = s->stereo3d->flags;
2827 av_freep(&s->stereo3d);
2830 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2831 AVFrameSideData *sd;
2836 /* Sum size of all parts. */
2837 for (i = 0; i < s->iccnum; i++)
2838 total_size += s->iccdatalens[i];
2840 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2842 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2843 return AVERROR(ENOMEM);
2846 /* Reassemble the parts, which are now in-order. */
2847 for (i = 0; i < s->iccnum; i++) {
2848 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2849 offset += s->iccdatalens[i];
2853 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2854 av_dict_free(&s->exif_metadata);
2856 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2857 ret = smv_process_frame(avctx, frame);
2859 av_frame_unref(frame);
2863 if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2864 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2865 avctx->coded_height > s->orig_height) {
2866 frame->height = avctx->coded_height;
2867 frame->crop_top = frame->height - s->orig_height;
2873 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2879 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2880 * even without having called ff_mjpeg_decode_init(). */
2881 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2883 MJpegDecodeContext *s = avctx->priv_data;
2886 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2887 av_log(avctx, AV_LOG_INFO, "Single field\n");
2891 av_frame_free(&s->picture);
2892 s->picture_ptr = NULL;
2893 } else if (s->picture_ptr)
2894 av_frame_unref(s->picture_ptr);
2896 av_packet_free(&s->pkt);
2898 av_frame_free(&s->smv_frame);
2900 av_freep(&s->buffer);
2901 av_freep(&s->stereo3d);
2902 av_freep(&s->ljpeg_buffer);
2903 s->ljpeg_buffer_size = 0;
2905 for (i = 0; i < 3; i++) {
2906 for (j = 0; j < 4; j++)
2907 ff_free_vlc(&s->vlcs[i][j]);
2909 for (i = 0; i < MAX_COMPONENTS; i++) {
2910 av_freep(&s->blocks[i]);
2911 av_freep(&s->last_nnz[i]);
2913 av_dict_free(&s->exif_metadata);
2915 reset_icc_profile(s);
2917 av_freep(&s->hwaccel_picture_private);
2922 static void decode_flush(AVCodecContext *avctx)
2924 MJpegDecodeContext *s = avctx->priv_data;
2927 s->smv_next_frame = 0;
2928 av_frame_unref(s->smv_frame);
2931 #if CONFIG_MJPEG_DECODER
2932 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2933 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2934 static const AVOption options[] = {
2935 { "extern_huff", "Use external huffman table.",
2936 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2940 static const AVClass mjpegdec_class = {
2941 .class_name = "MJPEG decoder",
2942 .item_name = av_default_item_name,
2944 .version = LIBAVUTIL_VERSION_INT,
2947 AVCodec ff_mjpeg_decoder = {
2949 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2950 .type = AVMEDIA_TYPE_VIDEO,
2951 .id = AV_CODEC_ID_MJPEG,
2952 .priv_data_size = sizeof(MJpegDecodeContext),
2953 .init = ff_mjpeg_decode_init,
2954 .close = ff_mjpeg_decode_end,
2955 .receive_frame = ff_mjpeg_receive_frame,
2956 .flush = decode_flush,
2957 .capabilities = AV_CODEC_CAP_DR1,
2959 .priv_class = &mjpegdec_class,
2960 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2961 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2962 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2963 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2964 #if CONFIG_MJPEG_NVDEC_HWACCEL
2965 HWACCEL_NVDEC(mjpeg),
2967 #if CONFIG_MJPEG_VAAPI_HWACCEL
2968 HWACCEL_VAAPI(mjpeg),
2974 #if CONFIG_THP_DECODER
2975 AVCodec ff_thp_decoder = {
2977 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2978 .type = AVMEDIA_TYPE_VIDEO,
2979 .id = AV_CODEC_ID_THP,
2980 .priv_data_size = sizeof(MJpegDecodeContext),
2981 .init = ff_mjpeg_decode_init,
2982 .close = ff_mjpeg_decode_end,
2983 .receive_frame = ff_mjpeg_receive_frame,
2984 .flush = decode_flush,
2985 .capabilities = AV_CODEC_CAP_DR1,
2987 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2988 FF_CODEC_CAP_SETS_PKT_DTS,
2992 #if CONFIG_SMVJPEG_DECODER
2993 AVCodec ff_smvjpeg_decoder = {
2995 .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
2996 .type = AVMEDIA_TYPE_VIDEO,
2997 .id = AV_CODEC_ID_SMVJPEG,
2998 .priv_data_size = sizeof(MJpegDecodeContext),
2999 .init = ff_mjpeg_decode_init,
3000 .close = ff_mjpeg_decode_end,
3001 .receive_frame = ff_mjpeg_receive_frame,
3002 .flush = decode_flush,
3003 .capabilities = AV_CODEC_CAP_DR1,
3004 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3005 FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP,