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