ffmpeg / libavcodec / msmpeg4.c @ 2912e87a
History  View  Annotate  Download (61 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 
* msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>

7 
*

8 
* This file is part of Libav.

9 
*

10 
* Libav is free software; you can redistribute it and/or

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

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

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

14 
*

15 
* Libav is distributed in the hope that it will be useful,

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

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

18 
* Lesser General Public License for more details.

19 
*

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

21 
* License along with Libav; if not, write to the Free Software

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

23 
*/

24  
25 
/**

26 
* @file

27 
* MSMPEG4 backend for ffmpeg encoder and decoder.

28 
*/

29  
30 
#include "avcodec.h" 
31 
#include "dsputil.h" 
32 
#include "mpegvideo.h" 
33 
#include "msmpeg4.h" 
34 
#include "libavutil/x86_cpu.h" 
35 
#include "h263.h" 
36 
#include "mpeg4video.h" 
37  
38 
/*

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

40 
*

41 
* TODO:

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

43 
*  (encoding) select best vlc/dc table

44 
*/

45 
//#define DEBUG

46  
47 
#define DC_VLC_BITS 9 
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  
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 
/* vc1 externs */

63 
extern const uint8_t wmv3_dc_scale_table[32]; 
64  
65 
#ifdef DEBUG

66 
int frame_count = 0; 
67 
#endif

68  
69 
#include "msmpeg4data.h" 
70  
71 
#if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced 
72 
static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; 
73 
#endif //CONFIG_ENCODERS 
74  
75 
static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3]; 
76  
77 
/* This table is practically identical to the one from h263

78 
* except that it is inverted. */

79 
static av_cold void init_h263_dc_for_msmpeg4(void) 
80 
{ 
81 
int level, uni_code, uni_len;

82  
83 
for(level=256; level<256; level++){ 
84 
int size, v, l;

85 
/* find number of bits */

86 
size = 0;

87 
v = abs(level); 
88 
while (v) {

89 
v >>= 1;

90 
size++; 
91 
} 
92  
93 
if (level < 0) 
94 
l= (level) ^ ((1 << size)  1); 
95 
else

96 
l= level; 
97  
98 
/* luminance h263 */

99 
uni_code= ff_mpeg4_DCtab_lum[size][0];

100 
uni_len = ff_mpeg4_DCtab_lum[size][1];

101 
uni_code ^= (1<<uni_len)1; //M$ does not like compatibility 
102  
103 
if (size > 0) { 
104 
uni_code<<=size; uni_code=l; 
105 
uni_len+=size; 
106 
if (size > 8){ 
107 
uni_code<<=1; uni_code=1; 
108 
uni_len++; 
109 
} 
110 
} 
111 
v2_dc_lum_table[level+256][0]= uni_code; 
112 
v2_dc_lum_table[level+256][1]= uni_len; 
113  
114 
/* chrominance h263 */

115 
uni_code= ff_mpeg4_DCtab_chrom[size][0];

116 
uni_len = ff_mpeg4_DCtab_chrom[size][1];

117 
uni_code ^= (1<<uni_len)1; //M$ does not like compatibility 
118  
119 
if (size > 0) { 
120 
uni_code<<=size; uni_code=l; 
121 
uni_len+=size; 
122 
if (size > 8){ 
123 
uni_code<<=1; uni_code=1; 
124 
uni_len++; 
125 
} 
126 
} 
127 
v2_dc_chroma_table[level+256][0]= uni_code; 
128 
v2_dc_chroma_table[level+256][1]= uni_len; 
129  
130 
} 
131 
} 
132  
133 
static av_cold void common_init(MpegEncContext * s) 
134 
{ 
135 
static int initialized=0; 
136  
137 
switch(s>msmpeg4_version){

138 
case 1: 
139 
case 2: 
140 
s>y_dc_scale_table= 
141 
s>c_dc_scale_table= ff_mpeg1_dc_scale_table; 
142 
break;

143 
case 3: 
144 
if(s>workaround_bugs){

145 
s>y_dc_scale_table= old_ff_y_dc_scale_table; 
146 
s>c_dc_scale_table= wmv1_c_dc_scale_table; 
147 
} else{

148 
s>y_dc_scale_table= ff_mpeg4_y_dc_scale_table; 
149 
s>c_dc_scale_table= ff_mpeg4_c_dc_scale_table; 
150 
} 
151 
break;

152 
case 4: 
153 
case 5: 
154 
s>y_dc_scale_table= wmv1_y_dc_scale_table; 
155 
s>c_dc_scale_table= wmv1_c_dc_scale_table; 
156 
break;

157 
#if CONFIG_VC1_DECODER

158 
case 6: 
159 
s>y_dc_scale_table= wmv3_dc_scale_table; 
160 
s>c_dc_scale_table= wmv3_dc_scale_table; 
161 
break;

162 
#endif

163  
164 
} 
165  
166  
167 
if(s>msmpeg4_version>=4){ 
168 
ff_init_scantable(s>dsp.idct_permutation, &s>intra_scantable , wmv1_scantable[1]);

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

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

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

172 
} 
173 
//Note the default tables are set in common_init in mpegvideo.c

174  
175 
if(!initialized){

176 
initialized=1;

177  
178 
init_h263_dc_for_msmpeg4(); 
179 
} 
180 
} 
181  
182 
#if CONFIG_ENCODERS

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

185 
static void init_mv_table(MVTable *tab) 
186 
{ 
187 
int i, x, y;

188  
189 
tab>table_mv_index = av_malloc(sizeof(uint16_t) * 4096); 
190 
/* mark all entries as not used */

191 
for(i=0;i<4096;i++) 
192 
tab>table_mv_index[i] = tab>n; 
193  
194 
for(i=0;i<tab>n;i++) { 
195 
x = tab>table_mvx[i]; 
196 
y = tab>table_mvy[i]; 
197 
tab>table_mv_index[(x << 6)  y] = i;

198 
} 
199 
} 
200  
201 
void ff_msmpeg4_code012(PutBitContext *pb, int n) 
202 
{ 
203 
if (n == 0) { 
204 
put_bits(pb, 1, 0); 
205 
} else {

206 
put_bits(pb, 1, 1); 
207 
put_bits(pb, 1, (n >= 2)); 
208 
} 
209 
} 
210  
211 
static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ 
212 
int size=0; 
213 
int code;

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

218 
if (code == rl>n) {

219 
int level1, run1;

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

224 
code = get_rl_index(rl, last, run, level1); 
225 
if (code == rl>n) {

226 
esc2:

227 
size++; 
228 
if (level > MAX_LEVEL)

229 
goto esc3;

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

233 
code = get_rl_index(rl, last, run1, level); 
234 
if (code == rl>n) {

235 
esc3:

236 
/* third escape */

237 
size+=1+1+6+8; 
238 
} else {

239 
/* second escape */

240 
size+= 1+1+ rl>table_vlc[code][1]; 
241 
} 
242 
} else {

243 
/* first escape */

244 
size+= 1+1+ rl>table_vlc[code][1]; 
245 
} 
246 
} else {

247 
size++; 
248 
} 
249 
return size;

250 
} 
251  
252 
av_cold void ff_msmpeg4_encode_init(MpegEncContext *s)

