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