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