ffmpeg / libavcodec / msmpeg4.c @ 650cec0c
History  View  Annotate  Download (60.6 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 library is free software; you can redistribute it and/or

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

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

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

10 
*

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

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

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

14 
* Lesser General Public License for more details.

15 
*

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

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

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

19 
*

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

21 
*/

22  
23 
/**

24 
* @file msmpeg4.c

25 
* MSMPEG4 backend for ffmpeg encoder and decoder.

26 
*/

27  
28 
#include "avcodec.h" 
29 
#include "dsputil.h" 
30 
#include "mpegvideo.h" 
31  
32 
/*

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

34 
*

35 
* TODO:

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

37 
*  (encoding) select best vlc/dc table

38 
*/

39 
//#define DEBUG

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

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

80 
int intra_count = 0; 
81 
int frame_count = 0; 
82 
#endif

83  
84 
#include "msmpeg4data.h" 
85  
86 
#ifdef CONFIG_ENCODERS //strangely gcc includes this even if its not references 
87 
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; 
88 
#endif //CONFIG_ENCODERS 
89  
90 
#ifdef STATS

91  
92 
const char *st_names[ST_NB] = { 
93 
"unknown",

94 
"dc",

95 
"intra_ac",

96 
"inter_ac",

97 
"intra_mb",

98 
"inter_mb",

99 
"mv",

100 
}; 
101  
102 
int st_current_index = 0; 
103 
unsigned int st_bit_counts[ST_NB]; 
104 
unsigned int st_out_bit_counts[ST_NB]; 
105  
106 
#define set_stat(var) st_current_index = var;

107  
108 
void print_stats(void) 
109 
{ 
110 
unsigned int total; 
111 
int i;

112  
113 
printf("Input:\n");

114 
total = 0;

115 
for(i=0;i<ST_NB;i++) 
116 
total += st_bit_counts[i]; 
117 
if (total == 0) 
118 
total = 1;

119 
for(i=0;i<ST_NB;i++) { 
120 
printf("%10s : %10.1f %5.1f%%\n",

121 
st_names[i], 
122 
(double)st_bit_counts[i] / 8.0, 
123 
(double)st_bit_counts[i] * 100.0 / total); 
124 
} 
125 
printf("%10s : %10.1f %5.1f%%\n",

126 
"total",

127 
(double)total / 8.0, 
128 
100.0); 
129  
130 
printf("Output:\n");

131 
total = 0;

132 
for(i=0;i<ST_NB;i++) 
133 
total += st_out_bit_counts[i]; 
134 
if (total == 0) 
135 
total = 1;

136 
for(i=0;i<ST_NB;i++) { 
137 
printf("%10s : %10.1f %5.1f%%\n",

138 
st_names[i], 
139 
(double)st_out_bit_counts[i] / 8.0, 
140 
(double)st_out_bit_counts[i] * 100.0 / total); 
141 
} 
142 
printf("%10s : %10.1f %5.1f%%\n",

143 
"total",

144 
(double)total / 8.0, 
145 
100.0); 
146 
} 
147  
148 
#else

149  
150 
#define set_stat(var)

151  
152 
#endif

153  
154 
static void common_init(MpegEncContext * s) 
155 
{ 
156 
static int inited=0; 
157 

158 
switch(s>msmpeg4_version){

159 
case 1: 
160 
case 2: 
161 
s>y_dc_scale_table= 
162 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
163 
break;

164 
case 3: 
165 
if(s>workaround_bugs){

166 
s>y_dc_scale_table= old_ff_y_dc_scale_table; 
167 
s>c_dc_scale_table= old_ff_c_dc_scale_table; 
168 
} else{

169 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 
170 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
171 
} 
172 
break;

173 
case 4: 
174 
case 5: 
175 
s>y_dc_scale_table= wmv1_y_dc_scale_table; 
176 
s>c_dc_scale_table= wmv1_c_dc_scale_table; 
177 
break;

178 
} 
179  
180 

181 
if(s>msmpeg4_version>=4){ 
182 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_scantable , wmv1_scantable[1]);

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

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

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

186 
} 
187 
//Note the default tables are set in common_init in mpegvideo.c

188 

189 
if(!inited){

190 
inited=1;

191  
192 
init_h263_dc_for_msmpeg4(); 
193 
} 
194 
} 
195  
196 
#ifdef CONFIG_ENCODERS

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

199 
static void init_mv_table(MVTable *tab) 
200 
{ 
201 
int i, x, y;

202  
203 
tab>table_mv_index = av_malloc(sizeof(uint16_t) * 4096); 
204 
/* mark all entries as not used */

205 
for(i=0;i<4096;i++) 
206 
tab>table_mv_index[i] = tab>n; 
207 

208 
for(i=0;i<tab>n;i++) { 
209 
x = tab>table_mvx[i]; 
210 
y = tab>table_mvy[i]; 
211 
tab>table_mv_index[(x << 6)  y] = i;

212 
} 
213 
} 
214  
215 
static void code012(PutBitContext *pb, int n) 
216 
{ 
217 
if (n == 0) { 
218 
put_bits(pb, 1, 0); 
219 
} else {

220 
put_bits(pb, 1, 1); 
221 
put_bits(pb, 1, (n >= 2)); 
222 
} 
223 
} 
224  
225 
void ff_msmpeg4_encode_init(MpegEncContext *s)

226 
{ 
227 
static int init_done=0; 
228 
int i;

229  
230 
common_init(s); 
231 
if(s>msmpeg4_version>=4){ 
232 
s>min_qcoeff= 255;

233 
s>max_qcoeff= 255;

234 
} 
235  
236 
if (!init_done) {

237 
/* init various encoding tables */

238 
init_done = 1;

239 
init_mv_table(&mv_tables[0]);

240 
init_mv_table(&mv_tables[1]);

241 
for(i=0;i<NB_RL_TABLES;i++) 
242 
init_rl(&rl_table[i], 1);

243  
244 
for(i=0; i<NB_RL_TABLES; i++){ 
245 
int level;

246 
for(level=0; level<=MAX_LEVEL; level++){ 
247 
int run;

248 
for(run=0; run<=MAX_RUN; run++){ 
249 
int last;

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

252 
} 
253 
} 
254 
} 
255 
} 
256 
} 
257 
} 
258  
259 
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ 
260 
int size=0; 
261 
int code;

262 
int run_diff= intra ? 0 : 1; 
263 

264 
code = get_rl_index(rl, last, run, level); 
265 
size+= rl>table_vlc[code][1];

266 
if (code == rl>n) {

267 
int level1, run1;

268  
269 
level1 = level  rl>max_level[last][run]; 
270 
if (level1 < 1) 
271 
goto esc2;

272 
code = get_rl_index(rl, last, run, level1); 
273 
if (code == rl>n) {

274 
esc2:

275 
size++; 
276 
if (level > MAX_LEVEL)

277 
goto esc3;

278 
run1 = run  rl>max_run[last][level]  run_diff; 
279 
if (run1 < 0) 
280 
goto esc3;

281 
code = get_rl_index(rl, last, run1, level); 
282 
if (code == rl>n) {

283 
esc3:

284 
/* third escape */

285 
size+=1+1+6+8; 
286 
} else {

287 
/* second escape */

288 
size+= 1+1+ rl>table_vlc[code][1]; 
289 
} 
290 
} else {

291 
/* first escape */

292 
size+= 1+1+ rl>table_vlc[code][1]; 
293 
} 
294 
} else {

295 
size++; 
296 
} 
297 
return size;

