Change license headers to say 'FFmpeg' instead of 'this program/this library'
[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 file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  * Support for external huffman table, various fixes (AVID workaround),
24  * aspecting, new decode_frame mechanism and apple mjpeg-b support
25  *                                  by Alex Beregszaszi <alex@naxine.org>
26  */
27
28 /**
29  * @file mjpeg.c
30  * MJPEG encoder and decoder.
31  */
32
33 //#define DEBUG
34 #include <assert.h>
35
36 #include "avcodec.h"
37 #include "dsputil.h"
38 #include "mpegvideo.h"
39
40 /* use two quantizer tables (one for luminance and one for chrominance) */
41 /* not yet working */
42 #undef TWOMATRIXES
43
44 typedef struct MJpegContext {
45     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
46     uint16_t huff_code_dc_luminance[12];
47     uint8_t huff_size_dc_chrominance[12];
48     uint16_t huff_code_dc_chrominance[12];
49
50     uint8_t huff_size_ac_luminance[256];
51     uint16_t huff_code_ac_luminance[256];
52     uint8_t huff_size_ac_chrominance[256];
53     uint16_t huff_code_ac_chrominance[256];
54 } MJpegContext;
55
56 /* JPEG marker codes */
57 typedef enum {
58     /* start of frame */
59     SOF0  = 0xc0,       /* baseline */
60     SOF1  = 0xc1,       /* extended sequential, huffman */
61     SOF2  = 0xc2,       /* progressive, huffman */
62     SOF3  = 0xc3,       /* lossless, huffman */
63
64     SOF5  = 0xc5,       /* differential sequential, huffman */
65     SOF6  = 0xc6,       /* differential progressive, huffman */
66     SOF7  = 0xc7,       /* differential lossless, huffman */
67     JPG   = 0xc8,       /* reserved for JPEG extension */
68     SOF9  = 0xc9,       /* extended sequential, arithmetic */
69     SOF10 = 0xca,       /* progressive, arithmetic */
70     SOF11 = 0xcb,       /* lossless, arithmetic */
71
72     SOF13 = 0xcd,       /* differential sequential, arithmetic */
73     SOF14 = 0xce,       /* differential progressive, arithmetic */
74     SOF15 = 0xcf,       /* differential lossless, arithmetic */
75
76     DHT   = 0xc4,       /* define huffman tables */
77
78     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
79
80     /* restart with modulo 8 count "m" */
81     RST0  = 0xd0,
82     RST1  = 0xd1,
83     RST2  = 0xd2,
84     RST3  = 0xd3,
85     RST4  = 0xd4,
86     RST5  = 0xd5,
87     RST6  = 0xd6,
88     RST7  = 0xd7,
89
90     SOI   = 0xd8,       /* start of image */
91     EOI   = 0xd9,       /* end of image */
92     SOS   = 0xda,       /* start of scan */
93     DQT   = 0xdb,       /* define quantization tables */
94     DNL   = 0xdc,       /* define number of lines */
95     DRI   = 0xdd,       /* define restart interval */
96     DHP   = 0xde,       /* define hierarchical progression */
97     EXP   = 0xdf,       /* expand reference components */
98
99     APP0  = 0xe0,
100     APP1  = 0xe1,
101     APP2  = 0xe2,
102     APP3  = 0xe3,
103     APP4  = 0xe4,
104     APP5  = 0xe5,
105     APP6  = 0xe6,
106     APP7  = 0xe7,
107     APP8  = 0xe8,
108     APP9  = 0xe9,
109     APP10 = 0xea,
110     APP11 = 0xeb,
111     APP12 = 0xec,
112     APP13 = 0xed,
113     APP14 = 0xee,
114     APP15 = 0xef,
115
116     JPG0  = 0xf0,
117     JPG1  = 0xf1,
118     JPG2  = 0xf2,
119     JPG3  = 0xf3,
120     JPG4  = 0xf4,
121     JPG5  = 0xf5,
122     JPG6  = 0xf6,
123     SOF48 = 0xf7,       ///< JPEG-LS
124     LSE   = 0xf8,       ///< JPEG-LS extension parameters
125     JPG9  = 0xf9,
126     JPG10 = 0xfa,
127     JPG11 = 0xfb,
128     JPG12 = 0xfc,
129     JPG13 = 0xfd,
130
131     COM   = 0xfe,       /* comment */
132
133     TEM   = 0x01,       /* temporary private use for arithmetic coding */
134
135     /* 0x02 -> 0xbf reserved */
136 } JPEG_MARKER;
137
138 #if 0
139 /* These are the sample quantization tables given in JPEG spec section K.1.
140  * The spec says that the values given produce "good" quality, and
141  * when divided by 2, "very good" quality.
142  */
143 static const unsigned char std_luminance_quant_tbl[64] = {
144     16,  11,  10,  16,  24,  40,  51,  61,
145     12,  12,  14,  19,  26,  58,  60,  55,
146     14,  13,  16,  24,  40,  57,  69,  56,
147     14,  17,  22,  29,  51,  87,  80,  62,
148     18,  22,  37,  56,  68, 109, 103,  77,
149     24,  35,  55,  64,  81, 104, 113,  92,
150     49,  64,  78,  87, 103, 121, 120, 101,
151     72,  92,  95,  98, 112, 100, 103,  99
152 };
153 static const unsigned char std_chrominance_quant_tbl[64] = {
154     17,  18,  24,  47,  99,  99,  99,  99,
155     18,  21,  26,  66,  99,  99,  99,  99,
156     24,  26,  56,  99,  99,  99,  99,  99,
157     47,  66,  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     99,  99,  99,  99,  99,  99,  99,  99,
161     99,  99,  99,  99,  99,  99,  99,  99
162 };
163 #endif
164
165 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
166 /* IMPORTANT: these are only valid for 8-bit data precision! */
167 static const uint8_t bits_dc_luminance[17] =
168 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
169 static const uint8_t val_dc_luminance[] =
170 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
171
172 static const uint8_t bits_dc_chrominance[17] =
173 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
174 static const uint8_t val_dc_chrominance[] =
175 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
176
177 static const uint8_t bits_ac_luminance[17] =
178 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
179 static const uint8_t val_ac_luminance[] =
180 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
181   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
182   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
183   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
184   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
185   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
186   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
187   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
188   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
189   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
190   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
191   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
192   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
193   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
194   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
195   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
196   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
197   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
198   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
199   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
200   0xf9, 0xfa
201 };
202
203 static const uint8_t bits_ac_chrominance[17] =
204 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
205
206 static const uint8_t val_ac_chrominance[] =
207 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
208   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
209   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
210   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
211   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
212   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
213   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
214   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
215   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
216   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
217   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
218   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
219   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
220   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
221   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
222   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
223   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
224   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
225   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
226   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
227   0xf9, 0xfa
228 };
229
230 /* isn't this function nicer than the one in the libjpeg ? */
231 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
232                                 const uint8_t *bits_table, const uint8_t *val_table)
233 {
234     int i, j, k,nb, code, sym;
235
236     code = 0;
237     k = 0;
238     for(i=1;i<=16;i++) {
239         nb = bits_table[i];
240         for(j=0;j<nb;j++) {
241             sym = val_table[k++];
242             huff_size[sym] = i;
243             huff_code[sym] = code;
244             code++;
245         }
246         code <<= 1;
247     }
248 }
249
250 #ifdef CONFIG_ENCODERS
251 int mjpeg_init(MpegEncContext *s)
252 {
253     MJpegContext *m;
254
255     m = av_malloc(sizeof(MJpegContext));
256     if (!m)
257         return -1;
258
259     s->min_qcoeff=-1023;
260     s->max_qcoeff= 1023;
261
262     /* build all the huffman tables */
263     build_huffman_codes(m->huff_size_dc_luminance,
264                         m->huff_code_dc_luminance,
265                         bits_dc_luminance,
266                         val_dc_luminance);
267     build_huffman_codes(m->huff_size_dc_chrominance,
268                         m->huff_code_dc_chrominance,
269                         bits_dc_chrominance,
270                         val_dc_chrominance);
271     build_huffman_codes(m->huff_size_ac_luminance,
272                         m->huff_code_ac_luminance,
273                         bits_ac_luminance,
274                         val_ac_luminance);
275     build_huffman_codes(m->huff_size_ac_chrominance,
276                         m->huff_code_ac_chrominance,
277                         bits_ac_chrominance,
278                         val_ac_chrominance);
279
280     s->mjpeg_ctx = m;
281     return 0;
282 }
283
284 void mjpeg_close(MpegEncContext *s)
285 {
286     av_free(s->mjpeg_ctx);
287 }
288 #endif //CONFIG_ENCODERS
289
290 #define PREDICT(ret, topleft, top, left, predictor)\
291     switch(predictor){\
292         case 1: ret= left; break;\
293         case 2: ret= top; break;\
294         case 3: ret= topleft; break;\
295         case 4: ret= left   +   top - topleft; break;\
296         case 5: ret= left   + ((top - topleft)>>1); break;\
297         case 6: ret= top + ((left   - topleft)>>1); break;\
298         default:\
299         case 7: ret= (left + top)>>1; break;\
300     }
301
302 #ifdef CONFIG_ENCODERS
303 static inline void put_marker(PutBitContext *p, int code)
304 {
305     put_bits(p, 8, 0xff);
306     put_bits(p, 8, code);
307 }
308
309 /* table_class: 0 = DC coef, 1 = AC coefs */
310 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
311                              const uint8_t *bits_table, const uint8_t *value_table)
312 {
313     PutBitContext *p = &s->pb;
314     int n, i;
315
316     put_bits(p, 4, table_class);
317     put_bits(p, 4, table_id);
318
319     n = 0;
320     for(i=1;i<=16;i++) {
321         n += bits_table[i];
322         put_bits(p, 8, bits_table[i]);
323     }
324
325     for(i=0;i<n;i++)
326         put_bits(p, 8, value_table[i]);
327
328     return n + 17;
329 }
330
331 static void jpeg_table_header(MpegEncContext *s)
332 {
333     PutBitContext *p = &s->pb;
334     int i, j, size;
335     uint8_t *ptr;
336
337     /* quant matrixes */
338     put_marker(p, DQT);
339 #ifdef TWOMATRIXES
340     put_bits(p, 16, 2 + 2 * (1 + 64));
341 #else
342     put_bits(p, 16, 2 + 1 * (1 + 64));
343 #endif
344     put_bits(p, 4, 0); /* 8 bit precision */
345     put_bits(p, 4, 0); /* table 0 */
346     for(i=0;i<64;i++) {
347         j = s->intra_scantable.permutated[i];
348         put_bits(p, 8, s->intra_matrix[j]);
349     }
350 #ifdef TWOMATRIXES
351     put_bits(p, 4, 0); /* 8 bit precision */
352     put_bits(p, 4, 1); /* table 1 */
353     for(i=0;i<64;i++) {
354         j = s->intra_scantable.permutated[i];
355         put_bits(p, 8, s->chroma_intra_matrix[j]);
356     }
357 #endif
358
359     /* huffman table */
360     put_marker(p, DHT);
361     flush_put_bits(p);
362     ptr = pbBufPtr(p);
363     put_bits(p, 16, 0); /* patched later */
364     size = 2;
365     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
366     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
367
368     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
369     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
370     ptr[0] = size >> 8;
371     ptr[1] = size;
372 }
373
374 static void jpeg_put_comments(MpegEncContext *s)
375 {
376     PutBitContext *p = &s->pb;
377     int size;
378     uint8_t *ptr;
379
380     if (s->aspect_ratio_info /* && !lossless */)
381     {
382     /* JFIF header */
383     put_marker(p, APP0);
384     put_bits(p, 16, 16);
385     ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
386     put_bits(p, 16, 0x0201); /* v 1.02 */
387     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
388     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
389     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
390     put_bits(p, 8, 0); /* thumbnail width */
391     put_bits(p, 8, 0); /* thumbnail height */
392     }
393
394     /* comment */
395     if(!(s->flags & CODEC_FLAG_BITEXACT)){
396         put_marker(p, COM);
397         flush_put_bits(p);
398         ptr = pbBufPtr(p);
399         put_bits(p, 16, 0); /* patched later */
400         ff_put_string(p, LIBAVCODEC_IDENT, 1);
401         size = strlen(LIBAVCODEC_IDENT)+3;
402         ptr[0] = size >> 8;
403         ptr[1] = size;
404     }
405
406     if(  s->avctx->pix_fmt == PIX_FMT_YUV420P
407        ||s->avctx->pix_fmt == PIX_FMT_YUV422P
408        ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
409         put_marker(p, COM);
410         flush_put_bits(p);
411         ptr = pbBufPtr(p);
412         put_bits(p, 16, 0); /* patched later */
413         ff_put_string(p, "CS=ITU601", 1);
414         size = strlen("CS=ITU601")+3;
415         ptr[0] = size >> 8;
416         ptr[1] = size;
417     }
418 }
419
420 void mjpeg_picture_header(MpegEncContext *s)
421 {
422     const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
423     const int ls      = s->avctx->codec_id == CODEC_ID_JPEGLS;
424
425     assert(!(ls && s->mjpeg_write_tables));
426
427     put_marker(&s->pb, SOI);
428
429     if (!s->mjpeg_data_only_frames)
430     {
431     jpeg_put_comments(s);
432
433     if (s->mjpeg_write_tables) jpeg_table_header(s);
434
435     switch(s->avctx->codec_id){
436     case CODEC_ID_MJPEG:  put_marker(&s->pb, SOF0 ); break;
437     case CODEC_ID_LJPEG:  put_marker(&s->pb, SOF3 ); break;
438     case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
439     default: assert(0);
440     }
441
442     put_bits(&s->pb, 16, 17);
443     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
444         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
445     else
446         put_bits(&s->pb, 8, 8); /* 8 bits/component */
447     put_bits(&s->pb, 16, s->height);
448     put_bits(&s->pb, 16, s->width);
449     put_bits(&s->pb, 8, 3); /* 3 components */
450
451     /* Y component */
452     put_bits(&s->pb, 8, 1); /* component number */
453     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
454     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
455     put_bits(&s->pb, 8, 0); /* select matrix */
456
457     /* Cb component */
458     put_bits(&s->pb, 8, 2); /* component number */
459     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
460     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
461 #ifdef TWOMATRIXES
462     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
463 #else
464     put_bits(&s->pb, 8, 0); /* select matrix */
465 #endif
466
467     /* Cr component */
468     put_bits(&s->pb, 8, 3); /* component number */
469     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
470     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
471 #ifdef TWOMATRIXES
472     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
473 #else
474     put_bits(&s->pb, 8, 0); /* select matrix */
475 #endif
476     }
477
478     /* scan header */
479     put_marker(&s->pb, SOS);
480     put_bits(&s->pb, 16, 12); /* length */
481     put_bits(&s->pb, 8, 3); /* 3 components */
482
483     /* Y component */
484     put_bits(&s->pb, 8, 1); /* index */
485     put_bits(&s->pb, 4, 0); /* DC huffman table index */
486     put_bits(&s->pb, 4, 0); /* AC huffman table index */
487
488     /* Cb component */
489     put_bits(&s->pb, 8, 2); /* index */
490     put_bits(&s->pb, 4, 1); /* DC huffman table index */
491     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
492
493     /* Cr component */
494     put_bits(&s->pb, 8, 3); /* index */
495     put_bits(&s->pb, 4, 1); /* DC huffman table index */
496     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
497
498     put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
499
500     switch(s->avctx->codec_id){
501     case CODEC_ID_MJPEG:  put_bits(&s->pb, 8, 63); break; /* Se (not used) */
502     case CODEC_ID_LJPEG:  put_bits(&s->pb, 8,  0); break; /* not used */
503     case CODEC_ID_JPEGLS: put_bits(&s->pb, 8,  1); break; /* ILV = line interleaved */
504     default: assert(0);
505     }
506
507     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
508
509     //FIXME DC/AC entropy table selectors stuff in jpegls
510 }
511
512 static void escape_FF(MpegEncContext *s, int start)
513 {
514     int size= put_bits_count(&s->pb) - start*8;
515     int i, ff_count;
516     uint8_t *buf= s->pb.buf + start;
517     int align= (-(size_t)(buf))&3;
518
519     assert((size&7) == 0);
520     size >>= 3;
521
522     ff_count=0;
523     for(i=0; i<size && i<align; i++){
524         if(buf[i]==0xFF) ff_count++;
525     }
526     for(; i<size-15; i+=16){
527         int acc, v;
528
529         v= *(uint32_t*)(&buf[i]);
530         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
531         v= *(uint32_t*)(&buf[i+4]);
532         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
533         v= *(uint32_t*)(&buf[i+8]);
534         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
535         v= *(uint32_t*)(&buf[i+12]);
536         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
537
538         acc>>=4;
539         acc+= (acc>>16);
540         acc+= (acc>>8);
541         ff_count+= acc&0xFF;
542     }
543     for(; i<size; i++){
544         if(buf[i]==0xFF) ff_count++;
545     }
546
547     if(ff_count==0) return;
548
549     /* skip put bits */
550     for(i=0; i<ff_count-3; i+=4)
551         put_bits(&s->pb, 32, 0);
552     put_bits(&s->pb, (ff_count-i)*8, 0);
553     flush_put_bits(&s->pb);
554
555     for(i=size-1; ff_count; i--){
556         int v= buf[i];
557
558         if(v==0xFF){
559 //printf("%d %d\n", i, ff_count);
560             buf[i+ff_count]= 0;
561             ff_count--;
562         }
563
564         buf[i+ff_count]= v;
565     }
566 }
567
568 void ff_mjpeg_stuffing(PutBitContext * pbc)
569 {
570     int length;
571     length= (-put_bits_count(pbc))&7;
572     if(length) put_bits(pbc, length, (1<<length)-1);
573 }
574
575 void mjpeg_picture_trailer(MpegEncContext *s)
576 {
577     ff_mjpeg_stuffing(&s->pb);
578     flush_put_bits(&s->pb);
579
580     assert((s->header_bits&7)==0);
581
582     escape_FF(s, s->header_bits>>3);
583
584     put_marker(&s->pb, EOI);
585 }
586
587 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
588                                    uint8_t *huff_size, uint16_t *huff_code)
589 {
590     int mant, nbits;
591
592     if (val == 0) {
593         put_bits(&s->pb, huff_size[0], huff_code[0]);
594     } else {
595         mant = val;
596         if (val < 0) {
597             val = -val;
598             mant--;
599         }
600
601         nbits= av_log2_16bit(val) + 1;
602
603         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
604
605         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
606     }
607 }
608
609 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
610 {
611     int mant, nbits, code, i, j;
612     int component, dc, run, last_index, val;
613     MJpegContext *m = s->mjpeg_ctx;
614     uint8_t *huff_size_ac;
615     uint16_t *huff_code_ac;
616
617     /* DC coef */
618     component = (n <= 3 ? 0 : (n&1) + 1);
619     dc = block[0]; /* overflow is impossible */
620     val = dc - s->last_dc[component];
621     if (n < 4) {
622         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
623         huff_size_ac = m->huff_size_ac_luminance;
624         huff_code_ac = m->huff_code_ac_luminance;
625     } else {
626         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
627         huff_size_ac = m->huff_size_ac_chrominance;
628         huff_code_ac = m->huff_code_ac_chrominance;
629     }
630     s->last_dc[component] = dc;
631
632     /* AC coefs */
633
634     run = 0;
635     last_index = s->block_last_index[n];
636     for(i=1;i<=last_index;i++) {
637         j = s->intra_scantable.permutated[i];
638         val = block[j];
639         if (val == 0) {
640             run++;
641         } else {
642             while (run >= 16) {
643                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
644                 run -= 16;
645             }
646             mant = val;
647             if (val < 0) {
648                 val = -val;
649                 mant--;
650             }
651
652             nbits= av_log2(val) + 1;
653             code = (run << 4) | nbits;
654
655             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
656
657             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
658             run = 0;
659         }
660     }
661
662     /* output EOB only if not already 64 values */
663     if (last_index < 63 || run != 0)
664         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
665 }
666
667 void mjpeg_encode_mb(MpegEncContext *s,
668                      DCTELEM block[6][64])
669 {
670     int i;
671     for(i=0;i<5;i++) {
672         encode_block(s, block[i], i);
673     }
674     if (s->chroma_format == CHROMA_420) {
675         encode_block(s, block[5], 5);
676     } else {
677         encode_block(s, block[6], 6);
678         encode_block(s, block[5], 5);
679         encode_block(s, block[7], 7);
680     }
681 }
682
683 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
684     MpegEncContext * const s = avctx->priv_data;
685     MJpegContext * const m = s->mjpeg_ctx;
686     AVFrame *pict = data;
687     const int width= s->width;
688     const int height= s->height;
689     AVFrame * const p= (AVFrame*)&s->current_picture;
690     const int predictor= avctx->prediction_method+1;
691
692     init_put_bits(&s->pb, buf, buf_size);
693
694     *p = *pict;
695     p->pict_type= FF_I_TYPE;
696     p->key_frame= 1;
697
698     mjpeg_picture_header(s);
699
700     s->header_bits= put_bits_count(&s->pb);
701
702     if(avctx->pix_fmt == PIX_FMT_RGBA32){
703         int x, y, i;
704         const int linesize= p->linesize[0];
705         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
706         int left[3], top[3], topleft[3];
707
708         for(i=0; i<3; i++){
709             buffer[0][i]= 1 << (9 - 1);
710         }
711
712         for(y = 0; y < height; y++) {
713             const int modified_predictor= y ? predictor : 1;
714             uint8_t *ptr = p->data[0] + (linesize * y);
715
716             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
717                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
718                 return -1;
719             }
720
721             for(i=0; i<3; i++){
722                 top[i]= left[i]= topleft[i]= buffer[0][i];
723             }
724             for(x = 0; x < width; x++) {
725                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
726                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
727                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
728
729                 for(i=0;i<3;i++) {
730                     int pred, diff;
731
732                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
733
734                     topleft[i]= top[i];
735                     top[i]= buffer[x+1][i];
736
737                     left[i]= buffer[x][i];
738
739                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
740
741                     if(i==0)
742                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
743                     else
744                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
745                 }
746             }
747         }
748     }else{
749         int mb_x, mb_y, i;
750         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
751         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
752
753         for(mb_y = 0; mb_y < mb_height; mb_y++) {
754             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]){
755                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
756                 return -1;
757             }
758             for(mb_x = 0; mb_x < mb_width; mb_x++) {
759                 if(mb_x==0 || mb_y==0){
760                     for(i=0;i<3;i++) {
761                         uint8_t *ptr;
762                         int x, y, h, v, linesize;
763                         h = s->mjpeg_hsample[i];
764                         v = s->mjpeg_vsample[i];
765                         linesize= p->linesize[i];
766
767                         for(y=0; y<v; y++){
768                             for(x=0; x<h; x++){
769                                 int pred;
770
771                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
772                                 if(y==0 && mb_y==0){
773                                     if(x==0 && mb_x==0){
774                                         pred= 128;
775                                     }else{
776                                         pred= ptr[-1];
777                                     }
778                                 }else{
779                                     if(x==0 && mb_x==0){
780                                         pred= ptr[-linesize];
781                                     }else{
782                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
783                                     }
784                                 }
785
786                                 if(i==0)
787                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
788                                 else
789                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
790                             }
791                         }
792                     }
793                 }else{
794                     for(i=0;i<3;i++) {
795                         uint8_t *ptr;
796                         int x, y, h, v, linesize;
797                         h = s->mjpeg_hsample[i];
798                         v = s->mjpeg_vsample[i];
799                         linesize= p->linesize[i];
800
801                         for(y=0; y<v; y++){
802                             for(x=0; x<h; x++){
803                                 int pred;
804
805                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
806 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
807                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
808
809                                 if(i==0)
810                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
811                                 else
812                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
813                             }
814                         }
815                     }
816                 }
817             }
818         }
819     }
820
821     emms_c();
822
823     mjpeg_picture_trailer(s);
824     s->picture_number++;
825
826     flush_put_bits(&s->pb);
827     return pbBufPtr(&s->pb) - s->pb.buf;
828 //    return (put_bits_count(&f->pb)+7)/8;
829 }
830
831 #endif //CONFIG_ENCODERS
832
833 /******************************************/
834 /* decoding */
835
836 #define MAX_COMPONENTS 4
837
838 typedef struct MJpegDecodeContext {
839     AVCodecContext *avctx;
840     GetBitContext gb;
841     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
842
843     int start_code; /* current start code */
844     int buffer_size;
845     uint8_t *buffer;
846
847     int16_t quant_matrixes[4][64];
848     VLC vlcs[2][4];
849     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
850
851     int org_height;  /* size given at codec init */
852     int first_picture;    /* true if decoding first picture */
853     int interlaced;     /* true if interlaced */
854     int bottom_field;   /* true if bottom field */
855     int lossless;
856     int ls;
857     int rgb;
858     int rct;            /* standard rct */
859     int pegasus_rct;    /* pegasus reversible colorspace transform */
860     int bits;           /* bits per component */
861
862     int maxval;
863     int near;         ///< near lossless bound (si 0 for lossless)
864     int t1,t2,t3;
865     int reset;        ///< context halfing intervall ?rename
866
867     int width, height;
868     int mb_width, mb_height;
869     int nb_components;
870     int component_id[MAX_COMPONENTS];
871     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
872     int v_count[MAX_COMPONENTS];
873     int comp_index[MAX_COMPONENTS];
874     int dc_index[MAX_COMPONENTS];
875     int ac_index[MAX_COMPONENTS];
876     int nb_blocks[MAX_COMPONENTS];
877     int h_scount[MAX_COMPONENTS];
878     int v_scount[MAX_COMPONENTS];
879     int h_max, v_max; /* maximum h and v counts */
880     int quant_index[4];   /* quant table index for each component */
881     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
882     AVFrame picture; /* picture structure */
883     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
884     int8_t *qscale_table;
885     DECLARE_ALIGNED_8(DCTELEM, block[64]);
886     ScanTable scantable;
887     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
888
889     int restart_interval;
890     int restart_count;
891
892     int buggy_avid;
893     int cs_itu601;
894     int interlace_polarity;
895
896     int mjpb_skiptosod;
897
898     int cur_scan; /* current scan, used by JPEG-LS */
899 } MJpegDecodeContext;
900
901 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant
902
903 static int mjpeg_decode_dht(MJpegDecodeContext *s);
904
905 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
906                       int nb_codes, int use_static, int is_ac)
907 {
908     uint8_t huff_size[256+16];
909     uint16_t huff_code[256+16];
910
911     assert(nb_codes <= 256);
912
913     memset(huff_size, 0, sizeof(huff_size));
914     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
915
916     if(is_ac){
917         memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
918         memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
919         memset(huff_size, 0, sizeof(uint8_t)*16);
920         memset(huff_code, 0, sizeof(uint16_t)*16);
921         nb_codes += 16;
922     }
923
924     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
925 }
926
927 static int mjpeg_decode_init(AVCodecContext *avctx)
928 {
929     MJpegDecodeContext *s = avctx->priv_data;
930     MpegEncContext s2;
931     memset(s, 0, sizeof(MJpegDecodeContext));
932
933     s->avctx = avctx;
934
935     /* ugly way to get the idct & scantable FIXME */
936     memset(&s2, 0, sizeof(MpegEncContext));
937     s2.avctx= avctx;
938 //    s2->out_format = FMT_MJPEG;
939     dsputil_init(&s2.dsp, avctx);
940     DCT_common_init(&s2);
941
942     s->scantable= s2.intra_scantable;
943     s->idct_put= s2.dsp.idct_put;
944
945     s->mpeg_enc_ctx_allocated = 0;
946     s->buffer_size = 0;
947     s->buffer = NULL;
948     s->start_code = -1;
949     s->first_picture = 1;
950     s->org_height = avctx->coded_height;
951
952     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
953     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
954     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
955     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
956
957     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
958     {
959         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
960         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
961         mjpeg_decode_dht(s);
962         /* should check for error - but dunno */
963     }
964
965     return 0;
966 }
967
968
969 /**
970  * finds the end of the current frame in the bitstream.
971  * @return the position of the first byte of the next frame, or -1
972  */
973 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
974     int vop_found, i;
975     uint16_t state;
976
977     vop_found= pc->frame_start_found;
978     state= pc->state;
979
980     i=0;
981     if(!vop_found){
982         for(i=0; i<buf_size; i++){
983             state= (state<<8) | buf[i];
984             if(state == 0xFFD8){
985                 i++;
986                 vop_found=1;
987                 break;
988             }
989         }
990     }
991
992     if(vop_found){
993         /* EOF considered as end of frame */
994         if (buf_size == 0)
995             return 0;
996         for(; i<buf_size; i++){
997             state= (state<<8) | buf[i];
998             if(state == 0xFFD8){
999                 pc->frame_start_found=0;
1000                 pc->state=0;
1001                 return i-1;
1002             }
1003         }
1004     }
1005     pc->frame_start_found= vop_found;
1006     pc->state= state;
1007     return END_NOT_FOUND;
1008 }
1009
1010 static int jpeg_parse(AVCodecParserContext *s,
1011                            AVCodecContext *avctx,
1012                            uint8_t **poutbuf, int *poutbuf_size,
1013                            const uint8_t *buf, int buf_size)
1014 {
1015     ParseContext *pc = s->priv_data;
1016     int next;
1017
1018     next= find_frame_end(pc, buf, buf_size);
1019
1020     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1021         *poutbuf = NULL;
1022         *poutbuf_size = 0;
1023         return buf_size;
1024     }
1025
1026     *poutbuf = (uint8_t *)buf;
1027     *poutbuf_size = buf_size;
1028     return next;
1029 }
1030
1031 /* quantize tables */
1032 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1033 {
1034     int len, index, i, j;
1035
1036     len = get_bits(&s->gb, 16) - 2;
1037
1038     while (len >= 65) {
1039         /* only 8 bit precision handled */
1040         if (get_bits(&s->gb, 4) != 0)
1041         {
1042             dprintf("dqt: 16bit precision\n");
1043             return -1;
1044         }
1045         index = get_bits(&s->gb, 4);
1046         if (index >= 4)
1047             return -1;
1048         dprintf("index=%d\n", index);
1049         /* read quant table */
1050         for(i=0;i<64;i++) {
1051             j = s->scantable.permutated[i];
1052             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1053         }
1054
1055         //XXX FIXME finetune, and perhaps add dc too
1056         s->qscale[index]= FFMAX(
1057             s->quant_matrixes[index][s->scantable.permutated[1]],
1058             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1059         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1060         len -= 65;
1061     }
1062
1063     return 0;
1064 }
1065
1066 /* decode huffman tables and build VLC decoders */
1067 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1068 {
1069     int len, index, i, class, n, v, code_max;
1070     uint8_t bits_table[17];
1071     uint8_t val_table[256];
1072
1073     len = get_bits(&s->gb, 16) - 2;
1074
1075     while (len > 0) {
1076         if (len < 17)
1077             return -1;
1078         class = get_bits(&s->gb, 4);
1079         if (class >= 2)
1080             return -1;
1081         index = get_bits(&s->gb, 4);
1082         if (index >= 4)
1083             return -1;
1084         n = 0;
1085         for(i=1;i<=16;i++) {
1086             bits_table[i] = get_bits(&s->gb, 8);
1087             n += bits_table[i];
1088         }
1089         len -= 17;
1090         if (len < n || n > 256)
1091             return -1;
1092
1093         code_max = 0;
1094         for(i=0;i<n;i++) {
1095             v = get_bits(&s->gb, 8);
1096             if (v > code_max)
1097                 code_max = v;
1098             val_table[i] = v;
1099         }
1100         len -= n;
1101
1102         /* build VLC and flush previous vlc if present */
1103         free_vlc(&s->vlcs[class][index]);
1104         dprintf("class=%d index=%d nb_codes=%d\n",
1105                class, index, code_max + 1);
1106         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1107             return -1;
1108         }
1109     }
1110     return 0;
1111 }
1112
1113 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1114 {
1115     int len, nb_components, i, width, height, pix_fmt_id;
1116
1117     /* XXX: verify len field validity */
1118     len = get_bits(&s->gb, 16);
1119     s->bits= get_bits(&s->gb, 8);
1120
1121     if(s->pegasus_rct) s->bits=9;
1122     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1123
1124     if (s->bits != 8 && !s->lossless){
1125         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1126         return -1;
1127     }
1128     if (s->bits > 8 && s->ls){
1129         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1130         return -1;
1131     }
1132
1133     height = get_bits(&s->gb, 16);
1134     width = get_bits(&s->gb, 16);
1135
1136     dprintf("sof0: picture: %dx%d\n", width, height);
1137     if(avcodec_check_dimensions(s->avctx, width, height))
1138         return -1;
1139
1140     nb_components = get_bits(&s->gb, 8);
1141     if (nb_components <= 0 ||
1142         nb_components > MAX_COMPONENTS)
1143         return -1;
1144     s->nb_components = nb_components;
1145     s->h_max = 1;
1146     s->v_max = 1;
1147     for(i=0;i<nb_components;i++) {
1148         /* component id */
1149         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1150         s->h_count[i] = get_bits(&s->gb, 4);
1151         s->v_count[i] = get_bits(&s->gb, 4);
1152         /* compute hmax and vmax (only used in interleaved case) */
1153         if (s->h_count[i] > s->h_max)
1154             s->h_max = s->h_count[i];
1155         if (s->v_count[i] > s->v_max)
1156             s->v_max = s->v_count[i];
1157         s->quant_index[i] = get_bits(&s->gb, 8);
1158         if (s->quant_index[i] >= 4)
1159             return -1;
1160         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1161             s->v_count[i], s->component_id[i], s->quant_index[i]);
1162     }
1163
1164     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1165         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1166         return -1;
1167     }
1168
1169     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1170
1171     /* if different size, realloc/alloc picture */
1172     /* XXX: also check h_count and v_count */
1173     if (width != s->width || height != s->height) {
1174         av_freep(&s->qscale_table);
1175
1176         s->width = width;
1177         s->height = height;
1178
1179         /* test interlaced mode */
1180         if (s->first_picture &&
1181             s->org_height != 0 &&
1182             s->height < ((s->org_height * 3) / 4)) {
1183             s->interlaced = 1;
1184 //            s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1185             s->bottom_field = 0;
1186             height *= 2;
1187         }
1188
1189         avcodec_set_dimensions(s->avctx, width, height);
1190
1191         s->qscale_table= av_mallocz((s->width+15)/16);
1192
1193         s->first_picture = 0;
1194     }
1195
1196     if(s->interlaced && s->bottom_field)
1197         return 0;
1198
1199     /* XXX: not complete test ! */
1200     pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1201                  (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
1202                  (s->h_count[2] <<  4) |  s->v_count[2];
1203     dprintf("pix fmt id %x\n", pix_fmt_id);
1204     switch(pix_fmt_id){
1205     case 0x222222:
1206     case 0x111111:
1207         if(s->rgb){
1208             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1209         }else if(s->nb_components==3)
1210             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1211         else
1212             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1213         break;
1214     case 0x211111:
1215     case 0x221212:
1216         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1217         break;
1218     default:
1219     case 0x221111:
1220         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1221         break;
1222     }
1223     if(s->ls){
1224         if(s->nb_components > 1)
1225             s->avctx->pix_fmt = PIX_FMT_RGB24;
1226         else
1227             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1228     }
1229
1230     if(s->picture.data[0])
1231         s->avctx->release_buffer(s->avctx, &s->picture);
1232
1233     s->picture.reference= 0;
1234     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1235         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1236         return -1;
1237     }
1238     s->picture.pict_type= I_TYPE;
1239     s->picture.key_frame= 1;
1240
1241     for(i=0; i<3; i++){
1242         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1243     }
1244
1245 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1246
1247     if (len != (8+(3*nb_components)))
1248     {
1249         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1250     }
1251
1252     return 0;
1253 }
1254
1255 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1256 {
1257     int code;
1258     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1259     if (code < 0)
1260     {
1261         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1262                 &s->vlcs[0][dc_index]);
1263         return 0xffff;
1264     }
1265
1266     if(code)
1267         return get_xbits(&s->gb, code);
1268     else
1269         return 0;
1270 }
1271
1272 /* decode block and dequantize */
1273 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1274                         int component, int dc_index, int ac_index, int16_t *quant_matrix)
1275 {
1276     int code, i, j, level, val;
1277
1278     /* DC coef */
1279     val = mjpeg_decode_dc(s, dc_index);
1280     if (val == 0xffff) {
1281         dprintf("error dc\n");
1282         return -1;
1283     }
1284     val = val * quant_matrix[0] + s->last_dc[component];
1285     s->last_dc[component] = val;
1286     block[0] = val;
1287     /* AC coefs */
1288     i = 0;
1289     {OPEN_READER(re, &s->gb)
1290     for(;;) {
1291         UPDATE_CACHE(re, &s->gb);
1292         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1293
1294         /* EOB */
1295         if (code == 0x10)
1296             break;
1297         i += ((unsigned)code) >> 4;
1298         if(code != 0x100){
1299             code &= 0xf;
1300             if(code > MIN_CACHE_BITS - 16){
1301                 UPDATE_CACHE(re, &s->gb)
1302             }
1303             {
1304                 int cache=GET_CACHE(re,&s->gb);
1305                 int sign=(~cache)>>31;
1306                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1307             }
1308
1309             LAST_SKIP_BITS(re, &s->gb, code)
1310
1311             if (i >= 63) {
1312                 if(i == 63){
1313                     j = s->scantable.permutated[63];
1314                     block[j] = level * quant_matrix[j];
1315                     break;
1316                 }
1317                 dprintf("error count: %d\n", i);
1318                 return -1;
1319             }
1320             j = s->scantable.permutated[i];
1321             block[j] = level * quant_matrix[j];
1322         }
1323     }
1324     CLOSE_READER(re, &s->gb)}
1325
1326     return 0;
1327 }
1328
1329 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1330     int i, mb_x, mb_y;
1331     uint16_t buffer[32768][4];
1332     int left[3], top[3], topleft[3];
1333     const int linesize= s->linesize[0];
1334     const int mask= (1<<s->bits)-1;
1335
1336     if((unsigned)s->mb_width > 32768) //dynamic alloc
1337         return -1;
1338
1339     for(i=0; i<3; i++){
1340         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1341     }
1342     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1343         const int modified_predictor= mb_y ? predictor : 1;
1344         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1345
1346         if (s->interlaced && s->bottom_field)
1347             ptr += linesize >> 1;
1348
1349         for(i=0; i<3; i++){
1350             top[i]= left[i]= topleft[i]= buffer[0][i];
1351         }
1352         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1353             if (s->restart_interval && !s->restart_count)
1354                 s->restart_count = s->restart_interval;
1355
1356             for(i=0;i<3;i++) {
1357                 int pred;
1358
1359                 topleft[i]= top[i];
1360                 top[i]= buffer[mb_x][i];
1361
1362                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1363
1364                 left[i]=
1365                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1366             }
1367
1368             if (s->restart_interval && !--s->restart_count) {
1369                 align_get_bits(&s->gb);
1370                 skip_bits(&s->gb, 16); /* skip RSTn */
1371             }
1372         }
1373
1374         if(s->rct){
1375             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1376                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1377                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1378                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1379             }
1380         }else if(s->pegasus_rct){
1381             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1382                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1383                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1384                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1385             }
1386         }else{
1387             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1388                 ptr[4*mb_x+0] = buffer[mb_x][0];
1389                 ptr[4*mb_x+1] = buffer[mb_x][1];
1390                 ptr[4*mb_x+2] = buffer[mb_x][2];
1391             }
1392         }
1393     }
1394     return 0;
1395 }
1396
1397 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1398     int i, mb_x, mb_y;
1399     const int nb_components=3;
1400
1401     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1402         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1403             if (s->restart_interval && !s->restart_count)
1404                 s->restart_count = s->restart_interval;
1405
1406             if(mb_x==0 || mb_y==0 || s->interlaced){
1407                 for(i=0;i<nb_components;i++) {
1408                     uint8_t *ptr;
1409                     int n, h, v, x, y, c, j, linesize;
1410                     n = s->nb_blocks[i];
1411                     c = s->comp_index[i];
1412                     h = s->h_scount[i];
1413                     v = s->v_scount[i];
1414                     x = 0;
1415                     y = 0;
1416                     linesize= s->linesize[c];
1417
1418                     for(j=0; j<n; j++) {
1419                         int pred;
1420
1421                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1422                         if(y==0 && mb_y==0){
1423                             if(x==0 && mb_x==0){
1424                                 pred= 128 << point_transform;
1425                             }else{
1426                                 pred= ptr[-1];
1427                             }
1428                         }else{
1429                             if(x==0 && mb_x==0){
1430                                 pred= ptr[-linesize];
1431                             }else{
1432                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1433                             }
1434                         }
1435
1436                         if (s->interlaced && s->bottom_field)
1437                             ptr += linesize >> 1;
1438                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1439
1440                         if (++x == h) {
1441                             x = 0;
1442                             y++;
1443                         }
1444                     }
1445                 }
1446             }else{
1447                 for(i=0;i<nb_components;i++) {
1448                     uint8_t *ptr;
1449                     int n, h, v, x, y, c, j, linesize;
1450                     n = s->nb_blocks[i];
1451                     c = s->comp_index[i];
1452                     h = s->h_scount[i];
1453                     v = s->v_scount[i];
1454                     x = 0;
1455                     y = 0;
1456                     linesize= s->linesize[c];
1457
1458                     for(j=0; j<n; j++) {
1459                         int pred;
1460
1461                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1462                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1463                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1464                         if (++x == h) {
1465                             x = 0;
1466                             y++;
1467                         }
1468                     }
1469                 }
1470             }
1471             if (s->restart_interval && !--s->restart_count) {
1472                 align_get_bits(&s->gb);
1473                 skip_bits(&s->gb, 16); /* skip RSTn */
1474             }
1475         }
1476     }
1477     return 0;
1478 }
1479
1480 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1481     int i, mb_x, mb_y;
1482     const int nb_components=3;
1483
1484     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1485         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1486             if (s->restart_interval && !s->restart_count)
1487                 s->restart_count = s->restart_interval;
1488
1489             for(i=0;i<nb_components;i++) {
1490                 uint8_t *ptr;
1491                 int n, h, v, x, y, c, j;
1492                 n = s->nb_blocks[i];
1493                 c = s->comp_index[i];
1494                 h = s->h_scount[i];
1495                 v = s->v_scount[i];
1496                 x = 0;
1497                 y = 0;
1498                 for(j=0;j<n;j++) {
1499                     memset(s->block, 0, sizeof(s->block));
1500                     if (decode_block(s, s->block, i,
1501                                      s->dc_index[i], s->ac_index[i],
1502                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1503                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1504                         return -1;
1505                     }
1506 //                    dprintf("mb: %d %d processed\n", mb_y, mb_x);
1507                     ptr = s->picture.data[c] +
1508                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1509                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1510                     if (s->interlaced && s->bottom_field)
1511                         ptr += s->linesize[c] >> 1;
1512 //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);
1513                     s->idct_put(ptr, s->linesize[c], s->block);
1514                     if (++x == h) {
1515                         x = 0;
1516                         y++;
1517                     }
1518                 }
1519             }
1520             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1521             if (s->restart_interval && (s->restart_interval < 1350) &&
1522                 !--s->restart_count) {
1523                 align_get_bits(&s->gb);
1524                 skip_bits(&s->gb, 16); /* skip RSTn */
1525                 for (i=0; i<nb_components; i++) /* reset dc */
1526                     s->last_dc[i] = 1024;
1527             }
1528         }
1529     }
1530     return 0;
1531 }
1532
1533 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1534 {
1535     int len, nb_components, i, h, v, predictor, point_transform;
1536     int vmax, hmax, index, id;
1537     const int block_size= s->lossless ? 1 : 8;
1538     int ilv;
1539
1540     /* XXX: verify len field validity */
1541     len = get_bits(&s->gb, 16);
1542     nb_components = get_bits(&s->gb, 8);
1543     if (len != 6+2*nb_components)
1544     {
1545         dprintf("decode_sos: invalid len (%d)\n", len);
1546         return -1;
1547     }
1548     /* XXX: only interleaved scan accepted */
1549     if ((nb_components != s->nb_components) && !s->ls)
1550     {
1551         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1552         return -1;
1553     }
1554     vmax = 0;
1555     hmax = 0;
1556     for(i=0;i<nb_components;i++) {
1557         id = get_bits(&s->gb, 8) - 1;
1558         dprintf("component: %d\n", id);
1559         /* find component index */
1560         for(index=0;index<s->nb_components;index++)
1561             if (id == s->component_id[index])
1562                 break;
1563         if (index == s->nb_components)
1564         {
1565             dprintf("decode_sos: index(%d) out of components\n", index);
1566             return -1;
1567         }
1568
1569         s->comp_index[i] = index;
1570
1571         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1572         s->h_scount[i] = s->h_count[index];
1573         s->v_scount[i] = s->v_count[index];
1574
1575         s->dc_index[i] = get_bits(&s->gb, 4);
1576         s->ac_index[i] = get_bits(&s->gb, 4);
1577
1578         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1579             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1580             goto out_of_range;
1581 #if 0 //buggy
1582         switch(s->start_code)
1583         {
1584             case SOF0:
1585                 if (dc_index[i] > 1 || ac_index[i] > 1)
1586                     goto out_of_range;
1587                 break;
1588             case SOF1:
1589             case SOF2:
1590                 if (dc_index[i] > 3 || ac_index[i] > 3)
1591                     goto out_of_range;
1592                 break;
1593             case SOF3:
1594                 if (dc_index[i] > 3 || ac_index[i] != 0)
1595                     goto out_of_range;
1596                 break;
1597         }
1598 #endif
1599     }
1600
1601     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1602     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1603     skip_bits(&s->gb, 4); /* Ah */
1604     point_transform= get_bits(&s->gb, 4); /* Al */
1605
1606     for(i=0;i<nb_components;i++)
1607         s->last_dc[i] = 1024;
1608
1609     if (nb_components > 1) {
1610         /* interleaved stream */
1611         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1612         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1613     } else if(!s->ls) { /* skip this for JPEG-LS */
1614         h = s->h_max / s->h_scount[s->comp_index[0]];
1615         v = s->v_max / s->v_scount[s->comp_index[0]];
1616         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1617         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1618         s->nb_blocks[0] = 1;
1619         s->h_scount[0] = 1;
1620         s->v_scount[0] = 1;
1621     }
1622
1623     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1624         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" : "",
1625                predictor, point_transform, ilv, s->bits,
1626                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1627
1628
1629     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1630     for (i = s->mjpb_skiptosod; i > 0; i--)
1631         skip_bits(&s->gb, 8);
1632
1633     if(s->lossless){
1634         if(s->ls){
1635 //            for(){
1636 //            reset_ls_coding_parameters(s, 0);
1637
1638             ls_decode_picture(s, predictor, point_transform, ilv);
1639         }else{
1640             if(s->rgb){
1641                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1642                     return -1;
1643             }else{
1644                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1645                     return -1;
1646             }
1647         }
1648     }else{
1649         if(mjpeg_decode_scan(s) < 0)
1650             return -1;
1651     }
1652     emms_c();
1653     return 0;
1654  out_of_range:
1655     dprintf("decode_sos: ac/dc index out of range\n");
1656     return -1;
1657 }
1658
1659 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1660 {
1661     if (get_bits(&s->gb, 16) != 4)
1662         return -1;
1663     s->restart_interval = get_bits(&s->gb, 16);
1664     s->restart_count = 0;
1665     dprintf("restart interval: %d\n", s->restart_interval);
1666
1667     return 0;
1668 }
1669
1670 static int mjpeg_decode_app(MJpegDecodeContext *s)
1671 {
1672     int len, id;
1673
1674     len = get_bits(&s->gb, 16);
1675     if (len < 5)
1676         return -1;
1677     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1678         return -1;
1679
1680     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1681     id = be2me_32(id);
1682     len -= 6;
1683
1684     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1685         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1686     }
1687
1688     /* buggy AVID, it puts EOI only at every 10th frame */
1689     /* also this fourcc is used by non-avid files too, it holds some
1690        informations, but it's always present in AVID creates files */
1691     if (id == ff_get_fourcc("AVI1"))
1692     {
1693         /* structure:
1694             4bytes      AVI1
1695             1bytes      polarity
1696             1bytes      always zero
1697             4bytes      field_size
1698             4bytes      field_size_less_padding
1699         */
1700             s->buggy_avid = 1;
1701 //        if (s->first_picture)
1702 //            printf("mjpeg: workarounding buggy AVID\n");
1703         s->interlace_polarity = get_bits(&s->gb, 8);
1704 #if 0
1705         skip_bits(&s->gb, 8);
1706         skip_bits(&s->gb, 32);
1707         skip_bits(&s->gb, 32);
1708         len -= 10;
1709 #endif
1710 //        if (s->interlace_polarity)
1711 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1712         goto out;
1713     }
1714
1715 //    len -= 2;
1716
1717     if (id == ff_get_fourcc("JFIF"))
1718     {
1719         int t_w, t_h, v1, v2;
1720         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1721         v1= get_bits(&s->gb, 8);
1722         v2= get_bits(&s->gb, 8);
1723         skip_bits(&s->gb, 8);
1724
1725         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1726         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1727
1728         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1729             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1730                 v1, v2,
1731                 s->avctx->sample_aspect_ratio.num,
1732                 s->avctx->sample_aspect_ratio.den
1733             );
1734
1735         t_w = get_bits(&s->gb, 8);
1736         t_h = get_bits(&s->gb, 8);
1737         if (t_w && t_h)
1738         {
1739             /* skip thumbnail */
1740             if (len-10-(t_w*t_h*3) > 0)
1741                 len -= t_w*t_h*3;
1742         }
1743         len -= 10;
1744         goto out;
1745     }
1746
1747     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1748     {
1749         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1750             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1751         skip_bits(&s->gb, 16); /* version */
1752         skip_bits(&s->gb, 16); /* flags0 */
1753         skip_bits(&s->gb, 16); /* flags1 */
1754         skip_bits(&s->gb, 8);  /* transform */
1755         len -= 7;
1756         goto out;
1757     }
1758
1759     if (id == ff_get_fourcc("LJIF")){
1760         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1761             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1762         skip_bits(&s->gb, 16); /* version ? */
1763         skip_bits(&s->gb, 16); /* unknwon always 0? */
1764         skip_bits(&s->gb, 16); /* unknwon always 0? */
1765         skip_bits(&s->gb, 16); /* unknwon always 0? */
1766         switch( get_bits(&s->gb, 8)){
1767         case 1:
1768             s->rgb= 1;
1769             s->pegasus_rct=0;
1770             break;
1771         case 2:
1772             s->rgb= 1;
1773             s->pegasus_rct=1;
1774             break;
1775         default:
1776             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1777         }
1778         len -= 9;
1779         goto out;
1780     }
1781
1782     /* Apple MJPEG-A */
1783     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1784     {
1785         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1786         id = be2me_32(id);
1787         len -= 4;
1788         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1789         {
1790 #if 0
1791             skip_bits(&s->gb, 32); /* field size */
1792             skip_bits(&s->gb, 32); /* pad field size */
1793             skip_bits(&s->gb, 32); /* next off */
1794             skip_bits(&s->gb, 32); /* quant off */
1795             skip_bits(&s->gb, 32); /* huff off */
1796             skip_bits(&s->gb, 32); /* image off */
1797             skip_bits(&s->gb, 32); /* scan off */
1798             skip_bits(&s->gb, 32); /* data off */
1799 #endif
1800             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1801                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1802         }
1803     }
1804
1805 out:
1806     /* slow but needed for extreme adobe jpegs */
1807     if (len < 0)
1808         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1809     while(--len > 0)
1810         skip_bits(&s->gb, 8);
1811
1812     return 0;
1813 }
1814
1815 static int mjpeg_decode_com(MJpegDecodeContext *s)
1816 {
1817     int len = get_bits(&s->gb, 16);
1818     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1819         char *cbuf = av_malloc(len - 1);
1820         if (cbuf) {
1821             int i;
1822             for (i = 0; i < len - 2; i++)
1823                 cbuf[i] = get_bits(&s->gb, 8);
1824             if (i > 0 && cbuf[i-1] == '\n')
1825                 cbuf[i-1] = 0;
1826             else
1827                 cbuf[i] = 0;
1828
1829             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1830                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1831
1832             /* buggy avid, it puts EOI only at every 10th frame */
1833             if (!strcmp(cbuf, "AVID"))
1834             {
1835                 s->buggy_avid = 1;
1836                 //        if (s->first_picture)
1837                 //            printf("mjpeg: workarounding buggy AVID\n");
1838             }
1839             else if(!strcmp(cbuf, "CS=ITU601")){
1840                 s->cs_itu601= 1;
1841             }
1842
1843             av_free(cbuf);
1844         }
1845     }
1846
1847     return 0;
1848 }
1849
1850 #if 0
1851 static int valid_marker_list[] =
1852 {
1853         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1854 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1856 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1857 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1858 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1859 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1860 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1861 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1862 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1863 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1864 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1865 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1866 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1867 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1868 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1869 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1870 }
1871 #endif
1872
1873 /* return the 8 bit start code value and update the search
1874    state. Return -1 if no start code found */
1875 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1876 {
1877     uint8_t *buf_ptr;
1878     unsigned int v, v2;
1879     int val;
1880 #ifdef DEBUG
1881     int skipped=0;
1882 #endif
1883
1884     buf_ptr = *pbuf_ptr;
1885     while (buf_ptr < buf_end) {
1886         v = *buf_ptr++;
1887         v2 = *buf_ptr;
1888         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1889             val = *buf_ptr++;
1890             goto found;
1891         }
1892 #ifdef DEBUG
1893         skipped++;
1894 #endif
1895     }
1896     val = -1;
1897 found:
1898 #ifdef DEBUG
1899     dprintf("find_marker skipped %d bytes\n", skipped);
1900 #endif
1901     *pbuf_ptr = buf_ptr;
1902     return val;
1903 }
1904
1905 static int mjpeg_decode_frame(AVCodecContext *avctx,
1906                               void *data, int *data_size,
1907                               uint8_t *buf, int buf_size)
1908 {
1909     MJpegDecodeContext *s = avctx->priv_data;
1910     uint8_t *buf_end, *buf_ptr;
1911     int start_code;
1912     AVFrame *picture = data;
1913
1914     buf_ptr = buf;
1915     buf_end = buf + buf_size;
1916     while (buf_ptr < buf_end) {
1917         /* find start next marker */
1918         start_code = find_marker(&buf_ptr, buf_end);
1919         {
1920             /* EOF */
1921             if (start_code < 0) {
1922                 goto the_end;
1923             } else {
1924                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1925
1926                 if ((buf_end - buf_ptr) > s->buffer_size)
1927                 {
1928                     av_free(s->buffer);
1929                     s->buffer_size = buf_end-buf_ptr;
1930                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1931                     dprintf("buffer too small, expanding to %d bytes\n",
1932                         s->buffer_size);
1933                 }
1934
1935                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1936                 if (start_code == SOS && !s->ls)
1937                 {
1938                     uint8_t *src = buf_ptr;
1939                     uint8_t *dst = s->buffer;
1940
1941                     while (src<buf_end)
1942                     {
1943                         uint8_t x = *(src++);
1944
1945                         *(dst++) = x;
1946                         if (x == 0xff)
1947                         {
1948                             while(src<buf_end && x == 0xff)
1949                                 x = *(src++);
1950
1951                             if (x >= 0xd0 && x <= 0xd7)
1952                                 *(dst++) = x;
1953                             else if (x)
1954                                 break;
1955                         }
1956                     }
1957                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1958
1959                     dprintf("escaping removed %d bytes\n",
1960                         (buf_end - buf_ptr) - (dst - s->buffer));
1961                 }
1962                 else if(start_code == SOS && s->ls){
1963                     uint8_t *src = buf_ptr;
1964                     uint8_t *dst = s->buffer;
1965                     int bit_count = 0;
1966                     int t = 0, b = 0;
1967                     PutBitContext pb;
1968
1969                     s->cur_scan++;
1970
1971                     /* find marker */
1972                     while (src + t < buf_end){
1973                         uint8_t x = src[t++];
1974                         if (x == 0xff){
1975                             while((src + t < buf_end) && x == 0xff)
1976                                 x = src[t++];
1977                             if (x & 0x80) {
1978                                 t -= 2;
1979                                 break;
1980                             }
1981                         }
1982                     }
1983                     bit_count = t * 8;
1984
1985                     init_put_bits(&pb, dst, t);
1986
1987                     /* unescape bitstream */
1988                     while(b < t){
1989                         uint8_t x = src[b++];
1990                         put_bits(&pb, 8, x);
1991                         if(x == 0xFF){
1992                             x = src[b++];
1993                             put_bits(&pb, 7, x);
1994                             bit_count--;
1995                         }
1996                     }
1997                     flush_put_bits(&pb);
1998
1999                     init_get_bits(&s->gb, dst, bit_count);
2000                 }
2001                 else
2002                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2003
2004                 s->start_code = start_code;
2005                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2006                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2007                 }
2008
2009                 /* process markers */
2010                 if (start_code >= 0xd0 && start_code <= 0xd7) {
2011                     dprintf("restart marker: %d\n", start_code&0x0f);
2012                     /* APP fields */
2013                 } else if (start_code >= APP0 && start_code <= APP15) {
2014                     mjpeg_decode_app(s);
2015                     /* Comment */
2016                 } else if (start_code == COM){
2017                     mjpeg_decode_com(s);
2018                 }
2019
2020                 switch(start_code) {
2021                 case SOI:
2022                     s->restart_interval = 0;
2023
2024                     s->restart_count = 0;
2025                     /* nothing to do on SOI */
2026                     break;
2027                 case DQT:
2028                     mjpeg_decode_dqt(s);
2029                     break;
2030                 case DHT:
2031                     if(mjpeg_decode_dht(s) < 0){
2032                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2033                         return -1;
2034                     }
2035                     break;
2036                 case SOF0:
2037                     s->lossless=0;
2038                     if (mjpeg_decode_sof(s) < 0)
2039                         return -1;
2040                     break;
2041                 case SOF3:
2042                     s->lossless=1;
2043                     if (mjpeg_decode_sof(s) < 0)
2044                         return -1;
2045                     break;
2046                 case SOF48:
2047                     s->lossless=1;
2048                     s->ls=1;
2049                     if (mjpeg_decode_sof(s) < 0)
2050                         return -1;
2051                     break;
2052                 case LSE:
2053                     if (decode_lse(s) < 0)
2054                         return -1;
2055                     break;
2056                 case EOI:
2057                     s->cur_scan = 0;
2058                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2059                         break;
2060 eoi_parser:
2061                     {
2062                         if (s->interlaced) {
2063                             s->bottom_field ^= 1;
2064                             /* if not bottom field, do not output image yet */
2065                             if (s->bottom_field)
2066                                 goto not_the_end;
2067                         }
2068                         *picture = s->picture;
2069                         *data_size = sizeof(AVFrame);
2070
2071                         if(!s->lossless){
2072                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2073                             picture->qstride= 0;
2074                             picture->qscale_table= s->qscale_table;
2075                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2076                             if(avctx->debug & FF_DEBUG_QP)
2077                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2078                             picture->quality*= FF_QP2LAMBDA;
2079                         }
2080
2081                         goto the_end;
2082                     }
2083                     break;
2084                 case SOS:
2085                     mjpeg_decode_sos(s);
2086                     /* buggy avid puts EOI every 10-20th frame */
2087                     /* if restart period is over process EOI */
2088                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2089                         goto eoi_parser;
2090                     break;
2091                 case DRI:
2092                     mjpeg_decode_dri(s);
2093                     break;
2094                 case SOF1:
2095                 case SOF2:
2096                 case SOF5:
2097                 case SOF6:
2098                 case SOF7:
2099                 case SOF9:
2100                 case SOF10:
2101                 case SOF11:
2102                 case SOF13:
2103                 case SOF14:
2104                 case SOF15:
2105                 case JPG:
2106                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2107                     break;
2108 //                default:
2109 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2110 //                    break;
2111                 }
2112
2113 not_the_end:
2114                 /* eof process start code */
2115                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2116                 dprintf("marker parser used %d bytes (%d bits)\n",
2117                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2118             }
2119         }
2120     }
2121 the_end:
2122     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2123 //    return buf_end - buf_ptr;
2124     return buf_ptr - buf;
2125 }
2126
2127 static int mjpegb_decode_frame(AVCodecContext *avctx,
2128                               void *data, int *data_size,
2129                               uint8_t *buf, int buf_size)
2130 {
2131     MJpegDecodeContext *s = avctx->priv_data;
2132     uint8_t *buf_end, *buf_ptr;
2133     AVFrame *picture = data;
2134     GetBitContext hgb; /* for the header */
2135     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2136     uint32_t field_size, sod_offs;
2137
2138     buf_ptr = buf;
2139     buf_end = buf + buf_size;
2140
2141 read_header:
2142     /* reset on every SOI */
2143     s->restart_interval = 0;
2144     s->restart_count = 0;
2145     s->mjpb_skiptosod = 0;
2146
2147     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2148
2149     skip_bits(&hgb, 32); /* reserved zeros */
2150
2151     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2152     {
2153         dprintf("not mjpeg-b (bad fourcc)\n");
2154         return 0;
2155     }
2156
2157     field_size = get_bits_long(&hgb, 32); /* field size */
2158     dprintf("field size: 0x%x\n", field_size);
2159     skip_bits(&hgb, 32); /* padded field size */
2160     second_field_offs = get_bits_long(&hgb, 32);
2161     dprintf("second field offs: 0x%x\n", second_field_offs);
2162     if (second_field_offs)
2163         s->interlaced = 1;
2164
2165     dqt_offs = get_bits_long(&hgb, 32);
2166     dprintf("dqt offs: 0x%x\n", dqt_offs);
2167     if (dqt_offs)
2168     {
2169         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2170         s->start_code = DQT;
2171         mjpeg_decode_dqt(s);
2172     }
2173
2174     dht_offs = get_bits_long(&hgb, 32);
2175     dprintf("dht offs: 0x%x\n", dht_offs);
2176     if (dht_offs)
2177     {
2178         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2179         s->start_code = DHT;
2180         mjpeg_decode_dht(s);
2181     }
2182
2183     sof_offs = get_bits_long(&hgb, 32);
2184     dprintf("sof offs: 0x%x\n", sof_offs);
2185     if (sof_offs)
2186     {
2187         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2188         s->start_code = SOF0;
2189         if (mjpeg_decode_sof(s) < 0)
2190             return -1;
2191     }
2192
2193     sos_offs = get_bits_long(&hgb, 32);
2194     dprintf("sos offs: 0x%x\n", sos_offs);
2195     sod_offs = get_bits_long(&hgb, 32);
2196     dprintf("sod offs: 0x%x\n", sod_offs);
2197     if (sos_offs)
2198     {
2199 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2200         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2201         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2202         s->start_code = SOS;
2203         mjpeg_decode_sos(s);
2204     }
2205
2206     if (s->interlaced) {
2207         s->bottom_field ^= 1;
2208         /* if not bottom field, do not output image yet */
2209         if (s->bottom_field && second_field_offs)
2210         {
2211             buf_ptr = buf + second_field_offs;
2212             second_field_offs = 0;
2213             goto read_header;
2214             }
2215     }
2216
2217     //XXX FIXME factorize, this looks very similar to the EOI code
2218
2219     *picture= s->picture;
2220     *data_size = sizeof(AVFrame);
2221
2222     if(!s->lossless){
2223         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2224         picture->qstride= 0;
2225         picture->qscale_table= s->qscale_table;
2226         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2227         if(avctx->debug & FF_DEBUG_QP)
2228             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2229         picture->quality*= FF_QP2LAMBDA;
2230     }
2231
2232     return buf_ptr - buf;
2233 }
2234
2235 #include "sp5x.h"
2236
2237 static int sp5x_decode_frame(AVCodecContext *avctx,
2238                               void *data, int *data_size,
2239                               uint8_t *buf, int buf_size)
2240 {
2241 #if 0
2242     MJpegDecodeContext *s = avctx->priv_data;
2243 #endif
2244     const int qscale = 5;
2245     uint8_t *buf_ptr, *buf_end, *recoded;
2246     int i = 0, j = 0;
2247
2248     if (!avctx->width || !avctx->height)
2249         return -1;
2250
2251     buf_ptr = buf;
2252     buf_end = buf + buf_size;
2253
2254 #if 1
2255     recoded = av_mallocz(buf_size + 1024);
2256     if (!recoded)
2257         return -1;
2258
2259     /* SOI */
2260     recoded[j++] = 0xFF;
2261     recoded[j++] = 0xD8;
2262
2263     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2264     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2265     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2266     j += sizeof(sp5x_data_dqt);
2267
2268     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2269     j += sizeof(sp5x_data_dht);
2270
2271     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2272     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2273     recoded[j+6] = avctx->coded_height & 0xFF;
2274     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2275     recoded[j+8] = avctx->coded_width & 0xFF;
2276     j += sizeof(sp5x_data_sof);
2277
2278     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2279     j += sizeof(sp5x_data_sos);
2280
2281     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2282     {
2283         recoded[j++] = buf[i];
2284         if (buf[i] == 0xff)
2285             recoded[j++] = 0;
2286     }
2287
2288     /* EOI */
2289     recoded[j++] = 0xFF;
2290     recoded[j++] = 0xD9;
2291
2292     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2293
2294     av_free(recoded);
2295
2296 #else
2297     /* SOF */
2298     s->bits = 8;
2299     s->width  = avctx->coded_width;
2300     s->height = avctx->coded_height;
2301     s->nb_components = 3;
2302     s->component_id[0] = 0;
2303     s->h_count[0] = 2;
2304     s->v_count[0] = 2;
2305     s->quant_index[0] = 0;
2306     s->component_id[1] = 1;
2307     s->h_count[1] = 1;
2308     s->v_count[1] = 1;
2309     s->quant_index[1] = 1;
2310     s->component_id[2] = 2;
2311     s->h_count[2] = 1;
2312     s->v_count[2] = 1;
2313     s->quant_index[2] = 1;
2314     s->h_max = 2;
2315     s->v_max = 2;
2316
2317     s->qscale_table = av_mallocz((s->width+15)/16);
2318     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2319     s->interlaced = 0;
2320
2321     s->picture.reference = 0;
2322     if (avctx->get_buffer(avctx, &s->picture) < 0)
2323     {
2324         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2325         return -1;
2326     }
2327
2328     s->picture.pict_type = I_TYPE;
2329     s->picture.key_frame = 1;
2330
2331     for (i = 0; i < 3; i++)
2332         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2333
2334     /* DQT */
2335     for (i = 0; i < 64; i++)
2336     {
2337         j = s->scantable.permutated[i];
2338         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2339     }
2340     s->qscale[0] = FFMAX(
2341         s->quant_matrixes[0][s->scantable.permutated[1]],
2342         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2343
2344     for (i = 0; i < 64; i++)
2345     {
2346         j = s->scantable.permutated[i];
2347         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2348     }
2349     s->qscale[1] = FFMAX(
2350         s->quant_matrixes[1][s->scantable.permutated[1]],
2351         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2352
2353     /* DHT */
2354
2355     /* SOS */
2356     s->comp_index[0] = 0;
2357     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2358     s->h_scount[0] = s->h_count[0];
2359     s->v_scount[0] = s->v_count[0];
2360     s->dc_index[0] = 0;
2361     s->ac_index[0] = 0;
2362
2363     s->comp_index[1] = 1;
2364     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2365     s->h_scount[1] = s->h_count[1];
2366     s->v_scount[1] = s->v_count[1];
2367     s->dc_index[1] = 1;
2368     s->ac_index[1] = 1;
2369
2370     s->comp_index[2] = 2;
2371     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2372     s->h_scount[2] = s->h_count[2];
2373     s->v_scount[2] = s->v_count[2];
2374     s->dc_index[2] = 1;
2375     s->ac_index[2] = 1;
2376
2377     for (i = 0; i < 3; i++)
2378         s->last_dc[i] = 1024;
2379
2380     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2381     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2382
2383     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2384
2385     return mjpeg_decode_scan(s);
2386 #endif
2387
2388     return i;
2389 }
2390
2391 static int mjpeg_decode_end(AVCodecContext *avctx)
2392 {
2393     MJpegDecodeContext *s = avctx->priv_data;
2394     int i, j;
2395
2396     av_free(s->buffer);
2397     av_free(s->qscale_table);
2398
2399     for(i=0;i<2;i++) {
2400         for(j=0;j<4;j++)
2401             free_vlc(&s->vlcs[i][j]);
2402     }
2403     return 0;
2404 }
2405
2406 AVCodec mjpeg_decoder = {
2407     "mjpeg",
2408     CODEC_TYPE_VIDEO,
2409     CODEC_ID_MJPEG,
2410     sizeof(MJpegDecodeContext),
2411     mjpeg_decode_init,
2412     NULL,
2413     mjpeg_decode_end,
2414     mjpeg_decode_frame,
2415     CODEC_CAP_DR1,
2416     NULL
2417 };
2418
2419 AVCodec mjpegb_decoder = {
2420     "mjpegb",
2421     CODEC_TYPE_VIDEO,
2422     CODEC_ID_MJPEGB,
2423     sizeof(MJpegDecodeContext),
2424     mjpeg_decode_init,
2425     NULL,
2426     mjpeg_decode_end,
2427     mjpegb_decode_frame,
2428     CODEC_CAP_DR1,
2429     NULL
2430 };
2431
2432 AVCodec sp5x_decoder = {
2433     "sp5x",
2434     CODEC_TYPE_VIDEO,
2435     CODEC_ID_SP5X,
2436     sizeof(MJpegDecodeContext),
2437     mjpeg_decode_init,
2438     NULL,
2439     mjpeg_decode_end,
2440     sp5x_decode_frame,
2441     CODEC_CAP_DR1,
2442     NULL
2443 };
2444
2445 #ifdef CONFIG_ENCODERS
2446 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2447     "ljpeg",
2448     CODEC_TYPE_VIDEO,
2449     CODEC_ID_LJPEG,
2450     sizeof(MpegEncContext),
2451     MPV_encode_init,
2452     encode_picture_lossless,
2453     MPV_encode_end,
2454 };
2455 #endif
2456
2457 AVCodecParser mjpeg_parser = {
2458     { CODEC_ID_MJPEG },
2459     sizeof(ParseContext),
2460     NULL,
2461     jpeg_parse,
2462     ff_parse_close,
2463 };
2464