2fc870a61a69458c5ed1a230cafa69fbb6e0bc00
[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 - 4 + 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<6;i++) {
670         encode_block(s, block[i], i);
671     }
672 }
673
674 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
675     MpegEncContext * const s = avctx->priv_data;
676     MJpegContext * const m = s->mjpeg_ctx;
677     AVFrame *pict = data;
678     const int width= s->width;
679     const int height= s->height;
680     AVFrame * const p= (AVFrame*)&s->current_picture;
681     const int predictor= avctx->prediction_method+1;
682
683     init_put_bits(&s->pb, buf, buf_size);
684
685     *p = *pict;
686     p->pict_type= FF_I_TYPE;
687     p->key_frame= 1;
688
689     mjpeg_picture_header(s);
690
691     s->header_bits= put_bits_count(&s->pb);
692
693     if(avctx->pix_fmt == PIX_FMT_RGBA32){
694         int x, y, i;
695         const int linesize= p->linesize[0];
696         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
697         int left[3], top[3], topleft[3];
698
699         for(i=0; i<3; i++){
700             buffer[0][i]= 1 << (9 - 1);
701         }
702
703         for(y = 0; y < height; y++) {
704             const int modified_predictor= y ? predictor : 1;
705             uint8_t *ptr = p->data[0] + (linesize * y);
706
707             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
708                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
709                 return -1;
710             }
711
712             for(i=0; i<3; i++){
713                 top[i]= left[i]= topleft[i]= buffer[0][i];
714             }
715             for(x = 0; x < width; x++) {
716                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
717                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
718                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
719
720                 for(i=0;i<3;i++) {
721                     int pred, diff;
722
723                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
724
725                     topleft[i]= top[i];
726                     top[i]= buffer[x+1][i];
727
728                     left[i]= buffer[x][i];
729
730                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
731
732                     if(i==0)
733                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
734                     else
735                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
736                 }
737             }
738         }
739     }else{
740         int mb_x, mb_y, i;
741         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
742         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
743
744         for(mb_y = 0; mb_y < mb_height; mb_y++) {
745             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]){
746                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
747                 return -1;
748             }
749             for(mb_x = 0; mb_x < mb_width; mb_x++) {
750                 if(mb_x==0 || mb_y==0){
751                     for(i=0;i<3;i++) {
752                         uint8_t *ptr;
753                         int x, y, h, v, linesize;
754                         h = s->mjpeg_hsample[i];
755                         v = s->mjpeg_vsample[i];
756                         linesize= p->linesize[i];
757
758                         for(y=0; y<v; y++){
759                             for(x=0; x<h; x++){
760                                 int pred;
761
762                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
763                                 if(y==0 && mb_y==0){
764                                     if(x==0 && mb_x==0){
765                                         pred= 128;
766                                     }else{
767                                         pred= ptr[-1];
768                                     }
769                                 }else{
770                                     if(x==0 && mb_x==0){
771                                         pred= ptr[-linesize];
772                                     }else{
773                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
774                                     }
775                                 }
776
777                                 if(i==0)
778                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
779                                 else
780                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
781                             }
782                         }
783                     }
784                 }else{
785                     for(i=0;i<3;i++) {
786                         uint8_t *ptr;
787                         int x, y, h, v, linesize;
788                         h = s->mjpeg_hsample[i];
789                         v = s->mjpeg_vsample[i];
790                         linesize= p->linesize[i];
791
792                         for(y=0; y<v; y++){
793                             for(x=0; x<h; x++){
794                                 int pred;
795
796                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
797 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
798                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
799
800                                 if(i==0)
801                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
802                                 else
803                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
804                             }
805                         }
806                     }
807                 }
808             }
809         }
810     }
811
812     emms_c();
813
814     mjpeg_picture_trailer(s);
815     s->picture_number++;
816
817     flush_put_bits(&s->pb);
818     return pbBufPtr(&s->pb) - s->pb.buf;
819 //    return (put_bits_count(&f->pb)+7)/8;
820 }
821
822 #endif //CONFIG_ENCODERS
823
824 /******************************************/
825 /* decoding */
826
827 #define MAX_COMPONENTS 4
828
829 typedef struct MJpegDecodeContext {
830     AVCodecContext *avctx;
831     GetBitContext gb;
832     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
833
834     int start_code; /* current start code */
835     int buffer_size;
836     uint8_t *buffer;
837
838     int16_t quant_matrixes[4][64];
839     VLC vlcs[2][4];
840     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
841
842     int org_height;  /* size given at codec init */
843     int first_picture;    /* true if decoding first picture */
844     int interlaced;     /* true if interlaced */
845     int bottom_field;   /* true if bottom field */
846     int lossless;
847     int ls;
848     int rgb;
849     int rct;            /* standard rct */
850     int pegasus_rct;    /* pegasus reversible colorspace transform */
851     int bits;           /* bits per component */
852
853     int maxval;
854     int near;         ///< near lossless bound (si 0 for lossless)
855     int t1,t2,t3;
856     int reset;        ///< context halfing intervall ?rename
857
858     int width, height;
859     int mb_width, mb_height;
860     int nb_components;
861     int component_id[MAX_COMPONENTS];
862     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
863     int v_count[MAX_COMPONENTS];
864     int comp_index[MAX_COMPONENTS];
865     int dc_index[MAX_COMPONENTS];
866     int ac_index[MAX_COMPONENTS];
867     int nb_blocks[MAX_COMPONENTS];
868     int h_scount[MAX_COMPONENTS];
869     int v_scount[MAX_COMPONENTS];
870     int h_max, v_max; /* maximum h and v counts */
871     int quant_index[4];   /* quant table index for each component */
872     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
873     AVFrame picture; /* picture structure */
874     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
875     int8_t *qscale_table;
876     DECLARE_ALIGNED_8(DCTELEM, block[64]);
877     ScanTable scantable;
878     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
879
880     int restart_interval;
881     int restart_count;
882
883     int buggy_avid;
884     int cs_itu601;
885     int interlace_polarity;
886
887     int mjpb_skiptosod;
888
889     int cur_scan; /* current scan, used by JPEG-LS */
890 } MJpegDecodeContext;
891
892 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant
893
894 static int mjpeg_decode_dht(MJpegDecodeContext *s);
895
896 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
897                       int nb_codes, int use_static, int is_ac)
898 {
899     uint8_t huff_size[256+16];
900     uint16_t huff_code[256+16];
901
902     assert(nb_codes <= 256);
903
904     memset(huff_size, 0, sizeof(huff_size));
905     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
906
907     if(is_ac){
908         memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
909         memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
910         memset(huff_size, 0, sizeof(uint8_t)*16);
911         memset(huff_code, 0, sizeof(uint16_t)*16);
912         nb_codes += 16;
913     }
914
915     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
916 }
917
918 static int mjpeg_decode_init(AVCodecContext *avctx)
919 {
920     MJpegDecodeContext *s = avctx->priv_data;
921     MpegEncContext s2;
922     memset(s, 0, sizeof(MJpegDecodeContext));
923
924     s->avctx = avctx;
925
926     /* ugly way to get the idct & scantable FIXME */
927     memset(&s2, 0, sizeof(MpegEncContext));
928     s2.avctx= avctx;
929 //    s2->out_format = FMT_MJPEG;
930     dsputil_init(&s2.dsp, avctx);
931     DCT_common_init(&s2);
932
933     s->scantable= s2.intra_scantable;
934     s->idct_put= s2.dsp.idct_put;
935
936     s->mpeg_enc_ctx_allocated = 0;
937     s->buffer_size = 0;
938     s->buffer = NULL;
939     s->start_code = -1;
940     s->first_picture = 1;
941     s->org_height = avctx->coded_height;
942
943     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
944     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
945     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
946     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
947
948     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
949     {
950         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
951         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
952         mjpeg_decode_dht(s);
953         /* should check for error - but dunno */
954     }
955
956     return 0;
957 }
958
959
960 /**
961  * finds the end of the current frame in the bitstream.
962  * @return the position of the first byte of the next frame, or -1
963  */
964 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
965     int vop_found, i;
966     uint16_t state;
967
968     vop_found= pc->frame_start_found;
969     state= pc->state;
970
971     i=0;
972     if(!vop_found){
973         for(i=0; i<buf_size; i++){
974             state= (state<<8) | buf[i];
975             if(state == 0xFFD8){
976                 i++;
977                 vop_found=1;
978                 break;
979             }
980         }
981     }
982
983     if(vop_found){
984         /* EOF considered as end of frame */
985         if (buf_size == 0)
986             return 0;
987         for(; i<buf_size; i++){
988             state= (state<<8) | buf[i];
989             if(state == 0xFFD8){
990                 pc->frame_start_found=0;
991                 pc->state=0;
992                 return i-1;
993             }
994         }
995     }
996     pc->frame_start_found= vop_found;
997     pc->state= state;
998     return END_NOT_FOUND;
999 }
1000
1001 static int jpeg_parse(AVCodecParserContext *s,
1002                            AVCodecContext *avctx,
1003                            uint8_t **poutbuf, int *poutbuf_size,
1004                            const uint8_t *buf, int buf_size)
1005 {
1006     ParseContext *pc = s->priv_data;
1007     int next;
1008
1009     next= find_frame_end(pc, buf, buf_size);
1010
1011     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1012         *poutbuf = NULL;
1013         *poutbuf_size = 0;
1014         return buf_size;
1015     }
1016
1017     *poutbuf = (uint8_t *)buf;
1018     *poutbuf_size = buf_size;
1019     return next;
1020 }
1021
1022 /* quantize tables */
1023 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1024 {
1025     int len, index, i, j;
1026
1027     len = get_bits(&s->gb, 16) - 2;
1028
1029     while (len >= 65) {
1030         /* only 8 bit precision handled */
1031         if (get_bits(&s->gb, 4) != 0)
1032         {
1033             dprintf("dqt: 16bit precision\n");
1034             return -1;
1035         }
1036         index = get_bits(&s->gb, 4);
1037         if (index >= 4)
1038             return -1;
1039         dprintf("index=%d\n", index);
1040         /* read quant table */
1041         for(i=0;i<64;i++) {
1042             j = s->scantable.permutated[i];
1043             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1044         }
1045
1046         //XXX FIXME finetune, and perhaps add dc too
1047         s->qscale[index]= FFMAX(
1048             s->quant_matrixes[index][s->scantable.permutated[1]],
1049             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1050         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1051         len -= 65;
1052     }
1053
1054     return 0;
1055 }
1056
1057 /* decode huffman tables and build VLC decoders */
1058 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1059 {
1060     int len, index, i, class, n, v, code_max;
1061     uint8_t bits_table[17];
1062     uint8_t val_table[256];
1063
1064     len = get_bits(&s->gb, 16) - 2;
1065
1066     while (len > 0) {
1067         if (len < 17)
1068             return -1;
1069         class = get_bits(&s->gb, 4);
1070         if (class >= 2)
1071             return -1;
1072         index = get_bits(&s->gb, 4);
1073         if (index >= 4)
1074             return -1;
1075         n = 0;
1076         for(i=1;i<=16;i++) {
1077             bits_table[i] = get_bits(&s->gb, 8);
1078             n += bits_table[i];
1079         }
1080         len -= 17;
1081         if (len < n || n > 256)
1082             return -1;
1083
1084         code_max = 0;
1085         for(i=0;i<n;i++) {
1086             v = get_bits(&s->gb, 8);
1087             if (v > code_max)
1088                 code_max = v;
1089             val_table[i] = v;
1090         }
1091         len -= n;
1092
1093         /* build VLC and flush previous vlc if present */
1094         free_vlc(&s->vlcs[class][index]);
1095         dprintf("class=%d index=%d nb_codes=%d\n",
1096                class, index, code_max + 1);
1097         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1098             return -1;
1099         }
1100     }
1101     return 0;
1102 }
1103
1104 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1105 {
1106     int len, nb_components, i, width, height;
1107
1108     /* XXX: verify len field validity */
1109     len = get_bits(&s->gb, 16);
1110     s->bits= get_bits(&s->gb, 8);
1111
1112     if(s->pegasus_rct) s->bits=9;
1113     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1114
1115     if (s->bits != 8 && !s->lossless){
1116         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1117         return -1;
1118     }
1119     if (s->bits > 8 && s->ls){
1120         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1121         return -1;
1122     }
1123
1124     height = get_bits(&s->gb, 16);
1125     width = get_bits(&s->gb, 16);
1126
1127     dprintf("sof0: picture: %dx%d\n", width, height);
1128     if(avcodec_check_dimensions(s->avctx, width, height))
1129         return -1;
1130
1131     nb_components = get_bits(&s->gb, 8);
1132     if (nb_components <= 0 ||
1133         nb_components > MAX_COMPONENTS)
1134         return -1;
1135     s->nb_components = nb_components;
1136     s->h_max = 1;
1137     s->v_max = 1;
1138     for(i=0;i<nb_components;i++) {
1139         /* component id */
1140         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1141         s->h_count[i] = get_bits(&s->gb, 4);
1142         s->v_count[i] = get_bits(&s->gb, 4);
1143         /* compute hmax and vmax (only used in interleaved case) */
1144         if (s->h_count[i] > s->h_max)
1145             s->h_max = s->h_count[i];
1146         if (s->v_count[i] > s->v_max)
1147             s->v_max = s->v_count[i];
1148         s->quant_index[i] = get_bits(&s->gb, 8);
1149         if (s->quant_index[i] >= 4)
1150             return -1;
1151         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1152             s->v_count[i], s->component_id[i], s->quant_index[i]);
1153     }
1154
1155     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1156         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1157         return -1;
1158     }
1159
1160     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1161
1162     /* if different size, realloc/alloc picture */
1163     /* XXX: also check h_count and v_count */
1164     if (width != s->width || height != s->height) {
1165         av_freep(&s->qscale_table);
1166
1167         s->width = width;
1168         s->height = height;
1169
1170         /* test interlaced mode */
1171         if (s->first_picture &&
1172             s->org_height != 0 &&
1173             s->height < ((s->org_height * 3) / 4)) {
1174             s->interlaced = 1;
1175 //            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1176             s->bottom_field = 0;
1177             height *= 2;
1178         }
1179
1180         avcodec_set_dimensions(s->avctx, width, height);
1181
1182         s->qscale_table= av_mallocz((s->width+15)/16);
1183
1184         s->first_picture = 0;
1185     }
1186
1187     if(s->interlaced && s->bottom_field)
1188         return 0;
1189
1190     /* XXX: not complete test ! */
1191     switch((s->h_count[0] << 4) | s->v_count[0]) {
1192     case 0x11:
1193         if(s->rgb){
1194             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1195         }else if(s->nb_components==3)
1196             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1197         else
1198             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1199         break;
1200     case 0x21:
1201         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1202         break;
1203     default:
1204     case 0x22:
1205         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1206         break;
1207     }
1208     if(s->ls){
1209         if(s->nb_components > 1)
1210             s->avctx->pix_fmt = PIX_FMT_RGB24;
1211         else
1212             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1213     }
1214
1215     if(s->picture.data[0])
1216         s->avctx->release_buffer(s->avctx, &s->picture);
1217
1218     s->picture.reference= 0;
1219     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1220         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1221         return -1;
1222     }
1223     s->picture.pict_type= I_TYPE;
1224     s->picture.key_frame= 1;
1225
1226     for(i=0; i<3; i++){
1227         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1228     }
1229
1230 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1231
1232     if (len != (8+(3*nb_components)))
1233     {
1234         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1235     }
1236
1237     return 0;
1238 }
1239
1240 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1241 {
1242     int code;
1243     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1244     if (code < 0)
1245     {
1246         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1247                 &s->vlcs[0][dc_index]);
1248         return 0xffff;
1249     }
1250
1251     if(code)
1252         return get_xbits(&s->gb, code);
1253     else
1254         return 0;
1255 }
1256
1257 /* decode block and dequantize */
1258 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1259                         int component, int dc_index, int ac_index, int16_t *quant_matrix)
1260 {
1261     int code, i, j, level, val;
1262     VLC *ac_vlc;
1263
1264     /* DC coef */
1265     val = mjpeg_decode_dc(s, dc_index);
1266     if (val == 0xffff) {
1267         dprintf("error dc\n");
1268         return -1;
1269     }
1270     val = val * quant_matrix[0] + s->last_dc[component];
1271     s->last_dc[component] = val;
1272     block[0] = val;
1273     /* AC coefs */
1274     ac_vlc = &s->vlcs[1][ac_index];
1275     i = 0;
1276     {OPEN_READER(re, &s->gb)
1277     for(;;) {
1278         UPDATE_CACHE(re, &s->gb);
1279         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1280
1281         /* EOB */
1282         if (code == 0x10)
1283             break;
1284         if (code == 0x100) {
1285             i += 16;
1286         } else {
1287             i += ((unsigned)code) >> 4;
1288             code &= 0xf;
1289             if(code > MIN_CACHE_BITS - 16){
1290                 UPDATE_CACHE(re, &s->gb)
1291             }
1292             {
1293                 int cache=GET_CACHE(re,gb);
1294                 int sign=(~cache)>>31;
1295                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1296             }
1297
1298             LAST_SKIP_BITS(re, &s->gb, code)
1299
1300             if (i >= 63) {
1301                 if(i == 63){
1302                     j = s->scantable.permutated[63];
1303                     block[j] = level * quant_matrix[j];
1304                     break;
1305                 }
1306                 dprintf("error count: %d\n", i);
1307                 return -1;
1308             }
1309             j = s->scantable.permutated[i];
1310             block[j] = level * quant_matrix[j];
1311         }
1312     }
1313     CLOSE_READER(re, &s->gb)}
1314
1315     return 0;
1316 }
1317
1318 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1319     int i, mb_x, mb_y;
1320     uint16_t buffer[32768][4];
1321     int left[3], top[3], topleft[3];
1322     const int linesize= s->linesize[0];
1323     const int mask= (1<<s->bits)-1;
1324
1325     if((unsigned)s->mb_width > 32768) //dynamic alloc
1326         return -1;
1327
1328     for(i=0; i<3; i++){
1329         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1330     }
1331     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1332         const int modified_predictor= mb_y ? predictor : 1;
1333         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1334
1335         if (s->interlaced && s->bottom_field)
1336             ptr += linesize >> 1;
1337
1338         for(i=0; i<3; i++){
1339             top[i]= left[i]= topleft[i]= buffer[0][i];
1340         }
1341         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1342             if (s->restart_interval && !s->restart_count)
1343                 s->restart_count = s->restart_interval;
1344
1345             for(i=0;i<3;i++) {
1346                 int pred;
1347
1348                 topleft[i]= top[i];
1349                 top[i]= buffer[mb_x][i];
1350
1351                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1352
1353                 left[i]=
1354                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1355             }
1356
1357             if (s->restart_interval && !--s->restart_count) {
1358                 align_get_bits(&s->gb);
1359                 skip_bits(&s->gb, 16); /* skip RSTn */
1360             }
1361         }
1362
1363         if(s->rct){
1364             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1365                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1366                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1367                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1368             }
1369         }else if(s->pegasus_rct){
1370             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1371                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1372                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1373                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1374             }
1375         }else{
1376             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1377                 ptr[4*mb_x+0] = buffer[mb_x][0];
1378                 ptr[4*mb_x+1] = buffer[mb_x][1];
1379                 ptr[4*mb_x+2] = buffer[mb_x][2];
1380             }
1381         }
1382     }
1383     return 0;
1384 }
1385
1386 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1387     int i, mb_x, mb_y;
1388     const int nb_components=3;
1389
1390     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1391         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1392             if (s->restart_interval && !s->restart_count)
1393                 s->restart_count = s->restart_interval;
1394
1395             if(mb_x==0 || mb_y==0 || s->interlaced){
1396                 for(i=0;i<nb_components;i++) {
1397                     uint8_t *ptr;
1398                     int n, h, v, x, y, c, j, linesize;
1399                     n = s->nb_blocks[i];
1400                     c = s->comp_index[i];
1401                     h = s->h_scount[i];
1402                     v = s->v_scount[i];
1403                     x = 0;
1404                     y = 0;
1405                     linesize= s->linesize[c];
1406
1407                     for(j=0; j<n; j++) {
1408                         int pred;
1409
1410                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1411                         if(y==0 && mb_y==0){
1412                             if(x==0 && mb_x==0){
1413                                 pred= 128 << point_transform;
1414                             }else{
1415                                 pred= ptr[-1];
1416                             }
1417                         }else{
1418                             if(x==0 && mb_x==0){
1419                                 pred= ptr[-linesize];
1420                             }else{
1421                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1422                             }
1423                         }
1424
1425                         if (s->interlaced && s->bottom_field)
1426                             ptr += linesize >> 1;
1427                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1428
1429                         if (++x == h) {
1430                             x = 0;
1431                             y++;
1432                         }
1433                     }
1434                 }
1435             }else{
1436                 for(i=0;i<nb_components;i++) {
1437                     uint8_t *ptr;
1438                     int n, h, v, x, y, c, j, linesize;
1439                     n = s->nb_blocks[i];
1440                     c = s->comp_index[i];
1441                     h = s->h_scount[i];
1442                     v = s->v_scount[i];
1443                     x = 0;
1444                     y = 0;
1445                     linesize= s->linesize[c];
1446
1447                     for(j=0; j<n; j++) {
1448                         int pred;
1449
1450                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1451                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1452                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1453                         if (++x == h) {
1454                             x = 0;
1455                             y++;
1456                         }
1457                     }
1458                 }
1459             }
1460             if (s->restart_interval && !--s->restart_count) {
1461                 align_get_bits(&s->gb);
1462                 skip_bits(&s->gb, 16); /* skip RSTn */
1463             }
1464         }
1465     }
1466     return 0;
1467 }
1468
1469 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1470     int i, mb_x, mb_y;
1471     const int nb_components=3;
1472
1473     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1474         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1475             if (s->restart_interval && !s->restart_count)
1476                 s->restart_count = s->restart_interval;
1477
1478             for(i=0;i<nb_components;i++) {
1479                 uint8_t *ptr;
1480                 int n, h, v, x, y, c, j;
1481                 n = s->nb_blocks[i];
1482                 c = s->comp_index[i];
1483                 h = s->h_scount[i];
1484                 v = s->v_scount[i];
1485                 x = 0;
1486                 y = 0;
1487                 for(j=0;j<n;j++) {
1488                     memset(s->block, 0, sizeof(s->block));
1489                     if (decode_block(s, s->block, i,
1490                                      s->dc_index[i], s->ac_index[i],
1491                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1492                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1493                         return -1;
1494                     }
1495 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1496                     ptr = s->picture.data[c] +
1497                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1498                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1499                     if (s->interlaced && s->bottom_field)
1500                         ptr += s->linesize[c] >> 1;
1501 //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);
1502                     s->idct_put(ptr, s->linesize[c], s->block);
1503                     if (++x == h) {
1504                         x = 0;
1505                         y++;
1506                     }
1507                 }
1508             }
1509             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1510             if (s->restart_interval && (s->restart_interval < 1350) &&
1511                 !--s->restart_count) {
1512                 align_get_bits(&s->gb);
1513                 skip_bits(&s->gb, 16); /* skip RSTn */
1514                 for (i=0; i<nb_components; i++) /* reset dc */
1515                     s->last_dc[i] = 1024;
1516             }
1517         }
1518     }
1519     return 0;
1520 }
1521
1522 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1523 {
1524     int len, nb_components, i, h, v, predictor, point_transform;
1525     int vmax, hmax, index, id;
1526     const int block_size= s->lossless ? 1 : 8;
1527     int ilv;
1528
1529     /* XXX: verify len field validity */
1530     len = get_bits(&s->gb, 16);
1531     nb_components = get_bits(&s->gb, 8);
1532     if (len != 6+2*nb_components)
1533     {
1534         dprintf("decode_sos: invalid len (%d)\n", len);
1535         return -1;
1536     }
1537     /* XXX: only interleaved scan accepted */
1538     if ((nb_components != s->nb_components) && !s->ls)
1539     {
1540         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1541         return -1;
1542     }
1543     vmax = 0;
1544     hmax = 0;
1545     for(i=0;i<nb_components;i++) {
1546         id = get_bits(&s->gb, 8) - 1;
1547         dprintf("component: %d\n", id);
1548         /* find component index */
1549         for(index=0;index<s->nb_components;index++)
1550             if (id == s->component_id[index])
1551                 break;
1552         if (index == s->nb_components)
1553         {
1554             dprintf("decode_sos: index(%d) out of components\n", index);
1555             return -1;
1556         }
1557
1558         s->comp_index[i] = index;
1559
1560         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1561         s->h_scount[i] = s->h_count[index];
1562         s->v_scount[i] = s->v_count[index];
1563
1564         s->dc_index[i] = get_bits(&s->gb, 4);
1565         s->ac_index[i] = get_bits(&s->gb, 4);
1566
1567         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1568             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1569             goto out_of_range;
1570 #if 0 //buggy
1571         switch(s->start_code)
1572         {
1573             case SOF0:
1574                 if (dc_index[i] > 1 || ac_index[i] > 1)
1575                     goto out_of_range;
1576                 break;
1577             case SOF1:
1578             case SOF2:
1579                 if (dc_index[i] > 3 || ac_index[i] > 3)
1580                     goto out_of_range;
1581                 break;
1582             case SOF3:
1583                 if (dc_index[i] > 3 || ac_index[i] != 0)
1584                     goto out_of_range;
1585                 break;
1586         }
1587 #endif
1588     }
1589
1590     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1591     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1592     skip_bits(&s->gb, 4); /* Ah */
1593     point_transform= get_bits(&s->gb, 4); /* Al */
1594
1595     for(i=0;i<nb_components;i++)
1596         s->last_dc[i] = 1024;
1597
1598     if (nb_components > 1) {
1599         /* interleaved stream */
1600         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1601         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1602     } else if(!s->ls) { /* skip this for JPEG-LS */
1603         h = s->h_max / s->h_scount[s->comp_index[0]];
1604         v = s->v_max / s->v_scount[s->comp_index[0]];
1605         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1606         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1607         s->nb_blocks[0] = 1;
1608         s->h_scount[0] = 1;
1609         s->v_scount[0] = 1;
1610     }
1611
1612     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1613         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" : "",
1614                predictor, point_transform, ilv, s->bits,
1615                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1616
1617
1618     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1619     for (i = s->mjpb_skiptosod; i > 0; i--)
1620         skip_bits(&s->gb, 8);
1621
1622     if(s->lossless){
1623         if(s->ls){
1624 //            for(){
1625 //            reset_ls_coding_parameters(s, 0);
1626
1627             ls_decode_picture(s, predictor, point_transform, ilv);
1628         }else{
1629             if(s->rgb){
1630                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1631                     return -1;
1632             }else{
1633                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1634                     return -1;
1635             }
1636         }
1637     }else{
1638         if(mjpeg_decode_scan(s) < 0)
1639             return -1;
1640     }
1641     emms_c();
1642     return 0;
1643  out_of_range:
1644     dprintf("decode_sos: ac/dc index out of range\n");
1645     return -1;
1646 }
1647
1648 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1649 {
1650     if (get_bits(&s->gb, 16) != 4)
1651         return -1;
1652     s->restart_interval = get_bits(&s->gb, 16);
1653     s->restart_count = 0;
1654     dprintf("restart interval: %d\n", s->restart_interval);
1655
1656     return 0;
1657 }
1658
1659 static int mjpeg_decode_app(MJpegDecodeContext *s)
1660 {
1661     int len, id;
1662
1663     len = get_bits(&s->gb, 16);
1664     if (len < 5)
1665         return -1;
1666     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1667         return -1;
1668
1669     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1670     id = be2me_32(id);
1671     len -= 6;
1672
1673     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1674         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1675     }
1676
1677     /* buggy AVID, it puts EOI only at every 10th frame */
1678     /* also this fourcc is used by non-avid files too, it holds some
1679        informations, but it's always present in AVID creates files */
1680     if (id == ff_get_fourcc("AVI1"))
1681     {
1682         /* structure:
1683             4bytes      AVI1
1684             1bytes      polarity
1685             1bytes      always zero
1686             4bytes      field_size
1687             4bytes      field_size_less_padding
1688         */
1689             s->buggy_avid = 1;
1690 //        if (s->first_picture)
1691 //            printf("mjpeg: workarounding buggy AVID\n");
1692         s->interlace_polarity = get_bits(&s->gb, 8);
1693 #if 0
1694         skip_bits(&s->gb, 8);
1695         skip_bits(&s->gb, 32);
1696         skip_bits(&s->gb, 32);
1697         len -= 10;
1698 #endif
1699 //        if (s->interlace_polarity)
1700 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1701         goto out;
1702     }
1703
1704 //    len -= 2;
1705
1706     if (id == ff_get_fourcc("JFIF"))
1707     {
1708         int t_w, t_h, v1, v2;
1709         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1710         v1= get_bits(&s->gb, 8);
1711         v2= get_bits(&s->gb, 8);
1712         skip_bits(&s->gb, 8);
1713
1714         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1715         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1716
1717         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1719                 v1, v2,
1720                 s->avctx->sample_aspect_ratio.num,
1721                 s->avctx->sample_aspect_ratio.den
1722             );
1723
1724         t_w = get_bits(&s->gb, 8);
1725         t_h = get_bits(&s->gb, 8);
1726         if (t_w && t_h)
1727         {
1728             /* skip thumbnail */
1729             if (len-10-(t_w*t_h*3) > 0)
1730                 len -= t_w*t_h*3;
1731         }
1732         len -= 10;
1733         goto out;
1734     }
1735
1736     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1737     {
1738         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1739             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1740         skip_bits(&s->gb, 16); /* version */
1741         skip_bits(&s->gb, 16); /* flags0 */
1742         skip_bits(&s->gb, 16); /* flags1 */
1743         skip_bits(&s->gb, 8);  /* transform */
1744         len -= 7;
1745         goto out;
1746     }
1747
1748     if (id == ff_get_fourcc("LJIF")){
1749         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1750             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1751         skip_bits(&s->gb, 16); /* version ? */
1752         skip_bits(&s->gb, 16); /* unknwon always 0? */
1753         skip_bits(&s->gb, 16); /* unknwon always 0? */
1754         skip_bits(&s->gb, 16); /* unknwon always 0? */
1755         switch( get_bits(&s->gb, 8)){
1756         case 1:
1757             s->rgb= 1;
1758             s->pegasus_rct=0;
1759             break;
1760         case 2:
1761             s->rgb= 1;
1762             s->pegasus_rct=1;
1763             break;
1764         default:
1765             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1766         }
1767         len -= 9;
1768         goto out;
1769     }
1770
1771     /* Apple MJPEG-A */
1772     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1773     {
1774         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1775         id = be2me_32(id);
1776         len -= 4;
1777         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1778         {
1779 #if 0
1780             skip_bits(&s->gb, 32); /* field size */
1781             skip_bits(&s->gb, 32); /* pad field size */
1782             skip_bits(&s->gb, 32); /* next off */
1783             skip_bits(&s->gb, 32); /* quant off */
1784             skip_bits(&s->gb, 32); /* huff off */
1785             skip_bits(&s->gb, 32); /* image off */
1786             skip_bits(&s->gb, 32); /* scan off */
1787             skip_bits(&s->gb, 32); /* data off */
1788 #endif
1789             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1790                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1791         }
1792     }
1793
1794 out:
1795     /* slow but needed for extreme adobe jpegs */
1796     if (len < 0)
1797         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1798     while(--len > 0)
1799         skip_bits(&s->gb, 8);
1800
1801     return 0;
1802 }
1803
1804 static int mjpeg_decode_com(MJpegDecodeContext *s)
1805 {
1806     int len = get_bits(&s->gb, 16);
1807     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1808         uint8_t *cbuf = av_malloc(len - 1);
1809         if (cbuf) {
1810             int i;
1811             for (i = 0; i < len - 2; i++)
1812                 cbuf[i] = get_bits(&s->gb, 8);
1813             if (i > 0 && cbuf[i-1] == '\n')
1814                 cbuf[i-1] = 0;
1815             else
1816                 cbuf[i] = 0;
1817
1818             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1819                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1820
1821             /* buggy avid, it puts EOI only at every 10th frame */
1822             if (!strcmp(cbuf, "AVID"))
1823             {
1824                 s->buggy_avid = 1;
1825                 //        if (s->first_picture)
1826                 //            printf("mjpeg: workarounding buggy AVID\n");
1827             }
1828             else if(!strcmp(cbuf, "CS=ITU601")){
1829                 s->cs_itu601= 1;
1830             }
1831
1832             av_free(cbuf);
1833         }
1834     }
1835
1836     return 0;
1837 }
1838
1839 #if 0
1840 static int valid_marker_list[] =
1841 {
1842         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1843 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1852 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1853 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1854 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1856 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1857 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1858 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1859 }
1860 #endif
1861
1862 /* return the 8 bit start code value and update the search
1863    state. Return -1 if no start code found */
1864 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1865 {
1866     uint8_t *buf_ptr;
1867     unsigned int v, v2;
1868     int val;
1869 #ifdef DEBUG
1870     int skipped=0;
1871 #endif
1872
1873     buf_ptr = *pbuf_ptr;
1874     while (buf_ptr < buf_end) {
1875         v = *buf_ptr++;
1876         v2 = *buf_ptr;
1877         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1878             val = *buf_ptr++;
1879             goto found;
1880         }
1881 #ifdef DEBUG
1882         skipped++;
1883 #endif
1884     }
1885     val = -1;
1886 found:
1887 #ifdef DEBUG
1888     dprintf("find_marker skipped %d bytes\n", skipped);
1889 #endif
1890     *pbuf_ptr = buf_ptr;
1891     return val;
1892 }
1893
1894 static int mjpeg_decode_frame(AVCodecContext *avctx,
1895                               void *data, int *data_size,
1896                               uint8_t *buf, int buf_size)
1897 {
1898     MJpegDecodeContext *s = avctx->priv_data;
1899     uint8_t *buf_end, *buf_ptr;
1900     int start_code;
1901     AVFrame *picture = data;
1902
1903     buf_ptr = buf;
1904     buf_end = buf + buf_size;
1905     while (buf_ptr < buf_end) {
1906         /* find start next marker */
1907         start_code = find_marker(&buf_ptr, buf_end);
1908         {
1909             /* EOF */
1910             if (start_code < 0) {
1911                 goto the_end;
1912             } else {
1913                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1914
1915                 if ((buf_end - buf_ptr) > s->buffer_size)
1916                 {
1917                     av_free(s->buffer);
1918                     s->buffer_size = buf_end-buf_ptr;
1919                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1920                     dprintf("buffer too small, expanding to %d bytes\n",
1921                         s->buffer_size);
1922                 }
1923
1924                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1925                 if (start_code == SOS && !s->ls)
1926                 {
1927                     uint8_t *src = buf_ptr;
1928                     uint8_t *dst = s->buffer;
1929
1930                     while (src<buf_end)
1931                     {
1932                         uint8_t x = *(src++);
1933
1934                         *(dst++) = x;
1935                         if (x == 0xff)
1936                         {
1937                             while(src<buf_end && x == 0xff)
1938                                 x = *(src++);
1939
1940                             if (x >= 0xd0 && x <= 0xd7)
1941                                 *(dst++) = x;
1942                             else if (x)
1943                                 break;
1944                         }
1945                     }
1946                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1947
1948                     dprintf("escaping removed %d bytes\n",
1949                         (buf_end - buf_ptr) - (dst - s->buffer));
1950                 }
1951                 else if(start_code == SOS && s->ls){
1952                     uint8_t *src = buf_ptr;
1953                     uint8_t *dst = s->buffer;
1954                     int bit_count = 0;
1955                     int t = 0, b = 0;
1956                     PutBitContext pb;
1957
1958                     s->cur_scan++;
1959
1960                     /* find marker */
1961                     while (src + t < buf_end){
1962                         uint8_t x = src[t++];
1963                         if (x == 0xff){
1964                             while((src + t < buf_end) && x == 0xff)
1965                                 x = src[t++];
1966                             if (x & 0x80) {
1967                                 t -= 2;
1968                                 break;
1969                             }
1970                         }
1971                     }
1972                     bit_count = t * 8;
1973
1974                     init_put_bits(&pb, dst, t);
1975
1976                     /* unescape bitstream */
1977                     while(b < t){
1978                         uint8_t x = src[b++];
1979                         put_bits(&pb, 8, x);
1980                         if(x == 0xFF){
1981                             x = src[b++];
1982                             put_bits(&pb, 7, x);
1983                             bit_count--;
1984                         }
1985                     }
1986                     flush_put_bits(&pb);
1987
1988                     init_get_bits(&s->gb, dst, bit_count);
1989                 }
1990                 else
1991                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1992
1993                 s->start_code = start_code;
1994                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1995                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1996                 }
1997
1998                 /* process markers */
1999                 if (start_code >= 0xd0 && start_code <= 0xd7) {
2000                     dprintf("restart marker: %d\n", start_code&0x0f);
2001                     /* APP fields */
2002                 } else if (start_code >= APP0 && start_code <= APP15) {
2003                     mjpeg_decode_app(s);
2004                     /* Comment */
2005                 } else if (start_code == COM){
2006                     mjpeg_decode_com(s);
2007                 }
2008
2009                 switch(start_code) {
2010                 case SOI:
2011                     s->restart_interval = 0;
2012
2013                     s->restart_count = 0;
2014                     /* nothing to do on SOI */
2015                     break;
2016                 case DQT:
2017                     mjpeg_decode_dqt(s);
2018                     break;
2019                 case DHT:
2020                     if(mjpeg_decode_dht(s) < 0){
2021                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2022                         return -1;
2023                     }
2024                     break;
2025                 case SOF0:
2026                     s->lossless=0;
2027                     if (mjpeg_decode_sof(s) < 0)
2028                         return -1;
2029                     break;
2030                 case SOF3:
2031                     s->lossless=1;
2032                     if (mjpeg_decode_sof(s) < 0)
2033                         return -1;
2034                     break;
2035                 case SOF48:
2036                     s->lossless=1;
2037                     s->ls=1;
2038                     if (mjpeg_decode_sof(s) < 0)
2039                         return -1;
2040                     break;
2041                 case LSE:
2042                     if (decode_lse(s) < 0)
2043                         return -1;
2044                     break;
2045                 case EOI:
2046                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2047                         break;
2048 eoi_parser:
2049                     {
2050                         if (s->interlaced) {
2051                             s->bottom_field ^= 1;
2052                             /* if not bottom field, do not output image yet */
2053                             if (s->bottom_field)
2054                                 goto not_the_end;
2055                         }
2056                         *picture = s->picture;
2057                         *data_size = sizeof(AVFrame);
2058
2059                         if(!s->lossless){
2060                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2061                             picture->qstride= 0;
2062                             picture->qscale_table= s->qscale_table;
2063                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2064                             if(avctx->debug & FF_DEBUG_QP)
2065                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2066                             picture->quality*= FF_QP2LAMBDA;
2067                         }
2068
2069                         goto the_end;
2070                     }
2071                     break;
2072                 case SOS:
2073                     mjpeg_decode_sos(s);
2074                     /* buggy avid puts EOI every 10-20th frame */
2075                     /* if restart period is over process EOI */
2076                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2077                         goto eoi_parser;
2078                     break;
2079                 case DRI:
2080                     mjpeg_decode_dri(s);
2081                     break;
2082                 case SOF1:
2083                 case SOF2:
2084                 case SOF5:
2085                 case SOF6:
2086                 case SOF7:
2087                 case SOF9:
2088                 case SOF10:
2089                 case SOF11:
2090                 case SOF13:
2091                 case SOF14:
2092                 case SOF15:
2093                 case JPG:
2094                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2095                     break;
2096 //                default:
2097 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2098 //                    break;
2099                 }
2100
2101 not_the_end:
2102                 /* eof process start code */
2103                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2104                 dprintf("marker parser used %d bytes (%d bits)\n",
2105                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2106             }
2107         }
2108     }
2109 the_end:
2110     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2111 //    return buf_end - buf_ptr;
2112     return buf_ptr - buf;
2113 }
2114
2115 static int mjpegb_decode_frame(AVCodecContext *avctx,
2116                               void *data, int *data_size,
2117                               uint8_t *buf, int buf_size)
2118 {
2119     MJpegDecodeContext *s = avctx->priv_data;
2120     uint8_t *buf_end, *buf_ptr;
2121     AVFrame *picture = data;
2122     GetBitContext hgb; /* for the header */
2123     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2124     uint32_t field_size, sod_offs;
2125
2126     buf_ptr = buf;
2127     buf_end = buf + buf_size;
2128
2129 read_header:
2130     /* reset on every SOI */
2131     s->restart_interval = 0;
2132     s->restart_count = 0;
2133     s->mjpb_skiptosod = 0;
2134
2135     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2136
2137     skip_bits(&hgb, 32); /* reserved zeros */
2138
2139     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2140     {
2141         dprintf("not mjpeg-b (bad fourcc)\n");
2142         return 0;
2143     }
2144
2145     field_size = get_bits_long(&hgb, 32); /* field size */
2146     dprintf("field size: 0x%x\n", field_size);
2147     skip_bits(&hgb, 32); /* padded field size */
2148     second_field_offs = get_bits_long(&hgb, 32);
2149     dprintf("second field offs: 0x%x\n", second_field_offs);
2150     if (second_field_offs)
2151         s->interlaced = 1;
2152
2153     dqt_offs = get_bits_long(&hgb, 32);
2154     dprintf("dqt offs: 0x%x\n", dqt_offs);
2155     if (dqt_offs)
2156     {
2157         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2158         s->start_code = DQT;
2159         mjpeg_decode_dqt(s);
2160     }
2161
2162     dht_offs = get_bits_long(&hgb, 32);
2163     dprintf("dht offs: 0x%x\n", dht_offs);
2164     if (dht_offs)
2165     {
2166         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2167         s->start_code = DHT;
2168         mjpeg_decode_dht(s);
2169     }
2170
2171     sof_offs = get_bits_long(&hgb, 32);
2172     dprintf("sof offs: 0x%x\n", sof_offs);
2173     if (sof_offs)
2174     {
2175         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2176         s->start_code = SOF0;
2177         if (mjpeg_decode_sof(s) < 0)
2178             return -1;
2179     }
2180
2181     sos_offs = get_bits_long(&hgb, 32);
2182     dprintf("sos offs: 0x%x\n", sos_offs);
2183     sod_offs = get_bits_long(&hgb, 32);
2184     dprintf("sod offs: 0x%x\n", sod_offs);
2185     if (sos_offs)
2186     {
2187 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2188         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2189         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2190         s->start_code = SOS;
2191         mjpeg_decode_sos(s);
2192     }
2193
2194     if (s->interlaced) {
2195         s->bottom_field ^= 1;
2196         /* if not bottom field, do not output image yet */
2197         if (s->bottom_field && second_field_offs)
2198         {
2199             buf_ptr = buf + second_field_offs;
2200             second_field_offs = 0;
2201             goto read_header;
2202             }
2203     }
2204
2205     //XXX FIXME factorize, this looks very similar to the EOI code
2206
2207     *picture= s->picture;
2208     *data_size = sizeof(AVFrame);
2209
2210     if(!s->lossless){
2211         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2212         picture->qstride= 0;
2213         picture->qscale_table= s->qscale_table;
2214         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2215         if(avctx->debug & FF_DEBUG_QP)
2216             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2217         picture->quality*= FF_QP2LAMBDA;
2218     }
2219
2220     return buf_ptr - buf;
2221 }
2222
2223 #include "sp5x.h"
2224
2225 static int sp5x_decode_frame(AVCodecContext *avctx,
2226                               void *data, int *data_size,
2227                               uint8_t *buf, int buf_size)
2228 {
2229 #if 0
2230     MJpegDecodeContext *s = avctx->priv_data;
2231 #endif
2232     const int qscale = 5;
2233     uint8_t *buf_ptr, *buf_end, *recoded;
2234     int i = 0, j = 0;
2235
2236     if (!avctx->width || !avctx->height)
2237         return -1;
2238
2239     buf_ptr = buf;
2240     buf_end = buf + buf_size;
2241
2242 #if 1
2243     recoded = av_mallocz(buf_size + 1024);
2244     if (!recoded)
2245         return -1;
2246
2247     /* SOI */
2248     recoded[j++] = 0xFF;
2249     recoded[j++] = 0xD8;
2250
2251     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2252     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2253     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2254     j += sizeof(sp5x_data_dqt);
2255
2256     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2257     j += sizeof(sp5x_data_dht);
2258
2259     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2260     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2261     recoded[j+6] = avctx->coded_height & 0xFF;
2262     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2263     recoded[j+8] = avctx->coded_width & 0xFF;
2264     j += sizeof(sp5x_data_sof);
2265
2266     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2267     j += sizeof(sp5x_data_sos);
2268
2269     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2270     {
2271         recoded[j++] = buf[i];
2272         if (buf[i] == 0xff)
2273             recoded[j++] = 0;
2274     }
2275
2276     /* EOI */
2277     recoded[j++] = 0xFF;
2278     recoded[j++] = 0xD9;
2279
2280     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2281
2282     av_free(recoded);
2283
2284 #else
2285     /* SOF */
2286     s->bits = 8;
2287     s->width  = avctx->coded_width;
2288     s->height = avctx->coded_height;
2289     s->nb_components = 3;
2290     s->component_id[0] = 0;
2291     s->h_count[0] = 2;
2292     s->v_count[0] = 2;
2293     s->quant_index[0] = 0;
2294     s->component_id[1] = 1;
2295     s->h_count[1] = 1;
2296     s->v_count[1] = 1;
2297     s->quant_index[1] = 1;
2298     s->component_id[2] = 2;
2299     s->h_count[2] = 1;
2300     s->v_count[2] = 1;
2301     s->quant_index[2] = 1;
2302     s->h_max = 2;
2303     s->v_max = 2;
2304
2305     s->qscale_table = av_mallocz((s->width+15)/16);
2306     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2307     s->interlaced = 0;
2308
2309     s->picture.reference = 0;
2310     if (avctx->get_buffer(avctx, &s->picture) < 0)
2311     {
2312         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2313         return -1;
2314     }
2315
2316     s->picture.pict_type = I_TYPE;
2317     s->picture.key_frame = 1;
2318
2319     for (i = 0; i < 3; i++)
2320         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2321
2322     /* DQT */
2323     for (i = 0; i < 64; i++)
2324     {
2325         j = s->scantable.permutated[i];
2326         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2327     }
2328     s->qscale[0] = FFMAX(
2329         s->quant_matrixes[0][s->scantable.permutated[1]],
2330         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2331
2332     for (i = 0; i < 64; i++)
2333     {
2334         j = s->scantable.permutated[i];
2335         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2336     }
2337     s->qscale[1] = FFMAX(
2338         s->quant_matrixes[1][s->scantable.permutated[1]],
2339         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2340
2341     /* DHT */
2342
2343     /* SOS */
2344     s->comp_index[0] = 0;
2345     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2346     s->h_scount[0] = s->h_count[0];
2347     s->v_scount[0] = s->v_count[0];
2348     s->dc_index[0] = 0;
2349     s->ac_index[0] = 0;
2350
2351     s->comp_index[1] = 1;
2352     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2353     s->h_scount[1] = s->h_count[1];
2354     s->v_scount[1] = s->v_count[1];
2355     s->dc_index[1] = 1;
2356     s->ac_index[1] = 1;
2357
2358     s->comp_index[2] = 2;
2359     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2360     s->h_scount[2] = s->h_count[2];
2361     s->v_scount[2] = s->v_count[2];
2362     s->dc_index[2] = 1;
2363     s->ac_index[2] = 1;
2364
2365     for (i = 0; i < 3; i++)
2366         s->last_dc[i] = 1024;
2367
2368     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2369     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2370
2371     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2372
2373     return mjpeg_decode_scan(s);
2374 #endif
2375
2376     return i;
2377 }
2378
2379 static int mjpeg_decode_end(AVCodecContext *avctx)
2380 {
2381     MJpegDecodeContext *s = avctx->priv_data;
2382     int i, j;
2383
2384     av_free(s->buffer);
2385     av_free(s->qscale_table);
2386
2387     for(i=0;i<2;i++) {
2388         for(j=0;j<4;j++)
2389             free_vlc(&s->vlcs[i][j]);
2390     }
2391     return 0;
2392 }
2393
2394 AVCodec mjpeg_decoder = {
2395     "mjpeg",
2396     CODEC_TYPE_VIDEO,
2397     CODEC_ID_MJPEG,
2398     sizeof(MJpegDecodeContext),
2399     mjpeg_decode_init,
2400     NULL,
2401     mjpeg_decode_end,
2402     mjpeg_decode_frame,
2403     CODEC_CAP_DR1,
2404     NULL
2405 };
2406
2407 AVCodec mjpegb_decoder = {
2408     "mjpegb",
2409     CODEC_TYPE_VIDEO,
2410     CODEC_ID_MJPEGB,
2411     sizeof(MJpegDecodeContext),
2412     mjpeg_decode_init,
2413     NULL,
2414     mjpeg_decode_end,
2415     mjpegb_decode_frame,
2416     CODEC_CAP_DR1,
2417     NULL
2418 };
2419
2420 AVCodec sp5x_decoder = {
2421     "sp5x",
2422     CODEC_TYPE_VIDEO,
2423     CODEC_ID_SP5X,
2424     sizeof(MJpegDecodeContext),
2425     mjpeg_decode_init,
2426     NULL,
2427     mjpeg_decode_end,
2428     sp5x_decode_frame,
2429     CODEC_CAP_DR1,
2430     NULL
2431 };
2432
2433 #ifdef CONFIG_ENCODERS
2434 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2435     "ljpeg",
2436     CODEC_TYPE_VIDEO,
2437     CODEC_ID_LJPEG,
2438     sizeof(MpegEncContext),
2439     MPV_encode_init,
2440     encode_picture_lossless,
2441     MPV_encode_end,
2442 };
2443 #endif
2444
2445 AVCodecParser mjpeg_parser = {
2446     { CODEC_ID_MJPEG },
2447     sizeof(ParseContext),
2448     NULL,
2449     jpeg_parse,
2450     ff_parse_close,
2451 };
2452