ffmpeg / libavcodec / mpeg12.c @ d6db1c9c
History  View  Annotate  Download (63.8 KB)
1 
/*


2 
* MPEG1 encoder / MPEG2 decoder

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

4 
*

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

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

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

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

9 
*

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

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

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

13 
* Lesser General Public License for more details.

14 
*

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

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

17 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 021111307 USA

18 
*/

19 
//#define DEBUG

20 
#include "avcodec.h" 
21 
#include "dsputil.h" 
22 
#include "mpegvideo.h" 
23  
24 
#include "mpeg12data.h" 
25  
26 
#if 1 
27 
#define PRINT_QP(a, b) {}

28 
#else

29 
#define PRINT_QP(a, b) printf(a, b)

30 
#endif

31  
32 
/* Start codes. */

33 
#define SEQ_END_CODE 0x000001b7 
34 
#define SEQ_START_CODE 0x000001b3 
35 
#define GOP_START_CODE 0x000001b8 
36 
#define PICTURE_START_CODE 0x00000100 
37 
#define SLICE_MIN_START_CODE 0x00000101 
38 
#define SLICE_MAX_START_CODE 0x000001af 
39 
#define EXT_START_CODE 0x000001b5 
40 
#define USER_START_CODE 0x000001b2 
41  
42 
#define DC_VLC_BITS 9 
43 
#define MV_VLC_BITS 9 
44 
#define MBINCR_VLC_BITS 9 
45 
#define MB_PAT_VLC_BITS 9 
46 
#define MB_PTYPE_VLC_BITS 6 
47 
#define MB_BTYPE_VLC_BITS 6 
48 
#define TEX_VLC_BITS 9 
49  
50 
static void mpeg1_encode_block(MpegEncContext *s, 
51 
DCTELEM *block, 
52 
int component);

53 
static void mpeg1_encode_motion(MpegEncContext *s, int val); 
54 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num); 
55 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
56 
DCTELEM *block, 
57 
int n);

58 
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
59 
DCTELEM *block, 
60 
int n);

61 
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
62 
DCTELEM *block, 
63 
int n);

64 
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
65 
DCTELEM *block, 
66 
int n);

67 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); 
68  
69 
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 
70 
static UINT8 fcode_tab[MAX_MV*2+1]; 
71  
72 
static inline int get_bits_diff(MpegEncContext *s){ 
73 
int bits,ret;

74 

75 
bits= get_bit_count(&s>pb); 
76 
ret= bits  s>last_bits; 
77 
s>last_bits=bits; 
78 

79 
return ret;

80 
} 
81  
82 
static void init_2d_vlc_rl(RLTable *rl) 
83 
{ 
84 
int i;

85 

86 
init_vlc(&rl>vlc, TEX_VLC_BITS, rl>n + 2,

87 
&rl>table_vlc[0][1], 4, 2, 
88 
&rl>table_vlc[0][0], 4, 2); 
89  
90 

91 
rl>rl_vlc[0]= av_malloc(rl>vlc.table_size*sizeof(RL_VLC_ELEM)); 
92 
for(i=0; i<rl>vlc.table_size; i++){ 
93 
int code= rl>vlc.table[i][0]; 
94 
int len = rl>vlc.table[i][1]; 
95 
int level, run;

96 

97 
if(len==0){ // illegal code 
98 
run= 65;

99 
level= MAX_LEVEL; 
100 
}else if(len<0){ //more bits needed 
101 
run= 0;

102 
level= code; 
103 
}else{

104 
if(code==rl>n){ //esc 
105 
run= 65;

106 
level= 0;

107 
}else if(code==rl>n+1){ //eob 
108 
run= 0;

109 
level= 127;

110 
}else{

111 
run= rl>table_run [code] + 1;

112 
level= rl>table_level[code]; 
113 
} 
114 
} 
115 
rl>rl_vlc[0][i].len= len;

116 
rl>rl_vlc[0][i].level= level;

117 
rl>rl_vlc[0][i].run= run;

118 
} 
119 
} 
120  
121  
122 
static void put_header(MpegEncContext *s, int header) 
123 
{ 
124 
align_put_bits(&s>pb); 
125 
put_bits(&s>pb, 16, header>>16); 
126 
put_bits(&s>pb, 16, header&0xFFFF); 
127 
} 
128  
129 
/* put sequence header if needed */

130 
static void mpeg1_encode_sequence_header(MpegEncContext *s) 
131 
{ 
132 
unsigned int vbv_buffer_size; 
133 
unsigned int fps, v; 
134 
int n;

135 
UINT64 time_code; 
136 

137 
if (s>picture_in_gop_number == 0) { 
138 
/* mpeg1 header repeated every gop */

139 
put_header(s, SEQ_START_CODE); 
140 

141 
/* search closest frame rate */

142 
{ 
143 
int i, dmin, d;

144 
s>frame_rate_index = 0;

145 
dmin = 0x7fffffff;

146 
for(i=1;i<9;i++) { 
147 
d = abs(s>frame_rate  frame_rate_tab[i]); 
148 
if (d < dmin) {

149 
dmin = d; 
150 
s>frame_rate_index = i; 
151 
} 
152 
} 
153 
} 
154 

155 
put_bits(&s>pb, 12, s>width);

156 
put_bits(&s>pb, 12, s>height);

157 
put_bits(&s>pb, 4, 1); /* 1/1 aspect ratio */ 
158 
put_bits(&s>pb, 4, s>frame_rate_index);

159 
v = s>bit_rate / 400;

160 
if (v > 0x3ffff) 
161 
v = 0x3ffff;

162 
put_bits(&s>pb, 18, v);

163 
put_bits(&s>pb, 1, 1); /* marker */ 
164  
165 
if(s>avctx>rc_buffer_size)

166 
vbv_buffer_size = s>avctx>rc_buffer_size; 
167 
else

168 
/* VBV calculation: Scaled so that a VCD has the proper VBV size of 40 kilobytes */

169 
vbv_buffer_size = (( 20 * s>bit_rate) / (1151929 / 2)) * 8 * 1024; 
170 
put_bits(&s>pb, 10, (vbv_buffer_size + 16383) / 16384); 
171 
put_bits(&s>pb, 1, 1); /* constrained parameter flag */ 
172 
put_bits(&s>pb, 1, 0); /* no custom intra matrix */ 
173 
put_bits(&s>pb, 1, 0); /* no custom non intra matrix */ 
174  
175 
put_header(s, GOP_START_CODE); 
176 
put_bits(&s>pb, 1, 0); /* do drop frame */ 
177 
/* time code : we must convert from the real frame rate to a

178 
fake mpeg frame rate in case of low frame rate */

179 
fps = frame_rate_tab[s>frame_rate_index]; 
180 
time_code = (INT64)s>fake_picture_number * FRAME_RATE_BASE; 
181 
s>gop_picture_number = s>fake_picture_number; 
182 
put_bits(&s>pb, 5, (UINT32)((time_code / (fps * 3600)) % 24)); 
183 
put_bits(&s>pb, 6, (UINT32)((time_code / (fps * 60)) % 60)); 
184 
put_bits(&s>pb, 1, 1); 
185 
put_bits(&s>pb, 6, (UINT32)((time_code / fps) % 60)); 
186 
put_bits(&s>pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));

187 
put_bits(&s>pb, 1, 1); /* closed gop */ 
188 
put_bits(&s>pb, 1, 0); /* broken link */ 
189 
} 
190  
191 
if (s>frame_rate < (24 * FRAME_RATE_BASE) && s>picture_number > 0) { 
192 
/* insert empty P pictures to slow down to the desired

193 
frame rate. Each fake pictures takes about 20 bytes */

194 
fps = frame_rate_tab[s>frame_rate_index]; 
195 
n = (((INT64)s>picture_number * fps) / s>frame_rate)  1;

196 
while (s>fake_picture_number < n) {

197 
mpeg1_skip_picture(s, s>fake_picture_number  
198 
s>gop_picture_number); 
199 
s>fake_picture_number++; 
200 
} 
201  
202 
} 
203 
} 
204  
205  
206 
/* insert a fake P picture */

207 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num) 
208 
{ 
209 
unsigned int mb_incr; 
210  
211 
/* mpeg1 picture header */

212 
put_header(s, PICTURE_START_CODE); 
213 
/* temporal reference */

214 
put_bits(&s>pb, 10, pict_num & 0x3ff); 
215 

216 
put_bits(&s>pb, 3, P_TYPE);

217 
put_bits(&s>pb, 16, 0xffff); /* non constant bit rate */ 
218 

219 
put_bits(&s>pb, 1, 1); /* integer coordinates */ 
220 
put_bits(&s>pb, 3, 1); /* forward_f_code */ 
221 

222 
put_bits(&s>pb, 1, 0); /* extra bit picture */ 
223 

224 
/* only one slice */

225 
put_header(s, SLICE_MIN_START_CODE); 
226 
put_bits(&s>pb, 5, 1); /* quantizer scale */ 
227 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
228 

229 
mb_incr = 1;

230 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
231 
mbAddrIncrTable[mb_incr  1][0]); 
232 

233 
/* empty macroblock */

234 
put_bits(&s>pb, 3, 1); /* motion only */ 
235 

236 
/* zero motion x & y */

237 
put_bits(&s>pb, 1, 1); 
238 
put_bits(&s>pb, 1, 1); 
239  
240 
/* output a number of empty slice */

241 
mb_incr = s>mb_width * s>mb_height  1;

242 
while (mb_incr > 33) { 
243 
put_bits(&s>pb, 11, 0x008); 
244 
mb_incr = 33;

245 
} 
246 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
247 
mbAddrIncrTable[mb_incr  1][0]); 
248 

