2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * Support for external huffman table, various fixes (AVID workaround),
22 * aspecting, new decode_frame mechanism and apple mjpeg-b support
23 * by Alex Beregszaszi <alex@naxine.org>
28 * MJPEG encoder and decoder.
36 #include "mpegvideo.h"
38 /* use two quantizer tables (one for luminance and one for chrominance) */
42 typedef struct MJpegContext {
43 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
44 uint16_t huff_code_dc_luminance[12];
45 uint8_t huff_size_dc_chrominance[12];
46 uint16_t huff_code_dc_chrominance[12];
48 uint8_t huff_size_ac_luminance[256];
49 uint16_t huff_code_ac_luminance[256];
50 uint8_t huff_size_ac_chrominance[256];
51 uint16_t huff_code_ac_chrominance[256];
54 /* JPEG marker codes */
57 SOF0 = 0xc0, /* baseline */
58 SOF1 = 0xc1, /* extended sequential, huffman */
59 SOF2 = 0xc2, /* progressive, huffman */
60 SOF3 = 0xc3, /* lossless, huffman */
62 SOF5 = 0xc5, /* differential sequential, huffman */
63 SOF6 = 0xc6, /* differential progressive, huffman */
64 SOF7 = 0xc7, /* differential lossless, huffman */
65 JPG = 0xc8, /* reserved for JPEG extension */
66 SOF9 = 0xc9, /* extended sequential, arithmetic */
67 SOF10 = 0xca, /* progressive, arithmetic */
68 SOF11 = 0xcb, /* lossless, arithmetic */
70 SOF13 = 0xcd, /* differential sequential, arithmetic */
71 SOF14 = 0xce, /* differential progressive, arithmetic */
72 SOF15 = 0xcf, /* differential lossless, arithmetic */
74 DHT = 0xc4, /* define huffman tables */
76 DAC = 0xcc, /* define arithmetic-coding conditioning */
78 /* restart with modulo 8 count "m" */
88 SOI = 0xd8, /* start of image */
89 EOI = 0xd9, /* end of image */
90 SOS = 0xda, /* start of scan */
91 DQT = 0xdb, /* define quantization tables */
92 DNL = 0xdc, /* define number of lines */
93 DRI = 0xdd, /* define restart interval */
94 DHP = 0xde, /* define hierarchical progression */
95 EXP = 0xdf, /* expand reference components */
129 COM = 0xfe, /* comment */
131 TEM = 0x01, /* temporary private use for arithmetic coding */
133 /* 0x02 -> 0xbf reserved */
137 /* These are the sample quantization tables given in JPEG spec section K.1.
138 * The spec says that the values given produce "good" quality, and
139 * when divided by 2, "very good" quality.
141 static const unsigned char std_luminance_quant_tbl[64] = {
142 16, 11, 10, 16, 24, 40, 51, 61,
143 12, 12, 14, 19, 26, 58, 60, 55,
144 14, 13, 16, 24, 40, 57, 69, 56,
145 14, 17, 22, 29, 51, 87, 80, 62,
146 18, 22, 37, 56, 68, 109, 103, 77,
147 24, 35, 55, 64, 81, 104, 113, 92,
148 49, 64, 78, 87, 103, 121, 120, 101,
149 72, 92, 95, 98, 112, 100, 103, 99
151 static const unsigned char std_chrominance_quant_tbl[64] = {
152 17, 18, 24, 47, 99, 99, 99, 99,
153 18, 21, 26, 66, 99, 99, 99, 99,
154 24, 26, 56, 99, 99, 99, 99, 99,
155 47, 66, 99, 99, 99, 99, 99, 99,
156 99, 99, 99, 99, 99, 99, 99, 99,
157 99, 99, 99, 99, 99, 99, 99, 99,
158 99, 99, 99, 99, 99, 99, 99, 99,
159 99, 99, 99, 99, 99, 99, 99, 99
163 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
164 /* IMPORTANT: these are only valid for 8-bit data precision! */
165 static const uint8_t bits_dc_luminance[17] =
166 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
167 static const uint8_t val_dc_luminance[] =
168 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
170 static const uint8_t bits_dc_chrominance[17] =
171 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
172 static const uint8_t val_dc_chrominance[] =
173 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
175 static const uint8_t bits_ac_luminance[17] =
176 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
177 static const uint8_t val_ac_luminance[] =
178 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
179 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
180 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
181 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
182 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
183 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
184 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
185 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
186 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
187 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
188 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
189 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
190 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
191 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
192 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
193 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
194 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
195 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
201 static const uint8_t bits_ac_chrominance[17] =
202 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
204 static const uint8_t val_ac_chrominance[] =
205 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
206 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
207 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
208 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
209 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
210 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
211 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
212 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
213 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
214 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
215 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
216 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
218 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
219 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
220 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
221 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
222 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
228 /* isn't this function nicer than the one in the libjpeg ? */
229 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
230 const uint8_t *bits_table, const uint8_t *val_table)
232 int i, j, k,nb, code, sym;
239 sym = val_table[k++];
241 huff_code[sym] = code;
248 #ifdef CONFIG_ENCODERS
249 int mjpeg_init(MpegEncContext *s)
253 m = av_malloc(sizeof(MJpegContext));
260 /* build all the huffman tables */
261 build_huffman_codes(m->huff_size_dc_luminance,
262 m->huff_code_dc_luminance,
265 build_huffman_codes(m->huff_size_dc_chrominance,
266 m->huff_code_dc_chrominance,
269 build_huffman_codes(m->huff_size_ac_luminance,
270 m->huff_code_ac_luminance,
273 build_huffman_codes(m->huff_size_ac_chrominance,
274 m->huff_code_ac_chrominance,
282 void mjpeg_close(MpegEncContext *s)
284 av_free(s->mjpeg_ctx);
286 #endif //CONFIG_ENCODERS
288 #define PREDICT(ret, topleft, top, left, predictor)\
290 case 1: ret= left; break;\
291 case 2: ret= top; break;\
292 case 3: ret= topleft; break;\
293 case 4: ret= left + top - topleft; break;\
294 case 5: ret= left + ((top - topleft)>>1); break;\
295 case 6: ret= top + ((left - topleft)>>1); break;\
297 case 7: ret= (left + top)>>1; break;\
300 #ifdef CONFIG_ENCODERS
301 static inline void put_marker(PutBitContext *p, int code)
303 put_bits(p, 8, 0xff);
304 put_bits(p, 8, code);
307 /* table_class: 0 = DC coef, 1 = AC coefs */
308 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
309 const uint8_t *bits_table, const uint8_t *value_table)
311 PutBitContext *p = &s->pb;
314 put_bits(p, 4, table_class);
315 put_bits(p, 4, table_id);
320 put_bits(p, 8, bits_table[i]);
324 put_bits(p, 8, value_table[i]);
329 static void jpeg_table_header(MpegEncContext *s)
331 PutBitContext *p = &s->pb;
338 put_bits(p, 16, 2 + 2 * (1 + 64));
340 put_bits(p, 16, 2 + 1 * (1 + 64));
342 put_bits(p, 4, 0); /* 8 bit precision */
343 put_bits(p, 4, 0); /* table 0 */
345 j = s->intra_scantable.permutated[i];
346 put_bits(p, 8, s->intra_matrix[j]);
349 put_bits(p, 4, 0); /* 8 bit precision */
350 put_bits(p, 4, 1); /* table 1 */
352 j = s->intra_scantable.permutated[i];
353 put_bits(p, 8, s->chroma_intra_matrix[j]);
361 put_bits(p, 16, 0); /* patched later */
363 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
366 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
372 static void jpeg_put_comments(MpegEncContext *s)
374 PutBitContext *p = &s->pb;
378 if (s->aspect_ratio_info /* && !lossless */)
383 put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
384 put_bits(p, 16, 0x0201); /* v 1.02 */
385 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
386 put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
387 put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
388 put_bits(p, 8, 0); /* thumbnail width */
389 put_bits(p, 8, 0); /* thumbnail height */
393 if(!(s->flags & CODEC_FLAG_BITEXACT)){
397 put_bits(p, 16, 0); /* patched later */
398 put_string(p, LIBAVCODEC_IDENT, 1);
399 size = strlen(LIBAVCODEC_IDENT)+3;
405 void mjpeg_picture_header(MpegEncContext *s)
407 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
409 put_marker(&s->pb, SOI);
411 if (!s->mjpeg_data_only_frames)
413 jpeg_put_comments(s);
415 if (s->mjpeg_write_tables) jpeg_table_header(s);
417 put_marker(&s->pb, lossless ? SOF3 : SOF0);
419 put_bits(&s->pb, 16, 17);
420 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
421 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
423 put_bits(&s->pb, 8, 8); /* 8 bits/component */
424 put_bits(&s->pb, 16, s->height);
425 put_bits(&s->pb, 16, s->width);
426 put_bits(&s->pb, 8, 3); /* 3 components */
429 put_bits(&s->pb, 8, 1); /* component number */
430 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
431 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
432 put_bits(&s->pb, 8, 0); /* select matrix */
435 put_bits(&s->pb, 8, 2); /* component number */
436 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
437 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
439 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
441 put_bits(&s->pb, 8, 0); /* select matrix */
445 put_bits(&s->pb, 8, 3); /* component number */
446 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
447 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
449 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
451 put_bits(&s->pb, 8, 0); /* select matrix */
456 put_marker(&s->pb, SOS);
457 put_bits(&s->pb, 16, 12); /* length */
458 put_bits(&s->pb, 8, 3); /* 3 components */
461 put_bits(&s->pb, 8, 1); /* index */
462 put_bits(&s->pb, 4, 0); /* DC huffman table index */
463 put_bits(&s->pb, 4, 0); /* AC huffman table index */
466 put_bits(&s->pb, 8, 2); /* index */
467 put_bits(&s->pb, 4, 1); /* DC huffman table index */
468 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
471 put_bits(&s->pb, 8, 3); /* index */
472 put_bits(&s->pb, 4, 1); /* DC huffman table index */
473 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
475 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
476 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
477 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
480 static void escape_FF(MpegEncContext *s, int start)
482 int size= put_bits_count(&s->pb) - start*8;
484 uint8_t *buf= s->pb.buf + start;
485 int align= (-(size_t)(buf))&3;
487 assert((size&7) == 0);
491 for(i=0; i<size && i<align; i++){
492 if(buf[i]==0xFF) ff_count++;
494 for(; i<size-15; i+=16){
497 v= *(uint32_t*)(&buf[i]);
498 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
499 v= *(uint32_t*)(&buf[i+4]);
500 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
501 v= *(uint32_t*)(&buf[i+8]);
502 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
503 v= *(uint32_t*)(&buf[i+12]);
504 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
512 if(buf[i]==0xFF) ff_count++;
515 if(ff_count==0) return;
518 for(i=0; i<ff_count-3; i+=4)
519 put_bits(&s->pb, 32, 0);
520 put_bits(&s->pb, (ff_count-i)*8, 0);
521 flush_put_bits(&s->pb);
523 for(i=size-1; ff_count; i--){
527 //printf("%d %d\n", i, ff_count);
536 void ff_mjpeg_stuffing(PutBitContext * pbc)
539 length= (-put_bits_count(pbc))&7;
540 if(length) put_bits(pbc, length, (1<<length)-1);
543 void mjpeg_picture_trailer(MpegEncContext *s)
545 ff_mjpeg_stuffing(&s->pb);
546 flush_put_bits(&s->pb);
548 assert((s->header_bits&7)==0);
550 escape_FF(s, s->header_bits>>3);
552 put_marker(&s->pb, EOI);
555 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
556 uint8_t *huff_size, uint16_t *huff_code)
561 put_bits(&s->pb, huff_size[0], huff_code[0]);
569 nbits= av_log2_16bit(val) + 1;
571 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
573 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
577 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
579 int mant, nbits, code, i, j;
580 int component, dc, run, last_index, val;
581 MJpegContext *m = s->mjpeg_ctx;
582 uint8_t *huff_size_ac;
583 uint16_t *huff_code_ac;
586 component = (n <= 3 ? 0 : n - 4 + 1);
587 dc = block[0]; /* overflow is impossible */
588 val = dc - s->last_dc[component];
590 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
591 huff_size_ac = m->huff_size_ac_luminance;
592 huff_code_ac = m->huff_code_ac_luminance;
594 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
595 huff_size_ac = m->huff_size_ac_chrominance;
596 huff_code_ac = m->huff_code_ac_chrominance;
598 s->last_dc[component] = dc;
603 last_index = s->block_last_index[n];
604 for(i=1;i<=last_index;i++) {
605 j = s->intra_scantable.permutated[i];
611 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
620 nbits= av_log2(val) + 1;
621 code = (run << 4) | nbits;
623 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
625 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
630 /* output EOB only if not already 64 values */
631 if (last_index < 63 || run != 0)
632 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
635 void mjpeg_encode_mb(MpegEncContext *s,
636 DCTELEM block[6][64])
640 encode_block(s, block[i], i);
644 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
645 MpegEncContext * const s = avctx->priv_data;
646 MJpegContext * const m = s->mjpeg_ctx;
647 AVFrame *pict = data;
648 const int width= s->width;
649 const int height= s->height;
650 AVFrame * const p= (AVFrame*)&s->current_picture;
651 const int predictor= avctx->prediction_method+1;
653 init_put_bits(&s->pb, buf, buf_size);
656 p->pict_type= FF_I_TYPE;
659 mjpeg_picture_header(s);
661 s->header_bits= put_bits_count(&s->pb);
663 if(avctx->pix_fmt == PIX_FMT_RGBA32){
665 const int linesize= p->linesize[0];
666 uint16_t buffer[2048][4];
667 int left[3], top[3], topleft[3];
670 buffer[0][i]= 1 << (9 - 1);
673 for(y = 0; y < height; y++) {
674 const int modified_predictor= y ? predictor : 1;
675 uint8_t *ptr = p->data[0] + (linesize * y);
678 top[i]= left[i]= topleft[i]= buffer[0][i];
680 for(x = 0; x < width; x++) {
681 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
682 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
683 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
688 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
691 top[i]= buffer[x+1][i];
693 left[i]= buffer[x][i];
695 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
698 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
700 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
706 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
707 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
709 for(mb_y = 0; mb_y < mb_height; mb_y++) {
710 for(mb_x = 0; mb_x < mb_width; mb_x++) {
711 if(mb_x==0 || mb_y==0){
714 int x, y, h, v, linesize;
715 h = s->mjpeg_hsample[i];
716 v = s->mjpeg_vsample[i];
717 linesize= p->linesize[i];
723 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
732 pred= ptr[-linesize];
734 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
739 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
741 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
748 int x, y, h, v, linesize;
749 h = s->mjpeg_hsample[i];
750 v = s->mjpeg_vsample[i];
751 linesize= p->linesize[i];
757 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
758 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
759 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
762 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
764 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
775 mjpeg_picture_trailer(s);
778 flush_put_bits(&s->pb);
779 return pbBufPtr(&s->pb) - s->pb.buf;
780 // return (put_bits_count(&f->pb)+7)/8;
783 #endif //CONFIG_ENCODERS
785 /******************************************/
788 #define MAX_COMPONENTS 4
790 typedef struct MJpegDecodeContext {
791 AVCodecContext *avctx;
793 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
795 int start_code; /* current start code */
799 int16_t quant_matrixes[4][64];
801 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
803 int org_height; /* size given at codec init */
804 int first_picture; /* true if decoding first picture */
805 int interlaced; /* true if interlaced */
806 int bottom_field; /* true if bottom field */
809 int rct; /* standard rct */
810 int pegasus_rct; /* pegasus reversible colorspace transform */
811 int bits; /* bits per component */
814 int mb_width, mb_height;
816 int component_id[MAX_COMPONENTS];
817 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
818 int v_count[MAX_COMPONENTS];
819 int comp_index[MAX_COMPONENTS];
820 int dc_index[MAX_COMPONENTS];
821 int ac_index[MAX_COMPONENTS];
822 int nb_blocks[MAX_COMPONENTS];
823 int h_scount[MAX_COMPONENTS];
824 int v_scount[MAX_COMPONENTS];
825 int h_max, v_max; /* maximum h and v counts */
826 int quant_index[4]; /* quant table index for each component */
827 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
828 AVFrame picture; /* picture structure */
829 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
830 uint8_t *qscale_table;
831 DCTELEM block[64] __align8;
833 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
835 int restart_interval;
839 int interlace_polarity;
840 } MJpegDecodeContext;
842 static int mjpeg_decode_dht(MJpegDecodeContext *s);
844 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
847 uint8_t huff_size[256];
848 uint16_t huff_code[256];
850 memset(huff_size, 0, sizeof(huff_size));
851 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
853 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
856 static int mjpeg_decode_init(AVCodecContext *avctx)
858 MJpegDecodeContext *s = avctx->priv_data;
863 /* ugly way to get the idct & scantable FIXME */
864 memset(&s2, 0, sizeof(MpegEncContext));
866 // s2->out_format = FMT_MJPEG;
867 dsputil_init(&s2.dsp, avctx);
868 DCT_common_init(&s2);
870 s->scantable= s2.intra_scantable;
871 s->idct_put= s2.dsp.idct_put;
873 s->mpeg_enc_ctx_allocated = 0;
874 s->buffer_size = 102400; /* smaller buffer should be enough,
875 but photojpg files could ahive bigger sizes */
876 s->buffer = av_malloc(s->buffer_size);
880 s->first_picture = 1;
881 s->org_height = avctx->height;
883 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
884 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
885 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
886 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
888 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
890 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
891 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
893 /* should check for error - but dunno */
899 /* quantize tables */
900 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
902 int len, index, i, j;
904 len = get_bits(&s->gb, 16) - 2;
907 /* only 8 bit precision handled */
908 if (get_bits(&s->gb, 4) != 0)
910 dprintf("dqt: 16bit precision\n");
913 index = get_bits(&s->gb, 4);
916 dprintf("index=%d\n", index);
917 /* read quant table */
919 j = s->scantable.permutated[i];
920 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
923 //XXX FIXME finetune, and perhaps add dc too
924 s->qscale[index]= FFMAX(
925 s->quant_matrixes[index][s->scantable.permutated[1]],
926 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
927 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
934 /* decode huffman tables and build VLC decoders */
935 static int mjpeg_decode_dht(MJpegDecodeContext *s)
937 int len, index, i, class, n, v, code_max;
938 uint8_t bits_table[17];
939 uint8_t val_table[256];
941 len = get_bits(&s->gb, 16) - 2;
946 class = get_bits(&s->gb, 4);
949 index = get_bits(&s->gb, 4);
954 bits_table[i] = get_bits(&s->gb, 8);
958 if (len < n || n > 256)
963 v = get_bits(&s->gb, 8);
970 /* build VLC and flush previous vlc if present */
971 free_vlc(&s->vlcs[class][index]);
972 dprintf("class=%d index=%d nb_codes=%d\n",
973 class, index, code_max + 1);
974 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
981 static int mjpeg_decode_sof(MJpegDecodeContext *s)
983 int len, nb_components, i, width, height;
985 /* XXX: verify len field validity */
986 len = get_bits(&s->gb, 16);
987 s->bits= get_bits(&s->gb, 8);
989 if(s->pegasus_rct) s->bits=9;
990 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
992 if (s->bits != 8 && !s->lossless){
993 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
996 height = get_bits(&s->gb, 16);
997 width = get_bits(&s->gb, 16);
998 dprintf("sof0: picture: %dx%d\n", width, height);
1000 nb_components = get_bits(&s->gb, 8);
1001 if (nb_components <= 0 ||
1002 nb_components > MAX_COMPONENTS)
1004 s->nb_components = nb_components;
1007 for(i=0;i<nb_components;i++) {
1009 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1010 s->h_count[i] = get_bits(&s->gb, 4);
1011 s->v_count[i] = get_bits(&s->gb, 4);
1012 /* compute hmax and vmax (only used in interleaved case) */
1013 if (s->h_count[i] > s->h_max)
1014 s->h_max = s->h_count[i];
1015 if (s->v_count[i] > s->v_max)
1016 s->v_max = s->v_count[i];
1017 s->quant_index[i] = get_bits(&s->gb, 8);
1018 if (s->quant_index[i] >= 4)
1020 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1021 s->v_count[i], s->component_id[i], s->quant_index[i]);
1024 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1026 /* if different size, realloc/alloc picture */
1027 /* XXX: also check h_count and v_count */
1028 if (width != s->width || height != s->height) {
1029 av_freep(&s->qscale_table);
1033 s->avctx->width = s->width;
1034 s->avctx->height = s->height;
1036 /* test interlaced mode */
1037 if (s->first_picture &&
1038 s->org_height != 0 &&
1039 s->height < ((s->org_height * 3) / 4)) {
1041 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1042 s->bottom_field = 0;
1043 s->avctx->height *= 2;
1046 s->qscale_table= av_mallocz((s->width+15)/16);
1048 s->first_picture = 0;
1051 if(s->interlaced && s->bottom_field)
1054 /* XXX: not complete test ! */
1055 switch((s->h_count[0] << 4) | s->v_count[0]) {
1058 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1059 }else if(s->nb_components==3)
1060 s->avctx->pix_fmt = PIX_FMT_YUV444P;
1062 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1065 s->avctx->pix_fmt = PIX_FMT_YUV422P;
1069 s->avctx->pix_fmt = PIX_FMT_YUV420P;
1073 if(s->picture.data[0])
1074 s->avctx->release_buffer(s->avctx, &s->picture);
1076 s->picture.reference= 0;
1077 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1078 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1081 s->picture.pict_type= I_TYPE;
1082 s->picture.key_frame= 1;
1085 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1088 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1090 if (len != (8+(3*nb_components)))
1092 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1098 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1101 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1104 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1105 &s->vlcs[0][dc_index]);
1110 return get_xbits(&s->gb, code);
1115 /* decode block and dequantize */
1116 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1117 int component, int dc_index, int ac_index, int quant_index)
1119 int code, i, j, level, val;
1121 int16_t *quant_matrix;
1124 val = mjpeg_decode_dc(s, dc_index);
1125 if (val == 0xffff) {
1126 dprintf("error dc\n");
1129 quant_matrix = s->quant_matrixes[quant_index];
1130 val = val * quant_matrix[0] + s->last_dc[component];
1131 s->last_dc[component] = val;
1134 ac_vlc = &s->vlcs[1][ac_index];
1137 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1140 dprintf("error ac\n");
1149 level = get_xbits(&s->gb, code & 0xf);
1152 dprintf("error count: %d\n", i);
1155 j = s->scantable.permutated[i];
1156 block[j] = level * quant_matrix[j];
1165 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1167 uint16_t buffer[2048][4];
1168 int left[3], top[3], topleft[3];
1169 const int linesize= s->linesize[0];
1170 const int mask= (1<<s->bits)-1;
1173 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1175 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1176 const int modified_predictor= mb_y ? predictor : 1;
1177 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1179 if (s->interlaced && s->bottom_field)
1180 ptr += linesize >> 1;
1183 top[i]= left[i]= topleft[i]= buffer[0][i];
1185 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1186 if (s->restart_interval && !s->restart_count)
1187 s->restart_count = s->restart_interval;
1193 top[i]= buffer[mb_x][i];
1195 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1198 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1201 if (s->restart_interval && !--s->restart_count) {
1202 align_get_bits(&s->gb);
1203 skip_bits(&s->gb, 16); /* skip RSTn */
1208 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1209 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1210 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1211 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1213 }else if(s->pegasus_rct){
1214 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1215 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1216 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1217 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1220 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1221 ptr[4*mb_x+0] = buffer[mb_x][0];
1222 ptr[4*mb_x+1] = buffer[mb_x][1];
1223 ptr[4*mb_x+2] = buffer[mb_x][2];
1230 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1232 const int nb_components=3;
1234 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1235 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1236 if (s->restart_interval && !s->restart_count)
1237 s->restart_count = s->restart_interval;
1239 if(mb_x==0 || mb_y==0 || s->interlaced){
1240 for(i=0;i<nb_components;i++) {
1242 int n, h, v, x, y, c, j, linesize;
1243 n = s->nb_blocks[i];
1244 c = s->comp_index[i];
1249 linesize= s->linesize[c];
1251 for(j=0; j<n; j++) {
1254 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1255 if(y==0 && mb_y==0){
1256 if(x==0 && mb_x==0){
1257 pred= 128 << point_transform;
1262 if(x==0 && mb_x==0){
1263 pred= ptr[-linesize];
1265 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1269 if (s->interlaced && s->bottom_field)
1270 ptr += linesize >> 1;
1271 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1280 for(i=0;i<nb_components;i++) {
1282 int n, h, v, x, y, c, j, linesize;
1283 n = s->nb_blocks[i];
1284 c = s->comp_index[i];
1289 linesize= s->linesize[c];
1291 for(j=0; j<n; j++) {
1294 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1295 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1296 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1304 if (s->restart_interval && !--s->restart_count) {
1305 align_get_bits(&s->gb);
1306 skip_bits(&s->gb, 16); /* skip RSTn */
1313 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1315 const int nb_components=3;
1317 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1318 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1319 if (s->restart_interval && !s->restart_count)
1320 s->restart_count = s->restart_interval;
1322 for(i=0;i<nb_components;i++) {
1324 int n, h, v, x, y, c, j;
1325 n = s->nb_blocks[i];
1326 c = s->comp_index[i];
1332 memset(s->block, 0, sizeof(s->block));
1333 if (decode_block(s, s->block, i,
1334 s->dc_index[i], s->ac_index[i],
1335 s->quant_index[c]) < 0) {
1336 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1339 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1340 ptr = s->picture.data[c] +
1341 (((s->linesize[c] * (v * mb_y + y) * 8) +
1342 (h * mb_x + x) * 8) >> s->avctx->lowres);
1343 if (s->interlaced && s->bottom_field)
1344 ptr += s->linesize[c] >> 1;
1345 //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);
1346 s->idct_put(ptr, s->linesize[c], s->block);
1353 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1354 if (s->restart_interval && (s->restart_interval < 1350) &&
1355 !--s->restart_count) {
1356 align_get_bits(&s->gb);
1357 skip_bits(&s->gb, 16); /* skip RSTn */
1358 for (i=0; i<nb_components; i++) /* reset dc */
1359 s->last_dc[i] = 1024;
1366 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1368 int len, nb_components, i, h, v, predictor, point_transform;
1369 int vmax, hmax, index, id;
1370 const int block_size= s->lossless ? 1 : 8;
1372 /* XXX: verify len field validity */
1373 len = get_bits(&s->gb, 16);
1374 nb_components = get_bits(&s->gb, 8);
1375 if (len != 6+2*nb_components)
1377 dprintf("decode_sos: invalid len (%d)\n", len);
1380 /* XXX: only interleaved scan accepted */
1381 if (nb_components != s->nb_components)
1383 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1388 for(i=0;i<nb_components;i++) {
1389 id = get_bits(&s->gb, 8) - 1;
1390 dprintf("component: %d\n", id);
1391 /* find component index */
1392 for(index=0;index<s->nb_components;index++)
1393 if (id == s->component_id[index])
1395 if (index == s->nb_components)
1397 dprintf("decode_sos: index(%d) out of components\n", index);
1401 s->comp_index[i] = index;
1403 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1404 s->h_scount[i] = s->h_count[index];
1405 s->v_scount[i] = s->v_count[index];
1407 s->dc_index[i] = get_bits(&s->gb, 4);
1408 s->ac_index[i] = get_bits(&s->gb, 4);
1410 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1411 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1414 switch(s->start_code)
1417 if (dc_index[i] > 1 || ac_index[i] > 1)
1422 if (dc_index[i] > 3 || ac_index[i] > 3)
1426 if (dc_index[i] > 3 || ac_index[i] != 0)
1433 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1434 skip_bits(&s->gb, 8); /* Se */
1435 skip_bits(&s->gb, 4); /* Ah */
1436 point_transform= get_bits(&s->gb, 4); /* Al */
1438 for(i=0;i<nb_components;i++)
1439 s->last_dc[i] = 1024;
1441 if (nb_components > 1) {
1442 /* interleaved stream */
1443 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1444 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1446 h = s->h_max / s->h_scount[s->comp_index[0]];
1447 v = s->v_max / s->v_scount[s->comp_index[0]];
1448 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1449 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1450 s->nb_blocks[0] = 1;
1455 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1456 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1460 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1463 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1467 if(mjpeg_decode_scan(s) < 0)
1473 dprintf("decode_sos: ac/dc index out of range\n");
1477 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1479 if (get_bits(&s->gb, 16) != 4)
1481 s->restart_interval = get_bits(&s->gb, 16);
1482 dprintf("restart interval: %d\n", s->restart_interval);
1487 static int mjpeg_decode_app(MJpegDecodeContext *s)
1491 /* XXX: verify len field validity */
1492 len = get_bits(&s->gb, 16);
1496 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1500 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1501 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1504 /* buggy AVID, it puts EOI only at every 10th frame */
1505 /* also this fourcc is used by non-avid files too, it holds some
1506 informations, but it's always present in AVID creates files */
1507 if (id == ff_get_fourcc("AVI1"))
1514 4bytes field_size_less_padding
1517 // if (s->first_picture)
1518 // printf("mjpeg: workarounding buggy AVID\n");
1519 s->interlace_polarity = get_bits(&s->gb, 8);
1521 skip_bits(&s->gb, 8);
1522 skip_bits(&s->gb, 32);
1523 skip_bits(&s->gb, 32);
1526 // if (s->interlace_polarity)
1527 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1533 if (id == ff_get_fourcc("JFIF"))
1535 int t_w, t_h, v1, v2;
1536 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1537 v1= get_bits(&s->gb, 8);
1538 v2= get_bits(&s->gb, 8);
1539 skip_bits(&s->gb, 8);
1541 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1542 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1544 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1545 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1547 s->avctx->sample_aspect_ratio.num,
1548 s->avctx->sample_aspect_ratio.den
1551 t_w = get_bits(&s->gb, 8);
1552 t_h = get_bits(&s->gb, 8);
1555 /* skip thumbnail */
1556 if (len-10-(t_w*t_h*3) > 0)
1563 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1565 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1566 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1567 skip_bits(&s->gb, 16); /* version */
1568 skip_bits(&s->gb, 16); /* flags0 */
1569 skip_bits(&s->gb, 16); /* flags1 */
1570 skip_bits(&s->gb, 8); /* transform */
1575 if (id == ff_get_fourcc("LJIF")){
1576 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1577 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1578 skip_bits(&s->gb, 16); /* version ? */
1579 skip_bits(&s->gb, 16); /* unknwon always 0? */
1580 skip_bits(&s->gb, 16); /* unknwon always 0? */
1581 skip_bits(&s->gb, 16); /* unknwon always 0? */
1582 switch( get_bits(&s->gb, 8)){
1592 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1599 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1601 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1604 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1607 skip_bits(&s->gb, 32); /* field size */
1608 skip_bits(&s->gb, 32); /* pad field size */
1609 skip_bits(&s->gb, 32); /* next off */
1610 skip_bits(&s->gb, 32); /* quant off */
1611 skip_bits(&s->gb, 32); /* huff off */
1612 skip_bits(&s->gb, 32); /* image off */
1613 skip_bits(&s->gb, 32); /* scan off */
1614 skip_bits(&s->gb, 32); /* data off */
1616 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1617 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1622 /* slow but needed for extreme adobe jpegs */
1624 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1626 skip_bits(&s->gb, 8);
1631 static int mjpeg_decode_com(MJpegDecodeContext *s)
1633 /* XXX: verify len field validity */
1634 int len = get_bits(&s->gb, 16);
1635 if (len >= 2 && len < 32768) {
1636 /* XXX: any better upper bound */
1637 uint8_t *cbuf = av_malloc(len - 1);
1640 for (i = 0; i < len - 2; i++)
1641 cbuf[i] = get_bits(&s->gb, 8);
1642 if (i > 0 && cbuf[i-1] == '\n')
1647 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1648 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1650 /* buggy avid, it puts EOI only at every 10th frame */
1651 if (!strcmp(cbuf, "AVID"))
1654 // if (s->first_picture)
1655 // printf("mjpeg: workarounding buggy AVID\n");
1666 static int valid_marker_list[] =
1668 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1669 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1670 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1671 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1672 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1673 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1674 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1675 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1676 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1677 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1682 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1683 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1684 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1688 /* return the 8 bit start code value and update the search
1689 state. Return -1 if no start code found */
1690 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1699 buf_ptr = *pbuf_ptr;
1700 while (buf_ptr < buf_end) {
1703 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1714 dprintf("find_marker skipped %d bytes\n", skipped);
1716 *pbuf_ptr = buf_ptr;
1720 static int mjpeg_decode_frame(AVCodecContext *avctx,
1721 void *data, int *data_size,
1722 uint8_t *buf, int buf_size)
1724 MJpegDecodeContext *s = avctx->priv_data;
1725 uint8_t *buf_end, *buf_ptr;
1727 AVFrame *picture = data;
1729 /* no supplementary picture */
1734 buf_end = buf + buf_size;
1735 while (buf_ptr < buf_end) {
1736 /* find start next marker */
1737 start_code = find_marker(&buf_ptr, buf_end);
1740 if (start_code < 0) {
1743 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1745 if ((buf_end - buf_ptr) > s->buffer_size)
1748 s->buffer_size = buf_end-buf_ptr;
1749 s->buffer = av_malloc(s->buffer_size);
1750 dprintf("buffer too small, expanding to %d bytes\n",
1754 /* unescape buffer of SOS */
1755 if (start_code == SOS)
1757 uint8_t *src = buf_ptr;
1758 uint8_t *dst = s->buffer;
1762 uint8_t x = *(src++);
1767 while(*src == 0xff) src++;
1770 if (x >= 0xd0 && x <= 0xd7)
1776 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1778 dprintf("escaping removed %d bytes\n",
1779 (buf_end - buf_ptr) - (dst - s->buffer));
1782 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1784 s->start_code = start_code;
1785 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1786 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1789 /* process markers */
1790 if (start_code >= 0xd0 && start_code <= 0xd7) {
1791 dprintf("restart marker: %d\n", start_code&0x0f);
1793 } else if (start_code >= APP0 && start_code <= APP15) {
1794 mjpeg_decode_app(s);
1796 } else if (start_code == COM){
1797 mjpeg_decode_com(s);
1800 switch(start_code) {
1802 s->restart_interval = 0;
1803 /* nothing to do on SOI */
1806 mjpeg_decode_dqt(s);
1809 if(mjpeg_decode_dht(s) < 0){
1810 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1816 if (mjpeg_decode_sof(s) < 0)
1821 if (mjpeg_decode_sof(s) < 0)
1825 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1829 if (s->interlaced) {
1830 s->bottom_field ^= 1;
1831 /* if not bottom field, do not output image yet */
1832 if (s->bottom_field)
1835 *picture = s->picture;
1836 *data_size = sizeof(AVFrame);
1839 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1840 picture->qstride= 0;
1841 picture->qscale_table= s->qscale_table;
1842 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1843 if(avctx->debug & FF_DEBUG_QP)
1844 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1845 picture->quality*= FF_QP2LAMBDA;
1852 mjpeg_decode_sos(s);
1853 /* buggy avid puts EOI every 10-20th frame */
1854 /* if restart period is over process EOI */
1855 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1859 mjpeg_decode_dri(s);
1873 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1876 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1881 /* eof process start code */
1882 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1883 dprintf("marker parser used %d bytes (%d bits)\n",
1884 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1889 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1890 // return buf_end - buf_ptr;
1891 return buf_ptr - buf;
1894 static int mjpegb_decode_frame(AVCodecContext *avctx,
1895 void *data, int *data_size,
1896 uint8_t *buf, int buf_size)
1898 MJpegDecodeContext *s = avctx->priv_data;
1899 uint8_t *buf_end, *buf_ptr;
1900 AVFrame *picture = data;
1901 GetBitContext hgb; /* for the header */
1902 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1903 uint32_t field_size;
1905 /* no supplementary picture */
1910 buf_end = buf + buf_size;
1913 /* reset on every SOI */
1914 s->restart_interval = 0;
1916 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1918 skip_bits(&hgb, 32); /* reserved zeros */
1920 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1922 dprintf("not mjpeg-b (bad fourcc)\n");
1926 field_size = get_bits_long(&hgb, 32); /* field size */
1927 dprintf("field size: 0x%x\n", field_size);
1928 skip_bits(&hgb, 32); /* padded field size */
1929 second_field_offs = get_bits_long(&hgb, 32);
1930 dprintf("second field offs: 0x%x\n", second_field_offs);
1931 if (second_field_offs)
1934 dqt_offs = get_bits_long(&hgb, 32);
1935 dprintf("dqt offs: 0x%x\n", dqt_offs);
1938 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1939 s->start_code = DQT;
1940 mjpeg_decode_dqt(s);
1943 dht_offs = get_bits_long(&hgb, 32);
1944 dprintf("dht offs: 0x%x\n", dht_offs);
1947 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1948 s->start_code = DHT;
1949 mjpeg_decode_dht(s);
1952 sof_offs = get_bits_long(&hgb, 32);
1953 dprintf("sof offs: 0x%x\n", sof_offs);
1956 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1957 s->start_code = SOF0;
1958 if (mjpeg_decode_sof(s) < 0)
1962 sos_offs = get_bits_long(&hgb, 32);
1963 dprintf("sos offs: 0x%x\n", sos_offs);
1966 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1967 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1968 s->start_code = SOS;
1969 mjpeg_decode_sos(s);
1972 skip_bits(&hgb, 32); /* start of data offset */
1974 if (s->interlaced) {
1975 s->bottom_field ^= 1;
1976 /* if not bottom field, do not output image yet */
1977 if (s->bottom_field && second_field_offs)
1979 buf_ptr = buf + second_field_offs;
1980 second_field_offs = 0;
1985 //XXX FIXME factorize, this looks very similar to the EOI code
1987 *picture= s->picture;
1988 *data_size = sizeof(AVFrame);
1991 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1992 picture->qstride= 0;
1993 picture->qscale_table= s->qscale_table;
1994 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1995 if(avctx->debug & FF_DEBUG_QP)
1996 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1997 picture->quality*= FF_QP2LAMBDA;
2000 return buf_ptr - buf;
2005 static int sp5x_decode_frame(AVCodecContext *avctx,
2006 void *data, int *data_size,
2007 uint8_t *buf, int buf_size)
2010 MJpegDecodeContext *s = avctx->priv_data;
2012 const int qscale = 5;
2013 uint8_t *buf_ptr, *buf_end, *recoded;
2016 /* no supplementary picture */
2020 if (!avctx->width || !avctx->height)
2024 buf_end = buf + buf_size;
2027 recoded = av_mallocz(buf_size + 1024);
2032 recoded[j++] = 0xFF;
2033 recoded[j++] = 0xD8;
2035 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2036 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2037 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2038 j += sizeof(sp5x_data_dqt);
2040 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2041 j += sizeof(sp5x_data_dht);
2043 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2044 recoded[j+5] = (avctx->height >> 8) & 0xFF;
2045 recoded[j+6] = avctx->height & 0xFF;
2046 recoded[j+7] = (avctx->width >> 8) & 0xFF;
2047 recoded[j+8] = avctx->width & 0xFF;
2048 j += sizeof(sp5x_data_sof);
2050 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2051 j += sizeof(sp5x_data_sos);
2053 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2055 recoded[j++] = buf[i];
2061 recoded[j++] = 0xFF;
2062 recoded[j++] = 0xD9;
2064 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2071 s->width = avctx->width;
2072 s->height = avctx->height;
2073 s->nb_components = 3;
2074 s->component_id[0] = 0;
2077 s->quant_index[0] = 0;
2078 s->component_id[1] = 1;
2081 s->quant_index[1] = 1;
2082 s->component_id[2] = 2;
2085 s->quant_index[2] = 1;
2089 s->qscale_table = av_mallocz((s->width+15)/16);
2090 avctx->pix_fmt = PIX_FMT_YUV420P;
2093 s->picture.reference = 0;
2094 if (avctx->get_buffer(avctx, &s->picture) < 0)
2096 fprintf(stderr, "get_buffer() failed\n");
2100 s->picture.pict_type = I_TYPE;
2101 s->picture.key_frame = 1;
2103 for (i = 0; i < 3; i++)
2104 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2107 for (i = 0; i < 64; i++)
2109 j = s->scantable.permutated[i];
2110 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2112 s->qscale[0] = FFMAX(
2113 s->quant_matrixes[0][s->scantable.permutated[1]],
2114 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2116 for (i = 0; i < 64; i++)
2118 j = s->scantable.permutated[i];
2119 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2121 s->qscale[1] = FFMAX(
2122 s->quant_matrixes[1][s->scantable.permutated[1]],
2123 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2128 s->comp_index[0] = 0;
2129 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2130 s->h_scount[0] = s->h_count[0];
2131 s->v_scount[0] = s->v_count[0];
2135 s->comp_index[1] = 1;
2136 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2137 s->h_scount[1] = s->h_count[1];
2138 s->v_scount[1] = s->v_count[1];
2142 s->comp_index[2] = 2;
2143 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2144 s->h_scount[2] = s->h_count[2];
2145 s->v_scount[2] = s->v_count[2];
2149 for (i = 0; i < 3; i++)
2150 s->last_dc[i] = 1024;
2152 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2153 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2155 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2157 return mjpeg_decode_scan(s);
2163 static int mjpeg_decode_end(AVCodecContext *avctx)
2165 MJpegDecodeContext *s = avctx->priv_data;
2169 av_free(s->qscale_table);
2173 free_vlc(&s->vlcs[i][j]);
2178 AVCodec mjpeg_decoder = {
2182 sizeof(MJpegDecodeContext),
2191 AVCodec mjpegb_decoder = {
2195 sizeof(MJpegDecodeContext),
2199 mjpegb_decode_frame,
2204 AVCodec sp5x_decoder = {
2208 sizeof(MJpegDecodeContext),
2217 #ifdef CONFIG_ENCODERS
2218 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2222 sizeof(MpegEncContext),
2224 encode_picture_lossless,