git.sesse.net Git - ffmpeg/blob - libavcodec/msmpeg4.c

   1 /*
   2  * MSMPEG4 backend for ffmpeg encoder and decoder
   3  * Copyright (c) 2001 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
  20  */
  21 #include "avcodec.h"
  22 #include "dsputil.h"
  23 #include "mpegvideo.h"
  24 //#define PRINT_MB
  25
  26 /*
  27  * You can also call this codec : MPEG4 with a twist !
  28  *
  29  * TODO:
  30  *        - (encoding) select best mv table (two choices)
  31  *        - (encoding) select best vlc/dc table
  32  */
  33 //#define DEBUG
  34
  35 #define DC_VLC_BITS 9
  36 #define CBPY_VLC_BITS 6
  37 #define INTER_INTRA_VLC_BITS 3
  38 #define V1_INTRA_CBPC_VLC_BITS 6
  39 #define V1_INTER_CBPC_VLC_BITS 6
  40 #define V2_INTRA_CBPC_VLC_BITS 3
  41 #define V2_MB_TYPE_VLC_BITS 7
  42 #define MV_VLC_BITS 9
  43 #define V2_MV_VLC_BITS 9
  44 #define TEX_VLC_BITS 9
  45 #define MB_NON_INTRA_VLC_BITS 9
  46 #define MB_INTRA_VLC_BITS 9
  47
  48 #define II_BITRATE 128*1024
  49 #define MBAC_BITRATE 50*1024
  50
  51 #define DEFAULT_INTER_INDEX 3
  52
  53 static UINT32 v2_dc_lum_table[512][2];
  54 static UINT32 v2_dc_chroma_table[512][2];
  55
  56 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n);
  57 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
  58                                        int n, int coded, const uint8_t *scantable);
  59 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
  60 static int msmpeg4_decode_motion(MpegEncContext * s,
  61                                  int *mx_ptr, int *my_ptr);
  62 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val);
  63 static void init_h263_dc_for_msmpeg4(void);
  64 static inline void msmpeg4_memsetw(short *tab, int val, int n);
  65 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra);
  66 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
  67 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
  68 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);
  69
  70 extern UINT32 inverse[256];
  71
  72
  73 #ifdef DEBUG
  74 int intra_count = 0;
  75 int frame_count = 0;
  76 #endif
  77
  78 #include "msmpeg4data.h"
  79
  80 static UINT8 rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2];
  81
  82 #ifdef STATS
  83
  84 const char *st_names[ST_NB] = {
  85     "unknown",
  86     "dc",
  87     "intra_ac",
  88     "inter_ac",
  89     "intra_mb",
  90     "inter_mb",
  91     "mv",
  92 };
  93
  94 int st_current_index = 0;
  95 unsigned int st_bit_counts[ST_NB];
  96 unsigned int st_out_bit_counts[ST_NB];
  97
  98 #define set_stat(var) st_current_index = var;
  99
 100 void print_stats(void)
 101 {
 102     unsigned int total;
 103     int i;
 104
 105     printf("Input:\n");
 106     total = 0;
 107     for(i=0;i<ST_NB;i++)
 108         total += st_bit_counts[i];
 109     if (total == 0)
 110         total = 1;
 111     for(i=0;i<ST_NB;i++) {
 112         printf("%-10s : %10.1f %5.1f%%\n",
 113                st_names[i],
 114                (double)st_bit_counts[i] / 8.0,
 115                (double)st_bit_counts[i] * 100.0 / total);
 116     }
 117     printf("%-10s : %10.1f %5.1f%%\n",
 118            "total",
 119            (double)total / 8.0,
 120            100.0);
 121
 122     printf("Output:\n");
 123     total = 0;
 124     for(i=0;i<ST_NB;i++)
 125         total += st_out_bit_counts[i];
 126     if (total == 0)
 127         total = 1;
 128     for(i=0;i<ST_NB;i++) {
 129         printf("%-10s : %10.1f %5.1f%%\n",
 130                st_names[i],
 131                (double)st_out_bit_counts[i] / 8.0,
 132                (double)st_out_bit_counts[i] * 100.0 / total);
 133     }
 134     printf("%-10s : %10.1f %5.1f%%\n",
 135            "total",
 136            (double)total / 8.0,
 137            100.0);
 138 }
 139
 140 #else
 141
 142 #define set_stat(var)
 143
 144 #endif
 145
 146 static void common_init(MpegEncContext * s)
 147 {
 148     static int inited=0;
 149
 150     switch(s->msmpeg4_version){
 151     case 1:
 152     case 2:
 153         s->y_dc_scale_table=
 154         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 155         break;
 156     case 3:
 157         if(s->workaround_bugs){
 158             s->y_dc_scale_table= old_ff_y_dc_scale_table;
 159             s->c_dc_scale_table= old_ff_c_dc_scale_table;
 160         } else{
 161             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
 162             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
 163         }
 164         break;
 165     case 4:
 166     case 5:
 167         s->y_dc_scale_table= wmv1_y_dc_scale_table;
 168         s->c_dc_scale_table= wmv1_c_dc_scale_table;
 169         break;
 170     }
 171
 172
 173     if(s->msmpeg4_version>=4){
 174         ff_init_scantable(s, &s->intra_scantable  , wmv1_scantable[1]);
 175         ff_init_scantable(s, &s->intra_h_scantable, wmv1_scantable[2]);
 176         ff_init_scantable(s, &s->intra_v_scantable, wmv1_scantable[3]);
 177         ff_init_scantable(s, &s->inter_scantable  , wmv1_scantable[0]);
 178     }
 179     //Note the default tables are set in common_init in mpegvideo.c
 180
 181     if(!inited){
 182         inited=1;
 183
 184         init_h263_dc_for_msmpeg4();
 185     }
 186 }
 187
 188 /* build the table which associate a (x,y) motion vector to a vlc */
 189 static void init_mv_table(MVTable *tab)
 190 {
 191     int i, x, y;
 192
 193     tab->table_mv_index = av_malloc(sizeof(UINT16) * 4096);
 194     /* mark all entries as not used */
 195     for(i=0;i<4096;i++)
 196         tab->table_mv_index[i] = tab->n;
 197
 198     for(i=0;i<tab->n;i++) {
 199         x = tab->table_mvx[i];
 200         y = tab->table_mvy[i];
 201         tab->table_mv_index[(x << 6) | y] = i;
 202     }
 203 }
 204
 205 static void code012(PutBitContext *pb, int n)
 206 {
 207     if (n == 0) {
 208         put_bits(pb, 1, 0);
 209     } else {
 210         put_bits(pb, 1, 1);
 211         put_bits(pb, 1, (n >= 2));
 212     }
 213 }
 214
 215 void ff_msmpeg4_encode_init(MpegEncContext *s)
 216 {
 217     static int init_done=0;
 218     int i;
 219
 220     common_init(s);
 221     if(s->msmpeg4_version>=4){
 222         s->min_qcoeff= -255;
 223         s->max_qcoeff=  255;
 224     }
 225
 226     if (!init_done) {
 227         /* init various encoding tables */
 228         init_done = 1;
 229         init_mv_table(&mv_tables[0]);
 230         init_mv_table(&mv_tables[1]);
 231         for(i=0;i<NB_RL_TABLES;i++)
 232             init_rl(&rl_table[i]);
 233
 234         for(i=0; i<NB_RL_TABLES; i++){
 235             int level;
 236             for(level=0; level<=MAX_LEVEL; level++){
 237                 int run;
 238                 for(run=0; run<=MAX_RUN; run++){
 239                     int last;
 240                     for(last=0; last<2; last++){
 241                         rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
 242                     }
 243                 }
 244             }
 245         }
 246     }
 247 }
 248
 249 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
 250     int size=0;
 251     int code;
 252     int run_diff= intra ? 0 : 1;
 253
 254     code = get_rl_index(rl, last, run, level);
 255     size+= rl->table_vlc[code][1];
 256     if (code == rl->n) {
 257         int level1, run1;
 258
 259         level1 = level - rl->max_level[last][run];
 260         if (level1 < 1)
 261             goto esc2;
 262         code = get_rl_index(rl, last, run, level1);
 263         if (code == rl->n) {
 264             esc2:
 265             size++;
 266             if (level > MAX_LEVEL)
 267                 goto esc3;
 268             run1 = run - rl->max_run[last][level] - run_diff;
 269             if (run1 < 0)
 270                 goto esc3;
 271             code = get_rl_index(rl, last, run1, level);
 272             if (code == rl->n) {
 273             esc3:
 274                 /* third escape */
 275                 size+=1+1+6+8;
 276             } else {
 277                 /* second escape */
 278                 size+= 1+1+ rl->table_vlc[code][1];
 279             }
 280         } else {
 281             /* first escape */
 282             size+= 1+1+ rl->table_vlc[code][1];
 283         }
 284     } else {
 285         size++;
 286     }
 287     return size;
 288 }
 289
 290 static void find_best_tables(MpegEncContext * s)
 291 {
 292     int i;
 293     int best       =-1, best_size       =9999999;
 294     int chroma_best=-1, best_chroma_size=9999999;
 295
 296     for(i=0; i<3; i++){
 297         int level;
 298         int chroma_size=0;
 299         int size=0;
 300
 301         if(i>0){// ;)
 302             size++;
 303             chroma_size++;
 304         }
 305         for(level=0; level<=MAX_LEVEL; level++){
 306             int run;
 307             for(run=0; run<=MAX_RUN; run++){
 308                 int last;
 309                 const int last_size= size + chroma_size;
 310                 for(last=0; last<2; last++){
 311                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
 312                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
 313                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
 314
 315                     if(s->pict_type==I_TYPE){
 316                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
 317                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
 318                     }else{
 319                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
 320                                      +intra_chroma_count*rl_length[i+3][level][run][last]
 321                                      +inter_count       *rl_length[i+3][level][run][last];
 322                     }
 323                 }
 324                 if(last_size == size+chroma_size) break;
 325             }
 326         }
 327         if(size<best_size){
 328             best_size= size;
 329             best= i;
 330         }
 331         if(chroma_size<best_chroma_size){
 332             best_chroma_size= chroma_size;
 333             chroma_best= i;
 334         }
 335     }
 336
 337 //    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
 338 //           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
 339
 340     if(s->pict_type==P_TYPE) chroma_best= best;
 341
 342     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
 343
 344     s->rl_table_index       =        best;
 345     s->rl_chroma_table_index= chroma_best;
 346
 347     if(s->pict_type != s->last_non_b_pict_type){
 348         s->rl_table_index= 2;
 349         if(s->pict_type==I_TYPE)
 350             s->rl_chroma_table_index= 1;
 351         else
 352             s->rl_chroma_table_index= 2;
 353     }
 354
 355 }
 356
 357 /* write MSMPEG4 compatible frame header */
 358 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 359 {
 360     find_best_tables(s);
 361
 362     align_put_bits(&s->pb);
 363     put_bits(&s->pb, 2, s->pict_type - 1);
 364
 365     put_bits(&s->pb, 5, s->qscale);
 366     if(s->msmpeg4_version<=2){
 367         s->rl_table_index = 2;
 368         s->rl_chroma_table_index = 2;
 369     }
 370
 371     s->dc_table_index = 1;
 372     s->mv_table_index = 1; /* only if P frame */
 373     s->use_skip_mb_code = 1; /* only if P frame */
 374     s->per_mb_rl_table = 0;
 375     if(s->msmpeg4_version==4)
 376         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==P_TYPE);
 377 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
 378
 379     if (s->pict_type == I_TYPE) {
 380         s->slice_height= s->mb_height/1;
 381         put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height);
 382
 383         if(s->msmpeg4_version==4){
 384             msmpeg4_encode_ext_header(s);
 385             if(s->bit_rate>MBAC_BITRATE)
 386                 put_bits(&s->pb, 1, s->per_mb_rl_table);
 387         }
 388
 389         if(s->msmpeg4_version>2){
 390             if(!s->per_mb_rl_table){
 391                 code012(&s->pb, s->rl_chroma_table_index);
 392                 code012(&s->pb, s->rl_table_index);
 393             }
 394
 395             put_bits(&s->pb, 1, s->dc_table_index);
 396         }
 397     } else {
 398         put_bits(&s->pb, 1, s->use_skip_mb_code);
 399
 400         if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE)
 401             put_bits(&s->pb, 1, s->per_mb_rl_table);
 402
 403         if(s->msmpeg4_version>2){
 404             if(!s->per_mb_rl_table)
 405                 code012(&s->pb, s->rl_table_index);
 406
 407             put_bits(&s->pb, 1, s->dc_table_index);
 408
 409             put_bits(&s->pb, 1, s->mv_table_index);
 410         }
 411     }
 412
 413     s->esc3_level_length= 0;
 414     s->esc3_run_length= 0;
 415
 416 #ifdef DEBUG
 417     intra_count = 0;
 418     printf("*****frame %d:\n", frame_count++);
 419 #endif
 420 }
 421
 422 void msmpeg4_encode_ext_header(MpegEncContext * s)
 423 {
 424         put_bits(&s->pb, 5, s->frame_rate / FRAME_RATE_BASE); //yes 29.97 -> 29
 425
 426         put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047));
 427
 428         if(s->msmpeg4_version<3)
 429             s->flipflop_rounding=0;
 430         else{
 431             s->flipflop_rounding=1;
 432             put_bits(&s->pb, 1, s->flipflop_rounding);
 433         }
 434 }
 435
 436 /* predict coded block */
 437 static inline int coded_block_pred(MpegEncContext * s, int n, UINT8 **coded_block_ptr)
 438 {
 439     int xy, wrap, pred, a, b, c;
 440
 441     xy = s->block_index[n];
 442     wrap = s->block_wrap[0];
 443
 444     /* B C
 445      * A X
 446      */
 447     a = s->coded_block[xy - 1       ];
 448     b = s->coded_block[xy - 1 - wrap];
 449     c = s->coded_block[xy     - wrap];
 450
 451     if (b == c) {
 452         pred = a;
 453     } else {
 454         pred = c;
 455     }
 456
 457     /* store value */
 458     *coded_block_ptr = &s->coded_block[xy];
 459
 460     return pred;
 461 }
 462
 463 static void msmpeg4_encode_motion(MpegEncContext * s,
 464                                   int mx, int my)
 465 {
 466     int code;
 467     MVTable *mv;
 468
 469     /* modulo encoding */
 470     /* WARNING : you cannot reach all the MVs even with the modulo
 471        encoding. This is a somewhat strange compromise they took !!!  */
 472     if (mx <= -64)
 473         mx += 64;
 474     else if (mx >= 64)
 475         mx -= 64;
 476     if (my <= -64)
 477         my += 64;
 478     else if (my >= 64)
 479         my -= 64;
 480
 481     mx += 32;
 482     my += 32;
 483 #if 0
 484     if ((unsigned)mx >= 64 ||
 485         (unsigned)my >= 64)
 486         fprintf(stderr, "error mx=%d my=%d\n", mx, my);
 487 #endif
 488     mv = &mv_tables[s->mv_table_index];
 489
 490     code = mv->table_mv_index[(mx << 6) | my];
 491     set_stat(ST_MV);
 492     put_bits(&s->pb,
 493              mv->table_mv_bits[code],
 494              mv->table_mv_code[code]);
 495     if (code == mv->n) {
 496         /* escape : code litterally */
 497         put_bits(&s->pb, 6, mx);
 498         put_bits(&s->pb, 6, my);
 499     }
 500 }
 501
 502 static inline void handle_slices(MpegEncContext *s){
 503     if (s->mb_x == 0) {
 504         if (s->slice_height && (s->mb_y % s->slice_height) == 0) {
 505             if(s->msmpeg4_version < 4){
 506                 ff_mpeg4_clean_buffers(s);
 507             }
 508             s->first_slice_line = 1;
 509         } else {
 510             s->first_slice_line = 0;
 511         }
 512     }
 513 }
 514
 515 void msmpeg4_encode_mb(MpegEncContext * s,
 516                        DCTELEM block[6][64],
 517                        int motion_x, int motion_y)
 518 {
 519     int cbp, coded_cbp, i;
 520     int pred_x, pred_y;
 521     UINT8 *coded_block;
 522
 523     handle_slices(s);
 524
 525     if (!s->mb_intra) {
 526         /* compute cbp */
 527         set_stat(ST_INTER_MB);
 528         cbp = 0;
 529         for (i = 0; i < 6; i++) {
 530             if (s->block_last_index[i] >= 0)
 531                 cbp |= 1 << (5 - i);
 532         }
 533         if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) {
 534             /* skip macroblock */
 535             put_bits(&s->pb, 1, 1);
 536             return;
 537         }
 538         if (s->use_skip_mb_code)
 539             put_bits(&s->pb, 1, 0);     /* mb coded */
 540
 541         if(s->msmpeg4_version<=2){
 542             put_bits(&s->pb,
 543                      v2_mb_type[cbp&3][1],
 544                      v2_mb_type[cbp&3][0]);
 545             if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C;
 546             else             coded_cbp= cbp;
 547
 548             put_bits(&s->pb,
 549                      cbpy_tab[coded_cbp>>2][1],
 550                      cbpy_tab[coded_cbp>>2][0]);
 551
 552             h263_pred_motion(s, 0, &pred_x, &pred_y);
 553             msmpeg4v2_encode_motion(s, motion_x - pred_x);
 554             msmpeg4v2_encode_motion(s, motion_y - pred_y);
 555         }else{
 556             put_bits(&s->pb,
 557                      table_mb_non_intra[cbp + 64][1],
 558                      table_mb_non_intra[cbp + 64][0]);
 559
 560             /* motion vector */
 561             h263_pred_motion(s, 0, &pred_x, &pred_y);
 562             msmpeg4_encode_motion(s, motion_x - pred_x,
 563                                   motion_y - pred_y);
 564         }
 565     } else {
 566         /* compute cbp */
 567         cbp = 0;
 568         coded_cbp = 0;
 569         for (i = 0; i < 6; i++) {
 570             int val, pred;
 571             val = (s->block_last_index[i] >= 1);
 572             cbp |= val << (5 - i);
 573             if (i < 4) {
 574                 /* predict value for close blocks only for luma */
 575                 pred = coded_block_pred(s, i, &coded_block);
 576                 *coded_block = val;
 577                 val = val ^ pred;
 578             }
 579             coded_cbp |= val << (5 - i);
 580         }
 581 #if 0
 582         if (coded_cbp)
 583             printf("cbp=%x %x\n", cbp, coded_cbp);
 584 #endif
 585
 586         if(s->msmpeg4_version<=2){
 587             if (s->pict_type == I_TYPE) {
 588                 put_bits(&s->pb,
 589                          v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]);
 590             } else {
 591                 if (s->use_skip_mb_code)
 592                     put_bits(&s->pb, 1, 0);     /* mb coded */
 593                 put_bits(&s->pb,
 594                          v2_mb_type[(cbp&3) + 4][1],
 595                          v2_mb_type[(cbp&3) + 4][0]);
 596             }
 597             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
 598             put_bits(&s->pb,
 599                      cbpy_tab[cbp>>2][1],
 600                      cbpy_tab[cbp>>2][0]);
 601         }else{
 602             if (s->pict_type == I_TYPE) {
 603                 set_stat(ST_INTRA_MB);
 604                 put_bits(&s->pb,
 605                          table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);
 606             } else {
 607                 if (s->use_skip_mb_code)
 608                     put_bits(&s->pb, 1, 0);     /* mb coded */
 609                 put_bits(&s->pb,
 610                          table_mb_non_intra[cbp][1],
 611                          table_mb_non_intra[cbp][0]);
 612             }
 613             set_stat(ST_INTRA_MB);
 614             put_bits(&s->pb, 1, 0);     /* no AC prediction yet */
 615             if(s->inter_intra_pred){
 616                 s->h263_aic_dir=0;
 617                 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]);
 618             }
 619         }
 620     }
 621
 622     for (i = 0; i < 6; i++) {
 623         msmpeg4_encode_block(s, block[i], i);
 624     }
 625 }
 626
 627 /* old ffmpeg msmpeg4v3 mode */
 628 void ff_old_msmpeg4_dc_scale(MpegEncContext * s)
 629 {
 630     if (s->qscale < 5){
 631         s->y_dc_scale = 8;
 632         s->c_dc_scale = 8;
 633     }else if (s->qscale < 9){
 634         s->y_dc_scale = 2 * s->qscale;
 635         s->c_dc_scale = (s->qscale + 13)>>1;
 636     }else{
 637         s->y_dc_scale = s->qscale + 8;
 638         s->c_dc_scale = (s->qscale + 13)>>1;
 639     }
 640 }
 641
 642 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
 643                                     INT32 **dc_val_ptr)
 644 {
 645     int i;
 646
 647     if (n < 4) {
 648         i= 0;
 649     } else {
 650         i= n-3;
 651     }
 652
 653     *dc_val_ptr= &s->last_dc[i];
 654     return s->last_dc[i];
 655 }
 656
 657 static int get_dc(uint8_t *src, int stride, int scale)
 658 {
 659     int y;
 660     int sum=0;
 661     for(y=0; y<8; y++){
 662         int x;
 663         for(x=0; x<8; x++){
 664             sum+=src[x + y*stride];
 665         }
 666     }
 667     return (sum + (scale>>1))/scale;
 668 }
 669
 670 /* dir = 0: left, dir = 1: top prediction */
 671 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n,
 672                              UINT16 **dc_val_ptr, int *dir_ptr)
 673 {
 674     int a, b, c, wrap, pred, scale;
 675     INT16 *dc_val;
 676
 677     /* find prediction */
 678     if (n < 4) {
 679         scale = s->y_dc_scale;
 680     } else {
 681         scale = s->c_dc_scale;
 682     }
 683
 684     wrap = s->block_wrap[n];
 685     dc_val= s->dc_val[0] + s->block_index[n];
 686
 687     /* B C
 688      * A X
 689      */
 690     a = dc_val[ - 1];
 691     b = dc_val[ - 1 - wrap];
 692     c = dc_val[ - wrap];
 693
 694     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
 695         b=c=1024;
 696     }
 697
 698     /* XXX: the following solution consumes divisions, but it does not
 699        necessitate to modify mpegvideo.c. The problem comes from the
 700        fact they decided to store the quantized DC (which would lead
 701        to problems if Q could vary !) */
 702 #if defined ARCH_X86 && !defined PIC
 703     asm volatile(
 704         "movl %3, %%eax         \n\t"
 705         "shrl $1, %%eax         \n\t"
 706         "addl %%eax, %2         \n\t"
 707         "addl %%eax, %1         \n\t"
 708         "addl %0, %%eax         \n\t"
 709         "mull %4                \n\t"
 710         "movl %%edx, %0         \n\t"
 711         "movl %1, %%eax         \n\t"
 712         "mull %4                \n\t"
 713         "movl %%edx, %1         \n\t"
 714         "movl %2, %%eax         \n\t"
 715         "mull %4                \n\t"
 716         "movl %%edx, %2         \n\t"
 717         : "+b" (a), "+c" (b), "+D" (c)
 718         : "g" (scale), "S" (inverse[scale])
 719         : "%eax", "%edx"
 720     );
 721 #else
 722     /* #elif defined (ARCH_ALPHA) */
 723     /* Divisions are extremely costly on Alpha; optimize the most
 724        common case. But they are costly everywhere...
 725      */
 726     if (scale == 8) {
 727         a = (a + (8 >> 1)) / 8;
 728         b = (b + (8 >> 1)) / 8;
 729         c = (c + (8 >> 1)) / 8;
 730     } else {
 731         a = (a + (scale >> 1)) / scale;
 732         b = (b + (scale >> 1)) / scale;
 733         c = (c + (scale >> 1)) / scale;
 734     }
 735 #endif
 736     /* XXX: WARNING: they did not choose the same test as MPEG4. This
 737        is very important ! */
 738     if(s->msmpeg4_version>3){
 739         if(s->inter_intra_pred){
 740             uint8_t *dest;
 741             int wrap;
 742
 743             if(n==1){
 744                 pred=a;
 745                 *dir_ptr = 0;
 746             }else if(n==2){
 747                 pred=c;
 748                 *dir_ptr = 1;
 749             }else if(n==3){
 750                 if (abs(a - b) < abs(b - c)) {
 751                     pred = c;
 752                     *dir_ptr = 1;
 753                 } else {
 754                     pred = a;
 755                     *dir_ptr = 0;
 756                 }
 757             }else{
 758                 if(n<4){
 759                     wrap= s->linesize;
 760                     dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8*  wrap ) + ((n&1) + 2*s->mb_x) * 8;
 761                 }else{
 762                     wrap= s->uvlinesize;
 763                     dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
 764                 }
 765                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
 766                 else           a= get_dc(dest-8, wrap, scale*8);
 767                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
 768                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
 769
 770                 if (s->h263_aic_dir==0) {
 771                     pred= a;
 772                     *dir_ptr = 0;
 773                 }else if (s->h263_aic_dir==1) {
 774                     if(n==0){
 775                         pred= c;
 776                         *dir_ptr = 1;
 777                     }else{
 778                         pred= a;
 779                         *dir_ptr = 0;
 780                     }
 781                 }else if (s->h263_aic_dir==2) {
 782                     if(n==0){
 783                         pred= a;
 784                         *dir_ptr = 0;
 785                     }else{
 786                         pred= c;
 787                         *dir_ptr = 1;
 788                     }
 789                 } else {
 790                     pred= c;
 791                     *dir_ptr = 1;
 792                 }
 793             }
 794         }else{
 795             if (abs(a - b) < abs(b - c)) {
 796                 pred = c;
 797                 *dir_ptr = 1;
 798             } else {
 799                 pred = a;
 800                 *dir_ptr = 0;
 801             }
 802         }
 803     }else{
 804         if (abs(a - b) <= abs(b - c)) {
 805             pred = c;
 806             *dir_ptr = 1;
 807         } else {
 808             pred = a;
 809             *dir_ptr = 0;
 810         }
 811     }
 812
 813     /* update predictor */
 814     *dc_val_ptr = &dc_val[0];
 815     return pred;
 816 }
 817
 818 #define DC_MAX 119
 819
 820 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr)
 821 {
 822     int sign, code;
 823     int pred;
 824
 825     if(s->msmpeg4_version==1){
 826         INT32 *dc_val;
 827         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 828
 829         /* update predictor */
 830         *dc_val= level;
 831     }else{
 832         UINT16 *dc_val;
 833         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 834
 835         /* update predictor */
 836         if (n < 4) {
 837             *dc_val = level * s->y_dc_scale;
 838         } else {
 839             *dc_val = level * s->c_dc_scale;
 840         }
 841     }
 842
 843     /* do the prediction */
 844     level -= pred;
 845
 846     if(s->msmpeg4_version<=2){
 847         if (n < 4) {
 848             put_bits(&s->pb,
 849                      v2_dc_lum_table[level+256][1],
 850                      v2_dc_lum_table[level+256][0]);
 851         }else{
 852             put_bits(&s->pb,
 853                      v2_dc_chroma_table[level+256][1],
 854                      v2_dc_chroma_table[level+256][0]);
 855         }
 856     }else{
 857         sign = 0;
 858         if (level < 0) {
 859             level = -level;
 860             sign = 1;
 861         }
 862         code = level;
 863         if (code > DC_MAX)
 864             code = DC_MAX;
 865
 866         if (s->dc_table_index == 0) {
 867             if (n < 4) {
 868                 put_bits(&s->pb, table0_dc_lum[code][1], table0_dc_lum[code][0]);
 869             } else {
 870                 put_bits(&s->pb, table0_dc_chroma[code][1], table0_dc_chroma[code][0]);
 871             }
 872         } else {
 873             if (n < 4) {
 874                 put_bits(&s->pb, table1_dc_lum[code][1], table1_dc_lum[code][0]);
 875             } else {
 876                 put_bits(&s->pb, table1_dc_chroma[code][1], table1_dc_chroma[code][0]);
 877             }
 878         }
 879
 880         if (code == DC_MAX)
 881             put_bits(&s->pb, 8, level);
 882
 883         if (level != 0) {
 884             put_bits(&s->pb, 1, sign);
 885         }
 886     }
 887 }
 888
 889 /* Encoding of a block. Very similar to MPEG4 except for a different
 890    escape coding (same as H263) and more vlc tables.
 891  */
 892 static inline void msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 893 {
 894     int level, run, last, i, j, last_index;
 895     int last_non_zero, sign, slevel;
 896     int code, run_diff, dc_pred_dir;
 897     const RLTable *rl;
 898     const UINT8 *scantable;
 899
 900     if (s->mb_intra) {
 901         set_stat(ST_DC);
 902         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 903         i = 1;
 904         if (n < 4) {
 905             rl = &rl_table[s->rl_table_index];
 906         } else {
 907             rl = &rl_table[3 + s->rl_chroma_table_index];
 908         }
 909         run_diff = 0;
 910         scantable= s->intra_scantable.permutated;
 911         set_stat(ST_INTRA_AC);
 912     } else {
 913         i = 0;
 914         rl = &rl_table[3 + s->rl_table_index];
 915         if(s->msmpeg4_version<=2)
 916             run_diff = 0;
 917         else
 918             run_diff = 1;
 919         scantable= s->inter_scantable.permutated;
 920         set_stat(ST_INTER_AC);
 921     }
 922
 923     /* recalculate block_last_index for M$ wmv1 */
 924     if(s->msmpeg4_version>=4 && s->block_last_index[n]>0){
 925         for(last_index=63; last_index>=0; last_index--){
 926             if(block[scantable[last_index]]) break;
 927         }
 928         s->block_last_index[n]= last_index;
 929     }else
 930         last_index = s->block_last_index[n];
 931     /* AC coefs */
 932     last_non_zero = i - 1;
 933     for (; i <= last_index; i++) {
 934         j = scantable[i];
 935         level = block[j];
 936         if (level) {
 937             run = i - last_non_zero - 1;
 938             last = (i == last_index);
 939             sign = 0;
 940             slevel = level;
 941             if (level < 0) {
 942                 sign = 1;
 943                 level = -level;
 944             }
 945
 946             if(level<=MAX_LEVEL && run<=MAX_RUN){
 947                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
 948             }
 949 #if 0
 950 else
 951     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
 952 #endif
 953             code = get_rl_index(rl, last, run, level);
 954             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 955             if (code == rl->n) {
 956                 int level1, run1;
 957
 958                 level1 = level - rl->max_level[last][run];
 959                 if (level1 < 1)
 960                     goto esc2;
 961                 code = get_rl_index(rl, last, run, level1);
 962                 if (code == rl->n) {
 963                 esc2:
 964                     put_bits(&s->pb, 1, 0);
 965                     if (level > MAX_LEVEL)
 966                         goto esc3;
 967                     run1 = run - rl->max_run[last][level] - run_diff;
 968                     if (run1 < 0)
 969                         goto esc3;
 970                     code = get_rl_index(rl, last, run1, level);
 971                     if (code == rl->n) {
 972                     esc3:
 973                         /* third escape */
 974                         put_bits(&s->pb, 1, 0);
 975                         put_bits(&s->pb, 1, last);
 976                         if(s->msmpeg4_version>=4){
 977                             if(s->esc3_level_length==0){
 978                                 s->esc3_level_length=8;
 979                                 s->esc3_run_length= 6;
 980                                 if(s->qscale<8)
 981                                     put_bits(&s->pb, 6, 3);
 982                                 else
 983                                     put_bits(&s->pb, 8, 3);
 984                             }
 985                             put_bits(&s->pb, s->esc3_run_length, run);
 986                             put_bits(&s->pb, 1, sign);
 987                             put_bits(&s->pb, s->esc3_level_length, level);
 988                         }else{
 989                             put_bits(&s->pb, 6, run);
 990                             put_bits(&s->pb, 8, slevel & 0xff);
 991                         }
 992                     } else {
 993                         /* second escape */
 994                         put_bits(&s->pb, 1, 1);
 995                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 996                         put_bits(&s->pb, 1, sign);
 997                     }
 998                 } else {
 999                     /* first escape */
1000                     put_bits(&s->pb, 1, 1);
1001                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1002                     put_bits(&s->pb, 1, sign);
1003                 }
1004             } else {
1005                 put_bits(&s->pb, 1, sign);
1006             }
1007             last_non_zero = i;
1008         }
1009     }
1010 }
1011
1012 /****************************************/
1013 /* decoding stuff */
1014
1015 static VLC mb_non_intra_vlc[4];
1016 static VLC mb_intra_vlc;
1017 static VLC dc_lum_vlc[2];
1018 static VLC dc_chroma_vlc[2];
1019 static VLC v2_dc_lum_vlc;
1020 static VLC v2_dc_chroma_vlc;
1021 static VLC cbpy_vlc;
1022 static VLC v2_intra_cbpc_vlc;
1023 static VLC v2_mb_type_vlc;
1024 static VLC v2_mv_vlc;
1025 static VLC v1_intra_cbpc_vlc;
1026 static VLC v1_inter_cbpc_vlc;
1027 static VLC inter_intra_vlc;
1028
1029 /* this table is practically identical to the one from h263 except that its inverted */
1030 static void init_h263_dc_for_msmpeg4(void)
1031 {
1032         int level, uni_code, uni_len;
1033
1034         for(level=-256; level<256; level++){
1035             int size, v, l;
1036             /* find number of bits */
1037             size = 0;
1038             v = abs(level);
1039             while (v) {
1040                 v >>= 1;
1041                     size++;
1042             }
1043
1044             if (level < 0)
1045                 l= (-level) ^ ((1 << size) - 1);
1046             else
1047                 l= level;
1048
1049             /* luminance h263 */
1050             uni_code= DCtab_lum[size][0];
1051             uni_len = DCtab_lum[size][1];
1052             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1053
1054             if (size > 0) {
1055                 uni_code<<=size; uni_code|=l;
1056                 uni_len+=size;
1057                 if (size > 8){
1058                     uni_code<<=1; uni_code|=1;
1059                     uni_len++;
1060                 }
1061             }
1062             v2_dc_lum_table[level+256][0]= uni_code;
1063             v2_dc_lum_table[level+256][1]= uni_len;
1064
1065             /* chrominance h263 */
1066             uni_code= DCtab_chrom[size][0];
1067             uni_len = DCtab_chrom[size][1];
1068             uni_code ^= (1<<uni_len)-1; //M$ doesnt like compatibility
1069
1070             if (size > 0) {
1071                 uni_code<<=size; uni_code|=l;
1072                 uni_len+=size;
1073                 if (size > 8){
1074                     uni_code<<=1; uni_code|=1;
1075                     uni_len++;
1076                 }
1077             }
1078             v2_dc_chroma_table[level+256][0]= uni_code;
1079             v2_dc_chroma_table[level+256][1]= uni_len;
1080
1081         }
1082 }
1083
1084 /* init all vlc decoding tables */
1085 int ff_msmpeg4_decode_init(MpegEncContext *s)
1086 {
1087     static int done = 0;
1088     int i;
1089     MVTable *mv;
1090
1091     common_init(s);
1092
1093     if (!done) {
1094         done = 1;
1095
1096         for(i=0;i<NB_RL_TABLES;i++) {
1097             init_rl(&rl_table[i]);
1098             init_vlc_rl(&rl_table[i]);
1099         }
1100         for(i=0;i<2;i++) {
1101             mv = &mv_tables[i];
1102             init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1103                      mv->table_mv_bits, 1, 1,
1104                      mv->table_mv_code, 2, 2);
1105         }
1106
1107         init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120,
1108                  &table0_dc_lum[0][1], 8, 4,
1109                  &table0_dc_lum[0][0], 8, 4);
1110         init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120,
1111                  &table0_dc_chroma[0][1], 8, 4,
1112                  &table0_dc_chroma[0][0], 8, 4);
1113         init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120,
1114                  &table1_dc_lum[0][1], 8, 4,
1115                  &table1_dc_lum[0][0], 8, 4);
1116         init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120,
1117                  &table1_dc_chroma[0][1], 8, 4,
1118                  &table1_dc_chroma[0][0], 8, 4);
1119
1120         init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1121                  &v2_dc_lum_table[0][1], 8, 4,
1122                  &v2_dc_lum_table[0][0], 8, 4);
1123         init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1124                  &v2_dc_chroma_table[0][1], 8, 4,
1125                  &v2_dc_chroma_table[0][0], 8, 4);
1126
1127         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1128                  &cbpy_tab[0][1], 2, 1,
1129                  &cbpy_tab[0][0], 2, 1);
1130         init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1131                  &v2_intra_cbpc[0][1], 2, 1,
1132                  &v2_intra_cbpc[0][0], 2, 1);
1133         init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1134                  &v2_mb_type[0][1], 2, 1,
1135                  &v2_mb_type[0][0], 2, 1);
1136         init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1137                  &mvtab[0][1], 2, 1,
1138                  &mvtab[0][0], 2, 1);
1139
1140         for(i=0; i<4; i++){
1141             init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1142                      &wmv2_inter_table[i][0][1], 8, 4,
1143                      &wmv2_inter_table[i][0][0], 8, 4); //FIXME name?
1144         }
1145
1146         init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64,
1147                  &table_mb_intra[0][1], 4, 2,
1148                  &table_mb_intra[0][0], 4, 2);
1149
1150         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1151                  intra_MCBPC_bits, 1, 1,
1152                  intra_MCBPC_code, 1, 1);
1153         init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1154                  inter_MCBPC_bits, 1, 1,
1155                  inter_MCBPC_code, 1, 1);
1156
1157         init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1158                  &table_inter_intra[0][1], 2, 1,
1159                  &table_inter_intra[0][0], 2, 1);
1160     }
1161
1162     switch(s->msmpeg4_version){
1163     case 1:
1164     case 2:
1165         s->decode_mb= msmpeg4v12_decode_mb;
1166         break;
1167     case 3:
1168     case 4:
1169         s->decode_mb= msmpeg4v34_decode_mb;
1170         break;
1171     case 5:
1172         s->decode_mb= wmv2_decode_mb;
1173         break;
1174     }
1175
1176     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1177
1178     return 0;
1179 }
1180
1181 static int decode012(GetBitContext *gb)
1182 {
1183     int n;
1184     n = get_bits1(gb);
1185     if (n == 0)
1186         return 0;
1187     else
1188         return get_bits1(gb) + 1;
1189 }
1190
1191 int msmpeg4_decode_picture_header(MpegEncContext * s)
1192 {
1193     int code;
1194
1195 #if 0
1196 {
1197 int i;
1198 for(i=0; i<s->gb.size_in_bits; i++)
1199     printf("%d", get_bits1(&s->gb));
1200 //    get_bits1(&s->gb);
1201 printf("END\n");
1202 return -1;
1203 }
1204 #endif
1205
1206     if(s->msmpeg4_version==1){
1207         int start_code, num;
1208         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1209         if(start_code!=0x00000100){
1210             fprintf(stderr, "invalid startcode\n");
1211             return -1;
1212         }
1213
1214         num= get_bits(&s->gb, 5); // frame number */
1215     }
1216
1217     s->pict_type = get_bits(&s->gb, 2) + 1;
1218     if (s->pict_type != I_TYPE &&
1219         s->pict_type != P_TYPE){
1220         fprintf(stderr, "invalid picture type\n");
1221         return -1;
1222     }
1223 #if 0
1224 {
1225     static int had_i=0;
1226     if(s->pict_type == I_TYPE) had_i=1;
1227     if(!had_i) return -1;
1228 }
1229 #endif
1230     s->qscale = get_bits(&s->gb, 5);
1231
1232     if (s->pict_type == I_TYPE) {
1233         code = get_bits(&s->gb, 5);
1234         if(s->msmpeg4_version==1){
1235             if(code==0 || code>s->mb_height){
1236                 fprintf(stderr, "invalid slice height %d\n", code);
1237                 return -1;
1238             }
1239
1240             s->slice_height = code;
1241         }else{
1242             /* 0x17: one slice, 0x18: two slices, ... */
1243             if (code < 0x17){
1244                 fprintf(stderr, "error, slice code was %X\n", code);
1245                 return -1;
1246             }
1247
1248             s->slice_height = s->mb_height / (code - 0x16);
1249         }
1250
1251         switch(s->msmpeg4_version){
1252         case 1:
1253         case 2:
1254             s->rl_chroma_table_index = 2;
1255             s->rl_table_index = 2;
1256
1257             s->dc_table_index = 0; //not used
1258             break;
1259         case 3:
1260             s->rl_chroma_table_index = decode012(&s->gb);
1261             s->rl_table_index = decode012(&s->gb);
1262
1263             s->dc_table_index = get_bits1(&s->gb);
1264             break;
1265         case 4:
1266             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1267
1268             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1269             else                           s->per_mb_rl_table= 0;
1270
1271             if(!s->per_mb_rl_table){
1272                 s->rl_chroma_table_index = decode012(&s->gb);
1273                 s->rl_table_index = decode012(&s->gb);
1274             }
1275
1276             s->dc_table_index = get_bits1(&s->gb);
1277             s->inter_intra_pred= 0;
1278             break;
1279         }
1280         s->no_rounding = 1;
1281 /*      printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1282                 s->qscale,
1283                 s->rl_chroma_table_index,
1284                 s->rl_table_index,
1285                 s->dc_table_index,
1286                 s->per_mb_rl_table,
1287                 s->slice_height);*/
1288     } else {
1289         switch(s->msmpeg4_version){
1290         case 1:
1291         case 2:
1292             if(s->msmpeg4_version==1)
1293                 s->use_skip_mb_code = 1;
1294             else
1295                 s->use_skip_mb_code = get_bits1(&s->gb);
1296             s->rl_table_index = 2;
1297             s->rl_chroma_table_index = s->rl_table_index;
1298             s->dc_table_index = 0; //not used
1299             s->mv_table_index = 0;
1300             break;
1301         case 3:
1302             s->use_skip_mb_code = get_bits1(&s->gb);
1303             s->rl_table_index = decode012(&s->gb);
1304             s->rl_chroma_table_index = s->rl_table_index;
1305
1306             s->dc_table_index = get_bits1(&s->gb);
1307
1308             s->mv_table_index = get_bits1(&s->gb);
1309             break;
1310         case 4:
1311             s->use_skip_mb_code = get_bits1(&s->gb);
1312
1313             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1314             else                           s->per_mb_rl_table= 0;
1315
1316             if(!s->per_mb_rl_table){
1317                 s->rl_table_index = decode012(&s->gb);
1318                 s->rl_chroma_table_index = s->rl_table_index;
1319             }
1320
1321             s->dc_table_index = get_bits1(&s->gb);
1322
1323             s->mv_table_index = get_bits1(&s->gb);
1324             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1325             break;
1326         }
1327 /*      printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1328                 s->use_skip_mb_code,
1329                 s->rl_table_index,
1330                 s->rl_chroma_table_index,
1331                 s->dc_table_index,
1332                 s->mv_table_index,
1333                 s->per_mb_rl_table,
1334                 s->qscale);*/
1335         if(s->flipflop_rounding){
1336             s->no_rounding ^= 1;
1337         }else{
1338             s->no_rounding = 0;
1339         }
1340     }
1341 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1342
1343     s->esc3_level_length= 0;
1344     s->esc3_run_length= 0;
1345
1346 #ifdef DEBUG
1347     printf("*****frame %d:\n", frame_count++);
1348 #endif
1349     return 0;
1350 }
1351
1352 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1353 {
1354     int left= buf_size*8 - get_bits_count(&s->gb);
1355     int length= s->msmpeg4_version>=3 ? 17 : 16;
1356     /* the alt_bitstream reader could read over the end so we need to check it */
1357     if(left>=length && left<length+8)
1358     {
1359         int fps;
1360
1361         fps= get_bits(&s->gb, 5);
1362         s->bit_rate= get_bits(&s->gb, 11)*1024;
1363         if(s->msmpeg4_version>=3)
1364             s->flipflop_rounding= get_bits1(&s->gb);
1365         else
1366             s->flipflop_rounding= 0;
1367
1368 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1369     }
1370     else if(left<length+8)
1371     {
1372         s->flipflop_rounding= 0;
1373         printf("ext header missing, %d left\n", left);
1374     }
1375     else
1376     {
1377         fprintf(stderr, "I frame too long, ignoring ext header\n");
1378     }
1379
1380     return 0;
1381 }
1382
1383 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1384 {
1385     int i;
1386     for(i=0;i<n;i++)
1387         tab[i] = val;
1388 }
1389
1390 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1391 {
1392     int range, bit_size, sign, code, bits;
1393
1394     if (val == 0) {
1395         /* zero vector */
1396         code = 0;
1397         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1398     } else {
1399         bit_size = s->f_code - 1;
1400         range = 1 << bit_size;
1401         if (val <= -64)
1402             val += 64;
1403         else if (val >= 64)
1404             val -= 64;
1405
1406         if (val >= 0) {
1407             sign = 0;
1408         } else {
1409             val = -val;
1410             sign = 1;
1411         }
1412         val--;
1413         code = (val >> bit_size) + 1;
1414         bits = val & (range - 1);
1415
1416         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1417         if (bit_size > 0) {
1418             put_bits(&s->pb, bit_size, bits);
1419         }
1420     }
1421 }
1422
1423 /* this is identical to h263 except that its range is multiplied by 2 */
1424 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1425 {
1426     int code, val, sign, shift;
1427
1428     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1429 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1430     if (code < 0)
1431         return 0xffff;
1432
1433     if (code == 0)
1434         return pred;
1435     sign = get_bits1(&s->gb);
1436     shift = f_code - 1;
1437     val = (code - 1) << shift;
1438     if (shift > 0)
1439         val |= get_bits(&s->gb, shift);
1440     val++;
1441     if (sign)
1442         val = -val;
1443
1444     val += pred;
1445     if (val <= -64)
1446         val += 64;
1447     else if (val >= 64)
1448         val -= 64;
1449
1450     return val;
1451 }
1452
1453 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1454 {
1455     int cbp, code, i;
1456
1457     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1458
1459     if (s->pict_type == P_TYPE) {
1460         if (s->use_skip_mb_code) {
1461             if (get_bits1(&s->gb)) {
1462                 /* skip mb */
1463                 s->mb_intra = 0;
1464                 for(i=0;i<6;i++)
1465                     s->block_last_index[i] = -1;
1466                 s->mv_dir = MV_DIR_FORWARD;
1467                 s->mv_type = MV_TYPE_16X16;
1468                 s->mv[0][0][0] = 0;
1469                 s->mv[0][0][1] = 0;
1470                 s->mb_skiped = 1;
1471                 return 0;
1472             }
1473         }
1474
1475         if(s->msmpeg4_version==2)
1476             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1477         else
1478             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1479         if(code<0 || code>7){
1480             fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1481             return -1;
1482         }
1483
1484         s->mb_intra = code >>2;
1485
1486         cbp = code & 0x3;
1487     } else {
1488         s->mb_intra = 1;
1489         if(s->msmpeg4_version==2)
1490             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1491         else
1492             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1493         if(cbp<0 || cbp>3){
1494             fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1495             return -1;
1496         }
1497     }
1498
1499     if (!s->mb_intra) {
1500         int mx, my, cbpy;
1501
1502         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1503         if(cbpy<0){
1504             fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1505             return -1;
1506         }
1507
1508         cbp|= cbpy<<2;
1509         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1510
1511         h263_pred_motion(s, 0, &mx, &my);
1512         mx= msmpeg4v2_decode_motion(s, mx, 1);
1513         my= msmpeg4v2_decode_motion(s, my, 1);
1514
1515         s->mv_dir = MV_DIR_FORWARD;
1516         s->mv_type = MV_TYPE_16X16;
1517         s->mv[0][0][0] = mx;
1518         s->mv[0][0][1] = my;
1519     } else {
1520         if(s->msmpeg4_version==2){
1521             s->ac_pred = get_bits1(&s->gb);
1522             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1523         } else{
1524             s->ac_pred = 0;
1525             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1526             if(s->pict_type==P_TYPE) cbp^=0x3C;
1527         }
1528     }
1529
1530     for (i = 0; i < 6; i++) {
1531         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1532         {
1533              fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1534              return -1;
1535         }
1536     }
1537     return 0;
1538 }
1539
1540 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1541 {
1542     int cbp, code, i;
1543     UINT8 *coded_val;
1544
1545 #ifdef PRINT_MB
1546 if(s->mb_x==0){
1547     printf("\n");
1548     if(s->mb_y==0) printf("\n");
1549 }
1550 #endif
1551
1552     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1553
1554     if (s->pict_type == P_TYPE) {
1555         set_stat(ST_INTER_MB);
1556         if (s->use_skip_mb_code) {
1557             if (get_bits1(&s->gb)) {
1558                 /* skip mb */
1559                 s->mb_intra = 0;
1560                 for(i=0;i<6;i++)
1561                     s->block_last_index[i] = -1;
1562                 s->mv_dir = MV_DIR_FORWARD;
1563                 s->mv_type = MV_TYPE_16X16;
1564                 s->mv[0][0][0] = 0;
1565                 s->mv[0][0][1] = 0;
1566                 s->mb_skiped = 1;
1567 #ifdef PRINT_MB
1568 printf("S ");
1569 #endif
1570                 return 0;
1571             }
1572         }
1573
1574         code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1575         if (code < 0)
1576             return -1;
1577         //s->mb_intra = (code & 0x40) ? 0 : 1;
1578         s->mb_intra = (~code & 0x40) >> 6;
1579
1580         cbp = code & 0x3f;
1581     } else {
1582         set_stat(ST_INTRA_MB);
1583         s->mb_intra = 1;
1584         code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1585         if (code < 0)
1586             return -1;
1587         /* predict coded block pattern */
1588         cbp = 0;
1589         for(i=0;i<6;i++) {
1590             int val = ((code >> (5 - i)) & 1);
1591             if (i < 4) {
1592                 int pred = coded_block_pred(s, i, &coded_val);
1593                 val = val ^ pred;
1594                 *coded_val = val;
1595             }
1596             cbp |= val << (5 - i);
1597         }
1598     }
1599
1600     if (!s->mb_intra) {
1601         int mx, my;
1602 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1603         if(s->per_mb_rl_table && cbp){
1604             s->rl_table_index = decode012(&s->gb);
1605             s->rl_chroma_table_index = s->rl_table_index;
1606         }
1607         set_stat(ST_MV);
1608         h263_pred_motion(s, 0, &mx, &my);
1609         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1610             return -1;
1611         s->mv_dir = MV_DIR_FORWARD;
1612         s->mv_type = MV_TYPE_16X16;
1613         s->mv[0][0][0] = mx;
1614         s->mv[0][0][1] = my;
1615 #ifdef PRINT_MB
1616 printf("P ");
1617 #endif
1618     } else {
1619 //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));
1620         set_stat(ST_INTRA_MB);
1621         s->ac_pred = get_bits1(&s->gb);
1622 #ifdef PRINT_MB
1623 printf("%c", s->ac_pred ? 'A' : 'I');
1624 #endif
1625         if(s->inter_intra_pred){
1626             s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1627 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1628         }
1629         if(s->per_mb_rl_table && cbp){
1630             s->rl_table_index = decode012(&s->gb);
1631             s->rl_chroma_table_index = s->rl_table_index;
1632         }
1633     }
1634
1635     for (i = 0; i < 6; i++) {
1636         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1637         {
1638             fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1639             return -1;
1640         }
1641     }
1642
1643     return 0;
1644 }
1645 //#define ERROR_DETAILS
1646 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1647                               int n, int coded, const uint8_t *scan_table)
1648 {
1649     int level, i, last, run, run_diff;
1650     int dc_pred_dir;
1651     RLTable *rl;
1652     RL_VLC_ELEM *rl_vlc;
1653     int qmul, qadd;
1654
1655     if (s->mb_intra) {
1656         qmul=1;
1657         qadd=0;
1658
1659         /* DC coef */
1660         set_stat(ST_DC);
1661         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1662 #ifdef PRINT_MB
1663 {
1664     static int c;
1665     if(n==0) c=0;
1666     if(n==4) printf("%X", c);
1667     c+= c +dc_pred_dir;
1668 }
1669 #endif
1670         if (level < 0){
1671             fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1672             if(s->inter_intra_pred) level=0;
1673             else                    return -1;
1674         }
1675         if (n < 4) {
1676             rl = &rl_table[s->rl_table_index];
1677             if(level > 256*s->y_dc_scale){
1678                 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1679                 if(!s->inter_intra_pred) return -1;
1680             }
1681         } else {
1682             rl = &rl_table[3 + s->rl_chroma_table_index];
1683             if(level > 256*s->c_dc_scale){
1684                 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1685                 if(!s->inter_intra_pred) return -1;
1686             }
1687         }
1688         block[0] = level;
1689
1690         run_diff = 0;
1691         i = 0;
1692         if (!coded) {
1693             goto not_coded;
1694         }
1695         if (s->ac_pred) {
1696             if (dc_pred_dir == 0)
1697                 scan_table = s->intra_v_scantable.permutated; /* left */
1698             else
1699                 scan_table = s->intra_h_scantable.permutated; /* top */
1700         } else {
1701             scan_table = s->intra_scantable.permutated;
1702         }
1703         set_stat(ST_INTRA_AC);
1704         rl_vlc= rl->rl_vlc[0];
1705     } else {
1706         qmul = s->qscale << 1;
1707         qadd = (s->qscale - 1) | 1;
1708         i = -1;
1709         rl = &rl_table[3 + s->rl_table_index];
1710
1711         if(s->msmpeg4_version==2)
1712             run_diff = 0;
1713         else
1714             run_diff = 1;
1715
1716         if (!coded) {
1717             s->block_last_index[n] = i;
1718             return 0;
1719         }
1720         if(!scan_table)
1721             scan_table = s->inter_scantable.permutated;
1722         set_stat(ST_INTER_AC);
1723         rl_vlc= rl->rl_vlc[s->qscale];
1724     }
1725   {
1726     OPEN_READER(re, &s->gb);
1727     for(;;) {
1728         UPDATE_CACHE(re, &s->gb);
1729         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1730         if (level==0) {
1731             int cache;
1732             cache= GET_CACHE(re, &s->gb);
1733             /* escape */
1734             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1735                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1736                     /* third escape */
1737                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1738                     UPDATE_CACHE(re, &s->gb);
1739                     if(s->msmpeg4_version<=3){
1740                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1741                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1742                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1743                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1744                     }else{
1745                         int sign;
1746                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1747                         if(!s->esc3_level_length){
1748                             int ll;
1749                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1750                             if(s->qscale<8){
1751                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1752                                 if(ll==0){
1753                                     if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1754                                     SKIP_BITS(re, &s->gb, 1);
1755                                     ll=8;
1756                                 }
1757                             }else{
1758                                 ll=2;
1759                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1760                                     ll++;
1761                                     SKIP_BITS(re, &s->gb, 1);
1762                                 }
1763                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1764                             }
1765
1766                             s->esc3_level_length= ll;
1767                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1768 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1769                             UPDATE_CACHE(re, &s->gb);
1770                         }
1771                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1772                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1773
1774                         sign=  SHOW_UBITS(re, &s->gb, 1);
1775                         SKIP_BITS(re, &s->gb, 1);
1776
1777                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1778                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1779                         if(sign) level= -level;
1780                     }
1781 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1782 #if 0 // waste of time / this will detect very few errors
1783                     {
1784                         const int abs_level= ABS(level);
1785                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1786                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1787                             if(abs_level <= rl->max_level[last][run]){
1788                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1789                                 return DECODING_AC_LOST;
1790                             }
1791                             if(abs_level <= rl->max_level[last][run]*2){
1792                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1793                                 return DECODING_AC_LOST;
1794                             }
1795                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1796                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1797                                 return DECODING_AC_LOST;
1798                             }
1799                         }
1800                     }
1801 #endif
1802                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1803                     if (level>0) level= level * qmul + qadd;
1804                     else         level= level * qmul - qadd;
1805 #if 0 // waste of time too :(
1806                     if(level>2048 || level<-2048){
1807                         fprintf(stderr, "|level| overflow in 3. esc\n");
1808                         return DECODING_AC_LOST;
1809                     }
1810 #endif
1811                     i+= run + 1;
1812                     if(last) i+=192;
1813 #ifdef ERROR_DETAILS
1814                 if(run==66)
1815                     fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1816                 else if((i>62 && i<192) || i>192+63)
1817                     fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1818 #endif
1819                 } else {
1820                     /* second escape */
1821 #if MIN_CACHE_BITS < 23
1822                     LAST_SKIP_BITS(re, &s->gb, 2);
1823                     UPDATE_CACHE(re, &s->gb);
1824 #else
1825                     SKIP_BITS(re, &s->gb, 2);
1826 #endif
1827                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1828                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
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                     fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1834                 else if((i>62 && i<192) || i>192+63)
1835                     fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1836 #endif
1837                 }
1838             } else {
1839                 /* first escape */
1840 #if MIN_CACHE_BITS < 22
1841                 LAST_SKIP_BITS(re, &s->gb, 1);
1842                 UPDATE_CACHE(re, &s->gb);
1843 #else
1844                 SKIP_BITS(re, &s->gb, 1);
1845 #endif
1846                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1847                 i+= run;
1848                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1849                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1850                 LAST_SKIP_BITS(re, &s->gb, 1);
1851 #ifdef ERROR_DETAILS
1852                 if(run==66)
1853                     fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1854                 else if((i>62 && i<192) || i>192+63)
1855                     fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1856 #endif
1857             }
1858         } else {
1859             i+= run;
1860             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1861             LAST_SKIP_BITS(re, &s->gb, 1);
1862 #ifdef ERROR_DETAILS
1863                 if(run==66)
1864                     fprintf(stderr, "illegal vlc code level=%d\n", level);
1865                 else if((i>62 && i<192) || i>192+63)
1866                     fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1867 #endif
1868         }
1869         if (i > 62){
1870             i-= 192;
1871             if(i&(~63)){
1872                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1873                 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1874                     fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1875                     break;
1876                 }else{
1877                     fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1878                     return -1;
1879                 }
1880             }
1881
1882             block[scan_table[i]] = level;
1883             break;
1884         }
1885
1886         block[scan_table[i]] = level;
1887     }
1888     CLOSE_READER(re, &s->gb);
1889   }
1890  not_coded:
1891     if (s->mb_intra) {
1892         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1893         if (s->ac_pred) {
1894             i = 63; /* XXX: not optimal */
1895         }
1896     }
1897     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1898     s->block_last_index[n] = i;
1899
1900     return 0;
1901 }
1902
1903 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1904 {
1905     int level, pred;
1906
1907     if(s->msmpeg4_version<=2){
1908         if (n < 4) {
1909             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1910         } else {
1911             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1912         }
1913         if (level < 0)
1914             return -1;
1915         level-=256;
1916     }else{  //FIXME optimize use unified tables & index
1917         if (n < 4) {
1918             level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1919         } else {
1920             level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1921         }
1922         if (level < 0){
1923             fprintf(stderr, "illegal dc vlc\n");
1924             return -1;
1925         }
1926
1927         if (level == DC_MAX) {
1928             level = get_bits(&s->gb, 8);
1929             if (get_bits1(&s->gb))
1930                 level = -level;
1931         } else if (level != 0) {
1932             if (get_bits1(&s->gb))
1933                 level = -level;
1934         }
1935     }
1936
1937     if(s->msmpeg4_version==1){
1938         INT32 *dc_val;
1939         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1940         level += pred;
1941
1942         /* update predictor */
1943         *dc_val= level;
1944     }else{
1945         UINT16 *dc_val;
1946         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1947         level += pred;
1948
1949         /* update predictor */
1950         if (n < 4) {
1951             *dc_val = level * s->y_dc_scale;
1952         } else {
1953             *dc_val = level * s->c_dc_scale;
1954         }
1955     }
1956
1957     return level;
1958 }
1959
1960 static int msmpeg4_decode_motion(MpegEncContext * s,
1961                                  int *mx_ptr, int *my_ptr)
1962 {
1963     MVTable *mv;
1964     int code, mx, my;
1965
1966     mv = &mv_tables[s->mv_table_index];
1967
1968     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1969     if (code < 0){
1970         fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1971         return -1;
1972     }
1973     if (code == mv->n) {
1974 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1975         mx = get_bits(&s->gb, 6);
1976         my = get_bits(&s->gb, 6);
1977     } else {
1978         mx = mv->table_mvx[code];
1979         my = mv->table_mvy[code];
1980     }
1981
1982     mx += *mx_ptr - 32;
1983     my += *my_ptr - 32;
1984     /* WARNING : they do not do exactly modulo encoding */
1985     if (mx <= -64)
1986         mx += 64;
1987     else if (mx >= 64)
1988         mx -= 64;
1989
1990     if (my <= -64)
1991         my += 64;
1992     else if (my >= 64)
1993         my -= 64;
1994     *mx_ptr = mx;
1995     *my_ptr = my;
1996     return 0;
1997 }
1998
1999 /* cleanest way to support it
2000  * there is too much shared between versions so that we cant have 1 file per version & 1 common
2001  * as allmost everything would be in the common file
2002  */
2003 #include "wmv2.c"