recommit of
[ffmpeg.git] / libavcodec / mjpeg.c
1 /*
2  * MJPEG encoder and decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  * Support for external huffman table, various fixes (AVID workaround),
20  * aspecting, new decode_frame mechanism and apple mjpeg-b support
21  *                                  by Alex Beregszaszi <alex@naxine.org>
22  */
23
24 /**
25  * @file mjpeg.c
26  * MJPEG encoder and decoder.
27  */
28  
29 //#define DEBUG
30 #include <assert.h>
31
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "mpegvideo.h"
35
36 /* use two quantizer tables (one for luminance and one for chrominance) */
37 /* not yet working */
38 #undef TWOMATRIXES
39
40 typedef struct MJpegContext {
41     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
42     uint16_t huff_code_dc_luminance[12];
43     uint8_t huff_size_dc_chrominance[12];
44     uint16_t huff_code_dc_chrominance[12];
45
46     uint8_t huff_size_ac_luminance[256];
47     uint16_t huff_code_ac_luminance[256];
48     uint8_t huff_size_ac_chrominance[256];
49     uint16_t huff_code_ac_chrominance[256];
50 } MJpegContext;
51
52 /* JPEG marker codes */
53 typedef enum {
54     /* start of frame */
55     SOF0  = 0xc0,       /* baseline */
56     SOF1  = 0xc1,       /* extended sequential, huffman */
57     SOF2  = 0xc2,       /* progressive, huffman */
58     SOF3  = 0xc3,       /* lossless, huffman */
59
60     SOF5  = 0xc5,       /* differential sequential, huffman */
61     SOF6  = 0xc6,       /* differential progressive, huffman */
62     SOF7  = 0xc7,       /* differential lossless, huffman */
63     JPG   = 0xc8,       /* reserved for JPEG extension */
64     SOF9  = 0xc9,       /* extended sequential, arithmetic */
65     SOF10 = 0xca,       /* progressive, arithmetic */
66     SOF11 = 0xcb,       /* lossless, arithmetic */
67
68     SOF13 = 0xcd,       /* differential sequential, arithmetic */
69     SOF14 = 0xce,       /* differential progressive, arithmetic */
70     SOF15 = 0xcf,       /* differential lossless, arithmetic */
71
72     DHT   = 0xc4,       /* define huffman tables */
73
74     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
75
76     /* restart with modulo 8 count "m" */
77     RST0  = 0xd0,
78     RST1  = 0xd1,
79     RST2  = 0xd2,
80     RST3  = 0xd3,
81     RST4  = 0xd4,
82     RST5  = 0xd5,
83     RST6  = 0xd6,
84     RST7  = 0xd7,
85
86     SOI   = 0xd8,       /* start of image */
87     EOI   = 0xd9,       /* end of image */
88     SOS   = 0xda,       /* start of scan */
89     DQT   = 0xdb,       /* define quantization tables */
90     DNL   = 0xdc,       /* define number of lines */
91     DRI   = 0xdd,       /* define restart interval */
92     DHP   = 0xde,       /* define hierarchical progression */
93     EXP   = 0xdf,       /* expand reference components */
94
95     APP0  = 0xe0,
96     APP1  = 0xe1,
97     APP2  = 0xe2,
98     APP3  = 0xe3,
99     APP4  = 0xe4,
100     APP5  = 0xe5,
101     APP6  = 0xe6,
102     APP7  = 0xe7,
103     APP8  = 0xe8,
104     APP9  = 0xe9,
105     APP10 = 0xea,
106     APP11 = 0xeb,
107     APP12 = 0xec,
108     APP13 = 0xed,
109     APP14 = 0xee,
110     APP15 = 0xef,
111
112     JPG0  = 0xf0,
113     JPG1  = 0xf1,
114     JPG2  = 0xf2,
115     JPG3  = 0xf3,
116     JPG4  = 0xf4,
117     JPG5  = 0xf5,
118     JPG6  = 0xf6,
119     JPG7  = 0xf7,
120     JPG8  = 0xf8,
121     JPG9  = 0xf9,
122     JPG10 = 0xfa,
123     JPG11 = 0xfb,
124     JPG12 = 0xfc,
125     JPG13 = 0xfd,
126
127     COM   = 0xfe,       /* comment */
128
129     TEM   = 0x01,       /* temporary private use for arithmetic coding */
130
131     /* 0x02 -> 0xbf reserved */
132 } JPEG_MARKER;
133
134 #if 0
135 /* These are the sample quantization tables given in JPEG spec section K.1.
136  * The spec says that the values given produce "good" quality, and
137  * when divided by 2, "very good" quality.
138  */
139 static const unsigned char std_luminance_quant_tbl[64] = {
140     16,  11,  10,  16,  24,  40,  51,  61,
141     12,  12,  14,  19,  26,  58,  60,  55,
142     14,  13,  16,  24,  40,  57,  69,  56,
143     14,  17,  22,  29,  51,  87,  80,  62,
144     18,  22,  37,  56,  68, 109, 103,  77,
145     24,  35,  55,  64,  81, 104, 113,  92,
146     49,  64,  78,  87, 103, 121, 120, 101,
147     72,  92,  95,  98, 112, 100, 103,  99
148 };
149 static const unsigned char std_chrominance_quant_tbl[64] = {
150     17,  18,  24,  47,  99,  99,  99,  99,
151     18,  21,  26,  66,  99,  99,  99,  99,
152     24,  26,  56,  99,  99,  99,  99,  99,
153     47,  66,  99,  99,  99,  99,  99,  99,
154     99,  99,  99,  99,  99,  99,  99,  99,
155     99,  99,  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 };
159 #endif
160
161 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
162 /* IMPORTANT: these are only valid for 8-bit data precision! */
163 static const uint8_t bits_dc_luminance[17] =
164 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
165 static const uint8_t val_dc_luminance[] =
166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
167
168 static const uint8_t bits_dc_chrominance[17] =
169 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170 static const uint8_t val_dc_chrominance[] =
171 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172
173 static const uint8_t bits_ac_luminance[17] =
174 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
175 static const uint8_t val_ac_luminance[] =
176 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
177   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
178   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
179   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
180   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
181   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
182   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
183   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
184   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
185   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
186   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
187   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
188   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
189   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
190   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
191   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
192   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
193   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
194   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
195   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
196   0xf9, 0xfa 
197 };
198
199 static const uint8_t bits_ac_chrominance[17] =
200 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
201
202 static const uint8_t val_ac_chrominance[] =
203 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
204   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
205   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
206   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
207   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
208   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
209   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
210   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
211   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
212   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
213   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
214   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
215   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
216   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
217   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
218   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
219   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
220   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
221   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
222   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223   0xf9, 0xfa 
224 };
225
226 /* isn't this function nicer than the one in the libjpeg ? */
227 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
228                                 const uint8_t *bits_table, const uint8_t *val_table)
229 {
230     int i, j, k,nb, code, sym;
231
232     code = 0;
233     k = 0;
234     for(i=1;i<=16;i++) {
235         nb = bits_table[i];
236         for(j=0;j<nb;j++) {
237             sym = val_table[k++];
238             huff_size[sym] = i;
239             huff_code[sym] = code;
240             code++;
241         }
242         code <<= 1;
243     }
244 }
245
246 int mjpeg_init(MpegEncContext *s)
247 {
248     MJpegContext *m;
249     
250     m = av_malloc(sizeof(MJpegContext));
251     if (!m)
252         return -1;
253     
254     s->min_qcoeff=-1023;
255     s->max_qcoeff= 1023;
256
257     /* build all the huffman tables */
258     build_huffman_codes(m->huff_size_dc_luminance,
259                         m->huff_code_dc_luminance,
260                         bits_dc_luminance,
261                         val_dc_luminance);
262     build_huffman_codes(m->huff_size_dc_chrominance,
263                         m->huff_code_dc_chrominance,
264                         bits_dc_chrominance,
265                         val_dc_chrominance);
266     build_huffman_codes(m->huff_size_ac_luminance,
267                         m->huff_code_ac_luminance,
268                         bits_ac_luminance,
269                         val_ac_luminance);
270     build_huffman_codes(m->huff_size_ac_chrominance,
271                         m->huff_code_ac_chrominance,
272                         bits_ac_chrominance,
273                         val_ac_chrominance);
274     
275     s->mjpeg_ctx = m;
276     return 0;
277 }
278
279 void mjpeg_close(MpegEncContext *s)
280 {
281     av_free(s->mjpeg_ctx);
282 }
283
284 #define PREDICT(ret, topleft, top, left, predictor)\
285     switch(predictor){\
286         case 1: ret= left; break;\
287         case 2: ret= top; break;\
288         case 3: ret= topleft; break;\
289         case 4: ret= left   +   top - topleft; break;\
290         case 5: ret= left   + ((top - topleft)>>1); break;\
291         case 6: ret= top + ((left   - topleft)>>1); break;\
292         default:\
293         case 7: ret= (left + top)>>1; break;\
294     }
295
296 #ifdef CONFIG_ENCODERS
297 static inline void put_marker(PutBitContext *p, int code)
298 {
299     put_bits(p, 8, 0xff);
300     put_bits(p, 8, code);
301 }
302
303 /* table_class: 0 = DC coef, 1 = AC coefs */
304 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
305                              const uint8_t *bits_table, const uint8_t *value_table)
306 {
307     PutBitContext *p = &s->pb;
308     int n, i;
309
310     put_bits(p, 4, table_class);
311     put_bits(p, 4, table_id);
312
313     n = 0;
314     for(i=1;i<=16;i++) {
315         n += bits_table[i];
316         put_bits(p, 8, bits_table[i]);
317     }
318
319     for(i=0;i<n;i++)
320         put_bits(p, 8, value_table[i]);
321
322     return n + 17;
323 }
324
325 static void jpeg_table_header(MpegEncContext *s)
326 {
327     PutBitContext *p = &s->pb;
328     int i, j, size;
329     uint8_t *ptr;
330
331     /* quant matrixes */
332     put_marker(p, DQT);
333 #ifdef TWOMATRIXES
334     put_bits(p, 16, 2 + 2 * (1 + 64));
335 #else
336     put_bits(p, 16, 2 + 1 * (1 + 64));
337 #endif
338     put_bits(p, 4, 0); /* 8 bit precision */
339     put_bits(p, 4, 0); /* table 0 */
340     for(i=0;i<64;i++) {
341         j = s->intra_scantable.permutated[i];
342         put_bits(p, 8, s->intra_matrix[j]);
343     }
344 #ifdef TWOMATRIXES
345     put_bits(p, 4, 0); /* 8 bit precision */
346     put_bits(p, 4, 1); /* table 1 */
347     for(i=0;i<64;i++) {
348         j = s->intra_scantable.permutated[i];
349         put_bits(p, 8, s->chroma_intra_matrix[j]);
350     }
351 #endif
352
353     /* huffman table */
354     put_marker(p, DHT);
355     flush_put_bits(p);
356     ptr = pbBufPtr(p);
357     put_bits(p, 16, 0); /* patched later */
358     size = 2;
359     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
360     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
361     
362     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
363     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
364     ptr[0] = size >> 8;
365     ptr[1] = size;
366 }
367
368 static void jpeg_put_comments(MpegEncContext *s)
369 {
370     PutBitContext *p = &s->pb;
371     int size;
372     uint8_t *ptr;
373
374     if (s->aspect_ratio_info /* && !lossless */)
375     {
376     /* JFIF header */
377     put_marker(p, APP0);
378     put_bits(p, 16, 16);
379     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
380     put_bits(p, 16, 0x0201); /* v 1.02 */
381     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
382     switch(s->aspect_ratio_info)
383     {
384         case FF_ASPECT_4_3_625:
385         case FF_ASPECT_4_3_525:
386             put_bits(p, 16, 4); 
387             put_bits(p, 16, 3);
388             break;
389         case FF_ASPECT_16_9_625:
390         case FF_ASPECT_16_9_525:
391             put_bits(p, 16, 16); 
392             put_bits(p, 16, 9);
393             break;
394         case FF_ASPECT_EXTENDED:
395             put_bits(p, 16, s->aspected_width);
396             put_bits(p, 16, s->aspected_height);
397             break;
398         case FF_ASPECT_SQUARE:
399         default:
400             put_bits(p, 16, 1); /* aspect: 1:1 */
401             put_bits(p, 16, 1);
402             break;
403     }
404     put_bits(p, 8, 0); /* thumbnail width */
405     put_bits(p, 8, 0); /* thumbnail height */
406     }
407
408     /* comment */
409     if(!(s->flags & CODEC_FLAG_BITEXACT)){
410         put_marker(p, COM);
411         flush_put_bits(p);
412         ptr = pbBufPtr(p);
413         put_bits(p, 16, 0); /* patched later */
414         put_string(p, LIBAVCODEC_IDENT);
415         size = strlen(LIBAVCODEC_IDENT)+3;
416         ptr[0] = size >> 8;
417         ptr[1] = size;
418     }
419 }
420
421 void mjpeg_picture_header(MpegEncContext *s)
422 {
423     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
424
425     put_marker(&s->pb, SOI);
426
427     if (!s->mjpeg_data_only_frames)
428     {
429     jpeg_put_comments(s);    
430
431     if (s->mjpeg_write_tables) jpeg_table_header(s);
432
433     put_marker(&s->pb, lossless ? SOF3 : SOF0);
434
435     put_bits(&s->pb, 16, 17);
436     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
437         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
438     else
439         put_bits(&s->pb, 8, 8); /* 8 bits/component */
440     put_bits(&s->pb, 16, s->height);
441     put_bits(&s->pb, 16, s->width);
442     put_bits(&s->pb, 8, 3); /* 3 components */
443     
444     /* Y component */
445     put_bits(&s->pb, 8, 1); /* component number */
446     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
447     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
448     put_bits(&s->pb, 8, 0); /* select matrix */
449     
450     /* Cb component */
451     put_bits(&s->pb, 8, 2); /* component number */
452     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
453     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
454 #ifdef TWOMATRIXES
455     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
456 #else
457     put_bits(&s->pb, 8, 0); /* select matrix */
458 #endif
459
460     /* Cr component */
461     put_bits(&s->pb, 8, 3); /* component number */
462     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
463     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
464 #ifdef TWOMATRIXES
465     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
466 #else
467     put_bits(&s->pb, 8, 0); /* select matrix */
468 #endif
469     }
470
471     /* scan header */
472     put_marker(&s->pb, SOS);
473     put_bits(&s->pb, 16, 12); /* length */
474     put_bits(&s->pb, 8, 3); /* 3 components */
475     
476     /* Y component */
477     put_bits(&s->pb, 8, 1); /* index */
478     put_bits(&s->pb, 4, 0); /* DC huffman table index */
479     put_bits(&s->pb, 4, 0); /* AC huffman table index */
480     
481     /* Cb component */
482     put_bits(&s->pb, 8, 2); /* index */
483     put_bits(&s->pb, 4, 1); /* DC huffman table index */
484     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
485     
486     /* Cr component */
487     put_bits(&s->pb, 8, 3); /* index */
488     put_bits(&s->pb, 4, 1); /* DC huffman table index */
489     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
490
491     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
492     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
493     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
494 }
495
496 static void escape_FF(MpegEncContext *s, int start)
497 {
498     int size= get_bit_count(&s->pb) - start*8;
499     int i, ff_count;
500     uint8_t *buf= s->pb.buf + start;
501     int align= (-(size_t)(buf))&3;
502     
503     assert((size&7) == 0);
504     size >>= 3;
505     
506     ff_count=0;
507     for(i=0; i<size && i<align; i++){
508         if(buf[i]==0xFF) ff_count++;
509     }
510     for(; i<size-15; i+=16){
511         int acc, v;
512
513         v= *(uint32_t*)(&buf[i]);
514         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
515         v= *(uint32_t*)(&buf[i+4]);
516         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517         v= *(uint32_t*)(&buf[i+8]);
518         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519         v= *(uint32_t*)(&buf[i+12]);
520         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
521
522         acc>>=4;
523         acc+= (acc>>16);
524         acc+= (acc>>8);
525         ff_count+= acc&0xFF;
526     }
527     for(; i<size; i++){
528         if(buf[i]==0xFF) ff_count++;
529     }
530
531     if(ff_count==0) return;
532     
533     /* skip put bits */
534     for(i=0; i<ff_count-3; i+=4)
535         put_bits(&s->pb, 32, 0);
536     put_bits(&s->pb, (ff_count-i)*8, 0);
537     flush_put_bits(&s->pb); 
538
539     for(i=size-1; ff_count; i--){
540         int v= buf[i];
541
542         if(v==0xFF){
543 //printf("%d %d\n", i, ff_count);
544             buf[i+ff_count]= 0;
545             ff_count--;
546         }
547
548         buf[i+ff_count]= v;
549     }
550 }
551
552 void mjpeg_picture_trailer(MpegEncContext *s)
553 {
554     int pad= (-get_bit_count(&s->pb))&7;
555     
556     put_bits(&s->pb, pad,0xFF>>(8-pad));
557     flush_put_bits(&s->pb);
558
559     assert((s->header_bits&7)==0);
560     
561     escape_FF(s, s->header_bits>>3);
562
563     put_marker(&s->pb, EOI);
564 }
565
566 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
567                                    uint8_t *huff_size, uint16_t *huff_code)
568 {
569     int mant, nbits;
570
571     if (val == 0) {
572         put_bits(&s->pb, huff_size[0], huff_code[0]);
573     } else {
574         mant = val;
575         if (val < 0) {
576             val = -val;
577             mant--;
578         }
579         
580         nbits= av_log2_16bit(val) + 1;
581             
582         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
583         
584         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
585     }
586 }
587
588 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
589 {
590     int mant, nbits, code, i, j;
591     int component, dc, run, last_index, val;
592     MJpegContext *m = s->mjpeg_ctx;
593     uint8_t *huff_size_ac;
594     uint16_t *huff_code_ac;
595     
596     /* DC coef */
597     component = (n <= 3 ? 0 : n - 4 + 1);
598     dc = block[0]; /* overflow is impossible */
599     val = dc - s->last_dc[component];
600     if (n < 4) {
601         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
602         huff_size_ac = m->huff_size_ac_luminance;
603         huff_code_ac = m->huff_code_ac_luminance;
604     } else {
605         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
606         huff_size_ac = m->huff_size_ac_chrominance;
607         huff_code_ac = m->huff_code_ac_chrominance;
608     }
609     s->last_dc[component] = dc;
610     
611     /* AC coefs */
612     
613     run = 0;
614     last_index = s->block_last_index[n];
615     for(i=1;i<=last_index;i++) {
616         j = s->intra_scantable.permutated[i];
617         val = block[j];
618         if (val == 0) {
619             run++;
620         } else {
621             while (run >= 16) {
622                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
623                 run -= 16;
624             }
625             mant = val;
626             if (val < 0) {
627                 val = -val;
628                 mant--;
629             }
630             
631             nbits= av_log2(val) + 1;
632             code = (run << 4) | nbits;
633
634             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
635         
636             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
637             run = 0;
638         }
639     }
640
641     /* output EOB only if not already 64 values */
642     if (last_index < 63 || run != 0)
643         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
644 }
645
646 void mjpeg_encode_mb(MpegEncContext *s, 
647                      DCTELEM block[6][64])
648 {
649     int i;
650     for(i=0;i<6;i++) {
651         encode_block(s, block[i], i);
652     }
653 }
654
655 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
656     MpegEncContext * const s = avctx->priv_data;
657     MJpegContext * const m = s->mjpeg_ctx;
658     AVFrame *pict = data;
659     const int width= s->width;
660     const int height= s->height;
661     AVFrame * const p= (AVFrame*)&s->current_picture;
662     const int predictor= avctx->prediction_method+1;
663
664     init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
665
666     *p = *pict;
667     p->pict_type= FF_I_TYPE;
668     p->key_frame= 1;
669     
670     mjpeg_picture_header(s);
671
672     s->header_bits= get_bit_count(&s->pb);
673
674     if(avctx->pix_fmt == PIX_FMT_RGBA32){
675         int x, y, i;
676         const int linesize= p->linesize[0];
677         uint16_t buffer[2048][4];
678         int left[3], top[3], topleft[3];
679
680         for(i=0; i<3; i++){
681             buffer[0][i]= 1 << (9 - 1);
682         }
683
684         for(y = 0; y < height; y++) {
685             const int modified_predictor= y ? predictor : 1;
686             uint8_t *ptr = p->data[0] + (linesize * y);
687
688             for(i=0; i<3; i++){
689                 top[i]= left[i]= topleft[i]= buffer[0][i];
690             }
691             for(x = 0; x < width; x++) {
692                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
693                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
694                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
695
696                 for(i=0;i<3;i++) {
697                     int pred, diff;
698
699                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
700                         
701                     topleft[i]= top[i];
702                     top[i]= buffer[x+1][i];
703                     
704                     left[i]= buffer[x][i];
705
706                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
707                     
708                     if(i==0)
709                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
710                     else
711                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
712                 }
713             }
714         }
715     }else{
716         int mb_x, mb_y, i;
717         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
718         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
719         
720         for(mb_y = 0; mb_y < mb_height; mb_y++) {
721             for(mb_x = 0; mb_x < mb_width; mb_x++) {
722                 if(mb_x==0 || mb_y==0){
723                     for(i=0;i<3;i++) {
724                         uint8_t *ptr;
725                         int x, y, h, v, linesize;
726                         h = s->mjpeg_hsample[i];
727                         v = s->mjpeg_vsample[i];
728                         linesize= p->linesize[i];
729
730                         for(y=0; y<v; y++){
731                             for(x=0; x<h; x++){
732                                 int pred;
733
734                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
735                                 if(y==0 && mb_y==0){
736                                     if(x==0 && mb_x==0){
737                                         pred= 128;
738                                     }else{
739                                         pred= ptr[-1];
740                                     }
741                                 }else{
742                                     if(x==0 && mb_x==0){
743                                         pred= ptr[-linesize];
744                                     }else{
745                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
746                                     }
747                                 }
748                                 
749                                 if(i==0)
750                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
751                                 else
752                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
753                             }
754                         }
755                     }
756                 }else{
757                     for(i=0;i<3;i++) {
758                         uint8_t *ptr;
759                         int x, y, h, v, linesize;
760                         h = s->mjpeg_hsample[i];
761                         v = s->mjpeg_vsample[i];
762                         linesize= p->linesize[i];
763                              
764                         for(y=0; y<v; y++){
765                             for(x=0; x<h; x++){
766                                 int pred;
767
768                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
769 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); 
770                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
771
772                                 if(i==0)
773                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
774                                 else
775                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
776                             }
777                         }
778                     }
779                 }
780             }
781         }
782     }
783
784     emms_c();
785     
786     mjpeg_picture_trailer(s);
787     s->picture_number++;
788
789     flush_put_bits(&s->pb);
790     return pbBufPtr(&s->pb) - s->pb.buf;
791 //    return (get_bit_count(&f->pb)+7)/8;
792 }
793
794 #endif //CONFIG_ENCODERS
795
796 /******************************************/
797 /* decoding */
798
799 #define MAX_COMPONENTS 4
800
801 typedef struct MJpegDecodeContext {
802     AVCodecContext *avctx;
803     GetBitContext gb;
804     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
805
806     int start_code; /* current start code */
807     int buffer_size;
808     uint8_t *buffer;
809
810     int16_t quant_matrixes[4][64];
811     VLC vlcs[2][4];
812     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
813
814     int org_width, org_height;  /* size given at codec init */
815     int first_picture;    /* true if decoding first picture */
816     int interlaced;     /* true if interlaced */
817     int bottom_field;   /* true if bottom field */
818     int lossless;
819     int rgb;
820     int rct;            /* standard rct */  
821     int pegasus_rct;    /* pegasus reversible colorspace transform */  
822     int bits;           /* bits per component */
823
824     int width, height;
825     int mb_width, mb_height;
826     int nb_components;
827     int component_id[MAX_COMPONENTS];
828     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
829     int v_count[MAX_COMPONENTS];
830     int comp_index[MAX_COMPONENTS];
831     int dc_index[MAX_COMPONENTS];
832     int ac_index[MAX_COMPONENTS];
833     int nb_blocks[MAX_COMPONENTS];
834     int h_scount[MAX_COMPONENTS];
835     int v_scount[MAX_COMPONENTS];
836     int h_max, v_max; /* maximum h and v counts */
837     int quant_index[4];   /* quant table index for each component */
838     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
839     AVFrame picture; /* picture structure */
840     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
841     uint8_t *qscale_table;
842     DCTELEM block[64] __align8;
843     ScanTable scantable;
844     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
845
846     int restart_interval;
847     int restart_count;
848
849     int buggy_avid;
850     int interlace_polarity;
851 } MJpegDecodeContext;
852
853 static int mjpeg_decode_dht(MJpegDecodeContext *s);
854
855 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
856                       int nb_codes)
857 {
858     uint8_t huff_size[256];
859     uint16_t huff_code[256];
860
861     memset(huff_size, 0, sizeof(huff_size));
862     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
863     
864     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
865 }
866
867 static int mjpeg_decode_init(AVCodecContext *avctx)
868 {
869     MJpegDecodeContext *s = avctx->priv_data;
870     MpegEncContext s2;
871
872     s->avctx = avctx;
873
874     /* ugly way to get the idct & scantable FIXME */
875     memset(&s2, 0, sizeof(MpegEncContext));
876     s2.flags= avctx->flags;
877     s2.avctx= avctx;
878 //    s2->out_format = FMT_MJPEG;
879     s2.width = 8;
880     s2.height = 8;
881     if (MPV_common_init(&s2) < 0)
882        return -1;
883     s->scantable= s2.intra_scantable;
884     s->idct_put= s2.dsp.idct_put;
885     MPV_common_end(&s2);
886
887     s->mpeg_enc_ctx_allocated = 0;
888     s->buffer_size = 102400; /* smaller buffer should be enough,
889                                 but photojpg files could ahive bigger sizes */
890     s->buffer = av_malloc(s->buffer_size);
891     if (!s->buffer)
892         return -1;
893     s->start_code = -1;
894     s->first_picture = 1;
895     s->org_width = avctx->width;
896     s->org_height = avctx->height;
897     
898     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
899     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
900     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
901     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
902
903     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
904     {
905         printf("mjpeg: using external huffman table\n");
906         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
907         mjpeg_decode_dht(s);
908         /* should check for error - but dunno */
909     }
910
911     return 0;
912 }
913
914 /* quantize tables */
915 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
916 {
917     int len, index, i, j;
918     
919     len = get_bits(&s->gb, 16) - 2;
920
921     while (len >= 65) {
922         /* only 8 bit precision handled */
923         if (get_bits(&s->gb, 4) != 0)
924         {
925             dprintf("dqt: 16bit precision\n");
926             return -1;
927         }
928         index = get_bits(&s->gb, 4);
929         if (index >= 4)
930             return -1;
931         dprintf("index=%d\n", index);
932         /* read quant table */
933         for(i=0;i<64;i++) {
934             j = s->scantable.permutated[i];
935             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
936         }
937
938         //XXX FIXME finetune, and perhaps add dc too
939         s->qscale[index]= FFMAX(
940             s->quant_matrixes[index][s->scantable.permutated[1]],
941             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
942         len -= 65;
943     }
944     
945     return 0;
946 }
947
948 /* decode huffman tables and build VLC decoders */
949 static int mjpeg_decode_dht(MJpegDecodeContext *s)
950 {
951     int len, index, i, class, n, v, code_max;
952     uint8_t bits_table[17];
953     uint8_t val_table[256];
954     
955     len = get_bits(&s->gb, 16) - 2;
956
957     while (len > 0) {
958         if (len < 17)
959             return -1;
960         class = get_bits(&s->gb, 4);
961         if (class >= 2)
962             return -1;
963         index = get_bits(&s->gb, 4);
964         if (index >= 4)
965             return -1;
966         n = 0;
967         for(i=1;i<=16;i++) {
968             bits_table[i] = get_bits(&s->gb, 8);
969             n += bits_table[i];
970         }
971         len -= 17;
972         if (len < n || n > 256)
973             return -1;
974
975         code_max = 0;
976         for(i=0;i<n;i++) {
977             v = get_bits(&s->gb, 8);
978             if (v > code_max)
979                 code_max = v;
980             val_table[i] = v;
981         }
982         len -= n;
983
984         /* build VLC and flush previous vlc if present */
985         free_vlc(&s->vlcs[class][index]);
986         dprintf("class=%d index=%d nb_codes=%d\n",
987                class, index, code_max + 1);
988         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
989             return -1;
990         }
991     }
992     return 0;
993 }
994
995 static int mjpeg_decode_sof(MJpegDecodeContext *s)
996 {
997     int len, nb_components, i, width, height;
998
999     /* XXX: verify len field validity */
1000     len = get_bits(&s->gb, 16);
1001     s->bits= get_bits(&s->gb, 8);
1002     
1003     if(s->pegasus_rct) s->bits=9;  
1004     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1005
1006     if (s->bits != 8 && !s->lossless){
1007         printf("only 8 bits/component accepted\n");
1008         return -1;
1009     }
1010     height = get_bits(&s->gb, 16);
1011     width = get_bits(&s->gb, 16);
1012     dprintf("sof0: picture: %dx%d\n", width, height);
1013
1014     nb_components = get_bits(&s->gb, 8);
1015     if (nb_components <= 0 ||
1016         nb_components > MAX_COMPONENTS)
1017         return -1;
1018     s->nb_components = nb_components;
1019     s->h_max = 1;
1020     s->v_max = 1;
1021     for(i=0;i<nb_components;i++) {
1022         /* component id */
1023         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1024         s->h_count[i] = get_bits(&s->gb, 4);
1025         s->v_count[i] = get_bits(&s->gb, 4);
1026         /* compute hmax and vmax (only used in interleaved case) */
1027         if (s->h_count[i] > s->h_max)
1028             s->h_max = s->h_count[i];
1029         if (s->v_count[i] > s->v_max)
1030             s->v_max = s->v_count[i];
1031         s->quant_index[i] = get_bits(&s->gb, 8);
1032         if (s->quant_index[i] >= 4)
1033             return -1;
1034         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1035             s->v_count[i], s->component_id[i], s->quant_index[i]);
1036     }
1037     
1038     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1039
1040     /* if different size, realloc/alloc picture */
1041     /* XXX: also check h_count and v_count */
1042     if (width != s->width || height != s->height) {
1043         av_freep(&s->qscale_table);
1044             
1045         s->width = width;
1046         s->height = height;
1047         /* test interlaced mode */
1048         if (s->first_picture &&
1049             s->org_height != 0 &&
1050             s->height < ((s->org_height * 3) / 4)) {
1051             s->interlaced = 1;
1052 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1053             s->bottom_field = 0;
1054         }
1055
1056         s->qscale_table= av_mallocz((s->width+15)/16);
1057
1058         s->first_picture = 0;
1059     }
1060     
1061     if(s->interlaced && s->bottom_field)
1062         return 0;
1063  
1064     /* XXX: not complete test ! */
1065     switch((s->h_count[0] << 4) | s->v_count[0]) {
1066     case 0x11:
1067         if(s->rgb){
1068             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1069         }else
1070             s->avctx->pix_fmt = PIX_FMT_YUV444P;
1071         break;
1072     case 0x21:
1073         s->avctx->pix_fmt = PIX_FMT_YUV422P;
1074         break;
1075     default:
1076     case 0x22:
1077         s->avctx->pix_fmt = PIX_FMT_YUV420P;
1078         break;
1079     }
1080
1081     if(s->picture.data[0])
1082         s->avctx->release_buffer(s->avctx, &s->picture);
1083
1084     s->picture.reference= 0;
1085     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1086         fprintf(stderr, "get_buffer() failed\n");
1087         return -1;
1088     }
1089     s->picture.pict_type= I_TYPE;
1090     s->picture.key_frame= 1;
1091     
1092     for(i=0; i<3; i++){
1093         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1094     }
1095
1096 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1097     
1098     if (len != (8+(3*nb_components)))
1099     {
1100         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1101     }
1102     
1103     return 0;
1104 }
1105
1106 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1107 {
1108     int code;
1109     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1110     if (code < 0)
1111     {
1112         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1113                 &s->vlcs[0][dc_index]);
1114         return 0xffff;
1115     }
1116
1117     if(code)
1118         return get_xbits(&s->gb, code);
1119     else
1120         return 0;
1121 }
1122
1123 /* decode block and dequantize */
1124 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1125                         int component, int dc_index, int ac_index, int quant_index)
1126 {
1127     int code, i, j, level, val;
1128     VLC *ac_vlc;
1129     int16_t *quant_matrix;
1130
1131     /* DC coef */
1132     val = mjpeg_decode_dc(s, dc_index);
1133     if (val == 0xffff) {
1134         dprintf("error dc\n");
1135         return -1;
1136     }
1137     quant_matrix = s->quant_matrixes[quant_index];
1138     val = val * quant_matrix[0] + s->last_dc[component];
1139     s->last_dc[component] = val;
1140     block[0] = val;
1141     /* AC coefs */
1142     ac_vlc = &s->vlcs[1][ac_index];
1143     i = 1;
1144     for(;;) {
1145         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1146
1147         if (code < 0) {
1148             dprintf("error ac\n");
1149             return -1;
1150         }
1151         /* EOB */
1152         if (code == 0)
1153             break;
1154         if (code == 0xf0) {
1155             i += 16;
1156         } else {
1157             level = get_xbits(&s->gb, code & 0xf);
1158             i += code >> 4;
1159             if (i >= 64) {
1160                 dprintf("error count: %d\n", i);
1161                 return -1;
1162             }
1163             j = s->scantable.permutated[i];
1164             block[j] = level * quant_matrix[j];
1165             i++;
1166             if (i >= 64)
1167                 break;
1168         }
1169     }
1170     return 0;
1171 }
1172
1173 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1174     int i, mb_x, mb_y;
1175     uint16_t buffer[2048][4];
1176     int left[3], top[3], topleft[3];
1177     const int linesize= s->linesize[0];
1178     const int mask= (1<<s->bits)-1;
1179     
1180     for(i=0; i<3; i++){
1181         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1182     }
1183     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1184         const int modified_predictor= mb_y ? predictor : 1;
1185         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1186
1187         if (s->interlaced && s->bottom_field)
1188             ptr += linesize >> 1;
1189
1190         for(i=0; i<3; i++){
1191             top[i]= left[i]= topleft[i]= buffer[0][i];
1192         }
1193         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1194             if (s->restart_interval && !s->restart_count)
1195                 s->restart_count = s->restart_interval;
1196
1197             for(i=0;i<3;i++) {
1198                 int pred;
1199
1200                 topleft[i]= top[i];
1201                 top[i]= buffer[mb_x][i];
1202
1203                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1204                 
1205                 left[i]= 
1206                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1207             }
1208
1209             if (s->restart_interval && !--s->restart_count) {
1210                 align_get_bits(&s->gb);
1211                 skip_bits(&s->gb, 16); /* skip RSTn */
1212             }
1213         }
1214
1215         if(s->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] - 0x200)>>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 if(s->pegasus_rct){
1222             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1223                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1224                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1225                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1226             }
1227         }else{
1228             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1229                 ptr[4*mb_x+0] = buffer[mb_x][0];
1230                 ptr[4*mb_x+1] = buffer[mb_x][1];
1231                 ptr[4*mb_x+2] = buffer[mb_x][2];
1232             }
1233         }
1234     }
1235     return 0;
1236 }
1237
1238 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1239     int i, mb_x, mb_y;
1240     const int nb_components=3;
1241
1242     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1243         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1244             if (s->restart_interval && !s->restart_count)
1245                 s->restart_count = s->restart_interval;
1246
1247             if(mb_x==0 || mb_y==0 || s->interlaced){
1248                 for(i=0;i<nb_components;i++) {
1249                     uint8_t *ptr;
1250                     int n, h, v, x, y, c, j, linesize;
1251                     n = s->nb_blocks[i];
1252                     c = s->comp_index[i];
1253                     h = s->h_scount[i];
1254                     v = s->v_scount[i];
1255                     x = 0;
1256                     y = 0;
1257                     linesize= s->linesize[c];
1258                     
1259                     for(j=0; j<n; j++) {
1260                         int pred;
1261
1262                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1263                         if(y==0 && mb_y==0){
1264                             if(x==0 && mb_x==0){
1265                                 pred= 128 << point_transform;
1266                             }else{
1267                                 pred= ptr[-1];
1268                             }
1269                         }else{
1270                             if(x==0 && mb_x==0){
1271                                 pred= ptr[-linesize];
1272                             }else{
1273                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1274                             }
1275                         }
1276                         
1277                         if (s->interlaced && s->bottom_field)
1278                             ptr += linesize >> 1;
1279                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1280
1281                         if (++x == h) {
1282                             x = 0;
1283                             y++;
1284                         }
1285                     }
1286                 }
1287             }else{
1288                 for(i=0;i<nb_components;i++) {
1289                     uint8_t *ptr;
1290                     int n, h, v, x, y, c, j, linesize;
1291                     n = s->nb_blocks[i];
1292                     c = s->comp_index[i];
1293                     h = s->h_scount[i];
1294                     v = s->v_scount[i];
1295                     x = 0;
1296                     y = 0;
1297                     linesize= s->linesize[c];
1298                     
1299                     for(j=0; j<n; j++) {
1300                         int pred;
1301
1302                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1303                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1304                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1305                         if (++x == h) {
1306                             x = 0;
1307                             y++;
1308                         }
1309                     }
1310                 }
1311             }
1312             if (s->restart_interval && !--s->restart_count) {
1313                 align_get_bits(&s->gb);
1314                 skip_bits(&s->gb, 16); /* skip RSTn */
1315             }
1316         }
1317     }
1318     return 0;
1319 }
1320
1321 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1322     int i, mb_x, mb_y;
1323     const int nb_components=3;
1324
1325     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1326         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1327             if (s->restart_interval && !s->restart_count)
1328                 s->restart_count = s->restart_interval;
1329
1330             for(i=0;i<nb_components;i++) {
1331                 uint8_t *ptr;
1332                 int n, h, v, x, y, c, j;
1333                 n = s->nb_blocks[i];
1334                 c = s->comp_index[i];
1335                 h = s->h_scount[i];
1336                 v = s->v_scount[i];
1337                 x = 0;
1338                 y = 0;
1339                 for(j=0;j<n;j++) {
1340                     memset(s->block, 0, sizeof(s->block));
1341                     if (decode_block(s, s->block, i, 
1342                                      s->dc_index[i], s->ac_index[i], 
1343                                      s->quant_index[c]) < 0) {
1344                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1345                         return -1;
1346                     }
1347 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1348                     ptr = s->picture.data[c] + 
1349                         (s->linesize[c] * (v * mb_y + y) * 8) + 
1350                         (h * mb_x + x) * 8;
1351                     if (s->interlaced && s->bottom_field)
1352                         ptr += s->linesize[c] >> 1;
1353 //printf("%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);
1354                     s->idct_put(ptr, s->linesize[c], s->block);
1355                     if (++x == h) {
1356                         x = 0;
1357                         y++;
1358                     }
1359                 }
1360             }
1361             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1362             if (s->restart_interval && (s->restart_interval < 1350) &&
1363                 !--s->restart_count) {
1364                 align_get_bits(&s->gb);
1365                 skip_bits(&s->gb, 16); /* skip RSTn */
1366                 for (i=0; i<nb_components; i++) /* reset dc */
1367                     s->last_dc[i] = 1024;
1368             }
1369         }
1370     }
1371     return 0;
1372 }
1373
1374 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1375 {
1376     int len, nb_components, i, h, v, predictor, point_transform;
1377     int vmax, hmax, index, id;
1378     const int block_size= s->lossless ? 1 : 8;
1379
1380     /* XXX: verify len field validity */
1381     len = get_bits(&s->gb, 16);
1382     nb_components = get_bits(&s->gb, 8);
1383     if (len != 6+2*nb_components)
1384     {
1385         dprintf("decode_sos: invalid len (%d)\n", len);
1386         return -1;
1387     }
1388     /* XXX: only interleaved scan accepted */
1389     if (nb_components != 3)
1390     {
1391         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1392         return -1;
1393     }
1394     vmax = 0;
1395     hmax = 0;
1396     for(i=0;i<nb_components;i++) {
1397         id = get_bits(&s->gb, 8) - 1;
1398         dprintf("component: %d\n", id);
1399         /* find component index */
1400         for(index=0;index<s->nb_components;index++)
1401             if (id == s->component_id[index])
1402                 break;
1403         if (index == s->nb_components)
1404         {
1405             dprintf("decode_sos: index(%d) out of components\n", index);
1406             return -1;
1407         }
1408
1409         s->comp_index[i] = index;
1410
1411         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1412         s->h_scount[i] = s->h_count[index];
1413         s->v_scount[i] = s->v_count[index];
1414
1415         s->dc_index[i] = get_bits(&s->gb, 4);
1416         s->ac_index[i] = get_bits(&s->gb, 4);
1417
1418         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1419             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1420             goto out_of_range;
1421 #if 0 //buggy
1422         switch(s->start_code)
1423         {
1424             case SOF0:
1425                 if (dc_index[i] > 1 || ac_index[i] > 1)
1426                     goto out_of_range;
1427                 break;
1428             case SOF1:
1429             case SOF2:
1430                 if (dc_index[i] > 3 || ac_index[i] > 3)
1431                     goto out_of_range;
1432                 break;
1433             case SOF3:
1434                 if (dc_index[i] > 3 || ac_index[i] != 0)
1435                     goto out_of_range;
1436                 break;  
1437         }
1438 #endif
1439     }
1440
1441     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1442     skip_bits(&s->gb, 8); /* Se */
1443     skip_bits(&s->gb, 4); /* Ah */
1444     point_transform= get_bits(&s->gb, 4); /* Al */
1445
1446     for(i=0;i<nb_components;i++) 
1447         s->last_dc[i] = 1024;
1448
1449     if (nb_components > 1) {
1450         /* interleaved stream */
1451         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1452         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1453     } else {
1454         h = s->h_max / s->h_scount[s->comp_index[0]];
1455         v = s->v_max / s->v_scount[s->comp_index[0]];
1456         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1457         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1458         s->nb_blocks[0] = 1;
1459         s->h_scount[0] = 1;
1460         s->v_scount[0] = 1;
1461     }
1462
1463     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1464         printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1465     
1466     if(s->lossless){
1467             if(s->rgb){
1468                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1469                     return -1;
1470             }else{
1471                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1472                     return -1;
1473             }
1474     }else{
1475         if(mjpeg_decode_scan(s) < 0)
1476             return -1;
1477     }
1478     emms_c();
1479     return 0;
1480  out_of_range:
1481     dprintf("decode_sos: ac/dc index out of range\n");
1482     return -1;
1483 }
1484
1485 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1486 {
1487     if (get_bits(&s->gb, 16) != 4)
1488         return -1;
1489     s->restart_interval = get_bits(&s->gb, 16);
1490     dprintf("restart interval: %d\n", s->restart_interval);
1491
1492     return 0;
1493 }
1494
1495 static int mjpeg_decode_app(MJpegDecodeContext *s)
1496 {
1497     int len, id;
1498
1499     /* XXX: verify len field validity */
1500     len = get_bits(&s->gb, 16);
1501     if (len < 5)
1502         return -1;
1503
1504     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1505     id = be2me_32(id);
1506     len -= 6;
1507
1508     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1509         printf("APPx %8X\n", id); 
1510     }
1511     
1512     /* buggy AVID, it puts EOI only at every 10th frame */
1513     /* also this fourcc is used by non-avid files too, it holds some
1514        informations, but it's always present in AVID creates files */
1515     if (id == ff_get_fourcc("AVI1"))
1516     {
1517         /* structure:
1518             4bytes      AVI1
1519             1bytes      polarity
1520             1bytes      always zero
1521             4bytes      field_size
1522             4bytes      field_size_less_padding
1523         */
1524         s->buggy_avid = 1;
1525 //      if (s->first_picture)
1526 //          printf("mjpeg: workarounding buggy AVID\n");
1527         s->interlace_polarity = get_bits(&s->gb, 8);
1528 #if 0
1529         skip_bits(&s->gb, 8);
1530         skip_bits(&s->gb, 32);
1531         skip_bits(&s->gb, 32);
1532         len -= 10;
1533 #endif
1534 //      if (s->interlace_polarity)
1535 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1536         goto out;
1537     }
1538     
1539 //    len -= 2;
1540     
1541     if (id == ff_get_fourcc("JFIF"))
1542     {
1543         int t_w, t_h;
1544         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1545         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1546             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1547         if (get_bits(&s->gb, 8) == 0)
1548         {
1549             int x_density, y_density; 
1550             x_density = get_bits(&s->gb, 16);
1551             y_density = get_bits(&s->gb, 16);
1552
1553             dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1554                 (float)x_density, y_density, (float)y_density);
1555 #if 0
1556             //MN: needs to be checked
1557             if(x_density)
1558 //                s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1559                 s->avctx->aspect_ratio = (float)x_density/y_density;
1560                 /* it's better, but every JFIF I have seen stores 1:1 */
1561             else
1562                 s->avctx->aspect_ratio= 0.0;
1563 #endif
1564         }
1565         else
1566         {
1567             skip_bits(&s->gb, 16);
1568             skip_bits(&s->gb, 16);
1569         }
1570
1571         t_w = get_bits(&s->gb, 8);
1572         t_h = get_bits(&s->gb, 8);
1573         if (t_w && t_h)
1574         {
1575             /* skip thumbnail */
1576             if (len-10-(t_w*t_h*3) > 0)
1577                 len -= t_w*t_h*3;
1578         }
1579         len -= 10;
1580         goto out;
1581     }
1582     
1583     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1584     {
1585         printf("mjpeg: Adobe header found\n");
1586         skip_bits(&s->gb, 16); /* version */
1587         skip_bits(&s->gb, 16); /* flags0 */
1588         skip_bits(&s->gb, 16); /* flags1 */
1589         skip_bits(&s->gb, 8); /* transform */
1590         len -= 7;
1591         goto out;
1592     }
1593
1594     if (id == ff_get_fourcc("LJIF")){
1595         printf("Pegasus lossless jpeg header found\n");
1596         skip_bits(&s->gb, 16); /* version ? */
1597         skip_bits(&s->gb, 16); /* unknwon always 0? */
1598         skip_bits(&s->gb, 16); /* unknwon always 0? */
1599         skip_bits(&s->gb, 16); /* unknwon always 0? */
1600         switch( get_bits(&s->gb, 8)){
1601         case 1:
1602             s->rgb= 1;
1603             s->pegasus_rct=0;
1604             break;
1605         case 2:
1606             s->rgb= 1;
1607             s->pegasus_rct=1;
1608             break;
1609         default:
1610             printf("unknown colorspace\n");
1611         }
1612         len -= 9;
1613         goto out;
1614     }
1615     
1616     /* Apple MJPEG-A */
1617     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1618     {
1619         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1620         id = be2me_32(id);
1621         len -= 4;
1622         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1623         {
1624 #if 0
1625             skip_bits(&s->gb, 32); /* field size */
1626             skip_bits(&s->gb, 32); /* pad field size */
1627             skip_bits(&s->gb, 32); /* next off */
1628             skip_bits(&s->gb, 32); /* quant off */
1629             skip_bits(&s->gb, 32); /* huff off */
1630             skip_bits(&s->gb, 32); /* image off */
1631             skip_bits(&s->gb, 32); /* scan off */
1632             skip_bits(&s->gb, 32); /* data off */
1633 #endif
1634             if (s->first_picture)
1635                 printf("mjpeg: Apple MJPEG-A header found\n");
1636         }
1637     }
1638
1639 out:
1640     /* slow but needed for extreme adobe jpegs */
1641     if (len < 0)
1642         printf("mjpeg: error, decode_app parser read over the end\n");
1643     while(--len > 0)
1644         skip_bits(&s->gb, 8);
1645
1646     return 0;
1647 }
1648
1649 static int mjpeg_decode_com(MJpegDecodeContext *s)
1650 {
1651     /* XXX: verify len field validity */
1652     int len = get_bits(&s->gb, 16);
1653     if (len >= 2 && len < 32768) {
1654         /* XXX: any better upper bound */
1655         uint8_t *cbuf = av_malloc(len - 1);
1656         if (cbuf) {
1657             int i;
1658             for (i = 0; i < len - 2; i++)
1659                 cbuf[i] = get_bits(&s->gb, 8);
1660             if (i > 0 && cbuf[i-1] == '\n')
1661                 cbuf[i-1] = 0;
1662             else
1663                 cbuf[i] = 0;
1664
1665             printf("mjpeg comment: '%s'\n", cbuf);
1666
1667             /* buggy avid, it puts EOI only at every 10th frame */
1668             if (!strcmp(cbuf, "AVID"))
1669             {
1670                 s->buggy_avid = 1;
1671                 //      if (s->first_picture)
1672                 //          printf("mjpeg: workarounding buggy AVID\n");
1673             }
1674
1675             av_free(cbuf);
1676         }
1677     }
1678
1679     return 0;
1680 }
1681
1682 #if 0
1683 static int valid_marker_list[] =
1684 {
1685         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1686 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1691 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1698 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1699 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1700 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1701 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1702 }
1703 #endif
1704
1705 /* return the 8 bit start code value and update the search
1706    state. Return -1 if no start code found */
1707 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1708 {
1709     uint8_t *buf_ptr;
1710     unsigned int v, v2;
1711     int val;
1712 #ifdef DEBUG
1713     int skipped=0;
1714 #endif
1715
1716     buf_ptr = *pbuf_ptr;
1717     while (buf_ptr < buf_end) {
1718         v = *buf_ptr++;
1719         v2 = *buf_ptr;
1720         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1721             val = *buf_ptr++;
1722             goto found;
1723         }
1724 #ifdef DEBUG
1725         skipped++;
1726 #endif
1727     }
1728     val = -1;
1729 found:
1730 #ifdef DEBUG
1731     dprintf("find_marker skipped %d bytes\n", skipped);
1732 #endif
1733     *pbuf_ptr = buf_ptr;
1734     return val;
1735 }
1736
1737 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1738                               void *data, int *data_size,
1739                               uint8_t *buf, int buf_size)
1740 {
1741     MJpegDecodeContext *s = avctx->priv_data;
1742     uint8_t *buf_end, *buf_ptr;
1743     int i, start_code;
1744     AVFrame *picture = data;
1745
1746     *data_size = 0;
1747
1748     /* no supplementary picture */
1749     if (buf_size == 0)
1750         return 0;
1751
1752     buf_ptr = buf;
1753     buf_end = buf + buf_size;
1754     while (buf_ptr < buf_end) {
1755         /* find start next marker */
1756         start_code = find_marker(&buf_ptr, buf_end);
1757         {
1758             /* EOF */
1759             if (start_code < 0) {
1760                 goto the_end;
1761             } else {
1762                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1763                 
1764                 if ((buf_end - buf_ptr) > s->buffer_size)
1765                 {
1766                     av_free(s->buffer);
1767                     s->buffer_size = buf_end-buf_ptr;
1768                     s->buffer = av_malloc(s->buffer_size);
1769                     dprintf("buffer too small, expanding to %d bytes\n",
1770                         s->buffer_size);
1771                 }
1772                 
1773                 /* unescape buffer of SOS */
1774                 if (start_code == SOS)
1775                 {
1776                     uint8_t *src = buf_ptr;
1777                     uint8_t *dst = s->buffer;
1778
1779                     while (src<buf_end)
1780                     {
1781                         uint8_t x = *(src++);
1782
1783                         *(dst++) = x;
1784                         if (x == 0xff)
1785                         {
1786                             while(*src == 0xff) src++;
1787
1788                             x = *(src++);
1789                             if (x >= 0xd0 && x <= 0xd7)
1790                                 *(dst++) = x;
1791                             else if (x)
1792                                 break;
1793                         }
1794                     }
1795                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1796                     
1797                     dprintf("escaping removed %d bytes\n",
1798                         (buf_end - buf_ptr) - (dst - s->buffer));
1799                 }
1800                 else
1801                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1802                 
1803                 s->start_code = start_code;
1804                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1805                     printf("startcode: %X\n", start_code);
1806                 }
1807
1808                 /* process markers */
1809                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1810                     dprintf("restart marker: %d\n", start_code&0x0f);
1811                 } else if (s->first_picture) {
1812                     /* APP fields */
1813                     if (start_code >= 0xe0 && start_code <= 0xef)
1814                         mjpeg_decode_app(s);
1815                     /* Comment */
1816                     else if (start_code == COM)
1817                         mjpeg_decode_com(s);
1818                 }
1819
1820                 switch(start_code) {
1821                 case SOI:
1822                     s->restart_interval = 0;
1823                     /* nothing to do on SOI */
1824                     break;
1825                 case DQT:
1826                     mjpeg_decode_dqt(s);
1827                     break;
1828                 case DHT:
1829                     if(mjpeg_decode_dht(s) < 0){
1830                         fprintf(stderr, "huffman table decode error\n");
1831                         return -1;
1832                     }
1833                     break;
1834                 case SOF0:
1835                     s->lossless=0;
1836                     if (mjpeg_decode_sof(s) < 0) 
1837                         return -1;
1838                     break;
1839                 case SOF3:
1840                     s->lossless=1;
1841                     if (mjpeg_decode_sof(s) < 0) 
1842                         return -1;
1843                     break;
1844                 case EOI:
1845                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1846                         break;
1847 eoi_parser:
1848                     {
1849                         if (s->interlaced) {
1850                             s->bottom_field ^= 1;
1851                             /* if not bottom field, do not output image yet */
1852                             if (s->bottom_field)
1853                                 goto not_the_end;
1854                         }
1855                         *picture = s->picture;
1856                         *data_size = sizeof(AVFrame);
1857                         avctx->height = s->height;
1858                         if (s->interlaced)
1859                             avctx->height *= 2;
1860                         avctx->width = s->width;
1861
1862                         if(!s->lossless){
1863                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1864                             picture->qstride= 0;
1865                             picture->qscale_table= s->qscale_table;
1866                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1867                             if(avctx->debug & FF_DEBUG_QP)
1868                                 printf("QP: %d\n", picture->quality);
1869                             picture->quality*= FF_QP2LAMBDA;
1870                         }
1871                         
1872                         goto the_end;
1873                     }
1874                     break;
1875                 case SOS:
1876                     mjpeg_decode_sos(s);
1877                     /* buggy avid puts EOI every 10-20th frame */
1878                     /* if restart period is over process EOI */
1879                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1880                         goto eoi_parser;
1881                     break;
1882                 case DRI:
1883                     mjpeg_decode_dri(s);
1884                     break;
1885                 case SOF1:
1886                 case SOF2:
1887                 case SOF5:
1888                 case SOF6:
1889                 case SOF7:
1890                 case SOF9:
1891                 case SOF10:
1892                 case SOF11:
1893                 case SOF13:
1894                 case SOF14:
1895                 case SOF15:
1896                 case JPG:
1897                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1898                     break;
1899 //              default:
1900 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1901 //                  break;
1902                 }
1903
1904 not_the_end:
1905                 /* eof process start code */
1906                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1907                 dprintf("marker parser used %d bytes (%d bits)\n",
1908                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1909             }
1910         }
1911     }
1912 the_end:
1913     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1914 //    return buf_end - buf_ptr;
1915     return buf_ptr - buf;
1916 }
1917
1918 static int mjpegb_decode_frame(AVCodecContext *avctx, 
1919                               void *data, int *data_size,
1920                               uint8_t *buf, int buf_size)
1921 {
1922     MJpegDecodeContext *s = avctx->priv_data;
1923     uint8_t *buf_end, *buf_ptr;
1924     int i;
1925     AVFrame *picture = data;
1926     GetBitContext hgb; /* for the header */
1927     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1928     uint32_t field_size;
1929
1930     *data_size = 0;
1931
1932     /* no supplementary picture */
1933     if (buf_size == 0)
1934         return 0;
1935
1936     buf_ptr = buf;
1937     buf_end = buf + buf_size;
1938     
1939 read_header:
1940     /* reset on every SOI */
1941     s->restart_interval = 0;
1942
1943     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1944
1945     skip_bits(&hgb, 32); /* reserved zeros */
1946     
1947     if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1948     {
1949         dprintf("not mjpeg-b (bad fourcc)\n");
1950         return 0;
1951     }
1952
1953     field_size = get_bits(&hgb, 32); /* field size */
1954     dprintf("field size: 0x%x\n", field_size);
1955     skip_bits(&hgb, 32); /* padded field size */
1956     second_field_offs = get_bits(&hgb, 32);
1957     dprintf("second field offs: 0x%x\n", second_field_offs);
1958     if (second_field_offs)
1959         s->interlaced = 1;
1960
1961     dqt_offs = get_bits(&hgb, 32);
1962     dprintf("dqt offs: 0x%x\n", dqt_offs);
1963     if (dqt_offs)
1964     {
1965         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1966         s->start_code = DQT;
1967         mjpeg_decode_dqt(s);
1968     }
1969     
1970     dht_offs = get_bits(&hgb, 32);
1971     dprintf("dht offs: 0x%x\n", dht_offs);
1972     if (dht_offs)
1973     {
1974         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1975         s->start_code = DHT;
1976         mjpeg_decode_dht(s);
1977     }
1978
1979     sof_offs = get_bits(&hgb, 32);
1980     dprintf("sof offs: 0x%x\n", sof_offs);
1981     if (sof_offs)
1982     {
1983         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1984         s->start_code = SOF0;
1985         if (mjpeg_decode_sof(s) < 0)
1986             return -1;
1987     }
1988
1989     sos_offs = get_bits(&hgb, 32);
1990     dprintf("sos offs: 0x%x\n", sos_offs);
1991     if (sos_offs)
1992     {
1993 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1994         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1995         s->start_code = SOS;
1996         mjpeg_decode_sos(s);
1997     }
1998
1999     skip_bits(&hgb, 32); /* start of data offset */
2000
2001     if (s->interlaced) {
2002         s->bottom_field ^= 1;
2003         /* if not bottom field, do not output image yet */
2004         if (s->bottom_field && second_field_offs)
2005         {
2006             buf_ptr = buf + second_field_offs;
2007             second_field_offs = 0;
2008             goto read_header;
2009         }
2010     }
2011
2012     //XXX FIXME factorize, this looks very similar to the EOI code
2013
2014     *picture= s->picture;
2015     *data_size = sizeof(AVFrame);
2016     avctx->height = s->height;
2017     if (s->interlaced)
2018         avctx->height *= 2;
2019     avctx->width = s->width;
2020     
2021     if(!s->lossless){
2022         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2023         picture->qstride= 0;
2024         picture->qscale_table= s->qscale_table;
2025         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2026         if(avctx->debug & FF_DEBUG_QP)
2027             printf("QP: %d\n", picture->quality);
2028         picture->quality*= FF_QP2LAMBDA;
2029     }
2030
2031     return buf_ptr - buf;
2032 }
2033
2034
2035 static int mjpeg_decode_end(AVCodecContext *avctx)
2036 {
2037     MJpegDecodeContext *s = avctx->priv_data;
2038     int i, j;
2039
2040     av_free(s->buffer);
2041     av_free(s->qscale_table);
2042     avcodec_default_free_buffers(avctx);
2043     
2044     for(i=0;i<2;i++) {
2045         for(j=0;j<4;j++)
2046             free_vlc(&s->vlcs[i][j]);
2047     }
2048     return 0;
2049 }
2050
2051 AVCodec mjpeg_decoder = {
2052     "mjpeg",
2053     CODEC_TYPE_VIDEO,
2054     CODEC_ID_MJPEG,
2055     sizeof(MJpegDecodeContext),
2056     mjpeg_decode_init,
2057     NULL,
2058     mjpeg_decode_end,
2059     mjpeg_decode_frame,
2060     CODEC_CAP_DR1,
2061     NULL
2062 };
2063
2064 AVCodec mjpegb_decoder = {
2065     "mjpegb",
2066     CODEC_TYPE_VIDEO,
2067     CODEC_ID_MJPEGB,
2068     sizeof(MJpegDecodeContext),
2069     mjpeg_decode_init,
2070     NULL,
2071     mjpeg_decode_end,
2072     mjpegb_decode_frame,
2073     CODEC_CAP_DR1,
2074     NULL
2075 };
2076
2077 #ifdef CONFIG_ENCODERS
2078 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2079     "ljpeg",
2080     CODEC_TYPE_VIDEO,
2081     CODEC_ID_LJPEG,
2082     sizeof(MpegEncContext),
2083     MPV_encode_init,
2084     encode_picture_lossless,
2085     MPV_encode_end,
2086 };
2087 #endif