ffmpeg / libavcodec / mpeg12.c @ 8e1652dc
History  View  Annotate  Download (57.5 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 int mpeg1_decode_block(MpegEncContext *s, 
56 
DCTELEM *block, 
57 
int n);

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

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

64 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); 
65  
66 
static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 
67 
static UINT8 fcode_tab[MAX_MV*2+1]; 
68  
69 
static void init_2d_vlc_rl(RLTable *rl) 
70 
{ 
71 
int i;

72 

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

74 
&rl>table_vlc[0][1], 4, 2, 
75 
&rl>table_vlc[0][0], 4, 2); 
76  
77 

78 
rl>rl_vlc[0]= av_malloc(rl>vlc.table_size*sizeof(RL_VLC_ELEM)); 
79 
for(i=0; i<rl>vlc.table_size; i++){ 
80 
int code= rl>vlc.table[i][0]; 
81 
int len = rl>vlc.table[i][1]; 
82 
int level, run;

83 

84 
if(len==0){ // illegal code 
85 
run= 65;

86 
level= MAX_LEVEL; 
87 
}else if(len<0){ //more bits needed 
88 
run= 0;

89 
level= code; 
90 
}else{

91 
if(code==rl>n){ //esc 
92 
run= 65;

93 
level= 0;

94 
}else if(code==rl>n+1){ //eob 
95 
run= 192;

96 
level= 1;

97 
}else{

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

99 
level= rl>table_level[code]; 
100 
} 
101 
} 
102 
rl>rl_vlc[0][i].len= len;

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

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

105 
} 
106 
} 
107  
108  
109 
static void put_header(MpegEncContext *s, int header) 
110 
{ 
111 
align_put_bits(&s>pb); 
112 
put_bits(&s>pb, 16, header>>16); 
113 
put_bits(&s>pb, 16, header&0xFFFF); 
114 
} 
115  
116 
/* put sequence header if needed */

117 
static void mpeg1_encode_sequence_header(MpegEncContext *s) 
118 
{ 
119 
unsigned int vbv_buffer_size; 
120 
unsigned int fps, v; 
121 
int n;

122 
UINT64 time_code; 
123 

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

126 
put_header(s, SEQ_START_CODE); 
127 

128 
/* search closest frame rate */

129 
{ 
130 
int i, dmin, d;

131 
s>frame_rate_index = 0;

132 
dmin = 0x7fffffff;

133 
for(i=1;i<9;i++) { 
134 
d = abs(s>frame_rate  frame_rate_tab[i]); 
135 
if (d < dmin) {

136 
dmin = d; 
137 
s>frame_rate_index = i; 
138 
} 
139 
} 
140 
} 
141 

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

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

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

146 
v = s>bit_rate / 400;

147 
if (v > 0x3ffff) 
148 
v = 0x3ffff;

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

150 
put_bits(&s>pb, 1, 1); /* marker */ 
151  
152 
if(s>avctx>rc_buffer_size)

153 
vbv_buffer_size = s>avctx>rc_buffer_size; 
154 
else

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

156 
vbv_buffer_size = (( 20 * s>bit_rate) / (1151929 / 2)) * 8 * 1024; 
157 
put_bits(&s>pb, 10, (vbv_buffer_size + 16383) / 16384); 
158 
put_bits(&s>pb, 1, 1); /* constrained parameter flag */ 
159 
put_bits(&s>pb, 1, 0); /* no custom intra matrix */ 
160 
put_bits(&s>pb, 1, 0); /* no custom non intra matrix */ 
161  
162 
put_header(s, GOP_START_CODE); 
163 
put_bits(&s>pb, 1, 0); /* do drop frame */ 
164 
/* time code : we must convert from the real frame rate to a

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

166 
fps = frame_rate_tab[s>frame_rate_index]; 
167 
time_code = (INT64)s>fake_picture_number * FRAME_RATE_BASE; 
168 
s>gop_picture_number = s>fake_picture_number; 
169 
put_bits(&s>pb, 5, (UINT32)((time_code / (fps * 3600)) % 24)); 
170 
put_bits(&s>pb, 6, (UINT32)((time_code / (fps * 60)) % 60)); 
171 
put_bits(&s>pb, 1, 1); 
172 
put_bits(&s>pb, 6, (UINT32)((time_code / fps) % 60)); 
173 
put_bits(&s>pb, 6, (UINT32)((time_code % fps) / FRAME_RATE_BASE));

174 
put_bits(&s>pb, 1, 1); /* closed gop */ 
175 
put_bits(&s>pb, 1, 0); /* broken link */ 
176 
} 
177  
178 
if (s>frame_rate < (24 * FRAME_RATE_BASE) && s>picture_number > 0) { 
179 
/* insert empty P pictures to slow down to the desired

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

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

183 
while (s>fake_picture_number < n) {

184 
mpeg1_skip_picture(s, s>fake_picture_number  
185 
s>gop_picture_number); 
186 
s>fake_picture_number++; 
187 
} 
188  
189 
} 
190 
} 
191  
192  
193 
/* insert a fake P picture */

194 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num) 
195 
{ 
196 
unsigned int mb_incr; 
197  
198 
/* mpeg1 picture header */

199 
put_header(s, PICTURE_START_CODE); 
200 
/* temporal reference */

201 
put_bits(&s>pb, 10, pict_num & 0x3ff); 
202 

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

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

206 
put_bits(&s>pb, 1, 1); /* integer coordinates */ 
207 
put_bits(&s>pb, 3, 1); /* forward_f_code */ 
208 

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

211 
/* only one slice */

212 
put_header(s, SLICE_MIN_START_CODE); 
213 
put_bits(&s>pb, 5, 1); /* quantizer scale */ 
214 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
215 

216 
mb_incr = 1;

217 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
218 
mbAddrIncrTable[mb_incr  1][0]); 
219 

220 
/* empty macroblock */

221 
put_bits(&s>pb, 3, 1); /* motion only */ 
222 

223 
/* zero motion x & y */

224 
put_bits(&s>pb, 1, 1); 
225 
put_bits(&s>pb, 1, 1); 
226  
227 
/* output a number of empty slice */

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

229 
while (mb_incr > 33) { 
230 
put_bits(&s>pb, 11, 0x008); 
231 
mb_incr = 33;

232 
} 
233 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
234 
mbAddrIncrTable[mb_incr  1][0]); 
235 

236 
/* empty macroblock */

237 
put_bits(&s>pb, 3, 1); /* motion only */ 
238 

239 
/* zero motion x & y */

240 
put_bits(&s>pb, 1, 1); 
241 
put_bits(&s>pb, 1, 1); 
242 
} 
243  
244 
static void common_init(MpegEncContext *s) 
245 
{ 
246 
s>y_dc_scale_table= 
247 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
248 
} 
249  
250 
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) 
251 
{ 
252 
mpeg1_encode_sequence_header(s); 
253  
254 
/* mpeg1 picture header */

255 
put_header(s, PICTURE_START_CODE); 
256 
/* temporal reference */

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

258 
s>gop_picture_number) & 0x3ff);

259 
s>fake_picture_number++; 
260 

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

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

264 
if (s>pict_type == P_TYPE) {

265 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
266 
put_bits(&s>pb, 3, s>f_code); /* forward_f_code */ 
267 
} 
268 

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

271 
/* only one slice */

