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