FFmpeg
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 
59 static void mjpeg_find_raw_scan_data(MJpegDecodeContext *s,
60  const uint8_t **pbuf_ptr, size_t *pbuf_size);
61 
62 static 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 
105 static 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 
115 static 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 
124 av_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 
196 static 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 */
208 int 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 */
251 int 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 
310 int 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 
840 static 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 */
855 static 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 
904 static 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 */
921 static 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 \
1002 for (; ; 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 */
1019 static 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 */
1085 static 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 
1238 static 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 
1399 static 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 
1415 static 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 
1430 static 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 
1472 next_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 
1590 static 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 
1645 static 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 
1680 int 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 
1835 static 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 
1846 static 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 
2140 out:
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 
2151 static 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 */
2195 int 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;
2214 found:
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 
2221 static 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;
2245 found_hw:
2246  *pbuf_ptr = buf_ptr;
2247  *pbuf_size = ptr - buf_ptr;
2248  bytestream2_skipu(&s->gB, *pbuf_size);
2249 }
2250 
2251 int 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 
2314 found:
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 
2365 found_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 
2376 the_end:
2377  return init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2378 }
2379 
2380 static 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 
2394 int 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 
2418 redo_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:
2541 eoi_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 
2618 skip:
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;
2631 fail:
2632  s->got_picture = 0;
2633  return ret;
2634 the_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 
2884 the_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 
2890 int 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(). */
2900 av_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 
2937 static 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
2950 static 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 
2957 static 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 
2966 const 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
2995 const 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
3014 static 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 
3033 static 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 
3061 return_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 
3071 const 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
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:72
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:434
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1423
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
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
jpegtables.h
mjpeg.h
level
uint8_t level
Definition: svq3.c:208
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
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
blockdsp.h
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:688
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:447
opt.h
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(const GetByteContext *g)
Definition: bytestream.h:158
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
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:671
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1223
out
static FILE * out
Definition: movenc.c:55
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:99
SOS
@ SOS
Definition: mjpeg.h:72
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
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
APP1
@ APP1
Definition: mjpeg.h:80
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
ZERO_RUN
#define ZERO_RUN
Definition: mjpegdec.c:1001
SOF0
@ SOF0
Definition: mjpeg.h:39
src1
const pixel * src1
Definition: h264pred_template.c:420
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1416
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
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
av_cold
#define av_cold
Definition: attributes.h:119
ff_smvjpeg_decoder
const FFCodec ff_smvjpeg_decoder
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
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:254
init_idct
static void init_idct(AVCodecContext *avctx)
Definition: mjpegdec.c:115
mask
int mask
Definition: mediacodecdec_common.c:154
RST7
@ RST7
Definition: mjpeg.h:68
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
mjpegdec.h
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:231
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:472
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:154
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:595
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
ff_mjpeg_decoder
const FFCodec ff_mjpeg_decoder
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:603
SOF11
@ SOF11
Definition: mjpeg.h:50
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:694
AVOption
AVOption.
Definition: opt.h:428
b
#define b
Definition: input.c:43
ljpeg_decode_rgb_scan
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s)
Definition: mjpegdec.c:1085
jpeglsdec.h
data
const char data[16]
Definition: mxf.c:149
AVComponentDescriptor::step
int step
Number of elements between 2 horizontally consecutive pixels.
Definition: pixdesc.h:40
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
FFCodec
Definition: codec_internal.h:127
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:176
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
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_CODEC_ID_MEDIA100
@ AV_CODEC_ID_MEDIA100
Definition: codec_id.h:313
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:213
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
AV_CODEC_ID_THP
@ AV_CODEC_ID_THP
Definition: codec_id.h:150
AV_CODEC_ID_MXPEG
@ AV_CODEC_ID_MXPEG
Definition: codec_id.h:196
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Definition: utils.c:91
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:517
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1393
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:493
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
APP15
@ APP15
Definition: mjpeg.h:94
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:251
av_always_inline
#define av_always_inline
Definition: attributes.h:76
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
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:197
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3496
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:706
rgb
Definition: rpzaenc.c:60
ff_mjpeg_decode_dht
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
Definition: mjpegdec.c:251
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
shift_output
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
Definition: mjpegdec.c:1415
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FFHWAccel
Definition: hwaccel_internal.h:34
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:452
ff_mjpeg_decode_init
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
Definition: mjpegdec.c:124
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1667
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:597
SOF3
@ SOF3
Definition: mjpeg.h:42
GetBitContext
Definition: get_bits.h:109
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
mjpeg_decode_com
static int mjpeg_decode_com(MJpegDecodeContext *s)
Definition: mjpegdec.c:2151
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
av_exif_free
void av_exif_free(AVExifMetadata *ifd)
Frees all resources associated with the given EXIF metadata struct.
Definition: exif.c:659
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:3484
mjpeg_decode_scan_progressive_ac
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s)
Definition: mjpegdec.c:1590
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:619
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:522
ff_mjpeg_handle_restart
static int ff_mjpeg_handle_restart(MJpegDecodeContext *s, int *restart)
Definition: mjpegdec.h:218
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:52
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
ff_mjpeg_decode_sos
int ff_mjpeg_decode_sos(MJpegDecodeContext *s)
Definition: mjpegdec.c:1680
ff_mjpeg_profiles
const AVProfile ff_mjpeg_profiles[]
Definition: profiles.c:191
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:551
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:544
AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
Definition: defs.h:173
COM
@ COM
Definition: mjpeg.h:111
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:687
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:212
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
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
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:189
SOF5
@ SOF5
Definition: mjpeg.h:44
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:504
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:527
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:364
AV_STEREO3D_LINES
@ AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
Definition: stereo3d.h:126
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
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
ff_mjpeg_should_restart
static int ff_mjpeg_should_restart(MJpegDecodeContext *s)
Definition: mjpegdec.h:200
parse_avid
static void parse_avid(MJpegDecodeContext *s, uint8_t *buf, int len)
Definition: mjpegdec.c:105
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:552
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
g
const char * g
Definition: vf_curves.c:128
APP3
@ APP3
Definition: mjpeg.h:82
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
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(const PutByteContext *p)
Definition: bytestream.h:197
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:550
RST0
@ RST0
Definition: mjpeg.h:61
decode.h
reset_icc_profile
static void reset_icc_profile(MJpegDecodeContext *s)
Definition: mjpegdec.c:2380
ff_mjpeg_decode_end
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
Definition: mjpegdec.c:2900
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
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_mallocz
#define av_mallocz(s)
Definition: tableprint_vlc.h:31
SOF55
@ SOF55
JPEG-LS.
Definition: mjpeg.h:103
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:349
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
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:453
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:212
mjpeg_parse_len
static int mjpeg_parse_len(MJpegDecodeContext *s, int *plen, const char *name)
Definition: mjpegdec.c:196
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
fail
#define fail
Definition: test.h:478
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:561
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:529
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
ff_decode_exif_attach_ifd
int ff_decode_exif_attach_ifd(AVCodecContext *avctx, AVFrame *frame, const AVExifMetadata *ifd)
Definition: decode.c:2486
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
av_clip_int16
#define av_clip_int16
Definition: common.h:115
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:530
NULL
#define NULL
Definition: coverity.c:32
exif_internal.h
mjpeg_idct_scan_progressive_ac
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
Definition: mjpegdec.c:1645
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
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
run
uint8_t run
Definition: svq3.c:207
AV_EXIF_TIFF_HEADER
@ AV_EXIF_TIFF_HEADER
The TIFF header starts with 0x49492a00, or 0x4d4d002a.
Definition: exif.h:62
hwaccel_internal.h
AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT
Definition: defs.h:174
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_mjpeg_decode_dqt
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
Definition: mjpegdec.c:208
SOF13
@ SOF13
Definition: mjpeg.h:52
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:478
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
mjpeg_decode_dc
static int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index, int *val)
Definition: mjpegdec.c:840
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:242
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
profiles.h
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
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
options
Definition: swscale.c:50
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:235
MJpegDecodeContext
Definition: mjpegdec.h:56
lowres
static int lowres
Definition: ffplay.c:332
attributes.h
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
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
AV_PIX_FMT_ABGR
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
Definition: pixfmt.h:101
DRI
@ DRI
Definition: mjpeg.h:75
index
int index
Definition: gxfenc.c:90
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
mjpeg_decode_app
static int mjpeg_decode_app(MJpegDecodeContext *s, int start_code)
Definition: mjpegdec.c:1846
AV_CODEC_ID_MJPEGB
@ AV_CODEC_ID_MJPEGB
Definition: codec_id.h:58
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
PutByteContext
Definition: bytestream.h:37
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:1702
options
const OptionDef options[]
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
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1771
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:608
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
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
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
AVPacket::size
int size
Definition: packet.h:604
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
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
height
#define height
Definition: dsp.h:89
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
codec_internal.h
SOF14
@ SOF14
Definition: mjpeg.h:53
ff_jpegls_decode_lse
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
Decode LSE block with initialization parameters.
Definition: jpeglsdec.c:52
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
ff_mjpeg_decode_frame
int ff_mjpeg_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: mjpegdec.c:2890
av_bswap32
#define av_bswap32
Definition: bswap.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
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
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
AV_PROFILE_MJPEG_JPEG_LS
#define AV_PROFILE_MJPEG_JPEG_LS
Definition: defs.h:177
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
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
size
int size
Definition: twinvq_data.h:10344
AV_CODEC_ID_SMVJPEG
@ AV_CODEC_ID_SMVJPEG
Definition: codec_id.h:259
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
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:2178
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
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
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.
AVFrameSideData::data
uint8_t * data
Definition: frame.h:329
SOF15
@ SOF15
Definition: mjpeg.h:54
AVCodecHWConfigInternal
Definition: hwconfig.h:25
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:602
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
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
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
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
predictor
static void predictor(uint8_t *src, ptrdiff_t size)
Definition: exrenc.c:170
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:194
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
DQT
@ DQT
Definition: mjpeg.h:73
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
ff_thp_decoder
const FFCodec ff_thp_decoder
AVCodec::id
enum AVCodecID id
Definition: codec.h:183
layout
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel layout
Definition: filter_design.txt:18
SOF10
@ SOF10
Definition: mjpeg.h:49
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
NEG_USR32
#define NEG_USR32(a, s)
Definition: mathops.h:180
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
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
interlaced
uint8_t interlaced
Definition: mxfenc.c:2336
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
av_malloc
#define av_malloc(s)
Definition: ops_asmgen.c:44
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
EOI
@ EOI
Definition: mjpeg.h:71
copy_block.h
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:526
AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS
#define AV_PROFILE_MJPEG_HUFFMAN_LOSSLESS
Definition: defs.h:176
VD
#define VD
Definition: amfdec.c:787
src2
const pixel * src2
Definition: h264pred_template.c:421
ff_jpegls_decode_picture
int ff_jpegls_decode_picture(MJpegDecodeContext *s)
Definition: jpeglsdec.c:357
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:215
mjpeg_decode_scan
static int mjpeg_decode_scan(MJpegDecodeContext *s)
Definition: mjpegdec.c:1430
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
mjpeg_decode_dri
static int mjpeg_decode_dri(MJpegDecodeContext *s)
Definition: mjpegdec.c:1835
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
s
uint8_t s
Definition: llvidencdsp.c:39
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
ff_mjpeg_unescape_sos
int ff_mjpeg_unescape_sos(MJpegDecodeContext *s)
Definition: mjpegdec.c:2251
SOF9
@ SOF9
Definition: mjpeg.h:48
decode_flush
static av_cold void decode_flush(AVCodecContext *avctx)
Definition: mjpegdec.c:2937
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1400
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:496
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:176
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:688
len
int len
Definition: vorbis_enc_data.h:426
exif.h
DHT
@ DHT
Definition: mjpeg.h:56
AVCodecContext::height
int height
Definition: avcodec.h:604
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:643
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:695
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
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
idctdsp.h
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1883
REFINE_BIT
#define REFINE_BIT(j)
Definition: mjpegdec.c:993
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:580
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
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:204
pred
static const float pred[4]
Definition: siprdata.h:259
av_stereo3d_alloc
AVStereo3D * av_stereo3d_alloc(void)
Allocate an AVStereo3D structure and set its fields to default values.
Definition: stereo3d.c:34
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
SOF2
@ SOF2
Definition: mjpeg.h:41
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
hwaccel
static const char * hwaccel
Definition: ffplay.c:356
LSE
@ LSE
JPEG-LS extension parameters.
Definition: mjpeg.h:104
FF_DEBUG_QP
#define FF_DEBUG_QP
Definition: avcodec.h:1397
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
id
enum AVCodecID id
Definition: dts2pts.c:607
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:157
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AVCodecContext
main external API structure.
Definition: avcodec.h:443
FF_CODEC_RECEIVE_FRAME_CB
#define FF_CODEC_RECEIVE_FRAME_CB(func)
Definition: codec_internal.h:372
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:247
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:799
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
APP2
@ APP2
Definition: mjpeg.h:81
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:173
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1636
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:168
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:264
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
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
ff_mjpeg_bits_dc_chrominance
const uint8_t ff_mjpeg_bits_dc_chrominance[]
Definition: jpegtabs.h:37
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1392
ff_mjpeg_decode_sof
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
Definition: mjpegdec.c:310
APP0
@ APP0
Definition: mjpeg.h:79
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:619
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:105
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
mem.h
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
SOI
@ SOI
Definition: mjpeg.h:70
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
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:327
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:153
SOF1
@ SOF1
Definition: mjpeg.h:40
w
uint8_t w
Definition: llvidencdsp.c:39
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:468
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
ff_mjpeg_bits_dc_luminance
const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
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
AVPacket
This structure stores compressed data.
Definition: packet.h:580
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:470
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:326
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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_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
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
MAX_COMPONENTS
#define MAX_COMPONENTS
Definition: mjpegdec.h:47
rgb
static const SheerTable rgb[2]
Definition: sheervideodata.h:32
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ljpeg_decode_yuv_scan
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s)
Definition: mjpegdec.c:1238
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2070
SOF7
@ SOF7
Definition: mjpeg.h:46
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
pkt
static AVPacket * pkt
Definition: demux_decode.c:55
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
width
#define width
Definition: dsp.h:89
AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
#define AV_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
Definition: defs.h:175
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
PREDICT
#define PREDICT(ret, topleft, top, left, predictor)
Definition: mjpeg.h:118
put_bits.h
return_frame
static int return_frame(AVFilterContext *ctx, int is_second)
Definition: yadif_common.c:28
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
SOF6
@ SOF6
Definition: mjpeg.h:45
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:383
src
#define src
Definition: vp8dsp.c:248
JPG
@ JPG
Definition: mjpeg.h:47
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:323
Generated on Sun Jul 12 2026 19:22:47 for FFmpeg by   doxygen 1.8.17