298 
} 
299  
300 
static void find_best_tables(MpegEncContext * s) 
301 
{ 
302 
int i;

303 
int best =1, best_size =9999999; 
304 
int chroma_best=1, best_chroma_size=9999999; 
305  
306 
for(i=0; i<3; i++){ 
307 
int level;

308 
int chroma_size=0; 
309 
int size=0; 
310  
311 
if(i>0){// ;) 
312 
size++; 
313 
chroma_size++; 
314 
} 
315 
for(level=0; level<=MAX_LEVEL; level++){ 
316 
int run;

317 
for(run=0; run<=MAX_RUN; run++){ 
318 
int last;

319 
const int last_size= size + chroma_size; 
320 
for(last=0; last<2; last++){ 
321 
int inter_count = s>ac_stats[0][0][level][run][last] + s>ac_stats[0][1][level][run][last]; 
322 
int intra_luma_count = s>ac_stats[1][0][level][run][last]; 
323 
int intra_chroma_count= s>ac_stats[1][1][level][run][last]; 
324 

325 
if(s>pict_type==I_TYPE){

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

328 
}else{

329 
size+= intra_luma_count *rl_length[i ][level][run][last] 
330 
+intra_chroma_count*rl_length[i+3][level][run][last]

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

332 
} 
333 
} 
334 
if(last_size == size+chroma_size) break; 
335 
} 
336 
} 
337 
if(size<best_size){

338 
best_size= size; 
339 
best= i; 
340 
} 
341 
if(chroma_size<best_chroma_size){

342 
best_chroma_size= chroma_size; 
343 
chroma_best= i; 
344 
} 
345 
} 
346  
347 
// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",

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

349 

350 
if(s>pict_type==P_TYPE) chroma_best= best;

351  
352 
memset(s>ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); 
353  
354 
s>rl_table_index = best; 
355 
s>rl_chroma_table_index= chroma_best; 
356 

357 
if(s>pict_type != s>last_non_b_pict_type){

358 
s>rl_table_index= 2;

359 
if(s>pict_type==I_TYPE)

360 
s>rl_chroma_table_index= 1;

361 
else

362 
s>rl_chroma_table_index= 2;

363 
} 
364  
365 
} 
366  
367 
/* write MSMPEG4 compatible frame header */

368 
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
369 
{ 
370 
find_best_tables(s); 
371  
372 
align_put_bits(&s>pb); 
373 
put_bits(&s>pb, 2, s>pict_type  1); 
374  
375 
put_bits(&s>pb, 5, s>qscale);

376 
if(s>msmpeg4_version<=2){ 
377 
s>rl_table_index = 2;

378 
s>rl_chroma_table_index = 2;

379 
} 
380  
381 
s>dc_table_index = 1;

382 
s>mv_table_index = 1; /* only if P frame */ 
383 
s>use_skip_mb_code = 1; /* only if P frame */ 
384 
s>per_mb_rl_table = 0;

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

388  
389 
if (s>pict_type == I_TYPE) {

390 
s>slice_height= s>mb_height/1;

391 
put_bits(&s>pb, 5, 0x16 + s>mb_height/s>slice_height); 
392 

393 
if(s>msmpeg4_version==4){ 
394 
msmpeg4_encode_ext_header(s); 
395 
if(s>bit_rate>MBAC_BITRATE)

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

397 
} 
398  
399 
if(s>msmpeg4_version>2){ 
400 
if(!s>per_mb_rl_table){

401 
code012(&s>pb, s>rl_chroma_table_index); 
402 
code012(&s>pb, s>rl_table_index); 
403 
} 
404  
405 
put_bits(&s>pb, 1, s>dc_table_index);

406 
} 
407 
} else {

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

409 

410 
if(s>msmpeg4_version==4 && s>bit_rate>MBAC_BITRATE) 
411 
put_bits(&s>pb, 1, s>per_mb_rl_table);

412  
413 
if(s>msmpeg4_version>2){ 
414 
if(!s>per_mb_rl_table)

415 
code012(&s>pb, s>rl_table_index); 
416  
417 
put_bits(&s>pb, 1, s>dc_table_index);

418  
419 
put_bits(&s>pb, 1, s>mv_table_index);

420 
} 
421 
} 
422  
423 
s>esc3_level_length= 0;

424 
s>esc3_run_length= 0;

425  
426 
#ifdef DEBUG

427 
intra_count = 0;

428 
printf("*****frame %d:\n", frame_count++);

429 
#endif

430 
} 
431  
432 
void msmpeg4_encode_ext_header(MpegEncContext * s)

433 
{ 
434 
put_bits(&s>pb, 5, s>avctx>frame_rate / s>avctx>frame_rate_base); //yes 29.97 > 29 
435  
436 
put_bits(&s>pb, 11, FFMIN(s>bit_rate/1024, 2047)); 
437  
438 
if(s>msmpeg4_version>=3) 
439 
put_bits(&s>pb, 1, s>flipflop_rounding);

440 
else

441 
assert(s>flipflop_rounding==0);

442 
} 
443  
444 
#endif //CONFIG_ENCODERS 
445  
446 
/* predict coded block */

447 
static inline int coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) 
448 
{ 
449 
int xy, wrap, pred, a, b, c;

450  
451 
xy = s>block_index[n]; 
452 
wrap = s>b8_stride; 
453  
454 
/* B C

455 
* A X

456 
*/

457 
a = s>coded_block[xy  1 ];

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

459 
c = s>coded_block[xy  wrap]; 
460 

461 
if (b == c) {

462 
pred = a; 
463 
} else {

464 
pred = c; 
465 
} 
466 

467 
/* store value */

468 
*coded_block_ptr = &s>coded_block[xy]; 
469  
470 
return pred;

471 
} 
472  
473 
#ifdef CONFIG_ENCODERS

