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