fix some signedness warnings
[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
1263     /* DC coef */
1264     val = mjpeg_decode_dc(s, dc_index);
1265     if (val == 0xffff) {
1266         dprintf("error dc\n");
1267         return -1;
1268     }
1269     val = val * quant_matrix[0] + s->last_dc[component];
1270     s->last_dc[component] = val;
1271     block[0] = val;
1272     /* AC coefs */
1273     i = 0;
1274     {OPEN_READER(re, &s->gb)
1275     for(;;) {
1276         UPDATE_CACHE(re, &s->gb);
1277         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1278
1279         /* EOB */
1280         if (code == 0x10)
1281             break;
1282         i += ((unsigned)code) >> 4;
1283         if(code != 0x100){
1284             code &= 0xf;
1285             if(code > MIN_CACHE_BITS - 16){
1286                 UPDATE_CACHE(re, &s->gb)
1287             }
1288             {
1289                 int cache=GET_CACHE(re,&s->gb);
1290                 int sign=(~cache)>>31;
1291                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1292             }
1293
1294             LAST_SKIP_BITS(re, &s->gb, code)
1295
1296             if (i >= 63) {
1297                 if(i == 63){
1298                     j = s->scantable.permutated[63];
1299                     block[j] = level * quant_matrix[j];
1300                     break;
1301                 }
1302                 dprintf("error count: %d\n", i);
1303                 return -1;
1304             }
1305             j = s->scantable.permutated[i];
1306             block[j] = level * quant_matrix[j];
1307         }
1308     }
1309     CLOSE_READER(re, &s->gb)}
1310
1311     return 0;
1312 }
1313
1314 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1315     int i, mb_x, mb_y;
1316     uint16_t buffer[32768][4];
1317     int left[3], top[3], topleft[3];
1318     const int linesize= s->linesize[0];
1319     const int mask= (1<<s->bits)-1;
1320
1321     if((unsigned)s->mb_width > 32768) //dynamic alloc
1322         return -1;
1323
1324     for(i=0; i<3; i++){
1325         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1326     }
1327     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1328         const int modified_predictor= mb_y ? predictor : 1;
1329         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1330
1331         if (s->interlaced && s->bottom_field)
1332             ptr += linesize >> 1;
1333
1334         for(i=0; i<3; i++){
1335             top[i]= left[i]= topleft[i]= buffer[0][i];
1336         }
1337         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1338             if (s->restart_interval && !s->restart_count)
1339                 s->restart_count = s->restart_interval;
1340
1341             for(i=0;i<3;i++) {
1342                 int pred;
1343
1344                 topleft[i]= top[i];
1345                 top[i]= buffer[mb_x][i];
1346
1347                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1348
1349                 left[i]=
1350                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1351             }
1352
1353             if (s->restart_interval && !--s->restart_count) {
1354                 align_get_bits(&s->gb);
1355                 skip_bits(&s->gb, 16); /* skip RSTn */
1356             }
1357         }
1358
1359         if(s->rct){
1360             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1361                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1362                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1363                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1364             }
1365         }else if(s->pegasus_rct){
1366             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1367                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1368                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1369                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1370             }
1371         }else{
1372             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1373                 ptr[4*mb_x+0] = buffer[mb_x][0];
1374                 ptr[4*mb_x+1] = buffer[mb_x][1];
1375                 ptr[4*mb_x+2] = buffer[mb_x][2];
1376             }
1377         }
1378     }
1379     return 0;
1380 }
1381
1382 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1383     int i, mb_x, mb_y;
1384     const int nb_components=3;
1385
1386     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1387         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1388             if (s->restart_interval && !s->restart_count)
1389                 s->restart_count = s->restart_interval;
1390
1391             if(mb_x==0 || mb_y==0 || s->interlaced){
1392                 for(i=0;i<nb_components;i++) {
1393                     uint8_t *ptr;
1394                     int n, h, v, x, y, c, j, linesize;
1395                     n = s->nb_blocks[i];
1396                     c = s->comp_index[i];
1397                     h = s->h_scount[i];
1398                     v = s->v_scount[i];
1399                     x = 0;
1400                     y = 0;
1401                     linesize= s->linesize[c];
1402
1403                     for(j=0; j<n; j++) {
1404                         int pred;
1405
1406                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1407                         if(y==0 && mb_y==0){
1408                             if(x==0 && mb_x==0){
1409                                 pred= 128 << point_transform;
1410                             }else{
1411                                 pred= ptr[-1];
1412                             }
1413                         }else{
1414                             if(x==0 && mb_x==0){
1415                                 pred= ptr[-linesize];
1416                             }else{
1417                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1418                             }
1419                         }
1420
1421                         if (s->interlaced && s->bottom_field)
1422                             ptr += linesize >> 1;
1423                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1424
1425                         if (++x == h) {
1426                             x = 0;
1427                             y++;
1428                         }
1429                     }
1430                 }
1431             }else{
1432                 for(i=0;i<nb_components;i++) {
1433                     uint8_t *ptr;
1434                     int n, h, v, x, y, c, j, linesize;
1435                     n = s->nb_blocks[i];
1436                     c = s->comp_index[i];
1437                     h = s->h_scount[i];
1438                     v = s->v_scount[i];
1439                     x = 0;
1440                     y = 0;
1441                     linesize= s->linesize[c];
1442
1443                     for(j=0; j<n; j++) {
1444                         int pred;
1445
1446                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1447                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1448                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1449                         if (++x == h) {
1450                             x = 0;
1451                             y++;
1452                         }
1453                     }
1454                 }
1455             }
1456             if (s->restart_interval && !--s->restart_count) {
1457                 align_get_bits(&s->gb);
1458                 skip_bits(&s->gb, 16); /* skip RSTn */
1459             }
1460         }
1461     }
1462     return 0;
1463 }
1464
1465 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1466     int i, mb_x, mb_y;
1467     const int nb_components=3;
1468
1469     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1470         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1471             if (s->restart_interval && !s->restart_count)
1472                 s->restart_count = s->restart_interval;
1473
1474             for(i=0;i<nb_components;i++) {
1475                 uint8_t *ptr;
1476                 int n, h, v, x, y, c, j;
1477                 n = s->nb_blocks[i];
1478                 c = s->comp_index[i];
1479                 h = s->h_scount[i];
1480                 v = s->v_scount[i];
1481                 x = 0;
1482                 y = 0;
1483                 for(j=0;j<n;j++) {
1484                     memset(s->block, 0, sizeof(s->block));
1485                     if (decode_block(s, s->block, i,
1486                                      s->dc_index[i], s->ac_index[i],
1487                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1488                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1489                         return -1;
1490                     }
1491 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1492                     ptr = s->picture.data[c] +
1493                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1494                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1495                     if (s->interlaced && s->bottom_field)
1496                         ptr += s->linesize[c] >> 1;
1497 //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);
1498                     s->idct_put(ptr, s->linesize[c], s->block);
1499                     if (++x == h) {
1500                         x = 0;
1501                         y++;
1502                     }
1503                 }
1504             }
1505             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1506             if (s->restart_interval && (s->restart_interval < 1350) &&
1507                 !--s->restart_count) {
1508                 align_get_bits(&s->gb);
1509                 skip_bits(&s->gb, 16); /* skip RSTn */
1510                 for (i=0; i<nb_components; i++) /* reset dc */
1511                     s->last_dc[i] = 1024;
1512             }
1513         }
1514     }
1515     return 0;
1516 }
1517
1518 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1519 {
1520     int len, nb_components, i, h, v, predictor, point_transform;
1521     int vmax, hmax, index, id;
1522     const int block_size= s->lossless ? 1 : 8;
1523     int ilv;
1524
1525     /* XXX: verify len field validity */
1526     len = get_bits(&s->gb, 16);
1527     nb_components = get_bits(&s->gb, 8);
1528     if (len != 6+2*nb_components)
1529     {
1530         dprintf("decode_sos: invalid len (%d)\n", len);
1531         return -1;
1532     }
1533     /* XXX: only interleaved scan accepted */
1534     if ((nb_components != s->nb_components) && !s->ls)
1535     {
1536         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1537         return -1;
1538     }
1539     vmax = 0;
1540     hmax = 0;
1541     for(i=0;i<nb_components;i++) {
1542         id = get_bits(&s->gb, 8) - 1;
1543         dprintf("component: %d\n", id);
1544         /* find component index */
1545         for(index=0;index<s->nb_components;index++)
1546             if (id == s->component_id[index])
1547                 break;
1548         if (index == s->nb_components)
1549         {
1550             dprintf("decode_sos: index(%d) out of components\n", index);
1551             return -1;
1552         }
1553
1554         s->comp_index[i] = index;
1555
1556         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1557         s->h_scount[i] = s->h_count[index];
1558         s->v_scount[i] = s->v_count[index];
1559
1560         s->dc_index[i] = get_bits(&s->gb, 4);
1561         s->ac_index[i] = get_bits(&s->gb, 4);
1562
1563         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1564             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1565             goto out_of_range;
1566 #if 0 //buggy
1567         switch(s->start_code)
1568         {
1569             case SOF0:
1570                 if (dc_index[i] > 1 || ac_index[i] > 1)
1571                     goto out_of_range;
1572                 break;
1573             case SOF1:
1574             case SOF2:
1575                 if (dc_index[i] > 3 || ac_index[i] > 3)
1576                     goto out_of_range;
1577                 break;
1578             case SOF3:
1579                 if (dc_index[i] > 3 || ac_index[i] != 0)
1580                     goto out_of_range;
1581                 break;
1582         }
1583 #endif
1584     }
1585
1586     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1587     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1588     skip_bits(&s->gb, 4); /* Ah */
1589     point_transform= get_bits(&s->gb, 4); /* Al */
1590
1591     for(i=0;i<nb_components;i++)
1592         s->last_dc[i] = 1024;
1593
1594     if (nb_components > 1) {
1595         /* interleaved stream */
1596         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1597         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1598     } else if(!s->ls) { /* skip this for JPEG-LS */
1599         h = s->h_max / s->h_scount[s->comp_index[0]];
1600         v = s->v_max / s->v_scount[s->comp_index[0]];
1601         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1602         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1603         s->nb_blocks[0] = 1;
1604         s->h_scount[0] = 1;
1605         s->v_scount[0] = 1;
1606     }
1607
1608     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1609         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" : "",
1610                predictor, point_transform, ilv, s->bits,
1611                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1612
1613
1614     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1615     for (i = s->mjpb_skiptosod; i > 0; i--)
1616         skip_bits(&s->gb, 8);
1617
1618     if(s->lossless){
1619         if(s->ls){
1620 //            for(){
1621 //            reset_ls_coding_parameters(s, 0);
1622
1623             ls_decode_picture(s, predictor, point_transform, ilv);
1624         }else{
1625             if(s->rgb){
1626                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1627                     return -1;
1628             }else{
1629                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1630                     return -1;
1631             }
1632         }
1633     }else{
1634         if(mjpeg_decode_scan(s) < 0)
1635             return -1;
1636     }
1637     emms_c();
1638     return 0;
1639  out_of_range:
1640     dprintf("decode_sos: ac/dc index out of range\n");
1641     return -1;
1642 }
1643
1644 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1645 {
1646     if (get_bits(&s->gb, 16) != 4)
1647         return -1;
1648     s->restart_interval = get_bits(&s->gb, 16);
1649     s->restart_count = 0;
1650     dprintf("restart interval: %d\n", s->restart_interval);
1651
1652     return 0;
1653 }
1654
1655 static int mjpeg_decode_app(MJpegDecodeContext *s)
1656 {
1657     int len, id;
1658
1659     len = get_bits(&s->gb, 16);
1660     if (len < 5)
1661         return -1;
1662     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1663         return -1;
1664
1665     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1666     id = be2me_32(id);
1667     len -= 6;
1668
1669     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1670         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1671     }
1672
1673     /* buggy AVID, it puts EOI only at every 10th frame */
1674     /* also this fourcc is used by non-avid files too, it holds some
1675        informations, but it's always present in AVID creates files */
1676     if (id == ff_get_fourcc("AVI1"))
1677     {
1678         /* structure:
1679             4bytes      AVI1
1680             1bytes      polarity
1681             1bytes      always zero
1682             4bytes      field_size
1683             4bytes      field_size_less_padding
1684         */
1685             s->buggy_avid = 1;
1686 //        if (s->first_picture)
1687 //            printf("mjpeg: workarounding buggy AVID\n");
1688         s->interlace_polarity = get_bits(&s->gb, 8);
1689 #if 0
1690         skip_bits(&s->gb, 8);
1691         skip_bits(&s->gb, 32);
1692         skip_bits(&s->gb, 32);
1693         len -= 10;
1694 #endif
1695 //        if (s->interlace_polarity)
1696 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1697         goto out;
1698     }
1699
1700 //    len -= 2;
1701
1702     if (id == ff_get_fourcc("JFIF"))
1703     {
1704         int t_w, t_h, v1, v2;
1705         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1706         v1= get_bits(&s->gb, 8);
1707         v2= get_bits(&s->gb, 8);
1708         skip_bits(&s->gb, 8);
1709
1710         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1711         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1712
1713         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1715                 v1, v2,
1716                 s->avctx->sample_aspect_ratio.num,
1717                 s->avctx->sample_aspect_ratio.den
1718             );
1719
1720         t_w = get_bits(&s->gb, 8);
1721         t_h = get_bits(&s->gb, 8);
1722         if (t_w && t_h)
1723         {
1724             /* skip thumbnail */
1725             if (len-10-(t_w*t_h*3) > 0)
1726                 len -= t_w*t_h*3;
1727         }
1728         len -= 10;
1729         goto out;
1730     }
1731
1732     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1733     {
1734         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1735             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1736         skip_bits(&s->gb, 16); /* version */
1737         skip_bits(&s->gb, 16); /* flags0 */
1738         skip_bits(&s->gb, 16); /* flags1 */
1739         skip_bits(&s->gb, 8);  /* transform */
1740         len -= 7;
1741         goto out;
1742     }
1743
1744     if (id == ff_get_fourcc("LJIF")){
1745         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1746             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1747         skip_bits(&s->gb, 16); /* version ? */
1748         skip_bits(&s->gb, 16); /* unknwon always 0? */
1749         skip_bits(&s->gb, 16); /* unknwon always 0? */
1750         skip_bits(&s->gb, 16); /* unknwon always 0? */
1751         switch( get_bits(&s->gb, 8)){
1752         case 1:
1753             s->rgb= 1;
1754             s->pegasus_rct=0;
1755             break;
1756         case 2:
1757             s->rgb= 1;
1758             s->pegasus_rct=1;
1759             break;
1760         default:
1761             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1762         }
1763         len -= 9;
1764         goto out;
1765     }
1766
1767     /* Apple MJPEG-A */
1768     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1769     {
1770         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1771         id = be2me_32(id);
1772         len -= 4;
1773         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1774         {
1775 #if 0
1776             skip_bits(&s->gb, 32); /* field size */
1777             skip_bits(&s->gb, 32); /* pad field size */
1778             skip_bits(&s->gb, 32); /* next off */
1779             skip_bits(&s->gb, 32); /* quant off */
1780             skip_bits(&s->gb, 32); /* huff off */
1781             skip_bits(&s->gb, 32); /* image off */
1782             skip_bits(&s->gb, 32); /* scan off */
1783             skip_bits(&s->gb, 32); /* data off */
1784 #endif
1785             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1786                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1787         }
1788     }
1789
1790 out:
1791     /* slow but needed for extreme adobe jpegs */
1792     if (len < 0)
1793         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1794     while(--len > 0)
1795         skip_bits(&s->gb, 8);
1796
1797     return 0;
1798 }
1799
1800 static int mjpeg_decode_com(MJpegDecodeContext *s)
1801 {
1802     int len = get_bits(&s->gb, 16);
1803     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1804         char *cbuf = av_malloc(len - 1);
1805         if (cbuf) {
1806             int i;
1807             for (i = 0; i < len - 2; i++)
1808                 cbuf[i] = get_bits(&s->gb, 8);
1809             if (i > 0 && cbuf[i-1] == '\n')
1810                 cbuf[i-1] = 0;
1811             else
1812                 cbuf[i] = 0;
1813
1814             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1815                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1816
1817             /* buggy avid, it puts EOI only at every 10th frame */
1818             if (!strcmp(cbuf, "AVID"))
1819             {
1820                 s->buggy_avid = 1;
1821                 //        if (s->first_picture)
1822                 //            printf("mjpeg: workarounding buggy AVID\n");
1823             }
1824             else if(!strcmp(cbuf, "CS=ITU601")){
1825                 s->cs_itu601= 1;
1826             }
1827
1828             av_free(cbuf);
1829         }
1830     }
1831
1832     return 0;
1833 }
1834
1835 #if 0
1836 static int valid_marker_list[] =
1837 {
1838         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1839 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1840 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1841 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1842 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1843 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1852 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1853 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1854 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1855 }
1856 #endif
1857
1858 /* return the 8 bit start code value and update the search
1859    state. Return -1 if no start code found */
1860 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1861 {
1862     uint8_t *buf_ptr;
1863     unsigned int v, v2;
1864     int val;
1865 #ifdef DEBUG
1866     int skipped=0;
1867 #endif
1868
1869     buf_ptr = *pbuf_ptr;
1870     while (buf_ptr < buf_end) {
1871         v = *buf_ptr++;
1872         v2 = *buf_ptr;
1873         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1874             val = *buf_ptr++;
1875             goto found;
1876         }
1877 #ifdef DEBUG
1878         skipped++;
1879 #endif
1880     }
1881     val = -1;
1882 found:
1883 #ifdef DEBUG
1884     dprintf("find_marker skipped %d bytes\n", skipped);
1885 #endif
1886     *pbuf_ptr = buf_ptr;
1887     return val;
1888 }
1889
1890 static int mjpeg_decode_frame(AVCodecContext *avctx,
1891                               void *data, int *data_size,
1892                               uint8_t *buf, int buf_size)
1893 {
1894     MJpegDecodeContext *s = avctx->priv_data;
1895     uint8_t *buf_end, *buf_ptr;
1896     int start_code;
1897     AVFrame *picture = data;
1898
1899     buf_ptr = buf;
1900     buf_end = buf + buf_size;
1901     while (buf_ptr < buf_end) {
1902         /* find start next marker */
1903         start_code = find_marker(&buf_ptr, buf_end);
1904         {
1905             /* EOF */
1906             if (start_code < 0) {
1907                 goto the_end;
1908             } else {
1909                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1910
1911                 if ((buf_end - buf_ptr) > s->buffer_size)
1912                 {
1913                     av_free(s->buffer);
1914                     s->buffer_size = buf_end-buf_ptr;
1915                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1916                     dprintf("buffer too small, expanding to %d bytes\n",
1917                         s->buffer_size);
1918                 }
1919
1920                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1921                 if (start_code == SOS && !s->ls)
1922                 {
1923                     uint8_t *src = buf_ptr;
1924                     uint8_t *dst = s->buffer;
1925
1926                     while (src<buf_end)
1927                     {
1928                         uint8_t x = *(src++);
1929
1930                         *(dst++) = x;
1931                         if (x == 0xff)
1932                         {
1933                             while(src<buf_end && x == 0xff)
1934                                 x = *(src++);
1935
1936                             if (x >= 0xd0 && x <= 0xd7)
1937                                 *(dst++) = x;
1938                             else if (x)
1939                                 break;
1940                         }
1941                     }
1942                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1943
1944                     dprintf("escaping removed %d bytes\n",
1945                         (buf_end - buf_ptr) - (dst - s->buffer));
1946                 }
1947                 else if(start_code == SOS && s->ls){
1948                     uint8_t *src = buf_ptr;
1949                     uint8_t *dst = s->buffer;
1950                     int bit_count = 0;
1951                     int t = 0, b = 0;
1952                     PutBitContext pb;
1953
1954                     s->cur_scan++;
1955
1956                     /* find marker */
1957                     while (src + t < buf_end){
1958                         uint8_t x = src[t++];
1959                         if (x == 0xff){
1960                             while((src + t < buf_end) && x == 0xff)
1961                                 x = src[t++];
1962                             if (x & 0x80) {
1963                                 t -= 2;
1964                                 break;
1965                             }
1966                         }
1967                     }
1968                     bit_count = t * 8;
1969
1970                     init_put_bits(&pb, dst, t);
1971
1972                     /* unescape bitstream */
1973                     while(b < t){
1974                         uint8_t x = src[b++];
1975                         put_bits(&pb, 8, x);
1976                         if(x == 0xFF){
1977                             x = src[b++];
1978                             put_bits(&pb, 7, x);
1979                             bit_count--;
1980                         }
1981                     }
1982                     flush_put_bits(&pb);
1983
1984                     init_get_bits(&s->gb, dst, bit_count);
1985                 }
1986                 else
1987                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1988
1989                 s->start_code = start_code;
1990                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1991                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1992                 }
1993
1994                 /* process markers */
1995                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1996                     dprintf("restart marker: %d\n", start_code&0x0f);
1997                     /* APP fields */
1998                 } else if (start_code >= APP0 && start_code <= APP15) {
1999                     mjpeg_decode_app(s);
2000                     /* Comment */
2001                 } else if (start_code == COM){
2002                     mjpeg_decode_com(s);
2003                 }
2004
2005                 switch(start_code) {
2006                 case SOI:
2007                     s->restart_interval = 0;
2008
2009                     s->restart_count = 0;
2010                     /* nothing to do on SOI */
2011                     break;
2012                 case DQT:
2013                     mjpeg_decode_dqt(s);
2014                     break;
2015                 case DHT:
2016                     if(mjpeg_decode_dht(s) < 0){
2017                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2018                         return -1;
2019                     }
2020                     break;
2021                 case SOF0:
2022                     s->lossless=0;
2023                     if (mjpeg_decode_sof(s) < 0)
2024                         return -1;
2025                     break;
2026                 case SOF3:
2027                     s->lossless=1;
2028                     if (mjpeg_decode_sof(s) < 0)
2029                         return -1;
2030                     break;
2031                 case SOF48:
2032                     s->lossless=1;
2033                     s->ls=1;
2034                     if (mjpeg_decode_sof(s) < 0)
2035                         return -1;
2036                     break;
2037                 case LSE:
2038                     if (decode_lse(s) < 0)
2039                         return -1;
2040                     break;
2041                 case EOI:
2042                     s->cur_scan = 0;
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