272 
put_header(s, SLICE_MIN_START_CODE); 
273 
put_bits(&s>pb, 5, s>qscale); /* quantizer scale */ 
274 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
275 
} 
276  
277 
void mpeg1_encode_mb(MpegEncContext *s,

278 
DCTELEM block[6][64], 
279 
int motion_x, int motion_y) 
280 
{ 
281 
int mb_incr, i, cbp, mb_x, mb_y;

282  
283 
mb_x = s>mb_x; 
284 
mb_y = s>mb_y; 
285  
286 
/* compute cbp */

287 
cbp = 0;

288 
for(i=0;i<6;i++) { 
289 
if (s>block_last_index[i] >= 0) 
290 
cbp = 1 << (5  i); 
291 
} 
292  
293 
/* skip macroblock, except if first or last macroblock of a slice */

294 
if ((cbp  motion_x  motion_y) == 0 && 
295 
(!((mb_x  mb_y) == 0 

296 
(mb_x == s>mb_width  1 && mb_y == s>mb_height  1)))) { 
297 
s>mb_incr++; 
298 
s>qscale = s>dquant; 
299 
} else {

300 
/* output mb incr */

301 
mb_incr = s>mb_incr; 
302  
303 
while (mb_incr > 33) { 
304 
put_bits(&s>pb, 11, 0x008); 
305 
mb_incr = 33;

306 
} 
307 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
308 
mbAddrIncrTable[mb_incr  1][0]); 
309 

310 
if (s>pict_type == I_TYPE) {

311 
if(s>dquant && cbp){

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

314 
}else{

315 
put_bits(&s>pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */ 
316 
s>qscale = s>dquant; 
317 
} 
318 
} else {

319 
if (s>mb_intra) {

320 
if(s>dquant && cbp){

321 
put_bits(&s>pb, 6, 0x01); 
322 
put_bits(&s>pb, 5, s>qscale);

323 
}else{

324 
put_bits(&s>pb, 5, 0x03); 
325 
s>qscale = s>dquant; 
326 
} 
327 
} else {

328 
if (cbp != 0) { 
329 
if (motion_x == 0 && motion_y == 0) { 
330 
if(s>dquant){

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

333 
}else{

334 
put_bits(&s>pb, 2, 1); /* macroblock_pattern only */ 
335 
} 
336 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
337 
} else {

338 
if(s>dquant){

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

341 
}else{

342 
put_bits(&s>pb, 1, 1); /* motion + cbp */ 
343 
} 
344 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0]); 
345 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1]); 
346 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
347 
} 
348 
} else {

349 
put_bits(&s>pb, 3, 1); /* motion only */ 
350 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0]); 
351 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1]); 
352 
s>qscale = s>dquant; 
353 
} 
354 
} 
355 
} 
356 
for(i=0;i<6;i++) { 
357 
if (cbp & (1 << (5  i))) { 
358 
mpeg1_encode_block(s, block[i], i); 
359 
} 
360 
} 
361 
s>mb_incr = 1;

362 
} 
363 
s>last_mv[0][0][0] = motion_x; 
364 
s>last_mv[0][0][1] = motion_y; 
365 
} 
366  
367 
static void mpeg1_encode_motion(MpegEncContext *s, int val) 
368 
{ 
369 
int code, bit_size, l, m, bits, range, sign;

370  
371 
if (val == 0) { 
372 
/* zero vector */

373 
code = 0;

374 
put_bits(&s>pb, 
375 
mbMotionVectorTable[0][1], 
376 
mbMotionVectorTable[0][0]); 
377 
} else {

378 
bit_size = s>f_code  1;

379 
range = 1 << bit_size;

380 
/* modulo encoding */

381 
l = 16 * range;

382 
m = 2 * l;

383 
if (val < l) {

384 
val += m; 
385 
} else if (val >= l) { 
386 
val = m; 
387 
} 
388  
389 
if (val >= 0) { 
390 
val; 
391 
code = (val >> bit_size) + 1;

392 
bits = val & (range  1);

393 
sign = 0;

394 
} else {

395 
val = val; 
396 
val; 
397 
code = (val >> bit_size) + 1;

398 
bits = val & (range  1);

399 
sign = 1;

400 
} 
401 
put_bits(&s>pb, 
402 
mbMotionVectorTable[code][1],

403 
mbMotionVectorTable[code][0]);

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

405 
if (bit_size > 0) { 
406 
put_bits(&s>pb, bit_size, bits); 
407 
} 
408 
} 
409 
} 
410  
411 
void ff_mpeg1_encode_init(MpegEncContext *s)

412 
{ 
413 
static int done=0; 
414  
415 
common_init(s); 
416  
417 
if(!done){

418 
int f_code;

419 
int mv;

420 
int i;

421  
422 
done=1;

423 
init_rl(&rl_mpeg1); 
424 

425 
for(i=0; i<64; i++) 
426 
{ 
427 
mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i]; 
428 
mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i]; 
429 
} 
430  
431 
/* build unified dc encoding tables */

432 
for(i=255; i<256; i++) 
433 
{ 
434 
int adiff, index;

435 
int bits, code;

436 
int diff=i;

437  
438 
adiff = ABS(diff); 
439 
if(diff<0) diff; 
440 
index = vlc_dc_table[adiff]; 
441  
442 
bits= vlc_dc_lum_bits[index] + index; 
443 
code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index)  1)); 
444 
mpeg1_lum_dc_uni[i+255]= bits + (code<<8); 
445 

446 
bits= vlc_dc_chroma_bits[index] + index; 
447 
code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index)  1)); 
448 
mpeg1_chr_dc_uni[i+255]= bits + (code<<8); 
449 
} 
450  
451 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
452 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

453 
int len;

454  
455 
if(mv==0) len= mbMotionVectorTable[0][1]; 
456 
else{

457 
int val, bit_size, range, code;

458  
459 
bit_size = s>f_code  1;

460 
range = 1 << bit_size;

461  
462 
val=mv; 
463 
if (val < 0) 
464 
val = val; 
465 
val; 
466 
code = (val >> bit_size) + 1;

467 
if(code<17){ 
468 
len= mbMotionVectorTable[code][1] + 1 + bit_size; 
469 
}else{

470 
len= mbMotionVectorTable[16][1] + 2 + bit_size; 
471 
} 
472 
} 
473  
474 
mv_penalty[f_code][mv+MAX_MV]= len; 
475 
} 
476 
} 
477 

478  
479 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
480 
for(mv=(8<<f_code); mv<(8<<f_code); mv++){ 
481 
fcode_tab[mv+MAX_MV]= f_code; 
482 
} 
483 
} 
484 
} 
485 
s>mv_penalty= mv_penalty; 
486 
s>fcode_tab= fcode_tab; 
487 
s>min_qcoeff=255;

488 
s>max_qcoeff= 255;

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

491 
} 
492  
493 
static inline void encode_dc(MpegEncContext *s, int diff, int component) 
494 
{ 
495 
if (component == 0) { 
496 
put_bits( 
497 
&s>pb, 
498 
mpeg1_lum_dc_uni[diff+255]&0xFF, 
499 
mpeg1_lum_dc_uni[diff+255]>>8); 
500 
} else {

501 
put_bits( 
502 
&s>pb, 
503 
mpeg1_chr_dc_uni[diff+255]&0xFF, 
504 
mpeg1_chr_dc_uni[diff+255]>>8); 
505 
} 
506 
} 
507  
508 
static void mpeg1_encode_block(MpegEncContext *s, 
509 
DCTELEM *block, 
510 
int n)

