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