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