511 
{ 
512 
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;

513 
int code, component;

514 
// RLTable *rl = &rl_mpeg1;

515  
516 
last_index = s>block_last_index[n]; 
517  
518 
/* DC coef */

519 
if (s>mb_intra) {

520 
component = (n <= 3 ? 0 : n  4 + 1); 
521 
dc = block[0]; /* overflow is impossible */ 
522 
diff = dc  s>last_dc[component]; 
523 
encode_dc(s, diff, component); 
524 
s>last_dc[component] = dc; 
525 
i = 1;

526 
} else {

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

528 
it is handled slightly differently */

529 
level = block[0];

530 
if (abs(level) == 1) { 
531 
code = ((UINT32)level >> 31); /* the sign bit */ 
532 
put_bits(&s>pb, 2, code  0x02); 
533 
i = 1;

534 
} else {

535 
i = 0;

536 
last_non_zero = 1;

537 
goto next_coef;

538 
} 
539 
} 
540  
541 
/* now quantify & encode AC coefs */

542 
last_non_zero = i  1;

543  
544 
for(;i<=last_index;i++) {

545 
j = s>intra_scantable.permutated[i]; 
546 
level = block[j]; 
547 
next_coef:

548 
#if 0

549 
if (level != 0)

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

551 
#endif

552 
/* encode using VLC */

553 
if (level != 0) { 
554 
run = i  last_non_zero  1;

555 

556 
alevel= level; 
557 
MASK_ABS(sign, alevel) 
558 
sign&=1;

559  
560 
// code = get_rl_index(rl, 0, run, alevel);

561 
if (alevel > mpeg1_max_level[0][run]) 
562 
code= 111; /*rl>n*/ 
563 
else

564 
code= mpeg1_index_run[0][run] + alevel  1; 
565  
566 
if (code < 111 /* rl>n */) { 
567 
/* store the vlc & sign at once */

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

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

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

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

574 
if (alevel < 128) { 
575 
put_bits(&s>pb, 8, level & 0xff); 
576 
} else {

577 
if (level < 0) { 
578 
put_bits(&s>pb, 16, 0x8001 + level + 255); 
579 
} else {

580 
put_bits(&s>pb, 16, level & 0xffff); 
581 
} 
582 
} 
583 
} 
584 
last_non_zero = i; 
585 
} 
586 
} 
587 
/* end of block */

588 
put_bits(&s>pb, 2, 0x2); 
589 
} 
590  
591 
/******************************************/

592 
/* decoding */

593  
594 
static VLC dc_lum_vlc;

595 
static VLC dc_chroma_vlc;

596 
static VLC mv_vlc;

597 
static VLC mbincr_vlc;

598 
static VLC mb_ptype_vlc;

599 
static VLC mb_btype_vlc;

600 
static VLC mb_pat_vlc;

601  
602 
static void init_vlcs(MpegEncContext *s) 
603 
{ 
604 
static int done = 0; 
605  
606 
if (!done) {

607 
done = 1;

608  
609 
init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,

610 
vlc_dc_lum_bits, 1, 1, 
611 
vlc_dc_lum_code, 2, 2); 
612 
init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12,

613 
vlc_dc_chroma_bits, 1, 1, 
614 
vlc_dc_chroma_code, 2, 2); 
615 
init_vlc(&mv_vlc, MV_VLC_BITS, 17,

616 
&mbMotionVectorTable[0][1], 2, 1, 
617 
&mbMotionVectorTable[0][0], 2, 1); 
618 
init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35,

619 
&mbAddrIncrTable[0][1], 2, 1, 
620 
&mbAddrIncrTable[0][0], 2, 1); 
621 
init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,

622 
&mbPatTable[0][1], 2, 1, 
623 
&mbPatTable[0][0], 2, 1); 
624 

625 
init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32,

626 
&table_mb_ptype[0][1], 2, 1, 
627 
&table_mb_ptype[0][0], 2, 1); 
628 
init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32,

629 
&table_mb_btype[0][1], 2, 1, 
630 
&table_mb_btype[0][0], 2, 1); 
631 
init_rl(&rl_mpeg1); 
632 
init_rl(&rl_mpeg2); 
633  
634 
init_2d_vlc_rl(&rl_mpeg1); 
635 
init_2d_vlc_rl(&rl_mpeg2); 
636 
} 
637 
} 
638  
639 
static inline int get_dmv(MpegEncContext *s) 
640 
{ 
641 
if(get_bits1(&s>gb))

642 
return 1  (get_bits1(&s>gb) << 1); 
643 
else

644 
return 0; 
645 
} 
646  
647 
static inline int get_qscale(MpegEncContext *s) 
648 
{ 
649 
int qscale;

650 
if (s>mpeg2) {

651 
if (s>q_scale_type) {

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

653 
} else {

654 
qscale = get_bits(&s>gb, 5) << 1; 
655 
} 
656 
} else {

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

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

659 
} 
660 
return qscale;

661 
} 
662  
663 
/* motion type (for mpeg2) */

664 
#define MT_FIELD 1 
665 
#define MT_FRAME 2 
666 
#define MT_16X8 2 
667 
#define MT_DMV 3 
668  
669 
static int mpeg_decode_mb(MpegEncContext *s, 
670 
DCTELEM block[6][64]) 
671 
{ 
672 
int i, j, k, cbp, val, code, mb_type, motion_type;

673 

674 
/* skip mb handling */

675 
if (s>mb_incr == 0) { 
676 
/* read again increment */

677 
s>mb_incr = 1;

678 
for(;;) {

679 
code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2);

680 
if (code < 0) 
681 
return 1; /* error = end of slice */ 
682 
if (code >= 33) { 
683 
if (code == 33) { 
684 
s>mb_incr += 33;

685 
} 
686 
/* otherwise, stuffing, nothing to do */

687 
} else {

688 
s>mb_incr += code; 
689 
break;

690 
} 
691 
} 
692 
} 
693 
if(s>mb_x==1 /* first MB in a slice */ && s>mb_incr>1){ 
694 
s>mb_x+= (s>mb_incr  1) % s>mb_width;

695 
s>mb_y+= (s>mb_incr  1) / s>mb_width;

696 
s>mb_incr= 1;

697 
} 
698  
699 
if (++s>mb_x >= s>mb_width) {

700 
s>mb_x = 0;

701 
if (s>mb_y >= (s>mb_height  1)){ 
702 
fprintf(stderr, "slice too long\n");

703 
return 1; 
704 
} 
705 
s>mb_y++; 
706 
} 
707 
dprintf("decode_mb: x=%d y=%d\n", s>mb_x, s>mb_y);

