1 /*
2 * MJPEG decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
6 *
7 * Support for external huffman table, various fixes (AVID workaround),
8 * aspecting, new decode_frame mechanism and apple mjpeg-b support
9 * by Alex Beregszaszi
10 *
11 * This file is part of FFmpeg.
12 *
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.
17 *
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.
22 *
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
26 */
27
28 /**
29 * @file
30 * MJPEG decoder.
31 */
32
33 #include "libavutil/imgutils.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/opt.h"
36 #include "avcodec.h"
37 #include "blockdsp.h"
38 #include "copy_block.h"
39 #include "hwconfig.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "jpegtables.h"
43 #include "mjpeg.h"
44 #include "mjpegdec.h"
45 #include "jpeglsdec.h"
46 #include "profiles.h"
47 #include "put_bits.h"
48 #include "tiff.h"
49 #include "exif.h"
50 #include "bytestream.h"
51
52
build_vlc(VLC * vlc,const uint8_t * bits_table,const uint8_t * val_table,int nb_codes,int use_static,int is_ac)53 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
54 const uint8_t *val_table, int nb_codes,
55 int use_static, int is_ac)
56 {
57 uint8_t huff_size[256] = { 0 };
58 uint16_t huff_code[256];
59 uint16_t huff_sym[256];
60 int i;
61
62 av_assert0(nb_codes <= 256);
63
64 ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
65
66 for (i = 0; i < 256; i++)
67 huff_sym[i] = i + 16 * is_ac;
68
69 if (is_ac)
70 huff_sym[0] = 16 * 256;
71
72 return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
73 huff_code, 2, 2, huff_sym, 2, 2, use_static);
74 }
75
init_default_huffman_tables(MJpegDecodeContext * s)76 static int init_default_huffman_tables(MJpegDecodeContext *s)
77 {
78 static const struct {
79 int class;
80 int index;
81 const uint8_t *bits;
82 const uint8_t *values;
83 int codes;
84 int length;
85 } ht[] = {
86 { 0, 0, avpriv_mjpeg_bits_dc_luminance,
87 avpriv_mjpeg_val_dc, 12, 12 },
88 { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
89 avpriv_mjpeg_val_dc, 12, 12 },
90 { 1, 0, avpriv_mjpeg_bits_ac_luminance,
91 avpriv_mjpeg_val_ac_luminance, 251, 162 },
92 { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
93 avpriv_mjpeg_val_ac_chrominance, 251, 162 },
94 { 2, 0, avpriv_mjpeg_bits_ac_luminance,
95 avpriv_mjpeg_val_ac_luminance, 251, 162 },
96 { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
97 avpriv_mjpeg_val_ac_chrominance, 251, 162 },
98 };
99 int i, ret;
100
101 for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
102 ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
103 ht[i].bits, ht[i].values, ht[i].codes,
104 0, ht[i].class == 1);
105 if (ret < 0)
106 return ret;
107
108 if (ht[i].class < 2) {
109 memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
110 ht[i].bits + 1, 16);
111 memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
112 ht[i].values, ht[i].length);
113 }
114 }
115
116 return 0;
117 }
118
parse_avid(MJpegDecodeContext * s,uint8_t * buf,int len)119 static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
120 {
121 s->buggy_avid = 1;
122 if (len > 14 && buf[12] == 1) /* 1 - NTSC */
123 s->interlace_polarity = 1;
124 if (len > 14 && buf[12] == 2) /* 2 - PAL */
125 s->interlace_polarity = 0;
126 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
127 av_log(s->avctx, AV_LOG_INFO, "AVID: len:%d %d\n", len, len > 14 ? buf[12] : -1);
128 }
129
init_idct(AVCodecContext * avctx)130 static void init_idct(AVCodecContext *avctx)
131 {
132 MJpegDecodeContext *s = avctx->priv_data;
133
134 ff_idctdsp_init(&s->idsp, avctx);
135 ff_init_scantable(s->idsp.idct_permutation, &s->scantable,
136 ff_zigzag_direct);
137 }
138
ff_mjpeg_decode_init(AVCodecContext * avctx)139 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
140 {
141 MJpegDecodeContext *s = avctx->priv_data;
142 int ret;
143
144 if (!s->picture_ptr) {
145 s->picture = av_frame_alloc();
146 if (!s->picture)
147 return AVERROR(ENOMEM);
148 s->picture_ptr = s->picture;
149 }
150
151 s->avctx = avctx;
152 ff_blockdsp_init(&s->bdsp, avctx);
153 ff_hpeldsp_init(&s->hdsp, avctx->flags);
154 init_idct(avctx);
155 s->buffer_size = 0;
156 s->buffer = NULL;
157 s->start_code = -1;
158 s->first_picture = 1;
159 s->got_picture = 0;
160 s->org_height = avctx->coded_height;
161 avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
162 avctx->colorspace = AVCOL_SPC_BT470BG;
163 s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
164
165 if ((ret = init_default_huffman_tables(s)) < 0)
166 return ret;
167
168 if (s->extern_huff) {
169 av_log(avctx, AV_LOG_INFO, "using external huffman table\n");
170 if ((ret = init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8)) < 0)
171 return ret;
172 if (ff_mjpeg_decode_dht(s)) {
173 av_log(avctx, AV_LOG_ERROR,
174 "error using external huffman table, switching back to internal\n");
175 init_default_huffman_tables(s);
176 }
177 }
178 if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
179 s->interlace_polarity = 1; /* bottom field first */
180 av_log(avctx, AV_LOG_DEBUG, "bottom field first\n");
181 } else if (avctx->field_order == AV_FIELD_UNKNOWN) {
182 if (avctx->codec_tag == AV_RL32("MJPG"))
183 s->interlace_polarity = 1;
184 }
185
186 if ( avctx->extradata_size > 8
187 && AV_RL32(avctx->extradata) == 0x2C
188 && AV_RL32(avctx->extradata+4) == 0x18) {
189 parse_avid(s, avctx->extradata, avctx->extradata_size);
190 }
191
192 if (avctx->codec->id == AV_CODEC_ID_AMV)
193 s->flipped = 1;
194
195 return 0;
196 }
197
198
199 /* quantize tables */
ff_mjpeg_decode_dqt(MJpegDecodeContext * s)200 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
201 {
202 int len, index, i;
203
204 len = get_bits(&s->gb, 16) - 2;
205
206 if (8*len > get_bits_left(&s->gb)) {
207 av_log(s->avctx, AV_LOG_ERROR, "dqt: len %d is too large\n", len);
208 return AVERROR_INVALIDDATA;
209 }
210
211 while (len >= 65) {
212 int pr = get_bits(&s->gb, 4);
213 if (pr > 1) {
214 av_log(s->avctx, AV_LOG_ERROR, "dqt: invalid precision\n");
215 return AVERROR_INVALIDDATA;
216 }
217 index = get_bits(&s->gb, 4);
218 if (index >= 4)
219 return -1;
220 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
221 /* read quant table */
222 for (i = 0; i < 64; i++) {
223 s->quant_matrixes[index][i] = get_bits(&s->gb, pr ? 16 : 8);
224 if (s->quant_matrixes[index][i] == 0) {
225 av_log(s->avctx, AV_LOG_ERROR, "dqt: 0 quant value\n");
226 return AVERROR_INVALIDDATA;
227 }
228 }
229
230 // XXX FIXME fine-tune, and perhaps add dc too
231 s->qscale[index] = FFMAX(s->quant_matrixes[index][1],
232 s->quant_matrixes[index][8]) >> 1;
233 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
234 index, s->qscale[index]);
235 len -= 1 + 64 * (1+pr);
236 }
237 return 0;
238 }
239
240 /* decode huffman tables and build VLC decoders */
ff_mjpeg_decode_dht(MJpegDecodeContext * s)241 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
242 {
243 int len, index, i, class, n, v, code_max;
244 uint8_t bits_table[17];
245 uint8_t val_table[256];
246 int ret = 0;
247
248 len = get_bits(&s->gb, 16) - 2;
249
250 if (8*len > get_bits_left(&s->gb)) {
251 av_log(s->avctx, AV_LOG_ERROR, "dht: len %d is too large\n", len);
252 return AVERROR_INVALIDDATA;
253 }
254
255 while (len > 0) {
256 if (len < 17)
257 return AVERROR_INVALIDDATA;
258 class = get_bits(&s->gb, 4);
259 if (class >= 2)
260 return AVERROR_INVALIDDATA;
261 index = get_bits(&s->gb, 4);
262 if (index >= 4)
263 return AVERROR_INVALIDDATA;
264 n = 0;
265 for (i = 1; i <= 16; i++) {
266 bits_table[i] = get_bits(&s->gb, 8);
267 n += bits_table[i];
268 }
269 len -= 17;
270 if (len < n || n > 256)
271 return AVERROR_INVALIDDATA;
272
273 code_max = 0;
274 for (i = 0; i < n; i++) {
275 v = get_bits(&s->gb, 8);
276 if (v > code_max)
277 code_max = v;
278 val_table[i] = v;
279 }
280 len -= n;
281
282 /* build VLC and flush previous vlc if present */
283 ff_free_vlc(&s->vlcs[class][index]);
284 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
285 class, index, code_max + 1);
286 if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
287 code_max + 1, 0, class > 0)) < 0)
288 return ret;
289
290 if (class > 0) {
291 ff_free_vlc(&s->vlcs[2][index]);
292 if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
293 code_max + 1, 0, 0)) < 0)
294 return ret;
295 }
296
297 for (i = 0; i < 16; i++)
298 s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
299 for (i = 0; i < 256; i++)
300 s->raw_huffman_values[class][index][i] = val_table[i];
301 }
302 return 0;
303 }
304
ff_mjpeg_decode_sof(MJpegDecodeContext * s)305 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
306 {
307 int len, nb_components, i, width, height, bits, ret, size_change;
308 unsigned pix_fmt_id;
309 int h_count[MAX_COMPONENTS] = { 0 };
310 int v_count[MAX_COMPONENTS] = { 0 };
311
312 s->cur_scan = 0;
313 memset(s->upscale_h, 0, sizeof(s->upscale_h));
314 memset(s->upscale_v, 0, sizeof(s->upscale_v));
315
316 len = get_bits(&s->gb, 16);
317 bits = get_bits(&s->gb, 8);
318
319 if (bits > 16 || bits < 1) {
320 av_log(s->avctx, AV_LOG_ERROR, "bits %d is invalid\n", bits);
321 return AVERROR_INVALIDDATA;
322 }
323
324 if (s->avctx->bits_per_raw_sample != bits) {
325 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);
326 s->avctx->bits_per_raw_sample = bits;
327 init_idct(s->avctx);
328 }
329 if (s->pegasus_rct)
330 bits = 9;
331 if (bits == 9 && !s->pegasus_rct)
332 s->rct = 1; // FIXME ugly
333
334 if(s->lossless && s->avctx->lowres){
335 av_log(s->avctx, AV_LOG_ERROR, "lowres is not possible with lossless jpeg\n");
336 return -1;
337 }
338
339 height = get_bits(&s->gb, 16);
340 width = get_bits(&s->gb, 16);
341
342 // HACK for odd_height.mov
343 if (s->interlaced && s->width == width && s->height == height + 1)
344 height= s->height;
345
346 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
347 if (av_image_check_size(width, height, 0, s->avctx) < 0)
348 return AVERROR_INVALIDDATA;
349 if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
350 return AVERROR_INVALIDDATA;
351
352 nb_components = get_bits(&s->gb, 8);
353 if (nb_components <= 0 ||
354 nb_components > MAX_COMPONENTS)
355 return -1;
356 if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
357 if (nb_components != s->nb_components) {
358 av_log(s->avctx, AV_LOG_ERROR,
359 "nb_components changing in interlaced picture\n");
360 return AVERROR_INVALIDDATA;
361 }
362 }
363 if (s->ls && !(bits <= 8 || nb_components == 1)) {
364 avpriv_report_missing_feature(s->avctx,
365 "JPEG-LS that is not <= 8 "
366 "bits/component or 16-bit gray");
367 return AVERROR_PATCHWELCOME;
368 }
369 if (len != 8 + 3 * nb_components) {
370 av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
371 return AVERROR_INVALIDDATA;
372 }
373
374 s->nb_components = nb_components;
375 s->h_max = 1;
376 s->v_max = 1;
377 for (i = 0; i < nb_components; i++) {
378 /* component id */
379 s->component_id[i] = get_bits(&s->gb, 8) - 1;
380 h_count[i] = get_bits(&s->gb, 4);
381 v_count[i] = get_bits(&s->gb, 4);
382 /* compute hmax and vmax (only used in interleaved case) */
383 if (h_count[i] > s->h_max)
384 s->h_max = h_count[i];
385 if (v_count[i] > s->v_max)
386 s->v_max = v_count[i];
387 s->quant_index[i] = get_bits(&s->gb, 8);
388 if (s->quant_index[i] >= 4) {
389 av_log(s->avctx, AV_LOG_ERROR, "quant_index is invalid\n");
390 return AVERROR_INVALIDDATA;
391 }
392 if (!h_count[i] || !v_count[i]) {
393 av_log(s->avctx, AV_LOG_ERROR,
394 "Invalid sampling factor in component %d %d:%d\n",
395 i, h_count[i], v_count[i]);
396 return AVERROR_INVALIDDATA;
397 }
398
399 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
400 i, h_count[i], v_count[i],
401 s->component_id[i], s->quant_index[i]);
402 }
403 if ( nb_components == 4
404 && s->component_id[0] == 'C' - 1
405 && s->component_id[1] == 'M' - 1
406 && s->component_id[2] == 'Y' - 1
407 && s->component_id[3] == 'K' - 1)
408 s->adobe_transform = 0;
409
410 if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
411 avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
412 return AVERROR_PATCHWELCOME;
413 }
414
415 if (s->bayer) {
416 if (nb_components == 2) {
417 /* Bayer images embedded in DNGs can contain 2 interleaved components and the
418 width stored in their SOF3 markers is the width of each one. We only output
419 a single component, therefore we need to adjust the output image width. We
420 handle the deinterleaving (but not the debayering) in this file. */
421 width *= 2;
422 }
423 /* They can also contain 1 component, which is double the width and half the height
424 of the final image (rows are interleaved). We don't handle the decoding in this
425 file, but leave that to the TIFF/DNG decoder. */
426 }
427
428 /* if different size, realloc/alloc picture */
429 if (width != s->width || height != s->height || bits != s->bits ||
430 memcmp(s->h_count, h_count, sizeof(h_count)) ||
431 memcmp(s->v_count, v_count, sizeof(v_count))) {
432 size_change = 1;
433
434 s->width = width;
435 s->height = height;
436 s->bits = bits;
437 memcpy(s->h_count, h_count, sizeof(h_count));
438 memcpy(s->v_count, v_count, sizeof(v_count));
439 s->interlaced = 0;
440 s->got_picture = 0;
441
442 /* test interlaced mode */
443 if (s->first_picture &&
444 (s->multiscope != 2 || s->avctx->time_base.den >= 25 * s->avctx->time_base.num) &&
445 s->org_height != 0 &&
446 s->height < ((s->org_height * 3) / 4)) {
447 s->interlaced = 1;
448 s->bottom_field = s->interlace_polarity;
449 s->picture_ptr->interlaced_frame = 1;
450 s->picture_ptr->top_field_first = !s->interlace_polarity;
451 height *= 2;
452 }
453
454 ret = ff_set_dimensions(s->avctx, width, height);
455 if (ret < 0)
456 return ret;
457
458 s->first_picture = 0;
459 } else {
460 size_change = 0;
461 }
462
463 if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
464 if (s->progressive) {
465 avpriv_request_sample(s->avctx, "progressively coded interlaced picture");
466 return AVERROR_INVALIDDATA;
467 }
468 } else {
469 if (s->v_max == 1 && s->h_max == 1 && s->lossless==1 && (nb_components==3 || nb_components==4))
470 s->rgb = 1;
471 else if (!s->lossless)
472 s->rgb = 0;
473 /* XXX: not complete test ! */
474 pix_fmt_id = ((unsigned)s->h_count[0] << 28) | (s->v_count[0] << 24) |
475 (s->h_count[1] << 20) | (s->v_count[1] << 16) |
476 (s->h_count[2] << 12) | (s->v_count[2] << 8) |
477 (s->h_count[3] << 4) | s->v_count[3];
478 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
479 /* NOTE we do not allocate pictures large enough for the possible
480 * padding of h/v_count being 4 */
481 if (!(pix_fmt_id & 0xD0D0D0D0))
482 pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
483 if (!(pix_fmt_id & 0x0D0D0D0D))
484 pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
485
486 for (i = 0; i < 8; i++) {
487 int j = 6 + (i&1) - (i&6);
488 int is = (pix_fmt_id >> (4*i)) & 0xF;
489 int js = (pix_fmt_id >> (4*j)) & 0xF;
490
491 if (is == 1 && js != 2 && (i < 2 || i > 5))
492 js = (pix_fmt_id >> ( 8 + 4*(i&1))) & 0xF;
493 if (is == 1 && js != 2 && (i < 2 || i > 5))
494 js = (pix_fmt_id >> (16 + 4*(i&1))) & 0xF;
495
496 if (is == 1 && js == 2) {
497 if (i & 1) s->upscale_h[j/2] = 1;
498 else s->upscale_v[j/2] = 1;
499 }
500 }
501
502 if (s->bayer) {
503 if (pix_fmt_id != 0x11110000 && pix_fmt_id != 0x11000000)
504 goto unk_pixfmt;
505 }
506
507 switch (pix_fmt_id) {
508 case 0x11110000: /* for bayer-encoded huffman lossless JPEGs embedded in DNGs */
509 if (!s->bayer)
510 goto unk_pixfmt;
511 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16LE;
512 break;
513 case 0x11111100:
514 if (s->rgb)
515 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
516 else {
517 if ( s->adobe_transform == 0
518 || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
519 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
520 } else {
521 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
522 else s->avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
523 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
524 }
525 }
526 av_assert0(s->nb_components == 3);
527 break;
528 case 0x11111111:
529 if (s->rgb)
530 s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_ABGR : AV_PIX_FMT_RGBA64;
531 else {
532 if (s->adobe_transform == 0 && s->bits <= 8) {
533 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
534 } else {
535 s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_YUVA444P : AV_PIX_FMT_YUVA444P16;
536 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
537 }
538 }
539 av_assert0(s->nb_components == 4);
540 break;
541 case 0x22111122:
542 case 0x22111111:
543 if (s->adobe_transform == 0 && s->bits <= 8) {
544 s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
545 s->upscale_v[1] = s->upscale_v[2] = 1;
546 s->upscale_h[1] = s->upscale_h[2] = 1;
547 } else if (s->adobe_transform == 2 && s->bits <= 8) {
548 s->avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
549 s->upscale_v[1] = s->upscale_v[2] = 1;
550 s->upscale_h[1] = s->upscale_h[2] = 1;
551 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
552 } else {
553 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
554 else s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
555 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
556 }
557 av_assert0(s->nb_components == 4);
558 break;
559 case 0x12121100:
560 case 0x22122100:
561 case 0x21211100:
562 case 0x22211200:
563 case 0x22221100:
564 case 0x22112200:
565 case 0x11222200:
566 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
567 else
568 goto unk_pixfmt;
569 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
570 break;
571 case 0x11000000:
572 case 0x13000000:
573 case 0x14000000:
574 case 0x31000000:
575 case 0x33000000:
576 case 0x34000000:
577 case 0x41000000:
578 case 0x43000000:
579 case 0x44000000:
580 if(s->bits <= 8)
581 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
582 else
583 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
584 break;
585 case 0x12111100:
586 case 0x14121200:
587 case 0x14111100:
588 case 0x22211100:
589 case 0x22112100:
590 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
591 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
592 else
593 goto unk_pixfmt;
594 s->upscale_v[0] = s->upscale_v[1] = 1;
595 } else {
596 if (pix_fmt_id == 0x14111100)
597 s->upscale_v[1] = s->upscale_v[2] = 1;
598 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
599 else
600 goto unk_pixfmt;
601 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
602 }
603 break;
604 case 0x21111100:
605 if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
606 if (s->bits <= 8) s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
607 else
608 goto unk_pixfmt;
609 s->upscale_h[0] = s->upscale_h[1] = 1;
610 } else {
611 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
612 else s->avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
613 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
614 }
615 break;
616 case 0x31111100:
617 if (s->bits > 8)
618 goto unk_pixfmt;
619 s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
620 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
621 s->upscale_h[1] = s->upscale_h[2] = 2;
622 break;
623 case 0x22121100:
624 case 0x22111200:
625 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
626 else
627 goto unk_pixfmt;
628 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
629 break;
630 case 0x22111100:
631 case 0x23111100:
632 case 0x42111100:
633 case 0x24111100:
634 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
635 else s->avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
636 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
637 if (pix_fmt_id == 0x42111100) {
638 if (s->bits > 8)
639 goto unk_pixfmt;
640 s->upscale_h[1] = s->upscale_h[2] = 1;
641 } else if (pix_fmt_id == 0x24111100) {
642 if (s->bits > 8)
643 goto unk_pixfmt;
644 s->upscale_v[1] = s->upscale_v[2] = 1;
645 } else if (pix_fmt_id == 0x23111100) {
646 if (s->bits > 8)
647 goto unk_pixfmt;
648 s->upscale_v[1] = s->upscale_v[2] = 2;
649 }
650 break;
651 case 0x41111100:
652 if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV411P : AV_PIX_FMT_YUVJ411P;
653 else
654 goto unk_pixfmt;
655 s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
656 break;
657 default:
658 unk_pixfmt:
659 avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
660 memset(s->upscale_h, 0, sizeof(s->upscale_h));
661 memset(s->upscale_v, 0, sizeof(s->upscale_v));
662 return AVERROR_PATCHWELCOME;
663 }
664 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
665 avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
666 return AVERROR_PATCHWELCOME;
667 }
668 if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
669 avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
670 return AVERROR_PATCHWELCOME;
671 }
672 if (s->ls) {
673 memset(s->upscale_h, 0, sizeof(s->upscale_h));
674 memset(s->upscale_v, 0, sizeof(s->upscale_v));
675 if (s->nb_components == 3) {
676 s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
677 } else if (s->nb_components != 1) {
678 av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
679 return AVERROR_PATCHWELCOME;
680 } else if (s->palette_index && s->bits <= 8)
681 s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
682 else if (s->bits <= 8)
683 s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
684 else
685 s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
686 }
687
688 s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
689 if (!s->pix_desc) {
690 av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
691 return AVERROR_BUG;
692 }
693
694 if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
695 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
696 } else {
697 enum AVPixelFormat pix_fmts[] = {
698 #if CONFIG_MJPEG_NVDEC_HWACCEL
699 AV_PIX_FMT_CUDA,
700 #endif
701 #if CONFIG_MJPEG_VAAPI_HWACCEL
702 AV_PIX_FMT_VAAPI,
703 #endif
704 s->avctx->pix_fmt,
705 AV_PIX_FMT_NONE,
706 };
707 s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
708 if (s->hwaccel_pix_fmt < 0)
709 return AVERROR(EINVAL);
710
711 s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
712 s->avctx->pix_fmt = s->hwaccel_pix_fmt;
713 }
714
715 if (s->avctx->skip_frame == AVDISCARD_ALL) {
716 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
717 s->picture_ptr->key_frame = 1;
718 s->got_picture = 1;
719 return 0;
720 }
721
722 av_frame_unref(s->picture_ptr);
723 if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0)
724 return -1;
725 s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
726 s->picture_ptr->key_frame = 1;
727 s->got_picture = 1;
728
729 for (i = 0; i < 4; i++)
730 s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
731
732 ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
733 s->width, s->height, s->linesize[0], s->linesize[1],
734 s->interlaced, s->avctx->height);
735
736 }
737
738 if ((s->rgb && !s->lossless && !s->ls) ||
739 (!s->rgb && s->ls && s->nb_components > 1) ||
740 (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 && !s->ls)
741 ) {
742 av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
743 return AVERROR_PATCHWELCOME;
744 }
745
746 /* totally blank picture as progressive JPEG will only add details to it */
747 if (s->progressive) {
748 int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
749 int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
750 for (i = 0; i < s->nb_components; i++) {
751 int size = bw * bh * s->h_count[i] * s->v_count[i];
752 av_freep(&s->blocks[i]);
753 av_freep(&s->last_nnz[i]);
754 s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
755 s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
756 if (!s->blocks[i] || !s->last_nnz[i])
757 return AVERROR(ENOMEM);
758 s->block_stride[i] = bw * s->h_count[i];
759 }
760 memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
761 }
762
763 if (s->avctx->hwaccel) {
764 s->hwaccel_picture_private =
765 av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
766 if (!s->hwaccel_picture_private)
767 return AVERROR(ENOMEM);
768
769 ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
770 s->raw_image_buffer_size);
771 if (ret < 0)
772 return ret;
773 }
774
775 return 0;
776 }
777
mjpeg_decode_dc(MJpegDecodeContext * s,int dc_index)778 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
779 {
780 int code;
781 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
782 if (code < 0 || code > 16) {
783 av_log(s->avctx, AV_LOG_WARNING,
784 "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
785 0, dc_index, &s->vlcs[0][dc_index]);
786 return 0xfffff;
787 }
788
789 if (code)
790 return get_xbits(&s->gb, code);
791 else
792 return 0;
793 }
794
795 /* decode block and dequantize */
decode_block(MJpegDecodeContext * s,int16_t * block,int component,int dc_index,int ac_index,uint16_t * quant_matrix)796 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
797 int dc_index, int ac_index, uint16_t *quant_matrix)
798 {
799 int code, i, j, level, val;
800
801 /* DC coef */
802 val = mjpeg_decode_dc(s, dc_index);
803 if (val == 0xfffff) {
804 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
805 return AVERROR_INVALIDDATA;
806 }
807 val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
808 val = av_clip_int16(val);
809 s->last_dc[component] = val;
810 block[0] = val;
811 /* AC coefs */
812 i = 0;
813 {OPEN_READER(re, &s->gb);
814 do {
815 UPDATE_CACHE(re, &s->gb);
816 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
817
818 i += ((unsigned)code) >> 4;
819 code &= 0xf;
820 if (code) {
821 if (code > MIN_CACHE_BITS - 16)
822 UPDATE_CACHE(re, &s->gb);
823
824 {
825 int cache = GET_CACHE(re, &s->gb);
826 int sign = (~cache) >> 31;
827 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
828 }
829
830 LAST_SKIP_BITS(re, &s->gb, code);
831
832 if (i > 63) {
833 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
834 return AVERROR_INVALIDDATA;
835 }
836 j = s->scantable.permutated[i];
837 block[j] = level * quant_matrix[i];
838 }
839 } while (i < 63);
840 CLOSE_READER(re, &s->gb);}
841
842 return 0;
843 }
844
decode_dc_progressive(MJpegDecodeContext * s,int16_t * block,int component,int dc_index,uint16_t * quant_matrix,int Al)845 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
846 int component, int dc_index,
847 uint16_t *quant_matrix, int Al)
848 {
849 unsigned val;
850 s->bdsp.clear_block(block);
851 val = mjpeg_decode_dc(s, dc_index);
852 if (val == 0xfffff) {
853 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
854 return AVERROR_INVALIDDATA;
855 }
856 val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
857 s->last_dc[component] = val;
858 block[0] = val;
859 return 0;
860 }
861
862 /* decode block and dequantize - progressive JPEG version */
decode_block_progressive(MJpegDecodeContext * s,int16_t * block,uint8_t * last_nnz,int ac_index,uint16_t * quant_matrix,int ss,int se,int Al,int * EOBRUN)863 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
864 uint8_t *last_nnz, int ac_index,
865 uint16_t *quant_matrix,
866 int ss, int se, int Al, int *EOBRUN)
867 {
868 int code, i, j, val, run;
869 unsigned level;
870
871 if (*EOBRUN) {
872 (*EOBRUN)--;
873 return 0;
874 }
875
876 {
877 OPEN_READER(re, &s->gb);
878 for (i = ss; ; i++) {
879 UPDATE_CACHE(re, &s->gb);
880 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
881
882 run = ((unsigned) code) >> 4;
883 code &= 0xF;
884 if (code) {
885 i += run;
886 if (code > MIN_CACHE_BITS - 16)
887 UPDATE_CACHE(re, &s->gb);
888
889 {
890 int cache = GET_CACHE(re, &s->gb);
891 int sign = (~cache) >> 31;
892 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
893 }
894
895 LAST_SKIP_BITS(re, &s->gb, code);
896
897 if (i >= se) {
898 if (i == se) {
899 j = s->scantable.permutated[se];
900 block[j] = level * (quant_matrix[se] << Al);
901 break;
902 }
903 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
904 return AVERROR_INVALIDDATA;
905 }
906 j = s->scantable.permutated[i];
907 block[j] = level * (quant_matrix[i] << Al);
908 } else {
909 if (run == 0xF) {// ZRL - skip 15 coefficients
910 i += 15;
911 if (i >= se) {
912 av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
913 return AVERROR_INVALIDDATA;
914 }
915 } else {
916 val = (1 << run);
917 if (run) {
918 UPDATE_CACHE(re, &s->gb);
919 val += NEG_USR32(GET_CACHE(re, &s->gb), run);
920 LAST_SKIP_BITS(re, &s->gb, run);
921 }
922 *EOBRUN = val - 1;
923 break;
924 }
925 }
926 }
927 CLOSE_READER(re, &s->gb);
928 }
929
930 if (i > *last_nnz)
931 *last_nnz = i;
932
933 return 0;
934 }
935
936 #define REFINE_BIT(j) { \
937 UPDATE_CACHE(re, &s->gb); \
938 sign = block[j] >> 15; \
939 block[j] += SHOW_UBITS(re, &s->gb, 1) * \
940 ((quant_matrix[i] ^ sign) - sign) << Al; \
941 LAST_SKIP_BITS(re, &s->gb, 1); \
942 }
943
944 #define ZERO_RUN \
945 for (; ; i++) { \
946 if (i > last) { \
947 i += run; \
948 if (i > se) { \
949 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
950 return -1; \
951 } \
952 break; \
953 } \
954 j = s->scantable.permutated[i]; \
955 if (block[j]) \
956 REFINE_BIT(j) \
957 else if (run-- == 0) \
958 break; \
959 }
960
961 /* decode block and dequantize - progressive JPEG refinement pass */
decode_block_refinement(MJpegDecodeContext * s,int16_t * block,uint8_t * last_nnz,int ac_index,uint16_t * quant_matrix,int ss,int se,int Al,int * EOBRUN)962 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
963 uint8_t *last_nnz,
964 int ac_index, uint16_t *quant_matrix,
965 int ss, int se, int Al, int *EOBRUN)
966 {
967 int code, i = ss, j, sign, val, run;
968 int last = FFMIN(se, *last_nnz);
969
970 OPEN_READER(re, &s->gb);
971 if (*EOBRUN) {
972 (*EOBRUN)--;
973 } else {
974 for (; ; i++) {
975 UPDATE_CACHE(re, &s->gb);
976 GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
977
978 if (code & 0xF) {
979 run = ((unsigned) code) >> 4;
980 UPDATE_CACHE(re, &s->gb);
981 val = SHOW_UBITS(re, &s->gb, 1);
982 LAST_SKIP_BITS(re, &s->gb, 1);
983 ZERO_RUN;
984 j = s->scantable.permutated[i];
985 val--;
986 block[j] = ((quant_matrix[i] << Al) ^ val) - val;
987 if (i == se) {
988 if (i > *last_nnz)
989 *last_nnz = i;
990 CLOSE_READER(re, &s->gb);
991 return 0;
992 }
993 } else {
994 run = ((unsigned) code) >> 4;
995 if (run == 0xF) {
996 ZERO_RUN;
997 } else {
998 val = run;
999 run = (1 << run);
1000 if (val) {
1001 UPDATE_CACHE(re, &s->gb);
1002 run += SHOW_UBITS(re, &s->gb, val);
1003 LAST_SKIP_BITS(re, &s->gb, val);
1004 }
1005 *EOBRUN = run - 1;
1006 break;
1007 }
1008 }
1009 }
1010
1011 if (i > *last_nnz)
1012 *last_nnz = i;
1013 }
1014
1015 for (; i <= last; i++) {
1016 j = s->scantable.permutated[i];
1017 if (block[j])
1018 REFINE_BIT(j)
1019 }
1020 CLOSE_READER(re, &s->gb);
1021
1022 return 0;
1023 }
1024 #undef REFINE_BIT
1025 #undef ZERO_RUN
1026
handle_rstn(MJpegDecodeContext * s,int nb_components)1027 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
1028 {
1029 int i;
1030 int reset = 0;
1031
1032 if (s->restart_interval) {
1033 s->restart_count--;
1034 if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
1035 align_get_bits(&s->gb);
1036 for (i = 0; i < nb_components; i++) /* reset dc */
1037 s->last_dc[i] = (4 << s->bits);
1038 }
1039
1040 i = 8 + ((-get_bits_count(&s->gb)) & 7);
1041 /* skip RSTn */
1042 if (s->restart_count == 0) {
1043 if( show_bits(&s->gb, i) == (1 << i) - 1
1044 || show_bits(&s->gb, i) == 0xFF) {
1045 int pos = get_bits_count(&s->gb);
1046 align_get_bits(&s->gb);
1047 while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1048 skip_bits(&s->gb, 8);
1049 if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1050 for (i = 0; i < nb_components; i++) /* reset dc */
1051 s->last_dc[i] = (4 << s->bits);
1052 reset = 1;
1053 } else
1054 skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1055 }
1056 }
1057 }
1058 return reset;
1059 }
1060
1061 /* Handles 1 to 4 components */
ljpeg_decode_rgb_scan(MJpegDecodeContext * s,int nb_components,int predictor,int point_transform)1062 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1063 {
1064 int i, mb_x, mb_y;
1065 unsigned width;
1066 uint16_t (*buffer)[4];
1067 int left[4], top[4], topleft[4];
1068 const int linesize = s->linesize[0];
1069 const int mask = ((1 << s->bits) - 1) << point_transform;
1070 int resync_mb_y = 0;
1071 int resync_mb_x = 0;
1072 int vpred[6];
1073
1074 if (!s->bayer && s->nb_components < 3)
1075 return AVERROR_INVALIDDATA;
1076 if (s->bayer && s->nb_components > 2)
1077 return AVERROR_INVALIDDATA;
1078 if (s->nb_components <= 0 || s->nb_components > 4)
1079 return AVERROR_INVALIDDATA;
1080 if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1081 return AVERROR_INVALIDDATA;
1082
1083
1084 s->restart_count = s->restart_interval;
1085
1086 if (s->restart_interval == 0)
1087 s->restart_interval = INT_MAX;
1088
1089 if (s->bayer)
1090 width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1091 else
1092 width = s->mb_width;
1093
1094 av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1095 if (!s->ljpeg_buffer)
1096 return AVERROR(ENOMEM);
1097
1098 buffer = s->ljpeg_buffer;
1099
1100 for (i = 0; i < 4; i++)
1101 buffer[0][i] = 1 << (s->bits - 1);
1102
1103 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1104 uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1105
1106 if (s->interlaced && s->bottom_field)
1107 ptr += linesize >> 1;
1108
1109 for (i = 0; i < 4; i++)
1110 top[i] = left[i] = topleft[i] = buffer[0][i];
1111
1112 if ((mb_y * s->width) % s->restart_interval == 0) {
1113 for (i = 0; i < 6; i++)
1114 vpred[i] = 1 << (s->bits-1);
1115 }
1116
1117 for (mb_x = 0; mb_x < width; mb_x++) {
1118 int modified_predictor = predictor;
1119
1120 if (get_bits_left(&s->gb) < 1) {
1121 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1122 return AVERROR_INVALIDDATA;
1123 }
1124
1125 if (s->restart_interval && !s->restart_count){
1126 s->restart_count = s->restart_interval;
1127 resync_mb_x = mb_x;
1128 resync_mb_y = mb_y;
1129 for(i=0; i<4; i++)
1130 top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1131 }
1132 if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1133 modified_predictor = 1;
1134
1135 for (i=0;i<nb_components;i++) {
1136 int pred, dc;
1137
1138 topleft[i] = top[i];
1139 top[i] = buffer[mb_x][i];
1140
1141 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1142 if(dc == 0xFFFFF)
1143 return -1;
1144
1145 if (!s->bayer || mb_x) {
1146 pred = left[i];
1147 } else { /* This path runs only for the first line in bayer images */
1148 vpred[i] += dc;
1149 pred = vpred[i] - dc;
1150 }
1151
1152 PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1153
1154 left[i] = buffer[mb_x][i] =
1155 mask & (pred + (unsigned)(dc * (1 << point_transform)));
1156 }
1157
1158 if (s->restart_interval && !--s->restart_count) {
1159 align_get_bits(&s->gb);
1160 skip_bits(&s->gb, 16); /* skip RSTn */
1161 }
1162 }
1163 if (s->rct && s->nb_components == 4) {
1164 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1165 ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1166 ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1167 ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1168 ptr[4*mb_x + 0] = buffer[mb_x][3];
1169 }
1170 } else if (s->nb_components == 4) {
1171 for(i=0; i<nb_components; i++) {
1172 int c= s->comp_index[i];
1173 if (s->bits <= 8) {
1174 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1175 ptr[4*mb_x+3-c] = buffer[mb_x][i];
1176 }
1177 } else if(s->bits == 9) {
1178 return AVERROR_PATCHWELCOME;
1179 } else {
1180 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1181 ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1182 }
1183 }
1184 }
1185 } else if (s->rct) {
1186 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1188 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1189 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1190 }
1191 } else if (s->pegasus_rct) {
1192 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1193 ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1194 ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1195 ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1196 }
1197 } else if (s->bayer) {
1198 if (nb_components == 1) {
1199 /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1200 for (mb_x = 0; mb_x < width; mb_x++)
1201 ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1202 } else if (nb_components == 2) {
1203 for (mb_x = 0; mb_x < width; mb_x++) {
1204 ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1205 ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1206 }
1207 }
1208 } else {
1209 for(i=0; i<nb_components; i++) {
1210 int c= s->comp_index[i];
1211 if (s->bits <= 8) {
1212 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1213 ptr[3*mb_x+2-c] = buffer[mb_x][i];
1214 }
1215 } else if(s->bits == 9) {
1216 return AVERROR_PATCHWELCOME;
1217 } else {
1218 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1219 ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1220 }
1221 }
1222 }
1223 }
1224 }
1225 return 0;
1226 }
1227
ljpeg_decode_yuv_scan(MJpegDecodeContext * s,int predictor,int point_transform,int nb_components)1228 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1229 int point_transform, int nb_components)
1230 {
1231 int i, mb_x, mb_y, mask;
1232 int bits= (s->bits+7)&~7;
1233 int resync_mb_y = 0;
1234 int resync_mb_x = 0;
1235
1236 point_transform += bits - s->bits;
1237 mask = ((1 << s->bits) - 1) << point_transform;
1238
1239 av_assert0(nb_components>=1 && nb_components<=4);
1240
1241 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1242 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1243 if (get_bits_left(&s->gb) < 1) {
1244 av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1245 return AVERROR_INVALIDDATA;
1246 }
1247 if (s->restart_interval && !s->restart_count){
1248 s->restart_count = s->restart_interval;
1249 resync_mb_x = mb_x;
1250 resync_mb_y = mb_y;
1251 }
1252
1253 if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1254 int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1255 int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1256 for (i = 0; i < nb_components; i++) {
1257 uint8_t *ptr;
1258 uint16_t *ptr16;
1259 int n, h, v, x, y, c, j, linesize;
1260 n = s->nb_blocks[i];
1261 c = s->comp_index[i];
1262 h = s->h_scount[i];
1263 v = s->v_scount[i];
1264 x = 0;
1265 y = 0;
1266 linesize= s->linesize[c];
1267
1268 if(bits>8) linesize /= 2;
1269
1270 for(j=0; j<n; j++) {
1271 int pred, dc;
1272
1273 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1274 if(dc == 0xFFFFF)
1275 return -1;
1276 if ( h * mb_x + x >= s->width
1277 || v * mb_y + y >= s->height) {
1278 // Nothing to do
1279 } else if (bits<=8) {
1280 ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1281 if(y==0 && toprow){
1282 if(x==0 && leftcol){
1283 pred= 1 << (bits - 1);
1284 }else{
1285 pred= ptr[-1];
1286 }
1287 }else{
1288 if(x==0 && leftcol){
1289 pred= ptr[-linesize];
1290 }else{
1291 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1292 }
1293 }
1294
1295 if (s->interlaced && s->bottom_field)
1296 ptr += linesize >> 1;
1297 pred &= mask;
1298 *ptr= pred + ((unsigned)dc << point_transform);
1299 }else{
1300 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1301 if(y==0 && toprow){
1302 if(x==0 && leftcol){
1303 pred= 1 << (bits - 1);
1304 }else{
1305 pred= ptr16[-1];
1306 }
1307 }else{
1308 if(x==0 && leftcol){
1309 pred= ptr16[-linesize];
1310 }else{
1311 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1312 }
1313 }
1314
1315 if (s->interlaced && s->bottom_field)
1316 ptr16 += linesize >> 1;
1317 pred &= mask;
1318 *ptr16= pred + ((unsigned)dc << point_transform);
1319 }
1320 if (++x == h) {
1321 x = 0;
1322 y++;
1323 }
1324 }
1325 }
1326 } else {
1327 for (i = 0; i < nb_components; i++) {
1328 uint8_t *ptr;
1329 uint16_t *ptr16;
1330 int n, h, v, x, y, c, j, linesize, dc;
1331 n = s->nb_blocks[i];
1332 c = s->comp_index[i];
1333 h = s->h_scount[i];
1334 v = s->v_scount[i];
1335 x = 0;
1336 y = 0;
1337 linesize = s->linesize[c];
1338
1339 if(bits>8) linesize /= 2;
1340
1341 for (j = 0; j < n; j++) {
1342 int pred;
1343
1344 dc = mjpeg_decode_dc(s, s->dc_index[i]);
1345 if(dc == 0xFFFFF)
1346 return -1;
1347 if ( h * mb_x + x >= s->width
1348 || v * mb_y + y >= s->height) {
1349 // Nothing to do
1350 } else if (bits<=8) {
1351 ptr = s->picture_ptr->data[c] +
1352 (linesize * (v * mb_y + y)) +
1353 (h * mb_x + x); //FIXME optimize this crap
1354 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1355
1356 pred &= mask;
1357 *ptr = pred + ((unsigned)dc << point_transform);
1358 }else{
1359 ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1360 PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1361
1362 pred &= mask;
1363 *ptr16= pred + ((unsigned)dc << point_transform);
1364 }
1365
1366 if (++x == h) {
1367 x = 0;
1368 y++;
1369 }
1370 }
1371 }
1372 }
1373 if (s->restart_interval && !--s->restart_count) {
1374 align_get_bits(&s->gb);
1375 skip_bits(&s->gb, 16); /* skip RSTn */
1376 }
1377 }
1378 }
1379 return 0;
1380 }
1381
mjpeg_copy_block(MJpegDecodeContext * s,uint8_t * dst,const uint8_t * src,int linesize,int lowres)1382 static av_always_inline void mjpeg_copy_block(MJpegDecodeContext *s,
1383 uint8_t *dst, const uint8_t *src,
1384 int linesize, int lowres)
1385 {
1386 switch (lowres) {
1387 case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1388 break;
1389 case 1: copy_block4(dst, src, linesize, linesize, 4);
1390 break;
1391 case 2: copy_block2(dst, src, linesize, linesize, 2);
1392 break;
1393 case 3: *dst = *src;
1394 break;
1395 }
1396 }
1397
shift_output(MJpegDecodeContext * s,uint8_t * ptr,int linesize)1398 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1399 {
1400 int block_x, block_y;
1401 int size = 8 >> s->avctx->lowres;
1402 if (s->bits > 8) {
1403 for (block_y=0; block_y<size; block_y++)
1404 for (block_x=0; block_x<size; block_x++)
1405 *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1406 } else {
1407 for (block_y=0; block_y<size; block_y++)
1408 for (block_x=0; block_x<size; block_x++)
1409 *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1410 }
1411 }
1412
mjpeg_decode_scan(MJpegDecodeContext * s,int nb_components,int Ah,int Al,const uint8_t * mb_bitmask,int mb_bitmask_size,const AVFrame * reference)1413 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1414 int Al, const uint8_t *mb_bitmask,
1415 int mb_bitmask_size,
1416 const AVFrame *reference)
1417 {
1418 int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1419 uint8_t *data[MAX_COMPONENTS];
1420 const uint8_t *reference_data[MAX_COMPONENTS];
1421 int linesize[MAX_COMPONENTS];
1422 GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1423 int bytes_per_pixel = 1 + (s->bits > 8);
1424
1425 if (mb_bitmask) {
1426 if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1427 av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1428 return AVERROR_INVALIDDATA;
1429 }
1430 init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1431 }
1432
1433 s->restart_count = 0;
1434
1435 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1436 &chroma_v_shift);
1437 chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1438 chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1439
1440 for (i = 0; i < nb_components; i++) {
1441 int c = s->comp_index[i];
1442 data[c] = s->picture_ptr->data[c];
1443 reference_data[c] = reference ? reference->data[c] : NULL;
1444 linesize[c] = s->linesize[c];
1445 s->coefs_finished[c] |= 1;
1446 }
1447
1448 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1449 for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1450 const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1451
1452 if (s->restart_interval && !s->restart_count)
1453 s->restart_count = s->restart_interval;
1454
1455 if (get_bits_left(&s->gb) < 0) {
1456 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1457 -get_bits_left(&s->gb));
1458 return AVERROR_INVALIDDATA;
1459 }
1460 for (i = 0; i < nb_components; i++) {
1461 uint8_t *ptr;
1462 int n, h, v, x, y, c, j;
1463 int block_offset;
1464 n = s->nb_blocks[i];
1465 c = s->comp_index[i];
1466 h = s->h_scount[i];
1467 v = s->v_scount[i];
1468 x = 0;
1469 y = 0;
1470 for (j = 0; j < n; j++) {
1471 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1472 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1473
1474 if (s->interlaced && s->bottom_field)
1475 block_offset += linesize[c] >> 1;
1476 if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1477 && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1478 ptr = data[c] + block_offset;
1479 } else
1480 ptr = NULL;
1481 if (!s->progressive) {
1482 if (copy_mb) {
1483 if (ptr)
1484 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1485 linesize[c], s->avctx->lowres);
1486
1487 } else {
1488 s->bdsp.clear_block(s->block);
1489 if (decode_block(s, s->block, i,
1490 s->dc_index[i], s->ac_index[i],
1491 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1492 av_log(s->avctx, AV_LOG_ERROR,
1493 "error y=%d x=%d\n", mb_y, mb_x);
1494 return AVERROR_INVALIDDATA;
1495 }
1496 if (ptr) {
1497 s->idsp.idct_put(ptr, linesize[c], s->block);
1498 if (s->bits & 7)
1499 shift_output(s, ptr, linesize[c]);
1500 }
1501 }
1502 } else {
1503 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1504 (h * mb_x + x);
1505 int16_t *block = s->blocks[c][block_idx];
1506 if (Ah)
1507 block[0] += get_bits1(&s->gb) *
1508 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1509 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1510 s->quant_matrixes[s->quant_sindex[i]],
1511 Al) < 0) {
1512 av_log(s->avctx, AV_LOG_ERROR,
1513 "error y=%d x=%d\n", mb_y, mb_x);
1514 return AVERROR_INVALIDDATA;
1515 }
1516 }
1517 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1518 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1519 mb_x, mb_y, x, y, c, s->bottom_field,
1520 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1521 if (++x == h) {
1522 x = 0;
1523 y++;
1524 }
1525 }
1526 }
1527
1528 handle_rstn(s, nb_components);
1529 }
1530 }
1531 return 0;
1532 }
1533
mjpeg_decode_scan_progressive_ac(MJpegDecodeContext * s,int ss,int se,int Ah,int Al)1534 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
1535 int se, int Ah, int Al)
1536 {
1537 int mb_x, mb_y;
1538 int EOBRUN = 0;
1539 int c = s->comp_index[0];
1540 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1541
1542 av_assert0(ss>=0 && Ah>=0 && Al>=0);
1543 if (se < ss || se > 63) {
1544 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1545 return AVERROR_INVALIDDATA;
1546 }
1547
1548 // s->coefs_finished is a bitmask for coefficients coded
1549 // ss and se are parameters telling start and end coefficients
1550 s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1551
1552 s->restart_count = 0;
1553
1554 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1555 int block_idx = mb_y * s->block_stride[c];
1556 int16_t (*block)[64] = &s->blocks[c][block_idx];
1557 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1558 if (get_bits_left(&s->gb) <= 0) {
1559 av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1560 return AVERROR_INVALIDDATA;
1561 }
1562 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1563 int ret;
1564 if (s->restart_interval && !s->restart_count)
1565 s->restart_count = s->restart_interval;
1566
1567 if (Ah)
1568 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1569 quant_matrix, ss, se, Al, &EOBRUN);
1570 else
1571 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1572 quant_matrix, ss, se, Al, &EOBRUN);
1573 if (ret < 0) {
1574 av_log(s->avctx, AV_LOG_ERROR,
1575 "error y=%d x=%d\n", mb_y, mb_x);
1576 return AVERROR_INVALIDDATA;
1577 }
1578
1579 if (handle_rstn(s, 0))
1580 EOBRUN = 0;
1581 }
1582 }
1583 return 0;
1584 }
1585
mjpeg_idct_scan_progressive_ac(MJpegDecodeContext * s)1586 static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1587 {
1588 int mb_x, mb_y;
1589 int c;
1590 const int bytes_per_pixel = 1 + (s->bits > 8);
1591 const int block_size = s->lossless ? 1 : 8;
1592
1593 for (c = 0; c < s->nb_components; c++) {
1594 uint8_t *data = s->picture_ptr->data[c];
1595 int linesize = s->linesize[c];
1596 int h = s->h_max / s->h_count[c];
1597 int v = s->v_max / s->v_count[c];
1598 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1599 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1600
1601 if (~s->coefs_finished[c])
1602 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1603
1604 if (s->interlaced && s->bottom_field)
1605 data += linesize >> 1;
1606
1607 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1608 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1609 int block_idx = mb_y * s->block_stride[c];
1610 int16_t (*block)[64] = &s->blocks[c][block_idx];
1611 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1612 s->idsp.idct_put(ptr, linesize, *block);
1613 if (s->bits & 7)
1614 shift_output(s, ptr, linesize);
1615 ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1616 }
1617 }
1618 }
1619 }
1620
ff_mjpeg_decode_sos(MJpegDecodeContext * s,const uint8_t * mb_bitmask,int mb_bitmask_size,const AVFrame * reference)1621 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1622 int mb_bitmask_size, const AVFrame *reference)
1623 {
1624 int len, nb_components, i, h, v, predictor, point_transform;
1625 int index, id, ret;
1626 const int block_size = s->lossless ? 1 : 8;
1627 int ilv, prev_shift;
1628
1629 if (!s->got_picture) {
1630 av_log(s->avctx, AV_LOG_WARNING,
1631 "Can not process SOS before SOF, skipping\n");
1632 return -1;
1633 }
1634
1635 if (reference) {
1636 if (reference->width != s->picture_ptr->width ||
1637 reference->height != s->picture_ptr->height ||
1638 reference->format != s->picture_ptr->format) {
1639 av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1640 return AVERROR_INVALIDDATA;
1641 }
1642 }
1643
1644 /* XXX: verify len field validity */
1645 len = get_bits(&s->gb, 16);
1646 nb_components = get_bits(&s->gb, 8);
1647 if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1648 avpriv_report_missing_feature(s->avctx,
1649 "decode_sos: nb_components (%d)",
1650 nb_components);
1651 return AVERROR_PATCHWELCOME;
1652 }
1653 if (len != 6 + 2 * nb_components) {
1654 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1655 return AVERROR_INVALIDDATA;
1656 }
1657 for (i = 0; i < nb_components; i++) {
1658 id = get_bits(&s->gb, 8) - 1;
1659 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1660 /* find component index */
1661 for (index = 0; index < s->nb_components; index++)
1662 if (id == s->component_id[index])
1663 break;
1664 if (index == s->nb_components) {
1665 av_log(s->avctx, AV_LOG_ERROR,
1666 "decode_sos: index(%d) out of components\n", index);
1667 return AVERROR_INVALIDDATA;
1668 }
1669 /* Metasoft MJPEG codec has Cb and Cr swapped */
1670 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1671 && nb_components == 3 && s->nb_components == 3 && i)
1672 index = 3 - i;
1673
1674 s->quant_sindex[i] = s->quant_index[index];
1675 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1676 s->h_scount[i] = s->h_count[index];
1677 s->v_scount[i] = s->v_count[index];
1678
1679 if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1680 index = (index+2)%3;
1681
1682 s->comp_index[i] = index;
1683
1684 s->dc_index[i] = get_bits(&s->gb, 4);
1685 s->ac_index[i] = get_bits(&s->gb, 4);
1686
1687 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1688 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1689 goto out_of_range;
1690 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))
1691 goto out_of_range;
1692 }
1693
1694 predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1695 ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1696 if(s->avctx->codec_tag != AV_RL32("CJPG")){
1697 prev_shift = get_bits(&s->gb, 4); /* Ah */
1698 point_transform = get_bits(&s->gb, 4); /* Al */
1699 }else
1700 prev_shift = point_transform = 0;
1701
1702 if (nb_components > 1) {
1703 /* interleaved stream */
1704 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1705 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1706 } else if (!s->ls) { /* skip this for JPEG-LS */
1707 h = s->h_max / s->h_scount[0];
1708 v = s->v_max / s->v_scount[0];
1709 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1710 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1711 s->nb_blocks[0] = 1;
1712 s->h_scount[0] = 1;
1713 s->v_scount[0] = 1;
1714 }
1715
1716 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1717 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1718 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1719 predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1720 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1721
1722
1723 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1724 for (i = s->mjpb_skiptosod; i > 0; i--)
1725 skip_bits(&s->gb, 8);
1726
1727 next_field:
1728 for (i = 0; i < nb_components; i++)
1729 s->last_dc[i] = (4 << s->bits);
1730
1731 if (s->avctx->hwaccel) {
1732 int bytes_to_start = get_bits_count(&s->gb) / 8;
1733 av_assert0(bytes_to_start >= 0 &&
1734 s->raw_scan_buffer_size >= bytes_to_start);
1735
1736 ret = s->avctx->hwaccel->decode_slice(s->avctx,
1737 s->raw_scan_buffer + bytes_to_start,
1738 s->raw_scan_buffer_size - bytes_to_start);
1739 if (ret < 0)
1740 return ret;
1741
1742 } else if (s->lossless) {
1743 av_assert0(s->picture_ptr == s->picture);
1744 if (CONFIG_JPEGLS_DECODER && s->ls) {
1745 // for () {
1746 // reset_ls_coding_parameters(s, 0);
1747
1748 if ((ret = ff_jpegls_decode_picture(s, predictor,
1749 point_transform, ilv)) < 0)
1750 return ret;
1751 } else {
1752 if (s->rgb || s->bayer) {
1753 if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1754 return ret;
1755 } else {
1756 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1757 point_transform,
1758 nb_components)) < 0)
1759 return ret;
1760 }
1761 }
1762 } else {
1763 if (s->progressive && predictor) {
1764 av_assert0(s->picture_ptr == s->picture);
1765 if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1766 ilv, prev_shift,
1767 point_transform)) < 0)
1768 return ret;
1769 } else {
1770 if ((ret = mjpeg_decode_scan(s, nb_components,
1771 prev_shift, point_transform,
1772 mb_bitmask, mb_bitmask_size, reference)) < 0)
1773 return ret;
1774 }
1775 }
1776
1777 if (s->interlaced &&
1778 get_bits_left(&s->gb) > 32 &&
1779 show_bits(&s->gb, 8) == 0xFF) {
1780 GetBitContext bak = s->gb;
1781 align_get_bits(&bak);
1782 if (show_bits(&bak, 16) == 0xFFD1) {
1783 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1784 s->gb = bak;
1785 skip_bits(&s->gb, 16);
1786 s->bottom_field ^= 1;
1787
1788 goto next_field;
1789 }
1790 }
1791
1792 emms_c();
1793 return 0;
1794 out_of_range:
1795 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1796 return AVERROR_INVALIDDATA;
1797 }
1798
mjpeg_decode_dri(MJpegDecodeContext * s)1799 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1800 {
1801 if (get_bits(&s->gb, 16) != 4)
1802 return AVERROR_INVALIDDATA;
1803 s->restart_interval = get_bits(&s->gb, 16);
1804 s->restart_count = 0;
1805 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1806 s->restart_interval);
1807
1808 return 0;
1809 }
1810
mjpeg_decode_app(MJpegDecodeContext * s)1811 static int mjpeg_decode_app(MJpegDecodeContext *s)
1812 {
1813 int len, id, i;
1814
1815 len = get_bits(&s->gb, 16);
1816 if (len < 6) {
1817 if (s->bayer) {
1818 // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1819 av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1820 skip_bits(&s->gb, len);
1821 return 0;
1822 } else
1823 return AVERROR_INVALIDDATA;
1824 }
1825 if (8 * len > get_bits_left(&s->gb))
1826 return AVERROR_INVALIDDATA;
1827
1828 id = get_bits_long(&s->gb, 32);
1829 len -= 6;
1830
1831 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1832 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1833 av_fourcc2str(av_bswap32(id)), id, len);
1834
1835 /* Buggy AVID, it puts EOI only at every 10th frame. */
1836 /* Also, this fourcc is used by non-avid files too, it holds some
1837 information, but it's always present in AVID-created files. */
1838 if (id == AV_RB32("AVI1")) {
1839 /* structure:
1840 4bytes AVI1
1841 1bytes polarity
1842 1bytes always zero
1843 4bytes field_size
1844 4bytes field_size_less_padding
1845 */
1846 s->buggy_avid = 1;
1847 i = get_bits(&s->gb, 8); len--;
1848 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1849 goto out;
1850 }
1851
1852 if (id == AV_RB32("JFIF")) {
1853 int t_w, t_h, v1, v2;
1854 if (len < 8)
1855 goto out;
1856 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1857 v1 = get_bits(&s->gb, 8);
1858 v2 = get_bits(&s->gb, 8);
1859 skip_bits(&s->gb, 8);
1860
1861 s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1862 s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1863 if ( s->avctx->sample_aspect_ratio.num <= 0
1864 || s->avctx->sample_aspect_ratio.den <= 0) {
1865 s->avctx->sample_aspect_ratio.num = 0;
1866 s->avctx->sample_aspect_ratio.den = 1;
1867 }
1868
1869 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1870 av_log(s->avctx, AV_LOG_INFO,
1871 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1872 v1, v2,
1873 s->avctx->sample_aspect_ratio.num,
1874 s->avctx->sample_aspect_ratio.den);
1875
1876 len -= 8;
1877 if (len >= 2) {
1878 t_w = get_bits(&s->gb, 8);
1879 t_h = get_bits(&s->gb, 8);
1880 if (t_w && t_h) {
1881 /* skip thumbnail */
1882 if (len -10 - (t_w * t_h * 3) > 0)
1883 len -= t_w * t_h * 3;
1884 }
1885 len -= 2;
1886 }
1887 goto out;
1888 }
1889
1890 if ( id == AV_RB32("Adob")
1891 && len >= 7
1892 && show_bits(&s->gb, 8) == 'e'
1893 && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1894 skip_bits(&s->gb, 8); /* 'e' */
1895 skip_bits(&s->gb, 16); /* version */
1896 skip_bits(&s->gb, 16); /* flags0 */
1897 skip_bits(&s->gb, 16); /* flags1 */
1898 s->adobe_transform = get_bits(&s->gb, 8);
1899 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1900 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1901 len -= 7;
1902 goto out;
1903 }
1904
1905 if (id == AV_RB32("LJIF")) {
1906 int rgb = s->rgb;
1907 int pegasus_rct = s->pegasus_rct;
1908 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1909 av_log(s->avctx, AV_LOG_INFO,
1910 "Pegasus lossless jpeg header found\n");
1911 skip_bits(&s->gb, 16); /* version ? */
1912 skip_bits(&s->gb, 16); /* unknown always 0? */
1913 skip_bits(&s->gb, 16); /* unknown always 0? */
1914 skip_bits(&s->gb, 16); /* unknown always 0? */
1915 switch (i=get_bits(&s->gb, 8)) {
1916 case 1:
1917 rgb = 1;
1918 pegasus_rct = 0;
1919 break;
1920 case 2:
1921 rgb = 1;
1922 pegasus_rct = 1;
1923 break;
1924 default:
1925 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1926 }
1927
1928 len -= 9;
1929 if (s->got_picture)
1930 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1931 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1932 goto out;
1933 }
1934
1935 s->rgb = rgb;
1936 s->pegasus_rct = pegasus_rct;
1937
1938 goto out;
1939 }
1940 if (id == AV_RL32("colr") && len > 0) {
1941 s->colr = get_bits(&s->gb, 8);
1942 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1943 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1944 len --;
1945 goto out;
1946 }
1947 if (id == AV_RL32("xfrm") && len > 0) {
1948 s->xfrm = get_bits(&s->gb, 8);
1949 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1950 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1951 len --;
1952 goto out;
1953 }
1954
1955 /* JPS extension by VRex */
1956 if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1957 int flags, layout, type;
1958 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1959 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1960
1961 skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1962 skip_bits(&s->gb, 16); len -= 2; /* block length */
1963 skip_bits(&s->gb, 8); /* reserved */
1964 flags = get_bits(&s->gb, 8);
1965 layout = get_bits(&s->gb, 8);
1966 type = get_bits(&s->gb, 8);
1967 len -= 4;
1968
1969 av_freep(&s->stereo3d);
1970 s->stereo3d = av_stereo3d_alloc();
1971 if (!s->stereo3d) {
1972 goto out;
1973 }
1974 if (type == 0) {
1975 s->stereo3d->type = AV_STEREO3D_2D;
1976 } else if (type == 1) {
1977 switch (layout) {
1978 case 0x01:
1979 s->stereo3d->type = AV_STEREO3D_LINES;
1980 break;
1981 case 0x02:
1982 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1983 break;
1984 case 0x03:
1985 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1986 break;
1987 }
1988 if (!(flags & 0x04)) {
1989 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1990 }
1991 }
1992 goto out;
1993 }
1994
1995 /* EXIF metadata */
1996 if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1997 GetByteContext gbytes;
1998 int ret, le, ifd_offset, bytes_read;
1999 const uint8_t *aligned;
2000
2001 skip_bits(&s->gb, 16); // skip padding
2002 len -= 2;
2003
2004 // init byte wise reading
2005 aligned = align_get_bits(&s->gb);
2006 bytestream2_init(&gbytes, aligned, len);
2007
2008 // read TIFF header
2009 ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2010 if (ret) {
2011 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2012 } else {
2013 bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2014
2015 // read 0th IFD and store the metadata
2016 // (return values > 0 indicate the presence of subimage metadata)
2017 ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2018 if (ret < 0) {
2019 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2020 }
2021 }
2022
2023 bytes_read = bytestream2_tell(&gbytes);
2024 skip_bits(&s->gb, bytes_read << 3);
2025 len -= bytes_read;
2026
2027 goto out;
2028 }
2029
2030 /* Apple MJPEG-A */
2031 if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2032 id = get_bits_long(&s->gb, 32);
2033 len -= 4;
2034 /* Apple MJPEG-A */
2035 if (id == AV_RB32("mjpg")) {
2036 /* structure:
2037 4bytes field size
2038 4bytes pad field size
2039 4bytes next off
2040 4bytes quant off
2041 4bytes huff off
2042 4bytes image off
2043 4bytes scan off
2044 4bytes data off
2045 */
2046 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2047 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2048 }
2049 }
2050
2051 if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2052 int id2;
2053 unsigned seqno;
2054 unsigned nummarkers;
2055
2056 id = get_bits_long(&s->gb, 32);
2057 id2 = get_bits(&s->gb, 24);
2058 len -= 7;
2059 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2060 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2061 goto out;
2062 }
2063
2064 skip_bits(&s->gb, 8);
2065 seqno = get_bits(&s->gb, 8);
2066 len -= 2;
2067 if (seqno == 0) {
2068 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2069 goto out;
2070 }
2071
2072 nummarkers = get_bits(&s->gb, 8);
2073 len -= 1;
2074 if (nummarkers == 0) {
2075 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2076 goto out;
2077 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2078 av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2079 goto out;
2080 } else if (seqno > nummarkers) {
2081 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2082 goto out;
2083 }
2084
2085 /* Allocate if this is the first APP2 we've seen. */
2086 if (s->iccnum == 0) {
2087 s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2088 s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2089 if (!s->iccdata || !s->iccdatalens) {
2090 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2091 return AVERROR(ENOMEM);
2092 }
2093 s->iccnum = nummarkers;
2094 }
2095
2096 if (s->iccdata[seqno - 1]) {
2097 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2098 goto out;
2099 }
2100
2101 s->iccdatalens[seqno - 1] = len;
2102 s->iccdata[seqno - 1] = av_malloc(len);
2103 if (!s->iccdata[seqno - 1]) {
2104 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2105 return AVERROR(ENOMEM);
2106 }
2107
2108 memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2109 skip_bits(&s->gb, len << 3);
2110 len = 0;
2111 s->iccread++;
2112
2113 if (s->iccread > s->iccnum)
2114 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2115 }
2116
2117 out:
2118 /* slow but needed for extreme adobe jpegs */
2119 if (len < 0)
2120 av_log(s->avctx, AV_LOG_ERROR,
2121 "mjpeg: error, decode_app parser read over the end\n");
2122 while (--len > 0)
2123 skip_bits(&s->gb, 8);
2124
2125 return 0;
2126 }
2127
mjpeg_decode_com(MJpegDecodeContext * s)2128 static int mjpeg_decode_com(MJpegDecodeContext *s)
2129 {
2130 int len = get_bits(&s->gb, 16);
2131 if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2132 int i;
2133 char *cbuf = av_malloc(len - 1);
2134 if (!cbuf)
2135 return AVERROR(ENOMEM);
2136
2137 for (i = 0; i < len - 2; i++)
2138 cbuf[i] = get_bits(&s->gb, 8);
2139 if (i > 0 && cbuf[i - 1] == '\n')
2140 cbuf[i - 1] = 0;
2141 else
2142 cbuf[i] = 0;
2143
2144 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2145 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2146
2147 /* buggy avid, it puts EOI only at every 10th frame */
2148 if (!strncmp(cbuf, "AVID", 4)) {
2149 parse_avid(s, cbuf, len);
2150 } else if (!strcmp(cbuf, "CS=ITU601"))
2151 s->cs_itu601 = 1;
2152 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2153 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2154 s->flipped = 1;
2155 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2156 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2157 s->multiscope = 2;
2158 }
2159
2160 av_free(cbuf);
2161 }
2162
2163 return 0;
2164 }
2165
2166 /* return the 8 bit start code value and update the search
2167 state. Return -1 if no start code found */
find_marker(const uint8_t ** pbuf_ptr,const uint8_t * buf_end)2168 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2169 {
2170 const uint8_t *buf_ptr;
2171 unsigned int v, v2;
2172 int val;
2173 int skipped = 0;
2174
2175 buf_ptr = *pbuf_ptr;
2176 while (buf_end - buf_ptr > 1) {
2177 v = *buf_ptr++;
2178 v2 = *buf_ptr;
2179 if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2180 val = *buf_ptr++;
2181 goto found;
2182 }
2183 skipped++;
2184 }
2185 buf_ptr = buf_end;
2186 val = -1;
2187 found:
2188 ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2189 *pbuf_ptr = buf_ptr;
2190 return val;
2191 }
2192
ff_mjpeg_find_marker(MJpegDecodeContext * s,const uint8_t ** buf_ptr,const uint8_t * buf_end,const uint8_t ** unescaped_buf_ptr,int * unescaped_buf_size)2193 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
2194 const uint8_t **buf_ptr, const uint8_t *buf_end,
2195 const uint8_t **unescaped_buf_ptr,
2196 int *unescaped_buf_size)
2197 {
2198 int start_code;
2199 start_code = find_marker(buf_ptr, buf_end);
2200
2201 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2202 if (!s->buffer)
2203 return AVERROR(ENOMEM);
2204
2205 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2206 if (start_code == SOS && !s->ls) {
2207 const uint8_t *src = *buf_ptr;
2208 const uint8_t *ptr = src;
2209 uint8_t *dst = s->buffer;
2210
2211 #define copy_data_segment(skip) do { \
2212 ptrdiff_t length = (ptr - src) - (skip); \
2213 if (length > 0) { \
2214 memcpy(dst, src, length); \
2215 dst += length; \
2216 src = ptr; \
2217 } \
2218 } while (0)
2219
2220 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2221 ptr = buf_end;
2222 copy_data_segment(0);
2223 } else {
2224 while (ptr < buf_end) {
2225 uint8_t x = *(ptr++);
2226
2227 if (x == 0xff) {
2228 ptrdiff_t skip = 0;
2229 while (ptr < buf_end && x == 0xff) {
2230 x = *(ptr++);
2231 skip++;
2232 }
2233
2234 /* 0xFF, 0xFF, ... */
2235 if (skip > 1) {
2236 copy_data_segment(skip);
2237
2238 /* decrement src as it is equal to ptr after the
2239 * copy_data_segment macro and we might want to
2240 * copy the current value of x later on */
2241 src--;
2242 }
2243
2244 if (x < RST0 || x > RST7) {
2245 copy_data_segment(1);
2246 if (x)
2247 break;
2248 }
2249 }
2250 }
2251 if (src < ptr)
2252 copy_data_segment(0);
2253 }
2254 #undef copy_data_segment
2255
2256 *unescaped_buf_ptr = s->buffer;
2257 *unescaped_buf_size = dst - s->buffer;
2258 memset(s->buffer + *unescaped_buf_size, 0,
2259 AV_INPUT_BUFFER_PADDING_SIZE);
2260
2261 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2262 (buf_end - *buf_ptr) - (dst - s->buffer));
2263 } else if (start_code == SOS && s->ls) {
2264 const uint8_t *src = *buf_ptr;
2265 uint8_t *dst = s->buffer;
2266 int bit_count = 0;
2267 int t = 0, b = 0;
2268 PutBitContext pb;
2269
2270 /* find marker */
2271 while (src + t < buf_end) {
2272 uint8_t x = src[t++];
2273 if (x == 0xff) {
2274 while ((src + t < buf_end) && x == 0xff)
2275 x = src[t++];
2276 if (x & 0x80) {
2277 t -= FFMIN(2, t);
2278 break;
2279 }
2280 }
2281 }
2282 bit_count = t * 8;
2283 init_put_bits(&pb, dst, t);
2284
2285 /* unescape bitstream */
2286 while (b < t) {
2287 uint8_t x = src[b++];
2288 put_bits(&pb, 8, x);
2289 if (x == 0xFF && b < t) {
2290 x = src[b++];
2291 if (x & 0x80) {
2292 av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2293 x &= 0x7f;
2294 }
2295 put_bits(&pb, 7, x);
2296 bit_count--;
2297 }
2298 }
2299 flush_put_bits(&pb);
2300
2301 *unescaped_buf_ptr = dst;
2302 *unescaped_buf_size = (bit_count + 7) >> 3;
2303 memset(s->buffer + *unescaped_buf_size, 0,
2304 AV_INPUT_BUFFER_PADDING_SIZE);
2305 } else {
2306 *unescaped_buf_ptr = *buf_ptr;
2307 *unescaped_buf_size = buf_end - *buf_ptr;
2308 }
2309
2310 return start_code;
2311 }
2312
reset_icc_profile(MJpegDecodeContext * s)2313 static void reset_icc_profile(MJpegDecodeContext *s)
2314 {
2315 int i;
2316
2317 if (s->iccdata)
2318 for (i = 0; i < s->iccnum; i++)
2319 av_freep(&s->iccdata[i]);
2320 av_freep(&s->iccdata);
2321 av_freep(&s->iccdatalens);
2322
2323 s->iccread = 0;
2324 s->iccnum = 0;
2325 }
2326
ff_mjpeg_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)2327 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2328 AVPacket *avpkt)
2329 {
2330 AVFrame *frame = data;
2331 const uint8_t *buf = avpkt->data;
2332 int buf_size = avpkt->size;
2333 MJpegDecodeContext *s = avctx->priv_data;
2334 const uint8_t *buf_end, *buf_ptr;
2335 const uint8_t *unescaped_buf_ptr;
2336 int hshift, vshift;
2337 int unescaped_buf_size;
2338 int start_code;
2339 int i, index;
2340 int ret = 0;
2341 int is16bit;
2342
2343 s->buf_size = buf_size;
2344
2345 av_dict_free(&s->exif_metadata);
2346 av_freep(&s->stereo3d);
2347 s->adobe_transform = -1;
2348
2349 if (s->iccnum != 0)
2350 reset_icc_profile(s);
2351
2352 buf_ptr = buf;
2353 buf_end = buf + buf_size;
2354 while (buf_ptr < buf_end) {
2355 /* find start next marker */
2356 start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2357 &unescaped_buf_ptr,
2358 &unescaped_buf_size);
2359 /* EOF */
2360 if (start_code < 0) {
2361 break;
2362 } else if (unescaped_buf_size > INT_MAX / 8) {
2363 av_log(avctx, AV_LOG_ERROR,
2364 "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2365 start_code, unescaped_buf_size, buf_size);
2366 return AVERROR_INVALIDDATA;
2367 }
2368 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2369 start_code, buf_end - buf_ptr);
2370
2371 ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2372
2373 if (ret < 0) {
2374 av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2375 goto fail;
2376 }
2377
2378 s->start_code = start_code;
2379 if (s->avctx->debug & FF_DEBUG_STARTCODE)
2380 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2381
2382 /* process markers */
2383 if (start_code >= RST0 && start_code <= RST7) {
2384 av_log(avctx, AV_LOG_DEBUG,
2385 "restart marker: %d\n", start_code & 0x0f);
2386 /* APP fields */
2387 } else if (start_code >= APP0 && start_code <= APP15) {
2388 if ((ret = mjpeg_decode_app(s)) < 0)
2389 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2390 av_err2str(ret));
2391 /* Comment */
2392 } else if (start_code == COM) {
2393 ret = mjpeg_decode_com(s);
2394 if (ret < 0)
2395 return ret;
2396 } else if (start_code == DQT) {
2397 ret = ff_mjpeg_decode_dqt(s);
2398 if (ret < 0)
2399 return ret;
2400 }
2401
2402 ret = -1;
2403
2404 if (!CONFIG_JPEGLS_DECODER &&
2405 (start_code == SOF48 || start_code == LSE)) {
2406 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2407 return AVERROR(ENOSYS);
2408 }
2409
2410 if (avctx->skip_frame == AVDISCARD_ALL) {
2411 switch(start_code) {
2412 case SOF0:
2413 case SOF1:
2414 case SOF2:
2415 case SOF3:
2416 case SOF48:
2417 case SOI:
2418 case SOS:
2419 case EOI:
2420 break;
2421 default:
2422 goto skip;
2423 }
2424 }
2425
2426 switch (start_code) {
2427 case SOI:
2428 s->restart_interval = 0;
2429 s->restart_count = 0;
2430 s->raw_image_buffer = buf_ptr;
2431 s->raw_image_buffer_size = buf_end - buf_ptr;
2432 /* nothing to do on SOI */
2433 break;
2434 case DHT:
2435 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2436 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2437 goto fail;
2438 }
2439 break;
2440 case SOF0:
2441 case SOF1:
2442 if (start_code == SOF0)
2443 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2444 else
2445 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2446 s->lossless = 0;
2447 s->ls = 0;
2448 s->progressive = 0;
2449 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2450 goto fail;
2451 break;
2452 case SOF2:
2453 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2454 s->lossless = 0;
2455 s->ls = 0;
2456 s->progressive = 1;
2457 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2458 goto fail;
2459 break;
2460 case SOF3:
2461 s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2462 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2463 s->lossless = 1;
2464 s->ls = 0;
2465 s->progressive = 0;
2466 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2467 goto fail;
2468 break;
2469 case SOF48:
2470 s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2471 s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2472 s->lossless = 1;
2473 s->ls = 1;
2474 s->progressive = 0;
2475 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2476 goto fail;
2477 break;
2478 case LSE:
2479 if (!CONFIG_JPEGLS_DECODER ||
2480 (ret = ff_jpegls_decode_lse(s)) < 0)
2481 goto fail;
2482 break;
2483 case EOI:
2484 eoi_parser:
2485 if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2486 s->progressive && s->cur_scan && s->got_picture)
2487 mjpeg_idct_scan_progressive_ac(s);
2488 s->cur_scan = 0;
2489 if (!s->got_picture) {
2490 av_log(avctx, AV_LOG_WARNING,
2491 "Found EOI before any SOF, ignoring\n");
2492 break;
2493 }
2494 if (s->interlaced) {
2495 s->bottom_field ^= 1;
2496 /* if not bottom field, do not output image yet */
2497 if (s->bottom_field == !s->interlace_polarity)
2498 break;
2499 }
2500 if (avctx->skip_frame == AVDISCARD_ALL) {
2501 s->got_picture = 0;
2502 goto the_end_no_picture;
2503 }
2504 if (s->avctx->hwaccel) {
2505 ret = s->avctx->hwaccel->end_frame(s->avctx);
2506 if (ret < 0)
2507 return ret;
2508
2509 av_freep(&s->hwaccel_picture_private);
2510 }
2511 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2512 return ret;
2513 *got_frame = 1;
2514 s->got_picture = 0;
2515
2516 if (!s->lossless) {
2517 int qp = FFMAX3(s->qscale[0],
2518 s->qscale[1],
2519 s->qscale[2]);
2520 int qpw = (s->width + 15) / 16;
2521 AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2522 if (qp_table_buf) {
2523 memset(qp_table_buf->data, qp, qpw);
2524 av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2525 }
2526
2527 if(avctx->debug & FF_DEBUG_QP)
2528 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2529 }
2530
2531 goto the_end;
2532 case SOS:
2533 s->raw_scan_buffer = buf_ptr;
2534 s->raw_scan_buffer_size = buf_end - buf_ptr;
2535
2536 s->cur_scan++;
2537 if (avctx->skip_frame == AVDISCARD_ALL) {
2538 skip_bits(&s->gb, get_bits_left(&s->gb));
2539 break;
2540 }
2541
2542 if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2543 (avctx->err_recognition & AV_EF_EXPLODE))
2544 goto fail;
2545 break;
2546 case DRI:
2547 if ((ret = mjpeg_decode_dri(s)) < 0)
2548 return ret;
2549 break;
2550 case SOF5:
2551 case SOF6:
2552 case SOF7:
2553 case SOF9:
2554 case SOF10:
2555 case SOF11:
2556 case SOF13:
2557 case SOF14:
2558 case SOF15:
2559 case JPG:
2560 av_log(avctx, AV_LOG_ERROR,
2561 "mjpeg: unsupported coding type (%x)\n", start_code);
2562 break;
2563 }
2564
2565 skip:
2566 /* eof process start code */
2567 buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2568 av_log(avctx, AV_LOG_DEBUG,
2569 "marker parser used %d bytes (%d bits)\n",
2570 (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2571 }
2572 if (s->got_picture && s->cur_scan) {
2573 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2574 goto eoi_parser;
2575 }
2576 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2577 return AVERROR_INVALIDDATA;
2578 fail:
2579 s->got_picture = 0;
2580 return ret;
2581 the_end:
2582
2583 is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2584
2585 if (AV_RB32(s->upscale_h)) {
2586 int p;
2587 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2588 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2589 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2590 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2591 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2592 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2593 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2594 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2595 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2596 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2597 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2598 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2599 );
2600 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2601 if (ret)
2602 return ret;
2603
2604 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2605 for (p = 0; p<s->nb_components; p++) {
2606 uint8_t *line = s->picture_ptr->data[p];
2607 int w = s->width;
2608 int h = s->height;
2609 if (!s->upscale_h[p])
2610 continue;
2611 if (p==1 || p==2) {
2612 w = AV_CEIL_RSHIFT(w, hshift);
2613 h = AV_CEIL_RSHIFT(h, vshift);
2614 }
2615 if (s->upscale_v[p] == 1)
2616 h = (h+1)>>1;
2617 av_assert0(w > 0);
2618 for (i = 0; i < h; i++) {
2619 if (s->upscale_h[p] == 1) {
2620 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2621 else line[w - 1] = line[(w - 1) / 2];
2622 for (index = w - 2; index > 0; index--) {
2623 if (is16bit)
2624 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2625 else
2626 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2627 }
2628 } else if (s->upscale_h[p] == 2) {
2629 if (is16bit) {
2630 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2631 if (w > 1)
2632 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2633 } else {
2634 line[w - 1] = line[(w - 1) / 3];
2635 if (w > 1)
2636 line[w - 2] = line[w - 1];
2637 }
2638 for (index = w - 3; index > 0; index--) {
2639 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2640 }
2641 }
2642 line += s->linesize[p];
2643 }
2644 }
2645 }
2646 if (AV_RB32(s->upscale_v)) {
2647 int p;
2648 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2650 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2652 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2653 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2654 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2655 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2656 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2657 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2658 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2659 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2660 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2661 );
2662 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2663 if (ret)
2664 return ret;
2665
2666 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2667 for (p = 0; p < s->nb_components; p++) {
2668 uint8_t *dst;
2669 int w = s->width;
2670 int h = s->height;
2671 if (!s->upscale_v[p])
2672 continue;
2673 if (p==1 || p==2) {
2674 w = AV_CEIL_RSHIFT(w, hshift);
2675 h = AV_CEIL_RSHIFT(h, vshift);
2676 }
2677 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2678 for (i = h - 1; i; i--) {
2679 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2680 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2681 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2682 memcpy(dst, src1, w);
2683 } else {
2684 for (index = 0; index < w; index++)
2685 dst[index] = (src1[index] + src2[index]) >> 1;
2686 }
2687 dst -= s->linesize[p];
2688 }
2689 }
2690 }
2691 if (s->flipped && !s->rgb) {
2692 int j;
2693 ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2694 if (ret)
2695 return ret;
2696
2697 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2698 for (index=0; index<s->nb_components; index++) {
2699 uint8_t *dst = s->picture_ptr->data[index];
2700 int w = s->picture_ptr->width;
2701 int h = s->picture_ptr->height;
2702 if(index && index<3){
2703 w = AV_CEIL_RSHIFT(w, hshift);
2704 h = AV_CEIL_RSHIFT(h, vshift);
2705 }
2706 if(dst){
2707 uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2708 for (i=0; i<h/2; i++) {
2709 for (j=0; j<w; j++)
2710 FFSWAP(int, dst[j], dst2[j]);
2711 dst += s->picture_ptr->linesize[index];
2712 dst2 -= s->picture_ptr->linesize[index];
2713 }
2714 }
2715 }
2716 }
2717 if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2718 int w = s->picture_ptr->width;
2719 int h = s->picture_ptr->height;
2720 av_assert0(s->nb_components == 4);
2721 for (i=0; i<h; i++) {
2722 int j;
2723 uint8_t *dst[4];
2724 for (index=0; index<4; index++) {
2725 dst[index] = s->picture_ptr->data[index]
2726 + s->picture_ptr->linesize[index]*i;
2727 }
2728 for (j=0; j<w; j++) {
2729 int k = dst[3][j];
2730 int r = dst[0][j] * k;
2731 int g = dst[1][j] * k;
2732 int b = dst[2][j] * k;
2733 dst[0][j] = g*257 >> 16;
2734 dst[1][j] = b*257 >> 16;
2735 dst[2][j] = r*257 >> 16;
2736 dst[3][j] = 255;
2737 }
2738 }
2739 }
2740 if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2741 int w = s->picture_ptr->width;
2742 int h = s->picture_ptr->height;
2743 av_assert0(s->nb_components == 4);
2744 for (i=0; i<h; i++) {
2745 int j;
2746 uint8_t *dst[4];
2747 for (index=0; index<4; index++) {
2748 dst[index] = s->picture_ptr->data[index]
2749 + s->picture_ptr->linesize[index]*i;
2750 }
2751 for (j=0; j<w; j++) {
2752 int k = dst[3][j];
2753 int r = (255 - dst[0][j]) * k;
2754 int g = (128 - dst[1][j]) * k;
2755 int b = (128 - dst[2][j]) * k;
2756 dst[0][j] = r*257 >> 16;
2757 dst[1][j] = (g*257 >> 16) + 128;
2758 dst[2][j] = (b*257 >> 16) + 128;
2759 dst[3][j] = 255;
2760 }
2761 }
2762 }
2763
2764 if (s->stereo3d) {
2765 AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2766 if (stereo) {
2767 stereo->type = s->stereo3d->type;
2768 stereo->flags = s->stereo3d->flags;
2769 }
2770 av_freep(&s->stereo3d);
2771 }
2772
2773 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2774 AVFrameSideData *sd;
2775 size_t offset = 0;
2776 int total_size = 0;
2777 int i;
2778
2779 /* Sum size of all parts. */
2780 for (i = 0; i < s->iccnum; i++)
2781 total_size += s->iccdatalens[i];
2782
2783 sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2784 if (!sd) {
2785 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2786 return AVERROR(ENOMEM);
2787 }
2788
2789 /* Reassemble the parts, which are now in-order. */
2790 for (i = 0; i < s->iccnum; i++) {
2791 memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2792 offset += s->iccdatalens[i];
2793 }
2794 }
2795
2796 av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2797 av_dict_free(&s->exif_metadata);
2798
2799 the_end_no_picture:
2800 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2801 buf_end - buf_ptr);
2802 // return buf_end - buf_ptr;
2803 return buf_ptr - buf;
2804 }
2805
ff_mjpeg_decode_end(AVCodecContext * avctx)2806 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2807 {
2808 MJpegDecodeContext *s = avctx->priv_data;
2809 int i, j;
2810
2811 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2812 av_log(avctx, AV_LOG_INFO, "Single field\n");
2813 }
2814
2815 if (s->picture) {
2816 av_frame_free(&s->picture);
2817 s->picture_ptr = NULL;
2818 } else if (s->picture_ptr)
2819 av_frame_unref(s->picture_ptr);
2820
2821 av_freep(&s->buffer);
2822 av_freep(&s->stereo3d);
2823 av_freep(&s->ljpeg_buffer);
2824 s->ljpeg_buffer_size = 0;
2825
2826 for (i = 0; i < 3; i++) {
2827 for (j = 0; j < 4; j++)
2828 ff_free_vlc(&s->vlcs[i][j]);
2829 }
2830 for (i = 0; i < MAX_COMPONENTS; i++) {
2831 av_freep(&s->blocks[i]);
2832 av_freep(&s->last_nnz[i]);
2833 }
2834 av_dict_free(&s->exif_metadata);
2835
2836 reset_icc_profile(s);
2837
2838 av_freep(&s->hwaccel_picture_private);
2839
2840 return 0;
2841 }
2842
decode_flush(AVCodecContext * avctx)2843 static void decode_flush(AVCodecContext *avctx)
2844 {
2845 MJpegDecodeContext *s = avctx->priv_data;
2846 s->got_picture = 0;
2847 }
2848
2849 #if CONFIG_MJPEG_DECODER
2850 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2851 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2852 static const AVOption options[] = {
2853 { "extern_huff", "Use external huffman table.",
2854 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2855 { NULL },
2856 };
2857
2858 static const AVClass mjpegdec_class = {
2859 .class_name = "MJPEG decoder",
2860 .item_name = av_default_item_name,
2861 .option = options,
2862 .version = LIBAVUTIL_VERSION_INT,
2863 };
2864
2865 AVCodec ff_mjpeg_decoder = {
2866 .name = "mjpeg",
2867 .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2868 .type = AVMEDIA_TYPE_VIDEO,
2869 .id = AV_CODEC_ID_MJPEG,
2870 .priv_data_size = sizeof(MJpegDecodeContext),
2871 .init = ff_mjpeg_decode_init,
2872 .close = ff_mjpeg_decode_end,
2873 .decode = ff_mjpeg_decode_frame,
2874 .flush = decode_flush,
2875 .capabilities = AV_CODEC_CAP_DR1,
2876 .max_lowres = 3,
2877 .priv_class = &mjpegdec_class,
2878 .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2879 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2880 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2881 .hw_configs = (const AVCodecHWConfigInternal*[]) {
2882 #if CONFIG_MJPEG_NVDEC_HWACCEL
2883 HWACCEL_NVDEC(mjpeg),
2884 #endif
2885 #if CONFIG_MJPEG_VAAPI_HWACCEL
2886 HWACCEL_VAAPI(mjpeg),
2887 #endif
2888 NULL
2889 },
2890 };
2891 #endif
2892 #if CONFIG_THP_DECODER
2893 AVCodec ff_thp_decoder = {
2894 .name = "thp",
2895 .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2896 .type = AVMEDIA_TYPE_VIDEO,
2897 .id = AV_CODEC_ID_THP,
2898 .priv_data_size = sizeof(MJpegDecodeContext),
2899 .init = ff_mjpeg_decode_init,
2900 .close = ff_mjpeg_decode_end,
2901 .decode = ff_mjpeg_decode_frame,
2902 .flush = decode_flush,
2903 .capabilities = AV_CODEC_CAP_DR1,
2904 .max_lowres = 3,
2905 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
2906 };
2907 #endif
2908