ffmpeg / libavcodec / mpeg12.c @ 983e3246
History  View  Annotate  Download (74.2 KB)
1 
/*


2 
* MPEG1 codec / 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 

20 
/**

21 
* @file mpeg12.c

22 
* MPEG1 codec / MPEG2 decoder.

23 
*/

24 

25 
//#define DEBUG

26 
#include "avcodec.h" 
27 
#include "dsputil.h" 
28 
#include "mpegvideo.h" 
29  
30 
#include "mpeg12data.h" 
31  
32 
#if 1 
33 
#define PRINT_QP(a, b) {}

34 
#else

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

36 
#endif

37  
38 
/* Start codes. */

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

59 
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added 
60 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num); 
61 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
62 
DCTELEM *block, 
63 
int n);

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

67 
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
68 
DCTELEM *block, 
69 
int n);

70 
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
71 
DCTELEM *block, 
72 
int n);

73 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); 
74  
75 
#ifdef CONFIG_ENCODERS

76 
static uint16_t mv_penalty[MAX_FCODE+1][MAX_MV*2+1]; 
77 
static uint8_t fcode_tab[MAX_MV*2+1]; 
78  
79 
static uint32_t uni_mpeg1_ac_vlc_bits[64*64*2]; 
80 
static uint8_t uni_mpeg1_ac_vlc_len [64*64*2]; 
81 
#endif

82  
83 
static inline int get_bits_diff(MpegEncContext *s){ 
84 
int bits,ret;

85 

86 
bits= get_bit_count(&s>pb); 
87 
ret= bits  s>last_bits; 
88 
s>last_bits=bits; 
89 

90 
return ret;

91 
} 
92  
93 
static void init_2d_vlc_rl(RLTable *rl) 
94 
{ 
95 
int i;

96 

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

98 
&rl>table_vlc[0][1], 4, 2, 
99 
&rl>table_vlc[0][0], 4, 2); 
100  
101 

102 
rl>rl_vlc[0]= av_malloc(rl>vlc.table_size*sizeof(RL_VLC_ELEM)); 
103 
for(i=0; i<rl>vlc.table_size; i++){ 
104 
int code= rl>vlc.table[i][0]; 
105 
int len = rl>vlc.table[i][1]; 
106 
int level, run;

107 

108 
if(len==0){ // illegal code 
109 
run= 65;

110 
level= MAX_LEVEL; 
111 
}else if(len<0){ //more bits needed 
112 
run= 0;

113 
level= code; 
114 
}else{

115 
if(code==rl>n){ //esc 
116 
run= 65;

117 
level= 0;

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

120 
level= 127;

121 
}else{

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

123 
level= rl>table_level[code]; 
124 
} 
125 
} 
126 
rl>rl_vlc[0][i].len= len;

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

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

129 
} 
130 
} 
131  
132 
static void init_uni_ac_vlc(RLTable *rl, uint32_t *uni_ac_vlc_bits, uint8_t *uni_ac_vlc_len){ 
133 
int i;

134  
135 
for(i=0; i<128; i++){ 
136 
int level= i64; 
137 
int run;

138 
for(run=0; run<64; run++){ 
139 
int len, bits, code;

140 

141 
int alevel= ABS(level);

142 
int sign= (level>>31)&1; 
143  
144 
if (alevel > rl>max_level[0][run]) 
145 
code= 111; /*rl>n*/ 
146 
else

147 
code= rl>index_run[0][run] + alevel  1; 
148  
149 
if (code < 111 /* rl>n */) { 
150 
/* store the vlc & sign at once */

151 
len= mpeg1_vlc[code][1]+1; 
152 
bits= (mpeg1_vlc[code][0]<<1) + sign; 
153 
} else {

154 
len= mpeg1_vlc[111/*rl>n*/][1]+6; 
155 
bits= mpeg1_vlc[111/*rl>n*/][0]<<6; 
156  
157 
bits= run; 
158 
if (alevel < 128) { 
159 
bits<<=8; len+=8; 
160 
bits= level & 0xff;

161 
} else {

162 
bits<<=16; len+=16; 
163 
bits= level & 0xff;

164 
if (level < 0) { 
165 
bits= 0x8001 + level + 255; 
166 
} else {

167 
bits= level & 0xffff;

168 
} 
169 
} 
170 
} 
171  
172 
uni_ac_vlc_bits[UNI_AC_ENC_INDEX(run, i)]= bits; 
173 
uni_ac_vlc_len [UNI_AC_ENC_INDEX(run, i)]= len; 
174 
} 
175 
} 
176 
} 
177  
178 
static void put_header(MpegEncContext *s, int header) 
179 
{ 
180 
align_put_bits(&s>pb); 
181 
put_bits(&s>pb, 16, header>>16); 
182 
put_bits(&s>pb, 16, header&0xFFFF); 
183 
} 
184  
185 
/* put sequence header if needed */

186 
static void mpeg1_encode_sequence_header(MpegEncContext *s) 
187 
{ 
188 
unsigned int vbv_buffer_size; 
189 
unsigned int fps, v; 
190 
int n, i;

191 
uint64_t time_code; 
192 
float best_aspect_error= 1E10; 
193 
float aspect_ratio= s>avctx>aspect_ratio;

194 

195 
if(aspect_ratio==0.0) aspect_ratio= s>width / (float)s>height; //pixel aspect 1:1 (VGA) 
196 

197 
if (s>current_picture.key_frame) {

198 
/* mpeg1 header repeated every gop */

199 
put_header(s, SEQ_START_CODE); 
200 

201 
/* search closest frame rate */

202 
{ 
203 
int i, dmin, d;

204 
s>frame_rate_index = 0;

205 
dmin = 0x7fffffff;

206 
for(i=1;i<9;i++) { 
207 
d = abs(s>frame_rate  frame_rate_tab[i]); 
208 
if (d < dmin) {

209 
dmin = d; 
210 
s>frame_rate_index = i; 
211 
} 
212 
} 
213 
} 
214 

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

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

217 

218 
for(i=1; i<15; i++){ 
219 
float error= mpeg1_aspect[i]  s>width/(s>height*aspect_ratio);

220 
error= ABS(error); 
221 

222 
if(error < best_aspect_error){

223 
best_aspect_error= error; 
224 
s>aspect_ratio_info= i; 
225 
} 
226 
} 
227 

228 
put_bits(&s>pb, 4, s>aspect_ratio_info);

229 
put_bits(&s>pb, 4, s>frame_rate_index);

230 
v = s>bit_rate / 400;

231 
if (v > 0x3ffff) 
232 
v = 0x3ffff;

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

234 
put_bits(&s>pb, 1, 1); /* marker */ 
235  
236 
if(s>avctx>rc_buffer_size)

237 
vbv_buffer_size = s>avctx>rc_buffer_size; 
238 
else

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

240 
vbv_buffer_size = (( 20 * s>bit_rate) / (1151929 / 2)) * 8 * 1024; 
241 
put_bits(&s>pb, 10, (vbv_buffer_size + 16383) / 16384); 
242 
put_bits(&s>pb, 1, 1); /* constrained parameter flag */ 
243 
put_bits(&s>pb, 1, 0); /* no custom intra matrix */ 
244 
put_bits(&s>pb, 1, 0); /* no custom non intra matrix */ 
245  
246 
put_header(s, GOP_START_CODE); 
247 
put_bits(&s>pb, 1, 0); /* do drop frame */ 
248 
/* time code : we must convert from the real frame rate to a

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

250 
fps = frame_rate_tab[s>frame_rate_index]; 
251 
time_code = (int64_t)s>fake_picture_number * FRAME_RATE_BASE; 
252 
s>gop_picture_number = s>fake_picture_number; 
253 
put_bits(&s>pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); 
254 
put_bits(&s>pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); 
255 
put_bits(&s>pb, 1, 1); 
256 
put_bits(&s>pb, 6, (uint32_t)((time_code / fps) % 60)); 
257 
put_bits(&s>pb, 6, (uint32_t)((time_code % fps) / FRAME_RATE_BASE));

258 
put_bits(&s>pb, 1, 1); /* closed gop */ 
259 
put_bits(&s>pb, 1, 0); /* broken link */ 
260 
} 
261  
262 
if (s>frame_rate < (24 * FRAME_RATE_BASE) && s>picture_number > 0) { 
263 
/* insert empty P pictures to slow down to the desired

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

265 
fps = frame_rate_tab[s>frame_rate_index]; 
266 
n = (((int64_t)s>picture_number * fps) / s>frame_rate)  1;

267 
while (s>fake_picture_number < n) {

268 
mpeg1_skip_picture(s, s>fake_picture_number  
269 
s>gop_picture_number); 
270 
s>fake_picture_number++; 
271 
} 
272  
273 
} 
274 
} 
275  
276  
277 
/* insert a fake P picture */

278 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num) 
279 
{ 
280 
unsigned int mb_incr; 
281  
282 
/* mpeg1 picture header */

283 
put_header(s, PICTURE_START_CODE); 
284 
/* temporal reference */

285 
put_bits(&s>pb, 10, pict_num & 0x3ff); 
286 

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

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

290 
put_bits(&s>pb, 1, 1); /* integer coordinates */ 
291 
put_bits(&s>pb, 3, 1); /* forward_f_code */ 
292 

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

295 
/* only one slice */

296 
put_header(s, SLICE_MIN_START_CODE); 
297 
put_bits(&s>pb, 5, 1); /* quantizer scale */ 
298 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
299 

300 
mb_incr = 1;

301 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
302 
mbAddrIncrTable[mb_incr  1][0]); 
303 

304 
/* empty macroblock */

305 
put_bits(&s>pb, 3, 1); /* motion only */ 
306 

307 
/* zero motion x & y */

308 
put_bits(&s>pb, 1, 1); 
309 
put_bits(&s>pb, 1, 1); 
310  
311 
/* output a number of empty slice */

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

313 
while (mb_incr > 33) { 
314 
put_bits(&s>pb, 11, 0x008); 
315 
mb_incr = 33;

316 
} 
317 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
318 
mbAddrIncrTable[mb_incr  1][0]); 
319 

