ffmpeg / libavcodec / mpeg12.c @ 029911d1
History  View  Annotate  Download (85.5 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/2 codec

23 
*/

24 

25 
//#define DEBUG

26 
#include "avcodec.h" 
27 
#include "dsputil.h" 
28 
#include "mpegvideo.h" 
29  
30 
#include "mpeg12data.h" 
31  
32  
33 
/* Start codes. */

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

54 
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code); // RAL: f_code parameter added 
55 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num); 
56 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
57 
DCTELEM *block, 
58 
int n);

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

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

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

68 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred); 
69  
70 
#ifdef HAVE_XVMC

71 
extern int XVMC_field_start(MpegEncContext *s, AVCodecContext *avctx); 
72 
extern int XVMC_field_end(MpegEncContext *s); 
73 
#endif

74  
75 
#ifdef CONFIG_ENCODERS

76 
static uint8_t (*mv_penalty)[MAX_MV*2+1]= NULL; 
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  
82 
/* simple include everything table for dc, first byte is bits number next 3 are code*/

83 
static uint32_t mpeg1_lum_dc_uni[512]; 
84 
static uint32_t mpeg1_chr_dc_uni[512]; 
85  
86 
static uint8_t mpeg1_index_run[2][64]; 
87 
static int8_t mpeg1_max_level[2][64]; 
88 
#endif

89  
90 
static void init_2d_vlc_rl(RLTable *rl) 
91 
{ 
92 
int i;

93 

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

95 
&rl>table_vlc[0][1], 4, 2, 
96 
&rl>table_vlc[0][0], 4, 2); 
97  
98 

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

104 

105 
if(len==0){ // illegal code 
106 
run= 65;

107 
level= MAX_LEVEL; 
108 
}else if(len<0){ //more bits needed 
109 
run= 0;

110 
level= code; 
111 
}else{

112 
if(code==rl>n){ //esc 
113 
run= 65;

114 
level= 0;

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

117 
level= 127;

118 
}else{

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

120 
level= rl>table_level[code]; 
121 
} 
122 
} 
123 
rl>rl_vlc[0][i].len= len;

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

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

126 
} 
127 
} 
128  
129 
#ifdef CONFIG_ENCODERS

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

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

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

138 

139 
int alevel= ABS(level);

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

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

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

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

159 
} else {

160 
bits<<=16; len+=16; 
161 
bits= level & 0xff;

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

165 
bits= level & 0xffff;

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

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

189 
uint64_t time_code; 
190 
float best_aspect_error= 1E10; 
191 
float aspect_ratio= s>avctx>aspect_ratio;

192 

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

195 
if (s>current_picture.key_frame) {

196 
/* mpeg1 header repeated every gop */

197 
put_header(s, SEQ_START_CODE); 
198 

199 
/* search closest frame rate */

200 
{ 
201 
int i, dmin, d;

202 
s>frame_rate_index = 0;

203 
dmin = 0x7fffffff;

204 
for(i=1;i<14;i++) { 
205 
if(s>avctx>strict_std_compliance >= 0 && i>=9) break; 
206 

207 
d = abs(MPEG1_FRAME_RATE_BASE*(int64_t)s>avctx>frame_rate/s>avctx>frame_rate_base  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 + 399) / 400; 
231 
if (v > 0x3ffff && s>codec_id == CODEC_ID_MPEG1VIDEO) 
232 
v = 0x3ffff;

233 
put_bits(&s>pb, 18, v & 0x3FFFF); 
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) & 0x3FF); 
242 
put_bits(&s>pb, 1, 1); /* constrained parameter flag */ 
243 

244 
ff_write_quant_matrix(&s>pb, s>avctx>intra_matrix); 
245 
ff_write_quant_matrix(&s>pb, s>avctx>inter_matrix); 
246  
247 
if(s>codec_id == CODEC_ID_MPEG2VIDEO){

248 
put_header(s, EXT_START_CODE); 
249 
put_bits(&s>pb, 4, 1); //seq ext 
250 
put_bits(&s>pb, 1, 0); //esc 
251 
put_bits(&s>pb, 3, 4); //profile 
252 
put_bits(&s>pb, 4, 8); //level 
253 
put_bits(&s>pb, 1, s>progressive_sequence=1); 
254 
put_bits(&s>pb, 2, 1); //chroma format 4:2:0 
255 
put_bits(&s>pb, 2, 0); //horizontal size ext 
256 
put_bits(&s>pb, 2, 0); //vertical size ext 
257 
put_bits(&s>pb, 12, v>>18); //bitrate ext 
258 
put_bits(&s>pb, 1, 1); //marker 
259 
put_bits(&s>pb, 8, vbv_buffer_size >>10); //vbv buffer ext 
260 
put_bits(&s>pb, 1, s>low_delay);

261 
put_bits(&s>pb, 2, 0); // frame_rate_ext_n 
262 
put_bits(&s>pb, 5, 0); // frame_rate_ext_d 
263 
} 
264 

265 
put_header(s, GOP_START_CODE); 
266 
put_bits(&s>pb, 1, 0); /* do drop frame */ 
267 
/* time code : we must convert from the real frame rate to a

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

269 
fps = frame_rate_tab[s>frame_rate_index]; 
270 
time_code = (int64_t)s>fake_picture_number * MPEG1_FRAME_RATE_BASE; 
271 
s>gop_picture_number = s>fake_picture_number; 
272 
put_bits(&s>pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24)); 
273 
put_bits(&s>pb, 6, (uint32_t)((time_code / (fps * 60)) % 60)); 
274 
put_bits(&s>pb, 1, 1); 
275 
put_bits(&s>pb, 6, (uint32_t)((time_code / fps) % 60)); 
276 
put_bits(&s>pb, 6, (uint32_t)((time_code % fps) / MPEG1_FRAME_RATE_BASE));

277 
put_bits(&s>pb, 1, 1); /* closed gop */ 
278 
put_bits(&s>pb, 1, 0); /* broken link */ 
279 
} 
280  
281 
if (s>avctx>frame_rate < (24 * s>avctx>frame_rate_base) && s>picture_number > 0) { 
282 
/* insert empty P pictures to slow down to the desired

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

284 
fps = frame_rate_tab[s>frame_rate_index]; 
285 
n = av_rescale((int64_t)s>picture_number * s>avctx>frame_rate_base, fps, s>avctx>frame_rate) / MPEG1_FRAME_RATE_BASE  1;

286 
while (s>fake_picture_number < n) {

287 
mpeg1_skip_picture(s, s>fake_picture_number  
288 
s>gop_picture_number); 
289 
s>fake_picture_number++; 
290 
} 
291  
292 
} 
293 
} 
294  
295 
static inline void encode_mb_skip_run(MpegEncContext *s, int run){ 
296 
while (run >= 33) { 
297 
put_bits(&s>pb, 11, 0x008); 
298 
run = 33;

299 
} 
300 
put_bits(&s>pb, mbAddrIncrTable[run][1],

301 
mbAddrIncrTable[run][0]);

302 
} 
303  
304 
/* insert a fake P picture */

305 
static void mpeg1_skip_picture(MpegEncContext *s, int pict_num) 
306 
{ 
307 
assert(s>codec_id == CODEC_ID_MPEG1VIDEO); // mpeg2 can do these repeat things

308  
309 
/* mpeg1 picture header */

310 
put_header(s, PICTURE_START_CODE); 
311 
/* temporal reference */

312 
put_bits(&s>pb, 10, pict_num & 0x3ff); 
313 

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

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

317 
put_bits(&s>pb, 1, 1); /* integer coordinates */ 
318 
put_bits(&s>pb, 3, 1); /* forward_f_code */ 
319 

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

322 
/* only one slice */

323 
put_header(s, SLICE_MIN_START_CODE); 
324 
put_bits(&s>pb, 5, 1); /* quantizer scale */ 
325 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
326 

327 
encode_mb_skip_run(s, 0);

328 

329 
/* empty macroblock */

330 
put_bits(&s>pb, 3, 1); /* motion only */ 
331 

332 
/* zero motion x & y */

333 
put_bits(&s>pb, 1, 1); 
334 
put_bits(&s>pb, 1, 1); 
335  
336 
/* output a number of empty slice */

337 
encode_mb_skip_run(s, s>mb_width * s>mb_height  2);

338 

339 
/* empty macroblock */

340 
put_bits(&s>pb, 3, 1); /* motion only */ 
341 

342 
/* zero motion x & y */

343 
put_bits(&s>pb, 1, 1); 
344 
put_bits(&s>pb, 1, 1); 
345 
} 
346 
#endif

347  
348 
static void common_init(MpegEncContext *s) 
349 
{ 
350 
s>y_dc_scale_table= 
351 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
352 
} 
353  
354 
void ff_mpeg1_clean_buffers(MpegEncContext *s){

355 
s>last_dc[0] = 1 << (7 + s>intra_dc_precision); 
356 
s>last_dc[1] = s>last_dc[0]; 
357 
s>last_dc[2] = s>last_dc[0]; 
358 
memset(s>last_mv, 0, sizeof(s>last_mv)); 
359 
} 
360  
361 
#ifdef CONFIG_ENCODERS

362  
363 
void ff_mpeg1_encode_slice_header(MpegEncContext *s){

364 
put_header(s, SLICE_MIN_START_CODE + s>mb_y); 
365 
put_bits(&s>pb, 5, s>qscale); /* quantizer scale */ 
366 
put_bits(&s>pb, 1, 0); /* slice extra information */ 
367 
} 
368  
369 
void mpeg1_encode_picture_header(MpegEncContext *s, int picture_number) 
370 
{ 
371 
mpeg1_encode_sequence_header(s); 
372  
373 
/* mpeg1 picture header */

374 
put_header(s, PICTURE_START_CODE); 
375 
/* temporal reference */

376  
377 
// RAL: s>picture_number instead of s>fake_picture_number

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

379 
s>gop_picture_number) & 0x3ff);

380 
s>fake_picture_number++; 
381 

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

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

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

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

387 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
388 
put_bits(&s>pb, 3, s>f_code); /* forward_f_code */ 
389 
} 
390 

391 
// RAL: Backward f_code necessary for B frames

392 
if (s>pict_type == B_TYPE) {

393 
put_bits(&s>pb, 1, 0); /* half pel coordinates */ 
394 
put_bits(&s>pb, 3, s>b_code); /* backward_f_code */ 
395 
} 
396  
397 
put_bits(&s>pb, 1, 0); /* extra bit picture */ 
398 

399 
if(s>codec_id == CODEC_ID_MPEG2VIDEO){

400 
put_header(s, EXT_START_CODE); 
401 
put_bits(&s>pb, 4, 8); //pic ext 
402 
put_bits(&s>pb, 4, s>f_code);

403 
put_bits(&s>pb, 4, s>f_code);

404 
put_bits(&s>pb, 4, s>b_code);

405 
put_bits(&s>pb, 4, s>b_code);

406 
put_bits(&s>pb, 2, s>intra_dc_precision);

407 
put_bits(&s>pb, 2, s>picture_structure= PICT_FRAME);

408 
put_bits(&s>pb, 1, s>top_field_first);

409 
put_bits(&s>pb, 1, s>frame_pred_frame_dct= 1); 
410 
put_bits(&s>pb, 1, s>concealment_motion_vectors);

411 
put_bits(&s>pb, 1, s>q_scale_type);

412 
put_bits(&s>pb, 1, s>intra_vlc_format);

413 
put_bits(&s>pb, 1, s>alternate_scan);

414 
put_bits(&s>pb, 1, s>repeat_first_field);

415 
put_bits(&s>pb, 1, s>chroma_420_type=1); 
416 
put_bits(&s>pb, 1, s>progressive_frame=1); 
417 
put_bits(&s>pb, 1, 0); //composite_display_flag 
418 
} 
419 

