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