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