ffmpeg / libavcodec / msmpeg4.c @ 755bfeab
History  View  Annotate  Download (60 KB)
1 
/*


2 
* MSMPEG4 backend for ffmpeg encoder and decoder

3 
* Copyright (c) 2001 Fabrice Bellard.

4 
* Copyright (c) 20022004 Michael Niedermayer <michaelni@gmx.at>

5 
*

6 
* This file is part of FFmpeg.

7 
*

8 
* FFmpeg is free software; you can redistribute it and/or

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

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

11 
* version 2.1 of the License, or (at your option) any later version.

12 
*

13 
* FFmpeg is distributed in the hope that it will be useful,

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

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

16 
* Lesser General Public License for more details.

17 
*

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

19 
* License along with FFmpeg; if not, write to the Free Software

20 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

21 
*

22 
* msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>

23 
*/

24  
25 
/**

26 
* @file msmpeg4.c

27 
* MSMPEG4 backend for ffmpeg encoder and decoder.

28 
*/

29  
30 
#include "avcodec.h" 
31 
#include "dsputil.h" 
32 
#include "mpegvideo.h" 
33  
34 
/*

35 
* You can also call this codec : MPEG4 with a twist !

36 
*

37 
* TODO:

38 
*  (encoding) select best mv table (two choices)

39 
*  (encoding) select best vlc/dc table

40 
*/

41 
//#define DEBUG

42  
43 
#define DC_VLC_BITS 9 
44 
#define CBPY_VLC_BITS 6 
45 
#define INTER_INTRA_VLC_BITS 3 
46 
#define V1_INTRA_CBPC_VLC_BITS 6 
47 
#define V1_INTER_CBPC_VLC_BITS 6 
48 
#define V2_INTRA_CBPC_VLC_BITS 3 
49 
#define V2_MB_TYPE_VLC_BITS 7 
50 
#define MV_VLC_BITS 9 
51 
#define V2_MV_VLC_BITS 9 
52 
#define TEX_VLC_BITS 9 
53 
#define MB_NON_INTRA_VLC_BITS 9 
54 
#define MB_INTRA_VLC_BITS 9 
55  
56 
#define II_BITRATE 128*1024 
57 
#define MBAC_BITRATE 50*1024 
58  
59 
#define DEFAULT_INTER_INDEX 3 
60  
61 
static uint32_t v2_dc_lum_table[512][2]; 
62 
static uint32_t v2_dc_chroma_table[512][2]; 
63  
64 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n); 
65 
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
66 
int n, int coded, const uint8_t *scantable); 
67 
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr); 
68 
static int msmpeg4_decode_motion(MpegEncContext * s, 
69 
int *mx_ptr, int *my_ptr); 
70 
static void init_h263_dc_for_msmpeg4(void); 
71 
static inline void msmpeg4_memsetw(short *tab, int val, int n); 
72 
#ifdef CONFIG_ENCODERS

73 
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val); 
74 
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra); 
75 
#endif //CONFIG_ENCODERS 
76 
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); 
77 
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); 
78 
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]); 
79  
80 
/* vc1 externs */

81 
extern uint8_t wmv3_dc_scale_table[32]; 
82  
83 
#ifdef DEBUG

84 
int intra_count = 0; 
85 
int frame_count = 0; 
86 
#endif

87  
88 
#include "msmpeg4data.h" 
89 
#include "msmpeg4tab.h" 
90  
91 
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references 
92 
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; 
93 
#endif //CONFIG_ENCODERS 
94  
95 
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3]; 
96  
97 
static void common_init(MpegEncContext * s) 
98 
{ 
99 
static int inited=0; 
100  
101 
switch(s>msmpeg4_version){

102 
case 1: 
103 
case 2: 
104 
s>y_dc_scale_table= 
105 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
106 
break;

107 
case 3: 
108 
if(s>workaround_bugs){

109 
s>y_dc_scale_table= old_ff_y_dc_scale_table; 
110 
s>c_dc_scale_table= old_ff_c_dc_scale_table; 
111 
} else{

112 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 
113 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
114 
} 
115 
break;

116 
case 4: 
117 
case 5: 
118 
s>y_dc_scale_table= wmv1_y_dc_scale_table; 
119 
s>c_dc_scale_table= wmv1_c_dc_scale_table; 
120 
break;

121 
#if defined(CONFIG_WMV3_DECODER)defined(CONFIG_VC1_DECODER)

122 
case 6: 
123 
s>y_dc_scale_table= wmv3_dc_scale_table; 
124 
s>c_dc_scale_table= wmv3_dc_scale_table; 
125 
break;

126 
#endif

127  
128 
} 
129  
130  
131 
if(s>msmpeg4_version>=4){ 
132 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_scantable , wmv1_scantable[1]);

133 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_h_scantable, wmv1_scantable[2]);

134 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_v_scantable, wmv1_scantable[3]);

135 
ff_init_scantable(s>dsp.idct_permutation, &s>inter_scantable , wmv1_scantable[0]);

136 
} 
137 
//Note the default tables are set in common_init in mpegvideo.c

138  
139 
if(!inited){

140 
inited=1;

141  
142 
init_h263_dc_for_msmpeg4(); 
143 
} 
144 
} 
145  
146 
#ifdef CONFIG_ENCODERS

147  
148 
/* build the table which associate a (x,y) motion vector to a vlc */

149 
static void init_mv_table(MVTable *tab) 
150 
{ 
151 
int i, x, y;

152  
153 
tab>table_mv_index = av_malloc(sizeof(uint16_t) * 4096); 
154 
/* mark all entries as not used */

155 
for(i=0;i<4096;i++) 
156 
tab>table_mv_index[i] = tab>n; 
157  
158 
for(i=0;i<tab>n;i++) { 
159 
x = tab>table_mvx[i]; 
160 
y = tab>table_mvy[i]; 
161 
tab>table_mv_index[(x << 6)  y] = i;

162 
} 
163 
} 
164  
165 
void ff_code012(PutBitContext *pb, int n) 
166 
{ 
167 
if (n == 0) { 
168 
put_bits(pb, 1, 0); 
169 
} else {

170 
put_bits(pb, 1, 1); 
171 
put_bits(pb, 1, (n >= 2)); 
172 
} 
173 
} 
174  
175 
void ff_msmpeg4_encode_init(MpegEncContext *s)

176 
{ 
177 
static int init_done=0; 
178 
int i;

179  
180 
common_init(s); 
181 
if(s>msmpeg4_version>=4){ 
182 
s>min_qcoeff= 255;

183 
s>max_qcoeff= 255;

184 
} 
185  
186 
if (!init_done) {

187 
/* init various encoding tables */

188 
init_done = 1;

189 
init_mv_table(&mv_tables[0]);

190 
init_mv_table(&mv_tables[1]);

191 
for(i=0;i<NB_RL_TABLES;i++) 
192 
init_rl(&rl_table[i], static_rl_table_store[i]); 
193  
194 
for(i=0; i<NB_RL_TABLES; i++){ 
195 
int level;

196 
for(level=0; level<=MAX_LEVEL; level++){ 
197 
int run;

198 
for(run=0; run<=MAX_RUN; run++){ 
199 
int last;

200 
for(last=0; last<2; last++){ 
201 
rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0);

202 
} 
203 
} 
204 
} 
205 
} 
206 
} 
207 
} 
208  
209 
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ 
210 
int size=0; 
211 
int code;

212 
int run_diff= intra ? 0 : 1; 
213  
214 
code = get_rl_index(rl, last, run, level); 
215 
size+= rl>table_vlc[code][1];

216 
if (code == rl>n) {

217 
int level1, run1;

218  
219 
level1 = level  rl>max_level[last][run]; 
220 
if (level1 < 1) 
221 
goto esc2;

222 
code = get_rl_index(rl, last, run, level1); 
223 
if (code == rl>n) {

224 
esc2:

225 
size++; 
226 
if (level > MAX_LEVEL)

227 
goto esc3;

228 
run1 = run  rl>max_run[last][level]  run_diff; 
229 
if (run1 < 0) 
230 
goto esc3;

231 
code = get_rl_index(rl, last, run1, level); 
232 
if (code == rl>n) {

233 
esc3:

234 
/* third escape */

235 
size+=1+1+6+8; 
236 
} else {

237 
/* second escape */

238 
size+= 1+1+ rl>table_vlc[code][1]; 
239 
} 
240 
} else {

241 
/* first escape */

242 
size+= 1+1+ rl>table_vlc[code][1]; 
243 
} 
244 
} else {

245 
size++; 
246 
} 
247 
return size;