420 
s>mb_y=0;

421 
ff_mpeg1_encode_slice_header(s); 
422 
} 
423  
424 
void mpeg1_encode_mb(MpegEncContext *s,

425 
DCTELEM block[6][64], 
426 
int motion_x, int motion_y) 
427 
{ 
428 
int i, cbp;

429 
const int mb_x = s>mb_x; 
430 
const int mb_y = s>mb_y; 
431 
const int first_mb= mb_x == s>resync_mb_x && mb_y == s>resync_mb_y; 
432  
433 
/* compute cbp */

434 
cbp = 0;

435 
for(i=0;i<6;i++) { 
436 
if (s>block_last_index[i] >= 0) 
437 
cbp = 1 << (5  i); 
438 
} 
439  
440 
if (cbp == 0 && !first_mb && (mb_x != s>mb_width  1  (mb_y != s>mb_height  1 && s>codec_id == CODEC_ID_MPEG1VIDEO)) && 
441 
((s>pict_type == P_TYPE && (motion_x  motion_y) == 0) 

442 
(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)  
443 
((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))) { 
444 
s>mb_skip_run++; 
445 
s>qscale = s>dquant; 
446 
s>skip_count++; 
447 
s>misc_bits++; 
448 
s>last_bits++; 
449 
} else {

450 
if(first_mb){

451 
assert(s>mb_skip_run == 0);

452 
encode_mb_skip_run(s, s>mb_x); 
453 
}else{

454 
encode_mb_skip_run(s, s>mb_skip_run); 
455 
} 
456 

457 
if (s>pict_type == I_TYPE) {

458 
if(s>dquant && cbp){

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

461 
}else{

462 
put_bits(&s>pb, 1, 1); /* macroblock_type : macroblock_quant = 0 */ 
463 
s>qscale = s>dquant; 
464 
} 
465 
s>misc_bits+= get_bits_diff(s); 
466 
s>i_count++; 
467 
} else if (s>mb_intra) { 
468 
if(s>dquant && cbp){

469 
put_bits(&s>pb, 6, 0x01); 
470 
put_bits(&s>pb, 5, s>qscale);

471 
}else{

472 
put_bits(&s>pb, 5, 0x03); 
473 
s>qscale = s>dquant; 
474 
} 
475 
s>misc_bits+= get_bits_diff(s); 
476 
s>i_count++; 
477 
s>last_mv[0][0][0] = 
478 
s>last_mv[0][0][1] = 0; 
479 
} else if (s>pict_type == P_TYPE) { 
480 
if (cbp != 0) { 
481 
if (motion_x == 0 && motion_y == 0) { 
482 
if(s>dquant){

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

485 
}else{

486 
put_bits(&s>pb, 2, 1); /* macroblock_pattern only */ 
487 
} 
488 
s>misc_bits+= get_bits_diff(s); 
489 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
490 
} else {

491 
if(s>dquant){

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

494 
}else{

495 
put_bits(&s>pb, 1, 1); /* motion + cbp */ 
496 
} 
497 
s>misc_bits+= get_bits_diff(s); 
498 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); // RAL: f_code parameter added 
499 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); // RAL: f_code parameter added 
500 
s>mv_bits+= get_bits_diff(s); 
501 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
502 
} 
503 
} else {

504 
put_bits(&s>pb, 3, 1); /* motion only */ 
505 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); // RAL: f_code parameter added 
506 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); // RAL: f_code parameter added 
507 
s>qscale = s>dquant; 
508 
s>mv_bits+= get_bits_diff(s); 
509 
} 
510 
s>f_count++; 
511 
} else

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

513 
if (cbp != 0) 
514 
{ // With coded bloc pattern

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

516 
{ // Bidirectional motion

517 
if (s>dquant)

518 
{ // With QScale

519 
put_bits(&s>pb, 5, 2); 
520 
put_bits(&s>pb, 5, s>qscale);

521 
} 
522 
else // Without QScale 
523 
put_bits(&s>pb, 2, 3); 
524 
s>misc_bits += get_bits_diff(s); 
525 
mpeg1_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
526 
mpeg1_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
527 
mpeg1_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
528 
mpeg1_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
529 
s>b_count++; 
530 
s>f_count++; 
531 
s>mv_bits += get_bits_diff(s); 
532 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
533 
} 
534 
else if (s>mv_dir == MV_DIR_BACKWARD) 
535 
{ // Backward motion

536 
if (s>dquant)

537 
{ // With QScale

538 
put_bits(&s>pb, 6, 2); 
539 
put_bits(&s>pb, 5, s>qscale);

540 
} 
541 
else // Without QScale 
542 
put_bits(&s>pb, 3, 3); 
543 
s>misc_bits += get_bits_diff(s); 
544 
mpeg1_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
545 
mpeg1_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
546 
s>b_count++; 
547 
s>mv_bits += get_bits_diff(s); 
548 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
549 
} 
550 
else if (s>mv_dir == MV_DIR_FORWARD) 
551 
{ // Forward motion

552 
if (s>dquant)

553 
{ // With QScale

554 
put_bits(&s>pb, 6, 3); 
555 
put_bits(&s>pb, 5, s>qscale);

556 
} 
557 
else // Without QScale 
558 
put_bits(&s>pb, 4, 3); 
559 
s>misc_bits += get_bits_diff(s); 
560 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
561 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
562 
s>f_count++; 
563 
s>mv_bits += get_bits_diff(s); 
564 
put_bits(&s>pb, mbPatTable[cbp  1][1], mbPatTable[cbp  1][0]); 
565 
} 
566 
} 
567 
else

568 
{ // No coded bloc pattern

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

570 
{ // Bidirectional motion

571 
put_bits(&s>pb, 2, 2); /* backward & forward motion */ 
572 
mpeg1_encode_motion(s, s>mv[0][0][0]  s>last_mv[0][0][0], s>f_code); 
573 
mpeg1_encode_motion(s, s>mv[0][0][1]  s>last_mv[0][0][1], s>f_code); 
574 
mpeg1_encode_motion(s, s>mv[1][0][0]  s>last_mv[1][0][0], s>b_code); 
575 
mpeg1_encode_motion(s, s>mv[1][0][1]  s>last_mv[1][0][1], s>b_code); 
576 
s>b_count++; 
577 
s>f_count++; 
578 
} 
579 
else if (s>mv_dir == MV_DIR_BACKWARD) 
580 
{ // Backward motion

581 
put_bits(&s>pb, 3, 2); /* backward motion only */ 
582 
mpeg1_encode_motion(s, motion_x  s>last_mv[1][0][0], s>b_code); 
583 
mpeg1_encode_motion(s, motion_y  s>last_mv[1][0][1], s>b_code); 
584 
s>b_count++; 
585 
} 
586 
else if (s>mv_dir == MV_DIR_FORWARD) 
587 
{ // Forward motion

588 
put_bits(&s>pb, 4, 2); /* forward motion only */ 
589 
mpeg1_encode_motion(s, motion_x  s>last_mv[0][0][0], s>f_code); 
590 
mpeg1_encode_motion(s, motion_y  s>last_mv[0][0][1], s>f_code); 
591 
s>f_count++; 
592 
} 
593 
s>qscale = s>dquant; 
594 
s>mv_bits += get_bits_diff(s); 
595 
} 
596 
// End of bloc from RAL

597 
} 
598 
for(i=0;i<6;i++) { 
599 
if (cbp & (1 << (5  i))) { 
600 
mpeg1_encode_block(s, block[i], i); 
601 
} 
602 
} 
603 
s>mb_skip_run = 0;

604 
if(s>mb_intra)

605 
s>i_tex_bits+= get_bits_diff(s); 
606 
else

607 
s>p_tex_bits+= get_bits_diff(s); 
608 
} 
609  
610 
// RAL: By this:

611 
if (s>mv_dir & MV_DIR_FORWARD)

612 
{ 
613 
s>last_mv[0][0][0]= s>mv[0][0][0]; 
614 
s>last_mv[0][0][1]= s>mv[0][0][1]; 
615 
} 
616 
if (s>mv_dir & MV_DIR_BACKWARD)

617 
{ 
618 
s>last_mv[1][0][0]= s>mv[1][0][0]; 
619 
s>last_mv[1][0][1]= s>mv[1][0][1]; 
620 
} 
621 
} 
622  
623 
// RAL: Parameter added: f_or_b_code

624 
static void mpeg1_encode_motion(MpegEncContext *s, int val, int f_or_b_code) 
625 
{ 
626 
int code, bit_size, l, m, bits, range, sign;

627  
628 
if (val == 0) { 
629 
/* zero vector */

630 
code = 0;

631 
put_bits(&s>pb, 
632 
mbMotionVectorTable[0][1], 
633 
mbMotionVectorTable[0][0]); 
634 
} else {

635 
bit_size = f_or_b_code  1;

636 
range = 1 << bit_size;

637 
/* modulo encoding */

638 
l = 16 * range;

639 
m = 2 * l;

640 
if (val < l) {

641 
val += m; 
642 
} else if (val >= l) { 
643 
val = m; 
644 
} 
645  
646 
if (val >= 0) { 
647 
val; 
648 
code = (val >> bit_size) + 1;

649 
bits = val & (range  1);

650 
sign = 0;

651 
} else {

652 
val = val; 
653 
val; 
654 
code = (val >> bit_size) + 1;

655 
bits = val & (range  1);

656 
sign = 1;

657 
} 
658  
659 
assert(code > 0 && code <= 16); 
660  
661 
put_bits(&s>pb, 
662 
mbMotionVectorTable[code][1],

663 
mbMotionVectorTable[code][0]);

664  
665 
put_bits(&s>pb, 1, sign);

666 
if (bit_size > 0) { 
667 
put_bits(&s>pb, bit_size, bits); 
668 
} 
669 
} 
670 
} 
671  
672 
void ff_mpeg1_encode_init(MpegEncContext *s)

