ffmpeg / libavcodec / mjpeg.c @ 5509bffa
History  View  Annotate  Download (72.9 KB)
1 
/*


2 
* MJPEG encoder and decoder

3 
* Copyright (c) 2000, 2001 Fabrice Bellard.

4 
* Copyright (c) 2003 Alex Beregszaszi

5 
* Copyright (c) 20032004 Michael Niedermayer

6 
*

7 
* This library is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2 of the License, or (at your option) any later version.

11 
*

12 
* This library is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with this library; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*

21 
* Support for external huffman table, various fixes (AVID workaround),

22 
* aspecting, new decode_frame mechanism and apple mjpegb support

23 
* by Alex Beregszaszi <alex@naxine.org>

24 
*/

25  
26 
/**

27 
* @file mjpeg.c

28 
* MJPEG encoder and decoder.

29 
*/

30  
31 
//#define DEBUG

32 
#include <assert.h> 
33  
34 
#include "avcodec.h" 
35 
#include "dsputil.h" 
36 
#include "mpegvideo.h" 
37  
38 
/* use two quantizer tables (one for luminance and one for chrominance) */

39 
/* not yet working */

40 
#undef TWOMATRIXES

41  
42 
typedef struct MJpegContext { 
43 
uint8_t huff_size_dc_luminance[12]; //FIXME use array [3] instead of lumi / chrom, for easier addressing 
44 
uint16_t huff_code_dc_luminance[12];

45 
uint8_t huff_size_dc_chrominance[12];

46 
uint16_t huff_code_dc_chrominance[12];

47  
48 
uint8_t huff_size_ac_luminance[256];

49 
uint16_t huff_code_ac_luminance[256];

50 
uint8_t huff_size_ac_chrominance[256];

51 
uint16_t huff_code_ac_chrominance[256];

52 
} MJpegContext; 
53  
54 
/* JPEG marker codes */

55 
typedef enum { 
56 
/* start of frame */

57 
SOF0 = 0xc0, /* baseline */ 
58 
SOF1 = 0xc1, /* extended sequential, huffman */ 
59 
SOF2 = 0xc2, /* progressive, huffman */ 
60 
SOF3 = 0xc3, /* lossless, huffman */ 
61  
62 
SOF5 = 0xc5, /* differential sequential, huffman */ 
63 
SOF6 = 0xc6, /* differential progressive, huffman */ 
64 
SOF7 = 0xc7, /* differential lossless, huffman */ 
65 
JPG = 0xc8, /* reserved for JPEG extension */ 
66 
SOF9 = 0xc9, /* extended sequential, arithmetic */ 
67 
SOF10 = 0xca, /* progressive, arithmetic */ 
68 
SOF11 = 0xcb, /* lossless, arithmetic */ 
69  
70 
SOF13 = 0xcd, /* differential sequential, arithmetic */ 
71 
SOF14 = 0xce, /* differential progressive, arithmetic */ 
72 
SOF15 = 0xcf, /* differential lossless, arithmetic */ 
73  
74 
DHT = 0xc4, /* define huffman tables */ 
75  
76 
DAC = 0xcc, /* define arithmeticcoding conditioning */ 
77  
78 
/* restart with modulo 8 count "m" */

79 
RST0 = 0xd0,

80 
RST1 = 0xd1,

81 
RST2 = 0xd2,

82 
RST3 = 0xd3,

83 
RST4 = 0xd4,

84 
RST5 = 0xd5,

85 
RST6 = 0xd6,

86 
RST7 = 0xd7,

87  
88 
SOI = 0xd8, /* start of image */ 
89 
EOI = 0xd9, /* end of image */ 
90 
SOS = 0xda, /* start of scan */ 
91 
DQT = 0xdb, /* define quantization tables */ 
92 
DNL = 0xdc, /* define number of lines */ 
93 
DRI = 0xdd, /* define restart interval */ 
94 
DHP = 0xde, /* define hierarchical progression */ 
95 
EXP = 0xdf, /* expand reference components */ 
96  
97 
APP0 = 0xe0,

98 
APP1 = 0xe1,

99 
APP2 = 0xe2,

100 
APP3 = 0xe3,

101 
APP4 = 0xe4,

102 
APP5 = 0xe5,

103 
APP6 = 0xe6,

104 
APP7 = 0xe7,

105 
APP8 = 0xe8,

106 
APP9 = 0xe9,

107 
APP10 = 0xea,

108 
APP11 = 0xeb,

109 
APP12 = 0xec,

110 
APP13 = 0xed,

111 
APP14 = 0xee,

112 
APP15 = 0xef,

113  
114 
JPG0 = 0xf0,

115 
JPG1 = 0xf1,

116 
JPG2 = 0xf2,

117 
JPG3 = 0xf3,

118 
JPG4 = 0xf4,

119 
JPG5 = 0xf5,

120 
JPG6 = 0xf6,

121 
SOF48 = 0xf7, ///< JPEGLS 
122 
LSE = 0xf8, ///< JPEGLS extension parameters 
123 
JPG9 = 0xf9,

124 
JPG10 = 0xfa,

125 
JPG11 = 0xfb,

126 
JPG12 = 0xfc,

127 
JPG13 = 0xfd,

128  
129 
COM = 0xfe, /* comment */ 
130  
131 
TEM = 0x01, /* temporary private use for arithmetic coding */ 
132  
133 
/* 0x02 > 0xbf reserved */

134 
} JPEG_MARKER; 
135  
136 
#if 0

137 
/* These are the sample quantization tables given in JPEG spec section K.1.

138 
* The spec says that the values given produce "good" quality, and

139 
* when divided by 2, "very good" quality.

140 
*/

141 
static const unsigned char std_luminance_quant_tbl[64] = {

142 
16, 11, 10, 16, 24, 40, 51, 61,

143 
12, 12, 14, 19, 26, 58, 60, 55,

144 
14, 13, 16, 24, 40, 57, 69, 56,

145 
14, 17, 22, 29, 51, 87, 80, 62,

146 
18, 22, 37, 56, 68, 109, 103, 77,

147 
24, 35, 55, 64, 81, 104, 113, 92,

148 
49, 64, 78, 87, 103, 121, 120, 101,

149 
72, 92, 95, 98, 112, 100, 103, 99

150 
};

151 
static const unsigned char std_chrominance_quant_tbl[64] = {

152 
17, 18, 24, 47, 99, 99, 99, 99,

153 
18, 21, 26, 66, 99, 99, 99, 99,

154 
24, 26, 56, 99, 99, 99, 99, 99,

155 
47, 66, 99, 99, 99, 99, 99, 99,

156 
99, 99, 99, 99, 99, 99, 99, 99,

157 
99, 99, 99, 99, 99, 99, 99, 99,

158 
99, 99, 99, 99, 99, 99, 99, 99,

159 
99, 99, 99, 99, 99, 99, 99, 99

160 
};

161 
#endif

162  
163 
/* Set up the standard Huffman tables (cf. JPEG standard section K.3) */

164 
/* IMPORTANT: these are only valid for 8bit data precision! */

165 
static const uint8_t bits_dc_luminance[17] = 
166 
{ /* 0base */ 0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0 }; 
167 
static const uint8_t val_dc_luminance[] = 
168 
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; 
169  
170 
static const uint8_t bits_dc_chrominance[17] = 
171 
{ /* 0base */ 0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }; 
172 
static const uint8_t val_dc_chrominance[] = 
173 
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; 
174  
175 
static const uint8_t bits_ac_luminance[17] = 
176 
{ /* 0base */ 0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d }; 
177 
static const uint8_t val_ac_luminance[] = 
178 
{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 
179 
0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07, 
180 
0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08, 
181 
0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 
182 
0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16, 
183 
0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28, 
184 
0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 
185 
0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 
186 
0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 
187 
0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 
188 
0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 
189 
0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 
190 
0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 
191 
0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 
192 
0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 
193 
0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 
194 
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 
195 
0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2, 
196 
0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 
197 
0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 
198 
0xf9, 0xfa 
199 
}; 
200  
201 
static const uint8_t bits_ac_chrominance[17] = 
202 
{ /* 0base */ 0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77 }; 
203  
204 
static const uint8_t val_ac_chrominance[] = 
205 
{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 
206 
0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 
207 
0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 
208 
0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 
209 
0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34, 
210 
0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26, 
211 
0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 
212 
0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 
213 
0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 
214 
0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 
215 
0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 
216 
0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 
217 
0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 
218 
0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 
219 
0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 
220 
0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 
221 
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 
222 
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 
223 
0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 
224 
0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 
225 
0xf9, 0xfa 
226 
}; 
227  
228 
/* isn't this function nicer than the one in the libjpeg ? */

229 
static void build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, 
230 
const uint8_t *bits_table, const uint8_t *val_table) 
231 
{ 
232 
int i, j, k,nb, code, sym;

233  
234 
code = 0;

235 
k = 0;

236 
for(i=1;i<=16;i++) { 
237 
nb = bits_table[i]; 
238 
for(j=0;j<nb;j++) { 
239 
sym = val_table[k++]; 
240 
huff_size[sym] = i; 
241 
huff_code[sym] = code; 
242 
code++; 
243 
} 
244 
code <<= 1;

245 
} 
246 
} 
247  
248 
#ifdef CONFIG_ENCODERS

249 
int mjpeg_init(MpegEncContext *s)

250 
{ 
251 
MJpegContext *m; 
252  
253 
m = av_malloc(sizeof(MJpegContext));

254 
if (!m)

255 
return 1; 
256  
257 
s>min_qcoeff=1023;

258 
s>max_qcoeff= 1023;

259  
260 
/* build all the huffman tables */

261 
build_huffman_codes(m>huff_size_dc_luminance, 
262 
m>huff_code_dc_luminance, 
263 
bits_dc_luminance, 
264 
val_dc_luminance); 
265 
build_huffman_codes(m>huff_size_dc_chrominance, 
266 
m>huff_code_dc_chrominance, 
267 
bits_dc_chrominance, 
268 
val_dc_chrominance); 
269 
build_huffman_codes(m>huff_size_ac_luminance, 
270 
m>huff_code_ac_luminance, 
271 
bits_ac_luminance, 
272 
val_ac_luminance); 
273 
build_huffman_codes(m>huff_size_ac_chrominance, 
274 
m>huff_code_ac_chrominance, 
275 
bits_ac_chrominance, 
276 
val_ac_chrominance); 
277  
278 
s>mjpeg_ctx = m; 
279 
return 0; 
280 
} 
281  
282 
void mjpeg_close(MpegEncContext *s)

283 
{ 
284 
av_free(s>mjpeg_ctx); 
285 
} 
286 
#endif //CONFIG_ENCODERS 
287  
288 
#define PREDICT(ret, topleft, top, left, predictor)\

289 
switch(predictor){\

290 
case 1: ret= left; break;\ 
291 
case 2: ret= top; break;\ 
292 
case 3: ret= topleft; break;\ 
293 
case 4: ret= left + top  topleft; break;\ 
294 
case 5: ret= left + ((top  topleft)>>1); break;\ 
295 
case 6: ret= top + ((left  topleft)>>1); break;\ 
296 
default:\

297 
case 7: ret= (left + top)>>1; break;\ 
298 
} 
299  
300 
#ifdef CONFIG_ENCODERS

301 
static inline void put_marker(PutBitContext *p, int code) 
302 
{ 
303 
put_bits(p, 8, 0xff); 
304 
put_bits(p, 8, code);

305 
} 
306  
307 
/* table_class: 0 = DC coef, 1 = AC coefs */

