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