253 
{ 
254 
static int init_done=0; 
255 
int i;

256  
257 
common_init(s); 
258 
if(s>msmpeg4_version>=4){ 
259 
s>min_qcoeff= 255;

260 
s>max_qcoeff= 255;

261 
} 
262  
263 
if (!init_done) {

264 
/* init various encoding tables */

265 
init_done = 1;

266 
init_mv_table(&mv_tables[0]);

267 
init_mv_table(&mv_tables[1]);

268 
for(i=0;i<NB_RL_TABLES;i++) 
269 
init_rl(&rl_table[i], static_rl_table_store[i]); 
270  
271 
for(i=0; i<NB_RL_TABLES; i++){ 
272 
int level;

273 
for(level=0; level<=MAX_LEVEL; level++){ 
274 
int run;

275 
for(run=0; run<=MAX_RUN; run++){ 
276 
int last;

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

279 
} 
280 
} 
281 
} 
282 
} 
283 
} 
284 
} 
285  
286 
static void find_best_tables(MpegEncContext * s) 
287 
{ 
288 
int i;

289 
int best =1, best_size =9999999; 
290 
int chroma_best=1, best_chroma_size=9999999; 
291  
292 
for(i=0; i<3; i++){ 
293 
int level;

294 
int chroma_size=0; 
295 
int size=0; 
296  
297 
if(i>0){// ;) 
298 
size++; 
299 
chroma_size++; 
300 
} 
301 
for(level=0; level<=MAX_LEVEL; level++){ 
302 
int run;

303 
for(run=0; run<=MAX_RUN; run++){ 
304 
int last;

305 
const int last_size= size + chroma_size; 
306 
for(last=0; last<2; last++){ 
307 
int inter_count = s>ac_stats[0][0][level][run][last] + s>ac_stats[0][1][level][run][last]; 
308 
int intra_luma_count = s>ac_stats[1][0][level][run][last]; 
309 
int intra_chroma_count= s>ac_stats[1][1][level][run][last]; 
310  
311 
if(s>pict_type==FF_I_TYPE){

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

314 
}else{

315 
size+= intra_luma_count *rl_length[i ][level][run][last] 
316 
+intra_chroma_count*rl_length[i+3][level][run][last]

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

318 
} 
319 
} 
320 
if(last_size == size+chroma_size) break; 
321 
} 
322 
} 
323 
if(size<best_size){

324 
best_size= size; 
325 
best= i; 
326 
} 
327 
if(chroma_size<best_chroma_size){

328 
best_chroma_size= chroma_size; 
329 
chroma_best= i; 
330 
} 
331 
} 
332  
333 
// printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",

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

335  
336 
if(s>pict_type==FF_P_TYPE) chroma_best= best;

337  
338 
memset(s>ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); 
339  
340 
s>rl_table_index = best; 
341 
s>rl_chroma_table_index= chroma_best; 
342  
343 
if(s>pict_type != s>last_non_b_pict_type){

344 
s>rl_table_index= 2;

345 
if(s>pict_type==FF_I_TYPE)

346 
s>rl_chroma_table_index= 1;

347 
else

348 
s>rl_chroma_table_index= 2;

349 
} 
350  
351 
} 
352  
353 
/* write MSMPEG4 compatible frame header */

354 
void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) 
355 
{ 
356 
find_best_tables(s); 
357  
358 
align_put_bits(&s>pb); 
359 
put_bits(&s>pb, 2, s>pict_type  1); 
360  
361 
put_bits(&s>pb, 5, s>qscale);

362 
if(s>msmpeg4_version<=2){ 
363 
s>rl_table_index = 2;

364 
s>rl_chroma_table_index = 2;

365 
} 
366  
367 
s>dc_table_index = 1;

368 
s>mv_table_index = 1; /* only if P frame */ 
369 
s>use_skip_mb_code = 1; /* only if P frame */ 
370 
s>per_mb_rl_table = 0;

371 
if(s>msmpeg4_version==4) 
372 
s>inter_intra_pred= (s>width*s>height < 320*240 && s>bit_rate<=II_BITRATE && s>pict_type==FF_P_TYPE); 
373 
//printf("%d %d %d %d %d\n", s>pict_type, s>bit_rate, s>inter_intra_pred, s>width, s>height);

374  
375 
if (s>pict_type == FF_I_TYPE) {

376 
s>slice_height= s>mb_height/1;

377 
put_bits(&s>pb, 5, 0x16 + s>mb_height/s>slice_height); 
378  
379 
if(s>msmpeg4_version==4){ 
380 
msmpeg4_encode_ext_header(s); 
381 
if(s>bit_rate>MBAC_BITRATE)

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

383 
} 
384  
385 
if(s>msmpeg4_version>2){ 
386 
if(!s>per_mb_rl_table){

387 
ff_msmpeg4_code012(&s>pb, s>rl_chroma_table_index); 
388 
ff_msmpeg4_code012(&s>pb, s>rl_table_index); 
389 
} 
390  
391 
put_bits(&s>pb, 1, s>dc_table_index);

392 
} 
393 
} else {

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

395  
396 
if(s>msmpeg4_version==4 && s>bit_rate>MBAC_BITRATE) 
397 
put_bits(&s>pb, 1, s>per_mb_rl_table);

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

401 
ff_msmpeg4_code012(&s>pb, s>rl_table_index); 
402  
403 
put_bits(&s>pb, 1, s>dc_table_index);

404  
405 
put_bits(&s>pb, 1, s>mv_table_index);

406 
} 
407 
} 
408  
409 
s>esc3_level_length= 0;

410 
s>esc3_run_length= 0;

411 
} 
412  
413 
void msmpeg4_encode_ext_header(MpegEncContext * s)

414 
{ 
415 
put_bits(&s>pb, 5, s>avctx>time_base.den / s>avctx>time_base.num); //yes 29.97 > 29 
416  
417 
put_bits(&s>pb, 11, FFMIN(s>bit_rate/1024, 2047)); 
418  
419 
if(s>msmpeg4_version>=3) 
420 
put_bits(&s>pb, 1, s>flipflop_rounding);

421 
else

422 
assert(s>flipflop_rounding==0);

423 
} 
424  
425 
#endif //CONFIG_ENCODERS 
426  
427 
/* predict coded block */

428 
int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) 
429 
{ 
430 
int xy, wrap, pred, a, b, c;

431  
432 
xy = s>block_index[n]; 
433 
wrap = s>b8_stride; 
434  
435 
/* B C

436 
* A X

437 
*/

438 
a = s>coded_block[xy  1 ];

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

440 
c = s>coded_block[xy  wrap]; 
441  
442 
if (b == c) {

443 
pred = a; 
444 
} else {

445 
pred = c; 
446 
} 
447  
448 
/* store value */

449 
*coded_block_ptr = &s>coded_block[xy]; 
450  
451 
return pred;

452 
} 
453  
454 
#if CONFIG_ENCODERS