308 
static int put_huffman_table(MpegEncContext *s, int table_class, int table_id, 
309 
const uint8_t *bits_table, const uint8_t *value_table) 
310 
{ 
311 
PutBitContext *p = &s>pb; 
312 
int n, i;

313  
314 
put_bits(p, 4, table_class);

315 
put_bits(p, 4, table_id);

316  
317 
n = 0;

318 
for(i=1;i<=16;i++) { 
319 
n += bits_table[i]; 
320 
put_bits(p, 8, bits_table[i]);

321 
} 
322  
323 
for(i=0;i<n;i++) 
324 
put_bits(p, 8, value_table[i]);

325  
326 
return n + 17; 
327 
} 
328  
329 
static void jpeg_table_header(MpegEncContext *s) 
330 
{ 
331 
PutBitContext *p = &s>pb; 
332 
int i, j, size;

333 
uint8_t *ptr; 
334  
335 
/* quant matrixes */

336 
put_marker(p, DQT); 
337 
#ifdef TWOMATRIXES

338 
put_bits(p, 16, 2 + 2 * (1 + 64)); 
339 
#else

340 
put_bits(p, 16, 2 + 1 * (1 + 64)); 
341 
#endif

342 
put_bits(p, 4, 0); /* 8 bit precision */ 
343 
put_bits(p, 4, 0); /* table 0 */ 
344 
for(i=0;i<64;i++) { 
345 
j = s>intra_scantable.permutated[i]; 
346 
put_bits(p, 8, s>intra_matrix[j]);

347 
} 
348 
#ifdef TWOMATRIXES

349 
put_bits(p, 4, 0); /* 8 bit precision */ 
350 
put_bits(p, 4, 1); /* table 1 */ 
351 
for(i=0;i<64;i++) { 
352 
j = s>intra_scantable.permutated[i]; 
353 
put_bits(p, 8, s>chroma_intra_matrix[j]);

354 
} 
355 
#endif

356  
357 
/* huffman table */

358 
put_marker(p, DHT); 
359 
flush_put_bits(p); 
360 
ptr = pbBufPtr(p); 
361 
put_bits(p, 16, 0); /* patched later */ 
362 
size = 2;

363 
size += put_huffman_table(s, 0, 0, bits_dc_luminance, val_dc_luminance); 
364 
size += put_huffman_table(s, 0, 1, bits_dc_chrominance, val_dc_chrominance); 
365  
366 
size += put_huffman_table(s, 1, 0, bits_ac_luminance, val_ac_luminance); 
367 
size += put_huffman_table(s, 1, 1, bits_ac_chrominance, val_ac_chrominance); 
368 
ptr[0] = size >> 8; 
369 
ptr[1] = size;

370 
} 
371  
372 
static void jpeg_put_comments(MpegEncContext *s) 
373 
{ 
374 
PutBitContext *p = &s>pb; 
375 
int size;

376 
uint8_t *ptr; 
377  
378 
if (s>aspect_ratio_info /* && !lossless */) 
379 
{ 
380 
/* JFIF header */

381 
put_marker(p, APP0); 
382 
put_bits(p, 16, 16); 
383 
ff_put_string(p, "JFIF", 1); /* this puts the trailing zerobyte too */ 
384 
put_bits(p, 16, 0x0201); /* v 1.02 */ 
385 
put_bits(p, 8, 0); /* units type: 0  aspect ratio */ 
386 
put_bits(p, 16, s>avctx>sample_aspect_ratio.num);

387 
put_bits(p, 16, s>avctx>sample_aspect_ratio.den);

388 
put_bits(p, 8, 0); /* thumbnail width */ 
389 
put_bits(p, 8, 0); /* thumbnail height */ 
390 
} 
391  
392 
/* comment */

393 
if(!(s>flags & CODEC_FLAG_BITEXACT)){

394 
put_marker(p, COM); 
395 
flush_put_bits(p); 
396 
ptr = pbBufPtr(p); 
397 
put_bits(p, 16, 0); /* patched later */ 
398 
ff_put_string(p, LIBAVCODEC_IDENT, 1);

399 
size = strlen(LIBAVCODEC_IDENT)+3;

400 
ptr[0] = size >> 8; 
401 
ptr[1] = size;

402 
} 
403  
404 
if( s>avctx>pix_fmt == PIX_FMT_YUV420P

405 
s>avctx>pix_fmt == PIX_FMT_YUV422P 
406 
s>avctx>pix_fmt == PIX_FMT_YUV444P){ 
407 
put_marker(p, COM); 
408 
flush_put_bits(p); 
409 
ptr = pbBufPtr(p); 
410 
put_bits(p, 16, 0); /* patched later */ 
411 
ff_put_string(p, "CS=ITU601", 1); 
412 
size = strlen("CS=ITU601")+3; 
413 
ptr[0] = size >> 8; 
414 
ptr[1] = size;

415 
} 
416 
} 
417  
418 
void mjpeg_picture_header(MpegEncContext *s)

419 
{ 
420 
const int lossless= s>avctx>codec_id != CODEC_ID_MJPEG; 
421 
const int ls = s>avctx>codec_id == CODEC_ID_JPEGLS; 
422  
423 
assert(!(ls && s>mjpeg_write_tables)); 
424  
425 
put_marker(&s>pb, SOI); 
426  
427 
if (!s>mjpeg_data_only_frames)

428 
{ 
429 
jpeg_put_comments(s); 
430  
431 
if (s>mjpeg_write_tables) jpeg_table_header(s);

432  
433 
switch(s>avctx>codec_id){

434 
case CODEC_ID_MJPEG: put_marker(&s>pb, SOF0 ); break; 
435 
case CODEC_ID_LJPEG: put_marker(&s>pb, SOF3 ); break; 
436 
case CODEC_ID_JPEGLS: put_marker(&s>pb, SOF48); break; 
437 
default: assert(0); 
438 
} 
439  
440 
put_bits(&s>pb, 16, 17); 
441 
if(lossless && s>avctx>pix_fmt == PIX_FMT_RGBA32)

442 
put_bits(&s>pb, 8, 9); /* 9 bits/component RCT */ 
443 
else

444 
put_bits(&s>pb, 8, 8); /* 8 bits/component */ 
445 
put_bits(&s>pb, 16, s>height);

446 
put_bits(&s>pb, 16, s>width);

447 
put_bits(&s>pb, 8, 3); /* 3 components */ 
448  
449 
/* Y component */

450 
put_bits(&s>pb, 8, 1); /* component number */ 
451 
put_bits(&s>pb, 4, s>mjpeg_hsample[0]); /* H factor */ 
452 
put_bits(&s>pb, 4, s>mjpeg_vsample[0]); /* V factor */ 
453 
put_bits(&s>pb, 8, 0); /* select matrix */ 
454  
455 
/* Cb component */

456 
put_bits(&s>pb, 8, 2); /* component number */ 
457 
put_bits(&s>pb, 4, s>mjpeg_hsample[1]); /* H factor */ 
458 
put_bits(&s>pb, 4, s>mjpeg_vsample[1]); /* V factor */ 
459 
#ifdef TWOMATRIXES

460 
put_bits(&s>pb, 8, lossless ? 0 : 1); /* select matrix */ 
461 
#else

462 
put_bits(&s>pb, 8, 0); /* select matrix */ 
463 
#endif

464  
465 
/* Cr component */

466 
put_bits(&s>pb, 8, 3); /* component number */ 
467 
put_bits(&s>pb, 4, s>mjpeg_hsample[2]); /* H factor */ 
468 
put_bits(&s>pb, 4, s>mjpeg_vsample[2]); /* V factor */ 
469 
#ifdef TWOMATRIXES

470 
put_bits(&s>pb, 8, lossless ? 0 : 1); /* select matrix */ 
471 
#else

472 
put_bits(&s>pb, 8, 0); /* select matrix */ 
473 
#endif

474 
} 
475  
476 
/* scan header */

477 
put_marker(&s>pb, SOS); 
478 
put_bits(&s>pb, 16, 12); /* length */ 
479 
put_bits(&s>pb, 8, 3); /* 3 components */ 
480  
481 
/* Y component */

482 
put_bits(&s>pb, 8, 1); /* index */ 
483 
put_bits(&s>pb, 4, 0); /* DC huffman table index */ 
484 
put_bits(&s>pb, 4, 0); /* AC huffman table index */ 
485  
486 
/* Cb component */

487 
put_bits(&s>pb, 8, 2); /* index */ 
488 
put_bits(&s>pb, 4, 1); /* DC huffman table index */ 
489 
put_bits(&s>pb, 4, lossless ? 0 : 1); /* AC huffman table index */ 
490  
491 
/* Cr component */

492 
put_bits(&s>pb, 8, 3); /* index */ 
493 
put_bits(&s>pb, 4, 1); /* DC huffman table index */ 
494 
put_bits(&s>pb, 4, lossless ? 0 : 1); /* AC huffman table index */ 
495  
496 
put_bits(&s>pb, 8, (lossless && !ls) ? s>avctx>prediction_method+1 : 0); /* Ss (not used) */ 
497  
498 
switch(s>avctx>codec_id){

499 
case CODEC_ID_MJPEG: put_bits(&s>pb, 8, 63); break; /* Se (not used) */ 
500 
case CODEC_ID_LJPEG: put_bits(&s>pb, 8, 0); break; /* not used */ 
501 
case CODEC_ID_JPEGLS: put_bits(&s>pb, 8, 1); break; /* ILV = line interleaved */ 
502 
default: assert(0); 
503 
} 
504  
505 
put_bits(&s>pb, 8, 0); /* Ah/Al (not used) */ 
506  
507 
//FIXME DC/AC entropy table selectors stuff in jpegls

508 
} 
509  
510 
static void escape_FF(MpegEncContext *s, int start) 
511 
{ 
512 
int size= put_bits_count(&s>pb)  start*8; 
513 
int i, ff_count;

514 
uint8_t *buf= s>pb.buf + start; 
515 
int align= ((size_t)(buf))&3; 
516  
517 
assert((size&7) == 0); 
518 
size >>= 3;

519  
520 
ff_count=0;

521 
for(i=0; i<size && i<align; i++){ 
522 
if(buf[i]==0xFF) ff_count++; 
523 
} 
524 
for(; i<size15; i+=16){ 
525 
int acc, v;

526  
527 
v= *(uint32_t*)(&buf[i]); 
528 
acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; 
529 
v= *(uint32_t*)(&buf[i+4]);

530 
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; 
531 
v= *(uint32_t*)(&buf[i+8]);

532 
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; 
533 
v= *(uint32_t*)(&buf[i+12]);

534 
acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010; 
535  
536 
acc>>=4;

537 
acc+= (acc>>16);

538 
acc+= (acc>>8);

539 
ff_count+= acc&0xFF;

540 
} 
541 
for(; i<size; i++){

542 
if(buf[i]==0xFF) ff_count++; 
543 
} 
544  
545 
if(ff_count==0) return; 
546  
547 
/* skip put bits */

548 
for(i=0; i<ff_count3; i+=4) 
549 
put_bits(&s>pb, 32, 0); 
550 
put_bits(&s>pb, (ff_counti)*8, 0); 
551 
flush_put_bits(&s>pb); 
552  
553 
for(i=size1; ff_count; i){ 
554 
int v= buf[i];

555  
556 
if(v==0xFF){ 
557 
//printf("%d %d\n", i, ff_count);

558 
buf[i+ff_count]= 0;

559 
ff_count; 
560 
} 
561  
562 
buf[i+ff_count]= v; 
563 
} 
564 
} 
565  
566 
void ff_mjpeg_stuffing(PutBitContext * pbc)

