Mercurial > audlegacy-plugins

comparison src/ffmpeg/libavcodec/mjpeg.c @ 808:e8776388b02a trunk

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