reset restart_count when restart_interval is set and fill the
[ffmpeg.git] / libavcodec / mjpeg.c
1 /*
2  * MJPEG encoder and decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard.
4  * Copyright (c) 2003 Alex Beregszaszi
5  * Copyright (c) 2003-2004 Michael Niedermayer
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  * Support for external huffman table, various fixes (AVID workaround),
22  * aspecting, new decode_frame mechanism and apple mjpeg-b support
23  *                                  by Alex Beregszaszi <alex@naxine.org>
24  */
25
26 /**
27  * @file mjpeg.c
28  * MJPEG encoder and decoder.
29  */
30  
31 //#define DEBUG
32 #include <assert.h>
33
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "mpegvideo.h"
37
38 /* use two quantizer tables (one for luminance and one for chrominance) */
39 /* not yet working */
40 #undef TWOMATRIXES
41
42 typedef struct MJpegContext {
43     uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
44     uint16_t huff_code_dc_luminance[12];
45     uint8_t huff_size_dc_chrominance[12];
46     uint16_t huff_code_dc_chrominance[12];
47
48     uint8_t huff_size_ac_luminance[256];
49     uint16_t huff_code_ac_luminance[256];
50     uint8_t huff_size_ac_chrominance[256];
51     uint16_t huff_code_ac_chrominance[256];
52 } MJpegContext;
53
54 /* JPEG marker codes */
55 typedef enum {
56     /* start of frame */
57     SOF0  = 0xc0,       /* baseline */
58     SOF1  = 0xc1,       /* extended sequential, huffman */
59     SOF2  = 0xc2,       /* progressive, huffman */
60     SOF3  = 0xc3,       /* lossless, huffman */
61
62     SOF5  = 0xc5,       /* differential sequential, huffman */
63     SOF6  = 0xc6,       /* differential progressive, huffman */
64     SOF7  = 0xc7,       /* differential lossless, huffman */
65     JPG   = 0xc8,       /* reserved for JPEG extension */
66     SOF9  = 0xc9,       /* extended sequential, arithmetic */
67     SOF10 = 0xca,       /* progressive, arithmetic */
68     SOF11 = 0xcb,       /* lossless, arithmetic */
69
70     SOF13 = 0xcd,       /* differential sequential, arithmetic */
71     SOF14 = 0xce,       /* differential progressive, arithmetic */
72     SOF15 = 0xcf,       /* differential lossless, arithmetic */
73
74     DHT   = 0xc4,       /* define huffman tables */
75
76     DAC   = 0xcc,       /* define arithmetic-coding conditioning */
77
78     /* restart with modulo 8 count "m" */
79     RST0  = 0xd0,
80     RST1  = 0xd1,
81     RST2  = 0xd2,
82     RST3  = 0xd3,
83     RST4  = 0xd4,
84     RST5  = 0xd5,
85     RST6  = 0xd6,
86     RST7  = 0xd7,
87
88     SOI   = 0xd8,       /* start of image */
89     EOI   = 0xd9,       /* end of image */
90     SOS   = 0xda,       /* start of scan */
91     DQT   = 0xdb,       /* define quantization tables */
92     DNL   = 0xdc,       /* define number of lines */
93     DRI   = 0xdd,       /* define restart interval */
94     DHP   = 0xde,       /* define hierarchical progression */
95     EXP   = 0xdf,       /* expand reference components */
96
97     APP0  = 0xe0,
98     APP1  = 0xe1,
99     APP2  = 0xe2,
100     APP3  = 0xe3,
101     APP4  = 0xe4,
102     APP5  = 0xe5,
103     APP6  = 0xe6,
104     APP7  = 0xe7,
105     APP8  = 0xe8,
106     APP9  = 0xe9,
107     APP10 = 0xea,
108     APP11 = 0xeb,
109     APP12 = 0xec,
110     APP13 = 0xed,
111     APP14 = 0xee,
112     APP15 = 0xef,
113
114     JPG0  = 0xf0,
115     JPG1  = 0xf1,
116     JPG2  = 0xf2,
117     JPG3  = 0xf3,
118     JPG4  = 0xf4,
119     JPG5  = 0xf5,
120     JPG6  = 0xf6,
121     JPG7  = 0xf7,
122     JPG8  = 0xf8,
123     JPG9  = 0xf9,
124     JPG10 = 0xfa,
125     JPG11 = 0xfb,
126     JPG12 = 0xfc,
127     JPG13 = 0xfd,
128
129     COM   = 0xfe,       /* comment */
130
131     TEM   = 0x01,       /* temporary private use for arithmetic coding */
132
133     /* 0x02 -> 0xbf reserved */
134 } JPEG_MARKER;
135
136 #if 0
137 /* These are the sample quantization tables given in JPEG spec section K.1.
138  * The spec says that the values given produce "good" quality, and
139  * when divided by 2, "very good" quality.
140  */
141 static const unsigned char std_luminance_quant_tbl[64] = {
142     16,  11,  10,  16,  24,  40,  51,  61,
143     12,  12,  14,  19,  26,  58,  60,  55,
144     14,  13,  16,  24,  40,  57,  69,  56,
145     14,  17,  22,  29,  51,  87,  80,  62,
146     18,  22,  37,  56,  68, 109, 103,  77,
147     24,  35,  55,  64,  81, 104, 113,  92,
148     49,  64,  78,  87, 103, 121, 120, 101,
149     72,  92,  95,  98, 112, 100, 103,  99
150 };
151 static const unsigned char std_chrominance_quant_tbl[64] = {
152     17,  18,  24,  47,  99,  99,  99,  99,
153     18,  21,  26,  66,  99,  99,  99,  99,
154     24,  26,  56,  99,  99,  99,  99,  99,
155     47,  66,  99,  99,  99,  99,  99,  99,
156     99,  99,  99,  99,  99,  99,  99,  99,
157     99,  99,  99,  99,  99,  99,  99,  99,
158     99,  99,  99,  99,  99,  99,  99,  99,
159     99,  99,  99,  99,  99,  99,  99,  99
160 };
161 #endif
162
163 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
164 /* IMPORTANT: these are only valid for 8-bit data precision! */
165 static const uint8_t bits_dc_luminance[17] =
166 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
167 static const uint8_t val_dc_luminance[] =
168 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
169
170 static const uint8_t bits_dc_chrominance[17] =
171 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
172 static const uint8_t val_dc_chrominance[] =
173 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
174
175 static const uint8_t bits_ac_luminance[17] =
176 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
177 static const uint8_t val_ac_luminance[] =
178 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
179   0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
180   0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
181   0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
182   0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
183   0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
184   0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
185   0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
186   0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
187   0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
188   0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
189   0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
190   0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
191   0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
192   0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
193   0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
194   0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
195   0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196   0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197   0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
198   0xf9, 0xfa 
199 };
200
201 static const uint8_t bits_ac_chrominance[17] =
202 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
203
204 static const uint8_t val_ac_chrominance[] =
205 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
206   0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
207   0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
208   0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
209   0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
210   0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
211   0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
212   0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
213   0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
214   0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
215   0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
216   0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217   0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
218   0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
219   0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
220   0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
221   0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
222   0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223   0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224   0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
225   0xf9, 0xfa 
226 };
227
228 /* isn't this function nicer than the one in the libjpeg ? */
229 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
230                                 const uint8_t *bits_table, const uint8_t *val_table)
231 {
232     int i, j, k,nb, code, sym;
233
234     code = 0;
235     k = 0;
236     for(i=1;i<=16;i++) {
237         nb = bits_table[i];
238         for(j=0;j<nb;j++) {
239             sym = val_table[k++];
240             huff_size[sym] = i;
241             huff_code[sym] = code;
242             code++;
243         }
244         code <<= 1;
245     }
246 }
247
248 #ifdef CONFIG_ENCODERS
249 int mjpeg_init(MpegEncContext *s)
250 {
251     MJpegContext *m;
252     
253     m = av_malloc(sizeof(MJpegContext));
254     if (!m)
255         return -1;
256     
257     s->min_qcoeff=-1023;
258     s->max_qcoeff= 1023;
259
260     /* build all the huffman tables */
261     build_huffman_codes(m->huff_size_dc_luminance,
262                         m->huff_code_dc_luminance,
263                         bits_dc_luminance,
264                         val_dc_luminance);
265     build_huffman_codes(m->huff_size_dc_chrominance,
266                         m->huff_code_dc_chrominance,
267                         bits_dc_chrominance,
268                         val_dc_chrominance);
269     build_huffman_codes(m->huff_size_ac_luminance,
270                         m->huff_code_ac_luminance,
271                         bits_ac_luminance,
272                         val_ac_luminance);
273     build_huffman_codes(m->huff_size_ac_chrominance,
274                         m->huff_code_ac_chrominance,
275                         bits_ac_chrominance,
276                         val_ac_chrominance);
277     
278     s->mjpeg_ctx = m;
279     return 0;
280 }
281
282 void mjpeg_close(MpegEncContext *s)
283 {
284     av_free(s->mjpeg_ctx);
285 }
286 #endif //CONFIG_ENCODERS
287
288 #define PREDICT(ret, topleft, top, left, predictor)\
289     switch(predictor){\
290         case 1: ret= left; break;\
291         case 2: ret= top; break;\
292         case 3: ret= topleft; break;\
293         case 4: ret= left   +   top - topleft; break;\
294         case 5: ret= left   + ((top - topleft)>>1); break;\
295         case 6: ret= top + ((left   - topleft)>>1); break;\
296         default:\
297         case 7: ret= (left + top)>>1; break;\
298     }
299
300 #ifdef CONFIG_ENCODERS
301 static inline void put_marker(PutBitContext *p, int code)
302 {
303     put_bits(p, 8, 0xff);
304     put_bits(p, 8, code);
305 }
306
307 /* table_class: 0 = DC coef, 1 = AC coefs */
308 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
309                              const uint8_t *bits_table, const uint8_t *value_table)
310 {
311     PutBitContext *p = &s->pb;
312     int n, i;
313
314     put_bits(p, 4, table_class);
315     put_bits(p, 4, table_id);
316
317     n = 0;
318     for(i=1;i<=16;i++) {
319         n += bits_table[i];
320         put_bits(p, 8, bits_table[i]);
321     }
322
323     for(i=0;i<n;i++)
324         put_bits(p, 8, value_table[i]);
325
326     return n + 17;
327 }
328
329 static void jpeg_table_header(MpegEncContext *s)
330 {
331     PutBitContext *p = &s->pb;
332     int i, j, size;
333     uint8_t *ptr;
334
335     /* quant matrixes */
336     put_marker(p, DQT);
337 #ifdef TWOMATRIXES
338     put_bits(p, 16, 2 + 2 * (1 + 64));
339 #else
340     put_bits(p, 16, 2 + 1 * (1 + 64));
341 #endif
342     put_bits(p, 4, 0); /* 8 bit precision */
343     put_bits(p, 4, 0); /* table 0 */
344     for(i=0;i<64;i++) {
345         j = s->intra_scantable.permutated[i];
346         put_bits(p, 8, s->intra_matrix[j]);
347     }
348 #ifdef TWOMATRIXES
349     put_bits(p, 4, 0); /* 8 bit precision */
350     put_bits(p, 4, 1); /* table 1 */
351     for(i=0;i<64;i++) {
352         j = s->intra_scantable.permutated[i];
353         put_bits(p, 8, s->chroma_intra_matrix[j]);
354     }
355 #endif
356
357     /* huffman table */
358     put_marker(p, DHT);
359     flush_put_bits(p);
360     ptr = pbBufPtr(p);
361     put_bits(p, 16, 0); /* patched later */
362     size = 2;
363     size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364     size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
365     
366     size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367     size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
368     ptr[0] = size >> 8;
369     ptr[1] = size;
370 }
371
372 static void jpeg_put_comments(MpegEncContext *s)
373 {
374     PutBitContext *p = &s->pb;
375     int size;
376     uint8_t *ptr;
377
378     if (s->aspect_ratio_info /* && !lossless */)
379     {
380     /* JFIF header */
381     put_marker(p, APP0);
382     put_bits(p, 16, 16);
383     put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
384     put_bits(p, 16, 0x0201); /* v 1.02 */
385     put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
386     put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
387     put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
388     put_bits(p, 8, 0); /* thumbnail width */
389     put_bits(p, 8, 0); /* thumbnail height */
390     }
391
392     /* comment */
393     if(!(s->flags & CODEC_FLAG_BITEXACT)){
394         put_marker(p, COM);
395         flush_put_bits(p);
396         ptr = pbBufPtr(p);
397         put_bits(p, 16, 0); /* patched later */
398         put_string(p, LIBAVCODEC_IDENT, 1);
399         size = strlen(LIBAVCODEC_IDENT)+3;
400         ptr[0] = size >> 8;
401         ptr[1] = size;
402     }
403
404     if(  s->avctx->pix_fmt == PIX_FMT_YUV420P 
405        ||s->avctx->pix_fmt == PIX_FMT_YUV422P
406        ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
407         put_marker(p, COM);
408         flush_put_bits(p);
409         ptr = pbBufPtr(p);
410         put_bits(p, 16, 0); /* patched later */
411         put_string(p, "CS=ITU601", 1);
412         size = strlen("CS=ITU601")+3;
413         ptr[0] = size >> 8;
414         ptr[1] = size;
415     }
416 }
417
418 void mjpeg_picture_header(MpegEncContext *s)
419 {
420     const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
421
422     put_marker(&s->pb, SOI);
423
424     if (!s->mjpeg_data_only_frames)
425     {
426     jpeg_put_comments(s);    
427
428     if (s->mjpeg_write_tables) jpeg_table_header(s);
429
430     put_marker(&s->pb, lossless ? SOF3 : SOF0);
431
432     put_bits(&s->pb, 16, 17);
433     if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
434         put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
435     else
436         put_bits(&s->pb, 8, 8); /* 8 bits/component */
437     put_bits(&s->pb, 16, s->height);
438     put_bits(&s->pb, 16, s->width);
439     put_bits(&s->pb, 8, 3); /* 3 components */
440     
441     /* Y component */
442     put_bits(&s->pb, 8, 1); /* component number */
443     put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
444     put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
445     put_bits(&s->pb, 8, 0); /* select matrix */
446     
447     /* Cb component */
448     put_bits(&s->pb, 8, 2); /* component number */
449     put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
450     put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
451 #ifdef TWOMATRIXES
452     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
453 #else
454     put_bits(&s->pb, 8, 0); /* select matrix */
455 #endif
456
457     /* Cr component */
458     put_bits(&s->pb, 8, 3); /* component number */
459     put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
460     put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
461 #ifdef TWOMATRIXES
462     put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
463 #else
464     put_bits(&s->pb, 8, 0); /* select matrix */
465 #endif
466     }
467
468     /* scan header */
469     put_marker(&s->pb, SOS);
470     put_bits(&s->pb, 16, 12); /* length */
471     put_bits(&s->pb, 8, 3); /* 3 components */
472     
473     /* Y component */
474     put_bits(&s->pb, 8, 1); /* index */
475     put_bits(&s->pb, 4, 0); /* DC huffman table index */
476     put_bits(&s->pb, 4, 0); /* AC huffman table index */
477     
478     /* Cb component */
479     put_bits(&s->pb, 8, 2); /* index */
480     put_bits(&s->pb, 4, 1); /* DC huffman table index */
481     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
482     
483     /* Cr component */
484     put_bits(&s->pb, 8, 3); /* index */
485     put_bits(&s->pb, 4, 1); /* DC huffman table index */
486     put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
487
488     put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
489     put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
490     put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
491 }
492
493 static void escape_FF(MpegEncContext *s, int start)
494 {
495     int size= put_bits_count(&s->pb) - start*8;
496     int i, ff_count;
497     uint8_t *buf= s->pb.buf + start;
498     int align= (-(size_t)(buf))&3;
499     
500     assert((size&7) == 0);
501     size >>= 3;
502     
503     ff_count=0;
504     for(i=0; i<size && i<align; i++){
505         if(buf[i]==0xFF) ff_count++;
506     }
507     for(; i<size-15; i+=16){
508         int acc, v;
509
510         v= *(uint32_t*)(&buf[i]);
511         acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
512         v= *(uint32_t*)(&buf[i+4]);
513         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
514         v= *(uint32_t*)(&buf[i+8]);
515         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
516         v= *(uint32_t*)(&buf[i+12]);
517         acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
518
519         acc>>=4;
520         acc+= (acc>>16);
521         acc+= (acc>>8);
522         ff_count+= acc&0xFF;
523     }
524     for(; i<size; i++){
525         if(buf[i]==0xFF) ff_count++;
526     }
527
528     if(ff_count==0) return;
529     
530     /* skip put bits */
531     for(i=0; i<ff_count-3; i+=4)
532         put_bits(&s->pb, 32, 0);
533     put_bits(&s->pb, (ff_count-i)*8, 0);
534     flush_put_bits(&s->pb); 
535
536     for(i=size-1; ff_count; i--){
537         int v= buf[i];
538
539         if(v==0xFF){
540 //printf("%d %d\n", i, ff_count);
541             buf[i+ff_count]= 0;
542             ff_count--;
543         }
544
545         buf[i+ff_count]= v;
546     }
547 }
548
549 void ff_mjpeg_stuffing(PutBitContext * pbc)
550 {
551     int length;
552     length= (-put_bits_count(pbc))&7;
553     if(length) put_bits(pbc, length, (1<<length)-1);
554 }
555
556 void mjpeg_picture_trailer(MpegEncContext *s)
557 {
558     ff_mjpeg_stuffing(&s->pb);
559     flush_put_bits(&s->pb);
560
561     assert((s->header_bits&7)==0);
562     
563     escape_FF(s, s->header_bits>>3);
564
565     put_marker(&s->pb, EOI);
566 }
567
568 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
569                                    uint8_t *huff_size, uint16_t *huff_code)
570 {
571     int mant, nbits;
572
573     if (val == 0) {
574         put_bits(&s->pb, huff_size[0], huff_code[0]);
575     } else {
576         mant = val;
577         if (val < 0) {
578             val = -val;
579             mant--;
580         }
581         
582         nbits= av_log2_16bit(val) + 1;
583             
584         put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
585         
586         put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
587     }
588 }
589
590 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
591 {
592     int mant, nbits, code, i, j;
593     int component, dc, run, last_index, val;
594     MJpegContext *m = s->mjpeg_ctx;
595     uint8_t *huff_size_ac;
596     uint16_t *huff_code_ac;
597     
598     /* DC coef */
599     component = (n <= 3 ? 0 : n - 4 + 1);
600     dc = block[0]; /* overflow is impossible */
601     val = dc - s->last_dc[component];
602     if (n < 4) {
603         mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
604         huff_size_ac = m->huff_size_ac_luminance;
605         huff_code_ac = m->huff_code_ac_luminance;
606     } else {
607         mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
608         huff_size_ac = m->huff_size_ac_chrominance;
609         huff_code_ac = m->huff_code_ac_chrominance;
610     }
611     s->last_dc[component] = dc;
612     
613     /* AC coefs */
614     
615     run = 0;
616     last_index = s->block_last_index[n];
617     for(i=1;i<=last_index;i++) {
618         j = s->intra_scantable.permutated[i];
619         val = block[j];
620         if (val == 0) {
621             run++;
622         } else {
623             while (run >= 16) {
624                 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
625                 run -= 16;
626             }
627             mant = val;
628             if (val < 0) {
629                 val = -val;
630                 mant--;
631             }
632             
633             nbits= av_log2(val) + 1;
634             code = (run << 4) | nbits;
635
636             put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
637         
638             put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
639             run = 0;
640         }
641     }
642
643     /* output EOB only if not already 64 values */
644     if (last_index < 63 || run != 0)
645         put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
646 }
647
648 void mjpeg_encode_mb(MpegEncContext *s, 
649                      DCTELEM block[6][64])
650 {
651     int i;
652     for(i=0;i<6;i++) {
653         encode_block(s, block[i], i);
654     }
655 }
656
657 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
658     MpegEncContext * const s = avctx->priv_data;
659     MJpegContext * const m = s->mjpeg_ctx;
660     AVFrame *pict = data;
661     const int width= s->width;
662     const int height= s->height;
663     AVFrame * const p= (AVFrame*)&s->current_picture;
664     const int predictor= avctx->prediction_method+1;
665
666     init_put_bits(&s->pb, buf, buf_size);
667
668     *p = *pict;
669     p->pict_type= FF_I_TYPE;
670     p->key_frame= 1;
671     
672     mjpeg_picture_header(s);
673
674     s->header_bits= put_bits_count(&s->pb);
675     
676     if(avctx->pix_fmt == PIX_FMT_RGBA32){
677         int x, y, i;
678         const int linesize= p->linesize[0];
679         uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
680         int left[3], top[3], topleft[3];
681
682         for(i=0; i<3; i++){
683             buffer[0][i]= 1 << (9 - 1);
684         }
685
686         for(y = 0; y < height; y++) {
687             const int modified_predictor= y ? predictor : 1;
688             uint8_t *ptr = p->data[0] + (linesize * y);
689
690             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
691                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
692                 return -1;
693             }
694             
695             for(i=0; i<3; i++){
696                 top[i]= left[i]= topleft[i]= buffer[0][i];
697             }
698             for(x = 0; x < width; x++) {
699                 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
700                 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
701                 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
702
703                 for(i=0;i<3;i++) {
704                     int pred, diff;
705
706                     PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
707                         
708                     topleft[i]= top[i];
709                     top[i]= buffer[x+1][i];
710                     
711                     left[i]= buffer[x][i];
712
713                     diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
714                     
715                     if(i==0)
716                         mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
717                     else
718                         mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
719                 }
720             }
721         }
722     }else{
723         int mb_x, mb_y, i;
724         const int mb_width  = (width  + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
725         const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
726         
727         for(mb_y = 0; mb_y < mb_height; mb_y++) {
728             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
729                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
730                 return -1;
731             }
732             for(mb_x = 0; mb_x < mb_width; mb_x++) {
733                 if(mb_x==0 || mb_y==0){
734                     for(i=0;i<3;i++) {
735                         uint8_t *ptr;
736                         int x, y, h, v, linesize;
737                         h = s->mjpeg_hsample[i];
738                         v = s->mjpeg_vsample[i];
739                         linesize= p->linesize[i];
740
741                         for(y=0; y<v; y++){
742                             for(x=0; x<h; x++){
743                                 int pred;
744
745                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
746                                 if(y==0 && mb_y==0){
747                                     if(x==0 && mb_x==0){
748                                         pred= 128;
749                                     }else{
750                                         pred= ptr[-1];
751                                     }
752                                 }else{
753                                     if(x==0 && mb_x==0){
754                                         pred= ptr[-linesize];
755                                     }else{
756                                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
757                                     }
758                                 }
759                                 
760                                 if(i==0)
761                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
762                                 else
763                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
764                             }
765                         }
766                     }
767                 }else{
768                     for(i=0;i<3;i++) {
769                         uint8_t *ptr;
770                         int x, y, h, v, linesize;
771                         h = s->mjpeg_hsample[i];
772                         v = s->mjpeg_vsample[i];
773                         linesize= p->linesize[i];
774                              
775                         for(y=0; y<v; y++){
776                             for(x=0; x<h; x++){
777                                 int pred;
778
779                                 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
780 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); 
781                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
782
783                                 if(i==0)
784                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
785                                 else
786                                     mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
787                             }
788                         }
789                     }
790                 }
791             }
792         }
793     }
794
795     emms_c();
796     
797     mjpeg_picture_trailer(s);
798     s->picture_number++;
799
800     flush_put_bits(&s->pb);
801     return pbBufPtr(&s->pb) - s->pb.buf;
802 //    return (put_bits_count(&f->pb)+7)/8;
803 }
804
805 #endif //CONFIG_ENCODERS
806
807 /******************************************/
808 /* decoding */
809
810 #define MAX_COMPONENTS 4
811
812 typedef struct MJpegDecodeContext {
813     AVCodecContext *avctx;
814     GetBitContext gb;
815     int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
816
817     int start_code; /* current start code */
818     int buffer_size;
819     uint8_t *buffer;
820
821     int16_t quant_matrixes[4][64];
822     VLC vlcs[2][4];
823     int qscale[4];      ///< quantizer scale calculated from quant_matrixes
824
825     int org_height;  /* size given at codec init */
826     int first_picture;    /* true if decoding first picture */
827     int interlaced;     /* true if interlaced */
828     int bottom_field;   /* true if bottom field */
829     int lossless;
830     int rgb;
831     int rct;            /* standard rct */  
832     int pegasus_rct;    /* pegasus reversible colorspace transform */  
833     int bits;           /* bits per component */
834
835     int width, height;
836     int mb_width, mb_height;
837     int nb_components;
838     int component_id[MAX_COMPONENTS];
839     int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
840     int v_count[MAX_COMPONENTS];
841     int comp_index[MAX_COMPONENTS];
842     int dc_index[MAX_COMPONENTS];
843     int ac_index[MAX_COMPONENTS];
844     int nb_blocks[MAX_COMPONENTS];
845     int h_scount[MAX_COMPONENTS];
846     int v_scount[MAX_COMPONENTS];
847     int h_max, v_max; /* maximum h and v counts */
848     int quant_index[4];   /* quant table index for each component */
849     int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
850     AVFrame picture; /* picture structure */
851     int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
852     int8_t *qscale_table;
853     DCTELEM block[64] __align8;
854     ScanTable scantable;
855     void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
856
857     int restart_interval;
858     int restart_count;
859
860     int buggy_avid;
861     int cs_itu601;
862     int interlace_polarity;
863
864     int mjpb_skiptosod;
865 } MJpegDecodeContext;
866
867 static int mjpeg_decode_dht(MJpegDecodeContext *s);
868
869 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
870                       int nb_codes, int use_static)
871 {
872     uint8_t huff_size[256];
873     uint16_t huff_code[256];
874
875     memset(huff_size, 0, sizeof(huff_size));
876     build_huffman_codes(huff_size, huff_code, bits_table, val_table);
877     
878     return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
879 }
880
881 static int mjpeg_decode_init(AVCodecContext *avctx)
882 {
883     MJpegDecodeContext *s = avctx->priv_data;
884     MpegEncContext s2;
885     memset(s, 0, sizeof(MJpegDecodeContext));
886
887     s->avctx = avctx;
888
889     /* ugly way to get the idct & scantable FIXME */
890     memset(&s2, 0, sizeof(MpegEncContext));
891     s2.avctx= avctx;
892 //    s2->out_format = FMT_MJPEG;
893     dsputil_init(&s2.dsp, avctx);
894     DCT_common_init(&s2);
895
896     s->scantable= s2.intra_scantable;
897     s->idct_put= s2.dsp.idct_put;
898
899     s->mpeg_enc_ctx_allocated = 0;
900     s->buffer_size = 0;
901     s->buffer = NULL;
902     s->start_code = -1;
903     s->first_picture = 1;
904     s->org_height = avctx->coded_height;
905     
906     build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
907     build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
908     build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
909     build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0);
910
911     if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
912     {
913         av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
914         init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
915         mjpeg_decode_dht(s);
916         /* should check for error - but dunno */
917     }
918
919     return 0;
920 }
921
922
923 /**
924  * finds the end of the current frame in the bitstream.
925  * @return the position of the first byte of the next frame, or -1
926  */
927 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
928     int vop_found, i;
929     uint16_t state;
930     
931     vop_found= pc->frame_start_found;
932     state= pc->state;
933     
934     i=0;
935     if(!vop_found){
936         for(i=0; i<buf_size; i++){
937             state= (state<<8) | buf[i];
938             if(state == 0xFFD8){
939                 i++;
940                 vop_found=1;
941                 break;
942             }
943         }
944     }
945
946     if(vop_found){
947         /* EOF considered as end of frame */
948         if (buf_size == 0)
949             return 0;
950         for(; i<buf_size; i++){
951             state= (state<<8) | buf[i];
952             if(state == 0xFFD8){
953                 pc->frame_start_found=0;
954                 pc->state=0; 
955                 return i-1;
956             }
957         }
958     }
959     pc->frame_start_found= vop_found;
960     pc->state= state;
961     return END_NOT_FOUND;
962 }
963
964 static int jpeg_parse(AVCodecParserContext *s,
965                            AVCodecContext *avctx,
966                            uint8_t **poutbuf, int *poutbuf_size, 
967                            const uint8_t *buf, int buf_size)
968 {
969     ParseContext *pc = s->priv_data;
970     int next;
971     
972     next= find_frame_end(pc, buf, buf_size);
973
974     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
975         *poutbuf = NULL;
976         *poutbuf_size = 0;
977         return buf_size;
978     }
979
980     *poutbuf = (uint8_t *)buf;
981     *poutbuf_size = buf_size;
982     return next;
983 }
984
985 /* quantize tables */
986 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
987 {
988     int len, index, i, j;
989     
990     len = get_bits(&s->gb, 16) - 2;
991
992     while (len >= 65) {
993         /* only 8 bit precision handled */
994         if (get_bits(&s->gb, 4) != 0)
995         {
996             dprintf("dqt: 16bit precision\n");
997             return -1;
998         }
999         index = get_bits(&s->gb, 4);
1000         if (index >= 4)
1001             return -1;
1002         dprintf("index=%d\n", index);
1003         /* read quant table */
1004         for(i=0;i<64;i++) {
1005             j = s->scantable.permutated[i];
1006             s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1007         }
1008
1009         //XXX FIXME finetune, and perhaps add dc too
1010         s->qscale[index]= FFMAX(
1011             s->quant_matrixes[index][s->scantable.permutated[1]],
1012             s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1013         dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1014         len -= 65;
1015     }
1016     
1017     return 0;
1018 }
1019
1020 /* decode huffman tables and build VLC decoders */
1021 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1022 {
1023     int len, index, i, class, n, v, code_max;
1024     uint8_t bits_table[17];
1025     uint8_t val_table[256];
1026     
1027     len = get_bits(&s->gb, 16) - 2;
1028
1029     while (len > 0) {
1030         if (len < 17)
1031             return -1;
1032         class = get_bits(&s->gb, 4);
1033         if (class >= 2)
1034             return -1;
1035         index = get_bits(&s->gb, 4);
1036         if (index >= 4)
1037             return -1;
1038         n = 0;
1039         for(i=1;i<=16;i++) {
1040             bits_table[i] = get_bits(&s->gb, 8);
1041             n += bits_table[i];
1042         }
1043         len -= 17;
1044         if (len < n || n > 256)
1045             return -1;
1046
1047         code_max = 0;
1048         for(i=0;i<n;i++) {
1049             v = get_bits(&s->gb, 8);
1050             if (v > code_max)
1051                 code_max = v;
1052             val_table[i] = v;
1053         }
1054         len -= n;
1055
1056         /* build VLC and flush previous vlc if present */
1057         free_vlc(&s->vlcs[class][index]);
1058         dprintf("class=%d index=%d nb_codes=%d\n",
1059                class, index, code_max + 1);
1060         if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){
1061             return -1;
1062         }
1063     }
1064     return 0;
1065 }
1066
1067 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1068 {
1069     int len, nb_components, i, width, height;
1070
1071     /* XXX: verify len field validity */
1072     len = get_bits(&s->gb, 16);
1073     s->bits= get_bits(&s->gb, 8);
1074     
1075     if(s->pegasus_rct) s->bits=9;  
1076     if(s->bits==9 && !s->pegasus_rct) s->rct=1;    //FIXME ugly
1077
1078     if (s->bits != 8 && !s->lossless){
1079         av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1080         return -1;
1081     }
1082     height = get_bits(&s->gb, 16);
1083     width = get_bits(&s->gb, 16);
1084     
1085     dprintf("sof0: picture: %dx%d\n", width, height);
1086     if(avcodec_check_dimensions(s->avctx, width, height))
1087         return -1;
1088
1089     nb_components = get_bits(&s->gb, 8);
1090     if (nb_components <= 0 ||
1091         nb_components > MAX_COMPONENTS)
1092         return -1;
1093     s->nb_components = nb_components;
1094     s->h_max = 1;
1095     s->v_max = 1;
1096     for(i=0;i<nb_components;i++) {
1097         /* component id */
1098         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1099         s->h_count[i] = get_bits(&s->gb, 4);
1100         s->v_count[i] = get_bits(&s->gb, 4);
1101         /* compute hmax and vmax (only used in interleaved case) */
1102         if (s->h_count[i] > s->h_max)
1103             s->h_max = s->h_count[i];
1104         if (s->v_count[i] > s->v_max)
1105             s->v_max = s->v_count[i];
1106         s->quant_index[i] = get_bits(&s->gb, 8);
1107         if (s->quant_index[i] >= 4)
1108             return -1;
1109         dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1110             s->v_count[i], s->component_id[i], s->quant_index[i]);
1111     }
1112     
1113     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1114
1115     /* if different size, realloc/alloc picture */
1116     /* XXX: also check h_count and v_count */
1117     if (width != s->width || height != s->height) {
1118         av_freep(&s->qscale_table);
1119             
1120         s->width = width;
1121         s->height = height;
1122         avcodec_set_dimensions(s->avctx, width, height);
1123
1124         /* test interlaced mode */
1125         if (s->first_picture &&
1126             s->org_height != 0 &&
1127             s->height < ((s->org_height * 3) / 4)) {
1128             s->interlaced = 1;
1129 //          s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1130             s->bottom_field = 0;
1131             s->avctx->height *= 2;
1132         }
1133
1134         s->qscale_table= av_mallocz((s->width+15)/16);
1135
1136         s->first_picture = 0;
1137     }
1138     
1139     if(s->interlaced && s->bottom_field)
1140         return 0;
1141  
1142     /* XXX: not complete test ! */
1143     switch((s->h_count[0] << 4) | s->v_count[0]) {
1144     case 0x11:
1145         if(s->rgb){
1146             s->avctx->pix_fmt = PIX_FMT_RGBA32;
1147         }else if(s->nb_components==3)
1148             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1149         else
1150             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1151         break;
1152     case 0x21:
1153         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1154         break;
1155     default:
1156     case 0x22:
1157         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1158         break;
1159     }
1160
1161     if(s->picture.data[0])
1162         s->avctx->release_buffer(s->avctx, &s->picture);
1163
1164     s->picture.reference= 0;
1165     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1166         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1167         return -1;
1168     }
1169     s->picture.pict_type= I_TYPE;
1170     s->picture.key_frame= 1;
1171     
1172     for(i=0; i<3; i++){
1173         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1174     }
1175
1176 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1177     
1178     if (len != (8+(3*nb_components)))
1179     {
1180         dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1181     }
1182     
1183     return 0;
1184 }
1185
1186 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1187 {
1188     int code;
1189     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1190     if (code < 0)
1191     {
1192         dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1193                 &s->vlcs[0][dc_index]);
1194         return 0xffff;
1195     }
1196
1197     if(code)
1198         return get_xbits(&s->gb, code);
1199     else
1200         return 0;
1201 }
1202
1203 /* decode block and dequantize */
1204 static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1205                         int component, int dc_index, int ac_index, int quant_index)
1206 {
1207     int code, i, j, level, val;
1208     VLC *ac_vlc;
1209     int16_t *quant_matrix;
1210
1211     /* DC coef */
1212     val = mjpeg_decode_dc(s, dc_index);
1213     if (val == 0xffff) {
1214         dprintf("error dc\n");
1215         return -1;
1216     }
1217     quant_matrix = s->quant_matrixes[quant_index];
1218     val = val * quant_matrix[0] + s->last_dc[component];
1219     s->last_dc[component] = val;
1220     block[0] = val;
1221     /* AC coefs */
1222     ac_vlc = &s->vlcs[1][ac_index];
1223     i = 1;
1224     for(;;) {
1225         code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1226
1227         if (code < 0) {
1228             dprintf("error ac\n");
1229             return -1;
1230         }
1231         /* EOB */
1232         if (code == 0)
1233             break;
1234         if (code == 0xf0) {
1235             i += 16;
1236         } else {
1237             level = get_xbits(&s->gb, code & 0xf);
1238             i += code >> 4;
1239             if (i >= 64) {
1240                 dprintf("error count: %d\n", i);
1241                 return -1;
1242             }
1243             j = s->scantable.permutated[i];
1244             block[j] = level * quant_matrix[j];
1245             i++;
1246             if (i >= 64)
1247                 break;
1248         }
1249     }
1250     return 0;
1251 }
1252
1253 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1254     int i, mb_x, mb_y;
1255     uint16_t buffer[32768][4];
1256     int left[3], top[3], topleft[3];
1257     const int linesize= s->linesize[0];
1258     const int mask= (1<<s->bits)-1;
1259     
1260     if((unsigned)s->mb_width > 32768) //dynamic alloc
1261         return -1;
1262     
1263     for(i=0; i<3; i++){
1264         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1265     }
1266     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1267         const int modified_predictor= mb_y ? predictor : 1;
1268         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1269
1270         if (s->interlaced && s->bottom_field)
1271             ptr += linesize >> 1;
1272
1273         for(i=0; i<3; i++){
1274             top[i]= left[i]= topleft[i]= buffer[0][i];
1275         }
1276         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1277             if (s->restart_interval && !s->restart_count)
1278                 s->restart_count = s->restart_interval;
1279
1280             for(i=0;i<3;i++) {
1281                 int pred;
1282
1283                 topleft[i]= top[i];
1284                 top[i]= buffer[mb_x][i];
1285
1286                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1287                 
1288                 left[i]= 
1289                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1290             }
1291
1292             if (s->restart_interval && !--s->restart_count) {
1293                 align_get_bits(&s->gb);
1294                 skip_bits(&s->gb, 16); /* skip RSTn */
1295             }
1296         }
1297
1298         if(s->rct){
1299             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1300                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1301                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1302                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1303             }
1304         }else if(s->pegasus_rct){
1305             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1306                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1307                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1308                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1309             }
1310         }else{
1311             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1312                 ptr[4*mb_x+0] = buffer[mb_x][0];
1313                 ptr[4*mb_x+1] = buffer[mb_x][1];
1314                 ptr[4*mb_x+2] = buffer[mb_x][2];
1315             }
1316         }
1317     }
1318     return 0;
1319 }
1320
1321 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1322     int i, mb_x, mb_y;
1323     const int nb_components=3;
1324
1325     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1326         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1327             if (s->restart_interval && !s->restart_count)
1328                 s->restart_count = s->restart_interval;
1329
1330             if(mb_x==0 || mb_y==0 || s->interlaced){
1331                 for(i=0;i<nb_components;i++) {
1332                     uint8_t *ptr;
1333                     int n, h, v, x, y, c, j, linesize;
1334                     n = s->nb_blocks[i];
1335                     c = s->comp_index[i];
1336                     h = s->h_scount[i];
1337                     v = s->v_scount[i];
1338                     x = 0;
1339                     y = 0;
1340                     linesize= s->linesize[c];
1341                     
1342                     for(j=0; j<n; j++) {
1343                         int pred;
1344
1345                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1346                         if(y==0 && mb_y==0){
1347                             if(x==0 && mb_x==0){
1348                                 pred= 128 << point_transform;
1349                             }else{
1350                                 pred= ptr[-1];
1351                             }
1352                         }else{
1353                             if(x==0 && mb_x==0){
1354                                 pred= ptr[-linesize];
1355                             }else{
1356                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1357                             }
1358                         }
1359                         
1360                         if (s->interlaced && s->bottom_field)
1361                             ptr += linesize >> 1;
1362                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1363
1364                         if (++x == h) {
1365                             x = 0;
1366                             y++;
1367                         }
1368                     }
1369                 }
1370             }else{
1371                 for(i=0;i<nb_components;i++) {
1372                     uint8_t *ptr;
1373                     int n, h, v, x, y, c, j, linesize;
1374                     n = s->nb_blocks[i];
1375                     c = s->comp_index[i];
1376                     h = s->h_scount[i];
1377                     v = s->v_scount[i];
1378                     x = 0;
1379                     y = 0;
1380                     linesize= s->linesize[c];
1381                     
1382                     for(j=0; j<n; j++) {
1383                         int pred;
1384
1385                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1386                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1387                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1388                         if (++x == h) {
1389                             x = 0;
1390                             y++;
1391                         }
1392                     }
1393                 }
1394             }
1395             if (s->restart_interval && !--s->restart_count) {
1396                 align_get_bits(&s->gb);
1397                 skip_bits(&s->gb, 16); /* skip RSTn */
1398             }
1399         }
1400     }
1401     return 0;
1402 }
1403
1404 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1405     int i, mb_x, mb_y;
1406     const int nb_components=3;
1407
1408     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1409         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1410             if (s->restart_interval && !s->restart_count)
1411                 s->restart_count = s->restart_interval;
1412
1413             for(i=0;i<nb_components;i++) {
1414                 uint8_t *ptr;
1415                 int n, h, v, x, y, c, j;
1416                 n = s->nb_blocks[i];
1417                 c = s->comp_index[i];
1418                 h = s->h_scount[i];
1419                 v = s->v_scount[i];
1420                 x = 0;
1421                 y = 0;
1422                 for(j=0;j<n;j++) {
1423                     memset(s->block, 0, sizeof(s->block));
1424                     if (decode_block(s, s->block, i, 
1425                                      s->dc_index[i], s->ac_index[i], 
1426                                      s->quant_index[c]) < 0) {
1427                         dprintf("error y=%d x=%d\n", mb_y, mb_x);
1428                         return -1;
1429                     }
1430 //                  dprintf("mb: %d %d processed\n", mb_y, mb_x);
1431                     ptr = s->picture.data[c] + 
1432                         (((s->linesize[c] * (v * mb_y + y) * 8) + 
1433                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1434                     if (s->interlaced && s->bottom_field)
1435                         ptr += s->linesize[c] >> 1;
1436 //av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1437                     s->idct_put(ptr, s->linesize[c], s->block);
1438                     if (++x == h) {
1439                         x = 0;
1440                         y++;
1441                     }
1442                 }
1443             }
1444             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1445             if (s->restart_interval && (s->restart_interval < 1350) &&
1446                 !--s->restart_count) {
1447                 align_get_bits(&s->gb);
1448                 skip_bits(&s->gb, 16); /* skip RSTn */
1449                 for (i=0; i<nb_components; i++) /* reset dc */
1450                     s->last_dc[i] = 1024;
1451             }
1452         }
1453     }
1454     return 0;
1455 }
1456
1457 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1458 {
1459     int len, nb_components, i, h, v, predictor, point_transform;
1460     int vmax, hmax, index, id;
1461     const int block_size= s->lossless ? 1 : 8;
1462
1463     /* XXX: verify len field validity */
1464     len = get_bits(&s->gb, 16);
1465     nb_components = get_bits(&s->gb, 8);
1466     if (len != 6+2*nb_components)
1467     {
1468         dprintf("decode_sos: invalid len (%d)\n", len);
1469         return -1;
1470     }
1471     /* XXX: only interleaved scan accepted */
1472     if (nb_components != s->nb_components)
1473     {
1474         dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1475         return -1;
1476     }
1477     vmax = 0;
1478     hmax = 0;
1479     for(i=0;i<nb_components;i++) {
1480         id = get_bits(&s->gb, 8) - 1;
1481         dprintf("component: %d\n", id);
1482         /* find component index */
1483         for(index=0;index<s->nb_components;index++)
1484             if (id == s->component_id[index])
1485                 break;
1486         if (index == s->nb_components)
1487         {
1488             dprintf("decode_sos: index(%d) out of components\n", index);
1489             return -1;
1490         }
1491
1492         s->comp_index[i] = index;
1493
1494         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1495         s->h_scount[i] = s->h_count[index];
1496         s->v_scount[i] = s->v_count[index];
1497
1498         s->dc_index[i] = get_bits(&s->gb, 4);
1499         s->ac_index[i] = get_bits(&s->gb, 4);
1500
1501         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1502             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1503             goto out_of_range;
1504 #if 0 //buggy
1505         switch(s->start_code)
1506         {
1507             case SOF0:
1508                 if (dc_index[i] > 1 || ac_index[i] > 1)
1509                     goto out_of_range;
1510                 break;
1511             case SOF1:
1512             case SOF2:
1513                 if (dc_index[i] > 3 || ac_index[i] > 3)
1514                     goto out_of_range;
1515                 break;
1516             case SOF3:
1517                 if (dc_index[i] > 3 || ac_index[i] != 0)
1518                     goto out_of_range;
1519                 break;  
1520         }
1521 #endif
1522     }
1523
1524     predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1525     skip_bits(&s->gb, 8); /* Se */
1526     skip_bits(&s->gb, 4); /* Ah */
1527     point_transform= get_bits(&s->gb, 4); /* Al */
1528
1529     for(i=0;i<nb_components;i++) 
1530         s->last_dc[i] = 1024;
1531
1532     if (nb_components > 1) {
1533         /* interleaved stream */
1534         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1535         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1536     } else {
1537         h = s->h_max / s->h_scount[s->comp_index[0]];
1538         v = s->v_max / s->v_scount[s->comp_index[0]];
1539         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1540         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1541         s->nb_blocks[0] = 1;
1542         s->h_scount[0] = 1;
1543         s->v_scount[0] = 1;
1544     }
1545
1546     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1547         av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1548     
1549     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1550     for (i = s->mjpb_skiptosod; i > 0; i--)
1551         skip_bits(&s->gb, 8);
1552
1553     if(s->lossless){
1554             if(s->rgb){
1555                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1556                     return -1;
1557             }else{
1558                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1559                     return -1;
1560             }
1561     }else{
1562         if(mjpeg_decode_scan(s) < 0)
1563             return -1;
1564     }
1565     emms_c();
1566     return 0;
1567  out_of_range:
1568     dprintf("decode_sos: ac/dc index out of range\n");
1569     return -1;
1570 }
1571
1572 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1573 {
1574     if (get_bits(&s->gb, 16) != 4)
1575         return -1;
1576     s->restart_interval = get_bits(&s->gb, 16);
1577     s->restart_count = 0;
1578     dprintf("restart interval: %d\n", s->restart_interval);
1579
1580     return 0;
1581 }
1582
1583 static int mjpeg_decode_app(MJpegDecodeContext *s)
1584 {
1585     int len, id;
1586
1587     len = get_bits(&s->gb, 16);
1588     if (len < 5)
1589         return -1;
1590     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1591         return -1;
1592
1593     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1594     id = be2me_32(id);
1595     len -= 6;
1596
1597     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1598         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id); 
1599     }
1600     
1601     /* buggy AVID, it puts EOI only at every 10th frame */
1602     /* also this fourcc is used by non-avid files too, it holds some
1603        informations, but it's always present in AVID creates files */
1604     if (id == ff_get_fourcc("AVI1"))
1605     {
1606         /* structure:
1607             4bytes      AVI1
1608             1bytes      polarity
1609             1bytes      always zero
1610             4bytes      field_size
1611             4bytes      field_size_less_padding
1612         */
1613         s->buggy_avid = 1;
1614 //      if (s->first_picture)
1615 //          printf("mjpeg: workarounding buggy AVID\n");
1616         s->interlace_polarity = get_bits(&s->gb, 8);
1617 #if 0
1618         skip_bits(&s->gb, 8);
1619         skip_bits(&s->gb, 32);
1620         skip_bits(&s->gb, 32);
1621         len -= 10;
1622 #endif
1623 //      if (s->interlace_polarity)
1624 //          printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1625         goto out;
1626     }
1627     
1628 //    len -= 2;
1629     
1630     if (id == ff_get_fourcc("JFIF"))
1631     {
1632         int t_w, t_h, v1, v2;
1633         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1634         v1= get_bits(&s->gb, 8);
1635         v2= get_bits(&s->gb, 8);
1636         skip_bits(&s->gb, 8);
1637
1638         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1639         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1640
1641         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1642             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1643                 v1, v2,
1644                 s->avctx->sample_aspect_ratio.num,
1645                 s->avctx->sample_aspect_ratio.den
1646             );
1647
1648         t_w = get_bits(&s->gb, 8);
1649         t_h = get_bits(&s->gb, 8);
1650         if (t_w && t_h)
1651         {
1652             /* skip thumbnail */
1653             if (len-10-(t_w*t_h*3) > 0)
1654                 len -= t_w*t_h*3;
1655         }
1656         len -= 10;
1657         goto out;
1658     }
1659     
1660     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1661     {
1662         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1663             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1664         skip_bits(&s->gb, 16); /* version */
1665         skip_bits(&s->gb, 16); /* flags0 */
1666         skip_bits(&s->gb, 16); /* flags1 */
1667         skip_bits(&s->gb, 8); /* transform */
1668         len -= 7;
1669         goto out;
1670     }
1671
1672     if (id == ff_get_fourcc("LJIF")){
1673         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1674             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1675         skip_bits(&s->gb, 16); /* version ? */
1676         skip_bits(&s->gb, 16); /* unknwon always 0? */
1677         skip_bits(&s->gb, 16); /* unknwon always 0? */
1678         skip_bits(&s->gb, 16); /* unknwon always 0? */
1679         switch( get_bits(&s->gb, 8)){
1680         case 1:
1681             s->rgb= 1;
1682             s->pegasus_rct=0;
1683             break;
1684         case 2:
1685             s->rgb= 1;
1686             s->pegasus_rct=1;
1687             break;
1688         default:
1689             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1690         }
1691         len -= 9;
1692         goto out;
1693     }
1694     
1695     /* Apple MJPEG-A */
1696     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1697     {
1698         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1699         id = be2me_32(id);
1700         len -= 4;
1701         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1702         {
1703 #if 0
1704             skip_bits(&s->gb, 32); /* field size */
1705             skip_bits(&s->gb, 32); /* pad field size */
1706             skip_bits(&s->gb, 32); /* next off */
1707             skip_bits(&s->gb, 32); /* quant off */
1708             skip_bits(&s->gb, 32); /* huff off */
1709             skip_bits(&s->gb, 32); /* image off */
1710             skip_bits(&s->gb, 32); /* scan off */
1711             skip_bits(&s->gb, 32); /* data off */
1712 #endif
1713             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1715         }
1716     }
1717
1718 out:
1719     /* slow but needed for extreme adobe jpegs */
1720     if (len < 0)
1721         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1722     while(--len > 0)
1723         skip_bits(&s->gb, 8);
1724
1725     return 0;
1726 }
1727
1728 static int mjpeg_decode_com(MJpegDecodeContext *s)
1729 {
1730     int len = get_bits(&s->gb, 16);
1731     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1732         uint8_t *cbuf = av_malloc(len - 1);
1733         if (cbuf) {
1734             int i;
1735             for (i = 0; i < len - 2; i++)
1736                 cbuf[i] = get_bits(&s->gb, 8);
1737             if (i > 0 && cbuf[i-1] == '\n')
1738                 cbuf[i-1] = 0;
1739             else
1740                 cbuf[i] = 0;
1741
1742             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1743                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1744
1745             /* buggy avid, it puts EOI only at every 10th frame */
1746             if (!strcmp(cbuf, "AVID"))
1747             {
1748                 s->buggy_avid = 1;
1749                 //      if (s->first_picture)
1750                 //          printf("mjpeg: workarounding buggy AVID\n");
1751             }
1752             else if(!strcmp(cbuf, "CS=ITU601")){
1753                 s->cs_itu601= 1;
1754             }
1755
1756             av_free(cbuf);
1757         }
1758     }
1759
1760     return 0;
1761 }
1762
1763 #if 0
1764 static int valid_marker_list[] =
1765 {
1766         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1767 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1768 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1769 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1770 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1771 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1772 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1774 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1775 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1776 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1777 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1778 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1779 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1780 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1781 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1782 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1783 }
1784 #endif
1785
1786 /* return the 8 bit start code value and update the search
1787    state. Return -1 if no start code found */
1788 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1789 {
1790     uint8_t *buf_ptr;
1791     unsigned int v, v2;
1792     int val;
1793 #ifdef DEBUG
1794     int skipped=0;
1795 #endif
1796
1797     buf_ptr = *pbuf_ptr;
1798     while (buf_ptr < buf_end) {
1799         v = *buf_ptr++;
1800         v2 = *buf_ptr;
1801         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1802             val = *buf_ptr++;
1803             goto found;
1804         }
1805 #ifdef DEBUG
1806         skipped++;
1807 #endif
1808     }
1809     val = -1;
1810 found:
1811 #ifdef DEBUG
1812     dprintf("find_marker skipped %d bytes\n", skipped);
1813 #endif
1814     *pbuf_ptr = buf_ptr;
1815     return val;
1816 }
1817
1818 static int mjpeg_decode_frame(AVCodecContext *avctx, 
1819                               void *data, int *data_size,
1820                               uint8_t *buf, int buf_size)
1821 {
1822     MJpegDecodeContext *s = avctx->priv_data;
1823     uint8_t *buf_end, *buf_ptr;
1824     int start_code;
1825     AVFrame *picture = data;
1826
1827     buf_ptr = buf;
1828     buf_end = buf + buf_size;
1829     while (buf_ptr < buf_end) {
1830         /* find start next marker */
1831         start_code = find_marker(&buf_ptr, buf_end);
1832         {
1833             /* EOF */
1834             if (start_code < 0) {
1835                 goto the_end;
1836             } else {
1837                 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1838                 
1839                 if ((buf_end - buf_ptr) > s->buffer_size)
1840                 {
1841                     av_free(s->buffer);
1842                     s->buffer_size = buf_end-buf_ptr;
1843                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1844                     dprintf("buffer too small, expanding to %d bytes\n",
1845                         s->buffer_size);
1846                 }
1847                 
1848                 /* unescape buffer of SOS */
1849                 if (start_code == SOS)
1850                 {
1851                     uint8_t *src = buf_ptr;
1852                     uint8_t *dst = s->buffer;
1853
1854                     while (src<buf_end)
1855                     {
1856                         uint8_t x = *(src++);
1857
1858                         *(dst++) = x;
1859                         if (x == 0xff)
1860                         {
1861                             while(src<buf_end && x == 0xff)
1862                                 x = *(src++);
1863
1864                             if (x >= 0xd0 && x <= 0xd7)
1865                                 *(dst++) = x;
1866                             else if (x)
1867                                 break;
1868                         }
1869                     }
1870                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1871                     
1872                     dprintf("escaping removed %d bytes\n",
1873                         (buf_end - buf_ptr) - (dst - s->buffer));
1874                 }
1875                 else
1876                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1877                 
1878                 s->start_code = start_code;
1879                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1880                     av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1881                 }
1882
1883                 /* process markers */
1884                 if (start_code >= 0xd0 && start_code <= 0xd7) {
1885                     dprintf("restart marker: %d\n", start_code&0x0f);
1886                     /* APP fields */
1887                 } else if (start_code >= APP0 && start_code <= APP15) {
1888                     mjpeg_decode_app(s);
1889                     /* Comment */
1890                 } else if (start_code == COM){
1891                     mjpeg_decode_com(s);
1892                 }
1893
1894                 switch(start_code) {
1895                 case SOI:
1896                     s->restart_interval = 0;
1897                     s->restart_count = 0;
1898                     /* nothing to do on SOI */
1899                     break;
1900                 case DQT:
1901                     mjpeg_decode_dqt(s);
1902                     break;
1903                 case DHT:
1904                     if(mjpeg_decode_dht(s) < 0){
1905                         av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1906                         return -1;
1907                     }
1908                     break;
1909                 case SOF0:
1910                     s->lossless=0;
1911                     if (mjpeg_decode_sof(s) < 0) 
1912                         return -1;
1913                     break;
1914                 case SOF3:
1915                     s->lossless=1;
1916                     if (mjpeg_decode_sof(s) < 0) 
1917                         return -1;
1918                     break;
1919                 case EOI:
1920                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval) 
1921                         break;
1922 eoi_parser:
1923                     {
1924                         if (s->interlaced) {
1925                             s->bottom_field ^= 1;
1926                             /* if not bottom field, do not output image yet */
1927                             if (s->bottom_field)
1928                                 goto not_the_end;
1929                         }
1930                         *picture = s->picture;
1931                         *data_size = sizeof(AVFrame);
1932
1933                         if(!s->lossless){
1934                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
1935                             picture->qstride= 0;
1936                             picture->qscale_table= s->qscale_table;
1937                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1938                             if(avctx->debug & FF_DEBUG_QP)
1939                                 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1940                             picture->quality*= FF_QP2LAMBDA;
1941                         }
1942                         
1943                         goto the_end;
1944                     }
1945                     break;
1946                 case SOS:
1947                     mjpeg_decode_sos(s);
1948                     /* buggy avid puts EOI every 10-20th frame */
1949                     /* if restart period is over process EOI */
1950                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1951                         goto eoi_parser;
1952                     break;
1953                 case DRI:
1954                     mjpeg_decode_dri(s);
1955                     break;
1956                 case SOF1:
1957                 case SOF2:
1958                 case SOF5:
1959                 case SOF6:
1960                 case SOF7:
1961                 case SOF9:
1962                 case SOF10:
1963                 case SOF11:
1964                 case SOF13:
1965                 case SOF14:
1966                 case SOF15:
1967                 case JPG:
1968                     av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1969                     break;
1970 //              default:
1971 //                  printf("mjpeg: unsupported marker (%x)\n", start_code);
1972 //                  break;
1973                 }
1974
1975 not_the_end:
1976                 /* eof process start code */
1977                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1978                 dprintf("marker parser used %d bytes (%d bits)\n",
1979                     (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1980             }
1981         }
1982     }
1983 the_end:
1984     dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1985 //    return buf_end - buf_ptr;
1986     return buf_ptr - buf;
1987 }
1988
1989 static int mjpegb_decode_frame(AVCodecContext *avctx, 
1990                               void *data, int *data_size,
1991                               uint8_t *buf, int buf_size)
1992 {
1993     MJpegDecodeContext *s = avctx->priv_data;
1994     uint8_t *buf_end, *buf_ptr;
1995     AVFrame *picture = data;
1996     GetBitContext hgb; /* for the header */
1997     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1998     uint32_t field_size, sod_offs;
1999
2000     buf_ptr = buf;
2001     buf_end = buf + buf_size;
2002     
2003 read_header:
2004     /* reset on every SOI */
2005     s->restart_interval = 0;
2006     s->restart_count = 0;
2007     s->mjpb_skiptosod = 0;
2008
2009     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2010
2011     skip_bits(&hgb, 32); /* reserved zeros */
2012     
2013     if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2014     {
2015         dprintf("not mjpeg-b (bad fourcc)\n");
2016         return 0;
2017     }
2018
2019     field_size = get_bits_long(&hgb, 32); /* field size */
2020     dprintf("field size: 0x%x\n", field_size);
2021     skip_bits(&hgb, 32); /* padded field size */
2022     second_field_offs = get_bits_long(&hgb, 32);
2023     dprintf("second field offs: 0x%x\n", second_field_offs);
2024     if (second_field_offs)
2025         s->interlaced = 1;
2026
2027     dqt_offs = get_bits_long(&hgb, 32);
2028     dprintf("dqt offs: 0x%x\n", dqt_offs);
2029     if (dqt_offs)
2030     {
2031         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2032         s->start_code = DQT;
2033         mjpeg_decode_dqt(s);
2034     }
2035     
2036     dht_offs = get_bits_long(&hgb, 32);
2037     dprintf("dht offs: 0x%x\n", dht_offs);
2038     if (dht_offs)
2039     {
2040         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2041         s->start_code = DHT;
2042         mjpeg_decode_dht(s);
2043     }
2044
2045     sof_offs = get_bits_long(&hgb, 32);
2046     dprintf("sof offs: 0x%x\n", sof_offs);
2047     if (sof_offs)
2048     {
2049         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2050         s->start_code = SOF0;
2051         if (mjpeg_decode_sof(s) < 0)
2052             return -1;
2053     }
2054
2055     sos_offs = get_bits_long(&hgb, 32);
2056     dprintf("sos offs: 0x%x\n", sos_offs);
2057     sod_offs = get_bits_long(&hgb, 32);
2058     dprintf("sod offs: 0x%x\n", sod_offs);
2059     if (sos_offs)
2060     {
2061 //      init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2062         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2063         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2064         s->start_code = SOS;
2065         mjpeg_decode_sos(s);
2066     }
2067
2068     if (s->interlaced) {
2069         s->bottom_field ^= 1;
2070         /* if not bottom field, do not output image yet */
2071         if (s->bottom_field && second_field_offs)
2072         {
2073             buf_ptr = buf + second_field_offs;
2074             second_field_offs = 0;
2075             goto read_header;
2076         }
2077     }
2078
2079     //XXX FIXME factorize, this looks very similar to the EOI code
2080
2081     *picture= s->picture;
2082     *data_size = sizeof(AVFrame);
2083     
2084     if(!s->lossless){
2085         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]); 
2086         picture->qstride= 0;
2087         picture->qscale_table= s->qscale_table;
2088         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2089         if(avctx->debug & FF_DEBUG_QP)
2090             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2091         picture->quality*= FF_QP2LAMBDA;
2092     }
2093
2094     return buf_ptr - buf;
2095 }
2096
2097 #include "sp5x.h"
2098
2099 static int sp5x_decode_frame(AVCodecContext *avctx, 
2100                               void *data, int *data_size,
2101                               uint8_t *buf, int buf_size)
2102 {
2103 #if 0
2104     MJpegDecodeContext *s = avctx->priv_data;
2105 #endif
2106     const int qscale = 5;
2107     uint8_t *buf_ptr, *buf_end, *recoded;
2108     int i = 0, j = 0;
2109
2110     if (!avctx->width || !avctx->height)
2111         return -1;
2112
2113     buf_ptr = buf;
2114     buf_end = buf + buf_size;
2115
2116 #if 1
2117     recoded = av_mallocz(buf_size + 1024);
2118     if (!recoded)
2119         return -1;
2120
2121     /* SOI */
2122     recoded[j++] = 0xFF;
2123     recoded[j++] = 0xD8;
2124
2125     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2126     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2127     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2128     j += sizeof(sp5x_data_dqt);
2129
2130     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2131     j += sizeof(sp5x_data_dht);
2132
2133     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2134     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2135     recoded[j+6] = avctx->coded_height & 0xFF;
2136     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2137     recoded[j+8] = avctx->coded_width & 0xFF;
2138     j += sizeof(sp5x_data_sof);
2139
2140     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2141     j += sizeof(sp5x_data_sos);
2142
2143     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2144     {
2145         recoded[j++] = buf[i];
2146         if (buf[i] == 0xff)
2147             recoded[j++] = 0;
2148     }
2149
2150     /* EOI */
2151     recoded[j++] = 0xFF;
2152     recoded[j++] = 0xD9;
2153
2154     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2155
2156     av_free(recoded);
2157
2158 #else
2159     /* SOF */
2160     s->bits = 8;
2161     s->width  = avctx->coded_width;
2162     s->height = avctx->coded_height;
2163     s->nb_components = 3;
2164     s->component_id[0] = 0;
2165     s->h_count[0] = 2;
2166     s->v_count[0] = 2;
2167     s->quant_index[0] = 0;
2168     s->component_id[1] = 1;
2169     s->h_count[1] = 1;
2170     s->v_count[1] = 1;
2171     s->quant_index[1] = 1;
2172     s->component_id[2] = 2;
2173     s->h_count[2] = 1;
2174     s->v_count[2] = 1;
2175     s->quant_index[2] = 1;
2176     s->h_max = 2;
2177     s->v_max = 2;
2178     
2179     s->qscale_table = av_mallocz((s->width+15)/16);
2180     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2181     s->interlaced = 0;
2182     
2183     s->picture.reference = 0;
2184     if (avctx->get_buffer(avctx, &s->picture) < 0)
2185     {
2186         fprintf(stderr, "get_buffer() failed\n");
2187         return -1;
2188     }
2189
2190     s->picture.pict_type = I_TYPE;
2191     s->picture.key_frame = 1;
2192
2193     for (i = 0; i < 3; i++)
2194         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2195
2196     /* DQT */
2197     for (i = 0; i < 64; i++)
2198     {
2199         j = s->scantable.permutated[i];
2200         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2201     }
2202     s->qscale[0] = FFMAX(
2203         s->quant_matrixes[0][s->scantable.permutated[1]],
2204         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2205
2206     for (i = 0; i < 64; i++)
2207     {
2208         j = s->scantable.permutated[i];
2209         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2210     }
2211     s->qscale[1] = FFMAX(
2212         s->quant_matrixes[1][s->scantable.permutated[1]],
2213         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2214
2215     /* DHT */
2216
2217     /* SOS */
2218     s->comp_index[0] = 0;
2219     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2220     s->h_scount[0] = s->h_count[0];
2221     s->v_scount[0] = s->v_count[0];
2222     s->dc_index[0] = 0;
2223     s->ac_index[0] = 0;
2224
2225     s->comp_index[1] = 1;
2226     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2227     s->h_scount[1] = s->h_count[1];
2228     s->v_scount[1] = s->v_count[1];
2229     s->dc_index[1] = 1;
2230     s->ac_index[1] = 1;
2231
2232     s->comp_index[2] = 2;
2233     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2234     s->h_scount[2] = s->h_count[2];
2235     s->v_scount[2] = s->v_count[2];
2236     s->dc_index[2] = 1;
2237     s->ac_index[2] = 1;
2238     
2239     for (i = 0; i < 3; i++)
2240         s->last_dc[i] = 1024;
2241
2242     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2243     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2244
2245     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2246     
2247     return mjpeg_decode_scan(s);
2248 #endif
2249
2250     return i;
2251 }
2252
2253 static int mjpeg_decode_end(AVCodecContext *avctx)
2254 {
2255     MJpegDecodeContext *s = avctx->priv_data;
2256     int i, j;
2257
2258     av_free(s->buffer);
2259     av_free(s->qscale_table);
2260     
2261     for(i=0;i<2;i++) {
2262         for(j=0;j<4;j++)
2263             free_vlc(&s->vlcs[i][j]);
2264     }
2265     return 0;
2266 }
2267
2268 AVCodec mjpeg_decoder = {
2269     "mjpeg",
2270     CODEC_TYPE_VIDEO,
2271     CODEC_ID_MJPEG,
2272     sizeof(MJpegDecodeContext),
2273     mjpeg_decode_init,
2274     NULL,
2275     mjpeg_decode_end,
2276     mjpeg_decode_frame,
2277     CODEC_CAP_DR1,
2278     NULL
2279 };
2280
2281 AVCodec mjpegb_decoder = {
2282     "mjpegb",
2283     CODEC_TYPE_VIDEO,
2284     CODEC_ID_MJPEGB,
2285     sizeof(MJpegDecodeContext),
2286     mjpeg_decode_init,
2287     NULL,
2288     mjpeg_decode_end,
2289     mjpegb_decode_frame,
2290     CODEC_CAP_DR1,
2291     NULL
2292 };
2293
2294 AVCodec sp5x_decoder = {
2295     "sp5x",
2296     CODEC_TYPE_VIDEO,
2297     CODEC_ID_SP5X,
2298     sizeof(MJpegDecodeContext),
2299     mjpeg_decode_init,
2300     NULL,
2301     mjpeg_decode_end,
2302     sp5x_decode_frame,
2303     CODEC_CAP_DR1,
2304     NULL
2305 };
2306
2307 #ifdef CONFIG_ENCODERS
2308 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2309     "ljpeg",
2310     CODEC_TYPE_VIDEO,
2311     CODEC_ID_LJPEG,
2312     sizeof(MpegEncContext),
2313     MPV_encode_init,
2314     encode_picture_lossless,
2315     MPV_encode_end,
2316 };
2317 #endif
2318
2319 AVCodecParser mjpeg_parser = {
2320     { CODEC_ID_MJPEG },
2321     sizeof(ParseContext),
2322     NULL,
2323     jpeg_parse,
2324     ff_parse_close,
2325 };
2326