ffmpeg / libavcodec / mjpeg.c @ 68b51e58
History  View  Annotate  Download (74.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 
DECLARE_ALIGNED_8(DCTELEM, block[64]);

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

881 
int restart_count;

882  
883 
int buggy_avid;

884 
int cs_itu601;

885 
int interlace_polarity;

886  
887 
int mjpb_skiptosod;

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

900 
uint16_t huff_code[256];

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

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

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

927 
s>buffer_size = 0;

928 
s>buffer = NULL;

929 
s>start_code = 1;

930 
s>first_picture = 1;

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

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

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

942 
mjpeg_decode_dht(s); 
943 
/* should check for error  but dunno */

944 
} 
945  
946 
return 0; 
947 
} 
948  
949  
950 
/**

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

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

953 
*/

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

956 
uint16_t state; 
957  
958 
vop_found= pc>frame_start_found; 
959 
state= pc>state; 
960  
961 
i=0;

962 
if(!vop_found){

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

965 
if(state == 0xFFD8){ 
966 
i++; 
967 
vop_found=1;

968 
break;

969 
} 
970 
} 
971 
} 
972  
973 
if(vop_found){

974 
/* EOF considered as end of frame */

975 
if (buf_size == 0) 
976 
return 0; 
977 
for(; i<buf_size; i++){

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

979 
if(state == 0xFFD8){ 
980 
pc>frame_start_found=0;

981 
pc>state=0;

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

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

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

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

1003 
*poutbuf_size = 0;

1004 
return buf_size;

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

1010 
} 
1011  
1012 
/* quantize tables */

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

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

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

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

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

1030 
/* read quant table */

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

1034 
} 
1035  
1036 
//XXX FIXME finetune, and perhaps add dc too

1037 
s>qscale[index]= FFMAX( 
1038 
s>quant_matrixes[index][s>scantable.permutated[1]],

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

1041 
len = 65;

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

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

1051 
uint8_t bits_table[17];

1052 
uint8_t val_table[256];

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

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

1063 
if (index >= 4) 
1064 
return 1; 
1065 
n = 0;

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

1068 
n += bits_table[i]; 
1069 
} 
1070 
len = 17;

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

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

1077 
if (v > code_max)

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

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

1086 
class, index, code_max + 1);

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

1097  
1098 
/* XXX: verify len field validity */

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

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

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

1107 
return 1; 
1108 
} 
1109 
if (s>bits > 8 && s>ls){ 
1110 
av_log(s>avctx, AV_LOG_ERROR, "only <= 8 bits/component accepted for JPEGLS\n");

1111 
return 1; 
1112 
} 
1113  
1114 
height = get_bits(&s>gb, 16);

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

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

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

1119 
return 1; 
1120  
1121 
nb_components = get_bits(&s>gb, 8);

1122 
if (nb_components <= 0  
1123 
nb_components > MAX_COMPONENTS) 
1124 
return 1; 
1125 
s>nb_components = nb_components; 
1126 
s>h_max = 1;

1127 
s>v_max = 1;

1128 
for(i=0;i<nb_components;i++) { 
1129 
/* component id */

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

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

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

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

1135 
s>h_max = s>h_count[i]; 
1136 
if (s>v_count[i] > s>v_max)

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

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

1142 
s>v_count[i], s>component_id[i], s>quant_index[i]); 
1143 
} 
1144  
1145 
if(s>ls && (s>h_max > 1  s>v_max > 1)) { 
1146 
av_log(s>avctx, AV_LOG_ERROR, "Subsampling in JPEGLS is not supported.\n");

1147 
return 1; 
1148 
} 
1149  
1150 
if(s>v_max==1 && s>h_max==1 && s>lossless==1) s>rgb=1; 
1151  
1152 
/* if different size, realloc/alloc picture */

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

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

1155 
av_freep(&s>qscale_table); 
1156  
1157 
s>width = width; 
1158 
s>height = height; 
1159  
1160 
/* test interlaced mode */

1161 
if (s>first_picture &&

1162 
s>org_height != 0 &&

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

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

1166 
s>bottom_field = 0;

1167 
height *= 2;

1168 
} 
1169  
1170 
avcodec_set_dimensions(s>avctx, width, height); 
1171  
1172 
s>qscale_table= av_mallocz((s>width+15)/16); 
1173  
1174 
s>first_picture = 0;

1175 
} 
1176  
1177 
if(s>interlaced && s>bottom_field)

1178 
return 0; 
1179  
1180 
/* XXX: not complete test ! */

1181 
switch((s>h_count[0] << 4)  s>v_count[0]) { 
1182 
case 0x11: 
1183 
if(s>rgb){

1184 
s>avctx>pix_fmt = PIX_FMT_RGBA32; 
1185 
}else if(s>nb_components==3) 
1186 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P; 
1187 
else

1188 
s>avctx>pix_fmt = PIX_FMT_GRAY8; 
1189 
break;

1190 
case 0x21: 
1191 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV422P : PIX_FMT_YUVJ422P; 
1192 
break;

1193 
default:

1194 
case 0x22: 
1195 
s>avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420P; 
1196 
break;

1197 
} 
1198 
if(s>ls){

1199 
if(s>nb_components > 1) 
1200 
s>avctx>pix_fmt = PIX_FMT_RGB24; 
1201 
else

1202 
s>avctx>pix_fmt = PIX_FMT_GRAY8; 
1203 
} 
1204  
1205 
if(s>picture.data[0]) 
1206 
s>avctx>release_buffer(s>avctx, &s>picture); 
1207  
1208 
s>picture.reference= 0;

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

1211 
return 1; 
1212 
} 
1213 
s>picture.pict_type= I_TYPE; 
1214 
s>picture.key_frame= 1;

1215  
1216 
for(i=0; i<3; i++){ 
1217 
s>linesize[i]= s>picture.linesize[i] << s>interlaced; 
1218 
} 
1219  
1220 
// printf("%d %d %d %d %d %d\n", s>width, s>height, s>linesize[0], s>linesize[1], s>interlaced, s>avctx>height);