320 
/* empty macroblock */

321 
put_bits(&s>pb, 3, 1); /* motion only */ 
322 

323 
/* zero motion x & y */

324 
put_bits(&s>pb, 1, 1); 
325 
put_bits(&s>pb, 1, 1); 
326 
} 
327  
328 
static void common_init(MpegEncContext *s) 
329 
{ 
330 
s>y_dc_scale_table= 
331 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
332 
} 
333  
334 
#ifdef CONFIG_ENCODERS

335 
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) 
336 
{ 
337 
mpeg1_encode_sequence_header(s); 
338  
339 
/* mpeg1 picture header */

340 
put_header(s, PICTURE_START_CODE); 
341 
/* temporal reference */

342  
343 
// RAL: s>picture_number instead of s>fake_picture_number

344 
put_bits(&s>pb, 10, (s>picture_number 

345 
s>gop_picture_number) & 0x3ff);

346 
s>fake_picture_number++; 
347 

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

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

351 
// RAL: Forward f_code also needed for B frames

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

353 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
354 
put_bits(&s>pb, 3, s>f_code); /* forward_f_code */ 
355 
} 
356 

357 
// RAL: Backward f_code necessary for B frames

358 
if (s>pict_type == B_TYPE) {

359 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
360 
put_bits(&s>pb, 3, s>b_code); /* backward_f_code */ 
361 
} 
362  
363 
put_bits(&s>pb, 1, 0); /* extra bit picture */ 
364 

365 
/* only one slice */

366 
put_header(s, SLICE_MIN_START_CODE); 
367 
put_bits(&s>pb, 5, s>qscale); /* quantizer scale */ 
368 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
369 
} 
370  
371 
void mpeg1_encode_mb(MpegEncContext *s,

372 
DCTELEM block[6][64], 
373 
int motion_x, int motion_y) 
374 
{ 
375 
int mb_incr, i, cbp, mb_x, mb_y;

376  
377 
mb_x = s>mb_x; 
378 
mb_y = s>mb_y; 
379  
380 
/* compute cbp */

381 
cbp = 0;

382 
for(i=0;i<6;i++) { 
383 
if (s>block_last_index[i] >= 0) 
384 
cbp = 1 << (5  i); 
385 
} 
386  
387 
// RAL: Skipped macroblocks for B frames...

388 
if (cbp == 0 && (!((mb_x  mb_y) == 0  (mb_x == s>mb_width  1 && mb_y == s>mb_height  1))) && 
389 
((s>pict_type == P_TYPE && (motion_x  motion_y) == 0) 

390 
(s>pict_type == B_TYPE && s>mv_dir == s>last_mv_dir && (((s>mv_dir & MV_DIR_FORWARD) ? ((s>mv[0][0][0]  s>last_mv[0][0][0])(s>mv[0][0][1]  s>last_mv[0][0][1])) : 0)  
391 
((s>mv_dir & MV_DIR_BACKWARD) ? ((s>mv[1][0][0]  s>last_mv[1][0][0])(s>mv[1][0][1]  s>last_mv[1][0][1])) : 0)) == 0))) { 
392 
s>mb_incr++; 
393 
s>qscale = s>dquant; 
394 
s>skip_count++; 
395 
s>misc_bits++; 
396 
s>last_bits++; 
397 
} else {

398 
/* output mb incr */

399 
mb_incr = s>mb_incr; 
400  
401 
while (mb_incr > 33) { 
402 
put_bits(&s>pb, 11, 0x008); 
403 
mb_incr = 33;

404 
} 
405 
put_bits(&s>pb, mbAddrIncrTable[mb_incr  1][1], 
406 
mbAddrIncrTable[mb_incr  1][0]); 
407 

408 
if (s>pict_type == I_TYPE) {

409 
if(s>dquant && cbp){

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

412 
}else{

413 
put_bits(&s>pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */ 
414 
s>qscale = s>dquant; 
415 
} 
416 
s>misc_bits+= get_bits_diff(s); 
417 
s>i_count++; 
418 
} else if (s>mb_intra) { 
419 
if(s>dquant && cbp){

420 
put_bits(&s>pb, 6, 0x01); 
421 
put_bits(&s>pb, 5, s>qscale);

422 
}else{

423 
put_bits(&s>pb, 5, 0x03); 
424 
s>qscale = s>dquant; 
425 
} 
426 
s>misc_bits+= get_bits_diff(s); 
427 
s>i_count++; 
428 
s>last_mv[0][0][0] = 
429 
s>last_mv[0][0][1] = 0; 
430 
} else if (s>pict_type == P_TYPE) { 
431 
if (cbp != 0) { 
432 
if (motion_x == 0 && motion_y == 0) { 
433 
if(s>dquant){

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

436 
}else{

437 
put_bits(&s>pb, 2, 1); /* macroblock_pattern only */ 
438 
} 
439 
s>misc_bits+= get_bits_diff(s); 
440 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
441 
} else {

442 
if(s>dquant){

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

445 
}else{

446 
put_bits(&s>pb, 1, 1); /* motion + cbp */ 
447 
} 
448 
s>misc_bits+= get_bits_diff(s); 
449 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); // RAL: f_code parameter added 
450 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); // RAL: f_code parameter added 
451 
s>mv_bits+= get_bits_diff(s); 
452 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
453 
} 
454 
} else {

455 
put_bits(&s>pb, 3, 1); /* motion only */ 
456 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); // RAL: f_code parameter added 
457 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); // RAL: f_code parameter added 
458 
s>qscale = s>dquant; 
459 
s>mv_bits+= get_bits_diff(s); 
460 
} 
461 
s>f_count++; 
462 
} else

463 
{ // RAL: All the following bloc added for B frames:

464 
if (cbp != 0) 
465 
{ // With coded bloc pattern

466 
if (s>mv_dir == (MV_DIR_FORWARD  MV_DIR_BACKWARD))

467 
{ // Bidirectional motion

468 
if (s>dquant)

469 
{ // With QScale

470 
put_bits(&s>pb, 5, 2); 
471 
put_bits(&s>pb, 5, s>qscale);

472 
} 
473 
else // Without QScale 
474 
put_bits(&s>pb, 2, 3); 
475 
s>misc_bits += get_bits_diff(s); 
476 
mpeg1_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
477 
mpeg1_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
478 
mpeg1_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
479 
mpeg1_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
480 
s>b_count++; 
481 
s>f_count++; 
482 
s>mv_bits += get_bits_diff(s); 
483 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
484 
} 
485 
else if (s>mv_dir == MV_DIR_BACKWARD) 
486 
{ // Backward motion

487 
if (s>dquant)

488 
{ // With QScale

489 
put_bits(&s>pb, 6, 2); 
490 
put_bits(&s>pb, 5, s>qscale);

491 
} 
492 
else // Without QScale 
493 
put_bits(&s>pb, 3, 3); 
494 
s>misc_bits += get_bits_diff(s); 
495 
mpeg1_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
496 
mpeg1_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
497 
s>b_count++; 
498 
s>mv_bits += get_bits_diff(s); 
499 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
500 
} 
501 
else if (s>mv_dir == MV_DIR_FORWARD) 
502 
{ // Forward motion

503 
if (s>dquant)

504 
{ // With QScale

505 
put_bits(&s>pb, 6, 3); 
506 
put_bits(&s>pb, 5, s>qscale);

507 
} 
508 
else // Without QScale 
509 
put_bits(&s>pb, 4, 3); 
510 
s>misc_bits += get_bits_diff(s); 
511 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
512 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
513 
s>f_count++; 
514 
s>mv_bits += get_bits_diff(s); 
515 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
516 
} 
517 
} 
518 
else

519 
{ // No coded bloc pattern

520 
if (s>mv_dir == (MV_DIR_FORWARD  MV_DIR_BACKWARD))

521 
{ // Bidirectional motion

522 
put_bits(&s>pb, 2, 2); /* backward & forward motion */ 
523 
mpeg1_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
524 
mpeg1_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
525 
mpeg1_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
526 
mpeg1_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
527 
s>b_count++; 
528 
s>f_count++; 
529 
} 
530 
else if (s>mv_dir == MV_DIR_BACKWARD) 
531 
{ // Backward motion

532 
put_bits(&s>pb, 3, 2); /* backward motion only */ 
533 
mpeg1_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
534 
mpeg1_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
535 
s>b_count++; 
536 
} 
537 
else if (s>mv_dir == MV_DIR_FORWARD) 
538 
{ // Forward motion

539 
put_bits(&s>pb, 4, 2); /* forward motion only */ 
540 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
541 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
542 
s>f_count++; 
543 
} 
544 
s>qscale = s>dquant; 
545 
s>mv_bits += get_bits_diff(s); 
546 
} 
547 
// End of bloc from RAL

548 
} 
549 
for(i=0;i<6;i++) { 
550 
if (cbp & (1 << (5  i))) { 
551 
mpeg1_encode_block(s, block[i], i); 
552 
} 
553 
} 
554 
s>mb_incr = 1;

555 
if(s>mb_intra)

556 
s>i_tex_bits+= get_bits_diff(s); 
557 
else

558 
s>p_tex_bits+= get_bits_diff(s); 
559 
} 
560  
561 
// RAL: By this:

562 
if (s>mv_dir & MV_DIR_FORWARD)

563 
{ 
564 
s>last_mv[0][0][0]= s>mv[0][0][0]; 
565 
s>last_mv[0][0][1]= s>mv[0][0][1]; 
566 
} 
567 
if (s>mv_dir & MV_DIR_BACKWARD)

