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
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * Support for external huffman table, various fixes (AVID workaround),
22 * aspecting, new decode_frame mechanism and apple mjpeg-b support
23 * by Alex Beregszaszi <alex@naxine.org>
28 * MJPEG encoder and decoder.
36 #include "mpegvideo.h"
38 /* use two quantizer tables (one for luminance and one for chrominance) */
42 typedef struct MJpegContext {
43 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
44 uint16_t huff_code_dc_luminance[12];
45 uint8_t huff_size_dc_chrominance[12];
46 uint16_t huff_code_dc_chrominance[12];
48 uint8_t huff_size_ac_luminance[256];
49 uint16_t huff_code_ac_luminance[256];
50 uint8_t huff_size_ac_chrominance[256];
51 uint16_t huff_code_ac_chrominance[256];
54 /* JPEG marker codes */
57 SOF0 = 0xc0, /* baseline */
58 SOF1 = 0xc1, /* extended sequential, huffman */
59 SOF2 = 0xc2, /* progressive, huffman */
60 SOF3 = 0xc3, /* lossless, huffman */
62 SOF5 = 0xc5, /* differential sequential, huffman */
63 SOF6 = 0xc6, /* differential progressive, huffman */
64 SOF7 = 0xc7, /* differential lossless, huffman */
65 JPG = 0xc8, /* reserved for JPEG extension */
66 SOF9 = 0xc9, /* extended sequential, arithmetic */
67 SOF10 = 0xca, /* progressive, arithmetic */
68 SOF11 = 0xcb, /* lossless, arithmetic */
70 SOF13 = 0xcd, /* differential sequential, arithmetic */
71 SOF14 = 0xce, /* differential progressive, arithmetic */
72 SOF15 = 0xcf, /* differential lossless, arithmetic */
74 DHT = 0xc4, /* define huffman tables */
76 DAC = 0xcc, /* define arithmetic-coding conditioning */
78 /* restart with modulo 8 count "m" */
88 SOI = 0xd8, /* start of image */
89 EOI = 0xd9, /* end of image */
90 SOS = 0xda, /* start of scan */
91 DQT = 0xdb, /* define quantization tables */
92 DNL = 0xdc, /* define number of lines */
93 DRI = 0xdd, /* define restart interval */
94 DHP = 0xde, /* define hierarchical progression */
95 EXP = 0xdf, /* expand reference components */
121 SOF48 = 0xf7, ///< JPEG-LS
122 LSE = 0xf8, ///< JPEG-LS extension parameters
129 COM = 0xfe, /* comment */
131 TEM = 0x01, /* temporary private use for arithmetic coding */
133 /* 0x02 -> 0xbf reserved */
137 /* These are the sample quantization tables given in JPEG spec section K.1.
138 * The spec says that the values given produce "good" quality, and
139 * when divided by 2, "very good" quality.
141 static const unsigned char std_luminance_quant_tbl[64] = {
142 16, 11, 10, 16, 24, 40, 51, 61,
143 12, 12, 14, 19, 26, 58, 60, 55,
144 14, 13, 16, 24, 40, 57, 69, 56,
145 14, 17, 22, 29, 51, 87, 80, 62,
146 18, 22, 37, 56, 68, 109, 103, 77,
147 24, 35, 55, 64, 81, 104, 113, 92,
148 49, 64, 78, 87, 103, 121, 120, 101,
149 72, 92, 95, 98, 112, 100, 103, 99
151 static const unsigned char std_chrominance_quant_tbl[64] = {
152 17, 18, 24, 47, 99, 99, 99, 99,
153 18, 21, 26, 66, 99, 99, 99, 99,
154 24, 26, 56, 99, 99, 99, 99, 99,
155 47, 66, 99, 99, 99, 99, 99, 99,
156 99, 99, 99, 99, 99, 99, 99, 99,
157 99, 99, 99, 99, 99, 99, 99, 99,
158 99, 99, 99, 99, 99, 99, 99, 99,
159 99, 99, 99, 99, 99, 99, 99, 99
163 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
164 /* IMPORTANT: these are only valid for 8-bit data precision! */
165 static const uint8_t bits_dc_luminance[17] =
166 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
167 static const uint8_t val_dc_luminance[] =
168 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
170 static const uint8_t bits_dc_chrominance[17] =
171 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
172 static const uint8_t val_dc_chrominance[] =
173 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
175 static const uint8_t bits_ac_luminance[17] =
176 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
177 static const uint8_t val_ac_luminance[] =
178 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
179 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
180 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
181 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
182 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
183 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
184 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
185 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
186 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
187 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
188 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
189 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
190 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
191 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
192 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
193 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
194 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
195 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
201 static const uint8_t bits_ac_chrominance[17] =
202 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
204 static const uint8_t val_ac_chrominance[] =
205 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
206 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
207 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
208 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
209 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
210 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
211 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
212 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
213 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
214 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
215 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
216 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
218 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
219 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
220 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
221 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
222 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
228 /* isn't this function nicer than the one in the libjpeg ? */
229 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
230 const uint8_t *bits_table, const uint8_t *val_table)
232 int i, j, k,nb, code, sym;
239 sym = val_table[k++];
241 huff_code[sym] = code;
248 #ifdef CONFIG_ENCODERS
249 int mjpeg_init(MpegEncContext *s)
253 m = av_malloc(sizeof(MJpegContext));
260 /* build all the huffman tables */
261 build_huffman_codes(m->huff_size_dc_luminance,
262 m->huff_code_dc_luminance,
265 build_huffman_codes(m->huff_size_dc_chrominance,
266 m->huff_code_dc_chrominance,
269 build_huffman_codes(m->huff_size_ac_luminance,
270 m->huff_code_ac_luminance,
273 build_huffman_codes(m->huff_size_ac_chrominance,
274 m->huff_code_ac_chrominance,
282 void mjpeg_close(MpegEncContext *s)
284 av_free(s->mjpeg_ctx);
286 #endif //CONFIG_ENCODERS
288 #define PREDICT(ret, topleft, top, left, predictor)\
290 case 1: ret= left; break;\
291 case 2: ret= top; break;\
292 case 3: ret= topleft; break;\
293 case 4: ret= left + top - topleft; break;\
294 case 5: ret= left + ((top - topleft)>>1); break;\
295 case 6: ret= top + ((left - topleft)>>1); break;\
297 case 7: ret= (left + top)>>1; break;\
300 #ifdef CONFIG_ENCODERS
301 static inline void put_marker(PutBitContext *p, int code)
303 put_bits(p, 8, 0xff);
304 put_bits(p, 8, code);
307 /* table_class: 0 = DC coef, 1 = AC coefs */
308 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
309 const uint8_t *bits_table, const uint8_t *value_table)
311 PutBitContext *p = &s->pb;
314 put_bits(p, 4, table_class);
315 put_bits(p, 4, table_id);
320 put_bits(p, 8, bits_table[i]);
324 put_bits(p, 8, value_table[i]);
329 static void jpeg_table_header(MpegEncContext *s)
331 PutBitContext *p = &s->pb;
338 put_bits(p, 16, 2 + 2 * (1 + 64));
340 put_bits(p, 16, 2 + 1 * (1 + 64));
342 put_bits(p, 4, 0); /* 8 bit precision */
343 put_bits(p, 4, 0); /* table 0 */
345 j = s->intra_scantable.permutated[i];
346 put_bits(p, 8, s->intra_matrix[j]);
349 put_bits(p, 4, 0); /* 8 bit precision */
350 put_bits(p, 4, 1); /* table 1 */
352 j = s->intra_scantable.permutated[i];
353 put_bits(p, 8, s->chroma_intra_matrix[j]);
361 put_bits(p, 16, 0); /* patched later */
363 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
366 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
372 static void jpeg_put_comments(MpegEncContext *s)
374 PutBitContext *p = &s->pb;
378 if (s->aspect_ratio_info /* && !lossless */)
383 ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
384 put_bits(p, 16, 0x0201); /* v 1.02 */
385 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
386 put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
387 put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
388 put_bits(p, 8, 0); /* thumbnail width */
389 put_bits(p, 8, 0); /* thumbnail height */
393 if(!(s->flags & CODEC_FLAG_BITEXACT)){
397 put_bits(p, 16, 0); /* patched later */
398 ff_put_string(p, LIBAVCODEC_IDENT, 1);
399 size = strlen(LIBAVCODEC_IDENT)+3;
404 if( s->avctx->pix_fmt == PIX_FMT_YUV420P
405 ||s->avctx->pix_fmt == PIX_FMT_YUV422P
406 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
410 put_bits(p, 16, 0); /* patched later */
411 ff_put_string(p, "CS=ITU601", 1);
412 size = strlen("CS=ITU601")+3;
418 void mjpeg_picture_header(MpegEncContext *s)
420 const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
421 const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS;
423 assert(!(ls && s->mjpeg_write_tables));
425 put_marker(&s->pb, SOI);
427 if (!s->mjpeg_data_only_frames)
429 jpeg_put_comments(s);
431 if (s->mjpeg_write_tables) jpeg_table_header(s);
433 switch(s->avctx->codec_id){
434 case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
435 case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
436 case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
440 put_bits(&s->pb, 16, 17);
441 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
442 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
444 put_bits(&s->pb, 8, 8); /* 8 bits/component */
445 put_bits(&s->pb, 16, s->height);
446 put_bits(&s->pb, 16, s->width);
447 put_bits(&s->pb, 8, 3); /* 3 components */
450 put_bits(&s->pb, 8, 1); /* component number */
451 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
452 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
453 put_bits(&s->pb, 8, 0); /* select matrix */
456 put_bits(&s->pb, 8, 2); /* component number */
457 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
458 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
460 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
462 put_bits(&s->pb, 8, 0); /* select matrix */
466 put_bits(&s->pb, 8, 3); /* component number */
467 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
468 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
470 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
472 put_bits(&s->pb, 8, 0); /* select matrix */
477 put_marker(&s->pb, SOS);
478 put_bits(&s->pb, 16, 12); /* length */
479 put_bits(&s->pb, 8, 3); /* 3 components */
482 put_bits(&s->pb, 8, 1); /* index */
483 put_bits(&s->pb, 4, 0); /* DC huffman table index */
484 put_bits(&s->pb, 4, 0); /* AC huffman table index */
487 put_bits(&s->pb, 8, 2); /* index */
488 put_bits(&s->pb, 4, 1); /* DC huffman table index */
489 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
492 put_bits(&s->pb, 8, 3); /* index */
493 put_bits(&s->pb, 4, 1); /* DC huffman table index */
494 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
496 put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
498 switch(s->avctx->codec_id){
499 case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
500 case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
501 case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */
505 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
507 //FIXME DC/AC entropy table selectors stuff in jpegls
510 static void escape_FF(MpegEncContext *s, int start)
512 int size= put_bits_count(&s->pb) - start*8;
514 uint8_t *buf= s->pb.buf + start;
515 int align= (-(size_t)(buf))&3;
517 assert((size&7) == 0);
521 for(i=0; i<size && i<align; i++){
522 if(buf[i]==0xFF) ff_count++;
524 for(; i<size-15; i+=16){
527 v= *(uint32_t*)(&buf[i]);
528 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
529 v= *(uint32_t*)(&buf[i+4]);
530 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
531 v= *(uint32_t*)(&buf[i+8]);
532 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
533 v= *(uint32_t*)(&buf[i+12]);
534 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
542 if(buf[i]==0xFF) ff_count++;
545 if(ff_count==0) return;
548 for(i=0; i<ff_count-3; i+=4)
549 put_bits(&s->pb, 32, 0);
550 put_bits(&s->pb, (ff_count-i)*8, 0);
551 flush_put_bits(&s->pb);
553 for(i=size-1; ff_count; i--){
557 //printf("%d %d\n", i, ff_count);
566 void ff_mjpeg_stuffing(PutBitContext * pbc)
569 length= (-put_bits_count(pbc))&7;
570 if(length) put_bits(pbc, length, (1<<length)-1);
573 void mjpeg_picture_trailer(MpegEncContext *s)
575 ff_mjpeg_stuffing(&s->pb);
576 flush_put_bits(&s->pb);
578 assert((s->header_bits&7)==0);
580 escape_FF(s, s->header_bits>>3);
582 put_marker(&s->pb, EOI);
585 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
586 uint8_t *huff_size, uint16_t *huff_code)
591 put_bits(&s->pb, huff_size[0], huff_code[0]);
599 nbits= av_log2_16bit(val) + 1;
601 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
603 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
607 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
609 int mant, nbits, code, i, j;
610 int component, dc, run, last_index, val;
611 MJpegContext *m = s->mjpeg_ctx;
612 uint8_t *huff_size_ac;
613 uint16_t *huff_code_ac;
616 component = (n <= 3 ? 0 : n - 4 + 1);
617 dc = block[0]; /* overflow is impossible */
618 val = dc - s->last_dc[component];
620 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
621 huff_size_ac = m->huff_size_ac_luminance;
622 huff_code_ac = m->huff_code_ac_luminance;
624 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
625 huff_size_ac = m->huff_size_ac_chrominance;
626 huff_code_ac = m->huff_code_ac_chrominance;
628 s->last_dc[component] = dc;
633 last_index = s->block_last_index[n];
634 for(i=1;i<=last_index;i++) {
635 j = s->intra_scantable.permutated[i];
641 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
650 nbits= av_log2(val) + 1;
651 code = (run << 4) | nbits;
653 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
655 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
660 /* output EOB only if not already 64 values */
661 if (last_index < 63 || run != 0)
662 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
665 void mjpeg_encode_mb(MpegEncContext *s,
666 DCTELEM block[6][64])
670 encode_block(s, block[i], i);
674 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
675 MpegEncContext * const s = avctx->priv_data;
676 MJpegContext * const m = s->mjpeg_ctx;
677 AVFrame *pict = data;
678 const int width= s->width;
679 const int height= s->height;
680 AVFrame * const p= (AVFrame*)&s->current_picture;
681 const int predictor= avctx->prediction_method+1;
683 init_put_bits(&s->pb, buf, buf_size);
686 p->pict_type= FF_I_TYPE;
689 mjpeg_picture_header(s);
691 s->header_bits= put_bits_count(&s->pb);
693 if(avctx->pix_fmt == PIX_FMT_RGBA32){
695 const int linesize= p->linesize[0];
696 uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
697 int left[3], top[3], topleft[3];
700 buffer[0][i]= 1 << (9 - 1);
703 for(y = 0; y < height; y++) {
704 const int modified_predictor= y ? predictor : 1;
705 uint8_t *ptr = p->data[0] + (linesize * y);
707 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
708 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
713 top[i]= left[i]= topleft[i]= buffer[0][i];
715 for(x = 0; x < width; x++) {
716 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
717 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
718 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
723 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
726 top[i]= buffer[x+1][i];
728 left[i]= buffer[x][i];
730 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
733 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
735 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
741 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
742 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
744 for(mb_y = 0; mb_y < mb_height; mb_y++) {
745 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]){
746 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
749 for(mb_x = 0; mb_x < mb_width; mb_x++) {
750 if(mb_x==0 || mb_y==0){
753 int x, y, h, v, linesize;
754 h = s->mjpeg_hsample[i];
755 v = s->mjpeg_vsample[i];
756 linesize= p->linesize[i];
762 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
771 pred= ptr[-linesize];
773 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
778 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
780 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
787 int x, y, h, v, linesize;
788 h = s->mjpeg_hsample[i];
789 v = s->mjpeg_vsample[i];
790 linesize= p->linesize[i];
796 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
797 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
798 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
801 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
803 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
814 mjpeg_picture_trailer(s);
817 flush_put_bits(&s->pb);
818 return pbBufPtr(&s->pb) - s->pb.buf;
819 // return (put_bits_count(&f->pb)+7)/8;
822 #endif //CONFIG_ENCODERS
824 /******************************************/
827 #define MAX_COMPONENTS 4
829 typedef struct MJpegDecodeContext {
830 AVCodecContext *avctx;
832 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
834 int start_code; /* current start code */
838 int16_t quant_matrixes[4][64];
840 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
842 int org_height; /* size given at codec init */
843 int first_picture; /* true if decoding first picture */
844 int interlaced; /* true if interlaced */
845 int bottom_field; /* true if bottom field */
849 int rct; /* standard rct */
850 int pegasus_rct; /* pegasus reversible colorspace transform */
851 int bits; /* bits per component */
854 int near; ///< near lossless bound (si 0 for lossless)
856 int reset; ///< context halfing intervall ?rename
859 int mb_width, mb_height;
861 int component_id[MAX_COMPONENTS];
862 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
863 int v_count[MAX_COMPONENTS];
864 int comp_index[MAX_COMPONENTS];
865 int dc_index[MAX_COMPONENTS];
866 int ac_index[MAX_COMPONENTS];
867 int nb_blocks[MAX_COMPONENTS];
868 int h_scount[MAX_COMPONENTS];
869 int v_scount[MAX_COMPONENTS];
870 int h_max, v_max; /* maximum h and v counts */
871 int quant_index[4]; /* quant table index for each component */
872 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
873 AVFrame picture; /* picture structure */
874 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
875 int8_t *qscale_table;
876 DECLARE_ALIGNED_8(DCTELEM, block[64]);
878 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
880 int restart_interval;
885 int interlace_polarity;
889 int cur_scan; /* current scan, used by JPEG-LS */
890 } MJpegDecodeContext;
892 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant
894 static int mjpeg_decode_dht(MJpegDecodeContext *s);
896 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
897 int nb_codes, int use_static, int is_ac)
899 uint8_t huff_size[256+16];
900 uint16_t huff_code[256+16];
902 assert(nb_codes <= 256);
904 memset(huff_size, 0, sizeof(huff_size));
905 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
908 memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
909 memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
910 memset(huff_size, 0, sizeof(uint8_t)*16);
911 memset(huff_code, 0, sizeof(uint16_t)*16);
915 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
918 static int mjpeg_decode_init(AVCodecContext *avctx)
920 MJpegDecodeContext *s = avctx->priv_data;
922 memset(s, 0, sizeof(MJpegDecodeContext));
926 /* ugly way to get the idct & scantable FIXME */
927 memset(&s2, 0, sizeof(MpegEncContext));
929 // s2->out_format = FMT_MJPEG;
930 dsputil_init(&s2.dsp, avctx);
931 DCT_common_init(&s2);
933 s->scantable= s2.intra_scantable;
934 s->idct_put= s2.dsp.idct_put;
936 s->mpeg_enc_ctx_allocated = 0;
940 s->first_picture = 1;
941 s->org_height = avctx->coded_height;
943 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
944 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
945 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
946 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
948 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
950 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
951 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
953 /* should check for error - but dunno */
961 * finds the end of the current frame in the bitstream.
962 * @return the position of the first byte of the next frame, or -1
964 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
968 vop_found= pc->frame_start_found;
973 for(i=0; i<buf_size; i++){
974 state= (state<<8) | buf[i];
984 /* EOF considered as end of frame */
987 for(; i<buf_size; i++){
988 state= (state<<8) | buf[i];
990 pc->frame_start_found=0;
996 pc->frame_start_found= vop_found;
998 return END_NOT_FOUND;
1001 static int jpeg_parse(AVCodecParserContext *s,
1002 AVCodecContext *avctx,
1003 uint8_t **poutbuf, int *poutbuf_size,
1004 const uint8_t *buf, int buf_size)
1006 ParseContext *pc = s->priv_data;
1009 next= find_frame_end(pc, buf, buf_size);
1011 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1017 *poutbuf = (uint8_t *)buf;
1018 *poutbuf_size = buf_size;
1022 /* quantize tables */
1023 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1025 int len, index, i, j;
1027 len = get_bits(&s->gb, 16) - 2;
1030 /* only 8 bit precision handled */
1031 if (get_bits(&s->gb, 4) != 0)
1033 dprintf("dqt: 16bit precision\n");
1036 index = get_bits(&s->gb, 4);
1039 dprintf("index=%d\n", index);
1040 /* read quant table */
1042 j = s->scantable.permutated[i];
1043 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1046 //XXX FIXME finetune, and perhaps add dc too
1047 s->qscale[index]= FFMAX(
1048 s->quant_matrixes[index][s->scantable.permutated[1]],
1049 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1050 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1057 /* decode huffman tables and build VLC decoders */
1058 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1060 int len, index, i, class, n, v, code_max;
1061 uint8_t bits_table[17];
1062 uint8_t val_table[256];
1064 len = get_bits(&s->gb, 16) - 2;
1069 class = get_bits(&s->gb, 4);
1072 index = get_bits(&s->gb, 4);
1076 for(i=1;i<=16;i++) {
1077 bits_table[i] = get_bits(&s->gb, 8);
1081 if (len < n || n > 256)
1086 v = get_bits(&s->gb, 8);
1093 /* build VLC and flush previous vlc if present */
1094 free_vlc(&s->vlcs[class][index]);
1095 dprintf("class=%d index=%d nb_codes=%d\n",
1096 class, index, code_max + 1);
1097 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1104 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1106 int len, nb_components, i, width, height;
1108 /* XXX: verify len field validity */
1109 len = get_bits(&s->gb, 16);
1110 s->bits= get_bits(&s->gb, 8);
1112 if(s->pegasus_rct) s->bits=9;
1113 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1115 if (s->bits != 8 && !s->lossless){
1116 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1119 if (s->bits > 8 && s->ls){
1120 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1124 height = get_bits(&s->gb, 16);
1125 width = get_bits(&s->gb, 16);
1127 dprintf("sof0: picture: %dx%d\n", width, height);
1128 if(avcodec_check_dimensions(s->avctx, width, height))
1131 nb_components = get_bits(&s->gb, 8);
1132 if (nb_components <= 0 ||
1133 nb_components > MAX_COMPONENTS)
1135 s->nb_components = nb_components;
1138 for(i=0;i<nb_components;i++) {
1140 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1141 s->h_count[i] = get_bits(&s->gb, 4);
1142 s->v_count[i] = get_bits(&s->gb, 4);
1143 /* compute hmax and vmax (only used in interleaved case) */
1144 if (s->h_count[i] > s->h_max)
1145 s->h_max = s->h_count[i];
1146 if (s->v_count[i] > s->v_max)
1147 s->v_max = s->v_count[i];
1148 s->quant_index[i] = get_bits(&s->gb, 8);
1149 if (s->quant_index[i] >= 4)
1151 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1152 s->v_count[i], s->component_id[i], s->quant_index[i]);
1155 if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1156 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1160 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1162 /* if different size, realloc/alloc picture */
1163 /* XXX: also check h_count and v_count */
1164 if (width != s->width || height != s->height) {
1165 av_freep(&s->qscale_table);
1170 /* test interlaced mode */
1171 if (s->first_picture &&
1172 s->org_height != 0 &&
1173 s->height < ((s->org_height * 3) / 4)) {
1175 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1176 s->bottom_field = 0;
1180 avcodec_set_dimensions(s->avctx, width, height);
1182 s->qscale_table= av_mallocz((s->width+15)/16);
1184 s->first_picture = 0;
1187 if(s->interlaced && s->bottom_field)
1190 /* XXX: not complete test ! */
1191 switch((s->h_count[0] << 4) | s->v_count[0]) {
1194 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1195 }else if(s->nb_components==3)
1196 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1198 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1201 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1205 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1209 if(s->nb_components > 1)
1210 s->avctx->pix_fmt = PIX_FMT_RGB24;
1212 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1215 if(s->picture.data[0])
1216 s->avctx->release_buffer(s->avctx, &s->picture);
1218 s->picture.reference= 0;
1219 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1220 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1223 s->picture.pict_type= I_TYPE;
1224 s->picture.key_frame= 1;
1227 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1230 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1232 if (len != (8+(3*nb_components)))
1234 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1240 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1243 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1246 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1247 &s->vlcs[0][dc_index]);
1252 return get_xbits(&s->gb, code);
1257 /* decode block and dequantize */
1258 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1259 int component, int dc_index, int ac_index, int16_t *quant_matrix)
1261 int code, i, j, level, val;
1265 val = mjpeg_decode_dc(s, dc_index);
1266 if (val == 0xffff) {
1267 dprintf("error dc\n");
1270 val = val * quant_matrix[0] + s->last_dc[component];
1271 s->last_dc[component] = val;
1274 ac_vlc = &s->vlcs[1][ac_index];
1276 {OPEN_READER(re, &s->gb)
1278 UPDATE_CACHE(re, &s->gb);
1279 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1284 if (code == 0x100) {
1287 i += ((unsigned)code) >> 4;
1289 if(code > MIN_CACHE_BITS - 16){
1290 UPDATE_CACHE(re, &s->gb)
1293 int cache=GET_CACHE(re,gb);
1294 int sign=(~cache)>>31;
1295 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1298 LAST_SKIP_BITS(re, &s->gb, code)
1302 j = s->scantable.permutated[63];
1303 block[j] = level * quant_matrix[j];
1306 dprintf("error count: %d\n", i);
1309 j = s->scantable.permutated[i];
1310 block[j] = level * quant_matrix[j];
1313 CLOSE_READER(re, &s->gb)}
1318 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1320 uint16_t buffer[32768][4];
1321 int left[3], top[3], topleft[3];
1322 const int linesize= s->linesize[0];
1323 const int mask= (1<<s->bits)-1;
1325 if((unsigned)s->mb_width > 32768) //dynamic alloc
1329 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1331 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1332 const int modified_predictor= mb_y ? predictor : 1;
1333 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1335 if (s->interlaced && s->bottom_field)
1336 ptr += linesize >> 1;
1339 top[i]= left[i]= topleft[i]= buffer[0][i];
1341 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1342 if (s->restart_interval && !s->restart_count)
1343 s->restart_count = s->restart_interval;
1349 top[i]= buffer[mb_x][i];
1351 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1354 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1357 if (s->restart_interval && !--s->restart_count) {
1358 align_get_bits(&s->gb);
1359 skip_bits(&s->gb, 16); /* skip RSTn */
1364 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1365 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1366 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1367 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1369 }else if(s->pegasus_rct){
1370 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1371 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1372 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1373 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1376 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1377 ptr[4*mb_x+0] = buffer[mb_x][0];
1378 ptr[4*mb_x+1] = buffer[mb_x][1];
1379 ptr[4*mb_x+2] = buffer[mb_x][2];
1386 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1388 const int nb_components=3;
1390 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1391 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1392 if (s->restart_interval && !s->restart_count)
1393 s->restart_count = s->restart_interval;
1395 if(mb_x==0 || mb_y==0 || s->interlaced){
1396 for(i=0;i<nb_components;i++) {
1398 int n, h, v, x, y, c, j, linesize;
1399 n = s->nb_blocks[i];
1400 c = s->comp_index[i];
1405 linesize= s->linesize[c];
1407 for(j=0; j<n; j++) {
1410 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1411 if(y==0 && mb_y==0){
1412 if(x==0 && mb_x==0){
1413 pred= 128 << point_transform;
1418 if(x==0 && mb_x==0){
1419 pred= ptr[-linesize];
1421 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1425 if (s->interlaced && s->bottom_field)
1426 ptr += linesize >> 1;
1427 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1436 for(i=0;i<nb_components;i++) {
1438 int n, h, v, x, y, c, j, linesize;
1439 n = s->nb_blocks[i];
1440 c = s->comp_index[i];
1445 linesize= s->linesize[c];
1447 for(j=0; j<n; j++) {
1450 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1451 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1452 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1460 if (s->restart_interval && !--s->restart_count) {
1461 align_get_bits(&s->gb);
1462 skip_bits(&s->gb, 16); /* skip RSTn */
1469 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1471 const int nb_components=3;
1473 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1474 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1475 if (s->restart_interval && !s->restart_count)
1476 s->restart_count = s->restart_interval;
1478 for(i=0;i<nb_components;i++) {
1480 int n, h, v, x, y, c, j;
1481 n = s->nb_blocks[i];
1482 c = s->comp_index[i];
1488 memset(s->block, 0, sizeof(s->block));
1489 if (decode_block(s, s->block, i,
1490 s->dc_index[i], s->ac_index[i],
1491 s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1492 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1495 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1496 ptr = s->picture.data[c] +
1497 (((s->linesize[c] * (v * mb_y + y) * 8) +
1498 (h * mb_x + x) * 8) >> s->avctx->lowres);
1499 if (s->interlaced && s->bottom_field)
1500 ptr += s->linesize[c] >> 1;
1501 //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);
1502 s->idct_put(ptr, s->linesize[c], s->block);
1509 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1510 if (s->restart_interval && (s->restart_interval < 1350) &&
1511 !--s->restart_count) {
1512 align_get_bits(&s->gb);
1513 skip_bits(&s->gb, 16); /* skip RSTn */
1514 for (i=0; i<nb_components; i++) /* reset dc */
1515 s->last_dc[i] = 1024;
1522 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1524 int len, nb_components, i, h, v, predictor, point_transform;
1525 int vmax, hmax, index, id;
1526 const int block_size= s->lossless ? 1 : 8;
1529 /* XXX: verify len field validity */
1530 len = get_bits(&s->gb, 16);
1531 nb_components = get_bits(&s->gb, 8);
1532 if (len != 6+2*nb_components)
1534 dprintf("decode_sos: invalid len (%d)\n", len);
1537 /* XXX: only interleaved scan accepted */
1538 if ((nb_components != s->nb_components) && !s->ls)
1540 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1545 for(i=0;i<nb_components;i++) {
1546 id = get_bits(&s->gb, 8) - 1;
1547 dprintf("component: %d\n", id);
1548 /* find component index */
1549 for(index=0;index<s->nb_components;index++)
1550 if (id == s->component_id[index])
1552 if (index == s->nb_components)
1554 dprintf("decode_sos: index(%d) out of components\n", index);
1558 s->comp_index[i] = index;
1560 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1561 s->h_scount[i] = s->h_count[index];
1562 s->v_scount[i] = s->v_count[index];
1564 s->dc_index[i] = get_bits(&s->gb, 4);
1565 s->ac_index[i] = get_bits(&s->gb, 4);
1567 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1568 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1571 switch(s->start_code)
1574 if (dc_index[i] > 1 || ac_index[i] > 1)
1579 if (dc_index[i] > 3 || ac_index[i] > 3)
1583 if (dc_index[i] > 3 || ac_index[i] != 0)
1590 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1591 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1592 skip_bits(&s->gb, 4); /* Ah */
1593 point_transform= get_bits(&s->gb, 4); /* Al */
1595 for(i=0;i<nb_components;i++)
1596 s->last_dc[i] = 1024;
1598 if (nb_components > 1) {
1599 /* interleaved stream */
1600 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1601 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1602 } else if(!s->ls) { /* skip this for JPEG-LS */
1603 h = s->h_max / s->h_scount[s->comp_index[0]];
1604 v = s->v_max / s->v_scount[s->comp_index[0]];
1605 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1606 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1607 s->nb_blocks[0] = 1;
1612 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1613 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" : "",
1614 predictor, point_transform, ilv, s->bits,
1615 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1618 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1619 for (i = s->mjpb_skiptosod; i > 0; i--)
1620 skip_bits(&s->gb, 8);
1625 // reset_ls_coding_parameters(s, 0);
1627 ls_decode_picture(s, predictor, point_transform, ilv);
1630 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1633 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1638 if(mjpeg_decode_scan(s) < 0)
1644 dprintf("decode_sos: ac/dc index out of range\n");
1648 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1650 if (get_bits(&s->gb, 16) != 4)
1652 s->restart_interval = get_bits(&s->gb, 16);
1653 s->restart_count = 0;
1654 dprintf("restart interval: %d\n", s->restart_interval);
1659 static int mjpeg_decode_app(MJpegDecodeContext *s)
1663 len = get_bits(&s->gb, 16);
1666 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1669 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1673 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1674 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1677 /* buggy AVID, it puts EOI only at every 10th frame */
1678 /* also this fourcc is used by non-avid files too, it holds some
1679 informations, but it's always present in AVID creates files */
1680 if (id == ff_get_fourcc("AVI1"))
1687 4bytes field_size_less_padding
1690 // if (s->first_picture)
1691 // printf("mjpeg: workarounding buggy AVID\n");
1692 s->interlace_polarity = get_bits(&s->gb, 8);
1694 skip_bits(&s->gb, 8);
1695 skip_bits(&s->gb, 32);
1696 skip_bits(&s->gb, 32);
1699 // if (s->interlace_polarity)
1700 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1706 if (id == ff_get_fourcc("JFIF"))
1708 int t_w, t_h, v1, v2;
1709 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1710 v1= get_bits(&s->gb, 8);
1711 v2= get_bits(&s->gb, 8);
1712 skip_bits(&s->gb, 8);
1714 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1715 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1717 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1720 s->avctx->sample_aspect_ratio.num,
1721 s->avctx->sample_aspect_ratio.den
1724 t_w = get_bits(&s->gb, 8);
1725 t_h = get_bits(&s->gb, 8);
1728 /* skip thumbnail */
1729 if (len-10-(t_w*t_h*3) > 0)
1736 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1738 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1739 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1740 skip_bits(&s->gb, 16); /* version */
1741 skip_bits(&s->gb, 16); /* flags0 */
1742 skip_bits(&s->gb, 16); /* flags1 */
1743 skip_bits(&s->gb, 8); /* transform */
1748 if (id == ff_get_fourcc("LJIF")){
1749 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1750 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1751 skip_bits(&s->gb, 16); /* version ? */
1752 skip_bits(&s->gb, 16); /* unknwon always 0? */
1753 skip_bits(&s->gb, 16); /* unknwon always 0? */
1754 skip_bits(&s->gb, 16); /* unknwon always 0? */
1755 switch( get_bits(&s->gb, 8)){
1765 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1772 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1774 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1777 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1780 skip_bits(&s->gb, 32); /* field size */
1781 skip_bits(&s->gb, 32); /* pad field size */
1782 skip_bits(&s->gb, 32); /* next off */
1783 skip_bits(&s->gb, 32); /* quant off */
1784 skip_bits(&s->gb, 32); /* huff off */
1785 skip_bits(&s->gb, 32); /* image off */
1786 skip_bits(&s->gb, 32); /* scan off */
1787 skip_bits(&s->gb, 32); /* data off */
1789 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1790 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1795 /* slow but needed for extreme adobe jpegs */
1797 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1799 skip_bits(&s->gb, 8);
1804 static int mjpeg_decode_com(MJpegDecodeContext *s)
1806 int len = get_bits(&s->gb, 16);
1807 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1808 uint8_t *cbuf = av_malloc(len - 1);
1811 for (i = 0; i < len - 2; i++)
1812 cbuf[i] = get_bits(&s->gb, 8);
1813 if (i > 0 && cbuf[i-1] == '\n')
1818 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1819 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1821 /* buggy avid, it puts EOI only at every 10th frame */
1822 if (!strcmp(cbuf, "AVID"))
1825 // if (s->first_picture)
1826 // printf("mjpeg: workarounding buggy AVID\n");
1828 else if(!strcmp(cbuf, "CS=ITU601")){
1840 static int valid_marker_list[] =
1842 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1843 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1852 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1853 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1854 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1856 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1857 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1858 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1862 /* return the 8 bit start code value and update the search
1863 state. Return -1 if no start code found */
1864 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1873 buf_ptr = *pbuf_ptr;
1874 while (buf_ptr < buf_end) {
1877 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1888 dprintf("find_marker skipped %d bytes\n", skipped);
1890 *pbuf_ptr = buf_ptr;
1894 static int mjpeg_decode_frame(AVCodecContext *avctx,
1895 void *data, int *data_size,
1896 uint8_t *buf, int buf_size)
1898 MJpegDecodeContext *s = avctx->priv_data;
1899 uint8_t *buf_end, *buf_ptr;
1901 AVFrame *picture = data;
1904 buf_end = buf + buf_size;
1905 while (buf_ptr < buf_end) {
1906 /* find start next marker */
1907 start_code = find_marker(&buf_ptr, buf_end);
1910 if (start_code < 0) {
1913 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1915 if ((buf_end - buf_ptr) > s->buffer_size)
1918 s->buffer_size = buf_end-buf_ptr;
1919 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1920 dprintf("buffer too small, expanding to %d bytes\n",
1924 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1925 if (start_code == SOS && !s->ls)
1927 uint8_t *src = buf_ptr;
1928 uint8_t *dst = s->buffer;
1932 uint8_t x = *(src++);
1937 while(src<buf_end && x == 0xff)
1940 if (x >= 0xd0 && x <= 0xd7)
1946 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1948 dprintf("escaping removed %d bytes\n",
1949 (buf_end - buf_ptr) - (dst - s->buffer));
1951 else if(start_code == SOS && s->ls){
1952 uint8_t *src = buf_ptr;
1953 uint8_t *dst = s->buffer;
1961 while (src + t < buf_end){
1962 uint8_t x = src[t++];
1964 while((src + t < buf_end) && x == 0xff)
1974 init_put_bits(&pb, dst, t);
1976 /* unescape bitstream */
1978 uint8_t x = src[b++];
1979 put_bits(&pb, 8, x);
1982 put_bits(&pb, 7, x);
1986 flush_put_bits(&pb);
1988 init_get_bits(&s->gb, dst, bit_count);
1991 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1993 s->start_code = start_code;
1994 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1995 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1998 /* process markers */
1999 if (start_code >= 0xd0 && start_code <= 0xd7) {
2000 dprintf("restart marker: %d\n", start_code&0x0f);
2002 } else if (start_code >= APP0 && start_code <= APP15) {
2003 mjpeg_decode_app(s);
2005 } else if (start_code == COM){
2006 mjpeg_decode_com(s);
2009 switch(start_code) {
2011 s->restart_interval = 0;
2013 s->restart_count = 0;
2014 /* nothing to do on SOI */
2017 mjpeg_decode_dqt(s);
2020 if(mjpeg_decode_dht(s) < 0){
2021 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2027 if (mjpeg_decode_sof(s) < 0)
2032 if (mjpeg_decode_sof(s) < 0)
2038 if (mjpeg_decode_sof(s) < 0)
2042 if (decode_lse(s) < 0)
2046 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2050 if (s->interlaced) {
2051 s->bottom_field ^= 1;
2052 /* if not bottom field, do not output image yet */
2053 if (s->bottom_field)
2056 *picture = s->picture;
2057 *data_size = sizeof(AVFrame);
2060 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2061 picture->qstride= 0;
2062 picture->qscale_table= s->qscale_table;
2063 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2064 if(avctx->debug & FF_DEBUG_QP)
2065 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2066 picture->quality*= FF_QP2LAMBDA;
2073 mjpeg_decode_sos(s);
2074 /* buggy avid puts EOI every 10-20th frame */
2075 /* if restart period is over process EOI */
2076 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2080 mjpeg_decode_dri(s);
2094 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2097 // printf("mjpeg: unsupported marker (%x)\n", start_code);
2102 /* eof process start code */
2103 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2104 dprintf("marker parser used %d bytes (%d bits)\n",
2105 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2110 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2111 // return buf_end - buf_ptr;
2112 return buf_ptr - buf;
2115 static int mjpegb_decode_frame(AVCodecContext *avctx,
2116 void *data, int *data_size,
2117 uint8_t *buf, int buf_size)
2119 MJpegDecodeContext *s = avctx->priv_data;
2120 uint8_t *buf_end, *buf_ptr;
2121 AVFrame *picture = data;
2122 GetBitContext hgb; /* for the header */
2123 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2124 uint32_t field_size, sod_offs;
2127 buf_end = buf + buf_size;
2130 /* reset on every SOI */
2131 s->restart_interval = 0;
2132 s->restart_count = 0;
2133 s->mjpb_skiptosod = 0;
2135 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2137 skip_bits(&hgb, 32); /* reserved zeros */
2139 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2141 dprintf("not mjpeg-b (bad fourcc)\n");
2145 field_size = get_bits_long(&hgb, 32); /* field size */
2146 dprintf("field size: 0x%x\n", field_size);
2147 skip_bits(&hgb, 32); /* padded field size */
2148 second_field_offs = get_bits_long(&hgb, 32);
2149 dprintf("second field offs: 0x%x\n", second_field_offs);
2150 if (second_field_offs)
2153 dqt_offs = get_bits_long(&hgb, 32);
2154 dprintf("dqt offs: 0x%x\n", dqt_offs);
2157 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2158 s->start_code = DQT;
2159 mjpeg_decode_dqt(s);
2162 dht_offs = get_bits_long(&hgb, 32);
2163 dprintf("dht offs: 0x%x\n", dht_offs);
2166 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2167 s->start_code = DHT;
2168 mjpeg_decode_dht(s);
2171 sof_offs = get_bits_long(&hgb, 32);
2172 dprintf("sof offs: 0x%x\n", sof_offs);
2175 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2176 s->start_code = SOF0;
2177 if (mjpeg_decode_sof(s) < 0)
2181 sos_offs = get_bits_long(&hgb, 32);
2182 dprintf("sos offs: 0x%x\n", sos_offs);
2183 sod_offs = get_bits_long(&hgb, 32);
2184 dprintf("sod offs: 0x%x\n", sod_offs);
2187 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2188 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2189 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2190 s->start_code = SOS;
2191 mjpeg_decode_sos(s);
2194 if (s->interlaced) {
2195 s->bottom_field ^= 1;
2196 /* if not bottom field, do not output image yet */
2197 if (s->bottom_field && second_field_offs)
2199 buf_ptr = buf + second_field_offs;
2200 second_field_offs = 0;
2205 //XXX FIXME factorize, this looks very similar to the EOI code
2207 *picture= s->picture;
2208 *data_size = sizeof(AVFrame);
2211 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2212 picture->qstride= 0;
2213 picture->qscale_table= s->qscale_table;
2214 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2215 if(avctx->debug & FF_DEBUG_QP)
2216 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2217 picture->quality*= FF_QP2LAMBDA;
2220 return buf_ptr - buf;
2225 static int sp5x_decode_frame(AVCodecContext *avctx,
2226 void *data, int *data_size,
2227 uint8_t *buf, int buf_size)
2230 MJpegDecodeContext *s = avctx->priv_data;
2232 const int qscale = 5;
2233 uint8_t *buf_ptr, *buf_end, *recoded;
2236 if (!avctx->width || !avctx->height)
2240 buf_end = buf + buf_size;
2243 recoded = av_mallocz(buf_size + 1024);
2248 recoded[j++] = 0xFF;
2249 recoded[j++] = 0xD8;
2251 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2252 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2253 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2254 j += sizeof(sp5x_data_dqt);
2256 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2257 j += sizeof(sp5x_data_dht);
2259 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2260 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2261 recoded[j+6] = avctx->coded_height & 0xFF;
2262 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2263 recoded[j+8] = avctx->coded_width & 0xFF;
2264 j += sizeof(sp5x_data_sof);
2266 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2267 j += sizeof(sp5x_data_sos);
2269 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2271 recoded[j++] = buf[i];
2277 recoded[j++] = 0xFF;
2278 recoded[j++] = 0xD9;
2280 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2287 s->width = avctx->coded_width;
2288 s->height = avctx->coded_height;
2289 s->nb_components = 3;
2290 s->component_id[0] = 0;
2293 s->quant_index[0] = 0;
2294 s->component_id[1] = 1;
2297 s->quant_index[1] = 1;
2298 s->component_id[2] = 2;
2301 s->quant_index[2] = 1;
2305 s->qscale_table = av_mallocz((s->width+15)/16);
2306 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2309 s->picture.reference = 0;
2310 if (avctx->get_buffer(avctx, &s->picture) < 0)
2312 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2316 s->picture.pict_type = I_TYPE;
2317 s->picture.key_frame = 1;
2319 for (i = 0; i < 3; i++)
2320 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2323 for (i = 0; i < 64; i++)
2325 j = s->scantable.permutated[i];
2326 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2328 s->qscale[0] = FFMAX(
2329 s->quant_matrixes[0][s->scantable.permutated[1]],
2330 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2332 for (i = 0; i < 64; i++)
2334 j = s->scantable.permutated[i];
2335 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2337 s->qscale[1] = FFMAX(
2338 s->quant_matrixes[1][s->scantable.permutated[1]],
2339 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2344 s->comp_index[0] = 0;
2345 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2346 s->h_scount[0] = s->h_count[0];
2347 s->v_scount[0] = s->v_count[0];
2351 s->comp_index[1] = 1;
2352 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2353 s->h_scount[1] = s->h_count[1];
2354 s->v_scount[1] = s->v_count[1];
2358 s->comp_index[2] = 2;
2359 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2360 s->h_scount[2] = s->h_count[2];
2361 s->v_scount[2] = s->v_count[2];
2365 for (i = 0; i < 3; i++)
2366 s->last_dc[i] = 1024;
2368 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2369 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2371 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2373 return mjpeg_decode_scan(s);
2379 static int mjpeg_decode_end(AVCodecContext *avctx)
2381 MJpegDecodeContext *s = avctx->priv_data;
2385 av_free(s->qscale_table);
2389 free_vlc(&s->vlcs[i][j]);
2394 AVCodec mjpeg_decoder = {
2398 sizeof(MJpegDecodeContext),
2407 AVCodec mjpegb_decoder = {
2411 sizeof(MJpegDecodeContext),
2415 mjpegb_decode_frame,
2420 AVCodec sp5x_decoder = {
2424 sizeof(MJpegDecodeContext),
2433 #ifdef CONFIG_ENCODERS
2434 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2438 sizeof(MpegEncContext),
2440 encode_picture_lossless,
2445 AVCodecParser mjpeg_parser = {
2447 sizeof(ParseContext),