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