VirtualBox

source: vbox/trunk/src/libs/ffmpeg-20060710/libavcodec/mjpeg.c@ 5776

Last change on this file since 5776 was 5776, checked in by vboxsync, 17 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette