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