- Warning fix.
[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     if (!s->mjpeg_data_only_frames)
392     {
393     jpeg_put_comments(s);    
394
395     if (s->mjpeg_write_tables) jpeg_table_header(s);
396
397     put_marker(&s->pb, SOF0);
398
399     put_bits(&s->pb, 16, 17);
400     put_bits(&s->pb, 8, 8); /* 8 bits/component */
401     put_bits(&s->pb, 16, s->height);
402     put_bits(&s->pb, 16, s->width);
403     put_bits(&s->pb, 8, 3); /* 3 components */
404     
405     /* Y component */
406     put_bits(&s->pb, 8, 1); /* component number */
407     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
408     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
409     put_bits(&s->pb, 8, 0); /* select matrix */
410     
411     /* Cb component */
412     put_bits(&s->pb, 8, 2); /* component number */
413     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
414     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
415 #ifdef TWOMATRIXES
416     put_bits(&s->pb, 8, 1); /* select matrix */
417 #else
418     put_bits(&s->pb, 8, 0); /* select matrix */
419 #endif
420
421     /* Cr component */
422     put_bits(&s->pb, 8, 3); /* component number */
423     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
424     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
425 #ifdef TWOMATRIXES
426     put_bits(&s->pb, 8, 1); /* select matrix */
427 #else
428     put_bits(&s->pb, 8, 0); /* select matrix */
429 #endif
430     }
431
432     /* scan header */
433     put_marker(&s->pb, SOS);
434     put_bits(&s->pb, 16, 12); /* length */
435     put_bits(&s->pb, 8, 3); /* 3 components */
436     
437     /* Y component */
438     put_bits(&s->pb, 8, 1); /* index */
439     put_bits(&s->pb, 4, 0); /* DC huffman table index */
440     put_bits(&s->pb, 4, 0); /* AC huffman table index */
441     
442     /* Cb component */
443     put_bits(&s->pb, 8, 2); /* index */
444     put_bits(&s->pb, 4, 1); /* DC huffman table index */
445     put_bits(&s->pb, 4, 1); /* AC huffman table index */
446     
447     /* Cr component */
448     put_bits(&s->pb, 8, 3); /* index */
449     put_bits(&s->pb, 4, 1); /* DC huffman table index */
450     put_bits(&s->pb, 4, 1); /* AC huffman table index */
451
452     put_bits(&s->pb, 8, 0); /* Ss (not used) */
453     put_bits(&s->pb, 8, 63); /* Se (not used) */
454     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
455 }
456
457 void mjpeg_picture_trailer(MpegEncContext *s)
458 {
459     jflush_put_bits(&s->pb);
460     put_marker(&s->pb, EOI);
461 }
462
463 static inline void encode_dc(MpegEncContext *s, int val, 
464                              UINT8 *huff_size, UINT16 *huff_code)
465 {
466     int mant, nbits;
467
468     if (val == 0) {
469         jput_bits(&s->pb, huff_size[0], huff_code[0]);
470     } else {
471         mant = val;
472         if (val < 0) {
473             val = -val;
474             mant--;
475         }
476         
477         /* compute the log (XXX: optimize) */
478         nbits = 0;
479         while (val != 0) {
480             val = val >> 1;
481             nbits++;
482         }
483             
484         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
485         
486         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
487     }
488 }
489
490 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
491 {
492     int mant, nbits, code, i, j;
493     int component, dc, run, last_index, val;
494     MJpegContext *m = s->mjpeg_ctx;
495     UINT8 *huff_size_ac;
496     UINT16 *huff_code_ac;
497     
498     /* DC coef */
499     component = (n <= 3 ? 0 : n - 4 + 1);
500     dc = block[0]; /* overflow is impossible */
501     val = dc - s->last_dc[component];
502     if (n < 4) {
503         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
504         huff_size_ac = m->huff_size_ac_luminance;
505         huff_code_ac = m->huff_code_ac_luminance;
506     } else {
507         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
508         huff_size_ac = m->huff_size_ac_chrominance;
509         huff_code_ac = m->huff_code_ac_chrominance;
510     }
511     s->last_dc[component] = dc;
512     
513     /* AC coefs */
514     
515     run = 0;
516     last_index = s->block_last_index[n];
517     for(i=1;i<=last_index;i++) {
518         j = zigzag_direct[i];
519         val = block[j];
520         if (val == 0) {
521             run++;
522         } else {
523             while (run >= 16) {
524                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
525                 run -= 16;
526             }
527             mant = val;
528             if (val < 0) {
529                 val = -val;
530                 mant--;
531             }
532             
533             /* compute the log (XXX: optimize) */
534             nbits = 0;
535             while (val != 0) {
536                 val = val >> 1;
537                 nbits++;
538             }
539             code = (run << 4) | nbits;
540
541             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
542         
543             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
544             run = 0;
545         }
546     }
547
548     /* output EOB only if not already 64 values */
549     if (last_index < 63 || run != 0)
550         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
551 }
552
553 void mjpeg_encode_mb(MpegEncContext *s, 
554                      DCTELEM block[6][64])
555 {
556     int i;
557     for(i=0;i<6;i++) {
558         encode_block(s, block[i], i);
559     }
560 }
561
562 /******************************************/
563 /* decoding */
564
565 /* compressed picture size */
566 #define PICTURE_BUFFER_SIZE 100000
567
568 #define MAX_COMPONENTS 4
569
570 typedef struct MJpegDecodeContext {
571     AVCodecContext *avctx;
572     GetBitContext gb;
573     UINT32 header_state;
574     int start_code; /* current start code */
575     UINT8 *buf_ptr;
576     int buffer_size;
577     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
578     INT16 quant_matrixes[4][64];
579     VLC vlcs[2][4];
580
581     int org_width, org_height;  /* size given at codec init */
582     int first_picture;    /* true if decoding first picture */
583     int interlaced;     /* true if interlaced */
584     int bottom_field;   /* true if bottom field */
585
586     int width, height;
587     int nb_components;
588     int component_id[MAX_COMPONENTS];
589     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
590     int v_count[MAX_COMPONENTS];
591     int h_max, v_max; /* maximum h and v counts */
592     int quant_index[4];   /* quant table index for each component */
593     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
594     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
595     int linesize[MAX_COMPONENTS];
596     DCTELEM block[64] __align8;
597     UINT8 buffer[PICTURE_BUFFER_SIZE]; 
598
599     int buggy_avid;
600     int restart_interval;
601     int restart_count;
602     int interleaved_rows;
603 } MJpegDecodeContext;
604
605 #define SKIP_REMAINING(gb, len) { \
606     dprintf("reamining %d bytes in marker\n", len); \
607     if (len) while (--len) \
608         skip_bits(gb, 8); \
609 }
610
611 static int mjpeg_decode_dht(MJpegDecodeContext *s, UINT8 *buf, int buf_size);
612
613 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 
614                       int nb_codes)
615 {
616     UINT8 huff_size[256];
617     UINT16 huff_code[256];
618
619     memset(huff_size, 0, sizeof(huff_size));
620     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
621     
622     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
623 }
624
625 static int mjpeg_decode_init(AVCodecContext *avctx)
626 {
627     MJpegDecodeContext *s = avctx->priv_data;
628
629     s->avctx = avctx;
630
631     s->header_state = 0;
632     s->mpeg_enc_ctx_allocated = 0;
633     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
634                                                  account FF 00 case */
635     s->start_code = -1;
636     s->buf_ptr = s->buffer;
637     s->first_picture = 1;
638     s->org_width = avctx->width;
639     s->org_height = avctx->height;
640
641     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
642     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
643     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
644     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
645     
646     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
647     {
648         printf("mjpeg: using external huffman table\n");
649         mjpeg_decode_dht(s, avctx->extradata, avctx->extradata_size);
650         /* should check for error - but dunno */
651     }
652     return 0;
653 }
654
655 /* quantize tables */
656 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
657                             UINT8 *buf, int buf_size)
658 {
659     int len, index, i, j;
660     init_get_bits(&s->gb, buf, buf_size);
661     
662     len = get_bits(&s->gb, 16) - 2;
663
664     while (len >= 65) {
665         /* only 8 bit precision handled */
666         if (get_bits(&s->gb, 4) != 0)
667         {
668             dprintf("dqt: 16bit precision\n");
669             return -1;
670         }
671         index = get_bits(&s->gb, 4);
672         if (index >= 4)
673             return -1;
674         dprintf("index=%d\n", index);
675         /* read quant table */
676         for(i=0;i<64;i++) {
677             j = zigzag_direct[i];
678             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
679         }
680         len -= 65;
681     }
682     
683     SKIP_REMAINING(&s->gb, len);
684
685     return 0;
686 }
687
688 /* decode huffman tables and build VLC decoders */
689 static int mjpeg_decode_dht(MJpegDecodeContext *s,
690                             UINT8 *buf, int buf_size)
691 {
692     int len, index, i, class, n, v, code_max;
693     UINT8 bits_table[17];
694     UINT8 val_table[256];
695     
696     init_get_bits(&s->gb, buf, buf_size);
697
698     len = get_bits(&s->gb, 16);
699     len -= 2;
700
701     while (len > 0) {
702         if (len < 17)
703             return -1;
704         class = get_bits(&s->gb, 4);
705         if (class >= 2)
706             return -1;
707         index = get_bits(&s->gb, 4);
708         if (index >= 4)
709             return -1;
710         n = 0;
711         for(i=1;i<=16;i++) {
712             bits_table[i] = get_bits(&s->gb, 8);
713             n += bits_table[i];
714         }
715         len -= 17;
716         if (len < n || n > 256)
717             return -1;
718
719         code_max = 0;
720         for(i=0;i<n;i++) {
721             v = get_bits(&s->gb, 8);
722             if (v > code_max)
723                 code_max = v;
724             val_table[i] = v;
725         }
726         len -= n;
727
728         /* build VLC and flush previous vlc if present */
729         free_vlc(&s->vlcs[class][index]);
730         dprintf("class=%d index=%d nb_codes=%d\n",
731                class, index, code_max + 1);
732         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
733     }
734     return 0;
735 }
736
737 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
738                              UINT8 *buf, int buf_size)
739 {
740     int len, nb_components, i, width, height;
741
742     init_get_bits(&s->gb, buf, buf_size);
743
744     /* XXX: verify len field validity */
745     len = get_bits(&s->gb, 16);
746     /* only 8 bits/component accepted */
747     if (get_bits(&s->gb, 8) != 8)
748         return -1;
749     height = get_bits(&s->gb, 16);
750     width = get_bits(&s->gb, 16);
751     dprintf("sof0: picture: %dx%d\n", width, height);
752
753     nb_components = get_bits(&s->gb, 8);
754     if (nb_components <= 0 ||
755         nb_components > MAX_COMPONENTS)
756         return -1;
757     s->nb_components = nb_components;
758     s->h_max = 1;
759     s->v_max = 1;
760     for(i=0;i<nb_components;i++) {
761         /* component id */
762         s->component_id[i] = get_bits(&s->gb, 8) - 1;
763         s->h_count[i] = get_bits(&s->gb, 4);
764         s->v_count[i] = get_bits(&s->gb, 4);
765         /* compute hmax and vmax (only used in interleaved case) */
766         if (s->h_count[i] > s->h_max)
767             s->h_max = s->h_count[i];
768         if (s->v_count[i] > s->v_max)
769             s->v_max = s->v_count[i];
770         s->quant_index[i] = get_bits(&s->gb, 8);
771         if (s->quant_index[i] >= 4)
772             return -1;
773         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
774             s->v_count[i], s->component_id[i], s->quant_index[i]);
775     }
776
777     /* if different size, realloc/alloc picture */
778     /* XXX: also check h_count and v_count */
779     if (width != s->width || height != s->height) {
780         for(i=0;i<MAX_COMPONENTS;i++) {
781             free(s->current_picture[i]);
782             s->current_picture[i] = NULL;
783         }
784         s->width = width;
785         s->height = height;
786         /* test interlaced mode */
787         if (s->first_picture &&
788             s->org_height != 0 &&
789             s->height < ((s->org_height * 3) / 4)) {
790             s->interlaced = 1;
791             s->bottom_field = 0;
792         }
793
794         for(i=0;i<nb_components;i++) {
795             int w, h;
796             w = (s->width  + 8 * s->h_max - 1) / (8 * s->h_max);
797             h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
798             w = w * 8 * s->h_count[i];
799             h = h * 8 * s->v_count[i];
800             if (s->interlaced)
801                 w *= 2;
802             s->linesize[i] = w;
803             /* memory test is done in mjpeg_decode_sos() */
804             s->current_picture[i] = av_mallocz(w * h);
805         }
806         s->first_picture = 0;
807     }
808
809     if (len != (8+(3*nb_components)))
810     {
811         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
812     }
813     
814     return 0;
815 }
816
817 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
818 {
819     int code, diff;
820
821     code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
822     if (code < 0)
823     {
824         dprintf("decode_dc: bad vlc: %d:%d (%x)\n", 0, dc_index,
825             &s->vlcs[0][dc_index]);
826         return 0xffff;
827     }
828     if (code == 0) {
829         diff = 0;
830     } else {
831         diff = get_bits(&s->gb, code);
832         if ((diff & (1 << (code - 1))) == 0) 
833             diff = (-1 << code) | (diff + 1);
834     }
835     return diff;
836 }
837
838 /* decode block and dequantize */
839 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
840                         int component, int dc_index, int ac_index, int quant_index)
841 {
842     int nbits, code, i, j, level;
843     int run, val;
844     VLC *ac_vlc;
845     INT16 *quant_matrix;
846
847     /* DC coef */
848     val = decode_dc(s, dc_index);
849     if (val == 0xffff) {
850         dprintf("error dc\n");
851         return -1;
852     }
853     quant_matrix = s->quant_matrixes[quant_index];
854     val = val * quant_matrix[0] + s->last_dc[component];
855     s->last_dc[component] = val;
856     block[0] = val;
857     /* AC coefs */
858     ac_vlc = &s->vlcs[1][ac_index];
859     i = 1;
860     for(;;) {
861         code = get_vlc(&s->gb, ac_vlc);
862         if (code < 0) {
863             dprintf("error ac\n");
864             return -1;
865         }
866         /* EOB */
867         if (code == 0)
868             break;
869         if (code == 0xf0) {
870             i += 16;
871         } else {
872             run = code >> 4;
873             nbits = code & 0xf;
874             level = get_bits(&s->gb, nbits);
875             if ((level & (1 << (nbits - 1))) == 0) 
876                 level = (-1 << nbits) | (level + 1);
877             i += run;
878             if (i >= 64) {
879                 dprintf("error count: %d\n", i);
880                 return -1;
881             }
882             j = zigzag_direct[i];
883             block[j] = level * quant_matrix[j];
884             i++;
885             if (i >= 64)
886                 break;
887         }
888     }
889     return 0;
890 }
891
892 static int mjpeg_decode_sos(MJpegDecodeContext *s,
893                             UINT8 *buf, int buf_size)
894 {
895     int len, nb_components, i, j, n, h, v, ret;
896     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
897     int comp_index[4];
898     int dc_index[4];
899     int ac_index[4];
900     int nb_blocks[4];
901     int h_count[4];
902     int v_count[4];
903     
904     init_get_bits(&s->gb, buf, buf_size);
905     /* XXX: verify len field validity */
906     len = get_bits(&s->gb, 16);
907     nb_components = get_bits(&s->gb, 8);
908     /* XXX: only interleaved scan accepted */
909     if (nb_components != 3)
910     {
911         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
912         return -1;
913     }
914     vmax = 0;
915     hmax = 0;
916     for(i=0;i<nb_components;i++) {
917         id = get_bits(&s->gb, 8) - 1;
918         dprintf("component: %d\n", id);
919         /* find component index */
920         for(index=0;index<s->nb_components;index++)
921             if (id == s->component_id[index])
922                 break;
923         if (index == s->nb_components)
924         {
925             dprintf("decode_sos: index(%d) out of components\n", index);
926             return -1;
927         }
928
929         comp_index[i] = index;
930         nb_blocks[i] = s->h_count[index] * s->v_count[index];
931         h_count[i] = s->h_count[index];
932         v_count[i] = s->v_count[index];
933
934         dc_index[i] = get_bits(&s->gb, 4);
935         ac_index[i] = get_bits(&s->gb, 4);
936
937         if (dc_index[i] < 0 || ac_index[i] < 0 ||
938             dc_index[i] >= 4 || ac_index[i] >= 4)
939             goto out_of_range;
940         switch(s->start_code)
941         {
942             case SOF0:
943                 if (dc_index[i] > 1 || ac_index[i] > 1)
944                     goto out_of_range;
945                 break;
946             case SOF1:
947             case SOF2:
948                 if (dc_index[i] > 3 || ac_index[i] > 3)
949                     goto out_of_range;
950                 break;
951             case SOF3:
952                 if (dc_index[i] > 3 || ac_index[i] != 0)
953                     goto out_of_range;
954                 break;  
955         }
956     }
957     skip_bits(&s->gb, 8); /* Ss */
958     skip_bits(&s->gb, 8); /* Se */
959     skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
960
961     for(i=0;i<nb_components;i++) 
962         s->last_dc[i] = 1024;
963
964     if (nb_components > 1) {
965         /* interleaved stream */
966         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
967         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
968     } else {
969         h = s->h_max / s->h_count[comp_index[0]];
970         v = s->v_max / s->v_count[comp_index[0]];
971         mb_width = (s->width + h * 8 - 1) / (h * 8);
972         mb_height = (s->height + v * 8 - 1) / (v * 8);
973         nb_blocks[0] = 1;
974         h_count[0] = 1;
975         v_count[0] = 1;
976     }
977
978     for(mb_y = 0; mb_y < mb_height; mb_y++) {
979         for(mb_x = 0; mb_x < mb_width; mb_x++) {
980             for(i=0;i<nb_components;i++) {
981                 UINT8 *ptr;
982                 int x, y, c;
983                 n = nb_blocks[i];
984                 c = comp_index[i];
985                 h = h_count[i];
986                 v = v_count[i];
987                 x = 0;
988                 y = 0;
989                 if (s->restart_interval && !s->restart_count)
990                     s->restart_count = s->restart_interval;
991                 for(j=0;j<n;j++) {
992                     memset(s->block, 0, sizeof(s->block));
993                     if (decode_block(s, s->block, i, 
994                                      dc_index[i], ac_index[i], 
995                                      s->quant_index[c]) < 0) {
996                         dprintf("error %d %d\n", mb_y, mb_x);
997                         ret = -1;
998                         goto the_end;
999                     }
1000 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1001                     ff_idct (s->block);
1002                     ptr = s->current_picture[c] + 
1003                         (s->linesize[c] * (v * mb_y + y) * 8) + 
1004                         (h * mb_x + x) * 8;
1005                     if (s->interlaced && s->bottom_field)
1006                         ptr += s->linesize[c] >> 1;
1007                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
1008                     if (++x == h) {
1009                         x = 0;
1010                         y++;
1011                     }
1012                 }
1013             }
1014         }
1015     }
1016     ret = 0;
1017  the_end:
1018     emms_c();
1019     return ret;
1020  out_of_range:
1021     dprintf("decode_sos: ac/dc index out of range\n");
1022     return -1;
1023 }
1024
1025 static int mjpeg_decode_dri(MJpegDecodeContext *s,
1026                              UINT8 *buf, int buf_size)
1027 {
1028     init_get_bits(&s->gb, buf, buf_size);
1029
1030     if (get_bits(&s->gb, 16) != 4)
1031         return -1;
1032     s->restart_interval = get_bits(&s->gb, 16);
1033     printf("restart interval: %d\n", s->restart_interval);
1034
1035     return 0;
1036 }
1037
1038 #define FOURCC(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d)
1039 static int mjpeg_decode_app(MJpegDecodeContext *s,
1040                              UINT8 *buf, int buf_size, int start_code)
1041 {
1042     int len, id;
1043
1044     init_get_bits(&s->gb, buf, buf_size);
1045
1046     /* XXX: verify len field validity */
1047     len = get_bits(&s->gb, 16);
1048     if (len < 5)
1049         return -1;
1050
1051     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1052     len -= 6;
1053
1054     /* buggy AVID, it puts EOI only at every 10th frame */
1055     /* also this fourcc is used by non-avid files too, it means
1056        interleaving, but it's always present in AVID files */
1057     if (id == FOURCC('A','V','I','1'))
1058     {
1059         /* structure:
1060             4bytes      AVI1
1061             1bytes      polarity
1062             1bytes      always zero
1063             4bytes      field_size
1064             4bytes      field_size_less_padding
1065         */
1066         s->buggy_avid = 1;
1067         if (s->first_picture)
1068             printf("mjpeg: workarounding buggy AVID\n");
1069         s->interleaved_rows = get_bits(&s->gb, 8);
1070 #if 0
1071         skip_bits(&s->gb, 8);
1072         skip_bits(&s->gb, 32);
1073         skip_bits(&s->gb, 32);
1074         len -= 10;
1075 #endif
1076         if (s->interleaved_rows)
1077             printf("mjpeg: interleaved rows: %d\n", s->interleaved_rows);
1078         goto out;
1079     }
1080     
1081     len -= 2;
1082     
1083     if (id == FOURCC('J','F','I','F'))
1084     {
1085         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1086         printf("mjpeg: JFIF header found (version: %x.%x)\n",
1087             get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1088         goto out;
1089     }
1090     
1091     /* Apple MJPEG-A */
1092     if ((start_code == APP1) && (len > (0x28 - 8)))
1093     {
1094         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1095         len -= 4;
1096         if (id == FOURCC('m','j','p','g')) /* Apple MJPEG-A */
1097         {
1098 #if 0
1099             skip_bits(&s->gb, 32); /* field size */
1100             skip_bits(&s->gb, 32); /* pad field size */
1101             skip_bits(&s->gb, 32); /* next off */
1102             skip_bits(&s->gb, 32); /* quant off */
1103             skip_bits(&s->gb, 32); /* huff off */
1104             skip_bits(&s->gb, 32); /* image off */
1105             skip_bits(&s->gb, 32); /* scan off */
1106             skip_bits(&s->gb, 32); /* data off */
1107 #endif
1108             if (s->first_picture)
1109                 printf("mjpeg: Apple MJPEG-A header found\n");
1110         }
1111     }
1112
1113 out:
1114     /* should check for further values.. */
1115     SKIP_REMAINING(&s->gb, len);
1116
1117     return 0;
1118 }
1119 #undef FOURCC
1120
1121 static int mjpeg_decode_com(MJpegDecodeContext *s,
1122                              UINT8 *buf, int buf_size)
1123 {
1124     int len, i;
1125     UINT8 *cbuf;
1126
1127     init_get_bits(&s->gb, buf, buf_size);
1128
1129     /* XXX: verify len field validity */
1130     len = get_bits(&s->gb, 16)-2;
1131     cbuf = malloc(len+1);
1132
1133     for (i = 0; i < len; i++)
1134         cbuf[i] = get_bits(&s->gb, 8);
1135     if (cbuf[i-1] == '\n')
1136         cbuf[i-1] = 0;
1137     else
1138         cbuf[i] = 0;
1139
1140     printf("mjpeg comment: '%s'\n", cbuf);
1141
1142     /* buggy avid, it puts EOI only at every 10th frame */
1143     if (!strcmp(cbuf, "AVID"))
1144     {
1145         s->buggy_avid = 1;
1146         if (s->first_picture)
1147             printf("mjpeg: workarounding buggy AVID\n");
1148     }
1149     
1150     free(cbuf);
1151
1152     return 0;
1153 }
1154
1155 /* return the 8 bit start code value and update the search
1156    state. Return -1 if no start code found */
1157 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end, 
1158                        UINT32 *header_state)
1159 {
1160     UINT8 *buf_ptr;
1161     unsigned int state, v;
1162     int val;
1163
1164     state = *header_state;
1165     buf_ptr = *pbuf_ptr;
1166     if (state) {
1167         /* get marker */
1168     found:
1169         if (buf_ptr < buf_end) {
1170             val = *buf_ptr++;
1171             state = 0;
1172         } else {
1173             val = -1;
1174         }
1175     } else {
1176         while (buf_ptr < buf_end) {
1177             v = *buf_ptr++;
1178             if (v == 0xff) {
1179                 state = 1;
1180                 goto found;
1181             }
1182         }
1183         val = -1;
1184     }
1185     *pbuf_ptr = buf_ptr;
1186     *header_state = state;
1187     return val;
1188 }
1189
1190 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1191                               void *data, int *data_size,
1192                               UINT8 *buf, int buf_size)
1193 {
1194     MJpegDecodeContext *s = avctx->priv_data;
1195     UINT8 *buf_end, *buf_ptr, *buf_start;
1196     int len, code, input_size, i;
1197     AVPicture *picture = data;
1198     unsigned int start_code;
1199
1200     *data_size = 0;
1201
1202     /* no supplementary picture */
1203     if (buf_size == 0)
1204         return 0;
1205
1206     buf_ptr = buf;
1207     buf_end = buf + buf_size;
1208     while (buf_ptr < buf_end) {
1209         buf_start = buf_ptr;
1210         /* find start next marker */
1211         code = find_marker(&buf_ptr, buf_end, &s->header_state);
1212         /* copy to buffer */
1213         len = buf_ptr - buf_start;
1214         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1215             /* data too big : flush */
1216             s->buf_ptr = s->buffer;
1217             if (code > 0)
1218                 s->start_code = code;
1219         } else {
1220             memcpy(s->buf_ptr, buf_start, len);
1221             s->buf_ptr += len;
1222             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
1223             /* valid marker code is between 00 and ff - alex */
1224             if (code <= 0 || code >= 0xff) {
1225                 s->buf_ptr--;
1226             } else {
1227                 /* prepare data for next start code */
1228                 input_size = s->buf_ptr - s->buffer;
1229                 start_code = s->start_code;
1230                 s->buf_ptr = s->buffer;
1231                 s->start_code = code;
1232                 dprintf("marker=%x\n", start_code);
1233                 switch(start_code) {
1234                 case SOI:
1235                     s->restart_interval = 0;
1236                     /* nothing to do on SOI */
1237                     break;
1238                 case DQT:
1239                     mjpeg_decode_dqt(s, s->buffer, input_size);
1240                     break;
1241                 case DHT:
1242                     mjpeg_decode_dht(s, s->buffer, input_size);
1243                     break;
1244                 case SOF0:
1245                     mjpeg_decode_sof0(s, s->buffer, input_size);
1246                     break;
1247                 case SOS:
1248                     mjpeg_decode_sos(s, s->buffer, input_size);
1249                     if (s->start_code == EOI || s->buggy_avid || s->restart_interval) {
1250                         int l;
1251                         if (s->interlaced) {
1252                             s->bottom_field ^= 1;
1253                             /* if not bottom field, do not output image yet */
1254                             if (s->bottom_field)
1255                                 goto the_end;
1256                         }
1257                         for(i=0;i<3;i++) {
1258                             picture->data[i] = s->current_picture[i];
1259                             l = s->linesize[i];
1260                             if (s->interlaced)
1261                                 l >>= 1;
1262                             picture->linesize[i] = l;
1263                         }
1264                         *data_size = sizeof(AVPicture);
1265                         avctx->height = s->height;
1266                         if (s->interlaced)
1267                             avctx->height *= 2;
1268                         avctx->width = s->width;
1269                         /* XXX: not complete test ! */
1270                         switch((s->h_count[0] << 4) | s->v_count[0]) {
1271                         case 0x11:
1272                             avctx->pix_fmt = PIX_FMT_YUV444P;
1273                             break;
1274                         case 0x21:
1275                             avctx->pix_fmt = PIX_FMT_YUV422P;
1276                             break;
1277                         default:
1278                         case 0x22:
1279                             avctx->pix_fmt = PIX_FMT_YUV420P;
1280                             break;
1281                         }
1282                         /* dummy quality */
1283                         /* XXX: infer it with matrix */
1284                         avctx->quality = 3; 
1285                         goto the_end;
1286                     }
1287                     break;
1288                 case DRI:
1289                     mjpeg_decode_dri(s, s->buffer, input_size);
1290                     break;
1291                 case SOF1:
1292                 case SOF2:
1293                 case SOF3:
1294                 case SOF5:
1295                 case SOF6:
1296                 case SOF7:
1297                 case SOF9:
1298                 case SOF10:
1299                 case SOF11:
1300                 case SOF13:
1301                 case SOF14:
1302                 case SOF15:
1303                 case JPG:
1304                     printf("mjpeg: unsupported coding type (%x)\n", start_code);
1305                     return -1;
1306                 }
1307 #if 1
1308                 if (start_code >= 0xd0 && start_code <= 0xd7)
1309                 {
1310                     dprintf("restart marker: %d\n", start_code&0x0f);
1311                 }
1312                 else if (s->first_picture)
1313                 {
1314                     /* APP fields */
1315                     if (start_code >= 0xe0 && start_code <= 0xef)
1316                         mjpeg_decode_app(s, s->buffer, input_size, start_code);
1317                     /* Comment */
1318                     else if (start_code == COM)
1319                         mjpeg_decode_com(s, s->buffer, input_size);
1320                 }
1321 #endif
1322             }
1323         }
1324     }
1325  the_end:
1326     return buf_ptr - buf;
1327 }
1328
1329 static int mjpeg_decode_end(AVCodecContext *avctx)
1330 {
1331     MJpegDecodeContext *s = avctx->priv_data;
1332     int i, j;
1333
1334     for(i=0;i<MAX_COMPONENTS;i++)
1335         free(s->current_picture[i]);
1336     for(i=0;i<2;i++) {
1337         for(j=0;j<4;j++)
1338             free_vlc(&s->vlcs[i][j]);
1339     }
1340     return 0;
1341 }
1342
1343 AVCodec mjpeg_decoder = {
1344     "mjpeg",
1345     CODEC_TYPE_VIDEO,
1346     CODEC_ID_MJPEG,
1347     sizeof(MJpegDecodeContext),
1348     mjpeg_decode_init,
1349     NULL,
1350     mjpeg_decode_end,
1351     mjpeg_decode_frame,
1352     0,
1353     NULL
1354 };