673 
{ 
674 
static int done=0; 
675  
676 
common_init(s); 
677  
678 
if(!done){

679 
int f_code;

680 
int mv;

681 
int i;

682  
683 
done=1;

684 
init_rl(&rl_mpeg1); 
685  
686 
for(i=0; i<64; i++) 
687 
{ 
688 
mpeg1_max_level[0][i]= rl_mpeg1.max_level[0][i]; 
689 
mpeg1_index_run[0][i]= rl_mpeg1.index_run[0][i]; 
690 
} 
691 

692 
init_uni_ac_vlc(&rl_mpeg1, uni_mpeg1_ac_vlc_bits, uni_mpeg1_ac_vlc_len); 
693  
694 
/* build unified dc encoding tables */

695 
for(i=255; i<256; i++) 
696 
{ 
697 
int adiff, index;

698 
int bits, code;

699 
int diff=i;

700  
701 
adiff = ABS(diff); 
702 
if(diff<0) diff; 
703 
index = vlc_dc_table[adiff]; 
704  
705 
bits= vlc_dc_lum_bits[index] + index; 
706 
code= (vlc_dc_lum_code[index]<<index) + (diff & ((1 << index)  1)); 
707 
mpeg1_lum_dc_uni[i+255]= bits + (code<<8); 
708 

709 
bits= vlc_dc_chroma_bits[index] + index; 
710 
code= (vlc_dc_chroma_code[index]<<index) + (diff & ((1 << index)  1)); 
711 
mpeg1_chr_dc_uni[i+255]= bits + (code<<8); 
712 
} 
713  
714 
mv_penalty= av_mallocz( sizeof(uint8_t)*(MAX_FCODE+1)*(2*MAX_MV+1) ); 
715  
716 
for(f_code=1; f_code<=MAX_FCODE; f_code++){ 
717 
for(mv=MAX_MV; mv<=MAX_MV; mv++){

718 
int len;

719  
720 
if(mv==0) len= mbMotionVectorTable[0][1]; 
721 
else{

722 
int val, bit_size, range, code;

723  
724 
bit_size = s>f_code  1;

725 
range = 1 << bit_size;

726  
727 
val=mv; 
728 
if (val < 0) 
729 
val = val; 
730 
val; 
731 
code = (val >> bit_size) + 1;

732 
if(code<17){ 
733 
len= mbMotionVectorTable[code][1] + 1 + bit_size; 
734 
}else{

735 
len= mbMotionVectorTable[16][1] + 2 + bit_size; 
736 
} 
737 
} 
738  
739 
mv_penalty[f_code][mv+MAX_MV]= len; 
740 
} 
741 
} 
742 

743  
744 
for(f_code=MAX_FCODE; f_code>0; f_code){ 
745 
for(mv=(8<<f_code); mv<(8<<f_code); mv++){ 
746 
fcode_tab[mv+MAX_MV]= f_code; 
747 
} 
748 
} 
749 
} 
750 
s>me.mv_penalty= mv_penalty; 
751 
s>fcode_tab= fcode_tab; 
752 
if(s>codec_id == CODEC_ID_MPEG1VIDEO){

753 
s>min_qcoeff=255;

754 
s>max_qcoeff= 255;

755 
}else{

756 
s>min_qcoeff=2047;

757 
s>max_qcoeff= 2047;

758 
} 
759 
s>intra_ac_vlc_length= 
760 
s>inter_ac_vlc_length= uni_mpeg1_ac_vlc_len; 
761 
} 
762  
763 
static inline void encode_dc(MpegEncContext *s, int diff, int component) 
764 
{ 
765 
if (component == 0) { 
766 
put_bits( 
767 
&s>pb, 
768 
mpeg1_lum_dc_uni[diff+255]&0xFF, 
769 
mpeg1_lum_dc_uni[diff+255]>>8); 
770 
} else {

771 
put_bits( 
772 
&s>pb, 
773 
mpeg1_chr_dc_uni[diff+255]&0xFF, 
774 
mpeg1_chr_dc_uni[diff+255]>>8); 
775 
} 
776 
} 
777  
778 
static void mpeg1_encode_block(MpegEncContext *s, 
779 
DCTELEM *block, 
780 
int n)

781 
{ 
782 
int alevel, level, last_non_zero, dc, diff, i, j, run, last_index, sign;

783 
int code, component;

784 
// RLTable *rl = &rl_mpeg1;

785  
786 
last_index = s>block_last_index[n]; 
787  
788 
/* DC coef */

789 
if (s>mb_intra) {

790 
component = (n <= 3 ? 0 : n  4 + 1); 
791 
dc = block[0]; /* overflow is impossible */ 
792 
diff = dc  s>last_dc[component]; 
793 
encode_dc(s, diff, component); 
794 
s>last_dc[component] = dc; 
795 
i = 1;

796 
/*

797 
if (s>intra_vlc_format)

798 
rl = &rl_mpeg2;

799 
else

800 
rl = &rl_mpeg1;

801 
*/

802 
} else {

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

804 
it is handled slightly differently */

805 
level = block[0];

806 
if (abs(level) == 1) { 
807 
code = ((uint32_t)level >> 31); /* the sign bit */ 
808 
put_bits(&s>pb, 2, code  0x02); 
809 
i = 1;

810 
} else {

811 
i = 0;

812 
last_non_zero = 1;

813 
goto next_coef;

814 
} 
815 
} 
816  
817 
/* now quantify & encode AC coefs */

818 
last_non_zero = i  1;

819  
820 
for(;i<=last_index;i++) {

821 
j = s>intra_scantable.permutated[i]; 
822 
level = block[j]; 
823 
next_coef:

824 
#if 0

825 
if (level != 0)

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

827 
#endif

828 
/* encode using VLC */

829 
if (level != 0) { 
830 
run = i  last_non_zero  1;

831 

832 
alevel= level; 
833 
MASK_ABS(sign, alevel) 
834 
sign&=1;

835  
836 
// code = get_rl_index(rl, 0, run, alevel);

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

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

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

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

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

846 
if(s>codec_id == CODEC_ID_MPEG1VIDEO){

847 
if (alevel < 128) { 
848 
put_bits(&s>pb, 8, level & 0xff); 
849 
} else {

850 
if (level < 0) { 
851 
put_bits(&s>pb, 16, 0x8001 + level + 255); 
852 
} else {

853 
put_bits(&s>pb, 16, level & 0xffff); 
854 
} 
855 
} 
856 
}else{

857 
put_bits(&s>pb, 12, level & 0xfff); 
858 
} 
859 
} 
860 
last_non_zero = i; 
861 
} 
862 
} 
863 
/* end of block */

864 
put_bits(&s>pb, 2, 0x2); 
865 
} 
866 
#endif //CONFIG_ENCODERS 
867  
868 
/******************************************/

869 
/* decoding */

870  
871 
static VLC dc_lum_vlc;

872 
static VLC dc_chroma_vlc;

873 
static VLC mv_vlc;

874 
static VLC mbincr_vlc;

875 
static VLC mb_ptype_vlc;

876 
static VLC mb_btype_vlc;

877 
static VLC mb_pat_vlc;

878  
879 
static void init_vlcs() 
880 
{ 
881 
static int done = 0; 
882  
883 
if (!done) {

884 
done = 1;

885  
886 
init_vlc(&dc_lum_vlc, DC_VLC_BITS, 12,

887 
vlc_dc_lum_bits, 1, 1, 
888 
vlc_dc_lum_code, 2, 2); 
889 
init_vlc(&dc_chroma_vlc, DC_VLC_BITS, 12,

890 
vlc_dc_chroma_bits, 1, 1, 
891 
vlc_dc_chroma_code, 2, 2); 
892 
init_vlc(&mv_vlc, MV_VLC_BITS, 17,

893 
&mbMotionVectorTable[0][1], 2, 1, 
894 
&mbMotionVectorTable[0][0], 2, 1); 
895 
init_vlc(&mbincr_vlc, MBINCR_VLC_BITS, 36,

896 
&mbAddrIncrTable[0][1], 2, 1, 
897 
&mbAddrIncrTable[0][0], 2, 1); 
898 
init_vlc(&mb_pat_vlc, MB_PAT_VLC_BITS, 63,

899 
&mbPatTable[0][1], 2, 1, 
900 
&mbPatTable[0][0], 2, 1); 
901 

902 
init_vlc(&mb_ptype_vlc, MB_PTYPE_VLC_BITS, 7,

903 
&table_mb_ptype[0][1], 2, 1, 
904 
&table_mb_ptype[0][0], 2, 1); 
905 
init_vlc(&mb_btype_vlc, MB_BTYPE_VLC_BITS, 11,

906 
&table_mb_btype[0][1], 2, 1, 
907 
&table_mb_btype[0][0], 2, 1); 
908 
init_rl(&rl_mpeg1); 
909 
init_rl(&rl_mpeg2); 
910  
911 
init_2d_vlc_rl(&rl_mpeg1); 
912 
init_2d_vlc_rl(&rl_mpeg2); 
913 
} 
914 
} 
915  
916 
static inline int get_dmv(MpegEncContext *s) 
917 
{ 
918 
if(get_bits1(&s>gb))

919 
return 1  (get_bits1(&s>gb) << 1); 
920 
else

921 
return 0; 
922 
} 
923  
924 
static inline int get_qscale(MpegEncContext *s) 
925 
{ 
926 
int qscale = get_bits(&s>gb, 5); 
927 
if (s>codec_id == CODEC_ID_MPEG2VIDEO) {

928 
if (s>q_scale_type) {

929 
return non_linear_qscale[qscale];

930 
} else {

931 
return qscale << 1; 
932 
} 
933 
} 
934 
return qscale;

935 
} 
936  
937 
/* motion type (for mpeg2) */

938 
#define MT_FIELD 1 
939 
#define MT_FRAME 2 
940 
#define MT_16X8 2 
941 
#define MT_DMV 3 
942  
943 
static int mpeg_decode_mb(MpegEncContext *s, 
944 
DCTELEM block[6][64]) 
945 
{ 
946 
int i, j, k, cbp, val, mb_type, motion_type;

947 

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

949  
950 
assert(s>mb_skiped==0);

951  
952 
if (s>mb_skip_run != 0) { 
953 
if(s>pict_type == I_TYPE){

954 
fprintf(stderr, "skiped MB in I frame at %d %d\n", s>mb_x, s>mb_y);

955 
return 1; 
956 
} 
957 

958 
/* skip mb */

959 
s>mb_intra = 0;

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

962 
s>mv_type = MV_TYPE_16X16; 
963 
if (s>pict_type == P_TYPE) {

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

965 
s>mv_dir = MV_DIR_FORWARD; 
966 
s>mv[0][0][0] = s>mv[0][0][1] = 0; 
967 
s>last_mv[0][0][0] = s>last_mv[0][0][1] = 0; 
968 
s>last_mv[0][1][0] = s>last_mv[0][1][1] = 0; 
969 
s>mb_skiped = 1;

970 
s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride ]= MB_TYPE_SKIP  MB_TYPE_L0  MB_TYPE_16x16; 
971 
} else {

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

973 
s>mv[0][0][0] = s>last_mv[0][0][0]; 
974 
s>mv[0][0][1] = s>last_mv[0][0][1]; 
975 
s>mv[1][0][0] = s>last_mv[1][0][0]; 
976 
s>mv[1][0][1] = s>last_mv[1][0][1]; 
977  
978 
s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride ]= 
979 
s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride  1]  MB_TYPE_SKIP;

980 
// assert(s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride  1]&(MB_TYPE_16x16MB_TYPE_16x8));

981  
982 
if((s>mv[0][0][0]s>mv[0][0][1]s>mv[1][0][0]s>mv[1][0][1])==0) 
983 
s>mb_skiped = 1;

984 
} 
985  
986 
return 0; 
987 
} 
988  
989 
switch(s>pict_type) {

990 
default:

991 
case I_TYPE:

992 
if (get_bits1(&s>gb) == 0) { 
993 
if (get_bits1(&s>gb) == 0){ 
994 
fprintf(stderr, "invalid mb type in I Frame at %d %d\n", s>mb_x, s>mb_y);

995 
return 1; 
996 
} 
997 
mb_type = MB_TYPE_QUANT  MB_TYPE_INTRA; 
998 
} else {

999 
mb_type = MB_TYPE_INTRA; 
1000 
} 
1001 
break;

1002 
case P_TYPE:

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

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

1006 
return 1; 
1007 
} 
1008 
mb_type = ptype2mb_type[ mb_type ]; 
1009 
break;

1010 
case B_TYPE:

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

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

1014 
return 1; 
1015 
} 
1016 
mb_type = btype2mb_type[ mb_type ]; 
1017 
break;

1018 
} 
1019 
dprintf("mb_type=%x\n", mb_type);

1020 
// motion_type = 0; /* avoid warning */