568 
{ 
569 
s>last_mv[1][0][0]= s>mv[1][0][0]; 
570 
s>last_mv[1][0][1]= s>mv[1][0][1]; 
571 
} 
572 
} 
573  
574 
// RAL: Parameter added: f_or_b_code

575 
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) 
576 
{ 
577 
int code, bit_size, l, m, bits, range, sign;

578  
579 
if (val == 0) { 
580 
/* zero vector */

581 
code = 0;

582 
put_bits(&s>pb, 
583 
mbMotionVectorTable[0][1], 
584 
mbMotionVectorTable[0][0]); 
585 
} else {

586 
bit_size = f_or_b_code  1;

587 
range = 1 << bit_size;

588 
/* modulo encoding */

589 
l = 16 * range;

590 
m = 2 * l;

591 
if (val < l) {

592 
val += m; 
593 
} else if (val >= l) { 
594 
val = m; 
595 
} 
596  
597 
if (val >= 0) { 
598 
val; 
599 
code = (val >> bit_size) + 1;

600 
bits = val & (range  1);

601 
sign = 0;

602 
} else {

603 
val = val; 
604 
val; 
605 
code = (val >> bit_size) + 1;

606 
bits = val & (range  1);

607 
sign = 1;

608 
} 
609  
610 
assert(code > 0 && code <= 16); 
611  
612 
put_bits(&s>pb, 
613 
mbMotionVectorTable[code][1],

614 
mbMotionVectorTable[code][0]);

615  
616 
put_bits(&s>pb, 1, sign);

617 
if (bit_size > 0) { 
618 
put_bits(&s>pb, bit_size, bits); 
619 
} 
620 
} 
621 
} 
622  
623 
void ff_mpeg1_encode_init(MpegEncContext *s)

624 
{ 
625 
static int done=0; 
626  
627 
common_init(s); 
628  
629 
if(!done){

630 
int f_code;

631 
int mv;

632 
int i;

633  
634 
done=1;

635 
init_rl(&rl_mpeg1); 
636  
637 
for(i=0; i<64; i++) 
638 
{ 
639 
mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i]; 
640 
mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i]; 
641 
} 
642 

643 
init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len); 
644  
645 
/* build unified dc encoding tables */

646 
for(i=255; i<256; i++) 
647 
{ 
648 
int adiff, index;

649 
int bits, code;

650 
int diff=i;

651  
652 
adiff = ABS(diff); 
653 
if(diff<0) diff; 
654 
index = vlc_dc_table[adiff]; 
655  
656 
bits= vlc_dc_lum_bits[index] + index; 
657 
code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index)  1)); 
658 
mpeg1_lum_dc_uni[i+255]= bits + (code<<8); 
659 

660 
bits= vlc_dc_chroma_bits[index] + index; 
661 
code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index)  1)); 
662 
mpeg1_chr_dc_uni[i+255]= bits + (code<<8); 
663 
} 
664  
665 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
666 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

667 
int len;

668  
669 
if(mv==0) len= mbMotionVectorTable[0][1]; 
670 
else{

671 
int val, bit_size, range, code;

672  
673 
bit_size = s>f_code  1;

674 
range = 1 << bit_size;

675  
676 
val=mv; 
677 
if (val < 0) 
678 
val = val; 
679 
val; 
680 
code = (val >> bit_size) + 1;

681 
if(code<17){ 
682 
len= mbMotionVectorTable[code][1] + 1 + bit_size; 
683 
}else{

684 
len= mbMotionVectorTable[16][1] + 2 + bit_size; 
685 
} 
686 
} 
687  
688 
mv_penalty[f_code][mv+MAX_MV]= len; 
689 
} 
690 
} 
691 

692  
693 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
694 
for(mv=(8<<f_code); mv<(8<<f_code); mv++){ 
695 
fcode_tab[mv+MAX_MV]= f_code; 
696 
} 
697 
} 
698 
} 
699 
s>me.mv_penalty= mv_penalty; 
700 
s>fcode_tab= fcode_tab; 
701 
s>min_qcoeff=255;

702 
s>max_qcoeff= 255;

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

705 
s>intra_ac_vlc_length= 
706 
s>inter_ac_vlc_length= uni_mpeg1_ac_vlc_len; 
707 
} 
708  
709 
static inline void encode_dc(MpegEncContext *s, int diff, int component) 
710 
{ 
711 
if (component == 0) { 
712 
put_bits( 
713 
&s>pb, 
714 
mpeg1_lum_dc_uni[diff+255]&0xFF, 
715 
mpeg1_lum_dc_uni[diff+255]>>8); 
716 
} else {

717 
put_bits( 
718 
&s>pb, 
719 
mpeg1_chr_dc_uni[diff+255]&0xFF, 
720 
mpeg1_chr_dc_uni[diff+255]>>8); 
721 
} 
722 
} 
723  
724 
static void mpeg1_encode_block(MpegEncContext *s, 
725 
DCTELEM *block, 
726 
int n)

727 
{ 
728 
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;

729 
int code, component;

730 
// RLTable *rl = &rl_mpeg1;

731  
732 
last_index = s>block_last_index[n]; 
733  
734 
/* DC coef */

735 
if (s>mb_intra) {

736 
component = (n <= 3 ? 0 : n  4 + 1); 
737 
dc = block[0]; /* overflow is impossible */ 
738 
diff = dc  s>last_dc[component]; 
739 
encode_dc(s, diff, component); 
740 
s>last_dc[component] = dc; 
741 
i = 1;

742 
} else {

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

744 
it is handled slightly differently */

745 
level = block[0];

746 
if (abs(level) == 1) { 
747 
code = ((uint32_t)level >> 31); /* the sign bit */ 
748 
put_bits(&s>pb, 2, code  0x02); 
749 
i = 1;

750 
} else {

751 
i = 0;

752 
last_non_zero = 1;

753 
goto next_coef;

754 
} 
755 
} 
756  
757 
/* now quantify & encode AC coefs */

758 
last_non_zero = i  1;

759  
760 
for(;i<=last_index;i++) {

761 
j = s>intra_scantable.permutated[i]; 
762 
level = block[j]; 
763 
next_coef:

764 
#if 0

765 
if (level != 0)

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

767 
#endif

768 
/* encode using VLC */

769 
if (level != 0) { 
770 
run = i  last_non_zero  1;

771 

772 
alevel= level; 
773 
MASK_ABS(sign, alevel) 
774 
sign&=1;

775  
776 
// code = get_rl_index(rl, 0, run, alevel);

777 
if (alevel <= mpeg1_max_level[0][run]){ 
778 
code= mpeg1_index_run[0][run] + alevel  1; 
779 
/* store the vlc & sign at once */

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

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

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

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

786 
if (alevel < 128) { 
787 
put_bits(&s>pb, 8, level & 0xff); 
788 
} else {

789 
if (level < 0) { 
790 
put_bits(&s>pb, 16, 0x8001 + level + 255); 
791 
} else {

792 
put_bits(&s>pb, 16, level & 0xffff); 
793 
} 
794 
} 
795 
} 
796 
last_non_zero = i; 
797 
} 
798 
} 
799 
/* end of block */

800 
put_bits(&s>pb, 2, 0x2); 
801 
} 
802 
#endif //CONFIG_ENCODERS 
803  
804 
/******************************************/

805 
/* decoding */

806  
807 
static VLC dc_lum_vlc;

808 
static VLC dc_chroma_vlc;

809 
static VLC mv_vlc;

810 
static VLC mbincr_vlc;

811 
static VLC mb_ptype_vlc;

812 
static VLC mb_btype_vlc;

813 
static VLC mb_pat_vlc;

814  
815 
static void init_vlcs(MpegEncContext *s) 
816 
{ 
817 
static int done = 0; 
818  
819 
if (!done) {

820 
done = 1;

821  
822 
init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,

823 
vlc_dc_lum_bits, 1, 1, 
824 
vlc_dc_lum_code, 2, 2); 
825 
init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12,

826 
vlc_dc_chroma_bits, 1, 1, 
827 
vlc_dc_chroma_code, 2, 2); 
828 
init_vlc(&mv_vlc, MV_VLC_BITS, 17,

829 
&mbMotionVectorTable[0][1], 2, 1, 
830 
&mbMotionVectorTable[0][0], 2, 1); 
831 
init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 35,

832 
&mbAddrIncrTable[0][1], 2, 1, 
833 
&mbAddrIncrTable[0][0], 2, 1); 
834 
init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,

835 
&mbPatTable[0][1], 2, 1, 
836 
&mbPatTable[0][0], 2, 1); 
837 

838 
init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 32,

839 
&table_mb_ptype[0][1], 2, 1, 
840 
&table_mb_ptype[0][0], 2, 1); 
841 
init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 32,

842 
&table_mb_btype[0][1], 2, 1, 
843 
&table_mb_btype[0][0], 2, 1); 
844 
init_rl(&rl_mpeg1); 
845 
init_rl(&rl_mpeg2); 
846  
847 
init_2d_vlc_rl(&rl_mpeg1); 
848 
init_2d_vlc_rl(&rl_mpeg2); 
849 
} 
850 
} 
851  
852 
static inline int get_dmv(MpegEncContext *s) 
853 
{ 
854 
if(get_bits1(&s>gb))

855 
return 1  (get_bits1(&s>gb) << 1); 
856 
else

857 
return 0; 
858 
} 
859  
860 
static inline int get_qscale(MpegEncContext *s) 
861 
{ 
862 
int qscale;

863 
if (s>mpeg2) {

864 
if (s>q_scale_type) {

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

866 
} else {

867 
qscale = get_bits(&s>gb, 5) << 1; 
868 
} 
869 
} else {

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

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

872 
} 
873 
return qscale;

874 
} 
875  
876 
/* motion type (for mpeg2) */