1221  
1222 
if (len != (8+(3*nb_components))) 
1223 
{ 
1224 
dprintf("decode_sof0: error, len(%d) mismatch\n", len);

1225 
} 
1226  
1227 
return 0; 
1228 
} 
1229  
1230 
static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index) 
1231 
{ 
1232 
int code;

1233 
code = get_vlc2(&s>gb, s>vlcs[0][dc_index].table, 9, 2); 
1234 
if (code < 0) 
1235 
{ 
1236 
dprintf("mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index, 
1237 
&s>vlcs[0][dc_index]);

1238 
return 0xffff; 
1239 
} 
1240  
1241 
if(code)

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

1243 
else

1244 
return 0; 
1245 
} 
1246  
1247 
/* decode block and dequantize */

1248 
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, 
1249 
int component, int dc_index, int ac_index, int quant_index) 
1250 
{ 
1251 
int code, i, j, level, val;

1252 
VLC *ac_vlc; 
1253 
int16_t *quant_matrix; 
1254  
1255 
/* DC coef */

1256 
val = mjpeg_decode_dc(s, dc_index); 
1257 
if (val == 0xffff) { 
1258 
dprintf("error dc\n");

1259 
return 1; 
1260 
} 
1261 
quant_matrix = s>quant_matrixes[quant_index]; 
1262 
val = val * quant_matrix[0] + s>last_dc[component];

1263 
s>last_dc[component] = val; 
1264 
block[0] = val;

1265 
/* AC coefs */

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

1267 
i = 1;

1268 
for(;;) {

1269 
code = get_vlc2(&s>gb, s>vlcs[1][ac_index].table, 9, 2); 
1270  
1271 
if (code < 0) { 
1272 
dprintf("error ac\n");

1273 
return 1; 
1274 
} 
1275 
/* EOB */

1276 
if (code == 0) 
1277 
break;

1278 
if (code == 0xf0) { 
1279 
i += 16;

1280 
} else {

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

1282 
i += code >> 4;

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

1285 
return 1; 
1286 
} 
1287 
j = s>scantable.permutated[i]; 
1288 
block[j] = level * quant_matrix[j]; 
1289 
i++; 
1290 
if (i >= 64) 
1291 
break;

1292 
} 
1293 
} 
1294 
return 0; 
1295 
} 
1296  
1297 
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 
1298 
int i, mb_x, mb_y;

1299 
uint16_t buffer[32768][4]; 
1300 
int left[3], top[3], topleft[3]; 
1301 
const int linesize= s>linesize[0]; 
1302 
const int mask= (1<<s>bits)1; 
1303  
1304 
if((unsigned)s>mb_width > 32768) //dynamic alloc 
1305 
return 1; 
1306  
1307 
for(i=0; i<3; i++){ 
1308 
buffer[0][i]= 1 << (s>bits + point_transform  1); 
1309 
} 
1310 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1311 
const int modified_predictor= mb_y ? predictor : 1; 
1312 
uint8_t *ptr = s>picture.data[0] + (linesize * mb_y);

1313  
1314 
if (s>interlaced && s>bottom_field)

1315 
ptr += linesize >> 1;

1316  
1317 
for(i=0; i<3; i++){ 
1318 
top[i]= left[i]= topleft[i]= buffer[0][i];

1319 
} 
1320 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1321 
if (s>restart_interval && !s>restart_count)