474  
475 
static void msmpeg4_encode_motion(MpegEncContext * s, 
476 
int mx, int my) 
477 
{ 
478 
int code;

479 
MVTable *mv; 
480  
481 
/* modulo encoding */

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

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

484 
if (mx <= 64) 
485 
mx += 64;

486 
else if (mx >= 64) 
487 
mx = 64;

488 
if (my <= 64) 
489 
my += 64;

490 
else if (my >= 64) 
491 
my = 64;

492 

493 
mx += 32;

494 
my += 32;

495 
#if 0

496 
if ((unsigned)mx >= 64 

497 
(unsigned)my >= 64)

498 
fprintf(stderr, "error mx=%d my=%d\n", mx, my);

499 
#endif

500 
mv = &mv_tables[s>mv_table_index]; 
501  
502 
code = mv>table_mv_index[(mx << 6)  my];

503 
set_stat(ST_MV); 
504 
put_bits(&s>pb, 
505 
mv>table_mv_bits[code], 
506 
mv>table_mv_code[code]); 
507 
if (code == mv>n) {

508 
/* escape : code litterally */

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

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

511 
} 
512 
} 
513  
514 
static inline void handle_slices(MpegEncContext *s){ 
515 
if (s>mb_x == 0) { 
516 
if (s>slice_height && (s>mb_y % s>slice_height) == 0) { 
517 
if(s>msmpeg4_version < 4){ 
518 
ff_mpeg4_clean_buffers(s); 
519 
} 
520 
s>first_slice_line = 1;

521 
} else {

522 
s>first_slice_line = 0;

523 
} 
524 
} 
525 
} 
526  
527 
void msmpeg4_encode_mb(MpegEncContext * s,

528 
DCTELEM block[6][64], 
529 
int motion_x, int motion_y) 
530 
{ 
531 
int cbp, coded_cbp, i;

532 
int pred_x, pred_y;

533 
uint8_t *coded_block; 
534  
535 
handle_slices(s); 
536 

537 
if (!s>mb_intra) {

538 
/* compute cbp */

539 
set_stat(ST_INTER_MB); 
540 
cbp = 0;

541 
for (i = 0; i < 6; i++) { 
542 
if (s>block_last_index[i] >= 0) 
543 
cbp = 1 << (5  i); 
544 
} 
545 
if (s>use_skip_mb_code && (cbp  motion_x  motion_y) == 0) { 
546 
/* skip macroblock */

547 
put_bits(&s>pb, 1, 1); 
548 
s>last_bits++; 
549 
s>misc_bits++; 
550 
s>skip_count++; 
551  
552 
return;

553 
} 
554 
if (s>use_skip_mb_code)

555 
put_bits(&s>pb, 1, 0); /* mb coded */ 
556 

557 
if(s>msmpeg4_version<=2){ 
558 
put_bits(&s>pb, 
559 
v2_mb_type[cbp&3][1], 
560 
v2_mb_type[cbp&3][0]); 
561 
if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; 
562 
else coded_cbp= cbp;

563  
564 
put_bits(&s>pb, 
565 
cbpy_tab[coded_cbp>>2][1], 
566 
cbpy_tab[coded_cbp>>2][0]); 
567  
568 
s>misc_bits += get_bits_diff(s); 
569  
570 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
571 
msmpeg4v2_encode_motion(s, motion_x  pred_x); 
572 
msmpeg4v2_encode_motion(s, motion_y  pred_y); 
573 
}else{

574 
put_bits(&s>pb, 
575 
table_mb_non_intra[cbp + 64][1], 
576 
table_mb_non_intra[cbp + 64][0]); 
577  
578 
s>misc_bits += get_bits_diff(s); 
579  
580 
/* motion vector */

581 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
582 
msmpeg4_encode_motion(s, motion_x  pred_x, 
583 
motion_y  pred_y); 
584 
} 
585  
586 
s>mv_bits += get_bits_diff(s); 
587  
588 
for (i = 0; i < 6; i++) { 
589 
msmpeg4_encode_block(s, block[i], i); 
590 
} 
591 
s>p_tex_bits += get_bits_diff(s); 
592 
} else {

593 
/* compute cbp */

594 
cbp = 0;

595 
coded_cbp = 0;

596 
for (i = 0; i < 6; i++) { 
597 
int val, pred;

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

599 
cbp = val << (5  i);

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

602 
pred = coded_block_pred(s, i, &coded_block); 
603 
*coded_block = val; 
604 
val = val ^ pred; 
605 
} 
606 
coded_cbp = val << (5  i);

607 
} 
608 
#if 0

609 
if (coded_cbp)

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

611 
#endif

612  
613 
if(s>msmpeg4_version<=2){ 
614 
if (s>pict_type == I_TYPE) {

615 
put_bits(&s>pb, 
616 
v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); 
617 
} else {

618 
if (s>use_skip_mb_code)

619 
put_bits(&s>pb, 1, 0); /* mb coded */ 
620 
put_bits(&s>pb, 
621 
v2_mb_type[(cbp&3) + 4][1], 
622 
v2_mb_type[(cbp&3) + 4][0]); 
623 
} 
624 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
625 
put_bits(&s>pb, 
626 
cbpy_tab[cbp>>2][1], 
627 
cbpy_tab[cbp>>2][0]); 
628 
}else{

629 
if (s>pict_type == I_TYPE) {

630 
set_stat(ST_INTRA_MB); 
631 
put_bits(&s>pb, 
632 
table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]); 
633 
} else {

634 
if (s>use_skip_mb_code)

635 
put_bits(&s>pb, 1, 0); /* mb coded */ 
636 
put_bits(&s>pb, 
637 
table_mb_non_intra[cbp][1],

638 
table_mb_non_intra[cbp][0]);

639 
} 
640 
set_stat(ST_INTRA_MB); 
641 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
642 
if(s>inter_intra_pred){

643 
s>h263_aic_dir=0;

644 
put_bits(&s>pb, table_inter_intra[s>h263_aic_dir][1], table_inter_intra[s>h263_aic_dir][0]); 
645 
} 
646 
} 
647 
s>misc_bits += get_bits_diff(s); 
648  
649 
for (i = 0; i < 6; i++) { 
650 
msmpeg4_encode_block(s, block[i], i); 
651 
} 
652 
s>i_tex_bits += get_bits_diff(s); 
653 
s>i_count++; 
654 
} 
655 
} 
656  
657 
#endif //CONFIG_ENCODERS 
658  
659 
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
660 
int32_t **dc_val_ptr) 
661 
{ 
662 
int i;

663  
664 
if (n < 4) { 
665 
i= 0;

666 
} else {

667 
i= n3;

668 
} 
669 

670 
*dc_val_ptr= &s>last_dc[i]; 
671 
return s>last_dc[i];

672 
} 
673  
674 
static int get_dc(uint8_t *src, int stride, int scale) 
675 
{ 
676 
int y;

677 
int sum=0; 
678 
for(y=0; y<8; y++){ 
679 
int x;

680 
for(x=0; x<8; x++){ 
681 
sum+=src[x + y*stride]; 
682 
} 
683 
} 
684 
return FASTDIV((sum + (scale>>1)), scale); 
685 
} 
686  
687 
/* dir = 0: left, dir = 1: top prediction */

688 
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
689 
uint16_t **dc_val_ptr, int *dir_ptr)

690 
{ 
691 
int a, b, c, wrap, pred, scale;

692 
int16_t *dc_val; 
693  
694 
/* find prediction */

695 
if (n < 4) { 
696 
scale = s>y_dc_scale; 
697 
} else {

698 
scale = s>c_dc_scale; 
699 
} 
700 

701 
wrap = s>block_wrap[n]; 
702 
dc_val= s>dc_val[0] + s>block_index[n];

703  
704 
/* B C

705 
* A X

706 
*/

707 
a = dc_val[  1];

708 
b = dc_val[  1  wrap];

709 
c = dc_val[  wrap]; 
710 

711 
if(s>first_slice_line && (n&2)==0 && s>msmpeg4_version<4){ 
712 
b=c=1024;

713 
} 
714  
715 
/* XXX: the following solution consumes divisions, but it does not

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

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

718 
to problems if Q could vary !) */

719 
#if (defined(ARCH_X86)  defined(ARCH_X86_64)) && !defined PIC

720 
asm volatile( 
721 
"movl %3, %%eax \n\t"

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

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

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

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

726 
"mull %4 \n\t"

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

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

729 
"mull %4 \n\t"

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

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

732 
"mull %4 \n\t"

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

734 
: "+b" (a), "+c" (b), "+D" (c) 
735 
: "g" (scale), "S" (inverse[scale]) 
736 
: "%eax", "%edx" 
737 
); 
738 
#else

739 
/* #elif defined (ARCH_ALPHA) */

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

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

742 
*/

743 
if (scale == 8) { 
744 
a = (a + (8 >> 1)) / 8; 
745 
b = (b + (8 >> 1)) / 8; 
746 
c = (c + (8 >> 1)) / 8; 
747 
} else {

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

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

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

751 
} 
752 
#endif

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

754 
is very important ! */

755 
if(s>msmpeg4_version>3){ 
756 
if(s>inter_intra_pred){

757 
uint8_t *dest; 
758 
int wrap;

759 

760 
if(n==1){ 
761 
pred=a; 
762 
*dir_ptr = 0;

763 
}else if(n==2){ 
764 
pred=c; 
765 
*dir_ptr = 1;

766 
}else if(n==3){ 
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 
}else{

775 
if(n<4){ 
776 
wrap= s>linesize; 
777 
dest= s>current_picture.data[0] + (((n>>1) + 2*s>mb_y) * 8* wrap ) + ((n&1) + 2*s>mb_x) * 8; 
778 
}else{

779 
wrap= s>uvlinesize; 
780 
dest= s>current_picture.data[n3] + (s>mb_y * 8 * wrap) + s>mb_x * 8; 
781 
} 
782 
if(s>mb_x==0) a= (1024 + (scale>>1))/scale; 
783 
else a= get_dc(dest8, wrap, scale*8); 
784 
if(s>mb_y==0) c= (1024 + (scale>>1))/scale; 
785 
else c= get_dc(dest8*wrap, wrap, scale*8); 
786 

787 
if (s>h263_aic_dir==0) { 
788 
pred= a; 
789 
*dir_ptr = 0;

790 
}else if (s>h263_aic_dir==1) { 
791 
if(n==0){ 
792 
pred= c; 
793 
*dir_ptr = 1;

794 
}else{

795 
pred= a; 
796 
*dir_ptr = 0;

797 
} 
798 
}else if (s>h263_aic_dir==2) { 
799 
if(n==0){ 
800 
pred= a; 
801 
*dir_ptr = 0;

802 
}else{

803 
pred= c; 
804 
*dir_ptr = 1;

805 
} 
806 
} else {

807 
pred= c; 
808 
*dir_ptr = 1;

809 
} 
810 
} 
811 
}else{

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

813 
pred = c; 
814 
*dir_ptr = 1;

815 
} else {

816 
pred = a; 
817 
*dir_ptr = 0;

818 
} 
819 
} 
820 
}else{

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

822 
pred = c; 
823 
*dir_ptr = 1;

824 
} else {

825 
pred = a; 
826 
*dir_ptr = 0;

827 
} 
828 
} 
829  
830 
/* update predictor */

