cleanup
[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, int start)
474 {
475 int size= get_bit_count(&s->pb) - start*8;
476 int i, ff_count;
477 uint8_t *buf= s->pb.buf + start;
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 assert((s->header_bits&7)==0);
537
538 escape_FF(s, s->header_bits>>3);
539
540 put_marker(&s->pb, EOI);
541 }
542
543 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
544 UINT8 *huff_size, UINT16 *huff_code)
545 {
546 int mant, nbits;
547
548 if (val == 0) {
549 put_bits(&s->pb, huff_size[0], huff_code[0]);
550 } else {
551 mant = val;
552 if (val < 0) {
553 val = -val;
554 mant--;
555 }
556
557 /* compute the log (XXX: optimize) */
558 nbits = 0;
559 while (val != 0) {
560 val = val >> 1;
561 nbits++;
562 }
563
564 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
565
566 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
567 }
568 }
569
570 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
571 {
572 int mant, nbits, code, i, j;
573 int component, dc, run, last_index, val;
574 MJpegContext *m = s->mjpeg_ctx;
575 UINT8 *huff_size_ac;
576 UINT16 *huff_code_ac;
577
578 /* DC coef */
579 component = (n <= 3 ? 0 : n - 4 + 1);
580 dc = block[0]; /* overflow is impossible */
581 val = dc - s->last_dc[component];
582 if (n < 4) {
583 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
584 huff_size_ac = m->huff_size_ac_luminance;
585 huff_code_ac = m->huff_code_ac_luminance;
586 } else {
587 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
588 huff_size_ac = m->huff_size_ac_chrominance;
589 huff_code_ac = m->huff_code_ac_chrominance;
590 }
591 s->last_dc[component] = dc;
592
593 /* AC coefs */
594
595 run = 0;
596 last_index = s->block_last_index[n];
597 for(i=1;i<=last_index;i++) {
598 j = s->intra_scantable.permutated[i];
599 val = block[j];
600 if (val == 0) {
601 run++;
602 } else {
603 while (run >= 16) {
604 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
605 run -= 16;
606 }
607 mant = val;
608 if (val < 0) {
609 val = -val;
610 mant--;
611 }
612
613 /* compute the log (XXX: optimize) */
614 nbits = 0;
615 while (val != 0) {
616 val = val >> 1;
617 nbits++;
618 }
619 code = (run << 4) | nbits;
620
621 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
622
623 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
624 run = 0;
625 }
626 }
627
628 /* output EOB only if not already 64 values */
629 if (last_index < 63 || run != 0)
630 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
631 }
632
633 void mjpeg_encode_mb(MpegEncContext *s,
634 DCTELEM block[6][64])
635 {
636 int i;
637 for(i=0;i<6;i++) {
638 encode_block(s, block[i], i);
639 }
640 }
641
642 /******************************************/
643 /* decoding */
644
645 #define MAX_COMPONENTS 4
646
647 typedef struct MJpegDecodeContext {
648 AVCodecContext *avctx;
649 GetBitContext gb;
650 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
651
652 int start_code; /* current start code */
653 int buffer_size;
654 UINT8 *buffer;
655
656 INT16 quant_matrixes[4][64];
657 VLC vlcs[2][4];
658
659 int org_width, org_height; /* size given at codec init */
660 int first_picture; /* true if decoding first picture */
661 int interlaced; /* true if interlaced */
662 int bottom_field; /* true if bottom field */
663
664 int width, height;
665 int nb_components;
666 int component_id[MAX_COMPONENTS];
667 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
668 int v_count[MAX_COMPONENTS];
669 int h_max, v_max; /* maximum h and v counts */
670 int quant_index[4]; /* quant table index for each component */
671 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
672 UINT8 *current_picture[MAX_COMPONENTS]; /* picture structure */
673 int linesize[MAX_COMPONENTS];
674 DCTELEM block[64] __align8;
675 ScanTable scantable;
676 void (*idct_put)(UINT8 *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
677
678 int restart_interval;
679 int restart_count;
680
681 int buggy_avid;
682 int interlace_polarity;
683 } MJpegDecodeContext;
684
685 static int mjpeg_decode_dht(MJpegDecodeContext *s);
686
687 static void build_vlc(VLC *vlc, const UINT8 *bits_table, const UINT8 *val_table,
688 int nb_codes)
689 {
690 UINT8 huff_size[256];
691 UINT16 huff_code[256];
692
693 memset(huff_size, 0, sizeof(huff_size));
694 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
695
696 init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
697 }
698
699 static int mjpeg_decode_init(AVCodecContext *avctx)
700 {
701 MJpegDecodeContext *s = avctx->priv_data;
702 MpegEncContext s2;
703
704 s->avctx = avctx;
705
706 /* ugly way to get the idct & scantable */
707 memset(&s2, 0, sizeof(MpegEncContext));
708 s2.flags= avctx->flags;
709 s2.avctx= avctx;
710 // s2->out_format = FMT_MJPEG;
711 s2.width = 8;
712 s2.height = 8;
713 if (MPV_common_init(&s2) < 0)
714 return -1;
715 s->scantable= s2.intra_scantable;
716 s->idct_put= s2.idct_put;
717 MPV_common_end(&s2);
718
719 s->mpeg_enc_ctx_allocated = 0;
720 s->buffer_size = 102400; /* smaller buffer should be enough,
721 but photojpg files could ahive bigger sizes */
722 s->buffer = av_malloc(s->buffer_size);
723 s->start_code = -1;
724 s->first_picture = 1;
725 s->org_width = avctx->width;
726 s->org_height = avctx->height;
727
728 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
729 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
730 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
731 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
732
733 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
734 {
735 printf("mjpeg: using external huffman table\n");
736 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
737 mjpeg_decode_dht(s);
738 /* should check for error - but dunno */
739 }
740
741 return 0;
742 }
743
744 /* quantize tables */
745 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
746 {
747 int len, index, i, j;
748
749 len = get_bits(&s->gb, 16) - 2;
750
751 while (len >= 65) {
752 /* only 8 bit precision handled */
753 if (get_bits(&s->gb, 4) != 0)
754 {
755 dprintf("dqt: 16bit precision\n");
756 return -1;
757 }
758 index = get_bits(&s->gb, 4);
759 if (index >= 4)
760 return -1;
761 dprintf("index=%d\n", index);
762 /* read quant table */
763 for(i=0;i<64;i++) {
764 j = s->scantable.permutated[i];
765 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
766 }
767 len -= 65;
768 }
769
770 return 0;
771 }
772
773 /* decode huffman tables and build VLC decoders */
774 static int mjpeg_decode_dht(MJpegDecodeContext *s)
775 {
776 int len, index, i, class, n, v, code_max;
777 UINT8 bits_table[17];
778 UINT8 val_table[256];
779
780 len = get_bits(&s->gb, 16) - 2;
781
782 while (len > 0) {
783 if (len < 17)
784 return -1;
785 class = get_bits(&s->gb, 4);
786 if (class >= 2)
787 return -1;
788 index = get_bits(&s->gb, 4);
789 if (index >= 4)
790 return -1;
791 n = 0;
792 for(i=1;i<=16;i++) {
793 bits_table[i] = get_bits(&s->gb, 8);
794 n += bits_table[i];
795 }
796 len -= 17;
797 if (len < n || n > 256)
798 return -1;
799
800 code_max = 0;
801 for(i=0;i<n;i++) {
802 v = get_bits(&s->gb, 8);
803 if (v > code_max)
804 code_max = v;
805 val_table[i] = v;
806 }
807 len -= n;
808
809 /* build VLC and flush previous vlc if present */
810 free_vlc(&s->vlcs[class][index]);
811 dprintf("class=%d index=%d nb_codes=%d\n",
812 class, index, code_max + 1);
813 build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
814 }
815 return 0;
816 }
817
818 static int mjpeg_decode_sof0(MJpegDecodeContext *s)
819 {
820 int len, nb_components, i, width, height;
821
822 /* XXX: verify len field validity */
823 len = get_bits(&s->gb, 16);
824 /* only 8 bits/component accepted */
825 if (get_bits(&s->gb, 8) != 8)
826 return -1;
827 height = get_bits(&s->gb, 16);
828 width = get_bits(&s->gb, 16);
829 dprintf("sof0: picture: %dx%d\n", width, height);
830
831 nb_components = get_bits(&s->gb, 8);
832 if (nb_components <= 0 ||
833 nb_components > MAX_COMPONENTS)
834 return -1;
835 s->nb_components = nb_components;
836 s->h_max = 1;
837 s->v_max = 1;
838 for(i=0;i<nb_components;i++) {
839 /* component id */
840 s->component_id[i] = get_bits(&s->gb, 8) - 1;
841 s->h_count[i] = get_bits(&s->gb, 4);
842 s->v_count[i] = get_bits(&s->gb, 4);
843 /* compute hmax and vmax (only used in interleaved case) */
844 if (s->h_count[i] > s->h_max)
845 s->h_max = s->h_count[i];
846 if (s->v_count[i] > s->v_max)
847 s->v_max = s->v_count[i];
848 s->quant_index[i] = get_bits(&s->gb, 8);
849 if (s->quant_index[i] >= 4)
850 return -1;
851 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
852 s->v_count[i], s->component_id[i], s->quant_index[i]);
853 }
854
855 /* if different size, realloc/alloc picture */
856 /* XXX: also check h_count and v_count */
857 if (width != s->width || height != s->height) {
858 for(i=0;i<MAX_COMPONENTS;i++)
859 av_freep(&s->current_picture[i]);
860 s->width = width;
861 s->height = height;
862 /* test interlaced mode */
863 if (s->first_picture &&
864 s->org_height != 0 &&
865 s->height < ((s->org_height * 3) / 4)) {
866 s->interlaced = 1;
867 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
868 s->bottom_field = 0;
869 }
870
871 for(i=0;i<nb_components;i++) {
872 int w, h;
873 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
874 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
875 w = w * 8 * s->h_count[i];
876 h = h * 8 * s->v_count[i];
877 if (s->interlaced)
878 w *= 2;
879 s->linesize[i] = w;
880 /* memory test is done in mjpeg_decode_sos() */
881 s->current_picture[i] = av_mallocz(w * h);
882 }
883 s->first_picture = 0;
884 }
885
886 if (len != (8+(3*nb_components)))
887 {
888 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
889 }
890
891 return 0;
892 }
893
894 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
895 {
896 int code, diff;
897 #if 1
898 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
899 #else
900 code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
901 #endif
902 if (code < 0)
903 {
904 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
905 &s->vlcs[0][dc_index]);
906 return 0xffff;
907 }
908 if (code == 0) {
909 diff = 0;
910 } else {
911 diff = get_bits(&s->gb, code);
912 if ((diff & (1 << (code - 1))) == 0)
913 diff = (-1 << code) | (diff + 1);
914 }
915 return diff;
916 }
917
918 /* decode block and dequantize */
919 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
920 int component, int dc_index, int ac_index, int quant_index)
921 {
922 int nbits, code, i, j, level;
923 int run, val;
924 VLC *ac_vlc;
925 INT16 *quant_matrix;
926
927 /* DC coef */
928 val = mjpeg_decode_dc(s, dc_index);
929 if (val == 0xffff) {
930 dprintf("error dc\n");
931 return -1;
932 }
933 quant_matrix = s->quant_matrixes[quant_index];
934 val = val * quant_matrix[0] + s->last_dc[component];
935 s->last_dc[component] = val;
936 block[0] = val;
937 /* AC coefs */
938 ac_vlc = &s->vlcs[1][ac_index];
939 i = 1;
940 for(;;) {
941 #if 1
942 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
943 #else
944 code = get_vlc(&s->gb, ac_vlc);
945 #endif
946 if (code < 0) {
947 dprintf("error ac\n");
948 return -1;
949 }
950 /* EOB */
951 if (code == 0)
952 break;
953 if (code == 0xf0) {
954 i += 16;
955 } else {
956 run = code >> 4;
957 nbits = code & 0xf;
958 level = get_bits(&s->gb, nbits);
959 if ((level & (1 << (nbits - 1))) == 0)
960 level = (-1 << nbits) | (level + 1);
961 i += run;
962 if (i >= 64) {
963 dprintf("error count: %d\n", i);
964 return -1;
965 }
966 j = s->scantable.permutated[i];
967 block[j] = level * quant_matrix[j];
968 i++;
969 if (i >= 64)
970 break;
971 }
972 }
973 return 0;
974 }
975
976 static int mjpeg_decode_sos(MJpegDecodeContext *s)
977 {
978 int len, nb_components, i, j, n, h, v, ret;
979 int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
980 int comp_index[4];
981 int dc_index[4];
982 int ac_index[4];
983 int nb_blocks[4];
984 int h_count[4];
985 int v_count[4];
986
987 /* XXX: verify len field validity */
988 len = get_bits(&s->gb, 16);
989 nb_components = get_bits(&s->gb, 8);
990 if (len != 6+2*nb_components)
991 {
992 dprintf("decode_sos: invalid len (%d)\n", len);
993 return -1;
994 }
995 /* XXX: only interleaved scan accepted */
996 if (nb_components != 3)
997 {
998 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
999 return -1;
1000 }
1001 vmax = 0;
1002 hmax = 0;
1003 for(i=0;i<nb_components;i++) {
1004 id = get_bits(&s->gb, 8) - 1;
1005 dprintf("component: %d\n", id);
1006 /* find component index */
1007 for(index=0;index<s->nb_components;index++)
1008 if (id == s->component_id[index])
1009 break;
1010 if (index == s->nb_components)
1011 {
1012 dprintf("decode_sos: index(%d) out of components\n", index);
1013 return -1;
1014 }
1015
1016 comp_index[i] = index;
1017 nb_blocks[i] = s->h_count[index] * s->v_count[index];
1018 h_count[i] = s->h_count[index];
1019 v_count[i] = s->v_count[index];
1020
1021 dc_index[i] = get_bits(&s->gb, 4);
1022 ac_index[i] = get_bits(&s->gb, 4);
1023
1024 if (dc_index[i] < 0 || ac_index[i] < 0 ||
1025 dc_index[i] >= 4 || ac_index[i] >= 4)
1026 goto out_of_range;
1027 switch(s->start_code)
1028 {
1029 case SOF0:
1030 if (dc_index[i] > 1 || ac_index[i] > 1)
1031 goto out_of_range;
1032 break;
1033 case SOF1:
1034 case SOF2:
1035 if (dc_index[i] > 3 || ac_index[i] > 3)
1036 goto out_of_range;
1037 break;
1038 case SOF3:
1039 if (dc_index[i] > 3 || ac_index[i] != 0)
1040 goto out_of_range;
1041 break;
1042 }
1043 }
1044 skip_bits(&s->gb, 8); /* Ss */
1045 skip_bits(&s->gb, 8); /* Se */
1046 skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
1047
1048 for(i=0;i<nb_components;i++)
1049 s->last_dc[i] = 1024;
1050
1051 if (nb_components > 1) {
1052 /* interleaved stream */
1053 mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
1054 mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
1055 } else {
1056 h = s->h_max / s->h_count[comp_index[0]];
1057 v = s->v_max / s->v_count[comp_index[0]];
1058 mb_width = (s->width + h * 8 - 1) / (h * 8);
1059 mb_height = (s->height + v * 8 - 1) / (v * 8);
1060 nb_blocks[0] = 1;
1061 h_count[0] = 1;
1062 v_count[0] = 1;
1063 }
1064
1065 for(mb_y = 0; mb_y < mb_height; mb_y++) {
1066 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1067 for(i=0;i<nb_components;i++) {
1068 UINT8 *ptr;
1069 int x, y, c;
1070 n = nb_blocks[i];
1071 c = comp_index[i];
1072 h = h_count[i];
1073 v = v_count[i];
1074 x = 0;
1075 y = 0;
1076 if (s->restart_interval && !s->restart_count)
1077 s->restart_count = s->restart_interval;
1078 for(j=0;j<n;j++) {
1079 memset(s->block, 0, sizeof(s->block));
1080 if (decode_block(s, s->block, i,
1081 dc_index[i], ac_index[i],
1082 s->quant_index[c]) < 0) {
1083 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1084 ret = -1;
1085 goto the_end;
1086 }
1087 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1088 ptr = s->current_picture[c] +
1089 (s->linesize[c] * (v * mb_y + y) * 8) +
1090 (h * mb_x + x) * 8;
1091 if (s->interlaced && s->bottom_field)
1092 ptr += s->linesize[c] >> 1;
1093 s->idct_put(ptr, s->linesize[c], s->block);
1094 if (++x == h) {
1095 x = 0;
1096 y++;
1097 }
1098 }
1099 }
1100 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1101
1102 if ((s->restart_interval < 1350) && !--s->restart_count) {
1103 align_get_bits(&s->gb);
1104 skip_bits(&s->gb, 16); /* skip RSTn */
1105 for (j=0; j<nb_components; j++) /* reset dc */
1106 s->last_dc[j] = 1024;
1107 }
1108 }
1109 }
1110 ret = 0;
1111 the_end:
1112 emms_c();
1113 return ret;
1114 out_of_range:
1115 dprintf("decode_sos: ac/dc index out of range\n");
1116 return -1;
1117 }
1118
1119 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1120 {
1121 if (get_bits(&s->gb, 16) != 4)
1122 return -1;
1123 s->restart_interval = get_bits(&s->gb, 16);
1124 dprintf("restart interval: %d\n", s->restart_interval);
1125
1126 return 0;
1127 }
1128
1129 static int mjpeg_decode_app(MJpegDecodeContext *s)
1130 {
1131 int len, id;
1132
1133 /* XXX: verify len field validity */
1134 len = get_bits(&s->gb, 16);
1135 if (len < 5)
1136 return -1;
1137
1138 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1139 id = be2me_32(id);
1140 len -= 6;
1141
1142 /* buggy AVID, it puts EOI only at every 10th frame */
1143 /* also this fourcc is used by non-avid files too, it holds some
1144 informations, but it's always present in AVID creates files */
1145 if (id == ff_get_fourcc("AVI1"))
1146 {
1147 /* structure:
1148 4bytes AVI1
1149 1bytes polarity
1150 1bytes always zero
1151 4bytes field_size
1152 4bytes field_size_less_padding
1153 */
1154 s->buggy_avid = 1;
1155 // if (s->first_picture)
1156 // printf("mjpeg: workarounding buggy AVID\n");
1157 s->interlace_polarity = get_bits(&s->gb, 8);
1158 #if 0
1159 skip_bits(&s->gb, 8);
1160 skip_bits(&s->gb, 32);
1161 skip_bits(&s->gb, 32);
1162 len -= 10;
1163 #endif
1164 // if (s->interlace_polarity)
1165 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1166 goto out;
1167 }
1168
1169 // len -= 2;
1170
1171 if (id == ff_get_fourcc("JFIF"))
1172 {
1173 int t_w, t_h;
1174 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1175 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1176 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1177 if (get_bits(&s->gb, 8) == 0)
1178 {
1179 s->avctx->aspect_ratio_info = FF_ASPECT_EXTENDED;
1180 s->avctx->aspected_width = get_bits(&s->gb, 16);
1181 s->avctx->aspected_height = get_bits(&s->gb, 16);
1182 }
1183 else
1184 {
1185 skip_bits(&s->gb, 16);
1186 skip_bits(&s->gb, 16);
1187 }
1188 t_w = get_bits(&s->gb, 8);
1189 t_h = get_bits(&s->gb, 8);
1190 if (t_w && t_h)
1191 {
1192 /* skip thumbnail */
1193 if (len-10-(t_w*t_h*3) > 0)
1194 len -= t_w*t_h*3;
1195 }
1196 len -= 10;
1197 goto out;
1198 }
1199
1200 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1201 {
1202 printf("mjpeg: Adobe header found\n");
1203 skip_bits(&s->gb, 16); /* version */
1204 skip_bits(&s->gb, 16); /* flags0 */
1205 skip_bits(&s->gb, 16); /* flags1 */
1206 skip_bits(&s->gb, 8); /* transform */
1207 len -= 7;
1208 goto out;
1209 }
1210
1211 /* Apple MJPEG-A */
1212 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1213 {
1214 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1215 id = be2me_32(id);
1216 len -= 4;
1217 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1218 {
1219 #if 0
1220 skip_bits(&s->gb, 32); /* field size */
1221 skip_bits(&s->gb, 32); /* pad field size */
1222 skip_bits(&s->gb, 32); /* next off */
1223 skip_bits(&s->gb, 32); /* quant off */
1224 skip_bits(&s->gb, 32); /* huff off */
1225 skip_bits(&s->gb, 32); /* image off */
1226 skip_bits(&s->gb, 32); /* scan off */
1227 skip_bits(&s->gb, 32); /* data off */
1228 #endif
1229 if (s->first_picture)
1230 printf("mjpeg: Apple MJPEG-A header found\n");
1231 }
1232 }
1233
1234 out:
1235 /* slow but needed for extreme adobe jpegs */
1236 if (len < 0)
1237 printf("mjpeg: error, decode_app parser read over the end\n");
1238 while(--len > 0)
1239 skip_bits(&s->gb, 8);
1240
1241 return 0;
1242 }
1243
1244 static int mjpeg_decode_com(MJpegDecodeContext *s)
1245 {
1246 int len, i;
1247 UINT8 *cbuf;
1248
1249 /* XXX: verify len field validity */
1250 len = get_bits(&s->gb, 16)-2;
1251 cbuf = av_malloc(len+1);
1252
1253 for (i = 0; i < len; i++)
1254 cbuf[i] = get_bits(&s->gb, 8);
1255 if (cbuf[i-1] == '\n')
1256 cbuf[i-1] = 0;
1257 else
1258 cbuf[i] = 0;
1259
1260 printf("mjpeg comment: '%s'\n", cbuf);
1261
1262 /* buggy avid, it puts EOI only at every 10th frame */
1263 if (!strcmp(cbuf, "AVID"))
1264 {
1265 s->buggy_avid = 1;
1266 // if (s->first_picture)
1267 // printf("mjpeg: workarounding buggy AVID\n");
1268 }
1269
1270 av_free(cbuf);
1271
1272 return 0;
1273 }
1274
1275 #if 0
1276 static int valid_marker_list[] =
1277 {
1278 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1279 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1280 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1281 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1282 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1283 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1284 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1285 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1286 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1287 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1288 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1289 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1290 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1291 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1292 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1293 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1294 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1295 }
1296 #endif
1297
1298 /* return the 8 bit start code value and update the search
1299 state. Return -1 if no start code found */
1300 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1301 {
1302 UINT8 *buf_ptr;
1303 unsigned int v, v2;
1304 int val;
1305 #ifdef DEBUG
1306 int skipped=0;
1307 #endif
1308
1309 buf_ptr = *pbuf_ptr;
1310 while (buf_ptr < buf_end) {
1311 v = *buf_ptr++;
1312 v2 = *buf_ptr;
1313 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1314 val = *buf_ptr++;
1315 goto found;
1316 }
1317 #ifdef DEBUG
1318 skipped++;
1319 #endif
1320 }
1321 val = -1;
1322 found:
1323 #ifdef DEBUG
1324 dprintf("find_marker skipped %d bytes\n", skipped);
1325 #endif
1326 *pbuf_ptr = buf_ptr;
1327 return val;
1328 }
1329
1330 static int mjpeg_decode_frame(AVCodecContext *avctx,
1331 void *data, int *data_size,
1332 UINT8 *buf, int buf_size)
1333 {
1334 MJpegDecodeContext *s = avctx->priv_data;
1335 UINT8 *buf_end, *buf_ptr;
1336 int i, start_code;
1337 AVPicture *picture = data;
1338
1339 *data_size = 0;
1340
1341 /* no supplementary picture */
1342 if (buf_size == 0)
1343 return 0;
1344
1345 buf_ptr = buf;
1346 buf_end = buf + buf_size;
1347 while (buf_ptr < buf_end) {
1348 /* find start next marker */
1349 start_code = find_marker(&buf_ptr, buf_end);
1350 {
1351 /* EOF */
1352 if (start_code < 0) {
1353 goto the_end;
1354 } else {
1355 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1356
1357 if ((buf_end - buf_ptr) > s->buffer_size)
1358 {
1359 av_free(s->buffer);
1360 s->buffer_size = buf_end-buf_ptr;
1361 s->buffer = av_malloc(s->buffer_size);
1362 dprintf("buffer too small, expanding to %d bytes\n",
1363 s->buffer_size);
1364 }
1365
1366 /* unescape buffer of SOS */
1367 if (start_code == SOS)
1368 {
1369 UINT8 *src = buf_ptr;
1370 UINT8 *dst = s->buffer;
1371
1372 while (src<buf_end)
1373 {
1374 UINT8 x = *(src++);
1375
1376 #if 0
1377 if (x == 0xff && *src == 0xff)
1378 break;
1379 #endif
1380 *(dst++) = x;
1381 if (x == 0xff)
1382 {
1383 while(*src == 0xff) src++;
1384
1385 x = *(src++);
1386 if (x >= 0xd0 && x <= 0xd7)
1387 *(dst++) = x;
1388 else if (x)
1389 break;
1390 }
1391 }
1392 init_get_bits(&s->gb, s->buffer, dst - s->buffer);
1393
1394 dprintf("escaping removed %d bytes\n",
1395 (buf_end - buf_ptr) - (dst - s->buffer));
1396 }
1397 else
1398 init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);
1399
1400 s->start_code = start_code;
1401
1402 /* process markers */
1403 if (start_code >= 0xd0 && start_code <= 0xd7) {
1404 dprintf("restart marker: %d\n", start_code&0x0f);
1405 } else if (s->first_picture) {
1406 /* APP fields */
1407 if (start_code >= 0xe0 && start_code <= 0xef)
1408 mjpeg_decode_app(s);
1409 /* Comment */
1410 else if (start_code == COM)
1411 mjpeg_decode_com(s);
1412 }
1413
1414 switch(start_code) {
1415 case SOI:
1416 s->restart_interval = 0;
1417 /* nothing to do on SOI */
1418 break;
1419 case DQT:
1420 mjpeg_decode_dqt(s);
1421 break;
1422 case DHT:
1423 mjpeg_decode_dht(s);
1424 break;
1425 case SOF0:
1426 mjpeg_decode_sof0(s);
1427 break;
1428 case EOI:
1429 eoi_parser:
1430 {
1431 int l;
1432 if (s->interlaced) {
1433 s->bottom_field ^= 1;
1434 /* if not bottom field, do not output image yet */
1435 if (s->bottom_field)
1436 goto not_the_end;
1437 }
1438 for(i=0;i<3;i++) {
1439 picture->data[i] = s->current_picture[i];
1440 #if 1
1441 l = s->linesize[i];
1442 if (s->interlaced)
1443 l >>= 1;
1444 picture->linesize[i] = l;
1445 #else
1446 picture->linesize[i] = (s->interlaced) ?
1447 s->linesize[i] >> 1 : s->linesize[i];
1448 #endif
1449 }
1450 *data_size = sizeof(AVPicture);
1451 avctx->height = s->height;
1452 if (s->interlaced)
1453 avctx->height *= 2;
1454 avctx->width = s->width;
1455 /* XXX: not complete test ! */
1456 switch((s->h_count[0] << 4) | s->v_count[0]) {
1457 case 0x11:
1458 avctx->pix_fmt = PIX_FMT_YUV444P;
1459 break;
1460 case 0x21:
1461 avctx->pix_fmt = PIX_FMT_YUV422P;
1462 break;
1463 default:
1464 case 0x22:
1465 avctx->pix_fmt = PIX_FMT_YUV420P;
1466 break;
1467 }
1468 /* dummy quality */
1469 /* XXX: infer it with matrix */
1470 avctx->quality = 3;
1471 goto the_end;
1472 }
1473 break;
1474 case SOS:
1475 mjpeg_decode_sos(s);
1476 /* buggy avid puts EOI every 10-20th frame */
1477 /* if restart period is over process EOI */
1478 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1479 goto eoi_parser;
1480 break;
1481 case DRI:
1482 mjpeg_decode_dri(s);
1483 break;
1484 case SOF1:
1485 case SOF2:
1486 case SOF3:
1487 case SOF5:
1488 case SOF6:
1489 case SOF7:
1490 case SOF9:
1491 case SOF10:
1492 case SOF11:
1493 case SOF13:
1494 case SOF14:
1495 case SOF15:
1496 case JPG:
1497 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1498 break;
1499 // default:
1500 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1501 // break;
1502 }
1503
1504 not_the_end:
1505 /* eof process start code */
1506 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1507 dprintf("marker parser used %d bytes (%d bits)\n",
1508 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1509 }
1510 }
1511 }
1512 the_end:
1513
1514 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1515 // return buf_end - buf_ptr;
1516 return buf_ptr - buf;
1517 }
1518
1519 static int mjpeg_decode_end(AVCodecContext *avctx)
1520 {
1521 MJpegDecodeContext *s = avctx->priv_data;
1522 int i, j;
1523
1524 av_free(s->buffer);
1525 for(i=0;i<MAX_COMPONENTS;i++)
1526 av_free(s->current_picture[i]);
1527 for(i=0;i<2;i++) {
1528 for(j=0;j<4;j++)
1529 free_vlc(&s->vlcs[i][j]);
1530 }
1531 return 0;
1532 }
1533
1534 AVCodec mjpeg_decoder = {
1535 "mjpeg",
1536 CODEC_TYPE_VIDEO,
1537 CODEC_ID_MJPEG,
1538 sizeof(MJpegDecodeContext),
1539 mjpeg_decode_init,
1540 NULL,
1541 mjpeg_decode_end,
1542 mjpeg_decode_frame,
1543 0,
1544 NULL
1545 };