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