831 
*dc_val_ptr = &dc_val[0];

832 
return pred;

833 
} 
834  
835 
#define DC_MAX 119 
836  
837 
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) 
838 
{ 
839 
int sign, code;

840 
int pred;

841  
842 
if(s>msmpeg4_version==1){ 
843 
int32_t *dc_val; 
844 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
845 

846 
/* update predictor */

847 
*dc_val= level; 
848 
}else{

849 
uint16_t *dc_val; 
850 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
851  
852 
/* update predictor */

853 
if (n < 4) { 
854 
*dc_val = level * s>y_dc_scale; 
855 
} else {

856 
*dc_val = level * s>c_dc_scale; 
857 
} 
858 
} 
859  
860 
/* do the prediction */

861 
level = pred; 
862  
863 
if(s>msmpeg4_version<=2){ 
864 
if (n < 4) { 
865 
put_bits(&s>pb, 
866 
v2_dc_lum_table[level+256][1], 
867 
v2_dc_lum_table[level+256][0]); 
868 
}else{

869 
put_bits(&s>pb, 
870 
v2_dc_chroma_table[level+256][1], 
871 
v2_dc_chroma_table[level+256][0]); 
872 
} 
873 
}else{

874 
sign = 0;

875 
if (level < 0) { 
876 
level = level; 
877 
sign = 1;

878 
} 
879 
code = level; 
880 
if (code > DC_MAX)

881 
code = DC_MAX; 
882  
883 
if (s>dc_table_index == 0) { 
884 
if (n < 4) { 
885 
put_bits(&s>pb, table0_dc_lum[code][1], table0_dc_lum[code][0]); 
886 
} else {

887 
put_bits(&s>pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]); 
888 
} 
889 
} else {

890 
if (n < 4) { 
891 
put_bits(&s>pb, table1_dc_lum[code][1], table1_dc_lum[code][0]); 
892 
} else {

893 
put_bits(&s>pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]); 
894 
} 
895 
} 
896 

897 
if (code == DC_MAX)

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

899 

900 
if (level != 0) { 
901 
put_bits(&s>pb, 1, sign);

902 
} 
903 
} 
904 
} 
905  
906 
/* Encoding of a block. Very similar to MPEG4 except for a different

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

908 
*/

909 
static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
910 
{ 
911 
int level, run, last, i, j, last_index;

912 
int last_non_zero, sign, slevel;

913 
int code, run_diff, dc_pred_dir;

914 
const RLTable *rl;

915 
const uint8_t *scantable;

916  
917 
if (s>mb_intra) {

918 
set_stat(ST_DC); 
919 
msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);

920 
i = 1;

921 
if (n < 4) { 
922 
rl = &rl_table[s>rl_table_index]; 
923 
} else {

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

925 
} 
926 
run_diff = 0;

927 
scantable= s>intra_scantable.permutated; 
928 
set_stat(ST_INTRA_AC); 
929 
} else {

930 
i = 0;

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

932 
if(s>msmpeg4_version<=2) 
933 
run_diff = 0;

934 
else

935 
run_diff = 1;

936 
scantable= s>inter_scantable.permutated; 
937 
set_stat(ST_INTER_AC); 
938 
} 
939  
940 
/* recalculate block_last_index for M$ wmv1 */

941 
if(s>msmpeg4_version>=4 && s>block_last_index[n]>0){ 
942 
for(last_index=63; last_index>=0; last_index){ 
943 
if(block[scantable[last_index]]) break; 
944 
} 
945 
s>block_last_index[n]= last_index; 
946 
}else

947 
last_index = s>block_last_index[n]; 
948 
/* AC coefs */

949 
last_non_zero = i  1;

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

951 
j = scantable[i]; 
952 
level = block[j]; 
953 
if (level) {

954 
run = i  last_non_zero  1;

955 
last = (i == last_index); 
956 
sign = 0;

957 
slevel = level; 
958 
if (level < 0) { 
959 
sign = 1;

960 
level = level; 
961 
} 
962  
963 
if(level<=MAX_LEVEL && run<=MAX_RUN){

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

965 
} 
966 
#if 0

967 
else

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

969 
#endif

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

973 
int level1, run1;

974  
975 
level1 = level  rl>max_level[last][run]; 
976 
if (level1 < 1) 
977 
goto esc2;

978 
code = get_rl_index(rl, last, run, level1); 
979 
if (code == rl>n) {

980 
esc2:

981 
put_bits(&s>pb, 1, 0); 
982 
if (level > MAX_LEVEL)

983 
goto esc3;

984 
run1 = run  rl>max_run[last][level]  run_diff; 
985 
if (run1 < 0) 
986 
goto esc3;

987 
code = get_rl_index(rl, last, run1, level); 
988 
if (code == rl>n) {

989 
esc3:

990 
/* third escape */

991 
put_bits(&s>pb, 1, 0); 
992 
put_bits(&s>pb, 1, last);

993 
if(s>msmpeg4_version>=4){ 
994 
if(s>esc3_level_length==0){ 
995 
s>esc3_level_length=8;

996 
s>esc3_run_length= 6;

997 
if(s>qscale<8) 
998 
put_bits(&s>pb, 6, 3); 
999 
else

1000 
put_bits(&s>pb, 8, 3); 
1001 
} 
1002 
put_bits(&s>pb, s>esc3_run_length, run); 
1003 
put_bits(&s>pb, 1, sign);

1004 
put_bits(&s>pb, s>esc3_level_length, level); 
1005 
}else{

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

1007 
put_bits(&s>pb, 8, slevel & 0xff); 
1008 
} 
1009 
} else {

1010 
/* second escape */

1011 
put_bits(&s>pb, 1, 1); 
1012 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1013 
put_bits(&s>pb, 1, sign);

1014 
} 
1015 
} else {

1016 
/* first escape */

1017 
put_bits(&s>pb, 1, 1); 
1018 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1019 
put_bits(&s>pb, 1, sign);

1020 
} 
1021 
} else {

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

1023 
} 
1024 
last_non_zero = i; 
1025 
} 
1026 
} 
1027 
} 
1028  
1029 
/****************************************/

1030 
/* decoding stuff */

1031  
1032 
static VLC mb_non_intra_vlc[4]; 
1033 
static VLC mb_intra_vlc;

1034 
static VLC dc_lum_vlc[2]; 
1035 
static VLC dc_chroma_vlc[2]; 
1036 
static VLC v2_dc_lum_vlc;

1037 
static VLC v2_dc_chroma_vlc;

1038 
static VLC cbpy_vlc;

1039 
static VLC v2_intra_cbpc_vlc;

