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