455  
456 
void ff_msmpeg4_encode_motion(MpegEncContext * s,

457 
int mx, int my) 
458 
{ 
459 
int code;

460 
MVTable *mv; 
461  
462 
/* modulo encoding */

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

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

465 
if (mx <= 64) 
466 
mx += 64;

467 
else if (mx >= 64) 
468 
mx = 64;

469 
if (my <= 64) 
470 
my += 64;

471 
else if (my >= 64) 
472 
my = 64;

473  
474 
mx += 32;

475 
my += 32;

476 
#if 0

477 
if ((unsigned)mx >= 64 

478 
(unsigned)my >= 64)

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

480 
#endif

481 
mv = &mv_tables[s>mv_table_index]; 
482  
483 
code = mv>table_mv_index[(mx << 6)  my];

484 
put_bits(&s>pb, 
485 
mv>table_mv_bits[code], 
486 
mv>table_mv_code[code]); 
487 
if (code == mv>n) {

488 
/* escape : code literally */

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

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

491 
} 
492 
} 
493  
494 
void ff_msmpeg4_handle_slices(MpegEncContext *s){

495 
if (s>mb_x == 0) { 
496 
if (s>slice_height && (s>mb_y % s>slice_height) == 0) { 
497 
if(s>msmpeg4_version < 4){ 
498 
ff_mpeg4_clean_buffers(s); 
499 
} 
500 
s>first_slice_line = 1;

501 
} else {

502 
s>first_slice_line = 0;

503 
} 
504 
} 
505 
} 
506  
507 
static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) 
508 
{ 
509 
int range, bit_size, sign, code, bits;

510  
511 
if (val == 0) { 
512 
/* zero vector */

513 
code = 0;

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

516 
bit_size = s>f_code  1;

517 
range = 1 << bit_size;

518 
if (val <= 64) 
519 
val += 64;

520 
else if (val >= 64) 
521 
val = 64;

522  
523 
if (val >= 0) { 
524 
sign = 0;

525 
} else {

526 
val = val; 
527 
sign = 1;

528 
} 
529 
val; 
530 
code = (val >> bit_size) + 1;

531 
bits = val & (range  1);

532  
533 
put_bits(&s>pb, mvtab[code][1] + 1, (mvtab[code][0] << 1)  sign); 
534 
if (bit_size > 0) { 
535 
put_bits(&s>pb, bit_size, bits); 
536 
} 
537 
} 
538 
} 
539  
540 
void msmpeg4_encode_mb(MpegEncContext * s,

541 
DCTELEM block[6][64], 
542 
int motion_x, int motion_y) 
543 
{ 
544 
int cbp, coded_cbp, i;

545 
int pred_x, pred_y;

546 
uint8_t *coded_block; 
547  
548 
ff_msmpeg4_handle_slices(s); 
549  
550 
if (!s>mb_intra) {

551 
/* compute cbp */

552 
cbp = 0;

553 
for (i = 0; i < 6; i++) { 
554 
if (s>block_last_index[i] >= 0) 
555 
cbp = 1 << (5  i); 
556 
} 
557 
if (s>use_skip_mb_code && (cbp  motion_x  motion_y) == 0) { 
558 
/* skip macroblock */

559 
put_bits(&s>pb, 1, 1); 
560 
s>last_bits++; 
561 
s>misc_bits++; 
562 
s>skip_count++; 
563  
564 
return;

565 
} 
566 
if (s>use_skip_mb_code)

567 
put_bits(&s>pb, 1, 0); /* mb coded */ 
568  
569 
if(s>msmpeg4_version<=2){ 
570 
put_bits(&s>pb, 
571 
v2_mb_type[cbp&3][1], 
572 
v2_mb_type[cbp&3][0]); 
573 
if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; 
574 
else coded_cbp= cbp;

575  
576 
put_bits(&s>pb, 
577 
ff_h263_cbpy_tab[coded_cbp>>2][1], 
578 
ff_h263_cbpy_tab[coded_cbp>>2][0]); 
579  
580 
s>misc_bits += get_bits_diff(s); 
581  
582 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
583 
msmpeg4v2_encode_motion(s, motion_x  pred_x); 
584 
msmpeg4v2_encode_motion(s, motion_y  pred_y); 
585 
}else{

586 
put_bits(&s>pb, 
587 
table_mb_non_intra[cbp + 64][1], 
588 
table_mb_non_intra[cbp + 64][0]); 
589  
590 
s>misc_bits += get_bits_diff(s); 
591  
592 
/* motion vector */

593 
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); 
594 
ff_msmpeg4_encode_motion(s, motion_x  pred_x, 
595 
motion_y  pred_y); 
596 
} 
597  
598 
s>mv_bits += get_bits_diff(s); 
599  
600 
for (i = 0; i < 6; i++) { 
601 
ff_msmpeg4_encode_block(s, block[i], i); 
602 
} 
603 
s>p_tex_bits += get_bits_diff(s); 
604 
} else {

605 
/* compute cbp */

606 
cbp = 0;

607 
coded_cbp = 0;

608 
for (i = 0; i < 6; i++) { 
609 
int val, pred;

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

611 
cbp = val << (5  i);

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

614 
pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block); 
615 
*coded_block = val; 
616 
val = val ^ pred; 
617 
} 
618 
coded_cbp = val << (5  i);

619 
} 
620 
#if 0

621 
if (coded_cbp)

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

623 
#endif

624  
625 
if(s>msmpeg4_version<=2){ 
626 
if (s>pict_type == FF_I_TYPE) {

627 
put_bits(&s>pb, 
628 
v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); 
629 
} else {

630 
if (s>use_skip_mb_code)

631 
put_bits(&s>pb, 1, 0); /* mb coded */ 
632 
put_bits(&s>pb, 
633 
v2_mb_type[(cbp&3) + 4][1], 
634 
v2_mb_type[(cbp&3) + 4][0]); 
635 
} 
636 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
637 
put_bits(&s>pb, 
638 
ff_h263_cbpy_tab[cbp>>2][1], 
639 
ff_h263_cbpy_tab[cbp>>2][0]); 
640 
}else{

641 
if (s>pict_type == FF_I_TYPE) {

642 
put_bits(&s>pb, 
643 
ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); 
644 
} else {

645 
if (s>use_skip_mb_code)

646 
put_bits(&s>pb, 1, 0); /* mb coded */ 
647 
put_bits(&s>pb, 
648 
table_mb_non_intra[cbp][1],

649 
table_mb_non_intra[cbp][0]);

650 
} 
651 
put_bits(&s>pb, 1, 0); /* no AC prediction yet */ 
652 
if(s>inter_intra_pred){

653 
s>h263_aic_dir=0;

654 
put_bits(&s>pb, table_inter_intra[s>h263_aic_dir][1], table_inter_intra[s>h263_aic_dir][0]); 
655 
} 
656 
} 
657 
s>misc_bits += get_bits_diff(s); 
658  
659 
for (i = 0; i < 6; i++) { 
660 
ff_msmpeg4_encode_block(s, block[i], i); 
661 
} 
662 
s>i_tex_bits += get_bits_diff(s); 
663 
s>i_count++; 
664 
} 
665 
} 
666  
667 
#endif //CONFIG_ENCODERS 
668  
669 
static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, 
670 
int32_t **dc_val_ptr) 
671 
{ 
672 
int i;

673  
674 
if (n < 4) { 
675 
i= 0;

676 
} else {

677 
i= n3;

678 
} 
679  
680 
*dc_val_ptr= &s>last_dc[i]; 
681 
return s>last_dc[i];

682 
} 
683  
684 
static int get_dc(uint8_t *src, int stride, int scale) 
685 
{ 
686 
int y;

687 
int sum=0; 
688 
for(y=0; y<8; y++){ 
689 
int x;

690 
for(x=0; x<8; x++){ 
691 
sum+=src[x + y*stride]; 
692 
} 
693 
} 
694 
return FASTDIV((sum + (scale>>1)), scale); 
695 
} 
696  
697 
/* dir = 0: left, dir = 1: top prediction */

698 
static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, 
699 
int16_t **dc_val_ptr, int *dir_ptr)

700 
{ 
701 
int a, b, c, wrap, pred, scale;

702 
int16_t *dc_val; 
703  
704 
/* find prediction */

705 
if (n < 4) { 
706 
scale = s>y_dc_scale; 
707 
} else {

708 
scale = s>c_dc_scale; 
709 
} 
710  
711 
wrap = s>block_wrap[n]; 
712 
dc_val= s>dc_val[0] + s>block_index[n];

713  
714 
/* B C

715 
* A X

716 
*/

717 
a = dc_val[  1];

718 
b = dc_val[  1  wrap];

719 
c = dc_val[  wrap]; 
720  
721 
if(s>first_slice_line && (n&2)==0 && s>msmpeg4_version<4){ 
722 
b=c=1024;

723 
} 
724  
725 
/* XXX: the following solution consumes divisions, but it does not

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

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

728 
to problems if Q could vary !) */

729 
#if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE

730 
__asm__ volatile(

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

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

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

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

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

736 
"mull %4 \n\t"

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

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

739 
"mull %4 \n\t"

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

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

742 
"mull %4 \n\t"

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

744 
: "+b" (a), "+c" (b), "+D" (c) 
745 
: "g" (scale), "S" (ff_inverse[scale]) 
746 
: "%eax", "%edx" 
747 
); 
748 
#else

749 
/* #elif ARCH_ALPHA */

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

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

752 
*/

753 
if (scale == 8) { 
754 
a = (a + (8 >> 1)) / 8; 
755 
b = (b + (8 >> 1)) / 8; 
756 
c = (c + (8 >> 1)) / 8; 
757 
} else {

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

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

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

761 
} 
762 
#endif

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

764 
is very important ! */

765 
if(s>msmpeg4_version>3){ 
766 
if(s>inter_intra_pred){

767 
uint8_t *dest; 
768 
int wrap;

769  
770 
if(n==1){ 
771 
pred=a; 
772 
*dir_ptr = 0;

773 
}else if(n==2){ 
774 
pred=c; 
775 
*dir_ptr = 1;

776 
}else if(n==3){ 
777 
if (abs(a  b) < abs(b  c)) {

778 
pred = c; 
779 
*dir_ptr = 1;

780 
} else {

781 
pred = a; 
782 
*dir_ptr = 0;

783 
} 
784 
}else{

785 
if(n<4){ 
786 
wrap= s>linesize; 
787 
dest= s>current_picture.data[0] + (((n>>1) + 2*s>mb_y) * 8* wrap ) + ((n&1) + 2*s>mb_x) * 8; 
788 
}else{

789 
wrap= s>uvlinesize; 
790 
dest= s>current_picture.data[n3] + (s>mb_y * 8 * wrap) + s>mb_x * 8; 
791 
} 
792 
if(s>mb_x==0) a= (1024 + (scale>>1))/scale; 
793 
else a= get_dc(dest8, wrap, scale*8); 
794 
if(s>mb_y==0) c= (1024 + (scale>>1))/scale; 
795 
else c= get_dc(dest8*wrap, wrap, scale*8); 
796  
797 
if (s>h263_aic_dir==0) { 
798 
pred= a; 
799 
*dir_ptr = 0;

800 
}else if (s>h263_aic_dir==1) { 
801 
if(n==0){ 
802 
pred= c; 
803 
*dir_ptr = 1;

804 
}else{

805 
pred= a; 
806 
*dir_ptr = 0;

807 
} 
808 
}else if (s>h263_aic_dir==2) { 
809 
if(n==0){ 
810 
pred= a; 
811 
*dir_ptr = 0;

812 
}else{

813 
pred= c; 
814 
*dir_ptr = 1;

815 
} 
816 
} else {

817 
pred= c; 
818 
*dir_ptr = 1;

819 
} 
820 
} 
821 
}else{

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

823 
pred = c; 
824 
*dir_ptr = 1;

825 
} else {

826 
pred = a; 
827 
*dir_ptr = 0;

828 
} 
829 
} 
830 
}else{

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

832 
pred = c; 
833 
*dir_ptr = 1;

834 
} else {

835 
pred = a; 
836 
*dir_ptr = 0;

837 
} 
838 
} 
839  
840 
/* update predictor */