1040 
static VLC v2_mb_type_vlc;

1041 
static VLC v2_mv_vlc;

1042 
static VLC v1_intra_cbpc_vlc;

1043 
static VLC v1_inter_cbpc_vlc;

1044 
static VLC inter_intra_vlc;

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

1047 
static void init_h263_dc_for_msmpeg4(void) 
1048 
{ 
1049 
int level, uni_code, uni_len;

1050  
1051 
for(level=256; level<256; level++){ 
1052 
int size, v, l;

1053 
/* find number of bits */

1054 
size = 0;

1055 
v = abs(level); 
1056 
while (v) {

1057 
v >>= 1;

1058 
size++; 
1059 
} 
1060  
1061 
if (level < 0) 
1062 
l= (level) ^ ((1 << size)  1); 
1063 
else

1064 
l= level; 
1065  
1066 
/* luminance h263 */

1067 
uni_code= DCtab_lum[size][0];

1068 
uni_len = DCtab_lum[size][1];

1069 
uni_code ^= (1<<uni_len)1; //M$ doesnt like compatibility 
1070  
1071 
if (size > 0) { 
1072 
uni_code<<=size; uni_code=l; 
1073 
uni_len+=size; 
1074 
if (size > 8){ 
1075 
uni_code<<=1; uni_code=1; 
1076 
uni_len++; 
1077 
} 
1078 
} 
1079 
v2_dc_lum_table[level+256][0]= uni_code; 
1080 
v2_dc_lum_table[level+256][1]= uni_len; 
1081  
1082 
/* chrominance h263 */

1083 
uni_code= DCtab_chrom[size][0];

1084 
uni_len = DCtab_chrom[size][1];

1085 
uni_code ^= (1<<uni_len)1; //M$ doesnt like compatibility 
1086 

1087 
if (size > 0) { 
1088 
uni_code<<=size; uni_code=l; 
1089 
uni_len+=size; 
1090 
if (size > 8){ 
1091 
uni_code<<=1; uni_code=1; 
1092 
uni_len++; 
1093 
} 
1094 
} 
1095 
v2_dc_chroma_table[level+256][0]= uni_code; 
1096 
v2_dc_chroma_table[level+256][1]= uni_len; 
1097  
1098 
} 
1099 
} 
1100  
1101 
/* init all vlc decoding tables */

1102 
int ff_msmpeg4_decode_init(MpegEncContext *s)

1103 
{ 
1104 
static int done = 0; 
1105 
int i;

1106 
MVTable *mv; 
1107  
1108 
common_init(s); 
1109  
1110 
if (!done) {

1111 
done = 1;

1112  
1113 
for(i=0;i<NB_RL_TABLES;i++) { 
1114 
init_rl(&rl_table[i], 1);

1115 
init_vlc_rl(&rl_table[i], 1);

1116 
} 
1117 
for(i=0;i<2;i++) { 
1118 
mv = &mv_tables[i]; 
1119 
init_vlc(&mv>vlc, MV_VLC_BITS, mv>n + 1,

1120 
mv>table_mv_bits, 1, 1, 
1121 
mv>table_mv_code, 2, 2, 1); 
1122 
} 
1123  
1124 
init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 
1125 
&table0_dc_lum[0][1], 8, 4, 
1126 
&table0_dc_lum[0][0], 8, 4, 1); 
1127 
init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1128 
&table0_dc_chroma[0][1], 8, 4, 
1129 
&table0_dc_chroma[0][0], 8, 4, 1); 
1130 
init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 
1131 
&table1_dc_lum[0][1], 8, 4, 
1132 
&table1_dc_lum[0][0], 8, 4, 1); 
1133 
init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1134 
&table1_dc_chroma[0][1], 8, 4, 
1135 
&table1_dc_chroma[0][0], 8, 4, 1); 
1136 

1137 
init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,

1138 
&v2_dc_lum_table[0][1], 8, 4, 
1139 
&v2_dc_lum_table[0][0], 8, 4, 1); 
1140 
init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,

1141 
&v2_dc_chroma_table[0][1], 8, 4, 
1142 
&v2_dc_chroma_table[0][0], 8, 4, 1); 
1143 

1144 
init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,

1145 
&cbpy_tab[0][1], 2, 1, 
1146 
&cbpy_tab[0][0], 2, 1, 1); 
1147 
init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,

1148 
&v2_intra_cbpc[0][1], 2, 1, 
1149 
&v2_intra_cbpc[0][0], 2, 1, 1); 
1150 
init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,

1151 
&v2_mb_type[0][1], 2, 1, 
1152 
&v2_mb_type[0][0], 2, 1, 1); 
1153 
init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,

1154 
&mvtab[0][1], 2, 1, 
1155 
&mvtab[0][0], 2, 1, 1); 
1156  
1157 
for(i=0; i<4; i++){ 
1158 
init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,

1159 
&wmv2_inter_table[i][0][1], 8, 4, 
1160 
&wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name? 
1161 
} 
1162 

1163 
init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,

1164 
&table_mb_intra[0][1], 4, 2, 
1165 
&table_mb_intra[0][0], 4, 2, 1); 
1166 

1167 
init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,

1168 
intra_MCBPC_bits, 1, 1, 
1169 
intra_MCBPC_code, 1, 1, 1); 
1170 
init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,

1171 
inter_MCBPC_bits, 1, 1, 
1172 
inter_MCBPC_code, 1, 1, 1); 
1173 

1174 
init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,

1175 
&table_inter_intra[0][1], 2, 1, 
1176 
&table_inter_intra[0][0], 2, 1, 1); 
1177 
} 
1178 

1179 
switch(s>msmpeg4_version){

1180 
case 1: 
1181 
case 2: 
1182 
s>decode_mb= msmpeg4v12_decode_mb; 
1183 
break;

1184 
case 3: 
1185 
case 4: 
1186 
s>decode_mb= msmpeg4v34_decode_mb; 
1187 
break;

1188 
case 5: 
1189 
s>decode_mb= wmv2_decode_mb; 
1190 
break;

1191 
} 
1192 

1193 
s>slice_height= s>mb_height; //to avoid 1/0 if the first frame isnt a keyframe

1194 

1195 
return 0; 
1196 
} 
1197  
1198 
static int decode012(GetBitContext *gb) 
1199 
{ 
1200 
int n;

1201 
n = get_bits1(gb); 
1202 
if (n == 0) 
1203 
return 0; 
1204 
else

1205 
return get_bits1(gb) + 1; 
1206 
} 
1207  
1208 
int msmpeg4_decode_picture_header(MpegEncContext * s)

1209 
{ 
1210 
int code;

1211  
1212 
#if 0

1213 
{

1214 
int i;

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

1216 
printf("%d", get_bits1(&s>gb));

1217 
// get_bits1(&s>gb);

1218 
printf("END\n");

1219 
return 1;

1220 
}

1221 
#endif

1222  
1223 
if(s>msmpeg4_version==1){ 
1224 
int start_code, num;

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

1228 
return 1; 
1229 
} 
1230  
1231 
num= get_bits(&s>gb, 5); // frame number */ 
1232 
} 
1233  
1234 
s>pict_type = get_bits(&s>gb, 2) + 1; 
1235 
if (s>pict_type != I_TYPE &&

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

1238 
return 1; 
1239 
} 
1240 
#if 0

1241 
{

1242 
static int had_i=0;

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

1244 
if(!had_i) return 1;

1245 
}

1246 
#endif

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

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

1250 
return 1; 
1251 
} 
1252  
1253 
if (s>pict_type == I_TYPE) {

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

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

1258 
return 1; 
1259 
} 
1260  
1261 
s>slice_height = code; 
1262 
}else{

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

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

1266 
return 1; 
1267 
} 
1268  
1269 
s>slice_height = s>mb_height / (code  0x16);