248 
} 
249  
250 
static void find_best_tables(MpegEncContext * s) 
251 
{ 
252 
int i;

253 
int best =1, best_size =9999999; 
254 
int chroma_best=1, best_chroma_size=9999999; 
255  
256 
for(i=0; i<3; i++){ 
257 
int level;

258 
int chroma_size=0; 
259 
int size=0; 
260  
261 
if(i>0){// ;) 
262 
size++; 
263 
chroma_size++; 
264 
} 
265 
for(level=0; level<=MAX_LEVEL; level++){ 
266 
int run;

267 
for(run=0; run<=MAX_RUN; run++){ 
268 
int last;

269 
const int last_size= size + chroma_size; 
270 
for(last=0; last<2; last++){ 
271 
int inter_count = s>ac_stats[0][0][level][run][last] + s>ac_stats[0][1][level][run][last]; 
272 
int intra_luma_count = s>ac_stats[1][0][level][run][last]; 
273 
int intra_chroma_count= s>ac_stats[1][1][level][run][last]; 
274  
275 
if(s>pict_type==I_TYPE){

276 
size += intra_luma_count *rl_length[i ][level][run][last]; 
277 
chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];

278 
}else{

279 
size+= intra_luma_count *rl_length[i ][level][run][last] 
280 
+intra_chroma_count*rl_length[i+3][level][run][last]

281 
+inter_count *rl_length[i+3][level][run][last];

282 
} 
283 
} 
284 
if(last_size == size+chroma_size) break; 
285 
} 
286 
} 
287 
if(size<best_size){

288 
best_size= size; 
289 
best= i; 
290 
} 
291 
if(chroma_size<best_chroma_size){

292 
best_chroma_size= chroma_size; 
293 
chroma_best= i; 
294 
} 
295 
} 
296  
297 
// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",

298 
// s>pict_type, best, s>qscale, s>mb_var_sum, s>mc_mb_var_sum, best_size);

299  
300 
if(s>pict_type==P_TYPE) chroma_best= best;

301  
302 
memset(s>ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); 
303  
304 
s>rl_table_index = best; 
305 
s>rl_chroma_table_index= chroma_best; 
306  
307 
if(s>pict_type != s>last_non_b_pict_type){

308 
s>rl_table_index= 2;

309 
if(s>pict_type==I_TYPE)

310 
s>rl_chroma_table_index= 1;

311 
else

312 
s>rl_chroma_table_index= 2;

313 
} 
314  
315 
} 
316  
317 
/* write MSMPEG4 compatible frame header */

318 
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
319 
{ 
320 
find_best_tables(s); 
321  
322 
align_put_bits(&s>pb); 
323 
put_bits(&s>pb, 2, s>pict_type  1); 
324  
325 
put_bits(&s>pb, 5, s>qscale);

326 
if(s>msmpeg4_version<=2){ 
327 
s>rl_table_index = 2;

328 
s>rl_chroma_table_index = 2;

329 
} 
330  
331 
s>dc_table_index = 1;

332 
s>mv_table_index = 1; /* only if P frame */ 
333 
s>use_skip_mb_code = 1; /* only if P frame */ 
334 
s>per_mb_rl_table = 0;

335 
if(s>msmpeg4_version==4) 
336 
s>inter_intra_pred= (s>width*s>height < 320*240 && s>bit_rate<=II_BITRATE && s>pict_type==P_TYPE); 
337 
//printf("%d %d %d %d %d\n", s>pict_type, s>bit_rate, s>inter_intra_pred, s>width, s>height);

338  
339 
if (s>pict_type == I_TYPE) {

340 
s>slice_height= s>mb_height/1;

341 
put_bits(&s>pb, 5, 0x16 + s>mb_height/s>slice_height); 
342  
343 
if(s>msmpeg4_version==4){ 
344 
msmpeg4_encode_ext_header(s); 
345 
if(s>bit_rate>MBAC_BITRATE)

346 
put_bits(&s>pb, 1, s>per_mb_rl_table);

347 
} 
348  
349 
if(s>msmpeg4_version>2){ 
350 
if(!s>per_mb_rl_table){

351 
ff_code012(&s>pb, s>rl_chroma_table_index); 
352 
ff_code012(&s>pb, s>rl_table_index); 
353 
} 
354  
355 
put_bits(&s>pb, 1, s>dc_table_index);

356 
} 
357 
} else {

358 
put_bits(&s>pb, 1, s>use_skip_mb_code);

359  
360 
if(s>msmpeg4_version==4 && s>bit_rate>MBAC_BITRATE) 
361 
put_bits(&s>pb, 1, s>per_mb_rl_table);

362  
363 
if(s>msmpeg4_version>2){ 
364 
if(!s>per_mb_rl_table)

365 
ff_code012(&s>pb, s>rl_table_index); 
366  
367 
put_bits(&s>pb, 1, s>dc_table_index);

368  
369 
put_bits(&s>pb, 1, s>mv_table_index);

370 
} 
371 
} 
372  
373 
s>esc3_level_length= 0;

374 
s>esc3_run_length= 0;

375  
376 
#ifdef DEBUG

377 
intra_count = 0;

378 
av_log(s>avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);

379 
#endif

380 
} 
381  
382 
void msmpeg4_encode_ext_header(MpegEncContext * s)

383 
{ 
384 
put_bits(&s>pb, 5, s>avctx>time_base.den / s>avctx>time_base.num); //yes 29.97 > 29 
385  
386 
put_bits(&s>pb, 11, FFMIN(s>bit_rate/1024, 2047)); 
387  
388 
if(s>msmpeg4_version>=3) 
389 
put_bits(&s>pb, 1, s>flipflop_rounding);

390 
else

391 
assert(s>flipflop_rounding==0);

392 
} 
393  
394 
#endif //CONFIG_ENCODERS 
395  
396 
/* predict coded block */

397 
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) 
398 
{ 
399 
int xy, wrap, pred, a, b, c;

400  
401 
xy = s>block_index[n]; 
402 
wrap = s>b8_stride; 
403  
404 
/* B C

405 
* A X

406 
*/

407 
a = s>coded_block[xy  1 ];

408 
b = s>coded_block[xy  1  wrap];

409 
c = s>coded_block[xy  wrap]; 
410  
411 
if (b == c) {

412 
pred = a; 
413 
} else {

414 
pred = c; 
415 
} 
416  
417 
/* store value */

418 
*coded_block_ptr = &s>coded_block[xy]; 
419  
420 
return pred;

421 
} 
422  
423 
#ifdef CONFIG_ENCODERS