841 
*dc_val_ptr = &dc_val[0];

842 
return pred;

843 
} 
844  
845 
#define DC_MAX 119 
846  
847 
static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) 
848 
{ 
849 
int sign, code;

850 
int pred, extquant;

851 
int extrabits = 0; 
852  
853 
if(s>msmpeg4_version==1){ 
854 
int32_t *dc_val; 
855 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
856  
857 
/* update predictor */

858 
*dc_val= level; 
859 
}else{

860 
int16_t *dc_val; 
861 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
862  
863 
/* update predictor */

864 
if (n < 4) { 
865 
*dc_val = level * s>y_dc_scale; 
866 
} else {

867 
*dc_val = level * s>c_dc_scale; 
868 
} 
869 
} 
870  
871 
/* do the prediction */

872 
level = pred; 
873  
874 
if(s>msmpeg4_version<=2){ 
875 
if (n < 4) { 
876 
put_bits(&s>pb, 
877 
v2_dc_lum_table[level+256][1], 
878 
v2_dc_lum_table[level+256][0]); 
879 
}else{

880 
put_bits(&s>pb, 
881 
v2_dc_chroma_table[level+256][1], 
882 
v2_dc_chroma_table[level+256][0]); 
883 
} 
884 
}else{

885 
sign = 0;

886 
if (level < 0) { 
887 
level = level; 
888 
sign = 1;

889 
} 
890 
code = level; 
891 
if (code > DC_MAX)

892 
code = DC_MAX; 
893 
else if( s>msmpeg4_version>=6 ) { 
894 
if( s>qscale == 1 ) { 
895 
extquant = (level + 3) & 0x3; 
896 
code = ((level+3)>>2); 
897 
} else if( s>qscale == 2 ) { 
898 
extquant = (level + 1) & 0x1; 
899 
code = ((level+1)>>1); 
900 
} 
901 
} 
902  
903 
if (s>dc_table_index == 0) { 
904 
if (n < 4) { 
905 
put_bits(&s>pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]); 
906 
} else {

907 
put_bits(&s>pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]); 
908 
} 
909 
} else {

910 
if (n < 4) { 
911 
put_bits(&s>pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]); 
912 
} else {

913 
put_bits(&s>pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]); 
914 
} 
915 
} 
916  
917 
if(s>msmpeg4_version>=6 && s>qscale<=2) 
918 
extrabits = 3  s>qscale;

919  
920 
if (code == DC_MAX)

921 
put_bits(&s>pb, 8 + extrabits, level);

922 
else if(extrabits > 0)//== VC1 && s>qscale<=2 
923 
put_bits(&s>pb, extrabits, extquant); 
924  
925 
if (level != 0) { 
926 
put_bits(&s>pb, 1, sign);

927 
} 
928 
} 
929 
} 
930  
931 
/* Encoding of a block. Very similar to MPEG4 except for a different

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

933 
*/

934 
void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) 
935 
{ 
936 
int level, run, last, i, j, last_index;

937 
int last_non_zero, sign, slevel;

938 
int code, run_diff, dc_pred_dir;

939 
const RLTable *rl;

940 
const uint8_t *scantable;

941  
942 
if (s>mb_intra) {

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

944 
i = 1;

945 
if (n < 4) { 
946 
rl = &rl_table[s>rl_table_index]; 
947 
} else {

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

949 
} 
950 
run_diff = s>msmpeg4_version>=4;

951 
scantable= s>intra_scantable.permutated; 
952 
} else {

953 
i = 0;

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

955 
if(s>msmpeg4_version<=2) 
956 
run_diff = 0;

957 
else

958 
run_diff = 1;

959 
scantable= s>inter_scantable.permutated; 
960 
} 
961  
962 
/* recalculate block_last_index for M$ wmv1 */

963 
if(s>msmpeg4_version>=4 && s>msmpeg4_version<6 && s>block_last_index[n]>0){ 
964 
for(last_index=63; last_index>=0; last_index){ 
965 
if(block[scantable[last_index]]) break; 
966 
} 
967 
s>block_last_index[n]= last_index; 
968 
}else

969 
last_index = s>block_last_index[n]; 
970 
/* AC coefs */

971 
last_non_zero = i  1;

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

973 
j = scantable[i]; 
974 
level = block[j]; 
975 
if (level) {

976 
run = i  last_non_zero  1;

977 
last = (i == last_index); 
978 
sign = 0;

979 
slevel = level; 
980 
if (level < 0) { 
981 
sign = 1;

982 
level = level; 
983 
} 
984  
985 
if(level<=MAX_LEVEL && run<=MAX_RUN){

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

987 
} 
988 
#if 0

989 
else

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

991 
#endif

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

995 
int level1, run1;

996  
997 
level1 = level  rl>max_level[last][run]; 
998 
if (level1 < 1) 
999 
goto esc2;

1000 
code = get_rl_index(rl, last, run, level1); 
1001 
if (code == rl>n) {

1002 
esc2:

1003 
put_bits(&s>pb, 1, 0); 
1004 
if (level > MAX_LEVEL)

1005 
goto esc3;

1006 
run1 = run  rl>max_run[last][level]  run_diff; 
1007 
if (run1 < 0) 
1008 
goto esc3;

1009 
code = get_rl_index(rl, last, run1+1, level);

1010 
if (s>msmpeg4_version == 4 && code == rl>n) 
1011 
goto esc3;

1012 
code = get_rl_index(rl, last, run1, level); 
1013 
if (code == rl>n) {

1014 
esc3:

1015 
/* third escape */

1016 
put_bits(&s>pb, 1, 0); 
1017 
put_bits(&s>pb, 1, last);

1018 
if(s>msmpeg4_version>=4){ 
1019 
if(s>esc3_level_length==0){ 
1020 
s>esc3_level_length=8;

1021 
s>esc3_run_length= 6;

1022 
//ESCLVLSZ + ESCRUNSZ

1023 
if(s>qscale<8) 
1024 
put_bits(&s>pb, 6 + (s>msmpeg4_version>=6), 3); 
1025 
else

1026 
put_bits(&s>pb, 8, 3); 
1027 
} 
1028 
put_bits(&s>pb, s>esc3_run_length, run); 
1029 
put_bits(&s>pb, 1, sign);

1030 
put_bits(&s>pb, s>esc3_level_length, level); 
1031 
}else{

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

1033 
put_sbits(&s>pb, 8, slevel);

1034 
} 
1035 
} else {

1036 
/* second escape */

1037 
put_bits(&s>pb, 1, 1); 
1038 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1039 
put_bits(&s>pb, 1, sign);

1040 
} 
1041 
} else {

1042 
/* first escape */

1043 
put_bits(&s>pb, 1, 1); 
1044 
put_bits(&s>pb, rl>table_vlc[code][1], rl>table_vlc[code][0]); 
1045 
put_bits(&s>pb, 1, sign);

1046 
} 
1047 
} else {

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

1049 
} 
1050 
last_non_zero = i; 
1051 
} 
1052 
} 
1053 
} 
1054  
1055 
/****************************************/