567 
{ 
568 
int length;

569 
length= (put_bits_count(pbc))&7;

570 
if(length) put_bits(pbc, length, (1<<length)1); 
571 
} 
572  
573 
void mjpeg_picture_trailer(MpegEncContext *s)

574 
{ 
575 
ff_mjpeg_stuffing(&s>pb); 
576 
flush_put_bits(&s>pb); 
577  
578 
assert((s>header_bits&7)==0); 
579  
580 
escape_FF(s, s>header_bits>>3);

581  
582 
put_marker(&s>pb, EOI); 
583 
} 
584  
585 
static inline void mjpeg_encode_dc(MpegEncContext *s, int val, 
586 
uint8_t *huff_size, uint16_t *huff_code) 
587 
{ 
588 
int mant, nbits;

589  
590 
if (val == 0) { 
591 
put_bits(&s>pb, huff_size[0], huff_code[0]); 
592 
} else {

593 
mant = val; 
594 
if (val < 0) { 
595 
val = val; 
596 
mant; 
597 
} 
598  
599 
nbits= av_log2_16bit(val) + 1;

600  
601 
put_bits(&s>pb, huff_size[nbits], huff_code[nbits]); 
602  
603 
put_bits(&s>pb, nbits, mant & ((1 << nbits)  1)); 
604 
} 
605 
} 
606  
607 
static void encode_block(MpegEncContext *s, DCTELEM *block, int n) 
608 
{ 
609 
int mant, nbits, code, i, j;

610 
int component, dc, run, last_index, val;

611 
MJpegContext *m = s>mjpeg_ctx; 
612 
uint8_t *huff_size_ac; 
613 
uint16_t *huff_code_ac; 
614  
615 
/* DC coef */

616 
component = (n <= 3 ? 0 : n  4 + 1); 
617 
dc = block[0]; /* overflow is impossible */ 
618 
val = dc  s>last_dc[component]; 
619 
if (n < 4) { 
620 
mjpeg_encode_dc(s, val, m>huff_size_dc_luminance, m>huff_code_dc_luminance); 
621 
huff_size_ac = m>huff_size_ac_luminance; 
622 
huff_code_ac = m>huff_code_ac_luminance; 
623 
} else {

624 
mjpeg_encode_dc(s, val, m>huff_size_dc_chrominance, m>huff_code_dc_chrominance); 
625 
huff_size_ac = m>huff_size_ac_chrominance; 
626 
huff_code_ac = m>huff_code_ac_chrominance; 
627 
} 
628 
s>last_dc[component] = dc; 
629  
630 
/* AC coefs */

631  
632 
run = 0;

633 
last_index = s>block_last_index[n]; 
634 
for(i=1;i<=last_index;i++) { 
635 
j = s>intra_scantable.permutated[i]; 
636 
val = block[j]; 
637 
if (val == 0) { 
638 
run++; 
639 
} else {

640 
while (run >= 16) { 
641 
put_bits(&s>pb, huff_size_ac[0xf0], huff_code_ac[0xf0]); 
642 
run = 16;

643 
} 
644 
mant = val; 
645 
if (val < 0) { 
646 
val = val; 
647 
mant; 
648 
} 
649  
650 
nbits= av_log2(val) + 1;

651 
code = (run << 4)  nbits;

652  
653 
put_bits(&s>pb, huff_size_ac[code], huff_code_ac[code]); 
654  
655 
put_bits(&s>pb, nbits, mant & ((1 << nbits)  1)); 
656 
run = 0;

657 
} 
658 
} 
659  
660 
/* output EOB only if not already 64 values */

661 
if (last_index < 63  run != 0) 
662 
put_bits(&s>pb, huff_size_ac[0], huff_code_ac[0]); 
663 
} 
664  
665 
void mjpeg_encode_mb(MpegEncContext *s,

666 
DCTELEM block[6][64]) 
667 
{ 
668 
int i;

669 
for(i=0;i<6;i++) { 
670 
encode_block(s, block[i], i); 
671 
} 
672 
} 
673  
674 
static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ 
675 
MpegEncContext * const s = avctx>priv_data;

676 
MJpegContext * const m = s>mjpeg_ctx;

677 
AVFrame *pict = data; 
678 
const int width= s>width; 
679 
const int height= s>height; 
680 
AVFrame * const p= (AVFrame*)&s>current_picture;

681 
const int predictor= avctx>prediction_method+1; 
682  
683 
init_put_bits(&s>pb, buf, buf_size); 
684  
685 
*p = *pict; 
686 
p>pict_type= FF_I_TYPE; 
687 
p>key_frame= 1;

688  
689 
mjpeg_picture_header(s); 
690  
691 
s>header_bits= put_bits_count(&s>pb); 
692  
693 
if(avctx>pix_fmt == PIX_FMT_RGBA32){

694 
int x, y, i;

695 
const int linesize= p>linesize[0]; 
696 
uint16_t (*buffer)[4]= (void *) s>rd_scratchpad; 
697 
int left[3], top[3], topleft[3]; 
698  
699 
for(i=0; i<3; i++){ 
700 
buffer[0][i]= 1 << (9  1); 
701 
} 
702  
703 
for(y = 0; y < height; y++) { 
704 
const int modified_predictor= y ? predictor : 1; 
705 
uint8_t *ptr = p>data[0] + (linesize * y);

706  
707 
if(s>pb.buf_end  s>pb.buf  (put_bits_count(&s>pb)>>3) < width*3*4){ 
708 
av_log(s>avctx, AV_LOG_ERROR, "encoded frame too large\n");

709 
return 1; 
710 
} 
711  
712 
for(i=0; i<3; i++){ 
713 
top[i]= left[i]= topleft[i]= buffer[0][i];

714 
} 
715 
for(x = 0; x < width; x++) { 
716 
buffer[x][1] = ptr[4*x+0]  ptr[4*x+1] + 0x100; 
717 
buffer[x][2] = ptr[4*x+2]  ptr[4*x+1] + 0x100; 
718 
buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2; 
719  
720 
for(i=0;i<3;i++) { 
721 
int pred, diff;

722  
723 
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); 
724  
725 
topleft[i]= top[i]; 
726 
top[i]= buffer[x+1][i];

727  
728 
left[i]= buffer[x][i]; 
729  
730 
diff= ((left[i]  pred + 0x100)&0x1FF)  0x100; 
731  
732 
if(i==0) 
733 
mjpeg_encode_dc(s, diff, m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

734 
else

735 
mjpeg_encode_dc(s, diff, m>huff_size_dc_chrominance, m>huff_code_dc_chrominance); 
736 
} 
737 
} 
738 
} 
739 
}else{

740 
int mb_x, mb_y, i;

741 
const int mb_width = (width + s>mjpeg_hsample[0]  1) / s>mjpeg_hsample[0]; 
742 
const int mb_height = (height + s>mjpeg_vsample[0]  1) / s>mjpeg_vsample[0]; 
743  
744 
for(mb_y = 0; mb_y < mb_height; mb_y++) { 
745 
if(s>pb.buf_end  s>pb.buf  (put_bits_count(&s>pb)>>3) < mb_width * 4 * 3 * s>mjpeg_hsample[0] * s>mjpeg_vsample[0]){ 
746 
av_log(s>avctx, AV_LOG_ERROR, "encoded frame too large\n");

747 
return 1; 
748 
} 
749 
for(mb_x = 0; mb_x < mb_width; mb_x++) { 
750 
if(mb_x==0  mb_y==0){ 
751 
for(i=0;i<3;i++) { 
752 
uint8_t *ptr; 
753 
int x, y, h, v, linesize;

754 
h = s>mjpeg_hsample[i]; 
755 
v = s>mjpeg_vsample[i]; 
756 
linesize= p>linesize[i]; 
757  
758 
for(y=0; y<v; y++){ 
759 
for(x=0; x<h; x++){ 
760 
int pred;

761  
762 
ptr = p>data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

763 
if(y==0 && mb_y==0){ 
764 
if(x==0 && mb_x==0){ 
765 
pred= 128;

766 
}else{

767 
pred= ptr[1];

768 
} 
769 
}else{

770 
if(x==0 && mb_x==0){ 
771 
pred= ptr[linesize]; 
772 
}else{

773 
PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor); 
774 
} 
775 
} 
776  
777 
if(i==0) 
778 
mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

779 
else

780 
mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_chrominance, m>huff_code_dc_chrominance); 
781 
} 
782 
} 
783 
} 
784 
}else{

785 
for(i=0;i<3;i++) { 
786 
uint8_t *ptr; 
787 
int x, y, h, v, linesize;

788 
h = s>mjpeg_hsample[i]; 
789 
v = s>mjpeg_vsample[i]; 
790 
linesize= p>linesize[i]; 
791  
792 
for(y=0; y<v; y++){ 
793 
for(x=0; x<h; x++){ 
794 
int pred;

795  
796 
ptr = p>data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

797 
//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr);

798 
PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor); 
799  
800 
if(i==0) 
801 
mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_luminance, m>huff_code_dc_luminance); //FIXME ugly

802 
else

803 
mjpeg_encode_dc(s, (int8_t)(*ptr  pred), m>huff_size_dc_chrominance, m>huff_code_dc_chrominance); 
804 
} 
805 
} 
806 
} 
807 
} 
808 
} 
809 
} 
810 
} 
811  
812 
emms_c(); 
813  
814 
mjpeg_picture_trailer(s); 
815 
s>picture_number++; 
816  
817 
flush_put_bits(&s>pb); 
818 
return pbBufPtr(&s>pb)  s>pb.buf;

819 
// return (put_bits_count(&f>pb)+7)/8;

820 
} 
821  
822 
#endif //CONFIG_ENCODERS 
823  
824 
/******************************************/

825 
/* decoding */

826  
827 
#define MAX_COMPONENTS 4 
828  
829 
typedef struct MJpegDecodeContext { 
830 
AVCodecContext *avctx; 
831 
GetBitContext gb; 
832 
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 
833  
834 
int start_code; /* current start code */ 
835 
int buffer_size;

836 
uint8_t *buffer; 
837  
838 
int16_t quant_matrixes[4][64]; 
839 
VLC vlcs[2][4]; 
840 
int qscale[4]; ///< quantizer scale calculated from quant_matrixes 
841  
842 
int org_height; /* size given at codec init */ 
843 
int first_picture; /* true if decoding first picture */ 
844 
int interlaced; /* true if interlaced */ 
845 
int bottom_field; /* true if bottom field */ 
846 
int lossless;

847 
int ls;

848 
int rgb;

849 
int rct; /* standard rct */ 
850 
int pegasus_rct; /* pegasus reversible colorspace transform */ 
851 
int bits; /* bits per component */ 
852  
853 
int maxval;

854 
int near; ///< near lossless bound (si 0 for lossless) 
855 
int t1,t2,t3;

856 
int reset; ///< context halfing intervall ?rename 
857  
858 
int width, height;

859 
int mb_width, mb_height;

860 
int nb_components;

861 
int component_id[MAX_COMPONENTS];

862 
int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */ 
863 
int v_count[MAX_COMPONENTS];

864 
int comp_index[MAX_COMPONENTS];

865 
int dc_index[MAX_COMPONENTS];

866 
int ac_index[MAX_COMPONENTS];

867 
int nb_blocks[MAX_COMPONENTS];

868 
int h_scount[MAX_COMPONENTS];

869 
int v_scount[MAX_COMPONENTS];

870 
int h_max, v_max; /* maximum h and v counts */ 
871 
int quant_index[4]; /* quant table index for each component */ 
872 
int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */ 
873 
AVFrame picture; /* picture structure */

874 
int linesize[MAX_COMPONENTS]; ///< linesize << interlaced 
875 
int8_t *qscale_table; 
876 
DCTELEM block[64] __align8;

877 
ScanTable scantable; 
878 
void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); 
879  
880 
int restart_interval;