424  
425 
static void msmpeg4_encode_motion(MpegEncContext * s, 
426 
int mx, int my) 
427 
{ 
428 
int code;

429 
MVTable *mv; 
430  
431 
/* modulo encoding */

432 
/* WARNING : you cannot reach all the MVs even with the modulo

433 
encoding. This is a somewhat strange compromise they took !!! */

434 
if (mx <= 64) 
435 
mx += 64;

436 
else if (mx >= 64) 
437 
mx = 64;

438 
if (my <= 64) 
439 
my += 64;

440 
else if (my >= 64) 
441 
my = 64;

442  
443 
mx += 32;

444 
my += 32;

445 
#if 0

446 
if ((unsigned)mx >= 64 

447 
(unsigned)my >= 64)

448 
av_log(s>avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my);

449 
#endif

450 
mv = &mv_tables[s>mv_table_index]; 
451  
452 
code = mv>table_mv_index[(mx << 6)  my];

453 
put_bits(&s>pb, 
454 
mv>table_mv_bits[code], 
455 
mv>table_mv_code[code]); 
456 
if (code == mv>n) {

457 
/* escape : code litterally */

458 
put_bits(&s>pb, 6, mx);

459 
put_bits(&s>pb, 6, my);

460 
} 
461 
} 
462  
463 
static inline void handle_slices(MpegEncContext *s){ 
464 
if (s>mb_x == 0) { 
465 
if (s>slice_height && (s>mb_y % s>slice_height) == 0) { 
466 
if(s>msmpeg4_version < 4){ 
467 
ff_mpeg4_clean_buffers(s); 
468 
} 
469 
s>first_slice_line = 1;

470 
} else {

471 
s>first_slice_line = 0;

472 
} 
473 
} 
474 
} 
475  
476 
void msmpeg4_encode_mb(MpegEncContext * s,

477 
DCTELEM block[6][64], 
478 
int motion_x, int motion_y) 
479 
{ 
480 
int cbp, coded_cbp, i;

481 
int pred_x, pred_y;

482 
uint8_t *coded_block; 
483  
484 
handle_slices(s); 
485  
486 
if (!s>mb_intra) {

487 
/* compute cbp */

488 
cbp = 0;

489 
for (i = 0; i < 6; i++) { 
490 
if (s>block_last_index[i] >= 0) 
491 
cbp = 1 << (5  i); 
492 
} 
493 
if (s>use_skip_mb_code && (cbp  motion_x  motion_y) == 0) { 
494 
/* skip macroblock */

495 
put_bits(&s>pb, 1, 1); 
496 
s>last_bits++; 
497 
s>misc_bits++; 
498 
s>skip_count++; 
499  
500 
return;

501 
} 
502 
if (s>use_skip_mb_code)

503 
put_bits(&s>pb, 1, 0); /* mb coded */ 
504  
505 
if(s>msmpeg4_version<=2){ 
506 
put_bits(&s>pb, 
507 
v2_mb_type[cbp&3][1], 
508 
v2_mb_type[cbp&3][0]); 
509 
if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; 
510 
else coded_cbp= cbp;

511  
512 
put_bits(&s>pb, 
513 
cbpy_tab[coded_cbp>>2][1], 
514 
cbpy_tab[coded_cbp>>2][0]); 
515  
516 
s>misc_bits += get_bits_diff(s); 
517  
518 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
519 
msmpeg4v2_encode_motion(s, motion_x  pred_x); 
520 
msmpeg4v2_encode_motion(s, motion_y  pred_y); 
521 
}else{

522 
put_bits(&s>pb, 
523 
table_mb_non_intra[cbp + 64][1], 
524 
table_mb_non_intra[cbp + 64][0]); 
525  
526 
s>misc_bits += get_bits_diff(s); 
527  
528 
/* motion vector */

529 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
530 
msmpeg4_encode_motion(s, motion_x  pred_x, 
531 
motion_y  pred_y); 
532 
} 
533  
534 
s>mv_bits += get_bits_diff(s); 
535  
536 
for (i = 0; i < 6; i++) { 
537 
msmpeg4_encode_block(s, block[i], i); 
538 
} 
539 
s>p_tex_bits += get_bits_diff(s); 
540 
} else {

541 
/* compute cbp */

542 
cbp = 0;

543 
coded_cbp = 0;

544 
for (i = 0; i < 6; i++) { 
545 
int val, pred;

546 
val = (s>block_last_index[i] >= 1);

547 
cbp = val << (5  i);

548 
if (i < 4) { 
549 
/* predict value for close blocks only for luma */

550 
pred = coded_block_pred(s, i, &coded_block); 
551 
*coded_block = val; 
552 
val = val ^ pred; 
553 
} 
554 
coded_cbp = val << (5  i);

555 
} 
556 
#if 0

557 
if (coded_cbp)

558 
printf("cbp=%x %x\n", cbp, coded_cbp);

559 
#endif

560  
561 
if(s>msmpeg4_version<=2){ 
562 
if (s>pict_type == I_TYPE) {

563 
put_bits(&s>pb, 
564 
v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); 
565 
} else {

566 
if (s>use_skip_mb_code)

567 
put_bits(&s>pb, 1, 0); /* mb coded */ 
568 
put_bits(&s>pb, 
569 
v2_mb_type[(cbp&3) + 4][1], 
570 
v2_mb_type[(cbp&3) + 4][0]); 
571 
} 
572 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
573 
put_bits(&s>pb, 
574 
cbpy_tab[cbp>>2][1], 
575 
cbpy_tab[cbp>>2][0]); 
576 
}else{

577 
if (s>pict_type == I_TYPE) {

578 
put_bits(&s>pb, 
579 
ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); 
580 
} else {

581 
if (s>use_skip_mb_code)

582 
put_bits(&s>pb, 1, 0); /* mb coded */ 
583 
put_bits(&s>pb, 
584 
table_mb_non_intra[cbp][1],

585 
table_mb_non_intra[cbp][0]);

586 
} 
587 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
588 
if(s>inter_intra_pred){

589 
s>h263_aic_dir=0;

590 
put_bits(&s>pb, table_inter_intra[s>h263_aic_dir][1], table_inter_intra[s>h263_aic_dir][0]); 
591 
} 
592 
} 
593 
s>misc_bits += get_bits_diff(s); 
594  
595 
for (i = 0; i < 6; i++) { 
596 
msmpeg4_encode_block(s, block[i], i); 
597 
} 
598 
s>i_tex_bits += get_bits_diff(s); 
599 
s>i_count++; 
600 
} 
601 
} 
602  
603 
#endif //CONFIG_ENCODERS 
604  
605 
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
606 
int32_t **dc_val_ptr) 
607 
{ 
608 
int i;

609  
610 
if (n < 4) { 
611 
i= 0;

612 
} else {

613 
i= n3;

614 
} 
615  
616 
*dc_val_ptr= &s>last_dc[i]; 
617 
return s>last_dc[i];

618 
} 
619  
620 
static int get_dc(uint8_t *src, int stride, int scale) 
621 
{ 
622 
int y;

623 
int sum=0; 
624 
for(y=0; y<8; y++){ 
625 
int x;

626 
for(x=0; x<8; x++){ 
627 
sum+=src[x + y*stride]; 
628 
} 
629 
} 
630 
return FASTDIV((sum + (scale>>1)), scale); 
631 
} 
632  
633 
/* dir = 0: left, dir = 1: top prediction */

634 
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
635 
int16_t **dc_val_ptr, int *dir_ptr)

636 
{ 
637 
int a, b, c, wrap, pred, scale;

638 
int16_t *dc_val; 
639  
640 
/* find prediction */

641 
if (n < 4) { 
642 
scale = s>y_dc_scale; 
643 
} else {

644 
scale = s>c_dc_scale; 
645 
} 
646  
647 
wrap = s>block_wrap[n]; 
648 
dc_val= s>dc_val[0] + s>block_index[n];

649  
650 
/* B C

651 
* A X

652 
*/

653 
a = dc_val[  1];

654 
b = dc_val[  1  wrap];

655 
c = dc_val[  wrap]; 
656  
657 
if(s>first_slice_line && (n&2)==0 && s>msmpeg4_version<4){ 
658 
b=c=1024;

659 
} 
660  
661 
/* XXX: the following solution consumes divisions, but it does not

662 
necessitate to modify mpegvideo.c. The problem comes from the

663 
fact they decided to store the quantized DC (which would lead

664 
to problems if Q could vary !) */

665 
#if (defined(ARCH_X86)) && !defined PIC

666 
asm volatile( 
667 
"movl %3, %%eax \n\t"

668 
"shrl $1, %%eax \n\t"

669 
"addl %%eax, %2 \n\t"

670 
"addl %%eax, %1 \n\t"

671 
"addl %0, %%eax \n\t"

672 
"mull %4 \n\t"

673 
"movl %%edx, %0 \n\t"

674 
"movl %1, %%eax \n\t"

675 
"mull %4 \n\t"

676 
"movl %%edx, %1 \n\t"

677 
"movl %2, %%eax \n\t"

678 
"mull %4 \n\t"

679 
"movl %%edx, %2 \n\t"

680 
: "+b" (a), "+c" (b), "+D" (c) 
681 
: "g" (scale), "S" (ff_inverse[scale]) 
682 
: "%eax", "%edx" 
683 
); 
684 
#else

685 
/* #elif defined (ARCH_ALPHA) */

686 
/* Divisions are extremely costly on Alpha; optimize the most

687 
common case. But they are costly everywhere...

688 
*/

689 
if (scale == 8) { 
690 
a = (a + (8 >> 1)) / 8; 
691 
b = (b + (8 >> 1)) / 8; 
692 
c = (c + (8 >> 1)) / 8; 
693 
} else {

694 
a = FASTDIV((a + (scale >> 1)), scale);

695 
b = FASTDIV((b + (scale >> 1)), scale);

696 
c = FASTDIV((c + (scale >> 1)), scale);

697 
} 
698 
#endif

699 
/* XXX: WARNING: they did not choose the same test as MPEG4. This

700 
is very important ! */

701 
if(s>msmpeg4_version>3){ 
702 
if(s>inter_intra_pred){

703 
uint8_t *dest; 
704 
int wrap;

705  
706 
if(n==1){ 
707 
pred=a; 
708 
*dir_ptr = 0;

709 
}else if(n==2){ 
710 
pred=c; 
711 
*dir_ptr = 1;

712 
}else if(n==3){ 
713 
if (abs(a  b) < abs(b  c)) {

714 
pred = c; 
715 
*dir_ptr = 1;

716 
} else {

717 
pred = a; 
718 
*dir_ptr = 0;

719 
} 
720 
}else{

721 
if(n<4){ 
722 
wrap= s>linesize; 
723 
dest= s>current_picture.data[0] + (((n>>1) + 2*s>mb_y) * 8* wrap ) + ((n&1) + 2*s>mb_x) * 8; 
724 
}else{

725 
wrap= s>uvlinesize; 
726 
dest= s>current_picture.data[n3] + (s>mb_y * 8 * wrap) + s>mb_x * 8; 
727 
} 
728 
if(s>mb_x==0) a= (1024 + (scale>>1))/scale; 
729 
else a= get_dc(dest8, wrap, scale*8); 
730 
if(s>mb_y==0) c= (1024 + (scale>>1))/scale; 
731 
else c= get_dc(dest8*wrap, wrap, scale*8); 
732  
733 
if (s>h263_aic_dir==0) { 
734 
pred= a; 
735 
*dir_ptr = 0;

736 
}else if (s>h263_aic_dir==1) { 
737 
if(n==0){ 
738 
pred= c; 
739 
*dir_ptr = 1;

740 
}else{

741 
pred= a; 
742 
*dir_ptr = 0;

743 
} 
744 
}else if (s>h263_aic_dir==2) { 
745 
if(n==0){ 
746 
pred= a; 
747 
*dir_ptr = 0;

748 
}else{

749 
pred= c; 
750 
*dir_ptr = 1;

751 
} 
752 
} else {

753 
pred= c; 
754 
*dir_ptr = 1;

755 
} 
756 
} 
757 
}else{

758 
if (abs(a  b) < abs(b  c)) {

759 
pred = c; 
760 
*dir_ptr = 1;

761 
} else {

762 
pred = a; 
763 
*dir_ptr = 0;

764 
} 
765 
} 
766 
}else{

767 
if (abs(a  b) <= abs(b  c)) {

768 
pred = c; 
769 
*dir_ptr = 1;

770 
} else {

771 
pred = a; 
772 
*dir_ptr = 0;

773 
} 
774 
} 
775  
776 
/* update predictor */

777 
*dc_val_ptr = &dc_val[0];

778 
return pred;

779 
} 
780  
781 
#define DC_MAX 119 
782  
783 
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) 
784 
{ 
785 
int sign, code;

786 
int pred;

787  
788 
if(s>msmpeg4_version==1){ 
789 
int32_t *dc_val; 
790 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
791  
792 
/* update predictor */

793 
*dc_val= level; 
794 
}else{

795 
int16_t *dc_val; 
796 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
797  
798 
/* update predictor */

799 
if (n < 4) { 
800 
*dc_val = level * s>y_dc_scale; 
801 
} else {

802 
*dc_val = level * s>c_dc_scale; 
803 
} 
804 
} 
805  
806 
/* do the prediction */

807 
level = pred; 
808  
809 
if(s>msmpeg4_version<=2){ 
810 
if (n < 4) { 
811 
put_bits(&s>pb, 
812 
v2_dc_lum_table[level+256][1], 
813 
v2_dc_lum_table[level+256][0]); 
814 
}else{

815 
put_bits(&s>pb, 
816 
v2_dc_chroma_table[level+256][1], 
817 
v2_dc_chroma_table[level+256][0]); 
818 
} 
819 
}else{

820 
sign = 0;

821 
if (level < 0) { 
822 
level = level; 
823 
sign = 1;

824 
} 
825 
code = level; 
826 
if (code > DC_MAX)

827 
code = DC_MAX; 
828  
829 
if (s>dc_table_index == 0) { 
830 
if (n < 4) { 
831 
put_bits(&s>pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]); 
832 
} else {

833 
put_bits(&s>pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]); 
834 
} 
835 
} else {

836 
if (n < 4) { 
837 
put_bits(&s>pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]); 
838 
} else {

839 
put_bits(&s>pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]); 
840 
} 
841 
} 
842  
843 
if (code == DC_MAX)