1056 
/* decoding stuff */

1057  
1058 
VLC ff_mb_non_intra_vlc[4];

1059 
static VLC v2_dc_lum_vlc;

1060 
static VLC v2_dc_chroma_vlc;

1061 
static VLC v2_intra_cbpc_vlc;

1062 
static VLC v2_mb_type_vlc;

1063 
static VLC v2_mv_vlc;

1064 
VLC ff_inter_intra_vlc; 
1065  
1066 
/* This is identical to h263 except that its range is multiplied by 2. */

1067 
static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) 
1068 
{ 
1069 
int code, val, sign, shift;

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

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

1073 
if (code < 0) 
1074 
return 0xffff; 
1075  
1076 
if (code == 0) 
1077 
return pred;

1078 
sign = get_bits1(&s>gb); 
1079 
shift = f_code  1;

1080 
val = code; 
1081 
if (shift) {

1082 
val = (val  1) << shift;

1083 
val = get_bits(&s>gb, shift); 
1084 
val++; 
1085 
} 
1086 
if (sign)

1087 
val = val; 
1088  
1089 
val += pred; 
1090 
if (val <= 64) 
1091 
val += 64;

1092 
else if (val >= 64) 
1093 
val = 64;

1094  
1095 
return val;

1096 
} 
1097  
1098 
static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1099 
{ 
1100 
int cbp, code, i;

1101  
1102 
if (s>pict_type == FF_P_TYPE) {

1103 
if (s>use_skip_mb_code) {

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

1105 
/* skip mb */

1106 
s>mb_intra = 0;

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

1109 
s>mv_dir = MV_DIR_FORWARD; 
1110 
s>mv_type = MV_TYPE_16X16; 
1111 
s>mv[0][0][0] = 0; 
1112 
s>mv[0][0][1] = 0; 
1113 
s>mb_skipped = 1;

1114 
return 0; 
1115 
} 
1116 
} 
1117  
1118 
if(s>msmpeg4_version==2) 
1119 
code = get_vlc2(&s>gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);

1120 
else

1121 
code = get_vlc2(&s>gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);

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

1124 
return 1; 
1125 
} 
1126  
1127 
s>mb_intra = code >>2;

1128  
1129 
cbp = code & 0x3;

1130 
} else {

1131 
s>mb_intra = 1;

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

1134 
else

1135 
cbp= get_vlc2(&s>gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);

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

1138 
return 1; 
1139 
} 
1140 
} 
1141  
1142 
if (!s>mb_intra) {

1143 
int mx, my, cbpy;

1144  
1145 
cbpy= get_vlc2(&s>gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);

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

1148 
return 1; 
1149 
} 
1150  
1151 
cbp= cbpy<<2;

1152 
if(s>msmpeg4_version==1  (cbp&3) != 3) cbp^= 0x3C; 
1153  
1154 
h263_pred_motion(s, 0, 0, &mx, &my); 
1155 
mx= msmpeg4v2_decode_motion(s, mx, 1);

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

1157  
1158 
s>mv_dir = MV_DIR_FORWARD; 
1159 
s>mv_type = MV_TYPE_16X16; 
1160 
s>mv[0][0][0] = mx; 
1161 
s>mv[0][0][1] = my; 
1162 
} else {

1163 
if(s>msmpeg4_version==2){ 
1164 
s>ac_pred = get_bits1(&s>gb); 
1165 
cbp= get_vlc2(&s>gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1166 
} else{

1167 
s>ac_pred = 0;

1168 
cbp= get_vlc2(&s>gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors 
1169 
if(s>pict_type==FF_P_TYPE) cbp^=0x3C; 
1170 
} 
1171 
} 
1172  
1173 
s>dsp.clear_blocks(s>block[0]);

1174 
for (i = 0; i < 6; i++) { 
1175 
if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1176 
{ 
1177 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1178 
return 1; 
1179 
} 
1180 
} 
1181 
return 0; 
1182 
} 
1183  
1184 
static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) 
1185 
{ 
1186 
int cbp, code, i;

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

1189  
1190 
if (s>pict_type == FF_P_TYPE) {

1191 
if (s>use_skip_mb_code) {

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

1193 
/* skip mb */

1194 
s>mb_intra = 0;

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

1197 
s>mv_dir = MV_DIR_FORWARD; 
1198 
s>mv_type = MV_TYPE_16X16; 
1199 
s>mv[0][0][0] = 0; 
1200 
s>mv[0][0][1] = 0; 
1201 
s>mb_skipped = 1;

1202 
*mb_type_ptr = MB_TYPE_SKIP  MB_TYPE_L0  MB_TYPE_16x16; 
1203  
1204 
return 0; 
1205 
} 
1206 
} 
1207  
1208 
code = get_vlc2(&s>gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);

1209 
if (code < 0) 
1210 
return 1; 
1211 
//s>mb_intra = (code & 0x40) ? 0 : 1;

1212 
s>mb_intra = (~code & 0x40) >> 6; 
1213  
1214 
cbp = code & 0x3f;

1215 
} else {

1216 
s>mb_intra = 1;

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

1218 
if (code < 0) 
1219 
return 1; 
1220 
/* predict coded block pattern */

1221 
cbp = 0;

1222 
for(i=0;i<6;i++) { 
1223 
int val = ((code >> (5  i)) & 1); 
1224 
if (i < 4) { 
1225 
int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);

1226 
val = val ^ pred; 
1227 
*coded_val = val; 
1228 
} 
1229 
cbp = val << (5  i);

1230 
} 
1231 
} 
1232  
1233 
if (!s>mb_intra) {

1234 
int mx, my;

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

1236 
if(s>per_mb_rl_table && cbp){

1237 
s>rl_table_index = decode012(&s>gb); 
1238 
s>rl_chroma_table_index = s>rl_table_index; 
1239 
} 
1240 
h263_pred_motion(s, 0, 0, &mx, &my); 
1241 
if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0) 
1242 
return 1; 
1243 
s>mv_dir = MV_DIR_FORWARD; 
1244 
s>mv_type = MV_TYPE_16X16; 
1245 
s>mv[0][0][0] = mx; 
1246 
s>mv[0][0][1] = my; 
1247 
*mb_type_ptr = MB_TYPE_L0  MB_TYPE_16x16; 
1248 
} else {

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

1250 
s>ac_pred = get_bits1(&s>gb); 
1251 
*mb_type_ptr = MB_TYPE_INTRA; 
1252 
if(s>inter_intra_pred){

1253 
s>h263_aic_dir= get_vlc2(&s>gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);

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

1255 
} 
1256 
if(s>per_mb_rl_table && cbp){

1257 
s>rl_table_index = decode012(&s>gb); 
1258 
s>rl_chroma_table_index = s>rl_table_index; 
1259 
} 
1260 
} 
1261  
1262 
s>dsp.clear_blocks(s>block[0]);

1263 
for (i = 0; i < 6; i++) { 
1264 
if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5  i)) & 1, NULL) < 0) 
1265 
{ 
1266 
av_log(s>avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s>mb_x, s>mb_y, i);

1267 
return 1; 
1268 
} 
1269 
} 
1270  
1271 
return 0; 
1272 
} 
1273  
1274 
/* init all vlc decoding tables */

1275 
av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)

