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;
143 s->orig_height = avctx->coded_height;
144 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
145 avctx->colorspace = AVCOL_SPC_BT470BG;
146 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
148 if ((ret = init_default_huffman_tables(s)) < 0)
151 if (s->extern_huff) {
152 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
153 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
155 if (ff_mjpeg_decode_dht(s)) {
156 av_log(avctx, AV_LOG_ERROR,
157 "error using external huffman table, switching back to internal\n");
158 if ((ret = init_default_huffman_tables(s)) < 0)
162 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
163 s->interlace_polarity = 1; /* bottom field first */
164 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
165 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
166 if (avctx->codec_tag == AV_RL32("MJPG"))
167 s->interlace_polarity = 1;
170 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
171 if (avctx->extradata_size >= 4)
172 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
174 if (s->smv_frames_per_jpeg <= 0) {
175 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
176 return AVERROR_INVALIDDATA;
179 s->smv_frame = av_frame_alloc();
181 return AVERROR(ENOMEM);
182 } else if (avctx->extradata_size > 8
183 && AV_RL32(avctx->extradata) == 0x2C
184 && AV_RL32(avctx->extradata+4) == 0x18) {
185 parse_avid(s, avctx->extradata, avctx->extradata_size);
188 if (avctx->codec->id == AV_CODEC_ID_AMV)
195 /* quantize tables */
196 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
200 len = get_bits(&s->gb, 16) - 2;
202 if (8*len > get_bits_left(&s->gb)) {
203 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
204 return AVERROR_INVALIDDATA;
208 int pr = get_bits(&s->gb, 4);
210 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
211 return AVERROR_INVALIDDATA;
213 index = get_bits(&s->gb, 4);
216 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
217 /* read quant table */
218 for (i = 0; i < 64; i++) {
219 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
220 if (s->quant_matrixes[index][i] == 0) {
221 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
222 return AVERROR_INVALIDDATA;
226 // XXX FIXME fine-tune, and perhaps add dc too
227 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
228 s->quant_matrixes[index][8]) >> 1;
229 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
230 index, s->qscale[index]);
231 len -= 1 + 64 * (1+pr);
236 /* decode huffman tables and build VLC decoders */
237 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
239 int len, index, i, class, n, v;
240 uint8_t bits_table[17];
241 uint8_t val_table[256];
244 len = get_bits(&s->gb, 16) - 2;
246 if (8*len > get_bits_left(&s->gb)) {
247 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
248 return AVERROR_INVALIDDATA;
253 return AVERROR_INVALIDDATA;
254 class = get_bits(&s->gb, 4);
256 return AVERROR_INVALIDDATA;
257 index = get_bits(&s->gb, 4);
259 return AVERROR_INVALIDDATA;
261 for (i = 1; i <= 16; i++) {
262 bits_table[i] = get_bits(&s->gb, 8);
266 if (len < n || n > 256)
267 return AVERROR_INVALIDDATA;
269 for (i = 0; i < n; i++) {
270 v = get_bits(&s->gb, 8);
275 /* build VLC and flush previous vlc if present */
276 ff_free_vlc(&s->vlcs[class][index]);
277 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
279 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[class][index], bits_table,
280 val_table, class > 0, s->avctx)) < 0)
284 ff_free_vlc(&s->vlcs[2][index]);
285 if ((ret = ff_mjpeg_build_vlc(&s->vlcs[2][index], bits_table,
286 val_table, 0, s->avctx)) < 0)
290 for (i = 0; i < 16; i++)
291 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
292 for (i = 0; i < 256; i++)
293 s->raw_huffman_values[class][index][i] = val_table[i];
298 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
300 int len, nb_components, i, width, height, bits, ret, size_change;
302 int h_count[MAX_COMPONENTS] = { 0 };
303 int v_count[MAX_COMPONENTS] = { 0 };
306 memset(s->upscale_h, 0, sizeof(s->upscale_h));
307 memset(s->upscale_v, 0, sizeof(s->upscale_v));
309 len = get_bits(&s->gb, 16);
310 bits = get_bits(&s->gb, 8);
312 if (bits > 16 || bits < 1) {
313 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
314 return AVERROR_INVALIDDATA;
317 if (s->avctx->bits_per_raw_sample != bits) {
318 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);
319 s->avctx->bits_per_raw_sample = bits;
324 if (bits == 9 && !s->pegasus_rct)
325 s->rct = 1; // FIXME ugly
327 if(s->lossless && s->avctx->lowres){
328 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
332 height = get_bits(&s->gb, 16);
333 width = get_bits(&s->gb, 16);
335 // HACK for odd_height.mov
336 if (s->interlaced && s->width == width && s->height == height + 1)
339 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
340 if (av_image_check_size(width, height, 0, s->avctx) < 0)
341 return AVERROR_INVALIDDATA;
342 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
343 return AVERROR_INVALIDDATA;
345 nb_components = get_bits(&s->gb, 8);
346 if (nb_components <= 0 ||
347 nb_components > MAX_COMPONENTS)
349 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
350 if (nb_components != s->nb_components) {
351 av_log(s->avctx, AV_LOG_ERROR,
352 "nb_components changing in interlaced picture\n");
353 return AVERROR_INVALIDDATA;
356 if (s->ls && !(bits <= 8 || nb_components == 1)) {
357 avpriv_report_missing_feature(s->avctx,
358 "JPEG-LS that is not <= 8 "
359 "bits/component or 16-bit gray");
360 return AVERROR_PATCHWELCOME;
362 if (len != 8 + 3 * nb_components) {
363 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
364 return AVERROR_INVALIDDATA;
367 s->nb_components = nb_components;
370 for (i = 0; i < nb_components; i++) {
372 s->component_id[i] = get_bits(&s->gb, 8) - 1;
373 h_count[i] = get_bits(&s->gb, 4);
374 v_count[i] = get_bits(&s->gb, 4);
375 /* compute hmax and vmax (only used in interleaved case) */
376 if (h_count[i] > s->h_max)
377 s->h_max = h_count[i];
378 if (v_count[i] > s->v_max)
379 s->v_max = v_count[i];
380 s->quant_index[i] = get_bits(&s->gb, 8);
381 if (s->quant_index[i] >= 4) {
382 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
383 return AVERROR_INVALIDDATA;
385 if (!h_count[i] || !v_count[i]) {
386 av_log(s->avctx, AV_LOG_ERROR,
387 "Invalid sampling factor in component %d %d:%d\n",
388 i, h_count[i], v_count[i]);
389 return AVERROR_INVALIDDATA;
392 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
393 i, h_count[i], v_count[i],
394 s->component_id[i], s->quant_index[i]);
396 if ( nb_components == 4
397 && s->component_id[0] == 'C' - 1
398 && s->component_id[1] == 'M' - 1
399 && s->component_id[2] == 'Y' - 1
400 && s->component_id[3] == 'K' - 1)
401 s->adobe_transform = 0;
403 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
404 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
405 return AVERROR_PATCHWELCOME;
409 if (nb_components == 2) {
410 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
411 width stored in their SOF3 markers is the width of each one. We only output
412 a single component, therefore we need to adjust the output image width. We
413 handle the deinterleaving (but not the debayering) in this file. */
416 /* They can also contain 1 component, which is double the width and half the height
417 of the final image (rows are interleaved). We don't handle the decoding in this
418 file, but leave that to the TIFF/DNG decoder. */
421 /* if different size, realloc/alloc picture */
422 if (width != s->width || height != s->height || bits != s->bits ||
423 memcmp(s->h_count, h_count, sizeof(h_count)) ||
424 memcmp(s->v_count, v_count, sizeof(v_count))) {
430 memcpy(s->h_count, h_count, sizeof(h_count));
431 memcpy(s->v_count, v_count, sizeof(v_count));
436 /* test interlaced mode */
437 if (s->first_picture &&
438 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
439 s->orig_height != 0 &&
440 s->height < ((s->orig_height * 3) / 4)) {
442 s->bottom_field = s->interlace_polarity;
443 s->picture_ptr->interlaced_frame = 1;
444 s->picture_ptr->top_field_first = !s->interlace_polarity;
448 ret = ff_set_dimensions(s->avctx, width, height);
452 if ((s->avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
453 s->avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
454 s->orig_height < height)
455 s->avctx->height = AV_CEIL_RSHIFT(s->orig_height, s->avctx->lowres);
457 s->first_picture = 0;
462 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
463 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
464 if (s->avctx->height <= 0)
465 return AVERROR_INVALIDDATA;
468 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
469 if (s->progressive) {
470 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
471 return AVERROR_INVALIDDATA;
474 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
476 else if (!s->lossless)
478 /* XXX: not complete test ! */
479 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
480 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
481 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
482 (s->h_count[3] << 4) | s->v_count[3];
483 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
484 /* NOTE we do not allocate pictures large enough for the possible
485 * padding of h/v_count being 4 */
486 if (!(pix_fmt_id & 0xD0D0D0D0))
487 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
488 if (!(pix_fmt_id & 0x0D0D0D0D))
489 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
491 for (i = 0; i < 8; i++) {
492 int j = 6 + (i&1) - (i&6);
493 int is = (pix_fmt_id >> (4*i)) & 0xF;
494 int js = (pix_fmt_id >> (4*j)) & 0xF;
496 if (is == 1 && js != 2 && (i < 2 || i > 5))
497 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
498 if (is == 1 && js != 2 && (i < 2 || i > 5))
499 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
501 if (is == 1 && js == 2) {
502 if (i & 1) s->upscale_h[j/2] = 1;
503 else s->upscale_v[j/2] = 1;
508 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
512 switch (pix_fmt_id) {
513 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
516 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
520 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
522 if ( s->adobe_transform == 0
523 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
524 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
526 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
527 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
528 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
531 av_assert0(s->nb_components == 3);
535 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
537 if (s->adobe_transform == 0 && s->bits <= 8) {
538 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
540 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
541 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
544 av_assert0(s->nb_components == 4);
548 if (s->adobe_transform == 0 && s->bits <= 8) {
549 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
550 s->upscale_v[1] = s->upscale_v[2] = 1;
551 s->upscale_h[1] = s->upscale_h[2] = 1;
552 } else if (s->adobe_transform == 2 && s->bits <= 8) {
553 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
554 s->upscale_v[1] = s->upscale_v[2] = 1;
555 s->upscale_h[1] = s->upscale_h[2] = 1;
556 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
558 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
559 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
560 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
562 av_assert0(s->nb_components == 4);
572 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
575 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
587 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
589 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
596 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
597 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
600 s->upscale_v[0] = s->upscale_v[1] = 1;
602 if (pix_fmt_id == 0x14111100)
603 s->upscale_v[1] = s->upscale_v[2] = 1;
604 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
607 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
611 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
612 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
615 s->upscale_h[0] = s->upscale_h[1] = 1;
617 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
618 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
619 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
625 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
626 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
627 s->upscale_h[1] = s->upscale_h[2] = 2;
631 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
634 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
640 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
641 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
642 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
643 if (pix_fmt_id == 0x42111100) {
646 s->upscale_h[1] = s->upscale_h[2] = 1;
647 } else if (pix_fmt_id == 0x24111100) {
650 s->upscale_v[1] = s->upscale_v[2] = 1;
651 } else if (pix_fmt_id == 0x23111100) {
654 s->upscale_v[1] = s->upscale_v[2] = 2;
658 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
661 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
665 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
666 memset(s->upscale_h, 0, sizeof(s->upscale_h));
667 memset(s->upscale_v, 0, sizeof(s->upscale_v));
668 return AVERROR_PATCHWELCOME;
670 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
671 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
672 return AVERROR_PATCHWELCOME;
674 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
675 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
676 return AVERROR_PATCHWELCOME;
679 memset(s->upscale_h, 0, sizeof(s->upscale_h));
680 memset(s->upscale_v, 0, sizeof(s->upscale_v));
681 if (s->nb_components == 3) {
682 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
683 } else if (s->nb_components != 1) {
684 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
685 return AVERROR_PATCHWELCOME;
686 } else if (s->bits <= 8) {
687 avpriv_set_systematic_pal2(s->palette, s->avctx->pix_fmt);
688 if (s->palette_index)
689 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
691 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
693 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
696 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
698 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
702 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
703 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
705 enum AVPixelFormat pix_fmts[] = {
706 #if CONFIG_MJPEG_NVDEC_HWACCEL
709 #if CONFIG_MJPEG_VAAPI_HWACCEL
715 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
716 if (s->hwaccel_pix_fmt < 0)
717 return AVERROR(EINVAL);
719 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
720 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
723 if (s->avctx->skip_frame == AVDISCARD_ALL) {
724 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
725 s->picture_ptr->key_frame = 1;
733 if ((s->rgb && !s->lossless && !s->ls) ||
734 (!s->rgb && s->ls && s->nb_components > 1) ||
735 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
737 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
738 return AVERROR_PATCHWELCOME;
741 /* totally blank picture as progressive JPEG will only add details to it */
742 if (s->progressive) {
743 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
744 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
745 for (i = 0; i < s->nb_components; i++) {
746 int size = bw * bh * s->h_count[i] * s->v_count[i];
747 av_freep(&s->blocks[i]);
748 av_freep(&s->last_nnz[i]);
749 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
750 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
751 if (!s->blocks[i] || !s->last_nnz[i])
752 return AVERROR(ENOMEM);
753 s->block_stride[i] = bw * s->h_count[i];
755 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
761 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
764 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
765 if (code < 0 || code > 16) {
766 av_log(s->avctx, AV_LOG_WARNING,
767 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
768 0, dc_index, &s->vlcs[0][dc_index]);
773 return get_xbits(&s->gb, code);
778 /* decode block and dequantize */
779 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
780 int dc_index, int ac_index, uint16_t *quant_matrix)
782 int code, i, j, level, val;
785 val = mjpeg_decode_dc(s, dc_index);
786 if (val == 0xfffff) {
787 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
788 return AVERROR_INVALIDDATA;
790 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
791 val = av_clip_int16(val);
792 s->last_dc[component] = val;
796 {OPEN_READER(re, &s->gb);
798 UPDATE_CACHE(re, &s->gb);
799 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
801 i += ((unsigned)code) >> 4;
804 if (code > MIN_CACHE_BITS - 16)
805 UPDATE_CACHE(re, &s->gb);
808 int cache = GET_CACHE(re, &s->gb);
809 int sign = (~cache) >> 31;
810 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
813 LAST_SKIP_BITS(re, &s->gb, code);
816 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
817 return AVERROR_INVALIDDATA;
819 j = s->scantable.permutated[i];
820 block[j] = level * quant_matrix[i];
823 CLOSE_READER(re, &s->gb);}
828 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
829 int component, int dc_index,
830 uint16_t *quant_matrix, int Al)
833 s->bdsp.clear_block(block);
834 val = mjpeg_decode_dc(s, dc_index);
835 if (val == 0xfffff) {
836 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
837 return AVERROR_INVALIDDATA;
839 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
840 s->last_dc[component] = val;
845 /* decode block and dequantize - progressive JPEG version */
846 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
847 uint8_t *last_nnz, int ac_index,
848 uint16_t *quant_matrix,
849 int ss, int se, int Al, int *EOBRUN)
851 int code, i, j, val, run;
860 OPEN_READER(re, &s->gb);
861 for (i = ss; ; i++) {
862 UPDATE_CACHE(re, &s->gb);
863 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
865 run = ((unsigned) code) >> 4;
869 if (code > MIN_CACHE_BITS - 16)
870 UPDATE_CACHE(re, &s->gb);
873 int cache = GET_CACHE(re, &s->gb);
874 int sign = (~cache) >> 31;
875 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
878 LAST_SKIP_BITS(re, &s->gb, code);
882 j = s->scantable.permutated[se];
883 block[j] = level * (quant_matrix[se] << Al);
886 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
887 return AVERROR_INVALIDDATA;
889 j = s->scantable.permutated[i];
890 block[j] = level * (quant_matrix[i] << Al);
892 if (run == 0xF) {// ZRL - skip 15 coefficients
895 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
896 return AVERROR_INVALIDDATA;
901 UPDATE_CACHE(re, &s->gb);
902 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
903 LAST_SKIP_BITS(re, &s->gb, run);
910 CLOSE_READER(re, &s->gb);
919 #define REFINE_BIT(j) { \
920 UPDATE_CACHE(re, &s->gb); \
921 sign = block[j] >> 15; \
922 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
923 ((quant_matrix[i] ^ sign) - sign) << Al; \
924 LAST_SKIP_BITS(re, &s->gb, 1); \
932 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
937 j = s->scantable.permutated[i]; \
940 else if (run-- == 0) \
944 /* decode block and dequantize - progressive JPEG refinement pass */
945 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
947 int ac_index, uint16_t *quant_matrix,
948 int ss, int se, int Al, int *EOBRUN)
950 int code, i = ss, j, sign, val, run;
951 int last = FFMIN(se, *last_nnz);
953 OPEN_READER(re, &s->gb);
958 UPDATE_CACHE(re, &s->gb);
959 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
962 run = ((unsigned) code) >> 4;
963 UPDATE_CACHE(re, &s->gb);
964 val = SHOW_UBITS(re, &s->gb, 1);
965 LAST_SKIP_BITS(re, &s->gb, 1);
967 j = s->scantable.permutated[i];
969 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
973 CLOSE_READER(re, &s->gb);
977 run = ((unsigned) code) >> 4;
984 UPDATE_CACHE(re, &s->gb);
985 run += SHOW_UBITS(re, &s->gb, val);
986 LAST_SKIP_BITS(re, &s->gb, val);
998 for (; i <= last; i++) {
999 j = s->scantable.permutated[i];
1003 CLOSE_READER(re, &s->gb);
1010 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1015 if (s->restart_interval) {
1017 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1018 align_get_bits(&s->gb);
1019 for (i = 0; i < nb_components; i++) /* reset dc */
1020 s->last_dc[i] = (4 << s->bits);
1023 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1025 if (s->restart_count == 0) {
1026 if( show_bits(&s->gb, i) == (1 << i) - 1
1027 || show_bits(&s->gb, i) == 0xFF) {
1028 int pos = get_bits_count(&s->gb);
1029 align_get_bits(&s->gb);
1030 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1031 skip_bits(&s->gb, 8);
1032 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1033 for (i = 0; i < nb_components; i++) /* reset dc */
1034 s->last_dc[i] = (4 << s->bits);
1037 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1044 /* Handles 1 to 4 components */
1045 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1049 uint16_t (*buffer)[4];
1050 int left[4], top[4], topleft[4];
1051 const int linesize = s->linesize[0];
1052 const int mask = ((1 << s->bits) - 1) << point_transform;
1053 int resync_mb_y = 0;
1054 int resync_mb_x = 0;
1057 if (!s->bayer && s->nb_components < 3)
1058 return AVERROR_INVALIDDATA;
1059 if (s->bayer && s->nb_components > 2)
1060 return AVERROR_INVALIDDATA;
1061 if (s->nb_components <= 0 || s->nb_components > 4)
1062 return AVERROR_INVALIDDATA;
1063 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1064 return AVERROR_INVALIDDATA;
1067 s->restart_count = s->restart_interval;
1069 if (s->restart_interval == 0)
1070 s->restart_interval = INT_MAX;
1073 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1075 width = s->mb_width;
1077 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1078 if (!s->ljpeg_buffer)
1079 return AVERROR(ENOMEM);
1081 buffer = s->ljpeg_buffer;
1083 for (i = 0; i < 4; i++)
1084 buffer[0][i] = 1 << (s->bits - 1);
1086 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1087 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1089 if (s->interlaced && s->bottom_field)
1090 ptr += linesize >> 1;
1092 for (i = 0; i < 4; i++)
1093 top[i] = left[i] = topleft[i] = buffer[0][i];
1095 if ((mb_y * s->width) % s->restart_interval == 0) {
1096 for (i = 0; i < 6; i++)
1097 vpred[i] = 1 << (s->bits-1);
1100 for (mb_x = 0; mb_x < width; mb_x++) {
1101 int modified_predictor = predictor;
1103 if (get_bits_left(&s->gb) < 1) {
1104 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1105 return AVERROR_INVALIDDATA;
1108 if (s->restart_interval && !s->restart_count){
1109 s->restart_count = s->restart_interval;
1113 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1115 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1116 modified_predictor = 1;
1118 for (i=0;i<nb_components;i++) {
1121 topleft[i] = top[i];
1122 top[i] = buffer[mb_x][i];
1124 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1128 if (!s->bayer || mb_x) {
1130 } else { /* This path runs only for the first line in bayer images */
1132 pred = vpred[i] - dc;
1135 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1137 left[i] = buffer[mb_x][i] =
1138 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1141 if (s->restart_interval && !--s->restart_count) {
1142 align_get_bits(&s->gb);
1143 skip_bits(&s->gb, 16); /* skip RSTn */
1146 if (s->rct && s->nb_components == 4) {
1147 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1148 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1149 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1150 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1151 ptr[4*mb_x + 0] = buffer[mb_x][3];
1153 } else if (s->nb_components == 4) {
1154 for(i=0; i<nb_components; i++) {
1155 int c= s->comp_index[i];
1157 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1158 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1160 } else if(s->bits == 9) {
1161 return AVERROR_PATCHWELCOME;
1163 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1164 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1168 } else if (s->rct) {
1169 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1170 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1171 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1172 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1174 } else if (s->pegasus_rct) {
1175 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1176 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1177 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1178 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1180 } else if (s->bayer) {
1181 if (nb_components == 1) {
1182 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1183 for (mb_x = 0; mb_x < width; mb_x++)
1184 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1185 } else if (nb_components == 2) {
1186 for (mb_x = 0; mb_x < width; mb_x++) {
1187 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1188 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1192 for(i=0; i<nb_components; i++) {
1193 int c= s->comp_index[i];
1195 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1196 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1198 } else if(s->bits == 9) {
1199 return AVERROR_PATCHWELCOME;
1201 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1202 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1211 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1212 int point_transform, int nb_components)
1214 int i, mb_x, mb_y, mask;
1215 int bits= (s->bits+7)&~7;
1216 int resync_mb_y = 0;
1217 int resync_mb_x = 0;
1219 point_transform += bits - s->bits;
1220 mask = ((1 << s->bits) - 1) << point_transform;
1222 av_assert0(nb_components>=1 && nb_components<=4);
1224 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1225 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1226 if (get_bits_left(&s->gb) < 1) {
1227 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1228 return AVERROR_INVALIDDATA;
1230 if (s->restart_interval && !s->restart_count){
1231 s->restart_count = s->restart_interval;
1236 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1237 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1238 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1239 for (i = 0; i < nb_components; i++) {
1242 int n, h, v, x, y, c, j, linesize;
1243 n = s->nb_blocks[i];
1244 c = s->comp_index[i];
1249 linesize= s->linesize[c];
1251 if(bits>8) linesize /= 2;
1253 for(j=0; j<n; j++) {
1256 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1259 if ( h * mb_x + x >= s->width
1260 || v * mb_y + y >= s->height) {
1262 } else if (bits<=8) {
1263 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1265 if(x==0 && leftcol){
1266 pred= 1 << (bits - 1);
1271 if(x==0 && leftcol){
1272 pred= ptr[-linesize];
1274 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1278 if (s->interlaced && s->bottom_field)
1279 ptr += linesize >> 1;
1281 *ptr= pred + ((unsigned)dc << point_transform);
1283 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1285 if(x==0 && leftcol){
1286 pred= 1 << (bits - 1);
1291 if(x==0 && leftcol){
1292 pred= ptr16[-linesize];
1294 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1298 if (s->interlaced && s->bottom_field)
1299 ptr16 += linesize >> 1;
1301 *ptr16= pred + ((unsigned)dc << point_transform);
1310 for (i = 0; i < nb_components; i++) {
1313 int n, h, v, x, y, c, j, linesize, dc;
1314 n = s->nb_blocks[i];
1315 c = s->comp_index[i];
1320 linesize = s->linesize[c];
1322 if(bits>8) linesize /= 2;
1324 for (j = 0; j < n; j++) {
1327 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1330 if ( h * mb_x + x >= s->width
1331 || v * mb_y + y >= s->height) {
1333 } else if (bits<=8) {
1334 ptr = s->picture_ptr->data[c] +
1335 (linesize * (v * mb_y + y)) +
1336 (h * mb_x + x); //FIXME optimize this crap
1337 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1340 *ptr = pred + ((unsigned)dc << point_transform);
1342 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1343 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1346 *ptr16= pred + ((unsigned)dc << point_transform);
1356 if (s->restart_interval && !--s->restart_count) {
1357 align_get_bits(&s->gb);
1358 skip_bits(&s->gb, 16); /* skip RSTn */
1365 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1366 uint8_t *dst, const uint8_t *src,
1367 int linesize, int lowres)
1370 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1372 case 1: copy_block4(dst, src, linesize, linesize, 4);
1374 case 2: copy_block2(dst, src, linesize, linesize, 2);
1376 case 3: *dst = *src;
1381 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1383 int block_x, block_y;
1384 int size = 8 >> s->avctx->lowres;
1386 for (block_y=0; block_y<size; block_y++)
1387 for (block_x=0; block_x<size; block_x++)
1388 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1390 for (block_y=0; block_y<size; block_y++)
1391 for (block_x=0; block_x<size; block_x++)
1392 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1396 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1397 int Al, const uint8_t *mb_bitmask,
1398 int mb_bitmask_size,
1399 const AVFrame *reference)
1401 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1402 uint8_t *data[MAX_COMPONENTS];
1403 const uint8_t *reference_data[MAX_COMPONENTS];
1404 int linesize[MAX_COMPONENTS];
1405 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1406 int bytes_per_pixel = 1 + (s->bits > 8);
1409 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1410 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1411 return AVERROR_INVALIDDATA;
1413 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1416 s->restart_count = 0;
1418 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1420 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1421 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1423 for (i = 0; i < nb_components; i++) {
1424 int c = s->comp_index[i];
1425 data[c] = s->picture_ptr->data[c];
1426 reference_data[c] = reference ? reference->data[c] : NULL;
1427 linesize[c] = s->linesize[c];
1428 s->coefs_finished[c] |= 1;
1431 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1432 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1433 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1435 if (s->restart_interval && !s->restart_count)
1436 s->restart_count = s->restart_interval;
1438 if (get_bits_left(&s->gb) < 0) {
1439 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1440 -get_bits_left(&s->gb));
1441 return AVERROR_INVALIDDATA;
1443 for (i = 0; i < nb_components; i++) {
1445 int n, h, v, x, y, c, j;
1447 n = s->nb_blocks[i];
1448 c = s->comp_index[i];
1453 for (j = 0; j < n; j++) {
1454 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1455 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1457 if (s->interlaced && s->bottom_field)
1458 block_offset += linesize[c] >> 1;
1459 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1460 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1461 ptr = data[c] + block_offset;
1464 if (!s->progressive) {
1467 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1468 linesize[c], s->avctx->lowres);
1471 s->bdsp.clear_block(s->block);
1472 if (decode_block(s, s->block, i,
1473 s->dc_index[i], s->ac_index[i],
1474 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1475 av_log(s->avctx, AV_LOG_ERROR,
1476 "error y=%d x=%d\n", mb_y, mb_x);
1477 return AVERROR_INVALIDDATA;
1480 s->idsp.idct_put(ptr, linesize[c], s->block);
1482 shift_output(s, ptr, linesize[c]);
1486 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1488 int16_t *block = s->blocks[c][block_idx];
1490 block[0] += get_bits1(&s->gb) *
1491 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1492 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1493 s->quant_matrixes[s->quant_sindex[i]],
1495 av_log(s->avctx, AV_LOG_ERROR,
1496 "error y=%d x=%d\n", mb_y, mb_x);
1497 return AVERROR_INVALIDDATA;
1500 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1501 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1502 mb_x, mb_y, x, y, c, s->bottom_field,
1503 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1511 handle_rstn(s, nb_components);
1517 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1518 int se, int Ah, int Al)
1522 int c = s->comp_index[0];
1523 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1525 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1526 if (se < ss || se > 63) {
1527 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1528 return AVERROR_INVALIDDATA;
1531 // s->coefs_finished is a bitmask for coefficients coded
1532 // ss and se are parameters telling start and end coefficients
1533 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1535 s->restart_count = 0;
1537 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1538 int block_idx = mb_y * s->block_stride[c];
1539 int16_t (*block)[64] = &s->blocks[c][block_idx];
1540 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1541 if (get_bits_left(&s->gb) <= 0) {
1542 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1543 return AVERROR_INVALIDDATA;
1545 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1547 if (s->restart_interval && !s->restart_count)
1548 s->restart_count = s->restart_interval;
1551 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1552 quant_matrix, ss, se, Al, &EOBRUN);
1554 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1555 quant_matrix, ss, se, Al, &EOBRUN);
1557 av_log(s->avctx, AV_LOG_ERROR,
1558 "error y=%d x=%d\n", mb_y, mb_x);
1559 return AVERROR_INVALIDDATA;
1562 if (handle_rstn(s, 0))
1569 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1573 const int bytes_per_pixel = 1 + (s->bits > 8);
1574 const int block_size = s->lossless ? 1 : 8;
1576 for (c = 0; c < s->nb_components; c++) {
1577 uint8_t *data = s->picture_ptr->data[c];
1578 int linesize = s->linesize[c];
1579 int h = s->h_max / s->h_count[c];
1580 int v = s->v_max / s->v_count[c];
1581 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1582 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1584 if (~s->coefs_finished[c])
1585 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1587 if (s->interlaced && s->bottom_field)
1588 data += linesize >> 1;
1590 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1591 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1592 int block_idx = mb_y * s->block_stride[c];
1593 int16_t (*block)[64] = &s->blocks[c][block_idx];
1594 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1595 s->idsp.idct_put(ptr, linesize, *block);
1597 shift_output(s, ptr, linesize);
1598 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1604 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1605 int mb_bitmask_size, const AVFrame *reference)
1607 int len, nb_components, i, h, v, predictor, point_transform;
1609 const int block_size = s->lossless ? 1 : 8;
1610 int ilv, prev_shift;
1613 av_log(s->avctx, AV_LOG_WARNING,
1614 "Can not process SOS before SOF, skipping\n");
1618 if (!s->got_picture || !s->interlaced || !(s->bottom_field == !s->interlace_polarity)) {
1619 av_frame_unref(s->picture_ptr);
1620 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
1622 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
1623 s->picture_ptr->key_frame = 1;
1625 for (i = 0; i < 4; i++)
1626 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
1628 if (s->picture_ptr->format == AV_PIX_FMT_PAL8)
1629 memcpy(s->picture_ptr->data[1], s->palette, sizeof(s->palette));
1633 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
1634 s->width, s->height, s->linesize[0], s->linesize[1],
1635 s->interlaced, s->avctx->height);
1637 if (s->avctx->hwaccel && !s->hwaccel_picture_private) {
1638 s->hwaccel_picture_private =
1639 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
1640 if (!s->hwaccel_picture_private)
1641 return AVERROR(ENOMEM);
1643 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
1644 s->raw_image_buffer_size);
1651 if (reference->width != s->picture_ptr->width ||
1652 reference->height != s->picture_ptr->height ||
1653 reference->format != s->picture_ptr->format) {
1654 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1655 return AVERROR_INVALIDDATA;
1659 /* XXX: verify len field validity */
1660 len = get_bits(&s->gb, 16);
1661 nb_components = get_bits(&s->gb, 8);
1662 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1663 avpriv_report_missing_feature(s->avctx,
1664 "decode_sos: nb_components (%d)",
1666 return AVERROR_PATCHWELCOME;
1668 if (len != 6 + 2 * nb_components) {
1669 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1670 return AVERROR_INVALIDDATA;
1672 for (i = 0; i < nb_components; i++) {
1673 id = get_bits(&s->gb, 8) - 1;
1674 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1675 /* find component index */
1676 for (index = 0; index < s->nb_components; index++)
1677 if (id == s->component_id[index])
1679 if (index == s->nb_components) {
1680 av_log(s->avctx, AV_LOG_ERROR,
1681 "decode_sos: index(%d) out of components\n", index);
1682 return AVERROR_INVALIDDATA;
1684 /* Metasoft MJPEG codec has Cb and Cr swapped */
1685 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1686 && nb_components == 3 && s->nb_components == 3 && i)
1689 s->quant_sindex[i] = s->quant_index[index];
1690 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1691 s->h_scount[i] = s->h_count[index];
1692 s->v_scount[i] = s->v_count[index];
1694 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1695 index = (index+2)%3;
1697 s->comp_index[i] = index;
1699 s->dc_index[i] = get_bits(&s->gb, 4);
1700 s->ac_index[i] = get_bits(&s->gb, 4);
1702 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1703 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1705 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))
1709 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1710 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1711 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1712 prev_shift = get_bits(&s->gb, 4); /* Ah */
1713 point_transform = get_bits(&s->gb, 4); /* Al */
1715 prev_shift = point_transform = 0;
1717 if (nb_components > 1) {
1718 /* interleaved stream */
1719 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1720 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1721 } else if (!s->ls) { /* skip this for JPEG-LS */
1722 h = s->h_max / s->h_scount[0];
1723 v = s->v_max / s->v_scount[0];
1724 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1725 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1726 s->nb_blocks[0] = 1;
1731 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1732 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1733 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1734 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1735 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1738 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1739 for (i = s->mjpb_skiptosod; i > 0; i--)
1740 skip_bits(&s->gb, 8);
1743 for (i = 0; i < nb_components; i++)
1744 s->last_dc[i] = (4 << s->bits);
1746 if (s->avctx->hwaccel) {
1747 int bytes_to_start = get_bits_count(&s->gb) / 8;
1748 av_assert0(bytes_to_start >= 0 &&
1749 s->raw_scan_buffer_size >= bytes_to_start);
1751 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1752 s->raw_scan_buffer + bytes_to_start,
1753 s->raw_scan_buffer_size - bytes_to_start);
1757 } else if (s->lossless) {
1758 av_assert0(s->picture_ptr == s->picture);
1759 if (CONFIG_JPEGLS_DECODER && s->ls) {
1761 // reset_ls_coding_parameters(s, 0);
1763 if ((ret = ff_jpegls_decode_picture(s, predictor,
1764 point_transform, ilv)) < 0)
1767 if (s->rgb || s->bayer) {
1768 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1771 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1773 nb_components)) < 0)
1778 if (s->progressive && predictor) {
1779 av_assert0(s->picture_ptr == s->picture);
1780 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1782 point_transform)) < 0)
1785 if ((ret = mjpeg_decode_scan(s, nb_components,
1786 prev_shift, point_transform,
1787 mb_bitmask, mb_bitmask_size, reference)) < 0)
1792 if (s->interlaced &&
1793 get_bits_left(&s->gb) > 32 &&
1794 show_bits(&s->gb, 8) == 0xFF) {
1795 GetBitContext bak = s->gb;
1796 align_get_bits(&bak);
1797 if (show_bits(&bak, 16) == 0xFFD1) {
1798 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1800 skip_bits(&s->gb, 16);
1801 s->bottom_field ^= 1;
1810 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1811 return AVERROR_INVALIDDATA;
1814 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1816 if (get_bits(&s->gb, 16) != 4)
1817 return AVERROR_INVALIDDATA;
1818 s->restart_interval = get_bits(&s->gb, 16);
1819 s->restart_count = 0;
1820 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1821 s->restart_interval);
1826 static int mjpeg_decode_app(MJpegDecodeContext *s)
1830 len = get_bits(&s->gb, 16);
1833 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1834 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1835 skip_bits(&s->gb, len);
1838 return AVERROR_INVALIDDATA;
1840 if (8 * len > get_bits_left(&s->gb))
1841 return AVERROR_INVALIDDATA;
1843 id = get_bits_long(&s->gb, 32);
1846 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1847 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1848 av_fourcc2str(av_bswap32(id)), id, len);
1850 /* Buggy AVID, it puts EOI only at every 10th frame. */
1851 /* Also, this fourcc is used by non-avid files too, it holds some
1852 information, but it's always present in AVID-created files. */
1853 if (id == AV_RB32("AVI1")) {
1859 4bytes field_size_less_padding
1862 i = get_bits(&s->gb, 8); len--;
1863 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1867 if (id == AV_RB32("JFIF")) {
1868 int t_w, t_h, v1, v2;
1871 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1872 v1 = get_bits(&s->gb, 8);
1873 v2 = get_bits(&s->gb, 8);
1874 skip_bits(&s->gb, 8);
1876 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1877 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1878 if ( s->avctx->sample_aspect_ratio.num <= 0
1879 || s->avctx->sample_aspect_ratio.den <= 0) {
1880 s->avctx->sample_aspect_ratio.num = 0;
1881 s->avctx->sample_aspect_ratio.den = 1;
1884 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1885 av_log(s->avctx, AV_LOG_INFO,
1886 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1888 s->avctx->sample_aspect_ratio.num,
1889 s->avctx->sample_aspect_ratio.den);
1893 t_w = get_bits(&s->gb, 8);
1894 t_h = get_bits(&s->gb, 8);
1896 /* skip thumbnail */
1897 if (len -10 - (t_w * t_h * 3) > 0)
1898 len -= t_w * t_h * 3;
1905 if ( id == AV_RB32("Adob")
1907 && show_bits(&s->gb, 8) == 'e'
1908 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1909 skip_bits(&s->gb, 8); /* 'e' */
1910 skip_bits(&s->gb, 16); /* version */
1911 skip_bits(&s->gb, 16); /* flags0 */
1912 skip_bits(&s->gb, 16); /* flags1 */
1913 s->adobe_transform = get_bits(&s->gb, 8);
1914 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1915 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1920 if (id == AV_RB32("LJIF")) {
1922 int pegasus_rct = s->pegasus_rct;
1923 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1924 av_log(s->avctx, AV_LOG_INFO,
1925 "Pegasus lossless jpeg header found\n");
1926 skip_bits(&s->gb, 16); /* version ? */
1927 skip_bits(&s->gb, 16); /* unknown always 0? */
1928 skip_bits(&s->gb, 16); /* unknown always 0? */
1929 skip_bits(&s->gb, 16); /* unknown always 0? */
1930 switch (i=get_bits(&s->gb, 8)) {
1940 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1945 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1946 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1951 s->pegasus_rct = pegasus_rct;
1955 if (id == AV_RL32("colr") && len > 0) {
1956 s->colr = get_bits(&s->gb, 8);
1957 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1958 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1962 if (id == AV_RL32("xfrm") && len > 0) {
1963 s->xfrm = get_bits(&s->gb, 8);
1964 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1965 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1970 /* JPS extension by VRex */
1971 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1972 int flags, layout, type;
1973 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1974 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1976 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1977 skip_bits(&s->gb, 16); len -= 2; /* block length */
1978 skip_bits(&s->gb, 8); /* reserved */
1979 flags = get_bits(&s->gb, 8);
1980 layout = get_bits(&s->gb, 8);
1981 type = get_bits(&s->gb, 8);
1984 av_freep(&s->stereo3d);
1985 s->stereo3d = av_stereo3d_alloc();
1990 s->stereo3d->type = AV_STEREO3D_2D;
1991 } else if (type == 1) {
1994 s->stereo3d->type = AV_STEREO3D_LINES;
1997 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
2000 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2003 if (!(flags & 0x04)) {
2004 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2011 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2012 GetByteContext gbytes;
2013 int ret, le, ifd_offset, bytes_read;
2014 const uint8_t *aligned;
2016 skip_bits(&s->gb, 16); // skip padding
2019 // init byte wise reading
2020 aligned = align_get_bits(&s->gb);
2021 bytestream2_init(&gbytes, aligned, len);
2024 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2026 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2028 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2030 // read 0th IFD and store the metadata
2031 // (return values > 0 indicate the presence of subimage metadata)
2032 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2034 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2038 bytes_read = bytestream2_tell(&gbytes);
2039 skip_bits(&s->gb, bytes_read << 3);
2046 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2047 id = get_bits_long(&s->gb, 32);
2050 if (id == AV_RB32("mjpg")) {
2053 4bytes pad field size
2061 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2062 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2066 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2069 unsigned nummarkers;
2071 id = get_bits_long(&s->gb, 32);
2072 id2 = get_bits(&s->gb, 24);
2074 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2075 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2079 skip_bits(&s->gb, 8);
2080 seqno = get_bits(&s->gb, 8);
2083 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2087 nummarkers = get_bits(&s->gb, 8);
2089 if (nummarkers == 0) {
2090 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2092 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2093 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2095 } else if (seqno > nummarkers) {
2096 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2100 /* Allocate if this is the first APP2 we've seen. */
2101 if (s->iccnum == 0) {
2102 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2103 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2104 return AVERROR(ENOMEM);
2106 s->iccnum = nummarkers;
2109 if (s->iccentries[seqno - 1].data) {
2110 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2114 s->iccentries[seqno - 1].length = len;
2115 s->iccentries[seqno - 1].data = av_malloc(len);
2116 if (!s->iccentries[seqno - 1].data) {
2117 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2118 return AVERROR(ENOMEM);
2121 memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2122 skip_bits(&s->gb, len << 3);
2126 if (s->iccread > s->iccnum)
2127 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2131 /* slow but needed for extreme adobe jpegs */
2133 av_log(s->avctx, AV_LOG_ERROR,
2134 "mjpeg: error, decode_app parser read over the end\n");
2136 skip_bits(&s->gb, 8);
2141 static int mjpeg_decode_com(MJpegDecodeContext *s)
2143 int len = get_bits(&s->gb, 16);
2144 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2146 char *cbuf = av_malloc(len - 1);
2148 return AVERROR(ENOMEM);
2150 for (i = 0; i < len - 2; i++)
2151 cbuf[i] = get_bits(&s->gb, 8);
2152 if (i > 0 && cbuf[i - 1] == '\n')
2157 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2158 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2160 /* buggy avid, it puts EOI only at every 10th frame */
2161 if (!strncmp(cbuf, "AVID", 4)) {
2162 parse_avid(s, cbuf, len);
2163 } else if (!strcmp(cbuf, "CS=ITU601"))
2165 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2166 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2168 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2169 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2179 /* return the 8 bit start code value and update the search
2180 state. Return -1 if no start code found */
2181 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2183 const uint8_t *buf_ptr;
2188 buf_ptr = *pbuf_ptr;
2189 while (buf_end - buf_ptr > 1) {
2192 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2201 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2202 *pbuf_ptr = buf_ptr;
2206 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2207 const uint8_t **buf_ptr, const uint8_t *buf_end,
2208 const uint8_t **unescaped_buf_ptr,
2209 int *unescaped_buf_size)
2212 start_code = find_marker(buf_ptr, buf_end);
2214 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2216 return AVERROR(ENOMEM);
2218 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2219 if (start_code == SOS && !s->ls) {
2220 const uint8_t *src = *buf_ptr;
2221 const uint8_t *ptr = src;
2222 uint8_t *dst = s->buffer;
2224 #define copy_data_segment(skip) do { \
2225 ptrdiff_t length = (ptr - src) - (skip); \
2227 memcpy(dst, src, length); \
2233 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2235 copy_data_segment(0);
2237 while (ptr < buf_end) {
2238 uint8_t x = *(ptr++);
2242 while (ptr < buf_end && x == 0xff) {
2247 /* 0xFF, 0xFF, ... */
2249 copy_data_segment(skip);
2251 /* decrement src as it is equal to ptr after the
2252 * copy_data_segment macro and we might want to
2253 * copy the current value of x later on */
2257 if (x < RST0 || x > RST7) {
2258 copy_data_segment(1);
2265 copy_data_segment(0);
2267 #undef copy_data_segment
2269 *unescaped_buf_ptr = s->buffer;
2270 *unescaped_buf_size = dst - s->buffer;
2271 memset(s->buffer + *unescaped_buf_size, 0,
2272 AV_INPUT_BUFFER_PADDING_SIZE);
2274 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2275 (buf_end - *buf_ptr) - (dst - s->buffer));
2276 } else if (start_code == SOS && s->ls) {
2277 const uint8_t *src = *buf_ptr;
2278 uint8_t *dst = s->buffer;
2284 while (src + t < buf_end) {
2285 uint8_t x = src[t++];
2287 while ((src + t < buf_end) && x == 0xff)
2296 init_put_bits(&pb, dst, t);
2298 /* unescape bitstream */
2300 uint8_t x = src[b++];
2301 put_bits(&pb, 8, x);
2302 if (x == 0xFF && b < t) {
2305 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2308 put_bits(&pb, 7, x);
2312 flush_put_bits(&pb);
2314 *unescaped_buf_ptr = dst;
2315 *unescaped_buf_size = (bit_count + 7) >> 3;
2316 memset(s->buffer + *unescaped_buf_size, 0,
2317 AV_INPUT_BUFFER_PADDING_SIZE);
2319 *unescaped_buf_ptr = *buf_ptr;
2320 *unescaped_buf_size = buf_end - *buf_ptr;
2326 static void reset_icc_profile(MJpegDecodeContext *s)
2330 if (s->iccentries) {
2331 for (i = 0; i < s->iccnum; i++)
2332 av_freep(&s->iccentries[i].data);
2333 av_freep(&s->iccentries);
2340 // SMV JPEG just stacks several output frames into one JPEG picture
2341 // we handle that by setting up the cropping parameters appropriately
2342 static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2344 MJpegDecodeContext *s = avctx->priv_data;
2347 if (s->smv_next_frame > 0) {
2348 av_assert0(s->smv_frame->buf[0]);
2349 av_frame_unref(frame);
2350 ret = av_frame_ref(frame, s->smv_frame);
2354 av_assert0(frame->buf[0]);
2355 av_frame_unref(s->smv_frame);
2356 ret = av_frame_ref(s->smv_frame, frame);
2361 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2363 frame->width = avctx->coded_width;
2364 frame->height = avctx->coded_height;
2365 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2366 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2368 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2370 if (s->smv_next_frame == 0)
2371 av_frame_unref(s->smv_frame);
2376 static int mjpeg_get_packet(AVCodecContext *avctx)
2378 MJpegDecodeContext *s = avctx->priv_data;
2381 av_packet_unref(s->pkt);
2382 ret = ff_decode_get_packet(avctx, s->pkt);
2386 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2387 if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2388 avctx->codec_id == AV_CODEC_ID_AMV) {
2389 ret = ff_sp5x_process_packet(avctx, s->pkt);
2395 s->buf_size = s->pkt->size;
2400 int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2402 MJpegDecodeContext *s = avctx->priv_data;
2403 const uint8_t *buf_end, *buf_ptr;
2404 const uint8_t *unescaped_buf_ptr;
2406 int unescaped_buf_size;
2412 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2413 return smv_process_frame(avctx, frame);
2415 av_dict_free(&s->exif_metadata);
2416 av_freep(&s->stereo3d);
2417 s->adobe_transform = -1;
2420 reset_icc_profile(s);
2422 ret = mjpeg_get_packet(avctx);
2426 buf_ptr = s->pkt->data;
2427 buf_end = s->pkt->data + s->pkt->size;
2428 while (buf_ptr < buf_end) {
2429 /* find start next marker */
2430 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2432 &unescaped_buf_size);
2434 if (start_code < 0) {
2436 } else if (unescaped_buf_size > INT_MAX / 8) {
2437 av_log(avctx, AV_LOG_ERROR,
2438 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2439 start_code, unescaped_buf_size, s->pkt->size);
2440 return AVERROR_INVALIDDATA;
2442 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2443 start_code, buf_end - buf_ptr);
2445 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2448 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2452 s->start_code = start_code;
2453 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2454 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2456 /* process markers */
2457 if (start_code >= RST0 && start_code <= RST7) {
2458 av_log(avctx, AV_LOG_DEBUG,
2459 "restart marker: %d\n", start_code & 0x0f);
2461 } else if (start_code >= APP0 && start_code <= APP15) {
2462 if ((ret = mjpeg_decode_app(s)) < 0)
2463 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2466 } else if (start_code == COM) {
2467 ret = mjpeg_decode_com(s);
2470 } else if (start_code == DQT) {
2471 ret = ff_mjpeg_decode_dqt(s);
2478 if (!CONFIG_JPEGLS_DECODER &&
2479 (start_code == SOF48 || start_code == LSE)) {
2480 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2481 return AVERROR(ENOSYS);
2484 if (avctx->skip_frame == AVDISCARD_ALL) {
2485 switch(start_code) {
2500 switch (start_code) {
2502 s->restart_interval = 0;
2503 s->restart_count = 0;
2504 s->raw_image_buffer = buf_ptr;
2505 s->raw_image_buffer_size = buf_end - buf_ptr;
2506 /* nothing to do on SOI */
2509 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2510 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2516 if (start_code == SOF0)
2517 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2519 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2523 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2527 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2531 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2535 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2536 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2540 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2544 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2545 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2549 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2553 if (!CONFIG_JPEGLS_DECODER ||
2554 (ret = ff_jpegls_decode_lse(s)) < 0)
2559 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2560 s->progressive && s->cur_scan && s->got_picture)
2561 mjpeg_idct_scan_progressive_ac(s);
2563 if (!s->got_picture) {
2564 av_log(avctx, AV_LOG_WARNING,
2565 "Found EOI before any SOF, ignoring\n");
2568 if (s->interlaced) {
2569 s->bottom_field ^= 1;
2570 /* if not bottom field, do not output image yet */
2571 if (s->bottom_field == !s->interlace_polarity)
2574 if (avctx->skip_frame == AVDISCARD_ALL) {
2577 ret = AVERROR(EAGAIN);
2578 goto the_end_no_picture;
2580 if (s->avctx->hwaccel) {
2581 ret = s->avctx->hwaccel->end_frame(s->avctx);
2585 av_freep(&s->hwaccel_picture_private);
2587 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2592 frame->pkt_dts = s->pkt->dts;
2594 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2595 int qp = FFMAX3(s->qscale[0],
2599 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2604 s->raw_scan_buffer = buf_ptr;
2605 s->raw_scan_buffer_size = buf_end - buf_ptr;
2608 if (avctx->skip_frame == AVDISCARD_ALL) {
2609 skip_bits(&s->gb, get_bits_left(&s->gb));
2613 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2614 (avctx->err_recognition & AV_EF_EXPLODE))
2618 if ((ret = mjpeg_decode_dri(s)) < 0)
2631 av_log(avctx, AV_LOG_ERROR,
2632 "mjpeg: unsupported coding type (%x)\n", start_code);
2637 /* eof process start code */
2638 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2639 av_log(avctx, AV_LOG_DEBUG,
2640 "marker parser used %d bytes (%d bits)\n",
2641 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2643 if (s->got_picture && s->cur_scan) {
2644 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2647 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2648 return AVERROR_INVALIDDATA;
2655 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2657 if (AV_RB32(s->upscale_h)) {
2659 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2660 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2661 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2662 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2663 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2664 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2665 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2666 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2667 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2668 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2669 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2670 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2672 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2676 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2677 for (p = 0; p<s->nb_components; p++) {
2678 uint8_t *line = s->picture_ptr->data[p];
2681 if (!s->upscale_h[p])
2684 w = AV_CEIL_RSHIFT(w, hshift);
2685 h = AV_CEIL_RSHIFT(h, vshift);
2687 if (s->upscale_v[p] == 1)
2690 for (i = 0; i < h; i++) {
2691 if (s->upscale_h[p] == 1) {
2692 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2693 else line[w - 1] = line[(w - 1) / 2];
2694 for (index = w - 2; index > 0; index--) {
2696 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2698 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2700 } else if (s->upscale_h[p] == 2) {
2702 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2704 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2706 line[w - 1] = line[(w - 1) / 3];
2708 line[w - 2] = line[w - 1];
2710 for (index = w - 3; index > 0; index--) {
2711 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2714 line += s->linesize[p];
2718 if (AV_RB32(s->upscale_v)) {
2720 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2721 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2722 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2723 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2724 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2725 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2726 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2727 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2728 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2729 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2730 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2731 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2732 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2734 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2738 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2739 for (p = 0; p < s->nb_components; p++) {
2743 if (!s->upscale_v[p])
2746 w = AV_CEIL_RSHIFT(w, hshift);
2747 h = AV_CEIL_RSHIFT(h, vshift);
2749 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2750 for (i = h - 1; i; i--) {
2751 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2752 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2753 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2754 memcpy(dst, src1, w);
2756 for (index = 0; index < w; index++)
2757 dst[index] = (src1[index] + src2[index]) >> 1;
2759 dst -= s->linesize[p];
2763 if (s->flipped && !s->rgb) {
2765 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2769 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2770 for (index=0; index<s->nb_components; index++) {
2771 uint8_t *dst = s->picture_ptr->data[index];
2772 int w = s->picture_ptr->width;
2773 int h = s->picture_ptr->height;
2774 if(index && index<3){
2775 w = AV_CEIL_RSHIFT(w, hshift);
2776 h = AV_CEIL_RSHIFT(h, vshift);
2779 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2780 for (i=0; i<h/2; i++) {
2782 FFSWAP(int, dst[j], dst2[j]);
2783 dst += s->picture_ptr->linesize[index];
2784 dst2 -= s->picture_ptr->linesize[index];
2789 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2790 int w = s->picture_ptr->width;
2791 int h = s->picture_ptr->height;
2792 av_assert0(s->nb_components == 4);
2793 for (i=0; i<h; i++) {
2796 for (index=0; index<4; index++) {
2797 dst[index] = s->picture_ptr->data[index]
2798 + s->picture_ptr->linesize[index]*i;
2800 for (j=0; j<w; j++) {
2802 int r = dst[0][j] * k;
2803 int g = dst[1][j] * k;
2804 int b = dst[2][j] * k;
2805 dst[0][j] = g*257 >> 16;
2806 dst[1][j] = b*257 >> 16;
2807 dst[2][j] = r*257 >> 16;
2812 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2813 int w = s->picture_ptr->width;
2814 int h = s->picture_ptr->height;
2815 av_assert0(s->nb_components == 4);
2816 for (i=0; i<h; i++) {
2819 for (index=0; index<4; index++) {
2820 dst[index] = s->picture_ptr->data[index]
2821 + s->picture_ptr->linesize[index]*i;
2823 for (j=0; j<w; j++) {
2825 int r = (255 - dst[0][j]) * k;
2826 int g = (128 - dst[1][j]) * k;
2827 int b = (128 - dst[2][j]) * k;
2828 dst[0][j] = r*257 >> 16;
2829 dst[1][j] = (g*257 >> 16) + 128;
2830 dst[2][j] = (b*257 >> 16) + 128;
2837 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2839 stereo->type = s->stereo3d->type;
2840 stereo->flags = s->stereo3d->flags;
2842 av_freep(&s->stereo3d);
2845 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2846 AVFrameSideData *sd;
2851 /* Sum size of all parts. */
2852 for (i = 0; i < s->iccnum; i++)
2853 total_size += s->iccentries[i].length;
2855 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2857 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2858 return AVERROR(ENOMEM);
2861 /* Reassemble the parts, which are now in-order. */
2862 for (i = 0; i < s->iccnum; i++) {
2863 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2864 offset += s->iccentries[i].length;
2868 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2869 av_dict_free(&s->exif_metadata);
2871 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2872 ret = smv_process_frame(avctx, frame);
2874 av_frame_unref(frame);
2878 if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2879 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2880 avctx->coded_height > s->orig_height) {
2881 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2882 frame->crop_top = frame->height - avctx->height;
2888 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2894 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2895 * even without having called ff_mjpeg_decode_init(). */
2896 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2898 MJpegDecodeContext *s = avctx->priv_data;
2901 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2902 av_log(avctx, AV_LOG_INFO, "Single field\n");
2906 av_frame_free(&s->picture);
2907 s->picture_ptr = NULL;
2908 } else if (s->picture_ptr)
2909 av_frame_unref(s->picture_ptr);
2911 av_packet_free(&s->pkt);
2913 av_frame_free(&s->smv_frame);
2915 av_freep(&s->buffer);
2916 av_freep(&s->stereo3d);
2917 av_freep(&s->ljpeg_buffer);
2918 s->ljpeg_buffer_size = 0;
2920 for (i = 0; i < 3; i++) {
2921 for (j = 0; j < 4; j++)
2922 ff_free_vlc(&s->vlcs[i][j]);
2924 for (i = 0; i < MAX_COMPONENTS; i++) {
2925 av_freep(&s->blocks[i]);
2926 av_freep(&s->last_nnz[i]);
2928 av_dict_free(&s->exif_metadata);
2930 reset_icc_profile(s);
2932 av_freep(&s->hwaccel_picture_private);
2933 av_freep(&s->jls_state);
2938 static void decode_flush(AVCodecContext *avctx)
2940 MJpegDecodeContext *s = avctx->priv_data;
2944 s->smv_next_frame = 0;
2945 av_frame_unref(s->smv_frame);
2948 #if CONFIG_MJPEG_DECODER
2949 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2950 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2951 static const AVOption options[] = {
2952 { "extern_huff", "Use external huffman table.",
2953 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2957 static const AVClass mjpegdec_class = {
2958 .class_name = "MJPEG decoder",
2959 .item_name = av_default_item_name,
2961 .version = LIBAVUTIL_VERSION_INT,
2964 AVCodec ff_mjpeg_decoder = {
2966 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2967 .type = AVMEDIA_TYPE_VIDEO,
2968 .id = AV_CODEC_ID_MJPEG,
2969 .priv_data_size = sizeof(MJpegDecodeContext),
2970 .init = ff_mjpeg_decode_init,
2971 .close = ff_mjpeg_decode_end,
2972 .receive_frame = ff_mjpeg_receive_frame,
2973 .flush = decode_flush,
2974 .capabilities = AV_CODEC_CAP_DR1,
2976 .priv_class = &mjpegdec_class,
2977 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2978 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2979 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2980 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2981 #if CONFIG_MJPEG_NVDEC_HWACCEL
2982 HWACCEL_NVDEC(mjpeg),
2984 #if CONFIG_MJPEG_VAAPI_HWACCEL
2985 HWACCEL_VAAPI(mjpeg),
2991 #if CONFIG_THP_DECODER
2992 AVCodec ff_thp_decoder = {
2994 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2995 .type = AVMEDIA_TYPE_VIDEO,
2996 .id = AV_CODEC_ID_THP,
2997 .priv_data_size = sizeof(MJpegDecodeContext),
2998 .init = ff_mjpeg_decode_init,
2999 .close = ff_mjpeg_decode_end,
3000 .receive_frame = ff_mjpeg_receive_frame,
3001 .flush = decode_flush,
3002 .capabilities = AV_CODEC_CAP_DR1,
3004 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
3005 FF_CODEC_CAP_SETS_PKT_DTS,
3009 #if CONFIG_SMVJPEG_DECODER
3010 AVCodec ff_smvjpeg_decoder = {
3012 .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
3013 .type = AVMEDIA_TYPE_VIDEO,
3014 .id = AV_CODEC_ID_SMVJPEG,
3015 .priv_data_size = sizeof(MJpegDecodeContext),
3016 .init = ff_mjpeg_decode_init,
3017 .close = ff_mjpeg_decode_end,
3018 .receive_frame = ff_mjpeg_receive_frame,
3019 .flush = decode_flush,
3020 .capabilities = AV_CODEC_CAP_DR1,
3021 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3022 FF_CODEC_CAP_SETS_PKT_DTS | FF_CODEC_CAP_INIT_CLEANUP,