708  
709 
if (s>mb_incr != 0) { 
710 
/* skip mb */

711 
s>mb_intra = 0;

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

714 
s>mv_type = MV_TYPE_16X16; 
715 
if (s>pict_type == P_TYPE) {

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

717 
s>mv_dir = MV_DIR_FORWARD; 
718 
s>mv[0][0][0] = s>mv[0][0][1] = 0; 
719 
s>last_mv[0][0][0] = s>last_mv[0][0][1] = 0; 
720 
s>last_mv[0][1][0] = s>last_mv[0][1][1] = 0; 
721 
} else {

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

723 
s>mv[0][0][0] = s>last_mv[0][0][0]; 
724 
s>mv[0][0][1] = s>last_mv[0][0][1]; 
725 
s>mv[1][0][0] = s>last_mv[1][0][0]; 
726 
s>mv[1][0][1] = s>last_mv[1][0][1]; 
727 
} 
728 
s>mb_skiped = 1;

729 
return 0; 
730 
} 
731  
732 
switch(s>pict_type) {

733 
default:

734 
case I_TYPE:

735 
if (get_bits1(&s>gb) == 0) { 
736 
if (get_bits1(&s>gb) == 0) 
737 
return 1; 
738 
mb_type = MB_QUANT  MB_INTRA; 
739 
} else {

740 
mb_type = MB_INTRA; 
741 
} 
742 
break;

743 
case P_TYPE:

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

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

747 
return 1; 
748 
} 
749 
break;

750 
case B_TYPE:

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

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

754 
return 1; 
755 
} 
756 
break;

757 
} 
758 
dprintf("mb_type=%x\n", mb_type);

759 
motion_type = 0; /* avoid warning */ 
760 
if (mb_type & (MB_FORMB_BACK)) {

761 
/* get additionnal motion vector type */

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

763 
motion_type = MT_FRAME; 
764 
else

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

766 
} 
767 
/* compute dct type */

768 
if (s>picture_structure == PICT_FRAME &&

769 
!s>frame_pred_frame_dct && 
770 
(mb_type & (MB_PAT  MB_INTRA))) { 
771 
s>interlaced_dct = get_bits1(&s>gb); 
772 
#ifdef DEBUG

773 
if (s>interlaced_dct)

774 
printf("interlaced_dct\n");

775 
#endif

776 
} else {

777 
s>interlaced_dct = 0; /* frame based */ 
778 
} 
779  
780 
if (mb_type & MB_QUANT) {

781 
s>qscale = get_qscale(s); 
782 
} 
783 
if (mb_type & MB_INTRA) {

784 
if (s>concealment_motion_vectors) {

785 
/* just parse them */

786 
if (s>picture_structure != PICT_FRAME)

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

788 
mpeg_decode_motion(s, s>mpeg_f_code[0][0], 0); 
789 
mpeg_decode_motion(s, s>mpeg_f_code[0][1], 0); 
790 
} 
791 
s>mb_intra = 1;

792 
cbp = 0x3f;

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

795 
s>mb_intra = 0;

796 
cbp = 0;

797 
} 
798 
/* special case of implicit zero motion vector */

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

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

810 
s>mv_dir = 0;

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

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

815 
switch(motion_type) {

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

818 
/* MT_FRAME */

819 
s>mv_type = MV_TYPE_16X16; 
820 
for(k=0;k<2;k++) { 
821 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
822 
s>last_mv[i][0][k]);

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

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

825 
/* full_pel: only for mpeg1 */

826 
if (s>full_pel[i])

827 
val = val << 1;

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

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

830 
} 
831 
} else {

832 
/* MT_16X8 */

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

845 
case MT_FIELD:

846 
if (s>picture_structure == PICT_FRAME) {

847 
s>mv_type = MV_TYPE_FIELD; 
848 
for(j=0;j<2;j++) { 
849 
s>field_select[i][j] = get_bits1(&s>gb); 
850 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

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

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

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

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

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

856 
s>last_mv[i][j][1] >> 1); 
857 
s>last_mv[i][j][1] = val << 1; 
858 
s>mv[i][j][1] = val;

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

860 
} 
861 
} else {

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

864 
for(k=0;k<2;k++) { 
865 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
866 
s>last_mv[i][0][k]);

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

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

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

870 
} 
871 
} 
872 
break;

873 
case MT_DMV:

874 
{ 
875 
int dmx, dmy, mx, my, m;

876  
877 
mx = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

878 
s>last_mv[i][0][0]); 
879 
s>last_mv[i][0][0] = mx; 
880 
s>last_mv[i][1][0] = mx; 
881 
dmx = get_dmv(s); 
882 
my = mpeg_decode_motion(s, s>mpeg_f_code[i][1],

883 
s>last_mv[i][0][1] >> 1); 
884 
dmy = get_dmv(s); 
885 
s>mv_type = MV_TYPE_DMV; 
886 
/* XXX: totally broken */

887 
if (s>picture_structure == PICT_FRAME) {

888 
s>last_mv[i][0][1] = my << 1; 
889 
s>last_mv[i][1][1] = my << 1; 
890  
891 
m = s>top_field_first ? 1 : 3; 
892 
/* top > top pred */

893 
s>mv[i][0][0] = mx; 
894 
s>mv[i][0][1] = my << 1; 
895 
s>mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
896 
s>mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy  1; 
897 
m = 4  m;

898 
s>mv[i][2][0] = mx; 
899 
s>mv[i][2][1] = my << 1; 
900 
s>mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
901 
s>mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 
902 
} else {

903 
s>last_mv[i][0][1] = my; 
904 
s>last_mv[i][1][1] = my; 
905 
s>mv[i][0][0] = mx; 
906 
s>mv[i][0][1] = my; 
907 
s>mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx; 
908 
s>mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy  1 
909 
/* + 2 * cur_field */;

910 
} 
911 
} 
912 
break;

913 
} 
914 
} 
915 
} 
916 
} 
917  
918 
if ((mb_type & MB_INTRA) && s>concealment_motion_vectors) {

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

920 
} 
921 

922 
if (mb_type & MB_PAT) {

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

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

926 
return 1; 
927 
} 
928 
cbp++; 
929 
} 
930 
dprintf("cbp=%x\n", cbp);

