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