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