931  
932 
if (s>mpeg2) {

933 
if (s>mb_intra) {

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

939 
s>block_last_index[i] = 1;

940 
} 
941 
} 
942 
} else {

943 
for(i=0;i<6;i++) { 
944 
if (cbp & (1 << (5  i))) { 
945 
if (mpeg2_decode_block_non_intra(s, block[i], i) < 0) 
946 
return 1; 
947 
} else {

948 
s>block_last_index[i] = 1;

949 
} 
950 
} 
951 
} 
952 
} else {

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

958 
s>block_last_index[i] = 1;

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

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

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

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

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

979 
val = (code  1) << shift;

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

984 
val = val; 
985 
val += pred; 
986 

987 
/* modulo decoding */

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

990 
if (val < l) {

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

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

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

1004 
} else {

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

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

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

1013 
} else {

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

1019 
} 
1020  
1021 
static int mpeg1_decode_block(MpegEncContext *s, 
1022 
DCTELEM *block, 
1023 
int n)

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

1026 
int code, component;

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

1029  
1030 
if (s>mb_intra) {

1031 
/* DC coef */

1032 
component = (n <= 3 ? 0 : n  4 + 1); 
1033 
diff = decode_dc(s, component); 
1034 
if (diff >= 0xffff) 
1035 
return 1; 
1036 
dc = s>last_dc[component]; 
1037 
dc += diff; 
1038 
s>last_dc[component] = dc; 
1039 
block[0] = dc;

1040 
dprintf("dc=%d diff=%d\n", dc, diff);

1041 
i = 1;

1042 
} else {

1043 
int v;

1044 
OPEN_READER(re, &s>gb); 
1045 
i = 0;

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

1047 
UPDATE_CACHE(re, &s>gb); 
1048 
v= SHOW_UBITS(re, &s>gb, 2);

1049 
if (v & 2) { 
1050 
run = 0;

1051 
level = 1  ((v & 1) << 1); 
1052 
SKIP_BITS(re, &s>gb, 2);

1053 
CLOSE_READER(re, &s>gb); 
1054 
goto add_coef;

1055 
} 
1056 
CLOSE_READER(re, &s>gb); 
1057 
} 
1058  
1059 
/* now quantify & encode AC coefs */

1060 
for(;;) {

1061 
code = get_vlc2(&s>gb, rl>vlc.table, TEX_VLC_BITS, 2);

1062 
if (code < 0) { 
1063 
return 1; 
1064 
} 
1065 
if (code == 112) { 
1066 
break;

1067 
} else if (code == 111) { 
1068 
/* escape */

1069 
run = get_bits(&s>gb, 6);

1070 
level = get_bits(&s>gb, 8);

1071 
level= (level + ((1)<<7)) ^ ((1)<<7); //sign extension 
1072 
if (level == 128) { 
1073 
level = get_bits(&s>gb, 8)  256; 
1074 
} else if (level == 0) { 
1075 
level = get_bits(&s>gb, 8);

1076 
} 
1077 
} else {

1078 
run = rl>table_run[code]; 
1079 
level = rl>table_level[code]; 
1080 
if (get_bits1(&s>gb))

1081 
level = level; 
1082 
} 
1083 
i += run; 
1084 
if (i >= 64) 
1085 
return 1; 
1086 
add_coef:

1087 
dprintf("%d: run=%d level=%d\n", n, run, level);

1088 
j = scantable[i]; 
1089 
block[j] = level; 
1090 
i++; 
1091 
} 
1092 
s>block_last_index[n] = i1;

1093 
return 0; 
1094 
} 
1095  
1096 
/* Also does unquantization here, since I will never support mpeg2

1097 
encoding */

1098 
static int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1099 
DCTELEM *block, 
1100 
int n)

1101 
{ 
1102 
int level, i, j, run;

1103 
int code;

1104 
RLTable *rl = &rl_mpeg1; 
1105 
const UINT8 *scan_table;

1106 
const UINT16 *matrix;

1107 
int mismatch;

1108  
1109 
if (s>alternate_scan)

1110 
scan_table = s>intra_v_scantable.permutated; 
1111 
else

1112 
scan_table = s>intra_scantable.permutated; 
1113 
mismatch = 1;

1114  
1115 
{ 
1116 
int v;

1117 
OPEN_READER(re, &s>gb); 
1118 
i = 0;

1119 
if (n < 4) 
1120 
matrix = s>inter_matrix; 
1121 
else

1122 
matrix = s>chroma_inter_matrix; 
1123  
1124 
/* special case for the first coef. no need to add a second vlc table */

1125 
UPDATE_CACHE(re, &s>gb); 
1126 
v= SHOW_UBITS(re, &s>gb, 2);

1127 
if (v & 2) { 
1128 
run = 0;

1129 
level = 5  (v << 1); 
1130 
SKIP_BITS(re, &s>gb, 2);

1131 
CLOSE_READER(re, &s>gb); 
1132 
goto add_coef;

1133 
} 
1134 
CLOSE_READER(re, &s>gb); 
1135 
} 
1136  
1137 
/* now quantify & encode AC coefs */

1138 
for(;;) {

1139 
code = get_vlc2(&s>gb, rl>vlc.table, TEX_VLC_BITS, 2);

1140 
if (code < 0){ 
1141 
fprintf(stderr, "invalid ac code at %d %d\n", s>mb_x, s>mb_y);

1142 
return 1; 
1143 
} 
1144 
if (code == 112) { 
1145 
break;

1146 
} else if (code == 111) { 
1147 
/* escape */

1148 
run = get_bits(&s>gb, 6);

1149 
level = get_bits(&s>gb, 12);

1150 
level= (level + ((1)<<11)) ^ ((1)<<11); //sign extension 
1151 
} else {

1152 
run = rl>table_run[code]; 
1153 
level = rl>table_level[code]; 
1154 
if (get_bits1(&s>gb))

1155 
level = level; 
1156 
} 
1157 
i += run; 
1158 
if (i >= 64){ 
1159 
fprintf(stderr, "run too long at %d %d\n", s>mb_x, s>mb_y);

1160 
return 1; 
1161 
} 
1162 
add_coef:

1163 
j = scan_table[i]; 
1164 
dprintf("%d: run=%d level=%d\n", n, run, level);

1165 
/* XXX: optimize */

1166 
if (level > 0) { 
1167 
level = ((level * 2 + 1) * s>qscale * matrix[j]) >> 5; 
1168 
} else {

1169 
level = ((level * 2 + 1) * s>qscale * matrix[j]) >> 5; 
1170 
level = level; 
1171 
} 
1172 
/* XXX: is it really necessary to saturate since the encoder

1173 
knows whats going on ? */

1174 
mismatch ^= level; 
1175 
block[j] = level; 
1176 
i++; 
1177 
} 
1178 
block[63] ^= (mismatch & 1); 
1179 
s>block_last_index[n] = i; 
1180  
1181 
return 0; 
1182 
} 
1183  
1184 
static int mpeg2_decode_block_intra(MpegEncContext *s, 
1185 
DCTELEM *block, 
1186 
int n)

1187 
{ 
1188 
int level, dc, diff, i, j, run;

1189 
int code, component;

1190 
RLTable *rl; 
1191 
const UINT8 *scan_table;

1192 
const UINT16 *matrix;

1193 
int mismatch;

1194  
1195 
if (s>alternate_scan)

1196 
scan_table = s>intra_v_scantable.permutated; 
1197 
else

1198 
scan_table = s>intra_scantable.permutated; 
1199  
1200 
/* DC coef */

1201 
component = (n <= 3 ? 0 : n  4 + 1); 
1202 
diff = decode_dc(s, component); 
1203 
if (diff >= 0xffff) 
1204 
return 1; 
1205 
dc = s>last_dc[component]; 
1206 
dc += diff; 
1207 
s>last_dc[component] = dc; 
1208 
block[0] = dc << (3  s>intra_dc_precision); 
1209 
dprintf("dc=%d\n", block[0]); 
1210 
mismatch = block[0] ^ 1; 
1211 
i = 1;

1212 
if (s>intra_vlc_format)

1213 
rl = &rl_mpeg2; 
1214 
else

1215 
rl = &rl_mpeg1; 
1216 
if (n < 4) 
1217 
matrix = s>intra_matrix; 
1218 
else

1219 
matrix = s>chroma_intra_matrix; 
1220  
1221 
/* now quantify & encode AC coefs */

1222 
for(;;) {

1223 
code = get_vlc2(&s>gb, rl>vlc.table, TEX_VLC_BITS, 2);

1224 
if (code < 0){ 
1225 
fprintf(stderr, "invalid ac code at %d %d\n", s>mb_x, s>mb_y);

1226 
return 1; 
1227 
} 
1228 
if (code == 112) { 
1229 
break;

1230 
} else if (code == 111) { 
1231 
/* escape */

1232 
run = get_bits(&s>gb, 6);

1233 
level = get_bits(&s>gb, 12);

1234 
level= (level + ((1)<<11)) ^ ((1)<<11); //sign extension 
1235 
} else {

1236 
run = rl>table_run[code]; 
1237 
level = rl>table_level[code]; 
1238 
if (get_bits1(&s>gb))

1239 
level = level; 
1240 
} 
1241 
i += run; 
1242 
if (i >= 64){ 
1243 
fprintf(stderr, "run too long at %d %d\n", s>mb_x, s>mb_y);

1244 
return 1; 
1245 
} 
1246 
j = scan_table[i]; 
1247 
dprintf("%d: run=%d level=%d\n", n, run, level);

1248 
level = (level * s>qscale * matrix[j]) / 16;

1249 
/* XXX: is it really necessary to saturate since the encoder

1250 
knows whats going on ? */

1251 
mismatch ^= level; 
1252 
block[j] = level; 
1253 
i++; 
1254 
} 
1255 
block[63] ^= (mismatch & 1); 
1256 
s>block_last_index[n] = i; 
1257 
return 0; 
1258 
} 
1259  
1260 
/* compressed picture size */