1276 
{ 
1277 
MpegEncContext *s = avctx>priv_data; 
1278 
static int done = 0; 
1279 
int i;

1280 
MVTable *mv; 
1281  
1282 
ff_h263_decode_init(avctx); 
1283  
1284 
common_init(s); 
1285  
1286 
if (!done) {

1287 
done = 1;

1288  
1289 
for(i=0;i<NB_RL_TABLES;i++) { 
1290 
init_rl(&rl_table[i], static_rl_table_store[i]); 
1291 
} 
1292 
INIT_VLC_RL(rl_table[0], 642); 
1293 
INIT_VLC_RL(rl_table[1], 1104); 
1294 
INIT_VLC_RL(rl_table[2], 554); 
1295 
INIT_VLC_RL(rl_table[3], 940); 
1296 
INIT_VLC_RL(rl_table[4], 962); 
1297 
INIT_VLC_RL(rl_table[5], 554); 
1298  
1299 
mv = &mv_tables[0];

1300 
INIT_VLC_STATIC(&mv>vlc, MV_VLC_BITS, mv>n + 1,

1301 
mv>table_mv_bits, 1, 1, 
1302 
mv>table_mv_code, 2, 2, 3714); 
1303 
mv = &mv_tables[1];

1304 
INIT_VLC_STATIC(&mv>vlc, MV_VLC_BITS, mv>n + 1,

1305 
mv>table_mv_bits, 1, 1, 
1306 
mv>table_mv_code, 2, 2, 2694); 
1307  
1308 
INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 
1309 
&ff_table0_dc_lum[0][1], 8, 4, 
1310 
&ff_table0_dc_lum[0][0], 8, 4, 1158); 
1311 
INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 
1312 
&ff_table0_dc_chroma[0][1], 8, 4, 
1313 
&ff_table0_dc_chroma[0][0], 8, 4, 1118); 
1314 
INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 
1315 
&ff_table1_dc_lum[0][1], 8, 4, 
1316 
&ff_table1_dc_lum[0][0], 8, 4, 1476); 
1317 
INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 
1318 
&ff_table1_dc_chroma[0][1], 8, 4, 
1319 
&ff_table1_dc_chroma[0][0], 8, 4, 1216); 
1320  
1321 
INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,

1322 
&v2_dc_lum_table[0][1], 8, 4, 
1323 
&v2_dc_lum_table[0][0], 8, 4, 1472); 
1324 
INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,

1325 
&v2_dc_chroma_table[0][1], 8, 4, 
1326 
&v2_dc_chroma_table[0][0], 8, 4, 1506); 
1327  
1328 
INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,

1329 
&v2_intra_cbpc[0][1], 2, 1, 
1330 
&v2_intra_cbpc[0][0], 2, 1, 8); 
1331 
INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,

1332 
&v2_mb_type[0][1], 2, 1, 
1333 
&v2_mb_type[0][0], 2, 1, 128); 
1334 
INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,

1335 
&mvtab[0][1], 2, 1, 
1336 
&mvtab[0][0], 2, 1, 538); 
1337  
1338 
INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128, 
1339 
&wmv2_inter_table[0][0][1], 8, 4, 
1340 
&wmv2_inter_table[0][0][0], 8, 4, 1636); 
1341 
INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128, 
1342 
&wmv2_inter_table[1][0][1], 8, 4, 
1343 
&wmv2_inter_table[1][0][0], 8, 4, 2648); 
1344 
INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128, 
1345 
&wmv2_inter_table[2][0][1], 8, 4, 
1346 
&wmv2_inter_table[2][0][0], 8, 4, 1532); 
1347 
INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128, 
1348 
&wmv2_inter_table[3][0][1], 8, 4, 
1349 
&wmv2_inter_table[3][0][0], 8, 4, 2488); 
1350  
1351 
INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,

1352 
&ff_msmp4_mb_i_table[0][1], 4, 2, 
1353 
&ff_msmp4_mb_i_table[0][0], 4, 2, 536); 
1354  
1355 
INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,

1356 
&table_inter_intra[0][1], 2, 1, 
1357 
&table_inter_intra[0][0], 2, 1, 8); 
1358 
} 
1359  
1360 
switch(s>msmpeg4_version){

1361 
case 1: 
1362 
case 2: 
1363 
s>decode_mb= msmpeg4v12_decode_mb; 
1364 
break;

1365 
case 3: 
1366 
case 4: 
1367 
s>decode_mb= msmpeg4v34_decode_mb; 
1368 
break;

1369 
case 5: 
1370 
if (CONFIG_WMV2_DECODER)

1371 
s>decode_mb= ff_wmv2_decode_mb; 
1372 
case 6: 
1373 
//FIXME + TODO VC1 decode mb

1374 
break;

1375 
} 
1376  
1377 
s>slice_height= s>mb_height; //to avoid 1/0 if the first frame is not a keyframe

1378  
1379 
return 0; 
1380 
} 
1381  
1382 
int msmpeg4_decode_picture_header(MpegEncContext * s)

1383 
{ 
1384 
int code;

1385  
1386 
#if 0

1387 
{

1388 
int i;

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

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

1391 
// get_bits1(&s>gb);

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

1393 
return 1;

1394 
}

1395 
#endif

1396  
1397 
if(s>msmpeg4_version==1){ 
1398 
int start_code = get_bits_long(&s>gb, 32); 
1399 
if(start_code!=0x00000100){ 
1400 
av_log(s>avctx, AV_LOG_ERROR, "invalid startcode\n");

1401 
return 1; 
1402 
} 
1403  
1404 
skip_bits(&s>gb, 5); // frame number */ 
1405 
} 
1406  
1407 
s>pict_type = get_bits(&s>gb, 2) + 1; 
1408 
if (s>pict_type != FF_I_TYPE &&

1409 
s>pict_type != FF_P_TYPE){ 
1410 
av_log(s>avctx, AV_LOG_ERROR, "invalid picture type\n");

1411 
return 1; 
1412 
} 
1413 
#if 0

1414 
{

1415 
static int had_i=0;

1416 
if(s>pict_type == FF_I_TYPE) had_i=1;

1417 
if(!had_i) return 1;

1418 
}

1419 
#endif

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

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

1423 
return 1; 
1424 
} 
1425  
1426 
if (s>pict_type == FF_I_TYPE) {

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

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

1431 
return 1; 
1432 
} 
1433  
1434 
s>slice_height = code; 
1435 
}else{

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

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

1439 
return 1; 
1440 
} 
1441  
1442 
s>slice_height = s>mb_height / (code  0x16);

1443 
} 
1444  
1445 
switch(s>msmpeg4_version){

1446 
case 1: 
1447 
case 2: 
1448 
s>rl_chroma_table_index = 2;

1449 
s>rl_table_index = 2;

1450  
1451 
s>dc_table_index = 0; //not used 
1452 
break;

1453 
case 3: 
1454 
s>rl_chroma_table_index = decode012(&s>gb); 
1455 
s>rl_table_index = decode012(&s>gb); 
1456  
1457 
s>dc_table_index = get_bits1(&s>gb); 
1458 
break;

1459 
case 4: 
1460 
msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); 
1461  
1462 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1463 
else s>per_mb_rl_table= 0; 
1464  
1465 
if(!s>per_mb_rl_table){

1466 
s>rl_chroma_table_index = decode012(&s>gb); 
1467 
s>rl_table_index = decode012(&s>gb); 
1468 
} 
1469  
1470 
s>dc_table_index = get_bits1(&s>gb); 
1471 
s>inter_intra_pred= 0;

1472 
break;

1473 
} 
1474 
s>no_rounding = 1;

1475 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

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