877 
#define MT_FIELD 1 
878 
#define MT_FRAME 2 
879 
#define MT_16X8 2 
880 
#define MT_DMV 3 
881  
882 
static int mpeg_decode_mb(MpegEncContext *s, 
883 
DCTELEM block[6][64]) 
884 
{ 
885 
int i, j, k, cbp, val, mb_type, motion_type;

886 

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

888  
889 
assert(s>mb_skiped==0);

890  
891 
if (s>mb_incr != 0) { 
892 
/* skip mb */

893 
s>mb_intra = 0;

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

896 
s>mv_type = MV_TYPE_16X16; 
897 
if (s>pict_type == P_TYPE) {

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

899 
s>mv_dir = MV_DIR_FORWARD; 
900 
s>mv[0][0][0] = s>mv[0][0][1] = 0; 
901 
s>last_mv[0][0][0] = s>last_mv[0][0][1] = 0; 
902 
s>last_mv[0][1][0] = s>last_mv[0][1][1] = 0; 
903 
s>mb_skiped = 1;

904 
} else {

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

906 
s>mv[0][0][0] = s>last_mv[0][0][0]; 
907 
s>mv[0][0][1] = s>last_mv[0][0][1]; 
908 
s>mv[1][0][0] = s>last_mv[1][0][0]; 
909 
s>mv[1][0][1] = s>last_mv[1][0][1]; 
910  
911 
if((s>mv[0][0][0]s>mv[0][0][1]s>mv[1][0][0]s>mv[1][0][1])==0) 
912 
s>mb_skiped = 1;

913 
} 
914  
915 
return 0; 
916 
} 
917  
918 
switch(s>pict_type) {

919 
default:

920 
case I_TYPE:

921 
if (get_bits1(&s>gb) == 0) { 
922 
if (get_bits1(&s>gb) == 0) 
923 
return 1; 
924 
mb_type = MB_QUANT  MB_INTRA; 
925 
} else {

926 
mb_type = MB_INTRA; 
927 
} 
928 
break;

929 
case P_TYPE:

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

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

933 
return 1; 
934 
} 
935 
break;

936 
case B_TYPE:

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

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

940 
return 1; 
941 
} 
942 
break;

943 
} 
944 
dprintf("mb_type=%x\n", mb_type);

945 
motion_type = 0; /* avoid warning */ 
946 
if (mb_type & (MB_FORMB_BACK)) {

947 
/* get additionnal motion vector type */

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

949 
motion_type = MT_FRAME; 
950 
else

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

952 
} 
953 
/* compute dct type */

954 
if (s>picture_structure == PICT_FRAME &&

955 
!s>frame_pred_frame_dct && 
956 
(mb_type & (MB_PAT  MB_INTRA))) { 
957 
s>interlaced_dct = get_bits1(&s>gb); 
958 
#ifdef DEBUG

959 
if (s>interlaced_dct)

960 
printf("interlaced_dct\n");

961 
#endif

962 
} else {

963 
s>interlaced_dct = 0; /* frame based */ 
964 
} 
965  
966 
if (mb_type & MB_QUANT) {

967 
s>qscale = get_qscale(s); 
968 
} 
969 
if (mb_type & MB_INTRA) {

970 
if (s>concealment_motion_vectors) {

971 
/* just parse them */

972 
if (s>picture_structure != PICT_FRAME)

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

974 
mpeg_decode_motion(s, s>mpeg_f_code[0][0], 0); 
975 
mpeg_decode_motion(s, s>mpeg_f_code[0][1], 0); 
976 
} 
977 
s>mb_intra = 1;

978 
cbp = 0x3f;

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

981 
s>mb_intra = 0;

982 
cbp = 0;

983 
} 
984 
/* special case of implicit zero motion vector */

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

986 
s>mv_dir = MV_DIR_FORWARD; 
987 
s>mv_type = MV_TYPE_16X16; 
988 
s>last_mv[0][0][0] = 0; 
989 
s>last_mv[0][0][1] = 0; 
990 
s>last_mv[0][1][0] = 0; 
991 
s>last_mv[0][1][1] = 0; 
992 
s>mv[0][0][0] = 0; 
993 
s>mv[0][0][1] = 0; 
994 
} else if (mb_type & (MB_FOR  MB_BACK)) { 
995 
/* motion vectors */

996 
s>mv_dir = 0;

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

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

1001 
switch(motion_type) {

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

1004 
/* MT_FRAME */

1005 
s>mv_type = MV_TYPE_16X16; 
1006 
for(k=0;k<2;k++) { 
1007 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
1008 
s>last_mv[i][0][k]);

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

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

1011 
/* full_pel: only for mpeg1 */

1012 
if (s>full_pel[i])

1013 
val = val << 1;

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

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

1016 
} 
1017 
} else {

1018 
/* MT_16X8 */

1019 
s>mv_type = MV_TYPE_16X8; 
1020 
for(j=0;j<2;j++) { 
1021 
s>field_select[i][j] = get_bits1(&s>gb); 
1022 
for(k=0;k<2;k++) { 
1023 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
1024 
s>last_mv[i][j][k]); 
1025 
s>last_mv[i][j][k] = val; 
1026 
s>mv[i][j][k] = val; 
1027 
} 
1028 
} 
1029 
} 
1030 
break;

1031 
case MT_FIELD:

1032 
s>mv_type = MV_TYPE_FIELD; 
1033 
if (s>picture_structure == PICT_FRAME) {

1034 
for(j=0;j<2;j++) { 
1035 
s>field_select[i][j] = get_bits1(&s>gb); 
1036 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

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

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

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

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

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

1042 
s>last_mv[i][j][1] >> 1); 
1043 
s>last_mv[i][j][1] = val << 1; 
1044 
s>mv[i][j][1] = val;

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

1046 
} 
1047 
} else {

1048 
s>field_select[i][0] = get_bits1(&s>gb);

1049 
for(k=0;k<2;k++) { 
1050 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
1051 
s>last_mv[i][0][k]);

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

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

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

1055 
} 
1056 
} 
1057 
break;

1058 
case MT_DMV:

1059 
{ 
1060 
int dmx, dmy, mx, my, m;

1061  
1062 
mx = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

1063 
s>last_mv[i][0][0]); 
1064 
s>last_mv[i][0][0] = mx; 
1065 
s>last_mv[i][1][0] = mx; 
1066 
dmx = get_dmv(s); 
1067 
my = mpeg_decode_motion(s, s>mpeg_f_code[i][1],

1068 
s>last_mv[i][0][1] >> 1); 
1069 
dmy = get_dmv(s); 
1070 
s>mv_type = MV_TYPE_DMV; 
1071 
/* XXX: totally broken */

1072 
if (s>picture_structure == PICT_FRAME) {

1073 
s>last_mv[i][0][1] = my << 1; 
1074 
s>last_mv[i][1][1] = my << 1; 
1075  
1076 
m = s>top_field_first ? 1 : 3; 
1077 
/* top > top pred */

1078 
s>mv[i][0][0] = mx; 
1079 
s>mv[i][0][1] = my << 1; 
1080 
s>mv[i][1][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
1081 
s>mv[i][1][1] = ((my * m + (my > 0)) >> 1) + dmy  1; 
1082 
m = 4  m;

1083 
s>mv[i][2][0] = mx; 
1084 
s>mv[i][2][1] = my << 1; 
1085 
s>mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
1086 
s>mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 
1087 
} else {

1088 
s>last_mv[i][0][1] = my; 
1089 
s>last_mv[i][1][1] = my; 
1090 
s>mv[i][0][0] = mx; 
1091 
s>mv[i][0][1] = my; 
1092 
s>mv[i][1][0] = ((mx + (mx > 0)) >> 1) + dmx; 
1093 
s>mv[i][1][1] = ((my + (my > 0)) >> 1) + dmy  1 
1094 
/* + 2 * cur_field */;

1095 
} 
1096 
} 
1097 
break;

1098 
} 
1099 
} 
1100 
} 
1101 
} 
1102  
1103 
if ((mb_type & MB_INTRA) && s>concealment_motion_vectors) {

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

1105 
} 
1106 

1107 
if (mb_type & MB_PAT) {

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

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

1111 
return 1; 
1112 
} 
1113 
cbp++; 
1114 
} 
1115 
dprintf("cbp=%x\n", cbp);

1116  
1117 
if (s>mpeg2) {

1118 
if (s>mb_intra) {

1119 
for(i=0;i<6;i++) { 
1120 
if (mpeg2_decode_block_intra(s, block[i], i) < 0) 
1121 
return 1; 
1122 
} 
1123 
} else {

1124 
for(i=0;i<6;i++) { 
1125 
if (cbp & 32) { 
1126 
if (mpeg2_decode_block_non_intra(s, block[i], i) < 0) 
1127 
return 1; 
1128 
} else {

1129 
s>block_last_index[i] = 1;

1130 
} 
1131 
cbp+=cbp; 
1132 
} 
1133 
} 
1134 
} else {

1135 
if (s>mb_intra) {

1136 
for(i=0;i<6;i++) { 
1137 
if (mpeg1_decode_block_intra(s, block[i], i) < 0) 
1138 
return 1; 
1139 
} 
1140 
}else{

1141 
for(i=0;i<6;i++) { 
1142 
if (cbp & 32) { 
1143 
if (mpeg1_decode_block_inter(s, block[i], i) < 0) 
1144 
return 1; 
1145 
} else {

1146 
s>block_last_index[i] = 1;

1147 
} 
1148 
cbp+=cbp; 
1149 
} 
1150 
} 
1151 
} 
1152 
return 0; 
1153 
} 
1154  
1155 
/* as h263, but only 17 codes */

