FFmpeg  4.1.11
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 
1505  if (ret >= 0 && get_bits_left(&s->gb) < 0)
1506  ret = AVERROR_INVALIDDATA;
1507  if (ret < 0) {
1509  "error y=%d x=%d\n", mb_y, mb_x);
1510  return AVERROR_INVALIDDATA;
1511  }
1512 
1513  if (handle_rstn(s, 0))
1514  EOBRUN = 0;
1515  }
1516  }
1517  return 0;
1518 }
1519 
1521 {
1522  int mb_x, mb_y;
1523  int c;
1524  const int bytes_per_pixel = 1 + (s->bits > 8);
1525  const int block_size = s->lossless ? 1 : 8;
1526 
1527  for (c = 0; c < s->nb_components; c++) {
1528  uint8_t *data = s->picture_ptr->data[c];
1529  int linesize = s->linesize[c];
1530  int h = s->h_max / s->h_count[c];
1531  int v = s->v_max / s->v_count[c];
1532  int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1533  int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1534 
1535  if (~s->coefs_finished[c])
1536  av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1537 
1538  if (s->interlaced && s->bottom_field)
1539  data += linesize >> 1;
1540 
1541  for (mb_y = 0; mb_y < mb_height; mb_y++) {
1542  uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1543  int block_idx = mb_y * s->block_stride[c];
1544  int16_t (*block)[64] = &s->blocks[c][block_idx];
1545  for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1546  s->idsp.idct_put(ptr, linesize, *block);
1547  if (s->bits & 7)
1548  shift_output(s, ptr, linesize);
1549  ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1550  }
1551  }
1552  }
1553 }
1554 
1556  int mb_bitmask_size, const AVFrame *reference)
1557 {
1558  int len, nb_components, i, h, v, predictor, point_transform;
1559  int index, id, ret;
1560  const int block_size = s->lossless ? 1 : 8;
1561  int ilv, prev_shift;
1562 
1563  if (!s->got_picture) {
1565  "Can not process SOS before SOF, skipping\n");
1566  return -1;
1567  }
1568 
1569  if (reference) {
1570  if (reference->width != s->picture_ptr->width ||
1571  reference->height != s->picture_ptr->height ||
1572  reference->format != s->picture_ptr->format) {
1573  av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1574  return AVERROR_INVALIDDATA;
1575  }
1576  }
1577 
1578  /* XXX: verify len field validity */
1579  len = get_bits(&s->gb, 16);
1580  nb_components = get_bits(&s->gb, 8);
1581  if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1583  "decode_sos: nb_components (%d)",
1584  nb_components);
1585  return AVERROR_PATCHWELCOME;
1586  }
1587  if (len != 6 + 2 * nb_components) {
1588  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1589  return AVERROR_INVALIDDATA;
1590  }
1591  for (i = 0; i < nb_components; i++) {
1592  id = get_bits(&s->gb, 8) - 1;
1593  av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1594  /* find component index */
1595  for (index = 0; index < s->nb_components; index++)
1596  if (id == s->component_id[index])
1597  break;
1598  if (index == s->nb_components) {
1600  "decode_sos: index(%d) out of components\n", index);
1601  return AVERROR_INVALIDDATA;
1602  }
1603  /* Metasoft MJPEG codec has Cb and Cr swapped */
1604  if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1605  && nb_components == 3 && s->nb_components == 3 && i)
1606  index = 3 - i;
1607 
1608  s->quant_sindex[i] = s->quant_index[index];
1609  s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1610  s->h_scount[i] = s->h_count[index];
1611  s->v_scount[i] = s->v_count[index];
1612 
1613  if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1614  index = (index+2)%3;
1615 
1616  s->comp_index[i] = index;
1617 
1618  s->dc_index[i] = get_bits(&s->gb, 4);
1619  s->ac_index[i] = get_bits(&s->gb, 4);
1620 
1621  if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1622  s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1623  goto out_of_range;
1624  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))
1625  goto out_of_range;
1626  }
1627 
1628  predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1629  ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1630  if(s->avctx->codec_tag != AV_RL32("CJPG")){
1631  prev_shift = get_bits(&s->gb, 4); /* Ah */
1632  point_transform = get_bits(&s->gb, 4); /* Al */
1633  }else
1634  prev_shift = point_transform = 0;
1635 
1636  if (nb_components > 1) {
1637  /* interleaved stream */
1638  s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1639  s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1640  } else if (!s->ls) { /* skip this for JPEG-LS */
1641  h = s->h_max / s->h_scount[0];
1642  v = s->v_max / s->v_scount[0];
1643  s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1644  s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1645  s->nb_blocks[0] = 1;
1646  s->h_scount[0] = 1;
1647  s->v_scount[0] = 1;
1648  }
1649 
1650  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1651  av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1652  s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1653  predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1654  s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1655 
1656 
1657  /* mjpeg-b can have padding bytes between sos and image data, skip them */
1658  for (i = s->mjpb_skiptosod; i > 0; i--)
1659  skip_bits(&s->gb, 8);
1660 
1661 next_field:
1662  for (i = 0; i < nb_components; i++)
1663  s->last_dc[i] = (4 << s->bits);
1664 
1665  if (s->avctx->hwaccel) {
1666  int bytes_to_start = get_bits_count(&s->gb) / 8;
1667  av_assert0(bytes_to_start >= 0 &&
1668  s->raw_scan_buffer_size >= bytes_to_start);
1669 
1670  ret = s->avctx->hwaccel->decode_slice(s->avctx,
1671  s->raw_scan_buffer + bytes_to_start,
1672  s->raw_scan_buffer_size - bytes_to_start);
1673  if (ret < 0)
1674  return ret;
1675 
1676  } else if (s->lossless) {
1677  av_assert0(s->picture_ptr == s->picture);
1678  if (CONFIG_JPEGLS_DECODER && s->ls) {
1679 // for () {
1680 // reset_ls_coding_parameters(s, 0);
1681 
1682  if ((ret = ff_jpegls_decode_picture(s, predictor,
1683  point_transform, ilv)) < 0)
1684  return ret;
1685  } else {
1686  if (s->rgb) {
1687  if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1688  return ret;
1689  } else {
1690  if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1691  point_transform,
1692  nb_components)) < 0)
1693  return ret;
1694  }
1695  }
1696  } else {
1697  if (s->progressive && predictor) {
1698  av_assert0(s->picture_ptr == s->picture);
1699  if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1700  ilv, prev_shift,
1701  point_transform)) < 0)
1702  return ret;
1703  } else {
1704  if ((ret = mjpeg_decode_scan(s, nb_components,
1705  prev_shift, point_transform,
1706  mb_bitmask, mb_bitmask_size, reference)) < 0)
1707  return ret;
1708  }
1709  }
1710 
1711  if (s->interlaced &&
1712  get_bits_left(&s->gb) > 32 &&
1713  show_bits(&s->gb, 8) == 0xFF) {
1714  GetBitContext bak = s->gb;
1715  align_get_bits(&bak);
1716  if (show_bits(&bak, 16) == 0xFFD1) {
1717  av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1718  s->gb = bak;
1719  skip_bits(&s->gb, 16);
1720  s->bottom_field ^= 1;
1721 
1722  goto next_field;
1723  }
1724  }
1725 
1726  emms_c();
1727  return 0;
1728  out_of_range:
1729  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1730  return AVERROR_INVALIDDATA;
1731 }
1732 
1734 {
1735  if (get_bits(&s->gb, 16) != 4)
1736  return AVERROR_INVALIDDATA;
1737  s->restart_interval = get_bits(&s->gb, 16);
1738  s->restart_count = 0;
1739  av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1740  s->restart_interval);
1741 
1742  return 0;
1743 }
1744 
1746 {
1747  int len, id, i;
1748 
1749  len = get_bits(&s->gb, 16);
1750  if (len < 6)
1751  return AVERROR_INVALIDDATA;
1752  if (8 * len > get_bits_left(&s->gb))
1753  return AVERROR_INVALIDDATA;
1754 
1755  id = get_bits_long(&s->gb, 32);
1756  len -= 6;
1757 
1758  if (s->avctx->debug & FF_DEBUG_STARTCODE)
1759  av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1760  av_fourcc2str(av_bswap32(id)), id, len);
1761 
1762  /* Buggy AVID, it puts EOI only at every 10th frame. */
1763  /* Also, this fourcc is used by non-avid files too, it holds some
1764  information, but it's always present in AVID-created files. */
1765  if (id == AV_RB32("AVI1")) {
1766  /* structure:
1767  4bytes AVI1
1768  1bytes polarity
1769  1bytes always zero
1770  4bytes field_size
1771  4bytes field_size_less_padding
1772  */
1773  s->buggy_avid = 1;
1774  i = get_bits(&s->gb, 8); len--;
1775  av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1776  goto out;
1777  }
1778 
1779  if (id == AV_RB32("JFIF")) {
1780  int t_w, t_h, v1, v2;
1781  if (len < 8)
1782  goto out;
1783  skip_bits(&s->gb, 8); /* the trailing zero-byte */
1784  v1 = get_bits(&s->gb, 8);
1785  v2 = get_bits(&s->gb, 8);
1786  skip_bits(&s->gb, 8);
1787 
1788  s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1789  s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1790  if ( s->avctx->sample_aspect_ratio.num <= 0
1791  || s->avctx->sample_aspect_ratio.den <= 0) {
1792  s->avctx->sample_aspect_ratio.num = 0;
1793  s->avctx->sample_aspect_ratio.den = 1;
1794  }
1795 
1796  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1797  av_log(s->avctx, AV_LOG_INFO,
1798  "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1799  v1, v2,
1802 
1803  len -= 8;
1804  if (len >= 2) {
1805  t_w = get_bits(&s->gb, 8);
1806  t_h = get_bits(&s->gb, 8);
1807  if (t_w && t_h) {
1808  /* skip thumbnail */
1809  if (len -10 - (t_w * t_h * 3) > 0)
1810  len -= t_w * t_h * 3;
1811  }
1812  len -= 2;
1813  }
1814  goto out;
1815  }
1816 
1817  if ( id == AV_RB32("Adob")
1818  && len >= 7
1819  && show_bits(&s->gb, 8) == 'e'
1820  && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1821  skip_bits(&s->gb, 8); /* 'e' */
1822  skip_bits(&s->gb, 16); /* version */
1823  skip_bits(&s->gb, 16); /* flags0 */
1824  skip_bits(&s->gb, 16); /* flags1 */
1825  s->adobe_transform = get_bits(&s->gb, 8);
1826  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1827  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1828  len -= 7;
1829  goto out;
1830  }
1831 
1832  if (id == AV_RB32("LJIF")) {
1833  int rgb = s->rgb;
1834  int pegasus_rct = s->pegasus_rct;
1835  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1836  av_log(s->avctx, AV_LOG_INFO,
1837  "Pegasus lossless jpeg header found\n");
1838  skip_bits(&s->gb, 16); /* version ? */
1839  skip_bits(&s->gb, 16); /* unknown always 0? */
1840  skip_bits(&s->gb, 16); /* unknown always 0? */
1841  skip_bits(&s->gb, 16); /* unknown always 0? */
1842  switch (i=get_bits(&s->gb, 8)) {
1843  case 1:
1844  rgb = 1;
1845  pegasus_rct = 0;
1846  break;
1847  case 2:
1848  rgb = 1;
1849  pegasus_rct = 1;
1850  break;
1851  default:
1852  av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1853  }
1854 
1855  len -= 9;
1856  if (s->got_picture)
1857  if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1858  av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1859  goto out;
1860  }
1861 
1862  s->rgb = rgb;
1863  s->pegasus_rct = pegasus_rct;
1864 
1865  goto out;
1866  }
1867  if (id == AV_RL32("colr") && len > 0) {
1868  s->colr = get_bits(&s->gb, 8);
1869  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1870  av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1871  len --;
1872  goto out;
1873  }
1874  if (id == AV_RL32("xfrm") && len > 0) {
1875  s->xfrm = get_bits(&s->gb, 8);
1876  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1877  av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1878  len --;
1879  goto out;
1880  }
1881 
1882  /* JPS extension by VRex */
1883  if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1884  int flags, layout, type;
1885  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1886  av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1887 
1888  skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1889  skip_bits(&s->gb, 16); len -= 2; /* block length */
1890  skip_bits(&s->gb, 8); /* reserved */
1891  flags = get_bits(&s->gb, 8);
1892  layout = get_bits(&s->gb, 8);
1893  type = get_bits(&s->gb, 8);
1894  len -= 4;
1895 
1896  s->stereo3d = av_stereo3d_alloc();
1897  if (!s->stereo3d) {
1898  goto out;
1899  }
1900  if (type == 0) {
1902  } else if (type == 1) {
1903  switch (layout) {
1904  case 0x01:
1906  break;
1907  case 0x02:
1909  break;
1910  case 0x03:
1912  break;
1913  }
1914  if (!(flags & 0x04)) {
1916  }
1917  }
1918  goto out;
1919  }
1920 
1921  /* EXIF metadata */
1922  if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1923  GetByteContext gbytes;
1924  int ret, le, ifd_offset, bytes_read;
1925  const uint8_t *aligned;
1926 
1927  skip_bits(&s->gb, 16); // skip padding
1928  len -= 2;
1929 
1930  // init byte wise reading
1931  aligned = align_get_bits(&s->gb);
1932  bytestream2_init(&gbytes, aligned, len);
1933 
1934  // read TIFF header
1935  ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1936  if (ret) {
1937  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1938  } else {
1939  bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1940 
1941  // read 0th IFD and store the metadata
1942  // (return values > 0 indicate the presence of subimage metadata)
1943  ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1944  if (ret < 0) {
1945  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1946  }
1947  }
1948 
1949  bytes_read = bytestream2_tell(&gbytes);
1950  skip_bits(&s->gb, bytes_read << 3);
1951  len -= bytes_read;
1952 
1953  goto out;
1954  }
1955 
1956  /* Apple MJPEG-A */
1957  if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1958  id = get_bits_long(&s->gb, 32);
1959  len -= 4;
1960  /* Apple MJPEG-A */
1961  if (id == AV_RB32("mjpg")) {
1962  /* structure:
1963  4bytes field size
1964  4bytes pad field size
1965  4bytes next off
1966  4bytes quant off
1967  4bytes huff off
1968  4bytes image off
1969  4bytes scan off
1970  4bytes data off
1971  */
1972  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1973  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1974  }
1975  }
1976 
1977  if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
1978  int id2;
1979  unsigned seqno;
1980  unsigned nummarkers;
1981 
1982  id = get_bits_long(&s->gb, 32);
1983  id2 = get_bits_long(&s->gb, 24);
1984  len -= 7;
1985  if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
1986  av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
1987  goto out;
1988  }
1989 
1990  skip_bits(&s->gb, 8);
1991  seqno = get_bits(&s->gb, 8);
1992  len -= 2;
1993  if (seqno == 0) {
1994  av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
1995  goto out;
1996  }
1997 
1998  nummarkers = get_bits(&s->gb, 8);
1999  len -= 1;
2000  if (nummarkers == 0) {
2001  av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
2002  goto out;
2003  } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
2004  av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
2005  goto out;
2006  } else if (seqno > nummarkers) {
2007  av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
2008  goto out;
2009  }
2010 
2011  /* Allocate if this is the first APP2 we've seen. */
2012  if (s->iccnum == 0) {
2013  s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
2014  s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
2015  if (!s->iccdata || !s->iccdatalens) {
2016  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2017  return AVERROR(ENOMEM);
2018  }
2019  s->iccnum = nummarkers;
2020  }
2021 
2022  if (s->iccdata[seqno - 1]) {
2023  av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2024  goto out;
2025  }
2026 
2027  s->iccdatalens[seqno - 1] = len;
2028  s->iccdata[seqno - 1] = av_malloc(len);
2029  if (!s->iccdata[seqno - 1]) {
2030  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2031  return AVERROR(ENOMEM);
2032  }
2033 
2034  memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2035  skip_bits(&s->gb, len << 3);
2036  len = 0;
2037  s->iccread++;
2038 
2039  if (s->iccread > s->iccnum)
2040  av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2041  }
2042 
2043 out:
2044  /* slow but needed for extreme adobe jpegs */
2045  if (len < 0)
2047  "mjpeg: error, decode_app parser read over the end\n");
2048  while (--len > 0)
2049  skip_bits(&s->gb, 8);
2050 
2051  return 0;
2052 }
2053 
2055 {
2056  int len = get_bits(&s->gb, 16);
2057  if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2058  int i;
2059  char *cbuf = av_malloc(len - 1);
2060  if (!cbuf)
2061  return AVERROR(ENOMEM);
2062 
2063  for (i = 0; i < len - 2; i++)
2064  cbuf[i] = get_bits(&s->gb, 8);
2065  if (i > 0 && cbuf[i - 1] == '\n')
2066  cbuf[i - 1] = 0;
2067  else
2068  cbuf[i] = 0;
2069 
2070  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2071  av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2072 
2073  /* buggy avid, it puts EOI only at every 10th frame */
2074  if (!strncmp(cbuf, "AVID", 4)) {
2075  parse_avid(s, cbuf, len);
2076  } else if (!strcmp(cbuf, "CS=ITU601"))
2077  s->cs_itu601 = 1;
2078  else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2079  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2080  s->flipped = 1;
2081  else if (!strcmp(cbuf, "MULTISCOPE II")) {
2082  s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2083  s->multiscope = 2;
2084  }
2085 
2086  av_free(cbuf);
2087  }
2088 
2089  return 0;
2090 }
2091 
2092 /* return the 8 bit start code value and update the search
2093  state. Return -1 if no start code found */
2094 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2095 {
2096  const uint8_t *buf_ptr;
2097  unsigned int v, v2;
2098  int val;
2099  int skipped = 0;
2100 
2101  buf_ptr = *pbuf_ptr;
2102  while (buf_end - buf_ptr > 1) {
2103  v = *buf_ptr++;
2104  v2 = *buf_ptr;
2105  if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2106  val = *buf_ptr++;
2107  goto found;
2108  }
2109  skipped++;
2110  }
2111  buf_ptr = buf_end;
2112  val = -1;
2113 found:
2114  ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2115  *pbuf_ptr = buf_ptr;
2116  return val;
2117 }
2118 
2120  const uint8_t **buf_ptr, const uint8_t *buf_end,
2121  const uint8_t **unescaped_buf_ptr,
2122  int *unescaped_buf_size)
2123 {
2124  int start_code;
2125  start_code = find_marker(buf_ptr, buf_end);
2126 
2127  av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2128  if (!s->buffer)
2129  return AVERROR(ENOMEM);
2130 
2131  /* unescape buffer of SOS, use special treatment for JPEG-LS */
2132  if (start_code == SOS && !s->ls) {
2133  const uint8_t *src = *buf_ptr;
2134  const uint8_t *ptr = src;
2135  uint8_t *dst = s->buffer;
2136 
2137  #define copy_data_segment(skip) do { \
2138  ptrdiff_t length = (ptr - src) - (skip); \
2139  if (length > 0) { \
2140  memcpy(dst, src, length); \
2141  dst += length; \
2142  src = ptr; \
2143  } \
2144  } while (0)
2145 
2146  if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2147  ptr = buf_end;
2148  copy_data_segment(0);
2149  } else {
2150  while (ptr < buf_end) {
2151  uint8_t x = *(ptr++);
2152 
2153  if (x == 0xff) {
2154  ptrdiff_t skip = 0;
2155  while (ptr < buf_end && x == 0xff) {
2156  x = *(ptr++);
2157  skip++;
2158  }
2159 
2160  /* 0xFF, 0xFF, ... */
2161  if (skip > 1) {
2162  copy_data_segment(skip);
2163 
2164  /* decrement src as it is equal to ptr after the
2165  * copy_data_segment macro and we might want to
2166  * copy the current value of x later on */
2167  src--;
2168  }
2169 
2170  if (x < 0xd0 || x > 0xd7) {
2171  copy_data_segment(1);
2172  if (x)
2173  break;
2174  }
2175  }
2176  }
2177  if (src < ptr)
2178  copy_data_segment(0);
2179  }
2180  #undef copy_data_segment
2181 
2182  *unescaped_buf_ptr = s->buffer;
2183  *unescaped_buf_size = dst - s->buffer;
2184  memset(s->buffer + *unescaped_buf_size, 0,
2186 
2187  av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2188  (buf_end - *buf_ptr) - (dst - s->buffer));
2189  } else if (start_code == SOS && s->ls) {
2190  const uint8_t *src = *buf_ptr;
2191  uint8_t *dst = s->buffer;
2192  int bit_count = 0;
2193  int t = 0, b = 0;
2194  PutBitContext pb;
2195 
2196  /* find marker */
2197  while (src + t < buf_end) {
2198  uint8_t x = src[t++];
2199  if (x == 0xff) {
2200  while ((src + t < buf_end) && x == 0xff)
2201  x = src[t++];
2202  if (x & 0x80) {
2203  t -= FFMIN(2, t);
2204  break;
2205  }
2206  }
2207  }
2208  bit_count = t * 8;
2209  init_put_bits(&pb, dst, t);
2210 
2211  /* unescape bitstream */
2212  while (b < t) {
2213  uint8_t x = src[b++];
2214  put_bits(&pb, 8, x);
2215  if (x == 0xFF && b < t) {
2216  x = src[b++];
2217  if (x & 0x80) {
2218  av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2219  x &= 0x7f;
2220  }
2221  put_bits(&pb, 7, x);
2222  bit_count--;
2223  }
2224  }
2225  flush_put_bits(&pb);
2226 
2227  *unescaped_buf_ptr = dst;
2228  *unescaped_buf_size = (bit_count + 7) >> 3;
2229  memset(s->buffer + *unescaped_buf_size, 0,
2231  } else {
2232  *unescaped_buf_ptr = *buf_ptr;
2233  *unescaped_buf_size = buf_end - *buf_ptr;
2234  }
2235 
2236  return start_code;
2237 }
2238 
2240 {
2241  int i;
2242 
2243  if (s->iccdata)
2244  for (i = 0; i < s->iccnum; i++)
2245  av_freep(&s->iccdata[i]);
2246  av_freep(&s->iccdata);
2247  av_freep(&s->iccdatalens);
2248 
2249  s->iccread = 0;
2250  s->iccnum = 0;
2251 }
2252 
2253 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2254  AVPacket *avpkt)
2255 {
2256  AVFrame *frame = data;
2257  const uint8_t *buf = avpkt->data;
2258  int buf_size = avpkt->size;
2259  MJpegDecodeContext *s = avctx->priv_data;
2260  const uint8_t *buf_end, *buf_ptr;
2261  const uint8_t *unescaped_buf_ptr;
2262  int hshift, vshift;
2263  int unescaped_buf_size;
2264  int start_code;
2265  int i, index;
2266  int ret = 0;
2267  int is16bit;
2268 
2269  s->buf_size = buf_size;
2270 
2272  av_freep(&s->stereo3d);
2273  s->adobe_transform = -1;
2274 
2275  if (s->iccnum != 0)
2276  reset_icc_profile(s);
2277 
2278  buf_ptr = buf;
2279  buf_end = buf + buf_size;
2280  while (buf_ptr < buf_end) {
2281  /* find start next marker */
2282  start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2283  &unescaped_buf_ptr,
2284  &unescaped_buf_size);
2285  /* EOF */
2286  if (start_code < 0) {
2287  break;
2288  } else if (unescaped_buf_size > INT_MAX / 8) {
2289  av_log(avctx, AV_LOG_ERROR,
2290  "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2291  start_code, unescaped_buf_size, buf_size);
2292  return AVERROR_INVALIDDATA;
2293  }
2294  av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2295  start_code, buf_end - buf_ptr);
2296 
2297  ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2298 
2299  if (ret < 0) {
2300  av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2301  goto fail;
2302  }
2303 
2304  s->start_code = start_code;
2305  if (s->avctx->debug & FF_DEBUG_STARTCODE)
2306  av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2307 
2308  /* process markers */
2309  if (start_code >= 0xd0 && start_code <= 0xd7) {
2310  av_log(avctx, AV_LOG_DEBUG,
2311  "restart marker: %d\n", start_code & 0x0f);
2312  /* APP fields */
2313  } else if (start_code >= APP0 && start_code <= APP15) {
2314  if ((ret = mjpeg_decode_app(s)) < 0)
2315  av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2316  av_err2str(ret));
2317  /* Comment */
2318  } else if (start_code == COM) {
2319  ret = mjpeg_decode_com(s);
2320  if (ret < 0)
2321  return ret;
2322  } else if (start_code == DQT) {
2323  ret = ff_mjpeg_decode_dqt(s);
2324  if (ret < 0)
2325  return ret;
2326  }
2327 
2328  ret = -1;
2329 
2330  if (!CONFIG_JPEGLS_DECODER &&
2331  (start_code == SOF48 || start_code == LSE)) {
2332  av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2333  return AVERROR(ENOSYS);
2334  }
2335 
2336  if (avctx->skip_frame == AVDISCARD_ALL) {
2337  switch(start_code) {
2338  case SOF0:
2339  case SOF1:
2340  case SOF2:
2341  case SOF3:
2342  case SOF48:
2343  case SOI:
2344  case SOS:
2345  case EOI:
2346  break;
2347  default:
2348  goto skip;
2349  }
2350  }
2351 
2352  switch (start_code) {
2353  case SOI:
2354  s->restart_interval = 0;
2355  s->restart_count = 0;
2356  s->raw_image_buffer = buf_ptr;
2357  s->raw_image_buffer_size = buf_end - buf_ptr;
2358  /* nothing to do on SOI */
2359  break;
2360  case DHT:
2361  if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2362  av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2363  goto fail;
2364  }
2365  break;
2366  case SOF0:
2367  case SOF1:
2368  if (start_code == SOF0)
2370  else
2372  s->lossless = 0;
2373  s->ls = 0;
2374  s->progressive = 0;
2375  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2376  goto fail;
2377  break;
2378  case SOF2:
2380  s->lossless = 0;
2381  s->ls = 0;
2382  s->progressive = 1;
2383  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2384  goto fail;
2385  break;
2386  case SOF3:
2389  s->lossless = 1;
2390  s->ls = 0;
2391  s->progressive = 0;
2392  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2393  goto fail;
2394  break;
2395  case SOF48:
2398  s->lossless = 1;
2399  s->ls = 1;
2400  s->progressive = 0;
2401  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2402  goto fail;
2403  break;
2404  case LSE:
2405  if (!CONFIG_JPEGLS_DECODER ||
2406  (ret = ff_jpegls_decode_lse(s)) < 0)
2407  goto fail;
2408  break;
2409  case EOI:
2410 eoi_parser:
2411  if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2412  s->progressive && s->cur_scan && s->got_picture)
2414  s->cur_scan = 0;
2415  if (!s->got_picture) {
2416  av_log(avctx, AV_LOG_WARNING,
2417  "Found EOI before any SOF, ignoring\n");
2418  break;
2419  }
2420  if (s->interlaced) {
2421  s->bottom_field ^= 1;
2422  /* if not bottom field, do not output image yet */
2423  if (s->bottom_field == !s->interlace_polarity)
2424  break;
2425  }
2426  if (avctx->skip_frame == AVDISCARD_ALL) {
2427  s->got_picture = 0;
2428  goto the_end_no_picture;
2429  }
2430  if (s->avctx->hwaccel) {
2431  ret = s->avctx->hwaccel->end_frame(s->avctx);
2432  if (ret < 0)
2433  return ret;
2434 
2436  }
2437  if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2438  return ret;
2439  *got_frame = 1;
2440  s->got_picture = 0;
2441 
2442  if (!s->lossless) {
2443  int qp = FFMAX3(s->qscale[0],
2444  s->qscale[1],
2445  s->qscale[2]);
2446  int qpw = (s->width + 15) / 16;
2447  AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2448  if (qp_table_buf) {
2449  memset(qp_table_buf->data, qp, qpw);
2450  av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2451  }
2452 
2453  if(avctx->debug & FF_DEBUG_QP)
2454  av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2455  }
2456 
2457  goto the_end;
2458  case SOS:
2459  s->raw_scan_buffer = buf_ptr;
2460  s->raw_scan_buffer_size = buf_end - buf_ptr;
2461 
2462  s->cur_scan++;
2463  if (avctx->skip_frame == AVDISCARD_ALL) {
2464  skip_bits(&s->gb, get_bits_left(&s->gb));
2465  break;
2466  }
2467 
2468  if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2469  (avctx->err_recognition & AV_EF_EXPLODE))
2470  goto fail;
2471  break;
2472  case DRI:
2473  if ((ret = mjpeg_decode_dri(s)) < 0)
2474  return ret;
2475  break;
2476  case SOF5:
2477  case SOF6:
2478  case SOF7:
2479  case SOF9:
2480  case SOF10:
2481  case SOF11:
2482  case SOF13:
2483  case SOF14:
2484  case SOF15:
2485  case JPG:
2486  av_log(avctx, AV_LOG_ERROR,
2487  "mjpeg: unsupported coding type (%x)\n", start_code);
2488  break;
2489  }
2490 
2491 skip:
2492  /* eof process start code */
2493  buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2494  av_log(avctx, AV_LOG_DEBUG,
2495  "marker parser used %d bytes (%d bits)\n",
2496  (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2497  }
2498  if (s->got_picture && s->cur_scan) {
2499  av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2500  goto eoi_parser;
2501  }
2502  av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2503  return AVERROR_INVALIDDATA;
2504 fail:
2505  s->got_picture = 0;
2506  return ret;
2507 the_end:
2508 
2509  is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2510 
2511  if (AV_RB32(s->upscale_h)) {
2512  int p;
2514  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2515  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2516  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2517  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2518  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2519  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2520  avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2521  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2522  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2523  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2524  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2525  );
2526  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2527  if (ret)
2528  return ret;
2529 
2531  for (p = 0; p<s->nb_components; p++) {
2532  uint8_t *line = s->picture_ptr->data[p];
2533  int w = s->width;
2534  int h = s->height;
2535  if (!s->upscale_h[p])
2536  continue;
2537  if (p==1 || p==2) {
2538  w = AV_CEIL_RSHIFT(w, hshift);
2539  h = AV_CEIL_RSHIFT(h, vshift);
2540  }
2541  if (s->upscale_v[p] == 1)
2542  h = (h+1)>>1;
2543  av_assert0(w > 0);
2544  for (i = 0; i < h; i++) {
2545  if (s->upscale_h[p] == 1) {
2546  if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2547  else line[w - 1] = line[(w - 1) / 2];
2548  for (index = w - 2; index > 0; index--) {
2549  if (is16bit)
2550  ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2551  else
2552  line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2553  }
2554  } else if (s->upscale_h[p] == 2) {
2555  if (is16bit) {
2556  ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2557  if (w > 1)
2558  ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2559  } else {
2560  line[w - 1] = line[(w - 1) / 3];
2561  if (w > 1)
2562  line[w - 2] = line[w - 1];
2563  }
2564  for (index = w - 3; index > 0; index--) {
2565  line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2566  }
2567  }
2568  line += s->linesize[p];
2569  }
2570  }
2571  }
2572  if (AV_RB32(s->upscale_v)) {
2573  int p;
2575  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2576  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2577  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2578  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2579  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2580  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2581  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2582  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2583  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2584  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2585  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2586  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2587  );
2588  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2589  if (ret)
2590  return ret;
2591 
2593  for (p = 0; p < s->nb_components; p++) {
2594  uint8_t *dst;
2595  int w = s->width;
2596  int h = s->height;
2597  if (!s->upscale_v[p])
2598  continue;
2599  if (p==1 || p==2) {
2600  w = AV_CEIL_RSHIFT(w, hshift);
2601  h = AV_CEIL_RSHIFT(h, vshift);
2602  }
2603  dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2604  for (i = h - 1; i; i--) {
2605  uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2606  uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
2607  if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
2608  memcpy(dst, src1, w);
2609  } else {
2610  for (index = 0; index < w; index++)
2611  dst[index] = (src1[index] + src2[index]) >> 1;
2612  }
2613  dst -= s->linesize[p];
2614  }
2615  }
2616  }
2617  if (s->flipped && !s->rgb) {
2618  int j;
2619  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2620  if (ret)
2621  return ret;
2622 
2624  for (index=0; index<s->nb_components; index++) {
2625  uint8_t *dst = s->picture_ptr->data[index];
2626  int w = s->picture_ptr->width;
2627  int h = s->picture_ptr->height;
2628  if(index && index<3){
2629  w = AV_CEIL_RSHIFT(w, hshift);
2630  h = AV_CEIL_RSHIFT(h, vshift);
2631  }
2632  if(dst){
2633  uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2634  for (i=0; i<h/2; i++) {
2635  for (j=0; j<w; j++)
2636  FFSWAP(int, dst[j], dst2[j]);
2637  dst += s->picture_ptr->linesize[index];
2638  dst2 -= s->picture_ptr->linesize[index];
2639  }
2640  }
2641  }
2642  }
2643  if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2644  int w = s->picture_ptr->width;
2645  int h = s->picture_ptr->height;
2646  av_assert0(s->nb_components == 4);
2647  for (i=0; i<h; i++) {
2648  int j;
2649  uint8_t *dst[4];
2650  for (index=0; index<4; index++) {
2651  dst[index] = s->picture_ptr->data[index]
2652  + s->picture_ptr->linesize[index]*i;
2653  }
2654  for (j=0; j<w; j++) {
2655  int k = dst[3][j];
2656  int r = dst[0][j] * k;
2657  int g = dst[1][j] * k;
2658  int b = dst[2][j] * k;
2659  dst[0][j] = g*257 >> 16;
2660  dst[1][j] = b*257 >> 16;
2661  dst[2][j] = r*257 >> 16;
2662  dst[3][j] = 255;
2663  }
2664  }
2665  }
2666  if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2667  int w = s->picture_ptr->width;
2668  int h = s->picture_ptr->height;
2669  av_assert0(s->nb_components == 4);
2670  for (i=0; i<h; i++) {
2671  int j;
2672  uint8_t *dst[4];
2673  for (index=0; index<4; index++) {
2674  dst[index] = s->picture_ptr->data[index]
2675  + s->picture_ptr->linesize[index]*i;
2676  }
2677  for (j=0; j<w; j++) {
2678  int k = dst[3][j];
2679  int r = (255 - dst[0][j]) * k;
2680  int g = (128 - dst[1][j]) * k;
2681  int b = (128 - dst[2][j]) * k;
2682  dst[0][j] = r*257 >> 16;
2683  dst[1][j] = (g*257 >> 16) + 128;
2684  dst[2][j] = (b*257 >> 16) + 128;
2685  dst[3][j] = 255;
2686  }
2687  }
2688  }
2689 
2690  if (s->stereo3d) {
2691  AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2692  if (stereo) {
2693  stereo->type = s->stereo3d->type;
2694  stereo->flags = s->stereo3d->flags;
2695  }
2696  av_freep(&s->stereo3d);
2697  }
2698 
2699  if (s->iccnum != 0 && s->iccnum == s->iccread) {
2700  AVFrameSideData *sd;
2701  size_t offset = 0;
2702  int total_size = 0;
2703  int i;
2704 
2705  /* Sum size of all parts. */
2706  for (i = 0; i < s->iccnum; i++)
2707  total_size += s->iccdatalens[i];
2708 
2709  sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2710  if (!sd) {
2711  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2712  return AVERROR(ENOMEM);
2713  }
2714 
2715  /* Reassemble the parts, which are now in-order. */
2716  for (i = 0; i < s->iccnum; i++) {
2717  memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2718  offset += s->iccdatalens[i];
2719  }
2720  }
2721 
2722  av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2724 
2725 the_end_no_picture:
2726  av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2727  buf_end - buf_ptr);
2728 // return buf_end - buf_ptr;
2729  return buf_ptr - buf;
2730 }
2731 
2733 {
2734  MJpegDecodeContext *s = avctx->priv_data;
2735  int i, j;
2736 
2737  if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2738  av_log(avctx, AV_LOG_INFO, "Single field\n");
2739  }
2740 
2741  if (s->picture) {
2742  av_frame_free(&s->picture);
2743  s->picture_ptr = NULL;
2744  } else if (s->picture_ptr)
2746 
2747  av_freep(&s->buffer);
2748  av_freep(&s->stereo3d);
2749  av_freep(&s->ljpeg_buffer);
2750  s->ljpeg_buffer_size = 0;
2751 
2752  for (i = 0; i < 3; i++) {
2753  for (j = 0; j < 4; j++)
2754  ff_free_vlc(&s->vlcs[i][j]);
2755  }
2756  for (i = 0; i < MAX_COMPONENTS; i++) {
2757  av_freep(&s->blocks[i]);
2758  av_freep(&s->last_nnz[i]);
2759  }
2761 
2762  reset_icc_profile(s);
2763 
2765 
2766  return 0;
2767 }
2768 
2769 static void decode_flush(AVCodecContext *avctx)
2770 {
2771  MJpegDecodeContext *s = avctx->priv_data;
2772  s->got_picture = 0;
2773 }
2774 
2775 #if CONFIG_MJPEG_DECODER
2776 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2777 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2778 static const AVOption options[] = {
2779  { "extern_huff", "Use external huffman table.",
2780  OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2781  { NULL },
2782 };
2783 
2784 static const AVClass mjpegdec_class = {
2785  .class_name = "MJPEG decoder",
2786  .item_name = av_default_item_name,
2787  .option = options,
2788  .version = LIBAVUTIL_VERSION_INT,
2789 };
2790 
2792  .name = "mjpeg",
2793  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2794  .type = AVMEDIA_TYPE_VIDEO,
2795  .id = AV_CODEC_ID_MJPEG,
2796  .priv_data_size = sizeof(MJpegDecodeContext),
2798  .close = ff_mjpeg_decode_end,
2800  .flush = decode_flush,
2801  .capabilities = AV_CODEC_CAP_DR1,
2802  .max_lowres = 3,
2803  .priv_class = &mjpegdec_class,
2804  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2806  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2807 #if CONFIG_MJPEG_NVDEC_HWACCEL
2808  HWACCEL_NVDEC(mjpeg),
2809 #endif
2810 #if CONFIG_MJPEG_VAAPI_HWACCEL
2811  HWACCEL_VAAPI(mjpeg),
2812 #endif
2813  NULL
2814  },
2815 };
2816 #endif
2817 #if CONFIG_THP_DECODER
2819  .name = "thp",
2820  .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2821  .type = AVMEDIA_TYPE_VIDEO,
2822  .id = AV_CODEC_ID_THP,
2823  .priv_data_size = sizeof(MJpegDecodeContext),
2825  .close = ff_mjpeg_decode_end,
2827  .flush = decode_flush,
2828  .capabilities = AV_CODEC_CAP_DR1,
2829  .max_lowres = 3,
2830  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
2831 };
2832 #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:2054
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:2239
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
Definition: mjpegdec.c:1520
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:1733
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:163
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:2253
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:263
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:2732
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:188
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:2094
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:2093
#define width
int component_id[MAX_COMPONENTS]
Definition: mjpegdec.h:86
static int mjpeg_decode_app(MJpegDecodeContext *s)
Definition: mjpegdec.c:1745
#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:1919
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:348
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:610
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:3328
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference)
Definition: mjpegdec.c:1555
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:3329
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:2769
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:1120
#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:2119
#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