881 
int restart_count;

882  
883 
int buggy_avid;

884 
int cs_itu601;

885 
int interlace_polarity;

886  
887 
int mjpb_skiptosod;

888 
} MJpegDecodeContext; 
889  
890 
#include "jpeg_ls.c" //FIXME make jpegls more independant 
891  
892 
static int mjpeg_decode_dht(MJpegDecodeContext *s); 
893  
894 
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table, 
895 
int nb_codes, int use_static) 
896 
{ 
897 
uint8_t huff_size[256];

898 
uint16_t huff_code[256];

899  
900 
memset(huff_size, 0, sizeof(huff_size)); 
901 
build_huffman_codes(huff_size, huff_code, bits_table, val_table); 
902  
903 
return init_vlc(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, use_static); 
904 
} 
905  
906 
static int mjpeg_decode_init(AVCodecContext *avctx) 
907 
{ 
908 
MJpegDecodeContext *s = avctx>priv_data; 
909 
MpegEncContext s2; 
910 
memset(s, 0, sizeof(MJpegDecodeContext)); 
911  
912 
s>avctx = avctx; 
913  
914 
/* ugly way to get the idct & scantable FIXME */

915 
memset(&s2, 0, sizeof(MpegEncContext)); 
916 
s2.avctx= avctx; 
917 
// s2>out_format = FMT_MJPEG;

918 
dsputil_init(&s2.dsp, avctx); 
919 
DCT_common_init(&s2); 
920  
921 
s>scantable= s2.intra_scantable; 
922 
s>idct_put= s2.dsp.idct_put; 
923  
924 
s>mpeg_enc_ctx_allocated = 0;

925 
s>buffer_size = 0;

926 
s>buffer = NULL;

927 
s>start_code = 1;

928 
s>first_picture = 1;

929 
s>org_height = avctx>coded_height; 
930  
931 
build_vlc(&s>vlcs[0][0], bits_dc_luminance, val_dc_luminance, 12, 0); 
932 
build_vlc(&s>vlcs[0][1], bits_dc_chrominance, val_dc_chrominance, 12, 0); 
933 
build_vlc(&s>vlcs[1][0], bits_ac_luminance, val_ac_luminance, 251, 0); 
934 
build_vlc(&s>vlcs[1][1], bits_ac_chrominance, val_ac_chrominance, 251, 0); 
935  
936 
if (avctx>flags & CODEC_FLAG_EXTERN_HUFF)

937 
{ 
938 
av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");

939 
init_get_bits(&s>gb, avctx>extradata, avctx>extradata_size*8);

940 
mjpeg_decode_dht(s); 
941 
/* should check for error  but dunno */

942 
} 
943  
944 
return 0; 
945 
} 
946  
947  
948 
/**

949 
* finds the end of the current frame in the bitstream.

950 
* @return the position of the first byte of the next frame, or 1

951 
*/

952 
static int find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size){ 
953 
int vop_found, i;

954 
uint16_t state; 
955  
956 
vop_found= pc>frame_start_found; 
957 
state= pc>state; 
958  
959 
i=0;

960 
if(!vop_found){

961 
for(i=0; i<buf_size; i++){ 
962 
state= (state<<8)  buf[i];

963 
if(state == 0xFFD8){ 
964 
i++; 
965 
vop_found=1;

966 
break;

967 
} 
968 
} 
969 
} 
970  
971 
if(vop_found){

972 
/* EOF considered as end of frame */

973 
if (buf_size == 0) 
974 
return 0; 
975 
for(; i<buf_size; i++){

976 
state= (state<<8)  buf[i];

977 
if(state == 0xFFD8){ 
978 
pc>frame_start_found=0;

979 
pc>state=0;

980 
return i1; 
981 
} 
982 
} 
983 
} 
984 
pc>frame_start_found= vop_found; 
985 
pc>state= state; 
986 
return END_NOT_FOUND;

987 
} 
988  
989 
static int jpeg_parse(AVCodecParserContext *s, 
990 
AVCodecContext *avctx, 
991 
uint8_t **poutbuf, int *poutbuf_size,

992 
const uint8_t *buf, int buf_size) 
993 
{ 
994 
ParseContext *pc = s>priv_data; 
995 
int next;

996  
997 
next= find_frame_end(pc, buf, buf_size); 
998  
999 
if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) { 
1000 
*poutbuf = NULL;

1001 
*poutbuf_size = 0;

1002 
return buf_size;

1003 
} 
1004  
1005 
*poutbuf = (uint8_t *)buf; 
1006 
*poutbuf_size = buf_size; 
1007 
return next;

1008 
} 
1009  
1010 
/* quantize tables */

1011 
static int mjpeg_decode_dqt(MJpegDecodeContext *s) 
1012 
{ 
1013 
int len, index, i, j;

1014  
1015 
len = get_bits(&s>gb, 16)  2; 
1016  
1017 
while (len >= 65) { 
1018 
/* only 8 bit precision handled */

1019 
if (get_bits(&s>gb, 4) != 0) 
1020 
{ 
1021 
dprintf("dqt: 16bit precision\n");

1022 
return 1; 
1023 
} 
1024 
index = get_bits(&s>gb, 4);

1025 
if (index >= 4) 
1026 
return 1; 
1027 
dprintf("index=%d\n", index);

1028 
/* read quant table */

1029 
for(i=0;i<64;i++) { 
1030 
j = s>scantable.permutated[i]; 
1031 
s>quant_matrixes[index][j] = get_bits(&s>gb, 8);

1032 
} 
1033  
1034 
//XXX FIXME finetune, and perhaps add dc too

1035 
s>qscale[index]= FFMAX( 
1036 
s>quant_matrixes[index][s>scantable.permutated[1]],

1037 
s>quant_matrixes[index][s>scantable.permutated[8]]) >> 1; 
1038 
dprintf("qscale[%d]: %d\n", index, s>qscale[index]);

1039 
len = 65;

1040 
} 
1041  
1042 
return 0; 
1043 
} 
1044  
1045 
/* decode huffman tables and build VLC decoders */

1046 
static int mjpeg_decode_dht(MJpegDecodeContext *s) 
1047 
{ 
1048 
int len, index, i, class, n, v, code_max;

1049 
uint8_t bits_table[17];

1050 
uint8_t val_table[256];

1051  
1052 
len = get_bits(&s>gb, 16)  2; 
1053  
1054 
while (len > 0) { 
1055 
if (len < 17) 
1056 
return 1; 
1057 
class = get_bits(&s>gb, 4);

1058 
if (class >= 2) 
1059 
return 1; 
1060 
index = get_bits(&s>gb, 4);

1061 
if (index >= 4) 
1062 
return 1; 
1063 
n = 0;

1064 
for(i=1;i<=16;i++) { 
1065 
bits_table[i] = get_bits(&s>gb, 8);

1066 
n += bits_table[i]; 
1067 
} 
1068 
len = 17;

1069 
if (len < n  n > 256) 
1070 
return 1; 
1071  
1072 
code_max = 0;

1073 
for(i=0;i<n;i++) { 
1074 
v = get_bits(&s>gb, 8);

1075 
if (v > code_max)

1076 
code_max = v; 
1077 
val_table[i] = v; 
1078 
} 
1079 
len = n; 
1080  
1081 
/* build VLC and flush previous vlc if present */

1082 
free_vlc(&s>vlcs[class][index]); 
1083 
dprintf("class=%d index=%d nb_codes=%d\n",

1084 
class, index, code_max + 1);

1085 
if(build_vlc(&s>vlcs[class][index], bits_table, val_table, code_max + 1, 0) < 0){ 
1086 
return 1; 
1087 
} 
1088 
} 
1089 
return 0; 
1090 
} 
1091  
1092 
static int mjpeg_decode_sof(MJpegDecodeContext *s) 
1093 
{ 
1094 
int len, nb_components, i, width, height;

1095  
1096 
/* XXX: verify len field validity */

1097 
len = get_bits(&s>gb, 16);

1098 
s>bits= get_bits(&s>gb, 8);

1099  
1100 
if(s>pegasus_rct) s>bits=9; 
1101 
if(s>bits==9 && !s>pegasus_rct) s>rct=1; //FIXME ugly 
1102  
1103 
if (s>bits != 8 && !s>lossless){ 
1104 
av_log(s>avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");

1105 
return 1; 
1106 
} 
1107 
height = get_bits(&s>gb, 16);

1108 
width = get_bits(&s>gb, 16);

1109  
1110 
dprintf("sof0: picture: %dx%d\n", width, height);

1111 
if(avcodec_check_dimensions(s>avctx, width, height))

1112 
return 1; 
1113  
1114 
nb_components = get_bits(&s>gb, 8);

1115 
if (nb_components <= 0  
1116 
nb_components > MAX_COMPONENTS) 
1117 
return 1; 
1118 
s>nb_components = nb_components; 
1119 
s>h_max = 1;

1120 
s>v_max = 1;

1121 
for(i=0;i<nb_components;i++) { 
1122 
/* component id */

1123 
s>component_id[i] = get_bits(&s>gb, 8)  1; 
1124 
s>h_count[i] = get_bits(&s>gb, 4);

1125 
s>v_count[i] = get_bits(&s>gb, 4);

1126 
/* compute hmax and vmax (only used in interleaved case) */

1127 
if (s>h_count[i] > s>h_max)

1128 
s>h_max = s>h_count[i]; 
1129 
if (s>v_count[i] > s>v_max)

1130 
s>v_max = s>v_count[i]; 
1131 
s>quant_index[i] = get_bits(&s>gb, 8);

1132 
if (s>quant_index[i] >= 4) 
1133 
return 1; 
1134 
dprintf("component %d %d:%d id: %d quant:%d\n", i, s>h_count[i],

1135 
s>v_count[i], s>component_id[i], s>quant_index[i]); 
1136 
} 
1137  
1138 
if(s>v_max==1 && s>h_max==1 && s>lossless==1) s>rgb=1; 
1139  
1140 
/* if different size, realloc/alloc picture */

1141 
/* XXX: also check h_count and v_count */

1142 
if (width != s>width  height != s>height) {

1143 
av_freep(&s>qscale_table); 
1144  
1145 
s>width = width; 
1146 
s>height = height; 
1147 
avcodec_set_dimensions(s>avctx, width, height); 
1148  
1149 
/* test interlaced mode */

1150 
if (s>first_picture &&

1151 
s>org_height != 0 &&

1152 
s>height < ((s>org_height * 3) / 4)) { 
1153 
s>interlaced = 1;

1154 
// s>bottom_field = (s>interlace_polarity) ? 1 : 0;

1155 
s>bottom_field = 0;

1156 
s>avctx>height *= 2;

1157 
} 
1158  
1159 
s>qscale_table= av_mallocz((s>width+15)/16); 
1160  
1161 
s>first_picture = 0;

1162 
} 
1163  
1164 
if(s>interlaced && s>bottom_field)

1165 
return 0; 
1166  
1167 
/* XXX: not complete test ! */

1168 
switch((s>h_count[0] << 4)  s>v_count[0]) { 
1169 
case 0x11: 
1170 
if(s>rgb){

1171 
s>avctx>pix_fmt = PIX_FMT_RGBA32; 
1172 
}else if(s>nb_components==3) 
1173 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; 
1174 
else

1175 
s>avctx>pix_fmt = PIX_FMT_GRAY8; 
1176 
break;

1177 
case 0x21: 
1178 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; 
1179 
break;

1180 
default:

1181 
case 0x22: 
1182 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; 
1183 
break;

1184 
} 
1185  
1186 
if(s>picture.data[0]) 
1187 
s>avctx>release_buffer(s>avctx, &s>picture); 
1188  
1189 
s>picture.reference= 0;

1190 
if(s>avctx>get_buffer(s>avctx, &s>picture) < 0){ 
1191 
av_log(s>avctx, AV_LOG_ERROR, "get_buffer() failed\n");

1192 
return 1; 
1193 
} 
1194 
s>picture.pict_type= I_TYPE; 
1195 
s>picture.key_frame= 1;

1196  
1197 
for(i=0; i<3; i++){ 
1198 
s>linesize[i]= s>picture.linesize[i] << s>interlaced; 
1199 
} 
1200  
1201 
// printf("%d %d %d %d %d %d\n", s>width, s>height, s>linesize[0], s>linesize[1], s>interlaced, s>avctx>height);

1202  
1203 
if (len != (8+(3*nb_components))) 
1204 
{ 
1205 
dprintf("decode_sof0: error, len(%d) mismatch\n", len);

1206 
} 
1207  
1208 
return 0; 
1209 
} 
1210  
1211 
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) 
1212 
{ 
1213 
int code;

1214 
code = get_vlc2(&s>gb, s>vlcs[0][dc_index].table, 9, 2); 
1215 
if (code < 0) 
1216 
{ 
1217 
dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, 
1218 
&s>vlcs[0][dc_index]);

1219 
return 0xffff; 
1220 
} 
1221  
1222 
if(code)

