d1d01273124e46120454bc37b0ab3e68287fd3a3
[ffmpeg.git] / libavcodec / mjpeg.c
1 /*
2  * MJPEG encoder and decoder
3  * Copyright (c) 2000, 2001 Gerard Lantau.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program 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
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  * Support for external huffman table and various fixes (AVID workaround) by
20  *                                    Alex Beregszaszi <alex@naxine.org>
21  */
22 //#define DEBUG
23 #include "avcodec.h"
24 #include "dsputil.h"
25 #include "mpegvideo.h"
26 #include "common.h"
27
28 #include <string.h>
29 #include <stdio.h>
30
31 #ifdef USE_FASTMEMCPY
32 #include "fastmemcpy.h"
33 #endif
34
35 /* use two quantizer table (one for luminance and one for chrominance) */
36 /* not yet working */
37 #undef TWOMATRIXES
38
39 typedef struct MJpegContext {
40     UINT8 huff_size_dc_luminance[12];
41     UINT16 huff_code_dc_luminance[12];
42     UINT8 huff_size_dc_chrominance[12];
43     UINT16 huff_code_dc_chrominance[12];
44
45     UINT8 huff_size_ac_luminance[256];
46     UINT16 huff_code_ac_luminance[256];
47     UINT8 huff_size_ac_chrominance[256];
48     UINT16 huff_code_ac_chrominance[256];
49 } MJpegContext;
50
51 /* JPEG marker codes */
52 typedef enum {
53     /* start of frame */
54     SOF0  = 0xc0,       /* baseline */
55     SOF1  = 0xc1,       /* extended sequential, huffman */
56     SOF2  = 0xc2,       /* progressive, huffman */
57     SOF3  = 0xc3,       /* lossless, huffman */
58
59     SOF5  = 0xc5,       /* differential sequential, huffman */
60     SOF6  = 0xc6,       /* differential progressive, huffman */
61     SOF7  = 0xc7,       /* differential lossless, huffman */
62     JPG   = 0xc8,       /* reserved for JPEG extension */
63     SOF9  = 0xc9,       /* extended sequential, arithmetic */
64     SOF10 = 0xca,       /* progressive, arithmetic */
65     SOF11 = 0xcb,       /* lossless, arithmetic */
66
67     SOF13 = 0xcd,       /* differential sequential, arithmetic */
68     SOF14 = 0xce,       /* differential progressive, arithmetic */
69     SOF15 = 0xcf,       /* differential lossless, arithmetic */
70
71     DHT   = 0xc4,       /* define huffman tables */
72
73     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
74
75     /* restart with modulo 8 count "m" */
76     RST0  = 0xd0,
77     RST1  = 0xd1,
78     RST2  = 0xd2,
79     RST3  = 0xd3,
80     RST4  = 0xd4,
81     RST5  = 0xd5,
82     RST6  = 0xd6,
83     RST7  = 0xd7,
84
85     SOI   = 0xd8,       /* start of image */
86     EOI   = 0xd9,       /* end of image */
87     SOS   = 0xda,       /* start of scan */
88     DQT   = 0xdb,       /* define quantization tables */
89     DNL   = 0xdc,       /* define number of lines */
90     DRI   = 0xdd,       /* define restart interval */
91     DHP   = 0xde,       /* define hierarchical progression */
92     EXP   = 0xdf,       /* expand reference components */
93
94     APP0  = 0xe0,
95     APP1  = 0xe1,
96     APP2  = 0xe2,
97     APP3  = 0xe3,
98     APP4  = 0xe4,
99     APP5  = 0xe5,
100     APP6  = 0xe6,
101     APP7  = 0xe7,
102     APP8  = 0xe8,
103     APP9  = 0xe9,
104     APP10 = 0xea,
105     APP11 = 0xeb,
106     APP12 = 0xec,
107     APP13 = 0xed,
108     APP14 = 0xee,
109     APP15 = 0xef,
110
111     JPG0  = 0xf0,
112     JPG1  = 0xf1,
113     JPG2  = 0xf2,
114     JPG3  = 0xf3,
115     JPG4  = 0xf4,
116     JPG5  = 0xf5,
117     JPG6  = 0xf6,
118     JPG7  = 0xf7,
119     JPG8  = 0xf8,
120     JPG9  = 0xf9,
121     JPG10 = 0xfa,
122     JPG11 = 0xfb,
123     JPG12 = 0xfc,
124     JPG13 = 0xfd,
125
126     COM   = 0xfe,       /* comment */
127
128     TEM   = 0x01,       /* temporary private use for arithmetic coding */
129
130     /* 0x02 -> 0xbf reserved */
131 } JPEG_MARKER;
132
133 #if 0
134 /* These are the sample quantization tables given in JPEG spec section K.1.
135  * The spec says that the values given produce "good" quality, and
136  * when divided by 2, "very good" quality.
137  */
138 static const unsigned char std_luminance_quant_tbl[64] = {
139     16,  11,  10,  16,  24,  40,  51,  61,
140     12,  12,  14,  19,  26,  58,  60,  55,
141     14,  13,  16,  24,  40,  57,  69,  56,
142     14,  17,  22,  29,  51,  87,  80,  62,
143     18,  22,  37,  56,  68, 109, 103,  77,
144     24,  35,  55,  64,  81, 104, 113,  92,
145     49,  64,  78,  87, 103, 121, 120, 101,
146     72,  92,  95,  98, 112, 100, 103,  99
147 };
148 static const unsigned char std_chrominance_quant_tbl[64] = {
149     17,  18,  24,  47,  99,  99,  99,  99,
150     18,  21,  26,  66,  99,  99,  99,  99,
151     24,  26,  56,  99,  99,  99,  99,  99,
152     47,  66,  99,  99,  99,  99,  99,  99,
153     99,  99,  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 };
158 #endif
159
160 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
161 /* IMPORTANT: these are only valid for 8-bit data precision! */
162 static const UINT8 bits_dc_luminance[17] =
163 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
164 static const UINT8 val_dc_luminance[] =
165 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
166
167 static const UINT8 bits_dc_chrominance[17] =
168 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
169 static const UINT8 val_dc_chrominance[] =
170 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
171
172 static const UINT8 bits_ac_luminance[17] =
173 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
174 static const UINT8 val_ac_luminance[] =
175 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
176   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
177   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
178   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
179   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
180   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
181   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
182   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
183   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
184   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
185   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
186   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
187   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
188   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
189   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
190   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
191   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
192   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
193   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
194   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
195   0xf9, 0xfa 
196 };
197
198 static const UINT8 bits_ac_chrominance[17] =
199 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
200
201 static const UINT8 val_ac_chrominance[] =
202 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
203   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
204   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
205   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
206   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
207   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
208   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
209   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
210   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
211   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
212   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
213   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
214   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
215   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
216   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
217   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
218   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
219   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
220   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
221   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
222   0xf9, 0xfa 
223 };
224
225 /* isn't this function nicer than the one in the libjpeg ? */
226 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
227                                 const UINT8 *bits_table, const UINT8 *val_table)
228 {
229     int i, j, k,nb, code, sym;
230
231     code = 0;
232     k = 0;
233     for(i=1;i<=16;i++) {
234         nb = bits_table[i];
235         for(j=0;j<nb;j++) {
236             sym = val_table[k++];
237             huff_size[sym] = i;
238             huff_code[sym] = code;
239             code++;
240         }
241         code <<= 1;
242     }
243 }
244
245 int mjpeg_init(MpegEncContext *s)
246 {
247     MJpegContext *m;
248     
249     m = malloc(sizeof(MJpegContext));
250     if (!m)
251         return -1;
252     
253     s->min_qcoeff=-1023;
254     s->max_qcoeff= 1023;
255     s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
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     free(s->mjpeg_ctx);
282 }
283
284 static inline void put_marker(PutBitContext *p, int code)
285 {
286     put_bits(p, 8, 0xff);
287     put_bits(p, 8, code);
288 }
289
290 /* table_class: 0 = DC coef, 1 = AC coefs */
291 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
292                              const UINT8 *bits_table, const UINT8 *value_table)
293 {
294     PutBitContext *p = &s->pb;
295     int n, i;
296
297     put_bits(p, 4, table_class);
298     put_bits(p, 4, table_id);
299
300     n = 0;
301     for(i=1;i<=16;i++) {
302         n += bits_table[i];
303         put_bits(p, 8, bits_table[i]);
304     }
305
306     for(i=0;i<n;i++)
307         put_bits(p, 8, value_table[i]);
308
309     return n + 17;
310 }
311
312 static void jpeg_table_header(MpegEncContext *s)
313 {
314     PutBitContext *p = &s->pb;
315     int i, j, size;
316     UINT8 *ptr;
317
318     /* quant matrixes */
319     put_marker(p, DQT);
320 #ifdef TWOMATRIXES
321     put_bits(p, 16, 2 + 2 * (1 + 64));
322 #else
323     put_bits(p, 16, 2 + 1 * (1 + 64));
324 #endif
325     put_bits(p, 4, 0); /* 8 bit precision */
326     put_bits(p, 4, 0); /* table 0 */
327     for(i=0;i<64;i++) {
328         j = zigzag_direct[i];
329         put_bits(p, 8, s->intra_matrix[j]);
330     }
331 #ifdef TWOMATRIXES
332     put_bits(p, 4, 0); /* 8 bit precision */
333     put_bits(p, 4, 1); /* table 1 */
334     for(i=0;i<64;i++) {
335         j = zigzag_direct[i];
336         put_bits(p, 8, s->chroma_intra_matrix[j]);
337     }
338 #endif
339
340     /* huffman table */
341     put_marker(p, DHT);
342     flush_put_bits(p);
343     ptr = pbBufPtr(p);
344     put_bits(p, 16, 0); /* patched later */
345     size = 2;
346     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
347     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
348     
349     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
350     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
351     ptr[0] = size >> 8;
352     ptr[1] = size;
353 }
354
355 static void jpeg_put_comments(MpegEncContext *s)
356 {
357     PutBitContext *p = &s->pb;
358     int size;
359     UINT8 *ptr;
360
361 #if 0
362     /* JFIF header */
363     put_marker(p, APP0);
364     put_bits(p, 16, 16);
365     put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
366     put_bits(p, 16, 0x101);
367     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
368     put_bits(p, 16, 1); /* aspect: 1:1 */
369     put_bits(p, 16, 1);
370     put_bits(p, 8, 0); /* thumbnail width */
371     put_bits(p, 8, 0); /* thumbnail height */
372 #endif
373
374     /* comment */
375     put_marker(p, COM);
376     flush_put_bits(p);
377     ptr = pbBufPtr(p);
378     put_bits(p, 16, 0); /* patched later */
379 #define VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
380     put_string(p, VERSION);
381     size = strlen(VERSION)+3;
382 #undef VERSION
383     ptr[0] = size >> 8;
384     ptr[1] = size;
385 }
386
387 void mjpeg_picture_header(MpegEncContext *s)
388 {
389     put_marker(&s->pb, SOI);
390
391     jpeg_put_comments(s);    
392
393     if (s->mjpeg_write_tables) jpeg_table_header(s);
394
395     put_marker(&s->pb, SOF0);
396
397     put_bits(&s->pb, 16, 17);
398     put_bits(&s->pb, 8, 8); /* 8 bits/component */
399     put_bits(&s->pb, 16, s->height);
400     put_bits(&s->pb, 16, s->width);
401     put_bits(&s->pb, 8, 3); /* 3 components */
402     
403     /* Y component */
404     put_bits(&s->pb, 8, 1); /* component number */
405     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
406     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
407     put_bits(&s->pb, 8, 0); /* select matrix */
408     
409     /* Cb component */
410     put_bits(&s->pb, 8, 2); /* component number */
411     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
412     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
413 #ifdef TWOMATRIXES
414     put_bits(&s->pb, 8, 1); /* select matrix */
415 #else
416     put_bits(&s->pb, 8, 0); /* select matrix */
417 #endif
418
419     /* Cr component */
420     put_bits(&s->pb, 8, 3); /* component number */
421     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
422     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
423 #ifdef TWOMATRIXES
424     put_bits(&s->pb, 8, 1); /* select matrix */
425 #else
426     put_bits(&s->pb, 8, 0); /* select matrix */
427 #endif
428
429     /* scan header */
430     put_marker(&s->pb, SOS);
431     put_bits(&s->pb, 16, 12); /* length */
432     put_bits(&s->pb, 8, 3); /* 3 components */
433     
434     /* Y component */
435     put_bits(&s->pb, 8, 1); /* index */
436     put_bits(&s->pb, 4, 0); /* DC huffman table index */
437     put_bits(&s->pb, 4, 0); /* AC huffman table index */
438     
439     /* Cb component */
440     put_bits(&s->pb, 8, 2); /* index */
441     put_bits(&s->pb, 4, 1); /* DC huffman table index */
442     put_bits(&s->pb, 4, 1); /* AC huffman table index */
443     
444     /* Cr component */
445     put_bits(&s->pb, 8, 3); /* index */
446     put_bits(&s->pb, 4, 1); /* DC huffman table index */
447     put_bits(&s->pb, 4, 1); /* AC huffman table index */
448
449     put_bits(&s->pb, 8, 0); /* Ss (not used) */
450     put_bits(&s->pb, 8, 63); /* Se (not used) */
451     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
452 }
453
454 void mjpeg_picture_trailer(MpegEncContext *s)
455 {
456     jflush_put_bits(&s->pb);
457     put_marker(&s->pb, EOI);
458 }
459
460 static inline void encode_dc(MpegEncContext *s, int val, 
461                              UINT8 *huff_size, UINT16 *huff_code)
462 {
463     int mant, nbits;
464
465     if (val == 0) {
466         jput_bits(&s->pb, huff_size[0], huff_code[0]);
467     } else {
468         mant = val;
469         if (val < 0) {
470             val = -val;
471             mant--;
472         }
473         
474         /* compute the log (XXX: optimize) */
475         nbits = 0;
476         while (val != 0) {
477             val = val >> 1;
478             nbits++;
479         }
480             
481         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
482         
483         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
484     }
485 }
486
487 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
488 {
489     int mant, nbits, code, i, j;
490     int component, dc, run, last_index, val;
491     MJpegContext *m = s->mjpeg_ctx;
492     UINT8 *huff_size_ac;
493     UINT16 *huff_code_ac;
494     
495     /* DC coef */
496     component = (n <= 3 ? 0 : n - 4 + 1);
497     dc = block[0]; /* overflow is impossible */
498     val = dc - s->last_dc[component];
499     if (n < 4) {
500         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
501         huff_size_ac = m->huff_size_ac_luminance;
502         huff_code_ac = m->huff_code_ac_luminance;
503     } else {
504         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
505         huff_size_ac = m->huff_size_ac_chrominance;
506         huff_code_ac = m->huff_code_ac_chrominance;
507     }
508     s->last_dc[component] = dc;
509     
510     /* AC coefs */
511     
512     run = 0;
513     last_index = s->block_last_index[n];
514     for(i=1;i<=last_index;i++) {
515         j = zigzag_direct[i];
516         val = block[j];
517         if (val == 0) {
518             run++;
519         } else {
520             while (run >= 16) {
521                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
522                 run -= 16;
523             }
524             mant = val;
525             if (val < 0) {
526                 val = -val;
527                 mant--;
528             }
529             
530             /* compute the log (XXX: optimize) */
531             nbits = 0;
532             while (val != 0) {
533                 val = val >> 1;
534                 nbits++;
535             }
536             code = (run << 4) | nbits;
537
538             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
539         
540             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
541             run = 0;
542         }
543     }
544
545     /* output EOB only if not already 64 values */
546     if (last_index < 63 || run != 0)
547         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
548 }
549
550 void mjpeg_encode_mb(MpegEncContext *s, 
551                      DCTELEM block[6][64])
552 {
553     int i;
554     for(i=0;i<6;i++) {
555         encode_block(s, block[i], i);
556     }
557 }
558
559 /******************************************/
560 /* decoding */
561
562 /* compressed picture size */
563 #define PICTURE_BUFFER_SIZE 100000
564
565 #define MAX_COMPONENTS 4
566
567 typedef struct MJpegDecodeContext {
568     AVCodecContext *avctx;
569     GetBitContext gb;
570     UINT32 header_state;
571     int start_code; /* current start code */
572     UINT8 *buf_ptr;
573     int buffer_size;
574     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
575     INT16 quant_matrixes[4][64];
576     VLC vlcs[2][4];
577
578     int org_width, org_height;  /* size given at codec init */
579     int first_picture;    /* true if decoding first picture */
580     int interlaced;     /* true if interlaced */
581     int bottom_field;   /* true if bottom field */
582
583     int width, height;
584     int nb_components;
585     int component_id[MAX_COMPONENTS];
586     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
587     int v_count[MAX_COMPONENTS];
588     int h_max, v_max; /* maximum h and v counts */
589     int quant_index[4];   /* quant table index for each component */
590     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
591     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
592     int linesize[MAX_COMPONENTS];
593     DCTELEM block[64] __align8;
594     UINT8 buffer[PICTURE_BUFFER_SIZE]; 
595
596     int buggy_avid;
597     int restart_interval;
598     int restart_count;
599     int interleaved_rows;
600 } MJpegDecodeContext;
601
602 #define SKIP_REMAINING(gb, len) { \
603     dprintf("reamining %d bytes in marker\n", len); \
604     if (len) while (--len) \
605         skip_bits(gb, 8); \
606 }
607
608 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 
609                       int nb_codes)
610 {
611     UINT8 huff_size[256];
612     UINT16 huff_code[256];
613
614     memset(huff_size, 0, sizeof(huff_size));
615     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
616     
617     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
618 }
619
620 static int mjpeg_decode_init(AVCodecContext *avctx)
621 {
622     MJpegDecodeContext *s = avctx->priv_data;
623
624     s->avctx = avctx;
625
626     s->header_state = 0;
627     s->mpeg_enc_ctx_allocated = 0;
628     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
629                                                  account FF 00 case */
630     s->start_code = -1;
631     s->buf_ptr = s->buffer;
632     s->first_picture = 1;
633     s->org_width = avctx->width;
634     s->org_height = avctx->height;
635
636     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
637     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
638     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
639     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
640     
641     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
642     {
643         printf("mjpeg: using external huffman table\n");
644         mjpeg_decode_dht(s, avctx->extradata, avctx->extradata_size);
645         /* should check for error - but dunno */
646     }
647     return 0;
648 }
649
650 /* quantize tables */
651 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
652                             UINT8 *buf, int buf_size)
653 {
654     int len, index, i, j;
655     init_get_bits(&s->gb, buf, buf_size);
656     
657     len = get_bits(&s->gb, 16) - 2;
658
659     while (len >= 65) {
660         /* only 8 bit precision handled */
661         if (get_bits(&s->gb, 4) != 0)
662         {
663             dprintf("dqt: 16bit precision\n");
664             return -1;
665         }
666         index = get_bits(&s->gb, 4);
667         if (index >= 4)
668             return -1;
669         dprintf("index=%d\n", index);
670         /* read quant table */
671         for(i=0;i<64;i++) {
672             j = zigzag_direct[i];
673             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
674         }
675         len -= 65;
676     }
677     
678     SKIP_REMAINING(&s->gb, len);
679
680     return 0;
681 }
682
683 /* decode huffman tables and build VLC decoders */
684 static int mjpeg_decode_dht(MJpegDecodeContext *s,
685                             UINT8 *buf, int buf_size)
686 {
687     int len, index, i, class, n, v, code_max;
688     UINT8 bits_table[17];
689     UINT8 val_table[256];
690     
691     init_get_bits(&s->gb, buf, buf_size);
692
693     len = get_bits(&s->gb, 16);
694     len -= 2;
695
696     while (len > 0) {
697         if (len < 17)
698             return -1;
699         class = get_bits(&s->gb, 4);
700         if (class >= 2)
701             return -1;
702         index = get_bits(&s->gb, 4);
703         if (index >= 4)
704             return -1;
705         n = 0;
706         for(i=1;i<=16;i++) {
707             bits_table[i] = get_bits(&s->gb, 8);
708             n += bits_table[i];
709         }
710         len -= 17;
711         if (len < n || n > 256)
712             return -1;
713
714         code_max = 0;
715         for(i=0;i<n;i++) {
716             v = get_bits(&s->gb, 8);
717             if (v > code_max)
718                 code_max = v;
719             val_table[i] = v;
720         }
721         len -= n;
722
723         /* build VLC and flush previous vlc if present */
724         free_vlc(&s->vlcs[class][index]);
725         dprintf("class=%d index=%d nb_codes=%d\n",
726                class, index, code_max + 1);
727         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
728     }
729     return 0;
730 }
731
732 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
733                              UINT8 *buf, int buf_size)
734 {
735     int len, nb_components, i, width, height;
736
737     init_get_bits(&s->gb, buf, buf_size);
738
739     /* XXX: verify len field validity */
740     len = get_bits(&s->gb, 16);
741     /* only 8 bits/component accepted */
742     if (get_bits(&s->gb, 8) != 8)
743         return -1;
744     height = get_bits(&s->gb, 16);
745     width = get_bits(&s->gb, 16);
746     dprintf("sof0: picture: %dx%d\n", width, height);
747
748     nb_components = get_bits(&s->gb, 8);
749     if (nb_components <= 0 ||
750         nb_components > MAX_COMPONENTS)
751         return -1;
752     s->nb_components = nb_components;
753     s->h_max = 1;
754     s->v_max = 1;
755     for(i=0;i<nb_components;i++) {
756         /* component id */
757         s->component_id[i] = get_bits(&s->gb, 8) - 1;
758         s->h_count[i] = get_bits(&s->gb, 4);
759         s->v_count[i] = get_bits(&s->gb, 4);
760         /* compute hmax and vmax (only used in interleaved case) */
761         if (s->h_count[i] > s->h_max)
762             s->h_max = s->h_count[i];
763         if (s->v_count[i] > s->v_max)
764             s->v_max = s->v_count[i];
765         s->quant_index[i] = get_bits(&s->gb, 8);
766         if (s->quant_index[i] >= 4)
767             return -1;
768         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
769             s->v_count[i], s->component_id[i], s->quant_index[i]);
770     }
771
772     /* if different size, realloc/alloc picture */
773     /* XXX: also check h_count and v_count */
774     if (width != s->width || height != s->height) {
775         for(i=0;i<MAX_COMPONENTS;i++) {
776             free(s->current_picture[i]);
777             s->current_picture[i] = NULL;
778         }
779         s->width = width;
780         s->height = height;
781         /* test interlaced mode */
782         if (s->first_picture &&
783             s->org_height != 0 &&
784             s->height < ((s->org_height * 3) / 4)) {
785             s->interlaced = 1;
786             s->bottom_field = 0;
787         }
788
789         for(i=0;i<nb_components;i++) {
790             int w, h;
791             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
792             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
793             w = w * 8 * s->h_count[i];
794             h = h * 8 * s->v_count[i];
795             if (s->interlaced)
796                 w *= 2;
797             s->linesize[i] = w;
798             /* memory test is done in mjpeg_decode_sos() */
799             s->current_picture[i] = av_mallocz(w * h);
800         }
801         s->first_picture = 0;
802     }
803
804     if (len != (8+(3*nb_components)))
805     {
806         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
807     }
808     
809     return 0;
810 }
811
812 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
813 {
814     int code, diff;
815
816     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
817     if (code < 0)
818     {
819         dprintf("decode_dc: bad vlc: %d:%d (%x)\n", 0, dc_index,
820             &s->vlcs[0][dc_index]);
821         return 0xffff;
822     }
823     if (code == 0) {
824         diff = 0;
825     } else {
826         diff = get_bits(&s->gb, code);
827         if ((diff & (1 << (code - 1))) == 0) 
828             diff = (-1 << code) | (diff + 1);
829     }
830     return diff;
831 }
832
833 /* decode block and dequantize */
834 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
835                         int component, int dc_index, int ac_index, int quant_index)
836 {
837     int nbits, code, i, j, level;
838     int run, val;
839     VLC *ac_vlc;
840     INT16 *quant_matrix;
841
842     /* DC coef */
843     val = decode_dc(s, dc_index);
844     if (val == 0xffff) {
845         dprintf("error dc\n");
846         return -1;
847     }
848     quant_matrix = s->quant_matrixes[quant_index];
849     val = val * quant_matrix[0] + s->last_dc[component];
850     s->last_dc[component] = val;
851     block[0] = val;
852     /* AC coefs */
853     ac_vlc = &s->vlcs[1][ac_index];
854     i = 1;
855     for(;;) {
856         code = get_vlc(&s->gb, ac_vlc);
857         if (code < 0) {
858             dprintf("error ac\n");
859             return -1;
860         }
861         /* EOB */
862         if (code == 0)
863             break;
864         if (code == 0xf0) {
865             i += 16;
866         } else {
867             run = code >> 4;
868             nbits = code & 0xf;
869             level = get_bits(&s->gb, nbits);
870             if ((level & (1 << (nbits - 1))) == 0) 
871                 level = (-1 << nbits) | (level + 1);
872             i += run;
873             if (i >= 64) {
874                 dprintf("error count: %d\n", i);
875                 return -1;
876             }
877             j = zigzag_direct[i];
878             block[j] = level * quant_matrix[j];
879             i++;
880             if (i >= 64)
881                 break;
882         }
883     }
884     return 0;
885 }
886
887 static int mjpeg_decode_sos(MJpegDecodeContext *s,
888                             UINT8 *buf, int buf_size)
889 {
890     int len, nb_components, i, j, n, h, v, ret;
891     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
892     int comp_index[4];
893     int dc_index[4];
894     int ac_index[4];
895     int nb_blocks[4];
896     int h_count[4];
897     int v_count[4];
898     
899     init_get_bits(&s->gb, buf, buf_size);
900     /* XXX: verify len field validity */
901     len = get_bits(&s->gb, 16);
902     nb_components = get_bits(&s->gb, 8);
903     /* XXX: only interleaved scan accepted */
904     if (nb_components != 3)
905     {
906         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
907         return -1;
908     }
909     vmax = 0;
910     hmax = 0;
911     for(i=0;i<nb_components;i++) {
912         id = get_bits(&s->gb, 8) - 1;
913         dprintf("component: %d\n", id);
914         /* find component index */
915         for(index=0;index<s->nb_components;index++)
916             if (id == s->component_id[index])
917                 break;
918         if (index == s->nb_components)
919         {
920             dprintf("decode_sos: index(%d) out of components\n", index);
921             return -1;
922         }
923
924         comp_index[i] = index;
925         nb_blocks[i] = s->h_count[index] * s->v_count[index];
926         h_count[i] = s->h_count[index];
927         v_count[i] = s->v_count[index];
928
929         dc_index[i] = get_bits(&s->gb, 4);
930         ac_index[i] = get_bits(&s->gb, 4);
931
932         if (dc_index[i] < 0 || ac_index[i] < 0 ||
933             dc_index[i] >= 4 || ac_index[i] >= 4)
934             goto out_of_range;
935         switch(s->start_code)
936         {
937             case SOF0:
938                 if (dc_index[i] > 1 || ac_index[i] > 1)
939                     goto out_of_range;
940                 break;
941             case SOF1:
942             case SOF2:
943                 if (dc_index[i] > 3 || ac_index[i] > 3)
944                     goto out_of_range;
945                 break;
946             case SOF3:
947                 if (dc_index[i] > 3 || ac_index[i] != 0)
948                     goto out_of_range;
949                 break;  
950         }
951     }
952     skip_bits(&s->gb, 8); /* Ss */
953     skip_bits(&s->gb, 8); /* Se */
954     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
955
956     for(i=0;i<nb_components;i++) 
957         s->last_dc[i] = 1024;
958
959     if (nb_components > 1) {
960         /* interleaved stream */
961         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
962         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
963     } else {
964         h = s->h_max / s->h_count[comp_index[0]];
965         v = s->v_max / s->v_count[comp_index[0]];
966         mb_width = (s->width + h * 8 - 1) / (h * 8);
967         mb_height = (s->height + v * 8 - 1) / (v * 8);
968         nb_blocks[0] = 1;
969         h_count[0] = 1;
970         v_count[0] = 1;
971     }
972
973     for(mb_y = 0; mb_y < mb_height; mb_y++) {
974         for(mb_x = 0; mb_x < mb_width; mb_x++) {
975             for(i=0;i<nb_components;i++) {
976                 UINT8 *ptr;
977                 int x, y, c;
978                 n = nb_blocks[i];
979                 c = comp_index[i];
980                 h = h_count[i];
981                 v = v_count[i];
982                 x = 0;
983                 y = 0;
984                 if (s->restart_interval && !s->restart_count)
985                     s->restart_count = s->restart_interval;
986                 for(j=0;j<n;j++) {
987                     memset(s->block, 0, sizeof(s->block));
988                     if (decode_block(s, s->block, i, 
989                                      dc_index[i], ac_index[i], 
990                                      s->quant_index[c]) < 0) {
991                         dprintf("error %d %d\n", mb_y, mb_x);
992                         ret = -1;
993                         goto the_end;
994                     }
995 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
996                     ff_idct (s->block);
997                     ptr = s->current_picture[c] + 
998                         (s->linesize[c] * (v * mb_y + y) * 8) + 
999                         (h * mb_x + x) * 8;
1000                     if (s->interlaced && s->bottom_field)
1001                         ptr += s->linesize[c] >> 1;
1002                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
1003                     if (++x == h) {
1004                         x = 0;
1005                         y++;
1006                     }
1007                 }
1008             }
1009         }
1010     }
1011     ret = 0;
1012  the_end:
1013     emms_c();
1014     return ret;
1015  out_of_range:
1016     dprintf("decode_sos: ac/dc index out of range\n");
1017     return -1;
1018 }
1019
1020 static int mjpeg_decode_dri(MJpegDecodeContext *s,
1021                              UINT8 *buf, int buf_size)
1022 {
1023     init_get_bits(&s->gb, buf, buf_size);
1024
1025     if (get_bits(&s->gb, 16) != 4)
1026         return -1;
1027     s->restart_interval = get_bits(&s->gb, 16);
1028     printf("restart interval: %d\n", s->restart_interval);
1029
1030     return 0;
1031 }
1032
1033 #define FOURCC(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d)
1034 static int mjpeg_decode_app(MJpegDecodeContext *s,
1035                              UINT8 *buf, int buf_size, int start_code)
1036 {
1037     int len, id;
1038
1039     init_get_bits(&s->gb, buf, buf_size);
1040
1041     /* XXX: verify len field validity */
1042     len = get_bits(&s->gb, 16);
1043     if (len < 5)
1044         return -1;
1045
1046     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1047     len -= 6;
1048
1049     /* buggy AVID, it puts EOI only at every 10th frame */
1050     /* also this fourcc is used by non-avid files too, it means
1051        interleaving, but it's always present in AVID files */
1052     if (id == FOURCC('A','V','I','1'))
1053     {
1054         /* structure:
1055             4bytes      AVI1
1056             1bytes      polarity
1057             1bytes      always zero
1058             4bytes      field_size
1059             4bytes      field_size_less_padding
1060         */
1061         s->buggy_avid = 1;
1062         if (s->first_picture)
1063             printf("mjpeg: workarounding buggy AVID\n");
1064         s->interleaved_rows = get_bits(&s->gb, 8);
1065 #if 0
1066         skip_bits(&s->gb, 8);
1067         skip_bits(&s->gb, 32);
1068         skip_bits(&s->gb, 32);
1069         len -= 10;
1070 #endif
1071         if (s->interleaved_rows)
1072             printf("mjpeg: interleaved rows: %d\n", s->interleaved_rows);
1073         goto out;
1074     }
1075     
1076     len -= 2;
1077     
1078     if (id == FOURCC('J','F','I','F'))
1079     {
1080         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1081         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1082             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1083         goto out;
1084     }
1085     
1086     /* Apple MJPEG-A */
1087     if ((start_code == APP1) && (len > (0x28 - 8)))
1088     {
1089         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1090         len -= 4;
1091         if (id == FOURCC('m','j','p','g')) /* Apple MJPEG-A */
1092         {
1093 #if 0
1094             skip_bits(&s->gb, 32); /* field size */
1095             skip_bits(&s->gb, 32); /* pad field size */
1096             skip_bits(&s->gb, 32); /* next off */
1097             skip_bits(&s->gb, 32); /* quant off */
1098             skip_bits(&s->gb, 32); /* huff off */
1099             skip_bits(&s->gb, 32); /* image off */
1100             skip_bits(&s->gb, 32); /* scan off */
1101             skip_bits(&s->gb, 32); /* data off */
1102 #endif
1103             if (s->first_picture)
1104                 printf("mjpeg: Apple MJPEG-A header found\n");
1105         }
1106     }
1107
1108 out:
1109     /* should check for further values.. */
1110     SKIP_REMAINING(&s->gb, len);
1111
1112     return 0;
1113 }
1114 #undef FOURCC
1115
1116 static int mjpeg_decode_com(MJpegDecodeContext *s,
1117                              UINT8 *buf, int buf_size)
1118 {
1119     int len, i;
1120     UINT8 *cbuf;
1121
1122     init_get_bits(&s->gb, buf, buf_size);
1123
1124     /* XXX: verify len field validity */
1125     len = get_bits(&s->gb, 16)-2;
1126     cbuf = malloc(len+1);
1127
1128     for (i = 0; i < len; i++)
1129         cbuf[i] = get_bits(&s->gb, 8);
1130     if (cbuf[i-1] == '\n')
1131         cbuf[i-1] = 0;
1132     else
1133         cbuf[i] = 0;
1134
1135     printf("mjpeg comment: '%s'\n", cbuf);
1136
1137     /* buggy avid, it puts EOI only at every 10th frame */
1138     if (!strcmp(cbuf, "AVID"))
1139     {
1140         s->buggy_avid = 1;
1141         if (s->first_picture)
1142             printf("mjpeg: workarounding buggy AVID\n");
1143     }
1144     
1145     free(cbuf);
1146
1147     return 0;
1148 }
1149
1150 /* return the 8 bit start code value and update the search
1151    state. Return -1 if no start code found */
1152 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end, 
1153                        UINT32 *header_state)
1154 {
1155     UINT8 *buf_ptr;
1156     unsigned int state, v;
1157     int val;
1158
1159     state = *header_state;
1160     buf_ptr = *pbuf_ptr;
1161     if (state) {
1162         /* get marker */
1163     found:
1164         if (buf_ptr < buf_end) {
1165             val = *buf_ptr++;
1166             state = 0;
1167         } else {
1168             val = -1;
1169         }
1170     } else {
1171         while (buf_ptr < buf_end) {
1172             v = *buf_ptr++;
1173             if (v == 0xff) {
1174                 state = 1;
1175                 goto found;
1176             }
1177         }
1178         val = -1;
1179     }
1180     *pbuf_ptr = buf_ptr;
1181     *header_state = state;
1182     return val;
1183 }
1184
1185 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1186                               void *data, int *data_size,
1187                               UINT8 *buf, int buf_size)
1188 {
1189     MJpegDecodeContext *s = avctx->priv_data;
1190     UINT8 *buf_end, *buf_ptr, *buf_start;
1191     int len, code, input_size, i;
1192     AVPicture *picture = data;
1193     unsigned int start_code;
1194
1195     *data_size = 0;
1196
1197     /* no supplementary picture */
1198     if (buf_size == 0)
1199         return 0;
1200
1201     buf_ptr = buf;
1202     buf_end = buf + buf_size;
1203     while (buf_ptr < buf_end) {
1204         buf_start = buf_ptr;
1205         /* find start next marker */
1206         code = find_marker(&buf_ptr, buf_end, &s->header_state);
1207         /* copy to buffer */
1208         len = buf_ptr - buf_start;
1209         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1210             /* data too big : flush */
1211             s->buf_ptr = s->buffer;
1212             if (code > 0)
1213                 s->start_code = code;
1214         } else {
1215             memcpy(s->buf_ptr, buf_start, len);
1216             s->buf_ptr += len;
1217             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
1218             /* valid marker code is between 00 and ff - alex */
1219             if (code <= 0 || code >= 0xff) {
1220                 s->buf_ptr--;
1221             } else {
1222                 /* prepare data for next start code */
1223                 input_size = s->buf_ptr - s->buffer;
1224                 start_code = s->start_code;
1225                 s->buf_ptr = s->buffer;
1226                 s->start_code = code;
1227                 dprintf("marker=%x\n", start_code);
1228                 switch(start_code) {
1229                 case SOI:
1230                     s->restart_interval = 0;
1231                     /* nothing to do on SOI */
1232                     break;
1233                 case DQT:
1234                     mjpeg_decode_dqt(s, s->buffer, input_size);
1235                     break;
1236                 case DHT:
1237                     mjpeg_decode_dht(s, s->buffer, input_size);
1238                     break;
1239                 case SOF0:
1240                     mjpeg_decode_sof0(s, s->buffer, input_size);
1241                     break;
1242                 case SOS:
1243                     mjpeg_decode_sos(s, s->buffer, input_size);
1244                     if (s->start_code == EOI || s->buggy_avid || s->restart_interval) {
1245                         int l;
1246                         if (s->interlaced) {
1247                             s->bottom_field ^= 1;
1248                             /* if not bottom field, do not output image yet */
1249                             if (s->bottom_field)
1250                                 goto the_end;
1251                         }
1252                         for(i=0;i<3;i++) {
1253                             picture->data[i] = s->current_picture[i];
1254                             l = s->linesize[i];
1255                             if (s->interlaced)
1256                                 l >>= 1;
1257                             picture->linesize[i] = l;
1258                         }
1259                         *data_size = sizeof(AVPicture);
1260                         avctx->height = s->height;
1261                         if (s->interlaced)
1262                             avctx->height *= 2;
1263                         avctx->width = s->width;
1264                         /* XXX: not complete test ! */
1265                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1266                         case 0x11:
1267                             avctx->pix_fmt = PIX_FMT_YUV444P;
1268                             break;
1269                         case 0x21:
1270                             avctx->pix_fmt = PIX_FMT_YUV422P;
1271                             break;
1272                         default:
1273                         case 0x22:
1274                             avctx->pix_fmt = PIX_FMT_YUV420P;
1275                             break;
1276                         }
1277                         /* dummy quality */
1278                         /* XXX: infer it with matrix */
1279                         avctx->quality = 3; 
1280                         goto the_end;
1281                     }
1282                     break;
1283                 case DRI:
1284                     mjpeg_decode_dri(s, s->buffer, input_size);
1285                     break;
1286                 case SOF1:
1287                 case SOF2:
1288                 case SOF3:
1289                 case SOF5:
1290                 case SOF6:
1291                 case SOF7:
1292                 case SOF9:
1293                 case SOF10:
1294                 case SOF11:
1295                 case SOF13:
1296                 case SOF14:
1297                 case SOF15:
1298                 case JPG:
1299                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1300                     return -1;
1301                 }
1302 #if 1
1303                 if (start_code >= 0xd0 && start_code <= 0xd7)
1304                 {
1305                     dprintf("restart marker: %d\n", start_code&0x0f);
1306                 }
1307                 else if (s->first_picture)
1308                 {
1309                     /* APP fields */
1310                     if (start_code >= 0xe0 && start_code <= 0xef)
1311                         mjpeg_decode_app(s, s->buffer, input_size, start_code);
1312                     /* Comment */
1313                     else if (start_code == COM)
1314                         mjpeg_decode_com(s, s->buffer, input_size);
1315                 }
1316 #endif
1317             }
1318         }
1319     }
1320  the_end:
1321     return buf_ptr - buf;
1322 }
1323
1324 static int mjpeg_decode_end(AVCodecContext *avctx)
1325 {
1326     MJpegDecodeContext *s = avctx->priv_data;
1327     int i, j;
1328
1329     for(i=0;i<MAX_COMPONENTS;i++)
1330         free(s->current_picture[i]);
1331     for(i=0;i<2;i++) {
1332         for(j=0;j<4;j++)
1333             free_vlc(&s->vlcs[i][j]);
1334     }
1335     return 0;
1336 }
1337
1338 AVCodec mjpeg_decoder = {
1339     "mjpeg",
1340     CODEC_TYPE_VIDEO,
1341     CODEC_ID_MJPEG,
1342     sizeof(MJpegDecodeContext),
1343     mjpeg_decode_init,
1344     NULL,
1345     mjpeg_decode_end,
1346     mjpeg_decode_frame,
1347     0,
1348     NULL
1349 };