dsputil: Split clear_block*/fill_block* off into a separate context
[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 Libav.
12  *
13  * Libav 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  * Libav 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 Libav; 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 <assert.h>
34
35 #include "libavutil/imgutils.h"
36 #include "libavutil/opt.h"
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "internal.h"
40 #include "mjpeg.h"
41 #include "mjpegdec.h"
42 #include "jpeglsdec.h"
43
44
45 static int build_vlc(VLC *vlc, const uint8_t *bits_table,
46                      const uint8_t *val_table, int nb_codes,
47                      int use_static, int is_ac)
48 {
49     uint8_t huff_size[256] = { 0 };
50     uint16_t huff_code[256];
51     uint16_t huff_sym[256];
52     int i;
53
54     assert(nb_codes <= 256);
55
56     ff_mjpeg_build_huffman_codes(huff_size, huff_code, bits_table, val_table);
57
58     for (i = 0; i < 256; i++)
59         huff_sym[i] = i + 16 * is_ac;
60
61     if (is_ac)
62         huff_sym[0] = 16 * 256;
63
64     return ff_init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
65                               huff_code, 2, 2, huff_sym, 2, 2, use_static);
66 }
67
68 static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
69 {
70     build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
71               avpriv_mjpeg_val_dc, 12, 0, 0);
72     build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
73               avpriv_mjpeg_val_dc, 12, 0, 0);
74     build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
75               avpriv_mjpeg_val_ac_luminance, 251, 0, 1);
76     build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
77               avpriv_mjpeg_val_ac_chrominance, 251, 0, 1);
78     build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
79               avpriv_mjpeg_val_ac_luminance, 251, 0, 0);
80     build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
81               avpriv_mjpeg_val_ac_chrominance, 251, 0, 0);
82 }
83
84 av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
85 {
86     MJpegDecodeContext *s = avctx->priv_data;
87
88     if (!s->picture_ptr) {
89         s->picture = av_frame_alloc();
90         if (!s->picture)
91             return AVERROR(ENOMEM);
92         s->picture_ptr = s->picture;
93     }
94
95     s->avctx = avctx;
96     ff_blockdsp_init(&s->bdsp, avctx);
97     ff_hpeldsp_init(&s->hdsp, avctx->flags);
98     ff_dsputil_init(&s->dsp, avctx);
99     ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
100     s->buffer_size   = 0;
101     s->buffer        = NULL;
102     s->start_code    = -1;
103     s->first_picture = 1;
104     s->org_height    = avctx->coded_height;
105     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
106
107     build_basic_mjpeg_vlc(s);
108
109     if (s->extern_huff) {
110         int ret;
111         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
112         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
113         if ((ret = ff_mjpeg_decode_dht(s))) {
114             av_log(avctx, AV_LOG_ERROR,
115                    "mjpeg: error using external huffman table\n");
116             return ret;
117         }
118     }
119     if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
120         s->interlace_polarity = 1;           /* bottom field first */
121         av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
122     }
123     if (avctx->codec->id == AV_CODEC_ID_AMV)
124         s->flipped = 1;
125
126     return 0;
127 }
128
129
130 /* quantize tables */
131 int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
132 {
133     int len, index, i, j;
134
135     len = get_bits(&s->gb, 16) - 2;
136
137     while (len >= 65) {
138         /* only 8 bit precision handled */
139         if (get_bits(&s->gb, 4) != 0) {
140             av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
141             return -1;
142         }
143         index = get_bits(&s->gb, 4);
144         if (index >= 4)
145             return -1;
146         av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
147         /* read quant table */
148         for (i = 0; i < 64; i++) {
149             j = s->scantable.permutated[i];
150             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
151         }
152
153         // XXX FIXME finetune, and perhaps add dc too
154         s->qscale[index] = FFMAX(s->quant_matrixes[index][s->scantable.permutated[1]],
155                                  s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
156         av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
157                index, s->qscale[index]);
158         len -= 65;
159     }
160     return 0;
161 }
162
163 /* decode huffman tables and build VLC decoders */
164 int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
165 {
166     int len, index, i, class, n, v, code_max;
167     uint8_t bits_table[17];
168     uint8_t val_table[256];
169     int ret = 0;
170
171     len = get_bits(&s->gb, 16) - 2;
172
173     while (len > 0) {
174         if (len < 17)
175             return AVERROR_INVALIDDATA;
176         class = get_bits(&s->gb, 4);
177         if (class >= 2)
178             return AVERROR_INVALIDDATA;
179         index = get_bits(&s->gb, 4);
180         if (index >= 4)
181             return AVERROR_INVALIDDATA;
182         n = 0;
183         for (i = 1; i <= 16; i++) {
184             bits_table[i] = get_bits(&s->gb, 8);
185             n += bits_table[i];
186         }
187         len -= 17;
188         if (len < n || n > 256)
189             return AVERROR_INVALIDDATA;
190
191         code_max = 0;
192         for (i = 0; i < n; i++) {
193             v = get_bits(&s->gb, 8);
194             if (v > code_max)
195                 code_max = v;
196             val_table[i] = v;
197         }
198         len -= n;
199
200         /* build VLC and flush previous vlc if present */
201         ff_free_vlc(&s->vlcs[class][index]);
202         av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
203                class, index, code_max + 1);
204         if ((ret = build_vlc(&s->vlcs[class][index], bits_table, val_table,
205                              code_max + 1, 0, class > 0)) < 0)
206             return ret;
207
208         if (class > 0) {
209             ff_free_vlc(&s->vlcs[2][index]);
210             if ((ret = build_vlc(&s->vlcs[2][index], bits_table, val_table,
211                                  code_max + 1, 0, 0)) < 0)
212                 return ret;
213         }
214     }
215     return 0;
216 }
217
218 int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
219 {
220     int len, nb_components, i, width, height, pix_fmt_id, ret;
221
222     /* XXX: verify len field validity */
223     len     = get_bits(&s->gb, 16);
224     s->bits = get_bits(&s->gb, 8);
225
226     if (s->pegasus_rct)
227         s->bits = 9;
228     if (s->bits == 9 && !s->pegasus_rct)
229         s->rct  = 1;    // FIXME ugly
230
231     if (s->bits != 8 && !s->lossless) {
232         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
233         return -1;
234     }
235
236     height = get_bits(&s->gb, 16);
237     width  = get_bits(&s->gb, 16);
238
239     // HACK for odd_height.mov
240     if (s->interlaced && s->width == width && s->height == height + 1)
241         height= s->height;
242
243     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
244     if (av_image_check_size(width, height, 0, s->avctx))
245         return AVERROR_INVALIDDATA;
246
247     nb_components = get_bits(&s->gb, 8);
248     if (nb_components <= 0 ||
249         nb_components > MAX_COMPONENTS)
250         return -1;
251     if (s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
252         if (nb_components != s->nb_components) {
253             av_log(s->avctx, AV_LOG_ERROR,
254                    "nb_components changing in interlaced picture\n");
255             return AVERROR_INVALIDDATA;
256         }
257     }
258     if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
259         avpriv_report_missing_feature(s->avctx,
260                                       "JPEG-LS that is not <= 8 "
261                                       "bits/component or 16-bit gray");
262         return AVERROR_PATCHWELCOME;
263     }
264     s->nb_components = nb_components;
265     s->h_max         = 1;
266     s->v_max         = 1;
267     for (i = 0; i < nb_components; i++) {
268         /* component id */
269         s->component_id[i] = get_bits(&s->gb, 8) - 1;
270         s->h_count[i]      = get_bits(&s->gb, 4);
271         s->v_count[i]      = get_bits(&s->gb, 4);
272         /* compute hmax and vmax (only used in interleaved case) */
273         if (s->h_count[i] > s->h_max)
274             s->h_max = s->h_count[i];
275         if (s->v_count[i] > s->v_max)
276             s->v_max = s->v_count[i];
277         s->quant_index[i] = get_bits(&s->gb, 8);
278         if (s->quant_index[i] >= 4)
279             return AVERROR_INVALIDDATA;
280         if (!s->h_count[i] || !s->v_count[i]) {
281             av_log(s->avctx, AV_LOG_ERROR,
282                    "Invalid sampling factor in component %d %d:%d\n",
283                    i, s->h_count[i], s->v_count[i]);
284             return AVERROR_INVALIDDATA;
285         }
286
287         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
288                i, s->h_count[i], s->v_count[i],
289                s->component_id[i], s->quant_index[i]);
290     }
291
292     if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
293         avpriv_report_missing_feature(s->avctx, "Subsampling in JPEG-LS");
294         return AVERROR_PATCHWELCOME;
295     }
296
297     if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1)
298         s->rgb = 1;
299
300     /* if different size, realloc/alloc picture */
301     /* XXX: also check h_count and v_count */
302     if (width != s->width || height != s->height) {
303         s->width      = width;
304         s->height     = height;
305         s->interlaced = 0;
306
307         /* test interlaced mode */
308         if (s->first_picture   &&
309             s->org_height != 0 &&
310             s->height < ((s->org_height * 3) / 4)) {
311             s->interlaced                    = 1;
312             s->bottom_field                  = s->interlace_polarity;
313             s->picture_ptr->interlaced_frame = 1;
314             s->picture_ptr->top_field_first  = !s->interlace_polarity;
315             height *= 2;
316         }
317
318         ret = ff_set_dimensions(s->avctx, width, height);
319         if (ret < 0)
320             return ret;
321
322         s->first_picture = 0;
323     }
324
325     if (!(s->interlaced && (s->bottom_field == !s->interlace_polarity))) {
326     /* XXX: not complete test ! */
327     pix_fmt_id = (s->h_count[0] << 28) | (s->v_count[0] << 24) |
328                  (s->h_count[1] << 20) | (s->v_count[1] << 16) |
329                  (s->h_count[2] << 12) | (s->v_count[2] <<  8) |
330                  (s->h_count[3] <<  4) |  s->v_count[3];
331     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
332     /* NOTE we do not allocate pictures large enough for the possible
333      * padding of h/v_count being 4 */
334     if (!(pix_fmt_id & 0xD0D0D0D0))
335         pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
336     if (!(pix_fmt_id & 0x0D0D0D0D))
337         pix_fmt_id -= (pix_fmt_id & 0x0F0F0F0F) >> 1;
338
339     switch (pix_fmt_id) {
340     case 0x11111100:
341         if (s->rgb)
342             s->avctx->pix_fmt = AV_PIX_FMT_BGRA;
343         else {
344             s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
345             s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
346         }
347         assert(s->nb_components == 3);
348         break;
349     case 0x11000000:
350         s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
351         break;
352     case 0x12111100:
353         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV440P : AV_PIX_FMT_YUVJ440P;
354         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
355         break;
356     case 0x21111100:
357         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV422P : AV_PIX_FMT_YUVJ422P;
358         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
359         break;
360     case 0x22111100:
361         s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
362         s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
363         break;
364     default:
365         av_log(s->avctx, AV_LOG_ERROR, "Unhandled pixel format 0x%x\n", pix_fmt_id);
366         return AVERROR_PATCHWELCOME;
367     }
368     if (s->ls) {
369         if (s->nb_components > 1)
370             s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
371         else if (s->bits <= 8)
372             s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
373         else
374             s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
375     }
376
377     s->pix_desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
378     if (!s->pix_desc) {
379         av_log(s->avctx, AV_LOG_ERROR, "Could not get a pixel format descriptor.\n");
380         return AVERROR_BUG;
381     }
382
383     av_frame_unref(s->picture_ptr);
384     if (ff_get_buffer(s->avctx, s->picture_ptr, AV_GET_BUFFER_FLAG_REF) < 0) {
385         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
386         return -1;
387     }
388     s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
389     s->picture_ptr->key_frame = 1;
390     s->got_picture            = 1;
391
392     for (i = 0; i < 3; i++)
393         s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
394
395     av_dlog(s->avctx, "%d %d %d %d %d %d\n",
396             s->width, s->height, s->linesize[0], s->linesize[1],
397             s->interlaced, s->avctx->height);
398
399     if (len != (8 + (3 * nb_components)))
400         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
401     }
402
403     /* totally blank picture as progressive JPEG will only add details to it */
404     if (s->progressive) {
405         int bw = (width  + s->h_max * 8 - 1) / (s->h_max * 8);
406         int bh = (height + s->v_max * 8 - 1) / (s->v_max * 8);
407         for (i = 0; i < s->nb_components; i++) {
408             int size = bw * bh * s->h_count[i] * s->v_count[i];
409             av_freep(&s->blocks[i]);
410             av_freep(&s->last_nnz[i]);
411             s->blocks[i]       = av_malloc(size * sizeof(**s->blocks));
412             s->last_nnz[i]     = av_mallocz(size * sizeof(**s->last_nnz));
413             s->block_stride[i] = bw * s->h_count[i];
414         }
415         memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
416     }
417     return 0;
418 }
419
420 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
421 {
422     int code;
423     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
424     if (code < 0) {
425         av_log(s->avctx, AV_LOG_WARNING,
426                "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
427                0, dc_index, &s->vlcs[0][dc_index]);
428         return 0xffff;
429     }
430
431     if (code)
432         return get_xbits(&s->gb, code);
433     else
434         return 0;
435 }
436
437 /* decode block and dequantize */
438 static int decode_block(MJpegDecodeContext *s, int16_t *block, int component,
439                         int dc_index, int ac_index, int16_t *quant_matrix)
440 {
441     int code, i, j, level, val;
442
443     /* DC coef */
444     val = mjpeg_decode_dc(s, dc_index);
445     if (val == 0xffff) {
446         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
447         return AVERROR_INVALIDDATA;
448     }
449     val = val * quant_matrix[0] + s->last_dc[component];
450     s->last_dc[component] = val;
451     block[0] = val;
452     /* AC coefs */
453     i = 0;
454     {OPEN_READER(re, &s->gb);
455     do {
456         UPDATE_CACHE(re, &s->gb);
457         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2);
458
459         i += ((unsigned)code) >> 4;
460             code &= 0xf;
461         if (code) {
462             if (code > MIN_CACHE_BITS - 16)
463                 UPDATE_CACHE(re, &s->gb);
464
465             {
466                 int cache = GET_CACHE(re, &s->gb);
467                 int sign  = (~cache) >> 31;
468                 level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
469             }
470
471             LAST_SKIP_BITS(re, &s->gb, code);
472
473             if (i > 63) {
474                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
475                 return AVERROR_INVALIDDATA;
476             }
477             j        = s->scantable.permutated[i];
478             block[j] = level * quant_matrix[j];
479         }
480     } while (i < 63);
481     CLOSE_READER(re, &s->gb);}
482
483     return 0;
484 }
485
486 static int decode_dc_progressive(MJpegDecodeContext *s, int16_t *block,
487                                  int component, int dc_index,
488                                  int16_t *quant_matrix, int Al)
489 {
490     int val;
491     s->bdsp.clear_block(block);
492     val = mjpeg_decode_dc(s, dc_index);
493     if (val == 0xffff) {
494         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
495         return AVERROR_INVALIDDATA;
496     }
497     val = (val * quant_matrix[0] << Al) + s->last_dc[component];
498     s->last_dc[component] = val;
499     block[0] = val;
500     return 0;
501 }
502
503 /* decode block and dequantize - progressive JPEG version */
504 static int decode_block_progressive(MJpegDecodeContext *s, int16_t *block,
505                                     uint8_t *last_nnz, int ac_index,
506                                     int16_t *quant_matrix,
507                                     int ss, int se, int Al, int *EOBRUN)
508 {
509     int code, i, j, level, val, run;
510
511     if (*EOBRUN) {
512         (*EOBRUN)--;
513         return 0;
514     }
515
516     {
517         OPEN_READER(re, &s->gb);
518         for (i = ss; ; i++) {
519             UPDATE_CACHE(re, &s->gb);
520             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
521
522             run = ((unsigned) code) >> 4;
523             code &= 0xF;
524             if (code) {
525                 i += run;
526                 if (code > MIN_CACHE_BITS - 16)
527                     UPDATE_CACHE(re, &s->gb);
528
529                 {
530                     int cache = GET_CACHE(re, &s->gb);
531                     int sign  = (~cache) >> 31;
532                     level     = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
533                 }
534
535                 LAST_SKIP_BITS(re, &s->gb, code);
536
537                 if (i >= se) {
538                     if (i == se) {
539                         j = s->scantable.permutated[se];
540                         block[j] = level * quant_matrix[j] << Al;
541                         break;
542                     }
543                     av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
544                     return AVERROR_INVALIDDATA;
545                 }
546                 j = s->scantable.permutated[i];
547                 block[j] = level * quant_matrix[j] << Al;
548             } else {
549                 if (run == 0xF) {// ZRL - skip 15 coefficients
550                     i += 15;
551                     if (i >= se) {
552                         av_log(s->avctx, AV_LOG_ERROR, "ZRL overflow: %d\n", i);
553                         return AVERROR_INVALIDDATA;
554                     }
555                 } else {
556                     val = (1 << run);
557                     if (run) {
558                         UPDATE_CACHE(re, &s->gb);
559                         val += NEG_USR32(GET_CACHE(re, &s->gb), run);
560                         LAST_SKIP_BITS(re, &s->gb, run);
561                     }
562                     *EOBRUN = val - 1;
563                     break;
564                 }
565             }
566         }
567         CLOSE_READER(re, &s->gb);
568     }
569
570     if (i > *last_nnz)
571         *last_nnz = i;
572
573     return 0;
574 }
575
576 #define REFINE_BIT(j) {                                             \
577     UPDATE_CACHE(re, &s->gb);                                       \
578     sign = block[j] >> 15;                                          \
579     block[j] += SHOW_UBITS(re, &s->gb, 1) *                         \
580                 ((quant_matrix[j] ^ sign) - sign) << Al;            \
581     LAST_SKIP_BITS(re, &s->gb, 1);                                  \
582 }
583
584 #define ZERO_RUN                                                    \
585 for (; ; i++) {                                                     \
586     if (i > last) {                                                 \
587         i += run;                                                   \
588         if (i > se) {                                               \
589             av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i); \
590             return -1;                                              \
591         }                                                           \
592         break;                                                      \
593     }                                                               \
594     j = s->scantable.permutated[i];                                 \
595     if (block[j])                                                   \
596         REFINE_BIT(j)                                               \
597     else if (run-- == 0)                                            \
598         break;                                                      \
599 }
600
601 /* decode block and dequantize - progressive JPEG refinement pass */
602 static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
603                                    uint8_t *last_nnz,
604                                    int ac_index, int16_t *quant_matrix,
605                                    int ss, int se, int Al, int *EOBRUN)
606 {
607     int code, i = ss, j, sign, val, run;
608     int last    = FFMIN(se, *last_nnz);
609
610     OPEN_READER(re, &s->gb);
611     if (*EOBRUN) {
612         (*EOBRUN)--;
613     } else {
614         for (; ; i++) {
615             UPDATE_CACHE(re, &s->gb);
616             GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
617
618             if (code & 0xF) {
619                 run = ((unsigned) code) >> 4;
620                 UPDATE_CACHE(re, &s->gb);
621                 val = SHOW_UBITS(re, &s->gb, 1);
622                 LAST_SKIP_BITS(re, &s->gb, 1);
623                 ZERO_RUN;
624                 j = s->scantable.permutated[i];
625                 val--;
626                 block[j] = ((quant_matrix[j]^val) - val) << Al;
627                 if (i == se) {
628                     if (i > *last_nnz)
629                         *last_nnz = i;
630                     CLOSE_READER(re, &s->gb);
631                     return 0;
632                 }
633             } else {
634                 run = ((unsigned) code) >> 4;
635                 if (run == 0xF) {
636                     ZERO_RUN;
637                 } else {
638                     val = run;
639                     run = (1 << run);
640                     if (val) {
641                         UPDATE_CACHE(re, &s->gb);
642                         run += SHOW_UBITS(re, &s->gb, val);
643                         LAST_SKIP_BITS(re, &s->gb, val);
644                     }
645                     *EOBRUN = run - 1;
646                     break;
647                 }
648             }
649         }
650
651         if (i > *last_nnz)
652             *last_nnz = i;
653     }
654
655     for (; i <= last; i++) {
656         j = s->scantable.permutated[i];
657         if (block[j])
658             REFINE_BIT(j)
659     }
660     CLOSE_READER(re, &s->gb);
661
662     return 0;
663 }
664 #undef REFINE_BIT
665 #undef ZERO_RUN
666
667 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor,
668                                  int point_transform)
669 {
670     int i, mb_x, mb_y;
671     uint16_t (*buffer)[4];
672     int left[3], top[3], topleft[3];
673     const int linesize = s->linesize[0];
674     const int mask     = (1 << s->bits) - 1;
675
676     av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
677                    (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
678     buffer = s->ljpeg_buffer;
679
680     for (i = 0; i < 3; i++)
681         buffer[0][i] = 1 << (s->bits + point_transform - 1);
682
683     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
684         const int modified_predictor = mb_y ? predictor : 1;
685         uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
686
687         if (s->interlaced && s->bottom_field)
688             ptr += linesize >> 1;
689
690         for (i = 0; i < 3; i++)
691             top[i] = left[i] = topleft[i] = buffer[0][i];
692
693         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
694             if (s->restart_interval && !s->restart_count)
695                 s->restart_count = s->restart_interval;
696
697             for (i = 0; i < 3; i++) {
698                 int pred;
699
700                 topleft[i] = top[i];
701                 top[i]     = buffer[mb_x][i];
702
703                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
704
705                 left[i] = buffer[mb_x][i] =
706                     mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
707             }
708
709             if (s->restart_interval && !--s->restart_count) {
710                 align_get_bits(&s->gb);
711                 skip_bits(&s->gb, 16); /* skip RSTn */
712             }
713         }
714
715         if (s->rct) {
716             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
717                 ptr[4 * mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200) >> 2);
718                 ptr[4 * mb_x + 0] = buffer[mb_x][1] + ptr[4 * mb_x + 1];
719                 ptr[4 * mb_x + 2] = buffer[mb_x][2] + ptr[4 * mb_x + 1];
720             }
721         } else if (s->pegasus_rct) {
722             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
723                 ptr[4 * mb_x + 1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2]) >> 2);
724                 ptr[4 * mb_x + 0] = buffer[mb_x][1] + ptr[4 * mb_x + 1];
725                 ptr[4 * mb_x + 2] = buffer[mb_x][2] + ptr[4 * mb_x + 1];
726             }
727         } else {
728             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
729                 ptr[4 * mb_x + 0] = buffer[mb_x][2];
730                 ptr[4 * mb_x + 1] = buffer[mb_x][1];
731                 ptr[4 * mb_x + 2] = buffer[mb_x][0];
732             }
733         }
734     }
735     return 0;
736 }
737
738 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
739                                  int point_transform, int nb_components)
740 {
741     int i, mb_x, mb_y;
742
743     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
744         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
745             if (s->restart_interval && !s->restart_count)
746                 s->restart_count = s->restart_interval;
747
748             if (mb_x == 0 || mb_y == 0 || s->interlaced) {
749                 for (i = 0; i < nb_components; i++) {
750                     uint8_t *ptr;
751                     int n, h, v, x, y, c, j, linesize;
752                     n        = s->nb_blocks[i];
753                     c        = s->comp_index[i];
754                     h        = s->h_scount[i];
755                     v        = s->v_scount[i];
756                     x        = 0;
757                     y        = 0;
758                     linesize = s->linesize[c];
759
760                     for (j = 0; j < n; j++) {
761                         int pred;
762                         // FIXME optimize this crap
763                         ptr = s->picture_ptr->data[c] +
764                               (linesize * (v * mb_y + y)) +
765                               (h * mb_x + x);
766                         if (y == 0 && mb_y == 0) {
767                             if (x == 0 && mb_x == 0)
768                                 pred = 128 << point_transform;
769                             else
770                                 pred = ptr[-1];
771                         } else {
772                             if (x == 0 && mb_x == 0)
773                                 pred = ptr[-linesize];
774                             else
775                                 PREDICT(pred, ptr[-linesize - 1],
776                                         ptr[-linesize], ptr[-1], predictor);
777                        }
778
779                         if (s->interlaced && s->bottom_field)
780                             ptr += linesize >> 1;
781                         *ptr = pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
782
783                         if (++x == h) {
784                             x = 0;
785                             y++;
786                         }
787                     }
788                 }
789             } else {
790                 for (i = 0; i < nb_components; i++) {
791                     uint8_t *ptr;
792                     int n, h, v, x, y, c, j, linesize;
793                     n        = s->nb_blocks[i];
794                     c        = s->comp_index[i];
795                     h        = s->h_scount[i];
796                     v        = s->v_scount[i];
797                     x        = 0;
798                     y        = 0;
799                     linesize = s->linesize[c];
800
801                     for (j = 0; j < n; j++) {
802                         int pred;
803
804                         // FIXME optimize this crap
805                         ptr = s->picture_ptr->data[c] +
806                               (linesize * (v * mb_y + y)) +
807                               (h * mb_x + x);
808                         PREDICT(pred, ptr[-linesize - 1],
809                                 ptr[-linesize], ptr[-1], predictor);
810                         *ptr = pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
811                         if (++x == h) {
812                             x = 0;
813                             y++;
814                         }
815                     }
816                 }
817             }
818             if (s->restart_interval && !--s->restart_count) {
819                 align_get_bits(&s->gb);
820                 skip_bits(&s->gb, 16); /* skip RSTn */
821             }
822         }
823     }
824     return 0;
825 }
826
827 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
828                              int Al, const uint8_t *mb_bitmask,
829                              const AVFrame *reference)
830 {
831     int i, mb_x, mb_y;
832     uint8_t *data[MAX_COMPONENTS];
833     const uint8_t *reference_data[MAX_COMPONENTS];
834     int linesize[MAX_COMPONENTS];
835     GetBitContext mb_bitmask_gb;
836
837     if (mb_bitmask)
838         init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
839
840     for (i = 0; i < nb_components; i++) {
841         int c   = s->comp_index[i];
842         data[c] = s->picture_ptr->data[c];
843         reference_data[c] = reference ? reference->data[c] : NULL;
844         linesize[c] = s->linesize[c];
845         s->coefs_finished[c] |= 1;
846     }
847
848     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
849         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
850             const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
851
852             if (s->restart_interval && !s->restart_count)
853                 s->restart_count = s->restart_interval;
854
855             if (get_bits_left(&s->gb) < 0) {
856                 av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
857                        -get_bits_left(&s->gb));
858                 return AVERROR_INVALIDDATA;
859             }
860             for (i = 0; i < nb_components; i++) {
861                 uint8_t *ptr;
862                 int n, h, v, x, y, c, j;
863                 int block_offset;
864                 n = s->nb_blocks[i];
865                 c = s->comp_index[i];
866                 h = s->h_scount[i];
867                 v = s->v_scount[i];
868                 x = 0;
869                 y = 0;
870                 for (j = 0; j < n; j++) {
871                     block_offset = ((linesize[c] * (v * mb_y + y) * 8) +
872                                     (h * mb_x + x) * 8);
873
874                     if (s->interlaced && s->bottom_field)
875                         block_offset += linesize[c] >> 1;
876                     ptr = data[c] + block_offset;
877                     if (!s->progressive) {
878                         if (copy_mb)
879                             s->hdsp.put_pixels_tab[1][0](ptr,
880                                 reference_data[c] + block_offset,
881                                 linesize[c], 8);
882                         else {
883                             s->bdsp.clear_block(s->block);
884                             if (decode_block(s, s->block, i,
885                                              s->dc_index[i], s->ac_index[i],
886                                              s->quant_matrixes[s->quant_index[c]]) < 0) {
887                                 av_log(s->avctx, AV_LOG_ERROR,
888                                        "error y=%d x=%d\n", mb_y, mb_x);
889                                 return AVERROR_INVALIDDATA;
890                             }
891                             s->dsp.idct_put(ptr, linesize[c], s->block);
892                         }
893                     } else {
894                         int block_idx  = s->block_stride[c] * (v * mb_y + y) +
895                                          (h * mb_x + x);
896                         int16_t *block = s->blocks[c][block_idx];
897                         if (Ah)
898                             block[0] += get_bits1(&s->gb) *
899                                         s->quant_matrixes[s->quant_index[c]][0] << Al;
900                         else if (decode_dc_progressive(s, block, i, s->dc_index[i],
901                                                        s->quant_matrixes[s->quant_index[c]],
902                                                        Al) < 0) {
903                             av_log(s->avctx, AV_LOG_ERROR,
904                                    "error y=%d x=%d\n", mb_y, mb_x);
905                             return AVERROR_INVALIDDATA;
906                         }
907                     }
908                     av_dlog(s->avctx, "mb: %d %d processed\n", mb_y, mb_x);
909                     av_dlog(s->avctx, "%d %d %d %d %d %d %d %d \n",
910                             mb_x, mb_y, x, y, c, s->bottom_field,
911                             (v * mb_y + y) * 8, (h * mb_x + x) * 8);
912                     if (++x == h) {
913                         x = 0;
914                         y++;
915                     }
916                 }
917             }
918
919             if (s->restart_interval) {
920                 s->restart_count--;
921                 i = 8 + ((-get_bits_count(&s->gb)) & 7);
922                 /* skip RSTn */
923                 if (show_bits(&s->gb, i) == (1 << i) - 1) {
924                     int pos = get_bits_count(&s->gb);
925                     align_get_bits(&s->gb);
926                     while (get_bits_left(&s->gb) >= 8 && show_bits(&s->gb, 8) == 0xFF)
927                         skip_bits(&s->gb, 8);
928                     if ((get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
929                         for (i = 0; i < nb_components; i++) /* reset dc */
930                             s->last_dc[i] = 1024;
931                     } else
932                         skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
933                 }
934             }
935         }
936     }
937     return 0;
938 }
939
940 static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
941                                             int se, int Ah, int Al,
942                                             const uint8_t *mb_bitmask,
943                                             const AVFrame *reference)
944 {
945     int mb_x, mb_y;
946     int EOBRUN = 0;
947     int c = s->comp_index[0];
948     uint8_t *data = s->picture_ptr->data[c];
949     const uint8_t *reference_data = reference ? reference->data[c] : NULL;
950     int linesize  = s->linesize[c];
951     int last_scan = 0;
952     int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]];
953     GetBitContext mb_bitmask_gb;
954
955     if (ss < 0  || ss >= 64 ||
956         se < ss || se >= 64 ||
957         Ah < 0  || Al < 0)
958         return AVERROR_INVALIDDATA;
959
960     if (mb_bitmask)
961         init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
962
963     if (!Al) {
964         s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);
965         last_scan = !~s->coefs_finished[c];
966     }
967
968     if (s->interlaced && s->bottom_field) {
969         int offset      = linesize >> 1;
970         data           += offset;
971         reference_data += offset;
972     }
973
974     for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
975         int block_offset = mb_y * linesize * 8;
976         uint8_t *ptr     = data + block_offset;
977         int block_idx    = mb_y * s->block_stride[c];
978         int16_t (*block)[64] = &s->blocks[c][block_idx];
979         uint8_t *last_nnz    = &s->last_nnz[c][block_idx];
980         for (mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
981             const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
982
983             if (!copy_mb) {
984                 int ret;
985                 if (Ah)
986                     ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
987                                                   quant_matrix, ss, se, Al, &EOBRUN);
988                 else
989                     ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
990                                                    quant_matrix, ss, se, Al, &EOBRUN);
991                 if (ret < 0) {
992                     av_log(s->avctx, AV_LOG_ERROR,
993                            "error y=%d x=%d\n", mb_y, mb_x);
994                     return AVERROR_INVALIDDATA;
995                 }
996             }
997
998             if (last_scan) {
999                 if (copy_mb) {
1000                     s->hdsp.put_pixels_tab[1][0](ptr,
1001                                                  reference_data + block_offset,
1002                                                  linesize, 8);
1003                 } else {
1004                     s->dsp.idct_put(ptr, linesize, *block);
1005                     ptr += 8;
1006                 }
1007             }
1008         }
1009     }
1010     return 0;
1011 }
1012
1013 int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
1014                         const AVFrame *reference)
1015 {
1016     int len, nb_components, i, h, v, predictor, point_transform;
1017     int index, id, ret;
1018     const int block_size = s->lossless ? 1 : 8;
1019     int ilv, prev_shift;
1020
1021     /* XXX: verify len field validity */
1022     len = get_bits(&s->gb, 16);
1023     nb_components = get_bits(&s->gb, 8);
1024     if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
1025         av_log(s->avctx, AV_LOG_ERROR,
1026                "decode_sos: nb_components (%d) unsupported\n", nb_components);
1027         return AVERROR_PATCHWELCOME;
1028     }
1029     if (len != 6 + 2 * nb_components) {
1030         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1031         return AVERROR_INVALIDDATA;
1032     }
1033     for (i = 0; i < nb_components; i++) {
1034         id = get_bits(&s->gb, 8) - 1;
1035         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1036         /* find component index */
1037         for (index = 0; index < s->nb_components; index++)
1038             if (id == s->component_id[index])
1039                 break;
1040         if (index == s->nb_components) {
1041             av_log(s->avctx, AV_LOG_ERROR,
1042                    "decode_sos: index(%d) out of components\n", index);
1043             return AVERROR_INVALIDDATA;
1044         }
1045         /* Metasoft MJPEG codec has Cb and Cr swapped */
1046         if (s->avctx->codec_tag == MKTAG('M', 'T', 'S', 'J')
1047             && nb_components == 3 && s->nb_components == 3 && i)
1048             index = 3 - i;
1049
1050         s->comp_index[i] = index;
1051
1052         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1053         s->h_scount[i]  = s->h_count[index];
1054         s->v_scount[i]  = s->v_count[index];
1055
1056         s->dc_index[i] = get_bits(&s->gb, 4);
1057         s->ac_index[i] = get_bits(&s->gb, 4);
1058
1059         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1060             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1061             goto out_of_range;
1062         if (!s->vlcs[0][s->dc_index[i]].table ||
1063             !s->vlcs[1][s->ac_index[i]].table)
1064             goto out_of_range;
1065     }
1066
1067     predictor = get_bits(&s->gb, 8);       /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1068     ilv = get_bits(&s->gb, 8);             /* JPEG Se / JPEG-LS ILV */
1069     prev_shift      = get_bits(&s->gb, 4); /* Ah */
1070     point_transform = get_bits(&s->gb, 4); /* Al */
1071
1072     if (nb_components > 1) {
1073         /* interleaved stream */
1074         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1075         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1076     } else if (!s->ls) { /* skip this for JPEG-LS */
1077         h = s->h_max / s->h_scount[0];
1078         v = s->v_max / s->v_scount[0];
1079         s->mb_width     = (s->width  + h * block_size - 1) / (h * block_size);
1080         s->mb_height    = (s->height + v * block_size - 1) / (v * block_size);
1081         s->nb_blocks[0] = 1;
1082         s->h_scount[0]  = 1;
1083         s->v_scount[0]  = 1;
1084     }
1085
1086     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1087         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n",
1088                s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
1089                predictor, point_transform, ilv, s->bits,
1090                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1091
1092
1093     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1094     for (i = s->mjpb_skiptosod; i > 0; i--)
1095         skip_bits(&s->gb, 8);
1096
1097 next_field:
1098     for (i = 0; i < nb_components; i++)
1099         s->last_dc[i] = 1024;
1100
1101     if (s->lossless) {
1102         if (CONFIG_JPEGLS_DECODER && s->ls) {
1103 //            for () {
1104 //            reset_ls_coding_parameters(s, 0);
1105
1106             if ((ret = ff_jpegls_decode_picture(s, predictor,
1107                                                 point_transform, ilv)) < 0)
1108                 return ret;
1109         } else {
1110             if (s->rgb) {
1111                 if ((ret = ljpeg_decode_rgb_scan(s, predictor,
1112                                                  point_transform)) < 0)
1113                     return ret;
1114             } else {
1115                 if ((ret = ljpeg_decode_yuv_scan(s, predictor,
1116                                                  point_transform,
1117                                                  nb_components)) < 0)
1118                     return ret;
1119             }
1120         }
1121     } else {
1122         if (s->progressive && predictor) {
1123             if ((ret = mjpeg_decode_scan_progressive_ac(s, predictor,
1124                                                         ilv, prev_shift,
1125                                                         point_transform,
1126                                                         mb_bitmask,
1127                                                         reference)) < 0)
1128                 return ret;
1129         } else {
1130             if ((ret = mjpeg_decode_scan(s, nb_components,
1131                                          prev_shift, point_transform,
1132                                          mb_bitmask, reference)) < 0)
1133                 return ret;
1134         }
1135     }
1136
1137     if (s->interlaced &&
1138         get_bits_left(&s->gb) > 32 &&
1139         show_bits(&s->gb, 8) == 0xFF) {
1140         GetBitContext bak = s->gb;
1141         align_get_bits(&bak);
1142         if (show_bits(&bak, 16) == 0xFFD1) {
1143             av_dlog(s->avctx, "AVRn interlaced picture marker found\n");
1144             s->gb = bak;
1145             skip_bits(&s->gb, 16);
1146             s->bottom_field ^= 1;
1147
1148             goto next_field;
1149         }
1150     }
1151
1152     emms_c();
1153     return 0;
1154  out_of_range:
1155     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1156     return AVERROR_INVALIDDATA;
1157 }
1158
1159 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1160 {
1161     if (get_bits(&s->gb, 16) != 4)
1162         return AVERROR_INVALIDDATA;
1163     s->restart_interval = get_bits(&s->gb, 16);
1164     s->restart_count    = 0;
1165     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
1166            s->restart_interval);
1167
1168     return 0;
1169 }
1170
1171 static int mjpeg_decode_app(MJpegDecodeContext *s)
1172 {
1173     int len, id, i;
1174
1175     len = get_bits(&s->gb, 16);
1176     if (len < 5)
1177         return AVERROR_INVALIDDATA;
1178     if (8 * len > get_bits_left(&s->gb))
1179         return AVERROR_INVALIDDATA;
1180
1181     id   = get_bits_long(&s->gb, 32);
1182     id   = av_be2ne32(id);
1183     len -= 6;
1184
1185     if (s->avctx->debug & FF_DEBUG_STARTCODE)
1186         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1187
1188     /* Buggy AVID, it puts EOI only at every 10th frame. */
1189     /* Also, this fourcc is used by non-avid files too, it holds some
1190        information, but it's always present in AVID-created files. */
1191     if (id == AV_RL32("AVI1")) {
1192         /* structure:
1193             4bytes      AVI1
1194             1bytes      polarity
1195             1bytes      always zero
1196             4bytes      field_size
1197             4bytes      field_size_less_padding
1198         */
1199         s->buggy_avid = 1;
1200         i = get_bits(&s->gb, 8);
1201         if (i == 2)
1202             s->bottom_field = 1;
1203         else if (i == 1)
1204             s->bottom_field = 0;
1205 #if 0
1206         skip_bits(&s->gb, 8);
1207         skip_bits(&s->gb, 32);
1208         skip_bits(&s->gb, 32);
1209         len -= 10;
1210 #endif
1211         goto out;
1212     }
1213
1214 //    len -= 2;
1215
1216     if (id == AV_RL32("JFIF")) {
1217         int t_w, t_h, v1, v2;
1218         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1219         v1 = get_bits(&s->gb, 8);
1220         v2 = get_bits(&s->gb, 8);
1221         skip_bits(&s->gb, 8);
1222
1223         s->avctx->sample_aspect_ratio.num = get_bits(&s->gb, 16);
1224         s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
1225
1226         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1227             av_log(s->avctx, AV_LOG_INFO,
1228                    "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1229                    v1, v2,
1230                    s->avctx->sample_aspect_ratio.num,
1231                    s->avctx->sample_aspect_ratio.den);
1232
1233         t_w = get_bits(&s->gb, 8);
1234         t_h = get_bits(&s->gb, 8);
1235         if (t_w && t_h) {
1236             /* skip thumbnail */
1237             if (len -10 - (t_w * t_h * 3) > 0)
1238                 len -= t_w * t_h * 3;
1239         }
1240         len -= 10;
1241         goto out;
1242     }
1243
1244     if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e')) {
1245         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1246             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1247         skip_bits(&s->gb, 16); /* version */
1248         skip_bits(&s->gb, 16); /* flags0 */
1249         skip_bits(&s->gb, 16); /* flags1 */
1250         skip_bits(&s->gb,  8); /* transform */
1251         len -= 7;
1252         goto out;
1253     }
1254
1255     if (id == AV_RL32("LJIF")) {
1256         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1257             av_log(s->avctx, AV_LOG_INFO,
1258                    "Pegasus lossless jpeg header found\n");
1259         skip_bits(&s->gb, 16); /* version ? */
1260         skip_bits(&s->gb, 16); /* unknwon always 0? */
1261         skip_bits(&s->gb, 16); /* unknwon always 0? */
1262         skip_bits(&s->gb, 16); /* unknwon always 0? */
1263         switch (get_bits(&s->gb, 8)) {
1264         case 1:
1265             s->rgb         = 1;
1266             s->pegasus_rct = 0;
1267             break;
1268         case 2:
1269             s->rgb         = 1;
1270             s->pegasus_rct = 1;
1271             break;
1272         default:
1273             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1274         }
1275         len -= 9;
1276         goto out;
1277     }
1278
1279     /* Apple MJPEG-A */
1280     if ((s->start_code == APP1) && (len > (0x28 - 8))) {
1281         id   = get_bits_long(&s->gb, 32);
1282         id   = av_be2ne32(id);
1283         len -= 4;
1284         /* Apple MJPEG-A */
1285         if (id == AV_RL32("mjpg")) {
1286 #if 0
1287             skip_bits(&s->gb, 32); /* field size */
1288             skip_bits(&s->gb, 32); /* pad field size */
1289             skip_bits(&s->gb, 32); /* next off */
1290             skip_bits(&s->gb, 32); /* quant off */
1291             skip_bits(&s->gb, 32); /* huff off */
1292             skip_bits(&s->gb, 32); /* image off */
1293             skip_bits(&s->gb, 32); /* scan off */
1294             skip_bits(&s->gb, 32); /* data off */
1295 #endif
1296             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1297                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1298         }
1299     }
1300
1301 out:
1302     /* slow but needed for extreme adobe jpegs */
1303     if (len < 0)
1304         av_log(s->avctx, AV_LOG_ERROR,
1305                "mjpeg: error, decode_app parser read over the end\n");
1306     while (--len > 0)
1307         skip_bits(&s->gb, 8);
1308
1309     return 0;
1310 }
1311
1312 static int mjpeg_decode_com(MJpegDecodeContext *s)
1313 {
1314     int len = get_bits(&s->gb, 16);
1315     if (len >= 2 && 8 * len - 16 <= get_bits_left(&s->gb)) {
1316         char *cbuf = av_malloc(len - 1);
1317         if (cbuf) {
1318             int i;
1319             for (i = 0; i < len - 2; i++)
1320                 cbuf[i] = get_bits(&s->gb, 8);
1321             if (i > 0 && cbuf[i - 1] == '\n')
1322                 cbuf[i - 1] = 0;
1323             else
1324                 cbuf[i] = 0;
1325
1326             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1327                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1328
1329             /* buggy avid, it puts EOI only at every 10th frame */
1330             if (!strcmp(cbuf, "AVID")) {
1331                 s->buggy_avid = 1;
1332             } else if (!strcmp(cbuf, "CS=ITU601"))
1333                 s->cs_itu601 = 1;
1334             else if ((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) ||
1335                      (len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
1336                 s->flipped = 1;
1337
1338             av_free(cbuf);
1339         }
1340     }
1341
1342     return 0;
1343 }
1344
1345 /* return the 8 bit start code value and update the search
1346    state. Return -1 if no start code found */
1347 static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
1348 {
1349     const uint8_t *buf_ptr;
1350     unsigned int v, v2;
1351     int val;
1352 #ifdef DEBUG
1353     int skipped = 0;
1354 #endif
1355
1356     buf_ptr = *pbuf_ptr;
1357     while (buf_ptr < buf_end) {
1358         v  = *buf_ptr++;
1359         v2 = *buf_ptr;
1360         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1361             val = *buf_ptr++;
1362             goto found;
1363         }
1364 #ifdef DEBUG
1365         skipped++;
1366 #endif
1367     }
1368     val = -1;
1369 found:
1370     av_dlog(NULL, "find_marker skipped %d bytes\n", skipped);
1371     *pbuf_ptr = buf_ptr;
1372     return val;
1373 }
1374
1375 int ff_mjpeg_find_marker(MJpegDecodeContext *s,
1376                          const uint8_t **buf_ptr, const uint8_t *buf_end,
1377                          const uint8_t **unescaped_buf_ptr,
1378                          int *unescaped_buf_size)
1379 {
1380     int start_code;
1381     start_code = find_marker(buf_ptr, buf_end);
1382
1383     av_fast_padded_malloc(&s->buffer, &s->buffer_size, buf_end - *buf_ptr);
1384     if (!s->buffer)
1385         return AVERROR(ENOMEM);
1386
1387     /* unescape buffer of SOS, use special treatment for JPEG-LS */
1388     if (start_code == SOS && !s->ls) {
1389         const uint8_t *src = *buf_ptr;
1390         uint8_t *dst = s->buffer;
1391
1392         while (src < buf_end) {
1393             uint8_t x = *(src++);
1394
1395             *(dst++) = x;
1396             if (s->avctx->codec_id != AV_CODEC_ID_THP) {
1397                 if (x == 0xff) {
1398                     while (src < buf_end && x == 0xff)
1399                         x = *(src++);
1400
1401                     if (x >= 0xd0 && x <= 0xd7)
1402                         *(dst++) = x;
1403                     else if (x)
1404                         break;
1405                 }
1406             }
1407         }
1408         *unescaped_buf_ptr  = s->buffer;
1409         *unescaped_buf_size = dst - s->buffer;
1410         memset(s->buffer + *unescaped_buf_size, 0,
1411                FF_INPUT_BUFFER_PADDING_SIZE);
1412
1413         av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
1414                (buf_end - *buf_ptr) - (dst - s->buffer));
1415     } else if (start_code == SOS && s->ls) {
1416         const uint8_t *src = *buf_ptr;
1417         uint8_t *dst  = s->buffer;
1418         int bit_count = 0;
1419         int t = 0, b = 0;
1420         PutBitContext pb;
1421
1422         s->cur_scan++;
1423
1424         /* find marker */
1425         while (src + t < buf_end) {
1426             uint8_t x = src[t++];
1427             if (x == 0xff) {
1428                 while ((src + t < buf_end) && x == 0xff)
1429                     x = src[t++];
1430                 if (x & 0x80) {
1431                     t -= 2;
1432                     break;
1433                 }
1434             }
1435         }
1436         bit_count = t * 8;
1437         init_put_bits(&pb, dst, t);
1438
1439         /* unescape bitstream */
1440         while (b < t) {
1441             uint8_t x = src[b++];
1442             put_bits(&pb, 8, x);
1443             if (x == 0xFF) {
1444                 x = src[b++];
1445                 put_bits(&pb, 7, x);
1446                 bit_count--;
1447             }
1448         }
1449         flush_put_bits(&pb);
1450
1451         *unescaped_buf_ptr  = dst;
1452         *unescaped_buf_size = (bit_count + 7) >> 3;
1453         memset(s->buffer + *unescaped_buf_size, 0,
1454                FF_INPUT_BUFFER_PADDING_SIZE);
1455     } else {
1456         *unescaped_buf_ptr  = *buf_ptr;
1457         *unescaped_buf_size = buf_end - *buf_ptr;
1458     }
1459
1460     return start_code;
1461 }
1462
1463 int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1464                           AVPacket *avpkt)
1465 {
1466     AVFrame     *frame = data;
1467     const uint8_t *buf = avpkt->data;
1468     int buf_size       = avpkt->size;
1469     MJpegDecodeContext *s = avctx->priv_data;
1470     const uint8_t *buf_end, *buf_ptr;
1471     const uint8_t *unescaped_buf_ptr;
1472     int unescaped_buf_size;
1473     int start_code;
1474     int ret = 0;
1475
1476     s->got_picture = 0; // picture from previous image can not be reused
1477     buf_ptr = buf;
1478     buf_end = buf + buf_size;
1479     while (buf_ptr < buf_end) {
1480         /* find start next marker */
1481         start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
1482                                           &unescaped_buf_ptr,
1483                                           &unescaped_buf_size);
1484         /* EOF */
1485         if (start_code < 0) {
1486             goto the_end;
1487         } else if (unescaped_buf_size > INT_MAX / 8) {
1488             av_log(avctx, AV_LOG_ERROR,
1489                    "MJPEG packet 0x%x too big (%d/%d), corrupt data?\n",
1490                    start_code, unescaped_buf_size, buf_size);
1491             return AVERROR_INVALIDDATA;
1492         }
1493
1494         av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
1495                start_code, buf_end - buf_ptr);
1496
1497         ret = init_get_bits(&s->gb, unescaped_buf_ptr,
1498                             unescaped_buf_size * 8);
1499         if (ret < 0)
1500             return ret;
1501
1502         s->start_code = start_code;
1503         if (s->avctx->debug & FF_DEBUG_STARTCODE)
1504             av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1505
1506         /* process markers */
1507         if (start_code >= 0xd0 && start_code <= 0xd7)
1508             av_log(avctx, AV_LOG_DEBUG,
1509                    "restart marker: %d\n", start_code & 0x0f);
1510             /* APP fields */
1511         else if (start_code >= APP0 && start_code <= APP15)
1512             mjpeg_decode_app(s);
1513             /* Comment */
1514         else if (start_code == COM)
1515             mjpeg_decode_com(s);
1516
1517         if (!CONFIG_JPEGLS_DECODER &&
1518             (start_code == SOF48 || start_code == LSE)) {
1519             av_log(avctx, AV_LOG_ERROR, "JPEG-LS support not enabled.\n");
1520             return AVERROR(ENOSYS);
1521         }
1522
1523         switch (start_code) {
1524         case SOI:
1525             s->restart_interval = 0;
1526             s->restart_count    = 0;
1527             /* nothing to do on SOI */
1528             break;
1529         case DQT:
1530             ff_mjpeg_decode_dqt(s);
1531             break;
1532         case DHT:
1533             if ((ret = ff_mjpeg_decode_dht(s)) < 0) {
1534                 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
1535                 return ret;
1536             }
1537             break;
1538         case SOF0:
1539         case SOF1:
1540             s->lossless    = 0;
1541             s->ls          = 0;
1542             s->progressive = 0;
1543             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1544                 return ret;
1545             break;
1546         case SOF2:
1547             s->lossless    = 0;
1548             s->ls          = 0;
1549             s->progressive = 1;
1550             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1551                 return ret;
1552             break;
1553         case SOF3:
1554             s->lossless    = 1;
1555             s->ls          = 0;
1556             s->progressive = 0;
1557             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1558                 return ret;
1559             break;
1560         case SOF48:
1561             s->lossless    = 1;
1562             s->ls          = 1;
1563             s->progressive = 0;
1564             if ((ret = ff_mjpeg_decode_sof(s)) < 0)
1565                 return ret;
1566             break;
1567         case LSE:
1568             if (!CONFIG_JPEGLS_DECODER ||
1569                 (ret = ff_jpegls_decode_lse(s)) < 0)
1570                 return ret;
1571             break;
1572         case EOI:
1573             s->cur_scan = 0;
1574             if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1575                 break;
1576 eoi_parser:
1577             if (!s->got_picture) {
1578                 av_log(avctx, AV_LOG_WARNING,
1579                        "Found EOI before any SOF, ignoring\n");
1580                 break;
1581             }
1582             if (s->interlaced) {
1583                 s->bottom_field ^= 1;
1584                 /* if not bottom field, do not output image yet */
1585                 if (s->bottom_field == !s->interlace_polarity)
1586                     goto not_the_end;
1587             }
1588             if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
1589                 return ret;
1590             if (s->flipped) {
1591                 int i;
1592                 for (i = 0; frame->data[i]; i++) {
1593                     int h = frame->height >> ((i == 1 || i == 2) ?
1594                                               s->pix_desc->log2_chroma_h : 0);
1595                     frame->data[i] += frame->linesize[i] * (h - 1);
1596                     frame->linesize[i] *= -1;
1597                 }
1598             }
1599             *got_frame = 1;
1600
1601             if (!s->lossless &&
1602                 avctx->debug & FF_DEBUG_QP) {
1603                 av_log(avctx, AV_LOG_DEBUG,
1604                        "QP: %d\n", FFMAX3(s->qscale[0],
1605                                           s->qscale[1],
1606                                           s->qscale[2]));
1607             }
1608
1609             goto the_end;
1610         case SOS:
1611             if (!s->got_picture) {
1612                 av_log(avctx, AV_LOG_WARNING,
1613                        "Can not process SOS before SOF, skipping\n");
1614                 break;
1615                 }
1616             if ((ret = ff_mjpeg_decode_sos(s, NULL, NULL)) < 0 &&
1617                 (avctx->err_recognition & AV_EF_EXPLODE))
1618                 return ret;
1619             /* buggy avid puts EOI every 10-20th frame */
1620             /* if restart period is over process EOI */
1621             if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1622                 goto eoi_parser;
1623             break;
1624         case DRI:
1625             mjpeg_decode_dri(s);
1626             break;
1627         case SOF5:
1628         case SOF6:
1629         case SOF7:
1630         case SOF9:
1631         case SOF10:
1632         case SOF11:
1633         case SOF13:
1634         case SOF14:
1635         case SOF15:
1636         case JPG:
1637             av_log(avctx, AV_LOG_ERROR,
1638                    "mjpeg: unsupported coding type (%x)\n", start_code);
1639             break;
1640         }
1641
1642 not_the_end:
1643         /* eof process start code */
1644         buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
1645         av_log(avctx, AV_LOG_DEBUG,
1646                "marker parser used %d bytes (%d bits)\n",
1647                (get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
1648     }
1649     if (s->got_picture) {
1650         av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
1651         goto eoi_parser;
1652     }
1653     av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
1654     return AVERROR_INVALIDDATA;
1655 the_end:
1656     av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n",
1657            buf_end - buf_ptr);
1658 //  return buf_end - buf_ptr;
1659     return buf_ptr - buf;
1660 }
1661
1662 av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
1663 {
1664     MJpegDecodeContext *s = avctx->priv_data;
1665     int i, j;
1666
1667     if (s->picture) {
1668         av_frame_free(&s->picture);
1669         s->picture_ptr = NULL;
1670     } else if (s->picture_ptr)
1671         av_frame_unref(s->picture_ptr);
1672
1673     av_free(s->buffer);
1674     av_freep(&s->ljpeg_buffer);
1675     s->ljpeg_buffer_size = 0;
1676
1677     for (i = 0; i < 3; i++) {
1678         for (j = 0; j < 4; j++)
1679             ff_free_vlc(&s->vlcs[i][j]);
1680     }
1681     for (i = 0; i < MAX_COMPONENTS; i++) {
1682         av_freep(&s->blocks[i]);
1683         av_freep(&s->last_nnz[i]);
1684     }
1685     return 0;
1686 }
1687
1688 #define OFFSET(x) offsetof(MJpegDecodeContext, x)
1689 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1690 static const AVOption options[] = {
1691     { "extern_huff", "Use external huffman table.",
1692       OFFSET(extern_huff), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
1693     { NULL },
1694 };
1695
1696 static const AVClass mjpegdec_class = {
1697     .class_name = "MJPEG decoder",
1698     .item_name  = av_default_item_name,
1699     .option     = options,
1700     .version    = LIBAVUTIL_VERSION_INT,
1701 };
1702
1703 AVCodec ff_mjpeg_decoder = {
1704     .name           = "mjpeg",
1705     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
1706     .type           = AVMEDIA_TYPE_VIDEO,
1707     .id             = AV_CODEC_ID_MJPEG,
1708     .priv_data_size = sizeof(MJpegDecodeContext),
1709     .init           = ff_mjpeg_decode_init,
1710     .close          = ff_mjpeg_decode_end,
1711     .decode         = ff_mjpeg_decode_frame,
1712     .capabilities   = CODEC_CAP_DR1,
1713     .priv_class     = &mjpegdec_class,
1714 };
1715
1716 AVCodec ff_thp_decoder = {
1717     .name           = "thp",
1718     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
1719     .type           = AVMEDIA_TYPE_VIDEO,
1720     .id             = AV_CODEC_ID_THP,
1721     .priv_data_size = sizeof(MJpegDecodeContext),
1722     .init           = ff_mjpeg_decode_init,
1723     .close          = ff_mjpeg_decode_end,
1724     .decode         = ff_mjpeg_decode_frame,
1725     .capabilities   = CODEC_CAP_DR1,
1726 };