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