1322 
s>restart_count = s>restart_interval; 
1323  
1324 
for(i=0;i<3;i++) { 
1325 
int pred;

1326  
1327 
topleft[i]= top[i]; 
1328 
top[i]= buffer[mb_x][i]; 
1329  
1330 
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); 
1331  
1332 
left[i]= 
1333 
buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform)); 
1334 
} 
1335  
1336 
if (s>restart_interval && !s>restart_count) {

1337 
align_get_bits(&s>gb); 
1338 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1339 
} 
1340 
} 
1341  
1342 
if(s>rct){

1343 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1344 
ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2]  0x200)>>2); 
1345 
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 
1346 
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 
1347 
} 
1348 
}else if(s>pegasus_rct){ 
1349 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1350 
ptr[4*mb_x+1] = buffer[mb_x][0]  ((buffer[mb_x][1] + buffer[mb_x][2])>>2); 
1351 
ptr[4*mb_x+0] = buffer[mb_x][1] + ptr[4*mb_x+1]; 
1352 
ptr[4*mb_x+2] = buffer[mb_x][2] + ptr[4*mb_x+1]; 
1353 
} 
1354 
}else{

1355 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1356 
ptr[4*mb_x+0] = buffer[mb_x][0]; 
1357 
ptr[4*mb_x+1] = buffer[mb_x][1]; 
1358 
ptr[4*mb_x+2] = buffer[mb_x][2]; 
1359 
} 
1360 
} 
1361 
} 
1362 
return 0; 
1363 
} 
1364  
1365 
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){ 
1366 
int i, mb_x, mb_y;

1367 
const int nb_components=3; 
1368  
1369 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1370 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1371 
if (s>restart_interval && !s>restart_count)

1372 
s>restart_count = s>restart_interval; 
1373  
1374 
if(mb_x==0  mb_y==0  s>interlaced){ 
1375 
for(i=0;i<nb_components;i++) { 
1376 
uint8_t *ptr; 
1377 
int n, h, v, x, y, c, j, linesize;

1378 
n = s>nb_blocks[i]; 
1379 
c = s>comp_index[i]; 
1380 
h = s>h_scount[i]; 
1381 
v = s>v_scount[i]; 
1382 
x = 0;

1383 
y = 0;

1384 
linesize= s>linesize[c]; 
1385  
1386 
for(j=0; j<n; j++) { 
1387 
int pred;

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

1390 
if(y==0 && mb_y==0){ 
1391 
if(x==0 && mb_x==0){ 
1392 
pred= 128 << point_transform;

1393 
}else{

1394 
pred= ptr[1];

1395 
} 
1396 
}else{

1397 
if(x==0 && mb_x==0){ 
1398 
pred= ptr[linesize]; 
1399 
}else{

1400 
PREDICT(pred, ptr[linesize1], ptr[linesize], ptr[1], predictor); 
1401 
} 
1402 
} 
1403  
1404 
if (s>interlaced && s>bottom_field)

1405 
ptr += linesize >> 1;

1406 
*ptr= pred + (mjpeg_decode_dc(s, s>dc_index[i]) << point_transform); 
1407  
1408 
if (++x == h) {

1409 
x = 0;

1410 
y++; 
1411 
} 
1412 
} 
1413 
} 
1414 
}else{

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

1418 
n = s>nb_blocks[i]; 
1419 
c = s>comp_index[i]; 
1420 
h = s>h_scount[i]; 
1421 
v = s>v_scount[i]; 
1422 
x = 0;

1423 
y = 0;

1424 
linesize= s>linesize[c]; 
1425  
1426 
for(j=0; j<n; j++) { 
1427 
int pred;

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

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

1433 
x = 0;

1434 
y++; 
1435 
} 
1436 
} 
1437 
} 
1438 
} 
1439 
if (s>restart_interval && !s>restart_count) {

1440 
align_get_bits(&s>gb); 
1441 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1442 
} 
1443 
} 
1444 
} 
1445 
return 0; 
1446 
} 
1447  
1448 
static int mjpeg_decode_scan(MJpegDecodeContext *s){ 
1449 
int i, mb_x, mb_y;

1450 
const int nb_components=3; 
1451  
1452 
for(mb_y = 0; mb_y < s>mb_height; mb_y++) { 
1453 
for(mb_x = 0; mb_x < s>mb_width; mb_x++) { 
1454 
if (s>restart_interval && !s>restart_count)

1455 
s>restart_count = s>restart_interval; 
1456  
1457 
for(i=0;i<nb_components;i++) { 
1458 
uint8_t *ptr; 
1459 
int n, h, v, x, y, c, j;

1460 
n = s>nb_blocks[i]; 
1461 
c = s>comp_index[i]; 
1462 
h = s>h_scount[i]; 
1463 
v = s>v_scount[i]; 
1464 
x = 0;

1465 
y = 0;

1466 
for(j=0;j<n;j++) { 
1467 
memset(s>block, 0, sizeof(s>block)); 
1468 
if (decode_block(s, s>block, i,

1469 
s>dc_index[i], s>ac_index[i], 
1470 
s>quant_index[c]) < 0) {

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

1472 
return 1; 
1473 
} 
1474 
// dprintf("mb: %d %d processed\n", mb_y, mb_x);

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

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

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

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

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

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

1483 
x = 0;

1484 
y++; 
1485 
} 
1486 
} 
1487 
} 
1488 
/* (< 1350) buggy workaround for Spectralfan.mov, should be fixed */

1489 
if (s>restart_interval && (s>restart_interval < 1350) && 
1490 
!s>restart_count) { 
1491 
align_get_bits(&s>gb); 
1492 
skip_bits(&s>gb, 16); /* skip RSTn */ 
1493 
for (i=0; i<nb_components; i++) /* reset dc */ 
1494 
s>last_dc[i] = 1024;

1495 
} 
1496 
} 
1497 
} 
1498 
return 0; 
1499 
} 
1500  
1501 
static int mjpeg_decode_sos(MJpegDecodeContext *s) 
1502 
{ 
1503 
int len, nb_components, i, h, v, predictor, point_transform;

1504 
int vmax, hmax, index, id;

1505 
const int block_size= s>lossless ? 1 : 8; 
1506 
int ilv;

1507  
1508 
/* XXX: verify len field validity */

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

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

1511 
if (len != 6+2*nb_components) 
1512 
{ 
1513 
dprintf("decode_sos: invalid len (%d)\n", len);

1514 
return 1; 
1515 
} 
1516 
/* XXX: only interleaved scan accepted */

1517 
if ((nb_components != s>nb_components) && !s>ls)

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

1520 
return 1; 
1521 
} 
1522 
vmax = 0;

1523 
hmax = 0;

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

1527 
/* find component index */

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

1530 
break;

1531 
if (index == s>nb_components)

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

1534 
return 1; 
1535 
} 
1536  
1537 
s>comp_index[i] = index; 
1538  
1539 
s>nb_blocks[i] = s>h_count[index] * s>v_count[index]; 
1540 
s>h_scount[i] = s>h_count[index]; 
1541 
s>v_scount[i] = s>v_count[index]; 
1542  
1543 
s>dc_index[i] = get_bits(&s>gb, 4);

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

1545  
1546 
if (s>dc_index[i] < 0  s>ac_index[i] < 0  
1547 
s>dc_index[i] >= 4  s>ac_index[i] >= 4) 
1548 
goto out_of_range;

1549 
#if 0 //buggy

1550 
switch(s>start_code)

1551 
{

1552 
case SOF0:

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

1554 
goto out_of_range;

1555 
break;

1556 
case SOF1:

1557 
case SOF2:

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

1559 
goto out_of_range;

1560 
break;

1561 
case SOF3:

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

1563 
goto out_of_range;

1564 
break;

1565 
}

1566 
#endif

1567 
} 
1568  
1569 
predictor= get_bits(&s>gb, 8); /* JPEG Ss / lossless JPEG predictor /JPEGLS NEAR */ 
1570 
ilv= get_bits(&s>gb, 8); /* JPEG Se / JPEGLS ILV */ 
1571 
skip_bits(&s>gb, 4); /* Ah */ 
1572 
point_transform= get_bits(&s>gb, 4); /* Al */ 
1573  
1574 
for(i=0;i<nb_components;i++) 
1575 
s>last_dc[i] = 1024;

