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