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