remove MpegEncContext, patch by baptiste
[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 <alex@naxine.org>
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     av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
1129     if(avcodec_check_dimensions(s->avctx, width, height))
1130         return -1;
1131
1132     nb_components = get_bits(&s->gb, 8);
1133     if (nb_components <= 0 ||
1134         nb_components > MAX_COMPONENTS)
1135         return -1;
1136     if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1137         av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1138         return -1;
1139     }
1140     s->nb_components = nb_components;
1141     s->h_max = 1;
1142     s->v_max = 1;
1143     for(i=0;i<nb_components;i++) {
1144         /* component id */
1145         s->component_id[i] = get_bits(&s->gb, 8) - 1;
1146         s->h_count[i] = get_bits(&s->gb, 4);
1147         s->v_count[i] = get_bits(&s->gb, 4);
1148         /* compute hmax and vmax (only used in interleaved case) */
1149         if (s->h_count[i] > s->h_max)
1150             s->h_max = s->h_count[i];
1151         if (s->v_count[i] > s->v_max)
1152             s->v_max = s->v_count[i];
1153         s->quant_index[i] = get_bits(&s->gb, 8);
1154         if (s->quant_index[i] >= 4)
1155             return -1;
1156         av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1157                s->v_count[i], s->component_id[i], s->quant_index[i]);
1158     }
1159
1160     if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1161         av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1162         return -1;
1163     }
1164
1165     if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1166
1167     /* if different size, realloc/alloc picture */
1168     /* XXX: also check h_count and v_count */
1169     if (width != s->width || height != s->height) {
1170         av_freep(&s->qscale_table);
1171
1172         s->width = width;
1173         s->height = height;
1174
1175         /* test interlaced mode */
1176         if (s->first_picture &&
1177             s->org_height != 0 &&
1178             s->height < ((s->org_height * 3) / 4)) {
1179             s->interlaced = 1;
1180             s->bottom_field = s->interlace_polarity;
1181             s->picture.interlaced_frame = 1;
1182             s->picture.top_field_first = !s->interlace_polarity;
1183             height *= 2;
1184         }
1185
1186         avcodec_set_dimensions(s->avctx, width, height);
1187
1188         s->qscale_table= av_mallocz((s->width+15)/16);
1189
1190         s->first_picture = 0;
1191     }
1192
1193     if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
1194         return 0;
1195
1196     /* XXX: not complete test ! */
1197     pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1198                  (s->h_count[1] << 12) | (s->v_count[1] <<  8) |
1199                  (s->h_count[2] <<  4) |  s->v_count[2];
1200     av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
1201     switch(pix_fmt_id){
1202     case 0x222222:
1203     case 0x111111:
1204         if(s->rgb){
1205             s->avctx->pix_fmt = PIX_FMT_RGB32;
1206         }else if(s->nb_components==3)
1207             s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1208         else
1209             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1210         break;
1211     case 0x211111:
1212     case 0x221212:
1213         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1214         break;
1215     default:
1216     case 0x221111:
1217         s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1218         break;
1219     }
1220     if(s->ls){
1221         if(s->nb_components > 1)
1222             s->avctx->pix_fmt = PIX_FMT_RGB24;
1223         else if(s->bits <= 8)
1224             s->avctx->pix_fmt = PIX_FMT_GRAY8;
1225         else
1226             s->avctx->pix_fmt = PIX_FMT_GRAY16;
1227     }
1228
1229     if(s->picture.data[0])
1230         s->avctx->release_buffer(s->avctx, &s->picture);
1231
1232     s->picture.reference= 0;
1233     if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1234         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1235         return -1;
1236     }
1237     s->picture.pict_type= I_TYPE;
1238     s->picture.key_frame= 1;
1239
1240     for(i=0; i<3; i++){
1241         s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1242     }
1243
1244 //    printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1245
1246     if (len != (8+(3*nb_components)))
1247     {
1248         av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1249     }
1250
1251     /* totally blank picture as progressive JPEG will only add details to it */
1252     if(s->progressive){
1253         memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1254         memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1255         memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1256     }
1257     return 0;
1258 }
1259
1260 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1261 {
1262     int code;
1263     code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1264     if (code < 0)
1265     {
1266         av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1267                &s->vlcs[0][dc_index]);
1268         return 0xffff;
1269     }
1270
1271     if(code)
1272         return get_xbits(&s->gb, code);
1273     else
1274         return 0;
1275 }
1276
1277 /* decode block and dequantize */
1278 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1279                         int component, int dc_index, int ac_index, int16_t *quant_matrix)
1280 {
1281     int code, i, j, level, val;
1282
1283     /* DC coef */
1284     val = mjpeg_decode_dc(s, dc_index);
1285     if (val == 0xffff) {
1286         av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1287         return -1;
1288     }
1289     val = val * quant_matrix[0] + s->last_dc[component];
1290     s->last_dc[component] = val;
1291     block[0] = val;
1292     /* AC coefs */
1293     i = 0;
1294     {OPEN_READER(re, &s->gb)
1295     for(;;) {
1296         UPDATE_CACHE(re, &s->gb);
1297         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1298
1299         /* EOB */
1300         if (code == 0x10)
1301             break;
1302         i += ((unsigned)code) >> 4;
1303         if(code != 0x100){
1304             code &= 0xf;
1305             if(code > MIN_CACHE_BITS - 16){
1306                 UPDATE_CACHE(re, &s->gb)
1307             }
1308             {
1309                 int cache=GET_CACHE(re,&s->gb);
1310                 int sign=(~cache)>>31;
1311                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1312             }
1313
1314             LAST_SKIP_BITS(re, &s->gb, code)
1315
1316             if (i >= 63) {
1317                 if(i == 63){
1318                     j = s->scantable.permutated[63];
1319                     block[j] = level * quant_matrix[j];
1320                     break;
1321                 }
1322                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1323                 return -1;
1324             }
1325             j = s->scantable.permutated[i];
1326             block[j] = level * quant_matrix[j];
1327         }
1328     }
1329     CLOSE_READER(re, &s->gb)}
1330
1331     return 0;
1332 }
1333
1334 /* decode block and dequantize - progressive JPEG version */
1335 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1336                         int component, int dc_index, int ac_index, int16_t *quant_matrix,
1337                         int ss, int se, int Ah, int Al, int *EOBRUN)
1338 {
1339     int code, i, j, level, val, run;
1340
1341     /* DC coef */
1342     if(!ss){
1343         val = mjpeg_decode_dc(s, dc_index);
1344         if (val == 0xffff) {
1345             av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1346             return -1;
1347         }
1348         val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1349     }else
1350         val = 0;
1351     s->last_dc[component] = val;
1352     block[0] = val;
1353     if(!se) return 0;
1354     /* AC coefs */
1355     if(*EOBRUN){
1356         (*EOBRUN)--;
1357         return 0;
1358     }
1359     {OPEN_READER(re, &s->gb)
1360     for(i=ss;;i++) {
1361         UPDATE_CACHE(re, &s->gb);
1362         GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1363         /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1364         code -= 16;
1365         if(code & 0xF) {
1366             i += ((unsigned) code) >> 4;
1367             code &= 0xf;
1368             if(code > MIN_CACHE_BITS - 16){
1369                 UPDATE_CACHE(re, &s->gb)
1370             }
1371             {
1372                 int cache=GET_CACHE(re,&s->gb);
1373                 int sign=(~cache)>>31;
1374                 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1375             }
1376
1377             LAST_SKIP_BITS(re, &s->gb, code)
1378
1379             if (i >= se) {
1380                 if(i == se){
1381                     j = s->scantable.permutated[se];
1382                     block[j] = level * quant_matrix[j] << Al;
1383                     break;
1384                 }
1385                 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1386                 return -1;
1387             }
1388             j = s->scantable.permutated[i];
1389             block[j] = level * quant_matrix[j] << Al;
1390         }else{
1391             run = ((unsigned) code) >> 4;
1392             if(run == 0xF){// ZRL - skip 15 coefficients
1393                 i += 15;
1394             }else{
1395                 val = run;
1396                 run = (1 << run);
1397                 UPDATE_CACHE(re, &s->gb);
1398                 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1399                 if(val)
1400                     LAST_SKIP_BITS(re, &s->gb, val);
1401                 *EOBRUN = run - 1;
1402                 break;
1403             }
1404         }
1405     }
1406     CLOSE_READER(re, &s->gb)}
1407
1408     return 0;
1409 }
1410
1411 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1412     int i, mb_x, mb_y;
1413     uint16_t buffer[32768][4];
1414     int left[3], top[3], topleft[3];
1415     const int linesize= s->linesize[0];
1416     const int mask= (1<<s->bits)-1;
1417
1418     if((unsigned)s->mb_width > 32768) //dynamic alloc
1419         return -1;
1420
1421     for(i=0; i<3; i++){
1422         buffer[0][i]= 1 << (s->bits + point_transform - 1);
1423     }
1424     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1425         const int modified_predictor= mb_y ? predictor : 1;
1426         uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1427
1428         if (s->interlaced && s->bottom_field)
1429             ptr += linesize >> 1;
1430
1431         for(i=0; i<3; i++){
1432             top[i]= left[i]= topleft[i]= buffer[0][i];
1433         }
1434         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1435             if (s->restart_interval && !s->restart_count)
1436                 s->restart_count = s->restart_interval;
1437
1438             for(i=0;i<3;i++) {
1439                 int pred;
1440
1441                 topleft[i]= top[i];
1442                 top[i]= buffer[mb_x][i];
1443
1444                 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1445
1446                 left[i]=
1447                 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1448             }
1449
1450             if (s->restart_interval && !--s->restart_count) {
1451                 align_get_bits(&s->gb);
1452                 skip_bits(&s->gb, 16); /* skip RSTn */
1453             }
1454         }
1455
1456         if(s->rct){
1457             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1458                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1459                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1460                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1461             }
1462         }else if(s->pegasus_rct){
1463             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1464                 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1465                 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1466                 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1467             }
1468         }else{
1469             for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1470                 ptr[4*mb_x+0] = buffer[mb_x][0];
1471                 ptr[4*mb_x+1] = buffer[mb_x][1];
1472                 ptr[4*mb_x+2] = buffer[mb_x][2];
1473             }
1474         }
1475     }
1476     return 0;
1477 }
1478
1479 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1480     int i, mb_x, mb_y;
1481     const int nb_components=3;
1482
1483     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1484         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1485             if (s->restart_interval && !s->restart_count)
1486                 s->restart_count = s->restart_interval;
1487
1488             if(mb_x==0 || mb_y==0 || s->interlaced){
1489                 for(i=0;i<nb_components;i++) {
1490                     uint8_t *ptr;
1491                     int n, h, v, x, y, c, j, linesize;
1492                     n = s->nb_blocks[i];
1493                     c = s->comp_index[i];
1494                     h = s->h_scount[i];
1495                     v = s->v_scount[i];
1496                     x = 0;
1497                     y = 0;
1498                     linesize= s->linesize[c];
1499
1500                     for(j=0; j<n; j++) {
1501                         int pred;
1502
1503                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1504                         if(y==0 && mb_y==0){
1505                             if(x==0 && mb_x==0){
1506                                 pred= 128 << point_transform;
1507                             }else{
1508                                 pred= ptr[-1];
1509                             }
1510                         }else{
1511                             if(x==0 && mb_x==0){
1512                                 pred= ptr[-linesize];
1513                             }else{
1514                                 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1515                             }
1516                         }
1517
1518                         if (s->interlaced && s->bottom_field)
1519                             ptr += linesize >> 1;
1520                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1521
1522                         if (++x == h) {
1523                             x = 0;
1524                             y++;
1525                         }
1526                     }
1527                 }
1528             }else{
1529                 for(i=0;i<nb_components;i++) {
1530                     uint8_t *ptr;
1531                     int n, h, v, x, y, c, j, linesize;
1532                     n = s->nb_blocks[i];
1533                     c = s->comp_index[i];
1534                     h = s->h_scount[i];
1535                     v = s->v_scount[i];
1536                     x = 0;
1537                     y = 0;
1538                     linesize= s->linesize[c];
1539
1540                     for(j=0; j<n; j++) {
1541                         int pred;
1542
1543                         ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1544                         PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1545                         *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1546                         if (++x == h) {
1547                             x = 0;
1548                             y++;
1549                         }
1550                     }
1551                 }
1552             }
1553             if (s->restart_interval && !--s->restart_count) {
1554                 align_get_bits(&s->gb);
1555                 skip_bits(&s->gb, 16); /* skip RSTn */
1556             }
1557         }
1558     }
1559     return 0;
1560 }
1561
1562 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1563     int i, mb_x, mb_y;
1564     int EOBRUN = 0;
1565
1566     if(Ah) return 0; /* TODO decode refinement planes too */
1567     for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1568         for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1569             if (s->restart_interval && !s->restart_count)
1570                 s->restart_count = s->restart_interval;
1571
1572             for(i=0;i<nb_components;i++) {
1573                 uint8_t *ptr;
1574                 int n, h, v, x, y, c, j;
1575                 n = s->nb_blocks[i];
1576                 c = s->comp_index[i];
1577                 h = s->h_scount[i];
1578                 v = s->v_scount[i];
1579                 x = 0;
1580                 y = 0;
1581                 for(j=0;j<n;j++) {
1582                     memset(s->block, 0, sizeof(s->block));
1583                     if (!s->progressive && decode_block(s, s->block, i,
1584                                      s->dc_index[i], s->ac_index[i],
1585                                      s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1586                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1587                         return -1;
1588                     }
1589                     if (s->progressive && decode_block_progressive(s, s->block, i,
1590                                      s->dc_index[i], s->ac_index[i],
1591                                      s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1592                         av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1593                         return -1;
1594                     }
1595 //                    av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1596                     ptr = s->picture.data[c] +
1597                         (((s->linesize[c] * (v * mb_y + y) * 8) +
1598                         (h * mb_x + x) * 8) >> s->avctx->lowres);
1599                     if (s->interlaced && s->bottom_field)
1600                         ptr += s->linesize[c] >> 1;
1601 //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);
1602                     if(!s->progressive)
1603                         s->dsp.idct_put(ptr, s->linesize[c], s->block);
1604                     else
1605                         s->dsp.idct_add(ptr, s->linesize[c], s->block);
1606                     if (++x == h) {
1607                         x = 0;
1608                         y++;
1609                     }
1610                 }
1611             }
1612             /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1613             if (s->restart_interval && (s->restart_interval < 1350) &&
1614                 !--s->restart_count) {
1615                 align_get_bits(&s->gb);
1616                 skip_bits(&s->gb, 16); /* skip RSTn */
1617                 for (i=0; i<nb_components; i++) /* reset dc */
1618                     s->last_dc[i] = 1024;
1619             }
1620         }
1621     }
1622     return 0;
1623 }
1624
1625 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1626 {
1627     int len, nb_components, i, h, v, predictor, point_transform;
1628     int vmax, hmax, index, id;
1629     const int block_size= s->lossless ? 1 : 8;
1630     int ilv, prev_shift;
1631
1632     /* XXX: verify len field validity */
1633     len = get_bits(&s->gb, 16);
1634     nb_components = get_bits(&s->gb, 8);
1635     if (len != 6+2*nb_components)
1636     {
1637         av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1638         return -1;
1639     }
1640     vmax = 0;
1641     hmax = 0;
1642     for(i=0;i<nb_components;i++) {
1643         id = get_bits(&s->gb, 8) - 1;
1644         av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1645         /* find component index */
1646         for(index=0;index<s->nb_components;index++)
1647             if (id == s->component_id[index])
1648                 break;
1649         if (index == s->nb_components)
1650         {
1651             av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1652             return -1;
1653         }
1654
1655         s->comp_index[i] = index;
1656
1657         s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1658         s->h_scount[i] = s->h_count[index];
1659         s->v_scount[i] = s->v_count[index];
1660
1661         s->dc_index[i] = get_bits(&s->gb, 4);
1662         s->ac_index[i] = get_bits(&s->gb, 4);
1663
1664         if (s->dc_index[i] <  0 || s->ac_index[i] < 0 ||
1665             s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1666             goto out_of_range;
1667 #if 0 //buggy
1668         switch(s->start_code)
1669         {
1670             case SOF0:
1671                 if (dc_index[i] > 1 || ac_index[i] > 1)
1672                     goto out_of_range;
1673                 break;
1674             case SOF1:
1675             case SOF2:
1676                 if (dc_index[i] > 3 || ac_index[i] > 3)
1677                     goto out_of_range;
1678                 break;
1679             case SOF3:
1680                 if (dc_index[i] > 3 || ac_index[i] != 0)
1681                     goto out_of_range;
1682                 break;
1683         }
1684 #endif
1685     }
1686
1687     predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1688     ilv= get_bits(&s->gb, 8);    /* JPEG Se / JPEG-LS ILV */
1689     prev_shift = get_bits(&s->gb, 4); /* Ah */
1690     point_transform= get_bits(&s->gb, 4); /* Al */
1691
1692     for(i=0;i<nb_components;i++)
1693         s->last_dc[i] = 1024;
1694
1695     if (nb_components > 1) {
1696         /* interleaved stream */
1697         s->mb_width  = (s->width  + s->h_max * block_size - 1) / (s->h_max * block_size);
1698         s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1699     } else if(!s->ls) { /* skip this for JPEG-LS */
1700         h = s->h_max / s->h_scount[0];
1701         v = s->v_max / s->v_scount[0];
1702         s->mb_width  = (s->width  + h * block_size - 1) / (h * block_size);
1703         s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1704         s->nb_blocks[0] = 1;
1705         s->h_scount[0] = 1;
1706         s->v_scount[0] = 1;
1707     }
1708
1709     if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1710         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" : "",
1711                predictor, point_transform, ilv, s->bits,
1712                s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1713
1714
1715     /* mjpeg-b can have padding bytes between sos and image data, skip them */
1716     for (i = s->mjpb_skiptosod; i > 0; i--)
1717         skip_bits(&s->gb, 8);
1718
1719     if(s->lossless){
1720         if(s->ls){
1721 //            for(){
1722 //            reset_ls_coding_parameters(s, 0);
1723
1724             ls_decode_picture(s, predictor, point_transform, ilv);
1725         }else{
1726             if(s->rgb){
1727                 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1728                     return -1;
1729             }else{
1730                 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1731                     return -1;
1732             }
1733         }
1734     }else{
1735         if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1736             return -1;
1737     }
1738     emms_c();
1739     return 0;
1740  out_of_range:
1741     av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1742     return -1;
1743 }
1744
1745 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1746 {
1747     if (get_bits(&s->gb, 16) != 4)
1748         return -1;
1749     s->restart_interval = get_bits(&s->gb, 16);
1750     s->restart_count = 0;
1751     av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1752
1753     return 0;
1754 }
1755
1756 static int mjpeg_decode_app(MJpegDecodeContext *s)
1757 {
1758     int len, id;
1759
1760     len = get_bits(&s->gb, 16);
1761     if (len < 5)
1762         return -1;
1763     if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1764         return -1;
1765
1766     id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1767     id = be2me_32(id);
1768     len -= 6;
1769
1770     if(s->avctx->debug & FF_DEBUG_STARTCODE){
1771         av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1772     }
1773
1774     /* buggy AVID, it puts EOI only at every 10th frame */
1775     /* also this fourcc is used by non-avid files too, it holds some
1776        informations, but it's always present in AVID creates files */
1777     if (id == ff_get_fourcc("AVI1"))
1778     {
1779         /* structure:
1780             4bytes      AVI1
1781             1bytes      polarity
1782             1bytes      always zero
1783             4bytes      field_size
1784             4bytes      field_size_less_padding
1785         */
1786             s->buggy_avid = 1;
1787 //        if (s->first_picture)
1788 //            printf("mjpeg: workarounding buggy AVID\n");
1789         s->interlace_polarity = get_bits(&s->gb, 8);
1790 #if 0
1791         skip_bits(&s->gb, 8);
1792         skip_bits(&s->gb, 32);
1793         skip_bits(&s->gb, 32);
1794         len -= 10;
1795 #endif
1796 //        if (s->interlace_polarity)
1797 //            printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1798         goto out;
1799     }
1800
1801 //    len -= 2;
1802
1803     if (id == ff_get_fourcc("JFIF"))
1804     {
1805         int t_w, t_h, v1, v2;
1806         skip_bits(&s->gb, 8); /* the trailing zero-byte */
1807         v1= get_bits(&s->gb, 8);
1808         v2= get_bits(&s->gb, 8);
1809         skip_bits(&s->gb, 8);
1810
1811         s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1812         s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1813
1814         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1815             av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1816                 v1, v2,
1817                 s->avctx->sample_aspect_ratio.num,
1818                 s->avctx->sample_aspect_ratio.den
1819             );
1820
1821         t_w = get_bits(&s->gb, 8);
1822         t_h = get_bits(&s->gb, 8);
1823         if (t_w && t_h)
1824         {
1825             /* skip thumbnail */
1826             if (len-10-(t_w*t_h*3) > 0)
1827                 len -= t_w*t_h*3;
1828         }
1829         len -= 10;
1830         goto out;
1831     }
1832
1833     if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1834     {
1835         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1836             av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1837         skip_bits(&s->gb, 16); /* version */
1838         skip_bits(&s->gb, 16); /* flags0 */
1839         skip_bits(&s->gb, 16); /* flags1 */
1840         skip_bits(&s->gb, 8);  /* transform */
1841         len -= 7;
1842         goto out;
1843     }
1844
1845     if (id == ff_get_fourcc("LJIF")){
1846         if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1847             av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1848         skip_bits(&s->gb, 16); /* version ? */
1849         skip_bits(&s->gb, 16); /* unknwon always 0? */
1850         skip_bits(&s->gb, 16); /* unknwon always 0? */
1851         skip_bits(&s->gb, 16); /* unknwon always 0? */
1852         switch( get_bits(&s->gb, 8)){
1853         case 1:
1854             s->rgb= 1;
1855             s->pegasus_rct=0;
1856             break;
1857         case 2:
1858             s->rgb= 1;
1859             s->pegasus_rct=1;
1860             break;
1861         default:
1862             av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1863         }
1864         len -= 9;
1865         goto out;
1866     }
1867
1868     /* Apple MJPEG-A */
1869     if ((s->start_code == APP1) && (len > (0x28 - 8)))
1870     {
1871         id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1872         id = be2me_32(id);
1873         len -= 4;
1874         if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1875         {
1876 #if 0
1877             skip_bits(&s->gb, 32); /* field size */
1878             skip_bits(&s->gb, 32); /* pad field size */
1879             skip_bits(&s->gb, 32); /* next off */
1880             skip_bits(&s->gb, 32); /* quant off */
1881             skip_bits(&s->gb, 32); /* huff off */
1882             skip_bits(&s->gb, 32); /* image off */
1883             skip_bits(&s->gb, 32); /* scan off */
1884             skip_bits(&s->gb, 32); /* data off */
1885 #endif
1886             if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1887                 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1888         }
1889     }
1890
1891 out:
1892     /* slow but needed for extreme adobe jpegs */
1893     if (len < 0)
1894         av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1895     while(--len > 0)
1896         skip_bits(&s->gb, 8);
1897
1898     return 0;
1899 }
1900
1901 static int mjpeg_decode_com(MJpegDecodeContext *s)
1902 {
1903     int len = get_bits(&s->gb, 16);
1904     if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1905         char *cbuf = av_malloc(len - 1);
1906         if (cbuf) {
1907             int i;
1908             for (i = 0; i < len - 2; i++)
1909                 cbuf[i] = get_bits(&s->gb, 8);
1910             if (i > 0 && cbuf[i-1] == '\n')
1911                 cbuf[i-1] = 0;
1912             else
1913                 cbuf[i] = 0;
1914
1915             if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1916                 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1917
1918             /* buggy avid, it puts EOI only at every 10th frame */
1919             if (!strcmp(cbuf, "AVID"))
1920             {
1921                 s->buggy_avid = 1;
1922                 //        if (s->first_picture)
1923                 //            printf("mjpeg: workarounding buggy AVID\n");
1924             }
1925             else if(!strcmp(cbuf, "CS=ITU601")){
1926                 s->cs_itu601= 1;
1927             }
1928
1929             av_free(cbuf);
1930         }
1931     }
1932
1933     return 0;
1934 }
1935
1936 #if 0
1937 static int valid_marker_list[] =
1938 {
1939         /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1940 /* 0 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1941 /* 1 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1942 /* 2 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1943 /* 3 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1944 /* 4 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1945 /* 5 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1946 /* 6 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1947 /* 7 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1948 /* 8 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1949 /* 9 */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1950 /* a */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1951 /* b */    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1952 /* c */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1953 /* d */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1954 /* e */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1955 /* f */    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1956 }
1957 #endif
1958
1959 /* return the 8 bit start code value and update the search
1960    state. Return -1 if no start code found */
1961 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1962 {
1963     uint8_t *buf_ptr;
1964     unsigned int v, v2;
1965     int val;
1966 #ifdef DEBUG
1967     int skipped=0;
1968 #endif
1969
1970     buf_ptr = *pbuf_ptr;
1971     while (buf_ptr < buf_end) {
1972         v = *buf_ptr++;
1973         v2 = *buf_ptr;
1974         if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1975             val = *buf_ptr++;
1976             goto found;
1977         }
1978 #ifdef DEBUG
1979         skipped++;
1980 #endif
1981     }
1982     val = -1;
1983 found:
1984 #ifdef DEBUG
1985     av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
1986 #endif
1987     *pbuf_ptr = buf_ptr;
1988     return val;
1989 }
1990
1991 static int mjpeg_decode_frame(AVCodecContext *avctx,
1992                               void *data, int *data_size,
1993                               uint8_t *buf, int buf_size)
1994 {
1995     MJpegDecodeContext *s = avctx->priv_data;
1996     uint8_t *buf_end, *buf_ptr;
1997     int start_code;
1998     AVFrame *picture = data;
1999
2000     buf_ptr = buf;
2001     buf_end = buf + buf_size;
2002     while (buf_ptr < buf_end) {
2003         /* find start next marker */
2004         start_code = find_marker(&buf_ptr, buf_end);
2005         {
2006             /* EOF */
2007             if (start_code < 0) {
2008                 goto the_end;
2009             } else {
2010                 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2011
2012                 if ((buf_end - buf_ptr) > s->buffer_size)
2013                 {
2014                     av_free(s->buffer);
2015                     s->buffer_size = buf_end-buf_ptr;
2016                     s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2017                     av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
2018                         s->buffer_size);
2019                 }
2020
2021                 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2022                 if (start_code == SOS && !s->ls)
2023                 {
2024                     uint8_t *src = buf_ptr;
2025                     uint8_t *dst = s->buffer;
2026
2027                     while (src<buf_end)
2028                     {
2029                         uint8_t x = *(src++);
2030
2031                         *(dst++) = x;
2032                         if (avctx->codec_id != CODEC_ID_THP)
2033                         {
2034                             if (x == 0xff) {
2035                                 while (src < buf_end && x == 0xff)
2036                                     x = *(src++);
2037
2038                                 if (x >= 0xd0 && x <= 0xd7)
2039                                     *(dst++) = x;
2040                                 else if (x)
2041                                     break;
2042                             }
2043                         }
2044                     }
2045                     init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2046
2047                     av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
2048                            (buf_end - buf_ptr) - (dst - s->buffer));
2049                 }
2050                 else if(start_code == SOS && s->ls){
2051                     uint8_t *src = buf_ptr;
2052                     uint8_t *dst = s->buffer;
2053                     int bit_count = 0;
2054                     int t = 0, b = 0;
2055                     PutBitContext pb;
2056
2057                     s->cur_scan++;
2058
2059                     /* find marker */
2060                     while (src + t < buf_end){
2061                         uint8_t x = src[t++];
2062                         if (x == 0xff){
2063                             while((src + t < buf_end) && x == 0xff)
2064                                 x = src[t++];
2065                             if (x & 0x80) {
2066                                 t -= 2;
2067                                 break;
2068                             }
2069                         }
2070                     }
2071                     bit_count = t * 8;
2072
2073                     init_put_bits(&pb, dst, t);
2074
2075                     /* unescape bitstream */
2076                     while(b < t){
2077                         uint8_t x = src[b++];
2078                         put_bits(&pb, 8, x);
2079                         if(x == 0xFF){
2080                             x = src[b++];
2081                             put_bits(&pb, 7, x);
2082                             bit_count--;
2083                         }
2084                     }
2085                     flush_put_bits(&pb);
2086
2087                     init_get_bits(&s->gb, dst, bit_count);
2088                 }
2089                 else
2090                     init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2091
2092                 s->start_code = start_code;
2093                 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2094                     av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2095                 }
2096
2097                 /* process markers */
2098                 if (start_code >= 0xd0 && start_code <= 0xd7) {
2099                     av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
2100                     /* APP fields */
2101                 } else if (start_code >= APP0 && start_code <= APP15) {
2102                     mjpeg_decode_app(s);
2103                     /* Comment */
2104                 } else if (start_code == COM){
2105                     mjpeg_decode_com(s);
2106                 }
2107
2108                 switch(start_code) {
2109                 case SOI:
2110                     s->restart_interval = 0;
2111
2112                     s->restart_count = 0;
2113                     /* nothing to do on SOI */
2114                     break;
2115                 case DQT:
2116                     mjpeg_decode_dqt(s);
2117                     break;
2118                 case DHT:
2119                     if(mjpeg_decode_dht(s) < 0){
2120                         av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2121                         return -1;
2122                     }
2123                     break;
2124                 case SOF0:
2125                     s->lossless=0;
2126                     s->ls=0;
2127                     s->progressive=0;
2128                     if (mjpeg_decode_sof(s) < 0)
2129                         return -1;
2130                     break;
2131                 case SOF2:
2132                     s->lossless=0;
2133                     s->ls=0;
2134                     s->progressive=1;
2135                     if (mjpeg_decode_sof(s) < 0)
2136                         return -1;
2137                     break;
2138                 case SOF3:
2139                     s->lossless=1;
2140                     s->ls=0;
2141                     s->progressive=0;
2142                     if (mjpeg_decode_sof(s) < 0)
2143                         return -1;
2144                     break;
2145                 case SOF48:
2146                     s->lossless=1;
2147                     s->ls=1;
2148                     s->progressive=0;
2149                     if (mjpeg_decode_sof(s) < 0)
2150                         return -1;
2151                     break;
2152                 case LSE:
2153                     if (decode_lse(s) < 0)
2154                         return -1;
2155                     break;
2156                 case EOI:
2157                     s->cur_scan = 0;
2158                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2159                         break;
2160 eoi_parser:
2161                     {
2162                         if (s->interlaced) {
2163                             s->bottom_field ^= 1;
2164                             /* if not bottom field, do not output image yet */
2165                             if (s->bottom_field == !s->interlace_polarity)
2166                                 goto not_the_end;
2167                         }
2168                         *picture = s->picture;
2169                         *data_size = sizeof(AVFrame);
2170
2171                         if(!s->lossless){
2172                             picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2173                             picture->qstride= 0;
2174                             picture->qscale_table= s->qscale_table;
2175                             memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2176                             if(avctx->debug & FF_DEBUG_QP)
2177                                 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2178                             picture->quality*= FF_QP2LAMBDA;
2179                         }
2180
2181                         goto the_end;
2182                     }
2183                     break;
2184                 case SOS:
2185                     mjpeg_decode_sos(s);
2186                     /* buggy avid puts EOI every 10-20th frame */
2187                     /* if restart period is over process EOI */
2188                     if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2189                         goto eoi_parser;
2190                     break;
2191                 case DRI:
2192                     mjpeg_decode_dri(s);
2193                     break;
2194                 case SOF1:
2195                 case SOF5:
2196                 case SOF6:
2197                 case SOF7:
2198                 case SOF9:
2199                 case SOF10:
2200                 case SOF11:
2201                 case SOF13:
2202                 case SOF14:
2203                 case SOF15:
2204                 case JPG:
2205                     av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2206                     break;
2207 //                default:
2208 //                    printf("mjpeg: unsupported marker (%x)\n", start_code);
2209 //                    break;
2210                 }
2211
2212 not_the_end:
2213                 /* eof process start code */
2214                 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2215                 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2216                        (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2217             }
2218         }
2219     }
2220 the_end:
2221     av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2222 //    return buf_end - buf_ptr;
2223     return buf_ptr - buf;
2224 }
2225
2226 static int mjpegb_decode_frame(AVCodecContext *avctx,
2227                               void *data, int *data_size,
2228                               uint8_t *buf, int buf_size)
2229 {
2230     MJpegDecodeContext *s = avctx->priv_data;
2231     uint8_t *buf_end, *buf_ptr;
2232     AVFrame *picture = data;
2233     GetBitContext hgb; /* for the header */
2234     uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2235     uint32_t field_size, sod_offs;
2236
2237     buf_ptr = buf;
2238     buf_end = buf + buf_size;
2239
2240 read_header:
2241     /* reset on every SOI */
2242     s->restart_interval = 0;
2243     s->restart_count = 0;
2244     s->mjpb_skiptosod = 0;
2245
2246     init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2247
2248     skip_bits(&hgb, 32); /* reserved zeros */
2249
2250     if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2251     {
2252         av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2253         return 0;
2254     }
2255
2256     field_size = get_bits_long(&hgb, 32); /* field size */
2257     av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2258     skip_bits(&hgb, 32); /* padded field size */
2259     second_field_offs = get_bits_long(&hgb, 32);
2260     av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2261     if (second_field_offs)
2262         s->interlaced = 1;
2263
2264     dqt_offs = get_bits_long(&hgb, 32);
2265     av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2266     if (dqt_offs)
2267     {
2268         init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2269         s->start_code = DQT;
2270         mjpeg_decode_dqt(s);
2271     }
2272
2273     dht_offs = get_bits_long(&hgb, 32);
2274     av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2275     if (dht_offs)
2276     {
2277         init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2278         s->start_code = DHT;
2279         mjpeg_decode_dht(s);
2280     }
2281
2282     sof_offs = get_bits_long(&hgb, 32);
2283     av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2284     if (sof_offs)
2285     {
2286         init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2287         s->start_code = SOF0;
2288         if (mjpeg_decode_sof(s) < 0)
2289             return -1;
2290     }
2291
2292     sos_offs = get_bits_long(&hgb, 32);
2293     av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2294     sod_offs = get_bits_long(&hgb, 32);
2295     av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2296     if (sos_offs)
2297     {
2298 //        init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2299         init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2300         s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2301         s->start_code = SOS;
2302         mjpeg_decode_sos(s);
2303     }
2304
2305     if (s->interlaced) {
2306         s->bottom_field ^= 1;
2307         /* if not bottom field, do not output image yet */
2308         if (s->bottom_field && second_field_offs)
2309         {
2310             buf_ptr = buf + second_field_offs;
2311             second_field_offs = 0;
2312             goto read_header;
2313             }
2314     }
2315
2316     //XXX FIXME factorize, this looks very similar to the EOI code
2317
2318     *picture= s->picture;
2319     *data_size = sizeof(AVFrame);
2320
2321     if(!s->lossless){
2322         picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2323         picture->qstride= 0;
2324         picture->qscale_table= s->qscale_table;
2325         memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2326         if(avctx->debug & FF_DEBUG_QP)
2327             av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2328         picture->quality*= FF_QP2LAMBDA;
2329     }
2330
2331     return buf_ptr - buf;
2332 }
2333
2334 #include "sp5x.h"
2335
2336 static int sp5x_decode_frame(AVCodecContext *avctx,
2337                               void *data, int *data_size,
2338                               uint8_t *buf, int buf_size)
2339 {
2340 #if 0
2341     MJpegDecodeContext *s = avctx->priv_data;
2342 #endif
2343     const int qscale = 5;
2344     uint8_t *buf_ptr, *buf_end, *recoded;
2345     int i = 0, j = 0;
2346
2347     if (!avctx->width || !avctx->height)
2348         return -1;
2349
2350     buf_ptr = buf;
2351     buf_end = buf + buf_size;
2352
2353 #if 1
2354     recoded = av_mallocz(buf_size + 1024);
2355     if (!recoded)
2356         return -1;
2357
2358     /* SOI */
2359     recoded[j++] = 0xFF;
2360     recoded[j++] = 0xD8;
2361
2362     memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2363     memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2364     memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2365     j += sizeof(sp5x_data_dqt);
2366
2367     memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2368     j += sizeof(sp5x_data_dht);
2369
2370     memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2371     recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2372     recoded[j+6] = avctx->coded_height & 0xFF;
2373     recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2374     recoded[j+8] = avctx->coded_width & 0xFF;
2375     j += sizeof(sp5x_data_sof);
2376
2377     memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2378     j += sizeof(sp5x_data_sos);
2379
2380     for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2381     {
2382         recoded[j++] = buf[i];
2383         if (buf[i] == 0xff)
2384             recoded[j++] = 0;
2385     }
2386
2387     /* EOI */
2388     recoded[j++] = 0xFF;
2389     recoded[j++] = 0xD9;
2390
2391     i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2392
2393     av_free(recoded);
2394
2395 #else
2396     /* SOF */
2397     s->bits = 8;
2398     s->width  = avctx->coded_width;
2399     s->height = avctx->coded_height;
2400     s->nb_components = 3;
2401     s->component_id[0] = 0;
2402     s->h_count[0] = 2;
2403     s->v_count[0] = 2;
2404     s->quant_index[0] = 0;
2405     s->component_id[1] = 1;
2406     s->h_count[1] = 1;
2407     s->v_count[1] = 1;
2408     s->quant_index[1] = 1;
2409     s->component_id[2] = 2;
2410     s->h_count[2] = 1;
2411     s->v_count[2] = 1;
2412     s->quant_index[2] = 1;
2413     s->h_max = 2;
2414     s->v_max = 2;
2415
2416     s->qscale_table = av_mallocz((s->width+15)/16);
2417     avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2418     s->interlaced = 0;
2419
2420     s->picture.reference = 0;
2421     if (avctx->get_buffer(avctx, &s->picture) < 0)
2422     {
2423         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2424         return -1;
2425     }
2426
2427     s->picture.pict_type = I_TYPE;
2428     s->picture.key_frame = 1;
2429
2430     for (i = 0; i < 3; i++)
2431         s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2432
2433     /* DQT */
2434     for (i = 0; i < 64; i++)
2435     {
2436         j = s->scantable.permutated[i];
2437         s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2438     }
2439     s->qscale[0] = FFMAX(
2440         s->quant_matrixes[0][s->scantable.permutated[1]],
2441         s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2442
2443     for (i = 0; i < 64; i++)
2444     {
2445         j = s->scantable.permutated[i];
2446         s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2447     }
2448     s->qscale[1] = FFMAX(
2449         s->quant_matrixes[1][s->scantable.permutated[1]],
2450         s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2451
2452     /* DHT */
2453
2454     /* SOS */
2455     s->comp_index[0] = 0;
2456     s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2457     s->h_scount[0] = s->h_count[0];
2458     s->v_scount[0] = s->v_count[0];
2459     s->dc_index[0] = 0;
2460     s->ac_index[0] = 0;
2461
2462     s->comp_index[1] = 1;
2463     s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2464     s->h_scount[1] = s->h_count[1];
2465     s->v_scount[1] = s->v_count[1];
2466     s->dc_index[1] = 1;
2467     s->ac_index[1] = 1;
2468
2469     s->comp_index[2] = 2;
2470     s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2471     s->h_scount[2] = s->h_count[2];
2472     s->v_scount[2] = s->v_count[2];
2473     s->dc_index[2] = 1;
2474     s->ac_index[2] = 1;
2475
2476     for (i = 0; i < 3; i++)
2477         s->last_dc[i] = 1024;
2478
2479     s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2480     s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2481
2482     init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2483
2484     return mjpeg_decode_scan(s);
2485 #endif
2486
2487     return i;
2488 }
2489
2490 static int mjpeg_decode_end(AVCodecContext *avctx)
2491 {
2492     MJpegDecodeContext *s = avctx->priv_data;
2493     int i, j;
2494
2495     av_free(s->buffer);
2496     av_free(s->qscale_table);
2497
2498     for(i=0;i<2;i++) {
2499         for(j=0;j<4;j++)
2500             free_vlc(&s->vlcs[i][j]);
2501     }
2502     return 0;
2503 }
2504
2505 static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2506                               uint8_t **poutbuf, int *poutbuf_size,
2507                               const uint8_t *buf, int buf_size, int keyframe)
2508 {
2509     uint8_t *poutbufp;
2510     int i;
2511
2512     if (avctx->codec_id != CODEC_ID_MJPEG) {
2513         av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2514         return 0;
2515     }
2516
2517     *poutbuf_size = 0;
2518     *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2519     poutbufp = *poutbuf;
2520     bytestream_put_byte(&poutbufp, 0xff);
2521     bytestream_put_byte(&poutbufp, SOI);
2522     bytestream_put_byte(&poutbufp, 0xff);
2523     bytestream_put_byte(&poutbufp, APP1);
2524     bytestream_put_be16(&poutbufp, 42); /* size */
2525     bytestream_put_be32(&poutbufp, 0);
2526     bytestream_put_buffer(&poutbufp, "mjpg", 4);
2527     bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2528     bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2529     bytestream_put_be32(&poutbufp, 0);             /* next ptr */
2530
2531     for (i = 0; i < buf_size - 1; i++) {
2532         if (buf[i] == 0xff) {
2533             switch (buf[i + 1]) {
2534             case DQT:  /* quant off */
2535             case DHT:  /* huff  off */
2536             case SOF0: /* image off */
2537                 bytestream_put_be32(&poutbufp, i + 46);
2538                 break;
2539             case SOS:
2540                 bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2541                 bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2542                 bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2543                 *poutbuf_size = poutbufp - *poutbuf;
2544                 return 1;
2545             case APP1:
2546                 if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2547                     av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2548                     memcpy(*poutbuf, buf, buf_size);
2549                     *poutbuf_size = buf_size;
2550                     return 1;
2551                 }
2552             }
2553         }
2554     }
2555     av_freep(poutbuf);
2556     av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2557     return 0;
2558 }
2559
2560 AVCodec mjpeg_decoder = {
2561     "mjpeg",
2562     CODEC_TYPE_VIDEO,
2563     CODEC_ID_MJPEG,
2564     sizeof(MJpegDecodeContext),
2565     mjpeg_decode_init,
2566     NULL,
2567     mjpeg_decode_end,
2568     mjpeg_decode_frame,
2569     CODEC_CAP_DR1,
2570     NULL
2571 };
2572
2573 AVCodec thp_decoder = {
2574     "thp",
2575     CODEC_TYPE_VIDEO,
2576     CODEC_ID_THP,
2577     sizeof(MJpegDecodeContext),
2578     mjpeg_decode_init,
2579     NULL,
2580     mjpeg_decode_end,
2581     mjpeg_decode_frame,
2582     CODEC_CAP_DR1,
2583     NULL
2584 };
2585
2586 AVCodec mjpegb_decoder = {
2587     "mjpegb",
2588     CODEC_TYPE_VIDEO,
2589     CODEC_ID_MJPEGB,
2590     sizeof(MJpegDecodeContext),
2591     mjpeg_decode_init,
2592     NULL,
2593     mjpeg_decode_end,
2594     mjpegb_decode_frame,
2595     CODEC_CAP_DR1,
2596     NULL
2597 };
2598
2599 AVCodec sp5x_decoder = {
2600     "sp5x",
2601     CODEC_TYPE_VIDEO,
2602     CODEC_ID_SP5X,
2603     sizeof(MJpegDecodeContext),
2604     mjpeg_decode_init,
2605     NULL,
2606     mjpeg_decode_end,
2607     sp5x_decode_frame,
2608     CODEC_CAP_DR1,
2609     NULL
2610 };
2611
2612 #ifdef CONFIG_ENCODERS
2613 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2614     "ljpeg",
2615     CODEC_TYPE_VIDEO,
2616     CODEC_ID_LJPEG,
2617     sizeof(MpegEncContext),
2618     MPV_encode_init,
2619     encode_picture_lossless,
2620     MPV_encode_end,
2621 };
2622 #endif
2623
2624 AVCodecParser mjpeg_parser = {
2625     { CODEC_ID_MJPEG },
2626     sizeof(ParseContext),
2627     NULL,
2628     jpeg_parse,
2629     ff_parse_close,
2630 };
2631
2632 AVBitStreamFilter mjpega_dump_header_bsf = {
2633     "mjpegadump",
2634     0,
2635     mjpega_dump_header,
2636 };