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");
1128 if (s->bits > 8 && s->ls){
1129 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEG-LS\n");
1133 height = get_bits(&s->gb, 16);
1134 width = get_bits(&s->gb, 16);
1136 dprintf("sof0: picture: %dx%d\n", width, height);
1137 if(avcodec_check_dimensions(s->avctx, width, height))
1140 nb_components = get_bits(&s->gb, 8);
1141 if (nb_components <= 0 ||
1142 nb_components > MAX_COMPONENTS)
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;
1227 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1230 if(s->picture.data[0])
1231 s->avctx->release_buffer(s->avctx, &s->picture);
1233 s->picture.reference= 0;
1234 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1235 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1238 s->picture.pict_type= I_TYPE;
1239 s->picture.key_frame= 1;
1242 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1245 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1247 if (len != (8+(3*nb_components)))
1249 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1255 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1258 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1261 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1262 &s->vlcs[0][dc_index]);
1267 return get_xbits(&s->gb, code);
1272 /* decode block and dequantize */
1273 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1274 int component, int dc_index, int ac_index, int16_t *quant_matrix)
1276 int code, i, j, level, val;
1279 val = mjpeg_decode_dc(s, dc_index);
1280 if (val == 0xffff) {
1281 dprintf("error dc\n");
1284 val = val * quant_matrix[0] + s->last_dc[component];
1285 s->last_dc[component] = val;
1289 {OPEN_READER(re, &s->gb)
1291 UPDATE_CACHE(re, &s->gb);
1292 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1297 i += ((unsigned)code) >> 4;
1300 if(code > MIN_CACHE_BITS - 16){
1301 UPDATE_CACHE(re, &s->gb)
1304 int cache=GET_CACHE(re,&s->gb);
1305 int sign=(~cache)>>31;
1306 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1309 LAST_SKIP_BITS(re, &s->gb, code)
1313 j = s->scantable.permutated[63];
1314 block[j] = level * quant_matrix[j];
1317 dprintf("error count: %d\n", i);
1320 j = s->scantable.permutated[i];
1321 block[j] = level * quant_matrix[j];
1324 CLOSE_READER(re, &s->gb)}
1329 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1331 uint16_t buffer[32768][4];
1332 int left[3], top[3], topleft[3];
1333 const int linesize= s->linesize[0];
1334 const int mask= (1<<s->bits)-1;
1336 if((unsigned)s->mb_width > 32768) //dynamic alloc
1340 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1342 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1343 const int modified_predictor= mb_y ? predictor : 1;
1344 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1346 if (s->interlaced && s->bottom_field)
1347 ptr += linesize >> 1;
1350 top[i]= left[i]= topleft[i]= buffer[0][i];
1352 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1353 if (s->restart_interval && !s->restart_count)
1354 s->restart_count = s->restart_interval;
1360 top[i]= buffer[mb_x][i];
1362 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1365 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1368 if (s->restart_interval && !--s->restart_count) {
1369 align_get_bits(&s->gb);
1370 skip_bits(&s->gb, 16); /* skip RSTn */
1375 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1376 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1377 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1378 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1380 }else if(s->pegasus_rct){
1381 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1382 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1383 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1384 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1387 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1388 ptr[4*mb_x+0] = buffer[mb_x][0];
1389 ptr[4*mb_x+1] = buffer[mb_x][1];
1390 ptr[4*mb_x+2] = buffer[mb_x][2];
1397 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1399 const int nb_components=3;
1401 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1402 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1403 if (s->restart_interval && !s->restart_count)
1404 s->restart_count = s->restart_interval;
1406 if(mb_x==0 || mb_y==0 || s->interlaced){
1407 for(i=0;i<nb_components;i++) {
1409 int n, h, v, x, y, c, j, linesize;
1410 n = s->nb_blocks[i];
1411 c = s->comp_index[i];
1416 linesize= s->linesize[c];
1418 for(j=0; j<n; j++) {
1421 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1422 if(y==0 && mb_y==0){
1423 if(x==0 && mb_x==0){
1424 pred= 128 << point_transform;
1429 if(x==0 && mb_x==0){
1430 pred= ptr[-linesize];
1432 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1436 if (s->interlaced && s->bottom_field)
1437 ptr += linesize >> 1;
1438 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1447 for(i=0;i<nb_components;i++) {
1449 int n, h, v, x, y, c, j, linesize;
1450 n = s->nb_blocks[i];
1451 c = s->comp_index[i];
1456 linesize= s->linesize[c];
1458 for(j=0; j<n; j++) {
1461 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1462 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1463 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1471 if (s->restart_interval && !--s->restart_count) {
1472 align_get_bits(&s->gb);
1473 skip_bits(&s->gb, 16); /* skip RSTn */
1480 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1482 const int nb_components=3;
1484 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1485 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1486 if (s->restart_interval && !s->restart_count)
1487 s->restart_count = s->restart_interval;
1489 for(i=0;i<nb_components;i++) {
1491 int n, h, v, x, y, c, j;
1492 n = s->nb_blocks[i];
1493 c = s->comp_index[i];
1499 memset(s->block, 0, sizeof(s->block));
1500 if (decode_block(s, s->block, i,
1501 s->dc_index[i], s->ac_index[i],
1502 s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1503 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1506 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1507 ptr = s->picture.data[c] +
1508 (((s->linesize[c] * (v * mb_y + y) * 8) +
1509 (h * mb_x + x) * 8) >> s->avctx->lowres);
1510 if (s->interlaced && s->bottom_field)
1511 ptr += s->linesize[c] >> 1;
1512 //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);
1513 s->idct_put(ptr, s->linesize[c], s->block);
1520 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1521 if (s->restart_interval && (s->restart_interval < 1350) &&
1522 !--s->restart_count) {
1523 align_get_bits(&s->gb);
1524 skip_bits(&s->gb, 16); /* skip RSTn */
1525 for (i=0; i<nb_components; i++) /* reset dc */
1526 s->last_dc[i] = 1024;
1533 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1535 int len, nb_components, i, h, v, predictor, point_transform;
1536 int vmax, hmax, index, id;
1537 const int block_size= s->lossless ? 1 : 8;
1540 /* XXX: verify len field validity */
1541 len = get_bits(&s->gb, 16);
1542 nb_components = get_bits(&s->gb, 8);
1543 if (len != 6+2*nb_components)
1545 dprintf("decode_sos: invalid len (%d)\n", len);
1548 /* XXX: only interleaved scan accepted */
1549 if ((nb_components != s->nb_components) && !s->ls)
1551 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1556 for(i=0;i<nb_components;i++) {
1557 id = get_bits(&s->gb, 8) - 1;
1558 dprintf("component: %d\n", id);
1559 /* find component index */
1560 for(index=0;index<s->nb_components;index++)
1561 if (id == s->component_id[index])
1563 if (index == s->nb_components)
1565 dprintf("decode_sos: index(%d) out of components\n", index);
1569 s->comp_index[i] = index;
1571 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1572 s->h_scount[i] = s->h_count[index];
1573 s->v_scount[i] = s->v_count[index];
1575 s->dc_index[i] = get_bits(&s->gb, 4);
1576 s->ac_index[i] = get_bits(&s->gb, 4);
1578 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1579 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1582 switch(s->start_code)
1585 if (dc_index[i] > 1 || ac_index[i] > 1)
1590 if (dc_index[i] > 3 || ac_index[i] > 3)
1594 if (dc_index[i] > 3 || ac_index[i] != 0)
1601 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1602 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1603 skip_bits(&s->gb, 4); /* Ah */
1604 point_transform= get_bits(&s->gb, 4); /* Al */
1606 for(i=0;i<nb_components;i++)
1607 s->last_dc[i] = 1024;
1609 if (nb_components > 1) {
1610 /* interleaved stream */
1611 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1612 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1613 } else if(!s->ls) { /* skip this for JPEG-LS */
1614 h = s->h_max / s->h_scount[s->comp_index[0]];
1615 v = s->v_max / s->v_scount[s->comp_index[0]];
1616 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1617 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1618 s->nb_blocks[0] = 1;
1623 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1624 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" : "",
1625 predictor, point_transform, ilv, s->bits,
1626 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1629 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1630 for (i = s->mjpb_skiptosod; i > 0; i--)
1631 skip_bits(&s->gb, 8);
1636 // reset_ls_coding_parameters(s, 0);
1638 ls_decode_picture(s, predictor, point_transform, ilv);
1641 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1644 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1649 if(mjpeg_decode_scan(s) < 0)
1655 dprintf("decode_sos: ac/dc index out of range\n");
1659 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1661 if (get_bits(&s->gb, 16) != 4)
1663 s->restart_interval = get_bits(&s->gb, 16);
1664 s->restart_count = 0;
1665 dprintf("restart interval: %d\n", s->restart_interval);
1670 static int mjpeg_decode_app(MJpegDecodeContext *s)
1674 len = get_bits(&s->gb, 16);
1677 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1680 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1684 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1685 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1688 /* buggy AVID, it puts EOI only at every 10th frame */
1689 /* also this fourcc is used by non-avid files too, it holds some
1690 informations, but it's always present in AVID creates files */
1691 if (id == ff_get_fourcc("AVI1"))
1698 4bytes field_size_less_padding
1701 // if (s->first_picture)
1702 // printf("mjpeg: workarounding buggy AVID\n");
1703 s->interlace_polarity = get_bits(&s->gb, 8);
1705 skip_bits(&s->gb, 8);
1706 skip_bits(&s->gb, 32);
1707 skip_bits(&s->gb, 32);
1710 // if (s->interlace_polarity)
1711 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1717 if (id == ff_get_fourcc("JFIF"))
1719 int t_w, t_h, v1, v2;
1720 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1721 v1= get_bits(&s->gb, 8);
1722 v2= get_bits(&s->gb, 8);
1723 skip_bits(&s->gb, 8);
1725 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1726 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1728 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1729 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1731 s->avctx->sample_aspect_ratio.num,
1732 s->avctx->sample_aspect_ratio.den
1735 t_w = get_bits(&s->gb, 8);
1736 t_h = get_bits(&s->gb, 8);
1739 /* skip thumbnail */
1740 if (len-10-(t_w*t_h*3) > 0)
1747 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1749 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1750 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1751 skip_bits(&s->gb, 16); /* version */
1752 skip_bits(&s->gb, 16); /* flags0 */
1753 skip_bits(&s->gb, 16); /* flags1 */
1754 skip_bits(&s->gb, 8); /* transform */
1759 if (id == ff_get_fourcc("LJIF")){
1760 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1761 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1762 skip_bits(&s->gb, 16); /* version ? */
1763 skip_bits(&s->gb, 16); /* unknwon always 0? */
1764 skip_bits(&s->gb, 16); /* unknwon always 0? */
1765 skip_bits(&s->gb, 16); /* unknwon always 0? */
1766 switch( get_bits(&s->gb, 8)){
1776 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1783 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1785 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1788 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1791 skip_bits(&s->gb, 32); /* field size */
1792 skip_bits(&s->gb, 32); /* pad field size */
1793 skip_bits(&s->gb, 32); /* next off */
1794 skip_bits(&s->gb, 32); /* quant off */
1795 skip_bits(&s->gb, 32); /* huff off */
1796 skip_bits(&s->gb, 32); /* image off */
1797 skip_bits(&s->gb, 32); /* scan off */
1798 skip_bits(&s->gb, 32); /* data off */
1800 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1801 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1806 /* slow but needed for extreme adobe jpegs */
1808 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1810 skip_bits(&s->gb, 8);
1815 static int mjpeg_decode_com(MJpegDecodeContext *s)
1817 int len = get_bits(&s->gb, 16);
1818 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1819 char *cbuf = av_malloc(len - 1);
1822 for (i = 0; i < len - 2; i++)
1823 cbuf[i] = get_bits(&s->gb, 8);
1824 if (i > 0 && cbuf[i-1] == '\n')
1829 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1830 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1832 /* buggy avid, it puts EOI only at every 10th frame */
1833 if (!strcmp(cbuf, "AVID"))
1836 // if (s->first_picture)
1837 // printf("mjpeg: workarounding buggy AVID\n");
1839 else if(!strcmp(cbuf, "CS=ITU601")){
1851 static int valid_marker_list[] =
1853 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1854 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1856 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1857 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1858 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1859 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1860 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1861 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1862 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1863 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1864 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1865 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1866 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1867 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1868 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1869 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1873 /* return the 8 bit start code value and update the search
1874 state. Return -1 if no start code found */
1875 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1884 buf_ptr = *pbuf_ptr;
1885 while (buf_ptr < buf_end) {
1888 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1899 dprintf("find_marker skipped %d bytes\n", skipped);
1901 *pbuf_ptr = buf_ptr;
1905 static int mjpeg_decode_frame(AVCodecContext *avctx,
1906 void *data, int *data_size,
1907 uint8_t *buf, int buf_size)
1909 MJpegDecodeContext *s = avctx->priv_data;
1910 uint8_t *buf_end, *buf_ptr;
1912 AVFrame *picture = data;
1915 buf_end = buf + buf_size;
1916 while (buf_ptr < buf_end) {
1917 /* find start next marker */
1918 start_code = find_marker(&buf_ptr, buf_end);
1921 if (start_code < 0) {
1924 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1926 if ((buf_end - buf_ptr) > s->buffer_size)
1929 s->buffer_size = buf_end-buf_ptr;
1930 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1931 dprintf("buffer too small, expanding to %d bytes\n",
1935 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1936 if (start_code == SOS && !s->ls)
1938 uint8_t *src = buf_ptr;
1939 uint8_t *dst = s->buffer;
1943 uint8_t x = *(src++);
1948 while(src<buf_end && x == 0xff)
1951 if (x >= 0xd0 && x <= 0xd7)
1957 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1959 dprintf("escaping removed %d bytes\n",
1960 (buf_end - buf_ptr) - (dst - s->buffer));
1962 else if(start_code == SOS && s->ls){
1963 uint8_t *src = buf_ptr;
1964 uint8_t *dst = s->buffer;
1972 while (src + t < buf_end){
1973 uint8_t x = src[t++];
1975 while((src + t < buf_end) && x == 0xff)
1985 init_put_bits(&pb, dst, t);
1987 /* unescape bitstream */
1989 uint8_t x = src[b++];
1990 put_bits(&pb, 8, x);
1993 put_bits(&pb, 7, x);
1997 flush_put_bits(&pb);
1999 init_get_bits(&s->gb, dst, bit_count);
2002 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2004 s->start_code = start_code;
2005 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2006 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2009 /* process markers */
2010 if (start_code >= 0xd0 && start_code <= 0xd7) {
2011 dprintf("restart marker: %d\n", start_code&0x0f);
2013 } else if (start_code >= APP0 && start_code <= APP15) {
2014 mjpeg_decode_app(s);
2016 } else if (start_code == COM){
2017 mjpeg_decode_com(s);
2020 switch(start_code) {
2022 s->restart_interval = 0;
2024 s->restart_count = 0;
2025 /* nothing to do on SOI */
2028 mjpeg_decode_dqt(s);
2031 if(mjpeg_decode_dht(s) < 0){
2032 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2038 if (mjpeg_decode_sof(s) < 0)
2043 if (mjpeg_decode_sof(s) < 0)
2049 if (mjpeg_decode_sof(s) < 0)
2053 if (decode_lse(s) < 0)
2058 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2062 if (s->interlaced) {
2063 s->bottom_field ^= 1;
2064 /* if not bottom field, do not output image yet */
2065 if (s->bottom_field)
2068 *picture = s->picture;
2069 *data_size = sizeof(AVFrame);
2072 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2073 picture->qstride= 0;
2074 picture->qscale_table= s->qscale_table;
2075 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2076 if(avctx->debug & FF_DEBUG_QP)
2077 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2078 picture->quality*= FF_QP2LAMBDA;
2085 mjpeg_decode_sos(s);
2086 /* buggy avid puts EOI every 10-20th frame */
2087 /* if restart period is over process EOI */
2088 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2092 mjpeg_decode_dri(s);
2106 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2109 // printf("mjpeg: unsupported marker (%x)\n", start_code);
2114 /* eof process start code */
2115 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2116 dprintf("marker parser used %d bytes (%d bits)\n",
2117 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2122 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2123 // return buf_end - buf_ptr;
2124 return buf_ptr - buf;
2127 static int mjpegb_decode_frame(AVCodecContext *avctx,
2128 void *data, int *data_size,
2129 uint8_t *buf, int buf_size)
2131 MJpegDecodeContext *s = avctx->priv_data;
2132 uint8_t *buf_end, *buf_ptr;
2133 AVFrame *picture = data;
2134 GetBitContext hgb; /* for the header */
2135 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2136 uint32_t field_size, sod_offs;
2139 buf_end = buf + buf_size;
2142 /* reset on every SOI */
2143 s->restart_interval = 0;
2144 s->restart_count = 0;
2145 s->mjpb_skiptosod = 0;
2147 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2149 skip_bits(&hgb, 32); /* reserved zeros */
2151 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2153 dprintf("not mjpeg-b (bad fourcc)\n");
2157 field_size = get_bits_long(&hgb, 32); /* field size */
2158 dprintf("field size: 0x%x\n", field_size);
2159 skip_bits(&hgb, 32); /* padded field size */
2160 second_field_offs = get_bits_long(&hgb, 32);
2161 dprintf("second field offs: 0x%x\n", second_field_offs);
2162 if (second_field_offs)
2165 dqt_offs = get_bits_long(&hgb, 32);
2166 dprintf("dqt offs: 0x%x\n", dqt_offs);
2169 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2170 s->start_code = DQT;
2171 mjpeg_decode_dqt(s);
2174 dht_offs = get_bits_long(&hgb, 32);
2175 dprintf("dht offs: 0x%x\n", dht_offs);
2178 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2179 s->start_code = DHT;
2180 mjpeg_decode_dht(s);
2183 sof_offs = get_bits_long(&hgb, 32);
2184 dprintf("sof offs: 0x%x\n", sof_offs);
2187 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2188 s->start_code = SOF0;
2189 if (mjpeg_decode_sof(s) < 0)
2193 sos_offs = get_bits_long(&hgb, 32);
2194 dprintf("sos offs: 0x%x\n", sos_offs);
2195 sod_offs = get_bits_long(&hgb, 32);
2196 dprintf("sod offs: 0x%x\n", sod_offs);
2199 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2200 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2201 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2202 s->start_code = SOS;
2203 mjpeg_decode_sos(s);
2206 if (s->interlaced) {
2207 s->bottom_field ^= 1;
2208 /* if not bottom field, do not output image yet */
2209 if (s->bottom_field && second_field_offs)
2211 buf_ptr = buf + second_field_offs;
2212 second_field_offs = 0;
2217 //XXX FIXME factorize, this looks very similar to the EOI code
2219 *picture= s->picture;
2220 *data_size = sizeof(AVFrame);
2223 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2224 picture->qstride= 0;
2225 picture->qscale_table= s->qscale_table;
2226 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2227 if(avctx->debug & FF_DEBUG_QP)
2228 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2229 picture->quality*= FF_QP2LAMBDA;
2232 return buf_ptr - buf;
2237 static int sp5x_decode_frame(AVCodecContext *avctx,
2238 void *data, int *data_size,
2239 uint8_t *buf, int buf_size)
2242 MJpegDecodeContext *s = avctx->priv_data;
2244 const int qscale = 5;
2245 uint8_t *buf_ptr, *buf_end, *recoded;
2248 if (!avctx->width || !avctx->height)
2252 buf_end = buf + buf_size;
2255 recoded = av_mallocz(buf_size + 1024);
2260 recoded[j++] = 0xFF;
2261 recoded[j++] = 0xD8;
2263 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2264 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2265 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2266 j += sizeof(sp5x_data_dqt);
2268 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2269 j += sizeof(sp5x_data_dht);
2271 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2272 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2273 recoded[j+6] = avctx->coded_height & 0xFF;
2274 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2275 recoded[j+8] = avctx->coded_width & 0xFF;
2276 j += sizeof(sp5x_data_sof);
2278 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2279 j += sizeof(sp5x_data_sos);
2281 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2283 recoded[j++] = buf[i];
2289 recoded[j++] = 0xFF;
2290 recoded[j++] = 0xD9;
2292 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2299 s->width = avctx->coded_width;
2300 s->height = avctx->coded_height;
2301 s->nb_components = 3;
2302 s->component_id[0] = 0;
2305 s->quant_index[0] = 0;
2306 s->component_id[1] = 1;
2309 s->quant_index[1] = 1;
2310 s->component_id[2] = 2;
2313 s->quant_index[2] = 1;
2317 s->qscale_table = av_mallocz((s->width+15)/16);
2318 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2321 s->picture.reference = 0;
2322 if (avctx->get_buffer(avctx, &s->picture) < 0)
2324 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2328 s->picture.pict_type = I_TYPE;
2329 s->picture.key_frame = 1;
2331 for (i = 0; i < 3; i++)
2332 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2335 for (i = 0; i < 64; i++)
2337 j = s->scantable.permutated[i];
2338 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2340 s->qscale[0] = FFMAX(
2341 s->quant_matrixes[0][s->scantable.permutated[1]],
2342 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2344 for (i = 0; i < 64; i++)
2346 j = s->scantable.permutated[i];
2347 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2349 s->qscale[1] = FFMAX(
2350 s->quant_matrixes[1][s->scantable.permutated[1]],
2351 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2356 s->comp_index[0] = 0;
2357 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2358 s->h_scount[0] = s->h_count[0];
2359 s->v_scount[0] = s->v_count[0];
2363 s->comp_index[1] = 1;
2364 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2365 s->h_scount[1] = s->h_count[1];
2366 s->v_scount[1] = s->v_count[1];
2370 s->comp_index[2] = 2;
2371 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2372 s->h_scount[2] = s->h_count[2];
2373 s->v_scount[2] = s->v_count[2];
2377 for (i = 0; i < 3; i++)
2378 s->last_dc[i] = 1024;
2380 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2381 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2383 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2385 return mjpeg_decode_scan(s);
2391 static int mjpeg_decode_end(AVCodecContext *avctx)
2393 MJpegDecodeContext *s = avctx->priv_data;
2397 av_free(s->qscale_table);
2401 free_vlc(&s->vlcs[i][j]);
2406 AVCodec mjpeg_decoder = {
2410 sizeof(MJpegDecodeContext),
2419 AVCodec mjpegb_decoder = {
2423 sizeof(MJpegDecodeContext),
2427 mjpegb_decode_frame,
2432 AVCodec sp5x_decoder = {
2436 sizeof(MJpegDecodeContext),
2445 #ifdef CONFIG_ENCODERS
2446 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2450 sizeof(MpegEncContext),
2452 encode_picture_lossless,
2457 AVCodecParser mjpeg_parser = {
2459 sizeof(ParseContext),