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