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