0f2a4e7196615ade3f9a8bb1ef0f4fd37e5df557
[libav.git] / libavcodec / mjpeg.c
1 /*
2 * MJPEG encoder and decoder
3 * Copyright (c) 2000, 2001 Fabrice Bellard.
4 * Copyright (c) 2003 Alex Beregszaszi
5 * Copyright (c) 2003-2004 Michael Niedermayer
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 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 <alex@naxine.org>
24 */
25
26 /**
27 * @file mjpeg.c
28 * MJPEG encoder and decoder.
29 */
30
31 //#define DEBUG
32 #include <assert.h>
33
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "mpegvideo.h"
37
38 /* use two quantizer tables (one for luminance and one for chrominance) */
39 /* not yet working */
40 #undef TWOMATRIXES
41
42 typedef struct MJpegContext {
43 uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing
44 uint16_t huff_code_dc_luminance[12];
45 uint8_t huff_size_dc_chrominance[12];
46 uint16_t huff_code_dc_chrominance[12];
47
48 uint8_t huff_size_ac_luminance[256];
49 uint16_t huff_code_ac_luminance[256];
50 uint8_t huff_size_ac_chrominance[256];
51 uint16_t huff_code_ac_chrominance[256];
52 } MJpegContext;
53
54 /* JPEG marker codes */
55 typedef enum {
56 /* start of frame */
57 SOF0 = 0xc0, /* baseline */
58 SOF1 = 0xc1, /* extended sequential, huffman */
59 SOF2 = 0xc2, /* progressive, huffman */
60 SOF3 = 0xc3, /* lossless, huffman */
61
62 SOF5 = 0xc5, /* differential sequential, huffman */
63 SOF6 = 0xc6, /* differential progressive, huffman */
64 SOF7 = 0xc7, /* differential lossless, huffman */
65 JPG = 0xc8, /* reserved for JPEG extension */
66 SOF9 = 0xc9, /* extended sequential, arithmetic */
67 SOF10 = 0xca, /* progressive, arithmetic */
68 SOF11 = 0xcb, /* lossless, arithmetic */
69
70 SOF13 = 0xcd, /* differential sequential, arithmetic */
71 SOF14 = 0xce, /* differential progressive, arithmetic */
72 SOF15 = 0xcf, /* differential lossless, arithmetic */
73
74 DHT = 0xc4, /* define huffman tables */
75
76 DAC = 0xcc, /* define arithmetic-coding conditioning */
77
78 /* restart with modulo 8 count "m" */
79 RST0 = 0xd0,
80 RST1 = 0xd1,
81 RST2 = 0xd2,
82 RST3 = 0xd3,
83 RST4 = 0xd4,
84 RST5 = 0xd5,
85 RST6 = 0xd6,
86 RST7 = 0xd7,
87
88 SOI = 0xd8, /* start of image */
89 EOI = 0xd9, /* end of image */
90 SOS = 0xda, /* start of scan */
91 DQT = 0xdb, /* define quantization tables */
92 DNL = 0xdc, /* define number of lines */
93 DRI = 0xdd, /* define restart interval */
94 DHP = 0xde, /* define hierarchical progression */
95 EXP = 0xdf, /* expand reference components */
96
97 APP0 = 0xe0,
98 APP1 = 0xe1,
99 APP2 = 0xe2,
100 APP3 = 0xe3,
101 APP4 = 0xe4,
102 APP5 = 0xe5,
103 APP6 = 0xe6,
104 APP7 = 0xe7,
105 APP8 = 0xe8,
106 APP9 = 0xe9,
107 APP10 = 0xea,
108 APP11 = 0xeb,
109 APP12 = 0xec,
110 APP13 = 0xed,
111 APP14 = 0xee,
112 APP15 = 0xef,
113
114 JPG0 = 0xf0,
115 JPG1 = 0xf1,
116 JPG2 = 0xf2,
117 JPG3 = 0xf3,
118 JPG4 = 0xf4,
119 JPG5 = 0xf5,
120 JPG6 = 0xf6,
121 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 */
141 static const unsigned char std_luminance_quant_tbl[64] = {
142 16, 11, 10, 16, 24, 40, 51, 61,
143 12, 12, 14, 19, 26, 58, 60, 55,
144 14, 13, 16, 24, 40, 57, 69, 56,
145 14, 17, 22, 29, 51, 87, 80, 62,
146 18, 22, 37, 56, 68, 109, 103, 77,
147 24, 35, 55, 64, 81, 104, 113, 92,
148 49, 64, 78, 87, 103, 121, 120, 101,
149 72, 92, 95, 98, 112, 100, 103, 99
150 };
151 static const unsigned char std_chrominance_quant_tbl[64] = {
152 17, 18, 24, 47, 99, 99, 99, 99,
153 18, 21, 26, 66, 99, 99, 99, 99,
154 24, 26, 56, 99, 99, 99, 99, 99,
155 47, 66, 99, 99, 99, 99, 99, 99,
156 99, 99, 99, 99, 99, 99, 99, 99,
157 99, 99, 99, 99, 99, 99, 99, 99,
158 99, 99, 99, 99, 99, 99, 99, 99,
159 99, 99, 99, 99, 99, 99, 99, 99
160 };
161 #endif
162
163 /* Set up the standard Huffman tables (cf. JPEG standard section K.3) */
164 /* IMPORTANT: these are only valid for 8-bit data precision! */
165 static const uint8_t bits_dc_luminance[17] =
166 { /* 0-base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 };
167 static const uint8_t val_dc_luminance[] =
168 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
169
170 static const uint8_t bits_dc_chrominance[17] =
171 { /* 0-base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
172 static const uint8_t val_dc_chrominance[] =
173 { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
174
175 static const uint8_t bits_ac_luminance[17] =
176 { /* 0-base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d };
177 static const uint8_t val_ac_luminance[] =
178 { 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
179 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
180 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
181 0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
182 0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
183 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
184 0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
185 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
186 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
187 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
188 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
189 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
190 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
191 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
192 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
193 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
194 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
195 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
196 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
197 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
198 0xf9, 0xfa
199 };
200
201 static const uint8_t bits_ac_chrominance[17] =
202 { /* 0-base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 };
203
204 static const uint8_t val_ac_chrominance[] =
205 { 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
206 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
207 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
208 0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
209 0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
210 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
211 0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
212 0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
213 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
214 0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
215 0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
216 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217 0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
218 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
219 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
220 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
221 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
222 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
223 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
224 0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
225 0xf9, 0xfa
226 };
227
228 /* isn't this function nicer than the one in the libjpeg ? */
229 static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
230 const uint8_t *bits_table, const uint8_t *val_table)
231 {
232 int i, j, k,nb, code, sym;
233
234 code = 0;
235 k = 0;
236 for(i=1;i<=16;i++) {
237 nb = bits_table[i];
238 for(j=0;j<nb;j++) {
239 sym = val_table[k++];
240 huff_size[sym] = i;
241 huff_code[sym] = code;
242 code++;
243 }
244 code <<= 1;
245 }
246 }
247
248 #ifdef CONFIG_ENCODERS
249 int mjpeg_init(MpegEncContext *s)
250 {
251 MJpegContext *m;
252
253 m = av_malloc(sizeof(MJpegContext));
254 if (!m)
255 return -1;
256
257 s->min_qcoeff=-1023;
258 s->max_qcoeff= 1023;
259
260 /* build all the huffman tables */
261 build_huffman_codes(m->huff_size_dc_luminance,
262 m->huff_code_dc_luminance,
263 bits_dc_luminance,
264 val_dc_luminance);
265 build_huffman_codes(m->huff_size_dc_chrominance,
266 m->huff_code_dc_chrominance,
267 bits_dc_chrominance,
268 val_dc_chrominance);
269 build_huffman_codes(m->huff_size_ac_luminance,
270 m->huff_code_ac_luminance,
271 bits_ac_luminance,
272 val_ac_luminance);
273 build_huffman_codes(m->huff_size_ac_chrominance,
274 m->huff_code_ac_chrominance,
275 bits_ac_chrominance,
276 val_ac_chrominance);
277
278 s->mjpeg_ctx = m;
279 return 0;
280 }
281
282 void mjpeg_close(MpegEncContext *s)
283 {
284 av_free(s->mjpeg_ctx);
285 }
286 #endif //CONFIG_ENCODERS
287
288 #define PREDICT(ret, topleft, top, left, predictor)\
289 switch(predictor){\
290 case 1: ret= left; break;\
291 case 2: ret= top; break;\
292 case 3: ret= topleft; break;\
293 case 4: ret= left + top - topleft; break;\
294 case 5: ret= left + ((top - topleft)>>1); break;\
295 case 6: ret= top + ((left - topleft)>>1); break;\
296 default:\
297 case 7: ret= (left + top)>>1; break;\
298 }
299
300 #ifdef CONFIG_ENCODERS
301 static inline void put_marker(PutBitContext *p, int code)
302 {
303 put_bits(p, 8, 0xff);
304 put_bits(p, 8, code);
305 }
306
307 /* table_class: 0 = DC coef, 1 = AC coefs */
308 static int put_huffman_table(MpegEncContext *s, int table_class, int table_id,
309 const uint8_t *bits_table, const uint8_t *value_table)
310 {
311 PutBitContext *p = &s->pb;
312 int n, i;
313
314 put_bits(p, 4, table_class);
315 put_bits(p, 4, table_id);
316
317 n = 0;
318 for(i=1;i<=16;i++) {
319 n += bits_table[i];
320 put_bits(p, 8, bits_table[i]);
321 }
322
323 for(i=0;i<n;i++)
324 put_bits(p, 8, value_table[i]);
325
326 return n + 17;
327 }
328
329 static void jpeg_table_header(MpegEncContext *s)
330 {
331 PutBitContext *p = &s->pb;
332 int i, j, size;
333 uint8_t *ptr;
334
335 /* quant matrixes */
336 put_marker(p, DQT);
337 #ifdef TWOMATRIXES
338 put_bits(p, 16, 2 + 2 * (1 + 64));
339 #else
340 put_bits(p, 16, 2 + 1 * (1 + 64));
341 #endif
342 put_bits(p, 4, 0); /* 8 bit precision */
343 put_bits(p, 4, 0); /* table 0 */
344 for(i=0;i<64;i++) {
345 j = s->intra_scantable.permutated[i];
346 put_bits(p, 8, s->intra_matrix[j]);
347 }
348 #ifdef TWOMATRIXES
349 put_bits(p, 4, 0); /* 8 bit precision */
350 put_bits(p, 4, 1); /* table 1 */
351 for(i=0;i<64;i++) {
352 j = s->intra_scantable.permutated[i];
353 put_bits(p, 8, s->chroma_intra_matrix[j]);
354 }
355 #endif
356
357 /* huffman table */
358 put_marker(p, DHT);
359 flush_put_bits(p);
360 ptr = pbBufPtr(p);
361 put_bits(p, 16, 0); /* patched later */
362 size = 2;
363 size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance);
364 size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance);
365
366 size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance);
367 size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance);
368 ptr[0] = size >> 8;
369 ptr[1] = size;
370 }
371
372 static void jpeg_put_comments(MpegEncContext *s)
373 {
374 PutBitContext *p = &s->pb;
375 int size;
376 uint8_t *ptr;
377
378 if (s->aspect_ratio_info /* && !lossless */)
379 {
380 /* JFIF header */
381 put_marker(p, APP0);
382 put_bits(p, 16, 16);
383 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
418 void 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
510 static 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
566 void 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
573 void 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
585 static 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
607 static 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
665 void 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
674 static 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
829 typedef 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
894 static int mjpeg_decode_dht(MJpegDecodeContext *s);
895
896 static 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
918 static 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 */
964 static 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
1001 static 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 */
1023 static 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 */
1058 static 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
1104 static 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
1240 static 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 */
1258 static 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 VLC *ac_vlc;
1263
1264 /* DC coef */
1265 val = mjpeg_decode_dc(s, dc_index);
1266 if (val == 0xffff) {
1267 dprintf("error dc\n");
1268 return -1;
1269 }
1270 val = val * quant_matrix[0] + s->last_dc[component];
1271 s->last_dc[component] = val;
1272 block[0] = val;
1273 /* AC coefs */
1274 ac_vlc = &s->vlcs[1][ac_index];
1275 i = 0;
1276 OPEN_READER(re, &s->gb)
1277 for(;;) {
1278 UPDATE_CACHE(re, &s->gb);
1279 GET_VLC(code, re, &s->gb, s->vlcs[1][ac_index].table, 9, 2)
1280
1281 /* EOB */
1282 if (code == 0x10)
1283 break;
1284 if (code == 0x100) {
1285 i += 16;
1286 } else {
1287 i += ((unsigned)code) >> 4;
1288 code &= 0xf;
1289
1290 UPDATE_CACHE(re, &s->gb)
1291
1292 if ((int32_t)GET_CACHE(re,&s->gb)<0) { //MSB=1
1293 level = NEG_USR32( GET_CACHE(re,&s->gb),code);
1294 } else {
1295 level = - NEG_USR32(~GET_CACHE(re,&s->gb),code);
1296 }
1297
1298 LAST_SKIP_BITS(re, &s->gb, code)
1299
1300 if (i >= 63) {
1301 if(i == 63){
1302 j = s->scantable.permutated[63];
1303 block[j] = level * quant_matrix[j];
1304 break;
1305 }
1306 dprintf("error count: %d\n", i);
1307 return -1;
1308 }
1309 j = s->scantable.permutated[i];
1310 block[j] = level * quant_matrix[j];
1311 }
1312 }
1313 CLOSE_READER(re, &s->gb)
1314
1315 return 0;
1316 }
1317
1318 static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1319 int i, mb_x, mb_y;
1320 uint16_t buffer[32768][4];
1321 int left[3], top[3], topleft[3];
1322 const int linesize= s->linesize[0];
1323 const int mask= (1<<s->bits)-1;
1324
1325 if((unsigned)s->mb_width > 32768) //dynamic alloc
1326 return -1;
1327
1328 for(i=0; i<3; i++){
1329 buffer[0][i]= 1 << (s->bits + point_transform - 1);
1330 }
1331 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1332 const int modified_predictor= mb_y ? predictor : 1;
1333 uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
1334
1335 if (s->interlaced && s->bottom_field)
1336 ptr += linesize >> 1;
1337
1338 for(i=0; i<3; i++){
1339 top[i]= left[i]= topleft[i]= buffer[0][i];
1340 }
1341 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1342 if (s->restart_interval && !s->restart_count)
1343 s->restart_count = s->restart_interval;
1344
1345 for(i=0;i<3;i++) {
1346 int pred;
1347
1348 topleft[i]= top[i];
1349 top[i]= buffer[mb_x][i];
1350
1351 PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
1352
1353 left[i]=
1354 buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
1355 }
1356
1357 if (s->restart_interval && !--s->restart_count) {
1358 align_get_bits(&s->gb);
1359 skip_bits(&s->gb, 16); /* skip RSTn */
1360 }
1361 }
1362
1363 if(s->rct){
1364 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1365 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2] - 0x200)>>2);
1366 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1367 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1368 }
1369 }else if(s->pegasus_rct){
1370 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1371 ptr[4*mb_x+1] = buffer[mb_x][0] - ((buffer[mb_x][1] + buffer[mb_x][2])>>2);
1372 ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1];
1373 ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1];
1374 }
1375 }else{
1376 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1377 ptr[4*mb_x+0] = buffer[mb_x][0];
1378 ptr[4*mb_x+1] = buffer[mb_x][1];
1379 ptr[4*mb_x+2] = buffer[mb_x][2];
1380 }
1381 }
1382 }
1383 return 0;
1384 }
1385
1386 static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
1387 int i, mb_x, mb_y;
1388 const int nb_components=3;
1389
1390 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1391 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1392 if (s->restart_interval && !s->restart_count)
1393 s->restart_count = s->restart_interval;
1394
1395 if(mb_x==0 || mb_y==0 || s->interlaced){
1396 for(i=0;i<nb_components;i++) {
1397 uint8_t *ptr;
1398 int n, h, v, x, y, c, j, linesize;
1399 n = s->nb_blocks[i];
1400 c = s->comp_index[i];
1401 h = s->h_scount[i];
1402 v = s->v_scount[i];
1403 x = 0;
1404 y = 0;
1405 linesize= s->linesize[c];
1406
1407 for(j=0; j<n; j++) {
1408 int pred;
1409
1410 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1411 if(y==0 && mb_y==0){
1412 if(x==0 && mb_x==0){
1413 pred= 128 << point_transform;
1414 }else{
1415 pred= ptr[-1];
1416 }
1417 }else{
1418 if(x==0 && mb_x==0){
1419 pred= ptr[-linesize];
1420 }else{
1421 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1422 }
1423 }
1424
1425 if (s->interlaced && s->bottom_field)
1426 ptr += linesize >> 1;
1427 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1428
1429 if (++x == h) {
1430 x = 0;
1431 y++;
1432 }
1433 }
1434 }
1435 }else{
1436 for(i=0;i<nb_components;i++) {
1437 uint8_t *ptr;
1438 int n, h, v, x, y, c, j, linesize;
1439 n = s->nb_blocks[i];
1440 c = s->comp_index[i];
1441 h = s->h_scount[i];
1442 v = s->v_scount[i];
1443 x = 0;
1444 y = 0;
1445 linesize= s->linesize[c];
1446
1447 for(j=0; j<n; j++) {
1448 int pred;
1449
1450 ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
1451 PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
1452 *ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
1453 if (++x == h) {
1454 x = 0;
1455 y++;
1456 }
1457 }
1458 }
1459 }
1460 if (s->restart_interval && !--s->restart_count) {
1461 align_get_bits(&s->gb);
1462 skip_bits(&s->gb, 16); /* skip RSTn */
1463 }
1464 }
1465 }
1466 return 0;
1467 }
1468
1469 static int mjpeg_decode_scan(MJpegDecodeContext *s){
1470 int i, mb_x, mb_y;
1471 const int nb_components=3;
1472
1473 for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
1474 for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
1475 if (s->restart_interval && !s->restart_count)
1476 s->restart_count = s->restart_interval;
1477
1478 for(i=0;i<nb_components;i++) {
1479 uint8_t *ptr;
1480 int n, h, v, x, y, c, j;
1481 n = s->nb_blocks[i];
1482 c = s->comp_index[i];
1483 h = s->h_scount[i];
1484 v = s->v_scount[i];
1485 x = 0;
1486 y = 0;
1487 for(j=0;j<n;j++) {
1488 memset(s->block, 0, sizeof(s->block));
1489 if (decode_block(s, s->block, i,
1490 s->dc_index[i], s->ac_index[i],
1491 s->quant_matrixes[ s->quant_index[c] ]) < 0) {
1492 dprintf("error y=%d x=%d\n", mb_y, mb_x);
1493 return -1;
1494 }
1495 // dprintf("mb: %d %d processed\n", mb_y, mb_x);
1496 ptr = s->picture.data[c] +
1497 (((s->linesize[c] * (v * mb_y + y) * 8) +
1498 (h * mb_x + x) * 8) >> s->avctx->lowres);
1499 if (s->interlaced && s->bottom_field)
1500 ptr += s->linesize[c] >> 1;
1501 //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);
1502 s->idct_put(ptr, s->linesize[c], s->block);
1503 if (++x == h) {
1504 x = 0;
1505 y++;
1506 }
1507 }
1508 }
1509 /* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */
1510 if (s->restart_interval && (s->restart_interval < 1350) &&
1511 !--s->restart_count) {
1512 align_get_bits(&s->gb);
1513 skip_bits(&s->gb, 16); /* skip RSTn */
1514 for (i=0; i<nb_components; i++) /* reset dc */
1515 s->last_dc[i] = 1024;
1516 }
1517 }
1518 }
1519 return 0;
1520 }
1521
1522 static int mjpeg_decode_sos(MJpegDecodeContext *s)
1523 {
1524 int len, nb_components, i, h, v, predictor, point_transform;
1525 int vmax, hmax, index, id;
1526 const int block_size= s->lossless ? 1 : 8;
1527 int ilv;
1528
1529 /* XXX: verify len field validity */
1530 len = get_bits(&s->gb, 16);
1531 nb_components = get_bits(&s->gb, 8);
1532 if (len != 6+2*nb_components)
1533 {
1534 dprintf("decode_sos: invalid len (%d)\n", len);
1535 return -1;
1536 }
1537 /* XXX: only interleaved scan accepted */
1538 if ((nb_components != s->nb_components) && !s->ls)
1539 {
1540 dprintf("decode_sos: components(%d) mismatch\n", nb_components);
1541 return -1;
1542 }
1543 vmax = 0;
1544 hmax = 0;
1545 for(i=0;i<nb_components;i++) {
1546 id = get_bits(&s->gb, 8) - 1;
1547 dprintf("component: %d\n", id);
1548 /* find component index */
1549 for(index=0;index<s->nb_components;index++)
1550 if (id == s->component_id[index])
1551 break;
1552 if (index == s->nb_components)
1553 {
1554 dprintf("decode_sos: index(%d) out of components\n", index);
1555 return -1;
1556 }
1557
1558 s->comp_index[i] = index;
1559
1560 s->nb_blocks[i] = s->h_count[index] * s->v_count[index];
1561 s->h_scount[i] = s->h_count[index];
1562 s->v_scount[i] = s->v_count[index];
1563
1564 s->dc_index[i] = get_bits(&s->gb, 4);
1565 s->ac_index[i] = get_bits(&s->gb, 4);
1566
1567 if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
1568 s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
1569 goto out_of_range;
1570 #if 0 //buggy
1571 switch(s->start_code)
1572 {
1573 case SOF0:
1574 if (dc_index[i] > 1 || ac_index[i] > 1)
1575 goto out_of_range;
1576 break;
1577 case SOF1:
1578 case SOF2:
1579 if (dc_index[i] > 3 || ac_index[i] > 3)
1580 goto out_of_range;
1581 break;
1582 case SOF3:
1583 if (dc_index[i] > 3 || ac_index[i] != 0)
1584 goto out_of_range;
1585 break;
1586 }
1587 #endif
1588 }
1589
1590 predictor= get_bits(&s->gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEG-LS NEAR */
1591 ilv= get_bits(&s->gb, 8); /* JPEG Se / JPEG-LS ILV */
1592 skip_bits(&s->gb, 4); /* Ah */
1593 point_transform= get_bits(&s->gb, 4); /* Al */
1594
1595 for(i=0;i<nb_components;i++)
1596 s->last_dc[i] = 1024;
1597
1598 if (nb_components > 1) {
1599 /* interleaved stream */
1600 s->mb_width = (s->width + s->h_max * block_size - 1) / (s->h_max * block_size);
1601 s->mb_height = (s->height + s->v_max * block_size - 1) / (s->v_max * block_size);
1602 } else if(!s->ls) { /* skip this for JPEG-LS */
1603 h = s->h_max / s->h_scount[s->comp_index[0]];
1604 v = s->v_max / s->v_scount[s->comp_index[0]];
1605 s->mb_width = (s->width + h * block_size - 1) / (h * block_size);
1606 s->mb_height = (s->height + v * block_size - 1) / (v * block_size);
1607 s->nb_blocks[0] = 1;
1608 s->h_scount[0] = 1;
1609 s->v_scount[0] = 1;
1610 }
1611
1612 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1613 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" : "",
1614 predictor, point_transform, ilv, s->bits,
1615 s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
1616
1617
1618 /* mjpeg-b can have padding bytes between sos and image data, skip them */
1619 for (i = s->mjpb_skiptosod; i > 0; i--)
1620 skip_bits(&s->gb, 8);
1621
1622 if(s->lossless){
1623 if(s->ls){
1624 // for(){
1625 // reset_ls_coding_parameters(s, 0);
1626
1627 ls_decode_picture(s, predictor, point_transform, ilv);
1628 }else{
1629 if(s->rgb){
1630 if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0)
1631 return -1;
1632 }else{
1633 if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0)
1634 return -1;
1635 }
1636 }
1637 }else{
1638 if(mjpeg_decode_scan(s) < 0)
1639 return -1;
1640 }
1641 emms_c();
1642 return 0;
1643 out_of_range:
1644 dprintf("decode_sos: ac/dc index out of range\n");
1645 return -1;
1646 }
1647
1648 static int mjpeg_decode_dri(MJpegDecodeContext *s)
1649 {
1650 if (get_bits(&s->gb, 16) != 4)
1651 return -1;
1652 s->restart_interval = get_bits(&s->gb, 16);
1653 s->restart_count = 0;
1654 dprintf("restart interval: %d\n", s->restart_interval);
1655
1656 return 0;
1657 }
1658
1659 static int mjpeg_decode_app(MJpegDecodeContext *s)
1660 {
1661 int len, id;
1662
1663 len = get_bits(&s->gb, 16);
1664 if (len < 5)
1665 return -1;
1666 if(8*len + get_bits_count(&s->gb) > s->gb.size_in_bits)
1667 return -1;
1668
1669 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1670 id = be2me_32(id);
1671 len -= 6;
1672
1673 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1674 av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
1675 }
1676
1677 /* buggy AVID, it puts EOI only at every 10th frame */
1678 /* also this fourcc is used by non-avid files too, it holds some
1679 informations, but it's always present in AVID creates files */
1680 if (id == ff_get_fourcc("AVI1"))
1681 {
1682 /* structure:
1683 4bytes AVI1
1684 1bytes polarity
1685 1bytes always zero
1686 4bytes field_size
1687 4bytes field_size_less_padding
1688 */
1689 s->buggy_avid = 1;
1690 // if (s->first_picture)
1691 // printf("mjpeg: workarounding buggy AVID\n");
1692 s->interlace_polarity = get_bits(&s->gb, 8);
1693 #if 0
1694 skip_bits(&s->gb, 8);
1695 skip_bits(&s->gb, 32);
1696 skip_bits(&s->gb, 32);
1697 len -= 10;
1698 #endif
1699 // if (s->interlace_polarity)
1700 // printf("mjpeg: interlace polarity: %d\n", s->interlace_polarity);
1701 goto out;
1702 }
1703
1704 // len -= 2;
1705
1706 if (id == ff_get_fourcc("JFIF"))
1707 {
1708 int t_w, t_h, v1, v2;
1709 skip_bits(&s->gb, 8); /* the trailing zero-byte */
1710 v1= get_bits(&s->gb, 8);
1711 v2= get_bits(&s->gb, 8);
1712 skip_bits(&s->gb, 8);
1713
1714 s->avctx->sample_aspect_ratio.num= get_bits(&s->gb, 16);
1715 s->avctx->sample_aspect_ratio.den= get_bits(&s->gb, 16);
1716
1717 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1718 av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
1719 v1, v2,
1720 s->avctx->sample_aspect_ratio.num,
1721 s->avctx->sample_aspect_ratio.den
1722 );
1723
1724 t_w = get_bits(&s->gb, 8);
1725 t_h = get_bits(&s->gb, 8);
1726 if (t_w && t_h)
1727 {
1728 /* skip thumbnail */
1729 if (len-10-(t_w*t_h*3) > 0)
1730 len -= t_w*t_h*3;
1731 }
1732 len -= 10;
1733 goto out;
1734 }
1735
1736 if (id == ff_get_fourcc("Adob") && (get_bits(&s->gb, 8) == 'e'))
1737 {
1738 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1739 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
1740 skip_bits(&s->gb, 16); /* version */
1741 skip_bits(&s->gb, 16); /* flags0 */
1742 skip_bits(&s->gb, 16); /* flags1 */
1743 skip_bits(&s->gb, 8); /* transform */
1744 len -= 7;
1745 goto out;
1746 }
1747
1748 if (id == ff_get_fourcc("LJIF")){
1749 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1750 av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
1751 skip_bits(&s->gb, 16); /* version ? */
1752 skip_bits(&s->gb, 16); /* unknwon always 0? */
1753 skip_bits(&s->gb, 16); /* unknwon always 0? */
1754 skip_bits(&s->gb, 16); /* unknwon always 0? */
1755 switch( get_bits(&s->gb, 8)){
1756 case 1:
1757 s->rgb= 1;
1758 s->pegasus_rct=0;
1759 break;
1760 case 2:
1761 s->rgb= 1;
1762 s->pegasus_rct=1;
1763 break;
1764 default:
1765 av_log(s->avctx, AV_LOG_ERROR, "unknown colorspace\n");
1766 }
1767 len -= 9;
1768 goto out;
1769 }
1770
1771 /* Apple MJPEG-A */
1772 if ((s->start_code == APP1) && (len > (0x28 - 8)))
1773 {
1774 id = (get_bits(&s->gb, 16) << 16) | get_bits(&s->gb, 16);
1775 id = be2me_32(id);
1776 len -= 4;
1777 if (id == ff_get_fourcc("mjpg")) /* Apple MJPEG-A */
1778 {
1779 #if 0
1780 skip_bits(&s->gb, 32); /* field size */
1781 skip_bits(&s->gb, 32); /* pad field size */
1782 skip_bits(&s->gb, 32); /* next off */
1783 skip_bits(&s->gb, 32); /* quant off */
1784 skip_bits(&s->gb, 32); /* huff off */
1785 skip_bits(&s->gb, 32); /* image off */
1786 skip_bits(&s->gb, 32); /* scan off */
1787 skip_bits(&s->gb, 32); /* data off */
1788 #endif
1789 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1790 av_log(s->avctx, AV_LOG_INFO, "mjpeg: Apple MJPEG-A header found\n");
1791 }
1792 }
1793
1794 out:
1795 /* slow but needed for extreme adobe jpegs */
1796 if (len < 0)
1797 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
1798 while(--len > 0)
1799 skip_bits(&s->gb, 8);
1800
1801 return 0;
1802 }
1803
1804 static int mjpeg_decode_com(MJpegDecodeContext *s)
1805 {
1806 int len = get_bits(&s->gb, 16);
1807 if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
1808 uint8_t *cbuf = av_malloc(len - 1);
1809 if (cbuf) {
1810 int i;
1811 for (i = 0; i < len - 2; i++)
1812 cbuf[i] = get_bits(&s->gb, 8);
1813 if (i > 0 && cbuf[i-1] == '\n')
1814 cbuf[i-1] = 0;
1815 else
1816 cbuf[i] = 0;
1817
1818 if(s->avctx->debug & FF_DEBUG_PICT_INFO)
1819 av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
1820
1821 /* buggy avid, it puts EOI only at every 10th frame */
1822 if (!strcmp(cbuf, "AVID"))
1823 {
1824 s->buggy_avid = 1;
1825 // if (s->first_picture)
1826 // printf("mjpeg: workarounding buggy AVID\n");
1827 }
1828 else if(!strcmp(cbuf, "CS=ITU601")){
1829 s->cs_itu601= 1;
1830 }
1831
1832 av_free(cbuf);
1833 }
1834 }
1835
1836 return 0;
1837 }
1838
1839 #if 0
1840 static int valid_marker_list[] =
1841 {
1842 /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
1843 /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1844 /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1845 /* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1846 /* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1847 /* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1848 /* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1849 /* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1850 /* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1851 /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1852 /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1853 /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1854 /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1855 /* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1856 /* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1857 /* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1858 /* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
1859 }
1860 #endif
1861
1862 /* return the 8 bit start code value and update the search
1863 state. Return -1 if no start code found */
1864 static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end)
1865 {
1866 uint8_t *buf_ptr;
1867 unsigned int v, v2;
1868 int val;
1869 #ifdef DEBUG
1870 int skipped=0;
1871 #endif
1872
1873 buf_ptr = *pbuf_ptr;
1874 while (buf_ptr < buf_end) {
1875 v = *buf_ptr++;
1876 v2 = *buf_ptr;
1877 if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) {
1878 val = *buf_ptr++;
1879 goto found;
1880 }
1881 #ifdef DEBUG
1882 skipped++;
1883 #endif
1884 }
1885 val = -1;
1886 found:
1887 #ifdef DEBUG
1888 dprintf("find_marker skipped %d bytes\n", skipped);
1889 #endif
1890 *pbuf_ptr = buf_ptr;
1891 return val;
1892 }
1893
1894 static int mjpeg_decode_frame(AVCodecContext *avctx,
1895 void *data, int *data_size,
1896 uint8_t *buf, int buf_size)
1897 {
1898 MJpegDecodeContext *s = avctx->priv_data;
1899 uint8_t *buf_end, *buf_ptr;
1900 int start_code;
1901 AVFrame *picture = data;
1902
1903 buf_ptr = buf;
1904 buf_end = buf + buf_size;
1905 while (buf_ptr < buf_end) {
1906 /* find start next marker */
1907 start_code = find_marker(&buf_ptr, buf_end);
1908 {
1909 /* EOF */
1910 if (start_code < 0) {
1911 goto the_end;
1912 } else {
1913 dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end - buf_ptr);
1914
1915 if ((buf_end - buf_ptr) > s->buffer_size)
1916 {
1917 av_free(s->buffer);
1918 s->buffer_size = buf_end-buf_ptr;
1919 s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
1920 dprintf("buffer too small, expanding to %d bytes\n",
1921 s->buffer_size);
1922 }
1923
1924 /* unescape buffer of SOS, use special treatment for JPEG-LS */
1925 if (start_code == SOS && !s->ls)
1926 {
1927 uint8_t *src = buf_ptr;
1928 uint8_t *dst = s->buffer;
1929
1930 while (src<buf_end)
1931 {
1932 uint8_t x = *(src++);
1933
1934 *(dst++) = x;
1935 if (x == 0xff)
1936 {
1937 while(src<buf_end && x == 0xff)
1938 x = *(src++);
1939
1940 if (x >= 0xd0 && x <= 0xd7)
1941 *(dst++) = x;
1942 else if (x)
1943 break;
1944 }
1945 }
1946 init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
1947
1948 dprintf("escaping removed %d bytes\n",
1949 (buf_end - buf_ptr) - (dst - s->buffer));
1950 }
1951 else if(start_code == SOS && s->ls){
1952 uint8_t *src = buf_ptr;
1953 uint8_t *dst = s->buffer;
1954 int bit_count = 0;
1955 int t = 0, b = 0;
1956 PutBitContext pb;
1957
1958 s->cur_scan++;
1959
1960 /* find marker */
1961 while (src + t < buf_end){
1962 uint8_t x = src[t++];
1963 if (x == 0xff){
1964 while((src + t < buf_end) && x == 0xff)
1965 x = src[t++];
1966 if (x & 0x80) {
1967 t -= 2;
1968 break;
1969 }
1970 }
1971 }
1972 bit_count = t * 8;
1973
1974 init_put_bits(&pb, dst, t);
1975
1976 /* unescape bitstream */
1977 while(b < t){
1978 uint8_t x = src[b++];
1979 put_bits(&pb, 8, x);
1980 if(x == 0xFF){
1981 x = src[b++];
1982 put_bits(&pb, 7, x);
1983 bit_count--;
1984 }
1985 }
1986 flush_put_bits(&pb);
1987
1988 init_get_bits(&s->gb, dst, bit_count);
1989 }
1990 else
1991 init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
1992
1993 s->start_code = start_code;
1994 if(s->avctx->debug & FF_DEBUG_STARTCODE){
1995 av_log(s->avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
1996 }
1997
1998 /* process markers */
1999 if (start_code >= 0xd0 && start_code <= 0xd7) {
2000 dprintf("restart marker: %d\n", start_code&0x0f);
2001 /* APP fields */
2002 } else if (start_code >= APP0 && start_code <= APP15) {
2003 mjpeg_decode_app(s);
2004 /* Comment */
2005 } else if (start_code == COM){
2006 mjpeg_decode_com(s);
2007 }
2008
2009 switch(start_code) {
2010 case SOI:
2011 s->restart_interval = 0;
2012
2013 s->restart_count = 0;
2014 /* nothing to do on SOI */
2015 break;
2016 case DQT:
2017 mjpeg_decode_dqt(s);
2018 break;
2019 case DHT:
2020 if(mjpeg_decode_dht(s) < 0){
2021 av_log(s->avctx, AV_LOG_ERROR, "huffman table decode error\n");
2022 return -1;
2023 }
2024 break;
2025 case SOF0:
2026 s->lossless=0;
2027 if (mjpeg_decode_sof(s) < 0)
2028 return -1;
2029 break;
2030 case SOF3:
2031 s->lossless=1;
2032 if (mjpeg_decode_sof(s) < 0)
2033 return -1;
2034 break;
2035 case SOF48:
2036 s->lossless=1;
2037 s->ls=1;
2038 if (mjpeg_decode_sof(s) < 0)
2039 return -1;
2040 break;
2041 case LSE:
2042 if (decode_lse(s) < 0)
2043 return -1;
2044 break;
2045 case EOI:
2046 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2047 break;
2048 eoi_parser:
2049 {
2050 if (s->interlaced) {
2051 s->bottom_field ^= 1;
2052 /* if not bottom field, do not output image yet */
2053 if (s->bottom_field)
2054 goto not_the_end;
2055 }
2056 *picture = s->picture;
2057 *data_size = sizeof(AVFrame);
2058
2059 if(!s->lossless){
2060 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2061 picture->qstride= 0;
2062 picture->qscale_table= s->qscale_table;
2063 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2064 if(avctx->debug & FF_DEBUG_QP)
2065 av_log(s->avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2066 picture->quality*= FF_QP2LAMBDA;
2067 }
2068
2069 goto the_end;
2070 }
2071 break;
2072 case SOS:
2073 mjpeg_decode_sos(s);
2074 /* buggy avid puts EOI every 10-20th frame */
2075 /* if restart period is over process EOI */
2076 if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
2077 goto eoi_parser;
2078 break;
2079 case DRI:
2080 mjpeg_decode_dri(s);
2081 break;
2082 case SOF1:
2083 case SOF2:
2084 case SOF5:
2085 case SOF6:
2086 case SOF7:
2087 case SOF9:
2088 case SOF10:
2089 case SOF11:
2090 case SOF13:
2091 case SOF14:
2092 case SOF15:
2093 case JPG:
2094 av_log(s->avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
2095 break;
2096 // default:
2097 // printf("mjpeg: unsupported marker (%x)\n", start_code);
2098 // break;
2099 }
2100
2101 not_the_end:
2102 /* eof process start code */
2103 buf_ptr += (get_bits_count(&s->gb)+7)/8;
2104 dprintf("marker parser used %d bytes (%d bits)\n",
2105 (get_bits_count(&s->gb)+7)/8, get_bits_count(&s->gb));
2106 }
2107 }
2108 }
2109 the_end:
2110 dprintf("mjpeg decode frame unused %d bytes\n", buf_end - buf_ptr);
2111 // return buf_end - buf_ptr;
2112 return buf_ptr - buf;
2113 }
2114
2115 static int mjpegb_decode_frame(AVCodecContext *avctx,
2116 void *data, int *data_size,
2117 uint8_t *buf, int buf_size)
2118 {
2119 MJpegDecodeContext *s = avctx->priv_data;
2120 uint8_t *buf_end, *buf_ptr;
2121 AVFrame *picture = data;
2122 GetBitContext hgb; /* for the header */
2123 uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs;
2124 uint32_t field_size, sod_offs;
2125
2126 buf_ptr = buf;
2127 buf_end = buf + buf_size;
2128
2129 read_header:
2130 /* reset on every SOI */
2131 s->restart_interval = 0;
2132 s->restart_count = 0;
2133 s->mjpb_skiptosod = 0;
2134
2135 init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end - buf_ptr)*8);
2136
2137 skip_bits(&hgb, 32); /* reserved zeros */
2138
2139 if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg")))
2140 {
2141 dprintf("not mjpeg-b (bad fourcc)\n");
2142 return 0;
2143 }
2144
2145 field_size = get_bits_long(&hgb, 32); /* field size */
2146 dprintf("field size: 0x%x\n", field_size);
2147 skip_bits(&hgb, 32); /* padded field size */
2148 second_field_offs = get_bits_long(&hgb, 32);
2149 dprintf("second field offs: 0x%x\n", second_field_offs);
2150 if (second_field_offs)
2151 s->interlaced = 1;
2152
2153 dqt_offs = get_bits_long(&hgb, 32);
2154 dprintf("dqt offs: 0x%x\n", dqt_offs);
2155 if (dqt_offs)
2156 {
2157 init_get_bits(&s->gb, buf+dqt_offs, (buf_end - (buf+dqt_offs))*8);
2158 s->start_code = DQT;
2159 mjpeg_decode_dqt(s);
2160 }
2161
2162 dht_offs = get_bits_long(&hgb, 32);
2163 dprintf("dht offs: 0x%x\n", dht_offs);
2164 if (dht_offs)
2165 {
2166 init_get_bits(&s->gb, buf+dht_offs, (buf_end - (buf+dht_offs))*8);
2167 s->start_code = DHT;
2168 mjpeg_decode_dht(s);
2169 }
2170
2171 sof_offs = get_bits_long(&hgb, 32);
2172 dprintf("sof offs: 0x%x\n", sof_offs);
2173 if (sof_offs)
2174 {
2175 init_get_bits(&s->gb, buf+sof_offs, (buf_end - (buf+sof_offs))*8);
2176 s->start_code = SOF0;
2177 if (mjpeg_decode_sof(s) < 0)
2178 return -1;
2179 }
2180
2181 sos_offs = get_bits_long(&hgb, 32);
2182 dprintf("sos offs: 0x%x\n", sos_offs);
2183 sod_offs = get_bits_long(&hgb, 32);
2184 dprintf("sod offs: 0x%x\n", sod_offs);
2185 if (sos_offs)
2186 {
2187 // init_get_bits(&s->gb, buf+sos_offs, (buf_end - (buf+sos_offs))*8);
2188 init_get_bits(&s->gb, buf+sos_offs, field_size*8);
2189 s->mjpb_skiptosod = (sod_offs - sos_offs - show_bits(&s->gb, 16));
2190 s->start_code = SOS;
2191 mjpeg_decode_sos(s);
2192 }
2193
2194 if (s->interlaced) {
2195 s->bottom_field ^= 1;
2196 /* if not bottom field, do not output image yet */
2197 if (s->bottom_field && second_field_offs)
2198 {
2199 buf_ptr = buf + second_field_offs;
2200 second_field_offs = 0;
2201 goto read_header;
2202 }
2203 }
2204
2205 //XXX FIXME factorize, this looks very similar to the EOI code
2206
2207 *picture= s->picture;
2208 *data_size = sizeof(AVFrame);
2209
2210 if(!s->lossless){
2211 picture->quality= FFMAX(FFMAX(s->qscale[0], s->qscale[1]), s->qscale[2]);
2212 picture->qstride= 0;
2213 picture->qscale_table= s->qscale_table;
2214 memset(picture->qscale_table, picture->quality, (s->width+15)/16);
2215 if(avctx->debug & FF_DEBUG_QP)
2216 av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
2217 picture->quality*= FF_QP2LAMBDA;
2218 }
2219
2220 return buf_ptr - buf;
2221 }
2222
2223 #include "sp5x.h"
2224
2225 static int sp5x_decode_frame(AVCodecContext *avctx,
2226 void *data, int *data_size,
2227 uint8_t *buf, int buf_size)
2228 {
2229 #if 0
2230 MJpegDecodeContext *s = avctx->priv_data;
2231 #endif
2232 const int qscale = 5;
2233 uint8_t *buf_ptr, *buf_end, *recoded;
2234 int i = 0, j = 0;
2235
2236 if (!avctx->width || !avctx->height)
2237 return -1;
2238
2239 buf_ptr = buf;
2240 buf_end = buf + buf_size;
2241
2242 #if 1
2243 recoded = av_mallocz(buf_size + 1024);
2244 if (!recoded)
2245 return -1;
2246
2247 /* SOI */
2248 recoded[j++] = 0xFF;
2249 recoded[j++] = 0xD8;
2250
2251 memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt));
2252 memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64);
2253 memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64);
2254 j += sizeof(sp5x_data_dqt);
2255
2256 memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht));
2257 j += sizeof(sp5x_data_dht);
2258
2259 memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof));
2260 recoded[j+5] = (avctx->coded_height >> 8) & 0xFF;
2261 recoded[j+6] = avctx->coded_height & 0xFF;
2262 recoded[j+7] = (avctx->coded_width >> 8) & 0xFF;
2263 recoded[j+8] = avctx->coded_width & 0xFF;
2264 j += sizeof(sp5x_data_sof);
2265
2266 memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos));
2267 j += sizeof(sp5x_data_sos);
2268
2269 for (i = 14; i < buf_size && j < buf_size+1024-2; i++)
2270 {
2271 recoded[j++] = buf[i];
2272 if (buf[i] == 0xff)
2273 recoded[j++] = 0;
2274 }
2275
2276 /* EOI */
2277 recoded[j++] = 0xFF;
2278 recoded[j++] = 0xD9;
2279
2280 i = mjpeg_decode_frame(avctx, data, data_size, recoded, j);
2281
2282 av_free(recoded);
2283
2284 #else
2285 /* SOF */
2286 s->bits = 8;
2287 s->width = avctx->coded_width;
2288 s->height = avctx->coded_height;
2289 s->nb_components = 3;
2290 s->component_id[0] = 0;
2291 s->h_count[0] = 2;
2292 s->v_count[0] = 2;
2293 s->quant_index[0] = 0;
2294 s->component_id[1] = 1;
2295 s->h_count[1] = 1;
2296 s->v_count[1] = 1;
2297 s->quant_index[1] = 1;
2298 s->component_id[2] = 2;
2299 s->h_count[2] = 1;
2300 s->v_count[2] = 1;
2301 s->quant_index[2] = 1;
2302 s->h_max = 2;
2303 s->v_max = 2;
2304
2305 s->qscale_table = av_mallocz((s->width+15)/16);
2306 avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420;
2307 s->interlaced = 0;
2308
2309 s->picture.reference = 0;
2310 if (avctx->get_buffer(avctx, &s->picture) < 0)
2311 {
2312 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2313 return -1;
2314 }
2315
2316 s->picture.pict_type = I_TYPE;
2317 s->picture.key_frame = 1;
2318
2319 for (i = 0; i < 3; i++)
2320 s->linesize[i] = s->picture.linesize[i] << s->interlaced;
2321
2322 /* DQT */
2323 for (i = 0; i < 64; i++)
2324 {
2325 j = s->scantable.permutated[i];
2326 s->quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i];
2327 }
2328 s->qscale[0] = FFMAX(
2329 s->quant_matrixes[0][s->scantable.permutated[1]],
2330 s->quant_matrixes[0][s->scantable.permutated[8]]) >> 1;
2331
2332 for (i = 0; i < 64; i++)
2333 {
2334 j = s->scantable.permutated[i];
2335 s->quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i];
2336 }
2337 s->qscale[1] = FFMAX(
2338 s->quant_matrixes[1][s->scantable.permutated[1]],
2339 s->quant_matrixes[1][s->scantable.permutated[8]]) >> 1;
2340
2341 /* DHT */
2342
2343 /* SOS */
2344 s->comp_index[0] = 0;
2345 s->nb_blocks[0] = s->h_count[0] * s->v_count[0];
2346 s->h_scount[0] = s->h_count[0];
2347 s->v_scount[0] = s->v_count[0];
2348 s->dc_index[0] = 0;
2349 s->ac_index[0] = 0;
2350
2351 s->comp_index[1] = 1;
2352 s->nb_blocks[1] = s->h_count[1] * s->v_count[1];
2353 s->h_scount[1] = s->h_count[1];
2354 s->v_scount[1] = s->v_count[1];
2355 s->dc_index[1] = 1;
2356 s->ac_index[1] = 1;
2357
2358 s->comp_index[2] = 2;
2359 s->nb_blocks[2] = s->h_count[2] * s->v_count[2];
2360 s->h_scount[2] = s->h_count[2];
2361 s->v_scount[2] = s->v_count[2];
2362 s->dc_index[2] = 1;
2363 s->ac_index[2] = 1;
2364
2365 for (i = 0; i < 3; i++)
2366 s->last_dc[i] = 1024;
2367
2368 s->mb_width = (s->width * s->h_max * 8 -1) / (s->h_max * 8);
2369 s->mb_height = (s->height * s->v_max * 8 -1) / (s->v_max * 8);
2370
2371 init_get_bits(&s->gb, buf+14, (buf_size-14)*8);
2372
2373 return mjpeg_decode_scan(s);
2374 #endif
2375
2376 return i;
2377 }
2378
2379 static int mjpeg_decode_end(AVCodecContext *avctx)
2380 {
2381 MJpegDecodeContext *s = avctx->priv_data;
2382 int i, j;
2383
2384 av_free(s->buffer);
2385 av_free(s->qscale_table);
2386
2387 for(i=0;i<2;i++) {
2388 for(j=0;j<4;j++)
2389 free_vlc(&s->vlcs[i][j]);
2390 }
2391 return 0;
2392 }
2393
2394 AVCodec mjpeg_decoder = {
2395 "mjpeg",
2396 CODEC_TYPE_VIDEO,
2397 CODEC_ID_MJPEG,
2398 sizeof(MJpegDecodeContext),
2399 mjpeg_decode_init,
2400 NULL,
2401 mjpeg_decode_end,
2402 mjpeg_decode_frame,
2403 CODEC_CAP_DR1,
2404 NULL
2405 };
2406
2407 AVCodec mjpegb_decoder = {
2408 "mjpegb",
2409 CODEC_TYPE_VIDEO,
2410 CODEC_ID_MJPEGB,
2411 sizeof(MJpegDecodeContext),
2412 mjpeg_decode_init,
2413 NULL,
2414 mjpeg_decode_end,
2415 mjpegb_decode_frame,
2416 CODEC_CAP_DR1,
2417 NULL
2418 };
2419
2420 AVCodec sp5x_decoder = {
2421 "sp5x",
2422 CODEC_TYPE_VIDEO,
2423 CODEC_ID_SP5X,
2424 sizeof(MJpegDecodeContext),
2425 mjpeg_decode_init,
2426 NULL,
2427 mjpeg_decode_end,
2428 sp5x_decode_frame,
2429 CODEC_CAP_DR1,
2430 NULL
2431 };
2432
2433 #ifdef CONFIG_ENCODERS
2434 AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them
2435 "ljpeg",
2436 CODEC_TYPE_VIDEO,
2437 CODEC_ID_LJPEG,
2438 sizeof(MpegEncContext),
2439 MPV_encode_init,
2440 encode_picture_lossless,
2441 MPV_encode_end,
2442 };
2443 #endif
2444
2445 AVCodecParser mjpeg_parser = {
2446 { CODEC_ID_MJPEG },
2447 sizeof(ParseContext),
2448 NULL,
2449 jpeg_parse,
2450 ff_parse_close,
2451 };
2452