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