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