1156 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) 
1157 
{ 
1158 
int code, sign, val, m, l, shift;

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

1161 
if (code < 0) { 
1162 
return 0xffff; 
1163 
} 
1164 
if (code == 0) { 
1165 
return pred;

1166 
} 
1167 
sign = get_bits1(&s>gb); 
1168 
shift = fcode  1;

1169 
val = (code  1) << shift;

1170 
if (shift > 0) 
1171 
val = get_bits(&s>gb, shift); 
1172 
val++; 
1173 
if (sign)

1174 
val = val; 
1175 
val += pred; 
1176 

1177 
/* modulo decoding */

1178 
l = (1 << shift) * 16; 
1179 
m = 2 * l;

1180 
if (val < l) {

1181 
val += m; 
1182 
} else if (val >= l) { 
1183 
val = m; 
1184 
} 
1185 
return val;

1186 
} 
1187  
1188 
static inline int decode_dc(MpegEncContext *s, int component) 
1189 
{ 
1190 
int code, diff;

1191  
1192 
if (component == 0) { 
1193 
code = get_vlc2(&s>gb, dc_lum_vlc.table, DC_VLC_BITS, 2);

1194 
} else {

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

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

1199 
return 0xffff; 
1200 
} 
1201 
if (code == 0) { 
1202 
diff = 0;

1203 
} else {

1204 
diff = get_bits(&s>gb, code); 
1205 
if ((diff & (1 << (code  1))) == 0) 
1206 
diff = (1 << code)  (diff + 1); 
1207 
} 
1208 
return diff;

1209 
} 
1210  
1211 
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1212 
DCTELEM *block, 
1213 
int n)

1214 
{ 
1215 
int level, dc, diff, i, j, run;

1216 
int component;

1217 
RLTable *rl = &rl_mpeg1; 
1218 
uint8_t * const scantable= s>intra_scantable.permutated;

1219 
const uint16_t *quant_matrix= s>intra_matrix;

1220 
const int qscale= s>qscale; 
1221  
1222 
/* DC coef */

1223 
component = (n <= 3 ? 0 : n  4 + 1); 
1224 
diff = decode_dc(s, component); 
1225 
if (diff >= 0xffff) 
1226 
return 1; 
1227 
dc = s>last_dc[component]; 
1228 
dc += diff; 
1229 
s>last_dc[component] = dc; 
1230 
block[0] = dc<<3; 
1231 
dprintf("dc=%d diff=%d\n", dc, diff);

1232 
i = 0;

1233 
{ 
1234 
OPEN_READER(re, &s>gb); 
1235 
/* now quantify & encode AC coefs */

1236 
for(;;) {

1237 
UPDATE_CACHE(re, &s>gb); 
1238 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1239 

1240 
if(level == 127){ 
1241 
break;

1242 
} else if(level != 0) { 
1243 
i += run; 
1244 
j = scantable[i]; 
1245 
level= (level*qscale*quant_matrix[j])>>3;

1246 
level= (level1)1; 
1247 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1248 
LAST_SKIP_BITS(re, &s>gb, 1);

1249 
} else {

1250 
/* escape */

1251 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1252 
UPDATE_CACHE(re, &s>gb); 
1253 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1254 
if (level == 128) { 
1255 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1256 
} else if (level == 0) { 
1257 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1258 
} 
1259 
i += run; 
1260 
j = scantable[i]; 
1261 
if(level<0){ 
1262 
level= level; 
1263 
level= (level*qscale*quant_matrix[j])>>3;

1264 
level= (level1)1; 
1265 
level= level; 
1266 
}else{

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

1268 
level= (level1)1; 
1269 
} 
1270 
} 
1271 
if (i > 63){ 
1272 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1273 
return 1; 
1274 
} 
1275  
1276 
block[j] = level; 
1277 
} 
1278 
CLOSE_READER(re, &s>gb); 
1279 
} 
1280 
s>block_last_index[n] = i; 
1281 
return 0; 
1282 
} 
1283  
1284 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1285 
DCTELEM *block, 
1286 
int n)

1287 
{ 
1288 
int level, i, j, run;

1289 
RLTable *rl = &rl_mpeg1; 
1290 
uint8_t * const scantable= s>intra_scantable.permutated;

1291 
const uint16_t *quant_matrix= s>inter_matrix;

1292 
const int qscale= s>qscale; 
1293  
1294 
{ 
1295 
int v;

1296 
OPEN_READER(re, &s>gb); 
1297 
i = 1;

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

1299 
UPDATE_CACHE(re, &s>gb); 
1300 
v= SHOW_UBITS(re, &s>gb, 2);

1301 
if (v & 2) { 
1302 
LAST_SKIP_BITS(re, &s>gb, 2);

1303 
level= (3*qscale*quant_matrix[0])>>4; 
1304 
level= (level1)1; 
1305 
if(v&1) 
1306 
level= level; 
1307 
block[0] = level;

1308 
i++; 
1309 
} 
1310  
1311 
/* now quantify & encode AC coefs */

1312 
for(;;) {

1313 
UPDATE_CACHE(re, &s>gb); 
1314 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1315 

1316 
if(level == 127){ 
1317 
break;

1318 
} else if(level != 0) { 
1319 
i += run; 
1320 
j = scantable[i]; 
1321 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1322 
level= (level1)1; 
1323 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1324 
LAST_SKIP_BITS(re, &s>gb, 1);

1325 
} else {

1326 
/* escape */

1327 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1328 
UPDATE_CACHE(re, &s>gb); 
1329 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1330 
if (level == 128) { 
1331 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1332 
} else if (level == 0) { 
1333 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1334 
} 
1335 
i += run; 
1336 
j = scantable[i]; 
1337 
if(level<0){ 
1338 
level= level; 
1339 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1340 
level= (level1)1; 
1341 
level= level; 
1342 
}else{

1343 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1344 
level= (level1)1; 
1345 
} 
1346 
} 
1347 
if (i > 63){ 
1348 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1349 
return 1; 
1350 
} 
1351  
1352 
block[j] = level; 
1353 
} 
1354 
CLOSE_READER(re, &s>gb); 
1355 
} 
1356 
s>block_last_index[n] = i; 
1357 
return 0; 
1358 
} 
1359  
1360 
/* Also does unquantization here, since I will never support mpeg2

1361 
encoding */

1362 
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1363 
DCTELEM *block, 
1364 
int n)

1365 
{ 
1366 
int level, i, j, run;

1367 
RLTable *rl = &rl_mpeg1; 
1368 
uint8_t * const scantable= s>intra_scantable.permutated;

1369 
const uint16_t *quant_matrix;

1370 
const int qscale= s>qscale; 
1371 
int mismatch;

1372  
1373 
mismatch = 1;

1374  
1375 
{ 
1376 
int v;

1377 
OPEN_READER(re, &s>gb); 
1378 
i = 1;

1379 
if (n < 4) 
1380 
quant_matrix = s>inter_matrix; 
1381 
else

1382 
quant_matrix = s>chroma_inter_matrix; 
1383  
1384 
/* special case for the first coef. no need to add a second vlc table */

1385 
UPDATE_CACHE(re, &s>gb); 
1386 
v= SHOW_UBITS(re, &s>gb, 2);

1387 
if (v & 2) { 
1388 
LAST_SKIP_BITS(re, &s>gb, 2);

1389 
level= (3*qscale*quant_matrix[0])>>5; 
1390 
if(v&1) 
1391 
level= level; 
1392 
block[0] = level;

1393 
mismatch ^= level; 
1394 
i++; 
1395 
} 
1396  
1397 
/* now quantify & encode AC coefs */

1398 
for(;;) {

1399 
UPDATE_CACHE(re, &s>gb); 
1400 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1401 

1402 
if(level == 127){ 
1403 
break;

1404 
} else if(level != 0) { 
1405 
i += run; 
1406 
j = scantable[i]; 
1407 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1408 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1409 
LAST_SKIP_BITS(re, &s>gb, 1);

1410 
} else {

1411 
/* escape */

1412 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1413 
UPDATE_CACHE(re, &s>gb); 
1414 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1415  
1416 
i += run; 
1417 
j = scantable[i]; 
1418 
if(level<0){ 
1419 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1420 
level= level; 
1421 
}else{

1422 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1423 
} 
1424 
} 
1425 
if (i > 63){ 
1426 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1427 
return 1; 
1428 
} 
1429 

1430 
mismatch ^= level; 
1431 
block[j] = level; 
1432 
} 
1433 
CLOSE_READER(re, &s>gb); 
1434 
} 
1435 
block[63] ^= (mismatch & 1); 
1436 

1437 
s>block_last_index[n] = i; 
1438 
return 0; 
1439 
} 
1440  
1441 
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1442 
DCTELEM *block, 
1443 
int n)

