Decode non-interleaved scans
[ffmpeg.git] / libavcodec / mjpeg.c
1 /*
2  * MJPEG encoder and decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard.
4  * Copyright (c) 2003 Alex Beregszaszi
5  * Copyright (c) 2003-2004 Michael Niedermayer
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  * Support for external huffman table, various fixes (AVID workaround),
24  * aspecting, new decode_frame mechanism and apple mjpeg-b support
25  *                                  by Alex Beregszaszi <alex@naxine.org>
26  */
27
28 /**
29  * @file mjpeg.c
30  * MJPEG encoder and decoder.
31  */
32
33 //#define DEBUG
34 #include <assert.h>
35
36 #include "avcodec.h"
37 #include "dsputil.h"
38 #include "mpegvideo.h"
39
40 /* use two quantizer tables (one for luminance and one for chrominance) */
41 /* not yet working */
42 #undef TWOMATRIXES
43
44 typedef struct MJpegContext {
45     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
46     uint16_t huff_code_dc_luminance[12];
47     uint8_t huff_size_dc_chrominance[12];
48     uint16_t huff_code_dc_chrominance[12];
49
50     uint8_t huff_size_ac_luminance[256];
51     uint16_t huff_code_ac_luminance[256];
52     uint8_t huff_size_ac_chrominance[256];
53     uint16_t huff_code_ac_chrominance[256];
54 } MJpegContext;
55
56 /* JPEG marker codes */
57 typedef enum {
58     /* start of frame */
59     SOF0  = 0xc0,       /* baseline */
60     SOF1  = 0xc1,       /* extended sequential, huffman */
61     SOF2  = 0xc2,       /* progressive, huffman */
62     SOF3  = 0xc3,       /* lossless, huffman */
63
64     SOF5  = 0xc5,       /* differential sequential, huffman */
65     SOF6  = 0xc6,       /* differential progressive, huffman */
66     SOF7  = 0xc7,       /* differential lossless, huffman */
67     JPG   = 0xc8,       /* reserved for JPEG extension */
68     SOF9  = 0xc9,       /* extended sequential, arithmetic */
69     SOF10 = 0xca,       /* progressive, arithmetic */
70     SOF11 = 0xcb,       /* lossless, arithmetic */
71
72     SOF13 = 0xcd,       /* differential sequential, arithmetic */
73     SOF14 = 0xce,       /* differential progressive, arithmetic */
74     SOF15 = 0xcf,       /* differential lossless, arithmetic */
75
76     DHT   = 0xc4,       /* define huffman tables */
77
78     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
79
80     /* restart with modulo 8 count "m" */
81     RST0  = 0xd0,
82     RST1  = 0xd1,
83     RST2  = 0xd2,
84     RST3  = 0xd3,
85     RST4  = 0xd4,
86     RST5  = 0xd5,
87     RST6  = 0xd6,
88     RST7  = 0xd7,
89
90     SOI   = 0xd8,       /* start of image */
91     EOI   = 0xd9,       /* end of image */
92     SOS   = 0xda,       /* start of scan */
93     DQT   = 0xdb,       /* define quantization tables */
94     DNL   = 0xdc,       /* define number of lines */
95     DRI   = 0xdd,       /* define restart interval */
96     DHP   = 0xde,       /* define hierarchical progression */
97     EXP   = 0xdf,       /* expand reference components */
98
99     APP0  = 0xe0,
100     APP1  = 0xe1,
101     APP2  = 0xe2,
102     APP3  = 0xe3,
103     APP4  = 0xe4,
104     APP5  = 0xe5,
105     APP6  = 0xe6,
106     APP7  = 0xe7,
107     APP8  = 0xe8,
108     APP9  = 0xe9,
109     APP10 = 0xea,
110     APP11 = 0xeb,
111     APP12 = 0xec,
112     APP13 = 0xed,
113     APP14 = 0xee,
114     APP15 = 0xef,
115
116     JPG0  = 0xf0,
117     JPG1  = 0xf1,
118     JPG2  = 0xf2,
119     JPG3  = 0xf3,
120     JPG4  = 0xf4,
121     JPG5  = 0xf5,
122     JPG6  = 0xf6,
123     SOF48 = 0xf7,       ///< JPEG-LS
124     LSE   = 0xf8,       ///< JPEG-LS extension parameters
125     JPG9  = 0xf9,
126     JPG10 = 0xfa,
127     JPG11 = 0xfb,
128     JPG12 = 0xfc,
129     JPG13 = 0xfd,
130
131     COM   = 0xfe,       /* comment */
132
133     TEM   = 0x01,       /* temporary private use for arithmetic coding */
134
135     /* 0x02 -> 0xbf reserved */
136 } JPEG_MARKER;
137
138 #if 0
139 /* These are the sample quantization tables given in JPEG spec section K.1.
140  * The spec says that the values given produce "good" quality, and
141  * when divided by 2, "very good" quality.
142  */
143 static const unsigned char std_luminance_quant_tbl[64] = {
144     16,  11,  10,  16,  24,  40,  51,  61,
145     12,  12,  14,  19,  26,  58,  60,  55,
146     14,  13,  16,  24,  40,  57,  69,  56,
147     14,  17,  22,  29,  51,  87,  80,  62,
148     18,  22,  37,  56,  68, 109, 103,  77,
149     24,  35,  55,  64,  81, 104, 113,  92,
150     49,  64,  78,  87, 103, 121, 120, 101,
151     72,  92,  95,  98, 112, 100, 103,  99
152 };
153 static const unsigned char std_chrominance_quant_tbl[64] = {
154     17,  18,  24,  47,  99,  99,  99,  99,
155     18,  21,  26,  66,  99,  99,  99,  99,
156     24,  26,  56,  99,  99,  99,  99,  99,
157     47,  66,  99,  99,  99,  99,  99,  99,
158     99,  99,  99,  99,  99,  99,  99,  99,
159     99,  99,  99,  99,  99,  99,  99,  99,
160     99,  99,  99,  99,  99,  99,  99,  99,
161     99,  99,  99,  99,  99,  99,  99,  99
162 };
163 #endif
164
165 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
166 /* IMPORTANT: these are only valid for 8-bit data precision! */
167 static const uint8_t bits_dc_luminance[17] =
168 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
169 static const uint8_t val_dc_luminance[] =
170 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
171
172 static const uint8_t bits_dc_chrominance[17] =
173 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
174 static const uint8_t val_dc_chrominance[] =
175 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
176
177 static const uint8_t bits_ac_luminance[17] =
178 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
179 static const uint8_t val_ac_luminance[] =
180 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
181   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
182   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
183   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
184   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
185   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
186   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
187   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
188   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
189   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
190   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
191   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
192   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
193   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
194   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
195   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
196   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
197   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
198   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
199   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
200   0xf9, 0xfa
201 };
202
203 static const uint8_t bits_ac_chrominance[17] =
204 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
205
206 static const uint8_t val_ac_chrominance[] =
207 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
208   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
209   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
210   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
211   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
212   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
213   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
214   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
215   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
216   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
217   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
218   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
219   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
220   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
221   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
222   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
223   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
224   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
225   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
226   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
227   0xf9, 0xfa
228 };
229
230 /* isn't this function nicer than the one in the libjpeg ? */
231 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
232                                 const uint8_t *bits_table, const uint8_t *val_table)
233 {
234     int i, j, k,nb, code, sym;
235
236     code = 0;
237     k = 0;
238     for(i=1;i<=16;i++) {
239         nb = bits_table[i];
240         for(j=0;j<nb;j++) {
241             sym = val_table[k++];
242             huff_size[sym] = i;
243             huff_code[sym] = code;
244             code++;
245         }
246         code <<= 1;
247     }
248 }
249
250 #ifdef CONFIG_ENCODERS
251 int mjpeg_init(MpegEncContext *s)
252 {
253     MJpegContext *m;
254
255     m = av_malloc(sizeof(MJpegContext));
256     if (!m)
257         return -1;
258
259     s->min_qcoeff=-1023;
260     s->max_qcoeff= 1023;
261
262     /* build all the huffman tables */
263     build_huffman_codes(m->huff_size_dc_luminance,
264                         m->huff_code_dc_luminance,
265                         bits_dc_luminance,
266                         val_dc_luminance);
267     build_huffman_codes(m->huff_size_dc_chrominance,
268                         m->huff_code_dc_chrominance,
269                         bits_dc_chrominance,
270                         val_dc_chrominance);
271     build_huffman_codes(m->huff_size_ac_luminance,
272                         m->huff_code_ac_luminance,
273                         bits_ac_luminance,
274                         val_ac_luminance);
275     build_huffman_codes(m->huff_size_ac_chrominance,
276                         m->huff_code_ac_chrominance,
277                         bits_ac_chrominance,
278                         val_ac_chrominance);
279
280     s->mjpeg_ctx = m;
281     return 0;
282 }
283
284 void mjpeg_close(MpegEncContext *s)
285 {
286     av_free(s->mjpeg_ctx);
287 }
288 #endif //CONFIG_ENCODERS
289
290 #define PREDICT(ret, topleft, top, left, predictor)\
291     switch(predictor){\
292         case 1: ret= left; break;\
293         case 2: ret= top; break;\
294         case 3: ret= topleft; break;\
295         case 4: ret= left   +   top - topleft; break;\
296         case 5: ret= left   + ((top - topleft)>>1); break;\
297         case 6: ret= top + ((left   - topleft)>>1); break;\
298         default:\
299         case 7: ret= (left + top)>>1; break;\
300     }
301
302 #ifdef CONFIG_ENCODERS
303 static inline void put_marker(PutBitContext *p, int code)
304 {
305     put_bits(p, 8, 0xff);
306     put_bits(p, 8, code);
307 }
308
309 /* table_class: 0 = DC coef, 1 = AC coefs */
310 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
311                              const uint8_t *bits_table, const uint8_t *value_table)
312 {
313     PutBitContext *p = &s->pb;
314     int n, i;
315
316     put_bits(p, 4, table_class);
317     put_bits(p, 4, table_id);
318
319     n = 0;
320     for(i=1;i<=16;i++) {
321         n += bits_table[i];
322         put_bits(p, 8, bits_table[i]);
323     }
324
325     for(i=0;i<n;i++)
326         put_bits(p, 8, value_table[i]);
327
328     return n + 17;
329 }
330
331 static void jpeg_table_header(MpegEncContext *s)
332 {
333     PutBitContext *p = &s->pb;
334     int i, j, size;
335     uint8_t *ptr;
336
337     /* quant matrixes */
338     put_marker(p, DQT);
339 #ifdef TWOMATRIXES
340     put_bits(p, 16, 2 + 2 * (1 + 64));
341 #else
342     put_bits(p, 16, 2 + 1 * (1 + 64));
343 #endif
344     put_bits(p, 4, 0); /* 8 bit precision */
345     put_bits(p, 4, 0); /* table 0 */
346     for(i=0;i<64;i++) {
347         j = s->intra_scantable.permutated[i];
348         put_bits(p, 8, s->intra_matrix[j]);
349     }
350 #ifdef TWOMATRIXES
351     put_bits(p, 4, 0); /* 8 bit precision */
352     put_bits(p, 4, 1); /* table 1 */
353     for(i=0;i<64;i++) {
354         j = s->intra_scantable.permutated[i];
355         put_bits(p, 8, s->chroma_intra_matrix[j]);
356     }
357 #endif
358
359     /* huffman table */
360     put_marker(p, DHT);
361     flush_put_bits(p);
362     ptr = pbBufPtr(p);
363     put_bits(p, 16, 0); /* patched later */
364     size = 2;
365     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
366     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
367
368     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
369     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
370     ptr[0] = size >> 8;
371     ptr[1] = size;
372 }
373
374 static void jpeg_put_comments(MpegEncContext *s)
375 {
376     PutBitContext *p = &s->pb;
377     int size;
378     uint8_t *ptr;
379
380     if (s->aspect_ratio_info /* && !lossless */)
381     {
382     /* JFIF header */
383     put_marker(p, APP0);
384     put_bits(p, 16, 16);
385     ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
386     put_bits(p, 16, 0x0201); /* v 1.02 */
387     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
388     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
389     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
390     put_bits(p, 8, 0); /* thumbnail width */
391     put_bits(p, 8, 0); /* thumbnail height */
392     }
393
394     /* comment */
395     if(!(s->flags & CODEC_FLAG_BITEXACT)){
396         put_marker(p, COM);
397         flush_put_bits(p);
398         ptr = pbBufPtr(p);
399         put_bits(p, 16, 0); /* patched later */
400         ff_put_string(p, LIBAVCODEC_IDENT, 1);
401         size = strlen(LIBAVCODEC_IDENT)+3;
402         ptr[0] = size >> 8;
403         ptr[1] = size;
404     }
405
406     if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
407        ||s->avctx->pix_fmt == PIX_FMT_YUV422P
408        ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
409         put_marker(p, COM);
410         flush_put_bits(p);
411         ptr = pbBufPtr(p);
412         put_bits(p, 16, 0); /* patched later */
413         ff_put_string(p, "CS=ITU601", 1);
414         size = strlen("CS=ITU601")+3;
415         ptr[0] = size >> 8;
416         ptr[1] = size;
417     }
418 }
419
420 void mjpeg_picture_header(MpegEncContext *s)
421 {
422     const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
423     const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;
424
425     assert(!(ls && s->mjpeg_write_tables));
426
427     put_marker(&s->pb, SOI);
428
429     if (!s->mjpeg_data_only_frames)
430     {
431     jpeg_put_comments(s);
432
433     if (s->mjpeg_write_tables) jpeg_table_header(s);
434
435     switch(s->avctx->codec_id){
436     case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
437     case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
438     case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
439     default: assert(0);
440     }
441
442     put_bits(&s->pb, 16, 17);
443     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
444         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
445     else
446         put_bits(&s->pb, 8, 8); /* 8 bits/component */
447     put_bits(&s->pb, 16, s->height);
448     put_bits(&s->pb, 16, s->width);
449     put_bits(&s->pb, 8, 3); /* 3 components */
450
451     /* Y component */
452     put_bits(&s->pb, 8, 1); /* component number */
453     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
454     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
455     put_bits(&s->pb, 8, 0); /* select matrix */
456
457     /* Cb component */
458     put_bits(&s->pb, 8, 2); /* component number */
459     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
460     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
461 #ifdef TWOMATRIXES
462     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
463 #else
464     put_bits(&s->pb, 8, 0); /* select matrix */
465 #endif
466
467     /* Cr component */
468     put_bits(&s->pb, 8, 3); /* component number */
469     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
470     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
471 #ifdef TWOMATRIXES
472     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
473 #else
474     put_bits(&s->pb, 8, 0); /* select matrix */
475 #endif
476     }
477
478     /* scan header */
479     put_marker(&s->pb, SOS);
480     put_bits(&s->pb, 16, 12); /* length */
481     put_bits(&s->pb, 8, 3); /* 3 components */
482
483     /* Y component */
484     put_bits(&s->pb, 8, 1); /* index */
485     put_bits(&s->pb, 4, 0); /* DC huffman table index */
486     put_bits(&s->pb, 4, 0); /* AC huffman table index */
487
488     /* Cb component */
489     put_bits(&s->pb, 8, 2); /* index */
490     put_bits(&s->pb, 4, 1); /* DC huffman table index */
491     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
492
493     /* Cr component */
494     put_bits(&s->pb, 8, 3); /* index */
495     put_bits(&s->pb, 4, 1); /* DC huffman table index */
496     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
497
498     put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
499
500     switch(s->avctx->codec_id){
501     case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
502     case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
503     case CODEC_ID_JPEGLS: put_bits(&s->pb, 8,  1); break; /* ILV = line interleaved */
504     default: assert(0);
505     }
506
507     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
508
509     //FIXME DC/AC entropy table selectors stuff in jpegls
510 }
511
512 static void escape_FF(MpegEncContext *s, int start)
513 {
514     int size= put_bits_count(&s->pb) - start*8;
515     int i, ff_count;
516     uint8_t *buf= s->pb.buf + start;
517     int align= (-(size_t)(buf))&3;
518
519     assert((size&7) == 0);
520     size >>= 3;
521
522     ff_count=0;
523     for(i=0; i<size && i<align; i++){
524         if(buf[i]==0xFF) ff_count++;
525     }
526     for(; i<size-15; i+=16){
527         int acc, v;
528
529         v= *(uint32_t*)(&buf[i]);
530         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
531         v= *(uint32_t*)(&buf[i+4]);
532         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
533         v= *(uint32_t*)(&buf[i+8]);
534         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
535         v= *(uint32_t*)(&buf[i+12]);
536         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
537
538         acc>>=4;
539         acc+= (acc>>16);
540         acc+= (acc>>8);
541         ff_count+= acc&0xFF;
542     }
543     for(; i<size; i++){
544         if(buf[i]==0xFF) ff_count++;
545     }
546
547     if(ff_count==0) return;
548
549     /* skip put bits */
550     for(i=0; i<ff_count-3; i+=4)
551         put_bits(&s->pb, 32, 0);
552     put_bits(&s->pb, (ff_count-i)*8, 0);
553     flush_put_bits(&s->pb);
554
555     for(i=size-1; ff_count; i--){
556         int v= buf[i];
557
558         if(v==0xFF){
559 //printf("%d %d\n", i, ff_count);
560             buf[i+ff_count]= 0;
561             ff_count--;
562         }
563
564         buf[i+ff_count]= v;
565     }
566 }
567
568 void ff_mjpeg_stuffing(PutBitContext * pbc)
569 {
570     int length;
571     length= (-put_bits_count(pbc))&7;
572     if(length) put_bits(pbc, length, (1<<length)-1);
573 }
574
575 void mjpeg_picture_trailer(MpegEncContext *s)
576 {
577     ff_mjpeg_stuffing(&s->pb);
578     flush_put_bits(&s->pb);
579
580     assert((s->header_bits&7)==0);
581
582     escape_FF(s, s->header_bits>>3);
583
584     put_marker(&s->pb, EOI);
585 }
586
587 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
588                                    uint8_t *huff_size, uint16_t *huff_code)
589 {
590     int mant, nbits;
591
592     if (val == 0) {
593         put_bits(&s->pb, huff_size[0], huff_code[0]);
594     } else {
595         mant = val;
596         if (val < 0) {
597             val = -val;
598             mant--;
599         }
600
601         nbits= av_log2_16bit(val) + 1;
602
603         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
604
605         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
606     }
607 }
608
609 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
610 {
611     int mant, nbits, code, i, j;
612     int component, dc, run, last_index, val;
613     MJpegContext *m = s->mjpeg_ctx;
614     uint8_t *huff_size_ac;
615     uint16_t *huff_code_ac;
616
617     /* DC coef */
618     component = (n <= 3 ? 0 : (n&1) + 1);
619     dc = block[0]; /* overflow is impossible */
620     val = dc - s->last_dc[component];
621     if (n < 4) {
622         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
623         huff_size_ac = m->huff_size_ac_luminance;
624         huff_code_ac = m->huff_code_ac_luminance;
625     } else {
626         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
627         huff_size_ac = m->huff_size_ac_chrominance;
628         huff_code_ac = m->huff_code_ac_chrominance;
629     }
630     s->last_dc[component] = dc;
631
632     /* AC coefs */
633
634     run = 0;
635     last_index = s->block_last_index[n];
636     for(i=1;i<=last_index;i++) {
637         j = s->intra_scantable.permutated[i];
638         val = block[j];
639         if (val == 0) {
640             run++;
641         } else {
642             while (run >= 16) {
643                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
644                 run -= 16;
645             }
646             mant = val;
647             if (val < 0) {
648                 val = -val;
649                 mant--;
650             }
651
652             nbits= av_log2(val) + 1;
653             code = (run << 4) | nbits;
654
655             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
656
657             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
658             run = 0;
659         }
660     }
661
662     /* output EOB only if not already 64 values */
663     if (last_index < 63 || run != 0)
664         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
665 }
666
667 void mjpeg_encode_mb(MpegEncContext *s,
668                      DCTELEM block[6][64])
669 {
670     int i;
671     for(i=0;i<5;i++) {
672         encode_block(s, block[i], i);
673     }
674     if (s->chroma_format == CHROMA_420) {
675         encode_block(s, block[5], 5);
676     } else {
677         encode_block(s, block[6], 6);
678         encode_block(s, block[5], 5);
679         encode_block(s, block[7], 7);
680     }
681 }
682
683 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
684     MpegEncContext * const s = avctx->priv_data;
685     MJpegContext * const m = s->mjpeg_ctx;
686     AVFrame *pict = data;
687     const int width= s->width;
688     const int height= s->height;
689     AVFrame * const p= (AVFrame*)&s->current_picture;
690     const int predictor= avctx->prediction_method+1;
691
692     init_put_bits(&s->pb, buf, buf_size);
693
694     *p = *pict;
695     p->pict_type= FF_I_TYPE;
696     p->key_frame= 1;
697
698     mjpeg_picture_header(s);
699
700     s->header_bits= put_bits_count(&s->pb);
701
702     if(avctx->pix_fmt == PIX_FMT_RGBA32){
703         int x, y, i;
704         const int linesize= p->linesize[0];
705         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
706         int left[3], top[3], topleft[3];
707
708         for(i=0; i<3; i++){
709             buffer[0][i]= 1 << (9 - 1);
710         }
711
712         for(y = 0; y < height; y++) {
713             const int modified_predictor= y ? predictor : 1;
714             uint8_t *ptr = p->data[0] + (linesize * y);
715
716             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
717                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
718                 return -1;
719             }
720
721             for(i=0; i<3; i++){
722                 top[i]= left[i]= topleft[i]= buffer[0][i];
723             }
724             for(x = 0; x < width; x++) {
725                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
726                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
727                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
728
729                 for(i=0;i<3;i++) {
730                     int pred, diff;
731
732                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
733
734                     topleft[i]= top[i];
735                     top[i]= buffer[x+1][i];
736
737                     left[i]= buffer[x][i];
738
739                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
740
741                     if(i==0)
742                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
743                     else
744                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
745                 }
746             }
747         }
748     }else{
749         int mb_x, mb_y, i;
750         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
751         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
752
753         for(mb_y = 0; mb_y < mb_height; mb_y++) {
754             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
755                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
756                 return -1;
757             }
758             for(mb_x = 0; mb_x < mb_width; mb_x++) {
759                 if(mb_x==0 || mb_y==0){
760                     for(i=0;i<3;i++) {
761                         uint8_t *ptr;
762                         int x, y, h, v, linesize;
763                         h = s->mjpeg_hsample[i];
764                         v = s->mjpeg_vsample[i];
765                         linesize= p->linesize[i];
766
767                         for(y=0; y<v; y++){
768                             for(x=0; x<h; x++){
769                                 int pred;
770
771                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
772                                 if(y==0 && mb_y==0){
773                                     if(x==0 && mb_x==0){
774                                         pred= 128;
775                                     }else{
776                                         pred= ptr[-1];
777                                     }
778                                 }else{
779                                     if(x==0 && mb_x==0){
780                                         pred= ptr[-linesize];
781                                     }else{
782                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
783                                     }
784                                 }
785
786                                 if(i==0)
787                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
788                                 else
789                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
790                             }
791                         }
792                     }
793                 }else{
794                     for(i=0;i<3;i++) {
795                         uint8_t *ptr;
796                         int x, y, h, v, linesize;
797                         h = s->mjpeg_hsample[i];
798                         v = s->mjpeg_vsample[i];
799                         linesize= p->linesize[i];
800
801                         for(y=0; y<v; y++){
802                             for(x=0; x<h; x++){
803                                 int pred;
804
805                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
806 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
807                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
808
809                                 if(i==0)
810                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
811                                 else
812                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
813                             }
814                         }
815                     }
816                 }
817             }
818         }
819     }
820
821     emms_c();
822
823     mjpeg_picture_trailer(s);
824     s->picture_number++;
825
826     flush_put_bits(&s->pb);
827     return pbBufPtr(&s->pb) - s->pb.buf;
828 //    return (put_bits_count(&f->pb)+7)/8;
829 }
830
831 #endif //CONFIG_ENCODERS
832
833 /******************************************/
834 /* decoding */
835
836 #define MAX_COMPONENTS 4
837
838 typedef struct MJpegDecodeContext {
839     AVCodecContext *avctx;
840     GetBitContext gb;
841     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
842
843     int start_code; /* current start code */
844     int buffer_size;
845     uint8_t *buffer;
846
847     int16_t quant_matrixes[4][64];
848     VLC vlcs[2][4];
849     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
850
851     int org_height;  /* size given at codec init */
852     int first_picture;    /* true if decoding first picture */
853     int interlaced;     /* true if interlaced */
854     int bottom_field;   /* true if bottom field */
855     int lossless;
856     int ls;
857     int progressive;
858     int rgb;
859     int rct;            /* standard rct */
860     int pegasus_rct;    /* pegasus reversible colorspace transform */
861     int bits;           /* bits per component */
862
863     int maxval;
864     int near;         ///< near lossless bound (si 0 for lossless)
865     int t1,t2,t3;
866     int reset;        ///< context halfing intervall ?rename
867
868     int width, height;
869     int mb_width, mb_height;
870     int nb_components;
871     int component_id[MAX_COMPONENTS];
872     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
873     int v_count[MAX_COMPONENTS];
874     int comp_index[MAX_COMPONENTS];
875     int dc_index[MAX_COMPONENTS];
876     int ac_index[MAX_COMPONENTS];
877     int nb_blocks[MAX_COMPONENTS];
878     int h_scount[MAX_COMPONENTS];
879     int v_scount[MAX_COMPONENTS];
880     int h_max, v_max; /* maximum h and v counts */
881     int quant_index[4];   /* quant table index for each component */
882     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
883     AVFrame picture; /* picture structure */
884     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
885     int8_t *qscale_table;
886     DECLARE_ALIGNED_8(DCTELEM, block[64]);
887     ScanTable scantable;
888     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
889     void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
890
891     int restart_interval;
892     int restart_count;
893
894     int buggy_avid;
895     int cs_itu601;
896     int interlace_polarity;
897
898     int mjpb_skiptosod;
899
900     int cur_scan; /* current scan, used by JPEG-LS */
901 } MJpegDecodeContext;
902
903 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant
904
905 static int mjpeg_decode_dht(MJpegDecodeContext *s);
906
907 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
908                       int nb_codes, int use_static, int is_ac)
909 {
910     uint8_t huff_size[256+16];
911     uint16_t huff_code[256+16];
912
913     assert(nb_codes <= 256);
914
915     memset(huff_size, 0, sizeof(huff_size));
916     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
917
918     if(is_ac){
919         memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
920         memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
921         memset(huff_size, 0, sizeof(uint8_t)*16);
922         memset(huff_code, 0, sizeof(uint16_t)*16);
923         nb_codes += 16;
924     }
925
926     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
927 }
928
929 static int mjpeg_decode_init(AVCodecContext *avctx)
930 {
931     MJpegDecodeContext *s = avctx->priv_data;
932     MpegEncContext s2;
933     memset(s, 0, sizeof(MJpegDecodeContext));
934
935     s->avctx = avctx;
936
937     /* ugly way to get the idct & scantable FIXME */
938     memset(&s2, 0, sizeof(MpegEncContext));
939     s2.avctx= avctx;
940 //    s2->out_format = FMT_MJPEG;
941     dsputil_init(&s2.dsp, avctx);
942     DCT_common_init(&s2);
943
944     s->scantable= s2.intra_scantable;
945     s->idct_put= s2.dsp.idct_put;
946     s->idct_add= s2.dsp.idct_add;
947
948     s->mpeg_enc_ctx_allocated = 0;
949     s->buffer_size = 0;
950     s->buffer = NULL;
951     s->start_code = -1;
952     s->first_picture = 1;
953     s->org_height = avctx->coded_height;
954
955     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
956     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
957     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
958     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
959
960     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
961     {
962         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
963         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
964         mjpeg_decode_dht(s);
965         /* should check for error - but dunno */
966     }
967
968     return 0;
969 }
970
971
972 /**
973  * finds the end of the current frame in the bitstream.
974  * @return the position of the first byte of the next frame, or -1
975  */
976 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
977     int vop_found, i;
978     uint16_t state;
979
980     vop_found= pc->frame_start_found;
981     state= pc->state;
982
983     i=0;
984     if(!vop_found){
985         for(i=0; i<buf_size; i++){
986             state= (state<<8) | buf[i];
987             if(state == 0xFFD8){
988                 i++;
989                 vop_found=1;
990                 break;
991             }
992         }
993     }
994
995     if(vop_found){
996         /* EOF considered as end of frame */
997         if (buf_size == 0)
998             return 0;
999         for(; i<buf_size; i++){
1000             state= (state<<8) | buf[i];
1001             if(state == 0xFFD8){
1002                 pc->frame_start_found=0;
1003                 pc->state=0;
1004                 return i-1;
1005             }
1006         }
1007     }
1008     pc->frame_start_found= vop_found;
1009     pc->state= state;
1010     return END_NOT_FOUND;
1011 }
1012
1013 static int jpeg_parse(AVCodecParserContext *s,
1014                            AVCodecContext *avctx,
1015                            uint8_t **poutbuf, int *poutbuf_size,
1016                            const uint8_t *buf, int buf_size)
1017 {
1018     ParseContext *pc = s->priv_data;
1019     int next;
1020
1021     next= find_frame_end(pc, buf, buf_size);
1022
1023     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1024         *poutbuf = NULL;
1025         *poutbuf_size = 0;
1026         return buf_size;
1027     }
1028
1029     *poutbuf = (uint8_t *)buf;
1030     *poutbuf_size = buf_size;
1031     return next;
1032 }
1033
1034 /* quantize tables */
1035 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1036 {
1037     int len, index, i, j;
1038
1039     len = get_bits(&s->gb, 16) - 2;
1040
1041     while (len >= 65) {
1042         /* only 8 bit precision handled */
1043         if (get_bits(&s->gb, 4) != 0)
1044         {
1045             dprintf("dqt: 16bit precision\n");
1046             return -1;
1047         }
1048         index = get_bits(&s->gb, 4);
1049         if (index >= 4)
1050             return -1;
1051         dprintf("index=%d\n", index);
1052         /* read quant table */
1053         for(i=0;i<64;i++) {
1054             j = s->scantable.permutated[i];
1055             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1056         }
1057
1058         //XXX FIXME finetune, and perhaps add dc too
1059         s->qscale[index]= FFMAX(
1060             s->quant_matrixes[index][s->scantable.permutated[1]],
1061             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1062         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1063         len -= 65;
1064     }
1065
1066     return 0;
1067 }
1068
1069 /* decode huffman tables and build VLC decoders */
1070 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1071 {
1072     int len, index, i, class, n, v, code_max;
1073     uint8_t bits_table[17];
1074     uint8_t val_table[256];
1075
1076     len = get_bits(&s->gb, 16) - 2;
1077
1078     while (len > 0) {
1079         if (len < 17)
1080             return -1;
1081         class = get_bits(&s->gb, 4);
1082         if (class >= 2)
1083             return -1;
1084         index = get_bits(&s->gb, 4);
1085         if (index >= 4)
1086             return -1;
1087         n = 0;
1088         for(i=1;i<=16;i++) {
1089             bits_table[i] = get_bits(&s->gb, 8);
1090             n += bits_table[i];
1091         }
1092         len -= 17;
1093         if (len < n || n > 256)
1094             return -1;
1095
1096         code_max = 0;
1097         for(i=0;i<n;i++) {
1098             v = get_bits(&s->gb, 8);
1099             if (v > code_max)
1100                 code_max = v;
1101             val_table[i] = v;
1102         }
1103         len -= n;
1104
1105         /* build VLC and flush previous vlc if present */
1106         free_vlc(&s->vlcs[class][index]);
1107         dprintf("class=%d index=%d nb_codes=%d\n",
1108                class, index, code_max + 1);
1109         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1110             return -1;
1111         }
1112     }
1113     return 0;
1114 }
1115
1116 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1117 {
1118     int len, nb_components, i, width, height, pix_fmt_id;
1119
1120     /* XXX: verify len field validity */
1121     len = get_bits(&s->gb, 16);
1122     s->bits= get_bits(&s->gb, 8);
1123
1124     if(s->pegasus_rct) s->bits=9;
1125     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1126
1127     if (s->bits != 8 && !s->lossless){
1128         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1129         return -1;
1130     }
1131
1132     height = get_bits(&s->gb, 16);
1133     width = get_bits(&s->gb, 16);
1134
1135     dprintf("sof0: picture: %dx%d\n", width, height);
1136     if(avcodec_check_dimensions(s->avctx, width, height))
1137         return -1;
1138
1139     nb_components = get_bits(&s->gb, 8);
1140     if (nb_components <= 0 ||
1141         nb_components > MAX_COMPONENTS)
1142         return -1;
1143     if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1144         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1145         return -1;
1146     }
1147     s->nb_components = nb_components;
1148     s->h_max = 1;
1149     s->v_max = 1;
1150     for(i=0;i<nb_components;i++) {
1151         /* component id */
1152         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1153         s->h_count[i] = get_bits(&s->gb, 4);
1154         s->v_count[i] = get_bits(&s->gb, 4);
1155         /* compute hmax and vmax (only used in interleaved case) */
1156         if (s->h_count[i] > s->h_max)
1157             s->h_max = s->h_count[i];
1158         if (s->v_count[i] > s->v_max)
1159             s->v_max = s->v_count[i];
1160         s->quant_index[i] = get_bits(&s->gb, 8);
1161         if (s->quant_index[i] >= 4)
1162             return -1;
1163         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1164             s->v_count[i], s->component_id[i], s->quant_index[i]);
1165     }
1166
1167     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1168         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1169         return -1;
1170     }
1171
1172     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1173
1174     /* if different size, realloc/alloc picture */
1175     /* XXX: also check h_count and v_count */
1176     if (width != s->width || height != s->height) {
1177         av_freep(&s->qscale_table);
1178
1179         s->width = width;
1180         s->height = height;
1181
1182         /* test interlaced mode */
1183         if (s->first_picture &&
1184             s->org_height != 0 &&
1185             s->height < ((s->org_height * 3) / 4)) {
1186             s->interlaced = 1;
1187 //            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1188             s->bottom_field = 0;
1189             height *= 2;
1190         }
1191
1192         avcodec_set_dimensions(s->avctx, width, height);
1193
1194         s->qscale_table= av_mallocz((s->width+15)/16);
1195
1196         s->first_picture = 0;
1197     }
1198
1199     if(s->interlaced && s->bottom_field)
1200         return 0;
1201
1202     /* XXX: not complete test ! */
1203     pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1204                  (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
1205                  (s->h_count[2] <<  4) |  s->v_count[2];
1206     dprintf("pix fmt id %x\n", pix_fmt_id);
1207     switch(pix_fmt_id){
1208     case 0x222222:
1209     case 0x111111:
1210         if(s->rgb){
1211             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1212         }else if(s->nb_components==3)
1213             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1214         else
1215             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1216         break;
1217     case 0x211111:
1218     case 0x221212:
1219         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1220         break;
1221     default:
1222     case 0x221111:
1223         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1224         break;
1225     }
1226     if(s->ls){
1227         if(s->nb_components > 1)
1228             s->avctx->pix_fmt = PIX_FMT_RGB24;
1229         else if(s->bits <= 8)
1230             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1231         else
1232             s->avctx->pix_fmt = PIX_FMT_GRAY16;
1233     }
1234
1235     if(s->picture.data[0])
1236         s->avctx->release_buffer(s->avctx, &s->picture);
1237
1238     s->picture.reference= 0;
1239     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1240         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1241         return -1;
1242     }
1243     s->picture.pict_type= I_TYPE;
1244     s->picture.key_frame= 1;
1245
1246     for(i=0; i<3; i++){
1247         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1248     }
1249
1250 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1251
1252     if (len != (8+(3*nb_components)))
1253     {
1254         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1255     }
1256
1257     /* totally blank picture as progressive JPEG will only add details to it */
1258     if(s->progressive){
1259         memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1260         memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1261         memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1262     }
1263     return 0;
1264 }
1265
1266 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1267 {
1268     int code;
1269     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1270     if (code < 0)
1271     {
1272         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1273                 &s->vlcs[0][dc_index]);
1274         return 0xffff;
1275     }
1276
1277     if(code)
1278         return get_xbits(&s->gb, code);
1279     else
1280         return 0;
1281 }
1282
1283 /* decode block and dequantize */
1284 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1285                         int component, int dc_index, int ac_index, int16_t *quant_matrix)
1286 {
1287     int code, i, j, level, val;
1288
1289     /* DC coef */
1290     val = mjpeg_decode_dc(s, dc_index);
1291     if (val == 0xffff) {
1292         dprintf("error dc\n");
1293         return -1;
1294     }
1295     val = val * quant_matrix[0] + s->last_dc[component];
1296     s->last_dc[component] = val;
1297     block[0] = val;
1298     /* AC coefs */
1299     i = 0;
1300     {OPEN_READER(re, &s->gb)
1301     for(;;) {
1302         UPDATE_CACHE(re, &s->gb);
1303         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1304
1305         /* EOB */
1306         if (code == 0x10)
1307             break;
1308         i += ((unsigned)code) >> 4;
1309         if(code != 0x100){
1310             code &= 0xf;
1311             if(code > MIN_CACHE_BITS - 16){
1312                 UPDATE_CACHE(re, &s->gb)
1313             }
1314             {
1315                 int cache=GET_CACHE(re,&s->gb);
1316                 int sign=(~cache)>>31;
1317                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1318             }
1319
1320             LAST_SKIP_BITS(re, &s->gb, code)
1321
1322             if (i >= 63) {
1323                 if(i == 63){
1324                     j = s->scantable.permutated[63];
1325                     block[j] = level * quant_matrix[j];
1326                     break;
1327                 }
1328                 dprintf("error count: %d\n", i);
1329                 return -1;
1330             }
1331             j = s->scantable.permutated[i];
1332             block[j] = level * quant_matrix[j];
1333         }
1334     }
1335     CLOSE_READER(re, &s->gb)}
1336
1337     return 0;
1338 }
1339
1340 /* decode block and dequantize - progressive JPEG version */
1341 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1342                         int component, int dc_index, int ac_index, int16_t *quant_matrix,
1343                         int ss, int se, int Ah, int Al, int *EOBRUN)
1344 {
1345     int code, i, j, level, val, run;
1346
1347     /* DC coef */
1348     if(!ss){
1349         val = mjpeg_decode_dc(s, dc_index);
1350         if (val == 0xffff) {
1351             dprintf("error dc\n");
1352             return -1;
1353         }
1354         val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1355     }else
1356         val = 0;
1357     s->last_dc[component] = val;
1358     block[0] = val;
1359     if(!se) return 0;
1360     /* AC coefs */
1361     if(*EOBRUN){
1362         (*EOBRUN)--;
1363         return 0;
1364     }
1365     {OPEN_READER(re, &s->gb)
1366     for(i=ss;;i++) {
1367         UPDATE_CACHE(re, &s->gb);
1368         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1369         /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1370         code -= 16;
1371         if(code & 0xF) {
1372             i += ((unsigned) code) >> 4;
1373             code &= 0xf;
1374             if(code > MIN_CACHE_BITS - 16){
1375                 UPDATE_CACHE(re, &s->gb)
1376             }
1377             {
1378                 int cache=GET_CACHE(re,&s->gb);
1379                 int sign=(~cache)>>31;
1380                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1381             }
1382
1383             LAST_SKIP_BITS(re, &s->gb, code)
1384
1385             if (i >= se) {
1386                 if(i == se){
1387                     j = s->scantable.permutated[se];
1388                     block[j] = level * quant_matrix[j] << Al;
1389                     break;
1390                 }
1391                 dprintf("error count: %d\n", i);
1392                 return -1;
1393             }
1394             j = s->scantable.permutated[i];
1395             block[j] = level * quant_matrix[j] << Al;
1396         }else{
1397             run = ((unsigned) code) >> 4;
1398             if(run == 0xF){// ZRL - skip 15 coefficients
1399                 i += 15;
1400             }else{
1401                 val = run;
1402                 run = (1 << run);
1403                 UPDATE_CACHE(re, &s->gb);
1404                 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1405                 if(val)
1406                     LAST_SKIP_BITS(re, &s->gb, val);
1407                 *EOBRUN = run - 1;
1408                 break;
1409             }
1410         }
1411     }
1412     CLOSE_READER(re, &s->gb)}
1413
1414     return 0;
1415 }
1416
1417 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1418     int i, mb_x, mb_y;
1419     uint16_t buffer[32768][4];
1420     int left[3], top[3], topleft[3];
1421     const int linesize= s->linesize[0];
1422     const int mask= (1<<s->bits)-1;
1423
1424     if((unsigned)s->mb_width > 32768) //dynamic alloc
1425         return -1;
1426
1427     for(i=0; i<3; i++){
1428         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1429     }
1430     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1431         const int modified_predictor= mb_y ? predictor : 1;
1432         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1433
1434         if (s->interlaced && s->bottom_field)
1435             ptr += linesize >> 1;
1436
1437         for(i=0; i<3; i++){
1438             top[i]= left[i]= topleft[i]= buffer[0][i];
1439         }
1440         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1441             if (s->restart_interval && !s->restart_count)
1442                 s->restart_count = s->restart_interval;
1443
1444             for(i=0;i<3;i++) {
1445                 int pred;
1446
1447                 topleft[i]= top[i];
1448                 top[i]= buffer[mb_x][i];
1449
1450                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1451
1452                 left[i]=
1453                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1454             }
1455
1456             if (s->restart_interval && !--s->restart_count) {
1457                 align_get_bits(&s->gb);
1458                 skip_bits(&s->gb, 16); /* skip RSTn */
1459             }
1460         }
1461
1462         if(s->rct){
1463             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1464                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1465                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1466                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1467             }
1468         }else if(s->pegasus_rct){
1469             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1470                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1471                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1472                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1473             }
1474         }else{
1475             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1476                 ptr[4*mb_x+0] = buffer[mb_x][0];
1477                 ptr[4*mb_x+1] = buffer[mb_x][1];
1478                 ptr[4*mb_x+2] = buffer[mb_x][2];
1479             }
1480         }
1481     }
1482     return 0;
1483 }
1484
1485 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1486     int i, mb_x, mb_y;
1487     const int nb_components=3;
1488
1489     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1490         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1491             if (s->restart_interval && !s->restart_count)
1492                 s->restart_count = s->restart_interval;
1493
1494             if(mb_x==0 || mb_y==0 || s->interlaced){
1495                 for(i=0;i<nb_components;i++) {
1496                     uint8_t *ptr;
1497                     int n, h, v, x, y, c, j, linesize;
1498                     n = s->nb_blocks[i];
1499                     c = s->comp_index[i];
1500                     h = s->h_scount[i];
1501                     v = s->v_scount[i];
1502                     x = 0;
1503                     y = 0;
1504                     linesize= s->linesize[c];
1505
1506                     for(j=0; j<n; j++) {
1507                         int pred;
1508
1509                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1510                         if(y==0 && mb_y==0){
1511                             if(x==0 && mb_x==0){
1512                                 pred= 128 << point_transform;
1513                             }else{
1514                                 pred= ptr[-1];
1515                             }
1516                         }else{
1517                             if(x==0 && mb_x==0){
1518                                 pred= ptr[-linesize];
1519                             }else{
1520                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1521                             }
1522                         }
1523
1524                         if (s->interlaced && s->bottom_field)
1525                             ptr += linesize >> 1;
1526                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1527
1528                         if (++x == h) {
1529                             x = 0;
1530                             y++;
1531                         }
1532                     }
1533                 }
1534             }else{
1535                 for(i=0;i<nb_components;i++) {
1536                     uint8_t *ptr;
1537                     int n, h, v, x, y, c, j, linesize;
1538                     n = s->nb_blocks[i];
1539                     c = s->comp_index[i];
1540                     h = s->h_scount[i];
1541                     v = s->v_scount[i];
1542                     x = 0;
1543                     y = 0;
1544                     linesize= s->linesize[c];
1545
1546                     for(j=0; j<n; j++) {
1547                         int pred;
1548
1549                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1550                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1551                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1552                         if (++x == h) {
1553                             x = 0;
1554                             y++;
1555                         }
1556                     }
1557                 }
1558             }
1559             if (s->restart_interval && !--s->restart_count) {
1560                 align_get_bits(&s->gb);
1561                 skip_bits(&s->gb, 16); /* skip RSTn */
1562             }
1563         }
1564     }
1565     return 0;
1566 }
1567
1568 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1569     int i, mb_x, mb_y;
1570     int EOBRUN = 0;
1571
1572     if(Ah) return 0; /* TODO decode refinement planes too */
1573     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1574         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1575             if (s->restart_interval && !s->restart_count)
1576                 s->restart_count = s->restart_interval;
1577
1578             for(i=0;i<nb_components;i++) {
1579                 uint8_t *ptr;
1580                 int n, h, v, x, y, c, j;
1581                 n = s->nb_blocks[i];
1582                 c = s->comp_index[i];
1583                 h = s->h_scount[i];
1584                 v = s->v_scount[i];
1585                 x = 0;
1586                 y = 0;
1587                 for(j=0;j<n;j++) {
1588                     memset(s->block, 0, sizeof(s->block));
1589                     if (!s->progressive && decode_block(s, s->block, i,
1590                                      s->dc_index[i], s->ac_index[i],
1591                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1592                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1593                         return -1;
1594                     }
1595                     if (s->progressive && decode_block_progressive(s, s->block, i,
1596                                      s->dc_index[i], s->ac_index[i],
1597                                      s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1598                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1599                         return -1;
1600                     }
1601 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1602                     ptr = s->picture.data[c] +
1603                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1604                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1605                     if (s->interlaced && s->bottom_field)
1606                         ptr += s->linesize[c] >> 1;
1607 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1608                     if(!s->progressive)
1609                         s->idct_put(ptr, s->linesize[c], s->block);
1610                     else
1611                         s->idct_add(ptr, s->linesize[c], s->block);
1612                     if (++x == h) {
1613                         x = 0;
1614                         y++;
1615                     }
1616                 }
1617             }
1618             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1619             if (s->restart_interval && (s->restart_interval < 1350) &&
1620                 !--s->restart_count) {
1621                 align_get_bits(&s->gb);
1622                 skip_bits(&s->gb, 16); /* skip RSTn */
1623                 for (i=0; i<nb_components; i++) /* reset dc */
1624                     s->last_dc[i] = 1024;
1625             }
1626         }
1627     }
1628     return 0;
1629 }
1630
1631 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1632 {
1633     int len, nb_components, i, h, v, predictor, point_transform;
1634     int vmax, hmax, index, id;
1635     const int block_size= s->lossless ? 1 : 8;
1636     int ilv, prev_shift;
1637
1638     /* XXX: verify len field validity */
1639     len = get_bits(&s->gb, 16);
1640     nb_components = get_bits(&s->gb, 8);
1641     if (len != 6+2*nb_components)
1642     {
1643         dprintf("decode_sos: invalid len (%d)\n", len);
1644         return -1;
1645     }
1646     vmax = 0;
1647     hmax = 0;
1648     for(i=0;i<nb_components;i++) {
1649         id = get_bits(&s->gb, 8) - 1;
1650         dprintf("component: %d\n", id);
1651         /* find component index */
1652         for(index=0;index<s->nb_components;index++)
1653             if (id == s->component_id[index])
1654                 break;
1655         if (index == s->nb_components)
1656         {
1657             dprintf("decode_sos: index(%d) out of components\n", index);
1658             return -1;
1659         }
1660
1661         s->comp_index[i] = index;
1662
1663         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1664         s->h_scount[i] = s->h_count[index];
1665         s->v_scount[i] = s->v_count[index];
1666
1667         s->dc_index[i] = get_bits(&s->gb, 4);
1668         s->ac_index[i] = get_bits(&s->gb, 4);
1669
1670         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1671             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1672             goto out_of_range;
1673 #if 0 //buggy
1674         switch(s->start_code)
1675         {
1676             case SOF0:
1677                 if (dc_index[i] > 1 || ac_index[i] > 1)
1678                     goto out_of_range;
1679                 break;
1680             case SOF1:
1681             case SOF2:
1682                 if (dc_index[i] > 3 || ac_index[i] > 3)
1683                     goto out_of_range;
1684                 break;
1685             case SOF3:
1686                 if (dc_index[i] > 3 || ac_index[i] != 0)
1687                     goto out_of_range;
1688                 break;
1689         }
1690 #endif
1691     }
1692
1693     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1694     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1695     prev_shift = get_bits(&s->gb, 4); /* Ah */
1696     point_transform= get_bits(&s->gb, 4); /* Al */
1697
1698     for(i=0;i<nb_components;i++)
1699         s->last_dc[i] = 1024;
1700
1701     if (nb_components > 1) {
1702         /* interleaved stream */
1703         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1704         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1705     } else if(!s->ls) { /* skip this for JPEG-LS */
1706         h = s->h_max / s->h_scount[0];
1707         v = s->v_max / s->v_scount[0];
1708         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1709         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1710         s->nb_blocks[0] = 1;
1711         s->h_scount[0] = 1;
1712         s->v_scount[0] = 1;
1713     }
1714
1715     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1716         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
1717                predictor, point_transform, ilv, s->bits,
1718                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1719
1720
1721     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1722     for (i = s->mjpb_skiptosod; i > 0; i--)
1723         skip_bits(&s->gb, 8);
1724
1725     if(s->lossless){
1726         if(s->ls){
1727 //            for(){
1728 //            reset_ls_coding_parameters(s, 0);
1729
1730             ls_decode_picture(s, predictor, point_transform, ilv);
1731         }else{
1732             if(s->rgb){
1733                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1734                     return -1;
1735             }else{
1736                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1737                     return -1;
1738             }
1739         }
1740     }else{
1741         if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1742             return -1;
1743     }
1744     emms_c();
1745     return 0;
1746  out_of_range:
1747     dprintf("decode_sos: ac/dc index out of range\n");
1748     return -1;
1749 }
1750
1751 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1752 {
1753     if (get_bits(&s->gb, 16) != 4)
1754         return -1;
1755     s->restart_interval = get_bits(&s->gb, 16);
1756     s->restart_count = 0;
1757     dprintf("restart interval: %d\n", s->restart_interval);
1758
1759     return 0;
1760 }
1761
1762 static int mjpeg_decode_app(MJpegDecodeContext *s)
1763 {
1764     int len, id;
1765
1766     len = get_bits(&s->gb, 16);
1767     if (len < 5)
1768         return -1;
1769     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1770         return -1;
1771
1772     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1773     id = be2me_32(id);
1774     len -= 6;
1775
1776     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1777         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1778     }
1779
1780     /* buggy AVID, it puts EOI only at every 10th frame */
1781     /* also this fourcc is used by non-avid files too, it holds some
1782        informations, but it's always present in AVID creates files */
1783     if (id == ff_get_fourcc("AVI1"))
1784     {
1785         /* structure:
1786             4bytes      AVI1
1787             1bytes      polarity
1788             1bytes      always zero
1789             4bytes      field_size
1790             4bytes      field_size_less_padding
1791         */
1792             s->buggy_avid = 1;
1793 //        if (s->first_picture)
1794 //            printf("mjpeg: workarounding buggy AVID\n");
1795         s->interlace_polarity = get_bits(&s->gb, 8);
1796 #if 0
1797         skip_bits(&s->gb, 8);
1798         skip_bits(&s->gb, 32);
1799         skip_bits(&s->gb, 32);
1800         len -= 10;
1801 #endif
1802 //        if (s->interlace_polarity)
1803 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1804         goto out;
1805     }
1806
1807 //    len -= 2;
1808
1809     if (id == ff_get_fourcc("JFIF"))
1810     {
1811         int t_w, t_h, v1, v2;
1812         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1813         v1= get_bits(&s->gb, 8);
1814         v2= get_bits(&s->gb, 8);
1815         skip_bits(&s->gb, 8);
1816
1817         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1818         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1819
1820         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1821             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1822                 v1, v2,
1823                 s->avctx->sample_aspect_ratio.num,
1824                 s->avctx->sample_aspect_ratio.den
1825             );
1826
1827         t_w = get_bits(&s->gb, 8);
1828         t_h = get_bits(&s->gb, 8);
1829         if (t_w && t_h)
1830         {
1831             /* skip thumbnail */
1832             if (len-10-(t_w*t_h*3) > 0)
1833                 len -= t_w*t_h*3;
1834         }
1835         len -= 10;
1836         goto out;
1837     }
1838
1839     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1840     {
1841         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1842             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1843         skip_bits(&s->gb, 16); /* version */
1844         skip_bits(&s->gb, 16); /* flags0 */
1845         skip_bits(&s->gb, 16); /* flags1 */
1846         skip_bits(&s->gb, 8);  /* transform */
1847         len -= 7;
1848         goto out;
1849     }
1850
1851     if (id == ff_get_fourcc("LJIF")){
1852         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1853             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1854         skip_bits(&s->gb, 16); /* version ? */
1855         skip_bits(&s->gb, 16); /* unknwon always 0? */
1856         skip_bits(&s->gb, 16); /* unknwon always 0? */
1857         skip_bits(&s->gb, 16); /* unknwon always 0? */
1858         switch( get_bits(&s->gb, 8)){
1859         case 1:
1860             s->rgb= 1;
1861             s->pegasus_rct=0;
1862             break;
1863         case 2:
1864             s->rgb= 1;
1865             s->pegasus_rct=1;
1866             break;
1867         default:
1868             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1869         }
1870         len -= 9;
1871         goto out;
1872     }
1873
1874     /* Apple MJPEG-A */
1875     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1876     {
1877         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1878         id = be2me_32(id);
1879         len -= 4;
1880         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1881         {
1882 #if 0
1883             skip_bits(&s->gb, 32); /* field size */
1884             skip_bits(&s->gb, 32); /* pad field size */
1885             skip_bits(&s->gb, 32); /* next off */
1886             skip_bits(&s->gb, 32); /* quant off */
1887             skip_bits(&s->gb, 32); /* huff off */
1888             skip_bits(&s->gb, 32); /* image off */
1889             skip_bits(&s->gb, 32); /* scan off */
1890             skip_bits(&s->gb, 32); /* data off */
1891 #endif
1892             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1893                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1894         }
1895     }
1896
1897 out:
1898     /* slow but needed for extreme adobe jpegs */
1899     if (len < 0)
1900         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1901     while(--len > 0)
1902         skip_bits(&s->gb, 8);
1903
1904     return 0;
1905 }
1906
1907 static int mjpeg_decode_com(MJpegDecodeContext *s)
1908 {
1909     int len = get_bits(&s->gb, 16);
1910     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1911         char *cbuf = av_malloc(len - 1);
1912         if (cbuf) {
1913             int i;
1914             for (i = 0; i < len - 2; i++)
1915                 cbuf[i] = get_bits(&s->gb, 8);
1916             if (i > 0 && cbuf[i-1] == '\n')
1917                 cbuf[i-1] = 0;
1918             else
1919                 cbuf[i] = 0;
1920
1921             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1922                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1923
1924             /* buggy avid, it puts EOI only at every 10th frame */
1925             if (!strcmp(cbuf, "AVID"))
1926             {
1927                 s->buggy_avid = 1;
1928                 //        if (s->first_picture)
1929                 //            printf("mjpeg: workarounding buggy AVID\n");
1930             }
1931             else if(!strcmp(cbuf, "CS=ITU601")){
1932                 s->cs_itu601= 1;
1933             }
1934
1935             av_free(cbuf);
1936         }
1937     }
1938
1939     return 0;
1940 }
1941
1942 #if 0
1943 static int valid_marker_list[] =
1944 {
1945         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1946 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1947 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1949 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1950 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1951 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1952 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1953 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1954 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1955 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1956 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1957 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1958 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1959 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1960 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1961 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1962 }
1963 #endif
1964
1965 /* return the 8 bit start code value and update the search
1966    state. Return -1 if no start code found */
1967 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1968 {
1969     uint8_t *buf_ptr;
1970     unsigned int v, v2;
1971     int val;
1972 #ifdef DEBUG
1973     int skipped=0;
1974 #endif
1975
1976     buf_ptr = *pbuf_ptr;
1977     while (buf_ptr < buf_end) {
1978         v = *buf_ptr++;
1979         v2 = *buf_ptr;
1980         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1981             val = *buf_ptr++;
1982             goto found;
1983         }
1984 #ifdef DEBUG
1985         skipped++;
1986 #endif
1987     }
1988     val = -1;
1989 found:
1990 #ifdef DEBUG
1991     dprintf("find_marker skipped %d bytes\n", skipped);
1992 #endif
1993     *pbuf_ptr = buf_ptr;
1994     return val;
1995 }
1996
1997 static int mjpeg_decode_frame(AVCodecContext *avctx,
1998                               void *data, int *data_size,
1999                               uint8_t *buf, int buf_size)
2000 {
2001     MJpegDecodeContext *s = avctx->priv_data;
2002     uint8_t *buf_end, *buf_ptr;
2003     int start_code;
2004     AVFrame *picture = data;
2005
2006     buf_ptr = buf;
2007     buf_end = buf + buf_size;
2008     while (buf_ptr < buf_end) {
2009         /* find start next marker */
2010         start_code = find_marker(&buf_ptr, buf_end);
2011         {
2012             /* EOF */
2013             if (start_code < 0) {
2014                 goto the_end;
2015             } else {
2016                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2017
2018                 if ((buf_end - buf_ptr) > s->buffer_size)
2019                 {
2020                     av_free(s->buffer);
2021                     s->buffer_size = buf_end-buf_ptr;
2022                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2023                     dprintf("buffer too small, expanding to %d bytes\n",
2024                         s->buffer_size);
2025                 }
2026
2027                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2028                 if (start_code == SOS && !s->ls)
2029                 {
2030                     uint8_t *src = buf_ptr;
2031                     uint8_t *dst = s->buffer;
2032
2033                     while (src<buf_end)
2034                     {
2035                         uint8_t x = *(src++);
2036
2037                         *(dst++) = x;
2038                         if (x == 0xff)
2039                         {
2040                             while(src<buf_end && x == 0xff)
2041                                 x = *(src++);
2042
2043                             if (x >= 0xd0 && x <= 0xd7)
2044                                 *(dst++) = x;
2045                             else if (x)
2046                                 break;
2047                         }
2048                     }
2049                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2050
2051                     dprintf("escaping removed %d bytes\n",
2052                         (buf_end - buf_ptr) - (dst - s->buffer));
2053                 }
2054                 else if(start_code == SOS && s->ls){
2055                     uint8_t *src = buf_ptr;
2056                     uint8_t *dst = s->buffer;
2057                     int bit_count = 0;
2058                     int t = 0, b = 0;
2059                     PutBitContext pb;
2060
2061                     s->cur_scan++;
2062
2063                     /* find marker */
2064                     while (src + t < buf_end){
2065                         uint8_t x = src[t++];
2066                         if (x == 0xff){
2067                             while((src + t < buf_end) && x == 0xff)
2068                                 x = src[t++];
2069                             if (x & 0x80) {
2070                                 t -= 2;
2071                                 break;
2072                             }
2073                         }
2074                     }
2075                     bit_count = t * 8;
2076
2077                     init_put_bits(&pb, dst, t);
2078
2079                     /* unescape bitstream */
2080                     while(b < t){
2081                         uint8_t x = src[b++];
2082                         put_bits(&pb, 8, x);
2083                         if(x == 0xFF){
2084                             x = src[b++];
2085                             put_bits(&pb, 7, x);
2086                             bit_count--;
2087                         }
2088                     }
2089                     flush_put_bits(&pb);
2090
2091                     init_get_bits(&s->gb, dst, bit_count);
2092                 }
2093                 else
2094                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2095
2096                 s->start_code = start_code;
2097                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2098                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2099                 }
2100
2101                 /* process markers */
2102                 if (start_code >= 0xd0 && start_code <= 0xd7) {
2103                     dprintf("restart marker: %d\n", start_code&0x0f);
2104                     /* APP fields */
2105                 } else if (start_code >= APP0 && start_code <= APP15) {
2106                     mjpeg_decode_app(s);
2107                     /* Comment */
2108                 } else if (start_code == COM){
2109                     mjpeg_decode_com(s);
2110                 }
2111
2112                 switch(start_code) {
2113                 case SOI:
2114                     s->restart_interval = 0;
2115
2116                     s->restart_count = 0;
2117                     /* nothing to do on SOI */
2118                     break;
2119                 case DQT:
2120                     mjpeg_decode_dqt(s);
2121                     break;
2122                 case DHT:
2123                     if(mjpeg_decode_dht(s) < 0){
2124                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2125                         return -1;
2126                     }
2127                     break;
2128                 case SOF0:
2129                     s->lossless=0;
2130                     s->progressive=0;
2131                     if (mjpeg_decode_sof(s) < 0)
2132                         return -1;
2133                     break;
2134                 case SOF2:
2135                     s->lossless=0;
2136                     s->progressive=1;
2137                     if (mjpeg_decode_sof(s) < 0)
2138                         return -1;
2139                     break;
2140                 case SOF3:
2141                     s->lossless=1;
2142                     s->progressive=0;
2143                     if (mjpeg_decode_sof(s) < 0)
2144                         return -1;
2145                     break;
2146                 case SOF48:
2147                     s->lossless=1;
2148                     s->ls=1;
2149                     s->progressive=0;
2150                     if (mjpeg_decode_sof(s) < 0)
2151                         return -1;
2152                     break;
2153                 case LSE:
2154                     if (decode_lse(s) < 0)
2155                         return -1;
2156                     break;
2157                 case EOI:
2158                     s->cur_scan = 0;
2159                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2160                         break;
2161 eoi_parser:
2162                     {
2163                         if (s->interlaced) {
2164                             s->bottom_field ^= 1;
2165                             /* if not bottom field, do not output image yet */
2166                             if (s->bottom_field)
2167                                 goto not_the_end;
2168                         }
2169                         *picture = s->picture;
2170                         *data_size = sizeof(AVFrame);
2171
2172                         if(!s->lossless){
2173                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2174                             picture->qstride= 0;
2175                             picture->qscale_table= s->qscale_table;
2176                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2177                             if(avctx->debug & FF_DEBUG_QP)
2178                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2179                             picture->quality*= FF_QP2LAMBDA;
2180                         }
2181
2182                         goto the_end;
2183                     }
2184                     break;
2185                 case SOS:
2186                     mjpeg_decode_sos(s);
2187                     /* buggy avid puts EOI every 10-20th frame */
2188                     /* if restart period is over process EOI */
2189                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2190                         goto eoi_parser;
2191                     break;
2192                 case DRI:
2193                     mjpeg_decode_dri(s);
2194                     break;
2195                 case SOF1:
2196                 case SOF5:
2197                 case SOF6:
2198                 case SOF7:
2199                 case SOF9:
2200                 case SOF10:
2201                 case SOF11:
2202                 case SOF13:
2203                 case SOF14:
2204                 case SOF15:
2205                 case JPG:
2206                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2207                     break;
2208 //                default:
2209 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2210 //                    break;
2211                 }
2212
2213 not_the_end:
2214                 /* eof process start code */
2215                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2216                 dprintf("marker parser used %d bytes (%d bits)\n",
2217                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2218             }
2219         }
2220     }
2221 the_end:
2222     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2223 //    return buf_end - buf_ptr;
2224     return buf_ptr - buf;
2225 }
2226
2227 static int mjpegb_decode_frame(AVCodecContext *avctx,
2228                               void *data, int *data_size,
2229                               uint8_t *buf, int buf_size)
2230 {
2231     MJpegDecodeContext *s = avctx->priv_data;
2232     uint8_t *buf_end, *buf_ptr;
2233     AVFrame *picture = data;
2234     GetBitContext hgb; /* for the header */
2235     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2236     uint32_t field_size, sod_offs;
2237
2238     buf_ptr = buf;
2239     buf_end = buf + buf_size;
2240
2241 read_header:
2242     /* reset on every SOI */
2243     s->restart_interval = 0;
2244     s->restart_count = 0;
2245     s->mjpb_skiptosod = 0;
2246
2247     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2248
2249     skip_bits(&hgb, 32); /* reserved zeros */
2250
2251     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2252     {
2253         dprintf("not mjpeg-b (bad fourcc)\n");
2254         return 0;
2255     }
2256
2257     field_size = get_bits_long(&hgb, 32); /* field size */
2258     dprintf("field size: 0x%x\n", field_size);
2259     skip_bits(&hgb, 32); /* padded field size */
2260     second_field_offs = get_bits_long(&hgb, 32);
2261     dprintf("second field offs: 0x%x\n", second_field_offs);
2262     if (second_field_offs)
2263         s->interlaced = 1;
2264
2265     dqt_offs = get_bits_long(&hgb, 32);
2266     dprintf("dqt offs: 0x%x\n", dqt_offs);
2267     if (dqt_offs)
2268     {
2269         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2270         s->start_code = DQT;
2271         mjpeg_decode_dqt(s);
2272     }
2273
2274     dht_offs = get_bits_long(&hgb, 32);
2275     dprintf("dht offs: 0x%x\n", dht_offs);
2276     if (dht_offs)
2277     {
2278         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2279         s->start_code = DHT;
2280         mjpeg_decode_dht(s);
2281     }
2282
2283     sof_offs = get_bits_long(&hgb, 32);
2284     dprintf("sof offs: 0x%x\n", sof_offs);
2285     if (sof_offs)
2286     {
2287         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2288         s->start_code = SOF0;
2289         if (mjpeg_decode_sof(s) < 0)
2290             return -1;
2291     }
2292
2293     sos_offs = get_bits_long(&hgb, 32);
2294     dprintf("sos offs: 0x%x\n", sos_offs);
2295     sod_offs = get_bits_long(&hgb, 32);
2296     dprintf("sod offs: 0x%x\n", sod_offs);
2297     if (sos_offs)
2298     {
2299 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2300         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2301         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2302         s->start_code = SOS;
2303         mjpeg_decode_sos(s);
2304     }
2305
2306     if (s->interlaced) {
2307         s->bottom_field ^= 1;
2308         /* if not bottom field, do not output image yet */
2309         if (s->bottom_field && second_field_offs)
2310         {
2311             buf_ptr = buf + second_field_offs;
2312             second_field_offs = 0;
2313             goto read_header;
2314             }
2315     }
2316
2317     //XXX FIXME factorize, this looks very similar to the EOI code
2318
2319     *picture= s->picture;
2320     *data_size = sizeof(AVFrame);
2321
2322     if(!s->lossless){
2323         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2324         picture->qstride= 0;
2325         picture->qscale_table= s->qscale_table;
2326         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2327         if(avctx->debug & FF_DEBUG_QP)
2328             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2329         picture->quality*= FF_QP2LAMBDA;
2330     }
2331
2332     return buf_ptr - buf;
2333 }
2334
2335 #include "sp5x.h"
2336
2337 static int sp5x_decode_frame(AVCodecContext *avctx,
2338                               void *data, int *data_size,
2339                               uint8_t *buf, int buf_size)
2340 {
2341 #if 0
2342     MJpegDecodeContext *s = avctx->priv_data;
2343 #endif
2344     const int qscale = 5;
2345     uint8_t *buf_ptr, *buf_end, *recoded;
2346     int i = 0, j = 0;
2347
2348     if (!avctx->width || !avctx->height)
2349         return -1;
2350
2351     buf_ptr = buf;
2352     buf_end = buf + buf_size;
2353
2354 #if 1
2355     recoded = av_mallocz(buf_size + 1024);
2356     if (!recoded)
2357         return -1;
2358
2359     /* SOI */
2360     recoded[j++] = 0xFF;
2361     recoded[j++] = 0xD8;
2362
2363     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2364     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2365     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2366     j += sizeof(sp5x_data_dqt);
2367
2368     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2369     j += sizeof(sp5x_data_dht);
2370
2371     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2372     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2373     recoded[j+6] = avctx->coded_height & 0xFF;
2374     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2375     recoded[j+8] = avctx->coded_width & 0xFF;
2376     j += sizeof(sp5x_data_sof);
2377
2378     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2379     j += sizeof(sp5x_data_sos);
2380
2381     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2382     {
2383         recoded[j++] = buf[i];
2384         if (buf[i] == 0xff)
2385             recoded[j++] = 0;
2386     }
2387
2388     /* EOI */
2389     recoded[j++] = 0xFF;
2390     recoded[j++] = 0xD9;
2391
2392     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2393
2394     av_free(recoded);
2395
2396 #else
2397     /* SOF */
2398     s->bits = 8;
2399     s->width  = avctx->coded_width;
2400     s->height = avctx->coded_height;
2401     s->nb_components = 3;
2402     s->component_id[0] = 0;
2403     s->h_count[0] = 2;
2404     s->v_count[0] = 2;
2405     s->quant_index[0] = 0;
2406     s->component_id[1] = 1;
2407     s->h_count[1] = 1;
2408     s->v_count[1] = 1;
2409     s->quant_index[1] = 1;
2410     s->component_id[2] = 2;
2411     s->h_count[2] = 1;
2412     s->v_count[2] = 1;
2413     s->quant_index[2] = 1;
2414     s->h_max = 2;
2415     s->v_max = 2;
2416
2417     s->qscale_table = av_mallocz((s->width+15)/16);
2418     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2419     s->interlaced = 0;
2420
2421     s->picture.reference = 0;
2422     if (avctx->get_buffer(avctx, &s->picture) < 0)
2423     {
2424         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2425         return -1;
2426     }
2427
2428     s->picture.pict_type = I_TYPE;
2429     s->picture.key_frame = 1;
2430
2431     for (i = 0; i < 3; i++)
2432         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2433
2434     /* DQT */
2435     for (i = 0; i < 64; i++)
2436     {
2437         j = s->scantable.permutated[i];
2438         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2439     }
2440     s->qscale[0] = FFMAX(
2441         s->quant_matrixes[0][s->scantable.permutated[1]],
2442         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2443
2444     for (i = 0; i < 64; i++)
2445     {
2446         j = s->scantable.permutated[i];
2447         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2448     }
2449     s->qscale[1] = FFMAX(
2450         s->quant_matrixes[1][s->scantable.permutated[1]],
2451         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2452
2453     /* DHT */
2454
2455     /* SOS */
2456     s->comp_index[0] = 0;
2457     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2458     s->h_scount[0] = s->h_count[0];
2459     s->v_scount[0] = s->v_count[0];
2460     s->dc_index[0] = 0;
2461     s->ac_index[0] = 0;
2462
2463     s->comp_index[1] = 1;
2464     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2465     s->h_scount[1] = s->h_count[1];
2466     s->v_scount[1] = s->v_count[1];
2467     s->dc_index[1] = 1;
2468     s->ac_index[1] = 1;
2469
2470     s->comp_index[2] = 2;
2471     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2472     s->h_scount[2] = s->h_count[2];
2473     s->v_scount[2] = s->v_count[2];
2474     s->dc_index[2] = 1;
2475     s->ac_index[2] = 1;
2476
2477     for (i = 0; i < 3; i++)
2478         s->last_dc[i] = 1024;
2479
2480     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2481     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2482
2483     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2484
2485     return mjpeg_decode_scan(s);
2486 #endif
2487
2488     return i;
2489 }
2490
2491 static int mjpeg_decode_end(AVCodecContext *avctx)
2492 {
2493     MJpegDecodeContext *s = avctx->priv_data;
2494     int i, j;
2495
2496     av_free(s->buffer);
2497     av_free(s->qscale_table);
2498
2499     for(i=0;i<2;i++) {
2500         for(j=0;j<4;j++)
2501             free_vlc(&s->vlcs[i][j]);
2502     }
2503     return 0;
2504 }
2505
2506 AVCodec mjpeg_decoder = {
2507     "mjpeg",
2508     CODEC_TYPE_VIDEO,
2509     CODEC_ID_MJPEG,
2510     sizeof(MJpegDecodeContext),
2511     mjpeg_decode_init,
2512     NULL,
2513     mjpeg_decode_end,
2514     mjpeg_decode_frame,
2515     CODEC_CAP_DR1,
2516     NULL
2517 };
2518
2519 AVCodec mjpegb_decoder = {
2520     "mjpegb",
2521     CODEC_TYPE_VIDEO,
2522     CODEC_ID_MJPEGB,
2523     sizeof(MJpegDecodeContext),
2524     mjpeg_decode_init,
2525     NULL,
2526     mjpeg_decode_end,
2527     mjpegb_decode_frame,
2528     CODEC_CAP_DR1,
2529     NULL
2530 };
2531
2532 AVCodec sp5x_decoder = {
2533     "sp5x",
2534     CODEC_TYPE_VIDEO,
2535     CODEC_ID_SP5X,
2536     sizeof(MJpegDecodeContext),
2537     mjpeg_decode_init,
2538     NULL,
2539     mjpeg_decode_end,
2540     sp5x_decode_frame,
2541     CODEC_CAP_DR1,
2542     NULL
2543 };
2544
2545 #ifdef CONFIG_ENCODERS
2546 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2547     "ljpeg",
2548     CODEC_TYPE_VIDEO,
2549     CODEC_ID_LJPEG,
2550     sizeof(MpegEncContext),
2551     MPV_encode_init,
2552     encode_picture_lossless,
2553     MPV_encode_end,
2554 };
2555 #endif
2556
2557 AVCodecParser mjpeg_parser = {
2558     { CODEC_ID_MJPEG },
2559     sizeof(ParseContext),
2560     NULL,
2561     jpeg_parse,
2562     ff_parse_close,
2563 };
2564