projects / libav.git / blob
? search:


f2267faf8f714c6003269b503d7cb77f6dd6c4d1
[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, new decode_frame mechanism and apple mjpeg-b support
21 * by Alex Beregszaszi <alex@naxine.org>
22 */
23
24 /**
25 * @file mjpeg.c
26 * MJPEG encoder and decoder.
27 */
28
29 //#define DEBUG
30 #include <assert.h>
31
32 #include "avcodec.h"
33 #include "dsputil.h"
34 #include "mpegvideo.h"
35
36 /* use two quantizer tables (one for luminance and one for chrominance) */
37 /* not yet working */
38 #undef TWOMATRIXES
39
40 typedef struct MJpegContext {
41 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
42 uint16_t huff_code_dc_luminance[12];
43 uint8_t huff_size_dc_chrominance[12];
44 uint16_t huff_code_dc_chrominance[12];
45
46 uint8_t huff_size_ac_luminance[256];
47 uint16_t huff_code_ac_luminance[256];
48 uint8_t huff_size_ac_chrominance[256];
49 uint16_t huff_code_ac_chrominance[256];
50 } MJpegContext;
51
52 /* JPEG marker codes */
53 typedef enum {
54 /* start of frame */
55 SOF0 = 0xc0, /* baseline */
56 SOF1 = 0xc1, /* extended sequential, huffman */
57 SOF2 = 0xc2, /* progressive, huffman */
58 SOF3 = 0xc3, /* lossless, huffman */
59
60 SOF5 = 0xc5, /* differential sequential, huffman */
61 SOF6 = 0xc6, /* differential progressive, huffman */
62 SOF7 = 0xc7, /* differential lossless, huffman */
63 JPG = 0xc8, /* reserved for JPEG extension */
64 SOF9 = 0xc9, /* extended sequential, arithmetic */
65 SOF10 = 0xca, /* progressive, arithmetic */
66 SOF11 = 0xcb, /* lossless, arithmetic */
67
68 SOF13 = 0xcd, /* differential sequential, arithmetic */
69 SOF14 = 0xce, /* differential progressive, arithmetic */
70 SOF15 = 0xcf, /* differential lossless, arithmetic */
71
72 DHT = 0xc4, /* define huffman tables */
73
74 DAC = 0xcc, /* define arithmetic-coding conditioning */
75
76 /* restart with modulo 8 count "m" */
77 RST0 = 0xd0,
78 RST1 = 0xd1,
79 RST2 = 0xd2,
80 RST3 = 0xd3,
81 RST4 = 0xd4,
82 RST5 = 0xd5,
83 RST6 = 0xd6,
84 RST7 = 0xd7,
85
86 SOI = 0xd8, /* start of image */
87 EOI = 0xd9, /* end of image */
88 SOS = 0xda, /* start of scan */
89 DQT = 0xdb, /* define quantization tables */
90 DNL = 0xdc, /* define number of lines */
91 DRI = 0xdd, /* define restart interval */
92 DHP = 0xde, /* define hierarchical progression */
93 EXP = 0xdf, /* expand reference components */
94
95 APP0 = 0xe0,
96 APP1 = 0xe1,
97 APP2 = 0xe2,
98 APP3 = 0xe3,
99 APP4 = 0xe4,
100 APP5 = 0xe5,
101 APP6 = 0xe6,
102 APP7 = 0xe7,
103 APP8 = 0xe8,
104 APP9 = 0xe9,
105 APP10 = 0xea,
106 APP11 = 0xeb,
107 APP12 = 0xec,
108 APP13 = 0xed,
109 APP14 = 0xee,
110 APP15 = 0xef,
111
112 JPG0 = 0xf0,
113 JPG1 = 0xf1,
114 JPG2 = 0xf2,
115 JPG3 = 0xf3,
116 JPG4 = 0xf4,
117 JPG5 = 0xf5,
118 JPG6 = 0xf6,
119 JPG7 = 0xf7,
120 JPG8 = 0xf8,
121 JPG9 = 0xf9,
122 JPG10 = 0xfa,
123 JPG11 = 0xfb,
124 JPG12 = 0xfc,
125 JPG13 = 0xfd,
126
127 COM = 0xfe, /* comment */
128
129 TEM = 0x01, /* temporary private use for arithmetic coding */
130
131 /* 0x02 -> 0xbf reserved */
132 } JPEG_MARKER;
133
134 #if 0
135 /* These are the sample quantization tables given in JPEG spec section K.1.
136 * The spec says that the values given produce "good" quality, and
137 * when divided by 2, "very good" quality.
138 */
139 static const unsigned char std_luminance_quant_tbl[64] = {
140 16, 11, 10, 16, 24, 40, 51, 61,
141 12, 12, 14, 19, 26, 58, 60, 55,
142 14, 13, 16, 24, 40, 57, 69, 56,
143 14, 17, 22, 29, 51, 87, 80, 62,
144 18, 22, 37, 56, 68, 109, 103, 77,
145 24, 35, 55, 64, 81, 104, 113, 92,
146 49, 64, 78, 87, 103, 121, 120, 101,
147 72, 92, 95, 98, 112, 100, 103, 99
148 };
149 static const unsigned char std_chrominance_quant_tbl[64] = {
150 17, 18, 24, 47, 99, 99, 99, 99,
151 18, 21, 26, 66, 99, 99, 99, 99,
152 24, 26, 56, 99, 99, 99, 99, 99,
153 47, 66, 99, 99, 99, 99, 99, 99,
154 99, 99, 99, 99, 99, 99, 99, 99,
155 99, 99, 99, 99, 99, 99, 99, 99,
156 99, 99, 99, 99, 99, 99, 99, 99,
157 99, 99, 99, 99, 99, 99, 99, 99
158 };
159 #endif
160
161 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
162 /* IMPORTANT: these are only valid for 8-bit data precision! */
163 static const uint8_t bits_dc_luminance[17] =
164 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
165 static const uint8_t val_dc_luminance[] =
166 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
167
168 static const uint8_t bits_dc_chrominance[17] =
169 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
170 static const uint8_t val_dc_chrominance[] =
171 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
172
173 static const uint8_t bits_ac_luminance[17] =
174 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
175 static const uint8_t val_ac_luminance[] =
176 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
177 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
178 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
179 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
180 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
181 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
182 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
183 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
184 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
185 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
186 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
187 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
188 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
189 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
190 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
191 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
192 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
193 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
194 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
195 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
196 0xf9, 0xfa
197 };
198
199 static const uint8_t bits_ac_chrominance[17] =
200 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
201
202 static const uint8_t val_ac_chrominance[] =
203 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
204 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
205 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
206 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
207 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
208 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
209 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
210 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
211 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
212 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
213 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
214 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
215 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
216 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
217 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
218 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
219 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
220 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
221 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
222 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
223 0xf9, 0xfa
224 };
225
226 /* isn't this function nicer than the one in the libjpeg ? */
227 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
228 const uint8_t *bits_table, const uint8_t *val_table)
229 {
230 int i, j, k,nb, code, sym;
231
232 code = 0;
233 k = 0;
234 for(i=1;i<=16;i++) {
235 nb = bits_table[i];
236 for(j=0;j<nb;j++) {
237 sym = val_table[k++];
238 huff_size[sym] = i;
239 huff_code[sym] = code;
240 code++;
241 }
242 code <<= 1;
243 }
244 }
245
246 #ifdef CONFIG_ENCODERS
247 int mjpeg_init(MpegEncContext *s)
248 {
249 MJpegContext *m;
250
251 m = av_malloc(sizeof(MJpegContext));
252 if (!m)
253 return -1;
254
255 s->min_qcoeff=-1023;
256 s->max_qcoeff= 1023;
257
258 /* build all the huffman tables */
259 build_huffman_codes(m->huff_size_dc_luminance,
260 m->huff_code_dc_luminance,
261 bits_dc_luminance,
262 val_dc_luminance);
263 build_huffman_codes(m->huff_size_dc_chrominance,
264 m->huff_code_dc_chrominance,
265 bits_dc_chrominance,
266 val_dc_chrominance);
267 build_huffman_codes(m->huff_size_ac_luminance,
268 m->huff_code_ac_luminance,
269 bits_ac_luminance,
270 val_ac_luminance);
271 build_huffman_codes(m->huff_size_ac_chrominance,
272 m->huff_code_ac_chrominance,
273 bits_ac_chrominance,
274 val_ac_chrominance);
275
276 s->mjpeg_ctx = m;
277 return 0;
278 }
279
280 void mjpeg_close(MpegEncContext *s)
281 {
282 av_free(s->mjpeg_ctx);
283 }
284 #endif //CONFIG_ENCODERS
285
286 #define PREDICT(ret, topleft, top, left, predictor)\
287 switch(predictor){\
288 case 1: ret= left; break;\
289 case 2: ret= top; break;\
290 case 3: ret= topleft; break;\
291 case 4: ret= left + top - topleft; break;\
292 case 5: ret= left + ((top - topleft)>>1); break;\
293 case 6: ret= top + ((left - topleft)>>1); break;\
294 default:\
295 case 7: ret= (left + top)>>1; break;\
296 }
297
298 #ifdef CONFIG_ENCODERS
299 static inline void put_marker(PutBitContext *p, int code)
300 {
301 put_bits(p, 8, 0xff);
302 put_bits(p, 8, code);
303 }
304
305 /* table_class: 0 = DC coef, 1 = AC coefs */
306 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
307 const uint8_t *bits_table, const uint8_t *value_table)
308 {
309 PutBitContext *p = &s->pb;
310 int n, i;
311
312 put_bits(p, 4, table_class);
313 put_bits(p, 4, table_id);
314
315 n = 0;
316 for(i=1;i<=16;i++) {
317 n += bits_table[i];
318 put_bits(p, 8, bits_table[i]);
319 }
320
321 for(i=0;i<n;i++)
322 put_bits(p, 8, value_table[i]);
323
324 return n + 17;
325 }
326
327 static void jpeg_table_header(MpegEncContext *s)
328 {
329 PutBitContext *p = &s->pb;
330 int i, j, size;
331 uint8_t *ptr;
332
333 /* quant matrixes */
334 put_marker(p, DQT);
335 #ifdef TWOMATRIXES
336 put_bits(p, 16, 2 + 2 * (1 + 64));
337 #else
338 put_bits(p, 16, 2 + 1 * (1 + 64));
339 #endif
340 put_bits(p, 4, 0); /* 8 bit precision */
341 put_bits(p, 4, 0); /* table 0 */
342 for(i=0;i<64;i++) {
343 j = s->intra_scantable.permutated[i];
344 put_bits(p, 8, s->intra_matrix[j]);
345 }
346 #ifdef TWOMATRIXES
347 put_bits(p, 4, 0); /* 8 bit precision */
348 put_bits(p, 4, 1); /* table 1 */
349 for(i=0;i<64;i++) {
350 j = s->intra_scantable.permutated[i];
351 put_bits(p, 8, s->chroma_intra_matrix[j]);
352 }
353 #endif
354
355 /* huffman table */
356 put_marker(p, DHT);
357 flush_put_bits(p);
358 ptr = pbBufPtr(p);
359 put_bits(p, 16, 0); /* patched later */
360 size = 2;
361 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
362 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
363
364 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
365 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
366 ptr[0] = size >> 8;
367 ptr[1] = size;
368 }
369
370 static void jpeg_put_comments(MpegEncContext *s)
371 {
372 PutBitContext *p = &s->pb;
373 int size;
374 uint8_t *ptr;
375
376 if (s->aspect_ratio_info /* && !lossless */)
377 {
378 /* JFIF header */
379 put_marker(p, APP0);
380 put_bits(p, 16, 16);
381 put_string(p, "JFIF"); /* this puts the trailing zero-byte too */
382 put_bits(p, 16, 0x0201); /* v 1.02 */
383 put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
384 put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
385 put_bits(p, 16, s->avctx->sample_aspect_ratio.den);
386 put_bits(p, 8, 0); /* thumbnail width */
387 put_bits(p, 8, 0); /* thumbnail height */
388 }
389
390 /* comment */
391 if(!(s->flags & CODEC_FLAG_BITEXACT)){
392 put_marker(p, COM);
393 flush_put_bits(p);
394 ptr = pbBufPtr(p);
395 put_bits(p, 16, 0); /* patched later */
396 put_string(p, LIBAVCODEC_IDENT);
397 size = strlen(LIBAVCODEC_IDENT)+3;
398 ptr[0] = size >> 8;
399 ptr[1] = size;
400 }
401 }
402
403 void mjpeg_picture_header(MpegEncContext *s)
404 {
405 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
406
407 put_marker(&s->pb, SOI);
408
409 if (!s->mjpeg_data_only_frames)
410 {
411 jpeg_put_comments(s);
412
413 if (s->mjpeg_write_tables) jpeg_table_header(s);
414
415 put_marker(&s->pb, lossless ? SOF3 : SOF0);
416
417 put_bits(&s->pb, 16, 17);
418 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
419 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
420 else
421 put_bits(&s->pb, 8, 8); /* 8 bits/component */
422 put_bits(&s->pb, 16, s->height);
423 put_bits(&s->pb, 16, s->width);
424 put_bits(&s->pb, 8, 3); /* 3 components */
425
426 /* Y component */
427 put_bits(&s->pb, 8, 1); /* component number */
428 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
429 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
430 put_bits(&s->pb, 8, 0); /* select matrix */
431
432 /* Cb component */
433 put_bits(&s->pb, 8, 2); /* component number */
434 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
435 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
436 #ifdef TWOMATRIXES
437 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
438 #else
439 put_bits(&s->pb, 8, 0); /* select matrix */
440 #endif
441
442 /* Cr component */
443 put_bits(&s->pb, 8, 3); /* component number */
444 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
445 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
446 #ifdef TWOMATRIXES
447 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
448 #else
449 put_bits(&s->pb, 8, 0); /* select matrix */
450 #endif
451 }
452
453 /* scan header */
454 put_marker(&s->pb, SOS);
455 put_bits(&s->pb, 16, 12); /* length */
456 put_bits(&s->pb, 8, 3); /* 3 components */
457
458 /* Y component */
459 put_bits(&s->pb, 8, 1); /* index */
460 put_bits(&s->pb, 4, 0); /* DC huffman table index */
461 put_bits(&s->pb, 4, 0); /* AC huffman table index */
462
463 /* Cb component */
464 put_bits(&s->pb, 8, 2); /* index */
465 put_bits(&s->pb, 4, 1); /* DC huffman table index */
466 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
467
468 /* Cr component */
469 put_bits(&s->pb, 8, 3); /* index */
470 put_bits(&s->pb, 4, 1); /* DC huffman table index */
471 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
472
473 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
474 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
475 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
476 }
477
478 static void escape_FF(MpegEncContext *s, int start)
479 {
480 int size= get_bit_count(&s->pb) - start*8;
481 int i, ff_count;
482 uint8_t *buf= s->pb.buf + start;
483 int align= (-(size_t)(buf))&3;
484
485 assert((size&7) == 0);
486 size >>= 3;
487
488 ff_count=0;
489 for(i=0; i<size && i<align; i++){
490 if(buf[i]==0xFF) ff_count++;
491 }
492 for(; i<size-15; i+=16){
493 int acc, v;
494
495 v= *(uint32_t*)(&buf[i]);
496 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
497 v= *(uint32_t*)(&buf[i+4]);
498 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
499 v= *(uint32_t*)(&buf[i+8]);
500 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
501 v= *(uint32_t*)(&buf[i+12]);
502 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
503
504 acc>>=4;
505 acc+= (acc>>16);
506 acc+= (acc>>8);
507 ff_count+= acc&0xFF;
508 }
509 for(; i<size; i++){
510 if(buf[i]==0xFF) ff_count++;
511 }
512
513 if(ff_count==0) return;
514
515 /* skip put bits */
516 for(i=0; i<ff_count-3; i+=4)
517 put_bits(&s->pb, 32, 0);
518 put_bits(&s->pb, (ff_count-i)*8, 0);
519 flush_put_bits(&s->pb);
520
521 for(i=size-1; ff_count; i--){
522 int v= buf[i];
523
524 if(v==0xFF){
525 //printf("%d %d\n", i, ff_count);
526 buf[i+ff_count]= 0;
527 ff_count--;
528 }
529
530 buf[i+ff_count]= v;
531 }
532 }
533
534 void mjpeg_picture_trailer(MpegEncContext *s)
535 {
536 int pad= (-get_bit_count(&s->pb))&7;
537
538 put_bits(&s->pb, pad,0xFF>>(8-pad));
539 flush_put_bits(&s->pb);
540
541 assert((s->header_bits&7)==0);
542
543 escape_FF(s, s->header_bits>>3);
544
545 put_marker(&s->pb, EOI);
546 }
547
548 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
549 uint8_t *huff_size, uint16_t *huff_code)
550 {
551 int mant, nbits;
552
553 if (val == 0) {
554 put_bits(&s->pb, huff_size[0], huff_code[0]);
555 } else {
556 mant = val;
557 if (val < 0) {
558 val = -val;
559 mant--;
560 }
561
562 nbits= av_log2_16bit(val) + 1;
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_t *huff_size_ac;
576 uint16_t *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 nbits= av_log2(val) + 1;
614 code = (run << 4) | nbits;
615
616 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
617
618 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
619 run = 0;
620 }
621 }
622
623 /* output EOB only if not already 64 values */
624 if (last_index < 63 || run != 0)
625 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
626 }
627
628 void mjpeg_encode_mb(MpegEncContext *s,
629 DCTELEM block[6][64])
630 {
631 int i;
632 for(i=0;i<6;i++) {
633 encode_block(s, block[i], i);
634 }
635 }
636
637 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
638 MpegEncContext * const s = avctx->priv_data;
639 MJpegContext * const m = s->mjpeg_ctx;
640 AVFrame *pict = data;
641 const int width= s->width;
642 const int height= s->height;
643 AVFrame * const p= (AVFrame*)&s->current_picture;
644 const int predictor= avctx->prediction_method+1;
645
646 init_put_bits(&s->pb, buf, buf_size);
647
648 *p = *pict;
649 p->pict_type= FF_I_TYPE;
650 p->key_frame= 1;
651
652 mjpeg_picture_header(s);
653
654 s->header_bits= get_bit_count(&s->pb);
655
656 if(avctx->pix_fmt == PIX_FMT_RGBA32){
657 int x, y, i;
658 const int linesize= p->linesize[0];
659 uint16_t buffer[2048][4];
660 int left[3], top[3], topleft[3];
661
662 for(i=0; i<3; i++){
663 buffer[0][i]= 1 << (9 - 1);
664 }
665
666 for(y = 0; y < height; y++) {
667 const int modified_predictor= y ? predictor : 1;
668 uint8_t *ptr = p->data[0] + (linesize * y);
669
670 for(i=0; i<3; i++){
671 top[i]= left[i]= topleft[i]= buffer[0][i];
672 }
673 for(x = 0; x < width; x++) {
674 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
675 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
676 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
677
678 for(i=0;i<3;i++) {
679 int pred, diff;
680
681 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
682
683 topleft[i]= top[i];
684 top[i]= buffer[x+1][i];
685
686 left[i]= buffer[x][i];
687
688 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
689
690 if(i==0)
691 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
692 else
693 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
694 }
695 }
696 }
697 }else{
698 int mb_x, mb_y, i;
699 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
700 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
701
702 for(mb_y = 0; mb_y < mb_height; mb_y++) {
703 for(mb_x = 0; mb_x < mb_width; mb_x++) {
704 if(mb_x==0 || mb_y==0){
705 for(i=0;i<3;i++) {
706 uint8_t *ptr;
707 int x, y, h, v, linesize;
708 h = s->mjpeg_hsample[i];
709 v = s->mjpeg_vsample[i];
710 linesize= p->linesize[i];
711
712 for(y=0; y<v; y++){
713 for(x=0; x<h; x++){
714 int pred;
715
716 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
717 if(y==0 && mb_y==0){
718 if(x==0 && mb_x==0){
719 pred= 128;
720 }else{
721 pred= ptr[-1];
722 }
723 }else{
724 if(x==0 && mb_x==0){
725 pred= ptr[-linesize];
726 }else{
727 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
728 }
729 }
730
731 if(i==0)
732 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
733 else
734 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
735 }
736 }
737 }
738 }else{
739 for(i=0;i<3;i++) {
740 uint8_t *ptr;
741 int x, y, h, v, linesize;
742 h = s->mjpeg_hsample[i];
743 v = s->mjpeg_vsample[i];
744 linesize= p->linesize[i];
745
746 for(y=0; y<v; y++){
747 for(x=0; x<h; x++){
748 int pred;
749
750 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
751 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
752 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
753
754 if(i==0)
755 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
756 else
757 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
758 }
759 }
760 }
761 }
762 }
763 }
764 }
765
766 emms_c();
767
768 mjpeg_picture_trailer(s);
769 s->picture_number++;
770
771 flush_put_bits(&s->pb);
772 return pbBufPtr(&s->pb) - s->pb.buf;
773 // return (get_bit_count(&f->pb)+7)/8;
774 }
775
776 #endif //CONFIG_ENCODERS
777
778 /******************************************/
779 /* decoding */
780
781 #define MAX_COMPONENTS 4
782
783 typedef struct MJpegDecodeContext {
784 AVCodecContext *avctx;
785 GetBitContext gb;
786 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
787
788 int start_code; /* current start code */
789 int buffer_size;
790 uint8_t *buffer;
791
792 int16_t quant_matrixes[4][64];
793 VLC vlcs[2][4];
794 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
795
796 int org_width, org_height; /* size given at codec init */
797 int first_picture; /* true if decoding first picture */
798 int interlaced; /* true if interlaced */
799 int bottom_field; /* true if bottom field */
800 int lossless;
801 int rgb;
802 int rct; /* standard rct */
803 int pegasus_rct; /* pegasus reversible colorspace transform */
804 int bits; /* bits per component */
805
806 int width, height;
807 int mb_width, mb_height;
808 int nb_components;
809 int component_id[MAX_COMPONENTS];
810 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
811 int v_count[MAX_COMPONENTS];
812 int comp_index[MAX_COMPONENTS];
813 int dc_index[MAX_COMPONENTS];
814 int ac_index[MAX_COMPONENTS];
815 int nb_blocks[MAX_COMPONENTS];
816 int h_scount[MAX_COMPONENTS];
817 int v_scount[MAX_COMPONENTS];
818 int h_max, v_max; /* maximum h and v counts */
819 int quant_index[4]; /* quant table index for each component */
820 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
821 AVFrame picture; /* picture structure */
822 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
823 uint8_t *qscale_table;
824 DCTELEM block[64] __align8;
825 ScanTable scantable;
826 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
827
828 int restart_interval;
829 int restart_count;
830
831 int buggy_avid;
832 int interlace_polarity;
833 } MJpegDecodeContext;
834
835 static int mjpeg_decode_dht(MJpegDecodeContext *s);
836
837 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
838 int nb_codes)
839 {
840 uint8_t huff_size[256];
841 uint16_t huff_code[256];
842
843 memset(huff_size, 0, sizeof(huff_size));
844 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
845
846 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
847 }
848
849 static int mjpeg_decode_init(AVCodecContext *avctx)
850 {
851 MJpegDecodeContext *s = avctx->priv_data;
852 MpegEncContext s2;
853
854 s->avctx = avctx;
855
856 /* ugly way to get the idct & scantable FIXME */
857 memset(&s2, 0, sizeof(MpegEncContext));
858 s2.flags= avctx->flags;
859 s2.avctx= avctx;
860 // s2->out_format = FMT_MJPEG;
861 s2.width = 8;
862 s2.height = 8;
863 if (MPV_common_init(&s2) < 0)
864 return -1;
865 s->scantable= s2.intra_scantable;
866 s->idct_put= s2.dsp.idct_put;
867 MPV_common_end(&s2);
868
869 s->mpeg_enc_ctx_allocated = 0;
870 s->buffer_size = 102400; /* smaller buffer should be enough,
871 but photojpg files could ahive bigger sizes */
872 s->buffer = av_malloc(s->buffer_size);
873 if (!s->buffer)
874 return -1;
875 s->start_code = -1;
876 s->first_picture = 1;
877 s->org_width = avctx->width;
878 s->org_height = avctx->height;
879
880 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
881 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
882 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
883 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
884
885 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
886 {
887 printf("mjpeg: using external huffman table\n");
888 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
889 mjpeg_decode_dht(s);
890 /* should check for error - but dunno */
891 }
892
893 return 0;
894 }
895
896 /* quantize tables */
897 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
898 {
899 int len, index, i, j;
900
901 len = get_bits(&s->gb, 16) - 2;
902
903 while (len >= 65) {
904 /* only 8 bit precision handled */
905 if (get_bits(&s->gb, 4) != 0)
906 {
907 dprintf("dqt: 16bit precision\n");
908 return -1;
909 }
910 index = get_bits(&s->gb, 4);
911 if (index >= 4)
912 return -1;
913 dprintf("index=%d\n", index);
914 /* read quant table */
915 for(i=0;i<64;i++) {
916 j = s->scantable.permutated[i];
917 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
918 }
919
920 //XXX FIXME finetune, and perhaps add dc too
921 s->qscale[index]= FFMAX(
922 s->quant_matrixes[index][s->scantable.permutated[1]],
923 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
924 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
925 len -= 65;
926 }
927
928 return 0;
929 }
930
931 /* decode huffman tables and build VLC decoders */
932 static int mjpeg_decode_dht(MJpegDecodeContext *s)
933 {
934 int len, index, i, class, n, v, code_max;
935 uint8_t bits_table[17];
936 uint8_t val_table[256];
937
938 len = get_bits(&s->gb, 16) - 2;
939
940 while (len > 0) {
941 if (len < 17)
942 return -1;
943 class = get_bits(&s->gb, 4);
944 if (class >= 2)
945 return -1;
946 index = get_bits(&s->gb, 4);
947 if (index >= 4)
948 return -1;
949 n = 0;
950 for(i=1;i<=16;i++) {
951 bits_table[i] = get_bits(&s->gb, 8);
952 n += bits_table[i];
953 }
954 len -= 17;
955 if (len < n || n > 256)
956 return -1;
957
958 code_max = 0;
959 for(i=0;i<n;i++) {
960 v = get_bits(&s->gb, 8);
961 if (v > code_max)
962 code_max = v;
963 val_table[i] = v;
964 }
965 len -= n;
966
967 /* build VLC and flush previous vlc if present */
968 free_vlc(&s->vlcs[class][index]);
969 dprintf("class=%d index=%d nb_codes=%d\n",
970 class, index, code_max + 1);
971 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
972 return -1;
973 }
974 }
975 return 0;
976 }
977
978 static int mjpeg_decode_sof(MJpegDecodeContext *s)
979 {
980 int len, nb_components, i, width, height;
981
982 /* XXX: verify len field validity */
983 len = get_bits(&s->gb, 16);
984 s->bits= get_bits(&s->gb, 8);
985
986 if(s->pegasus_rct) s->bits=9;
987 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
988
989 if (s->bits != 8 && !s->lossless){
990 printf("only 8 bits/component accepted\n");
991 return -1;
992 }
993 height = get_bits(&s->gb, 16);
994 width = get_bits(&s->gb, 16);
995 dprintf("sof0: picture: %dx%d\n", width, height);
996
997 nb_components = get_bits(&s->gb, 8);
998 if (nb_components <= 0 ||
999 nb_components > MAX_COMPONENTS)
1000 return -1;
1001 s->nb_components = nb_components;
1002 s->h_max = 1;
1003 s->v_max = 1;
1004 for(i=0;i<nb_components;i++) {
1005 /* component id */
1006 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1007 s->h_count[i] = get_bits(&s->gb, 4);
1008 s->v_count[i] = get_bits(&s->gb, 4);
1009 /* compute hmax and vmax (only used in interleaved case) */
1010 if (s->h_count[i] > s->h_max)
1011 s->h_max = s->h_count[i];
1012 if (s->v_count[i] > s->v_max)
1013 s->v_max = s->v_count[i];
1014 s->quant_index[i] = get_bits(&s->gb, 8);
1015 if (s->quant_index[i] >= 4)
1016 return -1;
1017 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1018 s->v_count[i], s->component_id[i], s->quant_index[i]);
1019 }
1020
1021 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1022
1023 /* if different size, realloc/alloc picture */
1024 /* XXX: also check h_count and v_count */
1025 if (width != s->width || height != s->height) {
1026 av_freep(&s->qscale_table);
1027
1028 s->width = width;
1029 s->height = height;
1030 /* test interlaced mode */
1031 if (s->first_picture &&
1032 s->org_height != 0 &&
1033 s->height < ((s->org_height * 3) / 4)) {
1034 s->interlaced = 1;
1035 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1036 s->bottom_field = 0;
1037 }
1038
1039 s->qscale_table= av_mallocz((s->width+15)/16);
1040
1041 s->first_picture = 0;
1042 }
1043
1044 if(s->interlaced && s->bottom_field)
1045 return 0;
1046
1047 /* XXX: not complete test ! */
1048 switch((s->h_count[0] << 4) | s->v_count[0]) {
1049 case 0x11:
1050 if(s->rgb){
1051 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1052 }else
1053 s->avctx->pix_fmt = PIX_FMT_YUV444P;
1054 break;
1055 case 0x21:
1056 s->avctx->pix_fmt = PIX_FMT_YUV422P;
1057 break;
1058 default:
1059 case 0x22:
1060 s->avctx->pix_fmt = PIX_FMT_YUV420P;
1061 break;
1062 }
1063
1064 if(s->picture.data[0])
1065 s->avctx->release_buffer(s->avctx, &s->picture);
1066
1067 s->picture.reference= 0;
1068 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1069 fprintf(stderr, "get_buffer() failed\n");
1070 return -1;
1071 }
1072 s->picture.pict_type= I_TYPE;
1073 s->picture.key_frame= 1;
1074
1075 for(i=0; i<3; i++){
1076 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1077 }
1078
1079 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1080
1081 if (len != (8+(3*nb_components)))
1082 {
1083 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1084 }
1085
1086 return 0;
1087 }
1088
1089 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1090 {
1091 int code;
1092 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1093 if (code < 0)
1094 {
1095 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1096 &s->vlcs[0][dc_index]);
1097 return 0xffff;
1098 }
1099
1100 if(code)
1101 return get_xbits(&s->gb, code);
1102 else
1103 return 0;
1104 }
1105
1106 /* decode block and dequantize */
1107 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1108 int component, int dc_index, int ac_index, int quant_index)
1109 {
1110 int code, i, j, level, val;
1111 VLC *ac_vlc;
1112 int16_t *quant_matrix;
1113
1114 /* DC coef */
1115 val = mjpeg_decode_dc(s, dc_index);
1116 if (val == 0xffff) {
1117 dprintf("error dc\n");
1118 return -1;
1119 }
1120 quant_matrix = s->quant_matrixes[quant_index];
1121 val = val * quant_matrix[0] + s->last_dc[component];
1122 s->last_dc[component] = val;
1123 block[0] = val;
1124 /* AC coefs */
1125 ac_vlc = &s->vlcs[1][ac_index];
1126 i = 1;
1127 for(;;) {
1128 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1129
1130 if (code < 0) {
1131 dprintf("error ac\n");
1132 return -1;
1133 }
1134 /* EOB */
1135 if (code == 0)
1136 break;
1137 if (code == 0xf0) {
1138 i += 16;
1139 } else {
1140 level = get_xbits(&s->gb, code & 0xf);
1141 i += code >> 4;
1142 if (i >= 64) {
1143 dprintf("error count: %d\n", i);
1144 return -1;
1145 }
1146 j = s->scantable.permutated[i];
1147 block[j] = level * quant_matrix[j];
1148 i++;
1149 if (i >= 64)
1150 break;
1151 }
1152 }
1153 return 0;
1154 }
1155
1156 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1157 int i, mb_x, mb_y;
1158 uint16_t buffer[2048][4];
1159 int left[3], top[3], topleft[3];
1160 const int linesize= s->linesize[0];
1161 const int mask= (1<<s->bits)-1;
1162
1163 for(i=0; i<3; i++){
1164 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1165 }
1166 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1167 const int modified_predictor= mb_y ? predictor : 1;
1168 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1169
1170 if (s->interlaced && s->bottom_field)
1171 ptr += linesize >> 1;
1172
1173 for(i=0; i<3; i++){
1174 top[i]= left[i]= topleft[i]= buffer[0][i];
1175 }
1176 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1177 if (s->restart_interval && !s->restart_count)
1178 s->restart_count = s->restart_interval;
1179
1180 for(i=0;i<3;i++) {
1181 int pred;
1182
1183 topleft[i]= top[i];
1184 top[i]= buffer[mb_x][i];
1185
1186 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1187
1188 left[i]=
1189 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1190 }
1191
1192 if (s->restart_interval && !--s->restart_count) {
1193 align_get_bits(&s->gb);
1194 skip_bits(&s->gb, 16); /* skip RSTn */
1195 }
1196 }
1197
1198 if(s->rct){
1199 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1200 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1201 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1202 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1203 }
1204 }else if(s->pegasus_rct){
1205 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1206 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1207 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1208 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1209 }
1210 }else{
1211 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1212 ptr[4*mb_x+0] = buffer[mb_x][0];
1213 ptr[4*mb_x+1] = buffer[mb_x][1];
1214 ptr[4*mb_x+2] = buffer[mb_x][2];
1215 }
1216 }
1217 }
1218 return 0;
1219 }
1220
1221 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1222 int i, mb_x, mb_y;
1223 const int nb_components=3;
1224
1225 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1226 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1227 if (s->restart_interval && !s->restart_count)
1228 s->restart_count = s->restart_interval;
1229
1230 if(mb_x==0 || mb_y==0 || s->interlaced){
1231 for(i=0;i<nb_components;i++) {
1232 uint8_t *ptr;
1233 int n, h, v, x, y, c, j, linesize;
1234 n = s->nb_blocks[i];
1235 c = s->comp_index[i];
1236 h = s->h_scount[i];
1237 v = s->v_scount[i];
1238 x = 0;
1239 y = 0;
1240 linesize= s->linesize[c];
1241
1242 for(j=0; j<n; j++) {
1243 int pred;
1244
1245 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1246 if(y==0 && mb_y==0){
1247 if(x==0 && mb_x==0){
1248 pred= 128 << point_transform;
1249 }else{
1250 pred= ptr[-1];
1251 }
1252 }else{
1253 if(x==0 && mb_x==0){
1254 pred= ptr[-linesize];
1255 }else{
1256 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1257 }
1258 }
1259
1260 if (s->interlaced && s->bottom_field)
1261 ptr += linesize >> 1;
1262 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1263
1264 if (++x == h) {
1265 x = 0;
1266 y++;
1267 }
1268 }
1269 }
1270 }else{
1271 for(i=0;i<nb_components;i++) {
1272 uint8_t *ptr;
1273 int n, h, v, x, y, c, j, linesize;
1274 n = s->nb_blocks[i];
1275 c = s->comp_index[i];
1276 h = s->h_scount[i];
1277 v = s->v_scount[i];
1278 x = 0;
1279 y = 0;
1280 linesize= s->linesize[c];
1281
1282 for(j=0; j<n; j++) {
1283 int pred;
1284
1285 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1286 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1287 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1288 if (++x == h) {
1289 x = 0;
1290 y++;
1291 }
1292 }
1293 }
1294 }
1295 if (s->restart_interval && !--s->restart_count) {
1296 align_get_bits(&s->gb);
1297 skip_bits(&s->gb, 16); /* skip RSTn */
1298 }
1299 }
1300 }
1301 return 0;
1302 }
1303
1304 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1305 int i, mb_x, mb_y;
1306 const int nb_components=3;
1307
1308 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1309 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1310 if (s->restart_interval && !s->restart_count)
1311 s->restart_count = s->restart_interval;
1312
1313 for(i=0;i<nb_components;i++) {
1314 uint8_t *ptr;
1315 int n, h, v, x, y, c, j;
1316 n = s->nb_blocks[i];
1317 c = s->comp_index[i];
1318 h = s->h_scount[i];
1319 v = s->v_scount[i];
1320 x = 0;
1321 y = 0;
1322 for(j=0;j<n;j++) {
1323 memset(s->block, 0, sizeof(s->block));
1324 if (decode_block(s, s->block, i,
1325 s->dc_index[i], s->ac_index[i],
1326 s->quant_index[c]) < 0) {
1327 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1328 return -1;
1329 }
1330 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1331 ptr = s->picture.data[c] +
1332 (s->linesize[c] * (v * mb_y + y) * 8) +
1333 (h * mb_x + x) * 8;
1334 if (s->interlaced && s->bottom_field)
1335 ptr += s->linesize[c] >> 1;
1336 //printf("%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
1337 s->idct_put(ptr, s->linesize[c], s->block);
1338 if (++x == h) {
1339 x = 0;
1340 y++;
1341 }
1342 }
1343 }
1344 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1345 if (s->restart_interval && (s->restart_interval < 1350) &&
1346 !--s->restart_count) {
1347 align_get_bits(&s->gb);
1348 skip_bits(&s->gb, 16); /* skip RSTn */
1349 for (i=0; i<nb_components; i++) /* reset dc */
1350 s->last_dc[i] = 1024;
1351 }
1352 }
1353 }
1354 return 0;
1355 }
1356
1357 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1358 {
1359 int len, nb_components, i, h, v, predictor, point_transform;
1360 int vmax, hmax, index, id;
1361 const int block_size= s->lossless ? 1 : 8;
1362
1363 /* XXX: verify len field validity */
1364 len = get_bits(&s->gb, 16);
1365 nb_components = get_bits(&s->gb, 8);
1366 if (len != 6+2*nb_components)
1367 {
1368 dprintf("decode_sos: invalid len (%d)\n", len);
1369 return -1;
1370 }
1371 /* XXX: only interleaved scan accepted */
1372 if (nb_components != 3)
1373 {
1374 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1375 return -1;
1376 }
1377 vmax = 0;
1378 hmax = 0;
1379 for(i=0;i<nb_components;i++) {
1380 id = get_bits(&s->gb, 8) - 1;
1381 dprintf("component: %d\n", id);
1382 /* find component index */
1383 for(index=0;index<s->nb_components;index++)
1384 if (id == s->component_id[index])
1385 break;
1386 if (index == s->nb_components)
1387 {
1388 dprintf("decode_sos: index(%d) out of components\n", index);
1389 return -1;
1390 }
1391
1392 s->comp_index[i] = index;
1393
1394 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1395 s->h_scount[i] = s->h_count[index];
1396 s->v_scount[i] = s->v_count[index];
1397
1398 s->dc_index[i] = get_bits(&s->gb, 4);
1399 s->ac_index[i] = get_bits(&s->gb, 4);
1400
1401 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1402 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1403 goto out_of_range;
1404 #if 0 //buggy
1405 switch(s->start_code)
1406 {
1407 case SOF0:
1408 if (dc_index[i] > 1 || ac_index[i] > 1)
1409 goto out_of_range;
1410 break;
1411 case SOF1:
1412 case SOF2:
1413 if (dc_index[i] > 3 || ac_index[i] > 3)
1414 goto out_of_range;
1415 break;
1416 case SOF3:
1417 if (dc_index[i] > 3 || ac_index[i] != 0)
1418 goto out_of_range;
1419 break;
1420 }
1421 #endif
1422 }
1423
1424 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1425 skip_bits(&s->gb, 8); /* Se */
1426 skip_bits(&s->gb, 4); /* Ah */
1427 point_transform= get_bits(&s->gb, 4); /* Al */
1428
1429 for(i=0;i<nb_components;i++)
1430 s->last_dc[i] = 1024;
1431
1432 if (nb_components > 1) {
1433 /* interleaved stream */
1434 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1435 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1436 } else {
1437 h = s->h_max / s->h_scount[s->comp_index[0]];
1438 v = s->v_max / s->v_scount[s->comp_index[0]];
1439 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1440 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1441 s->nb_blocks[0] = 1;
1442 s->h_scount[0] = 1;
1443 s->v_scount[0] = 1;
1444 }
1445
1446 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1447 printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1448
1449 if(s->lossless){
1450 if(s->rgb){
1451 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1452 return -1;
1453 }else{
1454 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1455 return -1;
1456 }
1457 }else{
1458 if(mjpeg_decode_scan(s) < 0)
1459 return -1;
1460 }
1461 emms_c();
1462 return 0;
1463 out_of_range:
1464 dprintf("decode_sos: ac/dc index out of range\n");
1465 return -1;
1466 }
1467
1468 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1469 {
1470 if (get_bits(&s->gb, 16) != 4)
1471 return -1;
1472 s->restart_interval = get_bits(&s->gb, 16);
1473 dprintf("restart interval: %d\n", s->restart_interval);
1474
1475 return 0;
1476 }
1477
1478 static int mjpeg_decode_app(MJpegDecodeContext *s)
1479 {
1480 int len, id;
1481
1482 /* XXX: verify len field validity */
1483 len = get_bits(&s->gb, 16);
1484 if (len < 5)
1485 return -1;
1486
1487 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1488 id = be2me_32(id);
1489 len -= 6;
1490
1491 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1492 printf("APPx %8X\n", id);
1493 }
1494
1495 /* buggy AVID, it puts EOI only at every 10th frame */
1496 /* also this fourcc is used by non-avid files too, it holds some
1497 informations, but it's always present in AVID creates files */
1498 if (id == ff_get_fourcc("AVI1"))
1499 {
1500 /* structure:
1501 4bytes AVI1
1502 1bytes polarity
1503 1bytes always zero
1504 4bytes field_size
1505 4bytes field_size_less_padding
1506 */
1507 s->buggy_avid = 1;
1508 // if (s->first_picture)
1509 // printf("mjpeg: workarounding buggy AVID\n");
1510 s->interlace_polarity = get_bits(&s->gb, 8);
1511 #if 0
1512 skip_bits(&s->gb, 8);
1513 skip_bits(&s->gb, 32);
1514 skip_bits(&s->gb, 32);
1515 len -= 10;
1516 #endif
1517 // if (s->interlace_polarity)
1518 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1519 goto out;
1520 }
1521
1522 // len -= 2;
1523
1524 if (id == ff_get_fourcc("JFIF"))
1525 {
1526 int t_w, t_h;
1527 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1528 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1529 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1530 skip_bits(&s->gb, 8);
1531
1532 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1533 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1534
1535 t_w = get_bits(&s->gb, 8);
1536 t_h = get_bits(&s->gb, 8);
1537 if (t_w && t_h)
1538 {
1539 /* skip thumbnail */
1540 if (len-10-(t_w*t_h*3) > 0)
1541 len -= t_w*t_h*3;
1542 }
1543 len -= 10;
1544 goto out;
1545 }
1546
1547 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1548 {
1549 printf("mjpeg: Adobe header found\n");
1550 skip_bits(&s->gb, 16); /* version */
1551 skip_bits(&s->gb, 16); /* flags0 */
1552 skip_bits(&s->gb, 16); /* flags1 */
1553 skip_bits(&s->gb, 8); /* transform */
1554 len -= 7;
1555 goto out;
1556 }
1557
1558 if (id == ff_get_fourcc("LJIF")){
1559 printf("Pegasus lossless jpeg header found\n");
1560 skip_bits(&s->gb, 16); /* version ? */
1561 skip_bits(&s->gb, 16); /* unknwon always 0? */
1562 skip_bits(&s->gb, 16); /* unknwon always 0? */
1563 skip_bits(&s->gb, 16); /* unknwon always 0? */
1564 switch( get_bits(&s->gb, 8)){
1565 case 1:
1566 s->rgb= 1;
1567 s->pegasus_rct=0;
1568 break;
1569 case 2:
1570 s->rgb= 1;
1571 s->pegasus_rct=1;
1572 break;
1573 default:
1574 printf("unknown colorspace\n");
1575 }
1576 len -= 9;
1577 goto out;
1578 }
1579
1580 /* Apple MJPEG-A */
1581 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1582 {
1583 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1584 id = be2me_32(id);
1585 len -= 4;
1586 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1587 {
1588 #if 0
1589 skip_bits(&s->gb, 32); /* field size */
1590 skip_bits(&s->gb, 32); /* pad field size */
1591 skip_bits(&s->gb, 32); /* next off */
1592 skip_bits(&s->gb, 32); /* quant off */
1593 skip_bits(&s->gb, 32); /* huff off */
1594 skip_bits(&s->gb, 32); /* image off */
1595 skip_bits(&s->gb, 32); /* scan off */
1596 skip_bits(&s->gb, 32); /* data off */
1597 #endif
1598 if (s->first_picture)
1599 printf("mjpeg: Apple MJPEG-A header found\n");
1600 }
1601 }
1602
1603 out:
1604 /* slow but needed for extreme adobe jpegs */
1605 if (len < 0)
1606 printf("mjpeg: error, decode_app parser read over the end\n");
1607 while(--len > 0)
1608 skip_bits(&s->gb, 8);
1609
1610 return 0;
1611 }
1612
1613 static int mjpeg_decode_com(MJpegDecodeContext *s)
1614 {
1615 /* XXX: verify len field validity */
1616 int len = get_bits(&s->gb, 16);
1617 if (len >= 2 && len < 32768) {
1618 /* XXX: any better upper bound */
1619 uint8_t *cbuf = av_malloc(len - 1);
1620 if (cbuf) {
1621 int i;
1622 for (i = 0; i < len - 2; i++)
1623 cbuf[i] = get_bits(&s->gb, 8);
1624 if (i > 0 && cbuf[i-1] == '\n')
1625 cbuf[i-1] = 0;
1626 else
1627 cbuf[i] = 0;
1628
1629 printf("mjpeg comment: '%s'\n", cbuf);
1630
1631 /* buggy avid, it puts EOI only at every 10th frame */
1632 if (!strcmp(cbuf, "AVID"))
1633 {
1634 s->buggy_avid = 1;
1635 // if (s->first_picture)
1636 // printf("mjpeg: workarounding buggy AVID\n");
1637 }
1638
1639 av_free(cbuf);
1640 }
1641 }
1642
1643 return 0;
1644 }
1645
1646 #if 0
1647 static int valid_marker_list[] =
1648 {
1649 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1650 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1651 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1652 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1653 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1654 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1655 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1656 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1657 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1658 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1659 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1660 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1661 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1662 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1663 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1664 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1665 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1666 }
1667 #endif
1668
1669 /* return the 8 bit start code value and update the search
1670 state. Return -1 if no start code found */
1671 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1672 {
1673 uint8_t *buf_ptr;
1674 unsigned int v, v2;
1675 int val;
1676 #ifdef DEBUG
1677 int skipped=0;
1678 #endif
1679
1680 buf_ptr = *pbuf_ptr;
1681 while (buf_ptr < buf_end) {
1682 v = *buf_ptr++;
1683 v2 = *buf_ptr;
1684 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1685 val = *buf_ptr++;
1686 goto found;
1687 }
1688 #ifdef DEBUG
1689 skipped++;
1690 #endif
1691 }
1692 val = -1;
1693 found:
1694 #ifdef DEBUG
1695 dprintf("find_marker skipped %d bytes\n", skipped);
1696 #endif
1697 *pbuf_ptr = buf_ptr;
1698 return val;
1699 }
1700
1701 static int mjpeg_decode_frame(AVCodecContext *avctx,
1702 void *data, int *data_size,
1703 uint8_t *buf, int buf_size)
1704 {
1705 MJpegDecodeContext *s = avctx->priv_data;
1706 uint8_t *buf_end, *buf_ptr;
1707 int start_code;
1708 AVFrame *picture = data;
1709
1710 *data_size = 0;
1711
1712 /* no supplementary picture */
1713 if (buf_size == 0)
1714 return 0;
1715
1716 buf_ptr = buf;
1717 buf_end = buf + buf_size;
1718 while (buf_ptr < buf_end) {
1719 /* find start next marker */
1720 start_code = find_marker(&buf_ptr, buf_end);
1721 {
1722 /* EOF */
1723 if (start_code < 0) {
1724 goto the_end;
1725 } else {
1726 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1727
1728 if ((buf_end - buf_ptr) > s->buffer_size)
1729 {
1730 av_free(s->buffer);
1731 s->buffer_size = buf_end-buf_ptr;
1732 s->buffer = av_malloc(s->buffer_size);
1733 dprintf("buffer too small, expanding to %d bytes\n",
1734 s->buffer_size);
1735 }
1736
1737 /* unescape buffer of SOS */
1738 if (start_code == SOS)
1739 {
1740 uint8_t *src = buf_ptr;
1741 uint8_t *dst = s->buffer;
1742
1743 while (src<buf_end)
1744 {
1745 uint8_t x = *(src++);
1746
1747 *(dst++) = x;
1748 if (x == 0xff)
1749 {
1750 while(*src == 0xff) src++;
1751
1752 x = *(src++);
1753 if (x >= 0xd0 && x <= 0xd7)
1754 *(dst++) = x;
1755 else if (x)
1756 break;
1757 }
1758 }
1759 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1760
1761 dprintf("escaping removed %d bytes\n",
1762 (buf_end - buf_ptr) - (dst - s->buffer));
1763 }
1764 else
1765 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1766
1767 s->start_code = start_code;
1768 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1769 printf("startcode: %X\n", start_code);
1770 }
1771
1772 /* process markers */
1773 if (start_code >= 0xd0 && start_code <= 0xd7) {
1774 dprintf("restart marker: %d\n", start_code&0x0f);
1775 } else if (s->first_picture) {
1776 /* APP fields */
1777 if (start_code >= 0xe0 && start_code <= 0xef)
1778 mjpeg_decode_app(s);
1779 /* Comment */
1780 else if (start_code == COM)
1781 mjpeg_decode_com(s);
1782 }
1783
1784 switch(start_code) {
1785 case SOI:
1786 s->restart_interval = 0;
1787 /* nothing to do on SOI */
1788 break;
1789 case DQT:
1790 mjpeg_decode_dqt(s);
1791 break;
1792 case DHT:
1793 if(mjpeg_decode_dht(s) < 0){
1794 fprintf(stderr, "huffman table decode error\n");
1795 return -1;
1796 }
1797 break;
1798 case SOF0:
1799 s->lossless=0;
1800 if (mjpeg_decode_sof(s) < 0)
1801 return -1;
1802 break;
1803 case SOF3:
1804 s->lossless=1;
1805 if (mjpeg_decode_sof(s) < 0)
1806 return -1;
1807 break;
1808 case EOI:
1809 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1810 break;
1811 eoi_parser:
1812 {
1813 if (s->interlaced) {
1814 s->bottom_field ^= 1;
1815 /* if not bottom field, do not output image yet */
1816 if (s->bottom_field)
1817 goto not_the_end;
1818 }
1819 *picture = s->picture;
1820 *data_size = sizeof(AVFrame);
1821 avctx->height = s->height;
1822 if (s->interlaced)
1823 avctx->height *= 2;
1824 avctx->width = s->width;
1825
1826 if(!s->lossless){
1827 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1828 picture->qstride= 0;
1829 picture->qscale_table= s->qscale_table;
1830 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1831 if(avctx->debug & FF_DEBUG_QP)
1832 printf("QP: %d\n", picture->quality);
1833 picture->quality*= FF_QP2LAMBDA;
1834 }
1835
1836 goto the_end;
1837 }
1838 break;
1839 case SOS:
1840 mjpeg_decode_sos(s);
1841 /* buggy avid puts EOI every 10-20th frame */
1842 /* if restart period is over process EOI */
1843 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1844 goto eoi_parser;
1845 break;
1846 case DRI:
1847 mjpeg_decode_dri(s);
1848 break;
1849 case SOF1:
1850 case SOF2:
1851 case SOF5:
1852 case SOF6:
1853 case SOF7:
1854 case SOF9:
1855 case SOF10:
1856 case SOF11:
1857 case SOF13:
1858 case SOF14:
1859 case SOF15:
1860 case JPG:
1861 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1862 break;
1863 // default:
1864 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1865 // break;
1866 }
1867
1868 not_the_end:
1869 /* eof process start code */
1870 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1871 dprintf("marker parser used %d bytes (%d bits)\n",
1872 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1873 }
1874 }
1875 }
1876 the_end:
1877 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1878 // return buf_end - buf_ptr;
1879 return buf_ptr - buf;
1880 }
1881
1882 static int mjpegb_decode_frame(AVCodecContext *avctx,
1883 void *data, int *data_size,
1884 uint8_t *buf, int buf_size)
1885 {
1886 MJpegDecodeContext *s = avctx->priv_data;
1887 uint8_t *buf_end, *buf_ptr;
1888 AVFrame *picture = data;
1889 GetBitContext hgb; /* for the header */
1890 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1891 uint32_t field_size;
1892
1893 *data_size = 0;
1894
1895 /* no supplementary picture */
1896 if (buf_size == 0)
1897 return 0;
1898
1899 buf_ptr = buf;
1900 buf_end = buf + buf_size;
1901
1902 read_header:
1903 /* reset on every SOI */
1904 s->restart_interval = 0;
1905
1906 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1907
1908 skip_bits(&hgb, 32); /* reserved zeros */
1909
1910 if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1911 {
1912 dprintf("not mjpeg-b (bad fourcc)\n");
1913 return 0;
1914 }
1915
1916 field_size = get_bits(&hgb, 32); /* field size */
1917 dprintf("field size: 0x%x\n", field_size);
1918 skip_bits(&hgb, 32); /* padded field size */
1919 second_field_offs = get_bits(&hgb, 32);
1920 dprintf("second field offs: 0x%x\n", second_field_offs);
1921 if (second_field_offs)
1922 s->interlaced = 1;
1923
1924 dqt_offs = get_bits(&hgb, 32);
1925 dprintf("dqt offs: 0x%x\n", dqt_offs);
1926 if (dqt_offs)
1927 {
1928 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1929 s->start_code = DQT;
1930 mjpeg_decode_dqt(s);
1931 }
1932
1933 dht_offs = get_bits(&hgb, 32);
1934 dprintf("dht offs: 0x%x\n", dht_offs);
1935 if (dht_offs)
1936 {
1937 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1938 s->start_code = DHT;
1939 mjpeg_decode_dht(s);
1940 }
1941
1942 sof_offs = get_bits(&hgb, 32);
1943 dprintf("sof offs: 0x%x\n", sof_offs);
1944 if (sof_offs)
1945 {
1946 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1947 s->start_code = SOF0;
1948 if (mjpeg_decode_sof(s) < 0)
1949 return -1;
1950 }
1951
1952 sos_offs = get_bits(&hgb, 32);
1953 dprintf("sos offs: 0x%x\n", sos_offs);
1954 if (sos_offs)
1955 {
1956 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1957 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1958 s->start_code = SOS;
1959 mjpeg_decode_sos(s);
1960 }
1961
1962 skip_bits(&hgb, 32); /* start of data offset */
1963
1964 if (s->interlaced) {
1965 s->bottom_field ^= 1;
1966 /* if not bottom field, do not output image yet */
1967 if (s->bottom_field && second_field_offs)
1968 {
1969 buf_ptr = buf + second_field_offs;
1970 second_field_offs = 0;
1971 goto read_header;
1972 }
1973 }
1974
1975 //XXX FIXME factorize, this looks very similar to the EOI code
1976
1977 *picture= s->picture;
1978 *data_size = sizeof(AVFrame);
1979 avctx->height = s->height;
1980 if (s->interlaced)
1981 avctx->height *= 2;
1982 avctx->width = s->width;
1983
1984 if(!s->lossless){
1985 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1986 picture->qstride= 0;
1987 picture->qscale_table= s->qscale_table;
1988 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1989 if(avctx->debug & FF_DEBUG_QP)
1990 printf("QP: %d\n", picture->quality);
1991 picture->quality*= FF_QP2LAMBDA;
1992 }
1993
1994 return buf_ptr - buf;
1995 }
1996
1997 #include "sp5x.h"
1998
1999 static int sp5x_decode_frame(AVCodecContext *avctx,
2000 void *data, int *data_size,
2001 uint8_t *buf, int buf_size)
2002 {
2003 #if 0
2004 MJpegDecodeContext *s = avctx->priv_data;
2005 #endif
2006 const int qscale = 5;
2007 uint8_t *buf_ptr, *buf_end, *recoded;
2008 int i = 0, j = 0;
2009
2010 *data_size = 0;
2011
2012 /* no supplementary picture */
2013 if (buf_size == 0)
2014 return 0;
2015
2016 if (!avctx->width || !avctx->height)
2017 return -1;
2018
2019 buf_ptr = buf;
2020 buf_end = buf + buf_size;
2021
2022 #if 1
2023 recoded = av_mallocz(buf_size + 1024);
2024 if (!recoded)
2025 return -1;
2026
2027 /* SOI */
2028 recoded[j++] = 0xFF;
2029 recoded[j++] = 0xD8;
2030
2031 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2032 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2033 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2034 j += sizeof(sp5x_data_dqt);
2035
2036 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2037 j += sizeof(sp5x_data_dht);
2038
2039 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2040 recoded[j+5] = (avctx->height >> 8) & 0xFF;
2041 recoded[j+6] = avctx->height & 0xFF;
2042 recoded[j+7] = (avctx->width >> 8) & 0xFF;
2043 recoded[j+8] = avctx->width & 0xFF;
2044 j += sizeof(sp5x_data_sof);
2045
2046 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2047 j += sizeof(sp5x_data_sos);
2048
2049 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2050 {
2051 recoded[j++] = buf[i];
2052 if (buf[i] == 0xff)
2053 recoded[j++] = 0;
2054 }
2055
2056 /* EOI */
2057 recoded[j++] = 0xFF;
2058 recoded[j++] = 0xD9;
2059
2060 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2061
2062 av_free(recoded);
2063
2064 #else
2065 /* SOF */
2066 s->bits = 8;
2067 s->width = avctx->width;
2068 s->height = avctx->height;
2069 s->nb_components = 3;
2070 s->component_id[0] = 0;
2071 s->h_count[0] = 2;
2072 s->v_count[0] = 2;
2073 s->quant_index[0] = 0;
2074 s->component_id[1] = 1;
2075 s->h_count[1] = 1;
2076 s->v_count[1] = 1;
2077 s->quant_index[1] = 1;
2078 s->component_id[2] = 2;
2079 s->h_count[2] = 1;
2080 s->v_count[2] = 1;
2081 s->quant_index[2] = 1;
2082 s->h_max = 2;
2083 s->v_max = 2;
2084
2085 s->qscale_table = av_mallocz((s->width+15)/16);
2086 avctx->pix_fmt = PIX_FMT_YUV420P;
2087 s->interlaced = 0;
2088
2089 s->picture.reference = 0;
2090 if (avctx->get_buffer(avctx, &s->picture) < 0)
2091 {
2092 fprintf(stderr, "get_buffer() failed\n");
2093 return -1;
2094 }
2095
2096 s->picture.pict_type = I_TYPE;
2097 s->picture.key_frame = 1;
2098
2099 for (i = 0; i < 3; i++)
2100 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2101
2102 /* DQT */
2103 for (i = 0; i < 64; i++)
2104 {
2105 j = s->scantable.permutated[i];
2106 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2107 }
2108 s->qscale[0] = FFMAX(
2109 s->quant_matrixes[0][s->scantable.permutated[1]],
2110 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2111
2112 for (i = 0; i < 64; i++)
2113 {
2114 j = s->scantable.permutated[i];
2115 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2116 }
2117 s->qscale[1] = FFMAX(
2118 s->quant_matrixes[1][s->scantable.permutated[1]],
2119 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2120
2121 /* DHT */
2122
2123 /* SOS */
2124 s->comp_index[0] = 0;
2125 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2126 s->h_scount[0] = s->h_count[0];
2127 s->v_scount[0] = s->v_count[0];
2128 s->dc_index[0] = 0;
2129 s->ac_index[0] = 0;
2130
2131 s->comp_index[1] = 1;
2132 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2133 s->h_scount[1] = s->h_count[1];
2134 s->v_scount[1] = s->v_count[1];
2135 s->dc_index[1] = 1;
2136 s->ac_index[1] = 1;
2137
2138 s->comp_index[2] = 2;
2139 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2140 s->h_scount[2] = s->h_count[2];
2141 s->v_scount[2] = s->v_count[2];
2142 s->dc_index[2] = 1;
2143 s->ac_index[2] = 1;
2144
2145 for (i = 0; i < 3; i++)
2146 s->last_dc[i] = 1024;
2147
2148 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2149 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2150
2151 init_get_bits(&s->gb, buf, buf_size*8);
2152
2153 return mjpeg_decode_scan(s);
2154 #endif
2155
2156 return i;
2157 }
2158
2159 static int mjpeg_decode_end(AVCodecContext *avctx)
2160 {
2161 MJpegDecodeContext *s = avctx->priv_data;
2162 int i, j;
2163
2164 av_free(s->buffer);
2165 av_free(s->qscale_table);
2166 avcodec_default_free_buffers(avctx);
2167
2168 for(i=0;i<2;i++) {
2169 for(j=0;j<4;j++)
2170 free_vlc(&s->vlcs[i][j]);
2171 }
2172 return 0;
2173 }
2174
2175 AVCodec mjpeg_decoder = {
2176 "mjpeg",
2177 CODEC_TYPE_VIDEO,
2178 CODEC_ID_MJPEG,
2179 sizeof(MJpegDecodeContext),
2180 mjpeg_decode_init,
2181 NULL,
2182 mjpeg_decode_end,
2183 mjpeg_decode_frame,
2184 CODEC_CAP_DR1,
2185 NULL
2186 };
2187
2188 AVCodec mjpegb_decoder = {
2189 "mjpegb",
2190 CODEC_TYPE_VIDEO,
2191 CODEC_ID_MJPEGB,
2192 sizeof(MJpegDecodeContext),
2193 mjpeg_decode_init,
2194 NULL,
2195 mjpeg_decode_end,
2196 mjpegb_decode_frame,
2197 CODEC_CAP_DR1,
2198 NULL
2199 };
2200
2201 AVCodec sp5x_decoder = {
2202 "sp5x",
2203 CODEC_TYPE_VIDEO,
2204 CODEC_ID_SP5X,
2205 sizeof(MJpegDecodeContext),
2206 mjpeg_decode_init,
2207 NULL,
2208 mjpeg_decode_end,
2209 sp5x_decode_frame,
2210 CODEC_CAP_DR1,
2211 NULL
2212 };
2213
2214 #ifdef CONFIG_ENCODERS
2215 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2216 "ljpeg",
2217 CODEC_TYPE_VIDEO,
2218 CODEC_ID_LJPEG,
2219 sizeof(MpegEncContext),
2220 MPV_encode_init,
2221 encode_picture_lossless,
2222 MPV_encode_end,
2223 };
2224 #endif
Libav master