249 
/* empty macroblock */

250 
put_bits(&s>pb, 3, 1); /* motion only */ 
251 

252 
/* zero motion x & y */

253 
put_bits(&s>pb, 1, 1); 
254 
put_bits(&s>pb, 1, 1); 
255 
} 
256  
257 
static void common_init(MpegEncContext *s) 
258 
{ 
259 
s>y_dc_scale_table= 
260 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
261 
} 
262  
263 
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) 
264 
{ 
265 
mpeg1_encode_sequence_header(s); 
266  
267 
/* mpeg1 picture header */

268 
put_header(s, PICTURE_START_CODE); 
269 
/* temporal reference */

270 
put_bits(&s>pb, 10, (s>fake_picture_number 

271 
s>gop_picture_number) & 0x3ff);

272 
s>fake_picture_number++; 
273 

274 
put_bits(&s>pb, 3, s>pict_type);

275 
put_bits(&s>pb, 16, 0xffff); /* non constant bit rate */ 
276 

277 
if (s>pict_type == P_TYPE) {

278 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
279 
put_bits(&s>pb, 3, s>f_code); /* forward_f_code */ 
280 
} 
281 

282 
put_bits(&s>pb, 1, 0); /* extra bit picture */ 
283 

284 
/* only one slice */

285 
put_header(s, SLICE_MIN_START_CODE); 
286 
put_bits(&s>pb, 5, s>qscale); /* quantizer scale */ 
287 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
288 
} 
289  
290 
void mpeg1_encode_mb(MpegEncContext *s,

291 
DCTELEM block[6][64], 
292 
int motion_x, int motion_y) 
293 
{ 
294 
int mb_incr, i, cbp, mb_x, mb_y;

295  
296 
mb_x = s>mb_x; 
297 
mb_y = s>mb_y; 
298  
299 
/* compute cbp */

300 
cbp = 0;

301 
for(i=0;i<6;i++) { 
302 
if (s>block_last_index[i] >= 0) 
303 
cbp = 1 << (5  i); 
304 
} 
305  
306 
/* skip macroblock, except if first or last macroblock of a slice */

307 
if ((cbp  motion_x  motion_y) == 0 && 
308 
(!((mb_x  mb_y) == 0 

309 
(mb_x == s>mb_width  1 && mb_y == s>mb_height  1)))) { 
310 
s>mb_incr++; 
311 
s>qscale = s>dquant; 
312 
s>skip_count++; 
313 
s>misc_bits++; 
314 
s>last_bits++; 
315 
} else {

316 
/* output mb incr */

317 
mb_incr = s>mb_incr; 
318  
319 
while (mb_incr > 33) { 
320 
put_bits(&s>pb, 11, 0x008); 
321 
mb_incr = 33;

322 
} 
323 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
324 
mbAddrIncrTable[mb_incr  1][0]); 
325 

326 
if (s>pict_type == I_TYPE) {

327 
if(s>dquant && cbp){

328 
put_bits(&s>pb, 2, 1); /* macroblock_type : macroblock_quant = 1 */ 
329 
put_bits(&s>pb, 5, s>qscale);

330 
}else{

331 
put_bits(&s>pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */ 
332 
s>qscale = s>dquant; 
333 
} 
334 
s>misc_bits+= get_bits_diff(s); 
335 
s>i_count++; 
336 
} else {

337 
if (s>mb_intra) {

338 
if(s>dquant && cbp){

339 
put_bits(&s>pb, 6, 0x01); 
340 
put_bits(&s>pb, 5, s>qscale);

341 
}else{

342 
put_bits(&s>pb, 5, 0x03); 
343 
s>qscale = s>dquant; 
344 
} 
345 
s>misc_bits+= get_bits_diff(s); 
346 
s>i_count++; 
347 
} else {

348 
if (cbp != 0) { 
349 
if (motion_x == 0 && motion_y == 0) { 
350 
if(s>dquant){

351 
put_bits(&s>pb, 5, 1); /* macroblock_pattern & quant */ 
352 
put_bits(&s>pb, 5, s>qscale);

353 
}else{

354 
put_bits(&s>pb, 2, 1); /* macroblock_pattern only */ 
355 
} 
356 
s>misc_bits+= get_bits_diff(s); 
357 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
358 
} else {

359 
if(s>dquant){

360 
put_bits(&s>pb, 5, 2); /* motion + cbp */ 
361 
put_bits(&s>pb, 5, s>qscale);

362 
}else{

363 
put_bits(&s>pb, 1, 1); /* motion + cbp */ 
364 
} 
365 
s>misc_bits+= get_bits_diff(s); 
366 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0]); 
367 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1]); 
368 
s>mv_bits+= get_bits_diff(s); 
369 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
370 
} 
371 
} else {

372 
put_bits(&s>pb, 3, 1); /* motion only */ 
373 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0]); 
374 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1]); 
375 
s>qscale = s>dquant; 
376 
s>mv_bits+= get_bits_diff(s); 
377 
} 
378 
s>f_count++; 
379 
} 
380 
} 
381 
for(i=0;i<6;i++) { 
382 
if (cbp & (1 << (5  i))) { 
383 
mpeg1_encode_block(s, block[i], i); 
384 
} 
385 
} 
386 
s>mb_incr = 1;

387 
if(s>mb_intra)

388 
s>i_tex_bits+= get_bits_diff(s); 
389 
else

390 
s>p_tex_bits+= get_bits_diff(s); 
391 
} 
392 
s>last_mv[0][0][0] = motion_x; 
393 
s>last_mv[0][0][1] = motion_y; 
394 
} 
395  
396 
static void mpeg1_encode_motion(MpegEncContext *s, int val) 
397 
{ 
398 
int code, bit_size, l, m, bits, range, sign;

399  
400 
if (val == 0) { 
401 
/* zero vector */

402 
code = 0;

403 
put_bits(&s>pb, 
404 
mbMotionVectorTable[0][1], 
405 
mbMotionVectorTable[0][0]); 
406 
} else {

407 
bit_size = s>f_code  1;

408 
range = 1 << bit_size;

409 
/* modulo encoding */

410 
l = 16 * range;

411 
m = 2 * l;

412 
if (val < l) {

413 
val += m; 
414 
} else if (val >= l) { 
415 
val = m; 
416 
} 
417  
418 
if (val >= 0) { 
419 
val; 
420 
code = (val >> bit_size) + 1;

421 
bits = val & (range  1);

422 
sign = 0;

423 
} else {

424 
val = val; 
425 
val; 
426 
code = (val >> bit_size) + 1;

427 
bits = val & (range  1);

428 
sign = 1;

429 
} 
430 
put_bits(&s>pb, 
431 
mbMotionVectorTable[code][1],

432 
mbMotionVectorTable[code][0]);

433 
put_bits(&s>pb, 1, sign);

434 
if (bit_size > 0) { 
435 
put_bits(&s>pb, bit_size, bits); 
436 
} 
437 
} 
438 
} 
439  
440 
void ff_mpeg1_encode_init(MpegEncContext *s)

441 
{ 
442 
static int done=0; 
443  
444 
common_init(s); 
445  
446 
if(!done){

447 
int f_code;

448 
int mv;

449 
int i;

450  
451 
done=1;

452 
init_rl(&rl_mpeg1); 
453 

454 
for(i=0; i<64; i++) 
455 
{ 
456 
mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i]; 
457 
mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i]; 
458 
} 
459  
460 
/* build unified dc encoding tables */

461 
for(i=255; i<256; i++) 
462 
{ 
463 
int adiff, index;

464 
int bits, code;

465 
int diff=i;

466  
467 
adiff = ABS(diff); 
468 
if(diff<0) diff; 
469 
index = vlc_dc_table[adiff]; 
470  
471 
bits= vlc_dc_lum_bits[index] + index; 
472 
code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index)  1)); 
473 
mpeg1_lum_dc_uni[i+255]= bits + (code<<8); 
474 

475 
bits= vlc_dc_chroma_bits[index] + index; 
476 
code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index)  1)); 
477 
mpeg1_chr_dc_uni[i+255]= bits + (code<<8); 
478 
} 
479  
480 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
481 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

482 
int len;

483  
484 
if(mv==0) len= mbMotionVectorTable[0][1]; 
485 
else{

486 
int val, bit_size, range, code;

487  
488 
bit_size = s>f_code  1;

489 
range = 1 << bit_size;

490  
491 
val=mv; 
492 
if (val < 0) 
493 
val = val; 
494 
val; 
495 
code = (val >> bit_size) + 1;

496 
if(code<17){ 
497 
len= mbMotionVectorTable[code][1] + 1 + bit_size; 
498 
}else{

499 
len= mbMotionVectorTable[16][1] + 2 + bit_size; 
500 
} 
501 
} 
502  
503 
mv_penalty[f_code][mv+MAX_MV]= len; 
504 
} 
505 
} 
506 

507  
508 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
509 
for(mv=(8<<f_code); mv<(8<<f_code); mv++){ 
510 
fcode_tab[mv+MAX_MV]= f_code; 
511 
} 
512 
} 
513 
} 
514 
s>mv_penalty= mv_penalty; 
515 
s>fcode_tab= fcode_tab; 
516 
s>min_qcoeff=255;

517 
s>max_qcoeff= 255;

518 
s>intra_quant_bias= 3<<(QUANT_BIAS_SHIFT3); //(a + x*3/8)/x 
519 
s>inter_quant_bias= 0;