1270 
} 
1271  
1272 
switch(s>msmpeg4_version){

1273 
case 1: 
1274 
case 2: 
1275 
s>rl_chroma_table_index = 2;

1276 
s>rl_table_index = 2;

1277  
1278 
s>dc_table_index = 0; //not used 
1279 
break;

1280 
case 3: 
1281 
s>rl_chroma_table_index = decode012(&s>gb); 
1282 
s>rl_table_index = decode012(&s>gb); 
1283  
1284 
s>dc_table_index = get_bits1(&s>gb); 
1285 
break;

1286 
case 4: 
1287 
msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 
1288  
1289 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1290 
else s>per_mb_rl_table= 0; 
1291 

1292 
if(!s>per_mb_rl_table){

1293 
s>rl_chroma_table_index = decode012(&s>gb); 
1294 
s>rl_table_index = decode012(&s>gb); 
1295 
} 
1296  
1297 
s>dc_table_index = get_bits1(&s>gb); 
1298 
s>inter_intra_pred= 0;

1299 
break;

1300 
} 
1301 
s>no_rounding = 1;

1302 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

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

1304 
s>qscale, 
1305 
s>rl_chroma_table_index, 
1306 
s>rl_table_index, 
1307 
s>dc_table_index, 
1308 
s>per_mb_rl_table, 
1309 
s>slice_height); 
1310 
} else {

1311 
switch(s>msmpeg4_version){

1312 
case 1: 
1313 
case 2: 
1314 
if(s>msmpeg4_version==1) 
1315 
s>use_skip_mb_code = 1;

1316 
else

1317 
s>use_skip_mb_code = get_bits1(&s>gb); 
1318 
s>rl_table_index = 2;

1319 
s>rl_chroma_table_index = s>rl_table_index; 
1320 
s>dc_table_index = 0; //not used 
1321 
s>mv_table_index = 0;

1322 
break;

1323 
case 3: 
1324 
s>use_skip_mb_code = get_bits1(&s>gb); 
1325 
s>rl_table_index = decode012(&s>gb); 
1326 
s>rl_chroma_table_index = s>rl_table_index; 
1327  
1328 
s>dc_table_index = get_bits1(&s>gb); 
1329  
1330 
s>mv_table_index = get_bits1(&s>gb); 
1331 
break;

1332 
case 4: 
1333 
s>use_skip_mb_code = get_bits1(&s>gb); 
1334  
1335 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1336 
else s>per_mb_rl_table= 0; 
1337  
1338 
if(!s>per_mb_rl_table){

1339 
s>rl_table_index = decode012(&s>gb); 
1340 
s>rl_chroma_table_index = s>rl_table_index; 
1341 
} 
1342  
1343 
s>dc_table_index = get_bits1(&s>gb); 
1344  
1345 
s>mv_table_index = get_bits1(&s>gb); 
1346 
s>inter_intra_pred= (s>width*s>height < 320*240 && s>bit_rate<=II_BITRATE); 
1347 
break;

1348 
} 
1349 

1350 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

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

1352 
s>use_skip_mb_code, 
1353 
s>rl_table_index, 
1354 
s>rl_chroma_table_index, 
1355 
s>dc_table_index, 
1356 
s>mv_table_index, 
1357 
s>per_mb_rl_table, 
1358 
s>qscale); 
1359  
1360 
if(s>flipflop_rounding){

1361 
s>no_rounding ^= 1;

1362 
}else{

1363 
s>no_rounding = 0;

1364 
} 
1365 
} 
1366 
//printf("%d %d %d %d %d\n", s>pict_type, s>bit_rate, s>inter_intra_pred, s>width, s>height);

1367  
1368 
s>esc3_level_length= 0;

1369 
s>esc3_run_length= 0;

1370  
1371 
#ifdef DEBUG

1372 
printf("*****frame %d:\n", frame_count++);

1373 
#endif

1374 
return 0; 
1375 
} 
1376  
1377 
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) 
1378 
{ 
1379 
int left= buf_size*8  get_bits_count(&s>gb); 
1380 
int length= s>msmpeg4_version>=3 ? 17 : 16; 
1381 
/* the alt_bitstream reader could read over the end so we need to check it */

1382 
if(left>=length && left<length+8) 
1383 
{ 
1384 
int fps;

1385  
1386 
fps= get_bits(&s>gb, 5);

1387 
s>bit_rate= get_bits(&s>gb, 11)*1024; 
1388 
if(s>msmpeg4_version>=3) 
1389 
s>flipflop_rounding= get_bits1(&s>gb); 
1390 
else

1391 
s>flipflop_rounding= 0;

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

1394 
} 
1395 
else if(left<length+8) 
1396 
{ 
1397 
s>flipflop_rounding= 0;

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

1400 
} 
1401 
else

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

1404 
} 
1405  
1406 
return 0; 
1407 
} 
1408  
1409 
static inline void msmpeg4_memsetw(short *tab, int val, int n) 
1410 
{ 
1411 
int i;

1412 
for(i=0;i<n;i++) 
1413 
tab[i] = val; 
1414 
} 
1415  
1416 
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) 
1417 
{ 
1418 
int range, bit_size, sign, code, bits;

1419  
1420 
if (val == 0) { 
1421 
/* zero vector */

1422 
code = 0;

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

1425 
bit_size = s>f_code  1;

1426 
range = 1 << bit_size;

1427 
if (val <= 64) 
1428 
val += 64;

1429 
else if (val >= 64) 
1430 
val = 64;

1431  
1432 
if (val >= 0) { 
1433 
sign = 0;

1434 
} else {

1435 
val = val; 
1436 
sign = 1;

1437 
} 
1438 
val; 
1439 
code = (val >> bit_size) + 1;

1440 
bits = val & (range  1);

1441  
1442 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
1443 
if (bit_size > 0) { 
1444 
put_bits(&s>pb, bit_size, bits); 
1445 
} 
1446 
} 
1447 
} 
1448  
1449 
/* this is identical to h263 except that its range is multiplied by 2 */

1450 
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 
1451 
{ 
1452 
int code, val, sign, shift;

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

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

1456 
if (code < 0) 
1457 
return 0xffff; 
1458  
1459 
if (code == 0) 
1460 
return pred;

1461 
sign = get_bits1(&s>gb); 
1462 
shift = f_code  1;

1463 
val = code; 
1464 
if (shift) {

1465 
val = (val  1) << shift;

1466 
val = get_bits(&s>gb, shift); 
1467 
val++; 
1468 
} 
1469 
if (sign)

1470 
val = val; 
1471  
1472 
val += pred; 
1473 
if (val <= 64) 
1474 
val += 64;

1475 
else if (val >= 64) 
1476 
val = 64;

1477  
1478 
return val;

1479 
} 
1480  
1481 
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1482 
{ 
1483 
int cbp, code, i;

1484 

1485 
if (s>pict_type == P_TYPE) {

1486 
if (s>use_skip_mb_code) {

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

1488 
/* skip mb */

1489 
s>mb_intra = 0;

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

1492 
s>mv_dir = MV_DIR_FORWARD; 
1493 
s>mv_type = MV_TYPE_16X16; 
1494 
s>mv[0][0][0] = 0; 
1495 
s>mv[0][0][1] = 0; 
1496 
s>mb_skiped = 1;

1497 
return 0; 
1498 
} 
1499 
} 
1500  
1501 
if(s>msmpeg4_version==2) 
1502 
code = get_vlc2(&s>gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);

1503 
else

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

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

1507 
return 1; 
1508 
} 
1509  
1510 
s>mb_intra = code >>2;

1511 

1512 
cbp = code & 0x3;

1513 
} else {

1514 
s>mb_intra = 1;

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

1517 
else

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

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

1521 
return 1; 
1522 
} 
1523 
} 
1524  
1525 
if (!s>mb_intra) {

1526 
int mx, my, cbpy;

1527 

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

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

1531 
return 1; 
1532 
} 
1533  
1534 
cbp= cbpy<<2;

