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