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