97a9501f06d6f8540915278e6c2d9e60bacec032
[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 #include <stdlib.h>
20 #include <stdio.h>
21 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "mpegvideo.h"
24
25 typedef struct MJpegContext {
26     UINT8 huff_size_dc_luminance[12];
27     UINT16 huff_code_dc_luminance[12];
28     UINT8 huff_size_dc_chrominance[12];
29     UINT16 huff_code_dc_chrominance[12];
30
31     UINT8 huff_size_ac_luminance[256];
32     UINT16 huff_code_ac_luminance[256];
33     UINT8 huff_size_ac_chrominance[256];
34     UINT16 huff_code_ac_chrominance[256];
35 } MJpegContext;
36
37 #define SOF0 0xc0
38 #define SOI 0xd8
39 #define EOI 0xd9
40 #define DQT 0xdb
41 #define DHT 0xc4
42 #define SOS 0xda
43
44 #if 0
45 /* These are the sample quantization tables given in JPEG spec section K.1.
46  * The spec says that the values given produce "good" quality, and
47  * when divided by 2, "very good" quality.
48  */
49 static const unsigned char std_luminance_quant_tbl[64] = {
50     16,  11,  10,  16,  24,  40,  51,  61,
51     12,  12,  14,  19,  26,  58,  60,  55,
52     14,  13,  16,  24,  40,  57,  69,  56,
53     14,  17,  22,  29,  51,  87,  80,  62,
54     18,  22,  37,  56,  68, 109, 103,  77,
55     24,  35,  55,  64,  81, 104, 113,  92,
56     49,  64,  78,  87, 103, 121, 120, 101,
57     72,  92,  95,  98, 112, 100, 103,  99
58 };
59 static const unsigned char std_chrominance_quant_tbl[64] = {
60     17,  18,  24,  47,  99,  99,  99,  99,
61     18,  21,  26,  66,  99,  99,  99,  99,
62     24,  26,  56,  99,  99,  99,  99,  99,
63     47,  66,  99,  99,  99,  99,  99,  99,
64     99,  99,  99,  99,  99,  99,  99,  99,
65     99,  99,  99,  99,  99,  99,  99,  99,
66     99,  99,  99,  99,  99,  99,  99,  99,
67     99,  99,  99,  99,  99,  99,  99,  99
68 };
69 #endif
70
71 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
72 /* IMPORTANT: these are only valid for 8-bit data precision! */
73 static const UINT8 bits_dc_luminance[17] =
74 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
75 static const UINT8 val_dc_luminance[] =
76 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
77
78 static const UINT8 bits_dc_chrominance[17] =
79 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
80 static const UINT8 val_dc_chrominance[] =
81 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
82
83 static const UINT8 bits_ac_luminance[17] =
84 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
85 static const UINT8 val_ac_luminance[] =
86 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
87   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
88   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
89   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
90   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
91   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
92   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
93   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
94   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
95   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
96   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
97   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
98   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
99   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
100   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
101   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
102   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
103   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
104   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
105   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
106   0xf9, 0xfa 
107 };
108
109 static const UINT8 bits_ac_chrominance[17] =
110 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
111
112 static const UINT8 val_ac_chrominance[] =
113 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
114   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
115   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
116   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
117   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
118   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
119   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
120   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
121   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
122   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
123   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
124   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
125   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
126   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
127   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
128   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
129   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
130   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
131   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
132   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
133   0xf9, 0xfa 
134 };
135
136
137 /* isn't this function nicer than the one in the libjpeg ? */
138 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
139                                 const UINT8 *bits_table, const UINT8 *val_table)
140 {
141     int i, j, k,nb, code, sym;
142
143     code = 0;
144     k = 0;
145     for(i=1;i<=16;i++) {
146         nb = bits_table[i];
147         for(j=0;j<nb;j++) {
148             sym = val_table[k++];
149             huff_size[sym] = i;
150             huff_code[sym] = code;
151             code++;
152         }
153         code <<= 1;
154     }
155 }
156
157 int mjpeg_init(MpegEncContext *s)
158 {
159     MJpegContext *m;
160     
161     m = malloc(sizeof(MJpegContext));
162     if (!m)
163         return -1;
164
165     /* build all the huffman tables */
166     build_huffman_codes(m->huff_size_dc_luminance,
167                         m->huff_code_dc_luminance,
168                         bits_dc_luminance,
169                         val_dc_luminance);
170     build_huffman_codes(m->huff_size_dc_chrominance,
171                         m->huff_code_dc_chrominance,
172                         bits_dc_chrominance,
173                         val_dc_chrominance);
174     build_huffman_codes(m->huff_size_ac_luminance,
175                         m->huff_code_ac_luminance,
176                         bits_ac_luminance,
177                         val_ac_luminance);
178     build_huffman_codes(m->huff_size_ac_chrominance,
179                         m->huff_code_ac_chrominance,
180                         bits_ac_chrominance,
181                         val_ac_chrominance);
182     
183     s->mjpeg_ctx = m;
184     return 0;
185 }
186
187 void mjpeg_close(MpegEncContext *s)
188 {
189     free(s->mjpeg_ctx);
190 }
191
192 static inline void put_marker(PutBitContext *p, int code)
193 {
194     put_bits(p, 8, 0xff);
195     put_bits(p, 8, code);
196 }
197
198 /* table_class: 0 = DC coef, 1 = AC coefs */
199 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
200                              const UINT8 *bits_table, const UINT8 *value_table)
201 {
202     PutBitContext *p = &s->pb;
203     int n, i;
204
205     put_bits(p, 4, table_class);
206     put_bits(p, 4, table_id);
207
208     n = 0;
209     for(i=1;i<=16;i++) {
210         n += bits_table[i];
211         put_bits(p, 8, bits_table[i]);
212     }
213
214     for(i=0;i<n;i++)
215         put_bits(p, 8, value_table[i]);
216
217     return n + 17;
218 }
219
220 static void jpeg_table_header(MpegEncContext *s)
221 {
222     PutBitContext *p = &s->pb;
223     int i, j, size;
224     UINT8 *ptr;
225
226     /* quant matrixes */
227     put_marker(p, DQT);
228     put_bits(p, 16, 2 + 1 * (1 + 64));
229     put_bits(p, 4, 0); /* 8 bit precision */
230     put_bits(p, 4, 0); /* table 0 */
231     for(i=0;i<64;i++) {
232         j = zigzag_direct[i];
233         put_bits(p, 8, s->intra_matrix[j]);
234     }
235 #if 0
236     put_bits(p, 4, 0); /* 8 bit precision */
237     put_bits(p, 4, 1); /* table 1 */
238     for(i=0;i<64;i++) {
239         j = zigzag_direct[i];
240         put_bits(p, 8, s->chroma_intra_matrix[j]);
241     }
242 #endif
243
244     /* huffman table */
245     put_marker(p, DHT);
246     flush_put_bits(p);
247     ptr = p->buf_ptr;
248     put_bits(p, 16, 0); /* patched later */
249     size = 2;
250     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
251     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
252     
253     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
254     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
255     ptr[0] = size >> 8;
256     ptr[1] = size;
257 }
258
259 void mjpeg_picture_header(MpegEncContext *s)
260 {
261     put_marker(&s->pb, SOI);
262
263     jpeg_table_header(s);
264
265     put_marker(&s->pb, SOF0);
266
267     put_bits(&s->pb, 16, 17);
268     put_bits(&s->pb, 8, 8); /* 8 bits/component */
269     put_bits(&s->pb, 16, s->height);
270     put_bits(&s->pb, 16, s->width);
271     put_bits(&s->pb, 8, 3); /* 3 components */
272     
273     /* Y component */
274     put_bits(&s->pb, 8, 1); /* component number */
275     put_bits(&s->pb, 4, 2); /* H factor */
276     put_bits(&s->pb, 4, 2); /* V factor */
277     put_bits(&s->pb, 8, 0); /* select matrix */
278     
279     /* Cb component */
280     put_bits(&s->pb, 8, 2); /* component number */
281     put_bits(&s->pb, 4, 1); /* H factor */
282     put_bits(&s->pb, 4, 1); /* V factor */
283     put_bits(&s->pb, 8, 0); /* select matrix */
284
285     /* Cr component */
286     put_bits(&s->pb, 8, 3); /* component number */
287     put_bits(&s->pb, 4, 1); /* H factor */
288     put_bits(&s->pb, 4, 1); /* V factor */
289     put_bits(&s->pb, 8, 0); /* select matrix */
290
291     /* scan header */
292     put_marker(&s->pb, SOS);
293     put_bits(&s->pb, 16, 12); /* length */
294     put_bits(&s->pb, 8, 3); /* 3 components */
295     
296     /* Y component */
297     put_bits(&s->pb, 8, 1); /* index */
298     put_bits(&s->pb, 4, 0); /* DC huffman table index */
299     put_bits(&s->pb, 4, 0); /* AC huffman table index */
300     
301     /* Cb component */
302     put_bits(&s->pb, 8, 2); /* index */
303     put_bits(&s->pb, 4, 1); /* DC huffman table index */
304     put_bits(&s->pb, 4, 1); /* AC huffman table index */
305     
306     /* Cr component */
307     put_bits(&s->pb, 8, 3); /* index */
308     put_bits(&s->pb, 4, 1); /* DC huffman table index */
309     put_bits(&s->pb, 4, 1); /* AC huffman table index */
310
311     put_bits(&s->pb, 8, 0); /* Ss (not used) */
312     put_bits(&s->pb, 8, 63); /* Se (not used) */
313     put_bits(&s->pb, 8, 0); /* (not used) */
314 }
315
316 void mjpeg_picture_trailer(MpegEncContext *s)
317 {
318     jflush_put_bits(&s->pb);
319     put_marker(&s->pb, EOI);
320 }
321
322 static inline void encode_dc(MpegEncContext *s, int val, 
323                              UINT8 *huff_size, UINT16 *huff_code)
324 {
325     int mant, nbits;
326
327     if (val == 0) {
328         jput_bits(&s->pb, huff_size[0], huff_code[0]);
329     } else {
330         mant = val;
331         if (val < 0) {
332             val = -val;
333             mant--;
334         }
335         
336         /* compute the log (XXX: optimize) */
337         nbits = 0;
338         while (val != 0) {
339             val = val >> 1;
340             nbits++;
341         }
342             
343         jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
344         
345         jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
346     }
347 }
348
349 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
350 {
351     int mant, nbits, code, i, j;
352     int component, dc, run, last_index, val;
353     MJpegContext *m = s->mjpeg_ctx;
354     UINT8 *huff_size_ac;
355     UINT16 *huff_code_ac;
356     
357     /* DC coef */
358     component = (n <= 3 ? 0 : n - 4 + 1);
359     dc = block[0]; /* overflow is impossible */
360     val = dc - s->last_dc[component];
361     if (n < 4) {
362         encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
363         huff_size_ac = m->huff_size_ac_luminance;
364         huff_code_ac = m->huff_code_ac_luminance;
365     } else {
366         encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
367         huff_size_ac = m->huff_size_ac_chrominance;
368         huff_code_ac = m->huff_code_ac_chrominance;
369     }
370     s->last_dc[component] = dc;
371     
372     /* AC coefs */
373     
374     run = 0;
375     last_index = s->block_last_index[n];
376     for(i=1;i<=last_index;i++) {
377         j = zigzag_direct[i];
378         val = block[j];
379         if (val == 0) {
380             run++;
381         } else {
382             while (run >= 16) {
383                 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
384                 run -= 16;
385             }
386             mant = val;
387             if (val < 0) {
388                 val = -val;
389                 mant--;
390             }
391             
392             /* compute the log (XXX: optimize) */
393             nbits = 0;
394             while (val != 0) {
395                 val = val >> 1;
396                 nbits++;
397             }
398             code = (run << 4) | nbits;
399
400             jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
401         
402             jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
403             run = 0;
404         }
405     }
406
407     /* output EOB only if not already 64 values */
408     if (last_index < 63 || run != 0)
409         jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
410 }
411
412 void mjpeg_encode_mb(MpegEncContext *s, 
413                      DCTELEM block[6][64])
414 {
415     int i;
416     for(i=0;i<6;i++) {
417         encode_block(s, block[i], i);
418     }
419 }
420
421 /******************************************/
422 /* decoding */
423
424 //#define DEBUG
425
426 #ifdef DEBUG
427 #define dprintf(fmt,args...) printf(fmt, ## args)
428 #else
429 #define dprintf(fmt,args...)
430 #endif
431
432 /* compressed picture size */
433 #define PICTURE_BUFFER_SIZE 100000
434
435 #define MAX_COMPONENTS 4
436
437 typedef struct MJpegDecodeContext {
438     GetBitContext gb;
439     UINT32 header_state;
440     int start_code; /* current start code */
441     UINT8 *buf_ptr;
442     int buffer_size;
443     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
444     INT16 quant_matrixes[4][64];
445     VLC vlcs[2][4];
446     int width, height;
447     int nb_components;
448     int component_id[MAX_COMPONENTS];
449     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
450     int v_count[MAX_COMPONENTS];
451     int h_max, v_max; /* maximum h and v counts */
452     int quant_index[4];   /* quant table index for each component */
453     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
454     UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
455     int linesize[MAX_COMPONENTS];
456     DCTELEM block[64] __align8;
457     UINT8 buffer[PICTURE_BUFFER_SIZE]; 
458 } MJpegDecodeContext;
459
460 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table, 
461                       int nb_codes)
462 {
463     UINT8 huff_size[256];
464     UINT16 huff_code[256];
465
466     memset(huff_size, 0, sizeof(huff_size));
467     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
468     
469     init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
470 }
471
472 static int mjpeg_decode_init(AVCodecContext *avctx)
473 {
474     MJpegDecodeContext *s = avctx->priv_data;
475
476     s->header_state = 0;
477     s->mpeg_enc_ctx_allocated = 0;
478     s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
479                                                  account FF 00 case */
480     s->start_code = -1;
481     s->buf_ptr = s->buffer;
482
483     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
484     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
485     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
486     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
487     return 0;
488 }
489
490 /* quantize tables */
491 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
492                             UINT8 *buf, int buf_size)
493 {
494     int len, index, i, j;
495     init_get_bits(&s->gb, buf, buf_size);
496
497     len = get_bits(&s->gb, 16);
498     len -= 2;
499
500     while (len >= 65) {
501         /* only 8 bit precision handled */
502         if (get_bits(&s->gb, 4) != 0)
503             return -1;
504         index = get_bits(&s->gb, 4);
505         if (index >= 4)
506             return -1;
507         dprintf("index=%d\n", index);
508         /* read quant table */
509         for(i=0;i<64;i++) {
510             j = zigzag_direct[i];
511             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
512         }
513         len -= 65;
514     }
515     return 0;
516 }
517
518 /* decode huffman tables and build VLC decoders */
519 static int mjpeg_decode_dht(MJpegDecodeContext *s,
520                             UINT8 *buf, int buf_size)
521 {
522     int len, index, i, class, n, v, code_max;
523     UINT8 bits_table[17];
524     UINT8 val_table[256];
525     
526     init_get_bits(&s->gb, buf, buf_size);
527
528     len = get_bits(&s->gb, 16);
529     len -= 2;
530
531     while (len > 0) {
532         if (len < 17)
533             return -1;
534         class = get_bits(&s->gb, 4);
535         if (class >= 2)
536             return -1;
537         index = get_bits(&s->gb, 4);
538         if (index >= 4)
539             return -1;
540         n = 0;
541         for(i=1;i<=16;i++) {
542             bits_table[i] = get_bits(&s->gb, 8);
543             n += bits_table[i];
544         }
545         len -= 17;
546         if (len < n || n > 256)
547             return -1;
548
549         code_max = 0;
550         for(i=0;i<n;i++) {
551             v = get_bits(&s->gb, 8);
552             if (v > code_max)
553                 code_max = v;
554             val_table[i] = v;
555         }
556         len -= n;
557
558         /* build VLC and flush previous vlc if present */
559         free_vlc(&s->vlcs[class][index]);
560         dprintf("class=%d index=%d nb_codes=%d\n",
561                class, index, code_max + 1);
562         build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
563     }
564     return 0;
565 }
566
567 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
568                              UINT8 *buf, int buf_size)
569 {
570     int len, nb_components, i, width, height;
571
572     init_get_bits(&s->gb, buf, buf_size);
573
574     /* XXX: verify len field validity */
575     len = get_bits(&s->gb, 16);
576     /* only 8 bits/component accepted */
577     if (get_bits(&s->gb, 8) != 8)
578         return -1;
579     height = get_bits(&s->gb, 16);
580     width = get_bits(&s->gb, 16);
581
582     nb_components = get_bits(&s->gb, 8);
583     if (nb_components <= 0 ||
584         nb_components > MAX_COMPONENTS)
585         return -1;
586     s->nb_components = nb_components;
587     s->h_max = 1;
588     s->v_max = 1;
589     for(i=0;i<nb_components;i++) {
590         /* component id */
591         s->component_id[i] = get_bits(&s->gb, 8) - 1;
592         s->h_count[i] = get_bits(&s->gb, 4);
593         s->v_count[i] = get_bits(&s->gb, 4);
594         /* compute hmax and vmax (only used in interleaved case) */
595         if (s->h_count[i] > s->h_max)
596             s->h_max = s->h_count[i];
597         if (s->v_count[i] > s->v_max)
598             s->v_max = s->v_count[i];
599         s->quant_index[i] = get_bits(&s->gb, 8);
600         if (s->quant_index[i] >= 4)
601             return -1;
602         dprintf("component %d %d:%d\n", i, s->h_count[i], s->v_count[i]);
603     }
604
605     /* if different size, realloc/alloc picture */
606     /* XXX: also check h_count and v_count */
607     if (width != s->width || height != s->height) {
608         for(i=0;i<MAX_COMPONENTS;i++) {
609             free(s->current_picture[i]);
610             s->current_picture[i] = NULL;
611         }
612         s->width = width;
613         s->height = height;
614         for(i=0;i<nb_components;i++) {
615             int w, h, hh, vv;
616             hh = s->h_max / s->h_count[i];
617             vv = s->v_max / s->v_count[i];
618             w = (s->width + 8 * hh - 1) / (8 * hh);
619             h = (s->height + 8 * vv - 1) / (8 * vv);
620             w = w * 8;
621             h = h * 8;
622             s->linesize[i] = w;
623             /* memory test is done in mjpeg_decode_sos() */
624             s->current_picture[i] = av_mallocz(w * h);
625         }
626     }
627
628     return 0;
629 }
630
631 static inline int decode_dc(MJpegDecodeContext *s, int dc_index)
632 {
633     VLC *dc_vlc;
634     int code, diff;
635
636     dc_vlc = &s->vlcs[0][dc_index];
637     code = get_vlc(&s->gb, dc_vlc);
638     if (code < 0)
639         return 0xffff;
640     if (code == 0) {
641         diff = 0;
642     } else {
643         diff = get_bits(&s->gb, code);
644         if ((diff & (1 << (code - 1))) == 0) 
645             diff = (-1 << code) | (diff + 1);
646     }
647     return diff;
648 }
649
650 /* decode block and dequantize */
651 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
652                         int component, int dc_index, int ac_index, int quant_index)
653 {
654     int nbits, code, i, j, level;
655     int run, val;
656     VLC *ac_vlc;
657     INT16 *quant_matrix;
658
659     quant_matrix = s->quant_matrixes[quant_index];
660     /* DC coef */
661     val = decode_dc(s, dc_index);
662     if (val == 0xffff) {
663         dprintf("error dc\n");
664         return -1;
665     }
666     val = val * quant_matrix[0] + s->last_dc[component];
667     s->last_dc[component] = val;
668     block[0] = val;
669     /* AC coefs */
670     ac_vlc = &s->vlcs[1][ac_index];
671     i = 1;
672     for(;;) {
673         code = get_vlc(&s->gb, ac_vlc);
674         if (code < 0) {
675             dprintf("error ac\n");
676             return -1;
677         }
678         /* EOB */
679         if (code == 0)
680             break;
681         if (code == 0xf0) {
682             i += 16;
683         } else {
684             run = code >> 4;
685             nbits = code & 0xf;
686             level = get_bits(&s->gb, nbits);
687             if ((level & (1 << (nbits - 1))) == 0) 
688                 level = (-1 << nbits) | (level + 1);
689             i += run;
690             if (i >= 64) {
691                 dprintf("error count: %d\n", i);
692                 return -1;
693             }
694             j = zigzag_direct[i];
695             block[j] = level * quant_matrix[j];
696             i++;
697             if (i >= 64)
698                 break;
699         }
700     }
701     return 0;
702 }
703
704 static int mjpeg_decode_sos(MJpegDecodeContext *s,
705                             UINT8 *buf, int buf_size)
706 {
707     int len, nb_components, i, j, n, h, v;
708     int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
709     int comp_index[4];
710     int dc_index[4];
711     int ac_index[4];
712     int nb_blocks[4];
713     int h_count[4];
714     int v_count[4];
715     
716     init_get_bits(&s->gb, buf, buf_size);
717     /* XXX: verify len field validity */
718     len = get_bits(&s->gb, 16);
719     nb_components = get_bits(&s->gb, 8);
720     /* XXX: only interleaved scan accepted */
721     if (nb_components != 3)
722         return -1;
723     vmax = 0;
724     hmax = 0;
725     for(i=0;i<nb_components;i++) {
726         id = get_bits(&s->gb, 8) - 1;
727         /* find component index */
728         for(index=0;index<s->nb_components;index++)
729             if (id == s->component_id[index])
730                 break;
731         if (index == s->nb_components)
732             return -1;
733
734         comp_index[i] = index;
735         nb_blocks[i] = s->h_count[index] * s->v_count[index];
736         h_count[i] = s->h_count[index];
737         v_count[i] = s->v_count[index];
738
739         dc_index[i] = get_bits(&s->gb, 4);
740         if (dc_index[i] >= 4)
741             return -1;
742         ac_index[i] = get_bits(&s->gb, 4);
743         if (ac_index[i] >= 4)
744             return -1;
745     }
746     get_bits(&s->gb, 8); /* Ss */
747     get_bits(&s->gb, 8); /* Se */
748     get_bits(&s->gb, 8); /* not used */
749
750     for(i=0;i<nb_components;i++) 
751         s->last_dc[i] = 1024;
752
753     if (nb_components > 1) {
754         /* interleaved stream */
755         mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
756         mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
757     } else {
758         h = s->h_max / s->h_count[comp_index[0]];
759         v = s->v_max / s->v_count[comp_index[0]];
760         mb_width = (s->width + h * 8 - 1) / (h * 8);
761         mb_height = (s->height + v * 8 - 1) / (v * 8);
762         nb_blocks[0] = 1;
763         h_count[0] = 1;
764         v_count[0] = 1;
765     }
766
767     for(mb_y = 0; mb_y < mb_height; mb_y++) {
768         for(mb_x = 0; mb_x < mb_width; mb_x++) {
769             for(i=0;i<nb_components;i++) {
770                 UINT8 *ptr;
771                 int x, y, c;
772                 n = nb_blocks[i];
773                 c = comp_index[i];
774                 h = h_count[i];
775                 v = v_count[i];
776                 x = 0;
777                 y = 0;
778                 for(j=0;j<n;j++) {
779                     memset(s->block, 0, sizeof(s->block));
780                     if (decode_block(s, s->block, i, 
781                                      dc_index[i], ac_index[i], 
782                                      s->quant_index[c]) < 0) {
783                         dprintf("error %d %d\n", mb_y, mb_x);
784                         return -1;
785                     }
786                     ff_idct (s->block);
787                     ptr = s->current_picture[c] + 
788                         (s->linesize[c] * (v * mb_y + y) * 8) + 
789                         (h * mb_x + x) * 8;
790                     put_pixels_clamped(s->block, ptr, s->linesize[c]);
791                     if (++x == h) {
792                         x = 0;
793                         y++;
794                     }
795                 }
796             }
797         }
798     }
799     emms_c();
800     return 0;
801 }
802
803 /* return the 8 bit start code value and update the search
804    state. Return -1 if no start code found */
805 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end, 
806                        UINT32 *header_state)
807 {
808     UINT8 *buf_ptr;
809     unsigned int state, v;
810     int val;
811
812     state = *header_state;
813     buf_ptr = *pbuf_ptr;
814     if (state) {
815         /* get marker */
816     found:
817         if (buf_ptr < buf_end) {
818             val = *buf_ptr++;
819             state = 0;
820         } else {
821             val = -1;
822         }
823     } else {
824         while (buf_ptr < buf_end) {
825             v = *buf_ptr++;
826             if (v == 0xff) {
827                 state = 1;
828                 goto found;
829             }
830         }
831         val = -1;
832     }
833     *pbuf_ptr = buf_ptr;
834     *header_state = state;
835     return val;
836 }
837
838 static int mjpeg_decode_frame(AVCodecContext *avctx, 
839                               void *data, int *data_size,
840                               UINT8 *buf, int buf_size)
841 {
842     MJpegDecodeContext *s = avctx->priv_data;
843     UINT8 *buf_end, *buf_ptr, *buf_start;
844     int len, code, start_code, input_size, i;
845     AVPicture *picture = data;
846
847     /* no supplementary picture */
848     if (buf_size == 0) {
849         *data_size = 0;
850         return 0;
851     }
852
853     buf_ptr = buf;
854     buf_end = buf + buf_size;
855     while (buf_ptr < buf_end) {
856         buf_start = buf_ptr;
857         /* find start next marker */
858         code = find_marker(&buf_ptr, buf_end, &s->header_state);
859         /* copy to buffer */
860         len = buf_ptr - buf_start;
861         if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
862             /* data too big : flush */
863             s->buf_ptr = s->buffer;
864             if (code > 0)
865                 s->start_code = code;
866         } else {
867             memcpy(s->buf_ptr, buf_start, len);
868             s->buf_ptr += len;
869             /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
870             if (code == 0) {
871                 s->buf_ptr--;
872             } else if (code > 0) {
873                 /* prepare data for next start code */
874                 input_size = s->buf_ptr - s->buffer;
875                 start_code = s->start_code;
876                 s->buf_ptr = s->buffer;
877                 s->start_code = code;
878                 dprintf("marker=%x\n", start_code);
879                 switch(start_code) {
880                 case SOI:
881                     /* nothing to do on SOI */
882                     break;
883                 case DQT:
884                     mjpeg_decode_dqt(s, s->buffer, input_size);
885                     break;
886                 case DHT:
887                     mjpeg_decode_dht(s, s->buffer, input_size);
888                     break;
889                 case SOF0:
890                     mjpeg_decode_sof0(s, s->buffer, input_size);
891                     break;
892                 case SOS:
893                     mjpeg_decode_sos(s, s->buffer, input_size);
894                     if (s->start_code == EOI) {
895                         for(i=0;i<3;i++) {
896                             picture->data[i] = s->current_picture[i];
897                             picture->linesize[i] = s->linesize[i];
898                         }
899                         *data_size = sizeof(AVPicture);
900                         avctx->height = s->height;
901                         avctx->width = s->width;
902                         /* XXX: not complete test ! */
903                         switch((s->h_count[0] << 4) | s->v_count[0]) {
904                         case 0x11:
905                             avctx->pix_fmt = PIX_FMT_YUV444P;
906                             break;
907                         case 0x21:
908                             avctx->pix_fmt = PIX_FMT_YUV422P;
909                             break;
910                         default:
911                         case 0x22:
912                             avctx->pix_fmt = PIX_FMT_YUV420P;
913                             break;
914                         }
915                         goto the_end;
916                     }
917                     break;
918                 }
919             }
920         }
921     }
922  the_end:
923     return buf_ptr - buf;
924 }
925
926 static int mjpeg_decode_end(AVCodecContext *avctx)
927 {
928     MJpegDecodeContext *s = avctx->priv_data;
929     int i, j;
930
931     for(i=0;i<MAX_COMPONENTS;i++)
932         free(s->current_picture[i]);
933     for(i=0;i<2;i++) {
934         for(j=0;j<4;j++)
935             free_vlc(&s->vlcs[i][j]);
936     }
937     return 0;
938 }
939
940 AVCodec mjpeg_decoder = {
941     "mjpeg",
942     CODEC_TYPE_VIDEO,
943     CODEC_ID_MJPEG,
944     sizeof(MJpegDecodeContext),
945     mjpeg_decode_init,
946     NULL,
947     mjpeg_decode_end,
948     mjpeg_decode_frame,
949 };