set AVCodecContext.width/height before get_buffer()
[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
1056             s->avctx->pix_fmt = PIX_FMT_YUV444P;
1057         break;
1058     case 0x21:
1059         s->avctx->pix_fmt = PIX_FMT_YUV422P;
1060         break;
1061     default:
1062     case 0x22:
1063         s->avctx->pix_fmt = PIX_FMT_YUV420P;
1064         break;
1065     }
1066
1067     if(s->picture.data[0])
1068         s->avctx->release_buffer(s->avctx, &s->picture);
1069
1070     s->picture.reference= 0;
1071     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1072         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1073         return -1;
1074     }
1075     s->picture.pict_type= I_TYPE;
1076     s->picture.key_frame= 1;
1077     
1078     for(i=0; i<3; i++){
1079         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1080     }
1081
1082 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1083     
1084     if (len != (8+(3*nb_components)))
1085     {
1086         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1087     }
1088     
1089     return 0;
1090 }
1091
1092 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1093 {
1094     int code;
1095     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1096     if (code < 0)
1097     {
1098         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1099                 &s->vlcs[0][dc_index]);
1100         return 0xffff;
1101     }
1102
1103     if(code)
1104         return get_xbits(&s->gb, code);
1105     else
1106         return 0;
1107 }
1108
1109 /* decode block and dequantize */
1110 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1111                         int component, int dc_index, int ac_index, int quant_index)
1112 {
1113     int code, i, j, level, val;
1114     VLC *ac_vlc;
1115     int16_t *quant_matrix;
1116
1117     /* DC coef */
1118     val = mjpeg_decode_dc(s, dc_index);
1119     if (val == 0xffff) {
1120         dprintf("error dc\n");
1121         return -1;
1122     }
1123     quant_matrix = s->quant_matrixes[quant_index];
1124     val = val * quant_matrix[0] + s->last_dc[component];
1125     s->last_dc[component] = val;
1126     block[0] = val;
1127     /* AC coefs */
1128     ac_vlc = &s->vlcs[1][ac_index];
1129     i = 1;
1130     for(;;) {
1131         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1132
1133         if (code < 0) {
1134             dprintf("error ac\n");
1135             return -1;
1136         }
1137         /* EOB */
1138         if (code == 0)
1139             break;
1140         if (code == 0xf0) {
1141             i += 16;
1142         } else {
1143             level = get_xbits(&s->gb, code & 0xf);
1144             i += code >> 4;
1145             if (i >= 64) {
1146                 dprintf("error count: %d\n", i);
1147                 return -1;
1148             }
1149             j = s->scantable.permutated[i];
1150             block[j] = level * quant_matrix[j];
1151             i++;
1152             if (i >= 64)
1153                 break;
1154         }
1155     }
1156     return 0;
1157 }
1158
1159 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1160     int i, mb_x, mb_y;
1161     uint16_t buffer[2048][4];
1162     int left[3], top[3], topleft[3];
1163     const int linesize= s->linesize[0];
1164     const int mask= (1<<s->bits)-1;
1165     
1166     for(i=0; i<3; i++){
1167         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1168     }
1169     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1170         const int modified_predictor= mb_y ? predictor : 1;
1171         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1172
1173         if (s->interlaced && s->bottom_field)
1174             ptr += linesize >> 1;
1175
1176         for(i=0; i<3; i++){
1177             top[i]= left[i]= topleft[i]= buffer[0][i];
1178         }
1179         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1180             if (s->restart_interval && !s->restart_count)
1181                 s->restart_count = s->restart_interval;
1182
1183             for(i=0;i<3;i++) {
1184                 int pred;
1185
1186                 topleft[i]= top[i];
1187                 top[i]= buffer[mb_x][i];
1188
1189                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1190                 
1191                 left[i]= 
1192                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1193             }
1194
1195             if (s->restart_interval && !--s->restart_count) {
1196                 align_get_bits(&s->gb);
1197                 skip_bits(&s->gb, 16); /* skip RSTn */
1198             }
1199         }
1200
1201         if(s->rct){
1202             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1203                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1204                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1205                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1206             }
1207         }else if(s->pegasus_rct){
1208             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1209                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1210                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1211                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1212             }
1213         }else{
1214             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215                 ptr[4*mb_x+0] = buffer[mb_x][0];
1216                 ptr[4*mb_x+1] = buffer[mb_x][1];
1217                 ptr[4*mb_x+2] = buffer[mb_x][2];
1218             }
1219         }
1220     }
1221     return 0;
1222 }
1223
1224 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1225     int i, mb_x, mb_y;
1226     const int nb_components=3;
1227
1228     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1229         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1230             if (s->restart_interval && !s->restart_count)
1231                 s->restart_count = s->restart_interval;
1232
1233             if(mb_x==0 || mb_y==0 || s->interlaced){
1234                 for(i=0;i<nb_components;i++) {
1235                     uint8_t *ptr;
1236                     int n, h, v, x, y, c, j, linesize;
1237                     n = s->nb_blocks[i];
1238                     c = s->comp_index[i];
1239                     h = s->h_scount[i];
1240                     v = s->v_scount[i];
1241                     x = 0;
1242                     y = 0;
1243                     linesize= s->linesize[c];
1244                     
1245                     for(j=0; j<n; j++) {
1246                         int pred;
1247
1248                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1249                         if(y==0 && mb_y==0){
1250                             if(x==0 && mb_x==0){
1251                                 pred= 128 << point_transform;
1252                             }else{
1253                                 pred= ptr[-1];
1254                             }
1255                         }else{
1256                             if(x==0 && mb_x==0){
1257                                 pred= ptr[-linesize];
1258                             }else{
1259                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1260                             }
1261                         }
1262                         
1263                         if (s->interlaced && s->bottom_field)
1264                             ptr += linesize >> 1;
1265                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1266
1267                         if (++x == h) {
1268                             x = 0;
1269                             y++;
1270                         }
1271                     }
1272                 }
1273             }else{
1274                 for(i=0;i<nb_components;i++) {
1275                     uint8_t *ptr;
1276                     int n, h, v, x, y, c, j, linesize;
1277                     n = s->nb_blocks[i];
1278                     c = s->comp_index[i];
1279                     h = s->h_scount[i];
1280                     v = s->v_scount[i];
1281                     x = 0;
1282                     y = 0;
1283                     linesize= s->linesize[c];
1284                     
1285                     for(j=0; j<n; j++) {
1286                         int pred;
1287
1288                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1289                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1290                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1291                         if (++x == h) {
1292                             x = 0;
1293                             y++;
1294                         }
1295                     }
1296                 }
1297             }
1298             if (s->restart_interval && !--s->restart_count) {
1299                 align_get_bits(&s->gb);
1300                 skip_bits(&s->gb, 16); /* skip RSTn */
1301             }
1302         }
1303     }
1304     return 0;
1305 }
1306
1307 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1308     int i, mb_x, mb_y;
1309     const int nb_components=3;
1310
1311     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1312         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1313             if (s->restart_interval && !s->restart_count)
1314                 s->restart_count = s->restart_interval;
1315
1316             for(i=0;i<nb_components;i++) {
1317                 uint8_t *ptr;
1318                 int n, h, v, x, y, c, j;
1319                 n = s->nb_blocks[i];
1320                 c = s->comp_index[i];
1321                 h = s->h_scount[i];
1322                 v = s->v_scount[i];
1323                 x = 0;
1324                 y = 0;
1325                 for(j=0;j<n;j++) {
1326                     memset(s->block, 0, sizeof(s->block));
1327                     if (decode_block(s, s->block, i, 
1328                                      s->dc_index[i], s->ac_index[i], 
1329                                      s->quant_index[c]) < 0) {
1330                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1331                         return -1;
1332                     }
1333 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1334                     ptr = s->picture.data[c] + 
1335                         (s->linesize[c] * (v * mb_y + y) * 8) + 
1336                         (h * mb_x + x) * 8;
1337                     if (s->interlaced && s->bottom_field)
1338                         ptr += s->linesize[c] >> 1;
1339 //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);
1340                     s->idct_put(ptr, s->linesize[c], s->block);
1341                     if (++x == h) {
1342                         x = 0;
1343                         y++;
1344                     }
1345                 }
1346             }
1347             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1348             if (s->restart_interval && (s->restart_interval < 1350) &&
1349                 !--s->restart_count) {
1350                 align_get_bits(&s->gb);
1351                 skip_bits(&s->gb, 16); /* skip RSTn */
1352                 for (i=0; i<nb_components; i++) /* reset dc */
1353                     s->last_dc[i] = 1024;
1354             }
1355         }
1356     }
1357     return 0;
1358 }
1359
1360 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1361 {
1362     int len, nb_components, i, h, v, predictor, point_transform;
1363     int vmax, hmax, index, id;
1364     const int block_size= s->lossless ? 1 : 8;
1365
1366     /* XXX: verify len field validity */
1367     len = get_bits(&s->gb, 16);
1368     nb_components = get_bits(&s->gb, 8);
1369     if (len != 6+2*nb_components)
1370     {
1371         dprintf("decode_sos: invalid len (%d)\n", len);
1372         return -1;
1373     }
1374     /* XXX: only interleaved scan accepted */
1375     if (nb_components != 3)
1376     {
1377         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1378         return -1;
1379     }
1380     vmax = 0;
1381     hmax = 0;
1382     for(i=0;i<nb_components;i++) {
1383         id = get_bits(&s->gb, 8) - 1;
1384         dprintf("component: %d\n", id);
1385         /* find component index */
1386         for(index=0;index<s->nb_components;index++)
1387             if (id == s->component_id[index])
1388                 break;
1389         if (index == s->nb_components)
1390         {
1391             dprintf("decode_sos: index(%d) out of components\n", index);
1392             return -1;
1393         }
1394
1395         s->comp_index[i] = index;
1396
1397         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1398         s->h_scount[i] = s->h_count[index];
1399         s->v_scount[i] = s->v_count[index];
1400
1401         s->dc_index[i] = get_bits(&s->gb, 4);
1402         s->ac_index[i] = get_bits(&s->gb, 4);
1403
1404         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1405             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1406             goto out_of_range;
1407 #if 0 //buggy
1408         switch(s->start_code)
1409         {
1410             case SOF0:
1411                 if (dc_index[i] > 1 || ac_index[i] > 1)
1412                     goto out_of_range;
1413                 break;
1414             case SOF1:
1415             case SOF2:
1416                 if (dc_index[i] > 3 || ac_index[i] > 3)
1417                     goto out_of_range;
1418                 break;
1419             case SOF3:
1420                 if (dc_index[i] > 3 || ac_index[i] != 0)
1421                     goto out_of_range;
1422                 break;  
1423         }
1424 #endif
1425     }
1426
1427     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1428     skip_bits(&s->gb, 8); /* Se */
1429     skip_bits(&s->gb, 4); /* Ah */
1430     point_transform= get_bits(&s->gb, 4); /* Al */
1431
1432     for(i=0;i<nb_components;i++) 
1433         s->last_dc[i] = 1024;
1434
1435     if (nb_components > 1) {
1436         /* interleaved stream */
1437         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1438         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1439     } else {
1440         h = s->h_max / s->h_scount[s->comp_index[0]];
1441         v = s->v_max / s->v_scount[s->comp_index[0]];
1442         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1443         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1444         s->nb_blocks[0] = 1;
1445         s->h_scount[0] = 1;
1446         s->v_scount[0] = 1;
1447     }
1448
1449     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1450         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1451     
1452     if(s->lossless){
1453             if(s->rgb){
1454                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1455                     return -1;
1456             }else{
1457                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1458                     return -1;
1459             }
1460     }else{
1461         if(mjpeg_decode_scan(s) < 0)
1462             return -1;
1463     }
1464     emms_c();
1465     return 0;
1466  out_of_range:
1467     dprintf("decode_sos: ac/dc index out of range\n");
1468     return -1;
1469 }
1470
1471 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1472 {
1473     if (get_bits(&s->gb, 16) != 4)
1474         return -1;
1475     s->restart_interval = get_bits(&s->gb, 16);
1476     dprintf("restart interval: %d\n", s->restart_interval);
1477
1478     return 0;
1479 }
1480
1481 static int mjpeg_decode_app(MJpegDecodeContext *s)
1482 {
1483     int len, id;
1484
1485     /* XXX: verify len field validity */
1486     len = get_bits(&s->gb, 16);
1487     if (len < 5)
1488         return -1;
1489
1490     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1491     id = be2me_32(id);
1492     len -= 6;
1493
1494     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1495         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1496     }
1497     
1498     /* buggy AVID, it puts EOI only at every 10th frame */
1499     /* also this fourcc is used by non-avid files too, it holds some
1500        informations, but it's always present in AVID creates files */
1501     if (id == ff_get_fourcc("AVI1"))
1502     {
1503         /* structure:
1504             4bytes      AVI1
1505             1bytes      polarity
1506             1bytes      always zero
1507             4bytes      field_size
1508             4bytes      field_size_less_padding
1509         */
1510         s->buggy_avid = 1;
1511 //      if (s->first_picture)
1512 //          printf("mjpeg: workarounding buggy AVID\n");
1513         s->interlace_polarity = get_bits(&s->gb, 8);
1514 #if 0
1515         skip_bits(&s->gb, 8);
1516         skip_bits(&s->gb, 32);
1517         skip_bits(&s->gb, 32);
1518         len -= 10;
1519 #endif
1520 //      if (s->interlace_polarity)
1521 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1522         goto out;
1523     }
1524     
1525 //    len -= 2;
1526     
1527     if (id == ff_get_fourcc("JFIF"))
1528     {
1529         int t_w, t_h;
1530         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1531         av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x)\n",
1532             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1533         skip_bits(&s->gb, 8);
1534
1535         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1536         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1537
1538         t_w = get_bits(&s->gb, 8);
1539         t_h = get_bits(&s->gb, 8);
1540         if (t_w && t_h)
1541         {
1542             /* skip thumbnail */
1543             if (len-10-(t_w*t_h*3) > 0)
1544                 len -= t_w*t_h*3;
1545         }
1546         len -= 10;
1547         goto out;
1548     }
1549     
1550     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1551     {
1552         av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1553         skip_bits(&s->gb, 16); /* version */
1554         skip_bits(&s->gb, 16); /* flags0 */
1555         skip_bits(&s->gb, 16); /* flags1 */
1556         skip_bits(&s->gb, 8); /* transform */
1557         len -= 7;
1558         goto out;
1559     }
1560
1561     if (id == ff_get_fourcc("LJIF")){
1562         av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1563         skip_bits(&s->gb, 16); /* version ? */
1564         skip_bits(&s->gb, 16); /* unknwon always 0? */
1565         skip_bits(&s->gb, 16); /* unknwon always 0? */
1566         skip_bits(&s->gb, 16); /* unknwon always 0? */
1567         switch( get_bits(&s->gb, 8)){
1568         case 1:
1569             s->rgb= 1;
1570             s->pegasus_rct=0;
1571             break;
1572         case 2:
1573             s->rgb= 1;
1574             s->pegasus_rct=1;
1575             break;
1576         default:
1577             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1578         }
1579         len -= 9;
1580         goto out;
1581     }
1582     
1583     /* Apple MJPEG-A */
1584     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1585     {
1586         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1587         id = be2me_32(id);
1588         len -= 4;
1589         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1590         {
1591 #if 0
1592             skip_bits(&s->gb, 32); /* field size */
1593             skip_bits(&s->gb, 32); /* pad field size */
1594             skip_bits(&s->gb, 32); /* next off */
1595             skip_bits(&s->gb, 32); /* quant off */
1596             skip_bits(&s->gb, 32); /* huff off */
1597             skip_bits(&s->gb, 32); /* image off */
1598             skip_bits(&s->gb, 32); /* scan off */
1599             skip_bits(&s->gb, 32); /* data off */
1600 #endif
1601             if (s->first_picture)
1602                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1603         }
1604     }
1605
1606 out:
1607     /* slow but needed for extreme adobe jpegs */
1608     if (len < 0)
1609         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1610     while(--len > 0)
1611         skip_bits(&s->gb, 8);
1612
1613     return 0;
1614 }
1615
1616 static int mjpeg_decode_com(MJpegDecodeContext *s)
1617 {
1618     /* XXX: verify len field validity */
1619     int len = get_bits(&s->gb, 16);
1620     if (len >= 2 && len < 32768) {
1621         /* XXX: any better upper bound */
1622         uint8_t *cbuf = av_malloc(len - 1);
1623         if (cbuf) {
1624             int i;
1625             for (i = 0; i < len - 2; i++)
1626                 cbuf[i] = get_bits(&s->gb, 8);
1627             if (i > 0 && cbuf[i-1] == '\n')
1628                 cbuf[i-1] = 0;
1629             else
1630                 cbuf[i] = 0;
1631
1632             av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1633
1634             /* buggy avid, it puts EOI only at every 10th frame */
1635             if (!strcmp(cbuf, "AVID"))
1636             {
1637                 s->buggy_avid = 1;
1638                 //      if (s->first_picture)
1639                 //          printf("mjpeg: workarounding buggy AVID\n");
1640             }
1641
1642             av_free(cbuf);
1643         }
1644     }
1645
1646     return 0;
1647 }
1648
1649 #if 0
1650 static int valid_marker_list[] =
1651 {
1652         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1653 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1654 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1655 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1656 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1657 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1658 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1659 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1660 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1661 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1662 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1663 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1664 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1665 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1666 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1667 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1668 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1669 }
1670 #endif
1671
1672 /* return the 8 bit start code value and update the search
1673    state. Return -1 if no start code found */
1674 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1675 {
1676     uint8_t *buf_ptr;
1677     unsigned int v, v2;
1678     int val;
1679 #ifdef DEBUG
1680     int skipped=0;
1681 #endif
1682
1683     buf_ptr = *pbuf_ptr;
1684     while (buf_ptr < buf_end) {
1685         v = *buf_ptr++;
1686         v2 = *buf_ptr;
1687         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1688             val = *buf_ptr++;
1689             goto found;
1690         }
1691 #ifdef DEBUG
1692         skipped++;
1693 #endif
1694     }
1695     val = -1;
1696 found:
1697 #ifdef DEBUG
1698     dprintf("find_marker skipped %d bytes\n", skipped);
1699 #endif
1700     *pbuf_ptr = buf_ptr;
1701     return val;
1702 }
1703
1704 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1705                               void *data, int *data_size,
1706                               uint8_t *buf, int buf_size)
1707 {
1708     MJpegDecodeContext *s = avctx->priv_data;
1709     uint8_t *buf_end, *buf_ptr;
1710     int start_code;
1711     AVFrame *picture = data;
1712
1713     *data_size = 0;
1714
1715     /* no supplementary picture */
1716     if (buf_size == 0)
1717         return 0;
1718
1719     buf_ptr = buf;
1720     buf_end = buf + buf_size;
1721     while (buf_ptr < buf_end) {
1722         /* find start next marker */
1723         start_code = find_marker(&buf_ptr, buf_end);
1724         {
1725             /* EOF */
1726             if (start_code < 0) {
1727                 goto the_end;
1728             } else {
1729                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1730                 
1731                 if ((buf_end - buf_ptr) > s->buffer_size)
1732                 {
1733                     av_free(s->buffer);
1734                     s->buffer_size = buf_end-buf_ptr;
1735                     s->buffer = av_malloc(s->buffer_size);
1736                     dprintf("buffer too small, expanding to %d bytes\n",
1737                         s->buffer_size);
1738                 }
1739                 
1740                 /* unescape buffer of SOS */
1741                 if (start_code == SOS)
1742                 {
1743                     uint8_t *src = buf_ptr;
1744                     uint8_t *dst = s->buffer;
1745
1746                     while (src<buf_end)
1747                     {
1748                         uint8_t x = *(src++);
1749
1750                         *(dst++) = x;
1751                         if (x == 0xff)
1752                         {
1753                             while(*src == 0xff) src++;
1754
1755                             x = *(src++);
1756                             if (x >= 0xd0 && x <= 0xd7)
1757                                 *(dst++) = x;
1758                             else if (x)
1759                                 break;
1760                         }
1761                     }
1762                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1763                     
1764                     dprintf("escaping removed %d bytes\n",
1765                         (buf_end - buf_ptr) - (dst - s->buffer));
1766                 }
1767                 else
1768                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1769                 
1770                 s->start_code = start_code;
1771                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1772                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1773                 }
1774
1775                 /* process markers */
1776                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1777                     dprintf("restart marker: %d\n", start_code&0x0f);
1778                 } else if (s->first_picture) {
1779                     /* APP fields */
1780                     if (start_code >= 0xe0 && start_code <= 0xef)
1781                         mjpeg_decode_app(s);
1782                     /* Comment */
1783                     else if (start_code == COM)
1784                         mjpeg_decode_com(s);
1785                 }
1786
1787                 switch(start_code) {
1788                 case SOI:
1789                     s->restart_interval = 0;
1790                     /* nothing to do on SOI */
1791                     break;
1792                 case DQT:
1793                     mjpeg_decode_dqt(s);
1794                     break;
1795                 case DHT:
1796                     if(mjpeg_decode_dht(s) < 0){
1797                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1798                         return -1;
1799                     }
1800                     break;
1801                 case SOF0:
1802                     s->lossless=0;
1803                     if (mjpeg_decode_sof(s) < 0) 
1804                         return -1;
1805                     break;
1806                 case SOF3:
1807                     s->lossless=1;
1808                     if (mjpeg_decode_sof(s) < 0) 
1809                         return -1;
1810                     break;
1811                 case EOI:
1812                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1813                         break;
1814 eoi_parser:
1815                     {
1816                         if (s->interlaced) {
1817                             s->bottom_field ^= 1;
1818                             /* if not bottom field, do not output image yet */
1819                             if (s->bottom_field)
1820                                 goto not_the_end;
1821                         }
1822                         *picture = s->picture;
1823                         *data_size = sizeof(AVFrame);
1824
1825                         if(!s->lossless){
1826                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1827                             picture->qstride= 0;
1828                             picture->qscale_table= s->qscale_table;
1829                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1830                             if(avctx->debug & FF_DEBUG_QP)
1831                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1832                             picture->quality*= FF_QP2LAMBDA;
1833                         }
1834                         
1835                         goto the_end;
1836                     }
1837                     break;
1838                 case SOS:
1839                     mjpeg_decode_sos(s);
1840                     /* buggy avid puts EOI every 10-20th frame */
1841                     /* if restart period is over process EOI */
1842                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1843                         goto eoi_parser;
1844                     break;
1845                 case DRI:
1846                     mjpeg_decode_dri(s);
1847                     break;
1848                 case SOF1:
1849                 case SOF2:
1850                 case SOF5:
1851                 case SOF6:
1852                 case SOF7:
1853                 case SOF9:
1854                 case SOF10:
1855                 case SOF11:
1856                 case SOF13:
1857                 case SOF14:
1858                 case SOF15:
1859                 case JPG:
1860                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1861                     break;
1862 //              default:
1863 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1864 //                  break;
1865                 }
1866
1867 not_the_end:
1868                 /* eof process start code */
1869                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1870                 dprintf("marker parser used %d bytes (%d bits)\n",
1871                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1872             }
1873         }
1874     }
1875 the_end:
1876     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1877 //    return buf_end - buf_ptr;
1878     return buf_ptr - buf;
1879 }
1880
1881 static int mjpegb_decode_frame(AVCodecContext *avctx, 
1882                               void *data, int *data_size,
1883                               uint8_t *buf, int buf_size)
1884 {
1885     MJpegDecodeContext *s = avctx->priv_data;
1886     uint8_t *buf_end, *buf_ptr;
1887     AVFrame *picture = data;
1888     GetBitContext hgb; /* for the header */
1889     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1890     uint32_t field_size;
1891
1892     *data_size = 0;
1893
1894     /* no supplementary picture */
1895     if (buf_size == 0)
1896         return 0;
1897
1898     buf_ptr = buf;
1899     buf_end = buf + buf_size;
1900     
1901 read_header:
1902     /* reset on every SOI */
1903     s->restart_interval = 0;
1904
1905     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1906
1907     skip_bits(&hgb, 32); /* reserved zeros */
1908     
1909     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1910     {
1911         dprintf("not mjpeg-b (bad fourcc)\n");
1912         return 0;
1913     }
1914
1915     field_size = get_bits(&hgb, 32); /* field size */
1916     dprintf("field size: 0x%x\n", field_size);
1917     skip_bits(&hgb, 32); /* padded field size */
1918     second_field_offs = get_bits(&hgb, 32);
1919     dprintf("second field offs: 0x%x\n", second_field_offs);
1920     if (second_field_offs)
1921         s->interlaced = 1;
1922
1923     dqt_offs = get_bits(&hgb, 32);
1924     dprintf("dqt offs: 0x%x\n", dqt_offs);
1925     if (dqt_offs)
1926     {
1927         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1928         s->start_code = DQT;
1929         mjpeg_decode_dqt(s);
1930     }
1931     
1932     dht_offs = get_bits(&hgb, 32);
1933     dprintf("dht offs: 0x%x\n", dht_offs);
1934     if (dht_offs)
1935     {
1936         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1937         s->start_code = DHT;
1938         mjpeg_decode_dht(s);
1939     }
1940
1941     sof_offs = get_bits(&hgb, 32);
1942     dprintf("sof offs: 0x%x\n", sof_offs);
1943     if (sof_offs)
1944     {
1945         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1946         s->start_code = SOF0;
1947         if (mjpeg_decode_sof(s) < 0)
1948             return -1;
1949     }
1950
1951     sos_offs = get_bits(&hgb, 32);
1952     dprintf("sos offs: 0x%x\n", sos_offs);
1953     if (sos_offs)
1954     {
1955 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1956         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1957         s->start_code = SOS;
1958         mjpeg_decode_sos(s);
1959     }
1960
1961     skip_bits(&hgb, 32); /* start of data offset */
1962
1963     if (s->interlaced) {
1964         s->bottom_field ^= 1;
1965         /* if not bottom field, do not output image yet */
1966         if (s->bottom_field && second_field_offs)
1967         {
1968             buf_ptr = buf + second_field_offs;
1969             second_field_offs = 0;
1970             goto read_header;
1971         }
1972     }
1973
1974     //XXX FIXME factorize, this looks very similar to the EOI code
1975
1976     *picture= s->picture;
1977     *data_size = sizeof(AVFrame);
1978     
1979     if(!s->lossless){
1980         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1981         picture->qstride= 0;
1982         picture->qscale_table= s->qscale_table;
1983         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1984         if(avctx->debug & FF_DEBUG_QP)
1985             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1986         picture->quality*= FF_QP2LAMBDA;
1987     }
1988
1989     return buf_ptr - buf;
1990 }
1991
1992 #include "sp5x.h"
1993
1994 static int sp5x_decode_frame(AVCodecContext *avctx, 
1995                               void *data, int *data_size,
1996                               uint8_t *buf, int buf_size)
1997 {
1998 #if 0
1999     MJpegDecodeContext *s = avctx->priv_data;
2000 #endif
2001     const int qscale = 5;
2002     uint8_t *buf_ptr, *buf_end, *recoded;
2003     int i = 0, j = 0;
2004
2005     *data_size = 0;
2006
2007     /* no supplementary picture */
2008     if (buf_size == 0)
2009         return 0;
2010
2011     if (!avctx->width || !avctx->height)
2012         return -1;
2013
2014     buf_ptr = buf;
2015     buf_end = buf + buf_size;
2016
2017 #if 1
2018     recoded = av_mallocz(buf_size + 1024);
2019     if (!recoded)
2020         return -1;
2021
2022     /* SOI */
2023     recoded[j++] = 0xFF;
2024     recoded[j++] = 0xD8;
2025
2026     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2027     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2028     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2029     j += sizeof(sp5x_data_dqt);
2030
2031     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2032     j += sizeof(sp5x_data_dht);
2033
2034     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2035     recoded[j+5] = (avctx->height >> 8) & 0xFF;
2036     recoded[j+6] = avctx->height & 0xFF;
2037     recoded[j+7] = (avctx->width >> 8) & 0xFF;
2038     recoded[j+8] = avctx->width & 0xFF;
2039     j += sizeof(sp5x_data_sof);
2040
2041     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2042     j += sizeof(sp5x_data_sos);
2043
2044     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2045     {
2046         recoded[j++] = buf[i];
2047         if (buf[i] == 0xff)
2048             recoded[j++] = 0;
2049     }
2050
2051     /* EOI */
2052     recoded[j++] = 0xFF;
2053     recoded[j++] = 0xD9;
2054
2055     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2056
2057     av_free(recoded);
2058
2059 #else
2060     /* SOF */
2061     s->bits = 8;
2062     s->width = avctx->width;
2063     s->height = avctx->height;
2064     s->nb_components = 3;
2065     s->component_id[0] = 0;
2066     s->h_count[0] = 2;
2067     s->v_count[0] = 2;
2068     s->quant_index[0] = 0;
2069     s->component_id[1] = 1;
2070     s->h_count[1] = 1;
2071     s->v_count[1] = 1;
2072     s->quant_index[1] = 1;
2073     s->component_id[2] = 2;
2074     s->h_count[2] = 1;
2075     s->v_count[2] = 1;
2076     s->quant_index[2] = 1;
2077     s->h_max = 2;
2078     s->v_max = 2;
2079     
2080     s->qscale_table = av_mallocz((s->width+15)/16);
2081     avctx->pix_fmt = PIX_FMT_YUV420P;
2082     s->interlaced = 0;
2083     
2084     s->picture.reference = 0;
2085     if (avctx->get_buffer(avctx, &s->picture) < 0)
2086     {
2087         fprintf(stderr, "get_buffer() failed\n");
2088         return -1;
2089     }
2090
2091     s->picture.pict_type = I_TYPE;
2092     s->picture.key_frame = 1;
2093
2094     for (i = 0; i < 3; i++)
2095         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2096
2097     /* DQT */
2098     for (i = 0; i < 64; i++)
2099     {
2100         j = s->scantable.permutated[i];
2101         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2102     }
2103     s->qscale[0] = FFMAX(
2104         s->quant_matrixes[0][s->scantable.permutated[1]],
2105         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2106
2107     for (i = 0; i < 64; i++)
2108     {
2109         j = s->scantable.permutated[i];
2110         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2111     }
2112     s->qscale[1] = FFMAX(
2113         s->quant_matrixes[1][s->scantable.permutated[1]],
2114         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2115
2116     /* DHT */
2117
2118     /* SOS */
2119     s->comp_index[0] = 0;
2120     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2121     s->h_scount[0] = s->h_count[0];
2122     s->v_scount[0] = s->v_count[0];
2123     s->dc_index[0] = 0;
2124     s->ac_index[0] = 0;
2125
2126     s->comp_index[1] = 1;
2127     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2128     s->h_scount[1] = s->h_count[1];
2129     s->v_scount[1] = s->v_count[1];
2130     s->dc_index[1] = 1;
2131     s->ac_index[1] = 1;
2132
2133     s->comp_index[2] = 2;
2134     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2135     s->h_scount[2] = s->h_count[2];
2136     s->v_scount[2] = s->v_count[2];
2137     s->dc_index[2] = 1;
2138     s->ac_index[2] = 1;
2139     
2140     for (i = 0; i < 3; i++)
2141         s->last_dc[i] = 1024;
2142
2143     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2144     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2145
2146     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2147     
2148     return mjpeg_decode_scan(s);
2149 #endif
2150
2151     return i;
2152 }
2153
2154 static int mjpeg_decode_end(AVCodecContext *avctx)
2155 {
2156     MJpegDecodeContext *s = avctx->priv_data;
2157     int i, j;
2158
2159     av_free(s->buffer);
2160     av_free(s->qscale_table);
2161     avcodec_default_free_buffers(avctx);
2162     
2163     for(i=0;i<2;i++) {
2164         for(j=0;j<4;j++)
2165             free_vlc(&s->vlcs[i][j]);
2166     }
2167     return 0;
2168 }
2169
2170 AVCodec mjpeg_decoder = {
2171     "mjpeg",
2172     CODEC_TYPE_VIDEO,
2173     CODEC_ID_MJPEG,
2174     sizeof(MJpegDecodeContext),
2175     mjpeg_decode_init,
2176     NULL,
2177     mjpeg_decode_end,
2178     mjpeg_decode_frame,
2179     CODEC_CAP_DR1,
2180     NULL
2181 };
2182
2183 AVCodec mjpegb_decoder = {
2184     "mjpegb",
2185     CODEC_TYPE_VIDEO,
2186     CODEC_ID_MJPEGB,
2187     sizeof(MJpegDecodeContext),
2188     mjpeg_decode_init,
2189     NULL,
2190     mjpeg_decode_end,
2191     mjpegb_decode_frame,
2192     CODEC_CAP_DR1,
2193     NULL
2194 };
2195
2196 AVCodec sp5x_decoder = {
2197     "sp5x",
2198     CODEC_TYPE_VIDEO,
2199     CODEC_ID_SP5X,
2200     sizeof(MJpegDecodeContext),
2201     mjpeg_decode_init,
2202     NULL,
2203     mjpeg_decode_end,
2204     sp5x_decode_frame,
2205     CODEC_CAP_DR1,
2206     NULL
2207 };
2208
2209 #ifdef CONFIG_ENCODERS
2210 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2211     "ljpeg",
2212     CODEC_TYPE_VIDEO,
2213     CODEC_ID_LJPEG,
2214     sizeof(MpegEncContext),
2215     MPV_encode_init,
2216     encode_picture_lossless,
2217     MPV_encode_end,
2218 };
2219 #endif