1576  
1577 
if (nb_components > 1) { 
1578 
/* interleaved stream */

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

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

1581 
} else if(!s>ls) { /* skip this for JPEGLS */ 
1582 
h = s>h_max / s>h_scount[s>comp_index[0]];

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

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

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

1586 
s>nb_blocks[0] = 1; 
1587 
s>h_scount[0] = 1; 
1588 
s>v_scount[0] = 1; 
1589 
} 
1590  
1591 
if(s>avctx>debug & FF_DEBUG_PICT_INFO)

1592 
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" : "", 
1593 
predictor, point_transform, ilv, s>bits, 
1594 
s>pegasus_rct ? "PRCT" : (s>rct ? "RCT" : "")); 
1595  
1596  
1597 
/* mjpegb can have padding bytes between sos and image data, skip them */

1598 
for (i = s>mjpb_skiptosod; i > 0; i) 
1599 
skip_bits(&s>gb, 8);

1600  
1601 
if(s>lossless){

1602 
if(s>ls){

1603 
// for(){

1604 
// reset_ls_coding_parameters(s, 0);

1605  
1606 
ls_decode_picture(s, predictor, point_transform, ilv); 
1607 
}else{

1608 
if(s>rgb){

1609 
if(ljpeg_decode_rgb_scan(s, predictor, point_transform) < 0) 
1610 
return 1; 
1611 
}else{

1612 
if(ljpeg_decode_yuv_scan(s, predictor, point_transform) < 0) 
1613 
return 1; 
1614 
} 
1615 
} 
1616 
}else{

1617 
if(mjpeg_decode_scan(s) < 0) 
1618 
return 1; 
1619 
} 
1620 
emms_c(); 
1621 
return 0; 
1622 
out_of_range:

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

1624 
return 1; 
1625 
} 
1626  
1627 
static int mjpeg_decode_dri(MJpegDecodeContext *s) 
1628 
{ 
1629 
if (get_bits(&s>gb, 16) != 4) 
1630 
return 1; 
1631 
s>restart_interval = get_bits(&s>gb, 16);

1632 
s>restart_count = 0;

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

1634  
1635 
return 0; 
1636 
} 
1637  
1638 
static int mjpeg_decode_app(MJpegDecodeContext *s) 
1639 
{ 
1640 
int len, id;

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

1643 
if (len < 5) 
1644 
return 1; 
1645 
if(8*len + get_bits_count(&s>gb) > s>gb.size_in_bits) 
1646 
return 1; 
1647  
1648 
id = (get_bits(&s>gb, 16) << 16)  get_bits(&s>gb, 16); 
1649 
id = be2me_32(id); 
1650 
len = 6;

1651  
1652 
if(s>avctx>debug & FF_DEBUG_STARTCODE){

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

1654 
} 
1655  
1656 
/* buggy AVID, it puts EOI only at every 10th frame */

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

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

1659 
if (id == ff_get_fourcc("AVI1")) 
1660 
{ 
1661 
/* structure:

1662 
4bytes AVI1

1663 
1bytes polarity

1664 
1bytes always zero

1665 
4bytes field_size

1666 
4bytes field_size_less_padding

1667 
*/

1668 
s>buggy_avid = 1;

1669 
// if (s>first_picture)

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

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

1672 
#if 0

1673 
skip_bits(&s>gb, 8);

1674 
skip_bits(&s>gb, 32);

1675 
skip_bits(&s>gb, 32);

1676 
len = 10;

1677 
#endif

1678 
// if (s>interlace_polarity)

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

1680 
goto out;

1681 
} 
1682  
1683 
// len = 2;

1684  
1685 
if (id == ff_get_fourcc("JFIF")) 
1686 
{ 
1687 
int t_w, t_h, v1, v2;

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

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

1691 
skip_bits(&s>gb, 8);

1692  
1693 
s>avctx>sample_aspect_ratio.num= get_bits(&s>gb, 16);

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

1695  
1696 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

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

1698 
v1, v2, 
1699 
s>avctx>sample_aspect_ratio.num, 
1700 
s>avctx>sample_aspect_ratio.den 
1701 
); 
1702  
1703 
t_w = get_bits(&s>gb, 8);

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

1705 
if (t_w && t_h)

1706 
{ 
1707 
/* skip thumbnail */

1708 
if (len10(t_w*t_h*3) > 0) 
1709 
len = t_w*t_h*3;

1710 
} 
1711 
len = 10;

1712 
goto out;

1713 
} 
1714  
1715 
if (id == ff_get_fourcc("Adob") && (get_bits(&s>gb, 8) == 'e')) 
1716 
{ 
1717 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

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

1719 
skip_bits(&s>gb, 16); /* version */ 
1720 
skip_bits(&s>gb, 16); /* flags0 */ 
1721 
skip_bits(&s>gb, 16); /* flags1 */ 
1722 
skip_bits(&s>gb, 8); /* transform */ 
1723 
len = 7;

1724 
goto out;

1725 
} 
1726  
1727 
if (id == ff_get_fourcc("LJIF")){ 
1728 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

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

1730 
skip_bits(&s>gb, 16); /* version ? */ 
1731 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1732 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1733 
skip_bits(&s>gb, 16); /* unknwon always 0? */ 
1734 
switch( get_bits(&s>gb, 8)){ 
1735 
case 1: 
1736 
s>rgb= 1;

1737 
s>pegasus_rct=0;

1738 
break;

1739 
case 2: 
1740 
s>rgb= 1;

1741 
s>pegasus_rct=1;

1742 
break;

1743 
default:

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

1745 
} 
1746 
len = 9;

1747 
goto out;

1748 
} 
1749  
1750 
/* Apple MJPEGA */