1535 
if(s>msmpeg4_version==1  (cbp&3) != 3) cbp^= 0x3C; 
1536 

1537 
h263_pred_motion(s, 0, 0, &mx, &my); 
1538 
mx= msmpeg4v2_decode_motion(s, mx, 1);

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

1540 

1541 
s>mv_dir = MV_DIR_FORWARD; 
1542 
s>mv_type = MV_TYPE_16X16; 
1543 
s>mv[0][0][0] = mx; 
1544 
s>mv[0][0][1] = my; 
1545 
} else {

1546 
if(s>msmpeg4_version==2){ 
1547 
s>ac_pred = get_bits1(&s>gb); 
1548 
cbp= get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1549 
} else{

1550 
s>ac_pred = 0;

1551 
cbp= get_vlc2(&s>gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1552 
if(s>pict_type==P_TYPE) cbp^=0x3C; 
1553 
} 
1554 
} 
1555  
1556 
for (i = 0; i < 6; i++) { 
1557 
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1558 
{ 
1559 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1560 
return 1; 
1561 
} 
1562 
} 
1563 
return 0; 
1564 
} 
1565  
1566 
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1567 
{ 
1568 
int cbp, code, i;

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

1571  
1572 
if (s>pict_type == P_TYPE) {

1573 
set_stat(ST_INTER_MB); 
1574 
if (s>use_skip_mb_code) {

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

1576 
/* skip mb */

1577 
s>mb_intra = 0;

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

1580 
s>mv_dir = MV_DIR_FORWARD; 
1581 
s>mv_type = MV_TYPE_16X16; 
1582 
s>mv[0][0][0] = 0; 
1583 
s>mv[0][0][1] = 0; 
1584 
s>mb_skiped = 1;

1585 
*mb_type_ptr = MB_TYPE_SKIP  MB_TYPE_L0  MB_TYPE_16x16; 
1586  
1587 
return 0; 
1588 
} 
1589 
} 
1590 

1591 
code = get_vlc2(&s>gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);

1592 
if (code < 0) 
1593 
return 1; 
1594 
//s>mb_intra = (code & 0x40) ? 0 : 1;

1595 
s>mb_intra = (~code & 0x40) >> 6; 
1596 

1597 
cbp = code & 0x3f;

1598 
} else {

1599 
set_stat(ST_INTRA_MB); 
1600 
s>mb_intra = 1;

1601 
code = get_vlc2(&s>gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);

1602 
if (code < 0) 
1603 
return 1; 
1604 
/* predict coded block pattern */

1605 
cbp = 0;

1606 
for(i=0;i<6;i++) { 
1607 
int val = ((code >> (5  i)) & 1); 
1608 
if (i < 4) { 
1609 
int pred = coded_block_pred(s, i, &coded_val);

1610 
val = val ^ pred; 
1611 
*coded_val = val; 
1612 
} 
1613 
cbp = val << (5  i);

1614 
} 
1615 
} 
1616  
1617 
if (!s>mb_intra) {

1618 
int mx, my;

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

1620 
if(s>per_mb_rl_table && cbp){

1621 
s>rl_table_index = decode012(&s>gb); 
1622 
s>rl_chroma_table_index = s>rl_table_index; 
1623 
} 
1624 
set_stat(ST_MV); 
1625 
h263_pred_motion(s, 0, 0, &mx, &my); 
1626 
if (msmpeg4_decode_motion(s, &mx, &my) < 0) 
1627 
return 1; 
1628 
s>mv_dir = MV_DIR_FORWARD; 
1629 
s>mv_type = MV_TYPE_16X16; 
1630 
s>mv[0][0][0] = mx; 
1631 
s>mv[0][0][1] = my; 
1632 
*mb_type_ptr = MB_TYPE_L0  MB_TYPE_16x16; 
1633 
} else {

1634 
//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));

1635 
set_stat(ST_INTRA_MB); 
1636 
s>ac_pred = get_bits1(&s>gb); 
1637 
*mb_type_ptr = MB_TYPE_INTRA; 
1638 
if(s>inter_intra_pred){

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

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

1641 
} 
1642 
if(s>per_mb_rl_table && cbp){

1643 
s>rl_table_index = decode012(&s>gb); 
1644 
s>rl_chroma_table_index = s>rl_table_index; 
1645 
} 
1646 
} 
1647  
1648 
for (i = 0; i < 6; i++) { 
1649 
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1650 
{ 
1651 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1652 
return 1; 
1653 
} 
1654 
} 
1655 

1656 
return 0; 
1657 
} 
1658 
//#define ERROR_DETAILS

1659 
static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, 
1660 
int n, int coded, const uint8_t *scan_table) 
1661 
{ 
1662 
int level, i, last, run, run_diff;

1663 
int dc_pred_dir;

1664 
RLTable *rl; 
1665 
RL_VLC_ELEM *rl_vlc; 
1666 
int qmul, qadd;

1667  
1668 
if (s>mb_intra) {

1669 
qmul=1;

1670 
qadd=0;

1671  
1672 
/* DC coef */

1673 
set_stat(ST_DC); 
1674 
level = msmpeg4_decode_dc(s, n, &dc_pred_dir); 
1675 

1676 
if (level < 0){ 
1677 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow block: %d qscale: %d//\n", n, s>qscale);

1678 
if(s>inter_intra_pred) level=0; 
1679 
else return 1; 
1680 
} 
1681 
if (n < 4) { 
1682 
rl = &rl_table[s>rl_table_index]; 
1683 
if(level > 256*s>y_dc_scale){ 
1684 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s>qscale);

1685 
if(!s>inter_intra_pred) return 1; 
1686 
} 
1687 
} else {

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

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

1691 
if(!s>inter_intra_pred) return 1; 
1692 
} 
1693 
} 
1694 
block[0] = level;

1695  
1696 
run_diff = 0;

1697 
i = 0;

1698 
if (!coded) {

1699 
goto not_coded;

1700 
} 
1701 
if (s>ac_pred) {

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

1704 
else

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

1706 
} else {

1707 
scan_table = s>intra_scantable.permutated; 
1708 
} 
1709 
set_stat(ST_INTRA_AC); 
1710 
rl_vlc= rl>rl_vlc[0];