844 
put_bits(&s>pb, 8, level);

845  
846 
if (level != 0) { 
847 
put_bits(&s>pb, 1, sign);

848 
} 
849 
} 
850 
} 
851  
852 
/* Encoding of a block. Very similar to MPEG4 except for a different

853 
escape coding (same as H263) and more vlc tables.

854 
*/

855 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
856 
{ 
857 
int level, run, last, i, j, last_index;

858 
int last_non_zero, sign, slevel;

859 
int code, run_diff, dc_pred_dir;

860 
const RLTable *rl;

861 
const uint8_t *scantable;

862  
863 
if (s>mb_intra) {

864 
msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);

865 
i = 1;

866 
if (n < 4) { 
867 
rl = &rl_table[s>rl_table_index]; 
868 
} else {

869 
rl = &rl_table[3 + s>rl_chroma_table_index];

870 
} 
871 
run_diff = 0;

872 
scantable= s>intra_scantable.permutated; 
873 
} else {

874 
i = 0;

875 
rl = &rl_table[3 + s>rl_table_index];

876 
if(s>msmpeg4_version<=2) 
877 
run_diff = 0;

878 
else

879 
run_diff = 1;

880 
scantable= s>inter_scantable.permutated; 
881 
} 
882  
883 
/* recalculate block_last_index for M$ wmv1 */

884 
if(s>msmpeg4_version>=4 && s>block_last_index[n]>0){ 
885 
for(last_index=63; last_index>=0; last_index){ 
886 
if(block[scantable[last_index]]) break; 
887 
} 
888 
s>block_last_index[n]= last_index; 
889 
}else

890 
last_index = s>block_last_index[n]; 
891 
/* AC coefs */

892 
last_non_zero = i  1;

893 
for (; i <= last_index; i++) {

894 
j = scantable[i]; 
895 
level = block[j]; 
896 
if (level) {

897 
run = i  last_non_zero  1;

898 
last = (i == last_index); 
899 
sign = 0;

900 
slevel = level; 
901 
if (level < 0) { 
902 
sign = 1;

903 
level = level; 
904 
} 
905  
906 
if(level<=MAX_LEVEL && run<=MAX_RUN){

907 
s>ac_stats[s>mb_intra][n>3][level][run][last]++;

908 
} 
909 
#if 0

910 
else

911 
s>ac_stats[s>mb_intra][n>3][40][63][0]++; //esc3 like

912 
#endif

913 
code = get_rl_index(rl, last, run, level); 
914 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
915 
if (code == rl>n) {

916 
int level1, run1;

917  
918 
level1 = level  rl>max_level[last][run]; 
919 
if (level1 < 1) 
920 
goto esc2;

921 
code = get_rl_index(rl, last, run, level1); 
922 
if (code == rl>n) {

923 
esc2:

924 
put_bits(&s>pb, 1, 0); 
925 
if (level > MAX_LEVEL)

926 
goto esc3;

927 
run1 = run  rl>max_run[last][level]  run_diff; 
928 
if (run1 < 0) 
929 
goto esc3;

930 
code = get_rl_index(rl, last, run1, level); 
931 
if (code == rl>n) {

932 
esc3:

933 
/* third escape */

934 
put_bits(&s>pb, 1, 0); 
935 
put_bits(&s>pb, 1, last);

936 
if(s>msmpeg4_version>=4){ 
937 
if(s>esc3_level_length==0){ 
938 
s>esc3_level_length=8;

939 
s>esc3_run_length= 6;

940 
if(s>qscale<8) 
941 
put_bits(&s>pb, 6, 3); 
942 
else

943 
put_bits(&s>pb, 8, 3); 
944 
} 
945 
put_bits(&s>pb, s>esc3_run_length, run); 
946 
put_bits(&s>pb, 1, sign);

947 
put_bits(&s>pb, s>esc3_level_length, level); 
948 
}else{

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

950 
put_bits(&s>pb, 8, slevel & 0xff); 
951 
} 
952 
} else {

953 
/* second escape */

954 
put_bits(&s>pb, 1, 1); 
955 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
956 
put_bits(&s>pb, 1, sign);

957 
} 
958 
} else {

959 
/* first escape */

960 
put_bits(&s>pb, 1, 1); 
961 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
962 
put_bits(&s>pb, 1, sign);

963 
} 
964 
} else {

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

966 
} 
967 
last_non_zero = i; 
968 
} 
969 
} 
970 
} 
971  
972 
/****************************************/

973 
/* decoding stuff */

974  
975 
static VLC mb_non_intra_vlc[4]; 
976 
static VLC v2_dc_lum_vlc;

977 
static VLC v2_dc_chroma_vlc;

978 
static VLC cbpy_vlc;

979 
static VLC v2_intra_cbpc_vlc;

980 
static VLC v2_mb_type_vlc;

981 
static VLC v2_mv_vlc;

982 
static VLC v1_intra_cbpc_vlc;

983 
static VLC v1_inter_cbpc_vlc;

984 
static VLC inter_intra_vlc;

985  
986 
/* this table is practically identical to the one from h263 except that its inverted */

987 
static void init_h263_dc_for_msmpeg4(void) 
988 
{ 
989 
int level, uni_code, uni_len;

990  
991 
for(level=256; level<256; level++){ 
992 
int size, v, l;

993 
/* find number of bits */

994 
size = 0;

995 
v = abs(level); 
996 
while (v) {

997 
v >>= 1;

998 
size++; 
999 
} 
1000  
1001 
if (level < 0) 
1002 
l= (level) ^ ((1 << size)  1); 
1003 
else

1004 
l= level; 
1005  
1006 
/* luminance h263 */

1007 
uni_code= DCtab_lum[size][0];

1008 
uni_len = DCtab_lum[size][1];

1009 
uni_code ^= (1<<uni_len)1; //M$ does not like compatibility 
1010  
1011 
if (size > 0) { 
1012 
uni_code<<=size; uni_code=l; 
1013 
uni_len+=size; 
1014 
if (size > 8){ 
1015 
uni_code<<=1; uni_code=1; 
1016 
uni_len++; 
1017 
} 
1018 
} 
1019 
v2_dc_lum_table[level+256][0]= uni_code; 
1020 
v2_dc_lum_table[level+256][1]= uni_len; 
1021  
1022 
/* chrominance h263 */

1023 
uni_code= DCtab_chrom[size][0];

1024 
uni_len = DCtab_chrom[size][1];

1025 
uni_code ^= (1<<uni_len)1; //M$ does not like compatibility 
1026  
1027 
if (size > 0) { 
1028 
uni_code<<=size; uni_code=l; 
1029 
uni_len+=size; 
1030 
if (size > 8){ 
1031 
uni_code<<=1; uni_code=1; 
1032 
uni_len++; 
1033 
} 
1034 
} 
1035 
v2_dc_chroma_table[level+256][0]= uni_code; 
1036 
v2_dc_chroma_table[level+256][1]= uni_len; 
1037  
1038 
} 
1039 
} 
1040  
1041 
/* init all vlc decoding tables */