520 
} 
521  
522 
static inline void encode_dc(MpegEncContext *s, int diff, int component) 
523 
{ 
524 
if (component == 0) { 
525 
put_bits( 
526 
&s>pb, 
527 
mpeg1_lum_dc_uni[diff+255]&0xFF, 
528 
mpeg1_lum_dc_uni[diff+255]>>8); 
529 
} else {

530 
put_bits( 
531 
&s>pb, 
532 
mpeg1_chr_dc_uni[diff+255]&0xFF, 
533 
mpeg1_chr_dc_uni[diff+255]>>8); 
534 
} 
535 
} 
536  
537 
static void mpeg1_encode_block(MpegEncContext *s, 
538 
DCTELEM *block, 
539 
int n)

540 
{ 
541 
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;

542 
int code, component;

543 
// RLTable *rl = &rl_mpeg1;

544  
545 
last_index = s>block_last_index[n]; 
546  
547 
/* DC coef */

548 
if (s>mb_intra) {

549 
component = (n <= 3 ? 0 : n  4 + 1); 
550 
dc = block[0]; /* overflow is impossible */ 
551 
diff = dc  s>last_dc[component]; 
552 
encode_dc(s, diff, component); 
553 
s>last_dc[component] = dc; 
554 
i = 1;

555 
} else {

556 
/* encode the first coefficient : needs to be done here because

557 
it is handled slightly differently */

558 
level = block[0];

559 
if (abs(level) == 1) { 
560 
code = ((UINT32)level >> 31); /* the sign bit */ 
561 
put_bits(&s>pb, 2, code  0x02); 
562 
i = 1;

563 
} else {

564 
i = 0;

565 
last_non_zero = 1;

566 
goto next_coef;

567 
} 
568 
} 
569  
570 
/* now quantify & encode AC coefs */

571 
last_non_zero = i  1;

572  
573 
for(;i<=last_index;i++) {

574 
j = s>intra_scantable.permutated[i]; 
575 
level = block[j]; 
576 
next_coef:

577 
#if 0

578 
if (level != 0)

579 
dprintf("level[%d]=%d\n", i, level);

580 
#endif

581 
/* encode using VLC */

582 
if (level != 0) { 
583 
run = i  last_non_zero  1;

584 

585 
alevel= level; 
586 
MASK_ABS(sign, alevel) 
587 
sign&=1;

588  
589 
// code = get_rl_index(rl, 0, run, alevel);

590 
if (alevel > mpeg1_max_level[0][run]) 
591 
code= 111; /*rl>n*/ 
592 
else

593 
code= mpeg1_index_run[0][run] + alevel  1; 
594  
595 
if (code < 111 /* rl>n */) { 
596 
/* store the vlc & sign at once */

597 
put_bits(&s>pb, mpeg1_vlc[code][1]+1, (mpeg1_vlc[code][0]<<1) + sign); 
598 
} else {

599 
/* escape seems to be pretty rare <5% so i dont optimize it */

600 
put_bits(&s>pb, mpeg1_vlc[111/*rl>n*/][1], mpeg1_vlc[111/*rl>n*/][0]); 
601 
/* escape: only clip in this case */

602 
put_bits(&s>pb, 6, run);

603 
if (alevel < 128) { 
604 
put_bits(&s>pb, 8, level & 0xff); 
605 
} else {

606 
if (level < 0) { 
607 
put_bits(&s>pb, 16, 0x8001 + level + 255); 
608 
} else {

609 
put_bits(&s>pb, 16, level & 0xffff); 
610 
} 
611 
} 
612 
} 
613 
last_non_zero = i; 
614 
} 
615 
} 
616 
/* end of block */

617 
put_bits(&s>pb, 2, 0x2); 
618 
} 
619  
620 
/******************************************/

621 
/* decoding */

622  
623 
static VLC dc_lum_vlc;

624 
static VLC dc_chroma_vlc;

625 
static VLC mv_vlc;

626 
static VLC mbincr_vlc;

627 
static VLC mb_ptype_vlc;

628 
static VLC mb_btype_vlc;

629 
static VLC mb_pat_vlc;

630  
631 
static void init_vlcs(MpegEncContext *s) 
632 
{ 
633 
static int done = 0; 
634  
635 
if (!done) {

636 
done = 1;

637  
638 
init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,

639 
vlc_dc_lum_bits, 1, 1, 
640 
vlc_dc_lum_code, 2, 2); 
641 
init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12,

642 
vlc_dc_chroma_bits, 1, 1, 
643 
vlc_dc_chroma_code, 2, 2); 
644 
init_vlc(&mv_vlc, MV_VLC_BITS, 17,

645 
&mbMotionVectorTable[0][1], 2, 1, 
646 
&mbMotionVectorTable[0][0], 2, 1); 
647 
init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35,

648 
&mbAddrIncrTable[0][1], 2, 1, 
649 
&mbAddrIncrTable[0][0], 2, 1); 
650 
init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,

651 
&mbPatTable[0][1], 2, 1, 
652 
&mbPatTable[0][0], 2, 1); 
653 

654 
init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32,

655 
&table_mb_ptype[0][1], 2, 1, 
656 
&table_mb_ptype[0][0], 2, 1); 
657 
init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32,

658 
&table_mb_btype[0][1], 2, 1, 
659 
&table_mb_btype[0][0], 2, 1); 
660 
init_rl(&rl_mpeg1); 
661 
init_rl(&rl_mpeg2); 
662  
663 
init_2d_vlc_rl(&rl_mpeg1); 
664 
init_2d_vlc_rl(&rl_mpeg2); 
665 
} 
666 
} 
667  
668 
static inline int get_dmv(MpegEncContext *s) 
669 
{ 
670 
if(get_bits1(&s>gb))

671 
return 1  (get_bits1(&s>gb) << 1); 
672 
else

673 
return 0; 
674 
} 
675  
676 
static inline int get_qscale(MpegEncContext *s) 
677 
{ 
678 
int qscale;

679 
if (s>mpeg2) {

680 
if (s>q_scale_type) {

681 
qscale = non_linear_qscale[get_bits(&s>gb, 5)];

682 
} else {

683 
qscale = get_bits(&s>gb, 5) << 1; 
684 
} 
685 
} else {

686 
/* for mpeg1, we use the generic unquant code */

687 
qscale = get_bits(&s>gb, 5);

688 
} 
689 
return qscale;

690 
} 
691  
692 
/* motion type (for mpeg2) */

