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