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 if (s->avctx->codec_id == AV_CODEC_ID_THP) {
1481 if (s->restart_count < 0) {
1482 ret = ff_mjpeg_unescape_sos(s);
1483 if (ret < 0)
1484 return ret;
1485 }
1486 restart = ff_mjpeg_should_restart(s);
1487 if (restart)
1488 align_get_bits(&s->gb);
1489 } else {
1490 ret = ff_mjpeg_handle_restart(s, &restart);
1491 if (ret < 0)
1492 return ret;
1493 }
1494 if (restart) {
1495 for (i = 0; i < nb_components; i++)
1496 s->last_dc[i] = (4 << s->bits);
1497 }
1498
1499 if (get_bits_left(&s->gb) < 0) {
1500 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1501 -get_bits_left(&s->gb));
1502 return AVERROR_INVALIDDATA;
1503 }
1504 for (i = 0; i < nb_components; i++) {
1505 uint8_t *ptr;
1506 int n, h, v, x, y, c, j;
1507 int block_offset;
1508 n = s->nb_blocks[i];
1509 c = s->comp_index[i];
1510 h = s->h_scount[i];
1511 v = s->v_scount[i];
1512 x = 0;
1513 y = 0;
1514 for (j = 0; j < n; j++) {
1515 block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1516 (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1517
1518 if (s->interlaced && s->bottom_field)
1519 block_offset += linesize[c] >> 1;
1520 if ( 8 * (h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1521 && 8 * (v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1522 ptr = data[c] + block_offset;
1523 } else
1524 ptr = NULL;
1525 if (!s->progressive) {
1526 if (copy_mb) {
1527 if (ptr)
1528 mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1529 linesize[c], s->avctx->lowres);
1530
1531 } else {
1532 s->bdsp.clear_block(s->block);
1533 if (decode_block(s, s->block, i,
1534 s->dc_index[i], s->ac_index[i],
1535 s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1536 av_log(s->avctx, AV_LOG_ERROR,
1537 "error y=%d x=%d\n", mb_y, mb_x);
1538 return AVERROR_INVALIDDATA;
1539 }
1540 if (ptr && linesize[c]) {
1541 s->idsp.idct_put(ptr, linesize[c], s->block);
1542 if (s->bits & 7)
1543 shift_output(s, ptr, linesize[c]);
1544 }
1545 }
1546 } else {
1547 int block_idx = s->block_stride[c] * (v * mb_y + y) +
1548 (h * mb_x + x);
1549 int16_t *block = s->blocks[c][block_idx];
1550 if (Ah)
1551 block[0] += get_bits1(&s->gb) *
1552 s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1553 else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1554 s->quant_matrixes[s->quant_sindex[i]],
1555 Al) < 0) {
1556 av_log(s->avctx, AV_LOG_ERROR,
1557 "error y=%d x=%d\n", mb_y, mb_x);
1558 return AVERROR_INVALIDDATA;
1559 }
1560 }
1561 ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1562 ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1563 mb_x, mb_y, x, y, c, s->bottom_field,
1564 (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1565 if (++x == h) {
1566 x = 0;
1567 y++;
1568 }
1569 }
1570 }
1571 }
1572 }
1573
1574 if (s->interlaced &&
1575 bytestream2_get_bytes_left(&s->gB) > 2 &&
1576 bytestream2_tell(&s->gB) > 2 &&
1577 bytestream2_tell(&s->gB) != field_pos &&
1578 s->gB.buffer[-2] == 0xFF &&
1579 s->gB.buffer[-1] == 0xD1) {
1580 av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1581 field_pos = bytestream2_tell(&s->gB);
1582 s->bottom_field ^= 1;
1583
1584 goto next_field;
1585 }
1586
1587 return 0;
1588}
1589
1590static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s)
1591{
1592 int Ss = s->Ss;
1593 int Se = s->Se;
1594 int Ah = s->Ah;
1595 int Al = s->Al;
1596 int mb_x, mb_y;
1597 int EOBRUN = 0;
1598 int c = s->comp_index[0];
1599 uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1600
1601 av_assert0(Ss >= 0 && Ah >= 0 && Al >= 0);
1602 if (Se < Ss || Se > 63) {
1603 av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", Ss, Se);
1604 return AVERROR_INVALIDDATA;
1605 }
1606
1607 // s->coefs_finished is a bitmask for coefficients coded
1608 // Ss and Se are parameters telling start and end coefficients
1609 s->coefs_finished[c] |= (2ULL << Se) - (1ULL << Ss);
1610
1611 s->restart_count = -1;
1612
1613 for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1614 int block_idx = mb_y * s->block_stride[c];
1615 int16_t (*block)[64] = &s->blocks[c][block_idx];
1616 uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1617 for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1618 int ret;
1619 int restart;
1620 ret = ff_mjpeg_handle_restart(s, &restart);
1621 if (ret < 0)
1622 return ret;
1623 if (restart)
1624 EOBRUN = 0;
1625
1626 if (Ah)
1627 ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1628 quant_matrix, Ss, Se, Al, &EOBRUN);
1629 else
1630 ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1631 quant_matrix, Ss, Se, Al, &EOBRUN);
1632
1633 if (ret >= 0 && get_bits_left(&s->gb) < 0)
1634 ret = AVERROR_INVALIDDATA;
1635 if (ret < 0) {
1636 av_log(s->avctx, AV_LOG_ERROR,
1637 "error y=%d x=%d\n", mb_y, mb_x);
1638 return AVERROR_INVALIDDATA;
1639 }
1640 }
1641 }
1642 return 0;
1643}
1644
1645static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
1646{
1647 int mb_x, mb_y;
1648 int c;
1649 const int bytes_per_pixel = 1 + (s->bits > 8);
1650 const int block_size = s->lossless ? 1 : 8;
1651
1652 for (c = 0; c < s->nb_components; c++) {
1653 uint8_t *data = s->picture_ptr->data[c];
1654 int linesize = s->linesize[c];
1655 int h = s->h_max / s->h_count[c];
1656 int v = s->v_max / s->v_count[c];
1657 int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1658 int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1659
1660 if (~s->coefs_finished[c])
1661 av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1662
1663 if (s->interlaced && s->bottom_field)
1664 data += linesize >> 1;
1665
1666 for (mb_y = 0; mb_y < mb_height; mb_y++) {
1667 uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1668 int block_idx = mb_y * s->block_stride[c];
1669 int16_t (*block)[64] = &s->blocks[c][block_idx];
1670 for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1671 s->idsp.idct_put(ptr, linesize, *block);
1672 if (s->bits & 7)
1673 shift_output(s, ptr, linesize);
1674 ptr += bytes_per_pixel * 8 >> s->avctx->lowres;
1675 }
1676 }
1677 }
1678}
1679
1680int ff_mjpeg_decode_sos(MJpegDecodeContext *s)
1681{
1682 int len, i, h, v;
1683 int index, id, ret;
1684 const int block_size = s->lossless ? 1 : 8;
1685
1686 if (!s->got_picture) {
1687 av_log(s->avctx, AV_LOG_WARNING,
1688 "Can not process SOS before SOF, skipping\n");
1689 return AVERROR_INVALIDDATA;
1690 }
1691
1692 ret = mjpeg_parse_len(s, &len, "sos");
1693 if (ret < 0)
1694 return ret;
1695 if (len < 1)
1696 return AVERROR_INVALIDDATA;
1697 s->nb_components_sos = bytestream2_get_byteu(&s->gB);
1698 if (s->nb_components_sos == 0 || s->nb_components_sos > MAX_COMPONENTS) {
1699 avpriv_report_missing_feature(s->avctx,
1700 "decode_sos: nb_components (%d)",
1701 s->nb_components_sos);
1702 return AVERROR_PATCHWELCOME;
1703 }
1704 if (len != 4 + 2 * s->nb_components_sos) {
1705 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: len(%d) mismatch %d components\n", len, s->nb_components_sos);
1706 return AVERROR_INVALIDDATA;
1707 }
1708 for (i = 0; i < s->nb_components_sos; i++) {
1709 id = bytestream2_get_byteu(&s->gB);
1710 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1711 /* find component index */
1712 for (index = 0; index < s->nb_components; index++)
1713 if (id == s->component_id[index])
1714 break;
1715 if (index == s->nb_components) {
1716 av_log(s->avctx, AV_LOG_ERROR,
1717 "decode_sos: index(%d) out of components\n", index);
1718 return AVERROR_INVALIDDATA;
1719 }
1720 /* Metasoft MJPEG codec has Cb and Cr swapped */
1721 if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1722 && s->nb_components_sos == 3 && s->nb_components == 3 && i)
1723 index = 3 - i;
1724
1725 s->quant_sindex[i] = s->quant_index[index];
1726 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1727 s->h_scount[i] = s->h_count[index];
1728 s->v_scount[i] = s->v_count[index];
1729
1730 s->comp_index[i] = index;
1731
1732 uint8_t b = bytestream2_get_byteu(&s->gB);
1733 s->dc_index[i] = b >> 4;
1734 s->ac_index[i] = b & 0x0F;
1735
1736 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1737 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1738 goto out_of_range;
1739 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))
1740 goto out_of_range;
1741 }
1742
1743 s->Ss = bytestream2_get_byteu(&s->gB); /* JPEG Ss / lossless JPEG predictor / JPEG-LS NEAR */
1744 s->Se = bytestream2_get_byteu(&s->gB); /* JPEG Se / JPEG-LS ILV */
1745 uint8_t b = bytestream2_get_byteu(&s->gB);
1746 s->Ah = b >> 4; /* Ah */
1747 s->Al = b & 0x0F; /* Al */
1748
1749 if (s->nb_components_sos > 1) {
1750 /* interleaved stream */
1751 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1752 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1753 } else if (!s->ls) { /* skip this for JPEG-LS */
1754 h = s->h_max / s->h_scount[0];
1755 v = s->v_max / s->v_scount[0];
1756 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1757 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1758 s->nb_blocks[0] = 1;
1759 s->h_scount[0] = 1;
1760 s->v_scount[0] = 1;
1761 }
1762
1763 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1764 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1765 s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1766 s->Ss, s->Al, s->Se, s->bits, s->mjpb_skiptosod,
1767 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), s->nb_components_sos);
1768
1769
1770 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1771 if (s->mjpb_skiptosod)
1772 bytestream2_skip(&s->gB, s->mjpb_skiptosod);
1773
1774 if (!s->progressive && !s->lossless &&
1775 s->avctx->codec_id != AV_CODEC_ID_MXPEG) {
1776 s->nb_seq_component_scans += s->nb_components_sos;
1777 if (s->nb_seq_component_scans > s->nb_components) {
1778 av_log(s->avctx, AV_LOG_ERROR,
1779 "too many scans for a sequential image\n");
1780 return AVERROR_INVALIDDATA;
1781 }
1782 }
1783
1784 if (s->avctx->hwaccel) {
1785 const uint8_t *buf_ptr;
1786 size_t buf_size;
1787
1788 mjpeg_find_raw_scan_data(s, &buf_ptr, &buf_size);
1789
1790 ret = FF_HW_CALL(s->avctx, decode_slice, buf_ptr, buf_size);
1791 if (ret < 0)
1792 return ret;
1793
1794 } else {
1795 if (s->lossless) {
1796 av_assert0(s->picture_ptr == s->picture);
1797 if (CONFIG_JPEGLS_DECODER && s->ls) {
1798 if ((ret = ff_jpegls_decode_picture(s)) < 0)
1799 return ret;
1800 } else {
1801 if (s->rgb || s->bayer) {
1802 if ((ret = ljpeg_decode_rgb_scan(s)) < 0)
1803 return ret;
1804 } else {
1805 if ((ret = ljpeg_decode_yuv_scan(s)) < 0)
1806 return ret;
1807 }
1808 }
1809 } else {
1810 if (s->progressive && s->Ss) {
1811 av_assert0(s->picture_ptr == s->picture);
1812 if ((ret = mjpeg_decode_scan_progressive_ac(s)) < 0)
1813 return ret;
1814 } else {
1815 if ((ret = mjpeg_decode_scan(s)) < 0)
1816 return ret;
1817 }
1818 }
1819 }
1820
1821 if (s->avctx->codec_id == AV_CODEC_ID_MEDIA100 ||
1822 s->avctx->codec_id == AV_CODEC_ID_MJPEGB ||
1823 s->avctx->codec_id == AV_CODEC_ID_THP) {
1824 /* Add the amount of bits read from the unescaped image data buffer
1825 * into the GetByteContext. */
1826 bytestream2_skipu(&s->gB, (get_bits_count(&s->gb) + 7) / 8);
1827 }
1828
1829 return 0;
1830 out_of_range:
1831 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1832 return AVERROR_INVALIDDATA;
1833}
1834
1835static int mjpeg_decode_dri(MJpegDecodeContext *s)
1836{
1837 if (bytestream2_get_be16u(&s->gB) != 4)
1838 return AVERROR_INVALIDDATA;
1839 s->restart_interval = bytestream2_get_be16u(&s->gB);
1840 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1841 s->restart_interval);
1842
1843 return 0;
1844}
1845
1846static int mjpeg_decode_app(MJpegDecodeContext *s, int start_code)
1847{
1848 int len, id, i;
1849
1850 int ret = mjpeg_parse_len(s, &len, "app");
1851 if (ret < 0)
1852 return AVERROR_INVALIDDATA;
1853
1854 if (len < 4) {
1855 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1856 return AVERROR_INVALIDDATA;
1857 av_log(s->avctx, AV_LOG_VERBOSE, "skipping APPx stub (len=%" PRId32 ")\n", len);
1858 goto out;
1859 }
1860
1861 id = bytestream2_get_be32u(&s->gB);
1862 len -= 4;
1863
1864 if (s->avctx->debug & FF_DEBUG_STARTCODE)
1865 av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1866 av_fourcc2str(av_bswap32(id)), id, len);
1867
1868 /* This fourcc is used by non-avid files too, it holds some
1869 information, but it's always present in AVID-created files. */
1870 if (id == AV_RB32("AVI1")) {
1871 /* structure:
1872 4bytes AVI1
1873 1bytes polarity
1874 1bytes always zero
1875 4bytes field_size
1876 4bytes field_size_less_padding
1877 */
1878 if (len < 1)
1879 goto out;
1880 i = bytestream2_get_byteu(&s->gB); len--;
1881 av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1882 goto out;
1883 }
1884
1885 if (id == AV_RB32("JFIF")) {
1886 int t_w, t_h, v1, v2;
1887 if (len < 8)
1888 goto out;
1889 bytestream2_skipu(&s->gB, 1); /* the trailing zero-byte */
1890 v1 = bytestream2_get_byteu(&s->gB);
1891 v2 = bytestream2_get_byteu(&s->gB);
1892 bytestream2_skipu(&s->gB, 1);
1893
1894 s->avctx->sample_aspect_ratio.num = bytestream2_get_be16u(&s->gB);
1895 s->avctx->sample_aspect_ratio.den = bytestream2_get_be16u(&s->gB);
1896 if ( s->avctx->sample_aspect_ratio.num <= 0
1897 || s->avctx->sample_aspect_ratio.den <= 0) {
1898 s->avctx->sample_aspect_ratio.num = 0;
1899 s->avctx->sample_aspect_ratio.den = 1;
1900 }
1901
1902 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1903 av_log(s->avctx, AV_LOG_INFO,
1904 "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1905 v1, v2,
1906 s->avctx->sample_aspect_ratio.num,
1907 s->avctx->sample_aspect_ratio.den);
1908
1909 len -= 8;
1910 if (len >= 2) {
1911 t_w = bytestream2_get_byteu(&s->gB);
1912 t_h = bytestream2_get_byteu(&s->gB);
1913 if (t_w && t_h) {
1914 /* skip thumbnail */
1915 if (len - 10 - (t_w * t_h * 3) > 0)
1916 len -= t_w * t_h * 3;
1917 }
1918 len -= 2;
1919 }
1920 goto out;
1921 }
1922
1923 if ( id == AV_RB32("Adob")
1924 && len >= 8
1925 && bytestream2_peek_byteu(&s->gB) == 'e'
1926 && bytestream2_peek_be32u(&s->gB) != AV_RB32("e_CM")) {
1927 bytestream2_skipu(&s->gB, 1); /* 'e' */
1928 bytestream2_skipu(&s->gB, 2); /* version */
1929 bytestream2_skipu(&s->gB, 2); /* flags0 */
1930 bytestream2_skipu(&s->gB, 2); /* flags1 */
1931 s->adobe_transform = bytestream2_get_byteu(&s->gB);
1932 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1933 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1934 len -= 8;
1935 goto out;
1936 }
1937
1938 if (id == AV_RB32("LJIF")) {
1939 int rgb = s->rgb;
1940 int pegasus_rct = s->pegasus_rct;
1941 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1942 av_log(s->avctx, AV_LOG_INFO,
1943 "Pegasus lossless jpeg header found\n");
1944 if (len < 9)
1945 goto out;
1946 bytestream2_skipu(&s->gB, 2); /* version ? */
1947 bytestream2_skipu(&s->gB, 2); /* unknown always 0? */
1948 bytestream2_skipu(&s->gB, 2); /* unknown always 0? */
1949 bytestream2_skipu(&s->gB, 2); /* unknown always 0? */
1950 switch (i = bytestream2_get_byteu(&s->gB)) {
1951 case 1:
1952 rgb = 1;
1953 pegasus_rct = 0;
1954 break;
1955 case 2:
1956 rgb = 1;
1957 pegasus_rct = 1;
1958 break;
1959 default:
1960 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1961 }
1962
1963 len -= 9;
1964 if (s->bayer)
1965 goto out;
1966 if (s->got_picture)
1967 if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1968 av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1969 goto out;
1970 }
1971
1972 s->rgb = rgb;
1973 s->pegasus_rct = pegasus_rct;
1974
1975 goto out;
1976 }
1977 if (id == AV_RL32("colr") && len > 0) {
1978 s->colr = bytestream2_get_byteu(&s->gB);
1979 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1980 av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1981 len--;
1982 goto out;
1983 }
1984 if (id == AV_RL32("xfrm") && len > 0) {
1985 s->xfrm = bytestream2_get_byteu(&s->gB);
1986 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1987 av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1988 len--;
1989 goto out;
1990 }
1991
1992 /* JPS extension by VRex */
1993 if (start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1994 int flags, layout, type;
1995 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1996 av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1997
1998 bytestream2_skipu(&s->gB, 4); len -= 4; /* JPS_ */
1999 bytestream2_skipu(&s->gB, 2); len -= 2; /* block length */
2000 bytestream2_skipu(&s->gB, 1); /* reserved */
2001 flags = bytestream2_get_byteu(&s->gB);
2002 layout = bytestream2_get_byteu(&s->gB);
2003 type = bytestream2_get_byteu(&s->gB);
2004 len -= 4;
2005
2006 av_freep(&s->stereo3d);
2007 s->stereo3d = av_stereo3d_alloc();
2008 if (!s->stereo3d) {
2009 goto out;
2010 }
2011 if (type == 0) {
2012 s->stereo3d->type = AV_STEREO3D_2D;
2013 } else if (type == 1) {
2014 switch (layout) {
2015 case 0x01:
2016 s->stereo3d->type = AV_STEREO3D_LINES;
2017 break;
2018 case 0x02:
2019 s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
2020 break;
2021 case 0x03:
2022 s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
2023 break;
2024 }
2025 if (!(flags & 0x04)) {
2026 s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
2027 }
2028 }
2029 goto out;
2030 }
2031
2032 /* EXIF metadata */
2033 if (start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2034 int ret;
2035
2036 bytestream2_skipu(&s->gB, 2); // skip padding
2037 len -= 2;
2038
2039 if (s->exif_metadata.entries) {
2040 av_log(s->avctx, AV_LOG_WARNING, "multiple EXIF\n");
2041 goto out;
2042 }
2043
2044 ret = av_exif_parse_buffer(s->avctx, s->gB.buffer, len, &s->exif_metadata, AV_EXIF_TIFF_HEADER);
2045 if (ret < 0) {
2046 av_log(s->avctx, AV_LOG_WARNING, "unable to parse EXIF buffer\n");
2047 goto out;
2048 }
2049
2050 bytestream2_skipu(&s->gB, ret);
2051 len -= ret;
2052
2053 goto out;
2054 }
2055
2056 /* Apple MJPEG-A */
2057 if ((start_code == APP1) && (len > (0x28 - 8))) {
2058 id = bytestream2_get_be32u(&s->gB);
2059 len -= 4;
2060 /* Apple MJPEG-A */
2061 if (id == AV_RB32("mjpg")) {
2062 /* structure:
2063 4bytes field size
2064 4bytes pad field size
2065 4bytes next off
2066 4bytes quant off
2067 4bytes huff off
2068 4bytes image off
2069 4bytes scan off
2070 4bytes data off
2071 */
2072 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2073 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2074 }
2075 }
2076
2077 if (start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2078 int id2;
2079 unsigned seqno;
2080 unsigned nummarkers;
2081
2082 id = bytestream2_get_be32u(&s->gB);
2083 id2 = bytestream2_get_be24u(&s->gB);
2084 len -= 7;
2085 if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2086 av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2087 goto out;
2088 }
2089
2090 bytestream2_skipu(&s->gB, 1);
2091 seqno = bytestream2_get_byteu(&s->gB);
2092 len -= 2;
2093 if (seqno == 0) {
2094 av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2095 goto out;
2096 }
2097
2098 nummarkers = bytestream2_get_byteu(&s->gB);
2099 len -= 1;
2100 if (nummarkers == 0) {
2101 av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2102 goto out;
2103 } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2104 av_log(s->avctx, AV_LOG_WARNING, "Mismatch in coded number of ICC markers between markers\n");
2105 goto out;
2106 } else if (seqno > nummarkers) {
2107 av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2108 goto out;
2109 }
2110
2111 /* Allocate if this is the first APP2 we've seen. */
2112 if (s->iccnum == 0) {
2113 if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2114 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2115 return AVERROR(ENOMEM);
2116 }
2117 s->iccnum = nummarkers;
2118 }
2119
2120 if (s->iccentries[seqno - 1].data) {
2121 av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2122 goto out;
2123 }
2124
2125 s->iccentries[seqno - 1].length = len;
2126 s->iccentries[seqno - 1].data = av_malloc(len);
2127 if (!s->iccentries[seqno - 1].data) {
2128 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2129 return AVERROR(ENOMEM);
2130 }
2131
2132 bytestream2_get_bufferu(&s->gB, s->iccentries[seqno - 1].data, len);
2133 len = 0;
2134 s->iccread++;
2135
2136 if (s->iccread > s->iccnum)
2137 av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2138 }
2139
2140out:
2141 /* slow but needed for extreme adobe jpegs */
2142 if (len < 0)
2143 av_log(s->avctx, AV_LOG_ERROR,
2144 "mjpeg: error, decode_app parser read over the end\n");
2145 if (len > 0)
2146 bytestream2_skipu(&s->gB, len);
2147
2148 return 0;
2149}
2150
2151static int mjpeg_decode_com(MJpegDecodeContext *s)
2152{
2153 int len;
2154 int ret = mjpeg_parse_len(s, &len, "com");
2155 if (ret < 0)
2156 return ret;
2157 if (!len)
2158 return 0;
2159
2160 int i;
2161 char *cbuf = av_malloc(len + 1);
2162 if (!cbuf)
2163 return AVERROR(ENOMEM);
2164
2165 for (i = 0; i < len; i++)
2166 cbuf[i] = bytestream2_get_byteu(&s->gB);
2167 if (cbuf[i - 1] == '\n')
2168 cbuf[i - 1] = 0;
2169 else
2170 cbuf[i] = 0;
2171
2172 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2173 av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2174
2175 /* buggy avid, it puts EOI only at every 10th frame */
2176 if (!strncmp(cbuf, "AVID", 4)) {
2177 parse_avid(s, cbuf, len);
2178 } else if (!strcmp(cbuf, "CS=ITU601"))
2179 s->cs_itu601 = 1;
2180 else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2181 (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2182 s->flipped = 1;
2183 else if (!strcmp(cbuf, "MULTISCOPE II")) {
2184 s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2185 s->multiscope = 2;
2186 }
2187
2188 av_free(cbuf);
2189
2190 return 0;
2191}
2192
2193/* return the 8 bit start code value and update the search
2194 state. Return -1 if no start code found */
2195int ff_mjpeg_find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2196{
2197 const uint8_t *buf_ptr;
2198 int val;
2199
2200 buf_ptr = *pbuf_ptr;
2201 while ((buf_ptr = memchr(buf_ptr, 0xff, buf_end - buf_ptr))) {
2202 buf_ptr++;
2203 while (buf_ptr < buf_end) {
2204 val = *buf_ptr++;
2205 if (val != 0xff) {
2206 if ((val >= SOF0) && (val <= COM))
2207 goto found;
2208 break;
2209 }
2210 }
2211 }
2212 buf_ptr = buf_end;
2213 val = -1;
2214found:
2215 ff_dlog(NULL, "find_marker skipped %td bytes\n",
2216 (buf_ptr - *pbuf_ptr) - (val < 0 ? 0 : 2));
2217 *pbuf_ptr = buf_ptr;
2218 return val;
2219}
2220
2221static void mjpeg_find_raw_scan_data(MJpegDecodeContext *s,
2222 const uint8_t **pbuf_ptr, size_t *pbuf_size)
2223{
2224 const uint8_t *buf_ptr = s->gB.buffer;
2225 const uint8_t *buf_end = buf_ptr + bytestream2_get_bytes_left(&s->gB);
2226
2227 /* Find size of image data buffer (including restart markers).
2228 * No unescaping is performed. */
2229 const uint8_t *ptr = buf_ptr;
2230 while ((ptr = memchr(ptr, 0xff, buf_end - ptr))) {
2231 ptr++;
2232 if (ptr < buf_end) {
2233 uint8_t x = *ptr++;
2234 /* Discard multiple optional 0xFF fill bytes. */
2235 while (x == 0xff && ptr < buf_end)
2236 x = *ptr++;
2237 if (x && (x < RST0 || x > RST7)) {
2238 /* Non-restart marker */
2239 ptr -= 2;
2240 goto found_hw;
2241 }
2242 }
2243 }
2244 ptr = buf_end;
2245found_hw:
2246 *pbuf_ptr = buf_ptr;
2247 *pbuf_size = ptr - buf_ptr;
2248 bytestream2_skipu(&s->gB, *pbuf_size);
2249}
2250
2251int ff_mjpeg_unescape_sos(MJpegDecodeContext *s)
2252{
2253 const uint8_t *buf_ptr = s->gB.buffer;
2254 const uint8_t *buf_end = buf_ptr + bytestream2_get_bytes_left(&s->gB);
2255 const uint8_t *unescaped_buf_ptr;
2256 size_t unescaped_buf_size;
2257
2258 if (s->avctx->codec_id == AV_CODEC_ID_MEDIA100 ||
2259 s->avctx->codec_id == AV_CODEC_ID_MJPEGB ||
2260 s->avctx->codec_id == AV_CODEC_ID_THP) {
2261 /* The image data buffer is already unescaped. The only way to
2262 * find the size of the buffer is by fully decoding it. */
2263 unescaped_buf_ptr = buf_ptr;
2264 unescaped_buf_size = buf_end - buf_ptr;
2265 goto the_end;
2266 }
2267
2268 av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - buf_ptr);
2269 if (!s->buffer)
2270 return AVERROR(ENOMEM);
2271
2272 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2273 if (!s->ls) {
2274 const uint8_t *src = buf_ptr;
2275 const uint8_t *ptr = src;
2276 uint8_t *dst = s->buffer;
2277 PutByteContext pb;
2278
2279 bytestream2_init_writer(&pb, dst, buf_end - src);
2280
2281 while ((ptr = memchr(ptr, 0xff, buf_end - ptr))) {
2282 ptr++;
2283 if (ptr < buf_end) {
2284 /* Copy verbatim data. */
2285 ptrdiff_t length = (ptr - 1) - src;
2286 if (length > 0)
2287 bytestream2_put_bufferu(&pb, src, length);
2288
2289 uint8_t x = *ptr++;
2290 /* Discard multiple optional 0xFF fill bytes. */
2291 while (x == 0xff && ptr < buf_end)
2292 x = *ptr++;
2293
2294 src = ptr;
2295 if (x == 0) {
2296 /* Stuffed zero byte */
2297 bytestream2_put_byteu(&pb, 0xff);
2298 } else if (x >= RST0 && x <= RST7) {
2299 /* Restart marker */
2300 goto found;
2301 } else {
2302 /* Non-restart marker */
2303 ptr -= 2;
2304 goto found;
2305 }
2306 }
2307 }
2308 /* Copy remaining verbatim data. */
2309 ptr = buf_end;
2310 ptrdiff_t length = ptr - src;
2311 if (length > 0)
2312 bytestream2_put_bufferu(&pb, src, length);
2313
2314found:
2315 unescaped_buf_ptr = s->buffer;
2316 unescaped_buf_size = bytestream2_tell_p(&pb);
2317 memset(s->buffer + unescaped_buf_size, 0,
2318 AV_INPUT_BUFFER_PADDING_SIZE);
2319
2320 bytestream2_skipu(&s->gB, ptr - buf_ptr);
2321
2322 av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
2323 (buf_end - buf_ptr) - (unescaped_buf_size));
2324 } else {
2325 const uint8_t *src = buf_ptr;
2326 const uint8_t *ptr = src;
2327 uint8_t *dst = s->buffer;
2328 PutBitContext pb;
2329
2330 init_put_bits(&pb, dst, buf_end - src);
2331
2332 while ((ptr = memchr(ptr, 0xff, buf_end - ptr))) {
2333 ptr++;
2334 if (ptr < buf_end) {
2335 /* Copy verbatim data. */
2336 ptrdiff_t length = (ptr - 1) - src;
2337 if (length > 0)
2338 ff_copy_bits(&pb, src, length * 8);
2339
2340 uint8_t x = *ptr++;
2341 /* Discard multiple optional 0xFF fill bytes. */
2342 while (x == 0xff && ptr < buf_end)
2343 x = *ptr++;
2344
2345 src = ptr;
2346 if (!(x & 0x80)) {
2347 /* Stuffed zero bit */
2348 put_bits(&pb, 15, 0x7f80 | x);
2349 } else if (x >= RST0 && x <= RST7) {
2350 /* Restart marker */
2351 goto found_ls;
2352 } else {
2353 /* Non-restart marker */
2354 ptr -= 2;
2355 goto found_ls;
2356 }
2357 }
2358 }
2359 /* Copy remaining verbatim data. */
2360 ptr = buf_end;
2361 ptrdiff_t length = ptr - src;
2362 if (length > 0)
2363 ff_copy_bits(&pb, src, length * 8);
2364
2365found_ls:
2366 flush_put_bits(&pb);
2367
2368 unescaped_buf_ptr = dst;
2369 unescaped_buf_size = put_bytes_output(&pb);
2370 memset(s->buffer + unescaped_buf_size, 0,
2371 AV_INPUT_BUFFER_PADDING_SIZE);
2372
2373 bytestream2_skipu(&s->gB, ptr - buf_ptr);
2374 }
2375
2376the_end:
2377 return init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2378}
2379
2380static void reset_icc_profile(MJpegDecodeContext *s)
2381{
2382 int i;
2383
2384 if (s->iccentries) {
2385 for (i = 0; i < s->iccnum; i++)
2386 av_freep(&s->iccentries[i].data);
2387 av_freep(&s->iccentries);
2388 }
2389
2390 s->iccread = 0;
2391 s->iccnum = 0;
2392}
2393
2394int ff_mjpeg_decode_frame_from_buf(AVCodecContext *avctx, AVFrame *frame,
2395 int *got_frame, const AVPacket *avpkt,
2396 const uint8_t *buf, const int buf_size)
2397{
2398 MJpegDecodeContext *s = avctx->priv_data;
2399 const uint8_t *buf_end, *buf_ptr;
2400 int hshift, vshift;
2401 int start_code;
2402 int index;
2403 int ret = 0;
2404 int is16bit;
2405
2406 s->force_pal8 = 0;
2407 s->total_ls_decoded_height = 0;
2408
2409 s->buf_size = buf_size;
2410
2411 av_exif_free(&s->exif_metadata);
2412 av_freep(&s->stereo3d);
2413 s->adobe_transform = -1;
2414
2415 if (s->iccnum != 0)
2416 reset_icc_profile(s);
2417
2418redo_for_pal8:
2419 buf_ptr = buf;
2420 buf_end = buf + buf_size;
2421 while (buf_ptr < buf_end) {
2422 /* find start next marker */
2423 start_code = ff_mjpeg_find_marker(&buf_ptr, buf_end);
2424 /* EOF */
2425 if (start_code < 0)
2426 break;
2427
2428 ptrdiff_t bytes_left = buf_end - buf_ptr;
2429 if (bytes_left > INT_MAX / 8) {
2430 av_log(avctx, AV_LOG_ERROR,
2431 "MJPEG packet 0x%x too big (%td/%d), corrupt data?\n",
2432 start_code, bytes_left, buf_size);
2433 return AVERROR_INVALIDDATA;
2434 }
2435 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
2436 start_code, buf_end - buf_ptr);
2437
2438 bytestream2_init(&s->gB, buf_ptr, bytes_left);
2439
2440 if (avctx->debug & FF_DEBUG_STARTCODE)
2441 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2442
2443 /* process markers */
2444 if (start_code >= RST0 && start_code <= RST7) {
2445 av_log(avctx, AV_LOG_DEBUG,
2446 "restart marker: %d\n", start_code & 0x0f);
2447 /* APP fields */
2448 } else if (start_code >= APP0 && start_code <= APP15) {
2449 if ((ret = mjpeg_decode_app(s, start_code)) < 0)
2450 av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2451 av_err2str(ret));
2452 /* Comment */
2453 } else if (start_code == COM) {
2454 ret = mjpeg_decode_com(s);
2455 if (ret < 0)
2456 return ret;
2457 } else if (start_code == DQT) {
2458 ret = ff_mjpeg_decode_dqt(s);
2459 if (ret < 0)
2460 return ret;
2461 }
2462
2463 ret = -1;
2464
2465 if (!CONFIG_JPEGLS_DECODER &&
2466 (start_code == SOF55 || start_code == LSE)) {
2467 av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2468 return AVERROR(ENOSYS);
2469 }
2470
2471 if (avctx->skip_frame == AVDISCARD_ALL) {
2472 switch (start_code) {
2473 case SOF0:
2474 case SOF1:
2475 case SOF2:
2476 case SOF3:
2477 case SOF55:
2478 break;
2479 default:
2480 goto skip;
2481 }
2482 }
2483
2484 switch (start_code) {
2485 case SOI:
2486 s->restart_interval = 0;
2487 s->raw_image_buffer = buf_ptr;
2488 s->raw_image_buffer_size = buf_end - buf_ptr;
2489 /* nothing to do on SOI */
2490 break;
2491 case DHT:
2492 if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2493 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2494 goto fail;
2495 }
2496 break;
2497 case SOF0:
2498 case SOF1:
2499 if (start_code == SOF0)
2500 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2501 else
2502 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
2503 s->lossless = 0;
2504 s->ls = 0;
2505 s->progressive = 0;
2506 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2507 goto fail;
2508 break;
2509 case SOF2:
2510 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2511 s->lossless = 0;
2512 s->ls = 0;
2513 s->progressive = 1;
2514 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2515 goto fail;
2516 break;
2517 case SOF3:
2518 avctx->profile = AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2519 s->lossless = 1;
2520 s->ls = 0;
2521 s->progressive = 0;
2522 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2523 goto fail;
2524 break;
2525 case SOF55:
2526 avctx->profile = AV_PROFILE_MJPEG_JPEG_LS;
2527 s->lossless = 1;
2528 s->ls = 1;
2529 s->progressive = 0;
2530 if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2531 goto fail;
2532 break;
2533 case LSE:
2534 if (!CONFIG_JPEGLS_DECODER ||
2535 (ret = ff_jpegls_decode_lse(s)) < 0)
2536 goto fail;
2537 if (ret == 1)
2538 goto redo_for_pal8;
2539 break;
2540 case EOI:
2541eoi_parser:
2542 if (!avctx->hwaccel &&
2543 s->progressive && s->cur_scan && s->got_picture)
2544 mjpeg_idct_scan_progressive_ac(s);
2545 s->cur_scan = 0;
2546 if (!s->got_picture) {
2547 av_log(avctx, AV_LOG_WARNING,
2548 "Found EOI before any SOF, ignoring\n");
2549 break;
2550 }
2551 if (s->interlaced) {
2552 s->bottom_field ^= 1;
2553 /* if not bottom field, do not output image yet */
2554 if (s->bottom_field == !s->interlace_polarity)
2555 break;
2556 }
2557 if (avctx->hwaccel) {
2558 ret = FF_HW_SIMPLE_CALL(avctx, end_frame);
2559 if (ret < 0)
2560 return ret;
2561
2562 av_freep(&s->hwaccel_picture_private);
2563 }
2564 if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2565 return ret;
2566 if (s->lossless)
2567 frame->flags |= AV_FRAME_FLAG_LOSSLESS;
2568 *got_frame = 1;
2569 s->got_picture = 0;
2570
2571 if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2572 int qp = FFMAX3(s->qscale[0],
2573 s->qscale[1],
2574 s->qscale[2]);
2575
2576 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2577 }
2578
2579 goto the_end;
2580 case SOS:
2581 s->cur_scan++;
2582
2583 if ((ret = ff_mjpeg_decode_sos(s)) < 0 &&
2584 (avctx->err_recognition & AV_EF_EXPLODE))
2585 goto fail;
2586 break;
2587 case DRI:
2588 if ((ret = mjpeg_decode_dri(s)) < 0)
2589 return ret;
2590 break;
2591 case SOF5:
2592 case SOF6:
2593 case SOF7:
2594 case SOF9:
2595 case SOF10:
2596 case SOF11:
2597 case SOF13:
2598 case SOF14:
2599 case SOF15:
2600 case JPG:
2601 av_log(avctx, AV_LOG_ERROR,
2602 "mjpeg: unsupported coding type (%x)\n", start_code);
2603 break;
2604 }
2605
2606 if (avctx->skip_frame == AVDISCARD_ALL) {
2607 switch (start_code) {
2608 case SOF0:
2609 case SOF1:
2610 case SOF2:
2611 case SOF3:
2612 case SOF55:
2613 s->got_picture = 0;
2614 goto the_end_no_picture;
2615 }
2616 }
2617
2618skip:
2619 /* eof process start code */
2620 buf_ptr += bytestream2_tell(&s->gB);
2621 av_log(avctx, AV_LOG_DEBUG,
2622 "marker parser used %d bytes\n",
2623 bytestream2_tell(&s->gB));
2624 }
2625 if (s->got_picture && s->cur_scan) {
2626 av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2627 goto eoi_parser;
2628 }
2629 av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2630 return AVERROR_INVALIDDATA;
2631fail:
2632 s->got_picture = 0;
2633 return ret;
2634the_end:
2635
2636 is16bit = av_pix_fmt_desc_get(avctx->pix_fmt)->comp[0].step > 1;
2637
2638 if (AV_RB32(s->upscale_h)) {
2639 int p;
2640 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2641 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2642 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2643 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2644 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2645 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2646 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2647 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2648 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2649 avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2650 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2651 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2652 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2653 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2654 );
2655 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2656 if (ret)
2657 return ret;
2658
2659 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2660 for (p = 0; p < s->nb_components; p++) {
2661 uint8_t *line = s->picture_ptr->data[p];
2662 int w = s->width;
2663 int h = s->height;
2664 if (!s->upscale_h[p])
2665 continue;
2666 if (p == 1 || p == 2) {
2667 w = AV_CEIL_RSHIFT(w, hshift);
2668 h = AV_CEIL_RSHIFT(h, vshift);
2669 }
2670 if (s->upscale_v[p] == 1)
2671 h = (h + 1) >> 1;
2672 av_assert0(w > 0);
2673 for (int i = 0; i < h; i++) {
2674 if (s->upscale_h[p] == 1) {
2675 if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2676 else line[w - 1] = line[(w - 1) / 2];
2677 for (index = w - 2; index > 0; index--) {
2678 if (is16bit)
2679 ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2680 else
2681 line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2682 }
2683 } else if (s->upscale_h[p] == 2) {
2684 if (is16bit) {
2685 ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2686 if (w > 1)
2687 ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2688 } else {
2689 line[w - 1] = line[(w - 1) / 3];
2690 if (w > 1)
2691 line[w - 2] = line[w - 1];
2692 }
2693 for (index = w - 3; index > 0; index--) {
2694 line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2695 }
2696 } else if (s->upscale_h[p] == 4) {
2697 if (is16bit) {
2698 uint16_t *line16 = (uint16_t *) line;
2699 line16[w - 1] = line16[(w - 1) >> 2];
2700 if (w > 1)
2701 line16[w - 2] = (line16[(w - 1) >> 2] * 3 + line16[(w - 2) >> 2]) >> 2;
2702 if (w > 2)
2703 line16[w - 3] = (line16[(w - 1) >> 2] + line16[(w - 2) >> 2]) >> 1;
2704 } else {
2705 line[w - 1] = line[(w - 1) >> 2];
2706 if (w > 1)
2707 line[w - 2] = (line[(w - 1) >> 2] * 3 + line[(w - 2) >> 2]) >> 2;
2708 if (w > 2)
2709 line[w - 3] = (line[(w - 1) >> 2] + line[(w - 2) >> 2]) >> 1;
2710 }
2711 for (index = w - 4; index > 0; index--)
2712 line[index] = (line[(index + 3) >> 2] + line[(index + 2) >> 2]
2713 + line[(index + 1) >> 2] + line[index >> 2]) >> 2;
2714 }
2715 line += s->linesize[p];
2716 }
2717 }
2718 }
2719 if (AV_RB32(s->upscale_v)) {
2720 int p;
2721 av_assert0(avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
2722 avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2723 avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2724 avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2725 avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2726 avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2727 avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2728 avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2729 avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2730 avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2731 avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2732 avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2733 avctx->pix_fmt == AV_PIX_FMT_GBRAP
2734 );
2735 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2736 if (ret)
2737 return ret;
2738
2739 av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2740 for (p = 0; p < s->nb_components; p++) {
2741 uint8_t *dst;
2742 int w = s->width;
2743 int h = s->height;
2744 if (!s->upscale_v[p])
2745 continue;
2746 if (p == 1 || p == 2) {
2747 w = AV_CEIL_RSHIFT(w, hshift);
2748 h = AV_CEIL_RSHIFT(h, vshift);
2749 }
2750 dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2751 for (int i = h - 1; i; i--) {
2752 uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2753 uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2754 if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2755 memcpy(dst, src1, w);
2756 } else {
2757 for (index = 0; index < w; index++)
2758 dst[index] = (src1[index] + src2[index]) >> 1;
2759 }
2760 dst -= s->linesize[p];
2761 }
2762 }
2763 }
2764 if (s->flipped && !s->rgb && !s->bayer) {
2765 ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &hshift, &vshift);
2766 if (ret)
2767 return ret;
2768
2769 av_assert0(s->nb_components == av_pix_fmt_count_planes(frame->format));
2770 for (index = 0; index < s->nb_components; index++) {
2771 int h = frame->height;
2772 if (index && index < 3)
2773 h = AV_CEIL_RSHIFT(h, vshift);
2774 if (frame->data[index]) {
2775 frame->data[index] += (h - 1) * frame->linesize[index];
2776 frame->linesize[index] *= -1;
2777 }
2778 }
2779 }
2780
2781 if (avctx->pix_fmt == AV_PIX_FMT_GBRP) {
2782 av_assert0(s->nb_components == 3);
2783 FFSWAP(uint8_t *, frame->data[0], frame->data[2]);
2784 FFSWAP(uint8_t *, frame->data[0], frame->data[1]);
2785 FFSWAP(int, frame->linesize[0], frame->linesize[2]);
2786 FFSWAP(int, frame->linesize[0], frame->linesize[1]);
2787 }
2788
2789 if (s->adobe_transform == 0 && avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2790 int w = s->picture_ptr->width;
2791 int h = s->picture_ptr->height;
2792 av_assert0(s->nb_components == 4);
2793 for (int i = 0; i < h; i++) {
2794 int j;
2795 uint8_t *dst[4];
2796 for (index = 0; index < 4; index++) {
2797 dst[index] = s->picture_ptr->data[index]
2798 + s->picture_ptr->linesize[index]*i;
2799 }
2800 for (j = 0; j < w; j++) {
2801 int k = dst[3][j];
2802 int r = dst[0][j] * k;
2803 int g = dst[1][j] * k;
2804 int b = dst[2][j] * k;
2805 dst[0][j] = g * 257 >> 16;
2806 dst[1][j] = b * 257 >> 16;
2807 dst[2][j] = r * 257 >> 16;
2808 }
2809 memset(dst[3], 255, w);
2810 }
2811 }
2812 if (s->adobe_transform == 2 && avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2813 int w = s->picture_ptr->width;
2814 int h = s->picture_ptr->height;
2815 av_assert0(s->nb_components == 4);
2816 for (int i = 0; i < h; i++) {
2817 int j;
2818 uint8_t *dst[4];
2819 for (index = 0; index < 4; index++) {
2820 dst[index] = s->picture_ptr->data[index]
2821 + s->picture_ptr->linesize[index]*i;
2822 }
2823 for (j = 0; j < w; j++) {
2824 int k = dst[3][j];
2825 int r = (255 - dst[0][j]) * k;
2826 int g = (128 - dst[1][j]) * k;
2827 int b = (128 - dst[2][j]) * k;
2828 dst[0][j] = r * 257 >> 16;
2829 dst[1][j] = (g * 257 >> 16) + 128;
2830 dst[2][j] = (b * 257 >> 16) + 128;
2831 }
2832 memset(dst[3], 255, w);
2833 }
2834 }
2835
2836 if (s->stereo3d) {
2837 AVStereo3D *stereo = av_stereo3d_create_side_data(frame);
2838 if (stereo) {
2839 stereo->type = s->stereo3d->type;
2840 stereo->flags = s->stereo3d->flags;
2841 }
2842 av_freep(&s->stereo3d);
2843 }
2844
2845 if (s->iccnum != 0 && s->iccnum == s->iccread) {
2846 AVFrameSideData *sd;
2847 size_t offset = 0;
2848 int total_size = 0;
2849
2850 /* Sum size of all parts. */
2851 for (int i = 0; i < s->iccnum; i++)
2852 total_size += s->iccentries[i].length;
2853
2854 ret = ff_frame_new_side_data(avctx, frame, AV_FRAME_DATA_ICC_PROFILE, total_size, &sd);
2855 if (ret < 0) {
2856 av_log(avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2857 return ret;
2858 }
2859
2860 if (sd) {
2861 /* Reassemble the parts, which are now in-order. */
2862 for (int i = 0; i < s->iccnum; i++) {
2863 memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2864 offset += s->iccentries[i].length;
2865 }
2866 }
2867 }
2868
2869 if (s->exif_metadata.entries) {
2870 ret = ff_decode_exif_attach_ifd(avctx, frame, &s->exif_metadata);
2871 av_exif_free(&s->exif_metadata);
2872 if (ret < 0)
2873 av_log(avctx, AV_LOG_WARNING, "couldn't attach EXIF metadata\n");
2874 }
2875
2876 if (avctx->codec_id != AV_CODEC_ID_SMVJPEG &&
2877 (avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2878 avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2879 avctx->coded_height > s->orig_height) {
2880 frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2881 frame->crop_top = frame->height - avctx->height;
2882 }
2883
2884the_end_no_picture:
2885 av_log(avctx, AV_LOG_DEBUG, "decode frame unused %td bytes\n",
2886 buf_end - buf_ptr);
2887 return buf_ptr - buf;
2888}
2889
2890int ff_mjpeg_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame,
2891 AVPacket *avpkt)
2892{
2893 return ff_mjpeg_decode_frame_from_buf(avctx, frame, got_frame,
2894 avpkt, avpkt->data, avpkt->size);
2895}
2896
2897
2898/* mxpeg may call the following function (with a blank MJpegDecodeContext)
2899 * even without having called ff_mjpeg_decode_init(). */
2900av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
2901{
2902 MJpegDecodeContext *s = avctx->priv_data;
2903 int i, j;
2904
2905 if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_num) {
2906 av_log(avctx, AV_LOG_INFO, "Single field\n");
2907 }
2908
2909 av_frame_free(&s->picture);
2910 s->picture_ptr = NULL;
2911
2912 av_frame_free(&s->smv_frame);
2913
2914 av_freep(&s->buffer);
2915 av_freep(&s->stereo3d);
2916 av_freep(&s->ljpeg_buffer);
2917 s->ljpeg_buffer_size = 0;
2918
2919 for (i = 0; i < 3; i++) {
2920 for (j = 0; j < 4; j++)
2921 ff_vlc_free(&s->vlcs[i][j]);
2922 }
2923 for (i = 0; i < MAX_COMPONENTS; i++) {
2924 av_freep(&s->blocks[i]);
2925 av_freep(&s->last_nnz[i]);
2926 }
2927 av_exif_free(&s->exif_metadata);
2928
2929 reset_icc_profile(s);
2930
2931 av_freep(&s->hwaccel_picture_private);
2932 av_freep(&s->jls_state);
2933
2934 return 0;
2935}
2936
2937static av_cold void decode_flush(AVCodecContext *avctx)
2938{
2939 MJpegDecodeContext *s = avctx->priv_data;
2940 s->got_picture = 0;
2941
2942 s->smv_next_frame = 0;
2943 av_frame_unref(s->smv_frame);
2944}
2945
2946#if CONFIG_MJPEG_DECODER
2947#if FF_API_MJPEG_EXTERN_HUFF
2948#define OFFSET(x) offsetof(MJpegDecodeContext, x)
2949#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2950static const AVOption options[] = {
2951 { "extern_huff", "Use external huffman table.",
2952 OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD | AV_OPT_FLAG_DEPRECATED },
2953 { NULL },
2954};
2955#endif
2956
2957static const AVClass mjpegdec_class = {
2958 .class_name = "MJPEG decoder",
2959 .item_name = av_default_item_name,
2960#if FF_API_MJPEG_EXTERN_HUFF
2961 .option = options,
2962#endif
2963 .version = LIBAVUTIL_VERSION_INT,
2964};
2965
2966const FFCodec ff_mjpeg_decoder = {
2967 .p.name = "mjpeg",
2968 CODEC_LONG_NAME("MJPEG (Motion JPEG)"),
2969 .p.type = AVMEDIA_TYPE_VIDEO,
2970 .p.id = AV_CODEC_ID_MJPEG,
2971 .priv_data_size = sizeof(MJpegDecodeContext),
2972 .init = ff_mjpeg_decode_init,
2973 .close = ff_mjpeg_decode_end,
2974 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
2975 .flush = decode_flush,
2976 .p.capabilities = AV_CODEC_CAP_DR1,
2977 .p.max_lowres = 3,
2978 .p.priv_class = &mjpegdec_class,
2979 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
2980 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
2981 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |
2982 FF_CODEC_CAP_ICC_PROFILES,
2983 .hw_configs = (const AVCodecHWConfigInternal *const []) {
2984#if CONFIG_MJPEG_NVDEC_HWACCEL
2985 HWACCEL_NVDEC(mjpeg),
2986#endif
2987#if CONFIG_MJPEG_VAAPI_HWACCEL
2988 HWACCEL_VAAPI(mjpeg),
2989#endif
2990 NULL
2991 },
2992};
2993#endif
2994#if CONFIG_THP_DECODER
2995const FFCodec ff_thp_decoder = {
2996 .p.name = "thp",
2997 CODEC_LONG_NAME("Nintendo Gamecube THP video"),
2998 .p.type = AVMEDIA_TYPE_VIDEO,
2999 .p.id = AV_CODEC_ID_THP,
3000 .priv_data_size = sizeof(MJpegDecodeContext),
3001 .init = ff_mjpeg_decode_init,
3002 .close = ff_mjpeg_decode_end,
3003 FF_CODEC_DECODE_CB(ff_mjpeg_decode_frame),
3004 .flush = decode_flush,
3005 .p.capabilities = AV_CODEC_CAP_DR1,
3006 .p.max_lowres = 3,
3007 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
3008};
3009#endif
3010
3011#if CONFIG_SMVJPEG_DECODER
3012// SMV JPEG just stacks several output frames into one JPEG picture
3013// we handle that by setting up the cropping parameters appropriately
3014static void smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
3015{
3016 MJpegDecodeContext *s = avctx->priv_data;
3017
3018 av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
3019
3020 frame->width = avctx->coded_width;
3021 frame->height = avctx->coded_height;
3022 frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
3023 frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
3024
3025 if (s->smv_frame->pts != AV_NOPTS_VALUE)
3026 s->smv_frame->pts += s->smv_frame->duration;
3027 s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
3028
3029 if (s->smv_next_frame == 0)
3030 av_frame_unref(s->smv_frame);
3031}
3032
3033static int smvjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
3034{
3035 MJpegDecodeContext *s = avctx->priv_data;
3036 AVPacket *const pkt = avctx->internal->in_pkt;
3037 int got_frame = 0;
3038 int ret;
3039
3040 if (s->smv_next_frame > 0)
3041 goto return_frame;
3042
3043 ret = ff_decode_get_packet(avctx, pkt);
3044 if (ret < 0)
3045 return ret;
3046
3047 av_frame_unref(s->smv_frame);
3048
3049 ret = ff_mjpeg_decode_frame(avctx, s->smv_frame, &got_frame, pkt);
3050 s->smv_frame->pkt_dts = pkt->dts;
3051 av_packet_unref(pkt);
3052 if (ret < 0)
3053 return ret;
3054
3055 if (!got_frame)
3056 return AVERROR(EAGAIN);
3057
3058 // packet duration covers all the frames in the packet
3059 s->smv_frame->duration /= s->smv_frames_per_jpeg;
3060
3061return_frame:
3062 av_assert0(s->smv_frame->buf[0]);
3063 ret = av_frame_ref(frame, s->smv_frame);
3064 if (ret < 0)
3065 return ret;
3066
3067 smv_process_frame(avctx, frame);
3068 return 0;
3069}
3070
3071const FFCodec ff_smvjpeg_decoder = {
3072 .p.name = "smvjpeg",
3073 CODEC_LONG_NAME("SMV JPEG"),
3074 .p.type = AVMEDIA_TYPE_VIDEO,
3075 .p.id = AV_CODEC_ID_SMVJPEG,
3076 .priv_data_size = sizeof(MJpegDecodeContext),
3077 .init = ff_mjpeg_decode_init,
3078 .close = ff_mjpeg_decode_end,
3079 FF_CODEC_RECEIVE_FRAME_CB(smvjpeg_receive_frame),
3080 .flush = decode_flush,
3081 .p.capabilities = AV_CODEC_CAP_DR1,
3082 .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING |
3083 FF_CODEC_CAP_INIT_CLEANUP,
3084};
3085#endif
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
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
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:1400
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition avcodec.h:1393
FF_DEBUG_QP
#define FF_DEBUG_QP
Definition avcodec.h:1397
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:382
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 even if the frame is skipped due to the skip_frame sett...
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:374
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition codec_internal.h:359
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:1777
ff_decode_exif_attach_ifd
int ff_decode_exif_attach_ifd(AVCodecContext *avctx, AVFrame *frame, const AVExifMetadata *ifd)
Definition decode.c:2492
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:1229
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:2184
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:177
AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT
Definition defs.h:174
AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
Definition defs.h:173
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:215
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition defs.h:212
AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS
#define AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS
Definition defs.h:176
AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
Definition defs.h:175
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:882
av_exif_free
void av_exif_free(AVExifMetadata *ifd)
Frees all resources associated with the given EXIF metadata struct.
Definition exif.c:659
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:357
lowres
static int lowres
Definition ffplay.c:333
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
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition get_bits.h:560
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:232
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:434
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:695
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:700
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:708
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition frame.h:687
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:555
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
type
cl_device_type type
Definition hwcontext_opencl.c:213
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.
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:88
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:72
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:264
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:2937
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:2221
mjpeg_decode_app
static int mjpeg_decode_app(MJpegDecodeContext *s, int start_code)
Definition mjpegdec.c:1846
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:2380
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:1680
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:2151
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:2251
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:2900
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:2394
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:2890
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:1590
REFINE_BIT
#define REFINE_BIT(j)
Definition mjpegdec.c:993
mjpeg_decode_dri
static int mjpeg_decode_dri(MJpegDecodeContext *s)
Definition mjpegdec.c:1835
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:1645
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:2195
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
ff_mjpeg_should_restart
static int ff_mjpeg_should_restart(MJpegDecodeContext *s)
Definition mjpegdec.h:200
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:3500
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:3488
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3460
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition pixfmt.h:556
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition pixfmt.h:805
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:766
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition pixfmt.h:783
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition pixfmt.h:536
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition pixfmt.h:601
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition pixfmt.h:535
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:557
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition pixfmt.h:528
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition pixfmt.h:603
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition pixfmt.h:567
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition pixfmt.h:558
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:712
ff_mjpeg_profiles
const AVProfile ff_mjpeg_profiles[]
Definition profiles.c:191
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:1392
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:1883
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:1423
AVCodecContext::codec
const struct AVCodec * codec
Definition avcodec.h:452
AVCodecContext::profile
int profile
profile
Definition avcodec.h:1636
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:1702
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:1667
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition avcodec.h:1416
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:327
AVFrameSideData::data
uint8_t * data
Definition frame.h:329
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition frame.h:493
AVOption
AVOption.
Definition opt.h:428
AVPacket
This structure stores compressed data.
Definition packet.h:580
AVPacket::size
int size
Definition packet.h:604
AVPacket::data
uint8_t * data
Definition packet.h:603
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
out
static FILE * out
Definition movenc.c:55
buffer
static char buffer[20]
Definition seek.c:32
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
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:231
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 Sun Aug 16 2026 20:20:50 for FFmpeg by doxygen 1.13.2