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