1021 
if (IS_INTRA(mb_type)) {

1022 
/* compute dct type */

1023 
if (s>picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? 
1024 
!s>frame_pred_frame_dct) { 
1025 
s>interlaced_dct = get_bits1(&s>gb); 
1026 
} 
1027  
1028 
if (IS_QUANT(mb_type))

1029 
s>qscale = get_qscale(s); 
1030 

1031 
if (s>concealment_motion_vectors) {

1032 
/* just parse them */

1033 
if (s>picture_structure != PICT_FRAME)

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

1035 

1036 
s>mv[0][0][0]= s>last_mv[0][0][0]= s>last_mv[0][1][0] = 
1037 
mpeg_decode_motion(s, s>mpeg_f_code[0][0], s>last_mv[0][0][0]); 
1038 
s>mv[0][0][1]= s>last_mv[0][0][1]= s>last_mv[0][1][1] = 
1039 
mpeg_decode_motion(s, s>mpeg_f_code[0][1], s>last_mv[0][0][1]); 
1040  
1041 
skip_bits1(&s>gb); /* marker */

1042 
}else

1043 
memset(s>last_mv, 0, sizeof(s>last_mv)); /* reset mv prediction */ 
1044 
s>mb_intra = 1;

1045  
1046 
if (s>codec_id == CODEC_ID_MPEG2VIDEO) {

1047 
for(i=0;i<6;i++) { 
1048 
if (mpeg2_decode_block_intra(s, block[i], i) < 0) 
1049 
return 1; 
1050 
} 
1051 
} else {

1052 
for(i=0;i<6;i++) { 
1053 
if (mpeg1_decode_block_intra(s, block[i], i) < 0) 
1054 
return 1; 
1055 
} 
1056 
} 
1057 
} else {

1058 
if (mb_type & MB_TYPE_ZERO_MV){

1059 
assert(mb_type & MB_TYPE_PAT); 
1060  
1061 
/* compute dct type */

1062 
if (s>picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? 
1063 
!s>frame_pred_frame_dct) { 
1064 
s>interlaced_dct = get_bits1(&s>gb); 
1065 
} 
1066  
1067 
if (IS_QUANT(mb_type))

1068 
s>qscale = get_qscale(s); 
1069  
1070 
s>mv_dir = MV_DIR_FORWARD; 
1071 
s>mv_type = MV_TYPE_16X16; 
1072 
s>last_mv[0][0][0] = 0; 
1073 
s>last_mv[0][0][1] = 0; 
1074 
s>last_mv[0][1][0] = 0; 
1075 
s>last_mv[0][1][1] = 0; 
1076 
s>mv[0][0][0] = 0; 
1077 
s>mv[0][0][1] = 0; 
1078 
}else{

1079 
assert(mb_type & MB_TYPE_L0L1); 
1080 
//FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED

1081 
/* get additionnal motion vector type */

1082 
if (s>frame_pred_frame_dct)

1083 
motion_type = MT_FRAME; 
1084 
else{

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

1086 
} 
1087  
1088 
/* compute dct type */

1089 
if (s>picture_structure == PICT_FRAME && //FIXME add a interlaced_dct coded var? 
1090 
!s>frame_pred_frame_dct && IS_PAT(mb_type)) { 
1091 
s>interlaced_dct = get_bits1(&s>gb); 
1092 
} 
1093  
1094 
if (IS_QUANT(mb_type))

1095 
s>qscale = get_qscale(s); 
1096  
1097 
/* motion vectors */

1098 
s>mv_dir = 0;

1099 
for(i=0;i<2;i++) { 
1100 
if (USES_LIST(mb_type, i)) {

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

1103 
switch(motion_type) {

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

1106 
/* MT_FRAME */

1107 
mb_type = MB_TYPE_16x16; 
1108 
s>mv_type = MV_TYPE_16X16; 
1109 
s>mv[i][0][0]= s>last_mv[i][0][0]= s>last_mv[i][1][0] = 
1110 
mpeg_decode_motion(s, s>mpeg_f_code[i][0], s>last_mv[i][0][0]); 
1111 
s>mv[i][0][1]= s>last_mv[i][0][1]= s>last_mv[i][1][1] = 
1112 
mpeg_decode_motion(s, s>mpeg_f_code[i][1], s>last_mv[i][0][1]); 
1113 
/* full_pel: only for mpeg1 */

1114 
if (s>full_pel[i]){

1115 
s>mv[i][0][0] <<= 1; 
1116 
s>mv[i][0][1] <<= 1; 
1117 
} 
1118 
} else {

1119 
/* MT_16X8 */

1120 
mb_type = MB_TYPE_16x8; 
1121 
s>mv_type = MV_TYPE_16X8; 
1122 
for(j=0;j<2;j++) { 
1123 
s>field_select[i][j] = get_bits1(&s>gb); 
1124 
for(k=0;k<2;k++) { 
1125 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
1126 
s>last_mv[i][j][k]); 
1127 
s>last_mv[i][j][k] = val; 
1128 
s>mv[i][j][k] = val; 
1129 
} 
1130 
} 
1131 
} 
1132 
break;

1133 
case MT_FIELD:

1134 
s>mv_type = MV_TYPE_FIELD; 
1135 
if (s>picture_structure == PICT_FRAME) {

1136 
mb_type = MB_TYPE_16x8  MB_TYPE_INTERLACED; 
1137 
for(j=0;j<2;j++) { 
1138 
s>field_select[i][j] = get_bits1(&s>gb); 
1139 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

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

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

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

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

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

1145 
s>last_mv[i][j][1] >> 1); 
1146 
s>last_mv[i][j][1] = val << 1; 
1147 
s>mv[i][j][1] = val;

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

1149 
} 
1150 
} else {

1151 
mb_type = MB_TYPE_16x16; 
1152 
s>field_select[i][0] = get_bits1(&s>gb);

1153 
for(k=0;k<2;k++) { 
1154 
val = mpeg_decode_motion(s, s>mpeg_f_code[i][k], 
1155 
s>last_mv[i][0][k]);

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

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

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

1159 
} 
1160 
} 
1161 
break;

1162 
case MT_DMV:

1163 
{ 
1164 
int dmx, dmy, mx, my, m;

1165  
1166 
mx = mpeg_decode_motion(s, s>mpeg_f_code[i][0],

1167 
s>last_mv[i][0][0]); 
1168 
s>last_mv[i][0][0] = mx; 
1169 
s>last_mv[i][1][0] = mx; 
1170 
dmx = get_dmv(s); 
1171 
my = mpeg_decode_motion(s, s>mpeg_f_code[i][1],

1172 
s>last_mv[i][0][1] >> 1); 
1173 
dmy = get_dmv(s); 
1174 
s>mv_type = MV_TYPE_DMV; 
1175  
1176  
1177 
s>last_mv[i][0][1] = my<<1; 
1178 
s>last_mv[i][1][1] = my<<1; 
1179  
1180 
s>mv[i][0][0] = mx; 
1181 
s>mv[i][0][1] = my; 
1182 
s>mv[i][1][0] = mx;//not used 
1183 
s>mv[i][1][1] = my;//not used 
1184  
1185 
if (s>picture_structure == PICT_FRAME) {

1186 
mb_type = MB_TYPE_16x16  MB_TYPE_INTERLACED; 
1187  
1188 
//m = 1 + 2 * s>top_field_first;

1189 
m = s>top_field_first ? 1 : 3; 
1190  
1191 
/* top > top pred */

1192 
s>mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
1193 
s>mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy  1; 
1194 
m = 4  m;

1195 
s>mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx; 
1196 
s>mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1; 
1197 
} else {

1198 
mb_type = MB_TYPE_16x16; 
1199  
1200 
s>mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx; 
1201 
s>mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy; 
1202 
if(s>picture_structure == PICT_TOP_FIELD)

1203 
s>mv[i][2][1]; 
1204 
else

1205 
s>mv[i][2][1]++; 
1206 
} 
1207 
} 
1208 
break;

1209 
} 
1210 
} 
1211 
} 
1212 
} 
1213 

1214 
s>mb_intra = 0;

1215  
1216 
if (IS_PAT(mb_type)) {

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

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

1220 
return 1; 
1221 
} 
1222 
cbp++; 
1223  
1224 
if (s>codec_id == CODEC_ID_MPEG2VIDEO) {

1225 
for(i=0;i<6;i++) { 
1226 
if (cbp & 32) { 
1227 
if (mpeg2_decode_block_non_intra(s, block[i], i) < 0) 
1228 
return 1; 
1229 
} else {

1230 
s>block_last_index[i] = 1;

1231 
} 
1232 
cbp+=cbp; 
1233 
} 
1234 
} else {

1235 
for(i=0;i<6;i++) { 
1236 
if (cbp & 32) { 
1237 
if (mpeg1_decode_block_inter(s, block[i], i) < 0) 
1238 
return 1; 
1239 
} else {

1240 
s>block_last_index[i] = 1;

1241 
} 
1242 
cbp+=cbp; 
1243 
} 
1244 
} 
1245 
}else{

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

1248 
} 
1249 
} 
1250  
1251 
s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride ]= mb_type; 
1252  
1253 
return 0; 
1254 
} 
1255  
1256 
/* as h263, but only 17 codes */

1257 
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred) 
1258 
{ 
1259 
int code, sign, val, l, shift;

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

1262 
if (code == 0) { 
1263 
return pred;

1264 
} 
1265 
if (code < 0) { 
1266 
return 0xffff; 
1267 
} 
1268  
1269 
sign = get_bits1(&s>gb); 
1270 
shift = fcode  1;

1271 
val = code; 
1272 
if (shift) {

1273 
val = (val  1) << shift;

1274 
val = get_bits(&s>gb, shift); 
1275 
val++; 
1276 
} 
1277 
if (sign)

1278 
val = val; 
1279 
val += pred; 
1280 

1281 
/* modulo decoding */

1282 
l = 1 << (shift+4); 
1283 
val = ((val + l)&(l*21))  l; 
1284 
return val;

1285 
} 
1286  
1287 
static inline int decode_dc(GetBitContext *gb, int component) 
1288 
{ 
1289 
int code, diff;

1290  
1291 
if (component == 0) { 
1292 
code = get_vlc2(gb, dc_lum_vlc.table, DC_VLC_BITS, 2);

1293 
} else {

1294 
code = get_vlc2(gb, dc_chroma_vlc.table, DC_VLC_BITS, 2);

1295 
} 
1296 
if (code < 0){ 
1297 
fprintf(stderr, "invalid dc code at\n");

1298 
return 0xffff; 
1299 
} 
1300 
if (code == 0) { 
1301 
diff = 0;

1302 
} else {

1303 
diff = get_xbits(gb, code); 
1304 
} 
1305 
return diff;

1306 
} 
1307  
1308 
static inline int mpeg1_decode_block_intra(MpegEncContext *s, 
1309 
DCTELEM *block, 
1310 
int n)

