3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
11 * This file is part of FFmpeg.
13 * FFmpeg is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU Lesser General Public
15 * License as published by the Free Software Foundation; either
16 * version 2.1 of the License, or (at your option) any later version.
18 * FFmpeg is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * Lesser General Public License for more details.
23 * You should have received a copy of the GNU Lesser General Public
24 * License along with FFmpeg; if not, write to the Free Software
25 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
38 #include "copy_block.h"
43 #include "jpegtables.h"
46 #include "jpeglsdec.h"
51 #include "bytestream.h"
54 static void build_huffman_codes(uint8_t *huff_size, const uint8_t *bits_table)
56 for (int i = 1, k = 0; i <= 16; i++) {
57 int nb = bits_table[i];
58 for (int j = 0; j < nb;j++) {
65 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
66 const uint8_t *val_table, int nb_codes,
67 int is_ac, void *logctx)
69 uint8_t huff_size[256];
70 uint16_t huff_sym[256];
73 av_assert0(nb_codes <= 256);
75 build_huffman_codes(huff_size, bits_table);
77 for (i = 0; i < nb_codes; i++) {
78 huff_sym[i] = val_table[i] + 16 * is_ac;
80 if (is_ac && !val_table[i])
81 huff_sym[i] = 16 * 256;
84 return ff_init_vlc_from_lengths(vlc, 9, nb_codes, huff_size, 1,
85 huff_sym, 2, 2, 0, 0, logctx);
88 static int init_default_huffman_tables(MJpegDecodeContext *s)
94 const uint8_t *values;
97 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
98 avpriv_mjpeg_val_dc, 12 },
99 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
100 avpriv_mjpeg_val_dc, 12 },
101 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
102 avpriv_mjpeg_val_ac_luminance, 162 },
103 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
104 avpriv_mjpeg_val_ac_chrominance, 162 },
105 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
106 avpriv_mjpeg_val_ac_luminance, 162 },
107 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
108 avpriv_mjpeg_val_ac_chrominance, 162 },
112 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
113 ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
114 ht[i].bits, ht[i].values, ht[i].length,
115 ht[i].class == 1, s->avctx);
119 if (ht[i].class < 2) {
120 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
122 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
123 ht[i].values, ht[i].length);
130 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
133 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
134 s->interlace_polarity = 1;
135 if (len > 14 && buf[12] == 2) /* 2 - PAL */
136 s->interlace_polarity = 0;
137 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
138 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
141 static void init_idct(AVCodecContext *avctx)
143 MJpegDecodeContext *s = avctx->priv_data;
145 ff_idctdsp_init(&s->idsp, avctx);
146 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
150 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
152 MJpegDecodeContext *s = avctx->priv_data;
155 if (!s->picture_ptr) {
156 s->picture = av_frame_alloc();
158 return AVERROR(ENOMEM);
159 s->picture_ptr = s->picture;
162 s->pkt = av_packet_alloc();
164 return AVERROR(ENOMEM);
167 ff_blockdsp_init(&s->bdsp, avctx);
168 ff_hpeldsp_init(&s->hdsp, avctx->flags);
173 s->first_picture = 1;
175 s->orig_height = avctx->coded_height;
176 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
177 avctx->colorspace = AVCOL_SPC_BT470BG;
178 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
180 if ((ret = init_default_huffman_tables(s)) < 0)
183 if (s->extern_huff) {
184 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
185 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
187 if (ff_mjpeg_decode_dht(s)) {
188 av_log(avctx, AV_LOG_ERROR,
189 "error using external huffman table, switching back to internal\n");
190 init_default_huffman_tables(s);
193 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
194 s->interlace_polarity = 1; /* bottom field first */
195 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
196 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
197 if (avctx->codec_tag == AV_RL32("MJPG"))
198 s->interlace_polarity = 1;
201 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
202 if (avctx->extradata_size >= 4)
203 s->smv_frames_per_jpeg = AV_RL32(avctx->extradata);
205 if (s->smv_frames_per_jpeg <= 0) {
206 av_log(avctx, AV_LOG_ERROR, "Invalid number of frames per jpeg.\n");
207 return AVERROR_INVALIDDATA;
210 s->smv_frame = av_frame_alloc();
212 return AVERROR(ENOMEM);
213 } else if (avctx->extradata_size > 8
214 && AV_RL32(avctx->extradata) == 0x2C
215 && AV_RL32(avctx->extradata+4) == 0x18) {
216 parse_avid(s, avctx->extradata, avctx->extradata_size);
219 if (avctx->codec->id == AV_CODEC_ID_AMV)
226 /* quantize tables */
227 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
231 len = get_bits(&s->gb, 16) - 2;
233 if (8*len > get_bits_left(&s->gb)) {
234 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
235 return AVERROR_INVALIDDATA;
239 int pr = get_bits(&s->gb, 4);
241 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
242 return AVERROR_INVALIDDATA;
244 index = get_bits(&s->gb, 4);
247 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
248 /* read quant table */
249 for (i = 0; i < 64; i++) {
250 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
251 if (s->quant_matrixes[index][i] == 0) {
252 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
253 return AVERROR_INVALIDDATA;
257 // XXX FIXME fine-tune, and perhaps add dc too
258 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
259 s->quant_matrixes[index][8]) >> 1;
260 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
261 index, s->qscale[index]);
262 len -= 1 + 64 * (1+pr);
267 /* decode huffman tables and build VLC decoders */
268 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
270 int len, index, i, class, n, v;
271 uint8_t bits_table[17];
272 uint8_t val_table[256];
275 len = get_bits(&s->gb, 16) - 2;
277 if (8*len > get_bits_left(&s->gb)) {
278 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
279 return AVERROR_INVALIDDATA;
284 return AVERROR_INVALIDDATA;
285 class = get_bits(&s->gb, 4);
287 return AVERROR_INVALIDDATA;
288 index = get_bits(&s->gb, 4);
290 return AVERROR_INVALIDDATA;
292 for (i = 1; i <= 16; i++) {
293 bits_table[i] = get_bits(&s->gb, 8);
297 if (len < n || n > 256)
298 return AVERROR_INVALIDDATA;
300 for (i = 0; i < n; i++) {
301 v = get_bits(&s->gb, 8);
306 /* build VLC and flush previous vlc if present */
307 ff_free_vlc(&s->vlcs[class][index]);
308 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
310 if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
311 n, class > 0, s->avctx)) < 0)
315 ff_free_vlc(&s->vlcs[2][index]);
316 if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
317 n, 0, s->avctx)) < 0)
321 for (i = 0; i < 16; i++)
322 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
323 for (i = 0; i < 256; i++)
324 s->raw_huffman_values[class][index][i] = val_table[i];
329 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
331 int len, nb_components, i, width, height, bits, ret, size_change;
333 int h_count[MAX_COMPONENTS] = { 0 };
334 int v_count[MAX_COMPONENTS] = { 0 };
337 memset(s->upscale_h, 0, sizeof(s->upscale_h));
338 memset(s->upscale_v, 0, sizeof(s->upscale_v));
340 len = get_bits(&s->gb, 16);
341 bits = get_bits(&s->gb, 8);
343 if (bits > 16 || bits < 1) {
344 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
345 return AVERROR_INVALIDDATA;
348 if (s->avctx->bits_per_raw_sample != bits) {
349 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);
350 s->avctx->bits_per_raw_sample = bits;
355 if (bits == 9 && !s->pegasus_rct)
356 s->rct = 1; // FIXME ugly
358 if(s->lossless && s->avctx->lowres){
359 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
363 height = get_bits(&s->gb, 16);
364 width = get_bits(&s->gb, 16);
366 // HACK for odd_height.mov
367 if (s->interlaced && s->width == width && s->height == height + 1)
370 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
371 if (av_image_check_size(width, height, 0, s->avctx) < 0)
372 return AVERROR_INVALIDDATA;
373 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
374 return AVERROR_INVALIDDATA;
376 nb_components = get_bits(&s->gb, 8);
377 if (nb_components <= 0 ||
378 nb_components > MAX_COMPONENTS)
380 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
381 if (nb_components != s->nb_components) {
382 av_log(s->avctx, AV_LOG_ERROR,
383 "nb_components changing in interlaced picture\n");
384 return AVERROR_INVALIDDATA;
387 if (s->ls && !(bits <= 8 || nb_components == 1)) {
388 avpriv_report_missing_feature(s->avctx,
389 "JPEG-LS that is not <= 8 "
390 "bits/component or 16-bit gray");
391 return AVERROR_PATCHWELCOME;
393 if (len != 8 + 3 * nb_components) {
394 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
395 return AVERROR_INVALIDDATA;
398 s->nb_components = nb_components;
401 for (i = 0; i < nb_components; i++) {
403 s->component_id[i] = get_bits(&s->gb, 8) - 1;
404 h_count[i] = get_bits(&s->gb, 4);
405 v_count[i] = get_bits(&s->gb, 4);
406 /* compute hmax and vmax (only used in interleaved case) */
407 if (h_count[i] > s->h_max)
408 s->h_max = h_count[i];
409 if (v_count[i] > s->v_max)
410 s->v_max = v_count[i];
411 s->quant_index[i] = get_bits(&s->gb, 8);
412 if (s->quant_index[i] >= 4) {
413 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
414 return AVERROR_INVALIDDATA;
416 if (!h_count[i] || !v_count[i]) {
417 av_log(s->avctx, AV_LOG_ERROR,
418 "Invalid sampling factor in component %d %d:%d\n",
419 i, h_count[i], v_count[i]);
420 return AVERROR_INVALIDDATA;
423 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
424 i, h_count[i], v_count[i],
425 s->component_id[i], s->quant_index[i]);
427 if ( nb_components == 4
428 && s->component_id[0] == 'C' - 1
429 && s->component_id[1] == 'M' - 1
430 && s->component_id[2] == 'Y' - 1
431 && s->component_id[3] == 'K' - 1)
432 s->adobe_transform = 0;
434 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
435 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
436 return AVERROR_PATCHWELCOME;
440 if (nb_components == 2) {
441 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
442 width stored in their SOF3 markers is the width of each one. We only output
443 a single component, therefore we need to adjust the output image width. We
444 handle the deinterleaving (but not the debayering) in this file. */
447 /* They can also contain 1 component, which is double the width and half the height
448 of the final image (rows are interleaved). We don't handle the decoding in this
449 file, but leave that to the TIFF/DNG decoder. */
452 /* if different size, realloc/alloc picture */
453 if (width != s->width || height != s->height || bits != s->bits ||
454 memcmp(s->h_count, h_count, sizeof(h_count)) ||
455 memcmp(s->v_count, v_count, sizeof(v_count))) {
461 memcpy(s->h_count, h_count, sizeof(h_count));
462 memcpy(s->v_count, v_count, sizeof(v_count));
466 /* test interlaced mode */
467 if (s->first_picture &&
468 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
469 s->orig_height != 0 &&
470 s->height < ((s->orig_height * 3) / 4)) {
472 s->bottom_field = s->interlace_polarity;
473 s->picture_ptr->interlaced_frame = 1;
474 s->picture_ptr->top_field_first = !s->interlace_polarity;
478 ret = ff_set_dimensions(s->avctx, width, height);
482 s->first_picture = 0;
487 if (s->avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
488 s->avctx->height = s->avctx->coded_height / s->smv_frames_per_jpeg;
489 if (s->avctx->height <= 0)
490 return AVERROR_INVALIDDATA;
493 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
494 if (s->progressive) {
495 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
496 return AVERROR_INVALIDDATA;
499 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
501 else if (!s->lossless)
503 /* XXX: not complete test ! */
504 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
505 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
506 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
507 (s->h_count[3] << 4) | s->v_count[3];
508 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
509 /* NOTE we do not allocate pictures large enough for the possible
510 * padding of h/v_count being 4 */
511 if (!(pix_fmt_id & 0xD0D0D0D0))
512 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
513 if (!(pix_fmt_id & 0x0D0D0D0D))
514 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
516 for (i = 0; i < 8; i++) {
517 int j = 6 + (i&1) - (i&6);
518 int is = (pix_fmt_id >> (4*i)) & 0xF;
519 int js = (pix_fmt_id >> (4*j)) & 0xF;
521 if (is == 1 && js != 2 && (i < 2 || i > 5))
522 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
523 if (is == 1 && js != 2 && (i < 2 || i > 5))
524 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
526 if (is == 1 && js == 2) {
527 if (i & 1) s->upscale_h[j/2] = 1;
528 else s->upscale_v[j/2] = 1;
533 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
537 switch (pix_fmt_id) {
538 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
541 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
545 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
547 if ( s->adobe_transform == 0
548 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
549 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
551 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
552 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
553 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
556 av_assert0(s->nb_components == 3);
560 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
562 if (s->adobe_transform == 0 && s->bits <= 8) {
563 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
565 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
566 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
569 av_assert0(s->nb_components == 4);
573 if (s->adobe_transform == 0 && s->bits <= 8) {
574 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
575 s->upscale_v[1] = s->upscale_v[2] = 1;
576 s->upscale_h[1] = s->upscale_h[2] = 1;
577 } else if (s->adobe_transform == 2 && s->bits <= 8) {
578 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
579 s->upscale_v[1] = s->upscale_v[2] = 1;
580 s->upscale_h[1] = s->upscale_h[2] = 1;
581 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
583 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
584 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
585 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
587 av_assert0(s->nb_components == 4);
596 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
599 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
611 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
613 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
620 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
621 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
624 s->upscale_v[0] = s->upscale_v[1] = 1;
626 if (pix_fmt_id == 0x14111100)
627 s->upscale_v[1] = s->upscale_v[2] = 1;
628 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
631 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
635 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
636 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
639 s->upscale_h[0] = s->upscale_h[1] = 1;
641 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
642 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
643 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
649 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
650 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
651 s->upscale_h[1] = s->upscale_h[2] = 2;
655 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
658 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
664 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
665 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
666 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
667 if (pix_fmt_id == 0x42111100) {
670 s->upscale_h[1] = s->upscale_h[2] = 1;
671 } else if (pix_fmt_id == 0x24111100) {
674 s->upscale_v[1] = s->upscale_v[2] = 1;
675 } else if (pix_fmt_id == 0x23111100) {
678 s->upscale_v[1] = s->upscale_v[2] = 2;
682 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
685 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
689 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
690 memset(s->upscale_h, 0, sizeof(s->upscale_h));
691 memset(s->upscale_v, 0, sizeof(s->upscale_v));
692 return AVERROR_PATCHWELCOME;
694 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
695 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
696 return AVERROR_PATCHWELCOME;
698 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
699 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
700 return AVERROR_PATCHWELCOME;
703 memset(s->upscale_h, 0, sizeof(s->upscale_h));
704 memset(s->upscale_v, 0, sizeof(s->upscale_v));
705 if (s->nb_components == 3) {
706 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
707 } else if (s->nb_components != 1) {
708 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
709 return AVERROR_PATCHWELCOME;
710 } else if (s->palette_index && s->bits <= 8)
711 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
712 else if (s->bits <= 8)
713 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
715 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
718 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
720 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
724 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
725 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
727 enum AVPixelFormat pix_fmts[] = {
728 #if CONFIG_MJPEG_NVDEC_HWACCEL
731 #if CONFIG_MJPEG_VAAPI_HWACCEL
737 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
738 if (s->hwaccel_pix_fmt < 0)
739 return AVERROR(EINVAL);
741 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
742 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
745 if (s->avctx->skip_frame == AVDISCARD_ALL) {
746 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
747 s->picture_ptr->key_frame = 1;
752 av_frame_unref(s->picture_ptr);
753 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
755 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
756 s->picture_ptr->key_frame = 1;
759 for (i = 0; i < 4; i++)
760 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
762 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
763 s->width, s->height, s->linesize[0], s->linesize[1],
764 s->interlaced, s->avctx->height);
768 if ((s->rgb && !s->lossless && !s->ls) ||
769 (!s->rgb && s->ls && s->nb_components > 1) ||
770 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
772 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
773 return AVERROR_PATCHWELCOME;
776 /* totally blank picture as progressive JPEG will only add details to it */
777 if (s->progressive) {
778 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
779 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
780 for (i = 0; i < s->nb_components; i++) {
781 int size = bw * bh * s->h_count[i] * s->v_count[i];
782 av_freep(&s->blocks[i]);
783 av_freep(&s->last_nnz[i]);
784 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
785 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
786 if (!s->blocks[i] || !s->last_nnz[i])
787 return AVERROR(ENOMEM);
788 s->block_stride[i] = bw * s->h_count[i];
790 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
793 if (s->avctx->hwaccel) {
794 s->hwaccel_picture_private =
795 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
796 if (!s->hwaccel_picture_private)
797 return AVERROR(ENOMEM);
799 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
800 s->raw_image_buffer_size);
808 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
811 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
812 if (code < 0 || code > 16) {
813 av_log(s->avctx, AV_LOG_WARNING,
814 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
815 0, dc_index, &s->vlcs[0][dc_index]);
820 return get_xbits(&s->gb, code);
825 /* decode block and dequantize */
826 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
827 int dc_index, int ac_index, uint16_t *quant_matrix)
829 int code, i, j, level, val;
832 val = mjpeg_decode_dc(s, dc_index);
833 if (val == 0xfffff) {
834 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
835 return AVERROR_INVALIDDATA;
837 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
838 val = av_clip_int16(val);
839 s->last_dc[component] = val;
843 {OPEN_READER(re, &s->gb);
845 UPDATE_CACHE(re, &s->gb);
846 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
848 i += ((unsigned)code) >> 4;
851 if (code > MIN_CACHE_BITS - 16)
852 UPDATE_CACHE(re, &s->gb);
855 int cache = GET_CACHE(re, &s->gb);
856 int sign = (~cache) >> 31;
857 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
860 LAST_SKIP_BITS(re, &s->gb, code);
863 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
864 return AVERROR_INVALIDDATA;
866 j = s->scantable.permutated[i];
867 block[j] = level * quant_matrix[i];
870 CLOSE_READER(re, &s->gb);}
875 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
876 int component, int dc_index,
877 uint16_t *quant_matrix, int Al)
880 s->bdsp.clear_block(block);
881 val = mjpeg_decode_dc(s, dc_index);
882 if (val == 0xfffff) {
883 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
884 return AVERROR_INVALIDDATA;
886 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
887 s->last_dc[component] = val;
892 /* decode block and dequantize - progressive JPEG version */
893 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
894 uint8_t *last_nnz, int ac_index,
895 uint16_t *quant_matrix,
896 int ss, int se, int Al, int *EOBRUN)
898 int code, i, j, val, run;
907 OPEN_READER(re, &s->gb);
908 for (i = ss; ; i++) {
909 UPDATE_CACHE(re, &s->gb);
910 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
912 run = ((unsigned) code) >> 4;
916 if (code > MIN_CACHE_BITS - 16)
917 UPDATE_CACHE(re, &s->gb);
920 int cache = GET_CACHE(re, &s->gb);
921 int sign = (~cache) >> 31;
922 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
925 LAST_SKIP_BITS(re, &s->gb, code);
929 j = s->scantable.permutated[se];
930 block[j] = level * (quant_matrix[se] << Al);
933 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
934 return AVERROR_INVALIDDATA;
936 j = s->scantable.permutated[i];
937 block[j] = level * (quant_matrix[i] << Al);
939 if (run == 0xF) {// ZRL - skip 15 coefficients
942 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
943 return AVERROR_INVALIDDATA;
948 UPDATE_CACHE(re, &s->gb);
949 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
950 LAST_SKIP_BITS(re, &s->gb, run);
957 CLOSE_READER(re, &s->gb);
966 #define REFINE_BIT(j) { \
967 UPDATE_CACHE(re, &s->gb); \
968 sign = block[j] >> 15; \
969 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
970 ((quant_matrix[i] ^ sign) - sign) << Al; \
971 LAST_SKIP_BITS(re, &s->gb, 1); \
979 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
984 j = s->scantable.permutated[i]; \
987 else if (run-- == 0) \
991 /* decode block and dequantize - progressive JPEG refinement pass */
992 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
994 int ac_index, uint16_t *quant_matrix,
995 int ss, int se, int Al, int *EOBRUN)
997 int code, i = ss, j, sign, val, run;
998 int last = FFMIN(se, *last_nnz);
1000 OPEN_READER(re, &s->gb);
1005 UPDATE_CACHE(re, &s->gb);
1006 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
1009 run = ((unsigned) code) >> 4;
1010 UPDATE_CACHE(re, &s->gb);
1011 val = SHOW_UBITS(re, &s->gb, 1);
1012 LAST_SKIP_BITS(re, &s->gb, 1);
1014 j = s->scantable.permutated[i];
1016 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
1020 CLOSE_READER(re, &s->gb);
1024 run = ((unsigned) code) >> 4;
1031 UPDATE_CACHE(re, &s->gb);
1032 run += SHOW_UBITS(re, &s->gb, val);
1033 LAST_SKIP_BITS(re, &s->gb, val);
1045 for (; i <= last; i++) {
1046 j = s->scantable.permutated[i];
1050 CLOSE_READER(re, &s->gb);
1057 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1062 if (s->restart_interval) {
1064 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1065 align_get_bits(&s->gb);
1066 for (i = 0; i < nb_components; i++) /* reset dc */
1067 s->last_dc[i] = (4 << s->bits);
1070 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1072 if (s->restart_count == 0) {
1073 if( show_bits(&s->gb, i) == (1 << i) - 1
1074 || show_bits(&s->gb, i) == 0xFF) {
1075 int pos = get_bits_count(&s->gb);
1076 align_get_bits(&s->gb);
1077 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1078 skip_bits(&s->gb, 8);
1079 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1080 for (i = 0; i < nb_components; i++) /* reset dc */
1081 s->last_dc[i] = (4 << s->bits);
1084 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1091 /* Handles 1 to 4 components */
1092 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1096 uint16_t (*buffer)[4];
1097 int left[4], top[4], topleft[4];
1098 const int linesize = s->linesize[0];
1099 const int mask = ((1 << s->bits) - 1) << point_transform;
1100 int resync_mb_y = 0;
1101 int resync_mb_x = 0;
1104 if (!s->bayer && s->nb_components < 3)
1105 return AVERROR_INVALIDDATA;
1106 if (s->bayer && s->nb_components > 2)
1107 return AVERROR_INVALIDDATA;
1108 if (s->nb_components <= 0 || s->nb_components > 4)
1109 return AVERROR_INVALIDDATA;
1110 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1111 return AVERROR_INVALIDDATA;
1114 s->restart_count = s->restart_interval;
1116 if (s->restart_interval == 0)
1117 s->restart_interval = INT_MAX;
1120 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1122 width = s->mb_width;
1124 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1125 if (!s->ljpeg_buffer)
1126 return AVERROR(ENOMEM);
1128 buffer = s->ljpeg_buffer;
1130 for (i = 0; i < 4; i++)
1131 buffer[0][i] = 1 << (s->bits - 1);
1133 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1134 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1136 if (s->interlaced && s->bottom_field)
1137 ptr += linesize >> 1;
1139 for (i = 0; i < 4; i++)
1140 top[i] = left[i] = topleft[i] = buffer[0][i];
1142 if ((mb_y * s->width) % s->restart_interval == 0) {
1143 for (i = 0; i < 6; i++)
1144 vpred[i] = 1 << (s->bits-1);
1147 for (mb_x = 0; mb_x < width; mb_x++) {
1148 int modified_predictor = predictor;
1150 if (get_bits_left(&s->gb) < 1) {
1151 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1152 return AVERROR_INVALIDDATA;
1155 if (s->restart_interval && !s->restart_count){
1156 s->restart_count = s->restart_interval;
1160 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1162 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1163 modified_predictor = 1;
1165 for (i=0;i<nb_components;i++) {
1168 topleft[i] = top[i];
1169 top[i] = buffer[mb_x][i];
1171 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1175 if (!s->bayer || mb_x) {
1177 } else { /* This path runs only for the first line in bayer images */
1179 pred = vpred[i] - dc;
1182 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1184 left[i] = buffer[mb_x][i] =
1185 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1188 if (s->restart_interval && !--s->restart_count) {
1189 align_get_bits(&s->gb);
1190 skip_bits(&s->gb, 16); /* skip RSTn */
1193 if (s->rct && s->nb_components == 4) {
1194 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1195 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1196 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1197 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1198 ptr[4*mb_x + 0] = buffer[mb_x][3];
1200 } else if (s->nb_components == 4) {
1201 for(i=0; i<nb_components; i++) {
1202 int c= s->comp_index[i];
1204 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1205 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1207 } else if(s->bits == 9) {
1208 return AVERROR_PATCHWELCOME;
1210 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1211 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1215 } else if (s->rct) {
1216 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1217 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1218 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1219 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1221 } else if (s->pegasus_rct) {
1222 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1223 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1224 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1225 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1227 } else if (s->bayer) {
1228 if (nb_components == 1) {
1229 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1230 for (mb_x = 0; mb_x < width; mb_x++)
1231 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1232 } else if (nb_components == 2) {
1233 for (mb_x = 0; mb_x < width; mb_x++) {
1234 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1235 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1239 for(i=0; i<nb_components; i++) {
1240 int c= s->comp_index[i];
1242 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1243 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1245 } else if(s->bits == 9) {
1246 return AVERROR_PATCHWELCOME;
1248 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1249 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1258 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1259 int point_transform, int nb_components)
1261 int i, mb_x, mb_y, mask;
1262 int bits= (s->bits+7)&~7;
1263 int resync_mb_y = 0;
1264 int resync_mb_x = 0;
1266 point_transform += bits - s->bits;
1267 mask = ((1 << s->bits) - 1) << point_transform;
1269 av_assert0(nb_components>=1 && nb_components<=4);
1271 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1272 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1273 if (get_bits_left(&s->gb) < 1) {
1274 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1275 return AVERROR_INVALIDDATA;
1277 if (s->restart_interval && !s->restart_count){
1278 s->restart_count = s->restart_interval;
1283 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1284 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1285 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1286 for (i = 0; i < nb_components; i++) {
1289 int n, h, v, x, y, c, j, linesize;
1290 n = s->nb_blocks[i];
1291 c = s->comp_index[i];
1296 linesize= s->linesize[c];
1298 if(bits>8) linesize /= 2;
1300 for(j=0; j<n; j++) {
1303 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1306 if ( h * mb_x + x >= s->width
1307 || v * mb_y + y >= s->height) {
1309 } else if (bits<=8) {
1310 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1312 if(x==0 && leftcol){
1313 pred= 1 << (bits - 1);
1318 if(x==0 && leftcol){
1319 pred= ptr[-linesize];
1321 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1325 if (s->interlaced && s->bottom_field)
1326 ptr += linesize >> 1;
1328 *ptr= pred + ((unsigned)dc << point_transform);
1330 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1332 if(x==0 && leftcol){
1333 pred= 1 << (bits - 1);
1338 if(x==0 && leftcol){
1339 pred= ptr16[-linesize];
1341 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1345 if (s->interlaced && s->bottom_field)
1346 ptr16 += linesize >> 1;
1348 *ptr16= pred + ((unsigned)dc << point_transform);
1357 for (i = 0; i < nb_components; i++) {
1360 int n, h, v, x, y, c, j, linesize, dc;
1361 n = s->nb_blocks[i];
1362 c = s->comp_index[i];
1367 linesize = s->linesize[c];
1369 if(bits>8) linesize /= 2;
1371 for (j = 0; j < n; j++) {
1374 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1377 if ( h * mb_x + x >= s->width
1378 || v * mb_y + y >= s->height) {
1380 } else if (bits<=8) {
1381 ptr = s->picture_ptr->data[c] +
1382 (linesize * (v * mb_y + y)) +
1383 (h * mb_x + x); //FIXME optimize this crap
1384 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1387 *ptr = pred + ((unsigned)dc << point_transform);
1389 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1390 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1393 *ptr16= pred + ((unsigned)dc << point_transform);
1403 if (s->restart_interval && !--s->restart_count) {
1404 align_get_bits(&s->gb);
1405 skip_bits(&s->gb, 16); /* skip RSTn */
1412 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1413 uint8_t *dst, const uint8_t *src,
1414 int linesize, int lowres)
1417 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1419 case 1: copy_block4(dst, src, linesize, linesize, 4);
1421 case 2: copy_block2(dst, src, linesize, linesize, 2);
1423 case 3: *dst = *src;
1428 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1430 int block_x, block_y;
1431 int size = 8 >> s->avctx->lowres;
1433 for (block_y=0; block_y<size; block_y++)
1434 for (block_x=0; block_x<size; block_x++)
1435 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1437 for (block_y=0; block_y<size; block_y++)
1438 for (block_x=0; block_x<size; block_x++)
1439 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1443 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1444 int Al, const uint8_t *mb_bitmask,
1445 int mb_bitmask_size,
1446 const AVFrame *reference)
1448 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1449 uint8_t *data[MAX_COMPONENTS];
1450 const uint8_t *reference_data[MAX_COMPONENTS];
1451 int linesize[MAX_COMPONENTS];
1452 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1453 int bytes_per_pixel = 1 + (s->bits > 8);
1456 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1457 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1458 return AVERROR_INVALIDDATA;
1460 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1463 s->restart_count = 0;
1465 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1467 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1468 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1470 for (i = 0; i < nb_components; i++) {
1471 int c = s->comp_index[i];
1472 data[c] = s->picture_ptr->data[c];
1473 reference_data[c] = reference ? reference->data[c] : NULL;
1474 linesize[c] = s->linesize[c];
1475 s->coefs_finished[c] |= 1;
1478 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1479 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1480 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1482 if (s->restart_interval && !s->restart_count)
1483 s->restart_count = s->restart_interval;
1485 if (get_bits_left(&s->gb) < 0) {
1486 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1487 -get_bits_left(&s->gb));
1488 return AVERROR_INVALIDDATA;
1490 for (i = 0; i < nb_components; i++) {
1492 int n, h, v, x, y, c, j;
1494 n = s->nb_blocks[i];
1495 c = s->comp_index[i];
1500 for (j = 0; j < n; j++) {
1501 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1502 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1504 if (s->interlaced && s->bottom_field)
1505 block_offset += linesize[c] >> 1;
1506 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1507 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1508 ptr = data[c] + block_offset;
1511 if (!s->progressive) {
1514 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1515 linesize[c], s->avctx->lowres);
1518 s->bdsp.clear_block(s->block);
1519 if (decode_block(s, s->block, i,
1520 s->dc_index[i], s->ac_index[i],
1521 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1522 av_log(s->avctx, AV_LOG_ERROR,
1523 "error y=%d x=%d\n", mb_y, mb_x);
1524 return AVERROR_INVALIDDATA;
1527 s->idsp.idct_put(ptr, linesize[c], s->block);
1529 shift_output(s, ptr, linesize[c]);
1533 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1535 int16_t *block = s->blocks[c][block_idx];
1537 block[0] += get_bits1(&s->gb) *
1538 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1539 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1540 s->quant_matrixes[s->quant_sindex[i]],
1542 av_log(s->avctx, AV_LOG_ERROR,
1543 "error y=%d x=%d\n", mb_y, mb_x);
1544 return AVERROR_INVALIDDATA;
1547 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1548 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1549 mb_x, mb_y, x, y, c, s->bottom_field,
1550 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1558 handle_rstn(s, nb_components);
1564 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1565 int se, int Ah, int Al)
1569 int c = s->comp_index[0];
1570 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1572 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1573 if (se < ss || se > 63) {
1574 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1575 return AVERROR_INVALIDDATA;
1578 // s->coefs_finished is a bitmask for coefficients coded
1579 // ss and se are parameters telling start and end coefficients
1580 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1582 s->restart_count = 0;
1584 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1585 int block_idx = mb_y * s->block_stride[c];
1586 int16_t (*block)[64] = &s->blocks[c][block_idx];
1587 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1588 if (get_bits_left(&s->gb) <= 0) {
1589 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1590 return AVERROR_INVALIDDATA;
1592 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1594 if (s->restart_interval && !s->restart_count)
1595 s->restart_count = s->restart_interval;
1598 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1599 quant_matrix, ss, se, Al, &EOBRUN);
1601 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1602 quant_matrix, ss, se, Al, &EOBRUN);
1604 av_log(s->avctx, AV_LOG_ERROR,
1605 "error y=%d x=%d\n", mb_y, mb_x);
1606 return AVERROR_INVALIDDATA;
1609 if (handle_rstn(s, 0))
1616 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1620 const int bytes_per_pixel = 1 + (s->bits > 8);
1621 const int block_size = s->lossless ? 1 : 8;
1623 for (c = 0; c < s->nb_components; c++) {
1624 uint8_t *data = s->picture_ptr->data[c];
1625 int linesize = s->linesize[c];
1626 int h = s->h_max / s->h_count[c];
1627 int v = s->v_max / s->v_count[c];
1628 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1629 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1631 if (~s->coefs_finished[c])
1632 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1634 if (s->interlaced && s->bottom_field)
1635 data += linesize >> 1;
1637 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1638 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1639 int block_idx = mb_y * s->block_stride[c];
1640 int16_t (*block)[64] = &s->blocks[c][block_idx];
1641 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1642 s->idsp.idct_put(ptr, linesize, *block);
1644 shift_output(s, ptr, linesize);
1645 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1651 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1652 int mb_bitmask_size, const AVFrame *reference)
1654 int len, nb_components, i, h, v, predictor, point_transform;
1656 const int block_size = s->lossless ? 1 : 8;
1657 int ilv, prev_shift;
1659 if (!s->got_picture) {
1660 av_log(s->avctx, AV_LOG_WARNING,
1661 "Can not process SOS before SOF, skipping\n");
1666 if (reference->width != s->picture_ptr->width ||
1667 reference->height != s->picture_ptr->height ||
1668 reference->format != s->picture_ptr->format) {
1669 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1670 return AVERROR_INVALIDDATA;
1674 /* XXX: verify len field validity */
1675 len = get_bits(&s->gb, 16);
1676 nb_components = get_bits(&s->gb, 8);
1677 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1678 avpriv_report_missing_feature(s->avctx,
1679 "decode_sos: nb_components (%d)",
1681 return AVERROR_PATCHWELCOME;
1683 if (len != 6 + 2 * nb_components) {
1684 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1685 return AVERROR_INVALIDDATA;
1687 for (i = 0; i < nb_components; i++) {
1688 id = get_bits(&s->gb, 8) - 1;
1689 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1690 /* find component index */
1691 for (index = 0; index < s->nb_components; index++)
1692 if (id == s->component_id[index])
1694 if (index == s->nb_components) {
1695 av_log(s->avctx, AV_LOG_ERROR,
1696 "decode_sos: index(%d) out of components\n", index);
1697 return AVERROR_INVALIDDATA;
1699 /* Metasoft MJPEG codec has Cb and Cr swapped */
1700 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1701 && nb_components == 3 && s->nb_components == 3 && i)
1704 s->quant_sindex[i] = s->quant_index[index];
1705 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1706 s->h_scount[i] = s->h_count[index];
1707 s->v_scount[i] = s->v_count[index];
1709 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1710 index = (index+2)%3;
1712 s->comp_index[i] = index;
1714 s->dc_index[i] = get_bits(&s->gb, 4);
1715 s->ac_index[i] = get_bits(&s->gb, 4);
1717 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1718 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1720 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))
1724 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1725 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1726 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1727 prev_shift = get_bits(&s->gb, 4); /* Ah */
1728 point_transform = get_bits(&s->gb, 4); /* Al */
1730 prev_shift = point_transform = 0;
1732 if (nb_components > 1) {
1733 /* interleaved stream */
1734 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1735 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1736 } else if (!s->ls) { /* skip this for JPEG-LS */
1737 h = s->h_max / s->h_scount[0];
1738 v = s->v_max / s->v_scount[0];
1739 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1740 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1741 s->nb_blocks[0] = 1;
1746 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1747 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1748 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1749 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1750 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1753 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1754 for (i = s->mjpb_skiptosod; i > 0; i--)
1755 skip_bits(&s->gb, 8);
1758 for (i = 0; i < nb_components; i++)
1759 s->last_dc[i] = (4 << s->bits);
1761 if (s->avctx->hwaccel) {
1762 int bytes_to_start = get_bits_count(&s->gb) / 8;
1763 av_assert0(bytes_to_start >= 0 &&
1764 s->raw_scan_buffer_size >= bytes_to_start);
1766 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1767 s->raw_scan_buffer + bytes_to_start,
1768 s->raw_scan_buffer_size - bytes_to_start);
1772 } else if (s->lossless) {
1773 av_assert0(s->picture_ptr == s->picture);
1774 if (CONFIG_JPEGLS_DECODER && s->ls) {
1776 // reset_ls_coding_parameters(s, 0);
1778 if ((ret = ff_jpegls_decode_picture(s, predictor,
1779 point_transform, ilv)) < 0)
1782 if (s->rgb || s->bayer) {
1783 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1786 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1788 nb_components)) < 0)
1793 if (s->progressive && predictor) {
1794 av_assert0(s->picture_ptr == s->picture);
1795 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1797 point_transform)) < 0)
1800 if ((ret = mjpeg_decode_scan(s, nb_components,
1801 prev_shift, point_transform,
1802 mb_bitmask, mb_bitmask_size, reference)) < 0)
1807 if (s->interlaced &&
1808 get_bits_left(&s->gb) > 32 &&
1809 show_bits(&s->gb, 8) == 0xFF) {
1810 GetBitContext bak = s->gb;
1811 align_get_bits(&bak);
1812 if (show_bits(&bak, 16) == 0xFFD1) {
1813 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1815 skip_bits(&s->gb, 16);
1816 s->bottom_field ^= 1;
1825 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1826 return AVERROR_INVALIDDATA;
1829 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1831 if (get_bits(&s->gb, 16) != 4)
1832 return AVERROR_INVALIDDATA;
1833 s->restart_interval = get_bits(&s->gb, 16);
1834 s->restart_count = 0;
1835 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1836 s->restart_interval);
1841 static int mjpeg_decode_app(MJpegDecodeContext *s)
1845 len = get_bits(&s->gb, 16);
1848 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1849 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1850 skip_bits(&s->gb, len);
1853 return AVERROR_INVALIDDATA;
1855 if (8 * len > get_bits_left(&s->gb))
1856 return AVERROR_INVALIDDATA;
1858 id = get_bits_long(&s->gb, 32);
1861 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1862 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1863 av_fourcc2str(av_bswap32(id)), id, len);
1865 /* Buggy AVID, it puts EOI only at every 10th frame. */
1866 /* Also, this fourcc is used by non-avid files too, it holds some
1867 information, but it's always present in AVID-created files. */
1868 if (id == AV_RB32("AVI1")) {
1874 4bytes field_size_less_padding
1877 i = get_bits(&s->gb, 8); len--;
1878 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1882 if (id == AV_RB32("JFIF")) {
1883 int t_w, t_h, v1, v2;
1886 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1887 v1 = get_bits(&s->gb, 8);
1888 v2 = get_bits(&s->gb, 8);
1889 skip_bits(&s->gb, 8);
1891 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1892 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1893 if ( s->avctx->sample_aspect_ratio.num <= 0
1894 || s->avctx->sample_aspect_ratio.den <= 0) {
1895 s->avctx->sample_aspect_ratio.num = 0;
1896 s->avctx->sample_aspect_ratio.den = 1;
1899 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1900 av_log(s->avctx, AV_LOG_INFO,
1901 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1903 s->avctx->sample_aspect_ratio.num,
1904 s->avctx->sample_aspect_ratio.den);
1908 t_w = get_bits(&s->gb, 8);
1909 t_h = get_bits(&s->gb, 8);
1911 /* skip thumbnail */
1912 if (len -10 - (t_w * t_h * 3) > 0)
1913 len -= t_w * t_h * 3;
1920 if ( id == AV_RB32("Adob")
1922 && show_bits(&s->gb, 8) == 'e'
1923 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1924 skip_bits(&s->gb, 8); /* 'e' */
1925 skip_bits(&s->gb, 16); /* version */
1926 skip_bits(&s->gb, 16); /* flags0 */
1927 skip_bits(&s->gb, 16); /* flags1 */
1928 s->adobe_transform = get_bits(&s->gb, 8);
1929 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1930 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1935 if (id == AV_RB32("LJIF")) {
1937 int pegasus_rct = s->pegasus_rct;
1938 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1939 av_log(s->avctx, AV_LOG_INFO,
1940 "Pegasus lossless jpeg header found\n");
1941 skip_bits(&s->gb, 16); /* version ? */
1942 skip_bits(&s->gb, 16); /* unknown always 0? */
1943 skip_bits(&s->gb, 16); /* unknown always 0? */
1944 skip_bits(&s->gb, 16); /* unknown always 0? */
1945 switch (i=get_bits(&s->gb, 8)) {
1955 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1960 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1961 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1966 s->pegasus_rct = pegasus_rct;
1970 if (id == AV_RL32("colr") && len > 0) {
1971 s->colr = get_bits(&s->gb, 8);
1972 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1973 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1977 if (id == AV_RL32("xfrm") && len > 0) {
1978 s->xfrm = get_bits(&s->gb, 8);
1979 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1980 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1985 /* JPS extension by VRex */
1986 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1987 int flags, layout, type;
1988 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1989 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1991 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1992 skip_bits(&s->gb, 16); len -= 2; /* block length */
1993 skip_bits(&s->gb, 8); /* reserved */
1994 flags = get_bits(&s->gb, 8);
1995 layout = get_bits(&s->gb, 8);
1996 type = get_bits(&s->gb, 8);
1999 av_freep(&s->stereo3d);
2000 s->stereo3d = av_stereo3d_alloc();
2005 s->stereo3d->type = AV_STEREO3D_2D;
2006 } else if (type == 1) {
2009 s->stereo3d->type = AV_STEREO3D_LINES;
2012 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
2015 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2018 if (!(flags & 0x04)) {
2019 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2026 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2027 GetByteContext gbytes;
2028 int ret, le, ifd_offset, bytes_read;
2029 const uint8_t *aligned;
2031 skip_bits(&s->gb, 16); // skip padding
2034 // init byte wise reading
2035 aligned = align_get_bits(&s->gb);
2036 bytestream2_init(&gbytes, aligned, len);
2039 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2041 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2043 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2045 // read 0th IFD and store the metadata
2046 // (return values > 0 indicate the presence of subimage metadata)
2047 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2049 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2053 bytes_read = bytestream2_tell(&gbytes);
2054 skip_bits(&s->gb, bytes_read << 3);
2061 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2062 id = get_bits_long(&s->gb, 32);
2065 if (id == AV_RB32("mjpg")) {
2068 4bytes pad field size
2076 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2077 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2081 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2084 unsigned nummarkers;
2086 id = get_bits_long(&s->gb, 32);
2087 id2 = get_bits(&s->gb, 24);
2089 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2090 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2094 skip_bits(&s->gb, 8);
2095 seqno = get_bits(&s->gb, 8);
2098 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2102 nummarkers = get_bits(&s->gb, 8);
2104 if (nummarkers == 0) {
2105 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2107 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2108 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2110 } else if (seqno > nummarkers) {
2111 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2115 /* Allocate if this is the first APP2 we've seen. */
2116 if (s->iccnum == 0) {
2117 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2118 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2119 if (!s->iccdata || !s->iccdatalens) {
2120 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2121 return AVERROR(ENOMEM);
2123 s->iccnum = nummarkers;
2126 if (s->iccdata[seqno - 1]) {
2127 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2131 s->iccdatalens[seqno - 1] = len;
2132 s->iccdata[seqno - 1] = av_malloc(len);
2133 if (!s->iccdata[seqno - 1]) {
2134 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2135 return AVERROR(ENOMEM);
2138 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2139 skip_bits(&s->gb, len << 3);
2143 if (s->iccread > s->iccnum)
2144 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2148 /* slow but needed for extreme adobe jpegs */
2150 av_log(s->avctx, AV_LOG_ERROR,
2151 "mjpeg: error, decode_app parser read over the end\n");
2153 skip_bits(&s->gb, 8);
2158 static int mjpeg_decode_com(MJpegDecodeContext *s)
2160 int len = get_bits(&s->gb, 16);
2161 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2163 char *cbuf = av_malloc(len - 1);
2165 return AVERROR(ENOMEM);
2167 for (i = 0; i < len - 2; i++)
2168 cbuf[i] = get_bits(&s->gb, 8);
2169 if (i > 0 && cbuf[i - 1] == '\n')
2174 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2175 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2177 /* buggy avid, it puts EOI only at every 10th frame */
2178 if (!strncmp(cbuf, "AVID", 4)) {
2179 parse_avid(s, cbuf, len);
2180 } else if (!strcmp(cbuf, "CS=ITU601"))
2182 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2183 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2185 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2186 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2196 /* return the 8 bit start code value and update the search
2197 state. Return -1 if no start code found */
2198 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2200 const uint8_t *buf_ptr;
2205 buf_ptr = *pbuf_ptr;
2206 while (buf_end - buf_ptr > 1) {
2209 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2218 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2219 *pbuf_ptr = buf_ptr;
2223 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2224 const uint8_t **buf_ptr, const uint8_t *buf_end,
2225 const uint8_t **unescaped_buf_ptr,
2226 int *unescaped_buf_size)
2229 start_code = find_marker(buf_ptr, buf_end);
2231 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2233 return AVERROR(ENOMEM);
2235 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2236 if (start_code == SOS && !s->ls) {
2237 const uint8_t *src = *buf_ptr;
2238 const uint8_t *ptr = src;
2239 uint8_t *dst = s->buffer;
2241 #define copy_data_segment(skip) do { \
2242 ptrdiff_t length = (ptr - src) - (skip); \
2244 memcpy(dst, src, length); \
2250 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2252 copy_data_segment(0);
2254 while (ptr < buf_end) {
2255 uint8_t x = *(ptr++);
2259 while (ptr < buf_end && x == 0xff) {
2264 /* 0xFF, 0xFF, ... */
2266 copy_data_segment(skip);
2268 /* decrement src as it is equal to ptr after the
2269 * copy_data_segment macro and we might want to
2270 * copy the current value of x later on */
2274 if (x < RST0 || x > RST7) {
2275 copy_data_segment(1);
2282 copy_data_segment(0);
2284 #undef copy_data_segment
2286 *unescaped_buf_ptr = s->buffer;
2287 *unescaped_buf_size = dst - s->buffer;
2288 memset(s->buffer + *unescaped_buf_size, 0,
2289 AV_INPUT_BUFFER_PADDING_SIZE);
2291 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2292 (buf_end - *buf_ptr) - (dst - s->buffer));
2293 } else if (start_code == SOS && s->ls) {
2294 const uint8_t *src = *buf_ptr;
2295 uint8_t *dst = s->buffer;
2301 while (src + t < buf_end) {
2302 uint8_t x = src[t++];
2304 while ((src + t < buf_end) && x == 0xff)
2313 init_put_bits(&pb, dst, t);
2315 /* unescape bitstream */
2317 uint8_t x = src[b++];
2318 put_bits(&pb, 8, x);
2319 if (x == 0xFF && b < t) {
2322 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2325 put_bits(&pb, 7, x);
2329 flush_put_bits(&pb);
2331 *unescaped_buf_ptr = dst;
2332 *unescaped_buf_size = (bit_count + 7) >> 3;
2333 memset(s->buffer + *unescaped_buf_size, 0,
2334 AV_INPUT_BUFFER_PADDING_SIZE);
2336 *unescaped_buf_ptr = *buf_ptr;
2337 *unescaped_buf_size = buf_end - *buf_ptr;
2343 static void reset_icc_profile(MJpegDecodeContext *s)
2348 for (i = 0; i < s->iccnum; i++)
2349 av_freep(&s->iccdata[i]);
2350 av_freep(&s->iccdata);
2351 av_freep(&s->iccdatalens);
2357 // SMV JPEG just stacks several output frames into one JPEG picture
2358 // we handle that by setting up the cropping parameters appropriately
2359 static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
2361 MJpegDecodeContext *s = avctx->priv_data;
2364 if (s->smv_next_frame > 0) {
2365 av_assert0(s->smv_frame->buf[0]);
2366 av_frame_unref(frame);
2367 ret = av_frame_ref(frame, s->smv_frame);
2371 av_assert0(frame->buf[0]);
2372 av_frame_unref(s->smv_frame);
2373 ret = av_frame_ref(s->smv_frame, frame);
2378 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2380 frame->width = avctx->coded_width;
2381 frame->height = avctx->coded_height;
2382 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2383 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2385 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2387 if (s->smv_next_frame == 0)
2388 av_frame_unref(s->smv_frame);
2393 static int mjpeg_get_packet(AVCodecContext *avctx)
2395 MJpegDecodeContext *s = avctx->priv_data;
2398 av_packet_unref(s->pkt);
2399 ret = ff_decode_get_packet(avctx, s->pkt);
2403 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2404 if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2405 avctx->codec_id == AV_CODEC_ID_AMV) {
2406 ret = ff_sp5x_process_packet(avctx, s->pkt);
2412 s->buf_size = s->pkt->size;
2417 int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2419 MJpegDecodeContext *s = avctx->priv_data;
2420 const uint8_t *buf_end, *buf_ptr;
2421 const uint8_t *unescaped_buf_ptr;
2423 int unescaped_buf_size;
2429 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2430 return smv_process_frame(avctx, frame);
2432 av_dict_free(&s->exif_metadata);
2433 av_freep(&s->stereo3d);
2434 s->adobe_transform = -1;
2437 reset_icc_profile(s);
2439 ret = mjpeg_get_packet(avctx);
2443 buf_ptr = s->pkt->data;
2444 buf_end = s->pkt->data + s->pkt->size;
2445 while (buf_ptr < buf_end) {
2446 /* find start next marker */
2447 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2449 &unescaped_buf_size);
2451 if (start_code < 0) {
2453 } else if (unescaped_buf_size > INT_MAX / 8) {
2454 av_log(avctx, AV_LOG_ERROR,
2455 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2456 start_code, unescaped_buf_size, s->pkt->size);
2457 return AVERROR_INVALIDDATA;
2459 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2460 start_code, buf_end - buf_ptr);
2462 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2465 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2469 s->start_code = start_code;
2470 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2471 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2473 /* process markers */
2474 if (start_code >= RST0 && start_code <= RST7) {
2475 av_log(avctx, AV_LOG_DEBUG,
2476 "restart marker: %d\n", start_code & 0x0f);
2478 } else if (start_code >= APP0 && start_code <= APP15) {
2479 if ((ret = mjpeg_decode_app(s)) < 0)
2480 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2483 } else if (start_code == COM) {
2484 ret = mjpeg_decode_com(s);
2487 } else if (start_code == DQT) {
2488 ret = ff_mjpeg_decode_dqt(s);
2495 if (!CONFIG_JPEGLS_DECODER &&
2496 (start_code == SOF48 || start_code == LSE)) {
2497 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2498 return AVERROR(ENOSYS);
2501 if (avctx->skip_frame == AVDISCARD_ALL) {
2502 switch(start_code) {
2517 switch (start_code) {
2519 s->restart_interval = 0;
2520 s->restart_count = 0;
2521 s->raw_image_buffer = buf_ptr;
2522 s->raw_image_buffer_size = buf_end - buf_ptr;
2523 /* nothing to do on SOI */
2526 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2527 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2533 if (start_code == SOF0)
2534 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2536 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2540 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2544 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2548 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2552 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2553 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2557 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2561 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2562 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2566 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2570 if (!CONFIG_JPEGLS_DECODER ||
2571 (ret = ff_jpegls_decode_lse(s)) < 0)
2576 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2577 s->progressive && s->cur_scan && s->got_picture)
2578 mjpeg_idct_scan_progressive_ac(s);
2580 if (!s->got_picture) {
2581 av_log(avctx, AV_LOG_WARNING,
2582 "Found EOI before any SOF, ignoring\n");
2585 if (s->interlaced) {
2586 s->bottom_field ^= 1;
2587 /* if not bottom field, do not output image yet */
2588 if (s->bottom_field == !s->interlace_polarity)
2591 if (avctx->skip_frame == AVDISCARD_ALL) {
2593 ret = AVERROR(EAGAIN);
2594 goto the_end_no_picture;
2596 if (s->avctx->hwaccel) {
2597 ret = s->avctx->hwaccel->end_frame(s->avctx);
2601 av_freep(&s->hwaccel_picture_private);
2603 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2607 frame->pkt_dts = s->pkt->dts;
2610 int qp = FFMAX3(s->qscale[0],
2613 int qpw = (s->width + 15) / 16;
2614 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2616 memset(qp_table_buf->data, qp, qpw);
2617 av_frame_set_qp_table(frame, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2620 if(avctx->debug & FF_DEBUG_QP)
2621 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2626 s->raw_scan_buffer = buf_ptr;
2627 s->raw_scan_buffer_size = buf_end - buf_ptr;
2630 if (avctx->skip_frame == AVDISCARD_ALL) {
2631 skip_bits(&s->gb, get_bits_left(&s->gb));
2635 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2636 (avctx->err_recognition & AV_EF_EXPLODE))
2640 if ((ret = mjpeg_decode_dri(s)) < 0)
2653 av_log(avctx, AV_LOG_ERROR,
2654 "mjpeg: unsupported coding type (%x)\n", start_code);
2659 /* eof process start code */
2660 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2661 av_log(avctx, AV_LOG_DEBUG,
2662 "marker parser used %d bytes (%d bits)\n",
2663 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2665 if (s->got_picture && s->cur_scan) {
2666 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2669 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2670 return AVERROR_INVALIDDATA;
2676 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2678 if (AV_RB32(s->upscale_h)) {
2680 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2681 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2682 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2683 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2684 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2685 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2686 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2687 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2688 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2689 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2690 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2691 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2693 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2697 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2698 for (p = 0; p<s->nb_components; p++) {
2699 uint8_t *line = s->picture_ptr->data[p];
2702 if (!s->upscale_h[p])
2705 w = AV_CEIL_RSHIFT(w, hshift);
2706 h = AV_CEIL_RSHIFT(h, vshift);
2708 if (s->upscale_v[p] == 1)
2711 for (i = 0; i < h; i++) {
2712 if (s->upscale_h[p] == 1) {
2713 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2714 else line[w - 1] = line[(w - 1) / 2];
2715 for (index = w - 2; index > 0; index--) {
2717 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2719 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2721 } else if (s->upscale_h[p] == 2) {
2723 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2725 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2727 line[w - 1] = line[(w - 1) / 3];
2729 line[w - 2] = line[w - 1];
2731 for (index = w - 3; index > 0; index--) {
2732 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2735 line += s->linesize[p];
2739 if (AV_RB32(s->upscale_v)) {
2741 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2742 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2743 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2744 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2745 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2746 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2747 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2748 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2749 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2750 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2751 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2752 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2753 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2755 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2759 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2760 for (p = 0; p < s->nb_components; p++) {
2764 if (!s->upscale_v[p])
2767 w = AV_CEIL_RSHIFT(w, hshift);
2768 h = AV_CEIL_RSHIFT(h, vshift);
2770 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2771 for (i = h - 1; i; i--) {
2772 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2773 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2774 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2775 memcpy(dst, src1, w);
2777 for (index = 0; index < w; index++)
2778 dst[index] = (src1[index] + src2[index]) >> 1;
2780 dst -= s->linesize[p];
2784 if (s->flipped && !s->rgb) {
2786 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2790 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2791 for (index=0; index<s->nb_components; index++) {
2792 uint8_t *dst = s->picture_ptr->data[index];
2793 int w = s->picture_ptr->width;
2794 int h = s->picture_ptr->height;
2795 if(index && index<3){
2796 w = AV_CEIL_RSHIFT(w, hshift);
2797 h = AV_CEIL_RSHIFT(h, vshift);
2800 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2801 for (i=0; i<h/2; i++) {
2803 FFSWAP(int, dst[j], dst2[j]);
2804 dst += s->picture_ptr->linesize[index];
2805 dst2 -= s->picture_ptr->linesize[index];
2810 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2811 int w = s->picture_ptr->width;
2812 int h = s->picture_ptr->height;
2813 av_assert0(s->nb_components == 4);
2814 for (i=0; i<h; i++) {
2817 for (index=0; index<4; index++) {
2818 dst[index] = s->picture_ptr->data[index]
2819 + s->picture_ptr->linesize[index]*i;
2821 for (j=0; j<w; j++) {
2823 int r = dst[0][j] * k;
2824 int g = dst[1][j] * k;
2825 int b = dst[2][j] * k;
2826 dst[0][j] = g*257 >> 16;
2827 dst[1][j] = b*257 >> 16;
2828 dst[2][j] = r*257 >> 16;
2833 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2834 int w = s->picture_ptr->width;
2835 int h = s->picture_ptr->height;
2836 av_assert0(s->nb_components == 4);
2837 for (i=0; i<h; i++) {
2840 for (index=0; index<4; index++) {
2841 dst[index] = s->picture_ptr->data[index]
2842 + s->picture_ptr->linesize[index]*i;
2844 for (j=0; j<w; j++) {
2846 int r = (255 - dst[0][j]) * k;
2847 int g = (128 - dst[1][j]) * k;
2848 int b = (128 - dst[2][j]) * k;
2849 dst[0][j] = r*257 >> 16;
2850 dst[1][j] = (g*257 >> 16) + 128;
2851 dst[2][j] = (b*257 >> 16) + 128;
2858 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2860 stereo->type = s->stereo3d->type;
2861 stereo->flags = s->stereo3d->flags;
2863 av_freep(&s->stereo3d);
2866 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2867 AVFrameSideData *sd;
2872 /* Sum size of all parts. */
2873 for (i = 0; i < s->iccnum; i++)
2874 total_size += s->iccdatalens[i];
2876 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2878 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2879 return AVERROR(ENOMEM);
2882 /* Reassemble the parts, which are now in-order. */
2883 for (i = 0; i < s->iccnum; i++) {
2884 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2885 offset += s->iccdatalens[i];
2889 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2890 av_dict_free(&s->exif_metadata);
2892 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2893 ret = smv_process_frame(avctx, frame);
2895 av_frame_unref(frame);
2903 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2909 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2910 * even without having called ff_mjpeg_decode_init(). */
2911 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2913 MJpegDecodeContext *s = avctx->priv_data;
2916 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2917 av_log(avctx, AV_LOG_INFO, "Single field\n");
2921 av_frame_free(&s->picture);
2922 s->picture_ptr = NULL;
2923 } else if (s->picture_ptr)
2924 av_frame_unref(s->picture_ptr);
2926 av_packet_free(&s->pkt);
2928 av_frame_free(&s->smv_frame);
2930 av_freep(&s->buffer);
2931 av_freep(&s->stereo3d);
2932 av_freep(&s->ljpeg_buffer);
2933 s->ljpeg_buffer_size = 0;
2935 for (i = 0; i < 3; i++) {
2936 for (j = 0; j < 4; j++)
2937 ff_free_vlc(&s->vlcs[i][j]);
2939 for (i = 0; i < MAX_COMPONENTS; i++) {
2940 av_freep(&s->blocks[i]);
2941 av_freep(&s->last_nnz[i]);
2943 av_dict_free(&s->exif_metadata);
2945 reset_icc_profile(s);
2947 av_freep(&s->hwaccel_picture_private);
2952 static void decode_flush(AVCodecContext *avctx)
2954 MJpegDecodeContext *s = avctx->priv_data;
2957 s->smv_next_frame = 0;
2958 av_frame_unref(s->smv_frame);
2961 #if CONFIG_MJPEG_DECODER
2962 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2963 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2964 static const AVOption options[] = {
2965 { "extern_huff", "Use external huffman table.",
2966 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2970 static const AVClass mjpegdec_class = {
2971 .class_name = "MJPEG decoder",
2972 .item_name = av_default_item_name,
2974 .version = LIBAVUTIL_VERSION_INT,
2977 AVCodec ff_mjpeg_decoder = {
2979 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2980 .type = AVMEDIA_TYPE_VIDEO,
2981 .id = AV_CODEC_ID_MJPEG,
2982 .priv_data_size = sizeof(MJpegDecodeContext),
2983 .init = ff_mjpeg_decode_init,
2984 .close = ff_mjpeg_decode_end,
2985 .receive_frame = ff_mjpeg_receive_frame,
2986 .flush = decode_flush,
2987 .capabilities = AV_CODEC_CAP_DR1,
2989 .priv_class = &mjpegdec_class,
2990 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2991 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2992 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2993 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2994 #if CONFIG_MJPEG_NVDEC_HWACCEL
2995 HWACCEL_NVDEC(mjpeg),
2997 #if CONFIG_MJPEG_VAAPI_HWACCEL
2998 HWACCEL_VAAPI(mjpeg),
3004 #if CONFIG_THP_DECODER
3005 AVCodec ff_thp_decoder = {
3007 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
3008 .type = AVMEDIA_TYPE_VIDEO,
3009 .id = AV_CODEC_ID_THP,
3010 .priv_data_size = sizeof(MJpegDecodeContext),
3011 .init = ff_mjpeg_decode_init,
3012 .close = ff_mjpeg_decode_end,
3013 .receive_frame = ff_mjpeg_receive_frame,
3014 .flush = decode_flush,
3015 .capabilities = AV_CODEC_CAP_DR1,
3017 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
3018 FF_CODEC_CAP_SETS_PKT_DTS,
3022 #if CONFIG_SMVJPEG_DECODER
3023 AVCodec ff_smvjpeg_decoder = {
3025 .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
3026 .type = AVMEDIA_TYPE_VIDEO,
3027 .id = AV_CODEC_ID_SMVJPEG,
3028 .priv_data_size = sizeof(MJpegDecodeContext),
3029 .init = ff_mjpeg_decode_init,
3030 .close = ff_mjpeg_decode_end,
3031 .receive_frame = ff_mjpeg_receive_frame,
3032 .flush = decode_flush,
3033 .capabilities = AV_CODEC_CAP_DR1,
3034 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3035 FF_CODEC_CAP_SETS_PKT_DTS,