693 
#define MT_FIELD 1 
694 
#define MT_FRAME 2 
695 
#define MT_16X8 2 
696 
#define MT_DMV 3 
697  
698 
static int mpeg_decode_mb(MpegEncContext *s, 
699 
DCTELEM block[6][64]) 
700 
{ 
701 
int i, j, k, cbp, val, mb_type, motion_type;

702 

703 
dprintf("decode_mb: x=%d y=%d\n", s>mb_x, s>mb_y);

704  
705 
if (s>mb_incr != 0) { 
706 
/* skip mb */

707 
s>mb_intra = 0;

708 
for(i=0;i<6;i++) 
709 
s>block_last_index[i] = 1;

710 
s>mv_type = MV_TYPE_16X16; 
711 
if (s>pict_type == P_TYPE) {

712 
/* if P type, zero motion vector is implied */

713 
s>mv_dir = MV_DIR_FORWARD; 
714 
s>mv[0][0][0] = s>mv[0][0][1] = 0; 
715 
s>last_mv[0][0][0] = s>last_mv[0][0][1] = 0; 
716 
s>last_mv[0][1][0] = s>last_mv[0][1][1] = 0; 
717 
} else {

718 
/* if B type, reuse previous vectors and directions */

719 
s>mv[0][0][0] = s>last_mv[0][0][0]; 
720 
s>mv[0][0][1] = s>last_mv[0][0][1]; 
721 
s>mv[1][0][0] = s>last_mv[1][0][0]; 
722 
s>mv[1][0][1] = s>last_mv[1][0][1]; 
723 
} 
724 
s>mb_skiped = 1;

725 
return 0; 
726 
} 
727  
728 
switch(s>pict_type) {

729 
default:

730 
case I_TYPE:

731 
if (get_bits1(&s>gb) == 0) { 
732 
if (get_bits1(&s>gb) == 0) 
733 
return 1; 
734 
mb_type = MB_QUANT  MB_INTRA; 
735 
} else {

736 
mb_type = MB_INTRA; 
737 
} 
738 
break;

739 
case P_TYPE:

740 
mb_type = get_vlc2(&s>gb, mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);

741 
if (mb_type < 0){ 
742 
fprintf(stderr, "invalid mb type in P Frame at %d %d\n", s>mb_x, s>mb_y);

743 
return 1; 
744 
} 
745 
break;

746 
case B_TYPE:

747 
mb_type = get_vlc2(&s>gb, mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);

748 
if (mb_type < 0){ 
749 
fprintf(stderr, "invalid mb type in B Frame at %d %d\n", s>mb_x, s>mb_y);

750 
return 1; 
751 
} 
752 
break;

753 
} 
754 
dprintf("mb_type=%x\n", mb_type);

755 
motion_type = 0; /* avoid warning */ 
756 
if (mb_type & (MB_FORMB_BACK)) {

757 
/* get additionnal motion vector type */

758 
if (s>picture_structure == PICT_FRAME && s>frame_pred_frame_dct)

759 
motion_type = MT_FRAME; 
760 
else

761 
motion_type = get_bits(&s>gb, 2);

762 
} 
763 
/* compute dct type */

764 
if (s>picture_structure == PICT_FRAME &&

765 
!s>frame_pred_frame_dct && 
766 
(mb_type & (MB_PAT  MB_INTRA))) { 
767 
s>interlaced_dct = get_bits1(&s>gb); 
768 
#ifdef DEBUG

769 
if (s>interlaced_dct)

770 
printf("interlaced_dct\n");

771 
#endif

772 
} else {

773 
s>interlaced_dct = 0; /* frame based */ 
774 
} 
775  
776 
if (mb_type & MB_QUANT) {

777 
s>qscale = get_qscale(s); 
778 
} 
779 
if (mb_type & MB_INTRA) {

780 
if (s>concealment_motion_vectors) {

781 
/* just parse them */

782 
if (s>picture_structure != PICT_FRAME)

783 
skip_bits1(&s>gb); /* field select */

784 
mpeg_decode_motion(s, s>mpeg_f_code[0][0], 0); 
785 
mpeg_decode_motion(s, s>mpeg_f_code[0][1], 0); 
786 
} 
787 
s>mb_intra = 1;

788 
cbp = 0x3f;

789 
memset(s>last_mv, 0, sizeof(s>last_mv)); /* reset mv prediction */ 
790 
} else {

791 
s>mb_intra = 0;

792 
cbp = 0;

793 
} 
794 
/* special case of implicit zero motion vector */

795 
if (s>pict_type == P_TYPE && !(mb_type & MB_FOR)) {

796 
s>mv_dir = MV_DIR_FORWARD; 
797 
s>mv_type = MV_TYPE_16X16; 
798 
s>last_mv[0][0][0] = 0; 
799 
s>last_mv[0][0][1] = 0; 
800 
s>last_mv[0][1][0] = 0; 
801 
s>last_mv[0][1][1] = 0; 
802 
s>mv[0][0][0] = 0; 
803 
s>mv[0][0][1] = 0; 
804 
} else if (mb_type & (MB_FOR  MB_BACK)) { 
805 
/* motion vectors */

806 
s>mv_dir = 0;

807 
for(i=0;i<2;i++) { 
808 
if (mb_type & (MB_FOR >> i)) {

809 
s>mv_dir = (MV_DIR_FORWARD >> i); 
810 
dprintf("motion_type=%d\n", motion_type);

811 
switch(motion_type) {

812 
case MT_FRAME: /* or MT_16X8 */ 
813 
if (s>picture_structure == PICT_FRAME) {

814 
/* MT_FRAME */

815 
s>mv_type = MV_TYPE_16X16; 
816 
for(k=0;k<2;k++) { 
817 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
818 
s>last_mv[i][0][k]);

819 
s>last_mv[i][0][k] = val;

820 
s>last_mv[i][1][k] = val;

821 
/* full_pel: only for mpeg1 */

822 
if (s>full_pel[i])

823 
val = val << 1;

824 
s>mv[i][0][k] = val;

825 
dprintf("mv%d: %d\n", k, val);

826 
} 
827 
} else {

828 
/* MT_16X8 */

829 
s>mv_type = MV_TYPE_16X8; 
830 
for(j=0;j<2;j++) { 
831 
s>field_select[i][j] = get_bits1(&s>gb); 
832 
for(k=0;k<2;k++) { 
833 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
834 
s>last_mv[i][j][k]); 
835 
s>last_mv[i][j][k] = val; 
836 
s>mv[i][j][k] = val; 
837 
} 
838 
} 
839 
} 
840 
break;

841 
case MT_FIELD:

842 
if (s>picture_structure == PICT_FRAME) {

843 
s>mv_type = MV_TYPE_FIELD; 
844 
for(j=0;j<2;j++) { 
845 
s>field_select[i][j] = get_bits1(&s>gb); 
846 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

847 
s>last_mv[i][j][0]);

848 
s>last_mv[i][j][0] = val;

849 
s>mv[i][j][0] = val;

850 
dprintf("fmx=%d\n", val);

851 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][1],

852 
s>last_mv[i][j][1] >> 1); 
853 
s>last_mv[i][j][1] = val << 1; 
854 
s>mv[i][j][1] = val;

855 
dprintf("fmy=%d\n", val);

856 
} 
857 
} else {

858 
s>mv_type = MV_TYPE_16X16; 
859 
s>field_select[i][0] = get_bits1(&s>gb);

860 
for(k=0;k<2;k++) { 
861 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
862 
s>last_mv[i][0][k]);

863 
s>last_mv[i][0][k] = val;

864 
s>last_mv[i][1][k] = val;

865 
s>mv[i][0][k] = val;

866 
} 
867 
} 
868 
break;

869 
case MT_DMV:

870 
{ 
871 
int dmx, dmy, mx, my, m;

872  
873 
mx = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

874 
s>last_mv[i][0][0]); 
875 
s>last_mv[i][0][0] = mx; 
876 
s>last_mv[i][1][0] = mx; 
877 
dmx = get_dmv(s); 
878 
my = mpeg_decode_motion(s, s>mpeg_f_code[i][1],

879 
s>last_mv[i][0][1] >> 1); 
880 
dmy = get_dmv(s); 
881 
s>mv_type = MV_TYPE_DMV; 
882 
/* XXX: totally broken */

883 
if (s>picture_structure == PICT_FRAME) {

884 
s>last_mv[i][0][1] = my << 1; 
885 
s>last_mv[i][1][1] = my << 1; 
886  
887 
m = s>top_field_first ? 1 : 3; 
888 
/* top > top pred */

889 
s>mv[i][0][0] = mx; 
890 
s>mv[i][0][1] = my << 1; 
891 
s>mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
892 
s>mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy  1; 
893 
m = 4  m;

894 
s>mv[i][2][0] = mx; 
895 
s>mv[i][2][1] = my << 1; 
896 
s>mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
897 
s>mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 
898 
} else {

899 
s>last_mv[i][0][1] = my; 
900 
s>last_mv[i][1][1] = my; 
901 
s>mv[i][0][0] = mx; 
902 
s>mv[i][0][1] = my; 
903 
s>mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx; 
904 
s>mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy  1 
905 
/* + 2 * cur_field */;

906 
} 
907 
} 
908 
break;

909 
} 
910 
} 
911 
} 
912 
} 
913  
914 
if ((mb_type & MB_INTRA) && s>concealment_motion_vectors) {

915 
skip_bits1(&s>gb); /* marker */

916 
} 
917 

918 
if (mb_type & MB_PAT) {

919 
cbp = get_vlc2(&s>gb, mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);

920 
if (cbp < 0){ 
921 
fprintf(stderr, "invalid cbp at %d %d\n", s>mb_x, s>mb_y);

922 
return 1; 
923 
} 
924 
cbp++; 
925 
} 
926 
dprintf("cbp=%x\n", cbp);

927  
928 
if (s>mpeg2) {

929 
if (s>mb_intra) {

930 
for(i=0;i<6;i++) { 
931 
if (mpeg2_decode_block_intra(s, block[i], i) < 0) 
932 
return 1; 
933 
} 
934 
} else {

935 
for(i=0;i<6;i++) { 
936 
if (cbp & 32) { 
937 
if (mpeg2_decode_block_non_intra(s, block[i], i) < 0) 
938 
return 1; 
939 
} else {

940 
s>block_last_index[i] = 1;

941 
} 
942 
cbp+=cbp; 
943 
} 
944 
} 
945 
} else {

946 
if (s>mb_intra) {

947 
for(i=0;i<6;i++) { 
948 
if (mpeg1_decode_block_intra(s, block[i], i) < 0) 
949 
return 1; 
950 
} 
951 
}else{

952 
for(i=0;i<6;i++) { 
953 
if (cbp & 32) { 
954 
if (mpeg1_decode_block_inter(s, block[i], i) < 0) 
955 
return 1; 
956 
} else {

957 
s>block_last_index[i] = 1;

958 
} 
959 
cbp+=cbp; 
960 
} 
961 
} 
962 
} 
963 
return 0; 
964 
} 
965  
966 
/* as h263, but only 17 codes */

967 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) 
968 
{ 
969 
int code, sign, val, m, l, shift;

970  
971 
code = get_vlc2(&s>gb, mv_vlc.table, MV_VLC_BITS, 2);

972 
if (code < 0) { 
973 
return 0xffff; 
974 
} 
975 
if (code == 0) { 
976 
return pred;

977 
} 
978 
sign = get_bits1(&s>gb); 
979 
shift = fcode  1;

980 
val = (code  1) << shift;

981 
if (shift > 0) 
982 
val = get_bits(&s>gb, shift); 
983 
val++; 
984 
if (sign)

985 
val = val; 
986 
val += pred; 
987 

988 
/* modulo decoding */

989 
l = (1 << shift) * 16; 
990 
m = 2 * l;

991 
if (val < l) {

992 
val += m; 
993 
} else if (val >= l) { 
994 
val = m; 
995 
} 
996 
return val;

997 
} 
998  
999 
static inline int decode_dc(MpegEncContext *s, int component) 
1000 
{ 
1001 
int code, diff;

1002  
1003 
if (component == 0) { 
1004 
code = get_vlc2(&s>gb, dc_lum_vlc.table, DC_VLC_BITS, 2);

1005 
} else {

1006 
code = get_vlc2(&s>gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);

1007 
} 
1008 
if (code < 0){ 
1009 
fprintf(stderr, "invalid dc code at %d %d\n", s>mb_x, s>mb_y);

1010 
return 0xffff; 
1011 
} 
1012 
if (code == 0) { 
1013 
diff = 0;

1014 
} else {

1015 
diff = get_bits(&s>gb, code); 
1016 
if ((diff & (1 << (code  1))) == 0) 
1017 
diff = (1 << code)  (diff + 1); 
1018 
} 
1019 
return diff;

1020 
} 
1021  
1022 
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1023 
DCTELEM *block, 
1024 
int n)