1477 
s>qscale, 
1478 
s>rl_chroma_table_index, 
1479 
s>rl_table_index, 
1480 
s>dc_table_index, 
1481 
s>per_mb_rl_table, 
1482 
s>slice_height); 
1483 
} else {

1484 
switch(s>msmpeg4_version){

1485 
case 1: 
1486 
case 2: 
1487 
if(s>msmpeg4_version==1) 
1488 
s>use_skip_mb_code = 1;

1489 
else

1490 
s>use_skip_mb_code = get_bits1(&s>gb); 
1491 
s>rl_table_index = 2;

1492 
s>rl_chroma_table_index = s>rl_table_index; 
1493 
s>dc_table_index = 0; //not used 
1494 
s>mv_table_index = 0;

1495 
break;

1496 
case 3: 
1497 
s>use_skip_mb_code = get_bits1(&s>gb); 
1498 
s>rl_table_index = decode012(&s>gb); 
1499 
s>rl_chroma_table_index = s>rl_table_index; 
1500  
1501 
s>dc_table_index = get_bits1(&s>gb); 
1502  
1503 
s>mv_table_index = get_bits1(&s>gb); 
1504 
break;

1505 
case 4: 
1506 
s>use_skip_mb_code = get_bits1(&s>gb); 
1507  
1508 
if(s>bit_rate > MBAC_BITRATE) s>per_mb_rl_table= get_bits1(&s>gb);

1509 
else s>per_mb_rl_table= 0; 
1510  
1511 
if(!s>per_mb_rl_table){

1512 
s>rl_table_index = decode012(&s>gb); 
1513 
s>rl_chroma_table_index = s>rl_table_index; 
1514 
} 
1515  
1516 
s>dc_table_index = get_bits1(&s>gb); 
1517  
1518 
s>mv_table_index = get_bits1(&s>gb); 
1519 
s>inter_intra_pred= (s>width*s>height < 320*240 && s>bit_rate<=II_BITRATE); 
1520 
break;

1521 
} 
1522  
1523 
if(s>avctx>debug&FF_DEBUG_PICT_INFO)

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

1525 
s>use_skip_mb_code, 
1526 
s>rl_table_index, 
1527 
s>rl_chroma_table_index, 
1528 
s>dc_table_index, 
1529 
s>mv_table_index, 
1530 
s>per_mb_rl_table, 
1531 
s>qscale); 
1532  
1533 
if(s>flipflop_rounding){

1534 
s>no_rounding ^= 1;

1535 
}else{

1536 
s>no_rounding = 0;

1537 
} 
1538 
} 
1539 
//printf("%d %d %d %d %d\n", s>pict_type, s>bit_rate, s>inter_intra_pred, s>width, s>height);

1540  
1541 
s>esc3_level_length= 0;

1542 
s>esc3_run_length= 0;

1543  
1544 
return 0; 
1545 
} 
1546  
1547 
int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) 
1548 
{ 
1549 
int left= buf_size*8  get_bits_count(&s>gb); 
1550 
int length= s>msmpeg4_version>=3 ? 17 : 16; 
1551 
/* the alt_bitstream reader could read over the end so we need to check it */

1552 
if(left>=length && left<length+8) 
1553 
{ 
1554 
int fps;

1555  
1556 
fps= get_bits(&s>gb, 5);

1557 
s>bit_rate= get_bits(&s>gb, 11)*1024; 
1558 
if(s>msmpeg4_version>=3) 
1559 
s>flipflop_rounding= get_bits1(&s>gb); 
1560 
else

1561 
s>flipflop_rounding= 0;

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

1564 
} 
1565 
else if(left<length+8) 
1566 
{ 
1567 
s>flipflop_rounding= 0;

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

1570 
} 
1571 
else

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

1574 
} 
1575  
1576 
return 0; 
1577 
} 
1578  
1579 
static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) 
1580 
{ 
1581 
int level, pred;

1582  
1583 
if(s>msmpeg4_version<=2){ 
1584 
if (n < 4) { 
1585 
level = get_vlc2(&s>gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);

1586 
} else {

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

1588 
} 
1589 
if (level < 0) 
1590 
return 1; 
1591 
level=256;

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

1595 
} else {

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

1597 
} 
1598 
if (level < 0){ 
1599 
av_log(s>avctx, AV_LOG_ERROR, "illegal dc vlc\n");

1600 
return 1; 
1601 
} 
1602  
1603 
if (level == DC_MAX) {

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

1605 
if (get_bits1(&s>gb))

1606 
level = level; 
1607 
} else if (level != 0) { 
1608 
if (get_bits1(&s>gb))

1609 
level = level; 
1610 
} 
1611 
} 
1612  
1613 
if(s>msmpeg4_version==1){ 
1614 
int32_t *dc_val; 
1615 
pred = msmpeg4v1_pred_dc(s, n, &dc_val); 
1616 
level += pred; 
1617  
1618 
/* update predictor */

1619 
*dc_val= level; 
1620 
}else{

1621 
int16_t *dc_val; 
1622 
pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); 
1623 
level += pred; 
1624  
1625 
/* update predictor */

1626 
if (n < 4) { 
1627 
*dc_val = level * s>y_dc_scale; 
1628 
} else {

1629 
*dc_val = level * s>c_dc_scale; 
1630 
} 
1631 
} 
1632  
1633 
return level;

1634 
} 
1635  
1636 
//#define ERROR_DETAILS

1637 
int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,

1638 
int n, int coded, const uint8_t *scan_table) 
1639 
{ 
1640 
int level, i, last, run, run_diff;

1641 
int av_uninit(dc_pred_dir);

1642 
RLTable *rl; 
1643 
RL_VLC_ELEM *rl_vlc; 
1644 
int qmul, qadd;

1645  
1646 
if (s>mb_intra) {

1647 
qmul=1;

1648 
qadd=0;

1649  
1650 
/* DC coef */

1651 
level = msmpeg4_decode_dc(s, n, &dc_pred_dir); 
1652  
1653 
if (level < 0){ 
1654 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow block: %d qscale: %d//\n", n, s>qscale);

1655 
if(s>inter_intra_pred) level=0; 
1656 
else return 1; 
1657 
} 
1658 
if (n < 4) { 
1659 
rl = &rl_table[s>rl_table_index]; 
1660 
if(level > 256*s>y_dc_scale){ 
1661 
av_log(s>avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s>qscale);

1662 
if(!s>inter_intra_pred) return 1; 
1663 
} 
1664 
} else {

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

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

1668 
if(!s>inter_intra_pred) return 1; 
1669 
} 
1670 
} 
1671 
block[0] = level;

1672  
1673 
run_diff = s>msmpeg4_version >= 4;

1674 
i = 0;

1675 
if (!coded) {

1676 
goto not_coded;

1677 
} 
1678 
if (s>ac_pred) {

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

1681 
else

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

1683 
} else {

1684 
scan_table = s>intra_scantable.permutated; 
1685 
} 
1686 
rl_vlc= rl>rl_vlc[0];

1687 
} else {

1688 
qmul = s>qscale << 1;

1689 
qadd = (s>qscale  1)  1; 
1690 
i = 1;

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

1692  
1693 
if(s>msmpeg4_version==2) 
1694 
run_diff = 0;

1695 
else

1696 
run_diff = 1;

1697  
1698 
if (!coded) {

1699 
s>block_last_index[n] = i; 
1700 
return 0; 
1701 
} 
1702 
if(!scan_table)

1703 
scan_table = s>inter_scantable.permutated; 
1704 
rl_vlc= rl>rl_vlc[s>qscale]; 
1705 
} 
1706 
{ 
1707 
OPEN_READER(re, &s>gb); 
1708 
for(;;) {

1709 
UPDATE_CACHE(re, &s>gb); 
1710 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2, 0); 
1711 
if (level==0) { 
1712 
int cache;

1713 
cache= GET_CACHE(re, &s>gb); 
1714 
/* escape */

1715 
if (s>msmpeg4_version==1  (cache&0x80000000)==0) { 
1716 
if (s>msmpeg4_version==1  (cache&0x40000000)==0) { 
1717 
/* third escape */

1718 
if(s>msmpeg4_version!=1) LAST_SKIP_BITS(re, &s>gb, 2); 
1719 
UPDATE_CACHE(re, &s>gb); 
1720 
if(s>msmpeg4_version<=3){ 
1721 
last= SHOW_UBITS(re, &s>gb, 1); SKIP_CACHE(re, &s>gb, 1); 
1722 
run= SHOW_UBITS(re, &s>gb, 6); SKIP_CACHE(re, &s>gb, 6); 
1723 
level= SHOW_SBITS(re, &s>gb, 8); LAST_SKIP_CACHE(re, &s>gb, 8); 
1724 
SKIP_COUNTER(re, &s>gb, 1+6+8); 
1725 
}else{

1726 
int sign;

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

1729 
int ll;

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

1731 
if(s>qscale<8){ 
1732 
ll= SHOW_UBITS(re, &s>gb, 3); SKIP_BITS(re, &s>gb, 3); 
1733 
if(ll==0){ 
1734 
ll= 8+SHOW_UBITS(re, &s>gb, 1); SKIP_BITS(re, &s>gb, 1); 
1735 
} 
1736 
}else{

1737 
ll=2;

1738 
while(ll<8 && SHOW_UBITS(re, &s>gb, 1)==0){ 
1739 
ll++; 
1740 
SKIP_BITS(re, &s>gb, 1);

1741 
} 
1742 
if(ll<8) SKIP_BITS(re, &s>gb, 1); 
1743 
} 
1744  
1745 
s>esc3_level_length= ll; 
1746 
s>esc3_run_length= SHOW_UBITS(re, &s>gb, 2) + 3; SKIP_BITS(re, &s>gb, 2); 
1747 
//printf("level length:%d, run length: %d\n", ll, s>esc3_run_length);

1748 
UPDATE_CACHE(re, &s>gb); 
1749 
} 
1750 
run= SHOW_UBITS(re, &s>gb, s>esc3_run_length); 
1751 
SKIP_BITS(re, &s>gb, s>esc3_run_length); 
1752  
1753 
sign= SHOW_UBITS(re, &s>gb, 1);

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

1755  
1756 
level= SHOW_UBITS(re, &s>gb, s>esc3_level_length); 
1757 
SKIP_BITS(re, &s>gb, s>esc3_level_length); 
1758 
if(sign) level= level;

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

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

1762 
{

1763 
const int abs_level= FFABS(level);

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

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

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

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

1768 
return DECODING_AC_LOST;

1769 
}

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

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

1772 
return DECODING_AC_LOST;

1773 
}

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

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

1776 
return DECODING_AC_LOST;

1777 
}

1778 
}

1779 
}