1311 
{ 
1312 
int level, dc, diff, i, j, run;

1313 
int component;

1314 
RLTable *rl = &rl_mpeg1; 
1315 
uint8_t * const scantable= s>intra_scantable.permutated;

1316 
const uint16_t *quant_matrix= s>intra_matrix;

1317 
const int qscale= s>qscale; 
1318  
1319 
/* DC coef */

1320 
component = (n <= 3 ? 0 : n  4 + 1); 
1321 
diff = decode_dc(&s>gb, component); 
1322 
if (diff >= 0xffff) 
1323 
return 1; 
1324 
dc = s>last_dc[component]; 
1325 
dc += diff; 
1326 
s>last_dc[component] = dc; 
1327 
block[0] = dc<<3; 
1328 
dprintf("dc=%d diff=%d\n", dc, diff);

1329 
i = 0;

1330 
{ 
1331 
OPEN_READER(re, &s>gb); 
1332 
/* now quantify & encode AC coefs */

1333 
for(;;) {

1334 
UPDATE_CACHE(re, &s>gb); 
1335 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1336 

1337 
if(level == 127){ 
1338 
break;

1339 
} else if(level != 0) { 
1340 
i += run; 
1341 
j = scantable[i]; 
1342 
level= (level*qscale*quant_matrix[j])>>3;

1343 
level= (level1)1; 
1344 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1345 
LAST_SKIP_BITS(re, &s>gb, 1);

1346 
} else {

1347 
/* escape */

1348 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1349 
UPDATE_CACHE(re, &s>gb); 
1350 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1351 
if (level == 128) { 
1352 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1353 
} else if (level == 0) { 
1354 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1355 
} 
1356 
i += run; 
1357 
j = scantable[i]; 
1358 
if(level<0){ 
1359 
level= level; 
1360 
level= (level*qscale*quant_matrix[j])>>3;

1361 
level= (level1)1; 
1362 
level= level; 
1363 
}else{

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

1365 
level= (level1)1; 
1366 
} 
1367 
} 
1368 
if (i > 63){ 
1369 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1370 
return 1; 
1371 
} 
1372  
1373 
block[j] = level; 
1374 
} 
1375 
CLOSE_READER(re, &s>gb); 
1376 
} 
1377 
s>block_last_index[n] = i; 
1378 
return 0; 
1379 
} 
1380  
1381 
static inline int mpeg1_decode_block_inter(MpegEncContext *s, 
1382 
DCTELEM *block, 
1383 
int n)

1384 
{ 
1385 
int level, i, j, run;

1386 
RLTable *rl = &rl_mpeg1; 
1387 
uint8_t * const scantable= s>intra_scantable.permutated;

1388 
const uint16_t *quant_matrix= s>inter_matrix;

1389 
const int qscale= s>qscale; 
1390  
1391 
{ 
1392 
int v;

1393 
OPEN_READER(re, &s>gb); 
1394 
i = 1;

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

1396 
UPDATE_CACHE(re, &s>gb); 
1397 
v= SHOW_UBITS(re, &s>gb, 2);

1398 
if (v & 2) { 
1399 
LAST_SKIP_BITS(re, &s>gb, 2);

1400 
level= (3*qscale*quant_matrix[0])>>4; 
1401 
level= (level1)1; 
1402 
if(v&1) 
1403 
level= level; 
1404 
block[0] = level;

1405 
i++; 
1406 
} 
1407  
1408 
/* now quantify & encode AC coefs */

1409 
for(;;) {

1410 
UPDATE_CACHE(re, &s>gb); 
1411 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1412 

1413 
if(level == 127){ 
1414 
break;

1415 
} else if(level != 0) { 
1416 
i += run; 
1417 
j = scantable[i]; 
1418 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1419 
level= (level1)1; 
1420 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1421 
LAST_SKIP_BITS(re, &s>gb, 1);

1422 
} else {

1423 
/* escape */

1424 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1425 
UPDATE_CACHE(re, &s>gb); 
1426 
level = SHOW_SBITS(re, &s>gb, 8); SKIP_BITS(re, &s>gb, 8); 
1427 
if (level == 128) { 
1428 
level = SHOW_UBITS(re, &s>gb, 8)  256; LAST_SKIP_BITS(re, &s>gb, 8); 
1429 
} else if (level == 0) { 
1430 
level = SHOW_UBITS(re, &s>gb, 8) ; LAST_SKIP_BITS(re, &s>gb, 8); 
1431 
} 
1432 
i += run; 
1433 
j = scantable[i]; 
1434 
if(level<0){ 
1435 
level= level; 
1436 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1437 
level= (level1)1; 
1438 
level= level; 
1439 
}else{

1440 
level= ((level*2+1)*qscale*quant_matrix[j])>>4; 
1441 
level= (level1)1; 
1442 
} 
1443 
} 
1444 
if (i > 63){ 
1445 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1446 
return 1; 
1447 
} 
1448  
1449 
block[j] = level; 
1450 
} 
1451 
CLOSE_READER(re, &s>gb); 
1452 
} 
1453 
s>block_last_index[n] = i; 
1454 
return 0; 
1455 
} 
1456  
1457 
/* Also does unquantization here, since I will never support mpeg2

1458 
encoding */

1459 
static inline int mpeg2_decode_block_non_intra(MpegEncContext *s, 
1460 
DCTELEM *block, 
1461 
int n)

1462 
{ 
1463 
int level, i, j, run;

1464 
RLTable *rl = &rl_mpeg1; 
1465 
uint8_t * const scantable= s>intra_scantable.permutated;

1466 
const uint16_t *quant_matrix;

1467 
const int qscale= s>qscale; 
1468 
int mismatch;

1469  
1470 
mismatch = 1;

1471  
1472 
{ 
1473 
int v;

1474 
OPEN_READER(re, &s>gb); 
1475 
i = 1;

1476 
if (n < 4) 
1477 
quant_matrix = s>inter_matrix; 
1478 
else

1479 
quant_matrix = s>chroma_inter_matrix; 
1480  
1481 
/* special case for the first coef. no need to add a second vlc table */

1482 
UPDATE_CACHE(re, &s>gb); 
1483 
v= SHOW_UBITS(re, &s>gb, 2);

1484 
if (v & 2) { 
1485 
LAST_SKIP_BITS(re, &s>gb, 2);

1486 
level= (3*qscale*quant_matrix[0])>>5; 
1487 
if(v&1) 
1488 
level= level; 
1489 
block[0] = level;

1490 
mismatch ^= level; 
1491 
i++; 
1492 
} 
1493  
1494 
/* now quantify & encode AC coefs */

1495 
for(;;) {

1496 
UPDATE_CACHE(re, &s>gb); 
1497 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1498 

1499 
if(level == 127){ 
1500 
break;

1501 
} else if(level != 0) { 
1502 
i += run; 
1503 
j = scantable[i]; 
1504 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1505 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1506 
LAST_SKIP_BITS(re, &s>gb, 1);

1507 
} else {

1508 
/* escape */

1509 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1510 
UPDATE_CACHE(re, &s>gb); 
1511 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1512  
1513 
i += run; 
1514 
j = scantable[i]; 
1515 
if(level<0){ 
1516 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1517 
level= level; 
1518 
}else{

1519 
level= ((level*2+1)*qscale*quant_matrix[j])>>5; 
1520 
} 
1521 
} 
1522 
if (i > 63){ 
1523 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1524 
return 1; 
1525 
} 
1526 

1527 
mismatch ^= level; 
1528 
block[j] = level; 
1529 
} 
1530 
CLOSE_READER(re, &s>gb); 
1531 
} 
1532 
block[63] ^= (mismatch & 1); 
1533 

1534 
s>block_last_index[n] = i; 
1535 
return 0; 
1536 
} 
1537  
1538 
static inline int mpeg2_decode_block_intra(MpegEncContext *s, 
1539 
DCTELEM *block, 
1540 
int n)

1541 
{ 
1542 
int level, dc, diff, i, j, run;

1543 
int component;

1544 
RLTable *rl; 
1545 
uint8_t * const scantable= s>intra_scantable.permutated;

1546 
const uint16_t *quant_matrix;

1547 
const int qscale= s>qscale; 
1548 
int mismatch;

1549  
1550 
/* DC coef */

1551 
if (n < 4){ 
1552 
quant_matrix = s>intra_matrix; 
1553 
component = 0;

1554 
}else{

1555 
quant_matrix = s>chroma_intra_matrix; 
1556 
component = n  3;

1557 
} 
1558 
diff = decode_dc(&s>gb, component); 
1559 
if (diff >= 0xffff) 
1560 
return 1; 
1561 
dc = s>last_dc[component]; 
1562 
dc += diff; 
1563 
s>last_dc[component] = dc; 
1564 
block[0] = dc << (3  s>intra_dc_precision); 
1565 
dprintf("dc=%d\n", block[0]); 
1566 
mismatch = block[0] ^ 1; 
1567 
i = 0;

1568 
if (s>intra_vlc_format)

1569 
rl = &rl_mpeg2; 
1570 
else

1571 
rl = &rl_mpeg1; 
1572  
1573 
{ 
1574 
OPEN_READER(re, &s>gb); 
1575 
/* now quantify & encode AC coefs */

1576 
for(;;) {

1577 
UPDATE_CACHE(re, &s>gb); 
1578 
GET_RL_VLC(level, run, re, &s>gb, rl>rl_vlc[0], TEX_VLC_BITS, 2); 
1579 

1580 
if(level == 127){ 
1581 
break;

1582 
} else if(level != 0) { 
1583 
i += run; 
1584 
j = scantable[i]; 
1585 
level= (level*qscale*quant_matrix[j])>>4;

1586 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1587 
LAST_SKIP_BITS(re, &s>gb, 1);

1588 
} else {

1589 
/* escape */

1590 
run = SHOW_UBITS(re, &s>gb, 6)+1; LAST_SKIP_BITS(re, &s>gb, 6); 
1591 
UPDATE_CACHE(re, &s>gb); 
1592 
level = SHOW_SBITS(re, &s>gb, 12); SKIP_BITS(re, &s>gb, 12); 
1593 
i += run; 
1594 
j = scantable[i]; 
1595 
if(level<0){ 
1596 
level= (level*qscale*quant_matrix[j])>>4;

1597 
level= level; 
1598 
}else{

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

1600 
} 
1601 
} 
1602 
if (i > 63){ 
1603 
fprintf(stderr, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1604 
return 1; 
1605 
} 
1606 

1607 
mismatch^= level; 
1608 
block[j] = level; 
1609 
} 
1610 
CLOSE_READER(re, &s>gb); 
1611 
} 
1612 
block[63]^= mismatch&1; 
1613 

1614 
s>block_last_index[n] = i; 
1615 
return 0; 
1616 
} 
1617  
1618 
typedef struct Mpeg1Context { 
1619 
MpegEncContext mpeg_enc_ctx; 
1620 
int mpeg_enc_ctx_allocated; /* true if decoding context allocated */ 
1621 
int repeat_field; /* true if we must repeat the field */ 
1622 
} Mpeg1Context; 
1623  
1624 
static int mpeg_decode_init(AVCodecContext *avctx) 
1625 
{ 
1626 
Mpeg1Context *s = avctx>priv_data; 
1627 

1628 
s>mpeg_enc_ctx.flags= avctx>flags; 
1629 
common_init(&s>mpeg_enc_ctx); 
1630 
init_vlcs(); 
1631  
1632 
s>mpeg_enc_ctx_allocated = 0;

1633 
s>mpeg_enc_ctx.picture_number = 0;

1634 
s>repeat_field = 0;

1635 
s>mpeg_enc_ctx.codec_id= avctx>codec>id; 
1636 
return 0; 
1637 
} 
1638  
1639 
/* return the 8 bit start code value and update the search

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

1641 
static int find_start_code(uint8_t **pbuf_ptr, uint8_t *buf_end) 
1642 
{ 
1643 
uint8_t *buf_ptr; 
1644 
unsigned int state=0xFFFFFFFF, v; 
1645 
int val;

1646  
1647 
buf_ptr = *pbuf_ptr; 
1648 
while (buf_ptr < buf_end) {

1649 
v = *buf_ptr++; 
1650 
if (state == 0x000001) { 
1651 
state = ((state << 8)  v) & 0xffffff; 
1652 
val = state; 
1653 
goto found;

1654 
} 
1655 
state = ((state << 8)  v) & 0xffffff; 
1656 
} 
1657 
val = 1;

1658 
found:

1659 
*pbuf_ptr = buf_ptr; 
1660 
return val;

1661 
} 
1662  
1663 
static int mpeg1_decode_picture(AVCodecContext *avctx, 
1664 
uint8_t *buf, int buf_size)

1665 
{ 
1666 
Mpeg1Context *s1 = avctx>priv_data; 
1667 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1668 
int ref, f_code;

1669  
1670 
init_get_bits(&s>gb, buf, buf_size*8);

1671  
1672 
ref = get_bits(&s>gb, 10); /* temporal ref */ 
1673 
s>pict_type = get_bits(&s>gb, 3);

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

1675  
1676 
skip_bits(&s>gb, 16);

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

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

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

1680 
if (f_code == 0) 
1681 
return 1; 
1682 
s>mpeg_f_code[0][0] = f_code; 
1683 
s>mpeg_f_code[0][1] = f_code; 
1684 
} 
1685 
if (s>pict_type == B_TYPE) {

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

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

1688 
if (f_code == 0) 
1689 
return 1; 
1690 
s>mpeg_f_code[1][0] = f_code; 
1691 
s>mpeg_f_code[1][1] = f_code; 
1692 
} 
1693 
s>current_picture.pict_type= s>pict_type; 
1694 
s>current_picture.key_frame= s>pict_type == I_TYPE; 
1695 