1751 
if ((s>start_code == APP1) && (len > (0x28  8))) 
1752 
{ 
1753 
id = (get_bits(&s>gb, 16) << 16)  get_bits(&s>gb, 16); 
1754 
id = be2me_32(id); 
1755 
len = 4;

1756 
if (id == ff_get_fourcc("mjpg")) /* Apple MJPEGA */ 
1757 
{ 
1758 
#if 0

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

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

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

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

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

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

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

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

1767 
#endif

1768 
if (s>avctx>debug & FF_DEBUG_PICT_INFO)

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

1770 
} 
1771 
} 
1772  
1773 
out:

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

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

1777 
while(len > 0) 
1778 
skip_bits(&s>gb, 8);

1779  
1780 
return 0; 
1781 
} 
1782  
1783 
static int mjpeg_decode_com(MJpegDecodeContext *s) 
1784 
{ 
1785 
int len = get_bits(&s>gb, 16); 
1786 
if (len >= 2 && 8*len  16 + get_bits_count(&s>gb) <= s>gb.size_in_bits) { 
1787 
uint8_t *cbuf = av_malloc(len  1);

1788 
if (cbuf) {

1789 
int i;

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

1792 
if (i > 0 && cbuf[i1] == '\n') 
1793 
cbuf[i1] = 0; 
1794 
else

1795 
cbuf[i] = 0;

1796  
1797 
if(s>avctx>debug & FF_DEBUG_PICT_INFO)

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

1799  
1800 
/* buggy avid, it puts EOI only at every 10th frame */

1801 
if (!strcmp(cbuf, "AVID")) 
1802 
{ 
1803 
s>buggy_avid = 1;

1804 
// if (s>first_picture)

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

1806 
} 
1807 
else if(!strcmp(cbuf, "CS=ITU601")){ 
1808 
s>cs_itu601= 1;

1809 
} 
1810  
1811 
av_free(cbuf); 
1812 
} 
1813 
} 
1814  
1815 
return 0; 
1816 
} 
1817  
1818 
#if 0

1819 
static int valid_marker_list[] =