1444 
{ 
1445 
int level, dc, diff, i, j, run;

1446 
int component;

1447 
RLTable *rl; 
1448 
uint8_t * const scantable= s>intra_scantable.permutated;

1449 
const uint16_t *quant_matrix;

1450 
const int qscale= s>qscale; 
1451 
int mismatch;

1452  
1453 
/* DC coef */

1454 
if (n < 4){ 
1455 
quant_matrix = s>intra_matrix; 
1456 
component = 0;

1457 
}else{

1458 
quant_matrix = s>chroma_intra_matrix; 
1459 
component = n  3;

1460 
} 
1461 
diff = decode_dc(s, component); 
1462 
if (diff >= 0xffff) 
1463 
return 1; 
1464 
dc = s>last_dc[component]; 
1465 
dc += diff; 
1466 
s>last_dc[component] = dc; 
1467 
block[0] = dc << (3  s>intra_dc_precision); 
1468 
dprintf("dc=%d\n", block[0]); 
1469 
mismatch = block[0] ^ 1; 
1470 
i = 0;

1471 
if (s>intra_vlc_format)

1472 
rl = &rl_mpeg2; 
1473 
else

1474 
rl = &rl_mpeg1; 
1475  
1476 
{ 
1477 
OPEN_READER(re, &s>gb); 
1478 
/* now quantify & encode AC coefs */

1479 
for(;;) {

1480 
UPDATE_CACHE(re, &s>gb); 
1481 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1482 

1483 
if(level == 127){ 
1484 
break;

1485 
} else if(level != 0) { 
1486 
i += run; 
1487 
j = scantable[i]; 
1488 
level= (level*qscale*quant_matrix[j])>>4;

1489 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1490 
LAST_SKIP_BITS(re, &s>gb, 1);

1491 
} else {

1492 
/* escape */

1493 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1494 
UPDATE_CACHE(re, &s>gb); 
1495 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1496 
i += run; 
1497 
j = scantable[i]; 
1498 
if(level<0){ 
1499 
level= (level*qscale*quant_matrix[j])>>4;

1500 
level= level; 
1501 
}else{

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

1503 
} 
1504 
} 
1505 
if (i > 63){ 
1506 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1507 
return 1; 
1508 
} 
1509 

1510 
mismatch^= level; 
1511 
block[j] = level; 
1512 
} 
1513 
CLOSE_READER(re, &s>gb); 
1514 
} 
1515 
block[63]^= mismatch&1; 
1516 

1517 
s>block_last_index[n] = i; 
1518 
return 0; 
1519 
} 
1520  
1521 
/* compressed picture size */

1522 
#define PICTURE_BUFFER_SIZE 100000 
1523  
1524 
typedef struct Mpeg1Context { 
1525 
MpegEncContext mpeg_enc_ctx; 
1526 
uint32_t header_state; 
1527 
int start_code; /* current start code */ 
1528 
uint8_t buffer[PICTURE_BUFFER_SIZE]; 
1529 
uint8_t *buf_ptr; 
1530 
int buffer_size;

1531 
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 
1532 
int repeat_field; /* true if we must repeat the field */ 
1533 
} Mpeg1Context; 
1534  
1535 
static int mpeg_decode_init(AVCodecContext *avctx) 
1536 
{ 
1537 
Mpeg1Context *s = avctx>priv_data; 
1538 

1539 
s>mpeg_enc_ctx.flags= avctx>flags; 
1540 
common_init(&s>mpeg_enc_ctx); 
1541 
init_vlcs(&s>mpeg_enc_ctx); 
1542  
1543 
s>header_state = 0xff;

1544 
s>mpeg_enc_ctx_allocated = 0;

1545 
s>buffer_size = PICTURE_BUFFER_SIZE; 
1546 
s>start_code = 1;

1547 
s>buf_ptr = s>buffer; 
1548 
s>mpeg_enc_ctx.picture_number = 0;

1549 
s>repeat_field = 0;

1550 
s>mpeg_enc_ctx.codec_id= avctx>codec>id; 
1551 
return 0; 
1552 
} 
1553  
1554 
/* return the 8 bit start code value and update the search

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

1556 
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end, 
1557 
uint32_t *header_state) 
1558 
{ 
1559 
uint8_t *buf_ptr; 
1560 
unsigned int state, v; 
1561 
int val;

1562  
1563 
state = *header_state; 
1564 
buf_ptr = *pbuf_ptr; 
1565 
while (buf_ptr < buf_end) {

1566 
v = *buf_ptr++; 
1567 
if (state == 0x000001) { 
1568 
state = ((state << 8)  v) & 0xffffff; 
1569 
val = state; 
1570 
goto found;

1571 
} 
1572 
state = ((state << 8)  v) & 0xffffff; 
1573 
} 
1574 
val = 1;

1575 
found:

1576 
*pbuf_ptr = buf_ptr; 
1577 
*header_state = state; 
1578 
return val;

1579 
} 
1580  
1581 
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1582 
uint8_t *buf, int buf_size)

1583 
{ 
1584 
Mpeg1Context *s1 = avctx>priv_data; 
1585 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1586 
int ref, f_code;

1587  
1588 
init_get_bits(&s>gb, buf, buf_size*8);

1589  
1590 
ref = get_bits(&s>gb, 10); /* temporal ref */ 
1591 
s>pict_type = get_bits(&s>gb, 3);

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

1593  
1594 
skip_bits(&s>gb, 16);

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

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

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

1598 
if (f_code == 0) 
1599 
return 1; 
1600 
s>mpeg_f_code[0][0] = f_code; 
1601 
s>mpeg_f_code[0][1] = f_code; 
1602 
} 
1603 
if (s>pict_type == B_TYPE) {

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

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

1606 
if (f_code == 0) 
1607 
return 1; 
1608 
s>mpeg_f_code[1][0] = f_code; 
1609 
s>mpeg_f_code[1][1] = f_code; 
1610 
} 
1611 
s>current_picture.pict_type= s>pict_type; 
1612 
s>current_picture.key_frame= s>pict_type == I_TYPE; 
1613 

1614 
s>y_dc_scale = 8;

1615 
s>c_dc_scale = 8;

1616 
s>first_slice = 1;