1223 
return get_xbits(&s>gb, code);

1224 
else

1225 
return 0; 
1226 
} 
1227  
1228 
/* decode block and dequantize */

1229 
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1230 
int component, int dc_index, int ac_index, int quant_index) 
1231 
{ 
1232 
int code, i, j, level, val;

1233 
VLC *ac_vlc; 
1234 
int16_t *quant_matrix; 
1235  
1236 
/* DC coef */

1237 
val = mjpeg_decode_dc(s, dc_index); 
1238 
if (val == 0xffff) { 
1239 
dprintf("error dc\n");

1240 
return 1; 
1241 
} 
1242 
quant_matrix = s>quant_matrixes[quant_index]; 
1243 
val = val * quant_matrix[0] + s>last_dc[component];

1244 
s>last_dc[component] = val; 
1245 
block[0] = val;

1246 
/* AC coefs */

1247 
ac_vlc = &s>vlcs[1][ac_index];

1248 
i = 1;

1249 
for(;;) {

1250 
code = get_vlc2(&s>gb, s>vlcs[1][ac_index].table, 9, 2); 
1251  
1252 
if (code < 0) { 
1253 
dprintf("error ac\n");

1254 
return 1; 
1255 
} 
1256 
/* EOB */

1257 
if (code == 0) 
1258 
break;

1259 
if (code == 0xf0) { 
1260 
i += 16;

1261 
} else {

1262 
level = get_xbits(&s>gb, code & 0xf);

1263 
i += code >> 4;

1264 
if (i >= 64) { 
1265 
dprintf("error count: %d\n", i);

1266 
return 1; 
1267 
} 
1268 
j = s>scantable.permutated[i]; 
1269 
block[j] = level * quant_matrix[j]; 
1270 
i++; 
1271 
if (i >= 64) 
1272 
break;

1273 
} 
1274 
} 
1275 
return 0; 
1276 
} 
1277  
1278 
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 
1279 
int i, mb_x, mb_y;

1280 
uint16_t buffer[32768][4]; 
1281 
int left[3], top[3], topleft[3]; 
1282 
const int linesize= s>linesize[0]; 
1283 
const int mask= (1<<s>bits)1; 
1284  
1285 
if((unsigned)s>mb_width > 32768) //dynamic alloc 
1286 
return 1; 
1287  
1288 
for(i=0; i<3; i++){ 
1289 
buffer[0][i]= 1 << (s>bits + point_transform  1); 
1290 
} 
1291 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1292 
const int modified_predictor= mb_y ? predictor : 1; 
1293 
uint8_t *ptr = s>picture.data[0] + (linesize * mb_y);

1294  
1295 
if (s>interlaced && s>bottom_field)

1296 
ptr += linesize >> 1;

1297  
1298 
for(i=0; i<3; i++){ 
1299 
top[i]= left[i]= topleft[i]= buffer[0][i];

1300 
} 
1301 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1302 
if (s>restart_interval && !s>restart_count)

1303 
s>restart_count = s>restart_interval; 
1304  
1305 
for(i=0;i<3;i++) { 
1306 
int pred;

1307  
1308 
topleft[i]= top[i]; 
1309 
top[i]= buffer[mb_x][i]; 
1310  
1311 
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); 
1312  
1313 
left[i]= 
1314 
buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform)); 
1315 
} 
1316  
1317 
if (s>restart_interval && !s>restart_count) {

1318 
align_get_bits(&s>gb); 
1319 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1320 
} 
1321 
} 
1322  
1323 
if(s>rct){

1324 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1325 
ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2]  0x200)>>2); 
1326 
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 
1327 
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 
1328 
} 
1329 
}else if(s>pegasus_rct){ 
1330 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1331 
ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2])>>2); 
1332 
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 
1333 
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 
1334 
} 
1335 
}else{

1336 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1337 
ptr[4*mb_x+0] = buffer[mb_x][0]; 
1338 
ptr[4*mb_x+1] = buffer[mb_x][1]; 
1339 
ptr[4*mb_x+2] = buffer[mb_x][2]; 
1340 
} 
1341 
} 
1342 
} 
1343 
return 0; 
1344 
} 
1345  
1346 
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 
1347 
int i, mb_x, mb_y;

1348 
const int nb_components=3; 
1349  
1350 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1351 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1352 
if (s>restart_interval && !s>restart_count)

1353 
s>restart_count = s>restart_interval; 
1354  
1355 
if(mb_x==0  mb_y==0  s>interlaced){ 
1356 
for(i=0;i<nb_components;i++) { 
1357 
uint8_t *ptr; 
1358 
int n, h, v, x, y, c, j, linesize;

1359 
n = s>nb_blocks[i]; 
1360 
c = s>comp_index[i]; 
1361 
h = s>h_scount[i]; 
1362 
v = s>v_scount[i]; 
1363 
x = 0;

1364 
y = 0;

1365 
linesize= s>linesize[c]; 
1366  
1367 
for(j=0; j<n; j++) { 
1368 
int pred;

1369  
1370 
ptr = s>picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

1371 
if(y==0 && mb_y==0){ 
1372 
if(x==0 && mb_x==0){ 
1373 
pred= 128 << point_transform;

1374 
}else{

1375 
pred= ptr[1];

1376 
} 
1377 
}else{

1378 
if(x==0 && mb_x==0){ 
1379 
pred= ptr[linesize]; 
1380 
}else{

1381 
PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor); 
1382 
} 
1383 
} 
1384  
1385 
if (s>interlaced && s>bottom_field)

1386 
ptr += linesize >> 1;

1387 
*ptr= pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform); 
1388  
1389 
if (++x == h) {

1390 
x = 0;

1391 
y++; 
1392 
} 
1393 
} 
1394 
} 
1395 
}else{

1396 
for(i=0;i<nb_components;i++) { 
1397 
uint8_t *ptr; 
1398 
int n, h, v, x, y, c, j, linesize;

1399 
n = s>nb_blocks[i]; 
1400 
c = s>comp_index[i]; 
1401 
h = s>h_scount[i]; 
1402 
v = s>v_scount[i]; 
1403 
x = 0;

1404 
y = 0;

1405 
linesize= s>linesize[c]; 
1406  
1407 
for(j=0; j<n; j++) { 
1408 
int pred;

1409  
1410 
ptr = s>picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap

1411 
PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor); 
1412 
*ptr= pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform); 
1413 
if (++x == h) {

1414 
x = 0;

1415 
y++; 
1416 
} 
1417 
} 
1418 
} 
1419 
} 
1420 
if (s>restart_interval && !s>restart_count) {

1421 
align_get_bits(&s>gb); 
1422 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1423 
} 
1424 
} 
1425 
} 
1426 
return 0; 
1427 
} 
1428  
1429 
static int mjpeg_decode_scan(MJpegDecodeContext *s){ 
1430 
int i, mb_x, mb_y;

1431 
const int nb_components=3; 
1432  
1433 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1434 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1435 
if (s>restart_interval && !s>restart_count)

1436 
s>restart_count = s>restart_interval; 
1437  
1438 
for(i=0;i<nb_components;i++) { 
1439 
uint8_t *ptr; 
1440 
int n, h, v, x, y, c, j;

1441 
n = s>nb_blocks[i]; 
1442 
c = s>comp_index[i]; 
1443 
h = s>h_scount[i]; 
1444 
v = s>v_scount[i]; 
1445 
x = 0;

1446 
y = 0;

1447 
for(j=0;j<n;j++) { 
1448 
memset(s>block, 0, sizeof(s>block)); 
1449 
if (decode_block(s, s>block, i,

1450 
s>dc_index[i], s>ac_index[i], 
1451 
s>quant_index[c]) < 0) {

1452 
dprintf("error y=%d x=%d\n", mb_y, mb_x);

1453 
return 1; 
1454 
} 
1455 
// dprintf("mb: %d %d processed\n", mb_y, mb_x);

1456 
ptr = s>picture.data[c] + 
1457 
(((s>linesize[c] * (v * mb_y + y) * 8) +

1458 
(h * mb_x + x) * 8) >> s>avctx>lowres);

1459 
if (s>interlaced && s>bottom_field)

1460 
ptr += s>linesize[c] >> 1;

1461 
//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);

1462 
s>idct_put(ptr, s>linesize[c], s>block); 
1463 
if (++x == h) {

1464 
x = 0;

1465 
y++; 
1466 
} 
1467 
} 
1468 
} 
1469 
/* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */

1470 
if (s>restart_interval && (s>restart_interval < 1350) && 
1471 
!s>restart_count) { 
1472 
align_get_bits(&s>gb); 
1473 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1474 
for (i=0; i<nb_components; i++) /* reset dc */ 
1475 
s>last_dc[i] = 1024;

1476 
} 
1477 
} 
1478 
} 
1479 
return 0; 
1480 
} 
1481  
1482 
static int mjpeg_decode_sos(MJpegDecodeContext *s) 
1483 
{ 
1484 
int len, nb_components, i, h, v, predictor, point_transform;

1485 
int vmax, hmax, index, id;

1486 
const int block_size= s>lossless ? 1 : 8; 
1487 
int ilv;

1488  
1489 
/* XXX: verify len field validity */

1490 
len = get_bits(&s>gb, 16);

1491 
nb_components = get_bits(&s>gb, 8);

1492 
if (len != 6+2*nb_components) 
1493 
{ 
1494 
dprintf("decode_sos: invalid len (%d)\n", len);

1495 
return 1; 
1496 
} 
1497 
/* XXX: only interleaved scan accepted */

1498 
if (nb_components != s>nb_components)

1499 
{ 
1500 
dprintf("decode_sos: components(%d) mismatch\n", nb_components);

1501 
return 1; 
1502 
} 
1503 
vmax = 0;

1504 
hmax = 0;

1505 
for(i=0;i<nb_components;i++) { 
1506 
id = get_bits(&s>gb, 8)  1; 
1507 
dprintf("component: %d\n", id);

1508 
/* find component index */

1509 
for(index=0;index<s>nb_components;index++) 
1510 
if (id == s>component_id[index])

1511 
break;

1512 
if (index == s>nb_components)

1513 
{ 
1514 
dprintf("decode_sos: index(%d) out of components\n", index);

1515 
return 1; 
1516 
} 
1517  
1518 
s>comp_index[i] = index; 
1519  
1520 
s>nb_blocks[i] = s>h_count[index] * s>v_count[index]; 
1521 
s>h_scount[i] = s>h_count[index]; 
1522 
s>v_scount[i] = s>v_count[index]; 
1523  
1524 
s>dc_index[i] = get_bits(&s>gb, 4);

1525 
s>ac_index[i] = get_bits(&s>gb, 4);

1526  
1527 
if (s>dc_index[i] < 0  s>ac_index[i] < 0  
1528 
s>dc_index[i] >= 4  s>ac_index[i] >= 4) 
1529 
goto out_of_range;

1530 
#if 0 //buggy

1531 
switch(s>start_code)

1532 
{

1533 
case SOF0:

1534 
if (dc_index[i] > 1  ac_index[i] > 1)

1535 
goto out_of_range;

1536 
break;

1537 
case SOF1:

1538 
case SOF2:

1539 
if (dc_index[i] > 3  ac_index[i] > 3)

1540 
goto out_of_range;

1541 
break;

1542 
case SOF3:

1543 
if (dc_index[i] > 3  ac_index[i] != 0)

1544 
goto out_of_range;

1545 
break;

1546 
}

1547 
#endif

1548 
} 
1549  
1550 
predictor= get_bits(&s>gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEGLS NEAR */ 
1551 
ilv= get_bits(&s>gb, 8); /* JPEG Se / JPEGLS ILV */ 
1552 
skip_bits(&s>gb, 4); /* Ah */ 
1553 
point_transform= get_bits(&s>gb, 4); /* Al */ 
1554  
1555 
for(i=0;i<nb_components;i++) 
1556 
s>last_dc[i] = 1024;

1557  
1558 
if (nb_components > 1) { 
1559 
/* interleaved stream */

1560 
s>mb_width = (s>width + s>h_max * block_size  1) / (s>h_max * block_size);

1561 
s>mb_height = (s>height + s>v_max * block_size  1) / (s>v_max * block_size);

1562 
} else {

1563 
h = s>h_max / s>h_scount[s>comp_index[0]];

1564 
v = s>v_max / s>v_scount[s>comp_index[0]];

1565 
s>mb_width = (s>width + h * block_size  1) / (h * block_size);

1566 
s>mb_height = (s>height + v * block_size  1) / (v * block_size);

1567 
s>nb_blocks[0] = 1; 
1568 
s>h_scount[0] = 1; 
1569 
s>v_scount[0] = 1; 
1570 
} 
1571  
1572 
if(s>avctx>debug & FF_DEBUG_PICT_INFO)

1573 
av_log(s>avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s>lossless ? "lossless" : "sequencial DCT", s>rgb ? "RGB" : "", 
1574 
predictor, point_transform, ilv, s>bits, 
1575 
s>pegasus_rct ? "PRCT" : (s>rct ? "RCT" : "")); 
1576  
1577  
1578 
/* mjpegb can have padding bytes between sos and image data, skip them */

1579 
for (i = s>mjpb_skiptosod; i > 0; i) 
1580 
skip_bits(&s>gb, 8);

1581  
1582 
if(s>lossless){

1583 
if(s>ls){

1584 
// for(){

1585 
}else{

1586 
if(s>rgb){

1587 
if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) 
1588 
return 1; 
1589 
}else{

1590 
if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) 
1591 
return 1; 
1592 
} 
1593 
} 
1594 
}else{

1595 
if(mjpeg_decode_scan(s) < 0) 
1596 
return 1; 
1597 
} 
1598 
emms_c(); 
1599 
return 0; 
1600 
out_of_range:

