f67f280a880c745af5fff763c2fd63ef89463e1c
[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 switch(s->aspect_ratio_info)
385 {
386 case FF_ASPECT_4_3_625:
387 case FF_ASPECT_4_3_525:
388 put_bits(p, 16, 4);
389 put_bits(p, 16, 3);
390 break;
391 case FF_ASPECT_16_9_625:
392 case FF_ASPECT_16_9_525:
393 put_bits(p, 16, 16);
394 put_bits(p, 16, 9);
395 break;
396 case FF_ASPECT_EXTENDED:
397 put_bits(p, 16, s->aspected_width);
398 put_bits(p, 16, s->aspected_height);
399 break;
400 case FF_ASPECT_SQUARE:
401 default:
402 put_bits(p, 16, 1); /* aspect: 1:1 */
403 put_bits(p, 16, 1);
404 break;
405 }
406 put_bits(p, 8, 0); /* thumbnail width */
407 put_bits(p, 8, 0); /* thumbnail height */
408 }
409
410 /* comment */
411 if(!(s->flags & CODEC_FLAG_BITEXACT)){
412 put_marker(p, COM);
413 flush_put_bits(p);
414 ptr = pbBufPtr(p);
415 put_bits(p, 16, 0); /* patched later */
416 put_string(p, LIBAVCODEC_IDENT);
417 size = strlen(LIBAVCODEC_IDENT)+3;
418 ptr[0] = size >> 8;
419 ptr[1] = size;
420 }
421 }
422
423 void mjpeg_picture_header(MpegEncContext *s)
424 {
425 const int lossless= s->avctx->codec_id == CODEC_ID_LJPEG;
426
427 put_marker(&s->pb, SOI);
428
429 if (!s->mjpeg_data_only_frames)
430 {
431 jpeg_put_comments(s);
432
433 if (s->mjpeg_write_tables) jpeg_table_header(s);
434
435 put_marker(&s->pb, lossless ? SOF3 : SOF0);
436
437 put_bits(&s->pb, 16, 17);
438 if(lossless && s->avctx->pix_fmt == PIX_FMT_RGBA32)
439 put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
440 else
441 put_bits(&s->pb, 8, 8); /* 8 bits/component */
442 put_bits(&s->pb, 16, s->height);
443 put_bits(&s->pb, 16, s->width);
444 put_bits(&s->pb, 8, 3); /* 3 components */
445
446 /* Y component */
447 put_bits(&s->pb, 8, 1); /* component number */
448 put_bits(&s->pb, 4, s->mjpeg_hsample[0]); /* H factor */
449 put_bits(&s->pb, 4, s->mjpeg_vsample[0]); /* V factor */
450 put_bits(&s->pb, 8, 0); /* select matrix */
451
452 /* Cb component */
453 put_bits(&s->pb, 8, 2); /* component number */
454 put_bits(&s->pb, 4, s->mjpeg_hsample[1]); /* H factor */
455 put_bits(&s->pb, 4, s->mjpeg_vsample[1]); /* V factor */
456 #ifdef TWOMATRIXES
457 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
458 #else
459 put_bits(&s->pb, 8, 0); /* select matrix */
460 #endif
461
462 /* Cr component */
463 put_bits(&s->pb, 8, 3); /* component number */
464 put_bits(&s->pb, 4, s->mjpeg_hsample[2]); /* H factor */
465 put_bits(&s->pb, 4, s->mjpeg_vsample[2]); /* V factor */
466 #ifdef TWOMATRIXES
467 put_bits(&s->pb, 8, lossless ? 0 : 1); /* select matrix */
468 #else
469 put_bits(&s->pb, 8, 0); /* select matrix */
470 #endif
471 }
472
473 /* scan header */
474 put_marker(&s->pb, SOS);
475 put_bits(&s->pb, 16, 12); /* length */
476 put_bits(&s->pb, 8, 3); /* 3 components */
477
478 /* Y component */
479 put_bits(&s->pb, 8, 1); /* index */
480 put_bits(&s->pb, 4, 0); /* DC huffman table index */
481 put_bits(&s->pb, 4, 0); /* AC huffman table index */
482
483 /* Cb component */
484 put_bits(&s->pb, 8, 2); /* index */
485 put_bits(&s->pb, 4, 1); /* DC huffman table index */
486 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
487
488 /* Cr component */
489 put_bits(&s->pb, 8, 3); /* index */
490 put_bits(&s->pb, 4, 1); /* DC huffman table index */
491 put_bits(&s->pb, 4, lossless ? 0 : 1); /* AC huffman table index */
492
493 put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
494 put_bits(&s->pb, 8, lossless ? 0 : 63); /* Se (not used) */
495 put_bits(&s->pb, 8, 0); /* Ah/Al (not used) */
496 }
497
498 static void escape_FF(MpegEncContext *s, int start)
499 {
500 int size= get_bit_count(&s->pb) - start*8;
501 int i, ff_count;
502 uint8_t *buf= s->pb.buf + start;
503 int align= (-(size_t)(buf))&3;
504
505 assert((size&7) == 0);
506 size >>= 3;
507
508 ff_count=0;
509 for(i=0; i<size && i<align; i++){
510 if(buf[i]==0xFF) ff_count++;
511 }
512 for(; i<size-15; i+=16){
513 int acc, v;
514
515 v= *(uint32_t*)(&buf[i]);
516 acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
517 v= *(uint32_t*)(&buf[i+4]);
518 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
519 v= *(uint32_t*)(&buf[i+8]);
520 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
521 v= *(uint32_t*)(&buf[i+12]);
522 acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
523
524 acc>>=4;
525 acc+= (acc>>16);
526 acc+= (acc>>8);
527 ff_count+= acc&0xFF;
528 }
529 for(; i<size; i++){
530 if(buf[i]==0xFF) ff_count++;
531 }
532
533 if(ff_count==0) return;
534
535 /* skip put bits */
536 for(i=0; i<ff_count-3; i+=4)
537 put_bits(&s->pb, 32, 0);
538 put_bits(&s->pb, (ff_count-i)*8, 0);
539 flush_put_bits(&s->pb);
540
541 for(i=size-1; ff_count; i--){
542 int v= buf[i];
543
544 if(v==0xFF){
545 //printf("%d %d\n", i, ff_count);
546 buf[i+ff_count]= 0;
547 ff_count--;
548 }
549
550 buf[i+ff_count]= v;
551 }
552 }
553
554 void mjpeg_picture_trailer(MpegEncContext *s)
555 {
556 int pad= (-get_bit_count(&s->pb))&7;
557
558 put_bits(&s->pb, pad,0xFF>>(8-pad));
559 flush_put_bits(&s->pb);
560
561 assert((s->header_bits&7)==0);
562
563 escape_FF(s, s->header_bits>>3);
564
565 put_marker(&s->pb, EOI);
566 }
567
568 static inline void mjpeg_encode_dc(MpegEncContext *s, int val,
569 uint8_t *huff_size, uint16_t *huff_code)
570 {
571 int mant, nbits;
572
573 if (val == 0) {
574 put_bits(&s->pb, huff_size[0], huff_code[0]);
575 } else {
576 mant = val;
577 if (val < 0) {
578 val = -val;
579 mant--;
580 }
581
582 nbits= av_log2_16bit(val) + 1;
583
584 put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
585
586 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
587 }
588 }
589
590 static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
591 {
592 int mant, nbits, code, i, j;
593 int component, dc, run, last_index, val;
594 MJpegContext *m = s->mjpeg_ctx;
595 uint8_t *huff_size_ac;
596 uint16_t *huff_code_ac;
597
598 /* DC coef */
599 component = (n <= 3 ? 0 : n - 4 + 1);
600 dc = block[0]; /* overflow is impossible */
601 val = dc - s->last_dc[component];
602 if (n < 4) {
603 mjpeg_encode_dc(s, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);
604 huff_size_ac = m->huff_size_ac_luminance;
605 huff_code_ac = m->huff_code_ac_luminance;
606 } else {
607 mjpeg_encode_dc(s, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
608 huff_size_ac = m->huff_size_ac_chrominance;
609 huff_code_ac = m->huff_code_ac_chrominance;
610 }
611 s->last_dc[component] = dc;
612
613 /* AC coefs */
614
615 run = 0;
616 last_index = s->block_last_index[n];
617 for(i=1;i<=last_index;i++) {
618 j = s->intra_scantable.permutated[i];
619 val = block[j];
620 if (val == 0) {
621 run++;
622 } else {
623 while (run >= 16) {
624 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
625 run -= 16;
626 }
627 mant = val;
628 if (val < 0) {
629 val = -val;
630 mant--;
631 }
632
633 nbits= av_log2(val) + 1;
634 code = (run << 4) | nbits;
635
636 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
637
638 put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
639 run = 0;
640 }
641 }
642
643 /* output EOB only if not already 64 values */
644 if (last_index < 63 || run != 0)
645 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
646 }
647
648 void mjpeg_encode_mb(MpegEncContext *s,
649 DCTELEM block[6][64])
650 {
651 int i;
652 for(i=0;i<6;i++) {
653 encode_block(s, block[i], i);
654 }
655 }
656
657 static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
658 MpegEncContext * const s = avctx->priv_data;
659 MJpegContext * const m = s->mjpeg_ctx;
660 AVFrame *pict = data;
661 const int width= s->width;
662 const int height= s->height;
663 AVFrame * const p= (AVFrame*)&s->current_picture;
664 const int predictor= avctx->prediction_method+1;
665
666 init_put_bits(&s->pb, buf, buf_size);
667
668 *p = *pict;
669 p->pict_type= FF_I_TYPE;
670 p->key_frame= 1;
671
672 mjpeg_picture_header(s);
673
674 s->header_bits= get_bit_count(&s->pb);
675
676 if(avctx->pix_fmt == PIX_FMT_RGBA32){
677 int x, y, i;
678 const int linesize= p->linesize[0];
679 uint16_t buffer[2048][4];
680 int left[3], top[3], topleft[3];
681
682 for(i=0; i<3; i++){
683 buffer[0][i]= 1 << (9 - 1);
684 }
685
686 for(y = 0; y < height; y++) {
687 const int modified_predictor= y ? predictor : 1;
688 uint8_t *ptr = p->data[0] + (linesize * y);
689
690 for(i=0; i<3; i++){
691 top[i]= left[i]= topleft[i]= buffer[0][i];
692 }
693 for(x = 0; x < width; x++) {
694 buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100;
695 buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100;
696 buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2;
697
698 for(i=0;i<3;i++) {
699 int pred, diff;
700
701 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
702
703 topleft[i]= top[i];
704 top[i]= buffer[x+1][i];
705
706 left[i]= buffer[x][i];
707
708 diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100;
709
710 if(i==0)
711 mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
712 else
713 mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
714 }
715 }
716 }
717 }else{
718 int mb_x, mb_y, i;
719 const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0];
720 const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0];
721
722 for(mb_y = 0; mb_y < mb_height; mb_y++) {
723 for(mb_x = 0; mb_x < mb_width; mb_x++) {
724 if(mb_x==0 || mb_y==0){
725 for(i=0;i<3;i++) {
726 uint8_t *ptr;
727 int x, y, h, v, linesize;
728 h = s->mjpeg_hsample[i];
729 v = s->mjpeg_vsample[i];
730 linesize= p->linesize[i];
731
732 for(y=0; y<v; y++){
733 for(x=0; x<h; x++){
734 int pred;
735
736 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
737 if(y==0 && mb_y==0){
738 if(x==0 && mb_x==0){
739 pred= 128;
740 }else{
741 pred= ptr[-1];
742 }
743 }else{
744 if(x==0 && mb_x==0){
745 pred= ptr[-linesize];
746 }else{
747 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
748 }
749 }
750
751 if(i==0)
752 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
753 else
754 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
755 }
756 }
757 }
758 }else{
759 for(i=0;i<3;i++) {
760 uint8_t *ptr;
761 int x, y, h, v, linesize;
762 h = s->mjpeg_hsample[i];
763 v = s->mjpeg_vsample[i];
764 linesize= p->linesize[i];
765
766 for(y=0; y<v; y++){
767 for(x=0; x<h; x++){
768 int pred;
769
770 ptr = p->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
771 //printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);
772 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
773
774 if(i==0)
775 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly
776 else
777 mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);
778 }
779 }
780 }
781 }
782 }
783 }
784 }
785
786 emms_c();
787
788 mjpeg_picture_trailer(s);
789 s->picture_number++;
790
791 flush_put_bits(&s->pb);
792 return pbBufPtr(&s->pb) - s->pb.buf;
793 // return (get_bit_count(&f->pb)+7)/8;
794 }
795
796 #endif //CONFIG_ENCODERS
797
798 /******************************************/
799 /* decoding */
800
801 #define MAX_COMPONENTS 4
802
803 typedef struct MJpegDecodeContext {
804 AVCodecContext *avctx;
805 GetBitContext gb;
806 int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
807
808 int start_code; /* current start code */
809 int buffer_size;
810 uint8_t *buffer;
811
812 int16_t quant_matrixes[4][64];
813 VLC vlcs[2][4];
814 int qscale[4]; ///< quantizer scale calculated from quant_matrixes
815
816 int org_width, org_height; /* size given at codec init */
817 int first_picture; /* true if decoding first picture */
818 int interlaced; /* true if interlaced */
819 int bottom_field; /* true if bottom field */
820 int lossless;
821 int rgb;
822 int rct; /* standard rct */
823 int pegasus_rct; /* pegasus reversible colorspace transform */
824 int bits; /* bits per component */
825
826 int width, height;
827 int mb_width, mb_height;
828 int nb_components;
829 int component_id[MAX_COMPONENTS];
830 int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
831 int v_count[MAX_COMPONENTS];
832 int comp_index[MAX_COMPONENTS];
833 int dc_index[MAX_COMPONENTS];
834 int ac_index[MAX_COMPONENTS];
835 int nb_blocks[MAX_COMPONENTS];
836 int h_scount[MAX_COMPONENTS];
837 int v_scount[MAX_COMPONENTS];
838 int h_max, v_max; /* maximum h and v counts */
839 int quant_index[4]; /* quant table index for each component */
840 int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
841 AVFrame picture; /* picture structure */
842 int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
843 uint8_t *qscale_table;
844 DCTELEM block[64] __align8;
845 ScanTable scantable;
846 void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
847
848 int restart_interval;
849 int restart_count;
850
851 int buggy_avid;
852 int interlace_polarity;
853 } MJpegDecodeContext;
854
855 static int mjpeg_decode_dht(MJpegDecodeContext *s);
856
857 static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
858 int nb_codes)
859 {
860 uint8_t huff_size[256];
861 uint16_t huff_code[256];
862
863 memset(huff_size, 0, sizeof(huff_size));
864 build_huffman_codes(huff_size, huff_code, bits_table, val_table);
865
866 return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2);
867 }
868
869 static int mjpeg_decode_init(AVCodecContext *avctx)
870 {
871 MJpegDecodeContext *s = avctx->priv_data;
872 MpegEncContext s2;
873
874 s->avctx = avctx;
875
876 /* ugly way to get the idct & scantable FIXME */
877 memset(&s2, 0, sizeof(MpegEncContext));
878 s2.flags= avctx->flags;
879 s2.avctx= avctx;
880 // s2->out_format = FMT_MJPEG;
881 s2.width = 8;
882 s2.height = 8;
883 if (MPV_common_init(&s2) < 0)
884 return -1;
885 s->scantable= s2.intra_scantable;
886 s->idct_put= s2.dsp.idct_put;
887 MPV_common_end(&s2);
888
889 s->mpeg_enc_ctx_allocated = 0;
890 s->buffer_size = 102400; /* smaller buffer should be enough,
891 but photojpg files could ahive bigger sizes */
892 s->buffer = av_malloc(s->buffer_size);
893 if (!s->buffer)
894 return -1;
895 s->start_code = -1;
896 s->first_picture = 1;
897 s->org_width = avctx->width;
898 s->org_height = avctx->height;
899
900 build_vlc(&s->vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12);
901 build_vlc(&s->vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12);
902 build_vlc(&s->vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251);
903 build_vlc(&s->vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251);
904
905 if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
906 {
907 printf("mjpeg: using external huffman table\n");
908 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
909 mjpeg_decode_dht(s);
910 /* should check for error - but dunno */
911 }
912
913 return 0;
914 }
915
916 /* quantize tables */
917 static int mjpeg_decode_dqt(MJpegDecodeContext *s)
918 {
919 int len, index, i, j;
920
921 len = get_bits(&s->gb, 16) - 2;
922
923 while (len >= 65) {
924 /* only 8 bit precision handled */
925 if (get_bits(&s->gb, 4) != 0)
926 {
927 dprintf("dqt: 16bit precision\n");
928 return -1;
929 }
930 index = get_bits(&s->gb, 4);
931 if (index >= 4)
932 return -1;
933 dprintf("index=%d\n", index);
934 /* read quant table */
935 for(i=0;i<64;i++) {
936 j = s->scantable.permutated[i];
937 s->quant_matrixes[index][j] = get_bits(&s->gb, 8);
938 }
939
940 //XXX FIXME finetune, and perhaps add dc too
941 s->qscale[index]= FFMAX(
942 s->quant_matrixes[index][s->scantable.permutated[1]],
943 s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
944 dprintf("qscale[%d]: %d\n", index, s->qscale[index]);
945 len -= 65;
946 }
947
948 return 0;
949 }
950
951 /* decode huffman tables and build VLC decoders */
952 static int mjpeg_decode_dht(MJpegDecodeContext *s)
953 {
954 int len, index, i, class, n, v, code_max;
955 uint8_t bits_table[17];
956 uint8_t val_table[256];
957
958 len = get_bits(&s->gb, 16) - 2;
959
960 while (len > 0) {
961 if (len < 17)
962 return -1;
963 class = get_bits(&s->gb, 4);
964 if (class >= 2)
965 return -1;
966 index = get_bits(&s->gb, 4);
967 if (index >= 4)
968 return -1;
969 n = 0;
970 for(i=1;i<=16;i++) {
971 bits_table[i] = get_bits(&s->gb, 8);
972 n += bits_table[i];
973 }
974 len -= 17;
975 if (len < n || n > 256)
976 return -1;
977
978 code_max = 0;
979 for(i=0;i<n;i++) {
980 v = get_bits(&s->gb, 8);
981 if (v > code_max)
982 code_max = v;
983 val_table[i] = v;
984 }
985 len -= n;
986
987 /* build VLC and flush previous vlc if present */
988 free_vlc(&s->vlcs[class][index]);
989 dprintf("class=%d index=%d nb_codes=%d\n",
990 class, index, code_max + 1);
991 if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1) < 0){
992 return -1;
993 }
994 }
995 return 0;
996 }
997
998 static int mjpeg_decode_sof(MJpegDecodeContext *s)
999 {
1000 int len, nb_components, i, width, height;
1001
1002 /* XXX: verify len field validity */
1003 len = get_bits(&s->gb, 16);
1004 s->bits= get_bits(&s->gb, 8);
1005
1006 if(s->pegasus_rct) s->bits=9;
1007 if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
1008
1009 if (s->bits != 8 && !s->lossless){
1010 printf("only 8 bits/component accepted\n");
1011 return -1;
1012 }
1013 height = get_bits(&s->gb, 16);
1014 width = get_bits(&s->gb, 16);
1015 dprintf("sof0: picture: %dx%d\n", width, height);
1016
1017 nb_components = get_bits(&s->gb, 8);
1018 if (nb_components <= 0 ||
1019 nb_components > MAX_COMPONENTS)
1020 return -1;
1021 s->nb_components = nb_components;
1022 s->h_max = 1;
1023 s->v_max = 1;
1024 for(i=0;i<nb_components;i++) {
1025 /* component id */
1026 s->component_id[i] = get_bits(&s->gb, 8) - 1;
1027 s->h_count[i] = get_bits(&s->gb, 4);
1028 s->v_count[i] = get_bits(&s->gb, 4);
1029 /* compute hmax and vmax (only used in interleaved case) */
1030 if (s->h_count[i] > s->h_max)
1031 s->h_max = s->h_count[i];
1032 if (s->v_count[i] > s->v_max)
1033 s->v_max = s->v_count[i];
1034 s->quant_index[i] = get_bits(&s->gb, 8);
1035 if (s->quant_index[i] >= 4)
1036 return -1;
1037 dprintf("component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
1038 s->v_count[i], s->component_id[i], s->quant_index[i]);
1039 }
1040
1041 if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
1042
1043 /* if different size, realloc/alloc picture */
1044 /* XXX: also check h_count and v_count */
1045 if (width != s->width || height != s->height) {
1046 av_freep(&s->qscale_table);
1047
1048 s->width = width;
1049 s->height = height;
1050 /* test interlaced mode */
1051 if (s->first_picture &&
1052 s->org_height != 0 &&
1053 s->height < ((s->org_height * 3) / 4)) {
1054 s->interlaced = 1;
1055 // s->bottom_field = (s->interlace_polarity) ? 1 : 0;
1056 s->bottom_field = 0;
1057 }
1058
1059 s->qscale_table= av_mallocz((s->width+15)/16);
1060
1061 s->first_picture = 0;
1062 }
1063
1064 if(s->interlaced && s->bottom_field)
1065 return 0;
1066
1067 /* XXX: not complete test ! */
1068 switch((s->h_count[0] << 4) | s->v_count[0]) {
1069 case 0x11:
1070 if(s->rgb){
1071 s->avctx->pix_fmt = PIX_FMT_RGBA32;
1072 }else
1073 s->avctx->pix_fmt = PIX_FMT_YUV444P;
1074 break;
1075 case 0x21:
1076 s->avctx->pix_fmt = PIX_FMT_YUV422P;
1077 break;
1078 default:
1079 case 0x22:
1080 s->avctx->pix_fmt = PIX_FMT_YUV420P;
1081 break;
1082 }
1083
1084 if(s->picture.data[0])
1085 s->avctx->release_buffer(s->avctx, &s->picture);
1086
1087 s->picture.reference= 0;
1088 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
1089 fprintf(stderr, "get_buffer() failed\n");
1090 return -1;
1091 }
1092 s->picture.pict_type= I_TYPE;
1093 s->picture.key_frame= 1;
1094
1095 for(i=0; i<3; i++){
1096 s->linesize[i]= s->picture.linesize[i] << s->interlaced;
1097 }
1098
1099 // printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
1100
1101 if (len != (8+(3*nb_components)))
1102 {
1103 dprintf("decode_sof0: error, len(%d) mismatch\n", len);
1104 }
1105
1106 return 0;
1107 }
1108
1109 static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
1110 {
1111 int code;
1112 code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
1113 if (code < 0)
1114 {
1115 dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
1116 &s->vlcs[0][dc_index]);
1117 return 0xffff;
1118 }
1119
1120 if(code)
1121 return get_xbits(&s->gb, code);
1122 else
1123 return 0;
1124 }
1125
1126 /* decode block and dequantize */
1127 static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
1128 int component, int dc_index, int ac_index, int quant_index)
1129 {
1130 int code, i, j, level, val;
1131 VLC *ac_vlc;
1132 int16_t *quant_matrix;
1133
1134 /* DC coef */
1135 val = mjpeg_decode_dc(s, dc_index);
1136 if (val == 0xffff) {
1137 dprintf("error dc\n");
1138 return -1;
1139 }
1140 quant_matrix = s->quant_matrixes[quant_index];
1141 val = val * quant_matrix[0] + s->last_dc[component];
1142 s->last_dc[component] = val;
1143 block[0] = val;
1144 /* AC coefs */
1145 ac_vlc = &s->vlcs[1][ac_index];
1146 i = 1;
1147 for(;;) {
1148 code = get_vlc2(&s->gb, s->vlcs[1][ac_index].table, 9, 2);
1149
1150 if (code < 0) {
1151 dprintf("error ac\n");
1152 return -1;
1153 }
1154 /* EOB */
1155 if (code == 0)
1156 break;
1157 if (code == 0xf0) {
1158 i += 16;
1159 } else {
1160 level = get_xbits(&s->gb, code & 0xf);
1161 i += code >> 4;
1162 if (i >= 64) {
1163 dprintf("error count: %d\n", i);
1164 return -1;
1165 }
1166 j = s->scantable.permutated[i];
1167 block[j] = level * quant_matrix[j];
1168 i++;
1169 if (i >= 64)
1170 break;
1171 }
1172 }
1173 return 0;
1174 }
1175
1176 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1177 int i, mb_x, mb_y;
1178 uint16_t buffer[2048][4];
1179 int left[3], top[3], topleft[3];
1180 const int linesize= s->linesize[0];
1181 const int mask= (1<<s->bits)-1;
1182
1183 for(i=0; i<3; i++){
1184 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1185 }
1186 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1187 const int modified_predictor= mb_y ? predictor : 1;
1188 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1189
1190 if (s->interlaced && s->bottom_field)
1191 ptr += linesize >> 1;
1192
1193 for(i=0; i<3; i++){
1194 top[i]= left[i]= topleft[i]= buffer[0][i];
1195 }
1196 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1197 if (s->restart_interval && !s->restart_count)
1198 s->restart_count = s->restart_interval;
1199
1200 for(i=0;i<3;i++) {
1201 int pred;
1202
1203 topleft[i]= top[i];
1204 top[i]= buffer[mb_x][i];
1205
1206 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1207
1208 left[i]=
1209 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1210 }
1211
1212 if (s->restart_interval && !--s->restart_count) {
1213 align_get_bits(&s->gb);
1214 skip_bits(&s->gb, 16); /* skip RSTn */
1215 }
1216 }
1217
1218 if(s->rct){
1219 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1220 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1221 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1222 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1223 }
1224 }else if(s->pegasus_rct){
1225 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1226 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1227 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1228 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1229 }
1230 }else{
1231 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1232 ptr[4*mb_x+0] = buffer[mb_x][0];
1233 ptr[4*mb_x+1] = buffer[mb_x][1];
1234 ptr[4*mb_x+2] = buffer[mb_x][2];
1235 }
1236 }
1237 }
1238 return 0;
1239 }
1240
1241 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1242 int i, mb_x, mb_y;
1243 const int nb_components=3;
1244
1245 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1246 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1247 if (s->restart_interval && !s->restart_count)
1248 s->restart_count = s->restart_interval;
1249
1250 if(mb_x==0 || mb_y==0 || s->interlaced){
1251 for(i=0;i<nb_components;i++) {
1252 uint8_t *ptr;
1253 int n, h, v, x, y, c, j, linesize;
1254 n = s->nb_blocks[i];
1255 c = s->comp_index[i];
1256 h = s->h_scount[i];
1257 v = s->v_scount[i];
1258 x = 0;
1259 y = 0;
1260 linesize= s->linesize[c];
1261
1262 for(j=0; j<n; j++) {
1263 int pred;
1264
1265 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1266 if(y==0 && mb_y==0){
1267 if(x==0 && mb_x==0){
1268 pred= 128 << point_transform;
1269 }else{
1270 pred= ptr[-1];
1271 }
1272 }else{
1273 if(x==0 && mb_x==0){
1274 pred= ptr[-linesize];
1275 }else{
1276 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1277 }
1278 }
1279
1280 if (s->interlaced && s->bottom_field)
1281 ptr += linesize >> 1;
1282 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1283
1284 if (++x == h) {
1285 x = 0;
1286 y++;
1287 }
1288 }
1289 }
1290 }else{
1291 for(i=0;i<nb_components;i++) {
1292 uint8_t *ptr;
1293 int n, h, v, x, y, c, j, linesize;
1294 n = s->nb_blocks[i];
1295 c = s->comp_index[i];
1296 h = s->h_scount[i];
1297 v = s->v_scount[i];
1298 x = 0;
1299 y = 0;
1300 linesize= s->linesize[c];
1301
1302 for(j=0; j<n; j++) {
1303 int pred;
1304
1305 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1306 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1307 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1308 if (++x == h) {
1309 x = 0;
1310 y++;
1311 }
1312 }
1313 }
1314 }
1315 if (s->restart_interval && !--s->restart_count) {
1316 align_get_bits(&s->gb);
1317 skip_bits(&s->gb, 16); /* skip RSTn */
1318 }
1319 }
1320 }
1321 return 0;
1322 }
1323
1324 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1325 int i, mb_x, mb_y;
1326 const int nb_components=3;
1327
1328 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1329 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1330 if (s->restart_interval && !s->restart_count)
1331 s->restart_count = s->restart_interval;
1332
1333 for(i=0;i<nb_components;i++) {
1334 uint8_t *ptr;
1335 int n, h, v, x, y, c, j;
1336 n = s->nb_blocks[i];
1337 c = s->comp_index[i];
1338 h = s->h_scount[i];
1339 v = s->v_scount[i];
1340 x = 0;
1341 y = 0;
1342 for(j=0;j<n;j++) {
1343 memset(s->block, 0, sizeof(s->block));
1344 if (decode_block(s, s->block, i,
1345 s->dc_index[i], s->ac_index[i],
1346 s->quant_index[c]) < 0) {
1347 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1348 return -1;
1349 }
1350 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1351 ptr = s->picture.data[c] +
1352 (s->linesize[c] * (v * mb_y + y) * 8) +
1353 (h * mb_x + x) * 8;
1354 if (s->interlaced && s->bottom_field)
1355 ptr += s->linesize[c] >> 1;
1356 //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);
1357 s->idct_put(ptr, s->linesize[c], s->block);
1358 if (++x == h) {
1359 x = 0;
1360 y++;
1361 }
1362 }
1363 }
1364 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1365 if (s->restart_interval && (s->restart_interval < 1350) &&
1366 !--s->restart_count) {
1367 align_get_bits(&s->gb);
1368 skip_bits(&s->gb, 16); /* skip RSTn */
1369 for (i=0; i<nb_components; i++) /* reset dc */
1370 s->last_dc[i] = 1024;
1371 }
1372 }
1373 }
1374 return 0;
1375 }
1376
1377 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1378 {
1379 int len, nb_components, i, h, v, predictor, point_transform;
1380 int vmax, hmax, index, id;
1381 const int block_size= s->lossless ? 1 : 8;
1382
1383 /* XXX: verify len field validity */
1384 len = get_bits(&s->gb, 16);
1385 nb_components = get_bits(&s->gb, 8);
1386 if (len != 6+2*nb_components)
1387 {
1388 dprintf("decode_sos: invalid len (%d)\n", len);
1389 return -1;
1390 }
1391 /* XXX: only interleaved scan accepted */
1392 if (nb_components != 3)
1393 {
1394 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1395 return -1;
1396 }
1397 vmax = 0;
1398 hmax = 0;
1399 for(i=0;i<nb_components;i++) {
1400 id = get_bits(&s->gb, 8) - 1;
1401 dprintf("component: %d\n", id);
1402 /* find component index */
1403 for(index=0;index<s->nb_components;index++)
1404 if (id == s->component_id[index])
1405 break;
1406 if (index == s->nb_components)
1407 {
1408 dprintf("decode_sos: index(%d) out of components\n", index);
1409 return -1;
1410 }
1411
1412 s->comp_index[i] = index;
1413
1414 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1415 s->h_scount[i] = s->h_count[index];
1416 s->v_scount[i] = s->v_count[index];
1417
1418 s->dc_index[i] = get_bits(&s->gb, 4);
1419 s->ac_index[i] = get_bits(&s->gb, 4);
1420
1421 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1422 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1423 goto out_of_range;
1424 #if 0 //buggy
1425 switch(s->start_code)
1426 {
1427 case SOF0:
1428 if (dc_index[i] > 1 || ac_index[i] > 1)
1429 goto out_of_range;
1430 break;
1431 case SOF1:
1432 case SOF2:
1433 if (dc_index[i] > 3 || ac_index[i] > 3)
1434 goto out_of_range;
1435 break;
1436 case SOF3:
1437 if (dc_index[i] > 3 || ac_index[i] != 0)
1438 goto out_of_range;
1439 break;
1440 }
1441 #endif
1442 }
1443
1444 predictor= get_bits(&s->gb, 8); /* lossless predictor or start of spectral (Ss) */
1445 skip_bits(&s->gb, 8); /* Se */
1446 skip_bits(&s->gb, 4); /* Ah */
1447 point_transform= get_bits(&s->gb, 4); /* Al */
1448
1449 for(i=0;i<nb_components;i++)
1450 s->last_dc[i] = 1024;
1451
1452 if (nb_components > 1) {
1453 /* interleaved stream */
1454 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1455 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1456 } else {
1457 h = s->h_max / s->h_scount[s->comp_index[0]];
1458 v = s->v_max / s->v_scount[s->comp_index[0]];
1459 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1460 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1461 s->nb_blocks[0] = 1;
1462 s->h_scount[0] = 1;
1463 s->v_scount[0] = 1;
1464 }
1465
1466 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1467 printf("%s %s p:%d >>:%d\n", s->lossless ? "lossless" : "sequencial DCT", s->rgb ? "RGB" : "", predictor, point_transform);
1468
1469 if(s->lossless){
1470 if(s->rgb){
1471 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1472 return -1;
1473 }else{
1474 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1475 return -1;
1476 }
1477 }else{
1478 if(mjpeg_decode_scan(s) < 0)
1479 return -1;
1480 }
1481 emms_c();
1482 return 0;
1483 out_of_range:
1484 dprintf("decode_sos: ac/dc index out of range\n");
1485 return -1;
1486 }
1487
1488 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1489 {
1490 if (get_bits(&s->gb, 16) != 4)
1491 return -1;
1492 s->restart_interval = get_bits(&s->gb, 16);
1493 dprintf("restart interval: %d\n", s->restart_interval);
1494
1495 return 0;
1496 }
1497
1498 static int mjpeg_decode_app(MJpegDecodeContext *s)
1499 {
1500 int len, id;
1501
1502 /* XXX: verify len field validity */
1503 len = get_bits(&s->gb, 16);
1504 if (len < 5)
1505 return -1;
1506
1507 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1508 id = be2me_32(id);
1509 len -= 6;
1510
1511 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1512 printf("APPx %8X\n", id);
1513 }
1514
1515 /* buggy AVID, it puts EOI only at every 10th frame */
1516 /* also this fourcc is used by non-avid files too, it holds some
1517 informations, but it's always present in AVID creates files */
1518 if (id == ff_get_fourcc("AVI1"))
1519 {
1520 /* structure:
1521 4bytes AVI1
1522 1bytes polarity
1523 1bytes always zero
1524 4bytes field_size
1525 4bytes field_size_less_padding
1526 */
1527 s->buggy_avid = 1;
1528 // if (s->first_picture)
1529 // printf("mjpeg: workarounding buggy AVID\n");
1530 s->interlace_polarity = get_bits(&s->gb, 8);
1531 #if 0
1532 skip_bits(&s->gb, 8);
1533 skip_bits(&s->gb, 32);
1534 skip_bits(&s->gb, 32);
1535 len -= 10;
1536 #endif
1537 // if (s->interlace_polarity)
1538 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1539 goto out;
1540 }
1541
1542 // len -= 2;
1543
1544 if (id == ff_get_fourcc("JFIF"))
1545 {
1546 int t_w, t_h;
1547 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1548 printf("mjpeg: JFIF header found (version: %x.%x)\n",
1549 get_bits(&s->gb, 8), get_bits(&s->gb, 8));
1550 if (get_bits(&s->gb, 8) == 0)
1551 {
1552 int x_density, y_density;
1553 x_density = get_bits(&s->gb, 16);
1554 y_density = get_bits(&s->gb, 16);
1555
1556 dprintf("x/y density: %d (%f), %d (%f)\n", x_density,
1557 (float)x_density, y_density, (float)y_density);
1558 #if 0
1559 //MN: needs to be checked
1560 if(x_density)
1561 // s->avctx->aspect_ratio= s->width*y_density/((float)s->height*x_density);
1562 s->avctx->aspect_ratio = (float)x_density/y_density;
1563 /* it's better, but every JFIF I have seen stores 1:1 */
1564 else
1565 s->avctx->aspect_ratio= 0.0;
1566 #endif
1567 }
1568 else
1569 {
1570 skip_bits(&s->gb, 16);
1571 skip_bits(&s->gb, 16);
1572 }
1573
1574 t_w = get_bits(&s->gb, 8);
1575 t_h = get_bits(&s->gb, 8);
1576 if (t_w && t_h)
1577 {
1578 /* skip thumbnail */
1579 if (len-10-(t_w*t_h*3) > 0)
1580 len -= t_w*t_h*3;
1581 }
1582 len -= 10;
1583 goto out;
1584 }
1585
1586 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1587 {
1588 printf("mjpeg: Adobe header found\n");
1589 skip_bits(&s->gb, 16); /* version */
1590 skip_bits(&s->gb, 16); /* flags0 */
1591 skip_bits(&s->gb, 16); /* flags1 */
1592 skip_bits(&s->gb, 8); /* transform */
1593 len -= 7;
1594 goto out;
1595 }
1596
1597 if (id == ff_get_fourcc("LJIF")){
1598 printf("Pegasus lossless jpeg header found\n");
1599 skip_bits(&s->gb, 16); /* version ? */
1600 skip_bits(&s->gb, 16); /* unknwon always 0? */
1601 skip_bits(&s->gb, 16); /* unknwon always 0? */
1602 skip_bits(&s->gb, 16); /* unknwon always 0? */
1603 switch( get_bits(&s->gb, 8)){
1604 case 1:
1605 s->rgb= 1;
1606 s->pegasus_rct=0;
1607 break;
1608 case 2:
1609 s->rgb= 1;
1610 s->pegasus_rct=1;
1611 break;
1612 default:
1613 printf("unknown colorspace\n");
1614 }
1615 len -= 9;
1616 goto out;
1617 }
1618
1619 /* Apple MJPEG-A */
1620 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1621 {
1622 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1623 id = be2me_32(id);
1624 len -= 4;
1625 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1626 {
1627 #if 0
1628 skip_bits(&s->gb, 32); /* field size */
1629 skip_bits(&s->gb, 32); /* pad field size */
1630 skip_bits(&s->gb, 32); /* next off */
1631 skip_bits(&s->gb, 32); /* quant off */
1632 skip_bits(&s->gb, 32); /* huff off */
1633 skip_bits(&s->gb, 32); /* image off */
1634 skip_bits(&s->gb, 32); /* scan off */
1635 skip_bits(&s->gb, 32); /* data off */
1636 #endif
1637 if (s->first_picture)
1638 printf("mjpeg: Apple MJPEG-A header found\n");
1639 }
1640 }
1641
1642 out:
1643 /* slow but needed for extreme adobe jpegs */
1644 if (len < 0)
1645 printf("mjpeg: error, decode_app parser read over the end\n");
1646 while(--len > 0)
1647 skip_bits(&s->gb, 8);
1648
1649 return 0;
1650 }
1651
1652 static int mjpeg_decode_com(MJpegDecodeContext *s)
1653 {
1654 /* XXX: verify len field validity */
1655 int len = get_bits(&s->gb, 16);
1656 if (len >= 2 && len < 32768) {
1657 /* XXX: any better upper bound */
1658 uint8_t *cbuf = av_malloc(len - 1);
1659 if (cbuf) {
1660 int i;
1661 for (i = 0; i < len - 2; i++)
1662 cbuf[i] = get_bits(&s->gb, 8);
1663 if (i > 0 && cbuf[i-1] == '\n')
1664 cbuf[i-1] = 0;
1665 else
1666 cbuf[i] = 0;
1667
1668 printf("mjpeg comment: '%s'\n", cbuf);
1669
1670 /* buggy avid, it puts EOI only at every 10th frame */
1671 if (!strcmp(cbuf, "AVID"))
1672 {
1673 s->buggy_avid = 1;
1674 // if (s->first_picture)
1675 // printf("mjpeg: workarounding buggy AVID\n");
1676 }
1677
1678 av_free(cbuf);
1679 }
1680 }
1681
1682 return 0;
1683 }
1684
1685 #if 0
1686 static int valid_marker_list[] =
1687 {
1688 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1689 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1690 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1691 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1698 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1699 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1700 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1701 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1702 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1703 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1704 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1705 }
1706 #endif
1707
1708 /* return the 8 bit start code value and update the search
1709 state. Return -1 if no start code found */
1710 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1711 {
1712 uint8_t *buf_ptr;
1713 unsigned int v, v2;
1714 int val;
1715 #ifdef DEBUG
1716 int skipped=0;
1717 #endif
1718
1719 buf_ptr = *pbuf_ptr;
1720 while (buf_ptr < buf_end) {
1721 v = *buf_ptr++;
1722 v2 = *buf_ptr;
1723 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe)) {
1724 val = *buf_ptr++;
1725 goto found;
1726 }
1727 #ifdef DEBUG
1728 skipped++;
1729 #endif
1730 }
1731 val = -1;
1732 found:
1733 #ifdef DEBUG
1734 dprintf("find_marker skipped %d bytes\n", skipped);
1735 #endif
1736 *pbuf_ptr = buf_ptr;
1737 return val;
1738 }
1739
1740 static int mjpeg_decode_frame(AVCodecContext *avctx,
1741 void *data, int *data_size,
1742 uint8_t *buf, int buf_size)
1743 {
1744 MJpegDecodeContext *s = avctx->priv_data;
1745 uint8_t *buf_end, *buf_ptr;
1746 int start_code;
1747 AVFrame *picture = data;
1748
1749 *data_size = 0;
1750
1751 /* no supplementary picture */
1752 if (buf_size == 0)
1753 return 0;
1754
1755 buf_ptr = buf;
1756 buf_end = buf + buf_size;
1757 while (buf_ptr < buf_end) {
1758 /* find start next marker */
1759 start_code = find_marker(&buf_ptr, buf_end);
1760 {
1761 /* EOF */
1762 if (start_code < 0) {
1763 goto the_end;
1764 } else {
1765 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1766
1767 if ((buf_end - buf_ptr) > s->buffer_size)
1768 {
1769 av_free(s->buffer);
1770 s->buffer_size = buf_end-buf_ptr;
1771 s->buffer = av_malloc(s->buffer_size);
1772 dprintf("buffer too small, expanding to %d bytes\n",
1773 s->buffer_size);
1774 }
1775
1776 /* unescape buffer of SOS */
1777 if (start_code == SOS)
1778 {
1779 uint8_t *src = buf_ptr;
1780 uint8_t *dst = s->buffer;
1781
1782 while (src<buf_end)
1783 {
1784 uint8_t x = *(src++);
1785
1786 *(dst++) = x;
1787 if (x == 0xff)
1788 {
1789 while(*src == 0xff) src++;
1790
1791 x = *(src++);
1792 if (x >= 0xd0 && x <= 0xd7)
1793 *(dst++) = x;
1794 else if (x)
1795 break;
1796 }
1797 }
1798 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1799
1800 dprintf("escaping removed %d bytes\n",
1801 (buf_end - buf_ptr) - (dst - s->buffer));
1802 }
1803 else
1804 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1805
1806 s->start_code = start_code;
1807 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1808 printf("startcode: %X\n", start_code);
1809 }
1810
1811 /* process markers */
1812 if (start_code >= 0xd0 && start_code <= 0xd7) {
1813 dprintf("restart marker: %d\n", start_code&0x0f);
1814 } else if (s->first_picture) {
1815 /* APP fields */
1816 if (start_code >= 0xe0 && start_code <= 0xef)
1817 mjpeg_decode_app(s);
1818 /* Comment */
1819 else if (start_code == COM)
1820 mjpeg_decode_com(s);
1821 }
1822
1823 switch(start_code) {
1824 case SOI:
1825 s->restart_interval = 0;
1826 /* nothing to do on SOI */
1827 break;
1828 case DQT:
1829 mjpeg_decode_dqt(s);
1830 break;
1831 case DHT:
1832 if(mjpeg_decode_dht(s) < 0){
1833 fprintf(stderr, "huffman table decode error\n");
1834 return -1;
1835 }
1836 break;
1837 case SOF0:
1838 s->lossless=0;
1839 if (mjpeg_decode_sof(s) < 0)
1840 return -1;
1841 break;
1842 case SOF3:
1843 s->lossless=1;
1844 if (mjpeg_decode_sof(s) < 0)
1845 return -1;
1846 break;
1847 case EOI:
1848 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1849 break;
1850 eoi_parser:
1851 {
1852 if (s->interlaced) {
1853 s->bottom_field ^= 1;
1854 /* if not bottom field, do not output image yet */
1855 if (s->bottom_field)
1856 goto not_the_end;
1857 }
1858 *picture = s->picture;
1859 *data_size = sizeof(AVFrame);
1860 avctx->height = s->height;
1861 if (s->interlaced)
1862 avctx->height *= 2;
1863 avctx->width = s->width;
1864
1865 if(!s->lossless){
1866 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
1867 picture->qstride= 0;
1868 picture->qscale_table= s->qscale_table;
1869 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
1870 if(avctx->debug & FF_DEBUG_QP)
1871 printf("QP: %d\n", picture->quality);
1872 picture->quality*= FF_QP2LAMBDA;
1873 }
1874
1875 goto the_end;
1876 }
1877 break;
1878 case SOS:
1879 mjpeg_decode_sos(s);
1880 /* buggy avid puts EOI every 10-20th frame */
1881 /* if restart period is over process EOI */
1882 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
1883 goto eoi_parser;
1884 break;
1885 case DRI:
1886 mjpeg_decode_dri(s);
1887 break;
1888 case SOF1:
1889 case SOF2:
1890 case SOF5:
1891 case SOF6:
1892 case SOF7:
1893 case SOF9:
1894 case SOF10:
1895 case SOF11:
1896 case SOF13:
1897 case SOF14:
1898 case SOF15:
1899 case JPG:
1900 printf("mjpeg: unsupported coding type (%x)\n", start_code);
1901 break;
1902 // default:
1903 // printf("mjpeg: unsupported marker (%x)\n", start_code);
1904 // break;
1905 }
1906
1907 not_the_end:
1908 /* eof process start code */
1909 buf_ptr += (get_bits_count(&s->gb)+7)/8;
1910 dprintf("marker parser used %d bytes (%d bits)\n",
1911 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
1912 }
1913 }
1914 }
1915 the_end:
1916 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
1917 // return buf_end - buf_ptr;
1918 return buf_ptr - buf;
1919 }
1920
1921 static int mjpegb_decode_frame(AVCodecContext *avctx,
1922 void *data, int *data_size,
1923 uint8_t *buf, int buf_size)
1924 {
1925 MJpegDecodeContext *s = avctx->priv_data;
1926 uint8_t *buf_end, *buf_ptr;
1927 AVFrame *picture = data;
1928 GetBitContext hgb; /* for the header */
1929 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
1930 uint32_t field_size;
1931
1932 *data_size = 0;
1933
1934 /* no supplementary picture */
1935 if (buf_size == 0)
1936 return 0;
1937
1938 buf_ptr = buf;
1939 buf_end = buf + buf_size;
1940
1941 read_header:
1942 /* reset on every SOI */
1943 s->restart_interval = 0;
1944
1945 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
1946
1947 skip_bits(&hgb, 32); /* reserved zeros */
1948
1949 if (get_bits(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
1950 {
1951 dprintf("not mjpeg-b (bad fourcc)\n");
1952 return 0;
1953 }
1954
1955 field_size = get_bits(&hgb, 32); /* field size */
1956 dprintf("field size: 0x%x\n", field_size);
1957 skip_bits(&hgb, 32); /* padded field size */
1958 second_field_offs = get_bits(&hgb, 32);
1959 dprintf("second field offs: 0x%x\n", second_field_offs);
1960 if (second_field_offs)
1961 s->interlaced = 1;
1962
1963 dqt_offs = get_bits(&hgb, 32);
1964 dprintf("dqt offs: 0x%x\n", dqt_offs);
1965 if (dqt_offs)
1966 {
1967 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
1968 s->start_code = DQT;
1969 mjpeg_decode_dqt(s);
1970 }
1971
1972 dht_offs = get_bits(&hgb, 32);
1973 dprintf("dht offs: 0x%x\n", dht_offs);
1974 if (dht_offs)
1975 {
1976 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
1977 s->start_code = DHT;
1978 mjpeg_decode_dht(s);
1979 }
1980
1981 sof_offs = get_bits(&hgb, 32);
1982 dprintf("sof offs: 0x%x\n", sof_offs);
1983 if (sof_offs)
1984 {
1985 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
1986 s->start_code = SOF0;
1987 if (mjpeg_decode_sof(s) < 0)
1988 return -1;
1989 }
1990
1991 sos_offs = get_bits(&hgb, 32);
1992 dprintf("sos offs: 0x%x\n", sos_offs);
1993 if (sos_offs)
1994 {
1995 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
1996 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
1997 s->start_code = SOS;
1998 mjpeg_decode_sos(s);
1999 }
2000
2001 skip_bits(&hgb, 32); /* start of data offset */
2002
2003 if (s->interlaced) {
2004 s->bottom_field ^= 1;
2005 /* if not bottom field, do not output image yet */
2006 if (s->bottom_field && second_field_offs)
2007 {
2008 buf_ptr = buf + second_field_offs;
2009 second_field_offs = 0;
2010 goto read_header;
2011 }
2012 }
2013
2014 //XXX FIXME factorize, this looks very similar to the EOI code
2015
2016 *picture= s->picture;
2017 *data_size = sizeof(AVFrame);
2018 avctx->height = s->height;
2019 if (s->interlaced)
2020 avctx->height *= 2;
2021 avctx->width = s->width;
2022
2023 if(!s->lossless){
2024 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2025 picture->qstride= 0;
2026 picture->qscale_table= s->qscale_table;
2027 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2028 if(avctx->debug & FF_DEBUG_QP)
2029 printf("QP: %d\n", picture->quality);
2030 picture->quality*= FF_QP2LAMBDA;
2031 }
2032
2033 return buf_ptr - buf;
2034 }
2035
2036 #include "sp5x.h"
2037
2038 static int sp5x_decode_frame(AVCodecContext *avctx,
2039 void *data, int *data_size,
2040 uint8_t *buf, int buf_size)
2041 {
2042 #if 0
2043 MJpegDecodeContext *s = avctx->priv_data;
2044 #endif
2045 const int qscale = 5;
2046 uint8_t *buf_ptr, *buf_end, *recoded;
2047 int i = 0, j = 0;
2048
2049 *data_size = 0;
2050
2051 /* no supplementary picture */
2052 if (buf_size == 0)
2053 return 0;
2054
2055 if (!avctx->width || !avctx->height)
2056 return -1;
2057
2058 buf_ptr = buf;
2059 buf_end = buf + buf_size;
2060
2061 #if 1
2062 recoded = av_mallocz(buf_size + 1024);
2063 if (!recoded)
2064 return -1;
2065
2066 /* SOI */
2067 recoded[j++] = 0xFF;
2068 recoded[j++] = 0xD8;
2069
2070 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2071 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2072 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2073 j += sizeof(sp5x_data_dqt);
2074
2075 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2076 j += sizeof(sp5x_data_dht);
2077
2078 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2079 recoded[j+5] = (avctx->height >> 8) & 0xFF;
2080 recoded[j+6] = avctx->height & 0xFF;
2081 recoded[j+7] = (avctx->width >> 8) & 0xFF;
2082 recoded[j+8] = avctx->width & 0xFF;
2083 j += sizeof(sp5x_data_sof);
2084
2085 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2086 j += sizeof(sp5x_data_sos);
2087
2088 for (i = 14; i < buf_size, j < buf_size+1024-2; i++)
2089 {
2090 recoded[j++] = buf[i];
2091 if (buf[i] == 0xff)
2092 recoded[j++] = 0;
2093 }
2094
2095 /* EOI */
2096 recoded[j++] = 0xFF;
2097 recoded[j++] = 0xD9;
2098
2099 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2100
2101 av_free(recoded);
2102
2103 #else
2104 /* SOF */
2105 s->bits = 8;
2106 s->width = avctx->width;
2107 s->height = avctx->height;
2108 s->nb_components = 3;
2109 s->component_id[0] = 0;
2110 s->h_count[0] = 2;
2111 s->v_count[0] = 2;
2112 s->quant_index[0] = 0;
2113 s->component_id[1] = 1;
2114 s->h_count[1] = 1;
2115 s->v_count[1] = 1;
2116 s->quant_index[1] = 1;
2117 s->component_id[2] = 2;
2118 s->h_count[2] = 1;
2119 s->v_count[2] = 1;
2120 s->quant_index[2] = 1;
2121 s->h_max = 2;
2122 s->v_max = 2;
2123
2124 s->qscale_table = av_mallocz((s->width+15)/16);
2125 avctx->pix_fmt = PIX_FMT_YUV420P;
2126 s->interlaced = 0;
2127
2128 s->picture.reference = 0;
2129 if (avctx->get_buffer(avctx, &s->picture) < 0)
2130 {
2131 fprintf(stderr, "get_buffer() failed\n");
2132 return -1;
2133 }
2134
2135 s->picture.pict_type = I_TYPE;
2136 s->picture.key_frame = 1;
2137
2138 for (i = 0; i < 3; i++)
2139 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2140
2141 /* DQT */
2142 for (i = 0; i < 64; i++)
2143 {
2144 j = s->scantable.permutated[i];
2145 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2146 }
2147 s->qscale[0] = FFMAX(
2148 s->quant_matrixes[0][s->scantable.permutated[1]],
2149 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2150
2151 for (i = 0; i < 64; i++)
2152 {
2153 j = s->scantable.permutated[i];
2154 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2155 }
2156 s->qscale[1] = FFMAX(
2157 s->quant_matrixes[1][s->scantable.permutated[1]],
2158 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2159
2160 /* DHT */
2161
2162 /* SOS */
2163 s->comp_index[0] = 0;
2164 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2165 s->h_scount[0] = s->h_count[0];
2166 s->v_scount[0] = s->v_count[0];
2167 s->dc_index[0] = 0;
2168 s->ac_index[0] = 0;
2169
2170 s->comp_index[1] = 1;
2171 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2172 s->h_scount[1] = s->h_count[1];
2173 s->v_scount[1] = s->v_count[1];
2174 s->dc_index[1] = 1;
2175 s->ac_index[1] = 1;
2176
2177 s->comp_index[2] = 2;
2178 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2179 s->h_scount[2] = s->h_count[2];
2180 s->v_scount[2] = s->v_count[2];
2181 s->dc_index[2] = 1;
2182 s->ac_index[2] = 1;
2183
2184 for (i = 0; i < 3; i++)
2185 s->last_dc[i] = 1024;
2186
2187 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2188 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2189
2190 init_get_bits(&s->gb, buf, buf_size*8);
2191
2192 return mjpeg_decode_scan(s);
2193 #endif
2194
2195 return i;
2196 }
2197
2198 static int mjpeg_decode_end(AVCodecContext *avctx)
2199 {
2200 MJpegDecodeContext *s = avctx->priv_data;
2201 int i, j;
2202
2203 av_free(s->buffer);
2204 av_free(s->qscale_table);
2205 avcodec_default_free_buffers(avctx);
2206
2207 for(i=0;i<2;i++) {
2208 for(j=0;j<4;j++)
2209 free_vlc(&s->vlcs[i][j]);
2210 }
2211 return 0;
2212 }
2213
2214 AVCodec mjpeg_decoder = {
2215 "mjpeg",
2216 CODEC_TYPE_VIDEO,
2217 CODEC_ID_MJPEG,
2218 sizeof(MJpegDecodeContext),
2219 mjpeg_decode_init,
2220 NULL,
2221 mjpeg_decode_end,
2222 mjpeg_decode_frame,
2223 CODEC_CAP_DR1,
2224 NULL
2225 };
2226
2227 AVCodec mjpegb_decoder = {
2228 "mjpegb",
2229 CODEC_TYPE_VIDEO,
2230 CODEC_ID_MJPEGB,
2231 sizeof(MJpegDecodeContext),
2232 mjpeg_decode_init,
2233 NULL,
2234 mjpeg_decode_end,
2235 mjpegb_decode_frame,
2236 CODEC_CAP_DR1,
2237 NULL
2238 };
2239
2240 AVCodec sp5x_decoder = {
2241 "sp5x",
2242 CODEC_TYPE_VIDEO,
2243 CODEC_ID_SP5X,
2244 sizeof(MJpegDecodeContext),
2245 mjpeg_decode_init,
2246 NULL,
2247 mjpeg_decode_end,
2248 sp5x_decode_frame,
2249 CODEC_CAP_DR1,
2250 NULL
2251 };
2252
2253 #ifdef CONFIG_ENCODERS
2254 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2255 "ljpeg",
2256 CODEC_TYPE_VIDEO,
2257 CODEC_ID_LJPEG,
2258 sizeof(MpegEncContext),
2259 MPV_encode_init,
2260 encode_picture_lossless,
2261 MPV_encode_end,
2262 };
2263 #endif