1696 
s>y_dc_scale = 8;

1697 
s>c_dc_scale = 8;

1698 
s>first_slice = 1;

1699 
return 0; 
1700 
} 
1701  
1702 
static void mpeg_decode_sequence_extension(MpegEncContext *s) 
1703 
{ 
1704 
int horiz_size_ext, vert_size_ext;

1705 
int bit_rate_ext, vbv_buf_ext;

1706 
int frame_rate_ext_n, frame_rate_ext_d;

1707 
int level, profile;

1708 
float aspect;

1709  
1710 
skip_bits(&s>gb, 1); /* profil and level esc*/ 
1711 
profile= get_bits(&s>gb, 3);

1712 
level= get_bits(&s>gb, 4);

1713 
s>progressive_sequence = get_bits1(&s>gb); /* progressive_sequence */

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

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

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

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

1719 
bit_rate_ext = get_bits(&s>gb, 12); /* XXX: handle it */ 
1720 
s>bit_rate = ((s>bit_rate / 400)  (bit_rate_ext << 12)) * 400; 
1721 
skip_bits1(&s>gb); /* marker */

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

1723  
1724 
s>low_delay = get_bits1(&s>gb); 
1725 
if(s>flags & CODEC_FLAG_LOW_DELAY) s>low_delay=1; 
1726  
1727 
frame_rate_ext_n = get_bits(&s>gb, 2);

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

1729 
av_reduce( 
1730 
&s>avctx>frame_rate, 
1731 
&s>avctx>frame_rate_base, 
1732 
frame_rate_tab[s>frame_rate_index] * (frame_rate_ext_n+1),

1733 
MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d+1),

1734 
1<<30); 
1735  
1736 
dprintf("sequence extension\n");

1737 
s>codec_id= s>avctx>codec_id= CODEC_ID_MPEG2VIDEO; 
1738 
s>avctx>sub_id = 2; /* indicates mpeg2 found */ 
1739  
1740 
aspect= mpeg2_aspect[s>aspect_ratio_info]; 
1741 
if(aspect>0.0) s>avctx>aspect_ratio= s>width/(aspect*s>height); 
1742 
else if(aspect<0.0) s>avctx>aspect_ratio= 1.0/aspect; 
1743 

1744 
if(s>avctx>debug & FF_DEBUG_PICT_INFO)

1745 
printf("profile: %d, level: %d \n", profile, level);

1746 
} 
1747  
1748 
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s) 
1749 
{ 
1750 
int i, v, j;

1751  
1752 
dprintf("matrix extension\n");

1753  
1754 
if (get_bits1(&s>gb)) {

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

1757 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1758 
s>intra_matrix[j] = v; 
1759 
s>chroma_intra_matrix[j] = v; 
1760 
} 
1761 
} 
1762 
if (get_bits1(&s>gb)) {

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

1765 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1766 
s>inter_matrix[j] = v; 
1767 
s>chroma_inter_matrix[j] = v; 
1768 
} 
1769 
} 
1770 
if (get_bits1(&s>gb)) {

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

1773 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1774 
s>chroma_intra_matrix[j] = v; 
1775 
} 
1776 
} 
1777 
if (get_bits1(&s>gb)) {

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

1780 
j= s>dsp.idct_permutation[ ff_zigzag_direct[i] ]; 
1781 
s>chroma_inter_matrix[j] = v; 
1782 
} 
1783 
} 
1784 
} 
1785  
1786 
static void mpeg_decode_picture_coding_extension(MpegEncContext *s) 
1787 
{ 
1788 
s>full_pel[0] = s>full_pel[1] = 0; 
1789 
s>mpeg_f_code[0][0] = get_bits(&s>gb, 4); 
1790 
s>mpeg_f_code[0][1] = get_bits(&s>gb, 4); 
1791 
s>mpeg_f_code[1][0] = get_bits(&s>gb, 4); 
1792 
s>mpeg_f_code[1][1] = get_bits(&s>gb, 4); 
1793 
s>intra_dc_precision = get_bits(&s>gb, 2);

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

1795 
s>top_field_first = get_bits1(&s>gb); 
1796 
s>frame_pred_frame_dct = get_bits1(&s>gb); 
1797 
s>concealment_motion_vectors = get_bits1(&s>gb); 
1798 
s>q_scale_type = get_bits1(&s>gb); 
1799 
s>intra_vlc_format = get_bits1(&s>gb); 
1800 
s>alternate_scan = get_bits1(&s>gb); 
1801 
s>repeat_first_field = get_bits1(&s>gb); 
1802 
s>chroma_420_type = get_bits1(&s>gb); 
1803 
s>progressive_frame = get_bits1(&s>gb); 
1804 

1805 
if(s>picture_structure == PICT_FRAME)

1806 
s>first_field=0;

1807 
else{

1808 
s>first_field ^= 1;

1809 
memset(s>mbskip_table, 0, s>mb_stride*s>mb_height);

1810 
} 
1811 

1812 
if(s>alternate_scan){

1813 
ff_init_scantable(s>dsp.idct_permutation, &s>inter_scantable , ff_alternate_vertical_scan); 
1814 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_scantable , ff_alternate_vertical_scan); 
1815 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_h_scantable, ff_alternate_vertical_scan); 
1816 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1817 
}else{

1818 
ff_init_scantable(s>dsp.idct_permutation, &s>inter_scantable , ff_zigzag_direct); 
1819 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_scantable , ff_zigzag_direct); 
1820 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_h_scantable, ff_alternate_horizontal_scan); 
1821 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_v_scantable, ff_alternate_vertical_scan); 
1822 
} 
1823 

1824 
/* composite display not parsed */

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

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

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

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

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

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

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

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

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

1834 
} 
1835  
1836 
static void mpeg_decode_extension(AVCodecContext *avctx, 
1837 
uint8_t *buf, int buf_size)

1838 
{ 
1839 
Mpeg1Context *s1 = avctx>priv_data; 
1840 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1841 
int ext_type;

1842  
1843 
init_get_bits(&s>gb, buf, buf_size*8);

1844 

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

1846 
switch(ext_type) {

1847 
case 0x1: 
1848 
/* sequence ext */

1849 
mpeg_decode_sequence_extension(s); 
1850 
break;

1851 
case 0x3: 
1852 
/* quant matrix extension */

1853 
mpeg_decode_quant_matrix_extension(s); 
1854 
break;

1855 
case 0x8: 
1856 
/* picture extension */

1857 
mpeg_decode_picture_coding_extension(s); 
1858 
break;

1859 
} 
1860 
} 
1861  
1862 
static void exchange_uv(AVFrame *f){ 
1863 
uint8_t *t= f>data[1];

1864 
f>data[1]= f>data[2]; 
1865 
f>data[2]= t;

1866 
} 
1867  
1868 
#define DECODE_SLICE_FATAL_ERROR 2 
1869 
#define DECODE_SLICE_ERROR 1 
1870 
#define DECODE_SLICE_OK 0 
1871  
1872 
/**

1873 
* decodes a slice.

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

1875 
* DECODE_SLICE_ERROR if the slice is damaged<br>

1876 
* DECODE_SLICE_OK if this slice is ok<br>

1877 
*/

1878 
static int mpeg_decode_slice(AVCodecContext *avctx, 
1879 
AVFrame *pict, 
1880 
int start_code,

1881 
uint8_t **buf, int buf_size)

1882 
{ 
1883 
Mpeg1Context *s1 = avctx>priv_data; 
1884 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
1885 
int ret;

1886 
const int field_pic= s>picture_structure != PICT_FRAME; 
1887  
1888 
s>resync_mb_x= s>mb_x = 
1889 
s>resync_mb_y= s>mb_y = 1;

1890 

1891 
start_code = (start_code  1) & 0xff; 
1892 
if (start_code >= s>mb_height){

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

1894 
return 1; 
1895 
} 
1896 

1897 
ff_mpeg1_clean_buffers(s); 
1898 
s>interlaced_dct = 0;

1899 

1900 
/* start frame decoding */

1901 
if (s>first_slice) {

1902 
if(s>first_field  s>picture_structure==PICT_FRAME){

1903 
if(MPV_frame_start(s, avctx) < 0) 
1904 
return DECODE_SLICE_FATAL_ERROR;

1905  
1906 
ff_er_frame_start(s); 
1907  
1908 
/* first check if we must repeat the frame */

1909 
s>current_picture_ptr>repeat_pict = 0;

1910 
if (s>repeat_first_field) {

1911 
if (s>progressive_sequence) {

1912 
if (s>top_field_first)

1913 
s>current_picture_ptr>repeat_pict = 4;

1914 
else

1915 
s>current_picture_ptr>repeat_pict = 2;

1916 
} else if (s>progressive_frame) { 
1917 
s>current_picture_ptr>repeat_pict = 1;

1918 
} 
1919 
} 
1920 
//printf("%d\n", s>current_picture_ptr>repeat_pict);

1921  
1922 
if(s>avctx>debug&FF_DEBUG_PICT_INFO){

1923 
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",

1924 
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], 
1925 
s>pict_type == I_TYPE ? "I" : (s>pict_type == P_TYPE ? "P" : (s>pict_type == B_TYPE ? "B" : "S")), 
1926 
s>progressive_sequence ? "pro" :"", s>alternate_scan ? "alt" :"", s>top_field_first ? "top" :"", 
1927 
s>intra_dc_precision, s>picture_structure, s>frame_pred_frame_dct, s>concealment_motion_vectors, 
1928 
s>q_scale_type, s>intra_vlc_format, s>repeat_first_field, s>chroma_420_type ? "420" :""); 
1929 
} 
1930 
}else{ //second field 
1931 
int i;

1932 

1933 
if(!s>current_picture_ptr){

1934 
fprintf(stderr, "first field missing\n");

1935 
return 1; 
1936 
} 
1937 

1938 
for(i=0; i<4; i++){ 
1939 
s>current_picture.data[i] = s>current_picture_ptr>data[i]; 
1940 
if(s>picture_structure == PICT_BOTTOM_FIELD){

1941 
s>current_picture.data[i] += s>current_picture_ptr>linesize[i]; 
1942 
} 
1943 
} 
1944 
} 
1945 
#ifdef HAVE_XVMC

1946 
// MPV_frame_start will call this function too,

1947 
// but we need to call it on every field

1948 
if(s>avctx>xvmc_acceleration)

1949 
XVMC_field_start(s,avctx); 
1950 
#endif

1951 
}//fi(s>first_slice)