1042 
int ff_msmpeg4_decode_init(MpegEncContext *s)

1043 
{ 
1044 
static int done = 0; 
1045 
int i;

1046 
MVTable *mv; 
1047  
1048 
common_init(s); 
1049  
1050 
if (!done) {

1051 
done = 1;

1052  
1053 
for(i=0;i<NB_RL_TABLES;i++) { 
1054 
init_rl(&rl_table[i], static_rl_table_store[i]); 
1055 
init_vlc_rl(&rl_table[i], 1);

1056 
} 
1057 
for(i=0;i<2;i++) { 
1058 
mv = &mv_tables[i]; 
1059 
init_vlc(&mv>vlc, MV_VLC_BITS, mv>n + 1,

1060 
mv>table_mv_bits, 1, 1, 
1061 
mv>table_mv_code, 2, 2, 1); 
1062 
} 
1063  
1064 
init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 
1065 
&ff_table0_dc_lum[0][1], 8, 4, 
1066 
&ff_table0_dc_lum[0][0], 8, 4, 1); 
1067 
init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1068 
&ff_table0_dc_chroma[0][1], 8, 4, 
1069 
&ff_table0_dc_chroma[0][0], 8, 4, 1); 
1070 
init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 
1071 
&ff_table1_dc_lum[0][1], 8, 4, 
1072 
&ff_table1_dc_lum[0][0], 8, 4, 1); 
1073 
init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1074 
&ff_table1_dc_chroma[0][1], 8, 4, 
1075 
&ff_table1_dc_chroma[0][0], 8, 4, 1); 
1076  
1077 
init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,

1078 
&v2_dc_lum_table[0][1], 8, 4, 
1079 
&v2_dc_lum_table[0][0], 8, 4, 1); 
1080 
init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,

1081 
&v2_dc_chroma_table[0][1], 8, 4, 
1082 
&v2_dc_chroma_table[0][0], 8, 4, 1); 
1083  
1084 
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,

1085 
&cbpy_tab[0][1], 2, 1, 
1086 
&cbpy_tab[0][0], 2, 1, 1); 
1087 
init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,

1088 
&v2_intra_cbpc[0][1], 2, 1, 
1089 
&v2_intra_cbpc[0][0], 2, 1, 1); 
1090 
init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,

1091 
&v2_mb_type[0][1], 2, 1, 
1092 
&v2_mb_type[0][0], 2, 1, 1); 
1093 
init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,

1094 
&mvtab[0][1], 2, 1, 
1095 
&mvtab[0][0], 2, 1, 1); 
1096  
1097 
for(i=0; i<4; i++){ 
1098 
init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,

1099 
&wmv2_inter_table[i][0][1], 8, 4, 
1100 
&wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name? 
1101 
} 
1102  
1103 
init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,

1104 
&ff_msmp4_mb_i_table[0][1], 4, 2, 
1105 
&ff_msmp4_mb_i_table[0][0], 4, 2, 1); 
1106  
1107 
init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,

1108 
intra_MCBPC_bits, 1, 1, 
1109 
intra_MCBPC_code, 1, 1, 1); 
1110 
init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,

1111 
inter_MCBPC_bits, 1, 1, 
1112 
inter_MCBPC_code, 1, 1, 1); 
1113  
1114 
init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,

1115 
&table_inter_intra[0][1], 2, 1, 
1116 
&table_inter_intra[0][0], 2, 1, 1); 
1117 
} 
1118  
1119 
switch(s>msmpeg4_version){

1120 
case 1: 
1121 
case 2: 
1122 
s>decode_mb= msmpeg4v12_decode_mb; 
1123 
break;

1124 
case 3: 
1125 
case 4: 
1126 
s>decode_mb= msmpeg4v34_decode_mb; 
1127 
break;

1128 
case 5: 
1129 
s>decode_mb= wmv2_decode_mb; 
1130 
case 6: 
1131 
//FIXME + TODO VC1 decode mb

1132 
break;

1133 
} 
1134  
1135 
s>slice_height= s>mb_height; //to avoid 1/0 if the first frame is not a keyframe

1136  
1137 
return 0; 
1138 
} 
1139  
1140 
int msmpeg4_decode_picture_header(MpegEncContext * s)

