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;
2609 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2610 int qp = FFMAX3(s->qscale[0],
2614 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2619 s->raw_scan_buffer = buf_ptr;
2620 s->raw_scan_buffer_size = buf_end - buf_ptr;
2623 if (avctx->skip_frame == AVDISCARD_ALL) {
2624 skip_bits(&s->gb, get_bits_left(&s->gb));
2628 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2629 (avctx->err_recognition & AV_EF_EXPLODE))
2633 if ((ret = mjpeg_decode_dri(s)) < 0)
2646 av_log(avctx, AV_LOG_ERROR,
2647 "mjpeg: unsupported coding type (%x)\n", start_code);
2652 /* eof process start code */
2653 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2654 av_log(avctx, AV_LOG_DEBUG,
2655 "marker parser used %d bytes (%d bits)\n",
2656 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2658 if (s->got_picture && s->cur_scan) {
2659 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2662 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2663 return AVERROR_INVALIDDATA;
2669 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2671 if (AV_RB32(s->upscale_h)) {
2673 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2674 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2675 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2676 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2677 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2678 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2679 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2680 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2681 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2682 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2683 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2684 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2686 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2690 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2691 for (p = 0; p<s->nb_components; p++) {
2692 uint8_t *line = s->picture_ptr->data[p];
2695 if (!s->upscale_h[p])
2698 w = AV_CEIL_RSHIFT(w, hshift);
2699 h = AV_CEIL_RSHIFT(h, vshift);
2701 if (s->upscale_v[p] == 1)
2704 for (i = 0; i < h; i++) {
2705 if (s->upscale_h[p] == 1) {
2706 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2707 else line[w - 1] = line[(w - 1) / 2];
2708 for (index = w - 2; index > 0; index--) {
2710 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2712 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2714 } else if (s->upscale_h[p] == 2) {
2716 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2718 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2720 line[w - 1] = line[(w - 1) / 3];
2722 line[w - 2] = line[w - 1];
2724 for (index = w - 3; index > 0; index--) {
2725 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2728 line += s->linesize[p];
2732 if (AV_RB32(s->upscale_v)) {
2734 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2735 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2736 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2737 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2738 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2739 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2740 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2741 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2742 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2743 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2744 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2745 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2746 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2748 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2752 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2753 for (p = 0; p < s->nb_components; p++) {
2757 if (!s->upscale_v[p])
2760 w = AV_CEIL_RSHIFT(w, hshift);
2761 h = AV_CEIL_RSHIFT(h, vshift);
2763 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2764 for (i = h - 1; i; i--) {
2765 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2766 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2767 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2768 memcpy(dst, src1, w);
2770 for (index = 0; index < w; index++)
2771 dst[index] = (src1[index] + src2[index]) >> 1;
2773 dst -= s->linesize[p];
2777 if (s->flipped && !s->rgb) {
2779 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2783 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2784 for (index=0; index<s->nb_components; index++) {
2785 uint8_t *dst = s->picture_ptr->data[index];
2786 int w = s->picture_ptr->width;
2787 int h = s->picture_ptr->height;
2788 if(index && index<3){
2789 w = AV_CEIL_RSHIFT(w, hshift);
2790 h = AV_CEIL_RSHIFT(h, vshift);
2793 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2794 for (i=0; i<h/2; i++) {
2796 FFSWAP(int, dst[j], dst2[j]);
2797 dst += s->picture_ptr->linesize[index];
2798 dst2 -= s->picture_ptr->linesize[index];
2803 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2804 int w = s->picture_ptr->width;
2805 int h = s->picture_ptr->height;
2806 av_assert0(s->nb_components == 4);
2807 for (i=0; i<h; i++) {
2810 for (index=0; index<4; index++) {
2811 dst[index] = s->picture_ptr->data[index]
2812 + s->picture_ptr->linesize[index]*i;
2814 for (j=0; j<w; j++) {
2816 int r = dst[0][j] * k;
2817 int g = dst[1][j] * k;
2818 int b = dst[2][j] * k;
2819 dst[0][j] = g*257 >> 16;
2820 dst[1][j] = b*257 >> 16;
2821 dst[2][j] = r*257 >> 16;
2826 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2827 int w = s->picture_ptr->width;
2828 int h = s->picture_ptr->height;
2829 av_assert0(s->nb_components == 4);
2830 for (i=0; i<h; i++) {
2833 for (index=0; index<4; index++) {
2834 dst[index] = s->picture_ptr->data[index]
2835 + s->picture_ptr->linesize[index]*i;
2837 for (j=0; j<w; j++) {
2839 int r = (255 - dst[0][j]) * k;
2840 int g = (128 - dst[1][j]) * k;
2841 int b = (128 - dst[2][j]) * k;
2842 dst[0][j] = r*257 >> 16;
2843 dst[1][j] = (g*257 >> 16) + 128;
2844 dst[2][j] = (b*257 >> 16) + 128;
2851 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2853 stereo->type = s->stereo3d->type;
2854 stereo->flags = s->stereo3d->flags;
2856 av_freep(&s->stereo3d);
2859 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2860 AVFrameSideData *sd;
2865 /* Sum size of all parts. */
2866 for (i = 0; i < s->iccnum; i++)
2867 total_size += s->iccdatalens[i];
2869 sd = av_frame_new_side_data(frame, AV_FRAME_DATA_ICC_PROFILE, total_size);
2871 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2872 return AVERROR(ENOMEM);
2875 /* Reassemble the parts, which are now in-order. */
2876 for (i = 0; i < s->iccnum; i++) {
2877 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2878 offset += s->iccdatalens[i];
2882 av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2883 av_dict_free(&s->exif_metadata);
2885 if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2886 ret = smv_process_frame(avctx, frame);
2888 av_frame_unref(frame);
2896 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2902 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2903 * even without having called ff_mjpeg_decode_init(). */
2904 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2906 MJpegDecodeContext *s = avctx->priv_data;
2909 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2910 av_log(avctx, AV_LOG_INFO, "Single field\n");
2914 av_frame_free(&s->picture);
2915 s->picture_ptr = NULL;
2916 } else if (s->picture_ptr)
2917 av_frame_unref(s->picture_ptr);
2919 av_packet_free(&s->pkt);
2921 av_frame_free(&s->smv_frame);
2923 av_freep(&s->buffer);
2924 av_freep(&s->stereo3d);
2925 av_freep(&s->ljpeg_buffer);
2926 s->ljpeg_buffer_size = 0;
2928 for (i = 0; i < 3; i++) {
2929 for (j = 0; j < 4; j++)
2930 ff_free_vlc(&s->vlcs[i][j]);
2932 for (i = 0; i < MAX_COMPONENTS; i++) {
2933 av_freep(&s->blocks[i]);
2934 av_freep(&s->last_nnz[i]);
2936 av_dict_free(&s->exif_metadata);
2938 reset_icc_profile(s);
2940 av_freep(&s->hwaccel_picture_private);
2945 static void decode_flush(AVCodecContext *avctx)
2947 MJpegDecodeContext *s = avctx->priv_data;
2950 s->smv_next_frame = 0;
2951 av_frame_unref(s->smv_frame);
2954 #if CONFIG_MJPEG_DECODER
2955 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2956 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2957 static const AVOption options[] = {
2958 { "extern_huff", "Use external huffman table.",
2959 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2963 static const AVClass mjpegdec_class = {
2964 .class_name = "MJPEG decoder",
2965 .item_name = av_default_item_name,
2967 .version = LIBAVUTIL_VERSION_INT,
2970 AVCodec ff_mjpeg_decoder = {
2972 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2973 .type = AVMEDIA_TYPE_VIDEO,
2974 .id = AV_CODEC_ID_MJPEG,
2975 .priv_data_size = sizeof(MJpegDecodeContext),
2976 .init = ff_mjpeg_decode_init,
2977 .close = ff_mjpeg_decode_end,
2978 .receive_frame = ff_mjpeg_receive_frame,
2979 .flush = decode_flush,
2980 .capabilities = AV_CODEC_CAP_DR1,
2982 .priv_class = &mjpegdec_class,
2983 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2984 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
2985 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM | FF_CODEC_CAP_SETS_PKT_DTS,
2986 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2987 #if CONFIG_MJPEG_NVDEC_HWACCEL
2988 HWACCEL_NVDEC(mjpeg),
2990 #if CONFIG_MJPEG_VAAPI_HWACCEL
2991 HWACCEL_VAAPI(mjpeg),
2997 #if CONFIG_THP_DECODER
2998 AVCodec ff_thp_decoder = {
3000 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
3001 .type = AVMEDIA_TYPE_VIDEO,
3002 .id = AV_CODEC_ID_THP,
3003 .priv_data_size = sizeof(MJpegDecodeContext),
3004 .init = ff_mjpeg_decode_init,
3005 .close = ff_mjpeg_decode_end,
3006 .receive_frame = ff_mjpeg_receive_frame,
3007 .flush = decode_flush,
3008 .capabilities = AV_CODEC_CAP_DR1,
3010 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP |
3011 FF_CODEC_CAP_SETS_PKT_DTS,
3015 #if CONFIG_SMVJPEG_DECODER
3016 AVCodec ff_smvjpeg_decoder = {
3018 .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
3019 .type = AVMEDIA_TYPE_VIDEO,
3020 .id = AV_CODEC_ID_SMVJPEG,
3021 .priv_data_size = sizeof(MJpegDecodeContext),
3022 .init = ff_mjpeg_decode_init,
3023 .close = ff_mjpeg_decode_end,
3024 .receive_frame = ff_mjpeg_receive_frame,
3025 .flush = decode_flush,
3026 .capabilities = AV_CODEC_CAP_DR1,
3027 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING |
3028 FF_CODEC_CAP_SETS_PKT_DTS,