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