1141 
{ 
1142 
int code;

1143  
1144 
#if 0

1145 
{

1146 
int i;

1147 
for(i=0; i<s>gb.size_in_bits; i++)

1148 
av_log(s>avctx, AV_LOG_DEBUG, "%d", get_bits1(&s>gb));

1149 
// get_bits1(&s>gb);

1150 
av_log(s>avctx, AV_LOG_DEBUG, "END\n");

1151 
return 1;

1152 
}

1153 
#endif

1154  
1155 
if(s>msmpeg4_version==1){ 
1156 
int start_code, num;

1157 
start_code = (get_bits(&s>gb, 16)<<16)  get_bits(&s>gb, 16); 
1158 
if(start_code!=0x00000100){ 
1159 
av_log(s>avctx, AV_LOG_ERROR, "invalid startcode\n");

1160 
return 1; 
1161 
} 
1162  
1163 
num= get_bits(&s>gb, 5); // frame number */ 
1164 
} 
1165  
1166 
s>pict_type = get_bits(&s>gb, 2) + 1; 
1167 
if (s>pict_type != I_TYPE &&

1168 
s>pict_type != P_TYPE){ 
1169 
av_log(s>avctx, AV_LOG_ERROR, "invalid picture type\n");

1170 
return 1; 
1171 
} 
1172 
#if 0

1173 
{

1174 
static int had_i=0;

1175 
if(s>pict_type == I_TYPE) had_i=1;

1176 
if(!had_i) return 1;

1177 
}

1178 
#endif

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

1180 
if(s>qscale==0){ 
1181 
av_log(s>avctx, AV_LOG_ERROR, "invalid qscale\n");

1182 
return 1; 
1183 
} 
1184  
1185 
if (s>pict_type == I_TYPE) {

1186 
code = get_bits(&s>gb, 5);

1187 
if(s>msmpeg4_version==1){ 
1188 
if(code==0  code>s>mb_height){ 
1189 
av_log(s>avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);

1190 
return 1; 
1191 
} 
1192  
1193 
s>slice_height = code; 
1194 
}else{

1195 
/* 0x17: one slice, 0x18: two slices, ... */

1196 
if (code < 0x17){ 
1197 
av_log(s>avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);

1198 
return 1; 
1199 
} 
1200  
1201 
s>slice_height = s>mb_height / (code  0x16);

1202 
} 
1203  
1204 
switch(s>msmpeg4_version){

1205 
case 1: 
1206 
case 2: 
1207 
s>rl_chroma_table_index = 2;

1208 
s>rl_table_index = 2;

1209  
1210 
s>dc_table_index = 0; //not used 
1211 
break;

1212 
case 3: 
1213 
s>rl_chroma_table_index = decode012(&s>gb); 
1214 
s>rl_table_index = decode012(&s>gb); 
1215  
1216 
s>dc_table_index = get_bits1(&s>gb); 
1217 
break;

1218 
case 4: 
1219 
msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 
1220  
1221 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1222 
else s>per_mb_rl_table= 0; 
1223  
1224 
if(!s>per_mb_rl_table){

1225 
s>rl_chroma_table_index = decode012(&s>gb); 
1226 
s>rl_table_index = decode012(&s>gb); 
1227 
} 
1228  
1229 
s>dc_table_index = get_bits1(&s>gb); 
1230 
s>inter_intra_pred= 0;

1231 
break;

1232 
} 
1233 
s>no_rounding = 1;

1234 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

1235 
av_log(s>avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n",

1236 
s>qscale, 
1237 
s>rl_chroma_table_index, 
1238 
s>rl_table_index, 
1239 
s>dc_table_index, 
1240 
s>per_mb_rl_table, 
1241 
s>slice_height); 
1242 
} else {

1243 
switch(s>msmpeg4_version){

1244 
case 1: 
1245 
case 2: 
1246 
if(s>msmpeg4_version==1) 
1247 
s>use_skip_mb_code = 1;

1248 
else

1249 
s>use_skip_mb_code = get_bits1(&s>gb); 
1250 
s>rl_table_index = 2;

1251 
s>rl_chroma_table_index = s>rl_table_index; 
1252 
s>dc_table_index = 0; //not used 
1253 
s>mv_table_index = 0;

1254 
break;

1255 
case 3: 
1256 
s>use_skip_mb_code = get_bits1(&s>gb); 
1257 
s>rl_table_index = decode012(&s>gb); 
1258 
s>rl_chroma_table_index = s>rl_table_index; 
1259  
1260 
s>dc_table_index = get_bits1(&s>gb); 
1261  
1262 
s>mv_table_index = get_bits1(&s>gb); 
1263 
break;

1264 
case 4: 
1265 
s>use_skip_mb_code = get_bits1(&s>gb); 
1266  
1267 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1268 
else s>per_mb_rl_table= 0; 
1269  
1270 
if(!s>per_mb_rl_table){

1271 
s>rl_table_index = decode012(&s>gb); 
1272 
s>rl_chroma_table_index = s>rl_table_index; 
1273 
} 
1274  
1275 
s>dc_table_index = get_bits1(&s>gb); 
1276  
1277 
s>mv_table_index = get_bits1(&s>gb); 
1278 
s>inter_intra_pred= (s>width*s>height < 320*240 && s>bit_rate<=II_BITRATE); 
1279 
break;

1280 
} 
1281  
1282 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

1283 
av_log(s>avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n",

1284 
s>use_skip_mb_code, 
1285 
s>rl_table_index, 
1286 
s>rl_chroma_table_index, 
1287 
s>dc_table_index, 
1288 
s>mv_table_index, 
1289 
s>per_mb_rl_table, 
1290 
s>qscale); 
1291  
1292 
if(s>flipflop_rounding){

1293 
s>no_rounding ^= 1;

1294 
}else{

1295 
s>no_rounding = 0;

1296 
} 
1297 
} 
1298 
//printf("%d %d %d %d %d\n", s>pict_type, s>bit_rate, s>inter_intra_pred, s>width, s>height);

1299  
1300 
s>esc3_level_length= 0;

1301 
s>esc3_run_length= 0;

1302  
1303 
#ifdef DEBUG

1304 
av_log(s>avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);

1305 
#endif

1306 
return 0; 
1307 
} 
1308  
1309 
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) 
1310 
{ 
1311 
int left= buf_size*8  get_bits_count(&s>gb); 
1312 
int length= s>msmpeg4_version>=3 ? 17 : 16; 
1313 
/* the alt_bitstream reader could read over the end so we need to check it */

1314 
if(left>=length && left<length+8) 
1315 
{ 
1316 
int fps;

1317  
1318 
fps= get_bits(&s>gb, 5);

1319 
s>bit_rate= get_bits(&s>gb, 11)*1024; 
1320 
if(s>msmpeg4_version>=3) 
1321 
s>flipflop_rounding= get_bits1(&s>gb); 
1322 
else

1323 
s>flipflop_rounding= 0;

1324  
1325 
// printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s>bit_rate/1024, s>flipflop_rounding);

1326 
} 
1327 
else if(left<length+8) 
1328 
{ 
1329 
s>flipflop_rounding= 0;

1330 
if(s>msmpeg4_version != 2) 
1331 
av_log(s>avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);

1332 
} 
1333 
else

1334 
{ 
1335 
av_log(s>avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");

1336 
} 
1337  
1338 
return 0; 
1339 
} 
1340  
1341 
static inline void msmpeg4_memsetw(short *tab, int val, int n) 
1342 
{ 
1343 
int i;

1344 
for(i=0;i<n;i++) 
1345 
tab[i] = val; 
1346 
} 
1347  
1348 
#ifdef CONFIG_ENCODERS

1349 
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) 
1350 
{ 
1351 
int range, bit_size, sign, code, bits;

1352  
1353 
if (val == 0) { 
1354 
/* zero vector */

1355 
code = 0;

1356 
put_bits(&s>pb, mvtab[code][1], mvtab[code][0]); 
1357 
} else {

1358 
bit_size = s>f_code  1;

1359 
range = 1 << bit_size;

1360 
if (val <= 64) 
1361 
val += 64;

1362 
else if (val >= 64) 
1363 
val = 64;

1364  
1365 
if (val >= 0) { 
1366 
sign = 0;

1367 
} else {

1368 
val = val; 
1369 
sign = 1;

1370 
} 
1371 
val; 
1372 
code = (val >> bit_size) + 1;

1373 
bits = val & (range  1);

1374  
1375 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
1376 
if (bit_size > 0) { 
1377 
put_bits(&s>pb, bit_size, bits); 
1378 
} 
1379 
} 
1380 
} 
1381 
#endif

1382  
1383 
/* this is identical to h263 except that its range is multiplied by 2 */

1384 
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 
1385 
{ 
1386 
int code, val, sign, shift;

1387  
1388 
code = get_vlc2(&s>gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);

1389 
// printf("MV code %d at %d %d pred: %d\n", code, s>mb_x,s>mb_y, pred);

1390 
if (code < 0) 
1391 
return 0xffff; 
1392  
1393 
if (code == 0) 
1394 
return pred;

1395 
sign = get_bits1(&s>gb); 
1396 
shift = f_code  1;

1397 
val = code; 
1398 
if (shift) {

1399 
val = (val  1) << shift;

1400 
val = get_bits(&s>gb, shift); 
1401 
val++; 
1402 
} 
1403 
if (sign)

1404 
val = val; 
1405  
1406 
val += pred; 
1407 
if (val <= 64) 
1408 
val += 64;

1409 
else if (val >= 64) 
1410 
val = 64;

1411  
1412 
return val;

1413 
} 
1414  
1415 
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1416 
{ 
1417 
int cbp, code, i;

1418  
1419 
if (s>pict_type == P_TYPE) {

1420 
if (s>use_skip_mb_code) {

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

1422 
/* skip mb */

1423 
s>mb_intra = 0;

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

1426 
s>mv_dir = MV_DIR_FORWARD; 
1427 
s>mv_type = MV_TYPE_16X16; 
1428 
s>mv[0][0][0] = 0; 
1429 
s>mv[0][0][1] = 0; 
1430 
s>mb_skipped = 1;

1431 
return 0; 
1432 
} 
1433 
} 
1434  
1435 
if(s>msmpeg4_version==2) 
1436 
code = get_vlc2(&s>gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);

1437 
else

1438 
code = get_vlc2(&s>gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);

1439 
if(code<0  code>7){ 
1440 
av_log(s>avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s>mb_x, s>mb_y);

1441 
return 1; 
1442 
} 
1443  
1444 
s>mb_intra = code >>2;

1445  
1446 
cbp = code & 0x3;

1447 
} else {

1448 
s>mb_intra = 1;

1449 
if(s>msmpeg4_version==2) 
1450 
cbp= get_vlc2(&s>gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);

1451 
else

1452 
cbp= get_vlc2(&s>gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);

1453 
if(cbp<0  cbp>3){ 
1454 
av_log(s>avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s>mb_x, s>mb_y);

1455 
return 1; 
1456 
} 
1457 
} 
1458  
1459 
if (!s>mb_intra) {

1460 
int mx, my, cbpy;

1461  
1462 
cbpy= get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);

1463 
if(cbpy<0){ 
1464 
av_log(s>avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s>mb_x, s>mb_y);

1465 
return 1; 
1466 
} 
1467  
1468 
cbp= cbpy<<2;

1469 
if(s>msmpeg4_version==1  (cbp&3) != 3) cbp^= 0x3C; 
1470  
1471 
h263_pred_motion(s, 0, 0, &mx, &my); 
1472 
mx= msmpeg4v2_decode_motion(s, mx, 1);

1473 
my= msmpeg4v2_decode_motion(s, my, 1);

1474  
1475 
s>mv_dir = MV_DIR_FORWARD; 
1476 
s>mv_type = MV_TYPE_16X16; 
1477 
s>mv[0][0][0] = mx; 
1478 
s>mv[0][0][1] = my; 
1479 
} else {

1480 
if(s>msmpeg4_version==2){ 
1481 
s>ac_pred = get_bits1(&s>gb); 
1482 
cbp= get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1483 
} else{

1484 
s>ac_pred = 0;

1485 
cbp= get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1486 
if(s>pict_type==P_TYPE) cbp^=0x3C; 
1487 
} 
1488 
} 
1489  
1490 
s>dsp.clear_blocks(s>block[0]);

