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