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