2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * Support for external huffman table, various fixes (AVID workaround),
20 * aspecting, new decode_frame mechanism and apple mjpeg-b support
21 * by Alex Beregszaszi <alex@naxine.org>
26 * MJPEG encoder and decoder.
34 #include "mpegvideo.h"
36 /* use two quantizer tables (one for luminance and one for chrominance) */
40 typedef struct MJpegContext {
41 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
42 uint16_t huff_code_dc_luminance[12];
43 uint8_t huff_size_dc_chrominance[12];
44 uint16_t huff_code_dc_chrominance[12];
46 uint8_t huff_size_ac_luminance[256];
47 uint16_t huff_code_ac_luminance[256];
48 uint8_t huff_size_ac_chrominance[256];
49 uint16_t huff_code_ac_chrominance[256];
52 /* JPEG marker codes */
55 SOF0 = 0xc0, /* baseline */
56 SOF1 = 0xc1, /* extended sequential, huffman */
57 SOF2 = 0xc2, /* progressive, huffman */
58 SOF3 = 0xc3, /* lossless, huffman */
60 SOF5 = 0xc5, /* differential sequential, huffman */
61 SOF6 = 0xc6, /* differential progressive, huffman */
62 SOF7 = 0xc7, /* differential lossless, huffman */
63 JPG = 0xc8, /* reserved for JPEG extension */
64 SOF9 = 0xc9, /* extended sequential, arithmetic */
65 SOF10 = 0xca, /* progressive, arithmetic */
66 SOF11 = 0xcb, /* lossless, arithmetic */
68 SOF13 = 0xcd, /* differential sequential, arithmetic */
69 SOF14 = 0xce, /* differential progressive, arithmetic */
70 SOF15 = 0xcf, /* differential lossless, arithmetic */
72 DHT = 0xc4, /* define huffman tables */
74 DAC = 0xcc, /* define arithmetic-coding conditioning */
76 /* restart with modulo 8 count "m" */
86 SOI = 0xd8, /* start of image */
87 EOI = 0xd9, /* end of image */
88 SOS = 0xda, /* start of scan */
89 DQT = 0xdb, /* define quantization tables */
90 DNL = 0xdc, /* define number of lines */
91 DRI = 0xdd, /* define restart interval */
92 DHP = 0xde, /* define hierarchical progression */
93 EXP = 0xdf, /* expand reference components */
127 COM = 0xfe, /* comment */
129 TEM = 0x01, /* temporary private use for arithmetic coding */
131 /* 0x02 -> 0xbf reserved */
135 /* These are the sample quantization tables given in JPEG spec section K.1.
136 * The spec says that the values given produce "good" quality, and
137 * when divided by 2, "very good" quality.
139 static const unsigned char std_luminance_quant_tbl[64] = {
140 16, 11, 10, 16, 24, 40, 51, 61,
141 12, 12, 14, 19, 26, 58, 60, 55,
142 14, 13, 16, 24, 40, 57, 69, 56,
143 14, 17, 22, 29, 51, 87, 80, 62,
144 18, 22, 37, 56, 68, 109, 103, 77,
145 24, 35, 55, 64, 81, 104, 113, 92,
146 49, 64, 78, 87, 103, 121, 120, 101,
147 72, 92, 95, 98, 112, 100, 103, 99
149 static const unsigned char std_chrominance_quant_tbl[64] = {
150 17, 18, 24, 47, 99, 99, 99, 99,
151 18, 21, 26, 66, 99, 99, 99, 99,
152 24, 26, 56, 99, 99, 99, 99, 99,
153 47, 66, 99, 99, 99, 99, 99, 99,
154 99, 99, 99, 99, 99, 99, 99, 99,
155 99, 99, 99, 99, 99, 99, 99, 99,
156 99, 99, 99, 99, 99, 99, 99, 99,
157 99, 99, 99, 99, 99, 99, 99, 99
161 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
162 /* IMPORTANT: these are only valid for 8-bit data precision! */
163 static const uint8_t bits_dc_luminance[17] =
164 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
165 static const uint8_t val_dc_luminance[] =
166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
168 static const uint8_t bits_dc_chrominance[17] =
169 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170 static const uint8_t val_dc_chrominance[] =
171 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
173 static const uint8_t bits_ac_luminance[17] =
174 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
175 static const uint8_t val_ac_luminance[] =
176 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
177 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
178 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
179 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
180 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
181 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
182 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
183 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
184 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
185 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
186 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
187 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
188 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
189 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
190 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
191 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
192 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
193 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
194 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
195 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
199 static const uint8_t bits_ac_chrominance[17] =
200 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
202 static const uint8_t val_ac_chrominance[] =
203 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
204 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
205 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
206 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
207 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
208 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
209 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
210 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
211 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
212 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
213 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
214 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
215 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
216 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
217 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
218 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
219 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
220 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
221 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
222 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
226 /* isn't this function nicer than the one in the libjpeg ? */
227 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
228 const uint8_t *bits_table, const uint8_t *val_table)
230 int i, j, k,nb, code, sym;
237 sym = val_table[k++];
239 huff_code[sym] = code;
246 int mjpeg_init(MpegEncContext *s)
250 m = av_malloc(sizeof(MJpegContext));
257 /* build all the huffman tables */
258 build_huffman_codes(m->huff_size_dc_luminance,
259 m->huff_code_dc_luminance,
262 build_huffman_codes(m->huff_size_dc_chrominance,
263 m->huff_code_dc_chrominance,
266 build_huffman_codes(m->huff_size_ac_luminance,
267 m->huff_code_ac_luminance,
270 build_huffman_codes(m->huff_size_ac_chrominance,
271 m->huff_code_ac_chrominance,
279 void mjpeg_close(MpegEncContext *s)
281 av_free(s->mjpeg_ctx);
284 #define PREDICT(ret, topleft, top, left, predictor)\
286 case 1: ret= left; break;\
287 case 2: ret= top; break;\
288 case 3: ret= topleft; break;\
289 case 4: ret= left + top - topleft; break;\
290 case 5: ret= left + ((top - topleft)>>1); break;\
291 case 6: ret= top + ((left - topleft)>>1); break;\
292 case 7: ret= (left + top)>>1; break;\
295 #ifdef CONFIG_ENCODERS
296 static inline void put_marker(PutBitContext *p, int code)
298 put_bits(p, 8, 0xff);
299 put_bits(p, 8, code);
302 /* table_class: 0 = DC coef, 1 = AC coefs */
303 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
304 const uint8_t *bits_table, const uint8_t *value_table)
306 PutBitContext *p = &s->pb;
309 put_bits(p, 4, table_class);
310 put_bits(p, 4, table_id);
315 put_bits(p, 8, bits_table[i]);
319 put_bits(p, 8, value_table[i]);
324 static void jpeg_table_header(MpegEncContext *s)
326 PutBitContext *p = &s->pb;
333 put_bits(p, 16, 2 + 2 * (1 + 64));
335 put_bits(p, 16, 2 + 1 * (1 + 64));
337 put_bits(p, 4, 0); /* 8 bit precision */
338 put_bits(p, 4, 0); /* table 0 */
340 j = s->intra_scantable.permutated[i];
341 put_bits(p, 8, s->intra_matrix[j]);
344 put_bits(p, 4, 0); /* 8 bit precision */
345 put_bits(p, 4, 1); /* table 1 */
347 j = s->intra_scantable.permutated[i];
348 put_bits(p, 8, s->chroma_intra_matrix[j]);
356 put_bits(p, 16, 0); /* patched later */
358 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
359 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
361 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
362 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
367 static void jpeg_put_comments(MpegEncContext *s)
369 PutBitContext *p = &s->pb;
373 if (s->aspect_ratio_info /* && !lossless */)
378 put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
379 put_bits(p, 16, 0x0201); /* v 1.02 */
380 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
381 switch(s->aspect_ratio_info)
383 case FF_ASPECT_4_3_625:
384 case FF_ASPECT_4_3_525:
388 case FF_ASPECT_16_9_625:
389 case FF_ASPECT_16_9_525:
393 case FF_ASPECT_EXTENDED:
394 put_bits(p, 16, s->aspected_width);
395 put_bits(p, 16, s->aspected_height);
397 case FF_ASPECT_SQUARE:
399 put_bits(p, 16, 1); /* aspect: 1:1 */
403 put_bits(p, 8, 0); /* thumbnail width */
404 put_bits(p, 8, 0); /* thumbnail height */
408 if(!(s->flags & CODEC_FLAG_BITEXACT)){
412 put_bits(p, 16, 0); /* patched later */
413 put_string(p, LIBAVCODEC_IDENT);
414 size = strlen(LIBAVCODEC_IDENT)+3;
420 void mjpeg_picture_header(MpegEncContext *s)
422 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
424 put_marker(&s->pb, SOI);
426 if (!s->mjpeg_data_only_frames)
428 jpeg_put_comments(s);
430 if (s->mjpeg_write_tables) jpeg_table_header(s);
432 put_marker(&s->pb, lossless ? SOF3 : SOF0);
434 put_bits(&s->pb, 16, 17);
435 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
436 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
438 put_bits(&s->pb, 8, 8); /* 8 bits/component */
439 put_bits(&s->pb, 16, s->height);
440 put_bits(&s->pb, 16, s->width);
441 put_bits(&s->pb, 8, 3); /* 3 components */
444 put_bits(&s->pb, 8, 1); /* component number */
445 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
446 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
447 put_bits(&s->pb, 8, 0); /* select matrix */
450 put_bits(&s->pb, 8, 2); /* component number */
451 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
452 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
454 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
456 put_bits(&s->pb, 8, 0); /* select matrix */
460 put_bits(&s->pb, 8, 3); /* component number */
461 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
462 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
464 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
466 put_bits(&s->pb, 8, 0); /* select matrix */
471 put_marker(&s->pb, SOS);
472 put_bits(&s->pb, 16, 12); /* length */
473 put_bits(&s->pb, 8, 3); /* 3 components */
476 put_bits(&s->pb, 8, 1); /* index */
477 put_bits(&s->pb, 4, 0); /* DC huffman table index */
478 put_bits(&s->pb, 4, 0); /* AC huffman table index */
481 put_bits(&s->pb, 8, 2); /* index */
482 put_bits(&s->pb, 4, 1); /* DC huffman table index */
483 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
486 put_bits(&s->pb, 8, 3); /* index */
487 put_bits(&s->pb, 4, 1); /* DC huffman table index */
488 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
490 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
491 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
492 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
495 static void escape_FF(MpegEncContext *s, int start)
497 int size= get_bit_count(&s->pb) - start*8;
499 uint8_t *buf= s->pb.buf + start;
500 int align= (-(size_t)(buf))&3;
502 assert((size&7) == 0);
506 for(i=0; i<size && i<align; i++){
507 if(buf[i]==0xFF) ff_count++;
509 for(; i<size-15; i+=16){
512 v= *(uint32_t*)(&buf[i]);
513 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
514 v= *(uint32_t*)(&buf[i+4]);
515 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
516 v= *(uint32_t*)(&buf[i+8]);
517 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
518 v= *(uint32_t*)(&buf[i+12]);
519 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
527 if(buf[i]==0xFF) ff_count++;
530 if(ff_count==0) return;
533 for(i=0; i<ff_count-3; i+=4)
534 put_bits(&s->pb, 32, 0);
535 put_bits(&s->pb, (ff_count-i)*8, 0);
536 flush_put_bits(&s->pb);
538 for(i=size-1; ff_count; i--){
542 //printf("%d %d\n", i, ff_count);
551 void mjpeg_picture_trailer(MpegEncContext *s)
553 int pad= (-get_bit_count(&s->pb))&7;
555 put_bits(&s->pb, pad,0xFF>>(8-pad));
556 flush_put_bits(&s->pb);
558 assert((s->header_bits&7)==0);
560 escape_FF(s, s->header_bits>>3);
562 put_marker(&s->pb, EOI);
565 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
566 uint8_t *huff_size, uint16_t *huff_code)
571 put_bits(&s->pb, huff_size[0], huff_code[0]);
579 nbits= av_log2_16bit(val) + 1;
581 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
583 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
587 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
589 int mant, nbits, code, i, j;
590 int component, dc, run, last_index, val;
591 MJpegContext *m = s->mjpeg_ctx;
592 uint8_t *huff_size_ac;
593 uint16_t *huff_code_ac;
596 component = (n <= 3 ? 0 : n - 4 + 1);
597 dc = block[0]; /* overflow is impossible */
598 val = dc - s->last_dc[component];
600 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
601 huff_size_ac = m->huff_size_ac_luminance;
602 huff_code_ac = m->huff_code_ac_luminance;
604 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
605 huff_size_ac = m->huff_size_ac_chrominance;
606 huff_code_ac = m->huff_code_ac_chrominance;
608 s->last_dc[component] = dc;
613 last_index = s->block_last_index[n];
614 for(i=1;i<=last_index;i++) {
615 j = s->intra_scantable.permutated[i];
621 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
630 nbits= av_log2(val) + 1;
631 code = (run << 4) | nbits;
633 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
635 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
640 /* output EOB only if not already 64 values */
641 if (last_index < 63 || run != 0)
642 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
645 void mjpeg_encode_mb(MpegEncContext *s,
646 DCTELEM block[6][64])
650 encode_block(s, block[i], i);
654 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
655 MpegEncContext * const s = avctx->priv_data;
656 MJpegContext * const m = s->mjpeg_ctx;
657 AVFrame *pict = data;
658 const int width= s->width;
659 const int height= s->height;
660 AVFrame * const p= (AVFrame*)&s->current_picture;
661 const int predictor= avctx->prediction_method+1;
663 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
666 p->pict_type= FF_I_TYPE;
669 mjpeg_picture_header(s);
671 s->header_bits= get_bit_count(&s->pb);
673 if(avctx->pix_fmt == PIX_FMT_RGBA32){
675 const int linesize= p->linesize[0];
676 uint16_t buffer[2048][4];
677 int left[3], top[3], topleft[3];
680 buffer[0][i]= 1 << (9 - 1);
683 for(y = 0; y < height; y++) {
684 const int modified_predictor= y ? predictor : 1;
685 uint8_t *ptr = p->data[0] + (linesize * y);
688 top[i]= left[i]= topleft[i]= buffer[0][i];
690 for(x = 0; x < width; x++) {
691 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
692 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
693 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
698 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
701 top[i]= buffer[x+1][i];
703 left[i]= buffer[x][i];
705 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
708 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
710 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
716 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
717 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
719 for(mb_y = 0; mb_y < mb_height; mb_y++) {
720 for(mb_x = 0; mb_x < mb_width; mb_x++) {
721 if(mb_x==0 || mb_y==0){
724 int x, y, h, v, linesize;
725 h = s->mjpeg_hsample[i];
726 v = s->mjpeg_vsample[i];
727 linesize= p->linesize[i];
733 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
742 pred= ptr[-linesize];
744 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
749 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
751 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
758 int x, y, h, v, linesize;
759 h = s->mjpeg_hsample[i];
760 v = s->mjpeg_vsample[i];
761 linesize= p->linesize[i];
767 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
768 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
769 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
772 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
774 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
785 mjpeg_picture_trailer(s);
788 flush_put_bits(&s->pb);
789 return pbBufPtr(&s->pb) - s->pb.buf;
790 // return (get_bit_count(&f->pb)+7)/8;
793 #endif //CONFIG_ENCODERS
795 /******************************************/
798 #define MAX_COMPONENTS 4
800 typedef struct MJpegDecodeContext {
801 AVCodecContext *avctx;
803 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
805 int start_code; /* current start code */
809 int16_t quant_matrixes[4][64];
811 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
813 int org_width, org_height; /* size given at codec init */
814 int first_picture; /* true if decoding first picture */
815 int interlaced; /* true if interlaced */
816 int bottom_field; /* true if bottom field */
819 int rct; /* standard rct */
820 int pegasus_rct; /* pegasus reversible colorspace transform */
821 int bits; /* bits per component */
824 int mb_width, mb_height;
826 int component_id[MAX_COMPONENTS];
827 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
828 int v_count[MAX_COMPONENTS];
829 int comp_index[MAX_COMPONENTS];
830 int dc_index[MAX_COMPONENTS];
831 int ac_index[MAX_COMPONENTS];
832 int nb_blocks[MAX_COMPONENTS];
833 int h_scount[MAX_COMPONENTS];
834 int v_scount[MAX_COMPONENTS];
835 int h_max, v_max; /* maximum h and v counts */
836 int quant_index[4]; /* quant table index for each component */
837 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
838 uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
839 int linesize[MAX_COMPONENTS];
840 uint8_t *qscale_table;
841 DCTELEM block[64] __align8;
843 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
845 int restart_interval;
849 int interlace_polarity;
850 } MJpegDecodeContext;
852 static int mjpeg_decode_dht(MJpegDecodeContext *s);
854 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
857 uint8_t huff_size[256];
858 uint16_t huff_code[256];
860 memset(huff_size, 0, sizeof(huff_size));
861 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
863 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
866 static int mjpeg_decode_init(AVCodecContext *avctx)
868 MJpegDecodeContext *s = avctx->priv_data;
873 /* ugly way to get the idct & scantable FIXME */
874 memset(&s2, 0, sizeof(MpegEncContext));
875 s2.flags= avctx->flags;
877 // s2->out_format = FMT_MJPEG;
880 if (MPV_common_init(&s2) < 0)
882 s->scantable= s2.intra_scantable;
883 s->idct_put= s2.dsp.idct_put;
886 s->mpeg_enc_ctx_allocated = 0;
887 s->buffer_size = 102400; /* smaller buffer should be enough,
888 but photojpg files could ahive bigger sizes */
889 s->buffer = av_malloc(s->buffer_size);
893 s->first_picture = 1;
894 s->org_width = avctx->width;
895 s->org_height = avctx->height;
897 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
898 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
899 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
900 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
902 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
904 printf("mjpeg: using external huffman table\n");
905 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
907 /* should check for error - but dunno */
913 /* quantize tables */
914 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
916 int len, index, i, j;
918 len = get_bits(&s->gb, 16) - 2;
921 /* only 8 bit precision handled */
922 if (get_bits(&s->gb, 4) != 0)
924 dprintf("dqt: 16bit precision\n");
927 index = get_bits(&s->gb, 4);
930 dprintf("index=%d\n", index);
931 /* read quant table */
933 j = s->scantable.permutated[i];
934 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
937 //XXX FIXME finetune, and perhaps add dc too
938 s->qscale[index]= FFMAX(
939 s->quant_matrixes[index][s->scantable.permutated[1]],
940 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
947 /* decode huffman tables and build VLC decoders */
948 static int mjpeg_decode_dht(MJpegDecodeContext *s)
950 int len, index, i, class, n, v, code_max;
951 uint8_t bits_table[17];
952 uint8_t val_table[256];
954 len = get_bits(&s->gb, 16) - 2;
959 class = get_bits(&s->gb, 4);
962 index = get_bits(&s->gb, 4);
967 bits_table[i] = get_bits(&s->gb, 8);
971 if (len < n || n > 256)
976 v = get_bits(&s->gb, 8);
983 /* build VLC and flush previous vlc if present */
984 free_vlc(&s->vlcs[class][index]);
985 dprintf("class=%d index=%d nb_codes=%d\n",
986 class, index, code_max + 1);
987 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
994 static int mjpeg_decode_sof(MJpegDecodeContext *s)
996 int len, nb_components, i, width, height;
998 /* XXX: verify len field validity */
999 len = get_bits(&s->gb, 16);
1000 s->bits= get_bits(&s->gb, 8);
1002 if(s->pegasus_rct) s->bits=9;
1003 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1005 if (s->bits != 8 && !s->lossless){
1006 printf("only 8 bits/component accepted\n");
1009 height = get_bits(&s->gb, 16);
1010 width = get_bits(&s->gb, 16);
1011 dprintf("sof0: picture: %dx%d\n", width, height);
1013 nb_components = get_bits(&s->gb, 8);
1014 if (nb_components <= 0 ||
1015 nb_components > MAX_COMPONENTS)
1017 s->nb_components = nb_components;
1020 for(i=0;i<nb_components;i++) {
1022 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1023 s->h_count[i] = get_bits(&s->gb, 4);
1024 s->v_count[i] = get_bits(&s->gb, 4);
1025 /* compute hmax and vmax (only used in interleaved case) */
1026 if (s->h_count[i] > s->h_max)
1027 s->h_max = s->h_count[i];
1028 if (s->v_count[i] > s->v_max)
1029 s->v_max = s->v_count[i];
1030 s->quant_index[i] = get_bits(&s->gb, 8);
1031 if (s->quant_index[i] >= 4)
1033 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1034 s->v_count[i], s->component_id[i], s->quant_index[i]);
1037 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1039 /* if different size, realloc/alloc picture */
1040 /* XXX: also check h_count and v_count */
1041 if (width != s->width || height != s->height) {
1042 for(i=0;i<MAX_COMPONENTS;i++)
1043 av_freep(&s->current_picture[i]);
1045 av_freep(&s->qscale_table);
1049 /* test interlaced mode */
1050 if (s->first_picture &&
1051 s->org_height != 0 &&
1052 s->height < ((s->org_height * 3) / 4)) {
1054 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1055 s->bottom_field = 0;
1064 s->linesize[0] = 4*w;
1065 s->current_picture[0] = av_mallocz(4*w * h);
1066 s->current_picture[1] = s->current_picture[2] = NULL;
1068 for(i=0;i<nb_components;i++) {
1070 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
1071 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1072 w = w * 8 * s->h_count[i];
1073 h = h * 8 * s->v_count[i];
1077 s->current_picture[i] = av_mallocz(w * h);
1078 if (!s->current_picture[i])
1080 dprintf("error: no picture buffers allocated\n");
1085 s->qscale_table= av_mallocz((s->width+15)/16);
1087 s->first_picture = 0;
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->current_picture[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->current_picture[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->current_picture[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->current_picture[c] +
1341 (s->linesize[c] * (v * mb_y + y) * 8) +
1343 if (s->interlaced && s->bottom_field)
1344 ptr += s->linesize[c] >> 1;
1345 s->idct_put(ptr, s->linesize[c], s->block);
1352 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1353 if (s->restart_interval && (s->restart_interval < 1350) &&
1354 !--s->restart_count) {
1355 align_get_bits(&s->gb);
1356 skip_bits(&s->gb, 16); /* skip RSTn */
1357 for (i=0; i<nb_components; i++) /* reset dc */
1358 s->last_dc[i] = 1024;
1365 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1367 int len, nb_components, i, h, v, predictor, point_transform, ilv;
1368 int vmax, hmax, index, id;
1369 const int block_size= s->lossless ? 1 : 8;
1371 /* XXX: verify len field validity */
1372 len = get_bits(&s->gb, 16);
1373 nb_components = get_bits(&s->gb, 8);
1374 if (len != 6+2*nb_components)
1376 dprintf("decode_sos: invalid len (%d)\n", len);
1379 /* XXX: only interleaved scan accepted */
1380 if (nb_components != 3)
1382 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1387 for(i=0;i<nb_components;i++) {
1388 id = get_bits(&s->gb, 8) - 1;
1389 dprintf("component: %d\n", id);
1390 /* find component index */
1391 for(index=0;index<s->nb_components;index++)
1392 if (id == s->component_id[index])
1394 if (index == s->nb_components)
1396 dprintf("decode_sos: index(%d) out of components\n", index);
1400 s->comp_index[i] = index;
1402 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1403 s->h_scount[i] = s->h_count[index];
1404 s->v_scount[i] = s->v_count[index];
1406 s->dc_index[i] = get_bits(&s->gb, 4);
1407 s->ac_index[i] = get_bits(&s->gb, 4);
1409 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1410 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1413 switch(s->start_code)
1416 if (dc_index[i] > 1 || ac_index[i] > 1)
1421 if (dc_index[i] > 3 || ac_index[i] > 3)
1425 if (dc_index[i] > 3 || ac_index[i] != 0)
1432 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1433 skip_bits(&s->gb, 8); /* Se */
1434 skip_bits(&s->gb, 4); /* Ah */
1435 point_transform= get_bits(&s->gb, 4); /* Al */
1437 for(i=0;i<nb_components;i++)
1438 s->last_dc[i] = 1024;
1440 if (nb_components > 1) {
1441 /* interleaved stream */
1442 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1443 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1445 h = s->h_max / s->h_scount[s->comp_index[0]];
1446 v = s->v_max / s->v_scount[s->comp_index[0]];
1447 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1448 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1449 s->nb_blocks[0] = 1;
1454 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1455 printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1459 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1462 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1466 if(mjpeg_decode_scan(s) < 0)
1472 dprintf("decode_sos: ac/dc index out of range\n");
1476 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1478 if (get_bits(&s->gb, 16) != 4)
1480 s->restart_interval = get_bits(&s->gb, 16);
1481 dprintf("restart interval: %d\n", s->restart_interval);
1486 static int mjpeg_decode_app(MJpegDecodeContext *s)
1490 /* XXX: verify len field validity */
1491 len = get_bits(&s->gb, 16);
1495 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1499 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1500 printf("APPx %8X\n", id);
1503 /* buggy AVID, it puts EOI only at every 10th frame */
1504 /* also this fourcc is used by non-avid files too, it holds some
1505 informations, but it's always present in AVID creates files */
1506 if (id == ff_get_fourcc("AVI1"))
1513 4bytes field_size_less_padding
1516 // if (s->first_picture)
1517 // printf("mjpeg: workarounding buggy AVID\n");
1518 s->interlace_polarity = get_bits(&s->gb, 8);
1520 skip_bits(&s->gb, 8);
1521 skip_bits(&s->gb, 32);
1522 skip_bits(&s->gb, 32);
1525 // if (s->interlace_polarity)
1526 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1532 if (id == ff_get_fourcc("JFIF"))
1535 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1536 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1537 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1538 if (get_bits(&s->gb, 8) == 0)
1540 int x_density, y_density;
1541 x_density = get_bits(&s->gb, 16);
1542 y_density = get_bits(&s->gb, 16);
1544 dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1545 (float)x_density, y_density, (float)y_density);
1547 //MN: needs to be checked
1549 // s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1550 s->avctx->aspect_ratio = (float)x_density/y_density;
1551 /* it's better, but every JFIF I have seen stores 1:1 */
1553 s->avctx->aspect_ratio= 0.0;
1558 skip_bits(&s->gb, 16);
1559 skip_bits(&s->gb, 16);
1562 t_w = get_bits(&s->gb, 8);
1563 t_h = get_bits(&s->gb, 8);
1566 /* skip thumbnail */
1567 if (len-10-(t_w*t_h*3) > 0)
1574 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1576 printf("mjpeg: Adobe header found\n");
1577 skip_bits(&s->gb, 16); /* version */
1578 skip_bits(&s->gb, 16); /* flags0 */
1579 skip_bits(&s->gb, 16); /* flags1 */
1580 skip_bits(&s->gb, 8); /* transform */
1585 if (id == ff_get_fourcc("LJIF")){
1586 printf("Pegasus lossless jpeg header found\n");
1587 skip_bits(&s->gb, 16); /* version ? */
1588 skip_bits(&s->gb, 16); /* unknwon always 0? */
1589 skip_bits(&s->gb, 16); /* unknwon always 0? */
1590 skip_bits(&s->gb, 16); /* unknwon always 0? */
1591 switch( get_bits(&s->gb, 8)){
1601 printf("unknown colorspace\n");
1608 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1610 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1613 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1616 skip_bits(&s->gb, 32); /* field size */
1617 skip_bits(&s->gb, 32); /* pad field size */
1618 skip_bits(&s->gb, 32); /* next off */
1619 skip_bits(&s->gb, 32); /* quant off */
1620 skip_bits(&s->gb, 32); /* huff off */
1621 skip_bits(&s->gb, 32); /* image off */
1622 skip_bits(&s->gb, 32); /* scan off */
1623 skip_bits(&s->gb, 32); /* data off */
1625 if (s->first_picture)
1626 printf("mjpeg: Apple MJPEG-A header found\n");
1631 /* slow but needed for extreme adobe jpegs */
1633 printf("mjpeg: error, decode_app parser read over the end\n");
1635 skip_bits(&s->gb, 8);
1640 static int mjpeg_decode_com(MJpegDecodeContext *s)
1642 /* XXX: verify len field validity */
1643 int len = get_bits(&s->gb, 16);
1644 if (len >= 2 && len < 32768) {
1645 /* XXX: any better upper bound */
1646 uint8_t *cbuf = av_malloc(len - 1);
1649 for (i = 0; i < len - 2; i++)
1650 cbuf[i] = get_bits(&s->gb, 8);
1651 if (i > 0 && cbuf[i-1] == '\n')
1656 printf("mjpeg comment: '%s'\n", cbuf);
1658 /* buggy avid, it puts EOI only at every 10th frame */
1659 if (!strcmp(cbuf, "AVID"))
1662 // if (s->first_picture)
1663 // printf("mjpeg: workarounding buggy AVID\n");
1674 static int valid_marker_list[] =
1676 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1677 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1690 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1691 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1692 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1696 /* return the 8 bit start code value and update the search
1697 state. Return -1 if no start code found */
1698 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1707 buf_ptr = *pbuf_ptr;
1708 while (buf_ptr < buf_end) {
1711 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1722 dprintf("find_marker skipped %d bytes\n", skipped);
1724 *pbuf_ptr = buf_ptr;
1728 static int mjpeg_decode_frame(AVCodecContext *avctx,
1729 void *data, int *data_size,
1730 uint8_t *buf, int buf_size)
1732 MJpegDecodeContext *s = avctx->priv_data;
1733 uint8_t *buf_end, *buf_ptr;
1735 AVFrame *picture = data;
1739 /* no supplementary picture */
1744 buf_end = buf + buf_size;
1745 while (buf_ptr < buf_end) {
1746 /* find start next marker */
1747 start_code = find_marker(&buf_ptr, buf_end);
1750 if (start_code < 0) {
1753 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1755 if ((buf_end - buf_ptr) > s->buffer_size)
1758 s->buffer_size = buf_end-buf_ptr;
1759 s->buffer = av_malloc(s->buffer_size);
1760 dprintf("buffer too small, expanding to %d bytes\n",
1764 /* unescape buffer of SOS */
1765 if (start_code == SOS)
1767 uint8_t *src = buf_ptr;
1768 uint8_t *dst = s->buffer;
1772 uint8_t x = *(src++);
1777 while(*src == 0xff) src++;
1780 if (x >= 0xd0 && x <= 0xd7)
1786 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1788 dprintf("escaping removed %d bytes\n",
1789 (buf_end - buf_ptr) - (dst - s->buffer));
1792 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1794 s->start_code = start_code;
1795 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1796 printf("startcode: %X\n", start_code);
1799 /* process markers */
1800 if (start_code >= 0xd0 && start_code <= 0xd7) {
1801 dprintf("restart marker: %d\n", start_code&0x0f);
1802 } else if (s->first_picture) {
1804 if (start_code >= 0xe0 && start_code <= 0xef)
1805 mjpeg_decode_app(s);
1807 else if (start_code == COM)
1808 mjpeg_decode_com(s);
1811 switch(start_code) {
1813 s->restart_interval = 0;
1814 /* nothing to do on SOI */
1817 mjpeg_decode_dqt(s);
1820 if(mjpeg_decode_dht(s) < 0){
1821 fprintf(stderr, "huffman table decode error\n");
1827 if (mjpeg_decode_sof(s) < 0)
1832 if (mjpeg_decode_sof(s) < 0)
1836 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1840 if (s->interlaced) {
1841 s->bottom_field ^= 1;
1842 /* if not bottom field, do not output image yet */
1843 if (s->bottom_field)
1847 picture->data[i] = s->current_picture[i];
1848 picture->linesize[i] = (s->interlaced) ?
1849 s->linesize[i] >> 1 : s->linesize[i];
1851 *data_size = sizeof(AVFrame);
1852 avctx->height = s->height;
1855 avctx->width = s->width;
1856 /* XXX: not complete test ! */
1857 switch((s->h_count[0] << 4) | s->v_count[0]) {
1860 avctx->pix_fmt = PIX_FMT_RGBA32;
1862 avctx->pix_fmt = PIX_FMT_YUV444P;
1865 avctx->pix_fmt = PIX_FMT_YUV422P;
1869 avctx->pix_fmt = PIX_FMT_YUV420P;
1874 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1875 picture->qstride= 0;
1876 picture->qscale_table= s->qscale_table;
1877 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1878 if(avctx->debug & FF_DEBUG_QP)
1879 printf("QP: %d\n", (int)picture->quality);
1886 mjpeg_decode_sos(s);
1887 /* buggy avid puts EOI every 10-20th frame */
1888 /* if restart period is over process EOI */
1889 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1893 mjpeg_decode_dri(s);
1907 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1910 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1915 /* eof process start code */
1916 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1917 dprintf("marker parser used %d bytes (%d bits)\n",
1918 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1923 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1924 // return buf_end - buf_ptr;
1925 return buf_ptr - buf;
1928 static int mjpegb_decode_frame(AVCodecContext *avctx,
1929 void *data, int *data_size,
1930 uint8_t *buf, int buf_size)
1932 MJpegDecodeContext *s = avctx->priv_data;
1933 uint8_t *buf_end, *buf_ptr;
1935 AVFrame *picture = data;
1936 GetBitContext hgb; /* for the header */
1937 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1938 uint32_t field_size;
1942 /* no supplementary picture */
1947 buf_end = buf + buf_size;
1950 /* reset on every SOI */
1951 s->restart_interval = 0;
1953 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1955 skip_bits(&hgb, 32); /* reserved zeros */
1957 if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1959 dprintf("not mjpeg-b (bad fourcc)\n");
1963 field_size = get_bits(&hgb, 32); /* field size */
1964 dprintf("field size: 0x%x\n", field_size);
1965 skip_bits(&hgb, 32); /* padded field size */
1966 second_field_offs = get_bits(&hgb, 32);
1967 dprintf("second field offs: 0x%x\n", second_field_offs);
1968 if (second_field_offs)
1971 dqt_offs = get_bits(&hgb, 32);
1972 dprintf("dqt offs: 0x%x\n", dqt_offs);
1975 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1976 s->start_code = DQT;
1977 mjpeg_decode_dqt(s);
1980 dht_offs = get_bits(&hgb, 32);
1981 dprintf("dht offs: 0x%x\n", dht_offs);
1984 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1985 s->start_code = DHT;
1986 mjpeg_decode_dht(s);
1989 sof_offs = get_bits(&hgb, 32);
1990 dprintf("sof offs: 0x%x\n", sof_offs);
1993 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1994 s->start_code = SOF0;
1995 if (mjpeg_decode_sof(s) < 0)
1999 sos_offs = get_bits(&hgb, 32);
2000 dprintf("sos offs: 0x%x\n", sos_offs);
2003 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2004 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2005 s->start_code = SOS;
2006 mjpeg_decode_sos(s);
2009 skip_bits(&hgb, 32); /* start of data offset */
2011 if (s->interlaced) {
2012 s->bottom_field ^= 1;
2013 /* if not bottom field, do not output image yet */
2014 if (s->bottom_field && second_field_offs)
2016 buf_ptr = buf + second_field_offs;
2017 second_field_offs = 0;
2022 //XXX FIXME factorize, this looks very similar to the EOI code
2025 picture->data[i] = s->current_picture[i];
2026 picture->linesize[i] = (s->interlaced) ?
2027 s->linesize[i] >> 1 : s->linesize[i];
2029 *data_size = sizeof(AVFrame);
2030 avctx->height = s->height;
2033 avctx->width = s->width;
2034 /* XXX: not complete test ! */
2035 switch((s->h_count[0] << 4) | s->v_count[0]) {
2037 avctx->pix_fmt = PIX_FMT_YUV444P;
2040 avctx->pix_fmt = PIX_FMT_YUV422P;
2044 avctx->pix_fmt = PIX_FMT_YUV420P;
2049 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2050 picture->qstride= 0;
2051 picture->qscale_table= s->qscale_table;
2052 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2053 if(avctx->debug & FF_DEBUG_QP)
2054 printf("QP: %f\n", picture->quality);
2057 return buf_ptr - buf;
2061 static int mjpeg_decode_end(AVCodecContext *avctx)
2063 MJpegDecodeContext *s = avctx->priv_data;
2067 av_free(s->qscale_table);
2068 for(i=0;i<MAX_COMPONENTS;i++)
2069 av_free(s->current_picture[i]);
2072 free_vlc(&s->vlcs[i][j]);
2077 AVCodec mjpeg_decoder = {
2081 sizeof(MJpegDecodeContext),
2090 AVCodec mjpegb_decoder = {
2094 sizeof(MJpegDecodeContext),
2098 mjpegb_decode_frame,
2103 #ifdef CONFIG_ENCODERS
2104 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2108 sizeof(MpegEncContext),
2110 encode_picture_lossless,