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