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