?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r105: This commit was manufactured by cvs2svn to create tag
[cinelerra_cv/mob.git] / hvirtual / quicktime / libavcodec / mjpeg.c
blob47ace7bc3895d2f5ebef07394537a18852e06ff7
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, new decode_frame mechanism and apple mjpeg-b support
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 if (!s->buffer)
724 return -1;
725 s->start_code = -1;
726 s->first_picture = 1;
727 s->org_width = avctx->width;
728 s->org_height = avctx->height;
729
730 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
731 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
732 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
733 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
734
735 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
736 {
737 printf("mjpeg: using external huffman table\n");
738 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
739 mjpeg_decode_dht(s);
740 /* should check for error - but dunno */
741 }
742
743 return 0;
744 }
745
746 /* quantize tables */
747 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
748 {
749 int len, index, i, j;
750
751 len = get_bits(&s->gb, 16) - 2;
752
753 while (len >= 65) {
754 /* only 8 bit precision handled */
755 if (get_bits(&s->gb, 4) != 0)
756 {
757 dprintf("dqt: 16bit precision\n");
758 return -1;
759 }
760 index = get_bits(&s->gb, 4);
761 if (index >= 4)
762 return -1;
763 dprintf("index=%d\n", index);
764 /* read quant table */
765 for(i=0;i<64;i++) {
766 j = s->scantable.permutated[i];
767 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
768 }
769 len -= 65;
770 }
771
772 return 0;
773 }
774
775 /* decode huffman tables and build VLC decoders */
776 static int mjpeg_decode_dht(MJpegDecodeContext *s)
777 {
778 int len, index, i, class, n, v, code_max;
779 UINT8 bits_table[17];
780 UINT8 val_table[256];
781
782 len = get_bits(&s->gb, 16) - 2;
783
784 while (len > 0) {
785 if (len < 17)
786 return -1;
787 class = get_bits(&s->gb, 4);
788 if (class >= 2)
789 return -1;
790 index = get_bits(&s->gb, 4);
791 if (index >= 4)
792 return -1;
793 n = 0;
794 for(i=1;i<=16;i++) {
795 bits_table[i] = get_bits(&s->gb, 8);
796 n += bits_table[i];
797 }
798 len -= 17;
799 if (len < n || n > 256)
800 return -1;
801
802 code_max = 0;
803 for(i=0;i<n;i++) {
804 v = get_bits(&s->gb, 8);
805 if (v > code_max)
806 code_max = v;
807 val_table[i] = v;
808 }
809 len -= n;
810
811 /* build VLC and flush previous vlc if present */
812 free_vlc(&s->vlcs[class][index]);
813 dprintf("class=%d index=%d nb_codes=%d\n",
814 class, index, code_max + 1);
815 build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1);
816 }
817 return 0;
818 }
819
820 static int mjpeg_decode_sof0(MJpegDecodeContext *s)
821 {
822 int len, nb_components, i, width, height;
823
824 /* XXX: verify len field validity */
825 len = get_bits(&s->gb, 16);
826 /* only 8 bits/component accepted */
827 if (get_bits(&s->gb, 8) != 8)
828 return -1;
829 height = get_bits(&s->gb, 16);
830 width = get_bits(&s->gb, 16);
831 dprintf("sof0: picture: %dx%d\n", width, height);
832
833 nb_components = get_bits(&s->gb, 8);
834 if (nb_components <= 0 ||
835 nb_components > MAX_COMPONENTS)
836 return -1;
837 s->nb_components = nb_components;
838 s->h_max = 1;
839 s->v_max = 1;
840 for(i=0;i<nb_components;i++) {
841 /* component id */
842 s->component_id[i] = get_bits(&s->gb, 8) - 1;
843 s->h_count[i] = get_bits(&s->gb, 4);
844 s->v_count[i] = get_bits(&s->gb, 4);
845 /* compute hmax and vmax (only used in interleaved case) */
846 if (s->h_count[i] > s->h_max)
847 s->h_max = s->h_count[i];
848 if (s->v_count[i] > s->v_max)
849 s->v_max = s->v_count[i];
850 s->quant_index[i] = get_bits(&s->gb, 8);
851 if (s->quant_index[i] >= 4)
852 return -1;
853 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
854 s->v_count[i], s->component_id[i], s->quant_index[i]);
855 }
856
857 /* if different size, realloc/alloc picture */
858 /* XXX: also check h_count and v_count */
859 if (width != s->width || height != s->height) {
860 for(i=0;i<MAX_COMPONENTS;i++)
861 av_freep(&s->current_picture[i]);
862 s->width = width;
863 s->height = height;
864 /* test interlaced mode */
865 if (s->first_picture &&
866 s->org_height != 0 &&
867 s->height < ((s->org_height * 3) / 4)) {
868 s->interlaced = 1;
869 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
870 s->bottom_field = 0;
871 }
872
873 for(i=0;i<nb_components;i++) {
874 int w, h;
875 w = (s->width + 8 * s->h_max - 1) / (8 * s->h_max);
876 h = (s->height + 8 * s->v_max - 1) / (8 * s->v_max);
877 w = w * 8 * s->h_count[i];
878 h = h * 8 * s->v_count[i];
879 if (s->interlaced)
880 w *= 2;
881 s->linesize[i] = w;
882 s->current_picture[i] = av_mallocz(w * h);
883 if (!s->current_picture[i])
884 {
885 dprintf("error: no picture buffers allocated\n");
886 return -1;
887 }
888 }
889 s->first_picture = 0;
890 }
891
892 if (len != (8+(3*nb_components)))
893 {
894 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
895 }
896
897 return 0;
898 }
899
900 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
901 {
902 int code, diff;
903 #if 1
904 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
905 #else
906 code = get_vlc(&s->gb, &s->vlcs[0][dc_index]);
907 #endif
908 if (code < 0)
909 {
910 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
911 &s->vlcs[0][dc_index]);
912 return 0xffff;
913 }
914 if (code == 0) {
915 diff = 0;
916 } else {
917 diff = get_bits(&s->gb, code);
918 if ((diff & (1 << (code - 1))) == 0)
919 diff = (-1 << code) | (diff + 1);
920 }
921 return diff;
922 }
923
924 /* decode block and dequantize */
925 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
926 int component, int dc_index, int ac_index, int quant_index)
927 {
928 int nbits, code, i, j, level;
929 int run, val;
930 VLC *ac_vlc;
931 INT16 *quant_matrix;
932
933 /* DC coef */
934 val = mjpeg_decode_dc(s, dc_index);
935 if (val == 0xffff) {
936 dprintf("error dc\n");
937 return -1;
938 }
939 quant_matrix = s->quant_matrixes[quant_index];
940 val = val * quant_matrix[0] + s->last_dc[component];
941 s->last_dc[component] = val;
942 block[0] = val;
943 /* AC coefs */
944 ac_vlc = &s->vlcs[1][ac_index];
945 i = 1;
946 for(;;) {
947 #if 1
948 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
949 #else
950 code = get_vlc(&s->gb, ac_vlc);
951 #endif
952 if (code < 0) {
953 dprintf("error ac\n");
954 return -1;
955 }
956 /* EOB */
957 if (code == 0)
958 break;
959 if (code == 0xf0) {
960 i += 16;
961 } else {
962 run = code >> 4;
963 nbits = code & 0xf;
964 level = get_bits(&s->gb, nbits);
965 if ((level & (1 << (nbits - 1))) == 0)
966 level = (-1 << nbits) | (level + 1);
967 i += run;
968 if (i >= 64) {
969 dprintf("error count: %d\n", i);
970 return -1;
971 }
972 j = s->scantable.permutated[i];
973 block[j] = level * quant_matrix[j];
974 i++;
975 if (i >= 64)
976 break;
977 }
978 }
979 return 0;
980 }
981
982 static int mjpeg_decode_sos(MJpegDecodeContext *s)
983 {
984 int len, nb_components, i, j, n, h, v, ret;
985 int mb_width, mb_height, mb_x, mb_y, vmax, hmax, index, id;
986 int comp_index[4];
987 int dc_index[4];
988 int ac_index[4];
989 int nb_blocks[4];
990 int h_count[4];
991 int v_count[4];
992
993 /* XXX: verify len field validity */
994 len = get_bits(&s->gb, 16);
995 nb_components = get_bits(&s->gb, 8);
996 if (len != 6+2*nb_components)
997 {
998 dprintf("decode_sos: invalid len (%d)\n", len);
999 return -1;
1000 }
1001 /* XXX: only interleaved scan accepted */
1002 if (nb_components != 3)
1003 {
1004 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1005 return -1;
1006 }
1007 vmax = 0;
1008 hmax = 0;
1009 for(i=0;i<nb_components;i++) {
1010 id = get_bits(&s->gb, 8) - 1;
1011 dprintf("component: %d\n", id);
1012 /* find component index */
1013 for(index=0;index<s->nb_components;index++)
1014 if (id == s->component_id[index])
1015 break;
1016 if (index == s->nb_components)
1017 {
1018 dprintf("decode_sos: index(%d) out of components\n", index);
1019 return -1;
1020 }
1021
1022 comp_index[i] = index;
1023 nb_blocks[i] = s->h_count[index] * s->v_count[index];
1024 h_count[i] = s->h_count[index];
1025 v_count[i] = s->v_count[index];
1026
1027 dc_index[i] = get_bits(&s->gb, 4);
1028 ac_index[i] = get_bits(&s->gb, 4);
1029
1030 if (dc_index[i] < 0 || ac_index[i] < 0 ||
1031 dc_index[i] >= 4 || ac_index[i] >= 4)
1032 goto out_of_range;
1033 switch(s->start_code)
1034 {
1035 case SOF0:
1036 if (dc_index[i] > 1 || ac_index[i] > 1)
1037 goto out_of_range;
1038 break;
1039 case SOF1:
1040 case SOF2:
1041 if (dc_index[i] > 3 || ac_index[i] > 3)
1042 goto out_of_range;
1043 break;
1044 case SOF3:
1045 if (dc_index[i] > 3 || ac_index[i] != 0)
1046 goto out_of_range;
1047 break;
1048 }
1049 }
1050 skip_bits(&s->gb, 8); /* Ss */
1051 skip_bits(&s->gb, 8); /* Se */
1052 skip_bits(&s->gb, 8); /* Ah and Al (each are 4 bits) */
1053
1054 for(i=0;i<nb_components;i++)
1055 s->last_dc[i] = 1024;
1056
1057 if (nb_components > 1) {
1058 /* interleaved stream */
1059 mb_width = (s->width + s->h_max * 8 - 1) / (s->h_max * 8);
1060 mb_height = (s->height + s->v_max * 8 - 1) / (s->v_max * 8);
1061 } else {
1062 h = s->h_max / s->h_count[comp_index[0]];
1063 v = s->v_max / s->v_count[comp_index[0]];
1064 mb_width = (s->width + h * 8 - 1) / (h * 8);
1065 mb_height = (s->height + v * 8 - 1) / (v * 8);
1066 nb_blocks[0] = 1;
1067 h_count[0] = 1;
1068 v_count[0] = 1;
1069 }
1070
1071 for(mb_y = 0; mb_y < mb_height; mb_y++) {
1072 for(mb_x = 0; mb_x < mb_width; mb_x++) {
1073 for(i=0;i<nb_components;i++) {
1074 UINT8 *ptr;
1075 int x, y, c;
1076 n = nb_blocks[i];
1077 c = comp_index[i];
1078 h = h_count[i];
1079 v = v_count[i];
1080 x = 0;
1081 y = 0;
1082 if (s->restart_interval && !s->restart_count)
1083 s->restart_count = s->restart_interval;
1084 for(j=0;j<n;j++) {
1085 memset(s->block, 0, sizeof(s->block));
1086 if (decode_block(s, s->block, i,
1087 dc_index[i], ac_index[i],
1088 s->quant_index[c]) < 0) {
1089 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1090 ret = -1;
1091 goto the_end;
1092 }
1093 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1094 ptr = s->current_picture[c] +
1095 (s->linesize[c] * (v * mb_y + y) * 8) +
1096 (h * mb_x + x) * 8;
1097 if (s->interlaced && s->bottom_field)
1098 ptr += s->linesize[c] >> 1;
1099 s->idct_put(ptr, s->linesize[c], s->block);
1100 if (++x == h) {
1101 x = 0;
1102 y++;
1103 }
1104 }
1105 }
1106 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1107 if (s->restart_interval && (s->restart_interval < 1350) &&
1108 !--s->restart_count) {
1109 align_get_bits(&s->gb);
1110 skip_bits(&s->gb, 16); /* skip RSTn */
1111 for (j=0; j<nb_components; j++) /* reset dc */
1112 s->last_dc[j] = 1024;
1113 }
1114 }
1115 }
1116 ret = 0;
1117 the_end:
1118 emms_c();
1119 return ret;
1120 out_of_range:
1121 dprintf("decode_sos: ac/dc index out of range\n");
1122 return -1;
1123 }
1124
1125 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1126 {
1127 if (get_bits(&s->gb, 16) != 4)
1128 return -1;
1129 s->restart_interval = get_bits(&s->gb, 16);
1130 dprintf("restart interval: %d\n", s->restart_interval);
1131
1132 return 0;
1133 }
1134
1135 static int mjpeg_decode_app(MJpegDecodeContext *s)
1136 {
1137 int len, id;
1138
1139 /* XXX: verify len field validity */
1140 len = get_bits(&s->gb, 16);
1141 if (len < 5)
1142 return -1;
1143
1144 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1145 id = be2me_32(id);
1146 len -= 6;
1147
1148 /* buggy AVID, it puts EOI only at every 10th frame */
1149 /* also this fourcc is used by non-avid files too, it holds some
1150 informations, but it's always present in AVID creates files */
1151 if (id == ff_get_fourcc("AVI1"))
1152 {
1153 /* structure:
1154 4bytes AVI1
1155 1bytes polarity
1156 1bytes always zero
1157 4bytes field_size
1158 4bytes field_size_less_padding
1159 */
1160 s->buggy_avid = 1;
1161 // if (s->first_picture)
1162 // printf("mjpeg: workarounding buggy AVID\n");
1163 s->interlace_polarity = get_bits(&s->gb, 8);
1164 #if 0
1165 skip_bits(&s->gb, 8);
1166 skip_bits(&s->gb, 32);
1167 skip_bits(&s->gb, 32);
1168 len -= 10;
1169 #endif
1170 // if (s->interlace_polarity)
1171 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1172 goto out;
1173 }
1174
1175 // len -= 2;
1176
1177 if (id == ff_get_fourcc("JFIF"))
1178 {
1179 int t_w, t_h;
1180 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1181 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1182 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1183 if (get_bits(&s->gb, 8) == 0)
1184 {
1185 int x_density = get_bits(&s->gb, 16);
1186 int y_density = get_bits(&s->gb, 16);
1187
1188 dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1189 (float)x_density, y_density, (float)y_density);
1190 #if 0
1191 //MN: needs to be checked
1192 if(x_density)
1193 // s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1194 s->avctx->aspect_ratio = (float)x_density/y_density;
1195 /* it's better, but every JFIF I have seen stores 1:1 */
1196 else
1197 s->avctx->aspect_ratio= 0.0;
1198 #endif
1199 }
1200 else
1201 {
1202 skip_bits(&s->gb, 16);
1203 skip_bits(&s->gb, 16);
1204 }
1205
1206 t_w = get_bits(&s->gb, 8);
1207 t_h = get_bits(&s->gb, 8);
1208 if (t_w && t_h)
1209 {
1210 /* skip thumbnail */
1211 if (len-10-(t_w*t_h*3) > 0)
1212 len -= t_w*t_h*3;
1213 }
1214 len -= 10;
1215 goto out;
1216 }
1217
1218 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1219 {
1220 printf("mjpeg: Adobe header found\n");
1221 skip_bits(&s->gb, 16); /* version */
1222 skip_bits(&s->gb, 16); /* flags0 */
1223 skip_bits(&s->gb, 16); /* flags1 */
1224 skip_bits(&s->gb, 8); /* transform */
1225 len -= 7;
1226 goto out;
1227 }
1228
1229 /* Apple MJPEG-A */
1230 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1231 {
1232 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1233 id = be2me_32(id);
1234 len -= 4;
1235 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1236 {
1237 #if 0
1238 skip_bits(&s->gb, 32); /* field size */
1239 skip_bits(&s->gb, 32); /* pad field size */
1240 skip_bits(&s->gb, 32); /* next off */
1241 skip_bits(&s->gb, 32); /* quant off */
1242 skip_bits(&s->gb, 32); /* huff off */
1243 skip_bits(&s->gb, 32); /* image off */
1244 skip_bits(&s->gb, 32); /* scan off */
1245 skip_bits(&s->gb, 32); /* data off */
1246 #endif
1247 if (s->first_picture)
1248 printf("mjpeg: Apple MJPEG-A header found\n");
1249 }
1250 }
1251
1252 out:
1253 /* slow but needed for extreme adobe jpegs */
1254 if (len < 0)
1255 printf("mjpeg: error, decode_app parser read over the end\n");
1256 while(--len > 0)
1257 skip_bits(&s->gb, 8);
1258
1259 return 0;
1260 }
1261
1262 static int mjpeg_decode_com(MJpegDecodeContext *s)
1263 {
1264 int len, i;
1265 UINT8 *cbuf;
1266
1267 /* XXX: verify len field validity */
1268 len = get_bits(&s->gb, 16)-2;
1269 cbuf = av_malloc(len+1);
1270
1271 for (i = 0; i < len; i++)
1272 cbuf[i] = get_bits(&s->gb, 8);
1273 if (cbuf[i-1] == '\n')
1274 cbuf[i-1] = 0;
1275 else
1276 cbuf[i] = 0;
1277
1278 printf("mjpeg comment: '%s'\n", cbuf);
1279
1280 /* buggy avid, it puts EOI only at every 10th frame */
1281 if (!strcmp(cbuf, "AVID"))
1282 {
1283 s->buggy_avid = 1;
1284 // if (s->first_picture)
1285 // printf("mjpeg: workarounding buggy AVID\n");
1286 }
1287
1288 av_free(cbuf);
1289
1290 return 0;
1291 }
1292
1293 #if 0
1294 static int valid_marker_list[] =
1295 {
1296 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1297 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1298 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1299 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1300 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1301 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1302 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1303 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1304 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1305 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1306 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1307 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1308 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1309 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1310 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1311 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1312 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1313 }
1314 #endif
1315
1316 /* return the 8 bit start code value and update the search
1317 state. Return -1 if no start code found */
1318 static int find_marker(UINT8 **pbuf_ptr, UINT8 *buf_end)
1319 {
1320 UINT8 *buf_ptr;
1321 unsigned int v, v2;
1322 int val;
1323 #ifdef DEBUG
1324 int skipped=0;
1325 #endif
1326
1327 buf_ptr = *pbuf_ptr;
1328 while (buf_ptr < buf_end) {
1329 v = *buf_ptr++;
1330 v2 = *buf_ptr;
1331 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1332 val = *buf_ptr++;
1333 goto found;
1334 }
1335 #ifdef DEBUG
1336 skipped++;
1337 #endif
1338 }
1339 val = -1;
1340 found:
1341 #ifdef DEBUG
1342 dprintf("find_marker skipped %d bytes\n", skipped);
1343 #endif
1344 *pbuf_ptr = buf_ptr;
1345 return val;
1346 }
1347
1348 static int mjpeg_decode_frame(AVCodecContext *avctx,
1349 void *data, int *data_size,
1350 UINT8 *buf, int buf_size)
1351 {
1352 MJpegDecodeContext *s = avctx->priv_data;
1353 UINT8 *buf_end, *buf_ptr;
1354 int i, start_code;
1355 AVPicture *picture = data;
1356
1357 *data_size = 0;
1358
1359 /* no supplementary picture */
1360 if (buf_size == 0)
1361 return 0;
1362
1363 buf_ptr = buf;
1364 buf_end = buf + buf_size;
1365 while (buf_ptr < buf_end) {
1366 /* find start next marker */
1367 start_code = find_marker(&buf_ptr, buf_end);
1368 {
1369 /* EOF */
1370 if (start_code < 0) {
1371 goto the_end;
1372 } else {
1373 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1374
1375 if ((buf_end - buf_ptr) > s->buffer_size)
1376 {
1377 av_free(s->buffer);
1378 s->buffer_size = buf_end-buf_ptr;
1379 s->buffer = av_malloc(s->buffer_size);
1380 dprintf("buffer too small, expanding to %d bytes\n",
1381 s->buffer_size);
1382 }
1383
1384 /* unescape buffer of SOS */
1385 if (start_code == SOS)
1386 {
1387 UINT8 *src = buf_ptr;
1388 UINT8 *dst = s->buffer;
1389
1390 while (src<buf_end)
1391 {
1392 UINT8 x = *(src++);
1393
1394 *(dst++) = x;
1395 if (x == 0xff)
1396 {
1397 while(*src == 0xff) src++;
1398
1399 x = *(src++);
1400 if (x >= 0xd0 && x <= 0xd7)
1401 *(dst++) = x;
1402 else if (x)
1403 break;
1404 }
1405 }
1406 init_get_bits(&s->gb, s->buffer, dst - s->buffer);
1407
1408 dprintf("escaping removed %d bytes\n",
1409 (buf_end - buf_ptr) - (dst - s->buffer));
1410 }
1411 else
1412 init_get_bits(&s->gb, buf_ptr, buf_end - buf_ptr);
1413
1414 s->start_code = start_code;
1415
1416 /* process markers */
1417 if (start_code >= 0xd0 && start_code <= 0xd7) {
1418 dprintf("restart marker: %d\n", start_code&0x0f);
1419 } else if (s->first_picture) {
1420 /* APP fields */
1421 if (start_code >= 0xe0 && start_code <= 0xef)
1422 mjpeg_decode_app(s);
1423 /* Comment */
1424 else if (start_code == COM)
1425 mjpeg_decode_com(s);
1426 }
1427
1428 switch(start_code) {
1429 case SOI:
1430 s->restart_interval = 0;
1431 /* nothing to do on SOI */
1432 break;
1433 case DQT:
1434 mjpeg_decode_dqt(s);
1435 break;
1436 case DHT:
1437 mjpeg_decode_dht(s);
1438 break;
1439 case SOF0:
1440 if (mjpeg_decode_sof0(s) < 0)
1441 return -1;
1442 break;
1443 case EOI:
1444 eoi_parser:
1445 {
1446 if (s->interlaced) {
1447 s->bottom_field ^= 1;
1448 /* if not bottom field, do not output image yet */
1449 if (s->bottom_field)
1450 goto not_the_end;
1451 }
1452 for(i=0;i<3;i++) {
1453 picture->data[i] = s->current_picture[i];
1454 picture->linesize[i] = (s->interlaced) ?
1455 s->linesize[i] >> 1 : s->linesize[i];
1456 }
1457 *data_size = sizeof(AVPicture);
1458 avctx->height = s->height;
1459 if (s->interlaced)
1460 avctx->height *= 2;
1461 avctx->width = s->width;
1462 /* XXX: not complete test ! */
1463 switch((s->h_count[0] << 4) | s->v_count[0]) {
1464 case 0x11:
1465 avctx->pix_fmt = PIX_FMT_YUV444P;
1466 break;
1467 case 0x21:
1468 avctx->pix_fmt = PIX_FMT_YUV422P;
1469 break;
1470 default:
1471 case 0x22:
1472 avctx->pix_fmt = PIX_FMT_YUV420P;
1473 break;
1474 }
1475 /* dummy quality */
1476 /* XXX: infer it with matrix */
1477 // avctx->quality = 3;
1478 goto the_end;
1479 }
1480 break;
1481 case SOS:
1482 mjpeg_decode_sos(s);
1483 /* buggy avid puts EOI every 10-20th frame */
1484 /* if restart period is over process EOI */
1485 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1486 goto eoi_parser;
1487 break;
1488 case DRI:
1489 mjpeg_decode_dri(s);
1490 break;
1491 case SOF1:
1492 case SOF2:
1493 case SOF3:
1494 case SOF5:
1495 case SOF6:
1496 case SOF7:
1497 case SOF9:
1498 case SOF10:
1499 case SOF11:
1500 case SOF13:
1501 case SOF14:
1502 case SOF15:
1503 case JPG:
1504 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1505 break;
1506 // default:
1507 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1508 // break;
1509 }
1510
1511 not_the_end:
1512 /* eof process start code */
1513 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1514 dprintf("marker parser used %d bytes (%d bits)\n",
1515 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1516 }
1517 }
1518 }
1519 the_end:
1520 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1521 // return buf_end - buf_ptr;
1522 return buf_ptr - buf;
1523 }
1524
1525 static int mjpegb_decode_frame(AVCodecContext *avctx,
1526 void *data, int *data_size,
1527 UINT8 *buf, int buf_size)
1528 {
1529 MJpegDecodeContext *s = avctx->priv_data;
1530 UINT8 *buf_end, *buf_ptr;
1531 int i;
1532 AVPicture *picture = data;
1533 GetBitContext hgb; /* for the header */
1534 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1535 uint32_t field_size;
1536
1537 *data_size = 0;
1538
1539 /* no supplementary picture */
1540 if (buf_size == 0)
1541 return 0;
1542
1543 buf_ptr = buf;
1544 buf_end = buf + buf_size;
1545
1546 read_header:
1547 /* reset on every SOI */
1548 s->restart_interval = 0;
1549
1550 init_get_bits(&hgb, buf_ptr, /*buf_size*/buf_end - buf_ptr);
1551
1552 skip_bits(&hgb, 32); /* reserved zeros */
1553
1554 if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1555 {
1556 dprintf("not mjpeg-b (bad fourcc)\n");
1557 return 0;
1558 }
1559
1560 field_size = get_bits(&hgb, 32); /* field size */
1561 dprintf("field size: 0x%x\n", field_size);
1562 skip_bits(&hgb, 32); /* padded field size */
1563 second_field_offs = get_bits(&hgb, 32);
1564 dprintf("second field offs: 0x%x\n", second_field_offs);
1565 if (second_field_offs)
1566 s->interlaced = 1;
1567
1568 dqt_offs = get_bits(&hgb, 32);
1569 dprintf("dqt offs: 0x%x\n", dqt_offs);
1570 if (dqt_offs)
1571 {
1572 init_get_bits(&s->gb, buf+dqt_offs, buf_end - (buf+dqt_offs));
1573 s->start_code = DQT;
1574 mjpeg_decode_dqt(s);
1575 }
1576
1577 dht_offs = get_bits(&hgb, 32);
1578 dprintf("dht offs: 0x%x\n", dht_offs);
1579 if (dht_offs)
1580 {
1581 init_get_bits(&s->gb, buf+dht_offs, buf_end - (buf+dht_offs));
1582 s->start_code = DHT;
1583 mjpeg_decode_dht(s);
1584 }
1585
1586 sof_offs = get_bits(&hgb, 32);
1587 dprintf("sof offs: 0x%x\n", sof_offs);
1588 if (sof_offs)
1589 {
1590 init_get_bits(&s->gb, buf+sof_offs, buf_end - (buf+sof_offs));
1591 s->start_code = SOF0;
1592 if (mjpeg_decode_sof0(s) < 0)
1593 return -1;
1594 }
1595
1596 sos_offs = get_bits(&hgb, 32);
1597 dprintf("sos offs: 0x%x\n", sos_offs);
1598 if (sos_offs)
1599 {
1600 // init_get_bits(&s->gb, buf+sos_offs, buf_end - (buf+sos_offs));
1601 init_get_bits(&s->gb, buf+sos_offs, field_size);
1602 s->start_code = SOS;
1603 mjpeg_decode_sos(s);
1604 }
1605
1606 skip_bits(&hgb, 32); /* start of data offset */
1607
1608 if (s->interlaced) {
1609 s->bottom_field ^= 1;
1610 /* if not bottom field, do not output image yet */
1611 if (s->bottom_field && second_field_offs)
1612 {
1613 buf_ptr = buf + second_field_offs;
1614 second_field_offs = 0;
1615 goto read_header;
1616 }
1617 }
1618
1619 for(i=0;i<3;i++) {
1620 picture->data[i] = s->current_picture[i];
1621 picture->linesize[i] = (s->interlaced) ?
1622 s->linesize[i] >> 1 : s->linesize[i];
1623 }
1624 *data_size = sizeof(AVPicture);
1625 avctx->height = s->height;
1626 if (s->interlaced)
1627 avctx->height *= 2;
1628 avctx->width = s->width;
1629 /* XXX: not complete test ! */
1630 switch((s->h_count[0] << 4) | s->v_count[0]) {
1631 case 0x11:
1632 avctx->pix_fmt = PIX_FMT_YUV444P;
1633 break;
1634 case 0x21:
1635 avctx->pix_fmt = PIX_FMT_YUV422P;
1636 break;
1637 default:
1638 case 0x22:
1639 avctx->pix_fmt = PIX_FMT_YUV420P;
1640 break;
1641 }
1642 /* dummy quality */
1643 /* XXX: infer it with matrix */
1644 // avctx->quality = 3;
1645
1646 return buf_ptr - buf;
1647 }
1648
1649
1650 static int mjpeg_decode_end(AVCodecContext *avctx)
1651 {
1652 MJpegDecodeContext *s = avctx->priv_data;
1653 int i, j;
1654
1655 av_free(s->buffer);
1656 for(i=0;i<MAX_COMPONENTS;i++)
1657 av_free(s->current_picture[i]);
1658 for(i=0;i<2;i++) {
1659 for(j=0;j<4;j++)
1660 free_vlc(&s->vlcs[i][j]);
1661 }
1662 return 0;
1663 }
1664
1665 AVCodec mjpeg_decoder = {
1666 "mjpeg",
1667 CODEC_TYPE_VIDEO,
1668 CODEC_ID_MJPEG,
1669 sizeof(MJpegDecodeContext),
1670 mjpeg_decode_init,
1671 NULL,
1672 mjpeg_decode_end,
1673 mjpeg_decode_frame,
1674 0,
1675 NULL
1676 };
1677
1678 AVCodec mjpegb_decoder = {
1679 "mjpegb",
1680 CODEC_TYPE_VIDEO,
1681 CODEC_ID_MJPEGB,
1682 sizeof(MJpegDecodeContext),
1683 mjpeg_decode_init,
1684 NULL,
1685 mjpeg_decode_end,
1686 mjpegb_decode_frame,
1687 0,
1688 NULL
1689 };
mob repository