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