1261 
#define PICTURE_BUFFER_SIZE 100000 
1262  
1263 
typedef struct Mpeg1Context { 
1264 
MpegEncContext mpeg_enc_ctx; 
1265 
UINT32 header_state; 
1266 
int start_code; /* current start code */ 
1267 
UINT8 buffer[PICTURE_BUFFER_SIZE]; 
1268 
UINT8 *buf_ptr; 
1269 
int buffer_size;

1270 
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 
1271 
int repeat_field; /* true if we must repeat the field */ 
1272 
} Mpeg1Context; 
1273  
1274 
static int mpeg_decode_init(AVCodecContext *avctx) 
1275 
{ 
1276 
Mpeg1Context *s = avctx>priv_data; 
1277 

1278 
s>mpeg_enc_ctx.flags= avctx>flags; 
1279 
common_init(&s>mpeg_enc_ctx); 
1280 
init_vlcs(&s>mpeg_enc_ctx); 
1281  
1282 
s>header_state = 0xff;

1283 
s>mpeg_enc_ctx_allocated = 0;

1284 
s>buffer_size = PICTURE_BUFFER_SIZE; 
1285 
s>start_code = 1;

1286 
s>buf_ptr = s>buffer; 
1287 
s>mpeg_enc_ctx.picture_number = 0;

1288 
s>repeat_field = 0;

1289 
s>mpeg_enc_ctx.codec_id= avctx>codec>id; 
1290 
avctx>mbskip_table= s>mpeg_enc_ctx.mbskip_table; 
1291 
return 0; 
1292 
} 
1293  
1294 
/* return the 8 bit start code value and update the search

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

1296 
static int find_start_code(UINT8 **pbuf_ptr, UINT8 *buf_end, 
1297 
UINT32 *header_state) 
1298 
{ 
1299 
UINT8 *buf_ptr; 
1300 
unsigned int state, v; 
1301 
int val;

1302  
1303 
state = *header_state; 
1304 
buf_ptr = *pbuf_ptr; 
1305 
while (buf_ptr < buf_end) {

1306 
v = *buf_ptr++; 
1307 
if (state == 0x000001) { 
1308 
state = ((state << 8)  v) & 0xffffff; 
1309 
val = state; 
1310 
goto found;

1311 
} 
1312 
state = ((state << 8)  v) & 0xffffff; 
1313 
} 
1314 
val = 1;

1315 
found:

1316 
*pbuf_ptr = buf_ptr; 
1317 
*header_state = state; 
1318 
return val;

1319 
} 
1320  
1321 
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1322 
UINT8 *buf, int buf_size)

1323 
{ 
1324 
Mpeg1Context *s1 = avctx>priv_data; 
1325 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1326 
int ref, f_code;

1327  
1328 
init_get_bits(&s>gb, buf, buf_size); 
1329  
1330 
ref = get_bits(&s>gb, 10); /* temporal ref */ 
1331 
s>pict_type = get_bits(&s>gb, 3);

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

1333 
skip_bits(&s>gb, 16);

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

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

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

1337 
if (f_code == 0) 
1338 
return 1; 
1339 
s>mpeg_f_code[0][0] = f_code; 
1340 
s>mpeg_f_code[0][1] = f_code; 
1341 
} 
1342 
if (s>pict_type == B_TYPE) {

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

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

1345 
if (f_code == 0) 
1346 
return 1; 
1347 
s>mpeg_f_code[1][0] = f_code; 
1348 
s>mpeg_f_code[1][1] = f_code; 
1349 
} 
1350 
s>y_dc_scale = 8;

1351 
s>c_dc_scale = 8;

1352 
s>first_slice = 1;

1353 
return 0; 
1354 
} 
1355  
1356 
static void mpeg_decode_sequence_extension(MpegEncContext *s) 
1357 
{ 
1358 
int horiz_size_ext, vert_size_ext;

1359 
int bit_rate_ext, vbv_buf_ext, low_delay;

1360 
int frame_rate_ext_n, frame_rate_ext_d;

1361  
1362 
skip_bits(&s>gb, 8); /* profil and level */ 
1363 
s>progressive_sequence = get_bits1(&s>gb); /* progressive_sequence */

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

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

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

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

1369 
bit_rate_ext = get_bits(&s>gb, 12); /* XXX: handle it */ 
1370 
s>bit_rate = ((s>bit_rate / 400)  (bit_rate_ext << 12)) * 400; 
1371 
skip_bits1(&s>gb); /* marker */

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

1373 
low_delay = get_bits1(&s>gb); 
1374 
frame_rate_ext_n = get_bits(&s>gb, 2);

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

1376 
if (frame_rate_ext_d >= 1) 
1377 
s>frame_rate = (s>frame_rate * frame_rate_ext_n) / frame_rate_ext_d; 
1378 
dprintf("sequence extension\n");

1379 
s>mpeg2 = 1;

1380 
s>avctx>sub_id = 2; /* indicates mpeg2 found */ 
1381 
} 
1382  
1383 
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 
1384 
{ 
1385 
int i, v, j;

1386  
1387 
dprintf("matrix extension\n");

1388  
1389 
if (get_bits1(&s>gb)) {

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

1392 
j = s>intra_scantable.permutated[i]; 
1393 
s>intra_matrix[j] = v; 
1394 
s>chroma_intra_matrix[j] = v; 
1395 
} 
1396 
} 
1397 
if (get_bits1(&s>gb)) {

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

1400 
j = s>intra_scantable.permutated[i]; 
1401 
s>inter_matrix[j] = v; 
1402 
s>chroma_inter_matrix[j] = v; 
1403 
} 
1404 
} 
1405 
if (get_bits1(&s>gb)) {

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

1408 
j = s>intra_scantable.permutated[i]; 
1409 
s>chroma_intra_matrix[j] = v; 
1410 
} 
1411 
} 
1412 
if (get_bits1(&s>gb)) {

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

1415 
j = s>intra_scantable.permutated[i]; 
1416 
s>chroma_inter_matrix[j] = v; 
1417 
} 
1418 
} 
1419 
} 
1420  
1421 
static void mpeg_decode_picture_coding_extension(MpegEncContext *s) 
1422 
{ 
1423 
s>full_pel[0] = s>full_pel[1] = 0; 
1424 
s>mpeg_f_code[0][0] = get_bits(&s>gb, 4); 
1425 
s>mpeg_f_code[0][1] = get_bits(&s>gb, 4); 
1426 
s>mpeg_f_code[1][0] = get_bits(&s>gb, 4); 
1427 
s>mpeg_f_code[1][1] = get_bits(&s>gb, 4); 
1428 
s>intra_dc_precision = get_bits(&s>gb, 2);

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

1430 
s>top_field_first = get_bits1(&s>gb); 
1431 
s>frame_pred_frame_dct = get_bits1(&s>gb); 
1432 
s>concealment_motion_vectors = get_bits1(&s>gb); 
1433 
s>q_scale_type = get_bits1(&s>gb); 
1434 
s>intra_vlc_format = get_bits1(&s>gb); 
1435 
s>alternate_scan = get_bits1(&s>gb); 
1436 
s>repeat_first_field = get_bits1(&s>gb); 
1437 
s>chroma_420_type = get_bits1(&s>gb); 
1438 
s>progressive_frame = get_bits1(&s>gb); 
1439 
/* composite display not parsed */

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

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

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

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

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

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

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

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

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

1449 
} 
1450  
1451 
static void mpeg_decode_extension(AVCodecContext *avctx, 
1452 
UINT8 *buf, int buf_size)