1025 
{ 
1026 
int level, dc, diff, i, j, run;

1027 
int component;

1028 
RLTable *rl = &rl_mpeg1; 
1029 
UINT8 * const scantable= s>intra_scantable.permutated;

1030 
const UINT16 *quant_matrix= s>intra_matrix;

1031 
const int qscale= s>qscale; 
1032  
1033 
/* DC coef */

1034 
component = (n <= 3 ? 0 : n  4 + 1); 
1035 
diff = decode_dc(s, component); 
1036 
if (diff >= 0xffff) 
1037 
return 1; 
1038 
dc = s>last_dc[component]; 
1039 
dc += diff; 
1040 
s>last_dc[component] = dc; 
1041 
block[0] = dc<<3; 
1042 
dprintf("dc=%d diff=%d\n", dc, diff);

1043 
i = 0;

1044 
{ 
1045 
OPEN_READER(re, &s>gb); 
1046 
/* now quantify & encode AC coefs */

1047 
for(;;) {

1048 
UPDATE_CACHE(re, &s>gb); 
1049 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1050 

1051 
if(level == 127){ 
1052 
break;

1053 
} else if(level != 0) { 
1054 
i += run; 
1055 
j = scantable[i]; 
1056 
level= (level*qscale*quant_matrix[j])>>3;

1057 
level= (level1)1; 
1058 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1059 
LAST_SKIP_BITS(re, &s>gb, 1);

1060 
} else {

1061 
/* escape */

1062 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1063 
UPDATE_CACHE(re, &s>gb); 
1064 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1065 
if (level == 128) { 
1066 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1067 
} else if (level == 0) { 
1068 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1069 
} 
1070 
i += run; 
1071 
j = scantable[i]; 
1072 
if(level<0){ 
1073 
level= level; 
1074 
level= (level*qscale*quant_matrix[j])>>3;

1075 
level= (level1)1; 
1076 
level= level; 
1077 
}else{

1078 
level= (level*qscale*quant_matrix[j])>>3;

1079 
level= (level1)1; 
1080 
} 
1081 
} 
1082 
if (i > 63){ 
1083 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1084 
return 1; 
1085 
} 
1086  
1087 
block[j] = level; 
1088 
} 
1089 
CLOSE_READER(re, &s>gb); 
1090 
} 
1091 
s>block_last_index[n] = i; 
1092 
return 0; 
1093 
} 
1094  
1095 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1096 
DCTELEM *block, 
1097 
int n)

1098 
{ 
1099 
int level, i, j, run;

1100 
RLTable *rl = &rl_mpeg1; 
1101 
UINT8 * const scantable= s>intra_scantable.permutated;

1102 
const UINT16 *quant_matrix= s>inter_matrix;

1103 
const int qscale= s>qscale; 
1104  
1105 
{ 
1106 
int v;

1107 
OPEN_READER(re, &s>gb); 
1108 
i = 1;

1109 
/* special case for the first coef. no need to add a second vlc table */

1110 
UPDATE_CACHE(re, &s>gb); 
1111 
v= SHOW_UBITS(re, &s>gb, 2);

1112 
if (v & 2) { 
1113 
LAST_SKIP_BITS(re, &s>gb, 2);

1114 
level= (3*qscale*quant_matrix[0])>>4; 
1115 
level= (level1)1; 
1116 
if(v&1) 
1117 
level= level; 
1118 
block[0] = level;

1119 
i++; 
1120 
} 
1121  
1122 
/* now quantify & encode AC coefs */

1123 
for(;;) {

1124 
UPDATE_CACHE(re, &s>gb); 
1125 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1126 

1127 
if(level == 127){ 
1128 
break;

1129 
} else if(level != 0) { 
1130 
i += run; 
1131 
j = scantable[i]; 
1132 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1133 
level= (level1)1; 
1134 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1135 
LAST_SKIP_BITS(re, &s>gb, 1);

1136 
} else {

1137 
/* escape */

1138 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1139 
UPDATE_CACHE(re, &s>gb); 
1140 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1141 
if (level == 128) { 
1142 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1143 
} else if (level == 0) { 
1144 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1145 
} 
1146 
i += run; 
1147 
j = scantable[i]; 
1148 
if(level<0){ 
1149 
level= level; 
1150 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1151 
level= (level1)1; 
1152 
level= level; 
1153 
}else{

1154 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1155 
level= (level1)1; 
1156 
} 
1157 
} 
1158 
if (i > 63){ 
1159 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1160 
return 1; 
1161 
} 
1162  
1163 
block[j] = level; 
1164 
} 
1165 
CLOSE_READER(re, &s>gb); 
1166 
} 
1167 
s>block_last_index[n] = i; 
1168 
return 0; 
1169 
} 
1170  
1171 
/* Also does unquantization here, since I will never support mpeg2

1172 
encoding */

1173 
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1174 
DCTELEM *block, 
1175 
int n)

1176 
{ 
1177 
int level, i, j, run;

1178 
RLTable *rl = &rl_mpeg1; 
1179 
UINT8 * const scantable= s>intra_scantable.permutated;

1180 
const UINT16 *quant_matrix;

1181 
const int qscale= s>qscale; 
1182 
int mismatch;

1183  
1184 
mismatch = 1;

1185  
1186 
{ 
1187 
int v;

1188 
OPEN_READER(re, &s>gb); 
1189 
i = 1;

1190 
if (n < 4) 
1191 
quant_matrix = s>inter_matrix; 
1192 
else

1193 
quant_matrix = s>chroma_inter_matrix; 
1194  
1195 
/* special case for the first coef. no need to add a second vlc table */

1196 
UPDATE_CACHE(re, &s>gb); 
1197 
v= SHOW_UBITS(re, &s>gb, 2);

1198 
if (v & 2) { 
1199 
LAST_SKIP_BITS(re, &s>gb, 2);

1200 
level= (3*qscale*quant_matrix[0])>>5; 
1201 
if(v&1) 
1202 
level= level; 
1203 
block[0] = level;

1204 
mismatch ^= level; 
1205 
i++; 
1206 
} 
1207  
1208 
/* now quantify & encode AC coefs */

1209 
for(;;) {

1210 
UPDATE_CACHE(re, &s>gb); 
1211 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1212 

1213 
if(level == 127){ 
1214 
break;

1215 
} else if(level != 0) { 
1216 
i += run; 
1217 
j = scantable[i]; 
1218 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1219 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1220 
LAST_SKIP_BITS(re, &s>gb, 1);

1221 
} else {

1222 
/* escape */

1223 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1224 
UPDATE_CACHE(re, &s>gb); 
1225 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1226  
1227 
i += run; 
1228 
j = scantable[i]; 
1229 
if(level<0){ 
1230 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1231 
level= level; 
1232 
}else{

1233 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1234 
} 
1235 
} 
1236 
if (i > 63){ 
1237 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1238 
return 1; 
1239 
} 
1240 

1241 
mismatch ^= level; 
1242 
block[j] = level; 
1243 
} 
1244 
CLOSE_READER(re, &s>gb); 
1245 
} 
1246 
block[63] ^= (mismatch & 1); 
1247 

1248 
s>block_last_index[n] = i; 
1249 
return 0; 
1250 
} 
1251  
1252 
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1253 
DCTELEM *block, 
1254 
int n)

1255 
{ 
1256 
int level, dc, diff, i, j, run;

1257 
int component;

1258 
RLTable *rl; 
1259 
UINT8 * const scantable= s>intra_scantable.permutated;

1260 
const UINT16 *quant_matrix;

1261 
const int qscale= s>qscale; 
1262 
int mismatch;

1263  
1264 
/* DC coef */

1265 
if (n < 4){ 
1266 
quant_matrix = s>intra_matrix; 
1267 
component = 0;

1268 
}else{

1269 
quant_matrix = s>chroma_intra_matrix; 
1270 
component = n  3;

1271 
} 
1272 
diff = decode_dc(s, component); 
1273 
if (diff >= 0xffff) 
1274 
return 1; 
1275 
dc = s>last_dc[component]; 
1276 
dc += diff; 
1277 
s>last_dc[component] = dc; 
1278 
block[0] = dc << (3  s>intra_dc_precision); 
1279 
dprintf("dc=%d\n", block[0]); 
1280 
mismatch = block[0] ^ 1; 
1281 
i = 0;

1282 
if (s>intra_vlc_format)

1283 
rl = &rl_mpeg2; 
1284 
else

1285 
rl = &rl_mpeg1; 
1286  
1287 
{ 
1288 
OPEN_READER(re, &s>gb); 
1289 
/* now quantify & encode AC coefs */

1290 
for(;;) {

1291 
UPDATE_CACHE(re, &s>gb); 
1292 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1293 

1294 
if(level == 127){ 
1295 
break;

1296 
} else if(level != 0) { 
1297 
i += run; 
1298 
j = scantable[i]; 
1299 
level= (level*qscale*quant_matrix[j])>>4;

1300 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1301 
LAST_SKIP_BITS(re, &s>gb, 1);

1302 
} else {

1303 
/* escape */

1304 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1305 
UPDATE_CACHE(re, &s>gb); 
1306 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1307 
i += run; 
1308 
j = scantable[i]; 
1309 
if(level<0){ 
1310 
level= (level*qscale*quant_matrix[j])>>4;

1311 
level= level; 
1312 
}else{

1313 
level= (level*qscale*quant_matrix[j])>>4;

1314 
} 
1315 
} 
1316 
if (i > 63){ 
1317 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1318 
return 1; 
1319 
} 
1320 

1321 
mismatch^= level; 
1322 
block[j] = level; 
1323 
} 
1324 
CLOSE_READER(re, &s>gb); 
1325 
} 
1326 
block[63]^= mismatch&1; 
1327 

1328 
s>block_last_index[n] = i; 
1329 
return 0; 
1330 
} 
1331  
1332 
/* compressed picture size */