1617 
return 0; 
1618 
} 
1619  
1620 
static void mpeg_decode_sequence_extension(MpegEncContext *s) 
1621 
{ 
1622 
int horiz_size_ext, vert_size_ext;

1623 
int bit_rate_ext, vbv_buf_ext;

1624 
int frame_rate_ext_n, frame_rate_ext_d;

1625 
float aspect;

1626  
1627 
skip_bits(&s>gb, 8); /* profil and level */ 
1628 
s>progressive_sequence = get_bits1(&s>gb); /* progressive_sequence */

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

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

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

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

1634 
bit_rate_ext = get_bits(&s>gb, 12); /* XXX: handle it */ 
1635 
s>bit_rate = ((s>bit_rate / 400)  (bit_rate_ext << 12)) * 400; 
1636 
skip_bits1(&s>gb); /* marker */

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

1638 
s>low_delay = get_bits1(&s>gb); 
1639 
frame_rate_ext_n = get_bits(&s>gb, 2);

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

1641 
if (frame_rate_ext_d >= 1) 
1642 
s>frame_rate = (s>frame_rate * frame_rate_ext_n) / frame_rate_ext_d; 
1643 
dprintf("sequence extension\n");

1644 
s>mpeg2 = 1;

1645 
s>avctx>sub_id = 2; /* indicates mpeg2 found */ 
1646  
1647 
aspect= mpeg2_aspect[s>aspect_ratio_info]; 
1648 
if(aspect>0.0) s>avctx>aspect_ratio= s>width/(aspect*s>height); 
1649 
else if(aspect<0.0) s>avctx>aspect_ratio= 1.0/aspect; 
1650 
} 
1651  
1652 
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 
1653 
{ 
1654 
int i, v, j;

1655  
1656 
dprintf("matrix extension\n");

1657  
1658 
if (get_bits1(&s>gb)) {

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

1661 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1662 
s>intra_matrix[j] = v; 
1663 
s>chroma_intra_matrix[j] = v; 
1664 
} 
1665 
} 
1666 
if (get_bits1(&s>gb)) {

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

1669 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1670 
s>inter_matrix[j] = v; 
1671 
s>chroma_inter_matrix[j] = v; 
1672 
} 
1673 
} 
1674 
if (get_bits1(&s>gb)) {

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

1677 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1678 
s>chroma_intra_matrix[j] = v; 
1679 
} 
1680 
} 
1681 
if (get_bits1(&s>gb)) {

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

1684 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1685 
s>chroma_inter_matrix[j] = v; 
1686 
} 
1687 
} 
1688 
} 
1689  
1690 
static void mpeg_decode_picture_coding_extension(MpegEncContext *s) 
1691 
{ 
1692 
s>full_pel[0] = s>full_pel[1] = 0; 
1693 
s>mpeg_f_code[0][0] = get_bits(&s>gb, 4); 
1694 
s>mpeg_f_code[0][1] = get_bits(&s>gb, 4); 
1695 
s>mpeg_f_code[1][0] = get_bits(&s>gb, 4); 
1696 
s>mpeg_f_code[1][1] = get_bits(&s>gb, 4); 
1697 
s>intra_dc_precision = get_bits(&s>gb, 2);

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

1699 
s>top_field_first = get_bits1(&s>gb); 
1700 
s>frame_pred_frame_dct = get_bits1(&s>gb); 
1701 
s>concealment_motion_vectors = get_bits1(&s>gb); 
1702 
s>q_scale_type = get_bits1(&s>gb); 
1703 
s>intra_vlc_format = get_bits1(&s>gb); 
1704 
s>alternate_scan = get_bits1(&s>gb); 
1705 
s>repeat_first_field = get_bits1(&s>gb); 
1706 
s>chroma_420_type = get_bits1(&s>gb); 
1707 
s>progressive_frame = get_bits1(&s>gb); 
1708 

1709 
if(s>picture_structure == PICT_FRAME)

1710 
s>first_field=0;

1711 
else{

1712 
s>first_field ^= 1;

1713 
memset(s>mbskip_table, 0, s>mb_width*s>mb_height);

1714 
} 
1715 

1716 
if(s>alternate_scan){

1717 
ff_init_scantable(s, &s>inter_scantable , ff_alternate_vertical_scan); 
1718 
ff_init_scantable(s, &s>intra_scantable , ff_alternate_vertical_scan); 
1719 
ff_init_scantable(s, &s>intra_h_scantable, ff_alternate_vertical_scan); 
1720 
ff_init_scantable(s, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1721 
}else{

1722 
ff_init_scantable(s, &s>inter_scantable , ff_zigzag_direct); 
1723 
ff_init_scantable(s, &s>intra_scantable , ff_zigzag_direct); 
1724 
ff_init_scantable(s, &s>intra_h_scantable, ff_alternate_horizontal_scan); 
1725 
ff_init_scantable(s, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1726 
} 
1727 

1728 
/* composite display not parsed */

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

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

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

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

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

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

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

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

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

1738 
} 
1739  
1740 
static void mpeg_decode_extension(AVCodecContext *avctx, 
1741 
uint8_t *buf, int buf_size)

1742 
{ 
1743 
Mpeg1Context *s1 = avctx>priv_data; 
1744 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1745 
int ext_type;

1746  
1747 
init_get_bits(&s>gb, buf, buf_size*8);

1748 

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

1750 
switch(ext_type) {

1751 
case 0x1: 
1752 
/* sequence ext */

1753 
mpeg_decode_sequence_extension(s); 
1754 
break;

1755 
case 0x3: 
1756 
/* quant matrix extension */

1757 
mpeg_decode_quant_matrix_extension(s); 
1758 
break;

1759 
case 0x8: 
1760 
/* picture extension */

1761 
mpeg_decode_picture_coding_extension(s); 
1762 
break;

1763 
} 
1764 
} 
1765  
1766 
#define DECODE_SLICE_FATAL_ERROR 2 
1767 
#define DECODE_SLICE_ERROR 1 
1768 
#define DECODE_SLICE_OK 0 
1769 
#define DECODE_SLICE_EOP 1 
1770  
1771 
/**

1772 
* decodes a slice.

1773 
* @return DECODE_SLICE_FATAL_ERROR if a non recoverable error occured<br>

1774 
* DECODE_SLICE_ERROR if the slice is damaged<br>

1775 
* DECODE_SLICE_OK if this slice is ok<br>

1776 
* DECODE_SLICE_EOP if the end of the picture is reached

1777 
*/

1778 
static int mpeg_decode_slice(AVCodecContext *avctx, 
1779 
AVFrame *pict, 
1780 
int start_code,

1781 
uint8_t *buf, int buf_size)

1782 
{ 
1783 
Mpeg1Context *s1 = avctx>priv_data; 
1784 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1785 
int ret;

1786 
const int field_pic= s>picture_structure != PICT_FRAME; 
1787  
1788 
start_code = (start_code  1) & 0xff; 
1789 
if (start_code >= s>mb_height){

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

1791 
return DECODE_SLICE_ERROR;

1792 
} 
1793 
s>last_dc[0] = 1 << (7 + s>intra_dc_precision); 
1794 
s>last_dc[1] = s>last_dc[0]; 
1795 
s>last_dc[2] = s>last_dc[0]; 
1796 
memset(s>last_mv, 0, sizeof(s>last_mv)); 
1797 

1798 
/* start frame decoding */

1799 
if (s>first_slice && (s>first_field  s>picture_structure==PICT_FRAME)) {

1800 
if(MPV_frame_start(s, avctx) < 0) 
1801 
return DECODE_SLICE_FATAL_ERROR;

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

1803 
s>current_picture.repeat_pict = 0;

1804  
1805 
if (s>repeat_first_field) {

1806 
if (s>progressive_sequence) {

1807 
if (s>top_field_first)

1808 
s>current_picture.repeat_pict = 4;

1809 
else

1810 
s>current_picture.repeat_pict = 2;

1811 
} else if (s>progressive_frame) { 
1812 
s>current_picture.repeat_pict = 1;

1813 
} 
1814 
} 
1815 
// printf("%d \n", s>current_picture.repeat_pict);

1816  
1817 
if(s>avctx>debug&FF_DEBUG_PICT_INFO){

1818 
printf("qp:%d fc:%2d%2d%2d%2d %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",

1819 
s>qscale, s>mpeg_f_code[0][0],s>mpeg_f_code[0][1],s>mpeg_f_code[1][0],s>mpeg_f_code[1][1], 
1820 
s>pict_type == I_TYPE ? "I" : (s>pict_type == P_TYPE ? "P" : (s>pict_type == B_TYPE ? "B" : "S")), 
1821 
s>progressive_sequence ? "pro" :"", s>alternate_scan ? "alt" :"", s>top_field_first ? "top" :"", 
1822 
s>intra_dc_precision, s>picture_structure, s>frame_pred_frame_dct, s>concealment_motion_vectors, 
1823 
s>q_scale_type, s>intra_vlc_format, s>repeat_first_field, s>chroma_420_type ? "420" :""); 
1824 
} 
1825 
} 
1826 
s>first_slice = 0;

1827  
1828 
init_get_bits(&s>gb, buf, buf_size*8);

1829  
1830 
s>qscale = get_qscale(s); 
1831 
/* extra slice info */

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

1834 
} 
1835  
1836 
s>mb_x=0;

1837 
for(;;) {

1838 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
1839 
if (code < 0) 
1840 
return 1; /* error = end of slice, but empty slice is bad or?*/ 
1841 
if (code >= 33) { 
1842 
if (code == 33) { 
1843 
s>mb_x += 33;

1844 
} 
1845 
/* otherwise, stuffing, nothing to do */

1846 
} else {

1847 
s>mb_x += code; 
1848 
break;

1849 
} 
1850 
} 
1851 
s>mb_y = start_code; 
1852 
s>mb_incr= 1;

1853  
1854 
for(;;) {

1855 
s>dsp.clear_blocks(s>block[0]);

1856 

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

1859 
if (ret < 0) 
1860 
return 1; 
1861 
//printf("%d %d\n", s>mb_x, s>mb_y);

1862 
//FIXME this isnt the most beautifull way to solve the problem ...

1863 
if(s>picture_structure!=PICT_FRAME){

1864 
if(s>picture_structure == PICT_BOTTOM_FIELD){

1865 
s>current_picture.data[0] += s>linesize;

1866 
s>current_picture.data[1] += s>uvlinesize;

1867 
s>current_picture.data[2] += s>uvlinesize;

1868 
} 
1869 
s>linesize *= 2;

1870 
s>uvlinesize *= 2;

1871 
} 
1872 
MPV_decode_mb(s, s>block); 
1873 
if(s>picture_structure!=PICT_FRAME){

1874 
s>linesize /= 2;

1875 
s>uvlinesize /= 2;

1876 
if(s>picture_structure == PICT_BOTTOM_FIELD){

1877 
s>current_picture.data[0] = s>linesize;

1878 
s>current_picture.data[1] = s>uvlinesize;

1879 
s>current_picture.data[2] = s>uvlinesize;

1880 
} 
1881 
} 
1882  
1883 
if (++s>mb_x >= s>mb_width) {

1884 
if(s>picture_structure==PICT_FRAME){

1885 
ff_draw_horiz_band(s, 16*s>mb_y, 16); 
1886 
}else{

1887 
if(!s>first_field){

1888 
ff_draw_horiz_band(s, 32*s>mb_y, 32); 
1889 
} 
1890 
} 
1891  
1892 
s>mb_x = 0;

1893 
s>mb_y++; 
1894 
PRINT_QP("%s", "\n"); 
1895 
} 
1896 
PRINT_QP("%2d", s>qscale);

1897  
1898 
/* skip mb handling */

1899 
if (s>mb_incr == 0) { 
1900 
/* read again increment */

1901 
s>mb_incr = 1;

1902 
for(;;) {

1903 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
1904 
if (code < 0) 
1905 
goto eos; /* error = end of slice */ 
1906 
if (code >= 33) { 
1907 
if (code == 33) { 
1908 
s>mb_incr += 33;

1909 
} 
1910 
/* otherwise, stuffing, nothing to do */

1911 
} else {

1912 
s>mb_incr += code; 
1913 
break;

1914 
} 
1915 
} 
1916 
} 
1917 
if(s>mb_y<<field_pic >= s>mb_height){

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

1919 
return DECODE_SLICE_ERROR;

1920 
} 
1921 
} 
1922 
eos: //end of slice 
1923 

1924 
emms_c(); 
1925 
//intf("%d %d %d %d\n", s>mb_y, s>mb_height, s>pict_type, s>picture_number);

1926 
/* end of slice reached */

1927 
if (s>mb_y<<field_pic == s>mb_height && !s>first_field) {

1928 
/* end of image */

1929  
1930 
if(s>mpeg2)

1931 
s>qscale >>=1;

1932  
1933 
MPV_frame_end(s); 
1934  
1935 
if (s>pict_type == B_TYPE  s>low_delay) {

1936 
*pict= *(AVFrame*)&s>current_picture; 
1937 
} else {

1938 
s>picture_number++; 
1939 
/* latency of 1 frame for I and P frames */

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

1941 
if (s>last_picture.data[0] == NULL) { 
1942 
return DECODE_SLICE_OK;

1943 
} else {

1944 
*pict= *(AVFrame*)&s>last_picture; 
1945 
} 
1946 
} 
1947 
return DECODE_SLICE_EOP;

1948 
} else {

1949 
return DECODE_SLICE_OK;

1950 
} 
1951 
} 
1952  
1953 
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
1954 
uint8_t *buf, int buf_size)