1711 
} else {

1712 
qmul = s>qscale << 1;

1713 
qadd = (s>qscale  1)  1; 
1714 
i = 1;

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

1716  
1717 
if(s>msmpeg4_version==2) 
1718 
run_diff = 0;

1719 
else

1720 
run_diff = 1;

1721  
1722 
if (!coded) {

1723 
s>block_last_index[n] = i; 
1724 
return 0; 
1725 
} 
1726 
if(!scan_table)

1727 
scan_table = s>inter_scantable.permutated; 
1728 
set_stat(ST_INTER_AC); 
1729 
rl_vlc= rl>rl_vlc[s>qscale]; 
1730 
} 
1731 
{ 
1732 
OPEN_READER(re, &s>gb); 
1733 
for(;;) {

1734 
UPDATE_CACHE(re, &s>gb); 
1735 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2);

1736 
if (level==0) { 
1737 
int cache;

1738 
cache= GET_CACHE(re, &s>gb); 
1739 
/* escape */

1740 
if (s>msmpeg4_version==1  (cache&0x80000000)==0) { 
1741 
if (s>msmpeg4_version==1  (cache&0x40000000)==0) { 
1742 
/* third escape */

1743 
if(s>msmpeg4_version!=1) LAST_SKIP_BITS(re, &s>gb, 2); 
1744 
UPDATE_CACHE(re, &s>gb); 
1745 
if(s>msmpeg4_version<=3){ 
1746 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
1747 
run= SHOW_UBITS(re, &s>gb, 6); SKIP_CACHE(re, &s>gb, 6); 
1748 
level= SHOW_SBITS(re, &s>gb, 8); LAST_SKIP_CACHE(re, &s>gb, 8); 
1749 
SKIP_COUNTER(re, &s>gb, 1+6+8); 
1750 
}else{

1751 
int sign;

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

1754 
int ll;

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

1756 
if(s>qscale<8){ 
1757 
ll= SHOW_UBITS(re, &s>gb, 3); SKIP_BITS(re, &s>gb, 3); 
1758 
if(ll==0){ 
1759 
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"); 
1760 
SKIP_BITS(re, &s>gb, 1);

1761 
ll=8;

1762 
} 
1763 
}else{

1764 
ll=2;

1765 
while(ll<8 && SHOW_UBITS(re, &s>gb, 1)==0){ 
1766 
ll++; 
1767 
SKIP_BITS(re, &s>gb, 1);

1768 
} 
1769 
if(ll<8) SKIP_BITS(re, &s>gb, 1); 
1770 
} 
1771  
1772 
s>esc3_level_length= ll; 
1773 
s>esc3_run_length= SHOW_UBITS(re, &s>gb, 2) + 3; SKIP_BITS(re, &s>gb, 2); 
1774 
//printf("level length:%d, run length: %d\n", ll, s>esc3_run_length);

1775 
UPDATE_CACHE(re, &s>gb); 
1776 
} 
1777 
run= SHOW_UBITS(re, &s>gb, s>esc3_run_length); 
1778 
SKIP_BITS(re, &s>gb, s>esc3_run_length); 
1779 

1780 
sign= SHOW_UBITS(re, &s>gb, 1);

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

1782 

1783 
level= SHOW_UBITS(re, &s>gb, s>esc3_level_length); 
1784 
SKIP_BITS(re, &s>gb, s>esc3_level_length); 
1785 
if(sign) level= level;

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

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

1789 
{

1790 
const int abs_level= ABS(level);

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

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

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

1794 
fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");

1795 
return DECODING_AC_LOST;

1796 
}

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

1798 
fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");

1799 
return DECODING_AC_LOST;

1800 
}

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

1802 
fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");

1803 
return DECODING_AC_LOST;

1804 
}

1805 
}

1806 
}

1807 
#endif

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

1809 
if (level>0) level= level * qmul + qadd; 
1810 
else level= level * qmul  qadd;

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

1812 
if(level>2048  level<2048){

1813 
fprintf(stderr, "level overflow in 3. esc\n");

1814 
return DECODING_AC_LOST;

1815 
}

1816 
#endif

1817 
i+= run + 1;

1818 
if(last) i+=192; 
1819 
#ifdef ERROR_DETAILS

1820 
if(run==66) 
1821 
fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);

1822 
else if((i>62 && i<192)  i>192+63) 
1823 
fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);

1824 
#endif

1825 
} else {

1826 
/* second escape */

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

1829 
UPDATE_CACHE(re, &s>gb); 
1830 
#else

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

1832 
#endif

1833 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2);

1834 
i+= run + rl>max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing 
1835 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1836 
LAST_SKIP_BITS(re, &s>gb, 1);

1837 
#ifdef ERROR_DETAILS

1838 
if(run==66) 
1839 
fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);

1840 
else if((i>62 && i<192)  i>192+63) 
1841 
fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);

1842 
#endif

1843 
} 
1844 
} else {

1845 
/* first escape */

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

1848 
UPDATE_CACHE(re, &s>gb); 
1849 
#else

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

1851 
#endif

1852 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2);

1853 
i+= run; 
1854 
level = level + rl>max_level[run>>7][(run1)&63] * qmul;//FIXME opt indexing 
1855 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1856 
LAST_SKIP_BITS(re, &s>gb, 1);

1857 
#ifdef ERROR_DETAILS

1858 
if(run==66) 
1859 
fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);

1860 
else if((i>62 && i<192)  i>192+63) 
1861 
fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);

1862 
#endif

1863 
} 
1864 
} else {

1865 
i+= run; 
1866 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1867 
LAST_SKIP_BITS(re, &s>gb, 1);

1868 
#ifdef ERROR_DETAILS

1869 
if(run==66) 
1870 
fprintf(stderr, "illegal vlc code level=%d\n", level);

1871 
else if((i>62 && i<192)  i>192+63) 
1872 
fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);

1873 
#endif

1874 
} 
1875 
if (i > 62){ 
1876 
i= 192;

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

1881 
break;

1882 
}else{

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

1884 
return 1; 
1885 
} 
1886 
} 
1887  
1888 
block[scan_table[i]] = level; 
1889 
break;

1890 
} 
1891  
1892 
block[scan_table[i]] = level; 
1893 
} 
1894 
CLOSE_READER(re, &s>gb); 
1895 
} 
1896 
not_coded:

1897 
if (s>mb_intra) {

1898 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
1899 
if (s>ac_pred) {

1900 
i = 63; /* XXX: not optimal */ 
1901 
} 
1902 
} 
1903 
if(s>msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize 
1904 
s>block_last_index[n] = i; 
1905 

1906 
return 0; 
1907 
} 
1908  
1909 
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
1910 
{ 
1911 
int level, pred;

1912  
1913 
if(s>msmpeg4_version<=2){ 
1914 
if (n < 4) { 
1915 
level = get_vlc2(&s>gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);

1916 
} else {

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

1918 
} 
1919 
if (level < 0) 
1920 
return 1; 
1921 
level=256;

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

1925 
} else {

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

1927 
} 
1928 
if (level < 0){ 
1929 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc vlc\n");

1930 
return 1; 
1931 
} 
1932  
1933 
if (level == DC_MAX) {

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

1935 
if (get_bits1(&s>gb))

1936 
level = level; 
1937 
} else if (level != 0) { 
1938 
if (get_bits1(&s>gb))

1939 
level = level; 
1940 
} 
1941 
} 
1942  
1943 
if(s>msmpeg4_version==1){ 
1944 
int32_t *dc_val; 
1945 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
1946 
level += pred; 
1947 

1948 
/* update predictor */

1949 
*dc_val= level; 
1950 
}else{

1951 
uint16_t *dc_val; 
1952 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
1953 
level += pred; 
1954  
1955 
/* update predictor */

1956 
if (n < 4) { 
1957 
*dc_val = level * s>y_dc_scale; 
1958 
} else {

1959 
*dc_val = level * s>c_dc_scale; 
1960 
} 
1961 
} 
1962  
1963 
return level;

1964 
} 
1965  
1966 
static int msmpeg4_decode_motion(MpegEncContext * s, 
1967 
int *mx_ptr, int *my_ptr) 
1968 
{ 
1969 
MVTable *mv; 
1970 
int code, mx, my;

1971  
1972 
mv = &mv_tables[s>mv_table_index]; 
1973  
1974 
code = get_vlc2(&s>gb, mv>vlc.table, MV_VLC_BITS, 2);

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

1977 
return 1; 
1978 
} 
1979 
if (code == mv>n) {

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

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

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

1983 
} else {

1984 
mx = mv>table_mvx[code]; 
1985 
my = mv>table_mvy[code]; 
1986 
} 
1987  
1988 
mx += *mx_ptr  32;

1989 
my += *my_ptr  32;

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

1991 
if (mx <= 64) 
1992 
mx += 64;

1993 
else if (mx >= 64) 
1994 
mx = 64;

1995  
1996 
if (my <= 64) 
1997 
my += 64;

1998 
else if (my >= 64) 
1999 
my = 64;

2000 
*mx_ptr = mx; 
2001 
*my_ptr = my; 
2002 
return 0; 
2003 
} 
2004  
2005 
/* cleanest way to support it

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

2007 
* as allmost everything would be in the common file

2008 
*/

2009 
#include "wmv2.c" 