1491 
for (i = 0; i < 6; i++) { 
1492 
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1493 
{ 
1494 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1495 
return 1; 
1496 
} 
1497 
} 
1498 
return 0; 
1499 
} 
1500  
1501 
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1502 
{ 
1503 
int cbp, code, i;

1504 
uint8_t *coded_val; 
1505 
uint32_t * const mb_type_ptr= &s>current_picture.mb_type[ s>mb_x + s>mb_y*s>mb_stride ];

1506  
1507 
if (s>pict_type == P_TYPE) {

1508 
if (s>use_skip_mb_code) {

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

1510 
/* skip mb */

1511 
s>mb_intra = 0;

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

1514 
s>mv_dir = MV_DIR_FORWARD; 
1515 
s>mv_type = MV_TYPE_16X16; 
1516 
s>mv[0][0][0] = 0; 
1517 
s>mv[0][0][1] = 0; 
1518 
s>mb_skipped = 1;

1519 
*mb_type_ptr = MB_TYPE_SKIP  MB_TYPE_L0  MB_TYPE_16x16; 
1520  
1521 
return 0; 
1522 
} 
1523 
} 
1524  
1525 
code = get_vlc2(&s>gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);

1526 
if (code < 0) 
1527 
return 1; 
1528 
//s>mb_intra = (code & 0x40) ? 0 : 1;

1529 
s>mb_intra = (~code & 0x40) >> 6; 
1530  
1531 
cbp = code & 0x3f;

1532 
} else {

1533 
s>mb_intra = 1;

1534 
code = get_vlc2(&s>gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);

1535 
if (code < 0) 
1536 
return 1; 
1537 
/* predict coded block pattern */

1538 
cbp = 0;

1539 
for(i=0;i<6;i++) { 
1540 
int val = ((code >> (5  i)) & 1); 
1541 
if (i < 4) { 
1542 
int pred = coded_block_pred(s, i, &coded_val);

1543 
val = val ^ pred; 
1544 
*coded_val = val; 
1545 
} 
1546 
cbp = val << (5  i);

1547 
} 
1548 
} 
1549  
1550 
if (!s>mb_intra) {

1551 
int mx, my;

1552 
//printf("P at %d %d\n", s>mb_x, s>mb_y);

1553 
if(s>per_mb_rl_table && cbp){

1554 
s>rl_table_index = decode012(&s>gb); 
1555 
s>rl_chroma_table_index = s>rl_table_index; 
1556 
} 
1557 
h263_pred_motion(s, 0, 0, &mx, &my); 
1558 
if (msmpeg4_decode_motion(s, &mx, &my) < 0) 
1559 
return 1; 
1560 
s>mv_dir = MV_DIR_FORWARD; 
1561 
s>mv_type = MV_TYPE_16X16; 
1562 
s>mv[0][0][0] = mx; 
1563 
s>mv[0][0][1] = my; 
1564 
*mb_type_ptr = MB_TYPE_L0  MB_TYPE_16x16; 
1565 
} else {

1566 
//printf("I at %d %d %d %06X\n", s>mb_x, s>mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s>gb, 24));

1567 
s>ac_pred = get_bits1(&s>gb); 
1568 
*mb_type_ptr = MB_TYPE_INTRA; 
1569 
if(s>inter_intra_pred){

1570 
s>h263_aic_dir= get_vlc2(&s>gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);

1571 
// printf("%d%d %d %d/", s>ac_pred, s>h263_aic_dir, s>mb_x, s>mb_y);

1572 
} 
1573 
if(s>per_mb_rl_table && cbp){

1574 
s>rl_table_index = decode012(&s>gb); 
1575 
s>rl_chroma_table_index = s>rl_table_index; 
1576 
} 
1577 
} 
1578  
1579 
s>dsp.clear_blocks(s>block[0]);

1580 
for (i = 0; i < 6; i++) { 
1581 
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1582 
{ 
1583 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1584 
return 1; 
1585 
} 
1586 
} 
1587  
1588 
return 0; 
1589 
} 
1590 
//#define ERROR_DETAILS

1591 
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
1592 
int n, int coded, const uint8_t *scan_table) 
1593 
{ 
1594 
int level, i, last, run, run_diff;

1595 
int dc_pred_dir;

1596 
RLTable *rl; 
1597 
RL_VLC_ELEM *rl_vlc; 
1598 
int qmul, qadd;

1599  
1600 
if (s>mb_intra) {

1601 
qmul=1;

1602 
qadd=0;

1603  
1604 
/* DC coef */

1605 
level = msmpeg4_decode_dc(s, n, &dc_pred_dir); 
1606  
1607 
if (level < 0){ 
1608 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow block: %d qscale: %d//\n", n, s>qscale);

1609 
if(s>inter_intra_pred) level=0; 
1610 
else return 1; 
1611 
} 
1612 
if (n < 4) { 
1613 
rl = &rl_table[s>rl_table_index]; 
1614 
if(level > 256*s>y_dc_scale){ 
1615 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s>qscale);

1616 
if(!s>inter_intra_pred) return 1; 
1617 
} 
1618 
} else {

1619 
rl = &rl_table[3 + s>rl_chroma_table_index];

1620 
if(level > 256*s>c_dc_scale){ 
1621 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s>qscale);

1622 
if(!s>inter_intra_pred) return 1; 
1623 
} 
1624 
} 
1625 
block[0] = level;

1626  
1627 
run_diff = 0;

1628 
i = 0;

1629 
if (!coded) {

1630 
goto not_coded;

1631 
} 
1632 
if (s>ac_pred) {

1633 
if (dc_pred_dir == 0) 
1634 
scan_table = s>intra_v_scantable.permutated; /* left */

1635 
else

1636 
scan_table = s>intra_h_scantable.permutated; /* top */

1637 
} else {

1638 
scan_table = s>intra_scantable.permutated; 
1639 
} 
1640 
rl_vlc= rl>rl_vlc[0];