1955 
{ 
1956 
Mpeg1Context *s1 = avctx>priv_data; 
1957 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1958 
int width, height, i, v, j;

1959 
float aspect;

1960  
1961 
init_get_bits(&s>gb, buf, buf_size*8);

1962  
1963 
width = get_bits(&s>gb, 12);

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

1965 
s>aspect_ratio_info= get_bits(&s>gb, 4);

1966 
if(!s>mpeg2){

1967 
aspect= mpeg1_aspect[s>aspect_ratio_info]; 
1968 
if(aspect!=0.0) avctx>aspect_ratio= width/(aspect*height); 
1969 
} 
1970  
1971 
s>frame_rate_index = get_bits(&s>gb, 4);

1972 
if (s>frame_rate_index == 0) 
1973 
return 1; 
1974 
s>bit_rate = get_bits(&s>gb, 18) * 400; 
1975 
if (get_bits1(&s>gb) == 0) /* marker */ 
1976 
return 1; 
1977 
if (width <= 0  height <= 0  
1978 
(width % 2) != 0  (height % 2) != 0) 
1979 
return 1; 
1980 
if (width != s>width 

1981 
height != s>height) { 
1982 
/* start new mpeg1 context decoding */

1983 
s>out_format = FMT_MPEG1; 
1984 
if (s1>mpeg_enc_ctx_allocated) {

1985 
MPV_common_end(s); 
1986 
} 
1987 
s>width = width; 
1988 
s>height = height; 
1989 
avctx>has_b_frames= 1;

1990 
s>avctx = avctx; 
1991 
avctx>width = width; 
1992 
avctx>height = height; 
1993 
if (s>frame_rate_index >= 9) { 
1994 
/* at least give a valid frame rate (some old mpeg1 have this) */

1995 
avctx>frame_rate = 25 * FRAME_RATE_BASE;

1996 
} else {

1997 
avctx>frame_rate = frame_rate_tab[s>frame_rate_index]; 
1998 
} 
1999 
s>frame_rate = avctx>frame_rate; 
2000 
avctx>bit_rate = s>bit_rate; 
2001 

2002 
if (MPV_common_init(s) < 0) 
2003 
return 1; 
2004 
s1>mpeg_enc_ctx_allocated = 1;

2005 
} 
2006  
2007 
skip_bits(&s>gb, 10); /* vbv_buffer_size */ 
2008 
skip_bits(&s>gb, 1);

2009  
2010 
/* get matrix */

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

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

2014 
j = s>intra_scantable.permutated[i]; 
2015 
s>intra_matrix[j] = v; 
2016 
s>chroma_intra_matrix[j] = v; 
2017 
} 
2018 
#ifdef DEBUG

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

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

2022 
printf("\n");

2023 
#endif

2024 
} else {

2025 
for(i=0;i<64;i++) { 
2026 
int j= s>dsp.idct_permutation[i];

2027 
v = ff_mpeg1_default_intra_matrix[i]; 
2028 
s>intra_matrix[j] = v; 
2029 
s>chroma_intra_matrix[j] = v; 
2030 
} 
2031 
} 
2032 
if (get_bits1(&s>gb)) {

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

2035 
j = s>intra_scantable.permutated[i]; 
2036 
s>inter_matrix[j] = v; 
2037 
s>chroma_inter_matrix[j] = v; 
2038 
} 
2039 
#ifdef DEBUG

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

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

2043 
printf("\n");

2044 
#endif

2045 
} else {

2046 
for(i=0;i<64;i++) { 
2047 
int j= s>dsp.idct_permutation[i];

2048 
v = ff_mpeg1_default_non_intra_matrix[i]; 
2049 
s>inter_matrix[j] = v; 
2050 
s>chroma_inter_matrix[j] = v; 
2051 
} 
2052 
} 
2053  
2054 
/* we set mpeg2 parameters so that it emulates mpeg1 */

2055 
s>progressive_sequence = 1;

2056 
s>progressive_frame = 1;

2057 
s>picture_structure = PICT_FRAME; 
2058 
s>frame_pred_frame_dct = 1;

2059 
s>mpeg2 = 0;

2060 
avctx>sub_id = 1; /* indicates mpeg1 */ 
2061 
return 0; 
2062 
} 
2063  
2064 
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2065 
const uint8_t *buf, int buf_size) 
2066 
{ 
2067 
const uint8_t *p;

2068 
int len, flags;

2069 
p = buf; 
2070 
len = buf_size; 
2071  
2072 
/* we parse the DTG active format information */

2073 
if (len >= 5 && 
2074 
p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { 
2075 
flags = p[4];

2076 
p += 5;

2077 
len = 5;

2078 
if (flags & 0x80) { 
2079 
/* skip event id */

2080 
if (len < 2) 
2081 
return;

2082 
p += 2;

2083 
len = 2;

2084 
} 
2085 
if (flags & 0x40) { 
2086 
if (len < 1) 
2087 
return;

2088 
avctx>dtg_active_format = p[0] & 0x0f; 
2089 
} 
2090 
} 
2091 
} 
2092  
2093 
/* handle buffering and image synchronisation */

2094 
static int mpeg_decode_frame(AVCodecContext *avctx, 
2095 
void *data, int *data_size, 
2096 
uint8_t *buf, int buf_size)

2097 
{ 
2098 
Mpeg1Context *s = avctx>priv_data; 
2099 
uint8_t *buf_end, *buf_ptr, *buf_start; 
2100 
int len, start_code_found, ret, code, start_code, input_size;

2101 
AVFrame *picture = data; 
2102 
MpegEncContext *s2 = &s>mpeg_enc_ctx; 
2103 

2104 
dprintf("fill_buffer\n");

2105  
2106 
*data_size = 0;

2107  
2108 
/* special case for last picture */

2109 
if (buf_size == 0) { 
2110 
if (s2>picture_number > 0) { 
2111 
*picture= *(AVFrame*)&s2>next_picture; 
2112  
2113 
*data_size = sizeof(AVFrame);

2114 
} 
2115 
return 0; 
2116 
} 
2117  
2118 
buf_ptr = buf; 
2119 
buf_end = buf + buf_size; 
2120  
2121 
#if 0

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

2123 
s>repeat_field++;

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

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

2126 
if (avctx>flags & CODEC_FLAG_REPEAT_FIELD) {

2127 
*data_size = sizeof(AVPicture);

2128 
goto the_end;

2129 
}

2130 
}

2131 
#endif

2132 
while (buf_ptr < buf_end) {

2133 
buf_start = buf_ptr; 
2134 
/* find start next code */

2135 
code = find_start_code(&buf_ptr, buf_end, &s>header_state); 
2136 
if (code >= 0) { 
2137 
start_code_found = 1;

2138 
} else {

2139 
start_code_found = 0;

2140 
} 
2141 
/* copy to buffer */

2142 
len = buf_ptr  buf_start; 
2143 
if (len + (s>buf_ptr  s>buffer) > s>buffer_size) {

2144 
/* data too big : flush */

2145 
s>buf_ptr = s>buffer; 
2146 
if (start_code_found)

2147 
s>start_code = code; 
2148 
} else {

2149 
memcpy(s>buf_ptr, buf_start, len); 
2150 
s>buf_ptr += len; 
2151 
if( (!(s2>flags&CODEC_FLAG_TRUNCATED)) && (!start_code_found)

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

2153 
start_code_found= 1;

2154 
code= 0x1FF;

2155 
s>header_state=0xFF;

2156 
s>buf_ptr[0]=0; 
2157 
s>buf_ptr[1]=0; 
2158 
s>buf_ptr[2]=1; 
2159 
s>buf_ptr[3]=0xFF; 
2160 
s>buf_ptr+=4;

2161 
} 
2162 
if (start_code_found) {

2163 
/* prepare data for next start code */

2164 
input_size = s>buf_ptr  s>buffer; 
2165 
start_code = s>start_code; 
2166 
s>buf_ptr = s>buffer; 
2167 
s>start_code = code; 
2168 
switch(start_code) {

2169 
case SEQ_START_CODE:

2170 
mpeg1_decode_sequence(avctx, s>buffer, 
2171 
input_size); 
2172 
break;

2173 

2174 
case PICTURE_START_CODE:

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

2176 
mpeg1_decode_picture(avctx, 
2177 
s>buffer, input_size); 
2178 
break;

2179 
case EXT_START_CODE:

2180 
mpeg_decode_extension(avctx, 
2181 
s>buffer, input_size); 
2182 
break;

2183 
case USER_START_CODE:

2184 
mpeg_decode_user_data(avctx, 
2185 
s>buffer, input_size); 
2186 
break;

2187 
default:

2188 
if (start_code >= SLICE_MIN_START_CODE &&

2189 
start_code <= SLICE_MAX_START_CODE) { 
2190 

2191 
/* skip b frames if we dont have reference frames */

2192 
if(s2>last_picture.data[0]==NULL && s2>pict_type==B_TYPE) break; 
2193 
/* skip b frames if we are in a hurry */

2194 
if(avctx>hurry_up && s2>pict_type==B_TYPE) break; 
2195 
/* skip everything if we are in a hurry>=5 */

2196 
if(avctx>hurry_up>=5) break; 
2197  
2198 
ret = mpeg_decode_slice(avctx, picture, 
2199 
start_code, s>buffer, input_size); 
2200  
2201 
if (ret == DECODE_SLICE_EOP) {

2202 
*data_size = sizeof(AVPicture);

2203 
goto the_end;

2204 
}else if(ret<0){ 
2205 
fprintf(stderr,"Error while decoding slice\n");

2206 
if(ret==DECODE_SLICE_FATAL_ERROR) return 1; 
2207 
} 
2208 
} 
2209 
break;

2210 
} 
2211 
} 
2212 
} 
2213 
} 
2214 
the_end:

2215 
return buf_ptr  buf;

2216 
} 
2217  
2218 
static int mpeg_decode_end(AVCodecContext *avctx) 
2219 
{ 
2220 
Mpeg1Context *s = avctx>priv_data; 
2221  
2222 
if (s>mpeg_enc_ctx_allocated)

2223 
MPV_common_end(&s>mpeg_enc_ctx); 
2224 
return 0; 
2225 
} 
2226  
2227 
AVCodec mpeg_decoder = { 
2228 
"mpegvideo",

2229 
CODEC_TYPE_VIDEO, 
2230 
CODEC_ID_MPEG1VIDEO, 
2231 
sizeof(Mpeg1Context),

2232 
mpeg_decode_init, 
2233 
NULL,

2234 
mpeg_decode_end, 
2235 
mpeg_decode_frame, 
2236 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1  CODEC_CAP_TRUNCATED, 
2237 
}; 