1601 
dprintf("decode_sos: ac/dc index out of range\n");

1602 
return 1; 
1603 
} 
1604  
1605 
static int mjpeg_decode_dri(MJpegDecodeContext *s) 
1606 
{ 
1607 
if (get_bits(&s>gb, 16) != 4) 
1608 
return 1; 
1609 
s>restart_interval = get_bits(&s>gb, 16);

1610 
s>restart_count = 0;

1611 
dprintf("restart interval: %d\n", s>restart_interval);

1612  
1613 
return 0; 
1614 
} 
1615  
1616 
static int mjpeg_decode_app(MJpegDecodeContext *s) 
1617 
{ 
1618 
int len, id;

1619  
1620 
len = get_bits(&s>gb, 16);

1621 
if (len < 5) 
1622 
return 1; 
1623 
if(8*len + get_bits_count(&s>gb) > s>gb.size_in_bits) 
1624 
return 1; 
1625  
1626 
id = (get_bits(&s>gb, 16) << 16)  get_bits(&s>gb, 16); 
1627 
id = be2me_32(id); 
1628 
len = 6;

1629  
1630 
if(s>avctx>debug & FF_DEBUG_STARTCODE){

1631 
av_log(s>avctx, AV_LOG_DEBUG, "APPx %8X\n", id);

1632 
} 
1633  
1634 
/* buggy AVID, it puts EOI only at every 10th frame */

1635 
/* also this fourcc is used by nonavid files too, it holds some

1636 
informations, but it's always present in AVID creates files */

1637 
if (id == ff_get_fourcc("AVI1")) 
1638 
{ 
1639 
/* structure:

1640 
4bytes AVI1

1641 
1bytes polarity

1642 
1bytes always zero

1643 
4bytes field_size

1644 
4bytes field_size_less_padding

1645 
*/

1646 
s>buggy_avid = 1;

1647 
// if (s>first_picture)

1648 
// printf("mjpeg: workarounding buggy AVID\n");

1649 
s>interlace_polarity = get_bits(&s>gb, 8);

1650 
#if 0

1651 
skip_bits(&s>gb, 8);

1652 
skip_bits(&s>gb, 32);

1653 
skip_bits(&s>gb, 32);

1654 
len = 10;

1655 
#endif

1656 
// if (s>interlace_polarity)

1657 
// printf("mjpeg: interlace polarity: %d\n", s>interlace_polarity);

1658 
goto out;

1659 
} 
1660  
1661 
// len = 2;

1662  
1663 
if (id == ff_get_fourcc("JFIF")) 
1664 
{ 
1665 
int t_w, t_h, v1, v2;

1666 
skip_bits(&s>gb, 8); /* the trailing zerobyte */ 
1667 
v1= get_bits(&s>gb, 8);

1668 
v2= get_bits(&s>gb, 8);

1669 
skip_bits(&s>gb, 8);

1670  
1671 
s>avctx>sample_aspect_ratio.num= get_bits(&s>gb, 16);

1672 
s>avctx>sample_aspect_ratio.den= get_bits(&s>gb, 16);

1673  
1674 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

1675 
av_log(s>avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",

1676 
v1, v2, 
1677 
s>avctx>sample_aspect_ratio.num, 
1678 
s>avctx>sample_aspect_ratio.den 
1679 
); 
1680  
1681 
t_w = get_bits(&s>gb, 8);

1682 
t_h = get_bits(&s>gb, 8);

1683 
if (t_w && t_h)

1684 
{ 
1685 
/* skip thumbnail */

1686 
if (len10(t_w*t_h*3) > 0) 
1687 
len = t_w*t_h*3;

1688 
} 
1689 
len = 10;

1690 
goto out;

1691 
} 
1692  
1693 
if (id == ff_get_fourcc("Adob") && (get_bits(&s>gb, 8) == 'e')) 
1694 
{ 
1695 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

1696 
av_log(s>avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");

1697 
skip_bits(&s>gb, 16); /* version */ 
1698 
skip_bits(&s>gb, 16); /* flags0 */ 
1699 
skip_bits(&s>gb, 16); /* flags1 */ 
1700 
skip_bits(&s>gb, 8); /* transform */ 
1701 
len = 7;

1702 
goto out;

1703 
} 
1704  
1705 
if (id == ff_get_fourcc("LJIF")){ 
1706 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

1707 
av_log(s>avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");

1708 
skip_bits(&s>gb, 16); /* version ? */ 
1709 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1710 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1711 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1712 
switch( get_bits(&s>gb, 8)){ 
1713 
case 1: 
1714 
s>rgb= 1;

1715 
s>pegasus_rct=0;

1716 
break;

1717 
case 2: 
1718 
s>rgb= 1;

1719 
s>pegasus_rct=1;

1720 
break;

1721 
default:

1722 
av_log(s>avctx, AV_LOG_ERROR, "unknown colorspace\n");

1723 
} 
1724 
len = 9;

1725 
goto out;

1726 
} 
1727  
1728 
/* Apple MJPEGA */

1729 
if ((s>start_code == APP1) && (len > (0x28  8))) 
1730 
{ 
1731 
id = (get_bits(&s>gb, 16) << 16)  get_bits(&s>gb, 16); 
1732 
id = be2me_32(id); 
1733 
len = 4;

1734 
if (id == ff_get_fourcc("mjpg")) /* Apple MJPEGA */ 
1735 
{ 
1736 
#if 0

1737 
skip_bits(&s>gb, 32); /* field size */

1738 
skip_bits(&s>gb, 32); /* pad field size */

1739 
skip_bits(&s>gb, 32); /* next off */

1740 
skip_bits(&s>gb, 32); /* quant off */

1741 
skip_bits(&s>gb, 32); /* huff off */

1742 
skip_bits(&s>gb, 32); /* image off */

1743 
skip_bits(&s>gb, 32); /* scan off */

1744 
skip_bits(&s>gb, 32); /* data off */

1745 
#endif

1746 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

1747 
av_log(s>avctx, AV_LOG_INFO, "mjpeg: Apple MJPEGA header found\n");

1748 
} 
1749 
} 
1750  
1751 
out:

1752 
/* slow but needed for extreme adobe jpegs */

1753 
if (len < 0) 
1754 
av_log(s>avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");

1755 
while(len > 0) 
1756 
skip_bits(&s>gb, 8);

1757  
1758 
return 0; 
1759 
} 
1760  
1761 
static int mjpeg_decode_com(MJpegDecodeContext *s) 
1762 
{ 
1763 
int len = get_bits(&s>gb, 16); 
1764 
if (len >= 2 && 8*len  16 + get_bits_count(&s>gb) <= s>gb.size_in_bits) { 
1765 
uint8_t *cbuf = av_malloc(len  1);

1766 
if (cbuf) {

1767 
int i;

1768 
for (i = 0; i < len  2; i++) 
1769 
cbuf[i] = get_bits(&s>gb, 8);

1770 
if (i > 0 && cbuf[i1] == '\n') 
1771 
cbuf[i1] = 0; 
1772 
else

1773 
cbuf[i] = 0;

1774  
1775 
if(s>avctx>debug & FF_DEBUG_PICT_INFO)

1776 
av_log(s>avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);

1777  
1778 
/* buggy avid, it puts EOI only at every 10th frame */

1779 
if (!strcmp(cbuf, "AVID")) 
1780 
{ 
1781 
s>buggy_avid = 1;

1782 
// if (s>first_picture)

1783 
// printf("mjpeg: workarounding buggy AVID\n");

1784 
} 
1785 
else if(!strcmp(cbuf, "CS=ITU601")){ 
1786 
s>cs_itu601= 1;

1787 
} 
1788  
1789 
av_free(cbuf); 
1790 
} 
1791 
} 
1792  
1793 
return 0; 
1794 
} 
1795  
1796 
#if 0

1797 
static int valid_marker_list[] =

1798 
{

1799 
/* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */

1800 
/* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1801 
/* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1802 
/* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1803 
/* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1804 
/* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1805 
/* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1806 
/* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1807 
/* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1808 
/* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1809 
/* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1810 
/* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1811 
/* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1812 
/* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1813 
/* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1814 
/* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1815 
/* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

1816 
}

1817 
#endif

1818  
1819 
/* return the 8 bit start code value and update the search

1820 
state. Return 1 if no start code found */

1821 
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end) 
1822 
{ 
1823 
uint8_t *buf_ptr; 
1824 
unsigned int v, v2; 
1825 
int val;

1826 
#ifdef DEBUG

1827 
int skipped=0; 
1828 
#endif

1829  
1830 
buf_ptr = *pbuf_ptr; 
1831 
while (buf_ptr < buf_end) {

1832 
v = *buf_ptr++; 
1833 
v2 = *buf_ptr; 
1834 
if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { 
1835 
val = *buf_ptr++; 
1836 
goto found;

1837 
} 
1838 
#ifdef DEBUG

1839 
skipped++; 
1840 
#endif

1841 
} 
1842 
val = 1;

1843 
found:

1844 
#ifdef DEBUG

1845 
dprintf("find_marker skipped %d bytes\n", skipped);

1846 
#endif

1847 
*pbuf_ptr = buf_ptr; 
1848 
return val;

1849 
} 
1850  
1851 
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1852 
void *data, int *data_size, 
1853 
uint8_t *buf, int buf_size)

1854 
{ 
1855 
MJpegDecodeContext *s = avctx>priv_data; 
1856 
uint8_t *buf_end, *buf_ptr; 
1857 
int start_code;

1858 
AVFrame *picture = data; 
1859  
1860 
buf_ptr = buf; 
1861 
buf_end = buf + buf_size; 
1862 
while (buf_ptr < buf_end) {

1863 
/* find start next marker */

1864 
start_code = find_marker(&buf_ptr, buf_end); 
1865 
{ 
1866 
/* EOF */

1867 
if (start_code < 0) { 
1868 
goto the_end;

1869 
} else {

1870 
dprintf("marker=%x avail_size_in_buf=%d\n", start_code, buf_end  buf_ptr);

1871  
1872 
if ((buf_end  buf_ptr) > s>buffer_size)

1873 
{ 
1874 
av_free(s>buffer); 
1875 
s>buffer_size = buf_endbuf_ptr; 
1876 
s>buffer = av_malloc(s>buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); 
1877 
dprintf("buffer too small, expanding to %d bytes\n",

1878 
s>buffer_size); 
1879 
} 
1880  
1881 
/* unescape buffer of SOS */

1882 
if (start_code == SOS)

1883 
{ 
1884 
uint8_t *src = buf_ptr; 
1885 
uint8_t *dst = s>buffer; 
1886  
1887 
while (src<buf_end)

1888 
{ 
1889 
uint8_t x = *(src++); 
1890  
1891 
*(dst++) = x; 
1892 
if (x == 0xff) 
1893 
{ 
1894 
while(src<buf_end && x == 0xff) 
1895 
x = *(src++); 
1896  
1897 
if (x >= 0xd0 && x <= 0xd7) 
1898 
*(dst++) = x; 
1899 
else if (x) 
1900 
break;

1901 
} 
1902 
} 
1903 
init_get_bits(&s>gb, s>buffer, (dst  s>buffer)*8);

1904  
1905 
dprintf("escaping removed %d bytes\n",

1906 
(buf_end  buf_ptr)  (dst  s>buffer)); 
1907 
} 
1908 
else

1909 
init_get_bits(&s>gb, buf_ptr, (buf_end  buf_ptr)*8);

1910  
1911 
s>start_code = start_code; 
1912 
if(s>avctx>debug & FF_DEBUG_STARTCODE){

1913 
av_log(s>avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);

1914 
} 
1915  
1916 
/* process markers */

1917 
if (start_code >= 0xd0 && start_code <= 0xd7) { 
1918 
dprintf("restart marker: %d\n", start_code&0x0f); 
1919 
/* APP fields */

1920 
} else if (start_code >= APP0 && start_code <= APP15) { 
1921 
mjpeg_decode_app(s); 
1922 
/* Comment */

1923 
} else if (start_code == COM){ 
1924 
mjpeg_decode_com(s); 
1925 
} 
1926  
1927 
switch(start_code) {

1928 
case SOI:

1929 
s>restart_interval = 0;

1930 
reset_ls_coding_parameters(s, 1);

1931  
1932 
s>restart_count = 0;

1933 
/* nothing to do on SOI */

1934 
break;

1935 
case DQT:

1936 
mjpeg_decode_dqt(s); 
1937 
break;

1938 
case DHT:

1939 
if(mjpeg_decode_dht(s) < 0){ 
1940 
av_log(s>avctx, AV_LOG_ERROR, "huffman table decode error\n");

1941 
return 1; 
1942 
} 
1943 
break;

1944 
case SOF0:

1945 
s>lossless=0;

1946 
if (mjpeg_decode_sof(s) < 0) 
1947 
return 1; 
1948 
break;

1949 
case SOF3:

1950 
s>lossless=1;

1951 
if (mjpeg_decode_sof(s) < 0) 
1952 
return 1; 
1953 
break;

1954 
case SOF48:

1955 
s>lossless=1;

1956 
s>ls=1;

1957 
if (mjpeg_decode_sof(s) < 0) 
1958 
return 1; 
1959 
break;

1960 
case LSE:

1961 
if (decode_lse(s) < 0) 
1962 
return 1; 
1963 
break;

1964 
case EOI:

1965 
if ((s>buggy_avid && !s>interlaced)  s>restart_interval)

1966 
break;

1967 
eoi_parser:

1968 
{ 
1969 
if (s>interlaced) {

1970 
s>bottom_field ^= 1;

1971 
/* if not bottom field, do not output image yet */

1972 
if (s>bottom_field)

1973 
goto not_the_end;

1974 
} 
1975 
*picture = s>picture; 
1976 
*data_size = sizeof(AVFrame);

1977  
1978 
if(!s>lossless){

1979 
picture>quality= FFMAX(FFMAX(s>qscale[0], s>qscale[1]), s>qscale[2]); 
1980 
picture>qstride= 0;

1981 
picture>qscale_table= s>qscale_table; 
1982 
memset(picture>qscale_table, picture>quality, (s>width+15)/16); 
1983 
if(avctx>debug & FF_DEBUG_QP)

1984 
av_log(s>avctx, AV_LOG_DEBUG, "QP: %d\n", picture>quality);

1985 
picture>quality*= FF_QP2LAMBDA; 
1986 
} 
1987  
1988 
goto the_end;

1989 
} 
1990 
break;

1991 
case SOS:

1992 
mjpeg_decode_sos(s); 
1993 
/* buggy avid puts EOI every 1020th frame */

1994 
/* if restart period is over process EOI */

1995 
if ((s>buggy_avid && !s>interlaced)  s>restart_interval)

1996 
goto eoi_parser;

1997 
break;

1998 
case DRI:

1999 
mjpeg_decode_dri(s); 
2000 
break;

2001 
case SOF1:

2002 
case SOF2:

2003 
case SOF5:

2004 
case SOF6:

2005 
case SOF7:

2006 
case SOF9:

2007 
case SOF10:

2008 
case SOF11:

2009 
case SOF13:

2010 
case SOF14:

2011 
case SOF15:

2012 
case JPG:

2013 
av_log(s>avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);

2014 
break;

2015 
// default:

2016 
// printf("mjpeg: unsupported marker (%x)\n", start_code);

2017 
// break;

2018 
} 
2019  
2020 
not_the_end:

2021 
/* eof process start code */

2022 
buf_ptr += (get_bits_count(&s>gb)+7)/8; 
2023 
dprintf("marker parser used %d bytes (%d bits)\n",

2024 
(get_bits_count(&s>gb)+7)/8, get_bits_count(&s>gb)); 
2025 
} 
2026 
} 
2027 
} 
2028 
the_end:

2029 
dprintf("mjpeg decode frame unused %d bytes\n", buf_end  buf_ptr);

2030 
// return buf_end  buf_ptr;

2031 
return buf_ptr  buf;

2032 
} 
2033  
2034 
static int mjpegb_decode_frame(AVCodecContext *avctx, 
2035 
void *data, int *data_size, 
2036 
uint8_t *buf, int buf_size)

2037 
{ 
2038 
MJpegDecodeContext *s = avctx>priv_data; 
2039 
uint8_t *buf_end, *buf_ptr; 
2040 
AVFrame *picture = data; 
2041 
GetBitContext hgb; /* for the header */

2042 
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs; 
2043 
uint32_t field_size, sod_offs; 
2044  
2045 
buf_ptr = buf; 
2046 
buf_end = buf + buf_size; 
2047  
2048 
read_header:

2049 
/* reset on every SOI */

2050 
s>restart_interval = 0;

2051 
s>restart_count = 0;

2052 
s>mjpb_skiptosod = 0;

2053  
2054 
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end  buf_ptr)*8); 
2055  
2056 
skip_bits(&hgb, 32); /* reserved zeros */ 
2057  
2058 
if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg"))) 
2059 
{ 
2060 
dprintf("not mjpegb (bad fourcc)\n");

2061 
return 0; 
2062 
} 
2063  
2064 
field_size = get_bits_long(&hgb, 32); /* field size */ 
2065 
dprintf("field size: 0x%x\n", field_size);

2066 
skip_bits(&hgb, 32); /* padded field size */ 
2067 
second_field_offs = get_bits_long(&hgb, 32);

2068 
dprintf("second field offs: 0x%x\n", second_field_offs);

2069 
if (second_field_offs)

2070 
s>interlaced = 1;

2071  
2072 
dqt_offs = get_bits_long(&hgb, 32);

2073 
dprintf("dqt offs: 0x%x\n", dqt_offs);

2074 
if (dqt_offs)

2075 
{ 
2076 
init_get_bits(&s>gb, buf+dqt_offs, (buf_end  (buf+dqt_offs))*8);

2077 
s>start_code = DQT; 
2078 
mjpeg_decode_dqt(s); 
2079 
} 
2080  
2081 
dht_offs = get_bits_long(&hgb, 32);

2082 
dprintf("dht offs: 0x%x\n", dht_offs);

2083 
if (dht_offs)

2084 
{ 
2085 
init_get_bits(&s>gb, buf+dht_offs, (buf_end  (buf+dht_offs))*8);

2086 
s>start_code = DHT; 
2087 
mjpeg_decode_dht(s); 
2088 
} 
2089  
2090 
sof_offs = get_bits_long(&hgb, 32);

2091 
dprintf("sof offs: 0x%x\n", sof_offs);

2092 
if (sof_offs)

2093 
{ 
2094 
init_get_bits(&s>gb, buf+sof_offs, (buf_end  (buf+sof_offs))*8);

2095 
s>start_code = SOF0; 
2096 
if (mjpeg_decode_sof(s) < 0) 
2097 
return 1; 
2098 
} 
2099  
2100 
sos_offs = get_bits_long(&hgb, 32);

2101 
dprintf("sos offs: 0x%x\n", sos_offs);

2102 
sod_offs = get_bits_long(&hgb, 32);

2103 
dprintf("sod offs: 0x%x\n", sod_offs);

2104 
if (sos_offs)

2105 
{ 
2106 
// init_get_bits(&s>gb, buf+sos_offs, (buf_end  (buf+sos_offs))*8);

2107 
init_get_bits(&s>gb, buf+sos_offs, field_size*8);

2108 
s>mjpb_skiptosod = (sod_offs  sos_offs  show_bits(&s>gb, 16));

2109 
s>start_code = SOS; 
2110 
mjpeg_decode_sos(s); 
2111 
} 
2112  
2113 
if (s>interlaced) {

2114 
s>bottom_field ^= 1;

2115 
/* if not bottom field, do not output image yet */

2116 
if (s>bottom_field && second_field_offs)

2117 
{ 
2118 
buf_ptr = buf + second_field_offs; 
2119 
second_field_offs = 0;

2120 
goto read_header;

2121 
} 
2122 
} 
2123  
2124 
//XXX FIXME factorize, this looks very similar to the EOI code

2125  
2126 
*picture= s>picture; 
2127 
*data_size = sizeof(AVFrame);

2128  
2129 
if(!s>lossless){

2130 
picture>quality= FFMAX(FFMAX(s>qscale[0], s>qscale[1]), s>qscale[2]); 
2131 
picture>qstride= 0;

2132 
picture>qscale_table= s>qscale_table; 
2133 
memset(picture>qscale_table, picture>quality, (s>width+15)/16); 
2134 
if(avctx>debug & FF_DEBUG_QP)

2135 
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture>quality);

2136 
picture>quality*= FF_QP2LAMBDA; 
2137 
} 
2138  
2139 
return buf_ptr  buf;