1333 
#define PICTURE_BUFFER_SIZE 100000 
1334  
1335 
typedef struct Mpeg1Context { 
1336 
MpegEncContext mpeg_enc_ctx; 
1337 
UINT32 header_state; 
1338 
int start_code; /* current start code */ 
1339 
UINT8 buffer[PICTURE_BUFFER_SIZE]; 
1340 
UINT8 *buf_ptr; 
1341 
int buffer_size;

1342 
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 
1343 
int repeat_field; /* true if we must repeat the field */ 
1344 
} Mpeg1Context; 
1345  
1346 
static int mpeg_decode_init(AVCodecContext *avctx) 
1347 
{ 
1348 
Mpeg1Context *s = avctx>priv_data; 
1349 

1350 
s>mpeg_enc_ctx.flags= avctx>flags; 
1351 
common_init(&s>mpeg_enc_ctx); 
1352 
init_vlcs(&s>mpeg_enc_ctx); 
1353  
1354 
s>header_state = 0xff;

1355 
s>mpeg_enc_ctx_allocated = 0;

1356 
s>buffer_size = PICTURE_BUFFER_SIZE; 
1357 
s>start_code = 1;

1358 
s>buf_ptr = s>buffer; 
1359 
s>mpeg_enc_ctx.picture_number = 0;

1360 
s>repeat_field = 0;

1361 
s>mpeg_enc_ctx.codec_id= avctx>codec>id; 
1362 
avctx>mbskip_table= s>mpeg_enc_ctx.mbskip_table; 
1363 
return 0; 
1364 
} 
1365  
1366 
/* return the 8 bit start code value and update the search

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

1368 
static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 
1369 
UINT32 *header_state) 
1370 
{ 
1371 
UINT8 *buf_ptr; 
1372 
unsigned int state, v; 
1373 
int val;

1374  
1375 
state = *header_state; 
1376 
buf_ptr = *pbuf_ptr; 
1377 
while (buf_ptr < buf_end) {

1378 
v = *buf_ptr++; 
1379 
if (state == 0x000001) { 
1380 
state = ((state << 8)  v) & 0xffffff; 
1381 
val = state; 
1382 
goto found;

1383 
} 
1384 
state = ((state << 8)  v) & 0xffffff; 
1385 
} 
1386 
val = 1;

1387 
found:

1388 
*pbuf_ptr = buf_ptr; 
1389 
*header_state = state; 
1390 
return val;

1391 
} 
1392  
1393 
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1394 
UINT8 *buf, int buf_size)

1395 
{ 
1396 
Mpeg1Context *s1 = avctx>priv_data; 
1397 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1398 
int ref, f_code;

1399  
1400 
init_get_bits(&s>gb, buf, buf_size); 
1401  
1402 
ref = get_bits(&s>gb, 10); /* temporal ref */ 
1403 
s>pict_type = get_bits(&s>gb, 3);

1404 
dprintf("pict_type=%d number=%d\n", s>pict_type, s>picture_number);

1405 
skip_bits(&s>gb, 16);

1406 
if (s>pict_type == P_TYPE  s>pict_type == B_TYPE) {

1407 
s>full_pel[0] = get_bits1(&s>gb);

1408 
f_code = get_bits(&s>gb, 3);

1409 
if (f_code == 0) 
1410 
return 1; 
1411 
s>mpeg_f_code[0][0] = f_code; 
1412 
s>mpeg_f_code[0][1] = f_code; 
1413 
} 
1414 
if (s>pict_type == B_TYPE) {

1415 
s>full_pel[1] = get_bits1(&s>gb);

1416 
f_code = get_bits(&s>gb, 3);

1417 
if (f_code == 0) 
1418 
return 1; 
1419 
s>mpeg_f_code[1][0] = f_code; 
1420 
s>mpeg_f_code[1][1] = f_code; 
1421 
} 
1422 
s>y_dc_scale = 8;

1423 
s>c_dc_scale = 8;

1424 
s>first_slice = 1;

