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