1641 
} else {

1642 
qmul = s>qscale << 1;

1643 
qadd = (s>qscale  1)  1; 
1644 
i = 1;

1645 
rl = &rl_table[3 + s>rl_table_index];

1646  
1647 
if(s>msmpeg4_version==2) 
1648 
run_diff = 0;

1649 
else

1650 
run_diff = 1;

1651  
1652 
if (!coded) {

1653 
s>block_last_index[n] = i; 
1654 
return 0; 
1655 
} 
1656 
if(!scan_table)

1657 
scan_table = s>inter_scantable.permutated; 
1658 
rl_vlc= rl>rl_vlc[s>qscale]; 
1659 
} 
1660 
{ 
1661 
OPEN_READER(re, &s>gb); 
1662 
for(;;) {

1663 
UPDATE_CACHE(re, &s>gb); 
1664 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2, 0); 
1665 
if (level==0) { 
1666 
int cache;

1667 
cache= GET_CACHE(re, &s>gb); 
1668 
/* escape */

1669 
if (s>msmpeg4_version==1  (cache&0x80000000)==0) { 
1670 
if (s>msmpeg4_version==1  (cache&0x40000000)==0) { 
1671 
/* third escape */

1672 
if(s>msmpeg4_version!=1) LAST_SKIP_BITS(re, &s>gb, 2); 
1673 
UPDATE_CACHE(re, &s>gb); 
1674 
if(s>msmpeg4_version<=3){ 
1675 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
1676 
run= SHOW_UBITS(re, &s>gb, 6); SKIP_CACHE(re, &s>gb, 6); 
1677 
level= SHOW_SBITS(re, &s>gb, 8); LAST_SKIP_CACHE(re, &s>gb, 8); 
1678 
SKIP_COUNTER(re, &s>gb, 1+6+8); 
1679 
}else{

1680 
int sign;

1681 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_BITS(re, &s>gb, 1); 
1682 
if(!s>esc3_level_length){

1683 
int ll;

1684 
//printf("ESC3 %X at %d %d\n", show_bits(&s>gb, 24), s>mb_x, s>mb_y);

1685 
if(s>qscale<8){ 
1686 
ll= SHOW_UBITS(re, &s>gb, 3); SKIP_BITS(re, &s>gb, 3); 
1687 
if(ll==0){ 
1688 
if(SHOW_UBITS(re, &s>gb, 1)) av_log(s>avctx, AV_LOG_ERROR, "cool a new vlc code ,contact the ffmpeg developers and upload the file\n"); 
1689 
SKIP_BITS(re, &s>gb, 1);

1690 
ll=8;

1691 
} 
1692 
}else{

1693 
ll=2;

1694 
while(ll<8 && SHOW_UBITS(re, &s>gb, 1)==0){ 
1695 
ll++; 
1696 
SKIP_BITS(re, &s>gb, 1);

1697 
} 
1698 
if(ll<8) SKIP_BITS(re, &s>gb, 1); 
1699 
} 
1700  
1701 
s>esc3_level_length= ll; 
1702 
s>esc3_run_length= SHOW_UBITS(re, &s>gb, 2) + 3; SKIP_BITS(re, &s>gb, 2); 
1703 
//printf("level length:%d, run length: %d\n", ll, s>esc3_run_length);

1704 
UPDATE_CACHE(re, &s>gb); 
1705 
} 
1706 
run= SHOW_UBITS(re, &s>gb, s>esc3_run_length); 
1707 
SKIP_BITS(re, &s>gb, s>esc3_run_length); 
1708  
1709 
sign= SHOW_UBITS(re, &s>gb, 1);

1710 
SKIP_BITS(re, &s>gb, 1);

1711  
1712 
level= SHOW_UBITS(re, &s>gb, s>esc3_level_length); 
1713 
SKIP_BITS(re, &s>gb, s>esc3_level_length); 
1714 
if(sign) level= level;

1715 
} 
1716 
//printf("level: %d, run: %d at %d %d\n", level, run, s>mb_x, s>mb_y);

1717 
#if 0 // waste of time / this will detect very few errors

1718 
{

1719 
const int abs_level= FFABS(level);

1720 
const int run1= run  rl>max_run[last][abs_level]  run_diff;

1721 
if(abs_level<=MAX_LEVEL && run<=MAX_RUN){

1722 
if(abs_level <= rl>max_level[last][run]){

1723 
av_log(s>avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");

1724 
return DECODING_AC_LOST;

1725 
}

1726 
if(abs_level <= rl>max_level[last][run]*2){

1727 
av_log(s>avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");

1728 
return DECODING_AC_LOST;

1729 
}

1730 
if(run1>=0 && abs_level <= rl>max_level[last][run1]){

1731 
av_log(s>avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");

1732 
return DECODING_AC_LOST;

1733 
}

1734 
}

1735 
}

1736 
#endif

1737 
//level = level * qmul + (level>0) * qadd  (level<=0) * qadd ;

1738 
if (level>0) level= level * qmul + qadd; 
1739 
else level= level * qmul  qadd;

1740 
#if 0 // waste of time too :(

1741 
if(level>2048  level<2048){

1742 
av_log(s>avctx, AV_LOG_ERROR, "level overflow in 3. esc\n");

1743 
return DECODING_AC_LOST;

1744 
}

1745 
#endif

1746 
i+= run + 1;

1747 
if(last) i+=192; 
1748 
#ifdef ERROR_DETAILS

1749 
if(run==66) 
1750 
av_log(s>avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);

1751 
else if((i>62 && i<192)  i>192+63) 
1752 
av_log(s>avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);

1753 
#endif

1754 
} else {

1755 
/* second escape */

1756 
#if MIN_CACHE_BITS < 23 
1757 
LAST_SKIP_BITS(re, &s>gb, 2);

1758 
UPDATE_CACHE(re, &s>gb); 
1759 
#else

1760 
SKIP_BITS(re, &s>gb, 2);

1761 
#endif

1762 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2, 1); 
1763 
i+= run + rl>max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing 
1764 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1765 
LAST_SKIP_BITS(re, &s>gb, 1);

1766 
#ifdef ERROR_DETAILS

1767 
if(run==66) 
1768 
av_log(s>avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);

1769 
else if((i>62 && i<192)  i>192+63) 
1770 
av_log(s>avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);

1771 
#endif

1772 
} 
1773 
} else {

1774 
/* first escape */

1775 
#if MIN_CACHE_BITS < 22 
1776 
LAST_SKIP_BITS(re, &s>gb, 1);

1777 
UPDATE_CACHE(re, &s>gb); 
1778 
#else

1779 
SKIP_BITS(re, &s>gb, 1);

1780 
#endif

1781 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2, 1); 
1782 
i+= run; 
1783 
level = level + rl>max_level[run>>7][(run1)&63] * qmul;//FIXME opt indexing 
1784 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1785 
LAST_SKIP_BITS(re, &s>gb, 1);

1786 
#ifdef ERROR_DETAILS

1787 
if(run==66) 
1788 
av_log(s>avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);

1789 
else if((i>62 && i<192)  i>192+63) 
1790 
av_log(s>avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);

1791 
#endif

1792 
} 
1793 
} else {

1794 
i+= run; 
1795 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1796 
LAST_SKIP_BITS(re, &s>gb, 1);

1797 
#ifdef ERROR_DETAILS

1798 
if(run==66) 
1799 
av_log(s>avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);

1800 
else if((i>62 && i<192)  i>192+63) 
1801 
av_log(s>avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);

1802 
#endif

1803 
} 
1804 
if (i > 62){ 
1805 
i= 192;

1806 
if(i&(~63)){ 
1807 
const int left= s>gb.size_in_bits  get_bits_count(&s>gb); 
1808 
if(((i+192 == 64 && level/qmul==1)  s>error_resilience<=1) && left>=0){ 
1809 
av_log(s>avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s>mb_x, s>mb_y);

1810 
break;

1811 
}else{

1812 
av_log(s>avctx, AV_LOG_ERROR, "actex damaged at %d %d\n", s>mb_x, s>mb_y);

1813 
return 1; 
1814 
} 
1815 
} 
1816  
1817 
block[scan_table[i]] = level; 
1818 
break;

1819 
} 
1820  
1821 
block[scan_table[i]] = level; 
1822 
} 
1823 
CLOSE_READER(re, &s>gb); 
1824 
} 
1825 
not_coded:

1826 
if (s>mb_intra) {

1827 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
1828 
if (s>ac_pred) {

1829 
i = 63; /* XXX: not optimal */ 
1830 
} 
1831 
} 
1832 
if(s>msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize 
1833 
s>block_last_index[n] = i; 
1834  
1835 
return 0; 
1836 
} 
1837  
1838 
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
1839 
{ 
1840 
int level, pred;

1841  
1842 
if(s>msmpeg4_version<=2){ 
1843 
if (n < 4) { 
1844 
level = get_vlc2(&s>gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);

1845 
} else {

1846 
level = get_vlc2(&s>gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);

1847 
} 
1848 
if (level < 0) 
1849 
return 1; 
1850 
level=256;

1851 
}else{ //FIXME optimize use unified tables & index 
1852 
if (n < 4) { 
1853 
level = get_vlc2(&s>gb, ff_msmp4_dc_luma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1854 
} else {

1855 
level = get_vlc2(&s>gb, ff_msmp4_dc_chroma_vlc[s>dc_table_index].table, DC_VLC_BITS, 3);

1856 
} 
1857 
if (level < 0){ 
1858 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc vlc\n");

1859 
return 1; 
1860 
} 
1861  
1862 
if (level == DC_MAX) {

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

1864 
if (get_bits1(&s>gb))

1865 
level = level; 
1866 
} else if (level != 0) { 
1867 
if (get_bits1(&s>gb))

1868 
level = level; 
1869 
} 
1870 
} 
1871  
1872 
if(s>msmpeg4_version==1){ 
1873 
int32_t *dc_val; 
1874 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
1875 
level += pred; 
1876  
1877 
/* update predictor */

1878 
*dc_val= level; 
1879 
}else{

1880 
int16_t *dc_val; 
1881 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
1882 
level += pred; 
1883  
1884 
/* update predictor */

1885 
if (n < 4) { 
1886 
*dc_val = level * s>y_dc_scale; 
1887 
} else {

1888 
*dc_val = level * s>c_dc_scale; 
1889 
} 
1890 
} 
1891  
1892 
return level;

1893 
} 
1894  
1895 
static int msmpeg4_decode_motion(MpegEncContext * s, 
1896 
int *mx_ptr, int *my_ptr) 
1897 
{ 
1898 
MVTable *mv; 
1899 
int code, mx, my;

1900  
1901 
mv = &mv_tables[s>mv_table_index]; 
1902  
1903 
code = get_vlc2(&s>gb, mv>vlc.table, MV_VLC_BITS, 2);

1904 
if (code < 0){ 
1905 
av_log(s>avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s>mb_x, s>mb_y);

1906 
return 1; 
1907 
} 
1908 
if (code == mv>n) {

1909 
//printf("MV ESC %X at %d %d\n", show_bits(&s>gb, 24), s>mb_x, s>mb_y);

1910 
mx = get_bits(&s>gb, 6);

1911 
my = get_bits(&s>gb, 6);

1912 
} else {

1913 
mx = mv>table_mvx[code]; 
1914 
my = mv>table_mvy[code]; 
1915 
} 
1916  
1917 
mx += *mx_ptr  32;

1918 
my += *my_ptr  32;

1919 
/* WARNING : they do not do exactly modulo encoding */

1920 
if (mx <= 64) 
1921 
mx += 64;

1922 
else if (mx >= 64) 
1923 
mx = 64;

1924  
1925 
if (my <= 64) 
1926 
my += 64;

1927 
else if (my >= 64) 
1928 
my = 64;

1929 
*mx_ptr = mx; 
1930 
*my_ptr = my; 
1931 
return 0; 
1932 
} 
1933  
1934 
/* cleanest way to support it

1935 
* there is too much shared between versions so that we cant have 1 file per version & 1 common

1936 
* as allmost everything would be in the common file

1937 
*/

1938 
#include "wmv2.c" 