2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * Support for external huffman table, various fixes (AVID workaround),
24 * aspecting, new decode_frame mechanism and apple mjpeg-b support
25 * by Alex Beregszaszi <alex@naxine.org>
30 * MJPEG encoder and decoder.
38 #include "mpegvideo.h"
39 #include "bytestream.h"
41 /* use two quantizer tables (one for luminance and one for chrominance) */
45 typedef struct MJpegContext {
46 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
47 uint16_t huff_code_dc_luminance[12];
48 uint8_t huff_size_dc_chrominance[12];
49 uint16_t huff_code_dc_chrominance[12];
51 uint8_t huff_size_ac_luminance[256];
52 uint16_t huff_code_ac_luminance[256];
53 uint8_t huff_size_ac_chrominance[256];
54 uint16_t huff_code_ac_chrominance[256];
57 /* JPEG marker codes */
60 SOF0 = 0xc0, /* baseline */
61 SOF1 = 0xc1, /* extended sequential, huffman */
62 SOF2 = 0xc2, /* progressive, huffman */
63 SOF3 = 0xc3, /* lossless, huffman */
65 SOF5 = 0xc5, /* differential sequential, huffman */
66 SOF6 = 0xc6, /* differential progressive, huffman */
67 SOF7 = 0xc7, /* differential lossless, huffman */
68 JPG = 0xc8, /* reserved for JPEG extension */
69 SOF9 = 0xc9, /* extended sequential, arithmetic */
70 SOF10 = 0xca, /* progressive, arithmetic */
71 SOF11 = 0xcb, /* lossless, arithmetic */
73 SOF13 = 0xcd, /* differential sequential, arithmetic */
74 SOF14 = 0xce, /* differential progressive, arithmetic */
75 SOF15 = 0xcf, /* differential lossless, arithmetic */
77 DHT = 0xc4, /* define huffman tables */
79 DAC = 0xcc, /* define arithmetic-coding conditioning */
81 /* restart with modulo 8 count "m" */
91 SOI = 0xd8, /* start of image */
92 EOI = 0xd9, /* end of image */
93 SOS = 0xda, /* start of scan */
94 DQT = 0xdb, /* define quantization tables */
95 DNL = 0xdc, /* define number of lines */
96 DRI = 0xdd, /* define restart interval */
97 DHP = 0xde, /* define hierarchical progression */
98 EXP = 0xdf, /* expand reference components */
124 SOF48 = 0xf7, ///< JPEG-LS
125 LSE = 0xf8, ///< JPEG-LS extension parameters
132 COM = 0xfe, /* comment */
134 TEM = 0x01, /* temporary private use for arithmetic coding */
136 /* 0x02 -> 0xbf reserved */
140 /* These are the sample quantization tables given in JPEG spec section K.1.
141 * The spec says that the values given produce "good" quality, and
142 * when divided by 2, "very good" quality.
144 static const unsigned char std_luminance_quant_tbl[64] = {
145 16, 11, 10, 16, 24, 40, 51, 61,
146 12, 12, 14, 19, 26, 58, 60, 55,
147 14, 13, 16, 24, 40, 57, 69, 56,
148 14, 17, 22, 29, 51, 87, 80, 62,
149 18, 22, 37, 56, 68, 109, 103, 77,
150 24, 35, 55, 64, 81, 104, 113, 92,
151 49, 64, 78, 87, 103, 121, 120, 101,
152 72, 92, 95, 98, 112, 100, 103, 99
154 static const unsigned char std_chrominance_quant_tbl[64] = {
155 17, 18, 24, 47, 99, 99, 99, 99,
156 18, 21, 26, 66, 99, 99, 99, 99,
157 24, 26, 56, 99, 99, 99, 99, 99,
158 47, 66, 99, 99, 99, 99, 99, 99,
159 99, 99, 99, 99, 99, 99, 99, 99,
160 99, 99, 99, 99, 99, 99, 99, 99,
161 99, 99, 99, 99, 99, 99, 99, 99,
162 99, 99, 99, 99, 99, 99, 99, 99
166 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
167 /* IMPORTANT: these are only valid for 8-bit data precision! */
168 static const uint8_t bits_dc_luminance[17] =
169 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
170 static const uint8_t val_dc_luminance[] =
171 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
173 static const uint8_t bits_dc_chrominance[17] =
174 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
175 static const uint8_t val_dc_chrominance[] =
176 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
178 static const uint8_t bits_ac_luminance[17] =
179 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
180 static const uint8_t val_ac_luminance[] =
181 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
182 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
183 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
184 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
185 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
186 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
187 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
188 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
189 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
190 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
191 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
192 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
193 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
194 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
195 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
196 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
197 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
198 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
199 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
200 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
204 static const uint8_t bits_ac_chrominance[17] =
205 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
207 static const uint8_t val_ac_chrominance[] =
208 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
209 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
210 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
211 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
212 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
213 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
214 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
215 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
216 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
217 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
218 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
219 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
220 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
221 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
222 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
223 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
224 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
225 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
226 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
227 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
231 /* isn't this function nicer than the one in the libjpeg ? */
232 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
233 const uint8_t *bits_table, const uint8_t *val_table)
235 int i, j, k,nb, code, sym;
242 sym = val_table[k++];
244 huff_code[sym] = code;
251 #ifdef CONFIG_ENCODERS
252 int mjpeg_init(MpegEncContext *s)
256 m = av_malloc(sizeof(MJpegContext));
263 /* build all the huffman tables */
264 build_huffman_codes(m->huff_size_dc_luminance,
265 m->huff_code_dc_luminance,
268 build_huffman_codes(m->huff_size_dc_chrominance,
269 m->huff_code_dc_chrominance,
272 build_huffman_codes(m->huff_size_ac_luminance,
273 m->huff_code_ac_luminance,
276 build_huffman_codes(m->huff_size_ac_chrominance,
277 m->huff_code_ac_chrominance,
285 void mjpeg_close(MpegEncContext *s)
287 av_free(s->mjpeg_ctx);
289 #endif //CONFIG_ENCODERS
291 #define PREDICT(ret, topleft, top, left, predictor)\
293 case 1: ret= left; break;\
294 case 2: ret= top; break;\
295 case 3: ret= topleft; break;\
296 case 4: ret= left + top - topleft; break;\
297 case 5: ret= left + ((top - topleft)>>1); break;\
298 case 6: ret= top + ((left - topleft)>>1); break;\
300 case 7: ret= (left + top)>>1; break;\
303 #ifdef CONFIG_ENCODERS
304 static inline void put_marker(PutBitContext *p, int code)
306 put_bits(p, 8, 0xff);
307 put_bits(p, 8, code);
310 /* table_class: 0 = DC coef, 1 = AC coefs */
311 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
312 const uint8_t *bits_table, const uint8_t *value_table)
314 PutBitContext *p = &s->pb;
317 put_bits(p, 4, table_class);
318 put_bits(p, 4, table_id);
323 put_bits(p, 8, bits_table[i]);
327 put_bits(p, 8, value_table[i]);
332 static void jpeg_table_header(MpegEncContext *s)
334 PutBitContext *p = &s->pb;
341 put_bits(p, 16, 2 + 2 * (1 + 64));
343 put_bits(p, 16, 2 + 1 * (1 + 64));
345 put_bits(p, 4, 0); /* 8 bit precision */
346 put_bits(p, 4, 0); /* table 0 */
348 j = s->intra_scantable.permutated[i];
349 put_bits(p, 8, s->intra_matrix[j]);
352 put_bits(p, 4, 0); /* 8 bit precision */
353 put_bits(p, 4, 1); /* table 1 */
355 j = s->intra_scantable.permutated[i];
356 put_bits(p, 8, s->chroma_intra_matrix[j]);
364 put_bits(p, 16, 0); /* patched later */
366 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
367 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
369 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
370 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
375 static void jpeg_put_comments(MpegEncContext *s)
377 PutBitContext *p = &s->pb;
381 if (s->aspect_ratio_info /* && !lossless */)
386 ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
387 put_bits(p, 16, 0x0201); /* v 1.02 */
388 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
389 put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
390 put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
391 put_bits(p, 8, 0); /* thumbnail width */
392 put_bits(p, 8, 0); /* thumbnail height */
396 if(!(s->flags & CODEC_FLAG_BITEXACT)){
400 put_bits(p, 16, 0); /* patched later */
401 ff_put_string(p, LIBAVCODEC_IDENT, 1);
402 size = strlen(LIBAVCODEC_IDENT)+3;
407 if( s->avctx->pix_fmt == PIX_FMT_YUV420P
408 ||s->avctx->pix_fmt == PIX_FMT_YUV422P
409 ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
413 put_bits(p, 16, 0); /* patched later */
414 ff_put_string(p, "CS=ITU601", 1);
415 size = strlen("CS=ITU601")+3;
421 void mjpeg_picture_header(MpegEncContext *s)
423 const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
424 const int ls = s->avctx->codec_id == CODEC_ID_JPEGLS;
426 assert(!(ls && s->mjpeg_write_tables));
428 put_marker(&s->pb, SOI);
430 if (!s->mjpeg_data_only_frames)
432 jpeg_put_comments(s);
434 if (s->mjpeg_write_tables) jpeg_table_header(s);
436 switch(s->avctx->codec_id){
437 case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
438 case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
439 case CODEC_ID_JPEGLS: put_marker(&s->pb, SOF48); break;
443 put_bits(&s->pb, 16, 17);
444 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
445 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
447 put_bits(&s->pb, 8, 8); /* 8 bits/component */
448 put_bits(&s->pb, 16, s->height);
449 put_bits(&s->pb, 16, s->width);
450 put_bits(&s->pb, 8, 3); /* 3 components */
453 put_bits(&s->pb, 8, 1); /* component number */
454 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
455 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
456 put_bits(&s->pb, 8, 0); /* select matrix */
459 put_bits(&s->pb, 8, 2); /* component number */
460 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
461 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
463 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
465 put_bits(&s->pb, 8, 0); /* select matrix */
469 put_bits(&s->pb, 8, 3); /* component number */
470 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
471 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
473 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
475 put_bits(&s->pb, 8, 0); /* select matrix */
480 put_marker(&s->pb, SOS);
481 put_bits(&s->pb, 16, 12); /* length */
482 put_bits(&s->pb, 8, 3); /* 3 components */
485 put_bits(&s->pb, 8, 1); /* index */
486 put_bits(&s->pb, 4, 0); /* DC huffman table index */
487 put_bits(&s->pb, 4, 0); /* AC huffman table index */
490 put_bits(&s->pb, 8, 2); /* index */
491 put_bits(&s->pb, 4, 1); /* DC huffman table index */
492 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
495 put_bits(&s->pb, 8, 3); /* index */
496 put_bits(&s->pb, 4, 1); /* DC huffman table index */
497 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
499 put_bits(&s->pb, 8, (lossless && !ls) ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
501 switch(s->avctx->codec_id){
502 case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
503 case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
504 case CODEC_ID_JPEGLS: put_bits(&s->pb, 8, 1); break; /* ILV = line interleaved */
508 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
510 //FIXME DC/AC entropy table selectors stuff in jpegls
513 static void escape_FF(MpegEncContext *s, int start)
515 int size= put_bits_count(&s->pb) - start*8;
517 uint8_t *buf= s->pb.buf + start;
518 int align= (-(size_t)(buf))&3;
520 assert((size&7) == 0);
524 for(i=0; i<size && i<align; i++){
525 if(buf[i]==0xFF) ff_count++;
527 for(; i<size-15; i+=16){
530 v= *(uint32_t*)(&buf[i]);
531 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
532 v= *(uint32_t*)(&buf[i+4]);
533 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
534 v= *(uint32_t*)(&buf[i+8]);
535 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
536 v= *(uint32_t*)(&buf[i+12]);
537 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
545 if(buf[i]==0xFF) ff_count++;
548 if(ff_count==0) return;
551 for(i=0; i<ff_count-3; i+=4)
552 put_bits(&s->pb, 32, 0);
553 put_bits(&s->pb, (ff_count-i)*8, 0);
554 flush_put_bits(&s->pb);
556 for(i=size-1; ff_count; i--){
560 //printf("%d %d\n", i, ff_count);
569 void ff_mjpeg_stuffing(PutBitContext * pbc)
572 length= (-put_bits_count(pbc))&7;
573 if(length) put_bits(pbc, length, (1<<length)-1);
576 void mjpeg_picture_trailer(MpegEncContext *s)
578 ff_mjpeg_stuffing(&s->pb);
579 flush_put_bits(&s->pb);
581 assert((s->header_bits&7)==0);
583 escape_FF(s, s->header_bits>>3);
585 put_marker(&s->pb, EOI);
588 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
589 uint8_t *huff_size, uint16_t *huff_code)
594 put_bits(&s->pb, huff_size[0], huff_code[0]);
602 nbits= av_log2_16bit(val) + 1;
604 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
606 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
610 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
612 int mant, nbits, code, i, j;
613 int component, dc, run, last_index, val;
614 MJpegContext *m = s->mjpeg_ctx;
615 uint8_t *huff_size_ac;
616 uint16_t *huff_code_ac;
619 component = (n <= 3 ? 0 : (n&1) + 1);
620 dc = block[0]; /* overflow is impossible */
621 val = dc - s->last_dc[component];
623 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
624 huff_size_ac = m->huff_size_ac_luminance;
625 huff_code_ac = m->huff_code_ac_luminance;
627 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
628 huff_size_ac = m->huff_size_ac_chrominance;
629 huff_code_ac = m->huff_code_ac_chrominance;
631 s->last_dc[component] = dc;
636 last_index = s->block_last_index[n];
637 for(i=1;i<=last_index;i++) {
638 j = s->intra_scantable.permutated[i];
644 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
653 nbits= av_log2(val) + 1;
654 code = (run << 4) | nbits;
656 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
658 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
663 /* output EOB only if not already 64 values */
664 if (last_index < 63 || run != 0)
665 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
668 void mjpeg_encode_mb(MpegEncContext *s,
669 DCTELEM block[6][64])
673 encode_block(s, block[i], i);
675 if (s->chroma_format == CHROMA_420) {
676 encode_block(s, block[5], 5);
678 encode_block(s, block[6], 6);
679 encode_block(s, block[5], 5);
680 encode_block(s, block[7], 7);
684 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
685 MpegEncContext * const s = avctx->priv_data;
686 MJpegContext * const m = s->mjpeg_ctx;
687 AVFrame *pict = data;
688 const int width= s->width;
689 const int height= s->height;
690 AVFrame * const p= (AVFrame*)&s->current_picture;
691 const int predictor= avctx->prediction_method+1;
693 init_put_bits(&s->pb, buf, buf_size);
696 p->pict_type= FF_I_TYPE;
699 mjpeg_picture_header(s);
701 s->header_bits= put_bits_count(&s->pb);
703 if(avctx->pix_fmt == PIX_FMT_RGB32){
705 const int linesize= p->linesize[0];
706 uint16_t (*buffer)[4]= (void *) s->rd_scratchpad;
707 int left[3], top[3], topleft[3];
710 buffer[0][i]= 1 << (9 - 1);
713 for(y = 0; y < height; y++) {
714 const int modified_predictor= y ? predictor : 1;
715 uint8_t *ptr = p->data[0] + (linesize * y);
717 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){
718 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
723 top[i]= left[i]= topleft[i]= buffer[0][i];
725 for(x = 0; x < width; x++) {
726 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
727 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
728 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
733 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
736 top[i]= buffer[x+1][i];
738 left[i]= buffer[x][i];
740 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
743 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
745 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
751 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
752 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
754 for(mb_y = 0; mb_y < mb_height; mb_y++) {
755 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]){
756 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
759 for(mb_x = 0; mb_x < mb_width; mb_x++) {
760 if(mb_x==0 || mb_y==0){
763 int x, y, h, v, linesize;
764 h = s->mjpeg_hsample[i];
765 v = s->mjpeg_vsample[i];
766 linesize= p->linesize[i];
772 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
781 pred= ptr[-linesize];
783 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
788 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
790 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
797 int x, y, h, v, linesize;
798 h = s->mjpeg_hsample[i];
799 v = s->mjpeg_vsample[i];
800 linesize= p->linesize[i];
806 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
807 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
808 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
811 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
813 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
824 mjpeg_picture_trailer(s);
827 flush_put_bits(&s->pb);
828 return pbBufPtr(&s->pb) - s->pb.buf;
829 // return (put_bits_count(&f->pb)+7)/8;
832 #endif //CONFIG_ENCODERS
834 /******************************************/
837 #define MAX_COMPONENTS 4
839 typedef struct MJpegDecodeContext {
840 AVCodecContext *avctx;
842 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
844 int start_code; /* current start code */
848 int16_t quant_matrixes[4][64];
850 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
852 int org_height; /* size given at codec init */
853 int first_picture; /* true if decoding first picture */
854 int interlaced; /* true if interlaced */
855 int bottom_field; /* true if bottom field */
860 int rct; /* standard rct */
861 int pegasus_rct; /* pegasus reversible colorspace transform */
862 int bits; /* bits per component */
865 int near; ///< near lossless bound (si 0 for lossless)
867 int reset; ///< context halfing intervall ?rename
870 int mb_width, mb_height;
872 int component_id[MAX_COMPONENTS];
873 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
874 int v_count[MAX_COMPONENTS];
875 int comp_index[MAX_COMPONENTS];
876 int dc_index[MAX_COMPONENTS];
877 int ac_index[MAX_COMPONENTS];
878 int nb_blocks[MAX_COMPONENTS];
879 int h_scount[MAX_COMPONENTS];
880 int v_scount[MAX_COMPONENTS];
881 int h_max, v_max; /* maximum h and v counts */
882 int quant_index[4]; /* quant table index for each component */
883 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
884 AVFrame picture; /* picture structure */
885 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
886 int8_t *qscale_table;
887 DECLARE_ALIGNED_8(DCTELEM, block[64]);
889 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
890 void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
892 int restart_interval;
897 int interlace_polarity;
901 int cur_scan; /* current scan, used by JPEG-LS */
902 } MJpegDecodeContext;
904 #include "jpeg_ls.c" //FIXME make jpeg-ls more independent
906 static int mjpeg_decode_dht(MJpegDecodeContext *s);
908 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
909 int nb_codes, int use_static, int is_ac)
911 uint8_t huff_size[256+16];
912 uint16_t huff_code[256+16];
914 assert(nb_codes <= 256);
916 memset(huff_size, 0, sizeof(huff_size));
917 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
920 memmove(huff_size+16, huff_size, sizeof(uint8_t)*nb_codes);
921 memmove(huff_code+16, huff_code, sizeof(uint16_t)*nb_codes);
922 memset(huff_size, 0, sizeof(uint8_t)*16);
923 memset(huff_code, 0, sizeof(uint16_t)*16);
927 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static);
930 static int mjpeg_decode_init(AVCodecContext *avctx)
932 MJpegDecodeContext *s = avctx->priv_data;
934 memset(s, 0, sizeof(MJpegDecodeContext));
938 /* ugly way to get the idct & scantable FIXME */
939 memset(&s2, 0, sizeof(MpegEncContext));
941 // s2->out_format = FMT_MJPEG;
942 dsputil_init(&s2.dsp, avctx);
943 DCT_common_init(&s2);
945 s->scantable= s2.intra_scantable;
946 s->idct_put= s2.dsp.idct_put;
947 s->idct_add= s2.dsp.idct_add;
949 s->mpeg_enc_ctx_allocated = 0;
953 s->first_picture = 1;
954 s->org_height = avctx->coded_height;
956 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0, 0);
957 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0, 0);
958 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0, 1);
959 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0, 1);
961 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
963 av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
964 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
966 /* should check for error - but dunno */
968 if (avctx->extradata_size > 9 &&
969 AV_RL32(avctx->extradata + 4) == MKTAG('f','i','e','l')) {
970 if (avctx->extradata[9] == 6) { /* quicktime icefloe 019 */
971 s->interlace_polarity = 1; /* bottom field first */
972 av_log(avctx, AV_LOG_DEBUG, "mjpeg bottom field first\n");
981 * finds the end of the current frame in the bitstream.
982 * @return the position of the first byte of the next frame, or -1
984 static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){
988 vop_found= pc->frame_start_found;
993 for(i=0; i<buf_size; i++){
994 state= (state<<8) | buf[i];
1004 /* EOF considered as end of frame */
1007 for(; i<buf_size; i++){
1008 state= (state<<8) | buf[i];
1009 if(state == 0xFFD8){
1010 pc->frame_start_found=0;
1016 pc->frame_start_found= vop_found;
1018 return END_NOT_FOUND;
1021 static int jpeg_parse(AVCodecParserContext *s,
1022 AVCodecContext *avctx,
1023 uint8_t **poutbuf, int *poutbuf_size,
1024 const uint8_t *buf, int buf_size)
1026 ParseContext *pc = s->priv_data;
1029 next= find_frame_end(pc, buf, buf_size);
1031 if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
1037 *poutbuf = (uint8_t *)buf;
1038 *poutbuf_size = buf_size;
1042 /* quantize tables */
1043 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
1045 int len, index, i, j;
1047 len = get_bits(&s->gb, 16) - 2;
1050 /* only 8 bit precision handled */
1051 if (get_bits(&s->gb, 4) != 0)
1053 av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
1056 index = get_bits(&s->gb, 4);
1059 av_log(s->avctx, AV_LOG_DEBUG, "index=%d\n", index);
1060 /* read quant table */
1062 j = s->scantable.permutated[i];
1063 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
1066 //XXX FIXME finetune, and perhaps add dc too
1067 s->qscale[index]= FFMAX(
1068 s->quant_matrixes[index][s->scantable.permutated[1]],
1069 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
1070 av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
1077 /* decode huffman tables and build VLC decoders */
1078 static int mjpeg_decode_dht(MJpegDecodeContext *s)
1080 int len, index, i, class, n, v, code_max;
1081 uint8_t bits_table[17];
1082 uint8_t val_table[256];
1084 len = get_bits(&s->gb, 16) - 2;
1089 class = get_bits(&s->gb, 4);
1092 index = get_bits(&s->gb, 4);
1096 for(i=1;i<=16;i++) {
1097 bits_table[i] = get_bits(&s->gb, 8);
1101 if (len < n || n > 256)
1106 v = get_bits(&s->gb, 8);
1113 /* build VLC and flush previous vlc if present */
1114 free_vlc(&s->vlcs[class][index]);
1115 av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
1116 class, index, code_max + 1);
1117 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
1124 static int mjpeg_decode_sof(MJpegDecodeContext *s)
1126 int len, nb_components, i, width, height, pix_fmt_id;
1128 /* XXX: verify len field validity */
1129 len = get_bits(&s->gb, 16);
1130 s->bits= get_bits(&s->gb, 8);
1132 if(s->pegasus_rct) s->bits=9;
1133 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1135 if (s->bits != 8 && !s->lossless){
1136 av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
1140 height = get_bits(&s->gb, 16);
1141 width = get_bits(&s->gb, 16);
1143 av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
1144 if(avcodec_check_dimensions(s->avctx, width, height))
1147 nb_components = get_bits(&s->gb, 8);
1148 if (nb_components <= 0 ||
1149 nb_components > MAX_COMPONENTS)
1151 if (s->ls && !(s->bits <= 8 || nb_components == 1)){
1152 av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
1155 s->nb_components = nb_components;
1158 for(i=0;i<nb_components;i++) {
1160 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1161 s->h_count[i] = get_bits(&s->gb, 4);
1162 s->v_count[i] = get_bits(&s->gb, 4);
1163 /* compute hmax and vmax (only used in interleaved case) */
1164 if (s->h_count[i] > s->h_max)
1165 s->h_max = s->h_count[i];
1166 if (s->v_count[i] > s->v_max)
1167 s->v_max = s->v_count[i];
1168 s->quant_index[i] = get_bits(&s->gb, 8);
1169 if (s->quant_index[i] >= 4)
1171 av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1172 s->v_count[i], s->component_id[i], s->quant_index[i]);
1175 if(s->ls && (s->h_max > 1 || s->v_max > 1)) {
1176 av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
1180 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1182 /* if different size, realloc/alloc picture */
1183 /* XXX: also check h_count and v_count */
1184 if (width != s->width || height != s->height) {
1185 av_freep(&s->qscale_table);
1190 /* test interlaced mode */
1191 if (s->first_picture &&
1192 s->org_height != 0 &&
1193 s->height < ((s->org_height * 3) / 4)) {
1195 s->bottom_field = s->interlace_polarity;
1196 s->picture.interlaced_frame = 1;
1197 s->picture.top_field_first = !s->interlace_polarity;
1201 avcodec_set_dimensions(s->avctx, width, height);
1203 s->qscale_table= av_mallocz((s->width+15)/16);
1205 s->first_picture = 0;
1208 if(s->interlaced && (s->bottom_field == !s->interlace_polarity))
1211 /* XXX: not complete test ! */
1212 pix_fmt_id = (s->h_count[0] << 20) | (s->v_count[0] << 16) |
1213 (s->h_count[1] << 12) | (s->v_count[1] << 8) |
1214 (s->h_count[2] << 4) | s->v_count[2];
1215 av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
1220 s->avctx->pix_fmt = PIX_FMT_RGB32;
1221 }else if(s->nb_components==3)
1222 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
1224 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1228 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P;
1232 s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P;
1236 if(s->nb_components > 1)
1237 s->avctx->pix_fmt = PIX_FMT_RGB24;
1238 else if(s->bits <= 8)
1239 s->avctx->pix_fmt = PIX_FMT_GRAY8;
1241 s->avctx->pix_fmt = PIX_FMT_GRAY16;
1244 if(s->picture.data[0])
1245 s->avctx->release_buffer(s->avctx, &s->picture);
1247 s->picture.reference= 0;
1248 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1249 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1252 s->picture.pict_type= I_TYPE;
1253 s->picture.key_frame= 1;
1256 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1259 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1261 if (len != (8+(3*nb_components)))
1263 av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
1266 /* totally blank picture as progressive JPEG will only add details to it */
1268 memset(s->picture.data[0], 0, s->picture.linesize[0] * s->height);
1269 memset(s->picture.data[1], 0, s->picture.linesize[1] * s->height >> (s->v_max - s->v_count[1]));
1270 memset(s->picture.data[2], 0, s->picture.linesize[2] * s->height >> (s->v_max - s->v_count[2]));
1275 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1278 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1281 av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1282 &s->vlcs[0][dc_index]);
1287 return get_xbits(&s->gb, code);
1292 /* decode block and dequantize */
1293 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1294 int component, int dc_index, int ac_index, int16_t *quant_matrix)
1296 int code, i, j, level, val;
1299 val = mjpeg_decode_dc(s, dc_index);
1300 if (val == 0xffff) {
1301 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1304 val = val * quant_matrix[0] + s->last_dc[component];
1305 s->last_dc[component] = val;
1309 {OPEN_READER(re, &s->gb)
1311 UPDATE_CACHE(re, &s->gb);
1312 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1317 i += ((unsigned)code) >> 4;
1320 if(code > MIN_CACHE_BITS - 16){
1321 UPDATE_CACHE(re, &s->gb)
1324 int cache=GET_CACHE(re,&s->gb);
1325 int sign=(~cache)>>31;
1326 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1329 LAST_SKIP_BITS(re, &s->gb, code)
1333 j = s->scantable.permutated[63];
1334 block[j] = level * quant_matrix[j];
1337 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1340 j = s->scantable.permutated[i];
1341 block[j] = level * quant_matrix[j];
1344 CLOSE_READER(re, &s->gb)}
1349 /* decode block and dequantize - progressive JPEG version */
1350 static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
1351 int component, int dc_index, int ac_index, int16_t *quant_matrix,
1352 int ss, int se, int Ah, int Al, int *EOBRUN)
1354 int code, i, j, level, val, run;
1358 val = mjpeg_decode_dc(s, dc_index);
1359 if (val == 0xffff) {
1360 av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
1363 val = (val * quant_matrix[0] << Al) + s->last_dc[component];
1366 s->last_dc[component] = val;
1374 {OPEN_READER(re, &s->gb)
1376 UPDATE_CACHE(re, &s->gb);
1377 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1378 /* Progressive JPEG use AC coeffs from zero and this decoder sets offset 16 by default */
1381 i += ((unsigned) code) >> 4;
1383 if(code > MIN_CACHE_BITS - 16){
1384 UPDATE_CACHE(re, &s->gb)
1387 int cache=GET_CACHE(re,&s->gb);
1388 int sign=(~cache)>>31;
1389 level = (NEG_USR32(sign ^ cache,code) ^ sign) - sign;
1392 LAST_SKIP_BITS(re, &s->gb, code)
1396 j = s->scantable.permutated[se];
1397 block[j] = level * quant_matrix[j] << Al;
1400 av_log(s->avctx, AV_LOG_ERROR, "error count: %d\n", i);
1403 j = s->scantable.permutated[i];
1404 block[j] = level * quant_matrix[j] << Al;
1406 run = ((unsigned) code) >> 4;
1407 if(run == 0xF){// ZRL - skip 15 coefficients
1412 UPDATE_CACHE(re, &s->gb);
1413 run += (GET_CACHE(re, &s->gb) >> (32 - val)) & (run - 1);
1415 LAST_SKIP_BITS(re, &s->gb, val);
1421 CLOSE_READER(re, &s->gb)}
1426 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1428 uint16_t buffer[32768][4];
1429 int left[3], top[3], topleft[3];
1430 const int linesize= s->linesize[0];
1431 const int mask= (1<<s->bits)-1;
1433 if((unsigned)s->mb_width > 32768) //dynamic alloc
1437 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1439 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1440 const int modified_predictor= mb_y ? predictor : 1;
1441 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1443 if (s->interlaced && s->bottom_field)
1444 ptr += linesize >> 1;
1447 top[i]= left[i]= topleft[i]= buffer[0][i];
1449 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1450 if (s->restart_interval && !s->restart_count)
1451 s->restart_count = s->restart_interval;
1457 top[i]= buffer[mb_x][i];
1459 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1462 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1465 if (s->restart_interval && !--s->restart_count) {
1466 align_get_bits(&s->gb);
1467 skip_bits(&s->gb, 16); /* skip RSTn */
1472 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1473 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1474 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1475 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1477 }else if(s->pegasus_rct){
1478 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1479 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1480 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1481 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1484 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1485 ptr[4*mb_x+0] = buffer[mb_x][0];
1486 ptr[4*mb_x+1] = buffer[mb_x][1];
1487 ptr[4*mb_x+2] = buffer[mb_x][2];
1494 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1496 const int nb_components=3;
1498 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1499 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1500 if (s->restart_interval && !s->restart_count)
1501 s->restart_count = s->restart_interval;
1503 if(mb_x==0 || mb_y==0 || s->interlaced){
1504 for(i=0;i<nb_components;i++) {
1506 int n, h, v, x, y, c, j, linesize;
1507 n = s->nb_blocks[i];
1508 c = s->comp_index[i];
1513 linesize= s->linesize[c];
1515 for(j=0; j<n; j++) {
1518 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1519 if(y==0 && mb_y==0){
1520 if(x==0 && mb_x==0){
1521 pred= 128 << point_transform;
1526 if(x==0 && mb_x==0){
1527 pred= ptr[-linesize];
1529 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1533 if (s->interlaced && s->bottom_field)
1534 ptr += linesize >> 1;
1535 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1544 for(i=0;i<nb_components;i++) {
1546 int n, h, v, x, y, c, j, linesize;
1547 n = s->nb_blocks[i];
1548 c = s->comp_index[i];
1553 linesize= s->linesize[c];
1555 for(j=0; j<n; j++) {
1558 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1559 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1560 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1568 if (s->restart_interval && !--s->restart_count) {
1569 align_get_bits(&s->gb);
1570 skip_bits(&s->gb, 16); /* skip RSTn */
1577 static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int ss, int se, int Ah, int Al){
1581 if(Ah) return 0; /* TODO decode refinement planes too */
1582 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1583 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1584 if (s->restart_interval && !s->restart_count)
1585 s->restart_count = s->restart_interval;
1587 for(i=0;i<nb_components;i++) {
1589 int n, h, v, x, y, c, j;
1590 n = s->nb_blocks[i];
1591 c = s->comp_index[i];
1597 memset(s->block, 0, sizeof(s->block));
1598 if (!s->progressive && decode_block(s, s->block, i,
1599 s->dc_index[i], s->ac_index[i],
1600 s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1601 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1604 if (s->progressive && decode_block_progressive(s, s->block, i,
1605 s->dc_index[i], s->ac_index[i],
1606 s->quant_matrixes[ s->quant_index[c] ], ss, se, Ah, Al, &EOBRUN) < 0) {
1607 av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
1610 // av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
1611 ptr = s->picture.data[c] +
1612 (((s->linesize[c] * (v * mb_y + y) * 8) +
1613 (h * mb_x + x) * 8) >> s->avctx->lowres);
1614 if (s->interlaced && s->bottom_field)
1615 ptr += s->linesize[c] >> 1;
1616 //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);
1618 s->idct_put(ptr, s->linesize[c], s->block);
1620 s->idct_add(ptr, s->linesize[c], s->block);
1627 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1628 if (s->restart_interval && (s->restart_interval < 1350) &&
1629 !--s->restart_count) {
1630 align_get_bits(&s->gb);
1631 skip_bits(&s->gb, 16); /* skip RSTn */
1632 for (i=0; i<nb_components; i++) /* reset dc */
1633 s->last_dc[i] = 1024;
1640 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1642 int len, nb_components, i, h, v, predictor, point_transform;
1643 int vmax, hmax, index, id;
1644 const int block_size= s->lossless ? 1 : 8;
1645 int ilv, prev_shift;
1647 /* XXX: verify len field validity */
1648 len = get_bits(&s->gb, 16);
1649 nb_components = get_bits(&s->gb, 8);
1650 if (len != 6+2*nb_components)
1652 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
1657 for(i=0;i<nb_components;i++) {
1658 id = get_bits(&s->gb, 8) - 1;
1659 av_log(s->avctx, AV_LOG_DEBUG, "component: %d\n", id);
1660 /* find component index */
1661 for(index=0;index<s->nb_components;index++)
1662 if (id == s->component_id[index])
1664 if (index == s->nb_components)
1666 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
1670 s->comp_index[i] = index;
1672 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1673 s->h_scount[i] = s->h_count[index];
1674 s->v_scount[i] = s->v_count[index];
1676 s->dc_index[i] = get_bits(&s->gb, 4);
1677 s->ac_index[i] = get_bits(&s->gb, 4);
1679 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1680 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1683 switch(s->start_code)
1686 if (dc_index[i] > 1 || ac_index[i] > 1)
1691 if (dc_index[i] > 3 || ac_index[i] > 3)
1695 if (dc_index[i] > 3 || ac_index[i] != 0)
1702 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1703 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1704 prev_shift = get_bits(&s->gb, 4); /* Ah */
1705 point_transform= get_bits(&s->gb, 4); /* Al */
1707 for(i=0;i<nb_components;i++)
1708 s->last_dc[i] = 1024;
1710 if (nb_components > 1) {
1711 /* interleaved stream */
1712 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1713 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1714 } else if(!s->ls) { /* skip this for JPEG-LS */
1715 h = s->h_max / s->h_scount[0];
1716 v = s->v_max / s->v_scount[0];
1717 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1718 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1719 s->nb_blocks[0] = 1;
1724 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1725 av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "",
1726 predictor, point_transform, ilv, s->bits,
1727 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1730 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1731 for (i = s->mjpb_skiptosod; i > 0; i--)
1732 skip_bits(&s->gb, 8);
1737 // reset_ls_coding_parameters(s, 0);
1739 ls_decode_picture(s, predictor, point_transform, ilv);
1742 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1745 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1750 if(mjpeg_decode_scan(s, nb_components, predictor, ilv, prev_shift, point_transform) < 0)
1756 av_log(s->avctx, AV_LOG_ERROR, "decode_sos: ac/dc index out of range\n");
1760 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1762 if (get_bits(&s->gb, 16) != 4)
1764 s->restart_interval = get_bits(&s->gb, 16);
1765 s->restart_count = 0;
1766 av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
1771 static int mjpeg_decode_app(MJpegDecodeContext *s)
1775 len = get_bits(&s->gb, 16);
1778 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1781 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1785 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1786 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1789 /* buggy AVID, it puts EOI only at every 10th frame */
1790 /* also this fourcc is used by non-avid files too, it holds some
1791 informations, but it's always present in AVID creates files */
1792 if (id == ff_get_fourcc("AVI1"))
1799 4bytes field_size_less_padding
1802 // if (s->first_picture)
1803 // printf("mjpeg: workarounding buggy AVID\n");
1804 s->interlace_polarity = get_bits(&s->gb, 8);
1806 skip_bits(&s->gb, 8);
1807 skip_bits(&s->gb, 32);
1808 skip_bits(&s->gb, 32);
1811 // if (s->interlace_polarity)
1812 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1818 if (id == ff_get_fourcc("JFIF"))
1820 int t_w, t_h, v1, v2;
1821 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1822 v1= get_bits(&s->gb, 8);
1823 v2= get_bits(&s->gb, 8);
1824 skip_bits(&s->gb, 8);
1826 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1827 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1829 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1830 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1832 s->avctx->sample_aspect_ratio.num,
1833 s->avctx->sample_aspect_ratio.den
1836 t_w = get_bits(&s->gb, 8);
1837 t_h = get_bits(&s->gb, 8);
1840 /* skip thumbnail */
1841 if (len-10-(t_w*t_h*3) > 0)
1848 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1850 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1851 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1852 skip_bits(&s->gb, 16); /* version */
1853 skip_bits(&s->gb, 16); /* flags0 */
1854 skip_bits(&s->gb, 16); /* flags1 */
1855 skip_bits(&s->gb, 8); /* transform */
1860 if (id == ff_get_fourcc("LJIF")){
1861 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1862 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1863 skip_bits(&s->gb, 16); /* version ? */
1864 skip_bits(&s->gb, 16); /* unknwon always 0? */
1865 skip_bits(&s->gb, 16); /* unknwon always 0? */
1866 skip_bits(&s->gb, 16); /* unknwon always 0? */
1867 switch( get_bits(&s->gb, 8)){
1877 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1884 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1886 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1889 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1892 skip_bits(&s->gb, 32); /* field size */
1893 skip_bits(&s->gb, 32); /* pad field size */
1894 skip_bits(&s->gb, 32); /* next off */
1895 skip_bits(&s->gb, 32); /* quant off */
1896 skip_bits(&s->gb, 32); /* huff off */
1897 skip_bits(&s->gb, 32); /* image off */
1898 skip_bits(&s->gb, 32); /* scan off */
1899 skip_bits(&s->gb, 32); /* data off */
1901 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1902 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1907 /* slow but needed for extreme adobe jpegs */
1909 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1911 skip_bits(&s->gb, 8);
1916 static int mjpeg_decode_com(MJpegDecodeContext *s)
1918 int len = get_bits(&s->gb, 16);
1919 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1920 char *cbuf = av_malloc(len - 1);
1923 for (i = 0; i < len - 2; i++)
1924 cbuf[i] = get_bits(&s->gb, 8);
1925 if (i > 0 && cbuf[i-1] == '\n')
1930 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1931 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1933 /* buggy avid, it puts EOI only at every 10th frame */
1934 if (!strcmp(cbuf, "AVID"))
1937 // if (s->first_picture)
1938 // printf("mjpeg: workarounding buggy AVID\n");
1940 else if(!strcmp(cbuf, "CS=ITU601")){
1952 static int valid_marker_list[] =
1954 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1955 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1956 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1957 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1958 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1959 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1960 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1961 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1962 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1963 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1964 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1965 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1966 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1967 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1968 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1969 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1970 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1974 /* return the 8 bit start code value and update the search
1975 state. Return -1 if no start code found */
1976 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1985 buf_ptr = *pbuf_ptr;
1986 while (buf_ptr < buf_end) {
1989 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
2000 av_log(NULL, AV_LOG_VERBOSE, "find_marker skipped %d bytes\n", skipped);
2002 *pbuf_ptr = buf_ptr;
2006 static int mjpeg_decode_frame(AVCodecContext *avctx,
2007 void *data, int *data_size,
2008 uint8_t *buf, int buf_size)
2010 MJpegDecodeContext *s = avctx->priv_data;
2011 uint8_t *buf_end, *buf_ptr;
2013 AVFrame *picture = data;
2016 buf_end = buf + buf_size;
2017 while (buf_ptr < buf_end) {
2018 /* find start next marker */
2019 start_code = find_marker(&buf_ptr, buf_end);
2022 if (start_code < 0) {
2025 av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
2027 if ((buf_end - buf_ptr) > s->buffer_size)
2030 s->buffer_size = buf_end-buf_ptr;
2031 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
2032 av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
2036 /* unescape buffer of SOS, use special treatment for JPEG-LS */
2037 if (start_code == SOS && !s->ls)
2039 uint8_t *src = buf_ptr;
2040 uint8_t *dst = s->buffer;
2044 uint8_t x = *(src++);
2049 while(src<buf_end && x == 0xff)
2052 if (x >= 0xd0 && x <= 0xd7)
2058 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
2060 av_log(avctx, AV_LOG_DEBUG, "escaping removed %d bytes\n",
2061 (buf_end - buf_ptr) - (dst - s->buffer));
2063 else if(start_code == SOS && s->ls){
2064 uint8_t *src = buf_ptr;
2065 uint8_t *dst = s->buffer;
2073 while (src + t < buf_end){
2074 uint8_t x = src[t++];
2076 while((src + t < buf_end) && x == 0xff)
2086 init_put_bits(&pb, dst, t);
2088 /* unescape bitstream */
2090 uint8_t x = src[b++];
2091 put_bits(&pb, 8, x);
2094 put_bits(&pb, 7, x);
2098 flush_put_bits(&pb);
2100 init_get_bits(&s->gb, dst, bit_count);
2103 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
2105 s->start_code = start_code;
2106 if(s->avctx->debug & FF_DEBUG_STARTCODE){
2107 av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
2110 /* process markers */
2111 if (start_code >= 0xd0 && start_code <= 0xd7) {
2112 av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
2114 } else if (start_code >= APP0 && start_code <= APP15) {
2115 mjpeg_decode_app(s);
2117 } else if (start_code == COM){
2118 mjpeg_decode_com(s);
2121 switch(start_code) {
2123 s->restart_interval = 0;
2125 s->restart_count = 0;
2126 /* nothing to do on SOI */
2129 mjpeg_decode_dqt(s);
2132 if(mjpeg_decode_dht(s) < 0){
2133 av_log(avctx, AV_LOG_ERROR, "huffman table decode error\n");
2141 if (mjpeg_decode_sof(s) < 0)
2148 if (mjpeg_decode_sof(s) < 0)
2155 if (mjpeg_decode_sof(s) < 0)
2162 if (mjpeg_decode_sof(s) < 0)
2166 if (decode_lse(s) < 0)
2171 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2175 if (s->interlaced) {
2176 s->bottom_field ^= 1;
2177 /* if not bottom field, do not output image yet */
2178 if (s->bottom_field == !s->interlace_polarity)
2181 *picture = s->picture;
2182 *data_size = sizeof(AVFrame);
2185 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2186 picture->qstride= 0;
2187 picture->qscale_table= s->qscale_table;
2188 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2189 if(avctx->debug & FF_DEBUG_QP)
2190 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2191 picture->quality*= FF_QP2LAMBDA;
2198 mjpeg_decode_sos(s);
2199 /* buggy avid puts EOI every 10-20th frame */
2200 /* if restart period is over process EOI */
2201 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2205 mjpeg_decode_dri(s);
2218 av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2221 // printf("mjpeg: unsupported marker (%x)\n", start_code);
2226 /* eof process start code */
2227 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2228 av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
2229 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2234 av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2235 // return buf_end - buf_ptr;
2236 return buf_ptr - buf;
2239 static int mjpegb_decode_frame(AVCodecContext *avctx,
2240 void *data, int *data_size,
2241 uint8_t *buf, int buf_size)
2243 MJpegDecodeContext *s = avctx->priv_data;
2244 uint8_t *buf_end, *buf_ptr;
2245 AVFrame *picture = data;
2246 GetBitContext hgb; /* for the header */
2247 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2248 uint32_t field_size, sod_offs;
2251 buf_end = buf + buf_size;
2254 /* reset on every SOI */
2255 s->restart_interval = 0;
2256 s->restart_count = 0;
2257 s->mjpb_skiptosod = 0;
2259 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2261 skip_bits(&hgb, 32); /* reserved zeros */
2263 if (get_bits_long(&hgb, 32) != MKBETAG('m','j','p','g'))
2265 av_log(avctx, AV_LOG_WARNING, "not mjpeg-b (bad fourcc)\n");
2269 field_size = get_bits_long(&hgb, 32); /* field size */
2270 av_log(avctx, AV_LOG_DEBUG, "field size: 0x%x\n", field_size);
2271 skip_bits(&hgb, 32); /* padded field size */
2272 second_field_offs = get_bits_long(&hgb, 32);
2273 av_log(avctx, AV_LOG_DEBUG, "second field offs: 0x%x\n", second_field_offs);
2274 if (second_field_offs)
2277 dqt_offs = get_bits_long(&hgb, 32);
2278 av_log(avctx, AV_LOG_DEBUG, "dqt offs: 0x%x\n", dqt_offs);
2281 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2282 s->start_code = DQT;
2283 mjpeg_decode_dqt(s);
2286 dht_offs = get_bits_long(&hgb, 32);
2287 av_log(avctx, AV_LOG_DEBUG, "dht offs: 0x%x\n", dht_offs);
2290 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2291 s->start_code = DHT;
2292 mjpeg_decode_dht(s);
2295 sof_offs = get_bits_long(&hgb, 32);
2296 av_log(avctx, AV_LOG_DEBUG, "sof offs: 0x%x\n", sof_offs);
2299 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2300 s->start_code = SOF0;
2301 if (mjpeg_decode_sof(s) < 0)
2305 sos_offs = get_bits_long(&hgb, 32);
2306 av_log(avctx, AV_LOG_DEBUG, "sos offs: 0x%x\n", sos_offs);
2307 sod_offs = get_bits_long(&hgb, 32);
2308 av_log(avctx, AV_LOG_DEBUG, "sod offs: 0x%x\n", sod_offs);
2311 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2312 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2313 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2314 s->start_code = SOS;
2315 mjpeg_decode_sos(s);
2318 if (s->interlaced) {
2319 s->bottom_field ^= 1;
2320 /* if not bottom field, do not output image yet */
2321 if (s->bottom_field && second_field_offs)
2323 buf_ptr = buf + second_field_offs;
2324 second_field_offs = 0;
2329 //XXX FIXME factorize, this looks very similar to the EOI code
2331 *picture= s->picture;
2332 *data_size = sizeof(AVFrame);
2335 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2336 picture->qstride= 0;
2337 picture->qscale_table= s->qscale_table;
2338 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2339 if(avctx->debug & FF_DEBUG_QP)
2340 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2341 picture->quality*= FF_QP2LAMBDA;
2344 return buf_ptr - buf;
2349 static int sp5x_decode_frame(AVCodecContext *avctx,
2350 void *data, int *data_size,
2351 uint8_t *buf, int buf_size)
2354 MJpegDecodeContext *s = avctx->priv_data;
2356 const int qscale = 5;
2357 uint8_t *buf_ptr, *buf_end, *recoded;
2360 if (!avctx->width || !avctx->height)
2364 buf_end = buf + buf_size;
2367 recoded = av_mallocz(buf_size + 1024);
2372 recoded[j++] = 0xFF;
2373 recoded[j++] = 0xD8;
2375 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2376 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2377 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2378 j += sizeof(sp5x_data_dqt);
2380 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2381 j += sizeof(sp5x_data_dht);
2383 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2384 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2385 recoded[j+6] = avctx->coded_height & 0xFF;
2386 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2387 recoded[j+8] = avctx->coded_width & 0xFF;
2388 j += sizeof(sp5x_data_sof);
2390 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2391 j += sizeof(sp5x_data_sos);
2393 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2395 recoded[j++] = buf[i];
2401 recoded[j++] = 0xFF;
2402 recoded[j++] = 0xD9;
2404 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2411 s->width = avctx->coded_width;
2412 s->height = avctx->coded_height;
2413 s->nb_components = 3;
2414 s->component_id[0] = 0;
2417 s->quant_index[0] = 0;
2418 s->component_id[1] = 1;
2421 s->quant_index[1] = 1;
2422 s->component_id[2] = 2;
2425 s->quant_index[2] = 1;
2429 s->qscale_table = av_mallocz((s->width+15)/16);
2430 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2433 s->picture.reference = 0;
2434 if (avctx->get_buffer(avctx, &s->picture) < 0)
2436 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2440 s->picture.pict_type = I_TYPE;
2441 s->picture.key_frame = 1;
2443 for (i = 0; i < 3; i++)
2444 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2447 for (i = 0; i < 64; i++)
2449 j = s->scantable.permutated[i];
2450 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2452 s->qscale[0] = FFMAX(
2453 s->quant_matrixes[0][s->scantable.permutated[1]],
2454 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2456 for (i = 0; i < 64; i++)
2458 j = s->scantable.permutated[i];
2459 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2461 s->qscale[1] = FFMAX(
2462 s->quant_matrixes[1][s->scantable.permutated[1]],
2463 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2468 s->comp_index[0] = 0;
2469 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2470 s->h_scount[0] = s->h_count[0];
2471 s->v_scount[0] = s->v_count[0];
2475 s->comp_index[1] = 1;
2476 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2477 s->h_scount[1] = s->h_count[1];
2478 s->v_scount[1] = s->v_count[1];
2482 s->comp_index[2] = 2;
2483 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2484 s->h_scount[2] = s->h_count[2];
2485 s->v_scount[2] = s->v_count[2];
2489 for (i = 0; i < 3; i++)
2490 s->last_dc[i] = 1024;
2492 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2493 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2495 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2497 return mjpeg_decode_scan(s);
2503 static int mjpeg_decode_end(AVCodecContext *avctx)
2505 MJpegDecodeContext *s = avctx->priv_data;
2509 av_free(s->qscale_table);
2513 free_vlc(&s->vlcs[i][j]);
2518 static int mjpega_dump_header(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
2519 uint8_t **poutbuf, int *poutbuf_size,
2520 const uint8_t *buf, int buf_size, int keyframe)
2525 if (avctx->codec_id != CODEC_ID_MJPEG) {
2526 av_log(avctx, AV_LOG_ERROR, "mjpega bitstream filter only applies to mjpeg codec\n");
2531 *poutbuf = av_malloc(buf_size + 44 + FF_INPUT_BUFFER_PADDING_SIZE);
2532 poutbufp = *poutbuf;
2533 bytestream_put_byte(&poutbufp, 0xff);
2534 bytestream_put_byte(&poutbufp, SOI);
2535 bytestream_put_byte(&poutbufp, 0xff);
2536 bytestream_put_byte(&poutbufp, APP1);
2537 bytestream_put_be16(&poutbufp, 42); /* size */
2538 bytestream_put_be32(&poutbufp, 0);
2539 bytestream_put_buffer(&poutbufp, "mjpg", 4);
2540 bytestream_put_be32(&poutbufp, buf_size + 44); /* field size */
2541 bytestream_put_be32(&poutbufp, buf_size + 44); /* pad field size */
2542 bytestream_put_be32(&poutbufp, 0); /* next ptr */
2544 for (i = 0; i < buf_size - 1; i++) {
2545 if (buf[i] == 0xff) {
2546 switch (buf[i + 1]) {
2547 case DQT: /* quant off */
2548 case DHT: /* huff off */
2549 case SOF0: /* image off */
2550 bytestream_put_be32(&poutbufp, i + 46);
2553 bytestream_put_be32(&poutbufp, i + 46); /* scan off */
2554 bytestream_put_be32(&poutbufp, i + 46 + AV_RB16(buf + i + 2)); /* data off */
2555 bytestream_put_buffer(&poutbufp, buf + 2, buf_size - 2); /* skip already written SOI */
2556 *poutbuf_size = poutbufp - *poutbuf;
2559 if (i + 8 < buf_size && AV_RL32(buf + i + 8) == ff_get_fourcc("mjpg")) {
2560 av_log(avctx, AV_LOG_ERROR, "bitstream already formatted\n");
2561 memcpy(*poutbuf, buf, buf_size);
2562 *poutbuf_size = buf_size;
2569 av_log(avctx, AV_LOG_ERROR, "could not find SOS marker in bitstream\n");
2573 AVCodec mjpeg_decoder = {
2577 sizeof(MJpegDecodeContext),
2586 AVCodec mjpegb_decoder = {
2590 sizeof(MJpegDecodeContext),
2594 mjpegb_decode_frame,
2599 AVCodec sp5x_decoder = {
2603 sizeof(MJpegDecodeContext),
2612 #ifdef CONFIG_ENCODERS
2613 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2617 sizeof(MpegEncContext),
2619 encode_picture_lossless,
2624 AVCodecParser mjpeg_parser = {
2626 sizeof(ParseContext),
2632 AVBitStreamFilter mjpega_dump_header_bsf = {