jpeg style yuv fixes
[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]= 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     /* XXX: verify len field validity */
1589     len = get_bits(&s->gb, 16);
1590     if (len < 5)
1591         return -1;
1592
1593     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1594     id = be2me_32(id);
1595     len -= 6;
1596
1597     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1598         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1599     }
1600     
1601     /* buggy AVID, it puts EOI only at every 10th frame */
1602     /* also this fourcc is used by non-avid files too, it holds some
1603        informations, but it's always present in AVID creates files */
1604     if (id == ff_get_fourcc("AVI1"))
1605     {
1606         /* structure:
1607             4bytes      AVI1
1608             1bytes      polarity
1609             1bytes      always zero
1610             4bytes      field_size
1611             4bytes      field_size_less_padding
1612         */
1613         s->buggy_avid = 1;
1614 //      if (s->first_picture)
1615 //          printf("mjpeg: workarounding buggy AVID\n");
1616         s->interlace_polarity = get_bits(&s->gb, 8);
1617 #if 0
1618         skip_bits(&s->gb, 8);
1619         skip_bits(&s->gb, 32);
1620         skip_bits(&s->gb, 32);
1621         len -= 10;
1622 #endif
1623 //      if (s->interlace_polarity)
1624 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1625         goto out;
1626     }
1627     
1628 //    len -= 2;
1629     
1630     if (id == ff_get_fourcc("JFIF"))
1631     {
1632         int t_w, t_h, v1, v2;
1633         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1634         v1= get_bits(&s->gb, 8);
1635         v2= get_bits(&s->gb, 8);
1636         skip_bits(&s->gb, 8);
1637
1638         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1639         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1640
1641         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1642             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1643                 v1, v2,
1644                 s->avctx->sample_aspect_ratio.num,
1645                 s->avctx->sample_aspect_ratio.den
1646             );
1647
1648         t_w = get_bits(&s->gb, 8);
1649         t_h = get_bits(&s->gb, 8);
1650         if (t_w && t_h)
1651         {
1652             /* skip thumbnail */
1653             if (len-10-(t_w*t_h*3) > 0)
1654                 len -= t_w*t_h*3;
1655         }
1656         len -= 10;
1657         goto out;
1658     }
1659     
1660     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1661     {
1662         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1663             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1664         skip_bits(&s->gb, 16); /* version */
1665         skip_bits(&s->gb, 16); /* flags0 */
1666         skip_bits(&s->gb, 16); /* flags1 */
1667         skip_bits(&s->gb, 8); /* transform */
1668         len -= 7;
1669         goto out;
1670     }
1671
1672     if (id == ff_get_fourcc("LJIF")){
1673         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1674             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1675         skip_bits(&s->gb, 16); /* version ? */
1676         skip_bits(&s->gb, 16); /* unknwon always 0? */
1677         skip_bits(&s->gb, 16); /* unknwon always 0? */
1678         skip_bits(&s->gb, 16); /* unknwon always 0? */
1679         switch( get_bits(&s->gb, 8)){
1680         case 1:
1681             s->rgb= 1;
1682             s->pegasus_rct=0;
1683             break;
1684         case 2:
1685             s->rgb= 1;
1686             s->pegasus_rct=1;
1687             break;
1688         default:
1689             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1690         }
1691         len -= 9;
1692         goto out;
1693     }
1694     
1695     /* Apple MJPEG-A */
1696     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1697     {
1698         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1699         id = be2me_32(id);
1700         len -= 4;
1701         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1702         {
1703 #if 0
1704             skip_bits(&s->gb, 32); /* field size */
1705             skip_bits(&s->gb, 32); /* pad field size */
1706             skip_bits(&s->gb, 32); /* next off */
1707             skip_bits(&s->gb, 32); /* quant off */
1708             skip_bits(&s->gb, 32); /* huff off */
1709             skip_bits(&s->gb, 32); /* image off */
1710             skip_bits(&s->gb, 32); /* scan off */
1711             skip_bits(&s->gb, 32); /* data off */
1712 #endif
1713             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1715         }
1716     }
1717
1718 out:
1719     /* slow but needed for extreme adobe jpegs */
1720     if (len < 0)
1721         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1722     while(--len > 0)
1723         skip_bits(&s->gb, 8);
1724
1725     return 0;
1726 }
1727
1728 static int mjpeg_decode_com(MJpegDecodeContext *s)
1729 {
1730     /* XXX: verify len field validity */
1731     int len = get_bits(&s->gb, 16);
1732     if (len >= 2 && len < 32768) {
1733         /* XXX: any better upper bound */
1734         uint8_t *cbuf = av_malloc(len - 1);
1735         if (cbuf) {
1736             int i;
1737             for (i = 0; i < len - 2; i++)
1738                 cbuf[i] = get_bits(&s->gb, 8);
1739             if (i > 0 && cbuf[i-1] == '\n')
1740                 cbuf[i-1] = 0;
1741             else
1742                 cbuf[i] = 0;
1743
1744             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1745                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1746
1747             /* buggy avid, it puts EOI only at every 10th frame */
1748             if (!strcmp(cbuf, "AVID"))
1749             {
1750                 s->buggy_avid = 1;
1751                 //      if (s->first_picture)
1752                 //          printf("mjpeg: workarounding buggy AVID\n");
1753             }
1754             else if(!strcmp(cbuf, "CS=ITU601")){
1755                 s->cs_itu601= 1;
1756             }
1757
1758             av_free(cbuf);
1759         }
1760     }
1761
1762     return 0;
1763 }
1764
1765 #if 0
1766 static int valid_marker_list[] =
1767 {
1768         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1769 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1770 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1771 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1772 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1774 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1775 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1776 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1777 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1778 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1779 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1780 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1781 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1782 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1783 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1784 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1785 }
1786 #endif
1787
1788 /* return the 8 bit start code value and update the search
1789    state. Return -1 if no start code found */
1790 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1791 {
1792     uint8_t *buf_ptr;
1793     unsigned int v, v2;
1794     int val;
1795 #ifdef DEBUG
1796     int skipped=0;
1797 #endif
1798
1799     buf_ptr = *pbuf_ptr;
1800     while (buf_ptr < buf_end) {
1801         v = *buf_ptr++;
1802         v2 = *buf_ptr;
1803         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1804             val = *buf_ptr++;
1805             goto found;
1806         }
1807 #ifdef DEBUG
1808         skipped++;
1809 #endif
1810     }
1811     val = -1;
1812 found:
1813 #ifdef DEBUG
1814     dprintf("find_marker skipped %d bytes\n", skipped);
1815 #endif
1816     *pbuf_ptr = buf_ptr;
1817     return val;
1818 }
1819
1820 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1821                               void *data, int *data_size,
1822                               uint8_t *buf, int buf_size)
1823 {
1824     MJpegDecodeContext *s = avctx->priv_data;
1825     uint8_t *buf_end, *buf_ptr;
1826     int start_code;
1827     AVFrame *picture = data;
1828
1829     /* no supplementary picture */
1830     if (buf_size == 0)
1831         return 0;
1832
1833     buf_ptr = buf;
1834     buf_end = buf + buf_size;
1835     while (buf_ptr < buf_end) {
1836         /* find start next marker */
1837         start_code = find_marker(&buf_ptr, buf_end);
1838         {
1839             /* EOF */
1840             if (start_code < 0) {
1841                 goto the_end;
1842             } else {
1843                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1844                 
1845                 if ((buf_end - buf_ptr) > s->buffer_size)
1846                 {
1847                     av_free(s->buffer);
1848                     s->buffer_size = buf_end-buf_ptr;
1849                     s->buffer = av_malloc(s->buffer_size);
1850                     dprintf("buffer too small, expanding to %d bytes\n",
1851                         s->buffer_size);
1852                 }
1853                 
1854                 /* unescape buffer of SOS */
1855                 if (start_code == SOS)
1856                 {
1857                     uint8_t *src = buf_ptr;
1858                     uint8_t *dst = s->buffer;
1859
1860                     while (src<buf_end)
1861                     {
1862                         uint8_t x = *(src++);
1863
1864                         *(dst++) = x;
1865                         if (x == 0xff)
1866                         {
1867                             while(src<buf_end && x == 0xff)
1868                                 x = *(src++);
1869
1870                             if (x >= 0xd0 && x <= 0xd7)
1871                                 *(dst++) = x;
1872                             else if (x)
1873                                 break;
1874                         }
1875                     }
1876                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1877                     
1878                     dprintf("escaping removed %d bytes\n",
1879                         (buf_end - buf_ptr) - (dst - s->buffer));
1880                 }
1881                 else
1882                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1883                 
1884                 s->start_code = start_code;
1885                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1886                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1887                 }
1888
1889                 /* process markers */
1890                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1891                     dprintf("restart marker: %d\n", start_code&0x0f);
1892                     /* APP fields */
1893                 } else if (start_code >= APP0 && start_code <= APP15) {
1894                     mjpeg_decode_app(s);
1895                     /* Comment */
1896                 } else if (start_code == COM){
1897                     mjpeg_decode_com(s);
1898                 }
1899
1900                 switch(start_code) {
1901                 case SOI:
1902                     s->restart_interval = 0;
1903                     /* nothing to do on SOI */
1904                     break;
1905                 case DQT:
1906                     mjpeg_decode_dqt(s);
1907                     break;
1908                 case DHT:
1909                     if(mjpeg_decode_dht(s) < 0){
1910                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1911                         return -1;
1912                     }
1913                     break;
1914                 case SOF0:
1915                     s->lossless=0;
1916                     if (mjpeg_decode_sof(s) < 0) 
1917                         return -1;
1918                     break;
1919                 case SOF3:
1920                     s->lossless=1;
1921                     if (mjpeg_decode_sof(s) < 0) 
1922                         return -1;
1923                     break;
1924                 case EOI:
1925                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1926                         break;
1927 eoi_parser:
1928                     {
1929                         if (s->interlaced) {
1930                             s->bottom_field ^= 1;
1931                             /* if not bottom field, do not output image yet */
1932                             if (s->bottom_field)
1933                                 goto not_the_end;
1934                         }
1935                         *picture = s->picture;
1936                         *data_size = sizeof(AVFrame);
1937
1938                         if(!s->lossless){
1939                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1940                             picture->qstride= 0;
1941                             picture->qscale_table= s->qscale_table;
1942                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1943                             if(avctx->debug & FF_DEBUG_QP)
1944                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1945                             picture->quality*= FF_QP2LAMBDA;
1946                         }
1947                         
1948                         goto the_end;
1949                     }
1950                     break;
1951                 case SOS:
1952                     mjpeg_decode_sos(s);
1953                     /* buggy avid puts EOI every 10-20th frame */
1954                     /* if restart period is over process EOI */
1955                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1956                         goto eoi_parser;
1957                     break;
1958                 case DRI:
1959                     mjpeg_decode_dri(s);
1960                     break;
1961                 case SOF1:
1962                 case SOF2:
1963                 case SOF5:
1964                 case SOF6:
1965                 case SOF7:
1966                 case SOF9:
1967                 case SOF10:
1968                 case SOF11:
1969                 case SOF13:
1970                 case SOF14:
1971                 case SOF15:
1972                 case JPG:
1973                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1974                     break;
1975 //              default:
1976 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1977 //                  break;
1978                 }
1979
1980 not_the_end:
1981                 /* eof process start code */
1982                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1983                 dprintf("marker parser used %d bytes (%d bits)\n",
1984                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1985             }
1986         }
1987     }
1988 the_end:
1989     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1990 //    return buf_end - buf_ptr;
1991     return buf_ptr - buf;
1992 }
1993
1994 static int mjpegb_decode_frame(AVCodecContext *avctx, 
1995                               void *data, int *data_size,
1996                               uint8_t *buf, int buf_size)
1997 {
1998     MJpegDecodeContext *s = avctx->priv_data;
1999     uint8_t *buf_end, *buf_ptr;
2000     AVFrame *picture = data;
2001     GetBitContext hgb; /* for the header */
2002     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2003     uint32_t field_size, sod_offs;
2004
2005     /* no supplementary picture */
2006     if (buf_size == 0)
2007         return 0;
2008
2009     buf_ptr = buf;
2010     buf_end = buf + buf_size;
2011     
2012 read_header:
2013     /* reset on every SOI */
2014     s->restart_interval = 0;
2015     s->mjpb_skiptosod = 0;
2016
2017     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2018
2019     skip_bits(&hgb, 32); /* reserved zeros */
2020     
2021     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2022     {
2023         dprintf("not mjpeg-b (bad fourcc)\n");
2024         return 0;
2025     }
2026
2027     field_size = get_bits_long(&hgb, 32); /* field size */
2028     dprintf("field size: 0x%x\n", field_size);
2029     skip_bits(&hgb, 32); /* padded field size */
2030     second_field_offs = get_bits_long(&hgb, 32);
2031     dprintf("second field offs: 0x%x\n", second_field_offs);
2032     if (second_field_offs)
2033         s->interlaced = 1;
2034
2035     dqt_offs = get_bits_long(&hgb, 32);
2036     dprintf("dqt offs: 0x%x\n", dqt_offs);
2037     if (dqt_offs)
2038     {
2039         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2040         s->start_code = DQT;
2041         mjpeg_decode_dqt(s);
2042     }
2043     
2044     dht_offs = get_bits_long(&hgb, 32);
2045     dprintf("dht offs: 0x%x\n", dht_offs);
2046     if (dht_offs)
2047     {
2048         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2049         s->start_code = DHT;
2050         mjpeg_decode_dht(s);
2051     }
2052
2053     sof_offs = get_bits_long(&hgb, 32);
2054     dprintf("sof offs: 0x%x\n", sof_offs);
2055     if (sof_offs)
2056     {
2057         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2058         s->start_code = SOF0;
2059         if (mjpeg_decode_sof(s) < 0)
2060             return -1;
2061     }
2062
2063     sos_offs = get_bits_long(&hgb, 32);
2064     dprintf("sos offs: 0x%x\n", sos_offs);
2065     sod_offs = get_bits_long(&hgb, 32);
2066     dprintf("sod offs: 0x%x\n", sod_offs);
2067     if (sos_offs)
2068     {
2069 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2070         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2071         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2072         s->start_code = SOS;
2073         mjpeg_decode_sos(s);
2074     }
2075
2076     if (s->interlaced) {
2077         s->bottom_field ^= 1;
2078         /* if not bottom field, do not output image yet */
2079         if (s->bottom_field && second_field_offs)
2080         {
2081             buf_ptr = buf + second_field_offs;
2082             second_field_offs = 0;
2083             goto read_header;
2084         }
2085     }
2086
2087     //XXX FIXME factorize, this looks very similar to the EOI code
2088
2089     *picture= s->picture;
2090     *data_size = sizeof(AVFrame);
2091     
2092     if(!s->lossless){
2093         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2094         picture->qstride= 0;
2095         picture->qscale_table= s->qscale_table;
2096         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2097         if(avctx->debug & FF_DEBUG_QP)
2098             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2099         picture->quality*= FF_QP2LAMBDA;
2100     }
2101
2102     return buf_ptr - buf;
2103 }
2104
2105 #include "sp5x.h"
2106
2107 static int sp5x_decode_frame(AVCodecContext *avctx, 
2108                               void *data, int *data_size,
2109                               uint8_t *buf, int buf_size)
2110 {
2111 #if 0
2112     MJpegDecodeContext *s = avctx->priv_data;
2113 #endif
2114     const int qscale = 5;
2115     uint8_t *buf_ptr, *buf_end, *recoded;
2116     int i = 0, j = 0;
2117
2118     /* no supplementary picture */
2119     if (buf_size == 0)
2120         return 0;
2121
2122     if (!avctx->width || !avctx->height)
2123         return -1;
2124
2125     buf_ptr = buf;
2126     buf_end = buf + buf_size;
2127
2128 #if 1
2129     recoded = av_mallocz(buf_size + 1024);
2130     if (!recoded)
2131         return -1;
2132
2133     /* SOI */
2134     recoded[j++] = 0xFF;
2135     recoded[j++] = 0xD8;
2136
2137     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2138     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2139     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2140     j += sizeof(sp5x_data_dqt);
2141
2142     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2143     j += sizeof(sp5x_data_dht);
2144
2145     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2146     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2147     recoded[j+6] = avctx->coded_height & 0xFF;
2148     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2149     recoded[j+8] = avctx->coded_width & 0xFF;
2150     j += sizeof(sp5x_data_sof);
2151
2152     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2153     j += sizeof(sp5x_data_sos);
2154
2155     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2156     {
2157         recoded[j++] = buf[i];
2158         if (buf[i] == 0xff)
2159             recoded[j++] = 0;
2160     }
2161
2162     /* EOI */
2163     recoded[j++] = 0xFF;
2164     recoded[j++] = 0xD9;
2165
2166     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2167
2168     av_free(recoded);
2169
2170 #else
2171     /* SOF */
2172     s->bits = 8;
2173     s->width  = avctx->coded_width;
2174     s->height = avctx->coded_height;
2175     s->nb_components = 3;
2176     s->component_id[0] = 0;
2177     s->h_count[0] = 2;
2178     s->v_count[0] = 2;
2179     s->quant_index[0] = 0;
2180     s->component_id[1] = 1;
2181     s->h_count[1] = 1;
2182     s->v_count[1] = 1;
2183     s->quant_index[1] = 1;
2184     s->component_id[2] = 2;
2185     s->h_count[2] = 1;
2186     s->v_count[2] = 1;
2187     s->quant_index[2] = 1;
2188     s->h_max = 2;
2189     s->v_max = 2;
2190     
2191     s->qscale_table = av_mallocz((s->width+15)/16);
2192     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2193     s->interlaced = 0;
2194     
2195     s->picture.reference = 0;
2196     if (avctx->get_buffer(avctx, &s->picture) < 0)
2197     {
2198         fprintf(stderr, "get_buffer() failed\n");
2199         return -1;
2200     }
2201
2202     s->picture.pict_type = I_TYPE;
2203     s->picture.key_frame = 1;
2204
2205     for (i = 0; i < 3; i++)
2206         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2207
2208     /* DQT */
2209     for (i = 0; i < 64; i++)
2210     {
2211         j = s->scantable.permutated[i];
2212         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2213     }
2214     s->qscale[0] = FFMAX(
2215         s->quant_matrixes[0][s->scantable.permutated[1]],
2216         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2217
2218     for (i = 0; i < 64; i++)
2219     {
2220         j = s->scantable.permutated[i];
2221         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2222     }
2223     s->qscale[1] = FFMAX(
2224         s->quant_matrixes[1][s->scantable.permutated[1]],
2225         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2226
2227     /* DHT */
2228
2229     /* SOS */
2230     s->comp_index[0] = 0;
2231     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2232     s->h_scount[0] = s->h_count[0];
2233     s->v_scount[0] = s->v_count[0];
2234     s->dc_index[0] = 0;
2235     s->ac_index[0] = 0;
2236
2237     s->comp_index[1] = 1;
2238     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2239     s->h_scount[1] = s->h_count[1];
2240     s->v_scount[1] = s->v_count[1];
2241     s->dc_index[1] = 1;
2242     s->ac_index[1] = 1;
2243
2244     s->comp_index[2] = 2;
2245     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2246     s->h_scount[2] = s->h_count[2];
2247     s->v_scount[2] = s->v_count[2];
2248     s->dc_index[2] = 1;
2249     s->ac_index[2] = 1;
2250     
2251     for (i = 0; i < 3; i++)
2252         s->last_dc[i] = 1024;
2253
2254     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2255     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2256
2257     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2258     
2259     return mjpeg_decode_scan(s);
2260 #endif
2261
2262     return i;
2263 }
2264
2265 static int mjpeg_decode_end(AVCodecContext *avctx)
2266 {
2267     MJpegDecodeContext *s = avctx->priv_data;
2268     int i, j;
2269
2270     av_free(s->buffer);
2271     av_free(s->qscale_table);
2272     
2273     for(i=0;i<2;i++) {
2274         for(j=0;j<4;j++)
2275             free_vlc(&s->vlcs[i][j]);
2276     }
2277     return 0;
2278 }
2279
2280 AVCodec mjpeg_decoder = {
2281     "mjpeg",
2282     CODEC_TYPE_VIDEO,
2283     CODEC_ID_MJPEG,
2284     sizeof(MJpegDecodeContext),
2285     mjpeg_decode_init,
2286     NULL,
2287     mjpeg_decode_end,
2288     mjpeg_decode_frame,
2289     CODEC_CAP_DR1,
2290     NULL
2291 };
2292
2293 AVCodec mjpegb_decoder = {
2294     "mjpegb",
2295     CODEC_TYPE_VIDEO,
2296     CODEC_ID_MJPEGB,
2297     sizeof(MJpegDecodeContext),
2298     mjpeg_decode_init,
2299     NULL,
2300     mjpeg_decode_end,
2301     mjpegb_decode_frame,
2302     CODEC_CAP_DR1,
2303     NULL
2304 };
2305
2306 AVCodec sp5x_decoder = {
2307     "sp5x",
2308     CODEC_TYPE_VIDEO,
2309     CODEC_ID_SP5X,
2310     sizeof(MJpegDecodeContext),
2311     mjpeg_decode_init,
2312     NULL,
2313     mjpeg_decode_end,
2314     sp5x_decode_frame,
2315     CODEC_CAP_DR1,
2316     NULL
2317 };
2318
2319 #ifdef CONFIG_ENCODERS
2320 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2321     "ljpeg",
2322     CODEC_TYPE_VIDEO,
2323     CODEC_ID_LJPEG,
2324     sizeof(MpegEncContext),
2325     MPV_encode_init,
2326     encode_picture_lossless,
2327     MPV_encode_end,
2328 };
2329 #endif
2330
2331 AVCodecParser mjpeg_parser = {
2332     { CODEC_ID_MJPEG },
2333     sizeof(ParseContext),
2334     NULL,
2335     jpeg_parse,
2336     ff_parse_close,
2337 };
2338