always parse APP* as it sometimes contains startcodes which confuse the decoder otherwise
[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", 1); /* 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, 1);
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= put_bits_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 ff_mjpeg_stuffing(PutBitContext * pbc)
535 {
536     int length;
537     length= (-put_bits_count(pbc))&7;
538     if(length) put_bits(pbc, length, (1<<length)-1);
539 }
540
541 void mjpeg_picture_trailer(MpegEncContext *s)
542 {
543     ff_mjpeg_stuffing(&s->pb);
544     flush_put_bits(&s->pb);
545
546     assert((s->header_bits&7)==0);
547     
548     escape_FF(s, s->header_bits>>3);
549
550     put_marker(&s->pb, EOI);
551 }
552
553 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
554                                    uint8_t *huff_size, uint16_t *huff_code)
555 {
556     int mant, nbits;
557
558     if (val == 0) {
559         put_bits(&s->pb, huff_size[0], huff_code[0]);
560     } else {
561         mant = val;
562         if (val < 0) {
563             val = -val;
564             mant--;
565         }
566         
567         nbits= av_log2_16bit(val) + 1;
568             
569         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
570         
571         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
572     }
573 }
574
575 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
576 {
577     int mant, nbits, code, i, j;
578     int component, dc, run, last_index, val;
579     MJpegContext *m = s->mjpeg_ctx;
580     uint8_t *huff_size_ac;
581     uint16_t *huff_code_ac;
582     
583     /* DC coef */
584     component = (n <= 3 ? 0 : n - 4 + 1);
585     dc = block[0]; /* overflow is impossible */
586     val = dc - s->last_dc[component];
587     if (n < 4) {
588         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
589         huff_size_ac = m->huff_size_ac_luminance;
590         huff_code_ac = m->huff_code_ac_luminance;
591     } else {
592         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
593         huff_size_ac = m->huff_size_ac_chrominance;
594         huff_code_ac = m->huff_code_ac_chrominance;
595     }
596     s->last_dc[component] = dc;
597     
598     /* AC coefs */
599     
600     run = 0;
601     last_index = s->block_last_index[n];
602     for(i=1;i<=last_index;i++) {
603         j = s->intra_scantable.permutated[i];
604         val = block[j];
605         if (val == 0) {
606             run++;
607         } else {
608             while (run >= 16) {
609                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
610                 run -= 16;
611             }
612             mant = val;
613             if (val < 0) {
614                 val = -val;
615                 mant--;
616             }
617             
618             nbits= av_log2(val) + 1;
619             code = (run << 4) | nbits;
620
621             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
622         
623             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
624             run = 0;
625         }
626     }
627
628     /* output EOB only if not already 64 values */
629     if (last_index < 63 || run != 0)
630         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
631 }
632
633 void mjpeg_encode_mb(MpegEncContext *s, 
634                      DCTELEM block[6][64])
635 {
636     int i;
637     for(i=0;i<6;i++) {
638         encode_block(s, block[i], i);
639     }
640 }
641
642 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
643     MpegEncContext * const s = avctx->priv_data;
644     MJpegContext * const m = s->mjpeg_ctx;
645     AVFrame *pict = data;
646     const int width= s->width;
647     const int height= s->height;
648     AVFrame * const p= (AVFrame*)&s->current_picture;
649     const int predictor= avctx->prediction_method+1;
650
651     init_put_bits(&s->pb, buf, buf_size);
652
653     *p = *pict;
654     p->pict_type= FF_I_TYPE;
655     p->key_frame= 1;
656     
657     mjpeg_picture_header(s);
658
659     s->header_bits= put_bits_count(&s->pb);
660
661     if(avctx->pix_fmt == PIX_FMT_RGBA32){
662         int x, y, i;
663         const int linesize= p->linesize[0];
664         uint16_t buffer[2048][4];
665         int left[3], top[3], topleft[3];
666
667         for(i=0; i<3; i++){
668             buffer[0][i]= 1 << (9 - 1);
669         }
670
671         for(y = 0; y < height; y++) {
672             const int modified_predictor= y ? predictor : 1;
673             uint8_t *ptr = p->data[0] + (linesize * y);
674
675             for(i=0; i<3; i++){
676                 top[i]= left[i]= topleft[i]= buffer[0][i];
677             }
678             for(x = 0; x < width; x++) {
679                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
680                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
681                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
682
683                 for(i=0;i<3;i++) {
684                     int pred, diff;
685
686                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
687                         
688                     topleft[i]= top[i];
689                     top[i]= buffer[x+1][i];
690                     
691                     left[i]= buffer[x][i];
692
693                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
694                     
695                     if(i==0)
696                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
697                     else
698                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
699                 }
700             }
701         }
702     }else{
703         int mb_x, mb_y, i;
704         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
705         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
706         
707         for(mb_y = 0; mb_y < mb_height; mb_y++) {
708             for(mb_x = 0; mb_x < mb_width; mb_x++) {
709                 if(mb_x==0 || mb_y==0){
710                     for(i=0;i<3;i++) {
711                         uint8_t *ptr;
712                         int x, y, h, v, linesize;
713                         h = s->mjpeg_hsample[i];
714                         v = s->mjpeg_vsample[i];
715                         linesize= p->linesize[i];
716
717                         for(y=0; y<v; y++){
718                             for(x=0; x<h; x++){
719                                 int pred;
720
721                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
722                                 if(y==0 && mb_y==0){
723                                     if(x==0 && mb_x==0){
724                                         pred= 128;
725                                     }else{
726                                         pred= ptr[-1];
727                                     }
728                                 }else{
729                                     if(x==0 && mb_x==0){
730                                         pred= ptr[-linesize];
731                                     }else{
732                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
733                                     }
734                                 }
735                                 
736                                 if(i==0)
737                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
738                                 else
739                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
740                             }
741                         }
742                     }
743                 }else{
744                     for(i=0;i<3;i++) {
745                         uint8_t *ptr;
746                         int x, y, h, v, linesize;
747                         h = s->mjpeg_hsample[i];
748                         v = s->mjpeg_vsample[i];
749                         linesize= p->linesize[i];
750                              
751                         for(y=0; y<v; y++){
752                             for(x=0; x<h; x++){
753                                 int pred;
754
755                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
756 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); 
757                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
758
759                                 if(i==0)
760                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
761                                 else
762                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
763                             }
764                         }
765                     }
766                 }
767             }
768         }
769     }
770
771     emms_c();
772     
773     mjpeg_picture_trailer(s);
774     s->picture_number++;
775
776     flush_put_bits(&s->pb);
777     return pbBufPtr(&s->pb) - s->pb.buf;
778 //    return (put_bits_count(&f->pb)+7)/8;
779 }
780
781 #endif //CONFIG_ENCODERS
782
783 /******************************************/
784 /* decoding */
785
786 #define MAX_COMPONENTS 4
787
788 typedef struct MJpegDecodeContext {
789     AVCodecContext *avctx;
790     GetBitContext gb;
791     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
792
793     int start_code; /* current start code */
794     int buffer_size;
795     uint8_t *buffer;
796
797     int16_t quant_matrixes[4][64];
798     VLC vlcs[2][4];
799     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
800
801     int org_height;  /* size given at codec init */
802     int first_picture;    /* true if decoding first picture */
803     int interlaced;     /* true if interlaced */
804     int bottom_field;   /* true if bottom field */
805     int lossless;
806     int rgb;
807     int rct;            /* standard rct */  
808     int pegasus_rct;    /* pegasus reversible colorspace transform */  
809     int bits;           /* bits per component */
810
811     int width, height;
812     int mb_width, mb_height;
813     int nb_components;
814     int component_id[MAX_COMPONENTS];
815     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
816     int v_count[MAX_COMPONENTS];
817     int comp_index[MAX_COMPONENTS];
818     int dc_index[MAX_COMPONENTS];
819     int ac_index[MAX_COMPONENTS];
820     int nb_blocks[MAX_COMPONENTS];
821     int h_scount[MAX_COMPONENTS];
822     int v_scount[MAX_COMPONENTS];
823     int h_max, v_max; /* maximum h and v counts */
824     int quant_index[4];   /* quant table index for each component */
825     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
826     AVFrame picture; /* picture structure */
827     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
828     uint8_t *qscale_table;
829     DCTELEM block[64] __align8;
830     ScanTable scantable;
831     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
832
833     int restart_interval;
834     int restart_count;
835
836     int buggy_avid;
837     int interlace_polarity;
838 } MJpegDecodeContext;
839
840 static int mjpeg_decode_dht(MJpegDecodeContext *s);
841
842 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
843                       int nb_codes)
844 {
845     uint8_t huff_size[256];
846     uint16_t huff_code[256];
847
848     memset(huff_size, 0, sizeof(huff_size));
849     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
850     
851     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
852 }
853
854 static int mjpeg_decode_init(AVCodecContext *avctx)
855 {
856     MJpegDecodeContext *s = avctx->priv_data;
857     MpegEncContext s2;
858
859     s->avctx = avctx;
860
861     /* ugly way to get the idct & scantable FIXME */
862     memset(&s2, 0, sizeof(MpegEncContext));
863     s2.avctx= avctx;
864 //    s2->out_format = FMT_MJPEG;
865     dsputil_init(&s2.dsp, avctx);
866     DCT_common_init(&s2);
867
868     s->scantable= s2.intra_scantable;
869     s->idct_put= s2.dsp.idct_put;
870
871     s->mpeg_enc_ctx_allocated = 0;
872     s->buffer_size = 102400; /* smaller buffer should be enough,
873                                 but photojpg files could ahive bigger sizes */
874     s->buffer = av_malloc(s->buffer_size);
875     if (!s->buffer)
876         return -1;
877     s->start_code = -1;
878     s->first_picture = 1;
879     s->org_height = avctx->height;
880     
881     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
882     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
883     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
884     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
885
886     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
887     {
888         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
889         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
890         mjpeg_decode_dht(s);
891         /* should check for error - but dunno */
892     }
893
894     return 0;
895 }
896
897 /* quantize tables */
898 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
899 {
900     int len, index, i, j;
901     
902     len = get_bits(&s->gb, 16) - 2;
903
904     while (len >= 65) {
905         /* only 8 bit precision handled */
906         if (get_bits(&s->gb, 4) != 0)
907         {
908             dprintf("dqt: 16bit precision\n");
909             return -1;
910         }
911         index = get_bits(&s->gb, 4);
912         if (index >= 4)
913             return -1;
914         dprintf("index=%d\n", index);
915         /* read quant table */
916         for(i=0;i<64;i++) {
917             j = s->scantable.permutated[i];
918             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
919         }
920
921         //XXX FIXME finetune, and perhaps add dc too
922         s->qscale[index]= FFMAX(
923             s->quant_matrixes[index][s->scantable.permutated[1]],
924             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
925         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
926         len -= 65;
927     }
928     
929     return 0;
930 }
931
932 /* decode huffman tables and build VLC decoders */
933 static int mjpeg_decode_dht(MJpegDecodeContext *s)
934 {
935     int len, index, i, class, n, v, code_max;
936     uint8_t bits_table[17];
937     uint8_t val_table[256];
938     
939     len = get_bits(&s->gb, 16) - 2;
940
941     while (len > 0) {
942         if (len < 17)
943             return -1;
944         class = get_bits(&s->gb, 4);
945         if (class >= 2)
946             return -1;
947         index = get_bits(&s->gb, 4);
948         if (index >= 4)
949             return -1;
950         n = 0;
951         for(i=1;i<=16;i++) {
952             bits_table[i] = get_bits(&s->gb, 8);
953             n += bits_table[i];
954         }
955         len -= 17;
956         if (len < n || n > 256)
957             return -1;
958
959         code_max = 0;
960         for(i=0;i<n;i++) {
961             v = get_bits(&s->gb, 8);
962             if (v > code_max)
963                 code_max = v;
964             val_table[i] = v;
965         }
966         len -= n;
967
968         /* build VLC and flush previous vlc if present */
969         free_vlc(&s->vlcs[class][index]);
970         dprintf("class=%d index=%d nb_codes=%d\n",
971                class, index, code_max + 1);
972         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
973             return -1;
974         }
975     }
976     return 0;
977 }
978
979 static int mjpeg_decode_sof(MJpegDecodeContext *s)
980 {
981     int len, nb_components, i, width, height;
982
983     /* XXX: verify len field validity */
984     len = get_bits(&s->gb, 16);
985     s->bits= get_bits(&s->gb, 8);
986     
987     if(s->pegasus_rct) s->bits=9;  
988     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
989
990     if (s->bits != 8 && !s->lossless){
991         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
992         return -1;
993     }
994     height = get_bits(&s->gb, 16);
995     width = get_bits(&s->gb, 16);
996     dprintf("sof0: picture: %dx%d\n", width, height);
997
998     nb_components = get_bits(&s->gb, 8);
999     if (nb_components <= 0 ||
1000         nb_components > MAX_COMPONENTS)
1001         return -1;
1002     s->nb_components = nb_components;
1003     s->h_max = 1;
1004     s->v_max = 1;
1005     for(i=0;i<nb_components;i++) {
1006         /* component id */
1007         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1008         s->h_count[i] = get_bits(&s->gb, 4);
1009         s->v_count[i] = get_bits(&s->gb, 4);
1010         /* compute hmax and vmax (only used in interleaved case) */
1011         if (s->h_count[i] > s->h_max)
1012             s->h_max = s->h_count[i];
1013         if (s->v_count[i] > s->v_max)
1014             s->v_max = s->v_count[i];
1015         s->quant_index[i] = get_bits(&s->gb, 8);
1016         if (s->quant_index[i] >= 4)
1017             return -1;
1018         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1019             s->v_count[i], s->component_id[i], s->quant_index[i]);
1020     }
1021     
1022     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1023
1024     /* if different size, realloc/alloc picture */
1025     /* XXX: also check h_count and v_count */
1026     if (width != s->width || height != s->height) {
1027         av_freep(&s->qscale_table);
1028             
1029         s->width = width;
1030         s->height = height;
1031         s->avctx->width = s->width;
1032         s->avctx->height = s->height;
1033
1034         /* test interlaced mode */
1035         if (s->first_picture &&
1036             s->org_height != 0 &&
1037             s->height < ((s->org_height * 3) / 4)) {
1038             s->interlaced = 1;
1039 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1040             s->bottom_field = 0;
1041             s->avctx->height *= 2;
1042         }
1043
1044         s->qscale_table= av_mallocz((s->width+15)/16);
1045
1046         s->first_picture = 0;
1047     }
1048     
1049     if(s->interlaced && s->bottom_field)
1050         return 0;
1051  
1052     /* XXX: not complete test ! */
1053     switch((s->h_count[0] << 4) | s->v_count[0]) {
1054     case 0x11:
1055         if(s->rgb){
1056             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1057         }else if(s->nb_components==3)
1058             s->avctx->pix_fmt = PIX_FMT_YUV444P;
1059         else
1060             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1061         break;
1062     case 0x21:
1063         s->avctx->pix_fmt = PIX_FMT_YUV422P;
1064         break;
1065     default:
1066     case 0x22:
1067         s->avctx->pix_fmt = PIX_FMT_YUV420P;
1068         break;
1069     }
1070
1071     if(s->picture.data[0])
1072         s->avctx->release_buffer(s->avctx, &s->picture);
1073
1074     s->picture.reference= 0;
1075     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1076         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1077         return -1;
1078     }
1079     s->picture.pict_type= I_TYPE;
1080     s->picture.key_frame= 1;
1081     
1082     for(i=0; i<3; i++){
1083         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1084     }
1085
1086 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1087     
1088     if (len != (8+(3*nb_components)))
1089     {
1090         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1091     }
1092     
1093     return 0;
1094 }
1095
1096 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1097 {
1098     int code;
1099     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1100     if (code < 0)
1101     {
1102         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1103                 &s->vlcs[0][dc_index]);
1104         return 0xffff;
1105     }
1106
1107     if(code)
1108         return get_xbits(&s->gb, code);
1109     else
1110         return 0;
1111 }
1112
1113 /* decode block and dequantize */
1114 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1115                         int component, int dc_index, int ac_index, int quant_index)
1116 {
1117     int code, i, j, level, val;
1118     VLC *ac_vlc;
1119     int16_t *quant_matrix;
1120
1121     /* DC coef */
1122     val = mjpeg_decode_dc(s, dc_index);
1123     if (val == 0xffff) {
1124         dprintf("error dc\n");
1125         return -1;
1126     }
1127     quant_matrix = s->quant_matrixes[quant_index];
1128     val = val * quant_matrix[0] + s->last_dc[component];
1129     s->last_dc[component] = val;
1130     block[0] = val;
1131     /* AC coefs */
1132     ac_vlc = &s->vlcs[1][ac_index];
1133     i = 1;
1134     for(;;) {
1135         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1136
1137         if (code < 0) {
1138             dprintf("error ac\n");
1139             return -1;
1140         }
1141         /* EOB */
1142         if (code == 0)
1143             break;
1144         if (code == 0xf0) {
1145             i += 16;
1146         } else {
1147             level = get_xbits(&s->gb, code & 0xf);
1148             i += code >> 4;
1149             if (i >= 64) {
1150                 dprintf("error count: %d\n", i);
1151                 return -1;
1152             }
1153             j = s->scantable.permutated[i];
1154             block[j] = level * quant_matrix[j];
1155             i++;
1156             if (i >= 64)
1157                 break;
1158         }
1159     }
1160     return 0;
1161 }
1162
1163 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1164     int i, mb_x, mb_y;
1165     uint16_t buffer[2048][4];
1166     int left[3], top[3], topleft[3];
1167     const int linesize= s->linesize[0];
1168     const int mask= (1<<s->bits)-1;
1169     
1170     for(i=0; i<3; i++){
1171         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1172     }
1173     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1174         const int modified_predictor= mb_y ? predictor : 1;
1175         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1176
1177         if (s->interlaced && s->bottom_field)
1178             ptr += linesize >> 1;
1179
1180         for(i=0; i<3; i++){
1181             top[i]= left[i]= topleft[i]= buffer[0][i];
1182         }
1183         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1184             if (s->restart_interval && !s->restart_count)
1185                 s->restart_count = s->restart_interval;
1186
1187             for(i=0;i<3;i++) {
1188                 int pred;
1189
1190                 topleft[i]= top[i];
1191                 top[i]= buffer[mb_x][i];
1192
1193                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1194                 
1195                 left[i]= 
1196                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1197             }
1198
1199             if (s->restart_interval && !--s->restart_count) {
1200                 align_get_bits(&s->gb);
1201                 skip_bits(&s->gb, 16); /* skip RSTn */
1202             }
1203         }
1204
1205         if(s->rct){
1206             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1207                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1208                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1209                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1210             }
1211         }else if(s->pegasus_rct){
1212             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1213                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1214                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1215                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1216             }
1217         }else{
1218             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1219                 ptr[4*mb_x+0] = buffer[mb_x][0];
1220                 ptr[4*mb_x+1] = buffer[mb_x][1];
1221                 ptr[4*mb_x+2] = buffer[mb_x][2];
1222             }
1223         }
1224     }
1225     return 0;
1226 }
1227
1228 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1229     int i, mb_x, mb_y;
1230     const int nb_components=3;
1231
1232     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1233         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1234             if (s->restart_interval && !s->restart_count)
1235                 s->restart_count = s->restart_interval;
1236
1237             if(mb_x==0 || mb_y==0 || s->interlaced){
1238                 for(i=0;i<nb_components;i++) {
1239                     uint8_t *ptr;
1240                     int n, h, v, x, y, c, j, linesize;
1241                     n = s->nb_blocks[i];
1242                     c = s->comp_index[i];
1243                     h = s->h_scount[i];
1244                     v = s->v_scount[i];
1245                     x = 0;
1246                     y = 0;
1247                     linesize= s->linesize[c];
1248                     
1249                     for(j=0; j<n; j++) {
1250                         int pred;
1251
1252                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1253                         if(y==0 && mb_y==0){
1254                             if(x==0 && mb_x==0){
1255                                 pred= 128 << point_transform;
1256                             }else{
1257                                 pred= ptr[-1];
1258                             }
1259                         }else{
1260                             if(x==0 && mb_x==0){
1261                                 pred= ptr[-linesize];
1262                             }else{
1263                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1264                             }
1265                         }
1266                         
1267                         if (s->interlaced && s->bottom_field)
1268                             ptr += linesize >> 1;
1269                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1270
1271                         if (++x == h) {
1272                             x = 0;
1273                             y++;
1274                         }
1275                     }
1276                 }
1277             }else{
1278                 for(i=0;i<nb_components;i++) {
1279                     uint8_t *ptr;
1280                     int n, h, v, x, y, c, j, linesize;
1281                     n = s->nb_blocks[i];
1282                     c = s->comp_index[i];
1283                     h = s->h_scount[i];
1284                     v = s->v_scount[i];
1285                     x = 0;
1286                     y = 0;
1287                     linesize= s->linesize[c];
1288                     
1289                     for(j=0; j<n; j++) {
1290                         int pred;
1291
1292                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1293                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1294                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1295                         if (++x == h) {
1296                             x = 0;
1297                             y++;
1298                         }
1299                     }
1300                 }
1301             }
1302             if (s->restart_interval && !--s->restart_count) {
1303                 align_get_bits(&s->gb);
1304                 skip_bits(&s->gb, 16); /* skip RSTn */
1305             }
1306         }
1307     }
1308     return 0;
1309 }
1310
1311 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1312     int i, mb_x, mb_y;
1313     const int nb_components=3;
1314
1315     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1316         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1317             if (s->restart_interval && !s->restart_count)
1318                 s->restart_count = s->restart_interval;
1319
1320             for(i=0;i<nb_components;i++) {
1321                 uint8_t *ptr;
1322                 int n, h, v, x, y, c, j;
1323                 n = s->nb_blocks[i];
1324                 c = s->comp_index[i];
1325                 h = s->h_scount[i];
1326                 v = s->v_scount[i];
1327                 x = 0;
1328                 y = 0;
1329                 for(j=0;j<n;j++) {
1330                     memset(s->block, 0, sizeof(s->block));
1331                     if (decode_block(s, s->block, i, 
1332                                      s->dc_index[i], s->ac_index[i], 
1333                                      s->quant_index[c]) < 0) {
1334                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1335                         return -1;
1336                     }
1337 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1338                     ptr = s->picture.data[c] + 
1339                         (s->linesize[c] * (v * mb_y + y) * 8) + 
1340                         (h * mb_x + x) * 8;
1341                     if (s->interlaced && s->bottom_field)
1342                         ptr += s->linesize[c] >> 1;
1343 //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);
1344                     s->idct_put(ptr, s->linesize[c], s->block);
1345                     if (++x == h) {
1346                         x = 0;
1347                         y++;
1348                     }
1349                 }
1350             }
1351             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1352             if (s->restart_interval && (s->restart_interval < 1350) &&
1353                 !--s->restart_count) {
1354                 align_get_bits(&s->gb);
1355                 skip_bits(&s->gb, 16); /* skip RSTn */
1356                 for (i=0; i<nb_components; i++) /* reset dc */
1357                     s->last_dc[i] = 1024;
1358             }
1359         }
1360     }
1361     return 0;
1362 }
1363
1364 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1365 {
1366     int len, nb_components, i, h, v, predictor, point_transform;
1367     int vmax, hmax, index, id;
1368     const int block_size= s->lossless ? 1 : 8;
1369
1370     /* XXX: verify len field validity */
1371     len = get_bits(&s->gb, 16);
1372     nb_components = get_bits(&s->gb, 8);
1373     if (len != 6+2*nb_components)
1374     {
1375         dprintf("decode_sos: invalid len (%d)\n", len);
1376         return -1;
1377     }
1378     /* XXX: only interleaved scan accepted */
1379     if (nb_components != s->nb_components)
1380     {
1381         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1382         return -1;
1383     }
1384     vmax = 0;
1385     hmax = 0;
1386     for(i=0;i<nb_components;i++) {
1387         id = get_bits(&s->gb, 8) - 1;
1388         dprintf("component: %d\n", id);
1389         /* find component index */
1390         for(index=0;index<s->nb_components;index++)
1391             if (id == s->component_id[index])
1392                 break;
1393         if (index == s->nb_components)
1394         {
1395             dprintf("decode_sos: index(%d) out of components\n", index);
1396             return -1;
1397         }
1398
1399         s->comp_index[i] = index;
1400
1401         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1402         s->h_scount[i] = s->h_count[index];
1403         s->v_scount[i] = s->v_count[index];
1404
1405         s->dc_index[i] = get_bits(&s->gb, 4);
1406         s->ac_index[i] = get_bits(&s->gb, 4);
1407
1408         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1409             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1410             goto out_of_range;
1411 #if 0 //buggy
1412         switch(s->start_code)
1413         {
1414             case SOF0:
1415                 if (dc_index[i] > 1 || ac_index[i] > 1)
1416                     goto out_of_range;
1417                 break;
1418             case SOF1:
1419             case SOF2:
1420                 if (dc_index[i] > 3 || ac_index[i] > 3)
1421                     goto out_of_range;
1422                 break;
1423             case SOF3:
1424                 if (dc_index[i] > 3 || ac_index[i] != 0)
1425                     goto out_of_range;
1426                 break;  
1427         }
1428 #endif
1429     }
1430
1431     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1432     skip_bits(&s->gb, 8); /* Se */
1433     skip_bits(&s->gb, 4); /* Ah */
1434     point_transform= get_bits(&s->gb, 4); /* Al */
1435
1436     for(i=0;i<nb_components;i++) 
1437         s->last_dc[i] = 1024;
1438
1439     if (nb_components > 1) {
1440         /* interleaved stream */
1441         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1442         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1443     } else {
1444         h = s->h_max / s->h_scount[s->comp_index[0]];
1445         v = s->v_max / s->v_scount[s->comp_index[0]];
1446         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1447         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1448         s->nb_blocks[0] = 1;
1449         s->h_scount[0] = 1;
1450         s->v_scount[0] = 1;
1451     }
1452
1453     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1454         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1455     
1456     if(s->lossless){
1457             if(s->rgb){
1458                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1459                     return -1;
1460             }else{
1461                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1462                     return -1;
1463             }
1464     }else{
1465         if(mjpeg_decode_scan(s) < 0)
1466             return -1;
1467     }
1468     emms_c();
1469     return 0;
1470  out_of_range:
1471     dprintf("decode_sos: ac/dc index out of range\n");
1472     return -1;
1473 }
1474
1475 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1476 {
1477     if (get_bits(&s->gb, 16) != 4)
1478         return -1;
1479     s->restart_interval = get_bits(&s->gb, 16);
1480     dprintf("restart interval: %d\n", s->restart_interval);
1481
1482     return 0;
1483 }
1484
1485 static int mjpeg_decode_app(MJpegDecodeContext *s)
1486 {
1487     int len, id;
1488
1489     /* XXX: verify len field validity */
1490     len = get_bits(&s->gb, 16);
1491     if (len < 5)
1492         return -1;
1493
1494     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1495     id = be2me_32(id);
1496     len -= 6;
1497
1498     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1499         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1500     }
1501     
1502     /* buggy AVID, it puts EOI only at every 10th frame */
1503     /* also this fourcc is used by non-avid files too, it holds some
1504        informations, but it's always present in AVID creates files */
1505     if (id == ff_get_fourcc("AVI1"))
1506     {
1507         /* structure:
1508             4bytes      AVI1
1509             1bytes      polarity
1510             1bytes      always zero
1511             4bytes      field_size
1512             4bytes      field_size_less_padding
1513         */
1514         s->buggy_avid = 1;
1515 //      if (s->first_picture)
1516 //          printf("mjpeg: workarounding buggy AVID\n");
1517         s->interlace_polarity = get_bits(&s->gb, 8);
1518 #if 0
1519         skip_bits(&s->gb, 8);
1520         skip_bits(&s->gb, 32);
1521         skip_bits(&s->gb, 32);
1522         len -= 10;
1523 #endif
1524 //      if (s->interlace_polarity)
1525 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1526         goto out;
1527     }
1528     
1529 //    len -= 2;
1530     
1531     if (id == ff_get_fourcc("JFIF"))
1532     {
1533         int t_w, t_h;
1534         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1535         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1536             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x)\n",
1537             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1538         skip_bits(&s->gb, 8);
1539
1540         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1541         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1542
1543         t_w = get_bits(&s->gb, 8);
1544         t_h = get_bits(&s->gb, 8);
1545         if (t_w && t_h)
1546         {
1547             /* skip thumbnail */
1548             if (len-10-(t_w*t_h*3) > 0)
1549                 len -= t_w*t_h*3;
1550         }
1551         len -= 10;
1552         goto out;
1553     }
1554     
1555     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1556     {
1557         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1558             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1559         skip_bits(&s->gb, 16); /* version */
1560         skip_bits(&s->gb, 16); /* flags0 */
1561         skip_bits(&s->gb, 16); /* flags1 */
1562         skip_bits(&s->gb, 8); /* transform */
1563         len -= 7;
1564         goto out;
1565     }
1566
1567     if (id == ff_get_fourcc("LJIF")){
1568         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1569             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1570         skip_bits(&s->gb, 16); /* version ? */
1571         skip_bits(&s->gb, 16); /* unknwon always 0? */
1572         skip_bits(&s->gb, 16); /* unknwon always 0? */
1573         skip_bits(&s->gb, 16); /* unknwon always 0? */
1574         switch( get_bits(&s->gb, 8)){
1575         case 1:
1576             s->rgb= 1;
1577             s->pegasus_rct=0;
1578             break;
1579         case 2:
1580             s->rgb= 1;
1581             s->pegasus_rct=1;
1582             break;
1583         default:
1584             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1585         }
1586         len -= 9;
1587         goto out;
1588     }
1589     
1590     /* Apple MJPEG-A */
1591     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1592     {
1593         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1594         id = be2me_32(id);
1595         len -= 4;
1596         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1597         {
1598 #if 0
1599             skip_bits(&s->gb, 32); /* field size */
1600             skip_bits(&s->gb, 32); /* pad field size */
1601             skip_bits(&s->gb, 32); /* next off */
1602             skip_bits(&s->gb, 32); /* quant off */
1603             skip_bits(&s->gb, 32); /* huff off */
1604             skip_bits(&s->gb, 32); /* image off */
1605             skip_bits(&s->gb, 32); /* scan off */
1606             skip_bits(&s->gb, 32); /* data off */
1607 #endif
1608             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1609                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1610         }
1611     }
1612
1613 out:
1614     /* slow but needed for extreme adobe jpegs */
1615     if (len < 0)
1616         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1617     while(--len > 0)
1618         skip_bits(&s->gb, 8);
1619
1620     return 0;
1621 }
1622
1623 static int mjpeg_decode_com(MJpegDecodeContext *s)
1624 {
1625     /* XXX: verify len field validity */
1626     int len = get_bits(&s->gb, 16);
1627     if (len >= 2 && len < 32768) {
1628         /* XXX: any better upper bound */
1629         uint8_t *cbuf = av_malloc(len - 1);
1630         if (cbuf) {
1631             int i;
1632             for (i = 0; i < len - 2; i++)
1633                 cbuf[i] = get_bits(&s->gb, 8);
1634             if (i > 0 && cbuf[i-1] == '\n')
1635                 cbuf[i-1] = 0;
1636             else
1637                 cbuf[i] = 0;
1638
1639             av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1640
1641             /* buggy avid, it puts EOI only at every 10th frame */
1642             if (!strcmp(cbuf, "AVID"))
1643             {
1644                 s->buggy_avid = 1;
1645                 //      if (s->first_picture)
1646                 //          printf("mjpeg: workarounding buggy AVID\n");
1647             }
1648
1649             av_free(cbuf);
1650         }
1651     }
1652
1653     return 0;
1654 }
1655
1656 #if 0
1657 static int valid_marker_list[] =
1658 {
1659         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1660 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1661 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1662 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1663 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1664 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1665 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1666 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1667 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1668 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1669 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1670 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1671 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1672 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1673 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1674 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1675 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1676 }
1677 #endif
1678
1679 /* return the 8 bit start code value and update the search
1680    state. Return -1 if no start code found */
1681 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1682 {
1683     uint8_t *buf_ptr;
1684     unsigned int v, v2;
1685     int val;
1686 #ifdef DEBUG
1687     int skipped=0;
1688 #endif
1689
1690     buf_ptr = *pbuf_ptr;
1691     while (buf_ptr < buf_end) {
1692         v = *buf_ptr++;
1693         v2 = *buf_ptr;
1694         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1695             val = *buf_ptr++;
1696             goto found;
1697         }
1698 #ifdef DEBUG
1699         skipped++;
1700 #endif
1701     }
1702     val = -1;
1703 found:
1704 #ifdef DEBUG
1705     dprintf("find_marker skipped %d bytes\n", skipped);
1706 #endif
1707     *pbuf_ptr = buf_ptr;
1708     return val;
1709 }
1710
1711 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1712                               void *data, int *data_size,
1713                               uint8_t *buf, int buf_size)
1714 {
1715     MJpegDecodeContext *s = avctx->priv_data;
1716     uint8_t *buf_end, *buf_ptr;
1717     int start_code;
1718     AVFrame *picture = data;
1719
1720     *data_size = 0;
1721
1722     /* no supplementary picture */
1723     if (buf_size == 0)
1724         return 0;
1725
1726     buf_ptr = buf;
1727     buf_end = buf + buf_size;
1728     while (buf_ptr < buf_end) {
1729         /* find start next marker */
1730         start_code = find_marker(&buf_ptr, buf_end);
1731         {
1732             /* EOF */
1733             if (start_code < 0) {
1734                 goto the_end;
1735             } else {
1736                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1737                 
1738                 if ((buf_end - buf_ptr) > s->buffer_size)
1739                 {
1740                     av_free(s->buffer);
1741                     s->buffer_size = buf_end-buf_ptr;
1742                     s->buffer = av_malloc(s->buffer_size);
1743                     dprintf("buffer too small, expanding to %d bytes\n",
1744                         s->buffer_size);
1745                 }
1746                 
1747                 /* unescape buffer of SOS */
1748                 if (start_code == SOS)
1749                 {
1750                     uint8_t *src = buf_ptr;
1751                     uint8_t *dst = s->buffer;
1752
1753                     while (src<buf_end)
1754                     {
1755                         uint8_t x = *(src++);
1756
1757                         *(dst++) = x;
1758                         if (x == 0xff)
1759                         {
1760                             while(*src == 0xff) src++;
1761
1762                             x = *(src++);
1763                             if (x >= 0xd0 && x <= 0xd7)
1764                                 *(dst++) = x;
1765                             else if (x)
1766                                 break;
1767                         }
1768                     }
1769                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1770                     
1771                     dprintf("escaping removed %d bytes\n",
1772                         (buf_end - buf_ptr) - (dst - s->buffer));
1773                 }
1774                 else
1775                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1776                 
1777                 s->start_code = start_code;
1778                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1779                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1780                 }
1781
1782                 /* process markers */
1783                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1784                     dprintf("restart marker: %d\n", start_code&0x0f);
1785                     /* APP fields */
1786                 } else if (start_code >= APP0 && start_code <= APP15) {
1787                     mjpeg_decode_app(s);
1788                     /* Comment */
1789                 } else if (start_code == COM){
1790                     mjpeg_decode_com(s);
1791                 }
1792
1793                 switch(start_code) {
1794                 case SOI:
1795                     s->restart_interval = 0;
1796                     /* nothing to do on SOI */
1797                     break;
1798                 case DQT:
1799                     mjpeg_decode_dqt(s);
1800                     break;
1801                 case DHT:
1802                     if(mjpeg_decode_dht(s) < 0){
1803                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1804                         return -1;
1805                     }
1806                     break;
1807                 case SOF0:
1808                     s->lossless=0;
1809                     if (mjpeg_decode_sof(s) < 0) 
1810                         return -1;
1811                     break;
1812                 case SOF3:
1813                     s->lossless=1;
1814                     if (mjpeg_decode_sof(s) < 0) 
1815                         return -1;
1816                     break;
1817                 case EOI:
1818                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1819                         break;
1820 eoi_parser:
1821                     {
1822                         if (s->interlaced) {
1823                             s->bottom_field ^= 1;
1824                             /* if not bottom field, do not output image yet */
1825                             if (s->bottom_field)
1826                                 goto not_the_end;
1827                         }
1828                         *picture = s->picture;
1829                         *data_size = sizeof(AVFrame);
1830
1831                         if(!s->lossless){
1832                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1833                             picture->qstride= 0;
1834                             picture->qscale_table= s->qscale_table;
1835                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1836                             if(avctx->debug & FF_DEBUG_QP)
1837                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1838                             picture->quality*= FF_QP2LAMBDA;
1839                         }
1840                         
1841                         goto the_end;
1842                     }
1843                     break;
1844                 case SOS:
1845                     mjpeg_decode_sos(s);
1846                     /* buggy avid puts EOI every 10-20th frame */
1847                     /* if restart period is over process EOI */
1848                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1849                         goto eoi_parser;
1850                     break;
1851                 case DRI:
1852                     mjpeg_decode_dri(s);
1853                     break;
1854                 case SOF1:
1855                 case SOF2:
1856                 case SOF5:
1857                 case SOF6:
1858                 case SOF7:
1859                 case SOF9:
1860                 case SOF10:
1861                 case SOF11:
1862                 case SOF13:
1863                 case SOF14:
1864                 case SOF15:
1865                 case JPG:
1866                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1867                     break;
1868 //              default:
1869 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1870 //                  break;
1871                 }
1872
1873 not_the_end:
1874                 /* eof process start code */
1875                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1876                 dprintf("marker parser used %d bytes (%d bits)\n",
1877                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1878             }
1879         }
1880     }
1881 the_end:
1882     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1883 //    return buf_end - buf_ptr;
1884     return buf_ptr - buf;
1885 }
1886
1887 static int mjpegb_decode_frame(AVCodecContext *avctx, 
1888                               void *data, int *data_size,
1889                               uint8_t *buf, int buf_size)
1890 {
1891     MJpegDecodeContext *s = avctx->priv_data;
1892     uint8_t *buf_end, *buf_ptr;
1893     AVFrame *picture = data;
1894     GetBitContext hgb; /* for the header */
1895     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1896     uint32_t field_size;
1897
1898     *data_size = 0;
1899
1900     /* no supplementary picture */
1901     if (buf_size == 0)
1902         return 0;
1903
1904     buf_ptr = buf;
1905     buf_end = buf + buf_size;
1906     
1907 read_header:
1908     /* reset on every SOI */
1909     s->restart_interval = 0;
1910
1911     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1912
1913     skip_bits(&hgb, 32); /* reserved zeros */
1914     
1915     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1916     {
1917         dprintf("not mjpeg-b (bad fourcc)\n");
1918         return 0;
1919     }
1920
1921     field_size = get_bits(&hgb, 32); /* field size */
1922     dprintf("field size: 0x%x\n", field_size);
1923     skip_bits(&hgb, 32); /* padded field size */
1924     second_field_offs = get_bits(&hgb, 32);
1925     dprintf("second field offs: 0x%x\n", second_field_offs);
1926     if (second_field_offs)
1927         s->interlaced = 1;
1928
1929     dqt_offs = get_bits(&hgb, 32);
1930     dprintf("dqt offs: 0x%x\n", dqt_offs);
1931     if (dqt_offs)
1932     {
1933         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1934         s->start_code = DQT;
1935         mjpeg_decode_dqt(s);
1936     }
1937     
1938     dht_offs = get_bits(&hgb, 32);
1939     dprintf("dht offs: 0x%x\n", dht_offs);
1940     if (dht_offs)
1941     {
1942         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1943         s->start_code = DHT;
1944         mjpeg_decode_dht(s);
1945     }
1946
1947     sof_offs = get_bits(&hgb, 32);
1948     dprintf("sof offs: 0x%x\n", sof_offs);
1949     if (sof_offs)
1950     {
1951         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1952         s->start_code = SOF0;
1953         if (mjpeg_decode_sof(s) < 0)
1954             return -1;
1955     }
1956
1957     sos_offs = get_bits(&hgb, 32);
1958     dprintf("sos offs: 0x%x\n", sos_offs);
1959     if (sos_offs)
1960     {
1961 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1962         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1963         s->start_code = SOS;
1964         mjpeg_decode_sos(s);
1965     }
1966
1967     skip_bits(&hgb, 32); /* start of data offset */
1968
1969     if (s->interlaced) {
1970         s->bottom_field ^= 1;
1971         /* if not bottom field, do not output image yet */
1972         if (s->bottom_field && second_field_offs)
1973         {
1974             buf_ptr = buf + second_field_offs;
1975             second_field_offs = 0;
1976             goto read_header;
1977         }
1978     }
1979
1980     //XXX FIXME factorize, this looks very similar to the EOI code
1981
1982     *picture= s->picture;
1983     *data_size = sizeof(AVFrame);
1984     
1985     if(!s->lossless){
1986         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1987         picture->qstride= 0;
1988         picture->qscale_table= s->qscale_table;
1989         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1990         if(avctx->debug & FF_DEBUG_QP)
1991             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1992         picture->quality*= FF_QP2LAMBDA;
1993     }
1994
1995     return buf_ptr - buf;
1996 }
1997
1998 #include "sp5x.h"
1999
2000 static int sp5x_decode_frame(AVCodecContext *avctx, 
2001                               void *data, int *data_size,
2002                               uint8_t *buf, int buf_size)
2003 {
2004 #if 0
2005     MJpegDecodeContext *s = avctx->priv_data;
2006 #endif
2007     const int qscale = 5;
2008     uint8_t *buf_ptr, *buf_end, *recoded;
2009     int i = 0, j = 0;
2010
2011     *data_size = 0;
2012
2013     /* no supplementary picture */
2014     if (buf_size == 0)
2015         return 0;
2016
2017     if (!avctx->width || !avctx->height)
2018         return -1;
2019
2020     buf_ptr = buf;
2021     buf_end = buf + buf_size;
2022
2023 #if 1
2024     recoded = av_mallocz(buf_size + 1024);
2025     if (!recoded)
2026         return -1;
2027
2028     /* SOI */
2029     recoded[j++] = 0xFF;
2030     recoded[j++] = 0xD8;
2031
2032     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2033     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2034     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2035     j += sizeof(sp5x_data_dqt);
2036
2037     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2038     j += sizeof(sp5x_data_dht);
2039
2040     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2041     recoded[j+5] = (avctx->height >> 8) & 0xFF;
2042     recoded[j+6] = avctx->height & 0xFF;
2043     recoded[j+7] = (avctx->width >> 8) & 0xFF;
2044     recoded[j+8] = avctx->width & 0xFF;
2045     j += sizeof(sp5x_data_sof);
2046
2047     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2048     j += sizeof(sp5x_data_sos);
2049
2050     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2051     {
2052         recoded[j++] = buf[i];
2053         if (buf[i] == 0xff)
2054             recoded[j++] = 0;
2055     }
2056
2057     /* EOI */
2058     recoded[j++] = 0xFF;
2059     recoded[j++] = 0xD9;
2060
2061     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2062
2063     av_free(recoded);
2064
2065 #else
2066     /* SOF */
2067     s->bits = 8;
2068     s->width = avctx->width;
2069     s->height = avctx->height;
2070     s->nb_components = 3;
2071     s->component_id[0] = 0;
2072     s->h_count[0] = 2;
2073     s->v_count[0] = 2;
2074     s->quant_index[0] = 0;
2075     s->component_id[1] = 1;
2076     s->h_count[1] = 1;
2077     s->v_count[1] = 1;
2078     s->quant_index[1] = 1;
2079     s->component_id[2] = 2;
2080     s->h_count[2] = 1;
2081     s->v_count[2] = 1;
2082     s->quant_index[2] = 1;
2083     s->h_max = 2;
2084     s->v_max = 2;
2085     
2086     s->qscale_table = av_mallocz((s->width+15)/16);
2087     avctx->pix_fmt = PIX_FMT_YUV420P;
2088     s->interlaced = 0;
2089     
2090     s->picture.reference = 0;
2091     if (avctx->get_buffer(avctx, &s->picture) < 0)
2092     {
2093         fprintf(stderr, "get_buffer() failed\n");
2094         return -1;
2095     }
2096
2097     s->picture.pict_type = I_TYPE;
2098     s->picture.key_frame = 1;
2099
2100     for (i = 0; i < 3; i++)
2101         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2102
2103     /* DQT */
2104     for (i = 0; i < 64; i++)
2105     {
2106         j = s->scantable.permutated[i];
2107         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2108     }
2109     s->qscale[0] = FFMAX(
2110         s->quant_matrixes[0][s->scantable.permutated[1]],
2111         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2112
2113     for (i = 0; i < 64; i++)
2114     {
2115         j = s->scantable.permutated[i];
2116         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2117     }
2118     s->qscale[1] = FFMAX(
2119         s->quant_matrixes[1][s->scantable.permutated[1]],
2120         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2121
2122     /* DHT */
2123
2124     /* SOS */
2125     s->comp_index[0] = 0;
2126     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2127     s->h_scount[0] = s->h_count[0];
2128     s->v_scount[0] = s->v_count[0];
2129     s->dc_index[0] = 0;
2130     s->ac_index[0] = 0;
2131
2132     s->comp_index[1] = 1;
2133     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2134     s->h_scount[1] = s->h_count[1];
2135     s->v_scount[1] = s->v_count[1];
2136     s->dc_index[1] = 1;
2137     s->ac_index[1] = 1;
2138
2139     s->comp_index[2] = 2;
2140     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2141     s->h_scount[2] = s->h_count[2];
2142     s->v_scount[2] = s->v_count[2];
2143     s->dc_index[2] = 1;
2144     s->ac_index[2] = 1;
2145     
2146     for (i = 0; i < 3; i++)
2147         s->last_dc[i] = 1024;
2148
2149     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2150     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2151
2152     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2153     
2154     return mjpeg_decode_scan(s);
2155 #endif
2156
2157     return i;
2158 }
2159
2160 static int mjpeg_decode_end(AVCodecContext *avctx)
2161 {
2162     MJpegDecodeContext *s = avctx->priv_data;
2163     int i, j;
2164
2165     av_free(s->buffer);
2166     av_free(s->qscale_table);
2167     avcodec_default_free_buffers(avctx);
2168     
2169     for(i=0;i<2;i++) {
2170         for(j=0;j<4;j++)
2171             free_vlc(&s->vlcs[i][j]);
2172     }
2173     return 0;
2174 }
2175
2176 AVCodec mjpeg_decoder = {
2177     "mjpeg",
2178     CODEC_TYPE_VIDEO,
2179     CODEC_ID_MJPEG,
2180     sizeof(MJpegDecodeContext),
2181     mjpeg_decode_init,
2182     NULL,
2183     mjpeg_decode_end,
2184     mjpeg_decode_frame,
2185     CODEC_CAP_DR1,
2186     NULL
2187 };
2188
2189 AVCodec mjpegb_decoder = {
2190     "mjpegb",
2191     CODEC_TYPE_VIDEO,
2192     CODEC_ID_MJPEGB,
2193     sizeof(MJpegDecodeContext),
2194     mjpeg_decode_init,
2195     NULL,
2196     mjpeg_decode_end,
2197     mjpegb_decode_frame,
2198     CODEC_CAP_DR1,
2199     NULL
2200 };
2201
2202 AVCodec sp5x_decoder = {
2203     "sp5x",
2204     CODEC_TYPE_VIDEO,
2205     CODEC_ID_SP5X,
2206     sizeof(MJpegDecodeContext),
2207     mjpeg_decode_init,
2208     NULL,
2209     mjpeg_decode_end,
2210     sp5x_decode_frame,
2211     CODEC_CAP_DR1,
2212     NULL
2213 };
2214
2215 #ifdef CONFIG_ENCODERS
2216 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2217     "ljpeg",
2218     CODEC_TYPE_VIDEO,
2219     CODEC_ID_LJPEG,
2220     sizeof(MpegEncContext),
2221     MPV_encode_init,
2222     encode_picture_lossless,
2223     MPV_encode_end,
2224 };
2225 #endif