1453 
{ 
1454 
Mpeg1Context *s1 = avctx>priv_data; 
1455 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1456 
int ext_type;

1457  
1458 
init_get_bits(&s>gb, buf, buf_size); 
1459 

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

1461 
switch(ext_type) {

1462 
case 0x1: 
1463 
/* sequence ext */

1464 
mpeg_decode_sequence_extension(s); 
1465 
break;

1466 
case 0x3: 
1467 
/* quant matrix extension */

1468 
mpeg_decode_quant_matrix_extension(s); 
1469 
break;

1470 
case 0x8: 
1471 
/* picture extension */

1472 
mpeg_decode_picture_coding_extension(s); 
1473 
break;

1474 
} 
1475 
} 
1476  
1477 
/* return 1 if end of frame */

1478 
static int mpeg_decode_slice(AVCodecContext *avctx, 
1479 
AVPicture *pict, 
1480 
int start_code,

1481 
UINT8 *buf, int buf_size)

1482 
{ 
1483 
Mpeg1Context *s1 = avctx>priv_data; 
1484 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1485 
int ret;

1486  
1487 
start_code = (start_code  1) & 0xff; 
1488 
if (start_code >= s>mb_height){

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

1490 
return 1; 
1491 
} 
1492 
s>last_dc[0] = 1 << (7 + s>intra_dc_precision); 
1493 
s>last_dc[1] = s>last_dc[0]; 
1494 
s>last_dc[2] = s>last_dc[0]; 
1495 
memset(s>last_mv, 0, sizeof(s>last_mv)); 
1496 
s>mb_x = 1;

1497 
s>mb_y = start_code; 
1498 
s>mb_incr = 0;

1499 
/* start frame decoding */

1500 
if (s>first_slice) {

1501 
s>first_slice = 0;

1502 
MPV_frame_start(s, avctx); 
1503 
} 
1504  
1505 
init_get_bits(&s>gb, buf, buf_size); 
1506  
1507 
s>qscale = get_qscale(s); 
1508 
/* extra slice info */

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

1511 
} 
1512  
1513 
for(;;) {

1514 
clear_blocks(s>block[0]);

1515 
emms_c(); 
1516 
ret = mpeg_decode_mb(s, s>block); 
1517 
dprintf("ret=%d\n", ret);

1518 
if (ret < 0) 
1519 
return 1; 
1520 
if (ret == 1) 
1521 
break;

1522 

1523 
if(s>mb_x==0) 
1524 
PRINT_QP("%s", "\n"); 
1525 
PRINT_QP("%2d", s>qscale);

1526 

1527 
MPV_decode_mb(s, s>block); 
1528 
} 
1529 
emms_c(); 
1530  
1531 
/* end of slice reached */

1532 
if (s>mb_x == (s>mb_width  1) && 
1533 
s>mb_y == (s>mb_height  1)) {

1534 
/* end of image */

1535 
UINT8 **picture; 
1536  
1537 
MPV_frame_end(s); 
1538  
1539 
/* XXX: incorrect reported qscale for mpeg2 */

1540 
if (s>pict_type == B_TYPE) {

1541 
picture = s>current_picture; 
1542 
avctx>quality = s>qscale; 
1543 
} else {

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

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

1546 
if (s>picture_number == 0) { 
1547 
picture = NULL;

1548 
} else {

1549 
picture = s>last_picture; 
1550 
avctx>quality = s>last_qscale; 
1551 
} 
1552 
s>last_qscale = s>qscale; 
1553 
s>picture_number++; 
1554 
} 
1555 
if (picture) {

1556 
pict>data[0] = picture[0]; 
1557 
pict>data[1] = picture[1]; 
1558 
pict>data[2] = picture[2]; 
1559 
pict>linesize[0] = s>linesize;

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

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

1562 
return 1; 
1563 
} else {

1564 
return 0; 
1565 
} 
1566 
} else {

1567 
return 0; 
1568 
} 
1569 
} 
1570  
1571 
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1572 
UINT8 *buf, int buf_size)

1573 
{ 
1574 
Mpeg1Context *s1 = avctx>priv_data; 
1575 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1576 
int width, height, i, v, j;

1577  
1578 
init_get_bits(&s>gb, buf, buf_size); 
1579  
1580 
width = get_bits(&s>gb, 12);

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

1582 
skip_bits(&s>gb, 4);

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

1584 
if (s>frame_rate_index == 0) 
1585 
return 1; 
1586 
s>bit_rate = get_bits(&s>gb, 18) * 400; 
1587 
if (get_bits1(&s>gb) == 0) /* marker */ 
1588 
return 1; 
1589 
if (width <= 0  height <= 0  
1590 
(width % 2) != 0  (height % 2) != 0) 
1591 
return 1; 
1592 
if (width != s>width 

1593 
height != s>height) { 
1594 
/* start new mpeg1 context decoding */

1595 
s>out_format = FMT_MPEG1; 
1596 
if (s1>mpeg_enc_ctx_allocated) {

1597 
MPV_common_end(s); 
1598 
} 
1599 
s>width = width; 
1600 
s>height = height; 
1601 
avctx>has_b_frames= s>has_b_frames = 1;

1602 
s>avctx = avctx; 
1603 
avctx>width = width; 
1604 
avctx>height = height; 
1605 
if (s>frame_rate_index >= 9) { 
1606 
/* at least give a valid frame rate (some old mpeg1 have this) */

1607 
avctx>frame_rate = 25 * FRAME_RATE_BASE;

1608 
} else {

1609 
avctx>frame_rate = frame_rate_tab[s>frame_rate_index]; 
1610 
} 
1611 
s>frame_rate = avctx>frame_rate; 
1612 
avctx>bit_rate = s>bit_rate; 
1613 

1614 
if (MPV_common_init(s) < 0) 
1615 
return 1; 
1616 
s1>mpeg_enc_ctx_allocated = 1;

1617 
} 
1618  
1619 
skip_bits(&s>gb, 10); /* vbv_buffer_size */ 
1620 
skip_bits(&s>gb, 1);

1621  
1622 
/* get matrix */

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

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

1626 
j = s>intra_scantable.permutated[i]; 
1627 
s>intra_matrix[j] = v; 
1628 
s>chroma_intra_matrix[j] = v; 
1629 
} 
1630 
#ifdef DEBUG

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

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

