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