1425 
return 0; 
1426 
} 
1427  
1428 
static void mpeg_decode_sequence_extension(MpegEncContext *s) 
1429 
{ 
1430 
int horiz_size_ext, vert_size_ext;

1431 
int bit_rate_ext, vbv_buf_ext, low_delay;

1432 
int frame_rate_ext_n, frame_rate_ext_d;

1433  
1434 
skip_bits(&s>gb, 8); /* profil and level */ 
1435 
s>progressive_sequence = get_bits1(&s>gb); /* progressive_sequence */

1436 
skip_bits(&s>gb, 2); /* chroma_format */ 
1437 
horiz_size_ext = get_bits(&s>gb, 2);

1438 
vert_size_ext = get_bits(&s>gb, 2);

1439 
s>width = (horiz_size_ext << 12);

1440 
s>height = (vert_size_ext << 12);

1441 
bit_rate_ext = get_bits(&s>gb, 12); /* XXX: handle it */ 
1442 
s>bit_rate = ((s>bit_rate / 400)  (bit_rate_ext << 12)) * 400; 
1443 
skip_bits1(&s>gb); /* marker */

1444 
vbv_buf_ext = get_bits(&s>gb, 8);

1445 
low_delay = get_bits1(&s>gb); 
1446 
frame_rate_ext_n = get_bits(&s>gb, 2);

1447 
frame_rate_ext_d = get_bits(&s>gb, 5);

1448 
if (frame_rate_ext_d >= 1) 
1449 
s>frame_rate = (s>frame_rate * frame_rate_ext_n) / frame_rate_ext_d; 
1450 
dprintf("sequence extension\n");

1451 
s>mpeg2 = 1;

1452 
s>avctx>sub_id = 2; /* indicates mpeg2 found */ 
1453 
} 
1454  
1455 
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 
1456 
{ 
1457 
int i, v, j;

1458  
1459 
dprintf("matrix extension\n");

1460  
1461 
if (get_bits1(&s>gb)) {

1462 
for(i=0;i<64;i++) { 
1463 
v = get_bits(&s>gb, 8);

1464 
j= s>idct_permutation[ ff_zigzag_direct[i] ]; 
1465 
s>intra_matrix[j] = v; 
1466 
s>chroma_intra_matrix[j] = v; 
1467 
} 
1468 
} 
1469 
if (get_bits1(&s>gb)) {

1470 
for(i=0;i<64;i++) { 
1471 
v = get_bits(&s>gb, 8);

1472 
j= s>idct_permutation[ ff_zigzag_direct[i] ]; 
1473 
s>inter_matrix[j] = v; 
1474 
s>chroma_inter_matrix[j] = v; 
1475 
} 
1476 
} 
1477 
if (get_bits1(&s>gb)) {

1478 
for(i=0;i<64;i++) { 
1479 
v = get_bits(&s>gb, 8);

1480 
j= s>idct_permutation[ ff_zigzag_direct[i] ]; 
1481 
s>chroma_intra_matrix[j] = v; 
1482 
} 
1483 
} 
1484 
if (get_bits1(&s>gb)) {

1485 
for(i=0;i<64;i++) { 
1486 
v = get_bits(&s>gb, 8);

1487 
j= s>idct_permutation[ ff_zigzag_direct[i] ]; 
1488 
s>chroma_inter_matrix[j] = v; 
1489 
} 
1490 
} 
1491 
} 
1492  
1493 
static void mpeg_decode_picture_coding_extension(MpegEncContext *s) 
1494 
{ 
1495 
s>full_pel[0] = s>full_pel[1] = 0; 
1496 
s>mpeg_f_code[0][0] = get_bits(&s>gb, 4); 
1497 
s>mpeg_f_code[0][1] = get_bits(&s>gb, 4); 
1498 
s>mpeg_f_code[1][0] = get_bits(&s>gb, 4); 
1499 
s>mpeg_f_code[1][1] = get_bits(&s>gb, 4); 
1500 
s>intra_dc_precision = get_bits(&s>gb, 2);

1501 
s>picture_structure = get_bits(&s>gb, 2);

1502 
s>top_field_first = get_bits1(&s>gb); 
1503 
s>frame_pred_frame_dct = get_bits1(&s>gb); 
1504 
s>concealment_motion_vectors = get_bits1(&s>gb); 
1505 
s>q_scale_type = get_bits1(&s>gb); 
1506 
s>intra_vlc_format = get_bits1(&s>gb); 
1507 
s>alternate_scan = get_bits1(&s>gb); 
1508 
s>repeat_first_field = get_bits1(&s>gb); 
1509 
s>chroma_420_type = get_bits1(&s>gb); 
1510 
s>progressive_frame = get_bits1(&s>gb); 
1511 

1512 
if(s>alternate_scan){

1513 
ff_init_scantable(s, &s>inter_scantable , ff_alternate_vertical_scan); 
1514 
ff_init_scantable(s, &s>intra_scantable , ff_alternate_vertical_scan); 
1515 
ff_init_scantable(s, &s>intra_h_scantable, ff_alternate_vertical_scan); 
1516 
ff_init_scantable(s, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1517 
}else{

1518 
ff_init_scantable(s, &s>inter_scantable , ff_zigzag_direct); 
1519 
ff_init_scantable(s, &s>intra_scantable , ff_zigzag_direct); 
1520 
ff_init_scantable(s, &s>intra_h_scantable, ff_alternate_horizontal_scan); 
1521 
ff_init_scantable(s, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1522 
} 
1523 

1524 
/* composite display not parsed */

1525 
dprintf("intra_dc_precision=%d\n", s>intra_dc_precision);

1526 
dprintf("picture_structure=%d\n", s>picture_structure);

1527 
dprintf("top field first=%d\n", s>top_field_first);

1528 
dprintf("repeat first field=%d\n", s>repeat_first_field);

1529 
dprintf("conceal=%d\n", s>concealment_motion_vectors);

1530 
dprintf("intra_vlc_format=%d\n", s>intra_vlc_format);

1531 
dprintf("alternate_scan=%d\n", s>alternate_scan);

1532 
dprintf("frame_pred_frame_dct=%d\n", s>frame_pred_frame_dct);

1533 
dprintf("progressive_frame=%d\n", s>progressive_frame);

1534 
} 
1535  
1536 
static void mpeg_decode_extension(AVCodecContext *avctx, 
1537 
UINT8 *buf, int buf_size)

1538 
{ 
1539 
Mpeg1Context *s1 = avctx>priv_data; 
1540 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1541 
int ext_type;

1542  
1543 
init_get_bits(&s>gb, buf, buf_size); 
1544 

1545 
ext_type = get_bits(&s>gb, 4);

1546 
switch(ext_type) {

1547 
case 0x1: 
1548 
/* sequence ext */

1549 
mpeg_decode_sequence_extension(s); 
1550 
break;

1551 
case 0x3: 
1552 
/* quant matrix extension */

1553 
mpeg_decode_quant_matrix_extension(s); 
1554 
break;

1555 
case 0x8: 
1556 
/* picture extension */

1557 
mpeg_decode_picture_coding_extension(s); 
1558 
break;

1559 
} 
1560 
} 
1561  
1562 
/* return 1 if end of frame */

1563 
static int mpeg_decode_slice(AVCodecContext *avctx, 
1564 
AVPicture *pict, 
1565 
int start_code,

1566 
UINT8 *buf, int buf_size)

1567 
{ 
1568 
Mpeg1Context *s1 = avctx>priv_data; 
1569 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1570 
int ret;

1571  
1572 
start_code = (start_code  1) & 0xff; 
1573 
if (start_code >= s>mb_height){

1574 
fprintf(stderr, "slice below image (%d >= %d)\n", start_code, s>mb_height);

1575 
return 1; 
1576 
} 
1577 
s>last_dc[0] = 1 << (7 + s>intra_dc_precision); 
1578 
s>last_dc[1] = s>last_dc[0]; 
1579 
s>last_dc[2] = s>last_dc[0]; 
1580 
memset(s>last_mv, 0, sizeof(s>last_mv)); 
1581 
/* start frame decoding */

1582 
if (s>first_slice) {

1583 
s>first_slice = 0;

1584 
if(MPV_frame_start(s, avctx) < 0) 
1585 
return 1; 
1586 
} 
1587  
1588 
init_get_bits(&s>gb, buf, buf_size); 
1589  
1590 
s>qscale = get_qscale(s); 
1591 
/* extra slice info */

1592 
while (get_bits1(&s>gb) != 0) { 
1593 
skip_bits(&s>gb, 8);

1594 
} 
1595  
1596 
s>mb_x=0;

1597 
for(;;) {

1598 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
1599 
if (code < 0) 
1600 
return 1; /* error = end of slice, but empty slice is bad or?*/ 
1601 
if (code >= 33) { 
1602 
if (code == 33) { 
1603 
s>mb_x += 33;

1604 
} 
1605 
/* otherwise, stuffing, nothing to do */

1606 
} else {

1607 
s>mb_x += code; 
1608 
break;

1609 
} 
1610 
} 
1611 
s>mb_y = start_code; 
1612 
s>mb_incr= 1;

1613  
1614 
for(;;) {

1615 
clear_blocks(s>block[0]);

1616 
emms_c(); 
1617 

1618 
ret = mpeg_decode_mb(s, s>block); 
1619 
dprintf("ret=%d\n", ret);

1620 
if (ret < 0) 
1621 
return 1; 
1622 

1623 
MPV_decode_mb(s, s>block); 
1624  
1625 
if (++s>mb_x >= s>mb_width) {

1626 
if ( avctx>draw_horiz_band

1627 
&& (s>num_available_buffers>=1  (!s>has_b_frames)) ) {

1628 
UINT8 *src_ptr[3];

1629 
int y, h, offset;

1630 
y = s>mb_y * 16;

1631 
h = s>height  y; 
1632 
if (h > 16) 
1633 
h = 16;

1634 
if(s>pict_type==B_TYPE)

1635 
offset = 0;

1636 
else

1637 
offset = y * s>linesize; 
1638 
if(s>pict_type==B_TYPE  (!s>has_b_frames)){

1639 
src_ptr[0] = s>current_picture[0] + offset; 
1640 
src_ptr[1] = s>current_picture[1] + (offset >> 2); 
1641 
src_ptr[2] = s>current_picture[2] + (offset >> 2); 
1642 
} else {

1643 
src_ptr[0] = s>last_picture[0] + offset; 
1644 
src_ptr[1] = s>last_picture[1] + (offset >> 2); 
1645 
src_ptr[2] = s>last_picture[2] + (offset >> 2); 
1646 
} 
1647 
avctx>draw_horiz_band(avctx, src_ptr, s>linesize, 
1648 
y, s>width, h); 
1649 
} 
1650  
1651 
s>mb_x = 0;

1652 
s>mb_y++; 
1653 
PRINT_QP("%s", "\n"); 
1654 
} 
1655 
PRINT_QP("%2d", s>qscale);

1656  
1657 
/* skip mb handling */

1658 
if (s>mb_incr == 0) { 
1659 
/* read again increment */

1660 
s>mb_incr = 1;

1661 
for(;;) {

1662 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
1663 
if (code < 0) 
1664 
goto eos; /* error = end of slice */ 
1665 
if (code >= 33) { 
1666 
if (code == 33) { 
1667 
s>mb_incr += 33;

1668 
} 
1669 
/* otherwise, stuffing, nothing to do */

1670 
} else {

1671 
s>mb_incr += code; 
1672 
break;

1673 
} 
1674 
} 
1675 
} 
1676 
if(s>mb_y >= s>mb_height){

1677 
fprintf(stderr, "slice too long\n");

1678 
return 1; 
1679 
} 
1680 
} 
1681 
eos: //end of slice 
1682 

1683 
emms_c(); 
1684  
1685 
/* end of slice reached */

1686 
if (/*s>mb_x == 0 &&*/ 
1687 
s>mb_y == s>mb_height) { 
1688 
/* end of image */

1689 
UINT8 **picture; 
1690  
1691 
MPV_frame_end(s); 
1692  
1693 
/* XXX: incorrect reported qscale for mpeg2 */

1694 
if (s>pict_type == B_TYPE) {

1695 
picture = s>current_picture; 
1696 
avctx>quality = s>qscale; 
1697 
} else {

1698 
/* latency of 1 frame for I and P frames */

1699 
/* XXX: use another variable than picture_number */

1700 
if (s>picture_number == 0) { 
1701 
picture = NULL;

1702 
} else {

1703 
picture = s>last_picture; 
1704 
avctx>quality = s>last_qscale; 
1705 
} 
1706 
s>last_qscale = s>qscale; 
1707 
s>picture_number++; 
1708 
} 
1709 
if (picture) {

1710 
pict>data[0] = picture[0]; 
1711 
pict>data[1] = picture[1]; 
1712 
pict>data[2] = picture[2]; 
1713 
pict>linesize[0] = s>linesize;

1714 
pict>linesize[1] = s>uvlinesize;

1715 
pict>linesize[2] = s>uvlinesize;

1716 
return 1; 
1717 
} else {

1718 
return 0; 
1719 
} 
1720 
} else {

1721 
return 0; 
1722 
} 
1723 
} 
1724  
1725 
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1726 
UINT8 *buf, int buf_size)

1727 
{ 
1728 
Mpeg1Context *s1 = avctx>priv_data; 
1729 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1730 
int width, height, i, v, j;

1731  
1732 
init_get_bits(&s>gb, buf, buf_size); 
1733  
1734 
width = get_bits(&s>gb, 12);

1735 
height = get_bits(&s>gb, 12);

1736 
skip_bits(&s>gb, 4);

1737 
s>frame_rate_index = get_bits(&s>gb, 4);

1738 
if (s>frame_rate_index == 0) 
1739 
return 1; 
1740 
s>bit_rate = get_bits(&s>gb, 18) * 400; 
1741 
if (get_bits1(&s>gb) == 0) /* marker */ 
1742 
return 1; 
1743 
if (width <= 0  height <= 0  
1744 
(width % 2) != 0  (height % 2) != 0) 
1745 
return 1; 
1746 
if (width != s>width 

1747 
height != s>height) { 
1748 
/* start new mpeg1 context decoding */

1749 
s>out_format = FMT_MPEG1; 
1750 
if (s1>mpeg_enc_ctx_allocated) {

1751 
MPV_common_end(s); 
1752 
} 
1753 
s>width = width; 
1754 
s>height = height; 
1755 
avctx>has_b_frames= s>has_b_frames = 1;

1756 
s>avctx = avctx; 
1757 
avctx>width = width; 
1758 
avctx>height = height; 
1759 
if (s>frame_rate_index >= 9) { 
1760 
/* at least give a valid frame rate (some old mpeg1 have this) */

1761 
avctx>frame_rate = 25 * FRAME_RATE_BASE;

1762 
} else {

1763 
avctx>frame_rate = frame_rate_tab[s>frame_rate_index]; 
1764 
} 
1765 
s>frame_rate = avctx>frame_rate; 
1766 
avctx>bit_rate = s>bit_rate; 
1767 

1768 
if (MPV_common_init(s) < 0) 
1769 
return 1; 
1770 
s1>mpeg_enc_ctx_allocated = 1;

1771 
} 
1772  
1773 
skip_bits(&s>gb, 10); /* vbv_buffer_size */ 
1774 
skip_bits(&s>gb, 1);

1775  
1776 
/* get matrix */

1777 
if (get_bits1(&s>gb)) {

1778 
for(i=0;i<64;i++) { 
1779 
v = get_bits(&s>gb, 8);

1780 
j = s>intra_scantable.permutated[i]; 
1781 
s>intra_matrix[j] = v; 
1782 
s>chroma_intra_matrix[j] = v; 
1783 
} 
1784 
#ifdef DEBUG

1785 
dprintf("intra matrix present\n");

1786 
for(i=0;i<64;i++) 
1787 
dprintf(" %d", s>intra_matrix[s>intra_scantable.permutated[i]]);

1788 
printf("\n");

1789 
#endif

1790 
} else {

1791 
for(i=0;i<64;i++) { 
1792 
int j= s>idct_permutation[i];

1793 
v = ff_mpeg1_default_intra_matrix[i]; 
1794 
s>intra_matrix[j] = v; 
1795 
s>chroma_intra_matrix[j] = v; 
1796 
} 
1797 
} 
1798 
if (get_bits1(&s>gb)) {

1799 
for(i=0;i<64;i++) { 
1800 
v = get_bits(&s>gb, 8);

1801 
j = s>intra_scantable.permutated[i]; 
1802 
s>inter_matrix[j] = v; 
1803 
s>chroma_inter_matrix[j] = v; 
1804 
} 
1805 
#ifdef DEBUG

1806 
dprintf("non intra matrix present\n");

1807 
for(i=0;i<64;i++) 
1808 
dprintf(" %d", s>inter_matrix[s>intra_scantable.permutated[i]]);

1809 
printf("\n");

1810 
#endif

1811 
} else {

1812 
for(i=0;i<64;i++) { 
1813 
int j= s>idct_permutation[i];

1814 
v = ff_mpeg1_default_non_intra_matrix[i]; 
1815 
s>inter_matrix[j] = v; 
1816 
s>chroma_inter_matrix[j] = v; 
1817 
} 
1818 
} 
1819  
1820 
/* we set mpeg2 parameters so that it emulates mpeg1 */

1821 
s>progressive_sequence = 1;

1822 
s>progressive_frame = 1;

1823 
s>picture_structure = PICT_FRAME; 
1824 
s>frame_pred_frame_dct = 1;

1825 
s>mpeg2 = 0;

1826 
avctx>sub_id = 1; /* indicates mpeg1 */ 
1827 
return 0; 
1828 
} 
1829  
1830 
/* handle buffering and image synchronisation */

1831 
static int mpeg_decode_frame(AVCodecContext *avctx, 
1832 
void *data, int *data_size, 
1833 
UINT8 *buf, int buf_size)

1834 
{ 
1835 
Mpeg1Context *s = avctx>priv_data; 
1836 
UINT8 *buf_end, *buf_ptr, *buf_start; 
1837 
int len, start_code_found, ret, code, start_code, input_size;

1838 
AVPicture *picture = data; 
1839 
MpegEncContext *s2 = &s>mpeg_enc_ctx; 
1840 

1841 
dprintf("fill_buffer\n");

1842  
1843 
*data_size = 0;

1844  
1845 
/* special case for last picture */

1846 
if (buf_size == 0) { 
1847 
if (s2>picture_number > 0) { 
1848 
picture>data[0] = s2>next_picture[0]; 
1849 
picture>data[1] = s2>next_picture[1]; 
1850 
picture>data[2] = s2>next_picture[2]; 
1851 
picture>linesize[0] = s2>linesize;

1852 
picture>linesize[1] = s2>uvlinesize;

1853 
picture>linesize[2] = s2>uvlinesize;

1854 
*data_size = sizeof(AVPicture);

1855 
} 
1856 
return 0; 
1857 
} 
1858  
1859 
buf_ptr = buf; 
1860 
buf_end = buf + buf_size; 
1861  
1862 
#if 0

1863 
if (s>repeat_field % 2 == 1) {

1864 
s>repeat_field++;

1865 
//fprintf(stderr,"\nRepeating last frame: %d > %d! pict: %d %d", avctx>frame_number1, avctx>frame_number,

1866 
// s2>picture_number, s>repeat_field);

1867 
if (avctx>flags & CODEC_FLAG_REPEAT_FIELD) {

1868 
*data_size = sizeof(AVPicture);

1869 
goto the_end;

1870 
}

1871 
}

1872 
#endif

1873 
while (buf_ptr < buf_end) {

1874 
buf_start = buf_ptr; 
1875 
/* find start next code */

1876 
code = find_start_code(&buf_ptr, buf_end, &s>header_state); 
1877 
if (code >= 0) { 
1878 
start_code_found = 1;

1879 
} else {

1880 
start_code_found = 0;

1881 
} 
1882 
/* copy to buffer */

1883 
len = buf_ptr  buf_start; 
1884 
if (len + (s>buf_ptr  s>buffer) > s>buffer_size) {

1885 
/* data too big : flush */

1886 
s>buf_ptr = s>buffer; 
1887 
if (start_code_found)

1888 
s>start_code = code; 
1889 
} else {

1890 
memcpy(s>buf_ptr, buf_start, len); 
1891 
s>buf_ptr += len; 
1892 
if( (s2>flags&CODEC_FLAG_NOT_TRUNCATED) && (!start_code_found)

1893 
&& s>buf_ptr+4<s>buffer+s>buffer_size){

1894 
start_code_found= 1;

1895 
code= 0x1FF;

1896 
s>header_state=0xFF;

1897 
s>buf_ptr[0]=0; 
1898 
s>buf_ptr[1]=0; 
1899 
s>buf_ptr[2]=1; 
1900 
s>buf_ptr[3]=0xFF; 
1901 
s>buf_ptr+=4;

1902 
} 
1903 
if (start_code_found) {

1904 
/* prepare data for next start code */

1905 
input_size = s>buf_ptr  s>buffer; 
1906 
start_code = s>start_code; 
1907 
s>buf_ptr = s>buffer; 
1908 
s>start_code = code; 
1909 
switch(start_code) {

1910 
case SEQ_START_CODE:

1911 
mpeg1_decode_sequence(avctx, s>buffer, 
1912 
input_size); 
1913 
break;

1914 

1915 
case PICTURE_START_CODE:

1916 
/* we have a complete image : we try to decompress it */

1917 
mpeg1_decode_picture(avctx, 
1918 
s>buffer, input_size); 
1919 
break;

1920 
case EXT_START_CODE:

1921 
mpeg_decode_extension(avctx, 
1922 
s>buffer, input_size); 
1923 
break;

1924 
default:

1925 
if (start_code >= SLICE_MIN_START_CODE &&

1926 
start_code <= SLICE_MAX_START_CODE) { 
1927 
ret = mpeg_decode_slice(avctx, picture, 
1928 
start_code, s>buffer, input_size); 
1929 
if (ret == 1) { 
1930 
/* got a picture: exit */

1931 
/* first check if we must repeat the frame */

1932 
avctx>repeat_pict = 0;

1933 
#if 0

1934 
if (s2>progressive_frame && s2>repeat_first_field) {

1935 
//fprintf(stderr,"\nRepeat this frame: %d! pict: %d",avctx>frame_number,s2>picture_number);

1936 
//s2>repeat_first_field = 0;

1937 
//s2>progressive_frame = 0;

1938 
if (++s>repeat_field > 2)

1939 
s>repeat_field = 0;

1940 
avctx>repeat_pict = 1;

1941 
}

1942 
#endif

1943 
if (s2>repeat_first_field) {

1944 
if (s2>progressive_sequence) {

1945 
if (s2>top_field_first)

1946 
avctx>repeat_pict = 4;

1947 
else

1948 
avctx>repeat_pict = 2;

1949 
} else if (s2>progressive_frame) { 
1950 
avctx>repeat_pict = 1;

1951 
} 
1952 
} 
1953 
*data_size = sizeof(AVPicture);

1954 
goto the_end;

1955 
}else if(ret==1){ 
1956 
printf("Error while decoding slice\n");

1957 
} 
1958 
} 
1959 
break;

1960 
} 
1961 
} 
1962 
} 
1963 
} 
1964 
the_end:

1965 
return buf_ptr  buf;

1966 
} 
1967  
1968 
static int mpeg_decode_end(AVCodecContext *avctx) 
1969 
{ 
1970 
Mpeg1Context *s = avctx>priv_data; 
1971  
1972 
if (s>mpeg_enc_ctx_allocated)

1973 
MPV_common_end(&s>mpeg_enc_ctx); 
1974 
return 0; 
1975 
} 
1976  
1977 
AVCodec mpeg_decoder = { 
1978 
"mpegvideo",

1979 
CODEC_TYPE_VIDEO, 
1980 
CODEC_ID_MPEG1VIDEO, 
1981 
sizeof(Mpeg1Context),

1982 
mpeg_decode_init, 
1983 
NULL,

1984 
mpeg_decode_end, 
1985 
mpeg_decode_frame, 
1986 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1, 
1987 
}; 