1952 
s>first_slice = 0;

1953  
1954 
init_get_bits(&s>gb, *buf, buf_size*8);

1955  
1956 
s>qscale = get_qscale(s); 
1957 
if(s>qscale == 0){ 
1958 
fprintf(stderr, "qscale == 0\n");

1959 
return 1; 
1960 
} 
1961 

1962 
/* extra slice info */

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

1965 
} 
1966 

1967 
s>mb_x=0;

1968  
1969 
for(;;) {

1970 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
1971 
if (code < 0){ 
1972 
fprintf(stderr, "first mb_incr damaged\n");

1973 
return 1; 
1974 
} 
1975 
if (code >= 33) { 
1976 
if (code == 33) { 
1977 
s>mb_x += 33;

1978 
} 
1979 
/* otherwise, stuffing, nothing to do */

1980 
} else {

1981 
s>mb_x += code; 
1982 
break;

1983 
} 
1984 
} 
1985 

1986 
s>resync_mb_x= s>mb_x; 
1987 
s>resync_mb_y= s>mb_y = start_code; 
1988 
s>mb_skip_run= 0;

1989 
ff_init_block_index(s); 
1990  
1991 
for(;;) {

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

1993  
1994 
ret = mpeg_decode_mb(s, s>block); 
1995  
1996 
dprintf("ret=%d\n", ret);

1997 
if (ret < 0) 
1998 
return 1; 
1999 

2000 
if(s>motion_val && s>pict_type != B_TYPE){ //note motion_val is normally NULL unless we want to extract the MVs 
2001 
const int wrap = s>block_wrap[0]; 
2002 
const int xy = s>mb_x*2 + 1 + (s>mb_y*2 +1)*wrap; 
2003 
int motion_x, motion_y;

2004  
2005 
if (s>mb_intra) {

2006 
motion_x = motion_y = 0;

2007 
}else if (s>mv_type == MV_TYPE_16X16) { 
2008 
motion_x = s>mv[0][0][0]; 
2009 
motion_y = s>mv[0][0][1]; 
2010 
} else /*if (s>mv_type == MV_TYPE_FIELD)*/ { 
2011 
motion_x = s>mv[0][0][0] + s>mv[0][1][0]; 
2012 
motion_y = s>mv[0][0][1] + s>mv[0][1][1]; 
2013 
motion_x = (motion_x>>1)  (motion_x&1); 
2014 
} 
2015 
s>motion_val[xy][0] = motion_x;

2016 
s>motion_val[xy][1] = motion_y;

2017 
s>motion_val[xy + 1][0] = motion_x; 
2018 
s>motion_val[xy + 1][1] = motion_y; 
2019 
s>motion_val[xy + wrap][0] = motion_x;

2020 
s>motion_val[xy + wrap][1] = motion_y;

2021 
s>motion_val[xy + 1 + wrap][0] = motion_x; 
2022 
s>motion_val[xy + 1 + wrap][1] = motion_y; 
2023 
} 
2024 

2025 
s>dest[0] += 16; 
2026 
s>dest[1] += 8; 
2027 
s>dest[2] += 8; 
2028  
2029 
MPV_decode_mb(s, s>block); 
2030 

2031 
if (++s>mb_x >= s>mb_width) {

2032 
if(s>avctx>codec_tag == ff_get_fourcc("VCR2")) 
2033 
exchange_uv((AVFrame*)s>current_picture_ptr); 
2034  
2035 
ff_draw_horiz_band(s, 16*s>mb_y, 16); 
2036  
2037 
if(s>avctx>codec_tag == ff_get_fourcc("VCR2")) 
2038 
exchange_uv((AVFrame*)s>current_picture_ptr); 
2039  
2040 
s>mb_x = 0;

2041 
s>mb_y++; 
2042  
2043 
if(s>mb_y<<field_pic >= s>mb_height){

2044 
int left= s>gb.size_in_bits  get_bits_count(&s>gb);

2045  
2046 
if(left < 0  (left && show_bits(&s>gb, FFMIN(left, 23))) 
2047 
 (avctx>error_resilience >= FF_ER_AGGRESSIVE && left>8)){

2048 
fprintf(stderr, "end missmatch left=%d\n", left);

2049 
return 1; 
2050 
}else

2051 
goto eos;

2052 
} 
2053 

2054 
ff_init_block_index(s); 
2055 
} 
2056  
2057 
/* skip mb handling */

2058 
if (s>mb_skip_run == 1) { 
2059 
/* read again increment */

2060 
s>mb_skip_run = 0;

2061 
for(;;) {

2062 
int code = get_vlc2(&s>gb, mbincr_vlc.table, MBINCR_VLC_BITS, 2); 
2063 
if (code < 0){ 
2064 
fprintf(stderr, "mb incr damaged\n");

2065 
return 1; 
2066 
} 
2067 
if (code >= 33) { 
2068 
if (code == 33) { 
2069 
s>mb_skip_run += 33;

2070 
}else if(code == 35){ 
2071 
if(s>mb_skip_run != 0  show_bits(&s>gb, 15) != 0){ 
2072 
fprintf(stderr, "slice missmatch\n");

2073 
return 1; 
2074 
} 
2075 
goto eos; /* end of slice */ 
2076 
} 
2077 
/* otherwise, stuffing, nothing to do */

2078 
} else {

2079 
s>mb_skip_run += code; 
2080 
break;

2081 
} 
2082 
} 
2083 
} 
2084 
} 
2085 
eos: // end of slice 
2086 
*buf += get_bits_count(&s>gb)/8  1; 
2087 
//printf("y %d %d %d %d\n", s>resync_mb_x, s>resync_mb_y, s>mb_x, s>mb_y);

2088 
return 0; 
2089 
} 
2090  
2091 
/**

2092 
* handles slice ends.

2093 
* @return 1 if it seems to be the last slice of

2094 
*/

2095 
static int slice_end(AVCodecContext *avctx, AVFrame *pict) 
2096 
{ 
2097 
Mpeg1Context *s1 = avctx>priv_data; 
2098 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
2099 

2100 
if (!s1>mpeg_enc_ctx_allocated  !s>current_picture_ptr)

2101 
return 0; 
2102  
2103 
#ifdef HAVE_XVMC

2104 
if(s>avctx>xvmc_acceleration)

2105 
XVMC_field_end(s); 
2106 
#endif

2107 
/* end of slice reached */

2108 
if (/*s>mb_y<<field_pic == s>mb_height &&*/ !s>first_field) { 
2109 
/* end of image */

2110  
2111 
if(s>codec_id == CODEC_ID_MPEG2VIDEO){

2112 
s>current_picture_ptr>qscale_type= FF_QSCALE_TYPE_MPEG2; 
2113 
}else

2114 
s>current_picture_ptr>qscale_type= FF_QSCALE_TYPE_MPEG1; 
2115  
2116 
ff_er_frame_end(s); 
2117  
2118 
MPV_frame_end(s); 
2119  
2120 
if (s>pict_type == B_TYPE  s>low_delay) {

2121 
*pict= *(AVFrame*)s>current_picture_ptr; 
2122 
ff_print_debug_info(s, s>current_picture_ptr); 
2123 
} else {

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

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

2127 
if (s>last_picture_ptr != NULL) { 
2128 
*pict= *(AVFrame*)s>last_picture_ptr; 
2129 
ff_print_debug_info(s, s>last_picture_ptr); 
2130 
} 
2131 
} 
2132 
if(s>avctx>codec_tag == ff_get_fourcc("VCR2")) 
2133 
exchange_uv(pict); 
2134  
2135 
return 1; 
2136 
} else {

2137 
return 0; 
2138 
} 
2139 
} 
2140  
2141 
static int mpeg1_decode_sequence(AVCodecContext *avctx, 
2142 
uint8_t *buf, int buf_size)

2143 
{ 
2144 
Mpeg1Context *s1 = avctx>priv_data; 
2145 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
2146 
int width, height, i, v, j;

2147 
float aspect;

2148  
2149 
init_get_bits(&s>gb, buf, buf_size*8);

2150  
2151 
width = get_bits(&s>gb, 12);

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

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

2154 
if(s>codec_id == CODEC_ID_MPEG1VIDEO){

2155 
aspect= mpeg1_aspect[s>aspect_ratio_info]; 
2156 
if(aspect!=0.0) avctx>aspect_ratio= width/(aspect*height); 
2157 
} 
2158  
2159 
s>frame_rate_index = get_bits(&s>gb, 4);

2160 
if (s>frame_rate_index == 0) 
2161 
return 1; 
2162 
s>bit_rate = get_bits(&s>gb, 18) * 400; 
2163 
if (get_bits1(&s>gb) == 0) /* marker */ 
2164 
return 1; 
2165 
if (width <= 0  height <= 0  
2166 
(width % 2) != 0  (height % 2) != 0) 
2167 
return 1; 
2168 
if (width != s>width 

2169 
height != s>height) { 
2170 
/* start new mpeg1 context decoding */

2171 
s>out_format = FMT_MPEG1; 
2172 
if (s1>mpeg_enc_ctx_allocated) {

2173 
MPV_common_end(s); 
2174 
} 
2175 
s>width = width; 
2176 
s>height = height; 
2177 
avctx>has_b_frames= 1;

2178 
s>avctx = avctx; 
2179 
avctx>width = width; 
2180 
avctx>height = height; 
2181 
av_reduce( 
2182 
&avctx>frame_rate, 
2183 
&avctx>frame_rate_base, 
2184 
frame_rate_tab[s>frame_rate_index], 
2185 
MPEG1_FRAME_RATE_BASE, //FIXME store in allready reduced form

2186 
1<<30 
2187 
); 
2188 
avctx>bit_rate = s>bit_rate; 
2189 

2190 
//get_format() or set_video(width,height,aspect,pix_fmt);

2191 
//until then pix_fmt may be changed right after codec init

2192 
if( avctx>pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )

2193 
avctx>idct_algo = FF_IDCT_SIMPLE; 
2194  
2195 
if (MPV_common_init(s) < 0) 
2196 
return 1; 
2197 
s1>mpeg_enc_ctx_allocated = 1;

2198 
} 
2199  
2200 
skip_bits(&s>gb, 10); /* vbv_buffer_size */ 
2201 
skip_bits(&s>gb, 1);

2202  
2203 
/* get matrix */

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

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

2207 
j = s>intra_scantable.permutated[i]; 
2208 
s>intra_matrix[j] = v; 
2209 
s>chroma_intra_matrix[j] = v; 
2210 
} 
2211 
#ifdef DEBUG

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

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

2215 
printf("\n");

2216 
#endif

2217 
} else {

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

2220 
v = ff_mpeg1_default_intra_matrix[i]; 
2221 
s>intra_matrix[j] = v; 
2222 
s>chroma_intra_matrix[j] = v; 
2223 
} 
2224 
} 
2225 
if (get_bits1(&s>gb)) {

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

2228 
j = s>intra_scantable.permutated[i]; 
2229 
s>inter_matrix[j] = v; 
2230 
s>chroma_inter_matrix[j] = v; 
2231 
} 
2232 
#ifdef DEBUG

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

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

2236 
printf("\n");

2237 
#endif

2238 
} else {

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

2241 
v = ff_mpeg1_default_non_intra_matrix[i]; 
2242 
s>inter_matrix[j] = v; 
2243 
s>chroma_inter_matrix[j] = v; 
2244 
} 
2245 
} 
2246  
2247 
/* we set mpeg2 parameters so that it emulates mpeg1 */

2248 
s>progressive_sequence = 1;

2249 
s>progressive_frame = 1;

2250 
s>picture_structure = PICT_FRAME; 
2251 
s>frame_pred_frame_dct = 1;