1820 
{

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

1822 
/* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1823 
/* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1824 
/* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1825 
/* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1826 
/* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1827 
/* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1828 
/* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1829 
/* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1830 
/* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1831 
/* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1832 
/* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1833 
/* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1834 
/* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1835 
/* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1836 
/* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1837 
/* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

1838 
}

1839 
#endif

1840  
1841 
/* return the 8 bit start code value and update the search

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

1843 
static int find_marker(uint8_t **pbuf_ptr, uint8_t *buf_end) 
1844 
{ 
1845 
uint8_t *buf_ptr; 
1846 
unsigned int v, v2; 
1847 
int val;

1848 
#ifdef DEBUG

1849 
int skipped=0; 
1850 
#endif

1851  
1852 
buf_ptr = *pbuf_ptr; 
1853 
while (buf_ptr < buf_end) {

1854 
v = *buf_ptr++; 
1855 
v2 = *buf_ptr; 
1856 
if ((v == 0xff) && (v2 >= 0xc0) && (v2 <= 0xfe) && buf_ptr < buf_end) { 
1857 
val = *buf_ptr++; 
1858 
goto found;

1859 
} 
1860 
#ifdef DEBUG

1861 
skipped++; 
1862 
#endif

1863 
} 
1864 
val = 1;

1865 
found:

1866 
#ifdef DEBUG

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

1868 
#endif

1869 
*pbuf_ptr = buf_ptr; 
1870 
return val;

1871 
} 
1872  
1873 
static int mjpeg_decode_frame(AVCodecContext *avctx, 
1874 
void *data, int *data_size, 
1875 
uint8_t *buf, int buf_size)

1876 
{ 
1877 
MJpegDecodeContext *s = avctx>priv_data; 
1878 
uint8_t *buf_end, *buf_ptr; 
1879 
int start_code;

1880 
AVFrame *picture = data; 
1881  
1882 
buf_ptr = buf; 
1883 
buf_end = buf + buf_size; 
1884 
while (buf_ptr < buf_end) {

1885 
/* find start next marker */

1886 
start_code = find_marker(&buf_ptr, buf_end); 
1887 
{ 
1888 
/* EOF */

1889 
if (start_code < 0) { 
1890 
goto the_end;

1891 
} else {

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

1893  
1894 
if ((buf_end  buf_ptr) > s>buffer_size)

1895 
{ 
1896 
av_free(s>buffer); 
1897 
s>buffer_size = buf_endbuf_ptr; 
1898 
s>buffer = av_malloc(s>buffer_size + FF_INPUT_BUFFER_PADDING_SIZE); 
1899 
dprintf("buffer too small, expanding to %d bytes\n",

1900 
s>buffer_size); 
1901 
} 
1902  
1903 
/* unescape buffer of SOS, use special treatment for JPEGLS */

1904 
if (start_code == SOS && !s>ls)

1905 
{ 
1906 
uint8_t *src = buf_ptr; 
1907 
uint8_t *dst = s>buffer; 
1908  
1909 
while (src<buf_end)

1910 
{ 
1911 
uint8_t x = *(src++); 
1912  
1913 
*(dst++) = x; 
1914 
if (x == 0xff) 
1915 
{ 
1916 
while(src<buf_end && x == 0xff) 
1917 
x = *(src++); 
1918  
1919 
if (x >= 0xd0 && x <= 0xd7) 
1920 
*(dst++) = x; 
1921 
else if (x) 
1922 
break;

1923 
} 
1924 
} 
1925 
init_get_bits(&s>gb, s>buffer, (dst  s>buffer)*8);

1926  
1927 
dprintf("escaping removed %d bytes\n",

1928 
(buf_end  buf_ptr)  (dst  s>buffer)); 
1929 
} 
1930 
else if(start_code == SOS && s>ls){ 
1931 
uint8_t *src = buf_ptr; 
1932 
uint8_t *dst = s>buffer; 
1933 
int bit_count = 0; 
1934 
int t = 0, b = 0; 
1935 
PutBitContext pb; 
1936  
1937 
s>cur_scan++; 
1938  
1939 
/* find marker */

1940 
while (src + t < buf_end){

1941 
uint8_t x = src[t++]; 
1942 
if (x == 0xff){ 
1943 
while((src + t < buf_end) && x == 0xff) 
1944 
x = src[t++]; 
1945 
if (x & 0x80) { 
1946 
t = 2;

1947 
break;

1948 
} 
1949 
} 
1950 
} 
1951 
bit_count = t * 8;

1952  
1953 
init_put_bits(&pb, dst, t); 
1954  
1955 
/* unescape bitstream */

1956 
while(b < t){

1957 
uint8_t x = src[b++]; 
1958 
put_bits(&pb, 8, x);

1959 
if(x == 0xFF){ 
1960 
x = src[b++]; 
1961 
put_bits(&pb, 7, x);

1962 
bit_count; 
1963 
} 
1964 
} 
1965 
flush_put_bits(&pb); 
1966  
1967 
init_get_bits(&s>gb, dst, bit_count); 
1968 
} 
1969 
else

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

1971  
1972 
s>start_code = start_code; 
1973 
if(s>avctx>debug & FF_DEBUG_STARTCODE){

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

1975 
} 
1976  
1977 
/* process markers */

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

1981 
} else if (start_code >= APP0 && start_code <= APP15) { 
1982 
mjpeg_decode_app(s); 
1983 
/* Comment */

1984 
} else if (start_code == COM){ 
1985 
mjpeg_decode_com(s); 
1986 
} 
1987  
1988 
switch(start_code) {

1989 
case SOI:

1990 
s>restart_interval = 0;

1991  
1992 
s>restart_count = 0;

1993 
/* nothing to do on SOI */

1994 
break;

1995 
case DQT:

1996 
mjpeg_decode_dqt(s); 
1997 
break;

1998 
case DHT:

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

2001 
return 1; 
2002 
} 
2003 
break;

2004 
case SOF0:

2005 
s>lossless=0;

2006 
if (mjpeg_decode_sof(s) < 0) 
2007 
return 1; 
2008 
break;

2009 
case SOF3:

2010 
s>lossless=1;

2011 
if (mjpeg_decode_sof(s) < 0) 
2012 
return 1; 
2013 
break;

2014 
case SOF48:

2015 
s>lossless=1;

2016 
s>ls=1;

2017 
if (mjpeg_decode_sof(s) < 0) 
2018 
return 1; 
2019 
break;

2020 
case LSE:

2021 
if (decode_lse(s) < 0) 
2022 
return 1; 
2023 
break;

2024 
case EOI:

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

2026 
break;

2027 
eoi_parser:

2028 
{ 
2029 
if (s>interlaced) {

2030 
s>bottom_field ^= 1;

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

2032 
if (s>bottom_field)

2033 
goto not_the_end;

2034 
} 
2035 
*picture = s>picture; 
2036 
*data_size = sizeof(AVFrame);

2037  
2038 
if(!s>lossless){

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

2041 
picture>qscale_table= s>qscale_table; 
2042 
memset(picture>qscale_table, picture>quality, (s>width+15)/16); 
2043 
if(avctx>debug & FF_DEBUG_QP)

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

2045 
picture>quality*= FF_QP2LAMBDA; 
2046 
} 
2047  
2048 
goto the_end;

2049 
} 
2050 
break;

2051 
case SOS:

2052 
mjpeg_decode_sos(s); 
2053 
/* buggy avid puts EOI every 1020th frame */

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

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

2056 
goto eoi_parser;

2057 
break;

2058 
case DRI:

2059 
mjpeg_decode_dri(s); 
2060 
break;

2061 
case SOF1:

2062 
case SOF2:

2063 
case SOF5:

2064 
case SOF6:

2065 
case SOF7:

2066 
case SOF9:

2067 
case SOF10:

2068 
case SOF11:

2069 
case SOF13:

2070 
case SOF14:

2071 
case SOF15:

2072 
case JPG:

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

2074 
break;

2075 
// default:

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

2077 
// break;

2078 
} 
2079  
2080 
not_the_end:

2081 
/* eof process start code */

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

2084 
(get_bits_count(&s>gb)+7)/8, get_bits_count(&s>gb)); 
2085 
} 
2086 
} 
2087 
} 
2088 
the_end:

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

2090 
// return buf_end  buf_ptr;

2091 
return buf_ptr  buf;

2092 
} 
2093  
2094 
static int mjpegb_decode_frame(AVCodecContext *avctx, 
2095 
void *data, int *data_size, 
2096 
uint8_t *buf, int buf_size)

2097 
{ 
2098 
MJpegDecodeContext *s = avctx>priv_data; 
2099 
uint8_t *buf_end, *buf_ptr; 
2100 
AVFrame *picture = data; 
2101 
GetBitContext hgb; /* for the header */

2102 
uint32_t dqt_offs, dht_offs, sof_offs, sos_offs, second_field_offs; 
2103 
uint32_t field_size, sod_offs; 
2104  
2105 
buf_ptr = buf; 
2106 
buf_end = buf + buf_size; 
2107  
2108 
read_header:

2109 
/* reset on every SOI */

2110 
s>restart_interval = 0;

2111 
s>restart_count = 0;

2112 
s>mjpb_skiptosod = 0;

2113  
2114 
init_get_bits(&hgb, buf_ptr, /*buf_size*/(buf_end  buf_ptr)*8); 
2115  
2116 
skip_bits(&hgb, 32); /* reserved zeros */ 
2117  
2118 
if (get_bits_long(&hgb, 32) != be2me_32(ff_get_fourcc("mjpg"))) 
2119 
{ 
2120 
dprintf("not mjpegb (bad fourcc)\n");

2121 
return 0; 
2122 
} 
2123  
2124 
field_size = get_bits_long(&hgb, 32); /* field size */ 
2125 
dprintf("field size: 0x%x\n", field_size);

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

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

2129 
if (second_field_offs)

2130 
s>interlaced = 1;

2131  
2132 
dqt_offs = get_bits_long(&hgb, 32);

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

2134 
if (dqt_offs)

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

2137 
s>start_code = DQT; 
2138 
mjpeg_decode_dqt(s); 
2139 
} 
2140  
2141 
dht_offs = get_bits_long(&hgb, 32);

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

