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 file is part of FFmpeg.
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.
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.
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
23 * Support for external huffman table, various fixes (AVID workaround),
24 * aspecting, new decode_frame mechanism and apple mjpeg-b support
25 * by Alex Beregszaszi <alex@naxine.org>
30 * MJPEG encoder and decoder.
38 #include "mpegvideo.h"
40 /* use two quantizer tables (one for luminance and one for chrominance) */
44 typedef struct MJpegContext {
45 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
46 uint16_t huff_code_dc_luminance[12];
47 uint8_t huff_size_dc_chrominance[12];
48 uint16_t huff_code_dc_chrominance[12];
50 uint8_t huff_size_ac_luminance[256];
51 uint16_t huff_code_ac_luminance[256];
52 uint8_t huff_size_ac_chrominance[256];
53 uint16_t huff_code_ac_chrominance[256];
56 /* JPEG marker codes */
59 SOF0 = 0xc0, /* baseline */
60 SOF1 = 0xc1, /* extended sequential, huffman */
61 SOF2 = 0xc2, /* progressive, huffman */
62 SOF3 = 0xc3, /* lossless, huffman */
64 SOF5 = 0xc5, /* differential sequential, huffman */
65 SOF6 = 0xc6, /* differential progressive, huffman */
66 SOF7 = 0xc7, /* differential lossless, huffman */
67 JPG = 0xc8, /* reserved for JPEG extension */
68 SOF9 = 0xc9, /* extended sequential, arithmetic */
69 SOF10 = 0xca, /* progressive, arithmetic */
70 SOF11 = 0xcb, /* lossless, arithmetic */
72 SOF13 = 0xcd, /* differential sequential, arithmetic */
73 SOF14 = 0xce, /* differential progressive, arithmetic */
74 SOF15 = 0xcf, /* differential lossless, arithmetic */
76 DHT = 0xc4, /* define huffman tables */
78 DAC = 0xcc, /* define arithmetic-coding conditioning */
80 /* restart with modulo 8 count "m" */
90 SOI = 0xd8, /* start of image */
91 EOI = 0xd9, /* end of image */
92 SOS = 0xda, /* start of scan */
93 DQT = 0xdb, /* define quantization tables */
94 DNL = 0xdc, /* define number of lines */
95 DRI = 0xdd, /* define restart interval */
96 DHP = 0xde, /* define hierarchical progression */
97 EXP = 0xdf, /* expand reference components */
123 SOF48 = 0xf7, ///< JPEG-LS
124 LSE = 0xf8, ///< JPEG-LS extension parameters
131 COM = 0xfe, /* comment */
133 TEM = 0x01, /* temporary private use for arithmetic coding */
135 /* 0x02 -> 0xbf reserved */
139 /* These are the sample quantization tables given in JPEG spec section K.1.
140 * The spec says that the values given produce "good" quality, and
141 * when divided by 2, "very good" quality.
143 static const unsigned char std_luminance_quant_tbl[64] = {
144 16, 11, 10, 16, 24, 40, 51, 61,
145 12, 12, 14, 19, 26, 58, 60, 55,
146 14, 13, 16, 24, 40, 57, 69, 56,
147 14, 17, 22, 29, 51, 87, 80, 62,
148 18, 22, 37, 56, 68, 109, 103, 77,
149 24, 35, 55, 64, 81, 104, 113, 92,
150 49, 64, 78, 87, 103, 121, 120, 101,
151 72, 92, 95, 98, 112, 100, 103, 99
153 static const unsigned char std_chrominance_quant_tbl[64] = {
154 17, 18, 24, 47, 99, 99, 99, 99,
155 18, 21, 26, 66, 99, 99, 99, 99,
156 24, 26, 56, 99, 99, 99, 99, 99,
157 47, 66, 99, 99, 99, 99, 99, 99,
158 99, 99, 99, 99, 99, 99, 99, 99,
159 99, 99, 99, 99, 99, 99, 99, 99,
160 99, 99, 99, 99, 99, 99, 99, 99,
161 99, 99, 99, 99, 99, 99, 99, 99
165 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
166 /* IMPORTANT: these are only valid for 8-bit data precision! */
167 static const uint8_t bits_dc_luminance[17] =
168 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
169 static const uint8_t val_dc_luminance[] =
170 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172 static const uint8_t bits_dc_chrominance[17] =
173 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
174 static const uint8_t val_dc_chrominance[] =
175 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
177 static const uint8_t bits_ac_luminance[17] =
178 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
179 static const uint8_t val_ac_luminance[] =
180 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
181 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
182 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
183 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
184 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
185 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
186 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
187 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
188 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
189 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
190 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
191 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
192 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
193 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
194 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
195 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
196 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
197 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
198 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
199 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
203 static const uint8_t bits_ac_chrominance[17] =
204 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
206 static const uint8_t val_ac_chrominance[] =
207 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
208 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
209 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
210 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
211 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
212 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
213 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
214 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
215 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
216 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
217 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
218 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
219 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
220 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
221 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
222 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
223 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
224 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
225 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
226 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
230 /* isn't this function nicer than the one in the libjpeg ? */
231 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
232 const uint8_t *bits_table, const uint8_t *val_table)
234 int i, j, k,nb, code, sym;
241 sym = val_table[k++];
243 huff_code[sym] = code;
250 #ifdef CONFIG_ENCODERS
251 int mjpeg_init(MpegEncContext *s)
255 m = av_malloc(sizeof(MJpegContext));
262 /* build all the huffman tables */
263 build_huffman_codes(m->huff_size_dc_luminance,
264 m->huff_code_dc_luminance,
267 build_huffman_codes(m->huff_size_dc_chrominance,
268 m->huff_code_dc_chrominance,
271 build_huffman_codes(m->huff_size_ac_luminance,
272 m->huff_code_ac_luminance,
275 build_huffman_codes(m->huff_size_ac_chrominance,
276 m->huff_code_ac_chrominance,
284 void mjpeg_close(MpegEncContext *s)
286 av_free(s->mjpeg_ctx);
288 #endif //CONFIG_ENCODERS
290 #define PREDICT(ret, topleft, top, left, predictor)\
292 case 1: ret= left; break;\
293 case 2: ret= top; break;\
294 case 3: ret= topleft; break;\
295 case 4: ret= left + top - topleft; break;\
296 case 5: ret= left + ((top - topleft)>>1); break;\
297 case 6: ret= top + ((left - topleft)>>1); break;\
299 case 7: ret= (left + top)>>1; break;\
302 #ifdef CONFIG_ENCODERS
303 static inline void put_marker(PutBitContext *p, int code)
305 put_bits(p, 8, 0xff);
306 put_bits(p, 8, code);
309 /* table_class: 0 = DC coef, 1 = AC coefs */
310 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
311 const uint8_t *bits_table, const uint8_t *value_table)
313 PutBitContext *p = &s->pb;
316 put_bits(p, 4, table_class);
317 put_bits(p, 4, table_id);
322 put_bits(p, 8, bits_table[i]);
326 put_bits(p, 8, value_table[i]);
331 static void jpeg_table_header(MpegEncContext *s)
333 PutBitContext *p = &s->pb;
340 put_bits(p, 16, 2 + 2 * (1 + 64));
342 put_bits(p, 16, 2 + 1 * (1 + 64));
344 put_bits(p, 4, 0); /* 8 bit precision */
345 put_bits(p, 4, 0); /* table 0 */
347 j = s->intra_scantable.permutated[i];
348 put_bits(p, 8, s->intra_matrix[j]);
351 put_bits(p, 4, 0); /* 8 bit precision */
352 put_bits(p, 4, 1); /* table 1 */
354 j = s->intra_scantable.permutated[i];
355 put_bits(p, 8, s->chroma_intra_matrix[j]);
363 put_bits(p, 16, 0); /* patched later */
365 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
366 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
368 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
369 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
374 static void jpeg_put_comments(MpegEncContext *s)
376 PutBitContext *p = &s->pb;
380 if (s->aspect_ratio_info /* && !lossless */)
385 ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
386 put_bits(p, 16, 0x0201); /* v 1.02 */
387 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
388 put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
389 put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
390 put_bits(p, 8, 0); /* thumbnail width */
391 put_bits(p, 8, 0); /* thumbnail height */
395 if(!(s->flags & CODEC_FLAG_BITEXACT)){
399 put_bits(p, 16, 0); /* patched later */
400 ff_put_string(p, LIBAVCODEC_IDENT, 1);
401 size = strlen(LIBAVCODEC_IDENT)+3;
406 if( s->avctx->pix_fmt == PIX_FMT_YUV420P
407 ||s->avctx->pix_fmt == PIX_FMT_YUV422P
408 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
412 put_bits(p, 16, 0); /* patched later */
413 ff_put_string(p, "CS=ITU601", 1);
414 size = strlen("CS=ITU601")+3;
420 void mjpeg_picture_header(MpegEncContext *s)
422 const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
423 const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS;
425 assert(!(ls && s->mjpeg_write_tables));
427 put_marker(&s->pb, SOI);
429 if (!s->mjpeg_data_only_frames)
431 jpeg_put_comments(s);
433 if (s->mjpeg_write_tables) jpeg_table_header(s);
435 switch(s->avctx->codec_id){
436 case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
437 case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
438 case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
442 put_bits(&s->pb, 16, 17);
443 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
444 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
446 put_bits(&s->pb, 8, 8); /* 8 bits/component */
447 put_bits(&s->pb, 16, s->height);
448 put_bits(&s->pb, 16, s->width);
449 put_bits(&s->pb, 8, 3); /* 3 components */
452 put_bits(&s->pb, 8, 1); /* component number */
453 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
454 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
455 put_bits(&s->pb, 8, 0); /* select matrix */
458 put_bits(&s->pb, 8, 2); /* component number */
459 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
460 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
462 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
464 put_bits(&s->pb, 8, 0); /* select matrix */
468 put_bits(&s->pb, 8, 3); /* component number */
469 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
470 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
472 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
474 put_bits(&s->pb, 8, 0); /* select matrix */
479 put_marker(&s->pb, SOS);
480 put_bits(&s->pb, 16, 12); /* length */
481 put_bits(&s->pb, 8, 3); /* 3 components */
484 put_bits(&s->pb, 8, 1); /* index */
485 put_bits(&s->pb, 4, 0); /* DC huffman table index */
486 put_bits(&s->pb, 4, 0); /* AC huffman table index */
489 put_bits(&s->pb, 8, 2); /* index */
490 put_bits(&s->pb, 4, 1); /* DC huffman table index */
491 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
494 put_bits(&s->pb, 8, 3); /* index */
495 put_bits(&s->pb, 4, 1); /* DC huffman table index */
496 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
498 put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
500 switch(s->avctx->codec_id){
501 case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
502 case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
503 case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */
507 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
509 //FIXME DC/AC entropy table selectors stuff in jpegls
512 static void escape_FF(MpegEncContext *s, int start)
514 int size= put_bits_count(&s->pb) - start*8;
516 uint8_t *buf= s->pb.buf + start;
517 int align= (-(size_t)(buf))&3;
519 assert((size&7) == 0);
523 for(i=0; i<size && i<align; i++){
524 if(buf[i]==0xFF) ff_count++;
526 for(; i<size-15; i+=16){
529 v= *(uint32_t*)(&buf[i]);
530 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
531 v= *(uint32_t*)(&buf[i+4]);
532 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
533 v= *(uint32_t*)(&buf[i+8]);
534 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
535 v= *(uint32_t*)(&buf[i+12]);
536 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
544 if(buf[i]==0xFF) ff_count++;
547 if(ff_count==0) return;
550 for(i=0; i<ff_count-3; i+=4)
551 put_bits(&s->pb, 32, 0);
552 put_bits(&s->pb, (ff_count-i)*8, 0);
553 flush_put_bits(&s->pb);
555 for(i=size-1; ff_count; i--){
559 //printf("%d %d\n", i, ff_count);
568 void ff_mjpeg_stuffing(PutBitContext * pbc)
571 length= (-put_bits_count(pbc))&7;
572 if(length) put_bits(pbc, length, (1<<length)-1);
575 void mjpeg_picture_trailer(MpegEncContext *s)
577 ff_mjpeg_stuffing(&s->pb);
578 flush_put_bits(&s->pb);
580 assert((s->header_bits&7)==0);
582 escape_FF(s, s->header_bits>>3);
584 put_marker(&s->pb, EOI);
587 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
588 uint8_t *huff_size, uint16_t *huff_code)
593 put_bits(&s->pb, huff_size[0], huff_code[0]);
601 nbits= av_log2_16bit(val) + 1;
603 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
605 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
609 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
611 int mant, nbits, code, i, j;
612 int component, dc, run, last_index, val;
613 MJpegContext *m = s->mjpeg_ctx;
614 uint8_t *huff_size_ac;
615 uint16_t *huff_code_ac;
618 component = (n <= 3 ? 0 : (n&1) + 1);
619 dc = block[0]; /* overflow is impossible */
620 val = dc - s->last_dc[component];
622 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
623 huff_size_ac = m->huff_size_ac_luminance;
624 huff_code_ac = m->huff_code_ac_luminance;
626 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
627 huff_size_ac = m->huff_size_ac_chrominance;
628 huff_code_ac = m->huff_code_ac_chrominance;
630 s->last_dc[component] = dc;
635 last_index = s->block_last_index[n];
636 for(i=1;i<=last_index;i++) {
637 j = s->intra_scantable.permutated[i];
643 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
652 nbits= av_log2(val) + 1;
653 code = (run << 4) | nbits;
655 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
657 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
662 /* output EOB only if not already 64 values */
663 if (last_index < 63 || run != 0)
664 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
667 void mjpeg_encode_mb(MpegEncContext *s,
668 DCTELEM block[6][64])
672 encode_block(s, block[i], i);
674 if (s->chroma_format == CHROMA_420) {
675 encode_block(s, block[5], 5);
677 encode_block(s, block[6], 6);
678 encode_block(s, block[5], 5);
679 encode_block(s, block[7], 7);
683 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
684 MpegEncContext * const s = avctx->priv_data;
685 MJpegContext * const m = s->mjpeg_ctx;
686 AVFrame *pict = data;
687 const int width= s->width;
688 const int height= s->height;
689 AVFrame * const p= (AVFrame*)&s->current_picture;
690 const int predictor= avctx->prediction_method+1;
692 init_put_bits(&s->pb, buf, buf_size);
695 p->pict_type= FF_I_TYPE;
698 mjpeg_picture_header(s);
700 s->header_bits= put_bits_count(&s->pb);
702 if(avctx->pix_fmt == PIX_FMT_RGBA32){
704 const int linesize= p->linesize[0];
705 uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
706 int left[3], top[3], topleft[3];
709 buffer[0][i]= 1 << (9 - 1);
712 for(y = 0; y < height; y++) {
713 const int modified_predictor= y ? predictor : 1;
714 uint8_t *ptr = p->data[0] + (linesize * y);
716 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
717 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
722 top[i]= left[i]= topleft[i]= buffer[0][i];
724 for(x = 0; x < width; x++) {
725 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
726 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
727 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
732 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
735 top[i]= buffer[x+1][i];
737 left[i]= buffer[x][i];
739 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
742 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
744 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
750 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
751 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
753 for(mb_y = 0; mb_y < mb_height; mb_y++) {
754 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]){
755 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
758 for(mb_x = 0; mb_x < mb_width; mb_x++) {
759 if(mb_x==0 || mb_y==0){
762 int x, y, h, v, linesize;
763 h = s->mjpeg_hsample[i];
764 v = s->mjpeg_vsample[i];
765 linesize= p->linesize[i];
771 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
780 pred= ptr[-linesize];
782 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
787 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
789 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
796 int x, y, h, v, linesize;
797 h = s->mjpeg_hsample[i];
798 v = s->mjpeg_vsample[i];
799 linesize= p->linesize[i];
805 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
806 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
807 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
810 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
812 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
823 mjpeg_picture_trailer(s);
826 flush_put_bits(&s->pb);
827 return pbBufPtr(&s->pb) - s->pb.buf;
828 // return (put_bits_count(&f->pb)+7)/8;
831 #endif //CONFIG_ENCODERS
833 /******************************************/
836 #define MAX_COMPONENTS 4
838 typedef struct MJpegDecodeContext {
839 AVCodecContext *avctx;
841 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
843 int start_code; /* current start code */
847 int16_t quant_matrixes[4][64];
849 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
851 int org_height; /* size given at codec init */
852 int first_picture; /* true if decoding first picture */
853 int interlaced; /* true if interlaced */
854 int bottom_field; /* true if bottom field */
858 int rct; /* standard rct */
859 int pegasus_rct; /* pegasus reversible colorspace transform */
860 int bits; /* bits per component */
863 int near; ///< near lossless bound (si 0 for lossless)
865 int reset; ///< context halfing intervall ?rename
868 int mb_width, mb_height;
870 int component_id[MAX_COMPONENTS];
871 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
872 int v_count[MAX_COMPONENTS];
873 int comp_index[MAX_COMPONENTS];
874 int dc_index[MAX_COMPONENTS];
875 int ac_index[MAX_COMPONENTS];
876 int nb_blocks[MAX_COMPONENTS];
877 int h_scount[MAX_COMPONENTS];
878 int v_scount[MAX_COMPONENTS];
879 int h_max, v_max; /* maximum h and v counts */
880 int quant_index[4]; /* quant table index for each component */
881 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
882 AVFrame picture; /* picture structure */
883 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
884 int8_t *qscale_table;
885 DECLARE_ALIGNED_8(DCTELEM, block[64]);
887 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
889 int restart_interval;
894 int interlace_polarity;
898 int cur_scan; /* current scan, used by JPEG-LS */
899 } MJpegDecodeContext;
901 #include "jpeg_ls.c" //FIXME make jpeg-ls more independant
903 static int mjpeg_decode_dht(MJpegDecodeContext *s);
905 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
906 int nb_codes, int use_static, int is_ac)
908 uint8_t huff_size[256+16];
909 uint16_t huff_code[256+16];
911 assert(nb_codes <= 256);
913 memset(huff_size, 0, sizeof(huff_size));
914 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
917 memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
918 memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
919 memset(huff_size, 0, sizeof(uint8_t)*16);
920 memset(huff_code, 0, sizeof(uint16_t)*16);
924 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
927 static int mjpeg_decode_init(AVCodecContext *avctx)
929 MJpegDecodeContext *s = avctx->priv_data;
931 memset(s, 0, sizeof(MJpegDecodeContext));
935 /* ugly way to get the idct & scantable FIXME */
936 memset(&s2, 0, sizeof(MpegEncContext));
938 // s2->out_format = FMT_MJPEG;
939 dsputil_init(&s2.dsp, avctx);
940 DCT_common_init(&s2);
942 s->scantable= s2.intra_scantable;
943 s->idct_put= s2.dsp.idct_put;
945 s->mpeg_enc_ctx_allocated = 0;
949 s->first_picture = 1;
950 s->org_height = avctx->coded_height;
952 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
953 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
954 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
955 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
957 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
959 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
960 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
962 /* should check for error - but dunno */
970 * finds the end of the current frame in the bitstream.
971 * @return the position of the first byte of the next frame, or -1
973 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
977 vop_found= pc->frame_start_found;
982 for(i=0; i<buf_size; i++){
983 state= (state<<8) | buf[i];
993 /* EOF considered as end of frame */
996 for(; i<buf_size; i++){
997 state= (state<<8) | buf[i];
999 pc->frame_start_found=0;
1005 pc->frame_start_found= vop_found;
1007 return END_NOT_FOUND;
1010 static int jpeg_parse(AVCodecParserContext *s,
1011 AVCodecContext *avctx,
1012 uint8_t **poutbuf, int *poutbuf_size,
1013 const uint8_t *buf, int buf_size)
1015 ParseContext *pc = s->priv_data;
1018 next= find_frame_end(pc, buf, buf_size);
1020 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1026 *poutbuf = (uint8_t *)buf;
1027 *poutbuf_size = buf_size;
1031 /* quantize tables */
1032 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1034 int len, index, i, j;
1036 len = get_bits(&s->gb, 16) - 2;
1039 /* only 8 bit precision handled */
1040 if (get_bits(&s->gb, 4) != 0)
1042 dprintf("dqt: 16bit precision\n");
1045 index = get_bits(&s->gb, 4);
1048 dprintf("index=%d\n", index);
1049 /* read quant table */
1051 j = s->scantable.permutated[i];
1052 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1055 //XXX FIXME finetune, and perhaps add dc too
1056 s->qscale[index]= FFMAX(
1057 s->quant_matrixes[index][s->scantable.permutated[1]],
1058 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1059 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1066 /* decode huffman tables and build VLC decoders */
1067 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1069 int len, index, i, class, n, v, code_max;
1070 uint8_t bits_table[17];
1071 uint8_t val_table[256];
1073 len = get_bits(&s->gb, 16) - 2;
1078 class = get_bits(&s->gb, 4);
1081 index = get_bits(&s->gb, 4);
1085 for(i=1;i<=16;i++) {
1086 bits_table[i] = get_bits(&s->gb, 8);
1090 if (len < n || n > 256)
1095 v = get_bits(&s->gb, 8);
1102 /* build VLC and flush previous vlc if present */
1103 free_vlc(&s->vlcs[class][index]);
1104 dprintf("class=%d index=%d nb_codes=%d\n",
1105 class, index, code_max + 1);
1106 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1113 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1115 int len, nb_components, i, width, height, pix_fmt_id;
1117 /* XXX: verify len field validity */
1118 len = get_bits(&s->gb, 16);
1119 s->bits= get_bits(&s->gb, 8);
1121 if(s->pegasus_rct) s->bits=9;
1122 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1124 if (s->bits != 8 && !s->lossless){
1125 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1129 height = get_bits(&s->gb, 16);
1130 width = get_bits(&s->gb, 16);
1132 dprintf("sof0: picture: %dx%d\n", width, height);
1133 if(avcodec_check_dimensions(s->avctx, width, height))
1136 nb_components = get_bits(&s->gb, 8);
1137 if (nb_components <= 0 ||
1138 nb_components > MAX_COMPONENTS)
1140 if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1141 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1144 s->nb_components = nb_components;
1147 for(i=0;i<nb_components;i++) {
1149 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1150 s->h_count[i] = get_bits(&s->gb, 4);
1151 s->v_count[i] = get_bits(&s->gb, 4);
1152 /* compute hmax and vmax (only used in interleaved case) */
1153 if (s->h_count[i] > s->h_max)
1154 s->h_max = s->h_count[i];
1155 if (s->v_count[i] > s->v_max)
1156 s->v_max = s->v_count[i];
1157 s->quant_index[i] = get_bits(&s->gb, 8);
1158 if (s->quant_index[i] >= 4)
1160 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1161 s->v_count[i], s->component_id[i], s->quant_index[i]);
1164 if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1165 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1169 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1171 /* if different size, realloc/alloc picture */
1172 /* XXX: also check h_count and v_count */
1173 if (width != s->width || height != s->height) {
1174 av_freep(&s->qscale_table);
1179 /* test interlaced mode */
1180 if (s->first_picture &&
1181 s->org_height != 0 &&
1182 s->height < ((s->org_height * 3) / 4)) {
1184 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1185 s->bottom_field = 0;
1189 avcodec_set_dimensions(s->avctx, width, height);
1191 s->qscale_table= av_mallocz((s->width+15)/16);
1193 s->first_picture = 0;
1196 if(s->interlaced && s->bottom_field)
1199 /* XXX: not complete test ! */
1200 pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1201 (s->h_count[1] << 12) | (s->v_count[1] << 8) |
1202 (s->h_count[2] << 4) | s->v_count[2];
1203 dprintf("pix fmt id %x\n", pix_fmt_id);
1208 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1209 }else if(s->nb_components==3)
1210 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1212 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1216 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1220 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1224 if(s->nb_components > 1)
1225 s->avctx->pix_fmt = PIX_FMT_RGB24;
1226 else if(s->bits <= 8)
1227 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1229 s->avctx->pix_fmt = PIX_FMT_GRAY16;
1232 if(s->picture.data[0])
1233 s->avctx->release_buffer(s->avctx, &s->picture);
1235 s->picture.reference= 0;
1236 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1237 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1240 s->picture.pict_type= I_TYPE;
1241 s->picture.key_frame= 1;
1244 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1247 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1249 if (len != (8+(3*nb_components)))
1251 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1257 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1260 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1263 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1264 &s->vlcs[0][dc_index]);
1269 return get_xbits(&s->gb, code);
1274 /* decode block and dequantize */
1275 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1276 int component, int dc_index, int ac_index, int16_t *quant_matrix)
1278 int code, i, j, level, val;
1281 val = mjpeg_decode_dc(s, dc_index);
1282 if (val == 0xffff) {
1283 dprintf("error dc\n");
1286 val = val * quant_matrix[0] + s->last_dc[component];
1287 s->last_dc[component] = val;
1291 {OPEN_READER(re, &s->gb)
1293 UPDATE_CACHE(re, &s->gb);
1294 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1299 i += ((unsigned)code) >> 4;
1302 if(code > MIN_CACHE_BITS - 16){
1303 UPDATE_CACHE(re, &s->gb)
1306 int cache=GET_CACHE(re,&s->gb);
1307 int sign=(~cache)>>31;
1308 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1311 LAST_SKIP_BITS(re, &s->gb, code)
1315 j = s->scantable.permutated[63];
1316 block[j] = level * quant_matrix[j];
1319 dprintf("error count: %d\n", i);
1322 j = s->scantable.permutated[i];
1323 block[j] = level * quant_matrix[j];
1326 CLOSE_READER(re, &s->gb)}
1331 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1333 uint16_t buffer[32768][4];
1334 int left[3], top[3], topleft[3];
1335 const int linesize= s->linesize[0];
1336 const int mask= (1<<s->bits)-1;
1338 if((unsigned)s->mb_width > 32768) //dynamic alloc
1342 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1344 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1345 const int modified_predictor= mb_y ? predictor : 1;
1346 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1348 if (s->interlaced && s->bottom_field)
1349 ptr += linesize >> 1;
1352 top[i]= left[i]= topleft[i]= buffer[0][i];
1354 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1355 if (s->restart_interval && !s->restart_count)
1356 s->restart_count = s->restart_interval;
1362 top[i]= buffer[mb_x][i];
1364 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1367 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1370 if (s->restart_interval && !--s->restart_count) {
1371 align_get_bits(&s->gb);
1372 skip_bits(&s->gb, 16); /* skip RSTn */
1377 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1378 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1379 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1380 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1382 }else if(s->pegasus_rct){
1383 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1384 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1385 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1386 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1389 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1390 ptr[4*mb_x+0] = buffer[mb_x][0];
1391 ptr[4*mb_x+1] = buffer[mb_x][1];
1392 ptr[4*mb_x+2] = buffer[mb_x][2];
1399 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1401 const int nb_components=3;
1403 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1404 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1405 if (s->restart_interval && !s->restart_count)
1406 s->restart_count = s->restart_interval;
1408 if(mb_x==0 || mb_y==0 || s->interlaced){
1409 for(i=0;i<nb_components;i++) {
1411 int n, h, v, x, y, c, j, linesize;
1412 n = s->nb_blocks[i];
1413 c = s->comp_index[i];
1418 linesize= s->linesize[c];
1420 for(j=0; j<n; j++) {
1423 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1424 if(y==0 && mb_y==0){
1425 if(x==0 && mb_x==0){
1426 pred= 128 << point_transform;
1431 if(x==0 && mb_x==0){
1432 pred= ptr[-linesize];
1434 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1438 if (s->interlaced && s->bottom_field)
1439 ptr += linesize >> 1;
1440 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1449 for(i=0;i<nb_components;i++) {
1451 int n, h, v, x, y, c, j, linesize;
1452 n = s->nb_blocks[i];
1453 c = s->comp_index[i];
1458 linesize= s->linesize[c];
1460 for(j=0; j<n; j++) {
1463 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1464 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1465 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1473 if (s->restart_interval && !--s->restart_count) {
1474 align_get_bits(&s->gb);
1475 skip_bits(&s->gb, 16); /* skip RSTn */
1482 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1484 const int nb_components=3;
1486 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1487 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1488 if (s->restart_interval && !s->restart_count)
1489 s->restart_count = s->restart_interval;
1491 for(i=0;i<nb_components;i++) {
1493 int n, h, v, x, y, c, j;
1494 n = s->nb_blocks[i];
1495 c = s->comp_index[i];
1501 memset(s->block, 0, sizeof(s->block));
1502 if (decode_block(s, s->block, i,
1503 s->dc_index[i], s->ac_index[i],
1504 s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1505 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1508 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1509 ptr = s->picture.data[c] +
1510 (((s->linesize[c] * (v * mb_y + y) * 8) +
1511 (h * mb_x + x) * 8) >> s->avctx->lowres);
1512 if (s->interlaced && s->bottom_field)
1513 ptr += s->linesize[c] >> 1;
1514 //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);
1515 s->idct_put(ptr, s->linesize[c], s->block);
1522 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1523 if (s->restart_interval && (s->restart_interval < 1350) &&
1524 !--s->restart_count) {
1525 align_get_bits(&s->gb);
1526 skip_bits(&s->gb, 16); /* skip RSTn */
1527 for (i=0; i<nb_components; i++) /* reset dc */
1528 s->last_dc[i] = 1024;
1535 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1537 int len, nb_components, i, h, v, predictor, point_transform;
1538 int vmax, hmax, index, id;
1539 const int block_size= s->lossless ? 1 : 8;
1542 /* XXX: verify len field validity */
1543 len = get_bits(&s->gb, 16);
1544 nb_components = get_bits(&s->gb, 8);
1545 if (len != 6+2*nb_components)
1547 dprintf("decode_sos: invalid len (%d)\n", len);
1550 /* XXX: only interleaved scan accepted */
1551 if ((nb_components != s->nb_components) && !s->ls)
1553 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1558 for(i=0;i<nb_components;i++) {
1559 id = get_bits(&s->gb, 8) - 1;
1560 dprintf("component: %d\n", id);
1561 /* find component index */
1562 for(index=0;index<s->nb_components;index++)
1563 if (id == s->component_id[index])
1565 if (index == s->nb_components)
1567 dprintf("decode_sos: index(%d) out of components\n", index);
1571 s->comp_index[i] = index;
1573 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1574 s->h_scount[i] = s->h_count[index];
1575 s->v_scount[i] = s->v_count[index];
1577 s->dc_index[i] = get_bits(&s->gb, 4);
1578 s->ac_index[i] = get_bits(&s->gb, 4);
1580 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1581 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1584 switch(s->start_code)
1587 if (dc_index[i] > 1 || ac_index[i] > 1)
1592 if (dc_index[i] > 3 || ac_index[i] > 3)
1596 if (dc_index[i] > 3 || ac_index[i] != 0)
1603 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1604 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1605 skip_bits(&s->gb, 4); /* Ah */
1606 point_transform= get_bits(&s->gb, 4); /* Al */
1608 for(i=0;i<nb_components;i++)
1609 s->last_dc[i] = 1024;
1611 if (nb_components > 1) {
1612 /* interleaved stream */
1613 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1614 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1615 } else if(!s->ls) { /* skip this for JPEG-LS */
1616 h = s->h_max / s->h_scount[s->comp_index[0]];
1617 v = s->v_max / s->v_scount[s->comp_index[0]];
1618 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1619 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1620 s->nb_blocks[0] = 1;
1625 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1626 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" : "",
1627 predictor, point_transform, ilv, s->bits,
1628 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1631 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1632 for (i = s->mjpb_skiptosod; i > 0; i--)
1633 skip_bits(&s->gb, 8);
1638 // reset_ls_coding_parameters(s, 0);
1640 ls_decode_picture(s, predictor, point_transform, ilv);
1643 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1646 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1651 if(mjpeg_decode_scan(s) < 0)
1657 dprintf("decode_sos: ac/dc index out of range\n");
1661 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1663 if (get_bits(&s->gb, 16) != 4)
1665 s->restart_interval = get_bits(&s->gb, 16);
1666 s->restart_count = 0;
1667 dprintf("restart interval: %d\n", s->restart_interval);
1672 static int mjpeg_decode_app(MJpegDecodeContext *s)
1676 len = get_bits(&s->gb, 16);
1679 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1682 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1686 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1687 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1690 /* buggy AVID, it puts EOI only at every 10th frame */
1691 /* also this fourcc is used by non-avid files too, it holds some
1692 informations, but it's always present in AVID creates files */
1693 if (id == ff_get_fourcc("AVI1"))
1700 4bytes field_size_less_padding
1703 // if (s->first_picture)
1704 // printf("mjpeg: workarounding buggy AVID\n");
1705 s->interlace_polarity = get_bits(&s->gb, 8);
1707 skip_bits(&s->gb, 8);
1708 skip_bits(&s->gb, 32);
1709 skip_bits(&s->gb, 32);
1712 // if (s->interlace_polarity)
1713 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1719 if (id == ff_get_fourcc("JFIF"))
1721 int t_w, t_h, v1, v2;
1722 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1723 v1= get_bits(&s->gb, 8);
1724 v2= get_bits(&s->gb, 8);
1725 skip_bits(&s->gb, 8);
1727 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1728 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1730 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1731 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1733 s->avctx->sample_aspect_ratio.num,
1734 s->avctx->sample_aspect_ratio.den
1737 t_w = get_bits(&s->gb, 8);
1738 t_h = get_bits(&s->gb, 8);
1741 /* skip thumbnail */
1742 if (len-10-(t_w*t_h*3) > 0)
1749 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1751 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1752 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1753 skip_bits(&s->gb, 16); /* version */
1754 skip_bits(&s->gb, 16); /* flags0 */
1755 skip_bits(&s->gb, 16); /* flags1 */
1756 skip_bits(&s->gb, 8); /* transform */
1761 if (id == ff_get_fourcc("LJIF")){
1762 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1763 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1764 skip_bits(&s->gb, 16); /* version ? */
1765 skip_bits(&s->gb, 16); /* unknwon always 0? */
1766 skip_bits(&s->gb, 16); /* unknwon always 0? */
1767 skip_bits(&s->gb, 16); /* unknwon always 0? */
1768 switch( get_bits(&s->gb, 8)){
1778 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1785 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1787 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1790 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1793 skip_bits(&s->gb, 32); /* field size */
1794 skip_bits(&s->gb, 32); /* pad field size */
1795 skip_bits(&s->gb, 32); /* next off */
1796 skip_bits(&s->gb, 32); /* quant off */
1797 skip_bits(&s->gb, 32); /* huff off */
1798 skip_bits(&s->gb, 32); /* image off */
1799 skip_bits(&s->gb, 32); /* scan off */
1800 skip_bits(&s->gb, 32); /* data off */
1802 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1803 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1808 /* slow but needed for extreme adobe jpegs */
1810 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1812 skip_bits(&s->gb, 8);
1817 static int mjpeg_decode_com(MJpegDecodeContext *s)
1819 int len = get_bits(&s->gb, 16);
1820 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1821 char *cbuf = av_malloc(len - 1);
1824 for (i = 0; i < len - 2; i++)
1825 cbuf[i] = get_bits(&s->gb, 8);
1826 if (i > 0 && cbuf[i-1] == '\n')
1831 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1832 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1834 /* buggy avid, it puts EOI only at every 10th frame */
1835 if (!strcmp(cbuf, "AVID"))
1838 // if (s->first_picture)
1839 // printf("mjpeg: workarounding buggy AVID\n");
1841 else if(!strcmp(cbuf, "CS=ITU601")){
1853 static int valid_marker_list[] =
1855 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1856 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1857 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1858 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1859 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1860 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1861 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1862 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1863 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1864 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1865 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1866 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1867 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1868 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1869 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1870 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1871 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1875 /* return the 8 bit start code value and update the search
1876 state. Return -1 if no start code found */
1877 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1886 buf_ptr = *pbuf_ptr;
1887 while (buf_ptr < buf_end) {
1890 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1901 dprintf("find_marker skipped %d bytes\n", skipped);
1903 *pbuf_ptr = buf_ptr;
1907 static int mjpeg_decode_frame(AVCodecContext *avctx,
1908 void *data, int *data_size,
1909 uint8_t *buf, int buf_size)
1911 MJpegDecodeContext *s = avctx->priv_data;
1912 uint8_t *buf_end, *buf_ptr;
1914 AVFrame *picture = data;
1917 buf_end = buf + buf_size;
1918 while (buf_ptr < buf_end) {
1919 /* find start next marker */
1920 start_code = find_marker(&buf_ptr, buf_end);
1923 if (start_code < 0) {
1926 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1928 if ((buf_end - buf_ptr) > s->buffer_size)
1931 s->buffer_size = buf_end-buf_ptr;
1932 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1933 dprintf("buffer too small, expanding to %d bytes\n",
1937 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1938 if (start_code == SOS && !s->ls)
1940 uint8_t *src = buf_ptr;
1941 uint8_t *dst = s->buffer;
1945 uint8_t x = *(src++);
1950 while(src<buf_end && x == 0xff)
1953 if (x >= 0xd0 && x <= 0xd7)
1959 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1961 dprintf("escaping removed %d bytes\n",
1962 (buf_end - buf_ptr) - (dst - s->buffer));
1964 else if(start_code == SOS && s->ls){
1965 uint8_t *src = buf_ptr;
1966 uint8_t *dst = s->buffer;
1974 while (src + t < buf_end){
1975 uint8_t x = src[t++];
1977 while((src + t < buf_end) && x == 0xff)
1987 init_put_bits(&pb, dst, t);
1989 /* unescape bitstream */
1991 uint8_t x = src[b++];
1992 put_bits(&pb, 8, x);
1995 put_bits(&pb, 7, x);
1999 flush_put_bits(&pb);
2001 init_get_bits(&s->gb, dst, bit_count);
2004 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2006 s->start_code = start_code;
2007 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2008 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2011 /* process markers */
2012 if (start_code >= 0xd0 && start_code <= 0xd7) {
2013 dprintf("restart marker: %d\n", start_code&0x0f);
2015 } else if (start_code >= APP0 && start_code <= APP15) {
2016 mjpeg_decode_app(s);
2018 } else if (start_code == COM){
2019 mjpeg_decode_com(s);
2022 switch(start_code) {
2024 s->restart_interval = 0;
2026 s->restart_count = 0;
2027 /* nothing to do on SOI */
2030 mjpeg_decode_dqt(s);
2033 if(mjpeg_decode_dht(s) < 0){
2034 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2040 if (mjpeg_decode_sof(s) < 0)
2045 if (mjpeg_decode_sof(s) < 0)
2051 if (mjpeg_decode_sof(s) < 0)
2055 if (decode_lse(s) < 0)
2060 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2064 if (s->interlaced) {
2065 s->bottom_field ^= 1;
2066 /* if not bottom field, do not output image yet */
2067 if (s->bottom_field)
2070 *picture = s->picture;
2071 *data_size = sizeof(AVFrame);
2074 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2075 picture->qstride= 0;
2076 picture->qscale_table= s->qscale_table;
2077 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2078 if(avctx->debug & FF_DEBUG_QP)
2079 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2080 picture->quality*= FF_QP2LAMBDA;
2087 mjpeg_decode_sos(s);
2088 /* buggy avid puts EOI every 10-20th frame */
2089 /* if restart period is over process EOI */
2090 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2094 mjpeg_decode_dri(s);
2108 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2111 // printf("mjpeg: unsupported marker (%x)\n", start_code);
2116 /* eof process start code */
2117 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2118 dprintf("marker parser used %d bytes (%d bits)\n",
2119 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2124 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2125 // return buf_end - buf_ptr;
2126 return buf_ptr - buf;
2129 static int mjpegb_decode_frame(AVCodecContext *avctx,
2130 void *data, int *data_size,
2131 uint8_t *buf, int buf_size)
2133 MJpegDecodeContext *s = avctx->priv_data;
2134 uint8_t *buf_end, *buf_ptr;
2135 AVFrame *picture = data;
2136 GetBitContext hgb; /* for the header */
2137 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2138 uint32_t field_size, sod_offs;
2141 buf_end = buf + buf_size;
2144 /* reset on every SOI */
2145 s->restart_interval = 0;
2146 s->restart_count = 0;
2147 s->mjpb_skiptosod = 0;
2149 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2151 skip_bits(&hgb, 32); /* reserved zeros */
2153 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2155 dprintf("not mjpeg-b (bad fourcc)\n");
2159 field_size = get_bits_long(&hgb, 32); /* field size */
2160 dprintf("field size: 0x%x\n", field_size);
2161 skip_bits(&hgb, 32); /* padded field size */
2162 second_field_offs = get_bits_long(&hgb, 32);
2163 dprintf("second field offs: 0x%x\n", second_field_offs);
2164 if (second_field_offs)
2167 dqt_offs = get_bits_long(&hgb, 32);
2168 dprintf("dqt offs: 0x%x\n", dqt_offs);
2171 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2172 s->start_code = DQT;
2173 mjpeg_decode_dqt(s);
2176 dht_offs = get_bits_long(&hgb, 32);
2177 dprintf("dht offs: 0x%x\n", dht_offs);
2180 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2181 s->start_code = DHT;
2182 mjpeg_decode_dht(s);
2185 sof_offs = get_bits_long(&hgb, 32);
2186 dprintf("sof offs: 0x%x\n", sof_offs);
2189 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2190 s->start_code = SOF0;
2191 if (mjpeg_decode_sof(s) < 0)
2195 sos_offs = get_bits_long(&hgb, 32);
2196 dprintf("sos offs: 0x%x\n", sos_offs);
2197 sod_offs = get_bits_long(&hgb, 32);
2198 dprintf("sod offs: 0x%x\n", sod_offs);
2201 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2202 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2203 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2204 s->start_code = SOS;
2205 mjpeg_decode_sos(s);
2208 if (s->interlaced) {
2209 s->bottom_field ^= 1;
2210 /* if not bottom field, do not output image yet */
2211 if (s->bottom_field && second_field_offs)
2213 buf_ptr = buf + second_field_offs;
2214 second_field_offs = 0;
2219 //XXX FIXME factorize, this looks very similar to the EOI code
2221 *picture= s->picture;
2222 *data_size = sizeof(AVFrame);
2225 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2226 picture->qstride= 0;
2227 picture->qscale_table= s->qscale_table;
2228 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2229 if(avctx->debug & FF_DEBUG_QP)
2230 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2231 picture->quality*= FF_QP2LAMBDA;
2234 return buf_ptr - buf;
2239 static int sp5x_decode_frame(AVCodecContext *avctx,
2240 void *data, int *data_size,
2241 uint8_t *buf, int buf_size)
2244 MJpegDecodeContext *s = avctx->priv_data;
2246 const int qscale = 5;
2247 uint8_t *buf_ptr, *buf_end, *recoded;
2250 if (!avctx->width || !avctx->height)
2254 buf_end = buf + buf_size;
2257 recoded = av_mallocz(buf_size + 1024);
2262 recoded[j++] = 0xFF;
2263 recoded[j++] = 0xD8;
2265 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2266 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2267 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2268 j += sizeof(sp5x_data_dqt);
2270 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2271 j += sizeof(sp5x_data_dht);
2273 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2274 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2275 recoded[j+6] = avctx->coded_height & 0xFF;
2276 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2277 recoded[j+8] = avctx->coded_width & 0xFF;
2278 j += sizeof(sp5x_data_sof);
2280 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2281 j += sizeof(sp5x_data_sos);
2283 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2285 recoded[j++] = buf[i];
2291 recoded[j++] = 0xFF;
2292 recoded[j++] = 0xD9;
2294 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2301 s->width = avctx->coded_width;
2302 s->height = avctx->coded_height;
2303 s->nb_components = 3;
2304 s->component_id[0] = 0;
2307 s->quant_index[0] = 0;
2308 s->component_id[1] = 1;
2311 s->quant_index[1] = 1;
2312 s->component_id[2] = 2;
2315 s->quant_index[2] = 1;
2319 s->qscale_table = av_mallocz((s->width+15)/16);
2320 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2323 s->picture.reference = 0;
2324 if (avctx->get_buffer(avctx, &s->picture) < 0)
2326 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2330 s->picture.pict_type = I_TYPE;
2331 s->picture.key_frame = 1;
2333 for (i = 0; i < 3; i++)
2334 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2337 for (i = 0; i < 64; i++)
2339 j = s->scantable.permutated[i];
2340 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2342 s->qscale[0] = FFMAX(
2343 s->quant_matrixes[0][s->scantable.permutated[1]],
2344 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2346 for (i = 0; i < 64; i++)
2348 j = s->scantable.permutated[i];
2349 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2351 s->qscale[1] = FFMAX(
2352 s->quant_matrixes[1][s->scantable.permutated[1]],
2353 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2358 s->comp_index[0] = 0;
2359 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2360 s->h_scount[0] = s->h_count[0];
2361 s->v_scount[0] = s->v_count[0];
2365 s->comp_index[1] = 1;
2366 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2367 s->h_scount[1] = s->h_count[1];
2368 s->v_scount[1] = s->v_count[1];
2372 s->comp_index[2] = 2;
2373 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2374 s->h_scount[2] = s->h_count[2];
2375 s->v_scount[2] = s->v_count[2];
2379 for (i = 0; i < 3; i++)
2380 s->last_dc[i] = 1024;
2382 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2383 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2385 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2387 return mjpeg_decode_scan(s);
2393 static int mjpeg_decode_end(AVCodecContext *avctx)
2395 MJpegDecodeContext *s = avctx->priv_data;
2399 av_free(s->qscale_table);
2403 free_vlc(&s->vlcs[i][j]);
2408 AVCodec mjpeg_decoder = {
2412 sizeof(MJpegDecodeContext),
2421 AVCodec mjpegb_decoder = {
2425 sizeof(MJpegDecodeContext),
2429 mjpegb_decode_frame,
2434 AVCodec sp5x_decoder = {
2438 sizeof(MJpegDecodeContext),
2447 #ifdef CONFIG_ENCODERS
2448 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2452 sizeof(MpegEncContext),
2454 encode_picture_lossless,
2459 AVCodecParser mjpeg_parser = {
2461 sizeof(ParseContext),