1634 
printf("\n");

1635 
#endif

1636 
} else {

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

1639 
v = ff_mpeg1_default_intra_matrix[i]; 
1640 
s>intra_matrix[j] = v; 
1641 
s>chroma_intra_matrix[j] = v; 
1642 
} 
1643 
} 
1644 
if (get_bits1(&s>gb)) {

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

1647 
j = s>intra_scantable.permutated[i]; 
1648 
s>inter_matrix[j] = v; 
1649 
s>chroma_inter_matrix[j] = v; 
1650 
} 
1651 
#ifdef DEBUG

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

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

1655 
printf("\n");

1656 
#endif

1657 
} else {

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

1660 
v = ff_mpeg1_default_non_intra_matrix[i]; 
1661 
s>inter_matrix[j] = v; 
1662 
s>chroma_inter_matrix[j] = v; 
1663 
} 
1664 
} 
1665  
1666 
/* we set mpeg2 parameters so that it emulates mpeg1 */

1667 
s>progressive_sequence = 1;

1668 
s>progressive_frame = 1;

1669 
s>picture_structure = PICT_FRAME; 
1670 
s>frame_pred_frame_dct = 1;

1671 
s>mpeg2 = 0;

1672 
avctx>sub_id = 1; /* indicates mpeg1 */ 
1673 
return 0; 
1674 
} 
1675  
1676 
/* handle buffering and image synchronisation */

1677 
static int mpeg_decode_frame(AVCodecContext *avctx, 
1678 
void *data, int *data_size, 
1679 
UINT8 *buf, int buf_size)

1680 
{ 
1681 
Mpeg1Context *s = avctx>priv_data; 
1682 
UINT8 *buf_end, *buf_ptr, *buf_start; 
1683 
int len, start_code_found, ret, code, start_code, input_size;

1684 
AVPicture *picture = data; 
1685 
MpegEncContext *s2 = &s>mpeg_enc_ctx; 
1686 

1687 
dprintf("fill_buffer\n");

1688  
1689 
*data_size = 0;

1690  
1691 
/* special case for last picture */

1692 
if (buf_size == 0) { 
1693 
if (s2>picture_number > 0) { 
1694 
picture>data[0] = s2>next_picture[0]; 
1695 
picture>data[1] = s2>next_picture[1]; 
1696 
picture>data[2] = s2>next_picture[2]; 
1697 
picture>linesize[0] = s2>linesize;

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

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

1700 
*data_size = sizeof(AVPicture);

1701 
} 
1702 
return 0; 
1703 
} 
1704  
1705 
buf_ptr = buf; 
1706 
buf_end = buf + buf_size; 
1707  
1708 
#if 0

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

1710 
s>repeat_field++;

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

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

1713 
if (avctx>flags & CODEC_FLAG_REPEAT_FIELD) {

1714 
*data_size = sizeof(AVPicture);

1715 
goto the_end;

1716 
}

1717 
}

1718 
#endif

1719 
while (buf_ptr < buf_end) {

1720 
buf_start = buf_ptr; 
1721 
/* find start next code */

1722 
code = find_start_code(&buf_ptr, buf_end, &s>header_state); 
1723 
if (code >= 0) { 
1724 
start_code_found = 1;

1725 
} else {

1726 
start_code_found = 0;

1727 
} 
1728 
/* copy to buffer */

1729 
len = buf_ptr  buf_start; 
1730 
if (len + (s>buf_ptr  s>buffer) > s>buffer_size) {

1731 
/* data too big : flush */

1732 
s>buf_ptr = s>buffer; 
1733 
if (start_code_found)

1734 
s>start_code = code; 
1735 
} else {

1736 
memcpy(s>buf_ptr, buf_start, len); 
1737 
s>buf_ptr += len; 
1738 
if( (s2>flags&CODEC_FLAG_NOT_TRUNCATED) && (!start_code_found)

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

1740 
start_code_found= 1;

1741 
code= 0x1FF;

1742 
s>header_state=0xFF;

1743 
s>buf_ptr[0]=0; 
1744 
s>buf_ptr[1]=0; 
1745 
s>buf_ptr[2]=1; 
1746 
s>buf_ptr[3]=0xFF; 
1747 
s>buf_ptr+=4;

1748 
} 
1749 
if (start_code_found) {

1750 
/* prepare data for next start code */

1751 
input_size = s>buf_ptr  s>buffer; 
1752 
start_code = s>start_code; 
1753 
s>buf_ptr = s>buffer; 
1754 
s>start_code = code; 
1755 
switch(start_code) {

1756 
case SEQ_START_CODE:

1757 
mpeg1_decode_sequence(avctx, s>buffer, 
1758 
input_size); 
1759 
break;

1760 

1761 
case PICTURE_START_CODE:

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

1763 
mpeg1_decode_picture(avctx, 
1764 
s>buffer, input_size); 
1765 
break;

1766 
case EXT_START_CODE:

1767 
mpeg_decode_extension(avctx, 
1768 
s>buffer, input_size); 
1769 
break;

1770 
default:

1771 
if (start_code >= SLICE_MIN_START_CODE &&

1772 
start_code <= SLICE_MAX_START_CODE) { 
1773 
ret = mpeg_decode_slice(avctx, picture, 
1774 
start_code, s>buffer, input_size); 
1775 
if (ret == 1) { 
1776 
/* got a picture: exit */

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

1778 
avctx>repeat_pict = 0;

1779 
#if 0

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

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

1782 
//s2>repeat_first_field = 0;

1783 
//s2>progressive_frame = 0;

1784 
if (++s>repeat_field > 2)

1785 
s>repeat_field = 0;

1786 
avctx>repeat_pict = 1;

1787 
}

1788 
#endif

1789 
if (s2>repeat_first_field) {

1790 
if (s2>progressive_sequence) {

1791 
if (s2>top_field_first)

1792 
avctx>repeat_pict = 4;

1793 
else

1794 
avctx>repeat_pict = 2;

1795 
} else if (s2>progressive_frame) { 
1796 
avctx>repeat_pict = 1;

1797 
} 
1798 
} 
1799 
*data_size = sizeof(AVPicture);

1800 
goto the_end;

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

1803 
} 
1804 
} 
1805 
break;

1806 
} 
1807 
} 
1808 
} 
1809 
} 
1810 
the_end:

1811 
return buf_ptr  buf;

1812 
} 
1813  
1814 
static int mpeg_decode_end(AVCodecContext *avctx) 
1815 
{ 
1816 
Mpeg1Context *s = avctx>priv_data; 
1817  
1818 
if (s>mpeg_enc_ctx_allocated)

1819 
MPV_common_end(&s>mpeg_enc_ctx); 
1820 
return 0; 
1821 
} 
1822  
1823 
AVCodec mpeg_decoder = { 
1824 
"mpegvideo",

1825 
CODEC_TYPE_VIDEO, 
1826 
CODEC_ID_MPEG1VIDEO, 
1827 
sizeof(Mpeg1Context),

1828 
mpeg_decode_init, 
1829 
NULL,

1830 
mpeg_decode_end, 
1831 
mpeg_decode_frame, 
1832 
CODEC_CAP_DR1, 
1833 
}; 