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;\
293 case 7: ret= (left + top)>>1; break;\
296 #ifdef CONFIG_ENCODERS
297 static inline void put_marker(PutBitContext *p, int code)
299 put_bits(p, 8, 0xff);
300 put_bits(p, 8, code);
303 /* table_class: 0 = DC coef, 1 = AC coefs */
304 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
305 const uint8_t *bits_table, const uint8_t *value_table)
307 PutBitContext *p = &s->pb;
310 put_bits(p, 4, table_class);
311 put_bits(p, 4, table_id);
316 put_bits(p, 8, bits_table[i]);
320 put_bits(p, 8, value_table[i]);
325 static void jpeg_table_header(MpegEncContext *s)
327 PutBitContext *p = &s->pb;
334 put_bits(p, 16, 2 + 2 * (1 + 64));
336 put_bits(p, 16, 2 + 1 * (1 + 64));
338 put_bits(p, 4, 0); /* 8 bit precision */
339 put_bits(p, 4, 0); /* table 0 */
341 j = s->intra_scantable.permutated[i];
342 put_bits(p, 8, s->intra_matrix[j]);
345 put_bits(p, 4, 0); /* 8 bit precision */
346 put_bits(p, 4, 1); /* table 1 */
348 j = s->intra_scantable.permutated[i];
349 put_bits(p, 8, s->chroma_intra_matrix[j]);
357 put_bits(p, 16, 0); /* patched later */
359 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
360 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
362 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
363 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
368 static void jpeg_put_comments(MpegEncContext *s)
370 PutBitContext *p = &s->pb;
374 if (s->aspect_ratio_info /* && !lossless */)
379 put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
380 put_bits(p, 16, 0x0201); /* v 1.02 */
381 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
382 switch(s->aspect_ratio_info)
384 case FF_ASPECT_4_3_625:
385 case FF_ASPECT_4_3_525:
389 case FF_ASPECT_16_9_625:
390 case FF_ASPECT_16_9_525:
394 case FF_ASPECT_EXTENDED:
395 put_bits(p, 16, s->aspected_width);
396 put_bits(p, 16, s->aspected_height);
398 case FF_ASPECT_SQUARE:
400 put_bits(p, 16, 1); /* aspect: 1:1 */
404 put_bits(p, 8, 0); /* thumbnail width */
405 put_bits(p, 8, 0); /* thumbnail height */
409 if(!(s->flags & CODEC_FLAG_BITEXACT)){
413 put_bits(p, 16, 0); /* patched later */
414 put_string(p, LIBAVCODEC_IDENT);
415 size = strlen(LIBAVCODEC_IDENT)+3;
421 void mjpeg_picture_header(MpegEncContext *s)
423 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
425 put_marker(&s->pb, SOI);
427 if (!s->mjpeg_data_only_frames)
429 jpeg_put_comments(s);
431 if (s->mjpeg_write_tables) jpeg_table_header(s);
433 put_marker(&s->pb, lossless ? SOF3 : SOF0);
435 put_bits(&s->pb, 16, 17);
436 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
437 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
439 put_bits(&s->pb, 8, 8); /* 8 bits/component */
440 put_bits(&s->pb, 16, s->height);
441 put_bits(&s->pb, 16, s->width);
442 put_bits(&s->pb, 8, 3); /* 3 components */
445 put_bits(&s->pb, 8, 1); /* component number */
446 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
447 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
448 put_bits(&s->pb, 8, 0); /* select matrix */
451 put_bits(&s->pb, 8, 2); /* component number */
452 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
453 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
455 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
457 put_bits(&s->pb, 8, 0); /* select matrix */
461 put_bits(&s->pb, 8, 3); /* component number */
462 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
463 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
465 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
467 put_bits(&s->pb, 8, 0); /* select matrix */
472 put_marker(&s->pb, SOS);
473 put_bits(&s->pb, 16, 12); /* length */
474 put_bits(&s->pb, 8, 3); /* 3 components */
477 put_bits(&s->pb, 8, 1); /* index */
478 put_bits(&s->pb, 4, 0); /* DC huffman table index */
479 put_bits(&s->pb, 4, 0); /* AC huffman table index */
482 put_bits(&s->pb, 8, 2); /* index */
483 put_bits(&s->pb, 4, 1); /* DC huffman table index */
484 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
487 put_bits(&s->pb, 8, 3); /* index */
488 put_bits(&s->pb, 4, 1); /* DC huffman table index */
489 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
491 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
492 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
493 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
496 static void escape_FF(MpegEncContext *s, int start)
498 int size= get_bit_count(&s->pb) - start*8;
500 uint8_t *buf= s->pb.buf + start;
501 int align= (-(size_t)(buf))&3;
503 assert((size&7) == 0);
507 for(i=0; i<size && i<align; i++){
508 if(buf[i]==0xFF) ff_count++;
510 for(; i<size-15; i+=16){
513 v= *(uint32_t*)(&buf[i]);
514 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
515 v= *(uint32_t*)(&buf[i+4]);
516 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517 v= *(uint32_t*)(&buf[i+8]);
518 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519 v= *(uint32_t*)(&buf[i+12]);
520 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
528 if(buf[i]==0xFF) ff_count++;
531 if(ff_count==0) return;
534 for(i=0; i<ff_count-3; i+=4)
535 put_bits(&s->pb, 32, 0);
536 put_bits(&s->pb, (ff_count-i)*8, 0);
537 flush_put_bits(&s->pb);
539 for(i=size-1; ff_count; i--){
543 //printf("%d %d\n", i, ff_count);
552 void mjpeg_picture_trailer(MpegEncContext *s)
554 int pad= (-get_bit_count(&s->pb))&7;
556 put_bits(&s->pb, pad,0xFF>>(8-pad));
557 flush_put_bits(&s->pb);
559 assert((s->header_bits&7)==0);
561 escape_FF(s, s->header_bits>>3);
563 put_marker(&s->pb, EOI);
566 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
567 uint8_t *huff_size, uint16_t *huff_code)
572 put_bits(&s->pb, huff_size[0], huff_code[0]);
580 nbits= av_log2_16bit(val) + 1;
582 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
584 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
588 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
590 int mant, nbits, code, i, j;
591 int component, dc, run, last_index, val;
592 MJpegContext *m = s->mjpeg_ctx;
593 uint8_t *huff_size_ac;
594 uint16_t *huff_code_ac;
597 component = (n <= 3 ? 0 : n - 4 + 1);
598 dc = block[0]; /* overflow is impossible */
599 val = dc - s->last_dc[component];
601 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
602 huff_size_ac = m->huff_size_ac_luminance;
603 huff_code_ac = m->huff_code_ac_luminance;
605 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
606 huff_size_ac = m->huff_size_ac_chrominance;
607 huff_code_ac = m->huff_code_ac_chrominance;
609 s->last_dc[component] = dc;
614 last_index = s->block_last_index[n];
615 for(i=1;i<=last_index;i++) {
616 j = s->intra_scantable.permutated[i];
622 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
631 nbits= av_log2(val) + 1;
632 code = (run << 4) | nbits;
634 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
636 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
641 /* output EOB only if not already 64 values */
642 if (last_index < 63 || run != 0)
643 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
646 void mjpeg_encode_mb(MpegEncContext *s,
647 DCTELEM block[6][64])
651 encode_block(s, block[i], i);
655 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
656 MpegEncContext * const s = avctx->priv_data;
657 MJpegContext * const m = s->mjpeg_ctx;
658 AVFrame *pict = data;
659 const int width= s->width;
660 const int height= s->height;
661 AVFrame * const p= (AVFrame*)&s->current_picture;
662 const int predictor= avctx->prediction_method+1;
664 init_put_bits(&s->pb, buf, buf_size, NULL, NULL);
667 p->pict_type= FF_I_TYPE;
670 mjpeg_picture_header(s);
672 s->header_bits= get_bit_count(&s->pb);
674 if(avctx->pix_fmt == PIX_FMT_RGBA32){
676 const int linesize= p->linesize[0];
677 uint16_t buffer[2048][4];
678 int left[3], top[3], topleft[3];
681 buffer[0][i]= 1 << (9 - 1);
684 for(y = 0; y < height; y++) {
685 const int modified_predictor= y ? predictor : 1;
686 uint8_t *ptr = p->data[0] + (linesize * y);
689 top[i]= left[i]= topleft[i]= buffer[0][i];
691 for(x = 0; x < width; x++) {
692 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
693 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
694 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
699 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
702 top[i]= buffer[x+1][i];
704 left[i]= buffer[x][i];
706 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
709 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
711 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
717 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
718 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
720 for(mb_y = 0; mb_y < mb_height; mb_y++) {
721 for(mb_x = 0; mb_x < mb_width; mb_x++) {
722 if(mb_x==0 || mb_y==0){
725 int x, y, h, v, linesize;
726 h = s->mjpeg_hsample[i];
727 v = s->mjpeg_vsample[i];
728 linesize= p->linesize[i];
734 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
743 pred= ptr[-linesize];
745 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
750 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
752 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
759 int x, y, h, v, linesize;
760 h = s->mjpeg_hsample[i];
761 v = s->mjpeg_vsample[i];
762 linesize= p->linesize[i];
768 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
769 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
770 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
773 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
775 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
786 mjpeg_picture_trailer(s);
789 flush_put_bits(&s->pb);
790 return pbBufPtr(&s->pb) - s->pb.buf;
791 // return (get_bit_count(&f->pb)+7)/8;
794 #endif //CONFIG_ENCODERS
796 /******************************************/
799 #define MAX_COMPONENTS 4
801 typedef struct MJpegDecodeContext {
802 AVCodecContext *avctx;
804 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
806 int start_code; /* current start code */
810 int16_t quant_matrixes[4][64];
812 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
814 int org_width, org_height; /* size given at codec init */
815 int first_picture; /* true if decoding first picture */
816 int interlaced; /* true if interlaced */
817 int bottom_field; /* true if bottom field */
820 int rct; /* standard rct */
821 int pegasus_rct; /* pegasus reversible colorspace transform */
822 int bits; /* bits per component */
825 int mb_width, mb_height;
827 int component_id[MAX_COMPONENTS];
828 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
829 int v_count[MAX_COMPONENTS];
830 int comp_index[MAX_COMPONENTS];
831 int dc_index[MAX_COMPONENTS];
832 int ac_index[MAX_COMPONENTS];
833 int nb_blocks[MAX_COMPONENTS];
834 int h_scount[MAX_COMPONENTS];
835 int v_scount[MAX_COMPONENTS];
836 int h_max, v_max; /* maximum h and v counts */
837 int quant_index[4]; /* quant table index for each component */
838 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
839 uint8_t *current_picture[MAX_COMPONENTS]; /* picture structure */
840 int linesize[MAX_COMPONENTS];
841 uint8_t *qscale_table;
842 DCTELEM block[64] __align8;
844 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
846 int restart_interval;
850 int interlace_polarity;
851 } MJpegDecodeContext;
853 static int mjpeg_decode_dht(MJpegDecodeContext *s);
855 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
858 uint8_t huff_size[256];
859 uint16_t huff_code[256];
861 memset(huff_size, 0, sizeof(huff_size));
862 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
864 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
867 static int mjpeg_decode_init(AVCodecContext *avctx)
869 MJpegDecodeContext *s = avctx->priv_data;
874 /* ugly way to get the idct & scantable FIXME */
875 memset(&s2, 0, sizeof(MpegEncContext));
876 s2.flags= avctx->flags;
878 // s2->out_format = FMT_MJPEG;
881 if (MPV_common_init(&s2) < 0)
883 s->scantable= s2.intra_scantable;
884 s->idct_put= s2.dsp.idct_put;
887 s->mpeg_enc_ctx_allocated = 0;
888 s->buffer_size = 102400; /* smaller buffer should be enough,
889 but photojpg files could ahive bigger sizes */
890 s->buffer = av_malloc(s->buffer_size);
894 s->first_picture = 1;
895 s->org_width = avctx->width;
896 s->org_height = avctx->height;
898 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
899 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
900 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
901 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
903 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
905 printf("mjpeg: using external huffman table\n");
906 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
908 /* should check for error - but dunno */
914 /* quantize tables */
915 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
917 int len, index, i, j;
919 len = get_bits(&s->gb, 16) - 2;
922 /* only 8 bit precision handled */
923 if (get_bits(&s->gb, 4) != 0)
925 dprintf("dqt: 16bit precision\n");
928 index = get_bits(&s->gb, 4);
931 dprintf("index=%d\n", index);
932 /* read quant table */
934 j = s->scantable.permutated[i];
935 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
938 //XXX FIXME finetune, and perhaps add dc too
939 s->qscale[index]= FFMAX(
940 s->quant_matrixes[index][s->scantable.permutated[1]],
941 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
948 /* decode huffman tables and build VLC decoders */
949 static int mjpeg_decode_dht(MJpegDecodeContext *s)
951 int len, index, i, class, n, v, code_max;
952 uint8_t bits_table[17];
953 uint8_t val_table[256];
955 len = get_bits(&s->gb, 16) - 2;
960 class = get_bits(&s->gb, 4);
963 index = get_bits(&s->gb, 4);
968 bits_table[i] = get_bits(&s->gb, 8);
972 if (len < n || n > 256)
977 v = get_bits(&s->gb, 8);
984 /* build VLC and flush previous vlc if present */
985 free_vlc(&s->vlcs[class][index]);
986 dprintf("class=%d index=%d nb_codes=%d\n",
987 class, index, code_max + 1);
988 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
995 static int mjpeg_decode_sof(MJpegDecodeContext *s)
997 int len, nb_components, i, width, height;
999 /* XXX: verify len field validity */
1000 len = get_bits(&s->gb, 16);
1001 s->bits= get_bits(&s->gb, 8);
1003 if(s->pegasus_rct) s->bits=9;
1004 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1006 if (s->bits != 8 && !s->lossless){
1007 printf("only 8 bits/component accepted\n");
1010 height = get_bits(&s->gb, 16);
1011 width = get_bits(&s->gb, 16);
1012 dprintf("sof0: picture: %dx%d\n", width, height);
1014 nb_components = get_bits(&s->gb, 8);
1015 if (nb_components <= 0 ||
1016 nb_components > MAX_COMPONENTS)
1018 s->nb_components = nb_components;
1021 for(i=0;i<nb_components;i++) {
1023 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1024 s->h_count[i] = get_bits(&s->gb, 4);
1025 s->v_count[i] = get_bits(&s->gb, 4);
1026 /* compute hmax and vmax (only used in interleaved case) */
1027 if (s->h_count[i] > s->h_max)
1028 s->h_max = s->h_count[i];
1029 if (s->v_count[i] > s->v_max)
1030 s->v_max = s->v_count[i];
1031 s->quant_index[i] = get_bits(&s->gb, 8);
1032 if (s->quant_index[i] >= 4)
1034 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1035 s->v_count[i], s->component_id[i], s->quant_index[i]);
1038 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1040 /* if different size, realloc/alloc picture */
1041 /* XXX: also check h_count and v_count */
1042 if (width != s->width || height != s->height) {
1043 for(i=0;i<MAX_COMPONENTS;i++)
1044 av_freep(&s->current_picture[i]);
1046 av_freep(&s->qscale_table);
1050 /* test interlaced mode */
1051 if (s->first_picture &&
1052 s->org_height != 0 &&
1053 s->height < ((s->org_height * 3) / 4)) {
1055 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1056 s->bottom_field = 0;
1065 s->linesize[0] = 4*w;
1066 s->current_picture[0] = av_mallocz(4*w * h);
1067 s->current_picture[1] = s->current_picture[2] = NULL;
1069 for(i=0;i<nb_components;i++) {
1071 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
1072 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
1073 w = w * 8 * s->h_count[i];
1074 h = h * 8 * s->v_count[i];
1078 s->current_picture[i] = av_mallocz(w * h);
1079 if (!s->current_picture[i])
1081 dprintf("error: no picture buffers allocated\n");
1086 s->qscale_table= av_mallocz((s->width+15)/16);
1088 s->first_picture = 0;
1091 if (len != (8+(3*nb_components)))
1093 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1099 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1102 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1105 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1106 &s->vlcs[0][dc_index]);
1111 return get_xbits(&s->gb, code);
1116 /* decode block and dequantize */
1117 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1118 int component, int dc_index, int ac_index, int quant_index)
1120 int code, i, j, level, val;
1122 int16_t *quant_matrix;
1125 val = mjpeg_decode_dc(s, dc_index);
1126 if (val == 0xffff) {
1127 dprintf("error dc\n");
1130 quant_matrix = s->quant_matrixes[quant_index];
1131 val = val * quant_matrix[0] + s->last_dc[component];
1132 s->last_dc[component] = val;
1135 ac_vlc = &s->vlcs[1][ac_index];
1138 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1141 dprintf("error ac\n");
1150 level = get_xbits(&s->gb, code & 0xf);
1153 dprintf("error count: %d\n", i);
1156 j = s->scantable.permutated[i];
1157 block[j] = level * quant_matrix[j];
1166 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1168 uint16_t buffer[2048][4];
1169 int left[3], top[3], topleft[3];
1170 const int linesize= s->linesize[0];
1171 const int mask= (1<<s->bits)-1;
1174 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1176 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1177 const int modified_predictor= mb_y ? predictor : 1;
1178 uint8_t *ptr = s->current_picture[0] + (linesize * mb_y);
1180 if (s->interlaced && s->bottom_field)
1181 ptr += linesize >> 1;
1184 top[i]= left[i]= topleft[i]= buffer[0][i];
1186 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1187 if (s->restart_interval && !s->restart_count)
1188 s->restart_count = s->restart_interval;
1194 top[i]= buffer[mb_x][i];
1196 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1199 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1202 if (s->restart_interval && !--s->restart_count) {
1203 align_get_bits(&s->gb);
1204 skip_bits(&s->gb, 16); /* skip RSTn */
1209 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1210 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1211 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1212 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1214 }else if(s->pegasus_rct){
1215 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1216 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1217 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1218 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1221 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1222 ptr[4*mb_x+0] = buffer[mb_x][0];
1223 ptr[4*mb_x+1] = buffer[mb_x][1];
1224 ptr[4*mb_x+2] = buffer[mb_x][2];
1231 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1233 const int nb_components=3;
1235 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1236 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1237 if (s->restart_interval && !s->restart_count)
1238 s->restart_count = s->restart_interval;
1240 if(mb_x==0 || mb_y==0 || s->interlaced){
1241 for(i=0;i<nb_components;i++) {
1243 int n, h, v, x, y, c, j, linesize;
1244 n = s->nb_blocks[i];
1245 c = s->comp_index[i];
1250 linesize= s->linesize[c];
1252 for(j=0; j<n; j++) {
1255 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1256 if(y==0 && mb_y==0){
1257 if(x==0 && mb_x==0){
1258 pred= 128 << point_transform;
1263 if(x==0 && mb_x==0){
1264 pred= ptr[-linesize];
1266 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1270 if (s->interlaced && s->bottom_field)
1271 ptr += linesize >> 1;
1272 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1281 for(i=0;i<nb_components;i++) {
1283 int n, h, v, x, y, c, j, linesize;
1284 n = s->nb_blocks[i];
1285 c = s->comp_index[i];
1290 linesize= s->linesize[c];
1292 for(j=0; j<n; j++) {
1295 ptr = s->current_picture[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1296 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1297 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1305 if (s->restart_interval && !--s->restart_count) {
1306 align_get_bits(&s->gb);
1307 skip_bits(&s->gb, 16); /* skip RSTn */
1314 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1316 const int nb_components=3;
1318 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1319 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1320 if (s->restart_interval && !s->restart_count)
1321 s->restart_count = s->restart_interval;
1323 for(i=0;i<nb_components;i++) {
1325 int n, h, v, x, y, c, j;
1326 n = s->nb_blocks[i];
1327 c = s->comp_index[i];
1333 memset(s->block, 0, sizeof(s->block));
1334 if (decode_block(s, s->block, i,
1335 s->dc_index[i], s->ac_index[i],
1336 s->quant_index[c]) < 0) {
1337 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1340 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1341 ptr = s->current_picture[c] +
1342 (s->linesize[c] * (v * mb_y + y) * 8) +
1344 if (s->interlaced && s->bottom_field)
1345 ptr += s->linesize[c] >> 1;
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 != 3)
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 printf("%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 printf("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"))
1536 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1537 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1538 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1539 if (get_bits(&s->gb, 8) == 0)
1541 int x_density, y_density;
1542 x_density = get_bits(&s->gb, 16);
1543 y_density = get_bits(&s->gb, 16);
1545 dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1546 (float)x_density, y_density, (float)y_density);
1548 //MN: needs to be checked
1550 // s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1551 s->avctx->aspect_ratio = (float)x_density/y_density;
1552 /* it's better, but every JFIF I have seen stores 1:1 */
1554 s->avctx->aspect_ratio= 0.0;
1559 skip_bits(&s->gb, 16);
1560 skip_bits(&s->gb, 16);
1563 t_w = get_bits(&s->gb, 8);
1564 t_h = get_bits(&s->gb, 8);
1567 /* skip thumbnail */
1568 if (len-10-(t_w*t_h*3) > 0)
1575 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1577 printf("mjpeg: Adobe header found\n");
1578 skip_bits(&s->gb, 16); /* version */
1579 skip_bits(&s->gb, 16); /* flags0 */
1580 skip_bits(&s->gb, 16); /* flags1 */
1581 skip_bits(&s->gb, 8); /* transform */
1586 if (id == ff_get_fourcc("LJIF")){
1587 printf("Pegasus lossless jpeg header found\n");
1588 skip_bits(&s->gb, 16); /* version ? */
1589 skip_bits(&s->gb, 16); /* unknwon always 0? */
1590 skip_bits(&s->gb, 16); /* unknwon always 0? */
1591 skip_bits(&s->gb, 16); /* unknwon always 0? */
1592 switch( get_bits(&s->gb, 8)){
1602 printf("unknown colorspace\n");
1609 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1611 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1614 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1617 skip_bits(&s->gb, 32); /* field size */
1618 skip_bits(&s->gb, 32); /* pad field size */
1619 skip_bits(&s->gb, 32); /* next off */
1620 skip_bits(&s->gb, 32); /* quant off */
1621 skip_bits(&s->gb, 32); /* huff off */
1622 skip_bits(&s->gb, 32); /* image off */
1623 skip_bits(&s->gb, 32); /* scan off */
1624 skip_bits(&s->gb, 32); /* data off */
1626 if (s->first_picture)
1627 printf("mjpeg: Apple MJPEG-A header found\n");
1632 /* slow but needed for extreme adobe jpegs */
1634 printf("mjpeg: error, decode_app parser read over the end\n");
1636 skip_bits(&s->gb, 8);
1641 static int mjpeg_decode_com(MJpegDecodeContext *s)
1643 /* XXX: verify len field validity */
1644 int len = get_bits(&s->gb, 16);
1645 if (len >= 2 && len < 32768) {
1646 /* XXX: any better upper bound */
1647 uint8_t *cbuf = av_malloc(len - 1);
1650 for (i = 0; i < len - 2; i++)
1651 cbuf[i] = get_bits(&s->gb, 8);
1652 if (i > 0 && cbuf[i-1] == '\n')
1657 printf("mjpeg comment: '%s'\n", cbuf);
1659 /* buggy avid, it puts EOI only at every 10th frame */
1660 if (!strcmp(cbuf, "AVID"))
1663 // if (s->first_picture)
1664 // printf("mjpeg: workarounding buggy AVID\n");
1675 static int valid_marker_list[] =
1677 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1678 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1679 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1680 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1681 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1689 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1691 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1692 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1693 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1697 /* return the 8 bit start code value and update the search
1698 state. Return -1 if no start code found */
1699 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1708 buf_ptr = *pbuf_ptr;
1709 while (buf_ptr < buf_end) {
1712 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1723 dprintf("find_marker skipped %d bytes\n", skipped);
1725 *pbuf_ptr = buf_ptr;
1729 static int mjpeg_decode_frame(AVCodecContext *avctx,
1730 void *data, int *data_size,
1731 uint8_t *buf, int buf_size)
1733 MJpegDecodeContext *s = avctx->priv_data;
1734 uint8_t *buf_end, *buf_ptr;
1736 AVFrame *picture = data;
1740 /* no supplementary picture */
1745 buf_end = buf + buf_size;
1746 while (buf_ptr < buf_end) {
1747 /* find start next marker */
1748 start_code = find_marker(&buf_ptr, buf_end);
1751 if (start_code < 0) {
1754 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1756 if ((buf_end - buf_ptr) > s->buffer_size)
1759 s->buffer_size = buf_end-buf_ptr;
1760 s->buffer = av_malloc(s->buffer_size);
1761 dprintf("buffer too small, expanding to %d bytes\n",
1765 /* unescape buffer of SOS */
1766 if (start_code == SOS)
1768 uint8_t *src = buf_ptr;
1769 uint8_t *dst = s->buffer;
1773 uint8_t x = *(src++);
1778 while(*src == 0xff) src++;
1781 if (x >= 0xd0 && x <= 0xd7)
1787 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1789 dprintf("escaping removed %d bytes\n",
1790 (buf_end - buf_ptr) - (dst - s->buffer));
1793 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1795 s->start_code = start_code;
1796 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1797 printf("startcode: %X\n", start_code);
1800 /* process markers */
1801 if (start_code >= 0xd0 && start_code <= 0xd7) {
1802 dprintf("restart marker: %d\n", start_code&0x0f);
1803 } else if (s->first_picture) {
1805 if (start_code >= 0xe0 && start_code <= 0xef)
1806 mjpeg_decode_app(s);
1808 else if (start_code == COM)
1809 mjpeg_decode_com(s);
1812 switch(start_code) {
1814 s->restart_interval = 0;
1815 /* nothing to do on SOI */
1818 mjpeg_decode_dqt(s);
1821 if(mjpeg_decode_dht(s) < 0){
1822 fprintf(stderr, "huffman table decode error\n");
1828 if (mjpeg_decode_sof(s) < 0)
1833 if (mjpeg_decode_sof(s) < 0)
1837 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1841 if (s->interlaced) {
1842 s->bottom_field ^= 1;
1843 /* if not bottom field, do not output image yet */
1844 if (s->bottom_field)
1848 picture->data[i] = s->current_picture[i];
1849 picture->linesize[i] = (s->interlaced) ?
1850 s->linesize[i] >> 1 : s->linesize[i];
1852 *data_size = sizeof(AVFrame);
1853 avctx->height = s->height;
1856 avctx->width = s->width;
1857 /* XXX: not complete test ! */
1858 switch((s->h_count[0] << 4) | s->v_count[0]) {
1861 avctx->pix_fmt = PIX_FMT_RGBA32;
1863 avctx->pix_fmt = PIX_FMT_YUV444P;
1866 avctx->pix_fmt = PIX_FMT_YUV422P;
1870 avctx->pix_fmt = PIX_FMT_YUV420P;
1875 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1876 picture->qstride= 0;
1877 picture->qscale_table= s->qscale_table;
1878 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1879 if(avctx->debug & FF_DEBUG_QP)
1880 printf("QP: %d\n", (int)picture->quality);
1887 mjpeg_decode_sos(s);
1888 /* buggy avid puts EOI every 10-20th frame */
1889 /* if restart period is over process EOI */
1890 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1894 mjpeg_decode_dri(s);
1908 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1911 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1916 /* eof process start code */
1917 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1918 dprintf("marker parser used %d bytes (%d bits)\n",
1919 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1924 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1925 // return buf_end - buf_ptr;
1926 return buf_ptr - buf;
1929 static int mjpegb_decode_frame(AVCodecContext *avctx,
1930 void *data, int *data_size,
1931 uint8_t *buf, int buf_size)
1933 MJpegDecodeContext *s = avctx->priv_data;
1934 uint8_t *buf_end, *buf_ptr;
1936 AVFrame *picture = data;
1937 GetBitContext hgb; /* for the header */
1938 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1939 uint32_t field_size;
1943 /* no supplementary picture */
1948 buf_end = buf + buf_size;
1951 /* reset on every SOI */
1952 s->restart_interval = 0;
1954 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1956 skip_bits(&hgb, 32); /* reserved zeros */
1958 if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1960 dprintf("not mjpeg-b (bad fourcc)\n");
1964 field_size = get_bits(&hgb, 32); /* field size */
1965 dprintf("field size: 0x%x\n", field_size);
1966 skip_bits(&hgb, 32); /* padded field size */
1967 second_field_offs = get_bits(&hgb, 32);
1968 dprintf("second field offs: 0x%x\n", second_field_offs);
1969 if (second_field_offs)
1972 dqt_offs = get_bits(&hgb, 32);
1973 dprintf("dqt offs: 0x%x\n", dqt_offs);
1976 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1977 s->start_code = DQT;
1978 mjpeg_decode_dqt(s);
1981 dht_offs = get_bits(&hgb, 32);
1982 dprintf("dht offs: 0x%x\n", dht_offs);
1985 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1986 s->start_code = DHT;
1987 mjpeg_decode_dht(s);
1990 sof_offs = get_bits(&hgb, 32);
1991 dprintf("sof offs: 0x%x\n", sof_offs);
1994 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1995 s->start_code = SOF0;
1996 if (mjpeg_decode_sof(s) < 0)
2000 sos_offs = get_bits(&hgb, 32);
2001 dprintf("sos offs: 0x%x\n", sos_offs);
2004 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2005 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2006 s->start_code = SOS;
2007 mjpeg_decode_sos(s);
2010 skip_bits(&hgb, 32); /* start of data offset */
2012 if (s->interlaced) {
2013 s->bottom_field ^= 1;
2014 /* if not bottom field, do not output image yet */
2015 if (s->bottom_field && second_field_offs)
2017 buf_ptr = buf + second_field_offs;
2018 second_field_offs = 0;
2023 //XXX FIXME factorize, this looks very similar to the EOI code
2026 picture->data[i] = s->current_picture[i];
2027 picture->linesize[i] = (s->interlaced) ?
2028 s->linesize[i] >> 1 : s->linesize[i];
2030 *data_size = sizeof(AVFrame);
2031 avctx->height = s->height;
2034 avctx->width = s->width;
2035 /* XXX: not complete test ! */
2036 switch((s->h_count[0] << 4) | s->v_count[0]) {
2038 avctx->pix_fmt = PIX_FMT_YUV444P;
2041 avctx->pix_fmt = PIX_FMT_YUV422P;
2045 avctx->pix_fmt = PIX_FMT_YUV420P;
2050 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2051 picture->qstride= 0;
2052 picture->qscale_table= s->qscale_table;
2053 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2054 if(avctx->debug & FF_DEBUG_QP)
2055 printf("QP: %f\n", picture->quality);
2058 return buf_ptr - buf;
2062 static int mjpeg_decode_end(AVCodecContext *avctx)
2064 MJpegDecodeContext *s = avctx->priv_data;
2068 av_free(s->qscale_table);
2069 for(i=0;i<MAX_COMPONENTS;i++)
2070 av_free(s->current_picture[i]);
2073 free_vlc(&s->vlcs[i][j]);
2078 AVCodec mjpeg_decoder = {
2082 sizeof(MJpegDecodeContext),
2091 AVCodec mjpegb_decoder = {
2095 sizeof(MJpegDecodeContext),
2099 mjpegb_decode_frame,
2104 #ifdef CONFIG_ENCODERS
2105 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2109 sizeof(MpegEncContext),
2111 encode_picture_lossless,