f0634a041363fb5bbca56b79d049e9a25119237f
[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
1290             UPDATE_CACHE(re, &s->gb)
1291
1292             if ((int32_t)GET_CACHE(re,&s->gb)<0) { //MSB=1
1293                 level =   NEG_USR32( GET_CACHE(re,&s->gb),code);
1294             } else {
1295                 level = - NEG_USR32(~GET_CACHE(re,&s->gb),code);
1296             }
1297
1298             LAST_SKIP_BITS(re, &s->gb, code)
1299
1300             if (i >= 64) {
1301                 dprintf("error count: %d\n", i);
1302                 return -1;
1303             }
1304             j = s->scantable.permutated[i];
1305             block[j] = level * quant_matrix[j];
1306             if (i >= 63)
1307                 break;
1308         }
1309     }
1310     CLOSE_READER(re, &s->gb)
1311
1312     return 0;
1313 }
1314
1315 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1316     int i, mb_x, mb_y;
1317     uint16_t buffer[32768][4];
1318     int left[3], top[3], topleft[3];
1319     const int linesize= s->linesize[0];
1320     const int mask= (1<<s->bits)-1;
1321
1322     if((unsigned)s->mb_width > 32768) //dynamic alloc
1323         return -1;
1324
1325     for(i=0; i<3; i++){
1326         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1327     }
1328     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1329         const int modified_predictor= mb_y ? predictor : 1;
1330         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1331
1332         if (s->interlaced && s->bottom_field)
1333             ptr += linesize >> 1;
1334
1335         for(i=0; i<3; i++){
1336             top[i]= left[i]= topleft[i]= buffer[0][i];
1337         }
1338         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1339             if (s->restart_interval && !s->restart_count)
1340                 s->restart_count = s->restart_interval;
1341
1342             for(i=0;i<3;i++) {
1343                 int pred;
1344
1345                 topleft[i]= top[i];
1346                 top[i]= buffer[mb_x][i];
1347
1348                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1349
1350                 left[i]=
1351                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1352             }
1353
1354             if (s->restart_interval && !--s->restart_count) {
1355                 align_get_bits(&s->gb);
1356                 skip_bits(&s->gb, 16); /* skip RSTn */
1357             }
1358         }
1359
1360         if(s->rct){
1361             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1362                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1363                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1364                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1365             }
1366         }else if(s->pegasus_rct){
1367             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1368                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1369                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1370                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1371             }
1372         }else{
1373             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1374                 ptr[4*mb_x+0] = buffer[mb_x][0];
1375                 ptr[4*mb_x+1] = buffer[mb_x][1];
1376                 ptr[4*mb_x+2] = buffer[mb_x][2];
1377             }
1378         }
1379     }
1380     return 0;
1381 }
1382
1383 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1384     int i, mb_x, mb_y;
1385     const int nb_components=3;
1386
1387     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1388         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1389             if (s->restart_interval && !s->restart_count)
1390                 s->restart_count = s->restart_interval;
1391
1392             if(mb_x==0 || mb_y==0 || s->interlaced){
1393                 for(i=0;i<nb_components;i++) {
1394                     uint8_t *ptr;
1395                     int n, h, v, x, y, c, j, linesize;
1396                     n = s->nb_blocks[i];
1397                     c = s->comp_index[i];
1398                     h = s->h_scount[i];
1399                     v = s->v_scount[i];
1400                     x = 0;
1401                     y = 0;
1402                     linesize= s->linesize[c];
1403
1404                     for(j=0; j<n; j++) {
1405                         int pred;
1406
1407                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1408                         if(y==0 && mb_y==0){
1409                             if(x==0 && mb_x==0){
1410                                 pred= 128 << point_transform;
1411                             }else{
1412                                 pred= ptr[-1];
1413                             }
1414                         }else{
1415                             if(x==0 && mb_x==0){
1416                                 pred= ptr[-linesize];
1417                             }else{
1418                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1419                             }
1420                         }
1421
1422                         if (s->interlaced && s->bottom_field)
1423                             ptr += linesize >> 1;
1424                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1425
1426                         if (++x == h) {
1427                             x = 0;
1428                             y++;
1429                         }
1430                     }
1431                 }
1432             }else{
1433                 for(i=0;i<nb_components;i++) {
1434                     uint8_t *ptr;
1435                     int n, h, v, x, y, c, j, linesize;
1436                     n = s->nb_blocks[i];
1437                     c = s->comp_index[i];
1438                     h = s->h_scount[i];
1439                     v = s->v_scount[i];
1440                     x = 0;
1441                     y = 0;
1442                     linesize= s->linesize[c];
1443
1444                     for(j=0; j<n; j++) {
1445                         int pred;
1446
1447                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1448                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1449                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1450                         if (++x == h) {
1451                             x = 0;
1452                             y++;
1453                         }
1454                     }
1455                 }
1456             }
1457             if (s->restart_interval && !--s->restart_count) {
1458                 align_get_bits(&s->gb);
1459                 skip_bits(&s->gb, 16); /* skip RSTn */
1460             }
1461         }
1462     }
1463     return 0;
1464 }
1465
1466 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1467     int i, mb_x, mb_y;
1468     const int nb_components=3;
1469
1470     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1471         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1472             if (s->restart_interval && !s->restart_count)
1473                 s->restart_count = s->restart_interval;
1474
1475             for(i=0;i<nb_components;i++) {
1476                 uint8_t *ptr;
1477                 int n, h, v, x, y, c, j;
1478                 n = s->nb_blocks[i];
1479                 c = s->comp_index[i];
1480                 h = s->h_scount[i];
1481                 v = s->v_scount[i];
1482                 x = 0;
1483                 y = 0;
1484                 for(j=0;j<n;j++) {
1485                     memset(s->block, 0, sizeof(s->block));
1486                     if (decode_block(s, s->block, i,
1487                                      s->dc_index[i], s->ac_index[i],
1488                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1489                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1490                         return -1;
1491                     }
1492 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1493                     ptr = s->picture.data[c] +
1494                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1495                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1496                     if (s->interlaced && s->bottom_field)
1497                         ptr += s->linesize[c] >> 1;
1498 //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);
1499                     s->idct_put(ptr, s->linesize[c], s->block);
1500                     if (++x == h) {
1501                         x = 0;
1502                         y++;
1503                     }
1504                 }
1505             }
1506             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1507             if (s->restart_interval && (s->restart_interval < 1350) &&
1508                 !--s->restart_count) {
1509                 align_get_bits(&s->gb);
1510                 skip_bits(&s->gb, 16); /* skip RSTn */
1511                 for (i=0; i<nb_components; i++) /* reset dc */
1512                     s->last_dc[i] = 1024;
1513             }
1514         }
1515     }
1516     return 0;
1517 }
1518
1519 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1520 {
1521     int len, nb_components, i, h, v, predictor, point_transform;
1522     int vmax, hmax, index, id;
1523     const int block_size= s->lossless ? 1 : 8;
1524     int ilv;
1525
1526     /* XXX: verify len field validity */
1527     len = get_bits(&s->gb, 16);
1528     nb_components = get_bits(&s->gb, 8);
1529     if (len != 6+2*nb_components)
1530     {
1531         dprintf("decode_sos: invalid len (%d)\n", len);
1532         return -1;
1533     }
1534     /* XXX: only interleaved scan accepted */
1535     if ((nb_components != s->nb_components) && !s->ls)
1536     {
1537         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1538         return -1;
1539     }
1540     vmax = 0;
1541     hmax = 0;
1542     for(i=0;i<nb_components;i++) {
1543         id = get_bits(&s->gb, 8) - 1;
1544         dprintf("component: %d\n", id);
1545         /* find component index */
1546         for(index=0;index<s->nb_components;index++)
1547             if (id == s->component_id[index])
1548                 break;
1549         if (index == s->nb_components)
1550         {
1551             dprintf("decode_sos: index(%d) out of components\n", index);
1552             return -1;
1553         }
1554
1555         s->comp_index[i] = index;
1556
1557         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1558         s->h_scount[i] = s->h_count[index];
1559         s->v_scount[i] = s->v_count[index];
1560
1561         s->dc_index[i] = get_bits(&s->gb, 4);
1562         s->ac_index[i] = get_bits(&s->gb, 4);
1563
1564         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1565             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1566             goto out_of_range;
1567 #if 0 //buggy
1568         switch(s->start_code)
1569         {
1570             case SOF0:
1571                 if (dc_index[i] > 1 || ac_index[i] > 1)
1572                     goto out_of_range;
1573                 break;
1574             case SOF1:
1575             case SOF2:
1576                 if (dc_index[i] > 3 || ac_index[i] > 3)
1577                     goto out_of_range;
1578                 break;
1579             case SOF3:
1580                 if (dc_index[i] > 3 || ac_index[i] != 0)
1581                     goto out_of_range;
1582                 break;
1583         }
1584 #endif
1585     }
1586
1587     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1588     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1589     skip_bits(&s->gb, 4); /* Ah */
1590     point_transform= get_bits(&s->gb, 4); /* Al */
1591
1592     for(i=0;i<nb_components;i++)
1593         s->last_dc[i] = 1024;
1594
1595     if (nb_components > 1) {
1596         /* interleaved stream */
1597         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1598         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1599     } else if(!s->ls) { /* skip this for JPEG-LS */
1600         h = s->h_max / s->h_scount[s->comp_index[0]];
1601         v = s->v_max / s->v_scount[s->comp_index[0]];
1602         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1603         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1604         s->nb_blocks[0] = 1;
1605         s->h_scount[0] = 1;
1606         s->v_scount[0] = 1;
1607     }
1608
1609     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1610         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" : "",
1611                predictor, point_transform, ilv, s->bits,
1612                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1613
1614
1615     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1616     for (i = s->mjpb_skiptosod; i > 0; i--)
1617         skip_bits(&s->gb, 8);
1618
1619     if(s->lossless){
1620         if(s->ls){
1621 //            for(){
1622 //            reset_ls_coding_parameters(s, 0);
1623
1624             ls_decode_picture(s, predictor, point_transform, ilv);
1625         }else{
1626             if(s->rgb){
1627                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1628                     return -1;
1629             }else{
1630                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1631                     return -1;
1632             }
1633         }
1634     }else{
1635         if(mjpeg_decode_scan(s) < 0)
1636             return -1;
1637     }
1638     emms_c();
1639     return 0;
1640  out_of_range:
1641     dprintf("decode_sos: ac/dc index out of range\n");
1642     return -1;
1643 }
1644
1645 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1646 {
1647     if (get_bits(&s->gb, 16) != 4)
1648         return -1;
1649     s->restart_interval = get_bits(&s->gb, 16);
1650     s->restart_count = 0;
1651     dprintf("restart interval: %d\n", s->restart_interval);
1652
1653     return 0;
1654 }
1655
1656 static int mjpeg_decode_app(MJpegDecodeContext *s)
1657 {
1658     int len, id;
1659
1660     len = get_bits(&s->gb, 16);
1661     if (len < 5)
1662         return -1;
1663     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1664         return -1;
1665
1666     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1667     id = be2me_32(id);
1668     len -= 6;
1669
1670     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1671         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1672     }
1673
1674     /* buggy AVID, it puts EOI only at every 10th frame */
1675     /* also this fourcc is used by non-avid files too, it holds some
1676        informations, but it's always present in AVID creates files */
1677     if (id == ff_get_fourcc("AVI1"))
1678     {
1679         /* structure:
1680             4bytes      AVI1
1681             1bytes      polarity
1682             1bytes      always zero
1683             4bytes      field_size
1684             4bytes      field_size_less_padding
1685         */
1686             s->buggy_avid = 1;
1687 //        if (s->first_picture)
1688 //            printf("mjpeg: workarounding buggy AVID\n");
1689         s->interlace_polarity = get_bits(&s->gb, 8);
1690 #if 0
1691         skip_bits(&s->gb, 8);
1692         skip_bits(&s->gb, 32);
1693         skip_bits(&s->gb, 32);
1694         len -= 10;
1695 #endif
1696 //        if (s->interlace_polarity)
1697 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1698         goto out;
1699     }
1700
1701 //    len -= 2;
1702
1703     if (id == ff_get_fourcc("JFIF"))
1704     {
1705         int t_w, t_h, v1, v2;
1706         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1707         v1= get_bits(&s->gb, 8);
1708         v2= get_bits(&s->gb, 8);
1709         skip_bits(&s->gb, 8);
1710
1711         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1712         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1713
1714         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1715             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1716                 v1, v2,
1717                 s->avctx->sample_aspect_ratio.num,
1718                 s->avctx->sample_aspect_ratio.den
1719             );
1720
1721         t_w = get_bits(&s->gb, 8);
1722         t_h = get_bits(&s->gb, 8);
1723         if (t_w && t_h)
1724         {
1725             /* skip thumbnail */
1726             if (len-10-(t_w*t_h*3) > 0)
1727                 len -= t_w*t_h*3;
1728         }
1729         len -= 10;
1730         goto out;
1731     }
1732
1733     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1734     {
1735         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1736             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1737         skip_bits(&s->gb, 16); /* version */
1738         skip_bits(&s->gb, 16); /* flags0 */
1739         skip_bits(&s->gb, 16); /* flags1 */
1740         skip_bits(&s->gb, 8);  /* transform */
1741         len -= 7;
1742         goto out;
1743     }
1744
1745     if (id == ff_get_fourcc("LJIF")){
1746         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1747             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1748         skip_bits(&s->gb, 16); /* version ? */
1749         skip_bits(&s->gb, 16); /* unknwon always 0? */
1750         skip_bits(&s->gb, 16); /* unknwon always 0? */
1751         skip_bits(&s->gb, 16); /* unknwon always 0? */
1752         switch( get_bits(&s->gb, 8)){
1753         case 1:
1754             s->rgb= 1;
1755             s->pegasus_rct=0;
1756             break;
1757         case 2:
1758             s->rgb= 1;
1759             s->pegasus_rct=1;
1760             break;
1761         default:
1762             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1763         }
1764         len -= 9;
1765         goto out;
1766     }
1767
1768     /* Apple MJPEG-A */
1769     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1770     {
1771         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1772         id = be2me_32(id);
1773         len -= 4;
1774         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1775         {
1776 #if 0
1777             skip_bits(&s->gb, 32); /* field size */
1778             skip_bits(&s->gb, 32); /* pad field size */
1779             skip_bits(&s->gb, 32); /* next off */
1780             skip_bits(&s->gb, 32); /* quant off */
1781             skip_bits(&s->gb, 32); /* huff off */
1782             skip_bits(&s->gb, 32); /* image off */
1783             skip_bits(&s->gb, 32); /* scan off */
1784             skip_bits(&s->gb, 32); /* data off */
1785 #endif
1786             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1787                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1788         }
1789     }
1790
1791 out:
1792     /* slow but needed for extreme adobe jpegs */
1793     if (len < 0)
1794         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1795     while(--len > 0)
1796         skip_bits(&s->gb, 8);
1797
1798     return 0;
1799 }
1800
1801 static int mjpeg_decode_com(MJpegDecodeContext *s)
1802 {
1803     int len = get_bits(&s->gb, 16);
1804     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1805         uint8_t *cbuf = av_malloc(len - 1);
1806         if (cbuf) {
1807             int i;
1808             for (i = 0; i < len - 2; i++)
1809                 cbuf[i] = get_bits(&s->gb, 8);
1810             if (i > 0 && cbuf[i-1] == '\n')
1811                 cbuf[i-1] = 0;
1812             else
1813                 cbuf[i] = 0;
1814
1815             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1816                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1817
1818             /* buggy avid, it puts EOI only at every 10th frame */
1819             if (!strcmp(cbuf, "AVID"))
1820             {
1821                 s->buggy_avid = 1;
1822                 //        if (s->first_picture)
1823                 //            printf("mjpeg: workarounding buggy AVID\n");
1824             }
1825             else if(!strcmp(cbuf, "CS=ITU601")){
1826                 s->cs_itu601= 1;
1827             }
1828
1829             av_free(cbuf);
1830         }
1831     }
1832
1833     return 0;
1834 }
1835
1836 #if 0
1837 static int valid_marker_list[] =
1838 {
1839         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1840 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1841 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1842 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1843 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1852 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1853 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1854 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1855 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1856 }
1857 #endif
1858
1859 /* return the 8 bit start code value and update the search
1860    state. Return -1 if no start code found */
1861 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1862 {
1863     uint8_t *buf_ptr;
1864     unsigned int v, v2;
1865     int val;
1866 #ifdef DEBUG
1867     int skipped=0;
1868 #endif
1869
1870     buf_ptr = *pbuf_ptr;
1871     while (buf_ptr < buf_end) {
1872         v = *buf_ptr++;
1873         v2 = *buf_ptr;
1874         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1875             val = *buf_ptr++;
1876             goto found;
1877         }
1878 #ifdef DEBUG
1879         skipped++;
1880 #endif
1881     }
1882     val = -1;
1883 found:
1884 #ifdef DEBUG
1885     dprintf("find_marker skipped %d bytes\n", skipped);
1886 #endif
1887     *pbuf_ptr = buf_ptr;
1888     return val;
1889 }
1890
1891 static int mjpeg_decode_frame(AVCodecContext *avctx,
1892                               void *data, int *data_size,
1893                               uint8_t *buf, int buf_size)
1894 {
1895     MJpegDecodeContext *s = avctx->priv_data;
1896     uint8_t *buf_end, *buf_ptr;
1897     int start_code;
1898     AVFrame *picture = data;
1899
1900     buf_ptr = buf;
1901     buf_end = buf + buf_size;
1902     while (buf_ptr < buf_end) {
1903         /* find start next marker */
1904         start_code = find_marker(&buf_ptr, buf_end);
1905         {
1906             /* EOF */
1907             if (start_code < 0) {
1908                 goto the_end;
1909             } else {
1910                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1911
1912                 if ((buf_end - buf_ptr) > s->buffer_size)
1913                 {
1914                     av_free(s->buffer);
1915                     s->buffer_size = buf_end-buf_ptr;
1916                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1917                     dprintf("buffer too small, expanding to %d bytes\n",
1918                         s->buffer_size);
1919                 }
1920
1921                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1922                 if (start_code == SOS && !s->ls)
1923                 {
1924                     uint8_t *src = buf_ptr;
1925                     uint8_t *dst = s->buffer;
1926
1927                     while (src<buf_end)
1928                     {
1929                         uint8_t x = *(src++);
1930
1931                         *(dst++) = x;
1932                         if (x == 0xff)
1933                         {
1934                             while(src<buf_end && x == 0xff)
1935                                 x = *(src++);
1936
1937                             if (x >= 0xd0 && x <= 0xd7)
1938                                 *(dst++) = x;
1939                             else if (x)
1940                                 break;
1941                         }
1942                     }
1943                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1944
1945                     dprintf("escaping removed %d bytes\n",
1946                         (buf_end - buf_ptr) - (dst - s->buffer));
1947                 }
1948                 else if(start_code == SOS && s->ls){
1949                     uint8_t *src = buf_ptr;
1950                     uint8_t *dst = s->buffer;
1951                     int bit_count = 0;
1952                     int t = 0, b = 0;
1953                     PutBitContext pb;
1954
1955                     s->cur_scan++;
1956
1957                     /* find marker */
1958                     while (src + t < buf_end){
1959                         uint8_t x = src[t++];
1960                         if (x == 0xff){
1961                             while((src + t < buf_end) && x == 0xff)
1962                                 x = src[t++];
1963                             if (x & 0x80) {
1964                                 t -= 2;
1965                                 break;
1966                             }
1967                         }
1968                     }
1969                     bit_count = t * 8;
1970
1971                     init_put_bits(&pb, dst, t);
1972
1973                     /* unescape bitstream */
1974                     while(b < t){
1975                         uint8_t x = src[b++];
1976                         put_bits(&pb, 8, x);
1977                         if(x == 0xFF){
1978                             x = src[b++];
1979                             put_bits(&pb, 7, x);
1980                             bit_count--;
1981                         }
1982                     }
1983                     flush_put_bits(&pb);
1984
1985                     init_get_bits(&s->gb, dst, bit_count);
1986                 }
1987                 else
1988                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1989
1990                 s->start_code = start_code;
1991                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1992                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1993                 }
1994
1995                 /* process markers */
1996                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1997                     dprintf("restart marker: %d\n", start_code&0x0f);
1998                     /* APP fields */
1999                 } else if (start_code >= APP0 && start_code <= APP15) {
2000                     mjpeg_decode_app(s);
2001                     /* Comment */
2002                 } else if (start_code == COM){
2003                     mjpeg_decode_com(s);
2004                 }
2005
2006                 switch(start_code) {
2007                 case SOI:
2008                     s->restart_interval = 0;
2009
2010                     s->restart_count = 0;
2011                     /* nothing to do on SOI */
2012                     break;
2013                 case DQT:
2014                     mjpeg_decode_dqt(s);
2015                     break;
2016                 case DHT:
2017                     if(mjpeg_decode_dht(s) < 0){
2018                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2019                         return -1;
2020                     }
2021                     break;
2022                 case SOF0:
2023                     s->lossless=0;
2024                     if (mjpeg_decode_sof(s) < 0)
2025                         return -1;
2026                     break;
2027                 case SOF3:
2028                     s->lossless=1;
2029                     if (mjpeg_decode_sof(s) < 0)
2030                         return -1;
2031                     break;
2032                 case SOF48:
2033                     s->lossless=1;
2034                     s->ls=1;
2035                     if (mjpeg_decode_sof(s) < 0)
2036                         return -1;
2037                     break;
2038                 case LSE:
2039                     if (decode_lse(s) < 0)
2040                         return -1;
2041                     break;
2042                 case EOI:
2043                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2044                         break;
2045 eoi_parser:
2046                     {
2047                         if (s->interlaced) {
2048                             s->bottom_field ^= 1;
2049                             /* if not bottom field, do not output image yet */
2050                             if (s->bottom_field)
2051                                 goto not_the_end;
2052                         }
2053                         *picture = s->picture;
2054                         *data_size = sizeof(AVFrame);
2055
2056                         if(!s->lossless){
2057                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2058                             picture->qstride= 0;
2059                             picture->qscale_table= s->qscale_table;
2060                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2061                             if(avctx->debug & FF_DEBUG_QP)
2062                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2063                             picture->quality*= FF_QP2LAMBDA;
2064                         }
2065
2066                         goto the_end;
2067                     }
2068                     break;
2069                 case SOS:
2070                     mjpeg_decode_sos(s);
2071                     /* buggy avid puts EOI every 10-20th frame */
2072                     /* if restart period is over process EOI */
2073                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2074                         goto eoi_parser;
2075                     break;
2076                 case DRI:
2077                     mjpeg_decode_dri(s);
2078                     break;
2079                 case SOF1:
2080                 case SOF2:
2081                 case SOF5:
2082                 case SOF6:
2083                 case SOF7:
2084                 case SOF9:
2085                 case SOF10:
2086                 case SOF11:
2087                 case SOF13:
2088                 case SOF14:
2089                 case SOF15:
2090                 case JPG:
2091                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2092                     break;
2093 //                default:
2094 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2095 //                    break;
2096                 }
2097
2098 not_the_end:
2099                 /* eof process start code */
2100                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2101                 dprintf("marker parser used %d bytes (%d bits)\n",
2102                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2103             }
2104         }
2105     }
2106 the_end:
2107     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2108 //    return buf_end - buf_ptr;
2109     return buf_ptr - buf;
2110 }
2111
2112 static int mjpegb_decode_frame(AVCodecContext *avctx,
2113                               void *data, int *data_size,
2114                               uint8_t *buf, int buf_size)
2115 {
2116     MJpegDecodeContext *s = avctx->priv_data;
2117     uint8_t *buf_end, *buf_ptr;
2118     AVFrame *picture = data;
2119     GetBitContext hgb; /* for the header */
2120     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2121     uint32_t field_size, sod_offs;
2122
2123     buf_ptr = buf;
2124     buf_end = buf + buf_size;
2125
2126 read_header:
2127     /* reset on every SOI */
2128     s->restart_interval = 0;
2129     s->restart_count = 0;
2130     s->mjpb_skiptosod = 0;
2131
2132     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2133
2134     skip_bits(&hgb, 32); /* reserved zeros */
2135
2136     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2137     {
2138         dprintf("not mjpeg-b (bad fourcc)\n");
2139         return 0;
2140     }
2141
2142     field_size = get_bits_long(&hgb, 32); /* field size */
2143     dprintf("field size: 0x%x\n", field_size);
2144     skip_bits(&hgb, 32); /* padded field size */
2145     second_field_offs = get_bits_long(&hgb, 32);
2146     dprintf("second field offs: 0x%x\n", second_field_offs);
2147     if (second_field_offs)
2148         s->interlaced = 1;
2149
2150     dqt_offs = get_bits_long(&hgb, 32);
2151     dprintf("dqt offs: 0x%x\n", dqt_offs);
2152     if (dqt_offs)
2153     {
2154         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2155         s->start_code = DQT;
2156         mjpeg_decode_dqt(s);
2157     }
2158
2159     dht_offs = get_bits_long(&hgb, 32);
2160     dprintf("dht offs: 0x%x\n", dht_offs);
2161     if (dht_offs)
2162     {
2163         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2164         s->start_code = DHT;
2165         mjpeg_decode_dht(s);
2166     }
2167
2168     sof_offs = get_bits_long(&hgb, 32);
2169     dprintf("sof offs: 0x%x\n", sof_offs);
2170     if (sof_offs)
2171     {
2172         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2173         s->start_code = SOF0;
2174         if (mjpeg_decode_sof(s) < 0)
2175             return -1;
2176     }
2177
2178     sos_offs = get_bits_long(&hgb, 32);
2179     dprintf("sos offs: 0x%x\n", sos_offs);
2180     sod_offs = get_bits_long(&hgb, 32);
2181     dprintf("sod offs: 0x%x\n", sod_offs);
2182     if (sos_offs)
2183     {
2184 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2185         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2186         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2187         s->start_code = SOS;
2188         mjpeg_decode_sos(s);
2189     }
2190
2191     if (s->interlaced) {
2192         s->bottom_field ^= 1;
2193         /* if not bottom field, do not output image yet */
2194         if (s->bottom_field && second_field_offs)
2195         {
2196             buf_ptr = buf + second_field_offs;
2197             second_field_offs = 0;
2198             goto read_header;
2199             }
2200     }
2201
2202     //XXX FIXME factorize, this looks very similar to the EOI code
2203
2204     *picture= s->picture;
2205     *data_size = sizeof(AVFrame);
2206
2207     if(!s->lossless){
2208         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2209         picture->qstride= 0;
2210         picture->qscale_table= s->qscale_table;
2211         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2212         if(avctx->debug & FF_DEBUG_QP)
2213             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2214         picture->quality*= FF_QP2LAMBDA;
2215     }
2216
2217     return buf_ptr - buf;
2218 }
2219
2220 #include "sp5x.h"
2221
2222 static int sp5x_decode_frame(AVCodecContext *avctx,
2223                               void *data, int *data_size,
2224                               uint8_t *buf, int buf_size)
2225 {
2226 #if 0
2227     MJpegDecodeContext *s = avctx->priv_data;
2228 #endif
2229     const int qscale = 5;
2230     uint8_t *buf_ptr, *buf_end, *recoded;
2231     int i = 0, j = 0;
2232
2233     if (!avctx->width || !avctx->height)
2234         return -1;
2235
2236     buf_ptr = buf;
2237     buf_end = buf + buf_size;
2238
2239 #if 1
2240     recoded = av_mallocz(buf_size + 1024);
2241     if (!recoded)
2242         return -1;
2243
2244     /* SOI */
2245     recoded[j++] = 0xFF;
2246     recoded[j++] = 0xD8;
2247
2248     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2249     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2250     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2251     j += sizeof(sp5x_data_dqt);
2252
2253     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2254     j += sizeof(sp5x_data_dht);
2255
2256     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2257     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2258     recoded[j+6] = avctx->coded_height & 0xFF;
2259     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2260     recoded[j+8] = avctx->coded_width & 0xFF;
2261     j += sizeof(sp5x_data_sof);
2262
2263     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2264     j += sizeof(sp5x_data_sos);
2265
2266     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2267     {
2268         recoded[j++] = buf[i];
2269         if (buf[i] == 0xff)
2270             recoded[j++] = 0;
2271     }
2272
2273     /* EOI */
2274     recoded[j++] = 0xFF;
2275     recoded[j++] = 0xD9;
2276
2277     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2278
2279     av_free(recoded);
2280
2281 #else
2282     /* SOF */
2283     s->bits = 8;
2284     s->width  = avctx->coded_width;
2285     s->height = avctx->coded_height;
2286     s->nb_components = 3;
2287     s->component_id[0] = 0;
2288     s->h_count[0] = 2;
2289     s->v_count[0] = 2;
2290     s->quant_index[0] = 0;
2291     s->component_id[1] = 1;
2292     s->h_count[1] = 1;
2293     s->v_count[1] = 1;
2294     s->quant_index[1] = 1;
2295     s->component_id[2] = 2;
2296     s->h_count[2] = 1;
2297     s->v_count[2] = 1;
2298     s->quant_index[2] = 1;
2299     s->h_max = 2;
2300     s->v_max = 2;
2301
2302     s->qscale_table = av_mallocz((s->width+15)/16);
2303     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2304     s->interlaced = 0;
2305
2306     s->picture.reference = 0;
2307     if (avctx->get_buffer(avctx, &s->picture) < 0)
2308     {
2309         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2310         return -1;
2311     }
2312
2313     s->picture.pict_type = I_TYPE;
2314     s->picture.key_frame = 1;
2315
2316     for (i = 0; i < 3; i++)
2317         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2318
2319     /* DQT */
2320     for (i = 0; i < 64; i++)
2321     {
2322         j = s->scantable.permutated[i];
2323         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2324     }
2325     s->qscale[0] = FFMAX(
2326         s->quant_matrixes[0][s->scantable.permutated[1]],
2327         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2328
2329     for (i = 0; i < 64; i++)
2330     {
2331         j = s->scantable.permutated[i];
2332         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2333     }
2334     s->qscale[1] = FFMAX(
2335         s->quant_matrixes[1][s->scantable.permutated[1]],
2336         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2337
2338     /* DHT */
2339
2340     /* SOS */
2341     s->comp_index[0] = 0;
2342     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2343     s->h_scount[0] = s->h_count[0];
2344     s->v_scount[0] = s->v_count[0];
2345     s->dc_index[0] = 0;
2346     s->ac_index[0] = 0;
2347
2348     s->comp_index[1] = 1;
2349     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2350     s->h_scount[1] = s->h_count[1];
2351     s->v_scount[1] = s->v_count[1];
2352     s->dc_index[1] = 1;
2353     s->ac_index[1] = 1;
2354
2355     s->comp_index[2] = 2;
2356     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2357     s->h_scount[2] = s->h_count[2];
2358     s->v_scount[2] = s->v_count[2];
2359     s->dc_index[2] = 1;
2360     s->ac_index[2] = 1;
2361
2362     for (i = 0; i < 3; i++)
2363         s->last_dc[i] = 1024;
2364
2365     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2366     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2367
2368     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2369
2370     return mjpeg_decode_scan(s);
2371 #endif
2372
2373     return i;
2374 }
2375
2376 static int mjpeg_decode_end(AVCodecContext *avctx)
2377 {
2378     MJpegDecodeContext *s = avctx->priv_data;
2379     int i, j;
2380
2381     av_free(s->buffer);
2382     av_free(s->qscale_table);
2383
2384     for(i=0;i<2;i++) {
2385         for(j=0;j<4;j++)
2386             free_vlc(&s->vlcs[i][j]);
2387     }
2388     return 0;
2389 }
2390
2391 AVCodec mjpeg_decoder = {
2392     "mjpeg",
2393     CODEC_TYPE_VIDEO,
2394     CODEC_ID_MJPEG,
2395     sizeof(MJpegDecodeContext),
2396     mjpeg_decode_init,
2397     NULL,
2398     mjpeg_decode_end,
2399     mjpeg_decode_frame,
2400     CODEC_CAP_DR1,
2401     NULL
2402 };
2403
2404 AVCodec mjpegb_decoder = {
2405     "mjpegb",
2406     CODEC_TYPE_VIDEO,
2407     CODEC_ID_MJPEGB,
2408     sizeof(MJpegDecodeContext),
2409     mjpeg_decode_init,
2410     NULL,
2411     mjpeg_decode_end,
2412     mjpegb_decode_frame,
2413     CODEC_CAP_DR1,
2414     NULL
2415 };
2416
2417 AVCodec sp5x_decoder = {
2418     "sp5x",
2419     CODEC_TYPE_VIDEO,
2420     CODEC_ID_SP5X,
2421     sizeof(MJpegDecodeContext),
2422     mjpeg_decode_init,
2423     NULL,
2424     mjpeg_decode_end,
2425     sp5x_decode_frame,
2426     CODEC_CAP_DR1,
2427     NULL
2428 };
2429
2430 #ifdef CONFIG_ENCODERS
2431 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2432     "ljpeg",
2433     CODEC_TYPE_VIDEO,
2434     CODEC_ID_LJPEG,
2435     sizeof(MpegEncContext),
2436     MPV_encode_init,
2437     encode_picture_lossless,
2438     MPV_encode_end,
2439 };
2440 #endif
2441
2442 AVCodecParser mjpeg_parser = {
2443     { CODEC_ID_MJPEG },
2444     sizeof(ParseContext),
2445     NULL,
2446     jpeg_parse,
2447     ff_parse_close,
2448 };
2449