3a5459f25a8af5769be527d03f04113de37036e7
[libav.git] / libavcodec / mjpeg.c
1 /*
2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 *
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.
9 *
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.
14 *
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
18 *
19 * Support for external huffman table, various fixes (AVID workaround),
20 * aspecting and new decode_frame mechanism
21 * by Alex Beregszaszi <alex@naxine.org>
22 */
23 //#define DEBUG
24 #include "avcodec.h"
25 #include "dsputil.h"
26 #include "mpegvideo.h"
27
28 /* use two quantizer tables (one for luminance and one for chrominance) */
29 /* not yet working */
30 #undef TWOMATRIXES
31
32 typedef struct MJpegContext {
33 UINT8 huff_size_dc_luminance[12];
34 UINT16 huff_code_dc_luminance[12];
35 UINT8 huff_size_dc_chrominance[12];
36 UINT16 huff_code_dc_chrominance[12];
37
38 UINT8 huff_size_ac_luminance[256];
39 UINT16 huff_code_ac_luminance[256];
40 UINT8 huff_size_ac_chrominance[256];
41 UINT16 huff_code_ac_chrominance[256];
42 } MJpegContext;
43
44 /* JPEG marker codes */
45 typedef enum {
46 /* start of frame */
47 SOF0 = 0xc0, /* baseline */
48 SOF1 = 0xc1, /* extended sequential, huffman */
49 SOF2 = 0xc2, /* progressive, huffman */
50 SOF3 = 0xc3, /* lossless, huffman */
51
52 SOF5 = 0xc5, /* differential sequential, huffman */
53 SOF6 = 0xc6, /* differential progressive, huffman */
54 SOF7 = 0xc7, /* differential lossless, huffman */
55 JPG = 0xc8, /* reserved for JPEG extension */
56 SOF9 = 0xc9, /* extended sequential, arithmetic */
57 SOF10 = 0xca, /* progressive, arithmetic */
58 SOF11 = 0xcb, /* lossless, arithmetic */
59
60 SOF13 = 0xcd, /* differential sequential, arithmetic */
61 SOF14 = 0xce, /* differential progressive, arithmetic */
62 SOF15 = 0xcf, /* differential lossless, arithmetic */
63
64 DHT = 0xc4, /* define huffman tables */
65
66 DAC = 0xcc, /* define arithmetic-coding conditioning */
67
68 /* restart with modulo 8 count "m" */
69 RST0 = 0xd0,
70 RST1 = 0xd1,
71 RST2 = 0xd2,
72 RST3 = 0xd3,
73 RST4 = 0xd4,
74 RST5 = 0xd5,
75 RST6 = 0xd6,
76 RST7 = 0xd7,
77
78 SOI = 0xd8, /* start of image */
79 EOI = 0xd9, /* end of image */
80 SOS = 0xda, /* start of scan */
81 DQT = 0xdb, /* define quantization tables */
82 DNL = 0xdc, /* define number of lines */
83 DRI = 0xdd, /* define restart interval */
84 DHP = 0xde, /* define hierarchical progression */
85 EXP = 0xdf, /* expand reference components */
86
87 APP0 = 0xe0,
88 APP1 = 0xe1,
89 APP2 = 0xe2,
90 APP3 = 0xe3,
91 APP4 = 0xe4,
92 APP5 = 0xe5,
93 APP6 = 0xe6,
94 APP7 = 0xe7,
95 APP8 = 0xe8,
96 APP9 = 0xe9,
97 APP10 = 0xea,
98 APP11 = 0xeb,
99 APP12 = 0xec,
100 APP13 = 0xed,
101 APP14 = 0xee,
102 APP15 = 0xef,
103
104 JPG0 = 0xf0,
105 JPG1 = 0xf1,
106 JPG2 = 0xf2,
107 JPG3 = 0xf3,
108 JPG4 = 0xf4,
109 JPG5 = 0xf5,
110 JPG6 = 0xf6,
111 JPG7 = 0xf7,
112 JPG8 = 0xf8,
113 JPG9 = 0xf9,
114 JPG10 = 0xfa,
115 JPG11 = 0xfb,
116 JPG12 = 0xfc,
117 JPG13 = 0xfd,
118
119 COM = 0xfe, /* comment */
120
121 TEM = 0x01, /* temporary private use for arithmetic coding */
122
123 /* 0x02 -> 0xbf reserved */
124 } JPEG_MARKER;
125
126 #if 0
127 /* These are the sample quantization tables given in JPEG spec section K.1.
128 * The spec says that the values given produce "good" quality, and
129 * when divided by 2, "very good" quality.
130 */
131 static const unsigned char std_luminance_quant_tbl[64] = {
132 16, 11, 10, 16, 24, 40, 51, 61,
133 12, 12, 14, 19, 26, 58, 60, 55,
134 14, 13, 16, 24, 40, 57, 69, 56,
135 14, 17, 22, 29, 51, 87, 80, 62,
136 18, 22, 37, 56, 68, 109, 103, 77,
137 24, 35, 55, 64, 81, 104, 113, 92,
138 49, 64, 78, 87, 103, 121, 120, 101,
139 72, 92, 95, 98, 112, 100, 103, 99
140 };
141 static const unsigned char std_chrominance_quant_tbl[64] = {
142 17, 18, 24, 47, 99, 99, 99, 99,
143 18, 21, 26, 66, 99, 99, 99, 99,
144 24, 26, 56, 99, 99, 99, 99, 99,
145 47, 66, 99, 99, 99, 99, 99, 99,
146 99, 99, 99, 99, 99, 99, 99, 99,
147 99, 99, 99, 99, 99, 99, 99, 99,
148 99, 99, 99, 99, 99, 99, 99, 99,
149 99, 99, 99, 99, 99, 99, 99, 99
150 };
151 #endif
152
153 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
154 /* IMPORTANT: these are only valid for 8-bit data precision! */
155 static const UINT8 bits_dc_luminance[17] =
156 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
157 static const UINT8 val_dc_luminance[] =
158 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
159
160 static const UINT8 bits_dc_chrominance[17] =
161 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
162 static const UINT8 val_dc_chrominance[] =
163 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
164
165 static const UINT8 bits_ac_luminance[17] =
166 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
167 static const UINT8 val_ac_luminance[] =
168 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
169 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
170 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
171 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
172 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
173 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
174 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
175 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
176 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
177 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
178 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
179 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
180 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
181 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
182 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
183 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
184 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
185 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
186 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
187 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
188 0xf9, 0xfa
189 };
190
191 static const UINT8 bits_ac_chrominance[17] =
192 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
193
194 static const UINT8 val_ac_chrominance[] =
195 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
196 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
197 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
198 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
199 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
200 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
201 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
202 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
203 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
204 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
205 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
206 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
207 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
208 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
209 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
210 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
211 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
212 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
213 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
214 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
215 0xf9, 0xfa
216 };
217
218 /* isn't this function nicer than the one in the libjpeg ? */
219 static void build_huffman_codes(UINT8 *huff_size, UINT16 *huff_code,
220 const UINT8 *bits_table, const UINT8 *val_table)
221 {
222 int i, j, k,nb, code, sym;
223
224 code = 0;
225 k = 0;
226 for(i=1;i<=16;i++) {
227 nb = bits_table[i];
228 for(j=0;j<nb;j++) {
229 sym = val_table[k++];
230 huff_size[sym] = i;
231 huff_code[sym] = code;
232 code++;
233 }
234 code <<= 1;
235 }
236 }
237
238 int mjpeg_init(MpegEncContext *s)
239 {
240 MJpegContext *m;
241
242 m = av_malloc(sizeof(MJpegContext));
243 if (!m)
244 return -1;
245
246 s->min_qcoeff=-1023;
247 s->max_qcoeff= 1023;
248 s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
249
250 /* build all the huffman tables */
251 build_huffman_codes(m->huff_size_dc_luminance,
252 m->huff_code_dc_luminance,
253 bits_dc_luminance,
254 val_dc_luminance);
255 build_huffman_codes(m->huff_size_dc_chrominance,
256 m->huff_code_dc_chrominance,
257 bits_dc_chrominance,
258 val_dc_chrominance);
259 build_huffman_codes(m->huff_size_ac_luminance,
260 m->huff_code_ac_luminance,
261 bits_ac_luminance,
262 val_ac_luminance);
263 build_huffman_codes(m->huff_size_ac_chrominance,
264 m->huff_code_ac_chrominance,
265 bits_ac_chrominance,
266 val_ac_chrominance);
267
268 s->mjpeg_ctx = m;
269 return 0;
270 }
271
272 void mjpeg_close(MpegEncContext *s)
273 {
274 av_free(s->mjpeg_ctx);
275 }
276
277 static inline void put_marker(PutBitContext *p, int code)
278 {
279 put_bits(p, 8, 0xff);
280 put_bits(p, 8, code);
281 }
282
283 /* table_class: 0 = DC coef, 1 = AC coefs */
284 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
285 const UINT8 *bits_table, const UINT8 *value_table)
286 {
287 PutBitContext *p = &s->pb;
288 int n, i;
289
290 put_bits(p, 4, table_class);
291 put_bits(p, 4, table_id);
292
293 n = 0;
294 for(i=1;i<=16;i++) {
295 n += bits_table[i];
296 put_bits(p, 8, bits_table[i]);
297 }
298
299 for(i=0;i<n;i++)
300 put_bits(p, 8, value_table[i]);
301
302 return n + 17;
303 }
304
305 static void jpeg_table_header(MpegEncContext *s)
306 {
307 PutBitContext *p = &s->pb;
308 int i, j, size;
309 UINT8 *ptr;
310
311 /* quant matrixes */
312 put_marker(p, DQT);
313 #ifdef TWOMATRIXES
314 put_bits(p, 16, 2 + 2 * (1 + 64));
315 #else
316 put_bits(p, 16, 2 + 1 * (1 + 64));
317 #endif
318 put_bits(p, 4, 0); /* 8 bit precision */
319 put_bits(p, 4, 0); /* table 0 */
320 for(i=0;i<64;i++) {
321 j = s->intra_scantable.permutated[i];
322 put_bits(p, 8, s->intra_matrix[j]);
323 }
324 #ifdef TWOMATRIXES
325 put_bits(p, 4, 0); /* 8 bit precision */
326 put_bits(p, 4, 1); /* table 1 */
327 for(i=0;i<64;i++) {
328 j = s->intra_scantable.permutated[i];
329 put_bits(p, 8, s->chroma_intra_matrix[j]);
330 }
331 #endif
332
333 /* huffman table */
334 put_marker(p, DHT);
335 flush_put_bits(p);
336 ptr = pbBufPtr(p);
337 put_bits(p, 16, 0); /* patched later */
338 size = 2;
339 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
340 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
341
342 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
343 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
344 ptr[0] = size >> 8;
345 ptr[1] = size;
346 }
347
348 static void jpeg_put_comments(MpegEncContext *s)
349 {
350 PutBitContext *p = &s->pb;
351 int size;
352 UINT8 *ptr;
353
354 if (s->aspect_ratio_info)
355 {
356 /* JFIF header */
357 put_marker(p, APP0);
358 put_bits(p, 16, 16);
359 put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
360 put_bits(p, 16, 0x0201); /* v 1.02 */
361 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
362 switch(s->aspect_ratio_info)
363 {
364 case FF_ASPECT_4_3_625:
365 case FF_ASPECT_4_3_525:
366 put_bits(p, 16, 4);
367 put_bits(p, 16, 3);
368 break;
369 case FF_ASPECT_16_9_625:
370 case FF_ASPECT_16_9_525:
371 put_bits(p, 16, 16);
372 put_bits(p, 16, 9);
373 break;
374 case FF_ASPECT_EXTENDED:
375 put_bits(p, 16, s->aspected_width);
376 put_bits(p, 16, s->aspected_height);
377 break;
378 case FF_ASPECT_SQUARE:
379 default:
380 put_bits(p, 16, 1); /* aspect: 1:1 */
381 put_bits(p, 16, 1);
382 break;
383 }
384 put_bits(p, 8, 0); /* thumbnail width */
385 put_bits(p, 8, 0); /* thumbnail height */
386 }
387
388 /* comment */
389 if(!ff_bit_exact){
390 put_marker(p, COM);
391 flush_put_bits(p);
392 ptr = pbBufPtr(p);
393 put_bits(p, 16, 0); /* patched later */
394 #define MJPEG_VERSION "FFmpeg" LIBAVCODEC_VERSION "b" LIBAVCODEC_BUILD_STR
395 put_string(p, MJPEG_VERSION);
396 size = strlen(MJPEG_VERSION)+3;
397 #undef MJPEG_VERSION
398 ptr[0] = size >> 8;
399 ptr[1] = size;
400 }
401 }
402
403 void mjpeg_picture_header(MpegEncContext *s)
404 {
405 put_marker(&s->pb, SOI);
406
407 if (!s->mjpeg_data_only_frames)
408 {
409 jpeg_put_comments(s);
410
411 if (s->mjpeg_write_tables) jpeg_table_header(s);
412
413 put_marker(&s->pb, SOF0);
414
415 put_bits(&s->pb, 16, 17);
416 put_bits(&s->pb, 8, 8); /* 8 bits/component */
417 put_bits(&s->pb, 16, s->height);
418 put_bits(&s->pb, 16, s->width);
419 put_bits(&s->pb, 8, 3); /* 3 components */
420
421 /* Y component */
422 put_bits(&s->pb, 8, 1); /* component number */
423 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
424 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
425 put_bits(&s->pb, 8, 0); /* select matrix */
426
427 /* Cb component */
428 put_bits(&s->pb, 8, 2); /* component number */
429 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
430 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
431 #ifdef TWOMATRIXES
432 put_bits(&s->pb, 8, 1); /* select matrix */
433 #else
434 put_bits(&s->pb, 8, 0); /* select matrix */
435 #endif
436
437 /* Cr component */
438 put_bits(&s->pb, 8, 3); /* component number */
439 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
440 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
441 #ifdef TWOMATRIXES
442 put_bits(&s->pb, 8, 1); /* select matrix */
443 #else
444 put_bits(&s->pb, 8, 0); /* select matrix */
445 #endif
446 }
447
448 /* scan header */
449 put_marker(&s->pb, SOS);
450 put_bits(&s->pb, 16, 12); /* length */
451 put_bits(&s->pb, 8, 3); /* 3 components */
452
453 /* Y component */
454 put_bits(&s->pb, 8, 1); /* index */
455 put_bits(&s->pb, 4, 0); /* DC huffman table index */
456 put_bits(&s->pb, 4, 0); /* AC huffman table index */
457
458 /* Cb component */
459 put_bits(&s->pb, 8, 2); /* index */
460 put_bits(&s->pb, 4, 1); /* DC huffman table index */
461 put_bits(&s->pb, 4, 1); /* AC huffman table index */
462
463 /* Cr component */
464 put_bits(&s->pb, 8, 3); /* index */
465 put_bits(&s->pb, 4, 1); /* DC huffman table index */
466 put_bits(&s->pb, 4, 1); /* AC huffman table index */
467
468 put_bits(&s->pb, 8, 0); /* Ss (not used) */
469 put_bits(&s->pb, 8, 63); /* Se (not used) */
470 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
471 }
472
473 static void escape_FF(MpegEncContext *s)
474 {
475 int size= get_bit_count(&s->pb) - s->header_bits;
476 int i, ff_count;
477 uint8_t *buf= s->pb.buf + (s->header_bits>>3);
478 int align= (-(int)(buf))&3;
479
480 assert((size&7) == 0);
481 size >>= 3;
482
483 ff_count=0;
484 for(i=0; i<size && i<align; i++){
485 if(buf[i]==0xFF) ff_count++;
486 }
487 for(; i<size-15; i+=16){
488 int acc, v;
489
490 v= *(uint32_t*)(&buf[i]);
491 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
492 v= *(uint32_t*)(&buf[i+4]);
493 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
494 v= *(uint32_t*)(&buf[i+8]);
495 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
496 v= *(uint32_t*)(&buf[i+12]);
497 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
498
499 acc>>=4;
500 acc+= (acc>>16);
501 acc+= (acc>>8);
502 ff_count+= acc&0xFF;
503 }
504 for(; i<size; i++){
505 if(buf[i]==0xFF) ff_count++;
506 }
507
508 if(ff_count==0) return;
509
510 /* skip put bits */
511 for(i=0; i<ff_count-3; i+=4)
512 put_bits(&s->pb, 32, 0);
513 put_bits(&s->pb, (ff_count-i)*8, 0);
514 flush_put_bits(&s->pb);
515
516 for(i=size-1; ff_count; i--){
517 int v= buf[i];
518
519 if(v==0xFF){
520 //printf("%d %d\n", i, ff_count);
521 buf[i+ff_count]= 0;
522 ff_count--;
523 }
524
525 buf[i+ff_count]= v;
526 }
527 }
528
529 void mjpeg_picture_trailer(MpegEncContext *s)
530 {
531 int pad= (-get_bit_count(&s->pb))&7;
532
533 put_bits(&s->pb, pad,0xFF>>(8-pad));
534 flush_put_bits(&s->pb);
535
536 escape_FF(s);
537
538 put_marker(&s->pb, EOI);
539 }
540
541 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
542 UINT8 *huff_size, UINT16 *huff_code)
543 {
544 int mant, nbits;
545
546 if (val == 0) {
547 put_bits(&s->pb, huff_size[0], huff_code[0]);
548 } else {
549 mant = val;
550 if (val < 0) {
551 val = -val;
552 mant--;
553 }
554
555 /* compute the log (XXX: optimize) */
556 nbits = 0;
557 while (val != 0) {
558 val = val >> 1;
559 nbits++;
560 }
561
562 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
563
564 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
565 }
566 }
567
568 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
569 {
570 int mant, nbits, code, i, j;
571 int component, dc, run, last_index, val;
572 MJpegContext *m = s->mjpeg_ctx;
573 UINT8 *huff_size_ac;
574 UINT16 *huff_code_ac;
575
576 /* DC coef */
577 component = (n <= 3 ? 0 : n - 4 + 1);
578 dc = block[0]; /* overflow is impossible */
579 val = dc - s->last_dc[component];
580 if (n < 4) {
581 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
582 huff_size_ac = m->huff_size_ac_luminance;
583 huff_code_ac = m->huff_code_ac_luminance;
584 } else {
585 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
586 huff_size_ac = m->huff_size_ac_chrominance;
587 huff_code_ac = m->huff_code_ac_chrominance;
588 }
589 s->last_dc[component] = dc;
590
591 /* AC coefs */
592
593 run = 0;
594 last_index = s->block_last_index[n];
595 for(i=1;i<=last_index;i++) {
596 j = s->intra_scantable.permutated[i];
597 val = block[j];
598 if (val == 0) {
599 run++;
600 } else {
601 while (run >= 16) {
602 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
603 run -= 16;
604 }
605 mant = val;
606 if (val < 0) {
607 val = -val;
608 mant--;
609 }
610
611 /* compute the log (XXX: optimize) */
612 nbits = 0;
613 while (val != 0) {
614 val = val >> 1;
615 nbits++;
616 }
617 code = (run << 4) | nbits;
618
619 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
620
621 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
622 run = 0;
623 }
624 }
625
626 /* output EOB only if not already 64 values */
627 if (last_index < 63 || run != 0)
628 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
629 }
630
631 void mjpeg_encode_mb(MpegEncContext *s,
632 DCTELEM block[6][64])
633 {
634 int i;
635 for(i=0;i<6;i++) {
636 encode_block(s, block[i], i);
637 }
638 }
639
640 /******************************************/
641 /* decoding */
642
643 #define MAX_COMPONENTS 4
644
645 typedef struct MJpegDecodeContext {
646 AVCodecContext *avctx;
647 GetBitContext gb;
648 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
649
650 int start_code; /* current start code */
651 int buffer_size;
652 UINT8 *buffer;
653
654 INT16 quant_matrixes[4][64];
655 VLC vlcs[2][4];
656
657 int org_width, org_height; /* size given at codec init */
658 int first_picture; /* true if decoding first picture */
659 int interlaced; /* true if interlaced */
660 int bottom_field; /* true if bottom field */
661
662 int width, height;
663 int nb_components;
664 int component_id[MAX_COMPONENTS];
665 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
666 int v_count[MAX_COMPONENTS];
667 int h_max, v_max; /* maximum h and v counts */
668 int quant_index[4]; /* quant table index for each component */
669 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
670 UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
671 int linesize[MAX_COMPONENTS];
672 DCTELEM block[64] __align8;
673 ScanTable scantable;
674 void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
675
676 int restart_interval;
677 int restart_count;
678
679 int buggy_avid;
680 int interlace_polarity;
681 } MJpegDecodeContext;
682
683 static int mjpeg_decode_dht(MJpegDecodeContext *s);
684
685 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
686 int nb_codes)
687 {
688 UINT8 huff_size[256];
689 UINT16 huff_code[256];
690
691 memset(huff_size, 0, sizeof(huff_size));
692 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
693
694 init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
695 }
696
697 static int mjpeg_decode_init(AVCodecContext *avctx)
698 {
699 MJpegDecodeContext *s = avctx->priv_data;
700 MpegEncContext s2;
701
702 s->avctx = avctx;
703
704 /* ugly way to get the idct & scantable */
705 memset(&s2, 0, sizeof(MpegEncContext));
706 s2.flags= avctx->flags;
707 s2.avctx= avctx;
708 // s2->out_format = FMT_MJPEG;
709 s2.width = 8;
710 s2.height = 8;
711 if (MPV_common_init(&s2) < 0)
712 return -1;
713 s->scantable= s2.intra_scantable;
714 s->idct_put= s2.idct_put;
715 MPV_common_end(&s2);
716
717 s->mpeg_enc_ctx_allocated = 0;
718 s->buffer_size = 102400; /* smaller buffer should be enough,
719 but photojpg files could ahive bigger sizes */
720 s->buffer = av_malloc(s->buffer_size);
721 s->start_code = -1;
722 s->first_picture = 1;
723 s->org_width = avctx->width;
724 s->org_height = avctx->height;
725
726 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
727 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
728 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
729 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
730
731 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
732 {
733 printf("mjpeg: using external huffman table\n");
734 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
735 mjpeg_decode_dht(s);
736 /* should check for error - but dunno */
737 }
738
739 return 0;
740 }
741
742 /* quantize tables */
743 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
744 {
745 int len, index, i, j;
746
747 len = get_bits(&s->gb, 16) - 2;
748
749 while (len >= 65) {
750 /* only 8 bit precision handled */
751 if (get_bits(&s->gb, 4) != 0)
752 {
753 dprintf("dqt: 16bit precision\n");
754 return -1;
755 }
756 index = get_bits(&s->gb, 4);
757 if (index >= 4)
758 return -1;
759 dprintf("index=%d\n", index);
760 /* read quant table */
761 for(i=0;i<64;i++) {
762 j = s->scantable.permutated[i];
763 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
764 }
765 len -= 65;
766 }
767
768 return 0;
769 }
770
771 /* decode huffman tables and build VLC decoders */
772 static int mjpeg_decode_dht(MJpegDecodeContext *s)
773 {
774 int len, index, i, class, n, v, code_max;
775 UINT8 bits_table[17];
776 UINT8 val_table[256];
777
778 len = get_bits(&s->gb, 16) - 2;
779
780 while (len > 0) {
781 if (len < 17)
782 return -1;
783 class = get_bits(&s->gb, 4);
784 if (class >= 2)
785 return -1;
786 index = get_bits(&s->gb, 4);
787 if (index >= 4)
788 return -1;
789 n = 0;
790 for(i=1;i<=16;i++) {
791 bits_table[i] = get_bits(&s->gb, 8);
792 n += bits_table[i];
793 }
794 len -= 17;
795 if (len < n || n > 256)
796 return -1;
797
798 code_max = 0;
799 for(i=0;i<n;i++) {
800 v = get_bits(&s->gb, 8);
801 if (v > code_max)
802 code_max = v;
803 val_table[i] = v;
804 }
805 len -= n;
806
807 /* build VLC and flush previous vlc if present */
808 free_vlc(&s->vlcs[class][index]);
809 dprintf("class=%d index=%d nb_codes=%d\n",
810 class, index, code_max + 1);
811 build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
812 }
813 return 0;
814 }
815
816 static int mjpeg_decode_sof0(MJpegDecodeContext *s)
817 {
818 int len, nb_components, i, width, height;
819
820 /* XXX: verify len field validity */
821 len = get_bits(&s->gb, 16);
822 /* only 8 bits/component accepted */
823 if (get_bits(&s->gb, 8) != 8)
824 return -1;
825 height = get_bits(&s->gb, 16);
826 width = get_bits(&s->gb, 16);
827 dprintf("sof0: picture: %dx%d\n", width, height);
828
829 nb_components = get_bits(&s->gb, 8);
830 if (nb_components <= 0 ||
831 nb_components > MAX_COMPONENTS)
832 return -1;
833 s->nb_components = nb_components;
834 s->h_max = 1;
835 s->v_max = 1;
836 for(i=0;i<nb_components;i++) {
837 /* component id */
838 s->component_id[i] = get_bits(&s->gb, 8) - 1;
839 s->h_count[i] = get_bits(&s->gb, 4);
840 s->v_count[i] = get_bits(&s->gb, 4);
841 /* compute hmax and vmax (only used in interleaved case) */
842 if (s->h_count[i] > s->h_max)
843 s->h_max = s->h_count[i];
844 if (s->v_count[i] > s->v_max)
845 s->v_max = s->v_count[i];
846 s->quant_index[i] = get_bits(&s->gb, 8);
847 if (s->quant_index[i] >= 4)
848 return -1;
849 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
850 s->v_count[i], s->component_id[i], s->quant_index[i]);
851 }
852
853 /* if different size, realloc/alloc picture */
854 /* XXX: also check h_count and v_count */
855 if (width != s->width || height != s->height) {
856 for(i=0;i<MAX_COMPONENTS;i++)
857 av_freep(&s->current_picture[i]);
858 s->width = width;
859 s->height = height;
860 /* test interlaced mode */
861 if (s->first_picture &&
862 s->org_height != 0 &&
863 s->height < ((s->org_height * 3) / 4)) {
864 s->interlaced = 1;
865 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
866 s->bottom_field = 0;
867 }
868
869 for(i=0;i<nb_components;i++) {
870 int w, h;
871 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
872 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
873 w = w * 8 * s->h_count[i];
874 h = h * 8 * s->v_count[i];
875 if (s->interlaced)
876 w *= 2;
877 s->linesize[i] = w;
878 /* memory test is done in mjpeg_decode_sos() */
879 s->current_picture[i] = av_mallocz(w * h);
880 }
881 s->first_picture = 0;
882 }
883
884 if (len != (8+(3*nb_components)))
885 {
886 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
887 }
888
889 return 0;
890 }
891
892 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
893 {
894 int code, diff;
895 #if 1
896 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
897 #else
898 code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
899 #endif
900 if (code < 0)
901 {
902 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
903 &s->vlcs[0][dc_index]);
904 return 0xffff;
905 }
906 if (code == 0) {
907 diff = 0;
908 } else {
909 diff = get_bits(&s->gb, code);
910 if ((diff & (1 << (code - 1))) == 0)
911 diff = (-1 << code) | (diff + 1);
912 }
913 return diff;
914 }
915
916 /* decode block and dequantize */
917 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
918 int component, int dc_index, int ac_index, int quant_index)
919 {
920 int nbits, code, i, j, level;
921 int run, val;
922 VLC *ac_vlc;
923 INT16 *quant_matrix;
924
925 /* DC coef */
926 val = mjpeg_decode_dc(s, dc_index);
927 if (val == 0xffff) {
928 dprintf("error dc\n");
929 return -1;
930 }
931 quant_matrix = s->quant_matrixes[quant_index];
932 val = val * quant_matrix[0] + s->last_dc[component];
933 s->last_dc[component] = val;
934 block[0] = val;
935 /* AC coefs */
936 ac_vlc = &s->vlcs[1][ac_index];
937 i = 1;
938 for(;;) {
939 #if 1
940 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
941 #else
942 code = get_vlc(&s->gb, ac_vlc);
943 #endif
944 if (code < 0) {
945 dprintf("error ac\n");
946 return -1;
947 }
948 /* EOB */
949 if (code == 0)
950 break;
951 if (code == 0xf0) {
952 i += 16;
953 } else {
954 run = code >> 4;
955 nbits = code & 0xf;
956 level = get_bits(&s->gb, nbits);
957 if ((level & (1 << (nbits - 1))) == 0)
958 level = (-1 << nbits) | (level + 1);
959 i += run;
960 if (i >= 64) {
961 dprintf("error count: %d\n", i);
962 return -1;
963 }
964 j = s->scantable.permutated[i];
965 block[j] = level * quant_matrix[j];
966 i++;
967 if (i >= 64)
968 break;
969 }
970 }
971 return 0;
972 }
973
974 static int mjpeg_decode_sos(MJpegDecodeContext *s)
975 {
976 int len, nb_components, i, j, n, h, v, ret;
977 int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
978 int comp_index[4];
979 int dc_index[4];
980 int ac_index[4];
981 int nb_blocks[4];
982 int h_count[4];
983 int v_count[4];
984
985 /* XXX: verify len field validity */
986 len = get_bits(&s->gb, 16);
987 nb_components = get_bits(&s->gb, 8);
988 if (len != 6+2*nb_components)
989 {
990 dprintf("decode_sos: invalid len (%d)\n", len);
991 return -1;
992 }
993 /* XXX: only interleaved scan accepted */
994 if (nb_components != 3)
995 {
996 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
997 return -1;
998 }
999 vmax = 0;
1000 hmax = 0;
1001 for(i=0;i<nb_components;i++) {
1002 id = get_bits(&s->gb, 8) - 1;
1003 dprintf("component: %d\n", id);
1004 /* find component index */
1005 for(index=0;index<s->nb_components;index++)
1006 if (id == s->component_id[index])
1007 break;
1008 if (index == s->nb_components)
1009 {
1010 dprintf("decode_sos: index(%d) out of components\n", index);
1011 return -1;
1012 }
1013
1014 comp_index[i] = index;
1015 nb_blocks[i] = s->h_count[index] * s->v_count[index];
1016 h_count[i] = s->h_count[index];
1017 v_count[i] = s->v_count[index];
1018
1019 dc_index[i] = get_bits(&s->gb, 4);
1020 ac_index[i] = get_bits(&s->gb, 4);
1021
1022 if (dc_index[i] < 0 || ac_index[i] < 0 ||
1023 dc_index[i] >= 4 || ac_index[i] >= 4)
1024 goto out_of_range;
1025 switch(s->start_code)
1026 {
1027 case SOF0:
1028 if (dc_index[i] > 1 || ac_index[i] > 1)
1029 goto out_of_range;
1030 break;
1031 case SOF1:
1032 case SOF2:
1033 if (dc_index[i] > 3 || ac_index[i] > 3)
1034 goto out_of_range;
1035 break;
1036 case SOF3:
1037 if (dc_index[i] > 3 || ac_index[i] != 0)
1038 goto out_of_range;
1039 break;
1040 }
1041 }
1042 skip_bits(&s->gb, 8); /* Ss */
1043 skip_bits(&s->gb, 8); /* Se */
1044 skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
1045
1046 for(i=0;i<nb_components;i++)
1047 s->last_dc[i] = 1024;
1048
1049 if (nb_components > 1) {
1050 /* interleaved stream */
1051 mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
1052 mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
1053 } else {
1054 h = s->h_max / s->h_count[comp_index[0]];
1055 v = s->v_max / s->v_count[comp_index[0]];
1056 mb_width = (s->width + h * 8 - 1) / (h * 8);
1057 mb_height = (s->height + v * 8 - 1) / (v * 8);
1058 nb_blocks[0] = 1;
1059 h_count[0] = 1;
1060 v_count[0] = 1;
1061 }
1062
1063 for(mb_y = 0; mb_y < mb_height; mb_y++) {
1064 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1065 for(i=0;i<nb_components;i++) {
1066 UINT8 *ptr;
1067 int x, y, c;
1068 n = nb_blocks[i];
1069 c = comp_index[i];
1070 h = h_count[i];
1071 v = v_count[i];
1072 x = 0;
1073 y = 0;
1074 if (s->restart_interval && !s->restart_count)
1075 s->restart_count = s->restart_interval;
1076 for(j=0;j<n;j++) {
1077 memset(s->block, 0, sizeof(s->block));
1078 if (decode_block(s, s->block, i,
1079 dc_index[i], ac_index[i],
1080 s->quant_index[c]) < 0) {
1081 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1082 ret = -1;
1083 goto the_end;
1084 }
1085 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1086 ptr = s->current_picture[c] +
1087 (s->linesize[c] * (v * mb_y + y) * 8) +
1088 (h * mb_x + x) * 8;
1089 if (s->interlaced && s->bottom_field)
1090 ptr += s->linesize[c] >> 1;
1091 s->idct_put(ptr, s->linesize[c], s->block);
1092 if (++x == h) {
1093 x = 0;
1094 y++;
1095 }
1096 }
1097 }
1098 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1099
1100 if ((s->restart_interval < 1350) && !--s->restart_count) {
1101 align_get_bits(&s->gb);
1102 skip_bits(&s->gb, 16); /* skip RSTn */
1103 for (j=0; j<nb_components; j++) /* reset dc */
1104 s->last_dc[j] = 1024;
1105 }
1106 }
1107 }
1108 ret = 0;
1109 the_end:
1110 emms_c();
1111 return ret;
1112 out_of_range:
1113 dprintf("decode_sos: ac/dc index out of range\n");
1114 return -1;
1115 }
1116
1117 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1118 {
1119 if (get_bits(&s->gb, 16) != 4)
1120 return -1;
1121 s->restart_interval = get_bits(&s->gb, 16);
1122 dprintf("restart interval: %d\n", s->restart_interval);
1123
1124 return 0;
1125 }
1126
1127 static int mjpeg_decode_app(MJpegDecodeContext *s)
1128 {
1129 int len, id;
1130
1131 /* XXX: verify len field validity */
1132 len = get_bits(&s->gb, 16);
1133 if (len < 5)
1134 return -1;
1135
1136 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1137 id = be2me_32(id);
1138 len -= 6;
1139
1140 /* buggy AVID, it puts EOI only at every 10th frame */
1141 /* also this fourcc is used by non-avid files too, it holds some
1142 informations, but it's always present in AVID creates files */
1143 if (id == ff_get_fourcc("AVI1"))
1144 {
1145 /* structure:
1146 4bytes AVI1
1147 1bytes polarity
1148 1bytes always zero
1149 4bytes field_size
1150 4bytes field_size_less_padding
1151 */
1152 s->buggy_avid = 1;
1153 // if (s->first_picture)
1154 // printf("mjpeg: workarounding buggy AVID\n");
1155 s->interlace_polarity = get_bits(&s->gb, 8);
1156 #if 0
1157 skip_bits(&s->gb, 8);
1158 skip_bits(&s->gb, 32);
1159 skip_bits(&s->gb, 32);
1160 len -= 10;
1161 #endif
1162 // if (s->interlace_polarity)
1163 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1164 goto out;
1165 }
1166
1167 // len -= 2;
1168
1169 if (id == ff_get_fourcc("JFIF"))
1170 {
1171 int t_w, t_h;
1172 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1173 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1174 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1175 if (get_bits(&s->gb, 8) == 0)
1176 {
1177 s->avctx->aspect_ratio_info = FF_ASPECT_EXTENDED;
1178 s->avctx->aspected_width = get_bits(&s->gb, 16);
1179 s->avctx->aspected_height = get_bits(&s->gb, 16);
1180 }
1181 else
1182 {
1183 skip_bits(&s->gb, 16);
1184 skip_bits(&s->gb, 16);
1185 }
1186 t_w = get_bits(&s->gb, 8);
1187 t_h = get_bits(&s->gb, 8);
1188 if (t_w && t_h)
1189 {
1190 /* skip thumbnail */
1191 if (len-10-(t_w*t_h*3) > 0)
1192 len -= t_w*t_h*3;
1193 }
1194 len -= 10;
1195 goto out;
1196 }
1197
1198 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1199 {
1200 printf("mjpeg: Adobe header found\n");
1201 skip_bits(&s->gb, 16); /* version */
1202 skip_bits(&s->gb, 16); /* flags0 */
1203 skip_bits(&s->gb, 16); /* flags1 */
1204 skip_bits(&s->gb, 8); /* transform */
1205 len -= 7;
1206 goto out;
1207 }
1208
1209 /* Apple MJPEG-A */
1210 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1211 {
1212 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1213 id = be2me_32(id);
1214 len -= 4;
1215 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1216 {
1217 #if 0
1218 skip_bits(&s->gb, 32); /* field size */
1219 skip_bits(&s->gb, 32); /* pad field size */
1220 skip_bits(&s->gb, 32); /* next off */
1221 skip_bits(&s->gb, 32); /* quant off */
1222 skip_bits(&s->gb, 32); /* huff off */
1223 skip_bits(&s->gb, 32); /* image off */
1224 skip_bits(&s->gb, 32); /* scan off */
1225 skip_bits(&s->gb, 32); /* data off */
1226 #endif
1227 if (s->first_picture)
1228 printf("mjpeg: Apple MJPEG-A header found\n");
1229 }
1230 }
1231
1232 out:
1233 /* slow but needed for extreme adobe jpegs */
1234 if (len < 0)
1235 printf("mjpeg: error, decode_app parser read over the end\n");
1236 while(--len > 0)
1237 skip_bits(&s->gb, 8);
1238
1239 return 0;
1240 }
1241
1242 static int mjpeg_decode_com(MJpegDecodeContext *s)
1243 {
1244 int len, i;
1245 UINT8 *cbuf;
1246
1247 /* XXX: verify len field validity */
1248 len = get_bits(&s->gb, 16)-2;
1249 cbuf = av_malloc(len+1);
1250
1251 for (i = 0; i < len; i++)
1252 cbuf[i] = get_bits(&s->gb, 8);
1253 if (cbuf[i-1] == '\n')
1254 cbuf[i-1] = 0;
1255 else
1256 cbuf[i] = 0;
1257
1258 printf("mjpeg comment: '%s'\n", cbuf);
1259
1260 /* buggy avid, it puts EOI only at every 10th frame */
1261 if (!strcmp(cbuf, "AVID"))
1262 {
1263 s->buggy_avid = 1;
1264 // if (s->first_picture)
1265 // printf("mjpeg: workarounding buggy AVID\n");
1266 }
1267
1268 av_free(cbuf);
1269
1270 return 0;
1271 }
1272
1273 #if 0
1274 static int valid_marker_list[] =
1275 {
1276 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1277 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1278 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1279 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1280 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1281 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1282 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1283 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1284 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1285 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1286 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1287 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1288 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1289 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1290 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1291 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1292 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1293 }
1294 #endif
1295
1296 /* return the 8 bit start code value and update the search
1297 state. Return -1 if no start code found */
1298 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1299 {
1300 UINT8 *buf_ptr;
1301 unsigned int v, v2;
1302 int val;
1303 #ifdef DEBUG
1304 int skipped=0;
1305 #endif
1306
1307 buf_ptr = *pbuf_ptr;
1308 while (buf_ptr < buf_end) {
1309 v = *buf_ptr++;
1310 v2 = *buf_ptr;
1311 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1312 val = *buf_ptr++;
1313 goto found;
1314 }
1315 #ifdef DEBUG
1316 skipped++;
1317 #endif
1318 }
1319 val = -1;
1320 found:
1321 #ifdef DEBUG
1322 dprintf("find_marker skipped %d bytes\n", skipped);
1323 #endif
1324 *pbuf_ptr = buf_ptr;
1325 return val;
1326 }
1327
1328 static int mjpeg_decode_frame(AVCodecContext *avctx,
1329 void *data, int *data_size,
1330 UINT8 *buf, int buf_size)
1331 {
1332 MJpegDecodeContext *s = avctx->priv_data;
1333 UINT8 *buf_end, *buf_ptr;
1334 int i, start_code;
1335 AVPicture *picture = data;
1336
1337 *data_size = 0;
1338
1339 /* no supplementary picture */
1340 if (buf_size == 0)
1341 return 0;
1342
1343 buf_ptr = buf;
1344 buf_end = buf + buf_size;
1345 while (buf_ptr < buf_end) {
1346 /* find start next marker */
1347 start_code = find_marker(&buf_ptr, buf_end);
1348 {
1349 /* EOF */
1350 if (start_code < 0) {
1351 goto the_end;
1352 } else {
1353 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1354
1355 if ((buf_end - buf_ptr) > s->buffer_size)
1356 {
1357 av_free(s->buffer);
1358 s->buffer_size = buf_end-buf_ptr;
1359 s->buffer = av_malloc(s->buffer_size);
1360 dprintf("buffer too small, expanding to %d bytes\n",
1361 s->buffer_size);
1362 }
1363
1364 /* unescape buffer of SOS */
1365 if (start_code == SOS)
1366 {
1367 UINT8 *src = buf_ptr;
1368 UINT8 *dst = s->buffer;
1369
1370 while (src<buf_end)
1371 {
1372 UINT8 x = *(src++);
1373
1374 #if 0
1375 if (x == 0xff && *src == 0xff)
1376 break;
1377 #endif
1378 *(dst++) = x;
1379 if (x == 0xff)
1380 {
1381 while(*src == 0xff) src++;
1382
1383 x = *(src++);
1384 if (x >= 0xd0 && x <= 0xd7)
1385 *(dst++) = x;
1386 else if (x)
1387 break;
1388 }
1389 }
1390 init_get_bits(&s->gb, s->buffer, dst - s->buffer);
1391
1392 dprintf("escaping removed %d bytes\n",
1393 (buf_end - buf_ptr) - (dst - s->buffer));
1394 }
1395 else
1396 init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);
1397
1398 s->start_code = start_code;
1399
1400 /* process markers */
1401 if (start_code >= 0xd0 && start_code <= 0xd7) {
1402 dprintf("restart marker: %d\n", start_code&0x0f);
1403 } else if (s->first_picture) {
1404 /* APP fields */
1405 if (start_code >= 0xe0 && start_code <= 0xef)
1406 mjpeg_decode_app(s);
1407 /* Comment */
1408 else if (start_code == COM)
1409 mjpeg_decode_com(s);
1410 }
1411
1412 switch(start_code) {
1413 case SOI:
1414 s->restart_interval = 0;
1415 /* nothing to do on SOI */
1416 break;
1417 case DQT:
1418 mjpeg_decode_dqt(s);
1419 break;
1420 case DHT:
1421 mjpeg_decode_dht(s);
1422 break;
1423 case SOF0:
1424 mjpeg_decode_sof0(s);
1425 break;
1426 case EOI:
1427 eoi_parser:
1428 {
1429 int l;
1430 if (s->interlaced) {
1431 s->bottom_field ^= 1;
1432 /* if not bottom field, do not output image yet */
1433 if (s->bottom_field)
1434 goto not_the_end;
1435 }
1436 for(i=0;i<3;i++) {
1437 picture->data[i] = s->current_picture[i];
1438 #if 1
1439 l = s->linesize[i];
1440 if (s->interlaced)
1441 l >>= 1;
1442 picture->linesize[i] = l;
1443 #else
1444 picture->linesize[i] = (s->interlaced) ?
1445 s->linesize[i] >> 1 : s->linesize[i];
1446 #endif
1447 }
1448 *data_size = sizeof(AVPicture);
1449 avctx->height = s->height;
1450 if (s->interlaced)
1451 avctx->height *= 2;
1452 avctx->width = s->width;
1453 /* XXX: not complete test ! */
1454 switch((s->h_count[0] << 4) | s->v_count[0]) {
1455 case 0x11:
1456 avctx->pix_fmt = PIX_FMT_YUV444P;
1457 break;
1458 case 0x21:
1459 avctx->pix_fmt = PIX_FMT_YUV422P;
1460 break;
1461 default:
1462 case 0x22:
1463 avctx->pix_fmt = PIX_FMT_YUV420P;
1464 break;
1465 }
1466 /* dummy quality */
1467 /* XXX: infer it with matrix */
1468 avctx->quality = 3;
1469 goto the_end;
1470 }
1471 break;
1472 case SOS:
1473 mjpeg_decode_sos(s);
1474 /* buggy avid puts EOI every 10-20th frame */
1475 /* if restart period is over process EOI */
1476 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1477 goto eoi_parser;
1478 break;
1479 case DRI:
1480 mjpeg_decode_dri(s);
1481 break;
1482 case SOF1:
1483 case SOF2:
1484 case SOF3:
1485 case SOF5:
1486 case SOF6:
1487 case SOF7:
1488 case SOF9:
1489 case SOF10:
1490 case SOF11:
1491 case SOF13:
1492 case SOF14:
1493 case SOF15:
1494 case JPG:
1495 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1496 break;
1497 // default:
1498 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1499 // break;
1500 }
1501
1502 not_the_end:
1503 /* eof process start code */
1504 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1505 dprintf("marker parser used %d bytes (%d bits)\n",
1506 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1507 }
1508 }
1509 }
1510 the_end:
1511
1512 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1513 // return buf_end - buf_ptr;
1514 return buf_ptr - buf;
1515 }
1516
1517 static int mjpeg_decode_end(AVCodecContext *avctx)
1518 {
1519 MJpegDecodeContext *s = avctx->priv_data;
1520 int i, j;
1521
1522 av_free(s->buffer);
1523 for(i=0;i<MAX_COMPONENTS;i++)
1524 av_free(s->current_picture[i]);
1525 for(i=0;i<2;i++) {
1526 for(j=0;j<4;j++)
1527 free_vlc(&s->vlcs[i][j]);
1528 }
1529 return 0;
1530 }
1531
1532 AVCodec mjpeg_decoder = {
1533 "mjpeg",
1534 CODEC_TYPE_VIDEO,
1535 CODEC_ID_MJPEG,
1536 sizeof(MJpegDecodeContext),
1537 mjpeg_decode_init,
1538 NULL,
1539 mjpeg_decode_end,
1540 mjpeg_decode_frame,
1541 0,
1542 NULL
1543 };