FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 0x42111100:
598  case 0x24111100:
602  if (pix_fmt_id == 0x42111100) {
603  if (s->bits > 8)
604  goto unk_pixfmt;
605  s->upscale_h[1] = s->upscale_h[2] = 1;
606  } else if (pix_fmt_id == 0x24111100) {
607  if (s->bits > 8)
608  goto unk_pixfmt;
609  s->upscale_v[1] = s->upscale_v[2] = 1;
610  }
611  break;
612  case 0x41111100:
614  else
615  goto unk_pixfmt;
617  break;
618  default:
619 unk_pixfmt:
620  avpriv_report_missing_feature(s->avctx, "Pixel format 0x%x bits:%d", pix_fmt_id, s->bits);
621  memset(s->upscale_h, 0, sizeof(s->upscale_h));
622  memset(s->upscale_v, 0, sizeof(s->upscale_v));
623  return AVERROR_PATCHWELCOME;
624  }
625  if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->avctx->lowres) {
626  avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
627  return AVERROR_PATCHWELCOME;
628  }
629  if (s->ls) {
630  memset(s->upscale_h, 0, sizeof(s->upscale_h));
631  memset(s->upscale_v, 0, sizeof(s->upscale_v));
632  if (s->nb_components == 3) {
634  } else if (s->nb_components != 1) {
635  av_log(s->avctx, AV_LOG_ERROR, "Unsupported number of components %d\n", s->nb_components);
636  return AVERROR_PATCHWELCOME;
637  } else if (s->palette_index && s->bits <= 8)
639  else if (s->bits <= 8)
641  else
643  }
644 
646  if (!s->pix_desc) {
647  av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
648  return AVERROR_BUG;
649  }
650 
651  if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
652  s->avctx->pix_fmt = s->hwaccel_pix_fmt;
653  } else {
654  enum AVPixelFormat pix_fmts[] = {
655 #if CONFIG_MJPEG_NVDEC_HWACCEL
657 #endif
658 #if CONFIG_MJPEG_VAAPI_HWACCEL
660 #endif
661  s->avctx->pix_fmt,
663  };
664  s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
665  if (s->hwaccel_pix_fmt < 0)
666  return AVERROR(EINVAL);
667 
669  s->avctx->pix_fmt = s->hwaccel_pix_fmt;
670  }
671 
672  if (s->avctx->skip_frame == AVDISCARD_ALL) {
674  s->picture_ptr->key_frame = 1;
675  s->got_picture = 1;
676  return 0;
677  }
678 
681  return -1;
683  s->picture_ptr->key_frame = 1;
684  s->got_picture = 1;
685 
686  for (i = 0; i < 4; i++)
687  s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
688 
689  ff_dlog(s->avctx, "%d %d %d %d %d %d\n",
690  s->width, s->height, s->linesize[0], s->linesize[1],
691  s->interlaced, s->avctx->height);
692 
693  if (len != (8 + (3 * nb_components)))
694  av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
695  }
696 
697  if ((s->rgb && !s->lossless && !s->ls) ||
698  (!s->rgb && s->ls && s->nb_components > 1)) {
699  av_log(s->avctx, AV_LOG_ERROR, "Unsupported coding and pixel format combination\n");
700  return AVERROR_PATCHWELCOME;
701  }
702 
703  /* totally blank picture as progressive JPEG will only add details to it */
704  if (s->progressive) {
705  int bw = (width + s->h_max * 8 - 1) / (s->h_max * 8);
706  int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
707  for (i = 0; i < s->nb_components; i++) {
708  int size = bw * bh * s->h_count[i] * s->v_count[i];
709  av_freep(&s->blocks[i]);
710  av_freep(&s->last_nnz[i]);
711  s->blocks[i] = av_mallocz_array(size, sizeof(**s->blocks));
712  s->last_nnz[i] = av_mallocz_array(size, sizeof(**s->last_nnz));
713  if (!s->blocks[i] || !s->last_nnz[i])
714  return AVERROR(ENOMEM);
715  s->block_stride[i] = bw * s->h_count[i];
716  }
717  memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
718  }
719 
720  if (s->avctx->hwaccel) {
723  if (!s->hwaccel_picture_private)
724  return AVERROR(ENOMEM);
725 
726  ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
728  if (ret < 0)
729  return ret;
730  }
731 
732  return 0;
733 }
734 
735 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
736 {
737  int code;
738  code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
739  if (code < 0 || code > 16) {
741  "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
742  0, dc_index, &s->vlcs[0][dc_index]);
743  return 0xfffff;
744  }
745 
746  if (code)
747  return get_xbits(&s->gb, code);
748  else
749  return 0;
750 }
751 
752 /* decode block and dequantize */
753 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
754  int dc_index, int ac_index, uint16_t *quant_matrix)
755 {
756  int code, i, j, level, val;
757 
758  /* DC coef */
759  val = mjpeg_decode_dc(s, dc_index);
760  if (val == 0xfffff) {
761  av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
762  return AVERROR_INVALIDDATA;
763  }
764  val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
765  val = av_clip_int16(val);
766  s->last_dc[component] = val;
767  block[0] = val;
768  /* AC coefs */
769  i = 0;
770  {OPEN_READER(re, &s->gb);
771  do {
772  UPDATE_CACHE(re, &s->gb);
773  GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
774 
775  i += ((unsigned)code) >> 4;
776  code &= 0xf;
777  if (code) {
778  if (code > MIN_CACHE_BITS - 16)
779  UPDATE_CACHE(re, &s->gb);
780 
781  {
782  int cache = GET_CACHE(re, &s->gb);
783  int sign = (~cache) >> 31;
784  level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
785  }
786 
787  LAST_SKIP_BITS(re, &s->gb, code);
788 
789  if (i > 63) {
790  av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
791  return AVERROR_INVALIDDATA;
792  }
793  j = s->scantable.permutated[i];
794  block[j] = level * quant_matrix[i];
795  }
796  } while (i < 63);
797  CLOSE_READER(re, &s->gb);}
798 
799  return 0;
800 }
801 
803  int component, int dc_index,
804  uint16_t *quant_matrix, int Al)
805 {
806  unsigned val;
807  s->bdsp.clear_block(block);
808  val = mjpeg_decode_dc(s, dc_index);
809  if (val == 0xfffff) {
810  av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
811  return AVERROR_INVALIDDATA;
812  }
813  val = (val * (quant_matrix[0] << Al)) + s->last_dc[component];
814  s->last_dc[component] = val;
815  block[0] = val;
816  return 0;
817 }
818 
819 /* decode block and dequantize - progressive JPEG version */
821  uint8_t *last_nnz, int ac_index,
822  uint16_t *quant_matrix,
823  int ss, int se, int Al, int *EOBRUN)
824 {
825  int code, i, j, val, run;
826  unsigned level;
827 
828  if (*EOBRUN) {
829  (*EOBRUN)--;
830  return 0;
831  }
832 
833  {
834  OPEN_READER(re, &s->gb);
835  for (i = ss; ; i++) {
836  UPDATE_CACHE(re, &s->gb);
837  GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
838 
839  run = ((unsigned) code) >> 4;
840  code &= 0xF;
841  if (code) {
842  i += run;
843  if (code > MIN_CACHE_BITS - 16)
844  UPDATE_CACHE(re, &s->gb);
845 
846  {
847  int cache = GET_CACHE(re, &s->gb);
848  int sign = (~cache) >> 31;
849  level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
850  }
851 
852  LAST_SKIP_BITS(re, &s->gb, code);
853 
854  if (i >= se) {
855  if (i == se) {
856  j = s->scantable.permutated[se];
857  block[j] = level * (quant_matrix[se] << Al);
858  break;
859  }
860  av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
861  return AVERROR_INVALIDDATA;
862  }
863  j = s->scantable.permutated[i];
864  block[j] = level * (quant_matrix[i] << Al);
865  } else {
866  if (run == 0xF) {// ZRL - skip 15 coefficients
867  i += 15;
868  if (i >= se) {
869  av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
870  return AVERROR_INVALIDDATA;
871  }
872  } else {
873  val = (1 << run);
874  if (run) {
875  UPDATE_CACHE(re, &s->gb);
876  val += NEG_USR32(GET_CACHE(re, &s->gb), run);
877  LAST_SKIP_BITS(re, &s->gb, run);
878  }
879  *EOBRUN = val - 1;
880  break;
881  }
882  }
883  }
884  CLOSE_READER(re, &s->gb);
885  }
886 
887  if (i > *last_nnz)
888  *last_nnz = i;
889 
890  return 0;
891 }
892 
893 #define REFINE_BIT(j) { \
894  UPDATE_CACHE(re, &s->gb); \
895  sign = block[j] >> 15; \
896  block[j] += SHOW_UBITS(re, &s->gb, 1) * \
897  ((quant_matrix[i] ^ sign) - sign) << Al; \
898  LAST_SKIP_BITS(re, &s->gb, 1); \
899 }
900 
901 #define ZERO_RUN \
902 for (; ; i++) { \
903  if (i > last) { \
904  i += run; \
905  if (i > se) { \
906  av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
907  return -1; \
908  } \
909  break; \
910  } \
911  j = s->scantable.permutated[i]; \
912  if (block[j]) \
913  REFINE_BIT(j) \
914  else if (run-- == 0) \
915  break; \
916 }
917 
918 /* decode block and dequantize - progressive JPEG refinement pass */
920  uint8_t *last_nnz,
921  int ac_index, uint16_t *quant_matrix,
922  int ss, int se, int Al, int *EOBRUN)
923 {
924  int code, i = ss, j, sign, val, run;
925  int last = FFMIN(se, *last_nnz);
926 
927  OPEN_READER(re, &s->gb);
928  if (*EOBRUN) {
929  (*EOBRUN)--;
930  } else {
931  for (; ; i++) {
932  UPDATE_CACHE(re, &s->gb);
933  GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
934 
935  if (code & 0xF) {
936  run = ((unsigned) code) >> 4;
937  UPDATE_CACHE(re, &s->gb);
938  val = SHOW_UBITS(re, &s->gb, 1);
939  LAST_SKIP_BITS(re, &s->gb, 1);
940  ZERO_RUN;
941  j = s->scantable.permutated[i];
942  val--;
943  block[j] = ((quant_matrix[i] << Al) ^ val) - val;
944  if (i == se) {
945  if (i > *last_nnz)
946  *last_nnz = i;
947  CLOSE_READER(re, &s->gb);
948  return 0;
949  }
950  } else {
951  run = ((unsigned) code) >> 4;
952  if (run == 0xF) {
953  ZERO_RUN;
954  } else {
955  val = run;
956  run = (1 << run);
957  if (val) {
958  UPDATE_CACHE(re, &s->gb);
959  run += SHOW_UBITS(re, &s->gb, val);
960  LAST_SKIP_BITS(re, &s->gb, val);
961  }
962  *EOBRUN = run - 1;
963  break;
964  }
965  }
966  }
967 
968  if (i > *last_nnz)
969  *last_nnz = i;
970  }
971 
972  for (; i <= last; i++) {
973  j = s->scantable.permutated[i];
974  if (block[j])
975  REFINE_BIT(j)
976  }
977  CLOSE_READER(re, &s->gb);
978 
979  return 0;
980 }
981 #undef REFINE_BIT
982 #undef ZERO_RUN
983 
984 static int handle_rstn(MJpegDecodeContext *s, int nb_components)
985 {
986  int i;
987  int reset = 0;
988 
989  if (s->restart_interval) {
990  s->restart_count--;
991  if(s->restart_count == 0 && s->avctx->codec_id == AV_CODEC_ID_THP){
992  align_get_bits(&s->gb);
993  for (i = 0; i < nb_components; i++) /* reset dc */
994  s->last_dc[i] = (4 << s->bits);
995  }
996 
997  i = 8 + ((-get_bits_count(&s->gb)) & 7);
998  /* skip RSTn */
999  if (s->restart_count == 0) {
1000  if( show_bits(&s->gb, i) == (1 << i) - 1
1001  || show_bits(&s->gb, i) == 0xFF) {
1002  int pos = get_bits_count(&s->gb);
1003  align_get_bits(&s->gb);
1004  while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
1005  skip_bits(&s->gb, 8);
1006  if (get_bits_left(&s->gb) >= 8 && (get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
1007  for (i = 0; i < nb_components; i++) /* reset dc */
1008  s->last_dc[i] = (4 << s->bits);
1009  reset = 1;
1010  } else
1011  skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
1012  }
1013  }
1014  }
1015  return reset;
1016 }
1017 
1018 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int nb_components, int predictor, int point_transform)
1019 {
1020  int i, mb_x, mb_y;
1021  uint16_t (*buffer)[4];
1022  int left[4], top[4], topleft[4];
1023  const int linesize = s->linesize[0];
1024  const int mask = ((1 << s->bits) - 1) << point_transform;
1025  int resync_mb_y = 0;
1026  int resync_mb_x = 0;
1027 
1028  if (s->nb_components != 3 && s->nb_components != 4)
1029  return AVERROR_INVALIDDATA;
1030  if (s->v_max != 1 || s->h_max != 1 || !s->lossless)
1031  return AVERROR_INVALIDDATA;
1032 
1033 
1035 
1037  (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
1038  if (!s->ljpeg_buffer)
1039  return AVERROR(ENOMEM);
1040 
1041  buffer = s->ljpeg_buffer;
1042 
1043  for (i = 0; i < 4; i++)
1044  buffer[0][i] = 1 << (s->bits - 1);
1045 
1046  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1047  uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
1048 
1049  if (s->interlaced && s->bottom_field)
1050  ptr += linesize >> 1;
1051 
1052  for (i = 0; i < 4; i++)
1053  top[i] = left[i] = topleft[i] = buffer[0][i];
1054 
1055  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1056  int modified_predictor = predictor;
1057 
1058  if (s->restart_interval && !s->restart_count){
1060  resync_mb_x = mb_x;
1061  resync_mb_y = mb_y;
1062  for(i=0; i<4; i++)
1063  top[i] = left[i]= topleft[i]= 1 << (s->bits - 1);
1064  }
1065  if (mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || !mb_x)
1066  modified_predictor = 1;
1067 
1068  for (i=0;i<nb_components;i++) {
1069  int pred, dc;
1070 
1071  topleft[i] = top[i];
1072  top[i] = buffer[mb_x][i];
1073 
1074  PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1075 
1076  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1077  if(dc == 0xFFFFF)
1078  return -1;
1079 
1080  left[i] = buffer[mb_x][i] =
1081  mask & (pred + (dc * (1 << point_transform)));
1082  }
1083 
1084  if (s->restart_interval && !--s->restart_count) {
1085  align_get_bits(&s->gb);
1086  skip_bits(&s->gb, 16); /* skip RSTn */
1087  }
1088  }
1089  if (s->rct && s->nb_components == 4) {
1090  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1091  ptr[4*mb_x + 2] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1092  ptr[4*mb_x + 1] = buffer[mb_x][1] + ptr[4*mb_x + 2];
1093  ptr[4*mb_x + 3] = buffer[mb_x][2] + ptr[4*mb_x + 2];
1094  ptr[4*mb_x + 0] = buffer[mb_x][3];
1095  }
1096  } else if (s->nb_components == 4) {
1097  for(i=0; i<nb_components; i++) {
1098  int c= s->comp_index[i];
1099  if (s->bits <= 8) {
1100  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1101  ptr[4*mb_x+3-c] = buffer[mb_x][i];
1102  }
1103  } else if(s->bits == 9) {
1104  return AVERROR_PATCHWELCOME;
1105  } else {
1106  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1107  ((uint16_t*)ptr)[4*mb_x+c] = buffer[mb_x][i];
1108  }
1109  }
1110  }
1111  } else if (s->rct) {
1112  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1113  ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
1114  ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1115  ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1116  }
1117  } else if (s->pegasus_rct) {
1118  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1119  ptr[3*mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
1120  ptr[3*mb_x + 0] = buffer[mb_x][1] + ptr[3*mb_x + 1];
1121  ptr[3*mb_x + 2] = buffer[mb_x][2] + ptr[3*mb_x + 1];
1122  }
1123  } else {
1124  for(i=0; i<nb_components; i++) {
1125  int c= s->comp_index[i];
1126  if (s->bits <= 8) {
1127  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1128  ptr[3*mb_x+2-c] = buffer[mb_x][i];
1129  }
1130  } else if(s->bits == 9) {
1131  return AVERROR_PATCHWELCOME;
1132  } else {
1133  for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1134  ((uint16_t*)ptr)[3*mb_x+2-c] = buffer[mb_x][i];
1135  }
1136  }
1137  }
1138  }
1139  }
1140  return 0;
1141 }
1142 
1143 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
1144  int point_transform, int nb_components)
1145 {
1146  int i, mb_x, mb_y, mask;
1147  int bits= (s->bits+7)&~7;
1148  int resync_mb_y = 0;
1149  int resync_mb_x = 0;
1150 
1151  point_transform += bits - s->bits;
1152  mask = ((1 << s->bits) - 1) << point_transform;
1153 
1154  av_assert0(nb_components>=1 && nb_components<=4);
1155 
1156  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1157  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1158  if (get_bits_left(&s->gb) < 1) {
1159  av_log(s->avctx, AV_LOG_ERROR, "bitstream end in yuv_scan\n");
1160  return AVERROR_INVALIDDATA;
1161  }
1162  if (s->restart_interval && !s->restart_count){
1164  resync_mb_x = mb_x;
1165  resync_mb_y = mb_y;
1166  }
1167 
1168  if(!mb_x || mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x || s->interlaced){
1169  int toprow = mb_y == resync_mb_y || mb_y == resync_mb_y+1 && mb_x < resync_mb_x;
1170  int leftcol = !mb_x || mb_y == resync_mb_y && mb_x == resync_mb_x;
1171  for (i = 0; i < nb_components; i++) {
1172  uint8_t *ptr;
1173  uint16_t *ptr16;
1174  int n, h, v, x, y, c, j, linesize;
1175  n = s->nb_blocks[i];
1176  c = s->comp_index[i];
1177  h = s->h_scount[i];
1178  v = s->v_scount[i];
1179  x = 0;
1180  y = 0;
1181  linesize= s->linesize[c];
1182 
1183  if(bits>8) linesize /= 2;
1184 
1185  for(j=0; j<n; j++) {
1186  int pred, dc;
1187 
1188  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1189  if(dc == 0xFFFFF)
1190  return -1;
1191  if ( h * mb_x + x >= s->width
1192  || v * mb_y + y >= s->height) {
1193  // Nothing to do
1194  } else if (bits<=8) {
1195  ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1196  if(y==0 && toprow){
1197  if(x==0 && leftcol){
1198  pred= 1 << (bits - 1);
1199  }else{
1200  pred= ptr[-1];
1201  }
1202  }else{
1203  if(x==0 && leftcol){
1204  pred= ptr[-linesize];
1205  }else{
1206  PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1207  }
1208  }
1209 
1210  if (s->interlaced && s->bottom_field)
1211  ptr += linesize >> 1;
1212  pred &= mask;
1213  *ptr= pred + ((unsigned)dc << point_transform);
1214  }else{
1215  ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1216  if(y==0 && toprow){
1217  if(x==0 && leftcol){
1218  pred= 1 << (bits - 1);
1219  }else{
1220  pred= ptr16[-1];
1221  }
1222  }else{
1223  if(x==0 && leftcol){
1224  pred= ptr16[-linesize];
1225  }else{
1226  PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1227  }
1228  }
1229 
1230  if (s->interlaced && s->bottom_field)
1231  ptr16 += linesize >> 1;
1232  pred &= mask;
1233  *ptr16= pred + ((unsigned)dc << point_transform);
1234  }
1235  if (++x == h) {
1236  x = 0;
1237  y++;
1238  }
1239  }
1240  }
1241  } else {
1242  for (i = 0; i < nb_components; i++) {
1243  uint8_t *ptr;
1244  uint16_t *ptr16;
1245  int n, h, v, x, y, c, j, linesize, dc;
1246  n = s->nb_blocks[i];
1247  c = s->comp_index[i];
1248  h = s->h_scount[i];
1249  v = s->v_scount[i];
1250  x = 0;
1251  y = 0;
1252  linesize = s->linesize[c];
1253 
1254  if(bits>8) linesize /= 2;
1255 
1256  for (j = 0; j < n; j++) {
1257  int pred;
1258 
1259  dc = mjpeg_decode_dc(s, s->dc_index[i]);
1260  if(dc == 0xFFFFF)
1261  return -1;
1262  if ( h * mb_x + x >= s->width
1263  || v * mb_y + y >= s->height) {
1264  // Nothing to do
1265  } else if (bits<=8) {
1266  ptr = s->picture_ptr->data[c] +
1267  (linesize * (v * mb_y + y)) +
1268  (h * mb_x + x); //FIXME optimize this crap
1269  PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1270 
1271  pred &= mask;
1272  *ptr = pred + ((unsigned)dc << point_transform);
1273  }else{
1274  ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
1275  PREDICT(pred, ptr16[-linesize-1], ptr16[-linesize], ptr16[-1], predictor);
1276 
1277  pred &= mask;
1278  *ptr16= pred + ((unsigned)dc << point_transform);
1279  }
1280 
1281  if (++x == h) {
1282  x = 0;
1283  y++;
1284  }
1285  }
1286  }
1287  }
1288  if (s->restart_interval && !--s->restart_count) {
1289  align_get_bits(&s->gb);
1290  skip_bits(&s->gb, 16); /* skip RSTn */
1291  }
1292  }
1293  }
1294  return 0;
1295 }
1296 
1298  uint8_t *dst, const uint8_t *src,
1299  int linesize, int lowres)
1300 {
1301  switch (lowres) {
1302  case 0: s->hdsp.put_pixels_tab[1][0](dst, src, linesize, 8);
1303  break;
1304  case 1: copy_block4(dst, src, linesize, linesize, 4);
1305  break;
1306  case 2: copy_block2(dst, src, linesize, linesize, 2);
1307  break;
1308  case 3: *dst = *src;
1309  break;
1310  }
1311 }
1312 
1313 static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
1314 {
1315  int block_x, block_y;
1316  int size = 8 >> s->avctx->lowres;
1317  if (s->bits > 8) {
1318  for (block_y=0; block_y<size; block_y++)
1319  for (block_x=0; block_x<size; block_x++)
1320  *(uint16_t*)(ptr + 2*block_x + block_y*linesize) <<= 16 - s->bits;
1321  } else {
1322  for (block_y=0; block_y<size; block_y++)
1323  for (block_x=0; block_x<size; block_x++)
1324  *(ptr + block_x + block_y*linesize) <<= 8 - s->bits;
1325  }
1326 }
1327 
1328 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
1329  int Al, const uint8_t *mb_bitmask,
1330  int mb_bitmask_size,
1331  const AVFrame *reference)
1332 {
1333  int i, mb_x, mb_y, chroma_h_shift, chroma_v_shift, chroma_width, chroma_height;
1335  const uint8_t *reference_data[MAX_COMPONENTS];
1336  int linesize[MAX_COMPONENTS];
1337  GetBitContext mb_bitmask_gb = {0}; // initialize to silence gcc warning
1338  int bytes_per_pixel = 1 + (s->bits > 8);
1339 
1340  if (mb_bitmask) {
1341  if (mb_bitmask_size != (s->mb_width * s->mb_height + 7)>>3) {
1342  av_log(s->avctx, AV_LOG_ERROR, "mb_bitmask_size mismatches\n");
1343  return AVERROR_INVALIDDATA;
1344  }
1345  init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
1346  }
1347 
1348  s->restart_count = 0;
1349 
1350  av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &chroma_h_shift,
1351  &chroma_v_shift);
1352  chroma_width = AV_CEIL_RSHIFT(s->width, chroma_h_shift);
1353  chroma_height = AV_CEIL_RSHIFT(s->height, chroma_v_shift);
1354 
1355  for (i = 0; i < nb_components; i++) {
1356  int c = s->comp_index[i];
1357  data[c] = s->picture_ptr->data[c];
1358  reference_data[c] = reference ? reference->data[c] : NULL;
1359  linesize[c] = s->linesize[c];
1360  s->coefs_finished[c] |= 1;
1361  }
1362 
1363  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1364  for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1365  const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
1366 
1367  if (s->restart_interval && !s->restart_count)
1369 
1370  if (get_bits_left(&s->gb) < 0) {
1371  av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
1372  -get_bits_left(&s->gb));
1373  return AVERROR_INVALIDDATA;
1374  }
1375  for (i = 0; i < nb_components; i++) {
1376  uint8_t *ptr;
1377  int n, h, v, x, y, c, j;
1378  int block_offset;
1379  n = s->nb_blocks[i];
1380  c = s->comp_index[i];
1381  h = s->h_scount[i];
1382  v = s->v_scount[i];
1383  x = 0;
1384  y = 0;
1385  for (j = 0; j < n; j++) {
1386  block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
1387  (h * mb_x + x) * 8 * bytes_per_pixel) >> s->avctx->lowres);
1388 
1389  if (s->interlaced && s->bottom_field)
1390  block_offset += linesize[c] >> 1;
1391  if ( 8*(h * mb_x + x) < ((c == 1) || (c == 2) ? chroma_width : s->width)
1392  && 8*(v * mb_y + y) < ((c == 1) || (c == 2) ? chroma_height : s->height)) {
1393  ptr = data[c] + block_offset;
1394  } else
1395  ptr = NULL;
1396  if (!s->progressive) {
1397  if (copy_mb) {
1398  if (ptr)
1399  mjpeg_copy_block(s, ptr, reference_data[c] + block_offset,
1400  linesize[c], s->avctx->lowres);
1401 
1402  } else {
1403  s->bdsp.clear_block(s->block);
1404  if (decode_block(s, s->block, i,
1405  s->dc_index[i], s->ac_index[i],
1406  s->quant_matrixes[s->quant_sindex[i]]) < 0) {
1408  "error y=%d x=%d\n", mb_y, mb_x);
1409  return AVERROR_INVALIDDATA;
1410  }
1411  if (ptr) {
1412  s->idsp.idct_put(ptr, linesize[c], s->block);
1413  if (s->bits & 7)
1414  shift_output(s, ptr, linesize[c]);
1415  }
1416  }
1417  } else {
1418  int block_idx = s->block_stride[c] * (v * mb_y + y) +
1419  (h * mb_x + x);
1420  int16_t *block = s->blocks[c][block_idx];
1421  if (Ah)
1422  block[0] += get_bits1(&s->gb) *
1423  s->quant_matrixes[s->quant_sindex[i]][0] << Al;
1424  else if (decode_dc_progressive(s, block, i, s->dc_index[i],
1425  s->quant_matrixes[s->quant_sindex[i]],
1426  Al) < 0) {
1428  "error y=%d x=%d\n", mb_y, mb_x);
1429  return AVERROR_INVALIDDATA;
1430  }
1431  }
1432  ff_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
1433  ff_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
1434  mb_x, mb_y, x, y, c, s->bottom_field,
1435  (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1436  if (++x == h) {
1437  x = 0;
1438  y++;
1439  }
1440  }
1441  }
1442 
1443  handle_rstn(s, nb_components);
1444  }
1445  }
1446  return 0;
1447 }
1448 
1450  int se, int Ah, int Al)
1451 {
1452  int mb_x, mb_y;
1453  int EOBRUN = 0;
1454  int c = s->comp_index[0];
1455  uint16_t *quant_matrix = s->quant_matrixes[s->quant_sindex[0]];
1456 
1457  av_assert0(ss>=0 && Ah>=0 && Al>=0);
1458  if (se < ss || se > 63) {
1459  av_log(s->avctx, AV_LOG_ERROR, "SS/SE %d/%d is invalid\n", ss, se);
1460  return AVERROR_INVALIDDATA;
1461  }
1462 
1463  // s->coefs_finished is a bitmask for coefficients coded
1464  // ss and se are parameters telling start and end coefficients
1465  s->coefs_finished[c] |= (2ULL << se) - (1ULL << ss);
1466 
1467  s->restart_count = 0;
1468 
1469  for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1470  int block_idx = mb_y * s->block_stride[c];
1471  int16_t (*block)[64] = &s->blocks[c][block_idx];
1472  uint8_t *last_nnz = &s->last_nnz[c][block_idx];
1473  if (get_bits_left(&s->gb) <= 0) {
1474  av_log(s->avctx, AV_LOG_ERROR, "bitstream truncated in mjpeg_decode_scan_progressive_ac\n");
1475  return AVERROR_INVALIDDATA;
1476  }
1477  for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
1478  int ret;
1479  if (s->restart_interval && !s->restart_count)
1481 
1482  if (Ah)
1483  ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
1484  quant_matrix, ss, se, Al, &EOBRUN);
1485  else
1486  ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
1487  quant_matrix, ss, se, Al, &EOBRUN);
1488  if (ret < 0) {
1490  "error y=%d x=%d\n", mb_y, mb_x);
1491  return AVERROR_INVALIDDATA;
1492  }
1493 
1494  if (handle_rstn(s, 0))
1495  EOBRUN = 0;
1496  }
1497  }
1498  return 0;
1499 }
1500 
1502 {
1503  int mb_x, mb_y;
1504  int c;
1505  const int bytes_per_pixel = 1 + (s->bits > 8);
1506  const int block_size = s->lossless ? 1 : 8;
1507 
1508  for (c = 0; c < s->nb_components; c++) {
1509  uint8_t *data = s->picture_ptr->data[c];
1510  int linesize = s->linesize[c];
1511  int h = s->h_max / s->h_count[c];
1512  int v = s->v_max / s->v_count[c];
1513  int mb_width = (s->width + h * block_size - 1) / (h * block_size);
1514  int mb_height = (s->height + v * block_size - 1) / (v * block_size);
1515 
1516  if (~s->coefs_finished[c])
1517  av_log(s->avctx, AV_LOG_WARNING, "component %d is incomplete\n", c);
1518 
1519  if (s->interlaced && s->bottom_field)
1520  data += linesize >> 1;
1521 
1522  for (mb_y = 0; mb_y < mb_height; mb_y++) {
1523  uint8_t *ptr = data + (mb_y * linesize * 8 >> s->avctx->lowres);
1524  int block_idx = mb_y * s->block_stride[c];
1525  int16_t (*block)[64] = &s->blocks[c][block_idx];
1526  for (mb_x = 0; mb_x < mb_width; mb_x++, block++) {
1527  s->idsp.idct_put(ptr, linesize, *block);
1528  if (s->bits & 7)
1529  shift_output(s, ptr, linesize);
1530  ptr += bytes_per_pixel*8 >> s->avctx->lowres;
1531  }
1532  }
1533  }
1534 }
1535 
1537  int mb_bitmask_size, const AVFrame *reference)
1538 {
1539  int len, nb_components, i, h, v, predictor, point_transform;
1540  int index, id, ret;
1541  const int block_size = s->lossless ? 1 : 8;
1542  int ilv, prev_shift;
1543 
1544  if (!s->got_picture) {
1546  "Can not process SOS before SOF, skipping\n");
1547  return -1;
1548  }
1549 
1550  if (reference) {
1551  if (reference->width != s->picture_ptr->width ||
1552  reference->height != s->picture_ptr->height ||
1553  reference->format != s->picture_ptr->format) {
1554  av_log(s->avctx, AV_LOG_ERROR, "Reference mismatching\n");
1555  return AVERROR_INVALIDDATA;
1556  }
1557  }
1558 
1559  /* XXX: verify len field validity */
1560  len = get_bits(&s->gb, 16);
1561  nb_components = get_bits(&s->gb, 8);
1562  if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1564  "decode_sos: nb_components (%d)",
1565  nb_components);
1566  return AVERROR_PATCHWELCOME;
1567  }
1568  if (len != 6 + 2 * nb_components) {
1569  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1570  return AVERROR_INVALIDDATA;
1571  }
1572  for (i = 0; i < nb_components; i++) {
1573  id = get_bits(&s->gb, 8) - 1;
1574  av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1575  /* find component index */
1576  for (index = 0; index < s->nb_components; index++)
1577  if (id == s->component_id[index])
1578  break;
1579  if (index == s->nb_components) {
1581  "decode_sos: index(%d) out of components\n", index);
1582  return AVERROR_INVALIDDATA;
1583  }
1584  /* Metasoft MJPEG codec has Cb and Cr swapped */
1585  if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1586  && nb_components == 3 && s->nb_components == 3 && i)
1587  index = 3 - i;
1588 
1589  s->quant_sindex[i] = s->quant_index[index];
1590  s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1591  s->h_scount[i] = s->h_count[index];
1592  s->v_scount[i] = s->v_count[index];
1593 
1594  if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1595  index = (i+2)%3;
1596  if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
1597  index = (index+2)%3;
1598 
1599  s->comp_index[i] = index;
1600 
1601  s->dc_index[i] = get_bits(&s->gb, 4);
1602  s->ac_index[i] = get_bits(&s->gb, 4);
1603 
1604  if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1605  s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1606  goto out_of_range;
1607  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))
1608  goto out_of_range;
1609  }
1610 
1611  predictor = get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1612  ilv = get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1613  if(s->avctx->codec_tag != AV_RL32("CJPG")){
1614  prev_shift = get_bits(&s->gb, 4); /* Ah */
1615  point_transform = get_bits(&s->gb, 4); /* Al */
1616  }else
1617  prev_shift = point_transform = 0;
1618 
1619  if (nb_components > 1) {
1620  /* interleaved stream */
1621  s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1622  s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1623  } else if (!s->ls) { /* skip this for JPEG-LS */
1624  h = s->h_max / s->h_scount[0];
1625  v = s->v_max / s->v_scount[0];
1626  s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1627  s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1628  s->nb_blocks[0] = 1;
1629  s->h_scount[0] = 1;
1630  s->v_scount[0] = 1;
1631  }
1632 
1633  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1634  av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d skip:%d %s comp:%d\n",
1635  s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1636  predictor, point_transform, ilv, s->bits, s->mjpb_skiptosod,
1637  s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""), nb_components);
1638 
1639 
1640  /* mjpeg-b can have padding bytes between sos and image data, skip them */
1641  for (i = s->mjpb_skiptosod; i > 0; i--)
1642  skip_bits(&s->gb, 8);
1643 
1644 next_field:
1645  for (i = 0; i < nb_components; i++)
1646  s->last_dc[i] = (4 << s->bits);
1647 
1648  if (s->avctx->hwaccel) {
1649  int bytes_to_start = get_bits_count(&s->gb) / 8;
1650  av_assert0(bytes_to_start >= 0 &&
1651  s->raw_scan_buffer_size >= bytes_to_start);
1652 
1653  ret = s->avctx->hwaccel->decode_slice(s->avctx,
1654  s->raw_scan_buffer + bytes_to_start,
1655  s->raw_scan_buffer_size - bytes_to_start);
1656  if (ret < 0)
1657  return ret;
1658 
1659  } else if (s->lossless) {
1660  av_assert0(s->picture_ptr == s->picture);
1661  if (CONFIG_JPEGLS_DECODER && s->ls) {
1662 // for () {
1663 // reset_ls_coding_parameters(s, 0);
1664 
1665  if ((ret = ff_jpegls_decode_picture(s, predictor,
1666  point_transform, ilv)) < 0)
1667  return ret;
1668  } else {
1669  if (s->rgb) {
1670  if ((ret = ljpeg_decode_rgb_scan(s, nb_components, predictor, point_transform)) < 0)
1671  return ret;
1672  } else {
1673  if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1674  point_transform,
1675  nb_components)) < 0)
1676  return ret;
1677  }
1678  }
1679  } else {
1680  if (s->progressive && predictor) {
1681  av_assert0(s->picture_ptr == s->picture);
1682  if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1683  ilv, prev_shift,
1684  point_transform)) < 0)
1685  return ret;
1686  } else {
1687  if ((ret = mjpeg_decode_scan(s, nb_components,
1688  prev_shift, point_transform,
1689  mb_bitmask, mb_bitmask_size, reference)) < 0)
1690  return ret;
1691  }
1692  }
1693 
1694  if (s->interlaced &&
1695  get_bits_left(&s->gb) > 32 &&
1696  show_bits(&s->gb, 8) == 0xFF) {
1697  GetBitContext bak = s->gb;
1698  align_get_bits(&bak);
1699  if (show_bits(&bak, 16) == 0xFFD1) {
1700  av_log(s->avctx, AV_LOG_DEBUG, "AVRn interlaced picture marker found\n");
1701  s->gb = bak;
1702  skip_bits(&s->gb, 16);
1703  s->bottom_field ^= 1;
1704 
1705  goto next_field;
1706  }
1707  }
1708 
1709  emms_c();
1710  return 0;
1711  out_of_range:
1712  av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1713  return AVERROR_INVALIDDATA;
1714 }
1715 
1717 {
1718  if (get_bits(&s->gb, 16) != 4)
1719  return AVERROR_INVALIDDATA;
1720  s->restart_interval = get_bits(&s->gb, 16);
1721  s->restart_count = 0;
1722  av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1723  s->restart_interval);
1724 
1725  return 0;
1726 }
1727 
1729 {
1730  int len, id, i;
1731 
1732  len = get_bits(&s->gb, 16);
1733  if (len < 6)
1734  return AVERROR_INVALIDDATA;
1735  if (8 * len > get_bits_left(&s->gb))
1736  return AVERROR_INVALIDDATA;
1737 
1738  id = get_bits_long(&s->gb, 32);
1739  len -= 6;
1740 
1741  if (s->avctx->debug & FF_DEBUG_STARTCODE)
1742  av_log(s->avctx, AV_LOG_DEBUG, "APPx (%s / %8X) len=%d\n",
1743  av_fourcc2str(av_bswap32(id)), id, len);
1744 
1745  /* Buggy AVID, it puts EOI only at every 10th frame. */
1746  /* Also, this fourcc is used by non-avid files too, it holds some
1747  information, but it's always present in AVID-created files. */
1748  if (id == AV_RB32("AVI1")) {
1749  /* structure:
1750  4bytes AVI1
1751  1bytes polarity
1752  1bytes always zero
1753  4bytes field_size
1754  4bytes field_size_less_padding
1755  */
1756  s->buggy_avid = 1;
1757  i = get_bits(&s->gb, 8); len--;
1758  av_log(s->avctx, AV_LOG_DEBUG, "polarity %d\n", i);
1759  goto out;
1760  }
1761 
1762  if (id == AV_RB32("JFIF")) {
1763  int t_w, t_h, v1, v2;
1764  if (len < 8)
1765  goto out;
1766  skip_bits(&s->gb, 8); /* the trailing zero-byte */
1767  v1 = get_bits(&s->gb, 8);
1768  v2 = get_bits(&s->gb, 8);
1769  skip_bits(&s->gb, 8);
1770 
1771  s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1772  s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1773  if ( s->avctx->sample_aspect_ratio.num <= 0
1774  || s->avctx->sample_aspect_ratio.den <= 0) {
1775  s->avctx->sample_aspect_ratio.num = 0;
1776  s->avctx->sample_aspect_ratio.den = 1;
1777  }
1778 
1779  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1780  av_log(s->avctx, AV_LOG_INFO,
1781  "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1782  v1, v2,
1785 
1786  len -= 8;
1787  if (len >= 2) {
1788  t_w = get_bits(&s->gb, 8);
1789  t_h = get_bits(&s->gb, 8);
1790  if (t_w && t_h) {
1791  /* skip thumbnail */
1792  if (len -10 - (t_w * t_h * 3) > 0)
1793  len -= t_w * t_h * 3;
1794  }
1795  len -= 2;
1796  }
1797  goto out;
1798  }
1799 
1800  if ( id == AV_RB32("Adob")
1801  && len >= 7
1802  && show_bits(&s->gb, 8) == 'e'
1803  && show_bits_long(&s->gb, 32) != AV_RB32("e_CM")) {
1804  skip_bits(&s->gb, 8); /* 'e' */
1805  skip_bits(&s->gb, 16); /* version */
1806  skip_bits(&s->gb, 16); /* flags0 */
1807  skip_bits(&s->gb, 16); /* flags1 */
1808  s->adobe_transform = get_bits(&s->gb, 8);
1809  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1810  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found, transform=%d\n", s->adobe_transform);
1811  len -= 7;
1812  goto out;
1813  }
1814 
1815  if (id == AV_RB32("LJIF")) {
1816  int rgb = s->rgb;
1817  int pegasus_rct = s->pegasus_rct;
1818  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1819  av_log(s->avctx, AV_LOG_INFO,
1820  "Pegasus lossless jpeg header found\n");
1821  skip_bits(&s->gb, 16); /* version ? */
1822  skip_bits(&s->gb, 16); /* unknown always 0? */
1823  skip_bits(&s->gb, 16); /* unknown always 0? */
1824  skip_bits(&s->gb, 16); /* unknown always 0? */
1825  switch (i=get_bits(&s->gb, 8)) {
1826  case 1:
1827  rgb = 1;
1828  pegasus_rct = 0;
1829  break;
1830  case 2:
1831  rgb = 1;
1832  pegasus_rct = 1;
1833  break;
1834  default:
1835  av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace %d\n", i);
1836  }
1837 
1838  len -= 9;
1839  if (s->got_picture)
1840  if (rgb != s->rgb || pegasus_rct != s->pegasus_rct) {
1841  av_log(s->avctx, AV_LOG_WARNING, "Mismatching LJIF tag\n");
1842  goto out;
1843  }
1844 
1845  s->rgb = rgb;
1846  s->pegasus_rct = pegasus_rct;
1847 
1848  goto out;
1849  }
1850  if (id == AV_RL32("colr") && len > 0) {
1851  s->colr = get_bits(&s->gb, 8);
1852  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1853  av_log(s->avctx, AV_LOG_INFO, "COLR %d\n", s->colr);
1854  len --;
1855  goto out;
1856  }
1857  if (id == AV_RL32("xfrm") && len > 0) {
1858  s->xfrm = get_bits(&s->gb, 8);
1859  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1860  av_log(s->avctx, AV_LOG_INFO, "XFRM %d\n", s->xfrm);
1861  len --;
1862  goto out;
1863  }
1864 
1865  /* JPS extension by VRex */
1866  if (s->start_code == APP3 && id == AV_RB32("_JPS") && len >= 10) {
1867  int flags, layout, type;
1868  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1869  av_log(s->avctx, AV_LOG_INFO, "_JPSJPS_\n");
1870 
1871  skip_bits(&s->gb, 32); len -= 4; /* JPS_ */
1872  skip_bits(&s->gb, 16); len -= 2; /* block length */
1873  skip_bits(&s->gb, 8); /* reserved */
1874  flags = get_bits(&s->gb, 8);
1875  layout = get_bits(&s->gb, 8);
1876  type = get_bits(&s->gb, 8);
1877  len -= 4;
1878 
1879  s->stereo3d = av_stereo3d_alloc();
1880  if (!s->stereo3d) {
1881  goto out;
1882  }
1883  if (type == 0) {
1885  } else if (type == 1) {
1886  switch (layout) {
1887  case 0x01:
1889  break;
1890  case 0x02:
1892  break;
1893  case 0x03:
1895  break;
1896  }
1897  if (!(flags & 0x04)) {
1899  }
1900  }
1901  goto out;
1902  }
1903 
1904  /* EXIF metadata */
1905  if (s->start_code == APP1 && id == AV_RB32("Exif") && len >= 2) {
1906  GetByteContext gbytes;
1907  int ret, le, ifd_offset, bytes_read;
1908  const uint8_t *aligned;
1909 
1910  skip_bits(&s->gb, 16); // skip padding
1911  len -= 2;
1912 
1913  // init byte wise reading
1914  aligned = align_get_bits(&s->gb);
1915  bytestream2_init(&gbytes, aligned, len);
1916 
1917  // read TIFF header
1918  ret = ff_tdecode_header(&gbytes, &le, &ifd_offset);
1919  if (ret) {
1920  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: invalid TIFF header in EXIF data\n");
1921  } else {
1922  bytestream2_seek(&gbytes, ifd_offset, SEEK_SET);
1923 
1924  // read 0th IFD and store the metadata
1925  // (return values > 0 indicate the presence of subimage metadata)
1926  ret = ff_exif_decode_ifd(s->avctx, &gbytes, le, 0, &s->exif_metadata);
1927  if (ret < 0) {
1928  av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error decoding EXIF data\n");
1929  }
1930  }
1931 
1932  bytes_read = bytestream2_tell(&gbytes);
1933  skip_bits(&s->gb, bytes_read << 3);
1934  len -= bytes_read;
1935 
1936  goto out;
1937  }
1938 
1939  /* Apple MJPEG-A */
1940  if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1941  id = get_bits_long(&s->gb, 32);
1942  len -= 4;
1943  /* Apple MJPEG-A */
1944  if (id == AV_RB32("mjpg")) {
1945  /* structure:
1946  4bytes field size
1947  4bytes pad field size
1948  4bytes next off
1949  4bytes quant off
1950  4bytes huff off
1951  4bytes image off
1952  4bytes scan off
1953  4bytes data off
1954  */
1955  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1956  av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1957  }
1958  }
1959 
1960  if (s->start_code == APP2 && id == AV_RB32("ICC_") && len >= 10) {
1961  int id2;
1962  unsigned seqno;
1963  unsigned nummarkers;
1964 
1965  id = get_bits_long(&s->gb, 32);
1966  id2 = get_bits_long(&s->gb, 24);
1967  len -= 7;
1968  if (id != AV_RB32("PROF") || id2 != AV_RB24("ILE")) {
1969  av_log(s->avctx, AV_LOG_WARNING, "Invalid ICC_PROFILE header in APP2\n");
1970  goto out;
1971  }
1972 
1973  skip_bits(&s->gb, 8);
1974  seqno = get_bits(&s->gb, 8);
1975  len -= 2;
1976  if (seqno == 0) {
1977  av_log(s->avctx, AV_LOG_WARNING, "Invalid sequence number in APP2\n");
1978  goto out;
1979  }
1980 
1981  nummarkers = get_bits(&s->gb, 8);
1982  len -= 1;
1983  if (nummarkers == 0) {
1984  av_log(s->avctx, AV_LOG_WARNING, "Invalid number of markers coded in APP2\n");
1985  goto out;
1986  } else if (s->iccnum != 0 && nummarkers != s->iccnum) {
1987  av_log(s->avctx, AV_LOG_WARNING, "Mistmatch in coded number of ICC markers between markers\n");
1988  goto out;
1989  } else if (seqno > nummarkers) {
1990  av_log(s->avctx, AV_LOG_WARNING, "Mismatching sequence number and coded number of ICC markers\n");
1991  goto out;
1992  }
1993 
1994  /* Allocate if this is the first APP2 we've seen. */
1995  if (s->iccnum == 0) {
1996  s->iccdata = av_mallocz(nummarkers * sizeof(*(s->iccdata)));
1997  s->iccdatalens = av_mallocz(nummarkers * sizeof(*(s->iccdatalens)));
1998  if (!s->iccdata || !s->iccdatalens) {
1999  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data arrays\n");
2000  return AVERROR(ENOMEM);
2001  }
2002  s->iccnum = nummarkers;
2003  }
2004 
2005  if (s->iccdata[seqno - 1]) {
2006  av_log(s->avctx, AV_LOG_WARNING, "Duplicate ICC sequence number\n");
2007  goto out;
2008  }
2009 
2010  s->iccdatalens[seqno - 1] = len;
2011  s->iccdata[seqno - 1] = av_malloc(len);
2012  if (!s->iccdata[seqno - 1]) {
2013  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate ICC data buffer\n");
2014  return AVERROR(ENOMEM);
2015  }
2016 
2017  memcpy(s->iccdata[seqno - 1], align_get_bits(&s->gb), len);
2018  skip_bits(&s->gb, len << 3);
2019  len = 0;
2020  s->iccread++;
2021 
2022  if (s->iccread > s->iccnum)
2023  av_log(s->avctx, AV_LOG_WARNING, "Read more ICC markers than are supposed to be coded\n");
2024  }
2025 
2026 out:
2027  /* slow but needed for extreme adobe jpegs */
2028  if (len < 0)
2030  "mjpeg: error, decode_app parser read over the end\n");
2031  while (--len > 0)
2032  skip_bits(&s->gb, 8);
2033 
2034  return 0;
2035 }
2036 
2038 {
2039  int len = get_bits(&s->gb, 16);
2040  if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
2041  int i;
2042  char *cbuf = av_malloc(len - 1);
2043  if (!cbuf)
2044  return AVERROR(ENOMEM);
2045 
2046  for (i = 0; i < len - 2; i++)
2047  cbuf[i] = get_bits(&s->gb, 8);
2048  if (i > 0 && cbuf[i - 1] == '\n')
2049  cbuf[i - 1] = 0;
2050  else
2051  cbuf[i] = 0;
2052 
2053  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2054  av_log(s->avctx, AV_LOG_INFO, "comment: '%s'\n", cbuf);
2055 
2056  /* buggy avid, it puts EOI only at every 10th frame */
2057  if (!strncmp(cbuf, "AVID", 4)) {
2058  parse_avid(s, cbuf, len);
2059  } else if (!strcmp(cbuf, "CS=ITU601"))
2060  s->cs_itu601 = 1;
2061  else if ((!strncmp(cbuf, "Intel(R) JPEG Library, version 1", 32) && s->avctx->codec_tag) ||
2062  (!strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
2063  s->flipped = 1;
2064  else if (!strcmp(cbuf, "MULTISCOPE II")) {
2065  s->avctx->sample_aspect_ratio = (AVRational) { 1, 2 };
2066  s->multiscope = 2;
2067  }
2068 
2069  av_free(cbuf);
2070  }
2071 
2072  return 0;
2073 }
2074 
2075 /* return the 8 bit start code value and update the search
2076  state. Return -1 if no start code found */
2077 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
2078 {
2079  const uint8_t *buf_ptr;
2080  unsigned int v, v2;
2081  int val;
2082  int skipped = 0;
2083 
2084  buf_ptr = *pbuf_ptr;
2085  while (buf_end - buf_ptr > 1) {
2086  v = *buf_ptr++;
2087  v2 = *buf_ptr;
2088  if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2089  val = *buf_ptr++;
2090  goto found;
2091  }
2092  skipped++;
2093  }
2094  buf_ptr = buf_end;
2095  val = -1;
2096 found:
2097  ff_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
2098  *pbuf_ptr = buf_ptr;
2099  return val;
2100 }
2101 
2103  const uint8_t **buf_ptr, const uint8_t *buf_end,
2104  const uint8_t **unescaped_buf_ptr,
2105  int *unescaped_buf_size)
2106 {
2107  int start_code;
2108  start_code = find_marker(buf_ptr, buf_end);
2109 
2110  av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
2111  if (!s->buffer)
2112  return AVERROR(ENOMEM);
2113 
2114  /* unescape buffer of SOS, use special treatment for JPEG-LS */
2115  if (start_code == SOS && !s->ls) {
2116  const uint8_t *src = *buf_ptr;
2117  const uint8_t *ptr = src;
2118  uint8_t *dst = s->buffer;
2119 
2120  #define copy_data_segment(skip) do { \
2121  ptrdiff_t length = (ptr - src) - (skip); \
2122  if (length > 0) { \
2123  memcpy(dst, src, length); \
2124  dst += length; \
2125  src = ptr; \
2126  } \
2127  } while (0)
2128 
2129  if (s->avctx->codec_id == AV_CODEC_ID_THP) {
2130  ptr = buf_end;
2131  copy_data_segment(0);
2132  } else {
2133  while (ptr < buf_end) {
2134  uint8_t x = *(ptr++);
2135 
2136  if (x == 0xff) {
2137  ptrdiff_t skip = 0;
2138  while (ptr < buf_end && x == 0xff) {
2139  x = *(ptr++);
2140  skip++;
2141  }
2142 
2143  /* 0xFF, 0xFF, ... */
2144  if (skip > 1) {
2145  copy_data_segment(skip);
2146 
2147  /* decrement src as it is equal to ptr after the
2148  * copy_data_segment macro and we might want to
2149  * copy the current value of x later on */
2150  src--;
2151  }
2152 
2153  if (x < 0xd0 || x > 0xd7) {
2154  copy_data_segment(1);
2155  if (x)
2156  break;
2157  }
2158  }
2159  }
2160  if (src < ptr)
2161  copy_data_segment(0);
2162  }
2163  #undef copy_data_segment
2164 
2165  *unescaped_buf_ptr = s->buffer;
2166  *unescaped_buf_size = dst - s->buffer;
2167  memset(s->buffer + *unescaped_buf_size, 0,
2169 
2170  av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %"PTRDIFF_SPECIFIER" bytes\n",
2171  (buf_end - *buf_ptr) - (dst - s->buffer));
2172  } else if (start_code == SOS && s->ls) {
2173  const uint8_t *src = *buf_ptr;
2174  uint8_t *dst = s->buffer;
2175  int bit_count = 0;
2176  int t = 0, b = 0;
2177  PutBitContext pb;
2178 
2179  /* find marker */
2180  while (src + t < buf_end) {
2181  uint8_t x = src[t++];
2182  if (x == 0xff) {
2183  while ((src + t < buf_end) && x == 0xff)
2184  x = src[t++];
2185  if (x & 0x80) {
2186  t -= FFMIN(2, t);
2187  break;
2188  }
2189  }
2190  }
2191  bit_count = t * 8;
2192  init_put_bits(&pb, dst, t);
2193 
2194  /* unescape bitstream */
2195  while (b < t) {
2196  uint8_t x = src[b++];
2197  put_bits(&pb, 8, x);
2198  if (x == 0xFF && b < t) {
2199  x = src[b++];
2200  if (x & 0x80) {
2201  av_log(s->avctx, AV_LOG_WARNING, "Invalid escape sequence\n");
2202  x &= 0x7f;
2203  }
2204  put_bits(&pb, 7, x);
2205  bit_count--;
2206  }
2207  }
2208  flush_put_bits(&pb);
2209 
2210  *unescaped_buf_ptr = dst;
2211  *unescaped_buf_size = (bit_count + 7) >> 3;
2212  memset(s->buffer + *unescaped_buf_size, 0,
2214  } else {
2215  *unescaped_buf_ptr = *buf_ptr;
2216  *unescaped_buf_size = buf_end - *buf_ptr;
2217  }
2218 
2219  return start_code;
2220 }
2221 
2223 {
2224  int i;
2225 
2226  if (s->iccdata)
2227  for (i = 0; i < s->iccnum; i++)
2228  av_freep(&s->iccdata[i]);
2229  av_freep(&s->iccdata);
2230  av_freep(&s->iccdatalens);
2231 
2232  s->iccread = 0;
2233  s->iccnum = 0;
2234 }
2235 
2236 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
2237  AVPacket *avpkt)
2238 {
2239  AVFrame *frame = data;
2240  const uint8_t *buf = avpkt->data;
2241  int buf_size = avpkt->size;
2242  MJpegDecodeContext *s = avctx->priv_data;
2243  const uint8_t *buf_end, *buf_ptr;
2244  const uint8_t *unescaped_buf_ptr;
2245  int hshift, vshift;
2246  int unescaped_buf_size;
2247  int start_code;
2248  int i, index;
2249  int ret = 0;
2250  int is16bit;
2251 
2252  s->buf_size = buf_size;
2253 
2255  av_freep(&s->stereo3d);
2256  s->adobe_transform = -1;
2257 
2258  if (s->iccnum != 0)
2259  reset_icc_profile(s);
2260 
2261  buf_ptr = buf;
2262  buf_end = buf + buf_size;
2263  while (buf_ptr < buf_end) {
2264  /* find start next marker */
2265  start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
2266  &unescaped_buf_ptr,
2267  &unescaped_buf_size);
2268  /* EOF */
2269  if (start_code < 0) {
2270  break;
2271  } else if (unescaped_buf_size > INT_MAX / 8) {
2272  av_log(avctx, AV_LOG_ERROR,
2273  "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
2274  start_code, unescaped_buf_size, buf_size);
2275  return AVERROR_INVALIDDATA;
2276  }
2277  av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%"PTRDIFF_SPECIFIER"\n",
2278  start_code, buf_end - buf_ptr);
2279 
2280  ret = init_get_bits8(&s->gb, unescaped_buf_ptr, unescaped_buf_size);
2281 
2282  if (ret < 0) {
2283  av_log(avctx, AV_LOG_ERROR, "invalid buffer\n");
2284  goto fail;
2285  }
2286 
2287  s->start_code = start_code;
2288  if (s->avctx->debug & FF_DEBUG_STARTCODE)
2289  av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2290 
2291  /* process markers */
2292  if (start_code >= 0xd0 && start_code <= 0xd7) {
2293  av_log(avctx, AV_LOG_DEBUG,
2294  "restart marker: %d\n", start_code & 0x0f);
2295  /* APP fields */
2296  } else if (start_code >= APP0 && start_code <= APP15) {
2297  if ((ret = mjpeg_decode_app(s)) < 0)
2298  av_log(avctx, AV_LOG_ERROR, "unable to decode APP fields: %s\n",
2299  av_err2str(ret));
2300  /* Comment */
2301  } else if (start_code == COM) {
2302  ret = mjpeg_decode_com(s);
2303  if (ret < 0)
2304  return ret;
2305  } else if (start_code == DQT) {
2306  ret = ff_mjpeg_decode_dqt(s);
2307  if (ret < 0)
2308  return ret;
2309  }
2310 
2311  ret = -1;
2312 
2313  if (!CONFIG_JPEGLS_DECODER &&
2314  (start_code == SOF48 || start_code == LSE)) {
2315  av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
2316  return AVERROR(ENOSYS);
2317  }
2318 
2319  if (avctx->skip_frame == AVDISCARD_ALL) {
2320  switch(start_code) {
2321  case SOF0:
2322  case SOF1:
2323  case SOF2:
2324  case SOF3:
2325  case SOF48:
2326  case SOI:
2327  case SOS:
2328  case EOI:
2329  break;
2330  default:
2331  goto skip;
2332  }
2333  }
2334 
2335  switch (start_code) {
2336  case SOI:
2337  s->restart_interval = 0;
2338  s->restart_count = 0;
2339  s->raw_image_buffer = buf_ptr;
2340  s->raw_image_buffer_size = buf_end - buf_ptr;
2341  /* nothing to do on SOI */
2342  break;
2343  case DHT:
2344  if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
2345  av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2346  goto fail;
2347  }
2348  break;
2349  case SOF0:
2350  case SOF1:
2351  if (start_code == SOF0)
2353  else
2355  s->lossless = 0;
2356  s->ls = 0;
2357  s->progressive = 0;
2358  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2359  goto fail;
2360  break;
2361  case SOF2:
2363  s->lossless = 0;
2364  s->ls = 0;
2365  s->progressive = 1;
2366  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2367  goto fail;
2368  break;
2369  case SOF3:
2372  s->lossless = 1;
2373  s->ls = 0;
2374  s->progressive = 0;
2375  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2376  goto fail;
2377  break;
2378  case SOF48:
2381  s->lossless = 1;
2382  s->ls = 1;
2383  s->progressive = 0;
2384  if ((ret = ff_mjpeg_decode_sof(s)) < 0)
2385  goto fail;
2386  break;
2387  case LSE:
2388  if (!CONFIG_JPEGLS_DECODER ||
2389  (ret = ff_jpegls_decode_lse(s)) < 0)
2390  goto fail;
2391  break;
2392  case EOI:
2393 eoi_parser:
2394  if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
2395  s->progressive && s->cur_scan && s->got_picture)
2397  s->cur_scan = 0;
2398  if (!s->got_picture) {
2399  av_log(avctx, AV_LOG_WARNING,
2400  "Found EOI before any SOF, ignoring\n");
2401  break;
2402  }
2403  if (s->interlaced) {
2404  s->bottom_field ^= 1;
2405  /* if not bottom field, do not output image yet */
2406  if (s->bottom_field == !s->interlace_polarity)
2407  break;
2408  }
2409  if (avctx->skip_frame == AVDISCARD_ALL) {
2410  s->got_picture = 0;
2411  goto the_end_no_picture;
2412  }
2413  if (s->avctx->hwaccel) {
2414  ret = s->avctx->hwaccel->end_frame(s->avctx);
2415  if (ret < 0)
2416  return ret;
2417 
2419  }
2420  if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
2421  return ret;
2422  *got_frame = 1;
2423  s->got_picture = 0;
2424 
2425  if (!s->lossless) {
2426  int qp = FFMAX3(s->qscale[0],
2427  s->qscale[1],
2428  s->qscale[2]);
2429  int qpw = (s->width + 15) / 16;
2430  AVBufferRef *qp_table_buf = av_buffer_alloc(qpw);
2431  if (qp_table_buf) {
2432  memset(qp_table_buf->data, qp, qpw);
2433  av_frame_set_qp_table(data, qp_table_buf, 0, FF_QSCALE_TYPE_MPEG1);
2434  }
2435 
2436  if(avctx->debug & FF_DEBUG_QP)
2437  av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", qp);
2438  }
2439 
2440  goto the_end;
2441  case SOS:
2442  s->raw_scan_buffer = buf_ptr;
2443  s->raw_scan_buffer_size = buf_end - buf_ptr;
2444 
2445  s->cur_scan++;
2446  if (avctx->skip_frame == AVDISCARD_ALL) {
2447  skip_bits(&s->gb, get_bits_left(&s->gb));
2448  break;
2449  }
2450 
2451  if ((ret = ff_mjpeg_decode_sos(s, NULL, 0, NULL)) < 0 &&
2452  (avctx->err_recognition & AV_EF_EXPLODE))
2453  goto fail;
2454  break;
2455  case DRI:
2456  if ((ret = mjpeg_decode_dri(s)) < 0)
2457  return ret;
2458  break;
2459  case SOF5:
2460  case SOF6:
2461  case SOF7:
2462  case SOF9:
2463  case SOF10:
2464  case SOF11:
2465  case SOF13:
2466  case SOF14:
2467  case SOF15:
2468  case JPG:
2469  av_log(avctx, AV_LOG_ERROR,
2470  "mjpeg: unsupported coding type (%x)\n", start_code);
2471  break;
2472  }
2473 
2474 skip:
2475  /* eof process start code */
2476  buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
2477  av_log(avctx, AV_LOG_DEBUG,
2478  "marker parser used %d bytes (%d bits)\n",
2479  (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
2480  }
2481  if (s->got_picture && s->cur_scan) {
2482  av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
2483  goto eoi_parser;
2484  }
2485  av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
2486  return AVERROR_INVALIDDATA;
2487 fail:
2488  s->got_picture = 0;
2489  return ret;
2490 the_end:
2491 
2492  is16bit = av_pix_fmt_desc_get(s->avctx->pix_fmt)->comp[0].step > 1;
2493 
2494  if (AV_RB32(s->upscale_h)) {
2495  int p;
2497  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2498  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2499  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2500  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2501  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2502  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2503  avctx->pix_fmt == AV_PIX_FMT_YUV420P16||
2504  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2505  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2506  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2507  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2508  );
2509  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2510  if (ret)
2511  return ret;
2512 
2514  for (p = 0; p<s->nb_components; p++) {
2515  uint8_t *line = s->picture_ptr->data[p];
2516  int w = s->width;
2517  int h = s->height;
2518  if (!s->upscale_h[p])
2519  continue;
2520  if (p==1 || p==2) {
2521  w = AV_CEIL_RSHIFT(w, hshift);
2522  h = AV_CEIL_RSHIFT(h, vshift);
2523  }
2524  if (s->upscale_v[p])
2525  h = (h+1)>>1;
2526  av_assert0(w > 0);
2527  for (i = 0; i < h; i++) {
2528  if (s->upscale_h[p] == 1) {
2529  if (is16bit) ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 2];
2530  else line[w - 1] = line[(w - 1) / 2];
2531  for (index = w - 2; index > 0; index--) {
2532  if (is16bit)
2533  ((uint16_t*)line)[index] = (((uint16_t*)line)[index / 2] + ((uint16_t*)line)[(index + 1) / 2]) >> 1;
2534  else
2535  line[index] = (line[index / 2] + line[(index + 1) / 2]) >> 1;
2536  }
2537  } else if (s->upscale_h[p] == 2) {
2538  if (is16bit) {
2539  ((uint16_t*)line)[w - 1] = ((uint16_t*)line)[(w - 1) / 3];
2540  if (w > 1)
2541  ((uint16_t*)line)[w - 2] = ((uint16_t*)line)[w - 1];
2542  } else {
2543  line[w - 1] = line[(w - 1) / 3];
2544  if (w > 1)
2545  line[w - 2] = line[w - 1];
2546  }
2547  for (index = w - 3; index > 0; index--) {
2548  line[index] = (line[index / 3] + line[(index + 1) / 3] + line[(index + 2) / 3] + 1) / 3;
2549  }
2550  }
2551  line += s->linesize[p];
2552  }
2553  }
2554  }
2555  if (AV_RB32(s->upscale_v)) {
2556  int p;
2558  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
2559  avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
2560  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
2561  avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
2562  avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
2563  avctx->pix_fmt == AV_PIX_FMT_YUV440P ||
2564  avctx->pix_fmt == AV_PIX_FMT_YUVJ440P ||
2565  avctx->pix_fmt == AV_PIX_FMT_YUVA444P ||
2566  avctx->pix_fmt == AV_PIX_FMT_YUVA420P ||
2567  avctx->pix_fmt == AV_PIX_FMT_YUVA420P16||
2568  avctx->pix_fmt == AV_PIX_FMT_GBRP ||
2569  avctx->pix_fmt == AV_PIX_FMT_GBRAP
2570  );
2571  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2572  if (ret)
2573  return ret;
2574 
2576  for (p = 0; p < s->nb_components; p++) {
2577  uint8_t *dst;
2578  int w = s->width;
2579  int h = s->height;
2580  if (!s->upscale_v[p])
2581  continue;
2582  if (p==1 || p==2) {
2583  w = AV_CEIL_RSHIFT(w, hshift);
2584  h = AV_CEIL_RSHIFT(h, vshift);
2585  }
2586  dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
2587  for (i = h - 1; i; i--) {
2588  uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];
2589  uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];
2590  if (src1 == src2 || i == h - 1) {
2591  memcpy(dst, src1, w);
2592  } else {
2593  for (index = 0; index < w; index++)
2594  dst[index] = (src1[index] + src2[index]) >> 1;
2595  }
2596  dst -= s->linesize[p];
2597  }
2598  }
2599  }
2600  if (s->flipped && !s->rgb) {
2601  int j;
2602  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt, &hshift, &vshift);
2603  if (ret)
2604  return ret;
2605 
2607  for (index=0; index<s->nb_components; index++) {
2608  uint8_t *dst = s->picture_ptr->data[index];
2609  int w = s->picture_ptr->width;
2610  int h = s->picture_ptr->height;
2611  if(index && index<3){
2612  w = AV_CEIL_RSHIFT(w, hshift);
2613  h = AV_CEIL_RSHIFT(h, vshift);
2614  }
2615  if(dst){
2616  uint8_t *dst2 = dst + s->picture_ptr->linesize[index]*(h-1);
2617  for (i=0; i<h/2; i++) {
2618  for (j=0; j<w; j++)
2619  FFSWAP(int, dst[j], dst2[j]);
2620  dst += s->picture_ptr->linesize[index];
2621  dst2 -= s->picture_ptr->linesize[index];
2622  }
2623  }
2624  }
2625  }
2626  if (s->adobe_transform == 0 && s->avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
2627  int w = s->picture_ptr->width;
2628  int h = s->picture_ptr->height;
2629  av_assert0(s->nb_components == 4);
2630  for (i=0; i<h; i++) {
2631  int j;
2632  uint8_t *dst[4];
2633  for (index=0; index<4; index++) {
2634  dst[index] = s->picture_ptr->data[index]
2635  + s->picture_ptr->linesize[index]*i;
2636  }
2637  for (j=0; j<w; j++) {
2638  int k = dst[3][j];
2639  int r = dst[0][j] * k;
2640  int g = dst[1][j] * k;
2641  int b = dst[2][j] * k;
2642  dst[0][j] = g*257 >> 16;
2643  dst[1][j] = b*257 >> 16;
2644  dst[2][j] = r*257 >> 16;
2645  dst[3][j] = 255;
2646  }
2647  }
2648  }
2649  if (s->adobe_transform == 2 && s->avctx->pix_fmt == AV_PIX_FMT_YUVA444P) {
2650  int w = s->picture_ptr->width;
2651  int h = s->picture_ptr->height;
2652  av_assert0(s->nb_components == 4);
2653  for (i=0; i<h; i++) {
2654  int j;
2655  uint8_t *dst[4];
2656  for (index=0; index<4; index++) {
2657  dst[index] = s->picture_ptr->data[index]
2658  + s->picture_ptr->linesize[index]*i;
2659  }
2660  for (j=0; j<w; j++) {
2661  int k = dst[3][j];
2662  int r = (255 - dst[0][j]) * k;
2663  int g = (128 - dst[1][j]) * k;
2664  int b = (128 - dst[2][j]) * k;
2665  dst[0][j] = r*257 >> 16;
2666  dst[1][j] = (g*257 >> 16) + 128;
2667  dst[2][j] = (b*257 >> 16) + 128;
2668  dst[3][j] = 255;
2669  }
2670  }
2671  }
2672 
2673  if (s->stereo3d) {
2674  AVStereo3D *stereo = av_stereo3d_create_side_data(data);
2675  if (stereo) {
2676  stereo->type = s->stereo3d->type;
2677  stereo->flags = s->stereo3d->flags;
2678  }
2679  av_freep(&s->stereo3d);
2680  }
2681 
2682  if (s->iccnum != 0 && s->iccnum == s->iccread) {
2683  AVFrameSideData *sd;
2684  size_t offset = 0;
2685  int total_size = 0;
2686  int i;
2687 
2688  /* Sum size of all parts. */
2689  for (i = 0; i < s->iccnum; i++)
2690  total_size += s->iccdatalens[i];
2691 
2692  sd = av_frame_new_side_data(data, AV_FRAME_DATA_ICC_PROFILE, total_size);
2693  if (!sd) {
2694  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate frame side data\n");
2695  return AVERROR(ENOMEM);
2696  }
2697 
2698  /* Reassemble the parts, which are now in-order. */
2699  for (i = 0; i < s->iccnum; i++) {
2700  memcpy(sd->data + offset, s->iccdata[i], s->iccdatalens[i]);
2701  offset += s->iccdatalens[i];
2702  }
2703  }
2704 
2705  av_dict_copy(&((AVFrame *) data)->metadata, s->exif_metadata, 0);
2707 
2708 the_end_no_picture:
2709  av_log(avctx, AV_LOG_DEBUG, "decode frame unused %"PTRDIFF_SPECIFIER" bytes\n",
2710  buf_end - buf_ptr);
2711 // return buf_end - buf_ptr;
2712  return buf_ptr - buf;
2713 }
2714 
2716 {
2717  MJpegDecodeContext *s = avctx->priv_data;
2718  int i, j;
2719 
2720  if (s->interlaced && s->bottom_field == !s->interlace_polarity && s->got_picture && !avctx->frame_number) {
2721  av_log(avctx, AV_LOG_INFO, "Single field\n");
2722  }
2723 
2724  if (s->picture) {
2725  av_frame_free(&s->picture);
2726  s->picture_ptr = NULL;
2727  } else if (s->picture_ptr)
2729 
2730  av_freep(&s->buffer);
2731  av_freep(&s->stereo3d);
2732  av_freep(&s->ljpeg_buffer);
2733  s->ljpeg_buffer_size = 0;
2734 
2735  for (i = 0; i < 3; i++) {
2736  for (j = 0; j < 4; j++)
2737  ff_free_vlc(&s->vlcs[i][j]);
2738  }
2739  for (i = 0; i < MAX_COMPONENTS; i++) {
2740  av_freep(&s->blocks[i]);
2741  av_freep(&s->last_nnz[i]);
2742  }
2744 
2745  reset_icc_profile(s);
2746 
2748 
2749  return 0;
2750 }
2751 
2752 static void decode_flush(AVCodecContext *avctx)
2753 {
2754  MJpegDecodeContext *s = avctx->priv_data;
2755  s->got_picture = 0;
2756 }
2757 
2758 #if CONFIG_MJPEG_DECODER
2759 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
2760 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2761 static const AVOption options[] = {
2762  { "extern_huff", "Use external huffman table.",
2763  OFFSET(extern_huff), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
2764  { NULL },
2765 };
2766 
2767 static const AVClass mjpegdec_class = {
2768  .class_name = "MJPEG decoder",
2769  .item_name = av_default_item_name,
2770  .option = options,
2771  .version = LIBAVUTIL_VERSION_INT,
2772 };
2773 
2775  .name = "mjpeg",
2776  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
2777  .type = AVMEDIA_TYPE_VIDEO,
2778  .id = AV_CODEC_ID_MJPEG,
2779  .priv_data_size = sizeof(MJpegDecodeContext),
2781  .close = ff_mjpeg_decode_end,
2783  .flush = decode_flush,
2784  .capabilities = AV_CODEC_CAP_DR1,
2785  .max_lowres = 3,
2786  .priv_class = &mjpegdec_class,
2787  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2789  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2790 #if CONFIG_MJPEG_NVDEC_HWACCEL
2791  HWACCEL_NVDEC(mjpeg),
2792 #endif
2793 #if CONFIG_MJPEG_VAAPI_HWACCEL
2794  HWACCEL_VAAPI(mjpeg),
2795 #endif
2796  NULL
2797  },
2798 };
2799 #endif
2800 #if CONFIG_THP_DECODER
2802  .name = "thp",
2803  .long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
2804  .type = AVMEDIA_TYPE_VIDEO,
2805  .id = AV_CODEC_ID_THP,
2806  .priv_data_size = sizeof(MJpegDecodeContext),
2808  .close = ff_mjpeg_decode_end,
2810  .flush = decode_flush,
2811  .capabilities = AV_CODEC_CAP_DR1,
2812  .max_lowres = 3,
2813  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
2814 };
2815 #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:405
#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:1299
const struct AVCodec * codec
Definition: avcodec.h:1527
const char const char void * val
Definition: avisynth_c.h:771
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:3638
const AVPixFmtDescriptor * pix_desc
!< stereoscopic information (cached, since it is read before frame allocation)
Definition: mjpegdec.h:135
const char * s
Definition: avisynth_c.h:768
#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
#define se(name, range_min, range_max)
Definition: cbs_h2645.c:349
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2363
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
int ff_exif_decode_ifd(void *logctx, GetByteContext *gbytes, int le, int depth, AVDictionary **metadata)
Definition: exif.c:122
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static void flush(AVCodecContext *avctx)
enum AVPixelFormat hwaccel_sw_pix_fmt
Definition: mjpegdec.h:151
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
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:67
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:207
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:269
#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:2403
Definition: mjpeg.h:42
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:64
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:212
const char * g
Definition: vf_curves.c:112
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:358
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:479
size_t raw_image_buffer_size
Definition: mjpegdec.h:144
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:2037
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2148
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:268
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:164
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:1431
const char * b
Definition: vf_curves.c:113
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
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:1896
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1727
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
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
Definition: mjpeg.h:53
int linesize[MAX_COMPONENTS]
linesize << interlaced
Definition: mjpegdec.h:102
discard all
Definition: avcodec.h:794
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:2741
static int decode_block(MJpegDecodeContext *s, int16_t *block, int component, int dc_index, int ac_index, uint16_t *quant_matrix)
Definition: mjpegdec.c:753
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2674
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2843
int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
Definition: mjpegdec.c:229
AVCodec.
Definition: avcodec.h:3408
EXIF metadata parser.
JPEG-LS decoder.
MJPEG encoder and decoder.
#define FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT
Definition: avcodec.h:2942
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:2222
static void mjpeg_idct_scan_progressive_ac(MJpegDecodeContext *s)
Definition: mjpegdec.c:1501
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:1640
#define FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT
Definition: avcodec.h:2940
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2975
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
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#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
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:97
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:1716
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
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:2599
uint16_t(* ljpeg_buffer)[4]
Definition: mjpegdec.h:127
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:441
#define FF_CODEC_PROPERTY_LOSSLESS
Definition: avcodec.h:3163
#define FF_PROFILE_MJPEG_JPEG_LS
Definition: avcodec.h:2944
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1618
Definition: mjpeg.h:54
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:87
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:90
static AVFrame * frame
AVFrame * picture_ptr
Definition: mjpegdec.h:100
Structure to hold side data for an AVFrame.
Definition: frame.h:180
#define height
uint8_t * data
Definition: avcodec.h:1430
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:96
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:200
static int flags
Definition: log.c:55
#define FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS
Definition: avcodec.h:2943
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:75
#define ff_dlog(a,...)
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:359
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:381
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:365
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2749
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
ptrdiff_t size
Definition: opengl_enc.c:101
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:406
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2155
#define av_log(a,...)
#define PREDICT(ret, topleft, top, left, predictor)
Definition: mjpeg.h:118
static int aligned(int val)
Definition: dashdec.c:165
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:596
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mjpegdec.c:2236
enum AVCodecID id
Definition: avcodec.h:3422
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:820
uint8_t ** iccdata
Definition: mjpegdec.h:137
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:161
int width
Definition: frame.h:276
#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:984
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:919
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
int nb_blocks[MAX_COMPONENTS]
Definition: mjpegdec.h:92
#define AVERROR(e)
Definition: error.h:43
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
Definition: jpegtables.c:70
static void copy_mb(CinepakEncContext *s, uint8_t *a_data[4], int a_linesize[4], uint8_t *b_data[4], int b_linesize[4])
Definition: cinepakenc.c:523
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
Definition: mjpegdec.c:2715
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:2391
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
const char * r
Definition: vf_curves.c:111
#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:408
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1598
Definition: graph2dot.c:48
uint16_t width
Definition: gdv.c:47
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
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:1328
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:2077
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define CLOSE_READER(name, gb)
Definition: get_bits.h:132
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:116
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:66
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:488
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
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:1297
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:301
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:387
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2642
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:352
#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:74
uint8_t interlaced
Definition: mxfenc.c:1949
int component_id[MAX_COMPONENTS]
Definition: mjpegdec.h:86
static int mjpeg_decode_app(MJpegDecodeContext *s)
Definition: mjpegdec.c:1728
#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:2941
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:304
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:182
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:563
int v_scount[MAX_COMPONENTS]
Definition: mjpegdec.h:94
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2653
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:485
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
GetBitContext gb
Definition: mjpegdec.h:49
HW acceleration through CUDA.
Definition: pixfmt.h:231
#define ZERO_RUN
Definition: mjpegdec.c:901
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:194
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:499
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:379
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:291
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:87
enum AVCodecID codec_id
Definition: avcodec.h:1528
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:249
#define ss
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:464
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:173
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:2598
AVStereo3D * stereo3d
Definition: mjpegdec.h:133
main external API structure.
Definition: avcodec.h:1518
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:226
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1543
#define OPEN_READER(name, gb)
Definition: get_bits.h:121
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1891
uint8_t * data
Definition: frame.h:182
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
GLint GLenum type
Definition: opengl_enc.c:105
static int build_basic_mjpeg_vlc(MJpegDecodeContext *s)
Definition: mjpegdec.c:75
int extradata_size
Definition: avcodec.h:1619
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:321
static void init_idct(AVCodecContext *avctx)
Definition: mjpegdec.c:118
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
Definition: jpeglsdec.c:346
int coded_height
Definition: avcodec.h:1705
Describe the class of an AVClass context structure.
Definition: log.h:67
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:314
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:720
int index
Definition: gxfenc.c:89
static int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
Definition: mjpegdec.c:735
int ac_index[MAX_COMPONENTS]
Definition: mjpegdec.h:91
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2141
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:1018
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:433
#define GET_CACHE(name, gb)
Definition: get_bits.h:198
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:354
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
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
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al)
Definition: mjpegdec.c:1449
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
#define MIN_CACHE_BITS
Definition: get_bits.h:113
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:551
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
size_t raw_scan_buffer_size
Definition: mjpegdec.h:146
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
uint8_t level
Definition: svq3.c:207
#define OFFSET(x)
Definition: ffmpeg_opt.c:3293
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference)
Definition: mjpegdec.c:1536
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:498
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:802
Definition: mjpeg.h:94
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform, int nb_components)
Definition: mjpegdec.c:1143
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:62
Y , 8bpp.
Definition: pixfmt.h:70
const OptionDef options[]
Definition: ffmpeg_opt.c:3294
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
if(ret< 0)
Definition: vf_mcdeint.c:279
#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
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
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:211
static double c[64]
#define FF_DEBUG_QP
Definition: avcodec.h:2603
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:76
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:69
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3162
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:773
static int lowres
Definition: ffplay.c:331
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:1545
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:2612
static void shift_output(MJpegDecodeContext *s, uint8_t *ptr, int linesize)
Definition: mjpegdec.c:1313
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:370
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:3686
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:296
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:254
int last_dc[MAX_COMPONENTS]
Definition: mjpegdec.h:98
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:472
uint64_t layout
#define REFINE_BIT(j)
Definition: mjpegdec.c:893
uint8_t upscale_h[4]
Definition: mjpegdec.h:68
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;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);returnNULL;}returnac;}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;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->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);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
static void decode_flush(AVCodecContext *avctx)
Definition: mjpegdec.c:2752
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2204
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:276
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:95
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:2170
#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:521
Definition: mjpeg.h:82
#define VD
Definition: cuviddec.c:1097
#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:2102
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3666
#define FF_QSCALE_TYPE_MPEG1
Definition: internal.h:81
MJPEG decoder.
#define MKTAG(a, b, c, d)
Definition: common.h:366
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3677
AVCodec ff_thp_decoder
enum AVCodecID id
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1407
uint16_t quant_matrixes[4][64]
Definition: mjpegdec.h:56
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:354
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1135
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:959
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:380
for(j=16;j >0;--j)
#define FFMAX3(a, b, c)
Definition: common.h:95
GLuint buffer
Definition: opengl_enc.c:102
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)
Definition: mem.c:191
Definition: mjpeg.h:49
bitstream writer API