2140 
} 
2141  
2142 
#include "sp5x.h" 
2143  
2144 
static int sp5x_decode_frame(AVCodecContext *avctx, 
2145 
void *data, int *data_size, 
2146 
uint8_t *buf, int buf_size)

2147 
{ 
2148 
#if 0

2149 
MJpegDecodeContext *s = avctx>priv_data;

2150 
#endif

2151 
const int qscale = 5; 
2152 
uint8_t *buf_ptr, *buf_end, *recoded; 
2153 
int i = 0, j = 0; 
2154  
2155 
if (!avctx>width  !avctx>height)

2156 
return 1; 
2157  
2158 
buf_ptr = buf; 
2159 
buf_end = buf + buf_size; 
2160  
2161 
#if 1 
2162 
recoded = av_mallocz(buf_size + 1024);

2163 
if (!recoded)

2164 
return 1; 
2165  
2166 
/* SOI */

2167 
recoded[j++] = 0xFF;

2168 
recoded[j++] = 0xD8;

2169  
2170 
memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt)); 
2171 
memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64); 
2172 
memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64); 
2173 
j += sizeof(sp5x_data_dqt);

2174  
2175 
memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht)); 
2176 
j += sizeof(sp5x_data_dht);

2177  
2178 
memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof)); 
2179 
recoded[j+5] = (avctx>coded_height >> 8) & 0xFF; 
2180 
recoded[j+6] = avctx>coded_height & 0xFF; 
2181 
recoded[j+7] = (avctx>coded_width >> 8) & 0xFF; 
2182 
recoded[j+8] = avctx>coded_width & 0xFF; 
2183 
j += sizeof(sp5x_data_sof);

