2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 * Support for external huffman table and various fixes (AVID workaround) by
20 * Alex Beregszaszi <alex@naxine.org>
25 #include "mpegvideo.h"
28 #include "fastmemcpy.h"
31 /* use two quantizer table (one for luminance and one for chrominance) */
35 typedef struct MJpegContext {
36 UINT8 huff_size_dc_luminance[12];
37 UINT16 huff_code_dc_luminance[12];
38 UINT8 huff_size_dc_chrominance[12];
39 UINT16 huff_code_dc_chrominance[12];
41 UINT8 huff_size_ac_luminance[256];
42 UINT16 huff_code_ac_luminance[256];
43 UINT8 huff_size_ac_chrominance[256];
44 UINT16 huff_code_ac_chrominance[256];
47 /* JPEG marker codes */
50 SOF0 = 0xc0, /* baseline */
51 SOF1 = 0xc1, /* extended sequential, huffman */
52 SOF2 = 0xc2, /* progressive, huffman */
53 SOF3 = 0xc3, /* lossless, huffman */
55 SOF5 = 0xc5, /* differential sequential, huffman */
56 SOF6 = 0xc6, /* differential progressive, huffman */
57 SOF7 = 0xc7, /* differential lossless, huffman */
58 JPG = 0xc8, /* reserved for JPEG extension */
59 SOF9 = 0xc9, /* extended sequential, arithmetic */
60 SOF10 = 0xca, /* progressive, arithmetic */
61 SOF11 = 0xcb, /* lossless, arithmetic */
63 SOF13 = 0xcd, /* differential sequential, arithmetic */
64 SOF14 = 0xce, /* differential progressive, arithmetic */
65 SOF15 = 0xcf, /* differential lossless, arithmetic */
67 DHT = 0xc4, /* define huffman tables */
69 DAC = 0xcc, /* define arithmetic-coding conditioning */
71 /* restart with modulo 8 count "m" */
81 SOI = 0xd8, /* start of image */
82 EOI = 0xd9, /* end of image */
83 SOS = 0xda, /* start of scan */
84 DQT = 0xdb, /* define quantization tables */
85 DNL = 0xdc, /* define number of lines */
86 DRI = 0xdd, /* define restart interval */
87 DHP = 0xde, /* define hierarchical progression */
88 EXP = 0xdf, /* expand reference components */
122 COM = 0xfe, /* comment */
124 TEM = 0x01, /* temporary private use for arithmetic coding */
126 /* 0x02 -> 0xbf reserved */
130 /* These are the sample quantization tables given in JPEG spec section K.1.
131 * The spec says that the values given produce "good" quality, and
132 * when divided by 2, "very good" quality.
134 static const unsigned char std_luminance_quant_tbl[64] = {
135 16, 11, 10, 16, 24, 40, 51, 61,
136 12, 12, 14, 19, 26, 58, 60, 55,
137 14, 13, 16, 24, 40, 57, 69, 56,
138 14, 17, 22, 29, 51, 87, 80, 62,
139 18, 22, 37, 56, 68, 109, 103, 77,
140 24, 35, 55, 64, 81, 104, 113, 92,
141 49, 64, 78, 87, 103, 121, 120, 101,
142 72, 92, 95, 98, 112, 100, 103, 99
144 static const unsigned char std_chrominance_quant_tbl[64] = {
145 17, 18, 24, 47, 99, 99, 99, 99,
146 18, 21, 26, 66, 99, 99, 99, 99,
147 24, 26, 56, 99, 99, 99, 99, 99,
148 47, 66, 99, 99, 99, 99, 99, 99,
149 99, 99, 99, 99, 99, 99, 99, 99,
150 99, 99, 99, 99, 99, 99, 99, 99,
151 99, 99, 99, 99, 99, 99, 99, 99,
152 99, 99, 99, 99, 99, 99, 99, 99
156 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
157 /* IMPORTANT: these are only valid for 8-bit data precision! */
158 static const UINT8 bits_dc_luminance[17] =
159 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
160 static const UINT8 val_dc_luminance[] =
161 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
163 static const UINT8 bits_dc_chrominance[17] =
164 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
165 static const UINT8 val_dc_chrominance[] =
166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
168 static const UINT8 bits_ac_luminance[17] =
169 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
170 static const UINT8 val_ac_luminance[] =
171 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
172 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
173 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
174 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
175 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
176 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
177 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
178 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
179 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
180 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
181 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
182 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
183 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
184 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
185 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
186 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
187 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
188 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
189 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
190 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
194 static const UINT8 bits_ac_chrominance[17] =
195 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
197 static const UINT8 val_ac_chrominance[] =
198 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
199 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
200 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
201 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
202 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
203 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
204 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
205 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
206 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
207 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
208 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
209 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
210 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
211 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
212 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
213 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
214 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
215 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
216 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
217 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
221 /* isn't this function nicer than the one in the libjpeg ? */
222 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
223 const UINT8 *bits_table, const UINT8 *val_table)
225 int i, j, k,nb, code, sym;
232 sym = val_table[k++];
234 huff_code[sym] = code;
241 int mjpeg_init(MpegEncContext *s)
245 m = av_malloc(sizeof(MJpegContext));
251 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
253 /* build all the huffman tables */
254 build_huffman_codes(m->huff_size_dc_luminance,
255 m->huff_code_dc_luminance,
258 build_huffman_codes(m->huff_size_dc_chrominance,
259 m->huff_code_dc_chrominance,
262 build_huffman_codes(m->huff_size_ac_luminance,
263 m->huff_code_ac_luminance,
266 build_huffman_codes(m->huff_size_ac_chrominance,
267 m->huff_code_ac_chrominance,
275 void mjpeg_close(MpegEncContext *s)
277 av_free(s->mjpeg_ctx);
280 static inline void put_marker(PutBitContext *p, int code)
282 put_bits(p, 8, 0xff);
283 put_bits(p, 8, code);
286 /* table_class: 0 = DC coef, 1 = AC coefs */
287 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
288 const UINT8 *bits_table, const UINT8 *value_table)
290 PutBitContext *p = &s->pb;
293 put_bits(p, 4, table_class);
294 put_bits(p, 4, table_id);
299 put_bits(p, 8, bits_table[i]);
303 put_bits(p, 8, value_table[i]);
308 static void jpeg_table_header(MpegEncContext *s)
310 PutBitContext *p = &s->pb;
317 put_bits(p, 16, 2 + 2 * (1 + 64));
319 put_bits(p, 16, 2 + 1 * (1 + 64));
321 put_bits(p, 4, 0); /* 8 bit precision */
322 put_bits(p, 4, 0); /* table 0 */
324 j = zigzag_direct[i];
325 put_bits(p, 8, s->intra_matrix[j]);
328 put_bits(p, 4, 0); /* 8 bit precision */
329 put_bits(p, 4, 1); /* table 1 */
331 j = zigzag_direct[i];
332 put_bits(p, 8, s->chroma_intra_matrix[j]);
340 put_bits(p, 16, 0); /* patched later */
342 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
343 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
345 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
346 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
351 static void jpeg_put_comments(MpegEncContext *s)
353 PutBitContext *p = &s->pb;
361 put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
362 put_bits(p, 16, 0x101);
363 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
364 put_bits(p, 16, 1); /* aspect: 1:1 */
366 put_bits(p, 8, 0); /* thumbnail width */
367 put_bits(p, 8, 0); /* thumbnail height */
374 put_bits(p, 16, 0); /* patched later */
375 #define MJPEG_VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
376 put_string(p, MJPEG_VERSION);
377 size = strlen(MJPEG_VERSION)+3;
383 void mjpeg_picture_header(MpegEncContext *s)
385 put_marker(&s->pb, SOI);
387 if (!s->mjpeg_data_only_frames)
389 jpeg_put_comments(s);
391 if (s->mjpeg_write_tables) jpeg_table_header(s);
393 put_marker(&s->pb, SOF0);
395 put_bits(&s->pb, 16, 17);
396 put_bits(&s->pb, 8, 8); /* 8 bits/component */
397 put_bits(&s->pb, 16, s->height);
398 put_bits(&s->pb, 16, s->width);
399 put_bits(&s->pb, 8, 3); /* 3 components */
402 put_bits(&s->pb, 8, 1); /* component number */
403 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
404 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
405 put_bits(&s->pb, 8, 0); /* select matrix */
408 put_bits(&s->pb, 8, 2); /* component number */
409 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
410 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
412 put_bits(&s->pb, 8, 1); /* select matrix */
414 put_bits(&s->pb, 8, 0); /* select matrix */
418 put_bits(&s->pb, 8, 3); /* component number */
419 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
420 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
422 put_bits(&s->pb, 8, 1); /* select matrix */
424 put_bits(&s->pb, 8, 0); /* select matrix */
429 put_marker(&s->pb, SOS);
430 put_bits(&s->pb, 16, 12); /* length */
431 put_bits(&s->pb, 8, 3); /* 3 components */
434 put_bits(&s->pb, 8, 1); /* index */
435 put_bits(&s->pb, 4, 0); /* DC huffman table index */
436 put_bits(&s->pb, 4, 0); /* AC huffman table index */
439 put_bits(&s->pb, 8, 2); /* index */
440 put_bits(&s->pb, 4, 1); /* DC huffman table index */
441 put_bits(&s->pb, 4, 1); /* AC huffman table index */
444 put_bits(&s->pb, 8, 3); /* index */
445 put_bits(&s->pb, 4, 1); /* DC huffman table index */
446 put_bits(&s->pb, 4, 1); /* AC huffman table index */
448 put_bits(&s->pb, 8, 0); /* Ss (not used) */
449 put_bits(&s->pb, 8, 63); /* Se (not used) */
450 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
453 void mjpeg_picture_trailer(MpegEncContext *s)
455 jflush_put_bits(&s->pb);
456 put_marker(&s->pb, EOI);
459 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
460 UINT8 *huff_size, UINT16 *huff_code)
465 jput_bits(&s->pb, huff_size[0], huff_code[0]);
473 /* compute the log (XXX: optimize) */
480 jput_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
482 jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
486 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
488 int mant, nbits, code, i, j;
489 int component, dc, run, last_index, val;
490 MJpegContext *m = s->mjpeg_ctx;
492 UINT16 *huff_code_ac;
495 component = (n <= 3 ? 0 : n - 4 + 1);
496 dc = block[0]; /* overflow is impossible */
497 val = dc - s->last_dc[component];
499 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
500 huff_size_ac = m->huff_size_ac_luminance;
501 huff_code_ac = m->huff_code_ac_luminance;
503 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
504 huff_size_ac = m->huff_size_ac_chrominance;
505 huff_code_ac = m->huff_code_ac_chrominance;
507 s->last_dc[component] = dc;
512 last_index = s->block_last_index[n];
513 for(i=1;i<=last_index;i++) {
514 j = zigzag_direct[i];
520 jput_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
529 /* compute the log (XXX: optimize) */
535 code = (run << 4) | nbits;
537 jput_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
539 jput_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
544 /* output EOB only if not already 64 values */
545 if (last_index < 63 || run != 0)
546 jput_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
549 void mjpeg_encode_mb(MpegEncContext *s,
550 DCTELEM block[6][64])
554 encode_block(s, block[i], i);
558 /******************************************/
561 /* compressed picture size */
562 #define PICTURE_BUFFER_SIZE 100000
564 #define MAX_COMPONENTS 4
566 typedef struct MJpegDecodeContext {
567 AVCodecContext *avctx;
570 int start_code; /* current start code */
573 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
574 INT16 quant_matrixes[4][64];
577 int org_width, org_height; /* size given at codec init */
578 int first_picture; /* true if decoding first picture */
579 int interlaced; /* true if interlaced */
580 int bottom_field; /* true if bottom field */
584 int component_id[MAX_COMPONENTS];
585 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
586 int v_count[MAX_COMPONENTS];
587 int h_max, v_max; /* maximum h and v counts */
588 int quant_index[4]; /* quant table index for each component */
589 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
590 UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
591 int linesize[MAX_COMPONENTS];
592 DCTELEM block[64] __align8;
593 UINT8 buffer[PICTURE_BUFFER_SIZE];
596 int restart_interval;
598 int interleaved_rows;
599 } MJpegDecodeContext;
601 #define SKIP_REMAINING(gb, len) { \
602 dprintf("reamining %d bytes in marker\n", len); \
603 if (len) while (--len) \
607 static int mjpeg_decode_dht(MJpegDecodeContext *s, UINT8 *buf, int buf_size);
609 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
612 UINT8 huff_size[256];
613 UINT16 huff_code[256];
615 memset(huff_size, 0, sizeof(huff_size));
616 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
618 init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
621 static int mjpeg_decode_init(AVCodecContext *avctx)
623 MJpegDecodeContext *s = avctx->priv_data;
628 s->mpeg_enc_ctx_allocated = 0;
629 s->buffer_size = PICTURE_BUFFER_SIZE - 1; /* minus 1 to take into
630 account FF 00 case */
632 s->buf_ptr = s->buffer;
633 s->first_picture = 1;
634 s->org_width = avctx->width;
635 s->org_height = avctx->height;
637 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
638 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
639 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
640 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
642 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
644 printf("mjpeg: using external huffman table\n");
645 mjpeg_decode_dht(s, avctx->extradata, avctx->extradata_size);
646 /* should check for error - but dunno */
651 /* quantize tables */
652 static int mjpeg_decode_dqt(MJpegDecodeContext *s,
653 UINT8 *buf, int buf_size)
655 int len, index, i, j;
656 init_get_bits(&s->gb, buf, buf_size);
658 len = get_bits(&s->gb, 16) - 2;
661 /* only 8 bit precision handled */
662 if (get_bits(&s->gb, 4) != 0)
664 dprintf("dqt: 16bit precision\n");
667 index = get_bits(&s->gb, 4);
670 dprintf("index=%d\n", index);
671 /* read quant table */
673 j = zigzag_direct[i];
674 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
679 SKIP_REMAINING(&s->gb, len);
684 /* decode huffman tables and build VLC decoders */
685 static int mjpeg_decode_dht(MJpegDecodeContext *s,
686 UINT8 *buf, int buf_size)
688 int len, index, i, class, n, v, code_max;
689 UINT8 bits_table[17];
690 UINT8 val_table[256];
692 init_get_bits(&s->gb, buf, buf_size);
694 len = get_bits(&s->gb, 16);
700 class = get_bits(&s->gb, 4);
703 index = get_bits(&s->gb, 4);
708 bits_table[i] = get_bits(&s->gb, 8);
712 if (len < n || n > 256)
717 v = get_bits(&s->gb, 8);
724 /* build VLC and flush previous vlc if present */
725 free_vlc(&s->vlcs[class][index]);
726 dprintf("class=%d index=%d nb_codes=%d\n",
727 class, index, code_max + 1);
728 build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
733 static int mjpeg_decode_sof0(MJpegDecodeContext *s,
734 UINT8 *buf, int buf_size)
736 int len, nb_components, i, width, height;
738 init_get_bits(&s->gb, buf, buf_size);
740 /* XXX: verify len field validity */
741 len = get_bits(&s->gb, 16);
742 /* only 8 bits/component accepted */
743 if (get_bits(&s->gb, 8) != 8)
745 height = get_bits(&s->gb, 16);
746 width = get_bits(&s->gb, 16);
747 dprintf("sof0: picture: %dx%d\n", width, height);
749 nb_components = get_bits(&s->gb, 8);
750 if (nb_components <= 0 ||
751 nb_components > MAX_COMPONENTS)
753 s->nb_components = nb_components;
756 for(i=0;i<nb_components;i++) {
758 s->component_id[i] = get_bits(&s->gb, 8) - 1;
759 s->h_count[i] = get_bits(&s->gb, 4);
760 s->v_count[i] = get_bits(&s->gb, 4);
761 /* compute hmax and vmax (only used in interleaved case) */
762 if (s->h_count[i] > s->h_max)
763 s->h_max = s->h_count[i];
764 if (s->v_count[i] > s->v_max)
765 s->v_max = s->v_count[i];
766 s->quant_index[i] = get_bits(&s->gb, 8);
767 if (s->quant_index[i] >= 4)
769 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
770 s->v_count[i], s->component_id[i], s->quant_index[i]);
773 /* if different size, realloc/alloc picture */
774 /* XXX: also check h_count and v_count */
775 if (width != s->width || height != s->height) {
776 for(i=0;i<MAX_COMPONENTS;i++)
777 av_freep(&s->current_picture[i]);
780 /* test interlaced mode */
781 if (s->first_picture &&
782 s->org_height != 0 &&
783 s->height < ((s->org_height * 3) / 4)) {
788 for(i=0;i<nb_components;i++) {
790 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
791 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
792 w = w * 8 * s->h_count[i];
793 h = h * 8 * s->v_count[i];
797 /* memory test is done in mjpeg_decode_sos() */
798 s->current_picture[i] = av_mallocz(w * h);
800 s->first_picture = 0;
803 if (len != (8+(3*nb_components)))
805 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
811 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
815 code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
818 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
819 &s->vlcs[0][dc_index]);
825 diff = get_bits(&s->gb, code);
826 if ((diff & (1 << (code - 1))) == 0)
827 diff = (-1 << code) | (diff + 1);
832 /* decode block and dequantize */
833 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
834 int component, int dc_index, int ac_index, int quant_index)
836 int nbits, code, i, j, level;
842 val = mjpeg_decode_dc(s, dc_index);
844 dprintf("error dc\n");
847 quant_matrix = s->quant_matrixes[quant_index];
848 val = val * quant_matrix[0] + s->last_dc[component];
849 s->last_dc[component] = val;
852 ac_vlc = &s->vlcs[1][ac_index];
855 code = get_vlc(&s->gb, ac_vlc);
857 dprintf("error ac\n");
868 level = get_bits(&s->gb, nbits);
869 if ((level & (1 << (nbits - 1))) == 0)
870 level = (-1 << nbits) | (level + 1);
873 dprintf("error count: %d\n", i);
876 j = zigzag_direct[i];
877 block[j] = level * quant_matrix[j];
886 static int mjpeg_decode_sos(MJpegDecodeContext *s,
887 UINT8 *buf, int buf_size)
889 int len, nb_components, i, j, n, h, v, ret;
890 int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
898 init_get_bits(&s->gb, buf, buf_size);
899 /* XXX: verify len field validity */
900 len = get_bits(&s->gb, 16);
901 nb_components = get_bits(&s->gb, 8);
902 /* XXX: only interleaved scan accepted */
903 if (nb_components != 3)
905 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
910 for(i=0;i<nb_components;i++) {
911 id = get_bits(&s->gb, 8) - 1;
912 dprintf("component: %d\n", id);
913 /* find component index */
914 for(index=0;index<s->nb_components;index++)
915 if (id == s->component_id[index])
917 if (index == s->nb_components)
919 dprintf("decode_sos: index(%d) out of components\n", index);
923 comp_index[i] = index;
924 nb_blocks[i] = s->h_count[index] * s->v_count[index];
925 h_count[i] = s->h_count[index];
926 v_count[i] = s->v_count[index];
928 dc_index[i] = get_bits(&s->gb, 4);
929 ac_index[i] = get_bits(&s->gb, 4);
931 if (dc_index[i] < 0 || ac_index[i] < 0 ||
932 dc_index[i] >= 4 || ac_index[i] >= 4)
934 switch(s->start_code)
937 if (dc_index[i] > 1 || ac_index[i] > 1)
942 if (dc_index[i] > 3 || ac_index[i] > 3)
946 if (dc_index[i] > 3 || ac_index[i] != 0)
951 skip_bits(&s->gb, 8); /* Ss */
952 skip_bits(&s->gb, 8); /* Se */
953 skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
955 for(i=0;i<nb_components;i++)
956 s->last_dc[i] = 1024;
958 if (nb_components > 1) {
959 /* interleaved stream */
960 mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
961 mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
963 h = s->h_max / s->h_count[comp_index[0]];
964 v = s->v_max / s->v_count[comp_index[0]];
965 mb_width = (s->width + h * 8 - 1) / (h * 8);
966 mb_height = (s->height + v * 8 - 1) / (v * 8);
972 for(mb_y = 0; mb_y < mb_height; mb_y++) {
973 for(mb_x = 0; mb_x < mb_width; mb_x++) {
974 for(i=0;i<nb_components;i++) {
983 if (s->restart_interval && !s->restart_count)
984 s->restart_count = s->restart_interval;
986 memset(s->block, 0, sizeof(s->block));
987 if (decode_block(s, s->block, i,
988 dc_index[i], ac_index[i],
989 s->quant_index[c]) < 0) {
990 dprintf("error y=%d x=%d\n", mb_y, mb_x);
994 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
995 ptr = s->current_picture[c] +
996 (s->linesize[c] * (v * mb_y + y) * 8) +
998 if (s->interlaced && s->bottom_field)
999 ptr += s->linesize[c] >> 1;
1000 ff_idct_put(ptr, s->linesize[c], s->block);
1014 dprintf("decode_sos: ac/dc index out of range\n");
1018 static int mjpeg_decode_dri(MJpegDecodeContext *s,
1019 UINT8 *buf, int buf_size)
1021 init_get_bits(&s->gb, buf, buf_size);
1023 if (get_bits(&s->gb, 16) != 4)
1025 s->restart_interval = get_bits(&s->gb, 16);
1026 dprintf("restart interval: %d\n", s->restart_interval);
1031 #define FOURCC(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d)
1032 static int mjpeg_decode_app(MJpegDecodeContext *s,
1033 UINT8 *buf, int buf_size, int start_code)
1037 init_get_bits(&s->gb, buf, buf_size);
1039 /* XXX: verify len field validity */
1040 len = get_bits(&s->gb, 16);
1044 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1047 /* buggy AVID, it puts EOI only at every 10th frame */
1048 /* also this fourcc is used by non-avid files too, it means
1049 interleaving, but it's always present in AVID files */
1050 if (id == FOURCC('A','V','I','1'))
1057 4bytes field_size_less_padding
1060 if (s->first_picture)
1061 printf("mjpeg: workarounding buggy AVID\n");
1062 s->interleaved_rows = get_bits(&s->gb, 8);
1064 skip_bits(&s->gb, 8);
1065 skip_bits(&s->gb, 32);
1066 skip_bits(&s->gb, 32);
1069 if (s->interleaved_rows)
1070 printf("mjpeg: interleaved rows: %d\n", s->interleaved_rows);
1076 if (id == FOURCC('J','F','I','F'))
1078 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1079 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1080 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1085 if ((start_code == APP1) && (len > (0x28 - 8)))
1087 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1089 if (id == FOURCC('m','j','p','g')) /* Apple MJPEG-A */
1092 skip_bits(&s->gb, 32); /* field size */
1093 skip_bits(&s->gb, 32); /* pad field size */
1094 skip_bits(&s->gb, 32); /* next off */
1095 skip_bits(&s->gb, 32); /* quant off */
1096 skip_bits(&s->gb, 32); /* huff off */
1097 skip_bits(&s->gb, 32); /* image off */
1098 skip_bits(&s->gb, 32); /* scan off */
1099 skip_bits(&s->gb, 32); /* data off */
1101 if (s->first_picture)
1102 printf("mjpeg: Apple MJPEG-A header found\n");
1107 /* should check for further values.. */
1108 SKIP_REMAINING(&s->gb, len);
1114 static int mjpeg_decode_com(MJpegDecodeContext *s,
1115 UINT8 *buf, int buf_size)
1120 init_get_bits(&s->gb, buf, buf_size);
1122 /* XXX: verify len field validity */
1123 len = get_bits(&s->gb, 16)-2;
1124 cbuf = av_malloc(len+1);
1126 for (i = 0; i < len; i++)
1127 cbuf[i] = get_bits(&s->gb, 8);
1128 if (cbuf[i-1] == '\n')
1133 printf("mjpeg comment: '%s'\n", cbuf);
1135 /* buggy avid, it puts EOI only at every 10th frame */
1136 if (!strcmp(cbuf, "AVID"))
1139 if (s->first_picture)
1140 printf("mjpeg: workarounding buggy AVID\n");
1148 /* return the 8 bit start code value and update the search
1149 state. Return -1 if no start code found */
1150 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end,
1151 UINT32 *header_state)
1154 unsigned int state, v;
1157 state = *header_state;
1158 buf_ptr = *pbuf_ptr;
1162 if (buf_ptr < buf_end) {
1169 while (buf_ptr < buf_end) {
1178 *pbuf_ptr = buf_ptr;
1179 *header_state = state;
1183 static int mjpeg_decode_frame(AVCodecContext *avctx,
1184 void *data, int *data_size,
1185 UINT8 *buf, int buf_size)
1187 MJpegDecodeContext *s = avctx->priv_data;
1188 UINT8 *buf_end, *buf_ptr, *buf_start;
1189 int len, code, input_size, i;
1190 AVPicture *picture = data;
1191 unsigned int start_code;
1195 /* no supplementary picture */
1200 buf_end = buf + buf_size;
1201 while (buf_ptr < buf_end) {
1202 buf_start = buf_ptr;
1203 /* find start next marker */
1204 code = find_marker(&buf_ptr, buf_end, &s->header_state);
1205 /* copy to buffer */
1206 len = buf_ptr - buf_start;
1207 if (len + (s->buf_ptr - s->buffer) > s->buffer_size) {
1208 /* data too big : flush */
1209 s->buf_ptr = s->buffer;
1211 s->start_code = code;
1213 memcpy(s->buf_ptr, buf_start, len);
1216 /* nothing to do: wait next marker */
1217 } else if (code == 0 || code == 0xff) {
1218 /* if we got FF 00, we copy FF to the stream to unescape FF 00 */
1219 /* valid marker code is between 00 and ff - alex */
1222 /* prepare data for next start code */
1223 input_size = s->buf_ptr - s->buffer;
1224 start_code = s->start_code;
1225 s->buf_ptr = s->buffer;
1226 s->start_code = code;
1227 dprintf("marker=%x\n", start_code);
1228 switch(start_code) {
1230 s->restart_interval = 0;
1231 /* nothing to do on SOI */
1234 mjpeg_decode_dqt(s, s->buffer, input_size);
1237 mjpeg_decode_dht(s, s->buffer, input_size);
1240 mjpeg_decode_sof0(s, s->buffer, input_size);
1243 mjpeg_decode_sos(s, s->buffer, input_size);
1244 if (s->start_code == EOI || s->buggy_avid || s->restart_interval) {
1246 if (s->interlaced) {
1247 s->bottom_field ^= 1;
1248 /* if not bottom field, do not output image yet */
1249 if (s->bottom_field)
1253 picture->data[i] = s->current_picture[i];
1257 picture->linesize[i] = l;
1259 *data_size = sizeof(AVPicture);
1260 avctx->height = s->height;
1263 avctx->width = s->width;
1264 /* XXX: not complete test ! */
1265 switch((s->h_count[0] << 4) | s->v_count[0]) {
1267 avctx->pix_fmt = PIX_FMT_YUV444P;
1270 avctx->pix_fmt = PIX_FMT_YUV422P;
1274 avctx->pix_fmt = PIX_FMT_YUV420P;
1278 /* XXX: infer it with matrix */
1284 mjpeg_decode_dri(s, s->buffer, input_size);
1299 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1303 if (start_code >= 0xd0 && start_code <= 0xd7) {
1304 dprintf("restart marker: %d\n", start_code&0x0f);
1305 } else if (s->first_picture) {
1307 if (start_code >= 0xe0 && start_code <= 0xef)
1308 mjpeg_decode_app(s, s->buffer, input_size, start_code);
1310 else if (start_code == COM)
1311 mjpeg_decode_com(s, s->buffer, input_size);
1319 return buf_ptr - buf;
1322 static int mjpeg_decode_end(AVCodecContext *avctx)
1324 MJpegDecodeContext *s = avctx->priv_data;
1327 for(i=0;i<MAX_COMPONENTS;i++)
1328 av_free(s->current_picture[i]);
1331 free_vlc(&s->vlcs[i][j]);
1336 AVCodec mjpeg_decoder = {
1340 sizeof(MJpegDecodeContext),