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