2184  
2185 
memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos)); 
2186 
j += sizeof(sp5x_data_sos);

2187  
2188 
for (i = 14; i < buf_size && j < buf_size+10242; i++) 
2189 
{ 
2190 
recoded[j++] = buf[i]; 
2191 
if (buf[i] == 0xff) 
2192 
recoded[j++] = 0;

2193 
} 
2194  
2195 
/* EOI */

2196 
recoded[j++] = 0xFF;

2197 
recoded[j++] = 0xD9;

2198  
2199 
i = mjpeg_decode_frame(avctx, data, data_size, recoded, j); 
2200  
2201 
av_free(recoded); 
2202  
2203 
#else

2204 
/* SOF */

2205 
s>bits = 8;

2206 
s>width = avctx>coded_width; 
2207 
s>height = avctx>coded_height; 
2208 
s>nb_components = 3;

2209 
s>component_id[0] = 0; 
2210 
s>h_count[0] = 2; 
2211 
s>v_count[0] = 2; 
2212 
s>quant_index[0] = 0; 
2213 
s>component_id[1] = 1; 
2214 
s>h_count[1] = 1; 
2215 
s>v_count[1] = 1; 
2216 
s>quant_index[1] = 1; 
2217 
s>component_id[2] = 2; 
2218 
s>h_count[2] = 1; 
2219 
s>v_count[2] = 1; 
2220 
s>quant_index[2] = 1; 
2221 
s>h_max = 2;

2222 
s>v_max = 2;

2223  
2224 
s>qscale_table = av_mallocz((s>width+15)/16); 
2225 
avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420; 
2226 
s>interlaced = 0;

2227  
2228 
s>picture.reference = 0;

2229 
if (avctx>get_buffer(avctx, &s>picture) < 0) 
2230 
{ 
2231 
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

2232 
return 1; 
2233 
} 
2234  
2235 
s>picture.pict_type = I_TYPE; 
2236 
s>picture.key_frame = 1;

2237  
2238 
for (i = 0; i < 3; i++) 
2239 
s>linesize[i] = s>picture.linesize[i] << s>interlaced; 
2240  
2241 
/* DQT */

2242 
for (i = 0; i < 64; i++) 
2243 
{ 
2244 
j = s>scantable.permutated[i]; 
2245 
s>quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i]; 
2246 
} 
2247 
s>qscale[0] = FFMAX(

2248 
s>quant_matrixes[0][s>scantable.permutated[1]], 
2249 
s>quant_matrixes[0][s>scantable.permutated[8]]) >> 1; 
2250  
2251 
for (i = 0; i < 64; i++) 
2252 
{ 
2253 
j = s>scantable.permutated[i]; 
2254 
s>quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i]; 
2255 
} 
2256 
s>qscale[1] = FFMAX(

2257 
s>quant_matrixes[1][s>scantable.permutated[1]], 
2258 
s>quant_matrixes[1][s>scantable.permutated[8]]) >> 1; 
2259  
2260 
/* DHT */

2261  
2262 
/* SOS */

2263 
s>comp_index[0] = 0; 
2264 
s>nb_blocks[0] = s>h_count[0] * s>v_count[0]; 
2265 
s>h_scount[0] = s>h_count[0]; 
2266 
s>v_scount[0] = s>v_count[0]; 
2267 
s>dc_index[0] = 0; 
2268 
s>ac_index[0] = 0; 
2269  
2270 
s>comp_index[1] = 1; 
2271 
s>nb_blocks[1] = s>h_count[1] * s>v_count[1]; 
2272 
s>h_scount[1] = s>h_count[1]; 
2273 
s>v_scount[1] = s>v_count[1]; 
2274 
s>dc_index[1] = 1; 
2275 
s>ac_index[1] = 1; 
2276  
2277 
s>comp_index[2] = 2; 
2278 
s>nb_blocks[2] = s>h_count[2] * s>v_count[2]; 
2279 
s>h_scount[2] = s>h_count[2]; 
2280 
s>v_scount[2] = s>v_count[2]; 
2281 
s>dc_index[2] = 1; 
2282 
s>ac_index[2] = 1; 
2283  
2284 
for (i = 0; i < 3; i++) 
2285 
s>last_dc[i] = 1024;

2286  
2287 
s>mb_width = (s>width * s>h_max * 8 1) / (s>h_max * 8); 
2288 
s>mb_height = (s>height * s>v_max * 8 1) / (s>v_max * 8); 
2289  
2290 
init_get_bits(&s>gb, buf+14, (buf_size14)*8); 
2291  
2292 
return mjpeg_decode_scan(s);

2293 
#endif

2294  
2295 
return i;

2296 
} 
2297  
2298 
static int mjpeg_decode_end(AVCodecContext *avctx) 
2299 
{ 
2300 
MJpegDecodeContext *s = avctx>priv_data; 
2301 
int i, j;

2302  
2303 
av_free(s>buffer); 
2304 
av_free(s>qscale_table); 
2305  
2306 
for(i=0;i<2;i++) { 
2307 
for(j=0;j<4;j++) 
2308 
free_vlc(&s>vlcs[i][j]); 
2309 
} 
2310 
return 0; 
2311 
} 
2312  
2313 
AVCodec mjpeg_decoder = { 
2314 
"mjpeg",

2315 
CODEC_TYPE_VIDEO, 
2316 
CODEC_ID_MJPEG, 
2317 
sizeof(MJpegDecodeContext),

2318 
mjpeg_decode_init, 
2319 
NULL,

2320 
mjpeg_decode_end, 
2321 
mjpeg_decode_frame, 
2322 
CODEC_CAP_DR1, 
2323 
NULL

2324 
}; 
2325  
2326 
AVCodec mjpegb_decoder = { 
2327 
"mjpegb",

2328 
CODEC_TYPE_VIDEO, 
2329 
CODEC_ID_MJPEGB, 
2330 
sizeof(MJpegDecodeContext),

2331 
mjpeg_decode_init, 
2332 
NULL,

2333 
mjpeg_decode_end, 
2334 
mjpegb_decode_frame, 
2335 
CODEC_CAP_DR1, 
2336 
NULL

2337 
}; 
2338  
2339 
AVCodec sp5x_decoder = { 
2340 
"sp5x",

2341 
CODEC_TYPE_VIDEO, 
2342 
CODEC_ID_SP5X, 
2343 
sizeof(MJpegDecodeContext),

2344 
mjpeg_decode_init, 
2345 
NULL,

2346 
mjpeg_decode_end, 
2347 
sp5x_decode_frame, 
2348 
CODEC_CAP_DR1, 
2349 
NULL

2350 
}; 
2351  
2352 
#ifdef CONFIG_ENCODERS

2353 
AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless jpeg shouldnt need them

2354 
"ljpeg",

2355 
CODEC_TYPE_VIDEO, 
2356 
CODEC_ID_LJPEG, 
2357 
sizeof(MpegEncContext),

2358 
MPV_encode_init, 
2359 
encode_picture_lossless, 
2360 
MPV_encode_end, 
2361 
}; 
2362 
#endif

2363  
2364 
AVCodecParser mjpeg_parser = { 
2365 
{ CODEC_ID_MJPEG }, 
2366 
sizeof(ParseContext),

2367 
NULL,

2368 
jpeg_parse, 
2369 
ff_parse_close, 
2370 
}; 
2371 