FFmpeg  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 
1086 
1087  s->restart_count = s->restart_interval;
1088 
1089  if (s->restart_interval == 0)
1090  s->restart_interval = INT_MAX;
1091 
1092  if (s->bayer)
1093  width = s->mb_width / nb_components; /* Interleaved, width stored is the total so need to divide */
1094  else
1095  width = s->mb_width;
1096 
1097  av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1098  if (!s->ljpeg_buffer)
1099  return AVERROR(ENOMEM);
1100 
1101  buffer = s->ljpeg_buffer;
1102 
1103  for (i = 0; i < 4; i++)
1104  buffer[0][i] = 1 << (s->bits - 1);
1105 
1106  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1107  uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1108 
1109  if (s->interlaced && s->bottom_field)
1110  ptr += linesize >> 1;
1111 
1112  for (i = 0; i < 4; i++)
1113  top[i] = left[i] = topleft[i] = buffer[0][i];
1114 
1115  if ((mb_y * s->width) % s->restart_interval == 0) {
1116  for (i = 0; i < 6; i++)
1117  vpred[i] = 1 << (s->bits-1);
1118  }
1119 
1120  for (mb_x = 0; mb_x < width; mb_x++) {
1121  int modified_predictor = predictor;
1122 
1123  if (get_bits_left(&s->gb) < 1) {
1124  av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
1125  return AVERROR_INVALIDDATA;
1126  }
1127 
1128  if (s->restart_interval && !s->restart_count){
1129  s->restart_count = s->restart_interval;
1130  resync_mb_x = mb_x;
1131  resync_mb_y = mb_y;
1132  for(i=0; i<4; i++)
1133  top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1134  }
1135  if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1136  modified_predictor = 1;
1137 
1138  for (i=0;i<nb_components;i++) {
1139  int pred, dc;
1140 
1141  topleft[i] = top[i];
1142  top[i] = buffer[mb_x][i];
1143 
1144  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1145  if(dc == 0xFFFFF)
1146  return -1;
1147 
1148  if (!s->bayer || mb_x) {
1149  pred = left[i];
1150  } else { /* This path runs only for the first line in bayer images */
1151  vpred[i] += dc;
1152  pred = vpred[i] - dc;
1153  }
1154 
1155  PREDICT(pred, topleft[i], top[i], pred, modified_predictor);
1156 
1157  left[i] = buffer[mb_x][i] =
1158  mask & (pred + (unsigned)(dc * (1 << point_transform)));
1159  }
1160 
1161  if (s->restart_interval && !--s->restart_count) {
1162  align_get_bits(&s->gb);
1163  skip_bits(&s->gb, 16); /* skip RSTn */
1164  }
1165  }
1166  if (s->rct && s->nb_components == 4) {
1167  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1168  ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1169  ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1170  ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1171  ptr[4*mb_x + 0] = buffer[mb_x][3];
1172  }
1173  } else if (s->nb_components == 4) {
1174  for(i=0; i<nb_components; i++) {
1175  int c= s->comp_index[i];
1176  if (s->bits <= 8) {
1177  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1178  ptr[4*mb_x+3-c] = buffer[mb_x][i];
1179  }
1180  } else if(s->bits == 9) {
1181  return AVERROR_PATCHWELCOME;
1182  } else {
1183  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1184  ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1185  }
1186  }
1187  }
1188  } else if (s->rct) {
1189  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1190  ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1191  ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1192  ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1193  }
1194  } else if (s->pegasus_rct) {
1195  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1196  ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1197  ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1198  ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1199  }
1200  } else if (s->bayer) {
1201  if (nb_components == 1) {
1202  /* Leave decoding to the TIFF/DNG decoder (see comment in ff_mjpeg_decode_sof) */
1203  for (mb_x = 0; mb_x < width; mb_x++)
1204  ((uint16_t*)ptr)[mb_x] = buffer[mb_x][0];
1205  } else if (nb_components == 2) {
1206  for (mb_x = 0; mb_x < width; mb_x++) {
1207  ((uint16_t*)ptr)[2*mb_x + 0] = buffer[mb_x][0];
1208  ((uint16_t*)ptr)[2*mb_x + 1] = buffer[mb_x][1];
1209  }
1210  }
1211  } else {
1212  for(i=0; i<nb_components; i++) {
1213  int c= s->comp_index[i];
1214  if (s->bits <= 8) {
1215  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1216  ptr[3*mb_x+2-c] = buffer[mb_x][i];
1217  }
1218  } else if(s->bits == 9) {
1219  return AVERROR_PATCHWELCOME;
1220  } else {
1221  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1222  ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1223  }
1224  }
1225  }
1226  }
1227  }
1228  return 0;
1229 }
1230 
1232  int point_transform, int nb_components)
1233 {
1234  int i, mb_x, mb_y, mask;
1235  int bits= (s->bits+7)&~7;
1236  int resync_mb_y = 0;
1237  int resync_mb_x = 0;
1238 
1239  point_transform += bits - s->bits;
1240  mask = ((1 << s->bits) - 1) << point_transform;
1241 
1242  av_assert0(nb_components>=1 && nb_components<=4);
1243 
1244  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1245  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1246  if (get_bits_left(&s->gb) < 1) {
1247  av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1248  return AVERROR_INVALIDDATA;
1249  }
1250  if (s->restart_interval && !s->restart_count){
1251  s->restart_count = s->restart_interval;
1252  resync_mb_x = mb_x;
1253  resync_mb_y = mb_y;
1254  }
1255 
1256  if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1257  int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1258  int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1259  for (i = 0; i < nb_components; i++) {
1260  uint8_t *ptr;
1261  uint16_t *ptr16;
1262  int n, h, v, x, y, c, j, linesize;
1263  n = s->nb_blocks[i];
1264  c = s->comp_index[i];
1265  h = s->h_scount[i];
1266  v = s->v_scount[i];
1267  x = 0;
1268  y = 0;
1269  linesize= s->linesize[c];
1270 
1271  if(bits>8) linesize /= 2;
1272 
1273  for(j=0; j<n; j++) {
1274  int pred, dc;
1275 
1276  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1277  if(dc == 0xFFFFF)
1278  return -1;
1279  if ( h * mb_x + x >= s->width
1280  || v * mb_y + y >= s->height) {
1281  // Nothing to do
1282  } else if (bits<=8) {
1283  ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1284  if(y==0 && toprow){
1285  if(x==0 && leftcol){
1286  pred= 1 << (bits - 1);
1287  }else{
1288  pred= ptr[-1];
1289  }
1290  }else{
1291  if(x==0 && leftcol){
1292  pred= ptr[-linesize];
1293  }else{
1294  PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1295  }
1296  }
1297 
1298  if (s->interlaced && s->bottom_field)
1299  ptr += linesize >> 1;
1300  pred &= mask;
1301  *ptr= pred + ((unsigned)dc << point_transform);
1302  }else{
1303  ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1304  if(y==0 && toprow){
1305  if(x==0 && leftcol){
1306  pred= 1 << (bits - 1);
1307  }else{
1308  pred= ptr16[-1];
1309  }
1310  }else{
1311  if(x==0 && leftcol){
1312  pred= ptr16[-linesize];
1313  }else{
1314  PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1315  }
1316  }
1317 
1318  if (s->interlaced && s->bottom_field)
1319  ptr16 += linesize >> 1;
1320  pred &= mask;
1321  *ptr16= pred + ((unsigned)dc << point_transform);
1322  }
1323  if (++x == h) {
1324  x = 0;
1325  y++;
1326  }
1327  }
1328  }
1329  } else {
1330  for (i = 0; i < nb_components; i++) {
1331  uint8_t *ptr;
1332  uint16_t *ptr16;
1333  int n, h, v, x, y, c, j, linesize, dc;
1334  n = s->nb_blocks[i];
1335  c = s->comp_index[i];
1336  h = s->h_scount[i];
1337  v = s->v_scount[i];
1338  x = 0;
1339  y = 0;
1340  linesize = s->linesize[c];
1341 
1342  if(bits>8) linesize /= 2;
1343 
1344  for (j = 0; j < n; j++) {
1345  int pred;
1346 
1347  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1348  if(dc == 0xFFFFF)
1349  return -1;
1350  if ( h * mb_x + x >= s->width
1351  || v * mb_y + y >= s->height) {
1352  // Nothing to do
1353  } else if (bits<=8) {
1354  ptr = s->picture_ptr->data[c] +
1355  (linesize * (v * mb_y + y)) +
1356  (h * mb_x + x); //FIXME optimize this crap
1357  PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1358 
1359  pred &= mask;
1360  *ptr = pred + ((unsigned)dc << point_transform);
1361  }else{
1362  ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1363  PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1364 
1365  pred &= mask;
1366  *ptr16= pred + ((unsigned)dc << point_transform);
1367  }
1368 
1369  if (++x == h) {
1370  x = 0;
1371  y++;
1372  }
1373  }
1374  }
1375  }
1376  if (s->restart_interval && !--s->restart_count) {
1377  align_get_bits(&s->gb);
1378  skip_bits(&s->gb, 16); /* skip RSTn */
1379  }
1380  }
1381  }
1382  return 0;
1383 }
1384 
1386  uint8_t *dst, const uint8_t *src,
1387  int linesize, int lowres)
1388 {
1389  switch (lowres) {
1390  case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1391  break;
1392  case 1: copy_block4(dst, src, linesize, linesize, 4);
1393  break;
1394  case 2: copy_block2(dst, src, linesize, linesize, 2);
1395  break;
1396  case 3: *dst = *src;
1397  break;
1398  }
1399 }
1400 
1401 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1402 {
1403  int block_x, block_y;
1404  int size = 8 >> s->avctx->lowres;
1405  if (s->bits > 8) {
1406  for (block_y=0; block_y<size; block_y++)
1407  for (block_x=0; block_x<size; block_x++)
1408  *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1409  } else {
1410  for (block_y=0; block_y<size; block_y++)
1411  for (block_x=0; block_x<size; block_x++)
1412  *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1413  }
1414 }
1415 
1416 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1417  int Al, const uint8_t *mb_bitmask,
1418  int mb_bitmask_size,
1419  const AVFrame *reference)
1420 {
1421  int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1423  const uint8_t *reference_data[MAX_COMPONENTS];
1424  int linesize[MAX_COMPONENTS];
1425  GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1426  int bytes_per_pixel = 1 + (s->bits > 8);
1427 
1428  if (mb_bitmask) {
1429  if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1430  av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1431  return AVERROR_INVALIDDATA;
1432  }
1433  init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1434  }
1435 
1436  s->restart_count = 0;
1437 
1438  av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1439  &chroma_v_shift);
1440  chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1441  chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1442 
1443  for (i = 0; i < nb_components; i++) {
1444  int c = s->comp_index[i];
1445  data[c] = s->picture_ptr->data[c];
1446  reference_data[c] = reference ? reference->data[c] : NULL;
1447  linesize[c] = s->linesize[c];
1448  s->coefs_finished[c] |= 1;
1449  }
1450 
1451  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1452  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1453  const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1454 
1455  if (s->restart_interval && !s->restart_count)
1456  s->restart_count = s->restart_interval;
1457 
1458  if (get_bits_left(&s->gb) < 0) {
1459  av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1460  -get_bits_left(&s->gb));
1461  return AVERROR_INVALIDDATA;
1462  }
1463  for (i = 0; i < nb_components; i++) {
1464  uint8_t *ptr;
1465  int n, h, v, x, y, c, j;
1466  int block_offset;
1467  n = s->nb_blocks[i];
1468  c = s->comp_index[i];
1469  h = s->h_scount[i];
1470  v = s->v_scount[i];
1471  x = 0;
1472  y = 0;
1473  for (j = 0; j < n; j++) {
1474  block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1475  (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1476 
1477  if (s->interlaced && s->bottom_field)
1478  block_offset += linesize[c] >> 1;
1479  if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1480  && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1481  ptr = data[c] + block_offset;
1482  } else
1483  ptr = NULL;
1484  if (!s->progressive) {
1485  if (copy_mb) {
1486  if (ptr)
1487  mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1488  linesize[c], s->avctx->lowres);
1489 
1490  } else {
1491  s->bdsp.clear_block(s->block);
1492  if (decode_block(s, s->block, i,
1493  s->dc_index[i], s->ac_index[i],
1494  s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1495  av_log(s->avctx, AV_LOG_ERROR,
1496  "error y=%d x=%d\n", mb_y, mb_x);
1497  return AVERROR_INVALIDDATA;
1498  }
1499  if (ptr) {
1500  s->idsp.idct_put(ptr, linesize[c], s->block);
1501  if (s->bits & 7)
1502  shift_output(s, ptr, linesize[c]);
1503  }
1504  }
1505  } else {
1506  int block_idx = s->block_stride[c] * (v * mb_y + y) +
1507  (h * mb_x + x);
1508  int16_t *block = s->blocks[c][block_idx];
1509  if (Ah)
1510  block[0] += get_bits1(&s->gb) *
1511  s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1512  else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1513  s->quant_matrixes[s->quant_sindex[i]],
1514  Al) < 0) {
1515  av_log(s->avctx, AV_LOG_ERROR,
1516  "error y=%d x=%d\n", mb_y, mb_x);
1517  return AVERROR_INVALIDDATA;
1518  }
1519  }
1520  ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1521  ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1522  mb_x, mb_y, x, y, c, s->bottom_field,
1523  (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1524  if (++x == h) {
1525  x = 0;
1526  y++;
1527  }
1528  }
1529  }
1530 
1531  handle_rstn(s, nb_components);
1532  }
1533  }
1534  return 0;
1535 }
1536 
1538  int se, int Ah, int Al)
1539 {
1540  int mb_x, mb_y;
1541  int EOBRUN = 0;
1542  int c = s->comp_index[0];
1543  uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1544 
1545  av_assert0(ss>=0 && Ah>=0 && Al>=0);
1546  if (se < ss || se > 63) {
1547  av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1548  return AVERROR_INVALIDDATA;
1549  }
1550 
1551  // s->coefs_finished is a bitmask for coefficients coded
1552  // ss and se are parameters telling start and end coefficients
1553  s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1554 
1555  s->restart_count = 0;
1556 
1557  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1558  int block_idx = mb_y * s->block_stride[c];
1559  int16_t (*block)[64] = &s->blocks[c][block_idx];
1560  uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1561  if (get_bits_left(&s->gb) <= 0) {
1562  av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1563  return AVERROR_INVALIDDATA;
1564  }
1565  for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1566  int ret;
1567  if (s->restart_interval && !s->restart_count)
1568  s->restart_count = s->restart_interval;
1569 
1570  if (Ah)
1571  ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1572  quant_matrix, ss, se, Al, &EOBRUN);
1573  else
1574  ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1575  quant_matrix, ss, se, Al, &EOBRUN);
1576  if (ret < 0) {
1577  av_log(s->avctx, AV_LOG_ERROR,
1578  "error y=%d x=%d\n", mb_y, mb_x);
1579  return AVERROR_INVALIDDATA;
1580  }
1581 
1582  if (handle_rstn(s, 0))
1583  EOBRUN = 0;
1584  }
1585  }
1586  return 0;
1587 }
1588 
1590 {
1591  int mb_x, mb_y;
1592  int c;
1593  const int bytes_per_pixel = 1 + (s->bits > 8);
1594  const int block_size = s->lossless ? 1 : 8;
1595 
1596  for (c = 0; c < s->nb_components; c++) {
1597  uint8_t *data = s->picture_ptr->data[c];
1598  int linesize = s->linesize[c];
1599  int h = s->h_max / s->h_count[c];
1600  int v = s->v_max / s->v_count[c];
1601  int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1602  int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1603 
1604  if (~s->coefs_finished[c])
1605  av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1606 
1607  if (s->interlaced && s->bottom_field)
1608  data += linesize >> 1;
1609 
1610  for (mb_y = 0; mb_y < mb_height; mb_y++) {
1611  uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1612  int block_idx = mb_y * s->block_stride[c];
1613  int16_t (*block)[64] = &s->blocks[c][block_idx];
1614  for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1615  s->idsp.idct_put(ptr, linesize, *block);
1616  if (s->bits & 7)
1617  shift_output(s, ptr, linesize);
1618  ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1619  }
1620  }
1621  }
1622 }
1623 
1625  int mb_bitmask_size, const AVFrame *reference)
1626 {
1627  int len, nb_components, i, h, v, predictor, point_transform;
1628  int index, id, ret;
1629  const int block_size = s->lossless ? 1 : 8;
1630  int ilv, prev_shift;
1631 
1632  if (!s->got_picture) {
1633  av_log(s->avctx, AV_LOG_WARNING,
1634  "Can not process SOS before SOF, skipping\n");
1635  return -1;
1636  }
1637 
1638  if (reference) {
1639  if (reference->width != s->picture_ptr->width ||
1640  reference->height != s->picture_ptr->height ||
1641  reference->format != s->picture_ptr->format) {
1642  av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1643  return AVERROR_INVALIDDATA;
1644  }
1645  }
1646 
1647  /* XXX: verify len field validity */
1648  len = get_bits(&s->gb, 16);
1649  nb_components = get_bits(&s->gb, 8);
1650  if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1652  "decode_sos: nb_components (%d)",
1653  nb_components);
1654  return AVERROR_PATCHWELCOME;
1655  }
1656  if (len != 6 + 2 * nb_components) {
1657  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1658  return AVERROR_INVALIDDATA;
1659  }
1660  for (i = 0; i < nb_components; i++) {
1661  id = get_bits(&s->gb, 8) - 1;
1662  av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1663  /* find component index */
1664  for (index = 0; index < s->nb_components; index++)
1665  if (id == s->component_id[index])
1666  break;
1667  if (index == s->nb_components) {
1668  av_log(s->avctx, AV_LOG_ERROR,
1669  "decode_sos: index(%d) out of components\n", index);
1670  return AVERROR_INVALIDDATA;
1671  }
1672  /* Metasoft MJPEG codec has Cb and Cr swapped */
1673  if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1674  && nb_components == 3 && s->nb_components == 3 && i)
1675  index = 3 - i;
1676 
1677  s->quant_sindex[i] = s->quant_index[index];
1678  s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1679  s->h_scount[i] = s->h_count[index];
1680  s->v_scount[i] = s->v_count[index];
1681 
1682  if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1683  index = (index+2)%3;
1684 
1685  s->comp_index[i] = index;
1686 
1687  s->dc_index[i] = get_bits(&s->gb, 4);
1688  s->ac_index[i] = get_bits(&s->gb, 4);
1689 
1690  if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1691  s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1692  goto out_of_range;
1693  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))
1694  goto out_of_range;
1695  }
1696 
1697  predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1698  ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1699  if(s->avctx->codec_tag != AV_RL32("CJPG")){
1700  prev_shift = get_bits(&s->gb, 4); /* Ah */
1701  point_transform = get_bits(&s->gb, 4); /* Al */
1702  }else
1703  prev_shift = point_transform = 0;
1704 
1705  if (nb_components > 1) {
1706  /* interleaved stream */
1707  s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1708  s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1709  } else if (!s->ls) { /* skip this for JPEG-LS */
1710  h = s->h_max / s->h_scount[0];
1711  v = s->v_max / s->v_scount[0];
1712  s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1713  s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1714  s->nb_blocks[0] = 1;
1715  s->h_scount[0] = 1;
1716  s->v_scount[0] = 1;
1717  }
1718 
1719  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1720  av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1721  s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1722  predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1723  s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1724 
1725 
1726  /* mjpeg-b can have padding bytes between sos and image data, skip them */
1727  for (i = s->mjpb_skiptosod; i > 0; i--)
1728  skip_bits(&s->gb, 8);
1729 
1730 next_field:
1731  for (i = 0; i < nb_components; i++)
1732  s->last_dc[i] = (4 << s->bits);
1733 
1734  if (s->avctx->hwaccel) {
1735  int bytes_to_start = get_bits_count(&s->gb) / 8;
1736  av_assert0(bytes_to_start >= 0 &&
1737  s->raw_scan_buffer_size >= bytes_to_start);
1738 
1739  ret = s->avctx->hwaccel->decode_slice(s->avctx,
1740  s->raw_scan_buffer + bytes_to_start,
1741  s->raw_scan_buffer_size - bytes_to_start);
1742  if (ret < 0)
1743  return ret;
1744 
1745  } else if (s->lossless) {
1746  av_assert0(s->picture_ptr == s->picture);
1747  if (CONFIG_JPEGLS_DECODER && s->ls) {
1748 // for () {
1749 // reset_ls_coding_parameters(s, 0);
1750 
1751  if ((ret = ff_jpegls_decode_picture(s, predictor,
1752  point_transform, ilv)) < 0)
1753  return ret;
1754  } else {
1755  if (s->rgb || s->bayer) {
1756  if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1757  return ret;
1758  } else {
1759  if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1760  point_transform,
1761  nb_components)) < 0)
1762  return ret;
1763  }
1764  }
1765  } else {
1766  if (s->progressive && predictor) {
1767  av_assert0(s->picture_ptr == s->picture);
1769  ilv, prev_shift,
1770  point_transform)) < 0)
1771  return ret;
1772  } else {
1773  if ((ret = mjpeg_decode_scan(s, nb_components,
1774  prev_shift, point_transform,
1775  mb_bitmask, mb_bitmask_size, reference)) < 0)
1776  return ret;
1777  }
1778  }
1779 
1780  if (s->interlaced &&
1781  get_bits_left(&s->gb) > 32 &&
1782  show_bits(&s->gb, 8) == 0xFF) {
1783  GetBitContext bak = s->gb;
1784  align_get_bits(&bak);
1785  if (show_bits(&bak, 16) == 0xFFD1) {
1786  av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1787  s->gb = bak;
1788  skip_bits(&s->gb, 16);
1789  s->bottom_field ^= 1;
1790 
1791  goto next_field;
1792  }
1793  }
1794 
1795  emms_c();
1796  return 0;
1797  out_of_range:
1798  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1799  return AVERROR_INVALIDDATA;
1800 }
1801 
1803 {
1804  if (get_bits(&s->gb, 16) != 4)
1805  return AVERROR_INVALIDDATA;
1806  s->restart_interval = get_bits(&s->gb, 16);
1807  s->restart_count = 0;
1808  av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1809  s->restart_interval);
1810 
1811  return 0;
1812 }
1813 
1815 {
1816  int len, id, i;
1817 
1818  len = get_bits(&s->gb, 16);
1819  if (len < 6) {
1820  if (s->bayer) {
1821  // Pentax K-1 (digital camera) JPEG images embedded in DNG images contain unknown APP0 markers
1822  av_log(s->avctx, AV_LOG_WARNING, "skipping APPx (len=%"PRId32") for bayer-encoded image\n", len);
1823  skip_bits(&s->gb, len);
1824  return 0;
1825  } else
1826  return AVERROR_INVALIDDATA;
1827  }
1828  if (8 * len > get_bits_left(&s->gb))
1829  return AVERROR_INVALIDDATA;
1830 
1831  id = get_bits_long(&s->gb, 32);
1832  len -= 6;
1833 
1834  if (s->avctx->debug & FF_DEBUG_STARTCODE)
1835  av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1836  av_fourcc2str(av_bswap32(id)), id, len);
1837 
1838  /* Buggy AVID, it puts EOI only at every 10th frame. */
1839  /* Also, this fourcc is used by non-avid files too, it holds some
1840  information, but it's always present in AVID-created files. */
1841  if (id == AV_RB32("AVI1")) {
1842  /* structure:
1843  4bytes AVI1
1844  1bytes polarity
1845  1bytes always zero
1846  4bytes field_size
1847  4bytes field_size_less_padding
1848  */
1849  s->buggy_avid = 1;
1850  i = get_bits(&s->gb, 8); len--;
1851  av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1852  goto out;
1853  }
1854 
1855  if (id == AV_RB32("JFIF")) {
1856  int t_w, t_h, v1, v2;
1857  if (len < 8)
1858  goto out;
1859  skip_bits(&s->gb, 8); /* the trailing zero-byte */
1860  v1 = get_bits(&s->gb, 8);
1861  v2 = get_bits(&s->gb, 8);
1862  skip_bits(&s->gb, 8);
1863 
1864  s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1865  s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1866  if ( s->avctx->sample_aspect_ratio.num <= 0
1867  || s->avctx->sample_aspect_ratio.den <= 0) {
1868  s->avctx->sample_aspect_ratio.num = 0;
1869  s->avctx->sample_aspect_ratio.den = 1;
1870  }
1871 
1872  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1873  av_log(s->avctx, AV_LOG_INFO,
1874  "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1875  v1, v2,
1876  s->avctx->sample_aspect_ratio.num,
1877  s->avctx->sample_aspect_ratio.den);
1878 
1879  len -= 8;
1880  if (len >= 2) {
1881  t_w = get_bits(&s->gb, 8);
1882  t_h = get_bits(&s->gb, 8);
1883  if (t_w && t_h) {
1884  /* skip thumbnail */
1885  if (len -10 - (t_w * t_h * 3) > 0)
1886  len -= t_w * t_h * 3;
1887  }
1888  len -= 2;
1889  }
1890  goto out;
1891  }
1892 
1893  if ( id == AV_RB32("Adob")
1894  && len >= 7
1895  && show_bits(&s->gb, 8) == 'e'
1896  && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1897  skip_bits(&s->gb, 8); /* 'e' */
1898  skip_bits(&s->gb, 16); /* version */
1899  skip_bits(&s->gb, 16); /* flags0 */
1900  skip_bits(&s->gb, 16); /* flags1 */
1901  s->adobe_transform = get_bits(&s->gb, 8);
1902  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1903  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1904  len -= 7;
1905  goto out;
1906  }
1907 
1908  if (id == AV_RB32("LJIF")) {
1909  int rgb = s->rgb;
1910  int pegasus_rct = s->pegasus_rct;
1911  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1912  av_log(s->avctx, AV_LOG_INFO,
1913  "Pegasus lossless jpeg header found\n");
1914  skip_bits(&s->gb, 16); /* version ? */
1915  skip_bits(&s->gb, 16); /* unknown always 0? */
1916  skip_bits(&s->gb, 16); /* unknown always 0? */
1917  skip_bits(&s->gb, 16); /* unknown always 0? */
1918  switch (i=get_bits(&s->gb, 8)) {
1919  case 1:
1920  rgb = 1;
1921  pegasus_rct = 0;
1922  break;
1923  case 2:
1924  rgb = 1;
1925  pegasus_rct = 1;
1926  break;
1927  default:
1928  av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1929  }
1930 
1931  len -= 9;
1932  if (s->got_picture)
1933  if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1934  av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1935  goto out;
1936  }
1937 
1938  s->rgb = rgb;
1939  s->pegasus_rct = pegasus_rct;
1940 
1941  goto out;
1942  }
1943  if (id == AV_RL32("colr") && len > 0) {
1944  s->colr = get_bits(&s->gb, 8);
1945  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1946  av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1947  len --;
1948  goto out;
1949  }
1950  if (id == AV_RL32("xfrm") && len > 0) {
1951  s->xfrm = get_bits(&s->gb, 8);
1952  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1953  av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1954  len --;
1955  goto out;
1956  }
1957 
1958  /* JPS extension by VRex */
1959  if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1960  int flags, layout, type;
1961  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1962  av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1963 
1964  skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1965  skip_bits(&s->gb, 16); len -= 2; /* block length */
1966  skip_bits(&s->gb, 8); /* reserved */
1967  flags = get_bits(&s->gb, 8);
1968  layout = get_bits(&s->gb, 8);
1969  type = get_bits(&s->gb, 8);
1970  len -= 4;
1971 
1972  av_freep(&s->stereo3d);
1973  s->stereo3d = av_stereo3d_alloc();
1974  if (!s->stereo3d) {
1975  goto out;
1976  }
1977  if (type == 0) {
1978  s->stereo3d->type = AV_STEREO3D_2D;
1979  } else if (type == 1) {
1980  switch (layout) {
1981  case 0x01:
1982  s->stereo3d->type = AV_STEREO3D_LINES;
1983  break;
1984  case 0x02:
1985  s->stereo3d->type = AV_STEREO3D_SIDEBYSIDE;
1986  break;
1987  case 0x03:
1988  s->stereo3d->type = AV_STEREO3D_TOPBOTTOM;
1989  break;
1990  }
1991  if (!(flags & 0x04)) {
1992  s->stereo3d->flags = AV_STEREO3D_FLAG_INVERT;
1993  }
1994  }
1995  goto out;
1996  }
1997 
1998  /* EXIF metadata */
1999  if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
2000  GetByteContext gbytes;
2001  int ret, le, ifd_offset, bytes_read;
2002  const uint8_t *aligned;
2003 
2004  skip_bits(&s->gb, 16); // skip padding
2005  len -= 2;
2006 
2007  // init byte wise reading
2008  aligned = align_get_bits(&s->gb);
2009  bytestream2_init(&gbytes, aligned, len);
2010 
2011  // read TIFF header
2012  ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
2013  if (ret) {
2014  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
2015  } else {
2016  bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
2017 
2018  // read 0th IFD and store the metadata
2019  // (return values > 0 indicate the presence of subimage metadata)
2020  ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
2021  if (ret < 0) {
2022  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
2023  }
2024  }
2025 
2026  bytes_read = bytestream2_tell(&gbytes);
2027  skip_bits(&s->gb, bytes_read << 3);
2028  len -= bytes_read;
2029 
2030  goto out;
2031  }
2032 
2033  /* Apple MJPEG-A */
2034  if ((s->start_code == APP1) && (len > (0x28 - 8))) {
2035  id = get_bits_long(&s->gb, 32);
2036  len -= 4;
2037  /* Apple MJPEG-A */
2038  if (id == AV_RB32("mjpg")) {
2039  /* structure:
2040  4bytes field size
2041  4bytes pad field size
2042  4bytes next off
2043  4bytes quant off
2044  4bytes huff off
2045  4bytes image off
2046  4bytes scan off
2047  4bytes data off
2048  */
2049  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2050  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
2051  }
2052  }
2053 
2054  if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
2055  int id2;
2056  unsigned seqno;
2057  unsigned nummarkers;
2058 
2059  id = get_bits_long(&s->gb, 32);
2060  id2 = get_bits(&s->gb, 24);
2061  len -= 7;
2062  if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
2063  av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
2064  goto out;
2065  }
2066 
2067  skip_bits(&s->gb, 8);
2068  seqno = get_bits(&s->gb, 8);
2069  len -= 2;
2070  if (seqno == 0) {
2071  av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
2072  goto out;
2073  }
2074 
2075  nummarkers = get_bits(&s->gb, 8);
2076  len -= 1;
2077  if (nummarkers == 0) {
2078  av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2079  goto out;
2080  } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2081  av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2082  goto out;
2083  } else if (seqno > nummarkers) {
2084  av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2085  goto out;
2086  }
2087 
2088  /* Allocate if this is the first APP2 we've seen. */
2089  if (s->iccnum == 0) {
2090  if (!FF_ALLOCZ_TYPED_ARRAY(s->iccentries, nummarkers)) {
2091  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2092  return AVERROR(ENOMEM);
2093  }
2094  s->iccnum = nummarkers;
2095  }
2096 
2097  if (s->iccentries[seqno - 1].data) {
2098  av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2099  goto out;
2100  }
2101 
2102  s->iccentries[seqno - 1].length = len;
2103  s->iccentries[seqno - 1].data = av_malloc(len);
2104  if (!s->iccentries[seqno - 1].data) {
2105  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2106  return AVERROR(ENOMEM);
2107  }
2108 
2109  memcpy(s->iccentries[seqno - 1].data, align_get_bits(&s->gb), len);
2110  skip_bits(&s->gb, len << 3);
2111  len = 0;
2112  s->iccread++;
2113 
2114  if (s->iccread > s->iccnum)
2115  av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2116  }
2117 
2118 out:
2119  /* slow but needed for extreme adobe jpegs */
2120  if (len < 0)
2121  av_log(s->avctx, AV_LOG_ERROR,
2122  "mjpeg: error, decode_app parser read over the end\n");
2123  while (--len > 0)
2124  skip_bits(&s->gb, 8);
2125 
2126  return 0;
2127 }
2128 
2130 {
2131  int len = get_bits(&s->gb, 16);
2132  if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2133  int i;
2134  char *cbuf = av_malloc(len - 1);
2135  if (!cbuf)
2136  return AVERROR(ENOMEM);
2137 
2138  for (i = 0; i < len - 2; i++)
2139  cbuf[i] = get_bits(&s->gb, 8);
2140  if (i > 0 && cbuf[i - 1] == '\n')
2141  cbuf[i - 1] = 0;
2142  else
2143  cbuf[i] = 0;
2144 
2145  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2146  av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2147 
2148  /* buggy avid, it puts EOI only at every 10th frame */
2149  if (!strncmp(cbuf, "AVID", 4)) {
2150  parse_avid(s, cbuf, len);
2151  } else if (!strcmp(cbuf, "CS=ITU601"))
2152  s->cs_itu601 = 1;
2153  else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2154  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2155  s->flipped = 1;
2156  else if (!strcmp(cbuf, "MULTISCOPE II")) {
2157  s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2158  s->multiscope = 2;
2159  }
2160 
2161  av_free(cbuf);
2162  }
2163 
2164  return 0;
2165 }
2166 
2167 /* return the 8 bit start code value and update the search
2168  state. Return -1 if no start code found */
2169 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2170 {
2171  const uint8_t *buf_ptr;
2172  unsigned int v, v2;
2173  int val;
2174  int skipped = 0;
2175 
2176  buf_ptr = *pbuf_ptr;
2177  while (buf_end - buf_ptr > 1) {
2178  v = *buf_ptr++;
2179  v2 = *buf_ptr;
2180  if ((v == 0xff) && (v2 >= SOF0) && (v2 <= COM) && buf_ptr < buf_end) {
2181  val = *buf_ptr++;
2182  goto found;
2183  }
2184  skipped++;
2185  }
2186  buf_ptr = buf_end;
2187  val = -1;
2188 found:
2189  ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2190  *pbuf_ptr = buf_ptr;
2191  return val;
2192 }
2193 
2195  const uint8_t **buf_ptr, const uint8_t *buf_end,
2196  const uint8_t **unescaped_buf_ptr,
2197  int *unescaped_buf_size)
2198 {
2199  int start_code;
2200  start_code = find_marker(buf_ptr, buf_end);
2201 
2202  av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2203  if (!s->buffer)
2204  return AVERROR(ENOMEM);
2205 
2206  /* unescape buffer of SOS, use special treatment for JPEG-LS */
2207  if (start_code == SOS && !s->ls) {
2208  const uint8_t *src = *buf_ptr;
2209  const uint8_t *ptr = src;
2210  uint8_t *dst = s->buffer;
2211 
2212  #define copy_data_segment(skip) do { \
2213  ptrdiff_t length = (ptr - src) - (skip); \
2214  if (length > 0) { \
2215  memcpy(dst, src, length); \
2216  dst += length; \
2217  src = ptr; \
2218  } \
2219  } while (0)
2220 
2221  if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2222  ptr = buf_end;
2223  copy_data_segment(0);
2224  } else {
2225  while (ptr < buf_end) {
2226  uint8_t x = *(ptr++);
2227 
2228  if (x == 0xff) {
2229  ptrdiff_t skip = 0;
2230  while (ptr < buf_end && x == 0xff) {
2231  x = *(ptr++);
2232  skip++;
2233  }
2234 
2235  /* 0xFF, 0xFF, ... */
2236  if (skip > 1) {
2237  copy_data_segment(skip);
2238 
2239  /* decrement src as it is equal to ptr after the
2240  * copy_data_segment macro and we might want to
2241  * copy the current value of x later on */
2242  src--;
2243  }
2244 
2245  if (x < RST0 || x > RST7) {
2246  copy_data_segment(1);
2247  if (x)
2248  break;
2249  }
2250  }
2251  }
2252  if (src < ptr)
2253  copy_data_segment(0);
2254  }
2255  #undef copy_data_segment
2256 
2257  *unescaped_buf_ptr = s->buffer;
2258  *unescaped_buf_size = dst - s->buffer;
2259  memset(s->buffer + *unescaped_buf_size, 0,
2261 
2262  av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2263  (buf_end - *buf_ptr) - (dst - s->buffer));
2264  } else if (start_code == SOS && s->ls) {
2265  const uint8_t *src = *buf_ptr;
2266  uint8_t *dst = s->buffer;
2267  int bit_count = 0;
2268  int t = 0, b = 0;
2269  PutBitContext pb;
2270 
2271  /* find marker */
2272  while (src + t < buf_end) {
2273  uint8_t x = src[t++];
2274  if (x == 0xff) {
2275  while ((src + t < buf_end) && x == 0xff)
2276  x = src[t++];
2277  if (x & 0x80) {
2278  t -= FFMIN(2, t);
2279  break;
2280  }
2281  }
2282  }
2283  bit_count = t * 8;
2284  init_put_bits(&pb, dst, t);
2285 
2286  /* unescape bitstream */
2287  while (b < t) {
2288  uint8_t x = src[b++];
2289  put_bits(&pb, 8, x);
2290  if (x == 0xFF && b < t) {
2291  x = src[b++];
2292  if (x & 0x80) {
2293  av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2294  x &= 0x7f;
2295  }
2296  put_bits(&pb, 7, x);
2297  bit_count--;
2298  }
2299  }
2300  flush_put_bits(&pb);
2301 
2302  *unescaped_buf_ptr = dst;
2303  *unescaped_buf_size = (bit_count + 7) >> 3;
2304  memset(s->buffer + *unescaped_buf_size, 0,
2306  } else {
2307  *unescaped_buf_ptr = *buf_ptr;
2308  *unescaped_buf_size = buf_end - *buf_ptr;
2309  }
2310 
2311  return start_code;
2312 }
2313 
2315 {
2316  int i;
2317 
2318  if (s->iccentries) {
2319  for (i = 0; i < s->iccnum; i++)
2320  av_freep(&s->iccentries[i].data);
2321  av_freep(&s->iccentries);
2322  }
2323 
2324  s->iccread = 0;
2325  s->iccnum = 0;
2326 }
2327 
2328 // SMV JPEG just stacks several output frames into one JPEG picture
2329 // we handle that by setting up the cropping parameters appropriately
2331 {
2332  MJpegDecodeContext *s = avctx->priv_data;
2333  int ret;
2334 
2335  if (s->smv_next_frame > 0) {
2336  av_assert0(s->smv_frame->buf[0]);
2338  ret = av_frame_ref(frame, s->smv_frame);
2339  if (ret < 0)
2340  return ret;
2341  } else {
2342  av_assert0(frame->buf[0]);
2343  av_frame_unref(s->smv_frame);
2344  ret = av_frame_ref(s->smv_frame, frame);
2345  if (ret < 0)
2346  return ret;
2347  }
2348 
2349  av_assert0((s->smv_next_frame + 1) * avctx->height <= avctx->coded_height);
2350 
2351  frame->width = avctx->coded_width;
2352  frame->height = avctx->coded_height;
2353  frame->crop_top = FFMIN(s->smv_next_frame * avctx->height, frame->height);
2354  frame->crop_bottom = frame->height - (s->smv_next_frame + 1) * avctx->height;
2355 
2356  s->smv_next_frame = (s->smv_next_frame + 1) % s->smv_frames_per_jpeg;
2357 
2358  if (s->smv_next_frame == 0)
2359  av_frame_unref(s->smv_frame);
2360 
2361  return 0;
2362 }
2363 
2365 {
2366  MJpegDecodeContext *s = avctx->priv_data;
2367  int ret;
2368 
2369  av_packet_unref(s->pkt);
2370  ret = ff_decode_get_packet(avctx, s->pkt);
2371  if (ret < 0)
2372  return ret;
2373 
2374 #if CONFIG_SP5X_DECODER || CONFIG_AMV_DECODER
2375  if (avctx->codec_id == AV_CODEC_ID_SP5X ||
2376  avctx->codec_id == AV_CODEC_ID_AMV) {
2377  ret = ff_sp5x_process_packet(avctx, s->pkt);
2378  if (ret < 0)
2379  return ret;
2380  }
2381 #endif
2382 
2383  s->buf_size = s->pkt->size;
2384 
2385  return 0;
2386 }
2387 
2389 {
2390  MJpegDecodeContext *s = avctx->priv_data;
2391  const uint8_t *buf_end, *buf_ptr;
2392  const uint8_t *unescaped_buf_ptr;
2393  int hshift, vshift;
2394  int unescaped_buf_size;
2395  int start_code;
2396  int i, index;
2397  int ret = 0;
2398  int is16bit;
2399 
2400  if (avctx->codec_id == AV_CODEC_ID_SMVJPEG && s->smv_next_frame > 0)
2401  return smv_process_frame(avctx, frame);
2402 
2403  av_dict_free(&s->exif_metadata);
2404  av_freep(&s->stereo3d);
2405  s->adobe_transform = -1;
2406 
2407  if (s->iccnum != 0)
2409 
2410  ret = mjpeg_get_packet(avctx);
2411  if (ret < 0)
2412  return ret;
2413 
2414  buf_ptr = s->pkt->data;
2415  buf_end = s->pkt->data + s->pkt->size;
2416  while (buf_ptr < buf_end) {
2417  /* find start next marker */
2418  start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2419  &unescaped_buf_ptr,
2420  &unescaped_buf_size);
2421  /* EOF */
2422  if (start_code < 0) {
2423  break;
2424  } else if (unescaped_buf_size > INT_MAX / 8) {
2425  av_log(avctx, AV_LOG_ERROR,
2426  "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2427  start_code, unescaped_buf_size, s->pkt->size);
2428  return AVERROR_INVALIDDATA;
2429  }
2430  av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2431  start_code, buf_end - buf_ptr);
2432 
2433  ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2434 
2435  if (ret < 0) {
2436  av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2437  goto fail;
2438  }
2439 
2440  s->start_code = start_code;
2441  if (s->avctx->debug & FF_DEBUG_STARTCODE)
2442  av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2443 
2444  /* process markers */
2445  if (start_code >= RST0 && start_code <= RST7) {
2446  av_log(avctx, AV_LOG_DEBUG,
2447  "restart marker: %d\n", start_code & 0x0f);
2448  /* APP fields */
2449  } else if (start_code >= APP0 && start_code <= APP15) {
2450  if ((ret = mjpeg_decode_app(s)) < 0)
2451  av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2452  av_err2str(ret));
2453  /* Comment */
2454  } else if (start_code == COM) {
2455  ret = mjpeg_decode_com(s);
2456  if (ret < 0)
2457  return ret;
2458  } else if (start_code == DQT) {
2459  ret = ff_mjpeg_decode_dqt(s);
2460  if (ret < 0)
2461  return ret;
2462  }
2463 
2464  ret = -1;
2465 
2466  if (!CONFIG_JPEGLS_DECODER &&
2467  (start_code == SOF48 || start_code == LSE)) {
2468  av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2469  return AVERROR(ENOSYS);
2470  }
2471 
2472  if (avctx->skip_frame == AVDISCARD_ALL) {
2473  switch(start_code) {
2474  case SOF0:
2475  case SOF1:
2476  case SOF2:
2477  case SOF3:
2478  case SOF48:
2479  case SOI:
2480  case SOS:
2481  case EOI:
2482  break;
2483  default:
2484  goto skip;
2485  }
2486  }
2487 
2488  switch (start_code) {
2489  case SOI:
2490  s->restart_interval = 0;
2491  s->restart_count = 0;
2492  s->raw_image_buffer = buf_ptr;
2493  s->raw_image_buffer_size = buf_end - buf_ptr;
2494  /* nothing to do on SOI */
2495  break;
2496  case DHT:
2497  if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2498  av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2499  goto fail;
2500  }
2501  break;
2502  case SOF0:
2503  case SOF1:
2504  if (start_code == SOF0)
2505  s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
2506  else
2508  s->lossless = 0;
2509  s->ls = 0;
2510  s->progressive = 0;
2511  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2512  goto fail;
2513  break;
2514  case SOF2:
2515  s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
2516  s->lossless = 0;
2517  s->ls = 0;
2518  s->progressive = 1;
2519  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2520  goto fail;
2521  break;
2522  case SOF3:
2523  s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
2524  s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2525  s->lossless = 1;
2526  s->ls = 0;
2527  s->progressive = 0;
2528  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2529  goto fail;
2530  break;
2531  case SOF48:
2532  s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
2533  s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
2534  s->lossless = 1;
2535  s->ls = 1;
2536  s->progressive = 0;
2537  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2538  goto fail;
2539  break;
2540  case LSE:
2541  if (!CONFIG_JPEGLS_DECODER ||
2542  (ret = ff_jpegls_decode_lse(s)) < 0)
2543  goto fail;
2544  break;
2545  case EOI:
2546 eoi_parser:
2547  if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2548  s->progressive && s->cur_scan && s->got_picture)
2550  s->cur_scan = 0;
2551  if (!s->got_picture) {
2552  av_log(avctx, AV_LOG_WARNING,
2553  "Found EOI before any SOF, ignoring\n");
2554  break;
2555  }
2556  if (s->interlaced) {
2557  s->bottom_field ^= 1;
2558  /* if not bottom field, do not output image yet */
2559  if (s->bottom_field == !s->interlace_polarity)
2560  break;
2561  }
2562  if (avctx->skip_frame == AVDISCARD_ALL) {
2563  s->got_picture = 0;
2564  ret = AVERROR(EAGAIN);
2565  goto the_end_no_picture;
2566  }
2567  if (s->avctx->hwaccel) {
2568  ret = s->avctx->hwaccel->end_frame(s->avctx);
2569  if (ret < 0)
2570  return ret;
2571 
2572  av_freep(&s->hwaccel_picture_private);
2573  }
2574  if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2575  return ret;
2576  s->got_picture = 0;
2577 
2578  frame->pkt_dts = s->pkt->dts;
2579 
2580  if (!s->lossless && avctx->debug & FF_DEBUG_QP) {
2581  int qp = FFMAX3(s->qscale[0],
2582  s->qscale[1],
2583  s->qscale[2]);
2584 
2585  av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2586  }
2587 
2588  goto the_end;
2589  case SOS:
2590  s->raw_scan_buffer = buf_ptr;
2591  s->raw_scan_buffer_size = buf_end - buf_ptr;
2592 
2593  s->cur_scan++;
2594  if (avctx->skip_frame == AVDISCARD_ALL) {
2595  skip_bits(&s->gb, get_bits_left(&s->gb));
2596  break;
2597  }
2598 
2599  if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2600  (avctx->err_recognition & AV_EF_EXPLODE))
2601  goto fail;
2602  break;
2603  case DRI:
2604  if ((ret = mjpeg_decode_dri(s)) < 0)
2605  return ret;
2606  break;
2607  case SOF5:
2608  case SOF6:
2609  case SOF7:
2610  case SOF9:
2611  case SOF10:
2612  case SOF11:
2613  case SOF13:
2614  case SOF14:
2615  case SOF15:
2616  case JPG:
2617  av_log(avctx, AV_LOG_ERROR,
2618  "mjpeg: unsupported coding type (%x)\n", start_code);
2619  break;
2620  }
2621 
2622 skip:
2623  /* eof process start code */
2624  buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2625  av_log(avctx, AV_LOG_DEBUG,
2626  "marker parser used %d bytes (%d bits)\n",
2627  (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2628  }
2629  if (s->got_picture && s->cur_scan) {
2630  av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2631  goto eoi_parser;
2632  }
2633  av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2634  return AVERROR_INVALIDDATA;
2635 fail:
2636  s->got_picture = 0;
2637  return ret;
2638 the_end:
2639 
2640  is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2641 
2642  if (AV_RB32(s->upscale_h)) {
2643  int p;
2645  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2646  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2647  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2648  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2649  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2650  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2651  avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2652  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2653  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2654  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2655  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2656  );
2657  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2658  if (ret)
2659  return ret;
2660 
2661  av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2662  for (p = 0; p<s->nb_components; p++) {
2663  uint8_t *line = s->picture_ptr->data[p];
2664  int w = s->width;
2665  int h = s->height;
2666  if (!s->upscale_h[p])
2667  continue;
2668  if (p==1 || p==2) {
2669  w = AV_CEIL_RSHIFT(w, hshift);
2670  h = AV_CEIL_RSHIFT(h, vshift);
2671  }
2672  if (s->upscale_v[p] == 1)
2673  h = (h+1)>>1;
2674  av_assert0(w > 0);
2675  for (i = 0; i < h; i++) {
2676  if (s->upscale_h[p] == 1) {
2677  if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2678  else line[w - 1] = line[(w - 1) / 2];
2679  for (index = w - 2; index > 0; index--) {
2680  if (is16bit)
2681  ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2682  else
2683  line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2684  }
2685  } else if (s->upscale_h[p] == 2) {
2686  if (is16bit) {
2687  ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2688  if (w > 1)
2689  ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2690  } else {
2691  line[w - 1] = line[(w - 1) / 3];
2692  if (w > 1)
2693  line[w - 2] = line[w - 1];
2694  }
2695  for (index = w - 3; index > 0; index--) {
2696  line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2697  }
2698  }
2699  line += s->linesize[p];
2700  }
2701  }
2702  }
2703  if (AV_RB32(s->upscale_v)) {
2704  int p;
2706  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2707  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2708  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2709  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2710  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2711  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2712  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2713  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2714  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2715  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2716  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2717  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2718  );
2719  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2720  if (ret)
2721  return ret;
2722 
2723  av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2724  for (p = 0; p < s->nb_components; p++) {
2725  uint8_t *dst;
2726  int w = s->width;
2727  int h = s->height;
2728  if (!s->upscale_v[p])
2729  continue;
2730  if (p==1 || p==2) {
2731  w = AV_CEIL_RSHIFT(w, hshift);
2732  h = AV_CEIL_RSHIFT(h, vshift);
2733  }
2734  dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2735  for (i = h - 1; i; i--) {
2736  uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2737  uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2738  if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2739  memcpy(dst, src1, w);
2740  } else {
2741  for (index = 0; index < w; index++)
2742  dst[index] = (src1[index] + src2[index]) >> 1;
2743  }
2744  dst -= s->linesize[p];
2745  }
2746  }
2747  }
2748  if (s->flipped && !s->rgb) {
2749  int j;
2750  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2751  if (ret)
2752  return ret;
2753 
2754  av_assert0(s->nb_components == av_pix_fmt_count_planes(s->picture_ptr->format));
2755  for (index=0; index<s->nb_components; index++) {
2756  uint8_t *dst = s->picture_ptr->data[index];
2757  int w = s->picture_ptr->width;
2758  int h = s->picture_ptr->height;
2759  if(index && index<3){
2760  w = AV_CEIL_RSHIFT(w, hshift);
2761  h = AV_CEIL_RSHIFT(h, vshift);
2762  }
2763  if(dst){
2764  uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2765  for (i=0; i<h/2; i++) {
2766  for (j=0; j<w; j++)
2767  FFSWAP(int, dst[j], dst2[j]);
2768  dst += s->picture_ptr->linesize[index];
2769  dst2 -= s->picture_ptr->linesize[index];
2770  }
2771  }
2772  }
2773  }
2774  if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2775  int w = s->picture_ptr->width;
2776  int h = s->picture_ptr->height;
2777  av_assert0(s->nb_components == 4);
2778  for (i=0; i<h; i++) {
2779  int j;
2780  uint8_t *dst[4];
2781  for (index=0; index<4; index++) {
2782  dst[index] = s->picture_ptr->data[index]
2783  + s->picture_ptr->linesize[index]*i;
2784  }
2785  for (j=0; j<w; j++) {
2786  int k = dst[3][j];
2787  int r = dst[0][j] * k;
2788  int g = dst[1][j] * k;
2789  int b = dst[2][j] * k;
2790  dst[0][j] = g*257 >> 16;
2791  dst[1][j] = b*257 >> 16;
2792  dst[2][j] = r*257 >> 16;
2793  dst[3][j] = 255;
2794  }
2795  }
2796  }
2797  if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2798  int w = s->picture_ptr->width;
2799  int h = s->picture_ptr->height;
2800  av_assert0(s->nb_components == 4);
2801  for (i=0; i<h; i++) {
2802  int j;
2803  uint8_t *dst[4];
2804  for (index=0; index<4; index++) {
2805  dst[index] = s->picture_ptr->data[index]
2806  + s->picture_ptr->linesize[index]*i;
2807  }
2808  for (j=0; j<w; j++) {
2809  int k = dst[3][j];
2810  int r = (255 - dst[0][j]) * k;
2811  int g = (128 - dst[1][j]) * k;
2812  int b = (128 - dst[2][j]) * k;
2813  dst[0][j] = r*257 >> 16;
2814  dst[1][j] = (g*257 >> 16) + 128;
2815  dst[2][j] = (b*257 >> 16) + 128;
2816  dst[3][j] = 255;
2817  }
2818  }
2819  }
2820 
2821  if (s->stereo3d) {
2823  if (stereo) {
2824  stereo->type = s->stereo3d->type;
2825  stereo->flags = s->stereo3d->flags;
2826  }
2827  av_freep(&s->stereo3d);
2828  }
2829 
2830  if (s->iccnum != 0 && s->iccnum == s->iccread) {
2831  AVFrameSideData *sd;
2832  size_t offset = 0;
2833  int total_size = 0;
2834  int i;
2835 
2836  /* Sum size of all parts. */
2837  for (i = 0; i < s->iccnum; i++)
2838  total_size += s->iccentries[i].length;
2839 
2841  if (!sd) {
2842  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2843  return AVERROR(ENOMEM);
2844  }
2845 
2846  /* Reassemble the parts, which are now in-order. */
2847  for (i = 0; i < s->iccnum; i++) {
2848  memcpy(sd->data + offset, s->iccentries[i].data, s->iccentries[i].length);
2849  offset += s->iccentries[i].length;
2850  }
2851  }
2852 
2853  av_dict_copy(&frame->metadata, s->exif_metadata, 0);
2854  av_dict_free(&s->exif_metadata);
2855 
2856  if (avctx->codec_id == AV_CODEC_ID_SMVJPEG) {
2857  ret = smv_process_frame(avctx, frame);
2858  if (ret < 0) {
2860  return ret;
2861  }
2862  }
2863  if ((avctx->codec_tag == MKTAG('A', 'V', 'R', 'n') ||
2864  avctx->codec_tag == MKTAG('A', 'V', 'D', 'J')) &&
2865  avctx->coded_height > s->orig_height) {
2866  frame->height = AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres);
2867  frame->crop_top = frame->height - avctx->height;
2868  }
2869 
2870  ret = 0;
2871 
2872 the_end_no_picture:
2873  av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2874  buf_end - buf_ptr);
2875 
2876  return ret;
2877 }
2878 
2879 /* mxpeg may call the following function (with a blank MJpegDecodeContext)
2880  * even without having called ff_mjpeg_decode_init(). */
2882 {
2883  MJpegDecodeContext *s = avctx->priv_data;
2884  int i, j;
2885 
2886  if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2887  av_log(avctx, AV_LOG_INFO, "Single field\n");
2888  }
2889 
2890  if (s->picture) {
2891  av_frame_free(&s->picture);
2892  s->picture_ptr = NULL;
2893  } else if (s->picture_ptr)
2894  av_frame_unref(s->picture_ptr);
2895 
2896  av_packet_free(&s->pkt);
2897 
2898  av_frame_free(&s->smv_frame);
2899 
2900  av_freep(&s->buffer);
2901  av_freep(&s->stereo3d);
2902  av_freep(&s->ljpeg_buffer);
2903  s->ljpeg_buffer_size = 0;
2904 
2905  for (i = 0; i < 3; i++) {
2906  for (j = 0; j < 4; j++)
2907  ff_free_vlc(&s->vlcs[i][j]);
2908  }
2909  for (i = 0; i < MAX_COMPONENTS; i++) {
2910  av_freep(&s->blocks[i]);
2911  av_freep(&s->last_nnz[i]);
2912  }
2913  av_dict_free(&s->exif_metadata);
2914 
2916 
2917  av_freep(&s->hwaccel_picture_private);
2918 
2919  return 0;
2920 }
2921 
2922 static void decode_flush(AVCodecContext *avctx)
2923 {
2924  MJpegDecodeContext *s = avctx->priv_data;
2925  s->got_picture = 0;
2926 
2927  s->smv_next_frame = 0;
2928  av_frame_unref(s->smv_frame);
2929 }
2930 
2931 #if CONFIG_MJPEG_DECODER
2932 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2933 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2934 static const AVOption options[] = {
2935  { "extern_huff", "Use external huffman table.",
2936  OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2937  { NULL },
2938 };
2939 
2940 static const AVClass mjpegdec_class = {
2941  .class_name = "MJPEG decoder",
2942  .item_name = av_default_item_name,
2943  .option = options,
2944  .version = LIBAVUTIL_VERSION_INT,
2945 };
2946 
2948  .name = "mjpeg",
2949  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2950  .type = AVMEDIA_TYPE_VIDEO,
2951  .id = AV_CODEC_ID_MJPEG,
2952  .priv_data_size = sizeof(MJpegDecodeContext),
2954  .close = ff_mjpeg_decode_end,
2956  .flush = decode_flush,
2957  .capabilities = AV_CODEC_CAP_DR1,
2958  .max_lowres = 3,
2959  .priv_class = &mjpegdec_class,
2963  .hw_configs = (const AVCodecHWConfigInternal *const []) {
2964 #if CONFIG_MJPEG_NVDEC_HWACCEL
2965  HWACCEL_NVDEC(mjpeg),
2966 #endif
2967 #if CONFIG_MJPEG_VAAPI_HWACCEL
2968  HWACCEL_VAAPI(mjpeg),
2969 #endif
2970  NULL
2971  },
2972 };
2973 #endif
2974 #if CONFIG_THP_DECODER
2976  .name = "thp",
2977  .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2978  .type = AVMEDIA_TYPE_VIDEO,
2979  .id = AV_CODEC_ID_THP,
2980  .priv_data_size = sizeof(MJpegDecodeContext),
2982  .close = ff_mjpeg_decode_end,
2984  .flush = decode_flush,
2985  .capabilities = AV_CODEC_CAP_DR1,
2986  .max_lowres = 3,
2989 };
2990 #endif
2991 
2992 #if CONFIG_SMVJPEG_DECODER
2994  .name = "smvjpeg",
2995  .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"),
2996  .type = AVMEDIA_TYPE_VIDEO,
2997  .id = AV_CODEC_ID_SMVJPEG,
2998  .priv_data_size = sizeof(MJpegDecodeContext),
3000  .close = ff_mjpeg_decode_end,
3002  .flush = decode_flush,
3003  .capabilities = AV_CODEC_CAP_DR1,
3006 };
3007 #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:1893
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:1317
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:348
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:1110
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:303
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:2364
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:2194
static void reset_icc_profile(MJpegDecodeContext *s)
Definition: mjpegdec.c:2314
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:2129
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:1231
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:1385
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
Definition: mjpegdec.c:2881
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:1416
#define ZERO_RUN
Definition: mjpegdec.c:947
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
Definition: mjpegdec.c:1401
int ff_mjpeg_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: mjpegdec.c:2388
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference)
Definition: mjpegdec.c:1624
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:1537
static void decode_flush(AVCodecContext *avctx)
Definition: mjpegdec.c:2922
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
Definition: mjpegdec.c:2169
#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:1802
static int smv_process_frame(AVCodecContext *avctx, AVFrame *frame)
Definition: mjpegdec.c:2330
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:1814
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
Definition: mjpegdec.c:1589
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]