1780 
#endif

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

1782 
if (level>0) level= level * qmul + qadd; 
1783 
else level= level * qmul  qadd;

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

1785 
if(level>2048  level<2048){

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

1787 
return DECODING_AC_LOST;

1788 
}

1789 
#endif

1790 
i+= run + 1;

1791 
if(last) i+=192; 
1792 
#ifdef ERROR_DETAILS

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

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

1797 
#endif

1798 
} else {

1799 
/* second escape */

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

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

1805 
#ifdef ERROR_DETAILS

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

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

1810 
#endif

1811 
} 
1812 
} else {

1813 
/* first escape */

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

1815 
GET_RL_VLC(level, run, re, &s>gb, rl_vlc, TEX_VLC_BITS, 2, 1); 
1816 
i+= run; 
1817 
level = level + rl>max_level[run>>7][(run1)&63] * qmul;//FIXME opt indexing 
1818 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1819 
LAST_SKIP_BITS(re, &s>gb, 1);

1820 
#ifdef ERROR_DETAILS

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

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

1825 
#endif

1826 
} 
1827 
} else {

1828 
i+= run; 
1829 
level = (level ^ SHOW_SBITS(re, &s>gb, 1))  SHOW_SBITS(re, &s>gb, 1); 
1830 
LAST_SKIP_BITS(re, &s>gb, 1);

1831 
#ifdef ERROR_DETAILS

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

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

1836 
#endif

1837 
} 
1838 
if (i > 62){ 
1839 
i= 192;

1840 
if(i&(~63)){ 
1841 
const int left= get_bits_left(&s>gb); 
1842 
if(((i+192 == 64 && level/qmul==1)  s>error_recognition<=1) && left>=0){ 
1843 
av_log(s>avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s>mb_x, s>mb_y);

1844 
break;

1845 
}else{

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

1847 
return 1; 
1848 
} 
1849 
} 
1850  
1851 
block[scan_table[i]] = level; 
1852 
break;

1853 
} 
1854  
1855 
block[scan_table[i]] = level; 
1856 
} 
1857 
CLOSE_READER(re, &s>gb); 
1858 
} 
1859 
not_coded:

1860 
if (s>mb_intra) {

1861 
mpeg4_pred_ac(s, block, n, dc_pred_dir); 
1862 
if (s>ac_pred) {

1863 
i = 63; /* XXX: not optimal */ 
1864 
} 
1865 
} 
1866 
if(s>msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize 
1867 
s>block_last_index[n] = i; 
1868  
1869 
return 0; 
1870 
} 
1871  
1872 
int ff_msmpeg4_decode_motion(MpegEncContext * s,

1873 
int *mx_ptr, int *my_ptr) 
1874 
{ 
1875 
MVTable *mv; 
1876 
int code, mx, my;

1877  
1878 
mv = &mv_tables[s>mv_table_index]; 
1879  
1880 
code = get_vlc2(&s>gb, mv>vlc.table, MV_VLC_BITS, 2);

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

1883 
return 1; 
1884 
} 
1885 
if (code == mv>n) {

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

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

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

1889 
} else {

1890 
mx = mv>table_mvx[code]; 
1891 
my = mv>table_mvy[code]; 
1892 
} 
1893  
1894 
mx += *mx_ptr  32;

1895 
my += *my_ptr  32;

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

1897 
if (mx <= 64) 
1898 
mx += 64;

1899 
else if (mx >= 64) 
1900 
mx = 64;

1901  
1902 
if (my <= 64) 
1903 
my += 64;

1904 
else if (my >= 64) 
1905 
my = 64;

1906 
*mx_ptr = mx; 
1907 
*my_ptr = my; 
1908 
return 0; 
1909 
} 
1910  
1911 
AVCodec ff_msmpeg4v1_decoder = { 
1912 
"msmpeg4v1",

1913 
AVMEDIA_TYPE_VIDEO, 
1914 
CODEC_ID_MSMPEG4V1, 
1915 
sizeof(MpegEncContext),

1916 
ff_msmpeg4_decode_init, 
1917 
NULL,

1918 
ff_h263_decode_end, 
1919 
ff_h263_decode_frame, 
1920 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1, 
1921 
.max_lowres= 3,

1922 
.long_name= NULL_IF_CONFIG_SMALL("MPEG4 part 2 Microsoft variant version 1"),

1923 
.pix_fmts= ff_pixfmt_list_420, 
1924 
}; 
1925  
1926 
AVCodec ff_msmpeg4v2_decoder = { 
1927 
"msmpeg4v2",

1928 
AVMEDIA_TYPE_VIDEO, 
1929 
CODEC_ID_MSMPEG4V2, 
1930 
sizeof(MpegEncContext),

1931 
ff_msmpeg4_decode_init, 
1932 
NULL,

1933 
ff_h263_decode_end, 
1934 
ff_h263_decode_frame, 
1935 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1, 
1936 
.max_lowres= 3,

1937 
.long_name= NULL_IF_CONFIG_SMALL("MPEG4 part 2 Microsoft variant version 2"),

1938 
.pix_fmts= ff_pixfmt_list_420, 
1939 
}; 
1940  
1941 
AVCodec ff_msmpeg4v3_decoder = { 
1942 
"msmpeg4",

1943 
AVMEDIA_TYPE_VIDEO, 
1944 
CODEC_ID_MSMPEG4V3, 
1945 
sizeof(MpegEncContext),

1946 
ff_msmpeg4_decode_init, 
1947 
NULL,

1948 
ff_h263_decode_end, 
1949 
ff_h263_decode_frame, 
1950 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1, 
1951 
.max_lowres= 3,

1952 
.long_name= NULL_IF_CONFIG_SMALL("MPEG4 part 2 Microsoft variant version 3"),

1953 
.pix_fmts= ff_pixfmt_list_420, 
1954 
}; 
1955  
1956 
AVCodec ff_wmv1_decoder = { 
1957 
"wmv1",

1958 
AVMEDIA_TYPE_VIDEO, 
1959 
CODEC_ID_WMV1, 
1960 
sizeof(MpegEncContext),

1961 
ff_msmpeg4_decode_init, 
1962 
NULL,

1963 
ff_h263_decode_end, 
1964 
ff_h263_decode_frame, 
1965 
CODEC_CAP_DRAW_HORIZ_BAND  CODEC_CAP_DR1, 
1966 
.max_lowres= 3,

1967 
.long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),

1968 
.pix_fmts= ff_pixfmt_list_420, 
1969 
}; 