2143 
if (dht_offs)

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

2146 
s>start_code = DHT; 
2147 
mjpeg_decode_dht(s); 
2148 
} 
2149  
2150 
sof_offs = get_bits_long(&hgb, 32);

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

2152 
if (sof_offs)

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

2155 
s>start_code = SOF0; 
2156 
if (mjpeg_decode_sof(s) < 0) 
2157 
return 1; 
2158 
} 
2159  
2160 
sos_offs = get_bits_long(&hgb, 32);

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

2162 
sod_offs = get_bits_long(&hgb, 32);

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

2164 
if (sos_offs)

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

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

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

2169 
s>start_code = SOS; 
2170 
mjpeg_decode_sos(s); 
2171 
} 
2172  
2173 
if (s>interlaced) {

2174 
s>bottom_field ^= 1;

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

2176 
if (s>bottom_field && second_field_offs)

2177 
{ 
2178 
buf_ptr = buf + second_field_offs; 
2179 
second_field_offs = 0;

2180 
goto read_header;

2181 
} 
2182 
} 
2183  
2184 
//XXX FIXME factorize, this looks very similar to the EOI code

2185  
2186 
*picture= s>picture; 
2187 
*data_size = sizeof(AVFrame);

2188  
2189 
if(!s>lossless){

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

2192 
picture>qscale_table= s>qscale_table; 
2193 
memset(picture>qscale_table, picture>quality, (s>width+15)/16); 
2194 
if(avctx>debug & FF_DEBUG_QP)

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

2196 
picture>quality*= FF_QP2LAMBDA; 
2197 
} 
2198  
2199 
return buf_ptr  buf;

2200 
} 
2201  
2202 
#include "sp5x.h" 
2203  
2204 
static int sp5x_decode_frame(AVCodecContext *avctx, 
2205 
void *data, int *data_size, 
2206 
uint8_t *buf, int buf_size)

2207 
{ 
2208 
#if 0

2209 
MJpegDecodeContext *s = avctx>priv_data;

2210 
#endif

2211 
const int qscale = 5; 
2212 
uint8_t *buf_ptr, *buf_end, *recoded; 
2213 
int i = 0, j = 0; 
2214  
2215 
if (!avctx>width  !avctx>height)

2216 
return 1; 
2217  
2218 
buf_ptr = buf; 
2219 
buf_end = buf + buf_size; 
2220  
2221 
#if 1 
2222 
recoded = av_mallocz(buf_size + 1024);

2223 
if (!recoded)

2224 
return 1; 
2225  
2226 
/* SOI */

2227 
recoded[j++] = 0xFF;

2228 
recoded[j++] = 0xD8;

2229  
2230 
memcpy(recoded+j, &sp5x_data_dqt[0], sizeof(sp5x_data_dqt)); 
2231 
memcpy(recoded+j+5, &sp5x_quant_table[qscale * 2], 64); 
2232 
memcpy(recoded+j+70, &sp5x_quant_table[(qscale * 2) + 1], 64); 
2233 
j += sizeof(sp5x_data_dqt);

2234  
2235 
memcpy(recoded+j, &sp5x_data_dht[0], sizeof(sp5x_data_dht)); 
2236 
j += sizeof(sp5x_data_dht);

2237  
2238 
memcpy(recoded+j, &sp5x_data_sof[0], sizeof(sp5x_data_sof)); 
2239 
recoded[j+5] = (avctx>coded_height >> 8) & 0xFF; 
2240 
recoded[j+6] = avctx>coded_height & 0xFF; 
2241 
recoded[j+7] = (avctx>coded_width >> 8) & 0xFF; 
2242 
recoded[j+8] = avctx>coded_width & 0xFF; 
2243 
j += sizeof(sp5x_data_sof);

2244  
2245 
memcpy(recoded+j, &sp5x_data_sos[0], sizeof(sp5x_data_sos)); 
2246 
j += sizeof(sp5x_data_sos);

2247  
2248 
for (i = 14; i < buf_size && j < buf_size+10242; i++) 
2249 
{ 
2250 
recoded[j++] = buf[i]; 
2251 
if (buf[i] == 0xff) 
2252 
recoded[j++] = 0;

2253 
} 
2254  
2255 
/* EOI */

2256 
recoded[j++] = 0xFF;

2257 
recoded[j++] = 0xD9;

2258  
2259 
i = mjpeg_decode_frame(avctx, data, data_size, recoded, j); 
2260  
2261 
av_free(recoded); 
2262  
2263 
#else

2264 
/* SOF */

2265 
s>bits = 8;

2266 
s>width = avctx>coded_width; 
2267 
s>height = avctx>coded_height; 
2268 
s>nb_components = 3;

2269 
s>component_id[0] = 0; 
2270 
s>h_count[0] = 2; 
2271 
s>v_count[0] = 2; 
2272 
s>quant_index[0] = 0; 
2273 
s>component_id[1] = 1; 
2274 
s>h_count[1] = 1; 
2275 
s>v_count[1] = 1; 
2276 
s>quant_index[1] = 1; 
2277 
s>component_id[2] = 2; 
2278 
s>h_count[2] = 1; 
2279 
s>v_count[2] = 1; 
2280 
s>quant_index[2] = 1; 
2281 
s>h_max = 2;

2282 
s>v_max = 2;

2283  
2284 
s>qscale_table = av_mallocz((s>width+15)/16); 
2285 
avctx>pix_fmt = s>cs_itu601 ? PIX_FMT_YUV420P : PIX_FMT_YUVJ420; 
2286 
s>interlaced = 0;

2287  
2288 
s>picture.reference = 0;

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

2292 
return 1; 
2293 
} 
2294  
2295 
s>picture.pict_type = I_TYPE; 
2296 
s>picture.key_frame = 1;

