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;
404 if( s->avctx->pix_fmt == PIX_FMT_YUV420P
405 ||s->avctx->pix_fmt == PIX_FMT_YUV422P
406 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
410 put_bits(p, 16, 0); /* patched later */
411 put_string(p, "CS=ITU601", 1);
412 size = strlen("CS=ITU601")+3;
418 void mjpeg_picture_header(MpegEncContext *s)
420 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
422 put_marker(&s->pb, SOI);
424 if (!s->mjpeg_data_only_frames)
426 jpeg_put_comments(s);
428 if (s->mjpeg_write_tables) jpeg_table_header(s);
430 put_marker(&s->pb, lossless ? SOF3 : SOF0);
432 put_bits(&s->pb, 16, 17);
433 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
434 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
436 put_bits(&s->pb, 8, 8); /* 8 bits/component */
437 put_bits(&s->pb, 16, s->height);
438 put_bits(&s->pb, 16, s->width);
439 put_bits(&s->pb, 8, 3); /* 3 components */
442 put_bits(&s->pb, 8, 1); /* component number */
443 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
444 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
445 put_bits(&s->pb, 8, 0); /* select matrix */
448 put_bits(&s->pb, 8, 2); /* component number */
449 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
450 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
452 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
454 put_bits(&s->pb, 8, 0); /* select matrix */
458 put_bits(&s->pb, 8, 3); /* component number */
459 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
460 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
462 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
464 put_bits(&s->pb, 8, 0); /* select matrix */
469 put_marker(&s->pb, SOS);
470 put_bits(&s->pb, 16, 12); /* length */
471 put_bits(&s->pb, 8, 3); /* 3 components */
474 put_bits(&s->pb, 8, 1); /* index */
475 put_bits(&s->pb, 4, 0); /* DC huffman table index */
476 put_bits(&s->pb, 4, 0); /* AC huffman table index */
479 put_bits(&s->pb, 8, 2); /* index */
480 put_bits(&s->pb, 4, 1); /* DC huffman table index */
481 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
484 put_bits(&s->pb, 8, 3); /* index */
485 put_bits(&s->pb, 4, 1); /* DC huffman table index */
486 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
488 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
489 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
490 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
493 static void escape_FF(MpegEncContext *s, int start)
495 int size= put_bits_count(&s->pb) - start*8;
497 uint8_t *buf= s->pb.buf + start;
498 int align= (-(size_t)(buf))&3;
500 assert((size&7) == 0);
504 for(i=0; i<size && i<align; i++){
505 if(buf[i]==0xFF) ff_count++;
507 for(; i<size-15; i+=16){
510 v= *(uint32_t*)(&buf[i]);
511 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
512 v= *(uint32_t*)(&buf[i+4]);
513 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
514 v= *(uint32_t*)(&buf[i+8]);
515 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
516 v= *(uint32_t*)(&buf[i+12]);
517 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
525 if(buf[i]==0xFF) ff_count++;
528 if(ff_count==0) return;
531 for(i=0; i<ff_count-3; i+=4)
532 put_bits(&s->pb, 32, 0);
533 put_bits(&s->pb, (ff_count-i)*8, 0);
534 flush_put_bits(&s->pb);
536 for(i=size-1; ff_count; i--){
540 //printf("%d %d\n", i, ff_count);
549 void ff_mjpeg_stuffing(PutBitContext * pbc)
552 length= (-put_bits_count(pbc))&7;
553 if(length) put_bits(pbc, length, (1<<length)-1);
556 void mjpeg_picture_trailer(MpegEncContext *s)
558 ff_mjpeg_stuffing(&s->pb);
559 flush_put_bits(&s->pb);
561 assert((s->header_bits&7)==0);
563 escape_FF(s, s->header_bits>>3);
565 put_marker(&s->pb, EOI);
568 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
569 uint8_t *huff_size, uint16_t *huff_code)
574 put_bits(&s->pb, huff_size[0], huff_code[0]);
582 nbits= av_log2_16bit(val) + 1;
584 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
586 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
590 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
592 int mant, nbits, code, i, j;
593 int component, dc, run, last_index, val;
594 MJpegContext *m = s->mjpeg_ctx;
595 uint8_t *huff_size_ac;
596 uint16_t *huff_code_ac;
599 component = (n <= 3 ? 0 : n - 4 + 1);
600 dc = block[0]; /* overflow is impossible */
601 val = dc - s->last_dc[component];
603 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
604 huff_size_ac = m->huff_size_ac_luminance;
605 huff_code_ac = m->huff_code_ac_luminance;
607 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
608 huff_size_ac = m->huff_size_ac_chrominance;
609 huff_code_ac = m->huff_code_ac_chrominance;
611 s->last_dc[component] = dc;
616 last_index = s->block_last_index[n];
617 for(i=1;i<=last_index;i++) {
618 j = s->intra_scantable.permutated[i];
624 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
633 nbits= av_log2(val) + 1;
634 code = (run << 4) | nbits;
636 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
638 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
643 /* output EOB only if not already 64 values */
644 if (last_index < 63 || run != 0)
645 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
648 void mjpeg_encode_mb(MpegEncContext *s,
649 DCTELEM block[6][64])
653 encode_block(s, block[i], i);
657 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
658 MpegEncContext * const s = avctx->priv_data;
659 MJpegContext * const m = s->mjpeg_ctx;
660 AVFrame *pict = data;
661 const int width= s->width;
662 const int height= s->height;
663 AVFrame * const p= (AVFrame*)&s->current_picture;
664 const int predictor= avctx->prediction_method+1;
666 init_put_bits(&s->pb, buf, buf_size);
669 p->pict_type= FF_I_TYPE;
672 mjpeg_picture_header(s);
674 s->header_bits= put_bits_count(&s->pb);
676 if(avctx->pix_fmt == PIX_FMT_RGBA32){
678 const int linesize= p->linesize[0];
679 uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
680 int left[3], top[3], topleft[3];
683 buffer[0][i]= 1 << (9 - 1);
686 for(y = 0; y < height; y++) {
687 const int modified_predictor= y ? predictor : 1;
688 uint8_t *ptr = p->data[0] + (linesize * y);
690 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
691 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
696 top[i]= left[i]= topleft[i]= buffer[0][i];
698 for(x = 0; x < width; x++) {
699 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
700 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
701 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
706 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
709 top[i]= buffer[x+1][i];
711 left[i]= buffer[x][i];
713 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
716 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
718 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
724 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
725 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
727 for(mb_y = 0; mb_y < mb_height; mb_y++) {
728 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){
729 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
732 for(mb_x = 0; mb_x < mb_width; mb_x++) {
733 if(mb_x==0 || mb_y==0){
736 int x, y, h, v, linesize;
737 h = s->mjpeg_hsample[i];
738 v = s->mjpeg_vsample[i];
739 linesize= p->linesize[i];
745 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
754 pred= ptr[-linesize];
756 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
761 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
763 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
770 int x, y, h, v, linesize;
771 h = s->mjpeg_hsample[i];
772 v = s->mjpeg_vsample[i];
773 linesize= p->linesize[i];
779 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
780 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
781 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
784 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
786 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
797 mjpeg_picture_trailer(s);
800 flush_put_bits(&s->pb);
801 return pbBufPtr(&s->pb) - s->pb.buf;
802 // return (put_bits_count(&f->pb)+7)/8;
805 #endif //CONFIG_ENCODERS
807 /******************************************/
810 #define MAX_COMPONENTS 4
812 typedef struct MJpegDecodeContext {
813 AVCodecContext *avctx;
815 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
817 int start_code; /* current start code */
821 int16_t quant_matrixes[4][64];
823 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
825 int org_height; /* size given at codec init */
826 int first_picture; /* true if decoding first picture */
827 int interlaced; /* true if interlaced */
828 int bottom_field; /* true if bottom field */
831 int rct; /* standard rct */
832 int pegasus_rct; /* pegasus reversible colorspace transform */
833 int bits; /* bits per component */
836 int mb_width, mb_height;
838 int component_id[MAX_COMPONENTS];
839 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
840 int v_count[MAX_COMPONENTS];
841 int comp_index[MAX_COMPONENTS];
842 int dc_index[MAX_COMPONENTS];
843 int ac_index[MAX_COMPONENTS];
844 int nb_blocks[MAX_COMPONENTS];
845 int h_scount[MAX_COMPONENTS];
846 int v_scount[MAX_COMPONENTS];
847 int h_max, v_max; /* maximum h and v counts */
848 int quant_index[4]; /* quant table index for each component */
849 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
850 AVFrame picture; /* picture structure */
851 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
852 int8_t *qscale_table;
853 DCTELEM block[64] __align8;
855 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
857 int restart_interval;
862 int interlace_polarity;
865 } MJpegDecodeContext;
867 static int mjpeg_decode_dht(MJpegDecodeContext *s);
869 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
870 int nb_codes, int use_static)
872 uint8_t huff_size[256];
873 uint16_t huff_code[256];
875 memset(huff_size, 0, sizeof(huff_size));
876 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
878 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
881 static int mjpeg_decode_init(AVCodecContext *avctx)
883 MJpegDecodeContext *s = avctx->priv_data;
888 /* ugly way to get the idct & scantable FIXME */
889 memset(&s2, 0, sizeof(MpegEncContext));
891 // s2->out_format = FMT_MJPEG;
892 dsputil_init(&s2.dsp, avctx);
893 DCT_common_init(&s2);
895 s->scantable= s2.intra_scantable;
896 s->idct_put= s2.dsp.idct_put;
898 s->mpeg_enc_ctx_allocated = 0;
899 s->buffer_size = 102400; /* smaller buffer should be enough,
900 but photojpg files could ahive bigger sizes */
901 s->buffer = av_malloc(s->buffer_size);
905 s->first_picture = 1;
906 s->org_height = avctx->coded_height;
908 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0);
909 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0);
910 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0);
911 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0);
913 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
915 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
916 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
918 /* should check for error - but dunno */
926 * finds the end of the current frame in the bitstream.
927 * @return the position of the first byte of the next frame, or -1
929 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
933 vop_found= pc->frame_start_found;
938 for(i=0; i<buf_size; i++){
939 state= (state<<8) | buf[i];
949 /* EOF considered as end of frame */
952 for(; i<buf_size; i++){
953 state= (state<<8) | buf[i];
955 pc->frame_start_found=0;
961 pc->frame_start_found= vop_found;
963 return END_NOT_FOUND;
966 static int jpeg_parse(AVCodecParserContext *s,
967 AVCodecContext *avctx,
968 uint8_t **poutbuf, int *poutbuf_size,
969 const uint8_t *buf, int buf_size)
971 ParseContext *pc = s->priv_data;
974 next= find_frame_end(pc, buf, buf_size);
976 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
982 *poutbuf = (uint8_t *)buf;
983 *poutbuf_size = buf_size;
987 /* quantize tables */
988 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
990 int len, index, i, j;
992 len = get_bits(&s->gb, 16) - 2;
995 /* only 8 bit precision handled */
996 if (get_bits(&s->gb, 4) != 0)
998 dprintf("dqt: 16bit precision\n");
1001 index = get_bits(&s->gb, 4);
1004 dprintf("index=%d\n", index);
1005 /* read quant table */
1007 j = s->scantable.permutated[i];
1008 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1011 //XXX FIXME finetune, and perhaps add dc too
1012 s->qscale[index]= FFMAX(
1013 s->quant_matrixes[index][s->scantable.permutated[1]],
1014 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1015 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
1022 /* decode huffman tables and build VLC decoders */
1023 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1025 int len, index, i, class, n, v, code_max;
1026 uint8_t bits_table[17];
1027 uint8_t val_table[256];
1029 len = get_bits(&s->gb, 16) - 2;
1034 class = get_bits(&s->gb, 4);
1037 index = get_bits(&s->gb, 4);
1041 for(i=1;i<=16;i++) {
1042 bits_table[i] = get_bits(&s->gb, 8);
1046 if (len < n || n > 256)
1051 v = get_bits(&s->gb, 8);
1058 /* build VLC and flush previous vlc if present */
1059 free_vlc(&s->vlcs[class][index]);
1060 dprintf("class=%d index=%d nb_codes=%d\n",
1061 class, index, code_max + 1);
1062 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){
1069 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1071 int len, nb_components, i, width, height;
1073 /* XXX: verify len field validity */
1074 len = get_bits(&s->gb, 16);
1075 s->bits= get_bits(&s->gb, 8);
1077 if(s->pegasus_rct) s->bits=9;
1078 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1080 if (s->bits != 8 && !s->lossless){
1081 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1084 height = get_bits(&s->gb, 16);
1085 width = get_bits(&s->gb, 16);
1087 dprintf("sof0: picture: %dx%d\n", width, height);
1088 if(avcodec_check_dimensions(s->avctx, width, height))
1091 nb_components = get_bits(&s->gb, 8);
1092 if (nb_components <= 0 ||
1093 nb_components > MAX_COMPONENTS)
1095 s->nb_components = nb_components;
1098 for(i=0;i<nb_components;i++) {
1100 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1101 s->h_count[i] = get_bits(&s->gb, 4);
1102 s->v_count[i] = get_bits(&s->gb, 4);
1103 /* compute hmax and vmax (only used in interleaved case) */
1104 if (s->h_count[i] > s->h_max)
1105 s->h_max = s->h_count[i];
1106 if (s->v_count[i] > s->v_max)
1107 s->v_max = s->v_count[i];
1108 s->quant_index[i] = get_bits(&s->gb, 8);
1109 if (s->quant_index[i] >= 4)
1111 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1112 s->v_count[i], s->component_id[i], s->quant_index[i]);
1115 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1117 /* if different size, realloc/alloc picture */
1118 /* XXX: also check h_count and v_count */
1119 if (width != s->width || height != s->height) {
1120 av_freep(&s->qscale_table);
1124 avcodec_set_dimensions(s->avctx, width, height);
1126 /* test interlaced mode */
1127 if (s->first_picture &&
1128 s->org_height != 0 &&
1129 s->height < ((s->org_height * 3) / 4)) {
1131 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1132 s->bottom_field = 0;
1133 s->avctx->height *= 2;
1136 s->qscale_table= av_mallocz((s->width+15)/16);
1138 s->first_picture = 0;
1141 if(s->interlaced && s->bottom_field)
1144 /* XXX: not complete test ! */
1145 switch((s->h_count[0] << 4) | s->v_count[0]) {
1148 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1149 }else if(s->nb_components==3)
1150 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1152 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1155 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1159 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1163 if(s->picture.data[0])
1164 s->avctx->release_buffer(s->avctx, &s->picture);
1166 s->picture.reference= 0;
1167 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1168 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1171 s->picture.pict_type= I_TYPE;
1172 s->picture.key_frame= 1;
1175 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1178 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1180 if (len != (8+(3*nb_components)))
1182 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1188 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1191 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1194 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1195 &s->vlcs[0][dc_index]);
1200 return get_xbits(&s->gb, code);
1205 /* decode block and dequantize */
1206 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1207 int component, int dc_index, int ac_index, int quant_index)
1209 int code, i, j, level, val;
1211 int16_t *quant_matrix;
1214 val = mjpeg_decode_dc(s, dc_index);
1215 if (val == 0xffff) {
1216 dprintf("error dc\n");
1219 quant_matrix = s->quant_matrixes[quant_index];
1220 val = val * quant_matrix[0] + s->last_dc[component];
1221 s->last_dc[component] = val;
1224 ac_vlc = &s->vlcs[1][ac_index];
1227 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1230 dprintf("error ac\n");
1239 level = get_xbits(&s->gb, code & 0xf);
1242 dprintf("error count: %d\n", i);
1245 j = s->scantable.permutated[i];
1246 block[j] = level * quant_matrix[j];
1255 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1257 uint16_t buffer[32768][4];
1258 int left[3], top[3], topleft[3];
1259 const int linesize= s->linesize[0];
1260 const int mask= (1<<s->bits)-1;
1262 if((unsigned)s->mb_width > 32768) //dynamic alloc
1266 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1268 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1269 const int modified_predictor= mb_y ? predictor : 1;
1270 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1272 if (s->interlaced && s->bottom_field)
1273 ptr += linesize >> 1;
1276 top[i]= left[i]= topleft[i]= buffer[0][i];
1278 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1279 if (s->restart_interval && !s->restart_count)
1280 s->restart_count = s->restart_interval;
1286 top[i]= buffer[mb_x][i];
1288 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1291 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1294 if (s->restart_interval && !--s->restart_count) {
1295 align_get_bits(&s->gb);
1296 skip_bits(&s->gb, 16); /* skip RSTn */
1301 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1302 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1303 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1304 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1306 }else if(s->pegasus_rct){
1307 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1308 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1309 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1310 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1313 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1314 ptr[4*mb_x+0] = buffer[mb_x][0];
1315 ptr[4*mb_x+1] = buffer[mb_x][1];
1316 ptr[4*mb_x+2] = buffer[mb_x][2];
1323 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1325 const int nb_components=3;
1327 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1328 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1329 if (s->restart_interval && !s->restart_count)
1330 s->restart_count = s->restart_interval;
1332 if(mb_x==0 || mb_y==0 || s->interlaced){
1333 for(i=0;i<nb_components;i++) {
1335 int n, h, v, x, y, c, j, linesize;
1336 n = s->nb_blocks[i];
1337 c = s->comp_index[i];
1342 linesize= s->linesize[c];
1344 for(j=0; j<n; j++) {
1347 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1348 if(y==0 && mb_y==0){
1349 if(x==0 && mb_x==0){
1350 pred= 128 << point_transform;
1355 if(x==0 && mb_x==0){
1356 pred= ptr[-linesize];
1358 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1362 if (s->interlaced && s->bottom_field)
1363 ptr += linesize >> 1;
1364 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1373 for(i=0;i<nb_components;i++) {
1375 int n, h, v, x, y, c, j, linesize;
1376 n = s->nb_blocks[i];
1377 c = s->comp_index[i];
1382 linesize= s->linesize[c];
1384 for(j=0; j<n; j++) {
1387 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1388 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1389 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1397 if (s->restart_interval && !--s->restart_count) {
1398 align_get_bits(&s->gb);
1399 skip_bits(&s->gb, 16); /* skip RSTn */
1406 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1408 const int nb_components=3;
1410 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1411 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1412 if (s->restart_interval && !s->restart_count)
1413 s->restart_count = s->restart_interval;
1415 for(i=0;i<nb_components;i++) {
1417 int n, h, v, x, y, c, j;
1418 n = s->nb_blocks[i];
1419 c = s->comp_index[i];
1425 memset(s->block, 0, sizeof(s->block));
1426 if (decode_block(s, s->block, i,
1427 s->dc_index[i], s->ac_index[i],
1428 s->quant_index[c]) < 0) {
1429 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1432 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1433 ptr = s->picture.data[c] +
1434 (((s->linesize[c] * (v * mb_y + y) * 8) +
1435 (h * mb_x + x) * 8) >> s->avctx->lowres);
1436 if (s->interlaced && s->bottom_field)
1437 ptr += s->linesize[c] >> 1;
1438 //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);
1439 s->idct_put(ptr, s->linesize[c], s->block);
1446 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1447 if (s->restart_interval && (s->restart_interval < 1350) &&
1448 !--s->restart_count) {
1449 align_get_bits(&s->gb);
1450 skip_bits(&s->gb, 16); /* skip RSTn */
1451 for (i=0; i<nb_components; i++) /* reset dc */
1452 s->last_dc[i] = 1024;
1459 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1461 int len, nb_components, i, h, v, predictor, point_transform;
1462 int vmax, hmax, index, id;
1463 const int block_size= s->lossless ? 1 : 8;
1465 /* XXX: verify len field validity */
1466 len = get_bits(&s->gb, 16);
1467 nb_components = get_bits(&s->gb, 8);
1468 if (len != 6+2*nb_components)
1470 dprintf("decode_sos: invalid len (%d)\n", len);
1473 /* XXX: only interleaved scan accepted */
1474 if (nb_components != s->nb_components)
1476 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1481 for(i=0;i<nb_components;i++) {
1482 id = get_bits(&s->gb, 8) - 1;
1483 dprintf("component: %d\n", id);
1484 /* find component index */
1485 for(index=0;index<s->nb_components;index++)
1486 if (id == s->component_id[index])
1488 if (index == s->nb_components)
1490 dprintf("decode_sos: index(%d) out of components\n", index);
1494 s->comp_index[i] = index;
1496 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1497 s->h_scount[i] = s->h_count[index];
1498 s->v_scount[i] = s->v_count[index];
1500 s->dc_index[i] = get_bits(&s->gb, 4);
1501 s->ac_index[i] = get_bits(&s->gb, 4);
1503 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1504 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1507 switch(s->start_code)
1510 if (dc_index[i] > 1 || ac_index[i] > 1)
1515 if (dc_index[i] > 3 || ac_index[i] > 3)
1519 if (dc_index[i] > 3 || ac_index[i] != 0)
1526 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1527 skip_bits(&s->gb, 8); /* Se */
1528 skip_bits(&s->gb, 4); /* Ah */
1529 point_transform= get_bits(&s->gb, 4); /* Al */
1531 for(i=0;i<nb_components;i++)
1532 s->last_dc[i] = 1024;
1534 if (nb_components > 1) {
1535 /* interleaved stream */
1536 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1537 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1539 h = s->h_max / s->h_scount[s->comp_index[0]];
1540 v = s->v_max / s->v_scount[s->comp_index[0]];
1541 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1542 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1543 s->nb_blocks[0] = 1;
1548 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1549 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1551 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1552 for (i = s->mjpb_skiptosod; i > 0; i--)
1553 skip_bits(&s->gb, 8);
1557 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1560 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1564 if(mjpeg_decode_scan(s) < 0)
1570 dprintf("decode_sos: ac/dc index out of range\n");
1574 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1576 if (get_bits(&s->gb, 16) != 4)
1578 s->restart_interval = get_bits(&s->gb, 16);
1579 dprintf("restart interval: %d\n", s->restart_interval);
1584 static int mjpeg_decode_app(MJpegDecodeContext *s)
1588 /* XXX: verify len field validity */
1589 len = get_bits(&s->gb, 16);
1593 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1597 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1598 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1601 /* buggy AVID, it puts EOI only at every 10th frame */
1602 /* also this fourcc is used by non-avid files too, it holds some
1603 informations, but it's always present in AVID creates files */
1604 if (id == ff_get_fourcc("AVI1"))
1611 4bytes field_size_less_padding
1614 // if (s->first_picture)
1615 // printf("mjpeg: workarounding buggy AVID\n");
1616 s->interlace_polarity = get_bits(&s->gb, 8);
1618 skip_bits(&s->gb, 8);
1619 skip_bits(&s->gb, 32);
1620 skip_bits(&s->gb, 32);
1623 // if (s->interlace_polarity)
1624 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1630 if (id == ff_get_fourcc("JFIF"))
1632 int t_w, t_h, v1, v2;
1633 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1634 v1= get_bits(&s->gb, 8);
1635 v2= get_bits(&s->gb, 8);
1636 skip_bits(&s->gb, 8);
1638 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1639 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1641 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1642 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1644 s->avctx->sample_aspect_ratio.num,
1645 s->avctx->sample_aspect_ratio.den
1648 t_w = get_bits(&s->gb, 8);
1649 t_h = get_bits(&s->gb, 8);
1652 /* skip thumbnail */
1653 if (len-10-(t_w*t_h*3) > 0)
1660 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1662 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1663 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1664 skip_bits(&s->gb, 16); /* version */
1665 skip_bits(&s->gb, 16); /* flags0 */
1666 skip_bits(&s->gb, 16); /* flags1 */
1667 skip_bits(&s->gb, 8); /* transform */
1672 if (id == ff_get_fourcc("LJIF")){
1673 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1674 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1675 skip_bits(&s->gb, 16); /* version ? */
1676 skip_bits(&s->gb, 16); /* unknwon always 0? */
1677 skip_bits(&s->gb, 16); /* unknwon always 0? */
1678 skip_bits(&s->gb, 16); /* unknwon always 0? */
1679 switch( get_bits(&s->gb, 8)){
1689 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1696 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1698 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1701 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1704 skip_bits(&s->gb, 32); /* field size */
1705 skip_bits(&s->gb, 32); /* pad field size */
1706 skip_bits(&s->gb, 32); /* next off */
1707 skip_bits(&s->gb, 32); /* quant off */
1708 skip_bits(&s->gb, 32); /* huff off */
1709 skip_bits(&s->gb, 32); /* image off */
1710 skip_bits(&s->gb, 32); /* scan off */
1711 skip_bits(&s->gb, 32); /* data off */
1713 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1714 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1719 /* slow but needed for extreme adobe jpegs */
1721 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1723 skip_bits(&s->gb, 8);
1728 static int mjpeg_decode_com(MJpegDecodeContext *s)
1730 /* XXX: verify len field validity */
1731 int len = get_bits(&s->gb, 16);
1732 if (len >= 2 && len < 32768) {
1733 /* XXX: any better upper bound */
1734 uint8_t *cbuf = av_malloc(len - 1);
1737 for (i = 0; i < len - 2; i++)
1738 cbuf[i] = get_bits(&s->gb, 8);
1739 if (i > 0 && cbuf[i-1] == '\n')
1744 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1745 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1747 /* buggy avid, it puts EOI only at every 10th frame */
1748 if (!strcmp(cbuf, "AVID"))
1751 // if (s->first_picture)
1752 // printf("mjpeg: workarounding buggy AVID\n");
1754 else if(!strcmp(cbuf, "CS=ITU601")){
1766 static int valid_marker_list[] =
1768 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1769 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1770 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1771 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1772 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1773 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1774 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1775 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1776 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1777 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1778 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1779 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1780 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1781 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1782 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1783 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1784 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1788 /* return the 8 bit start code value and update the search
1789 state. Return -1 if no start code found */
1790 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1799 buf_ptr = *pbuf_ptr;
1800 while (buf_ptr < buf_end) {
1803 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1814 dprintf("find_marker skipped %d bytes\n", skipped);
1816 *pbuf_ptr = buf_ptr;
1820 static int mjpeg_decode_frame(AVCodecContext *avctx,
1821 void *data, int *data_size,
1822 uint8_t *buf, int buf_size)
1824 MJpegDecodeContext *s = avctx->priv_data;
1825 uint8_t *buf_end, *buf_ptr;
1827 AVFrame *picture = data;
1830 buf_end = buf + buf_size;
1831 while (buf_ptr < buf_end) {
1832 /* find start next marker */
1833 start_code = find_marker(&buf_ptr, buf_end);
1836 if (start_code < 0) {
1839 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1841 if ((buf_end - buf_ptr) > s->buffer_size)
1844 s->buffer_size = buf_end-buf_ptr;
1845 s->buffer = av_malloc(s->buffer_size);
1846 dprintf("buffer too small, expanding to %d bytes\n",
1850 /* unescape buffer of SOS */
1851 if (start_code == SOS)
1853 uint8_t *src = buf_ptr;
1854 uint8_t *dst = s->buffer;
1858 uint8_t x = *(src++);
1863 while(src<buf_end && x == 0xff)
1866 if (x >= 0xd0 && x <= 0xd7)
1872 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1874 dprintf("escaping removed %d bytes\n",
1875 (buf_end - buf_ptr) - (dst - s->buffer));
1878 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1880 s->start_code = start_code;
1881 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1882 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1885 /* process markers */
1886 if (start_code >= 0xd0 && start_code <= 0xd7) {
1887 dprintf("restart marker: %d\n", start_code&0x0f);
1889 } else if (start_code >= APP0 && start_code <= APP15) {
1890 mjpeg_decode_app(s);
1892 } else if (start_code == COM){
1893 mjpeg_decode_com(s);
1896 switch(start_code) {
1898 s->restart_interval = 0;
1899 /* nothing to do on SOI */
1902 mjpeg_decode_dqt(s);
1905 if(mjpeg_decode_dht(s) < 0){
1906 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
1912 if (mjpeg_decode_sof(s) < 0)
1917 if (mjpeg_decode_sof(s) < 0)
1921 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1925 if (s->interlaced) {
1926 s->bottom_field ^= 1;
1927 /* if not bottom field, do not output image yet */
1928 if (s->bottom_field)
1931 *picture = s->picture;
1932 *data_size = sizeof(AVFrame);
1935 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1936 picture->qstride= 0;
1937 picture->qscale_table= s->qscale_table;
1938 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1939 if(avctx->debug & FF_DEBUG_QP)
1940 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
1941 picture->quality*= FF_QP2LAMBDA;
1948 mjpeg_decode_sos(s);
1949 /* buggy avid puts EOI every 10-20th frame */
1950 /* if restart period is over process EOI */
1951 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1955 mjpeg_decode_dri(s);
1969 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
1972 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1977 /* eof process start code */
1978 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1979 dprintf("marker parser used %d bytes (%d bits)\n",
1980 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1985 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1986 // return buf_end - buf_ptr;
1987 return buf_ptr - buf;
1990 static int mjpegb_decode_frame(AVCodecContext *avctx,
1991 void *data, int *data_size,
1992 uint8_t *buf, int buf_size)
1994 MJpegDecodeContext *s = avctx->priv_data;
1995 uint8_t *buf_end, *buf_ptr;
1996 AVFrame *picture = data;
1997 GetBitContext hgb; /* for the header */
1998 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1999 uint32_t field_size, sod_offs;
2002 buf_end = buf + buf_size;
2005 /* reset on every SOI */
2006 s->restart_interval = 0;
2007 s->mjpb_skiptosod = 0;
2009 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2011 skip_bits(&hgb, 32); /* reserved zeros */
2013 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2015 dprintf("not mjpeg-b (bad fourcc)\n");
2019 field_size = get_bits_long(&hgb, 32); /* field size */
2020 dprintf("field size: 0x%x\n", field_size);
2021 skip_bits(&hgb, 32); /* padded field size */
2022 second_field_offs = get_bits_long(&hgb, 32);
2023 dprintf("second field offs: 0x%x\n", second_field_offs);
2024 if (second_field_offs)
2027 dqt_offs = get_bits_long(&hgb, 32);
2028 dprintf("dqt offs: 0x%x\n", dqt_offs);
2031 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2032 s->start_code = DQT;
2033 mjpeg_decode_dqt(s);
2036 dht_offs = get_bits_long(&hgb, 32);
2037 dprintf("dht offs: 0x%x\n", dht_offs);
2040 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2041 s->start_code = DHT;
2042 mjpeg_decode_dht(s);
2045 sof_offs = get_bits_long(&hgb, 32);
2046 dprintf("sof offs: 0x%x\n", sof_offs);
2049 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2050 s->start_code = SOF0;
2051 if (mjpeg_decode_sof(s) < 0)
2055 sos_offs = get_bits_long(&hgb, 32);
2056 dprintf("sos offs: 0x%x\n", sos_offs);
2057 sod_offs = get_bits_long(&hgb, 32);
2058 dprintf("sod offs: 0x%x\n", sod_offs);
2061 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2062 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2063 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2064 s->start_code = SOS;
2065 mjpeg_decode_sos(s);
2068 if (s->interlaced) {
2069 s->bottom_field ^= 1;
2070 /* if not bottom field, do not output image yet */
2071 if (s->bottom_field && second_field_offs)
2073 buf_ptr = buf + second_field_offs;
2074 second_field_offs = 0;
2079 //XXX FIXME factorize, this looks very similar to the EOI code
2081 *picture= s->picture;
2082 *data_size = sizeof(AVFrame);
2085 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2086 picture->qstride= 0;
2087 picture->qscale_table= s->qscale_table;
2088 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2089 if(avctx->debug & FF_DEBUG_QP)
2090 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2091 picture->quality*= FF_QP2LAMBDA;
2094 return buf_ptr - buf;
2099 static int sp5x_decode_frame(AVCodecContext *avctx,
2100 void *data, int *data_size,
2101 uint8_t *buf, int buf_size)
2104 MJpegDecodeContext *s = avctx->priv_data;
2106 const int qscale = 5;
2107 uint8_t *buf_ptr, *buf_end, *recoded;
2110 if (!avctx->width || !avctx->height)
2114 buf_end = buf + buf_size;
2117 recoded = av_mallocz(buf_size + 1024);
2122 recoded[j++] = 0xFF;
2123 recoded[j++] = 0xD8;
2125 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2126 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2127 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2128 j += sizeof(sp5x_data_dqt);
2130 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2131 j += sizeof(sp5x_data_dht);
2133 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2134 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2135 recoded[j+6] = avctx->coded_height & 0xFF;
2136 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2137 recoded[j+8] = avctx->coded_width & 0xFF;
2138 j += sizeof(sp5x_data_sof);
2140 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2141 j += sizeof(sp5x_data_sos);
2143 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2145 recoded[j++] = buf[i];
2151 recoded[j++] = 0xFF;
2152 recoded[j++] = 0xD9;
2154 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2161 s->width = avctx->coded_width;
2162 s->height = avctx->coded_height;
2163 s->nb_components = 3;
2164 s->component_id[0] = 0;
2167 s->quant_index[0] = 0;
2168 s->component_id[1] = 1;
2171 s->quant_index[1] = 1;
2172 s->component_id[2] = 2;
2175 s->quant_index[2] = 1;
2179 s->qscale_table = av_mallocz((s->width+15)/16);
2180 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2183 s->picture.reference = 0;
2184 if (avctx->get_buffer(avctx, &s->picture) < 0)
2186 fprintf(stderr, "get_buffer() failed\n");
2190 s->picture.pict_type = I_TYPE;
2191 s->picture.key_frame = 1;
2193 for (i = 0; i < 3; i++)
2194 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2197 for (i = 0; i < 64; i++)
2199 j = s->scantable.permutated[i];
2200 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2202 s->qscale[0] = FFMAX(
2203 s->quant_matrixes[0][s->scantable.permutated[1]],
2204 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2206 for (i = 0; i < 64; i++)
2208 j = s->scantable.permutated[i];
2209 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2211 s->qscale[1] = FFMAX(
2212 s->quant_matrixes[1][s->scantable.permutated[1]],
2213 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2218 s->comp_index[0] = 0;
2219 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2220 s->h_scount[0] = s->h_count[0];
2221 s->v_scount[0] = s->v_count[0];
2225 s->comp_index[1] = 1;
2226 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2227 s->h_scount[1] = s->h_count[1];
2228 s->v_scount[1] = s->v_count[1];
2232 s->comp_index[2] = 2;
2233 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2234 s->h_scount[2] = s->h_count[2];
2235 s->v_scount[2] = s->v_count[2];
2239 for (i = 0; i < 3; i++)
2240 s->last_dc[i] = 1024;
2242 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2243 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2245 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2247 return mjpeg_decode_scan(s);
2253 static int mjpeg_decode_end(AVCodecContext *avctx)
2255 MJpegDecodeContext *s = avctx->priv_data;
2259 av_free(s->qscale_table);
2263 free_vlc(&s->vlcs[i][j]);
2268 AVCodec mjpeg_decoder = {
2272 sizeof(MJpegDecodeContext),
2281 AVCodec mjpegb_decoder = {
2285 sizeof(MJpegDecodeContext),
2289 mjpegb_decode_frame,
2294 AVCodec sp5x_decoder = {
2298 sizeof(MJpegDecodeContext),
2307 #ifdef CONFIG_ENCODERS
2308 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2312 sizeof(MpegEncContext),
2314 encode_picture_lossless,
2319 AVCodecParser mjpeg_parser = {
2321 sizeof(ParseContext),