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