2297  
2298 
for (i = 0; i < 3; i++) 
2299 
s>linesize[i] = s>picture.linesize[i] << s>interlaced; 
2300  
2301 
/* DQT */

2302 
for (i = 0; i < 64; i++) 
2303 
{ 
2304 
j = s>scantable.permutated[i]; 
2305 
s>quant_matrixes[0][j] = sp5x_quant_table[(qscale * 2) + i]; 
2306 
} 
2307 
s>qscale[0] = FFMAX(

2308 
s>quant_matrixes[0][s>scantable.permutated[1]], 
2309 
s>quant_matrixes[0][s>scantable.permutated[8]]) >> 1; 
2310  
2311 
for (i = 0; i < 64; i++) 
2312 
{ 
2313 
j = s>scantable.permutated[i]; 
2314 
s>quant_matrixes[1][j] = sp5x_quant_table[(qscale * 2) + 1 + i]; 
2315 
} 
2316 
s>qscale[1] = FFMAX(

2317 
s>quant_matrixes[1][s>scantable.permutated[1]], 
2318 
s>quant_matrixes[1][s>scantable.permutated[8]]) >> 1; 
2319  
2320 
/* DHT */

2321  
2322 
/* SOS */

2323 
s>comp_index[0] = 0; 
2324 
s>nb_blocks[0] = s>h_count[0] * s>v_count[0]; 
2325 
s>h_scount[0] = s>h_count[0]; 
2326 
s>v_scount[0] = s>v_count[0]; 
2327 
s>dc_index[0] = 0; 
2328 
s>ac_index[0] = 0; 
2329  
2330 
s>comp_index[1] = 1; 
2331 
s>nb_blocks[1] = s>h_count[1] * s>v_count[1]; 
2332 
s>h_scount[1] = s>h_count[1]; 
2333 
s>v_scount[1] = s>v_count[1]; 
2334 
s>dc_index[1] = 1; 
2335 
s>ac_index[1] = 1; 
2336  
2337 
s>comp_index[2] = 2; 
2338 
s>nb_blocks[2] = s>h_count[2] * s>v_count[2]; 
2339 
s>h_scount[2] = s>h_count[2]; 
2340 
s>v_scount[2] = s>v_count[2]; 
2341 
s>dc_index[2] = 1; 
2342 
s>ac_index[2] = 1; 
2343  
2344 
for (i = 0; i < 3; i++) 
2345 
s>last_dc[i] = 1024;

2346  
2347 
s>mb_width = (s>width * s>h_max * 8 1) / (s>h_max * 8); 
2348 
s>mb_height = (s>height * s>v_max * 8 1) / (s>v_max * 8); 
2349  
2350 
init_get_bits(&s>gb, buf+14, (buf_size14)*8); 
2351  
2352 
return mjpeg_decode_scan(s);

2353 
#endif

2354  
2355 
return i;

2356 
} 
2357  
2358 
static int mjpeg_decode_end(AVCodecContext *avctx) 
2359 
{ 
2360 
MJpegDecodeContext *s = avctx>priv_data; 
2361 
int i, j;

2362  
2363 
av_free(s>buffer); 
2364 
av_free(s>qscale_table); 
2365  
2366 
for(i=0;i<2;i++) { 
2367 
for(j=0;j<4;j++) 
2368 
free_vlc(&s>vlcs[i][j]); 
2369 
} 
2370 
return 0; 
2371 
} 
2372  
2373 
AVCodec mjpeg_decoder = { 
2374 
"mjpeg",

2375 
CODEC_TYPE_VIDEO, 
2376 
CODEC_ID_MJPEG, 
2377 
sizeof(MJpegDecodeContext),

2378 
mjpeg_decode_init, 
2379 
NULL,

2380 
mjpeg_decode_end, 
2381 
mjpeg_decode_frame, 
2382 
CODEC_CAP_DR1, 
2383 
NULL

2384 
}; 
2385  
2386 
AVCodec mjpegb_decoder = { 
2387 
"mjpegb",

2388 
CODEC_TYPE_VIDEO, 
2389 
CODEC_ID_MJPEGB, 
2390 
sizeof(MJpegDecodeContext),

2391 
mjpeg_decode_init, 
2392 
NULL,

2393 
mjpeg_decode_end, 
2394 
mjpegb_decode_frame, 
2395 
CODEC_CAP_DR1, 
2396 
NULL

2397 
}; 
2398  
2399 
AVCodec sp5x_decoder = { 
2400 
"sp5x",

2401 
CODEC_TYPE_VIDEO, 
2402 
CODEC_ID_SP5X, 
2403 
sizeof(MJpegDecodeContext),

2404 
mjpeg_decode_init, 
2405 
NULL,

2406 
mjpeg_decode_end, 
2407 
sp5x_decode_frame, 
2408 
CODEC_CAP_DR1, 
2409 
NULL

2410 
}; 
2411  
2412 
#ifdef CONFIG_ENCODERS

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

2414 
"ljpeg",

2415 
CODEC_TYPE_VIDEO, 
2416 
CODEC_ID_LJPEG, 
2417 
sizeof(MpegEncContext),

2418 
MPV_encode_init, 
2419 
encode_picture_lossless, 
2420 
MPV_encode_end, 
2421 
}; 
2422 
#endif

2423  
2424 
AVCodecParser mjpeg_parser = { 
2425 
{ CODEC_ID_MJPEG }, 
2426 
sizeof(ParseContext),

2427 
NULL,

2428 
jpeg_parse, 
2429 
ff_parse_close, 
2430 
}; 
2431 