2252 
s>codec_id= s>avctx>codec_id= CODEC_ID_MPEG1VIDEO; 
2253 
avctx>sub_id = 1; /* indicates mpeg1 */ 
2254 
return 0; 
2255 
} 
2256  
2257 
static int vcr2_init_sequence(AVCodecContext *avctx) 
2258 
{ 
2259 
Mpeg1Context *s1 = avctx>priv_data; 
2260 
MpegEncContext *s = &s1>mpeg_enc_ctx; 
2261 
int i, v;

2262  
2263 
/* start new mpeg1 context decoding */

2264 
s>out_format = FMT_MPEG1; 
2265 
if (s1>mpeg_enc_ctx_allocated) {

2266 
MPV_common_end(s); 
2267 
} 
2268 
s>width = avctx>width; 
2269 
s>height = avctx>height; 
2270 
avctx>has_b_frames= 0; //true? 
2271 
s>low_delay= 1;

2272 
s>avctx = avctx; 
2273  
2274 
//get_format() or set_video(width,height,aspect,pix_fmt);

2275 
//until then pix_fmt may be changed right after codec init

2276 
if( avctx>pix_fmt == PIX_FMT_XVMC_MPEG2_IDCT )

2277 
avctx>idct_algo = FF_IDCT_SIMPLE; 
2278 

2279 
if (MPV_common_init(s) < 0) 
2280 
return 1; 
2281 
s1>mpeg_enc_ctx_allocated = 1;

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

2285 
v = ff_mpeg1_default_intra_matrix[i]; 
2286 
s>intra_matrix[j] = v; 
2287 
s>chroma_intra_matrix[j] = v; 
2288  
2289 
v = ff_mpeg1_default_non_intra_matrix[i]; 
2290 
s>inter_matrix[j] = v; 
2291 
s>chroma_inter_matrix[j] = v; 
2292 
} 
2293  
2294 
s>progressive_sequence = 1;

2295 
s>progressive_frame = 1;

2296 
s>picture_structure = PICT_FRAME; 
2297 
s>frame_pred_frame_dct = 1;

2298 
s>codec_id= s>avctx>codec_id= CODEC_ID_MPEG2VIDEO; 
2299 
avctx>sub_id = 2; /* indicates mpeg2 */ 
2300 
return 0; 
2301 
} 
2302  
2303  
2304 
static void mpeg_decode_user_data(AVCodecContext *avctx, 
2305 
const uint8_t *buf, int buf_size) 
2306 
{ 
2307 
const uint8_t *p;

2308 
int len, flags;

2309 
p = buf; 
2310 
len = buf_size; 
2311  
2312 
/* we parse the DTG active format information */

2313 
if (len >= 5 && 
2314 
p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') { 
2315 
flags = p[4];

2316 
p += 5;

2317 
len = 5;

2318 
if (flags & 0x80) { 
2319 
/* skip event id */

2320 
if (len < 2) 
2321 
return;

2322 
p += 2;

2323 
len = 2;

2324 
} 
2325 
if (flags & 0x40) { 
2326 
if (len < 1) 
2327 
return;

2328 
avctx>dtg_active_format = p[0] & 0x0f; 
2329 
} 
2330 
} 
2331 
} 
2332  
2333 
/**

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

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

2336 
*/

2337 
static int mpeg1_find_frame_end(MpegEncContext *s, uint8_t *buf, int buf_size){ 
2338 
ParseContext *pc= &s>parse_context; 
2339 
int i;

2340 
uint32_t state; 
2341 

2342 
state= pc>state; 
2343 

2344 
i=0;

2345 
if(!pc>frame_start_found){

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

2348 
if(state >= SLICE_MIN_START_CODE && state <= SLICE_MAX_START_CODE){

2349 
i++; 
2350 
pc>frame_start_found=1;

2351 
break;

2352 
} 
2353 
} 
2354 
} 
2355 

2356 
if(pc>frame_start_found){

2357 
for(; i<buf_size; i++){

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

2359 
if((state&0xFFFFFF00) == 0x100){ 
2360 
if(state < SLICE_MIN_START_CODE  state > SLICE_MAX_START_CODE){

2361 
pc>frame_start_found=0;

2362 
pc>state=1;

2363 
return i3; 
2364 
} 
2365 
} 
2366 
} 
2367 
} 
2368 
pc>state= state; 
2369 
return END_NOT_FOUND;

2370 
} 
2371  
2372 
/* handle buffering and image synchronisation */

2373 
static int mpeg_decode_frame(AVCodecContext *avctx, 
2374 
void *data, int *data_size, 
2375 
uint8_t *buf, int buf_size)

2376 
{ 
2377 
Mpeg1Context *s = avctx>priv_data; 
2378 
uint8_t *buf_end, *buf_ptr; 
2379 
int ret, start_code, input_size;

2380 
AVFrame *picture = data; 
2381 
MpegEncContext *s2 = &s>mpeg_enc_ctx; 
2382 
dprintf("fill_buffer\n");

2383  
2384 
*data_size = 0;

2385  
2386 
/* special case for last picture */

2387 
if (buf_size == 0 && s2>low_delay==0 && s2>next_picture_ptr) { 
2388 
*picture= *(AVFrame*)s2>next_picture_ptr; 
2389 
s2>next_picture_ptr= NULL;

2390  
2391 
*data_size = sizeof(AVFrame);

2392 
return 0; 
2393 
} 
2394  
2395 
if(s2>flags&CODEC_FLAG_TRUNCATED){

2396 
int next= mpeg1_find_frame_end(s2, buf, buf_size);

2397 

2398 
if( ff_combine_frame(s2, next, &buf, &buf_size) < 0 ) 
2399 
return buf_size;

2400 
} 
2401 

2402 
buf_ptr = buf; 
2403 
buf_end = buf + buf_size; 
2404  
2405 
#if 0

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

2407 
s>repeat_field++;

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

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

2410 
if (avctx>flags & CODEC_FLAG_REPEAT_FIELD) {

2411 
*data_size = sizeof(AVPicture);

2412 
goto the_end;

2413 
}

2414 
}

2415 
#endif

2416  
2417 
if(s>mpeg_enc_ctx_allocated==0 && avctx>codec_tag == ff_get_fourcc("VCR2")) 
2418 
vcr2_init_sequence(avctx); 
2419  
2420 
for(;;) {

2421 
/* find start next code */

2422 
start_code = find_start_code(&buf_ptr, buf_end); 
2423 
if (start_code < 0){ 
2424 
if (slice_end(avctx, picture)) {

2425 
if(s2>last_picture_ptr) //FIXME merge with the stuff in mpeg_decode_slice 
2426 
*data_size = sizeof(AVPicture);

2427 
} 
2428 
return FFMAX(0, buf_ptr  buf  s2>parse_context.last_index); 
2429 
} 
2430 

2431 
input_size = buf_end  buf_ptr; 
2432  
2433 
if(avctx>debug & FF_DEBUG_STARTCODE){

2434 
printf("%3X at %d left %d\n", start_code, buf_ptrbuf, input_size);

2435 
} 
2436  
2437 
/* prepare data for next start code */

2438 
switch(start_code) {

2439 
case SEQ_START_CODE:

2440 
mpeg1_decode_sequence(avctx, buf_ptr, 
2441 
input_size); 
2442 
break;

2443 

2444 
case PICTURE_START_CODE:

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

2446 
mpeg1_decode_picture(avctx, 
2447 
buf_ptr, input_size); 
2448 
break;

2449 
case EXT_START_CODE:

2450 
mpeg_decode_extension(avctx, 
2451 
buf_ptr, input_size); 
2452 
break;

2453 
case USER_START_CODE:

2454 
mpeg_decode_user_data(avctx, 
2455 
buf_ptr, input_size); 
2456 
break;

2457 
case GOP_START_CODE:

2458 
s2>first_field=0;

2459 
break;

2460 
default:

2461 
if (start_code >= SLICE_MIN_START_CODE &&

2462 
start_code <= SLICE_MAX_START_CODE) { 
2463 

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

2465 
if(s2>last_picture_ptr==NULL && s2>pict_type==B_TYPE) break; 
2466 
/* skip b frames if we are in a hurry */

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

2469 
if(avctx>hurry_up>=5) break; 
2470 

2471 
if (!s>mpeg_enc_ctx_allocated) break; 
2472  
2473 
ret = mpeg_decode_slice(avctx, picture, 
2474 
start_code, &buf_ptr, input_size); 
2475 
emms_c(); 
2476  
2477 
if(ret < 0){ 
2478 
if(s2>resync_mb_x>=0 && s2>resync_mb_y>=0) 
2479 
ff_er_add_slice(s2, s2>resync_mb_x, s2>resync_mb_y, s2>mb_x, s2>mb_y, AC_ERRORDC_ERRORMV_ERROR); 
2480 
if(ret==DECODE_SLICE_FATAL_ERROR) return 1; 
2481 
}else{

2482 
ff_er_add_slice(s2, s2>resync_mb_x, s2>resync_mb_y, s2>mb_x1, s2>mb_y, AC_ENDDC_ENDMV_END);

2483 
} 
2484 
} 
2485 
break;

2486 
} 
2487 
} 
2488 
} 
2489  
2490 
static int mpeg_decode_end(AVCodecContext *avctx) 
2491 
{ 
2492 
Mpeg1Context *s = avctx>priv_data; 
2493  
2494 
if (s>mpeg_enc_ctx_allocated)

2495 
MPV_common_end(&s>mpeg_enc_ctx); 
2496 
return 0; 
2497 
} 
2498  
2499 
AVCodec mpeg_decoder = { 
2500 
"mpegvideo",

2501 
CODEC_TYPE_VIDEO, 
2502 
CODEC_ID_MPEG1VIDEO, 
2503 
sizeof(Mpeg1Context),

2504 
mpeg_decode_init, 
2505 
NULL,

2506 
mpeg_decode_end, 
2507 
mpeg_decode_frame, 
2508 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1  CODEC_CAP_TRUNCATED, 
2509 
.flush= ff_mpeg_flush, 
2510 
}; 
2511  
2512 
#ifdef HAVE_XVMC

2513 
static int mpeg_mc_decode_init(AVCodecContext *avctx){ 
2514 
Mpeg1Context *s; 
2515  
2516 
if( !(avctx>slice_flags & SLICE_FLAG_CODED_ORDER) )

2517 
return 1; 
2518 
if( !(avctx>slice_flags & SLICE_FLAG_ALLOW_FIELD) )

2519 
dprintf("mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");

2520  
2521 
mpeg_decode_init(avctx); 
2522 
s = avctx>priv_data; 
2523  
2524 
avctx>pix_fmt = PIX_FMT_XVMC_MPEG2_IDCT; 
2525 
avctx>xvmc_acceleration = 1;

2526  
2527 
return 0; 
2528 
} 
2529  
2530 
AVCodec mpeg_xvmc_decoder = { 
2531 
"mpegvideo_xvmc",

2532 
CODEC_TYPE_VIDEO, 
2533 
CODEC_ID_MPEG2VIDEO_XVMC, 
2534 
sizeof(Mpeg1Context),

2535 
mpeg_mc_decode_init, 
2536 
NULL,

2537 
mpeg_decode_end, 
2538 
mpeg_decode_frame, 
2539 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1  CODEC_CAP_TRUNCATED, 
2540 
}; 
2541  
2542 
#endif

2543  
2544 
/* this is ugly i know, but the alternative is too make

2545 
hundreds of vars global and prefix them with ff_mpeg1_

2546 
which is far uglier. */

2547 
#include "mdec.c" 