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 UINT8 rl_length[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[i][level][run][last]= get_size_of_code(s, &rl_table[  i], last, run, level, 0);
 238                     }
 239                 }
 240             }
 241         }
 242     }
 243 }
 244
 245 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){
 246     int size=0;
 247     int code;
 248     int run_diff= intra ? 0 : 1;
 249
 250     code = get_rl_index(rl, last, run, level);
 251     size+= rl->table_vlc[code][1];
 252     if (code == rl->n) {
 253         int level1, run1;
 254
 255         level1 = level - rl->max_level[last][run];
 256         if (level1 < 1)
 257             goto esc2;
 258         code = get_rl_index(rl, last, run, level1);
 259         if (code == rl->n) {
 260             esc2:
 261             size++;
 262             if (level > MAX_LEVEL)
 263                 goto esc3;
 264             run1 = run - rl->max_run[last][level] - run_diff;
 265             if (run1 < 0)
 266                 goto esc3;
 267             code = get_rl_index(rl, last, run1, level);
 268             if (code == rl->n) {
 269             esc3:
 270                 /* third escape */
 271                 size+=1+1+6+8;
 272             } else {
 273                 /* second escape */
 274                 size+= 1+1+ rl->table_vlc[code][1];
 275             }
 276         } else {
 277             /* first escape */
 278             size+= 1+1+ rl->table_vlc[code][1];
 279         }
 280     } else {
 281         size++;
 282     }
 283     return size;
 284 }
 285
 286 static void find_best_tables(MpegEncContext * s)
 287 {
 288     int i;
 289     int best       =-1, best_size       =9999999;
 290     int chroma_best=-1, best_chroma_size=9999999;
 291
 292     for(i=0; i<3; i++){
 293         int level;
 294         int chroma_size=0;
 295         int size=0;
 296
 297         if(i>0){// ;)
 298             size++;
 299             chroma_size++;
 300         }
 301         for(level=0; level<=MAX_LEVEL; level++){
 302             int run;
 303             for(run=0; run<=MAX_RUN; run++){
 304                 int last;
 305                 const int last_size= size + chroma_size;
 306                 for(last=0; last<2; last++){
 307                     int inter_count       = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last];
 308                     int intra_luma_count  = s->ac_stats[1][0][level][run][last];
 309                     int intra_chroma_count= s->ac_stats[1][1][level][run][last];
 310
 311                     if(s->pict_type==I_TYPE){
 312                         size       += intra_luma_count  *rl_length[i  ][level][run][last];
 313                         chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last];
 314                     }else{
 315                         size+=        intra_luma_count  *rl_length[i  ][level][run][last]
 316                                      +intra_chroma_count*rl_length[i+3][level][run][last]
 317                                      +inter_count       *rl_length[i+3][level][run][last];
 318                     }
 319                 }
 320                 if(last_size == size+chroma_size) break;
 321             }
 322         }
 323         if(size<best_size){
 324             best_size= size;
 325             best= i;
 326         }
 327         if(chroma_size<best_chroma_size){
 328             best_chroma_size= chroma_size;
 329             chroma_best= i;
 330         }
 331     }
 332
 333 //    printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n",
 334 //           s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size);
 335
 336     if(s->pict_type==P_TYPE) chroma_best= best;
 337
 338     memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2);
 339
 340     s->rl_table_index       =        best;
 341     s->rl_chroma_table_index= chroma_best;
 342
 343     if(s->pict_type != s->last_non_b_pict_type){
 344         s->rl_table_index= 2;
 345         if(s->pict_type==I_TYPE)
 346             s->rl_chroma_table_index= 1;
 347         else
 348             s->rl_chroma_table_index= 2;
 349     }
 350
 351 }
 352
 353 /* write MSMPEG4 compatible frame header */
 354 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
 355 {
 356     find_best_tables(s);
 357
 358     align_put_bits(&s->pb);
 359     put_bits(&s->pb, 2, s->pict_type - 1);
 360
 361     put_bits(&s->pb, 5, s->qscale);
 362     if(s->msmpeg4_version<=2){
 363         s->rl_table_index = 2;
 364         s->rl_chroma_table_index = 2;
 365     }
 366
 367     s->dc_table_index = 1;
 368     s->mv_table_index = 1; /* only if P frame */
 369     s->use_skip_mb_code = 1; /* only if P frame */
 370     s->per_mb_rl_table = 0;
 371     if(s->msmpeg4_version==4)
 372         s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==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, FFMIN(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     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame isnt a keyframe
1173
1174     return 0;
1175 }
1176
1177 static int decode012(GetBitContext *gb)
1178 {
1179     int n;
1180     n = get_bits1(gb);
1181     if (n == 0)
1182         return 0;
1183     else
1184         return get_bits1(gb) + 1;
1185 }
1186
1187 int msmpeg4_decode_picture_header(MpegEncContext * s)
1188 {
1189     int code;
1190
1191 #if 0
1192 {
1193 int i;
1194 for(i=0; i<s->gb.size*8; i++)
1195     printf("%d", get_bits1(&s->gb));
1196 //    get_bits1(&s->gb);
1197 printf("END\n");
1198 return -1;
1199 }
1200 #endif
1201
1202     if(s->msmpeg4_version==1){
1203         int start_code, num;
1204         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1205         if(start_code!=0x00000100){
1206             fprintf(stderr, "invalid startcode\n");
1207             return -1;
1208         }
1209
1210         num= get_bits(&s->gb, 5); // frame number */
1211     }
1212
1213     s->pict_type = get_bits(&s->gb, 2) + 1;
1214     if (s->pict_type != I_TYPE &&
1215         s->pict_type != P_TYPE){
1216         fprintf(stderr, "invalid picture type\n");
1217         return -1;
1218     }
1219 #if 0
1220 {
1221     static int had_i=0;
1222     if(s->pict_type == I_TYPE) had_i=1;
1223     if(!had_i) return -1;
1224 }
1225 #endif
1226     s->qscale = get_bits(&s->gb, 5);
1227
1228     if (s->pict_type == I_TYPE) {
1229         code = get_bits(&s->gb, 5);
1230         if(s->msmpeg4_version==1){
1231             if(code==0 || code>s->mb_height){
1232                 fprintf(stderr, "invalid slice height %d\n", code);
1233                 return -1;
1234             }
1235
1236             s->slice_height = code;
1237         }else{
1238             /* 0x17: one slice, 0x18: two slices, ... */
1239             if (code < 0x17){
1240                 fprintf(stderr, "error, slice code was %X\n", code);
1241                 return -1;
1242             }
1243
1244             s->slice_height = s->mb_height / (code - 0x16);
1245         }
1246
1247         switch(s->msmpeg4_version){
1248         case 1:
1249         case 2:
1250             s->rl_chroma_table_index = 2;
1251             s->rl_table_index = 2;
1252
1253             s->dc_table_index = 0; //not used
1254             break;
1255         case 3:
1256             s->rl_chroma_table_index = decode012(&s->gb);
1257             s->rl_table_index = decode012(&s->gb);
1258
1259             s->dc_table_index = get_bits1(&s->gb);
1260             break;
1261         case 4:
1262             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1263
1264             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1265             else                           s->per_mb_rl_table= 0;
1266
1267             if(!s->per_mb_rl_table){
1268                 s->rl_chroma_table_index = decode012(&s->gb);
1269                 s->rl_table_index = decode012(&s->gb);
1270             }
1271
1272             s->dc_table_index = get_bits1(&s->gb);
1273             s->inter_intra_pred= 0;
1274             break;
1275         }
1276         s->no_rounding = 1;
1277 /*      printf("qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1278                 s->qscale,
1279                 s->rl_chroma_table_index,
1280                 s->rl_table_index,
1281                 s->dc_table_index,
1282                 s->per_mb_rl_table,
1283                 s->slice_height);*/
1284     } else {
1285         switch(s->msmpeg4_version){
1286         case 1:
1287         case 2:
1288             if(s->msmpeg4_version==1)
1289                 s->use_skip_mb_code = 1;
1290             else
1291                 s->use_skip_mb_code = get_bits1(&s->gb);
1292             s->rl_table_index = 2;
1293             s->rl_chroma_table_index = s->rl_table_index;
1294             s->dc_table_index = 0; //not used
1295             s->mv_table_index = 0;
1296             break;
1297         case 3:
1298             s->use_skip_mb_code = get_bits1(&s->gb);
1299             s->rl_table_index = decode012(&s->gb);
1300             s->rl_chroma_table_index = s->rl_table_index;
1301
1302             s->dc_table_index = get_bits1(&s->gb);
1303
1304             s->mv_table_index = get_bits1(&s->gb);
1305             break;
1306         case 4:
1307             s->use_skip_mb_code = get_bits1(&s->gb);
1308
1309             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1310             else                           s->per_mb_rl_table= 0;
1311
1312             if(!s->per_mb_rl_table){
1313                 s->rl_table_index = decode012(&s->gb);
1314                 s->rl_chroma_table_index = s->rl_table_index;
1315             }
1316
1317             s->dc_table_index = get_bits1(&s->gb);
1318
1319             s->mv_table_index = get_bits1(&s->gb);
1320             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1321             break;
1322         }
1323 /*      printf("skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1324                 s->use_skip_mb_code,
1325                 s->rl_table_index,
1326                 s->rl_chroma_table_index,
1327                 s->dc_table_index,
1328                 s->mv_table_index,
1329                 s->per_mb_rl_table,
1330                 s->qscale);*/
1331         if(s->flipflop_rounding){
1332             s->no_rounding ^= 1;
1333         }else{
1334             s->no_rounding = 0;
1335         }
1336     }
1337
1338     s->esc3_level_length= 0;
1339     s->esc3_run_length= 0;
1340
1341 #ifdef DEBUG
1342     printf("*****frame %d:\n", frame_count++);
1343 #endif
1344     return 0;
1345 }
1346
1347 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1348 {
1349     int left= buf_size*8 - get_bits_count(&s->gb);
1350     int length= s->msmpeg4_version>=3 ? 17 : 16;
1351     /* the alt_bitstream reader could read over the end so we need to check it */
1352     if(left>=length && left<length+8)
1353     {
1354         int fps;
1355
1356         fps= get_bits(&s->gb, 5);
1357         s->bit_rate= get_bits(&s->gb, 11)*1024;
1358         if(s->msmpeg4_version>=3)
1359             s->flipflop_rounding= get_bits1(&s->gb);
1360         else
1361             s->flipflop_rounding= 0;
1362
1363 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1364     }
1365     else if(left<length+8)
1366     {
1367         s->flipflop_rounding= 0;
1368         printf("ext header missing, %d left\n", left);
1369     }
1370     else
1371     {
1372         fprintf(stderr, "I frame too long, ignoring ext header\n");
1373     }
1374
1375     return 0;
1376 }
1377
1378 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1379 {
1380     int i;
1381     for(i=0;i<n;i++)
1382         tab[i] = val;
1383 }
1384
1385 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1386 {
1387     int range, bit_size, sign, code, bits;
1388
1389     if (val == 0) {
1390         /* zero vector */
1391         code = 0;
1392         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1393     } else {
1394         bit_size = s->f_code - 1;
1395         range = 1 << bit_size;
1396         if (val <= -64)
1397             val += 64;
1398         else if (val >= 64)
1399             val -= 64;
1400
1401         if (val >= 0) {
1402             sign = 0;
1403         } else {
1404             val = -val;
1405             sign = 1;
1406         }
1407         val--;
1408         code = (val >> bit_size) + 1;
1409         bits = val & (range - 1);
1410
1411         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1412         if (bit_size > 0) {
1413             put_bits(&s->pb, bit_size, bits);
1414         }
1415     }
1416 }
1417
1418 /* this is identical to h263 except that its range is multiplied by 2 */
1419 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1420 {
1421     int code, val, sign, shift;
1422
1423     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1424 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1425     if (code < 0)
1426         return 0xffff;
1427
1428     if (code == 0)
1429         return pred;
1430     sign = get_bits1(&s->gb);
1431     shift = f_code - 1;
1432     val = (code - 1) << shift;
1433     if (shift > 0)
1434         val |= get_bits(&s->gb, shift);
1435     val++;
1436     if (sign)
1437         val = -val;
1438
1439     val += pred;
1440     if (val <= -64)
1441         val += 64;
1442     else if (val >= 64)
1443         val -= 64;
1444
1445     return val;
1446 }
1447
1448 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1449 {
1450     int cbp, code, i;
1451
1452     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1453
1454     if (s->pict_type == P_TYPE) {
1455         if (s->use_skip_mb_code) {
1456             if (get_bits1(&s->gb)) {
1457                 /* skip mb */
1458                 s->mb_intra = 0;
1459                 for(i=0;i<6;i++)
1460                     s->block_last_index[i] = -1;
1461                 s->mv_dir = MV_DIR_FORWARD;
1462                 s->mv_type = MV_TYPE_16X16;
1463                 s->mv[0][0][0] = 0;
1464                 s->mv[0][0][1] = 0;
1465                 s->mb_skiped = 1;
1466                 return 0;
1467             }
1468         }
1469
1470         if(s->msmpeg4_version==2)
1471             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1472         else
1473             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1474         if(code<0 || code>7){
1475             fprintf(stderr, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1476             return -1;
1477         }
1478
1479         s->mb_intra = code >>2;
1480
1481         cbp = code & 0x3;
1482     } else {
1483         s->mb_intra = 1;
1484         if(s->msmpeg4_version==2)
1485             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1486         else
1487             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1488         if(cbp<0 || cbp>3){
1489             fprintf(stderr, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1490             return -1;
1491         }
1492     }
1493
1494     if (!s->mb_intra) {
1495         int mx, my, cbpy;
1496
1497         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1498         if(cbpy<0){
1499             fprintf(stderr, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1500             return -1;
1501         }
1502
1503         cbp|= cbpy<<2;
1504         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1505
1506         h263_pred_motion(s, 0, &mx, &my);
1507         mx= msmpeg4v2_decode_motion(s, mx, 1);
1508         my= msmpeg4v2_decode_motion(s, my, 1);
1509
1510         s->mv_dir = MV_DIR_FORWARD;
1511         s->mv_type = MV_TYPE_16X16;
1512         s->mv[0][0][0] = mx;
1513         s->mv[0][0][1] = my;
1514     } else {
1515         if(s->msmpeg4_version==2){
1516             s->ac_pred = get_bits1(&s->gb);
1517             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1518         } else{
1519             s->ac_pred = 0;
1520             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1521             if(s->pict_type==P_TYPE) cbp^=0x3C;
1522         }
1523     }
1524
1525     for (i = 0; i < 6; i++) {
1526         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1527         {
1528              fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1529              return -1;
1530         }
1531     }
1532     return 0;
1533 }
1534
1535 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1536 {
1537     int cbp, code, i;
1538     UINT8 *coded_val;
1539
1540 #ifdef PRINT_MB
1541 if(s->mb_x==0){
1542     printf("\n");
1543     if(s->mb_y==0) printf("\n");
1544 }
1545 #endif
1546
1547     s->error_status_table[s->mb_x + s->mb_y*s->mb_width]= 0;
1548
1549     if (s->pict_type == P_TYPE) {
1550         set_stat(ST_INTER_MB);
1551         if (s->use_skip_mb_code) {
1552             if (get_bits1(&s->gb)) {
1553                 /* skip mb */
1554                 s->mb_intra = 0;
1555                 for(i=0;i<6;i++)
1556                     s->block_last_index[i] = -1;
1557                 s->mv_dir = MV_DIR_FORWARD;
1558                 s->mv_type = MV_TYPE_16X16;
1559                 s->mv[0][0][0] = 0;
1560                 s->mv[0][0][1] = 0;
1561                 s->mb_skiped = 1;
1562 #ifdef PRINT_MB
1563 printf("S ");
1564 #endif
1565                 return 0;
1566             }
1567         }
1568
1569         code = get_vlc2(&s->gb, mb_non_intra_vlc.table, MB_NON_INTRA_VLC_BITS, 3);
1570         if (code < 0)
1571             return -1;
1572         //s->mb_intra = (code & 0x40) ? 0 : 1;
1573         s->mb_intra = (~code & 0x40) >> 6;
1574
1575         cbp = code & 0x3f;
1576     } else {
1577         set_stat(ST_INTRA_MB);
1578         s->mb_intra = 1;
1579         code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);
1580         if (code < 0)
1581             return -1;
1582         /* predict coded block pattern */
1583         cbp = 0;
1584         for(i=0;i<6;i++) {
1585             int val = ((code >> (5 - i)) & 1);
1586             if (i < 4) {
1587                 int pred = coded_block_pred(s, i, &coded_val);
1588                 val = val ^ pred;
1589                 *coded_val = val;
1590             }
1591             cbp |= val << (5 - i);
1592         }
1593     }
1594
1595     if (!s->mb_intra) {
1596         int mx, my;
1597 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1598         if(s->per_mb_rl_table && cbp){
1599             s->rl_table_index = decode012(&s->gb);
1600             s->rl_chroma_table_index = s->rl_table_index;
1601         }
1602         set_stat(ST_MV);
1603         h263_pred_motion(s, 0, &mx, &my);
1604         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1605             return -1;
1606         s->mv_dir = MV_DIR_FORWARD;
1607         s->mv_type = MV_TYPE_16X16;
1608         s->mv[0][0][0] = mx;
1609         s->mv[0][0][1] = my;
1610 #ifdef PRINT_MB
1611 printf("P ");
1612 #endif
1613     } else {
1614 //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));
1615         set_stat(ST_INTRA_MB);
1616         s->ac_pred = get_bits1(&s->gb);
1617 #ifdef PRINT_MB
1618 printf("%c", s->ac_pred ? 'A' : 'I');
1619 #endif
1620         if(s->inter_intra_pred){
1621             s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1622 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1623         }
1624         if(s->per_mb_rl_table && cbp){
1625             s->rl_table_index = decode012(&s->gb);
1626             s->rl_chroma_table_index = s->rl_table_index;
1627         }
1628     }
1629
1630     for (i = 0; i < 6; i++) {
1631         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
1632         {
1633             fprintf(stderr,"\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1634             return -1;
1635         }
1636     }
1637
1638     return 0;
1639 }
1640 //#define ERROR_DETAILS
1641 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1642                               int n, int coded)
1643 {
1644     int level, i, last, run, run_diff;
1645     int dc_pred_dir;
1646     RLTable *rl;
1647     RL_VLC_ELEM *rl_vlc;
1648     const UINT8 *scan_table;
1649     int qmul, qadd;
1650
1651     if (s->mb_intra) {
1652         qmul=1;
1653         qadd=0;
1654
1655         /* DC coef */
1656         set_stat(ST_DC);
1657         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1658 #ifdef PRINT_MB
1659 {
1660     static int c;
1661     if(n==0) c=0;
1662     if(n==4) printf("%X", c);
1663     c+= c +dc_pred_dir;
1664 }
1665 #endif
1666         if (level < 0){
1667             fprintf(stderr, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1668             if(s->inter_intra_pred) level=0;
1669             else                    return -1;
1670         }
1671         if (n < 4) {
1672             rl = &rl_table[s->rl_table_index];
1673             if(level > 256*s->y_dc_scale){
1674                 fprintf(stderr, "dc overflow+ L qscale: %d//\n", s->qscale);
1675                 if(!s->inter_intra_pred) return -1;
1676             }
1677         } else {
1678             rl = &rl_table[3 + s->rl_chroma_table_index];
1679             if(level > 256*s->c_dc_scale){
1680                 fprintf(stderr, "dc overflow+ C qscale: %d//\n", s->qscale);
1681                 if(!s->inter_intra_pred) return -1;
1682             }
1683         }
1684         block[0] = level;
1685
1686         run_diff = 0;
1687         i = 0;
1688         if (!coded) {
1689             goto not_coded;
1690         }
1691         if (s->ac_pred) {
1692             if (dc_pred_dir == 0)
1693                 scan_table = s->intra_v_scantable.permutated; /* left */
1694             else
1695                 scan_table = s->intra_h_scantable.permutated; /* top */
1696         } else {
1697             scan_table = s->intra_scantable.permutated;
1698         }
1699         set_stat(ST_INTRA_AC);
1700         rl_vlc= rl->rl_vlc[0];
1701     } else {
1702         qmul = s->qscale << 1;
1703         qadd = (s->qscale - 1) | 1;
1704         i = -1;
1705         rl = &rl_table[3 + s->rl_table_index];
1706
1707         if(s->msmpeg4_version==2)
1708             run_diff = 0;
1709         else
1710             run_diff = 1;
1711
1712         if (!coded) {
1713             s->block_last_index[n] = i;
1714             return 0;
1715         }
1716         scan_table = s->inter_scantable.permutated;
1717         set_stat(ST_INTER_AC);
1718         rl_vlc= rl->rl_vlc[s->qscale];
1719     }
1720   {
1721     OPEN_READER(re, &s->gb);
1722     for(;;) {
1723         UPDATE_CACHE(re, &s->gb);
1724         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1725         if (level==0) {
1726             int cache;
1727             cache= GET_CACHE(re, &s->gb);
1728             /* escape */
1729             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1730                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1731                     /* third escape */
1732                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1733                     UPDATE_CACHE(re, &s->gb);
1734                     if(s->msmpeg4_version<=3){
1735                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1736                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1737                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1738                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1739                     }else{
1740                         int sign;
1741                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1742                         if(!s->esc3_level_length){
1743                             int ll;
1744                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1745                             if(s->qscale<8){
1746                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1747                                 if(ll==0){
1748                                     if(SHOW_UBITS(re, &s->gb, 1)) printf("cool a new vlc code ,contact the ffmpeg developers and upload the file\n");
1749                                     SKIP_BITS(re, &s->gb, 1);
1750                                     ll=8;
1751                                 }
1752                             }else{
1753                                 ll=2;
1754                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1755                                     ll++;
1756                                     SKIP_BITS(re, &s->gb, 1);
1757                                 }
1758                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1759                             }
1760
1761                             s->esc3_level_length= ll;
1762                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1763 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1764                             UPDATE_CACHE(re, &s->gb);
1765                         }
1766                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1767                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1768
1769                         sign=  SHOW_UBITS(re, &s->gb, 1);
1770                         SKIP_BITS(re, &s->gb, 1);
1771
1772                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1773                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1774                         if(sign) level= -level;
1775                     }
1776 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1777 #if 0 // waste of time / this will detect very few errors
1778                     {
1779                         const int abs_level= ABS(level);
1780                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1781                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1782                             if(abs_level <= rl->max_level[last][run]){
1783                                 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
1784                                 return DECODING_AC_LOST;
1785                             }
1786                             if(abs_level <= rl->max_level[last][run]*2){
1787                                 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
1788                                 return DECODING_AC_LOST;
1789                             }
1790                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1791                                 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
1792                                 return DECODING_AC_LOST;
1793                             }
1794                         }
1795                     }
1796 #endif
1797                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1798                     if (level>0) level= level * qmul + qadd;
1799                     else         level= level * qmul - qadd;
1800 #if 0 // waste of time too :(
1801                     if(level>2048 || level<-2048){
1802                         fprintf(stderr, "|level| overflow in 3. esc\n");
1803                         return DECODING_AC_LOST;
1804                     }
1805 #endif
1806                     i+= run + 1;
1807                     if(last) i+=192;
1808 #ifdef ERROR_DETAILS
1809                 if(run==66)
1810                     fprintf(stderr, "illegal vlc code in ESC3 level=%d\n", level);
1811                 else if((i>62 && i<192) || i>192+63)
1812                     fprintf(stderr, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1813 #endif
1814                 } else {
1815                     /* second escape */
1816 #if MIN_CACHE_BITS < 23
1817                     LAST_SKIP_BITS(re, &s->gb, 2);
1818                     UPDATE_CACHE(re, &s->gb);
1819 #else
1820                     SKIP_BITS(re, &s->gb, 2);
1821 #endif
1822                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1823                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1824                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1825                     LAST_SKIP_BITS(re, &s->gb, 1);
1826 #ifdef ERROR_DETAILS
1827                 if(run==66)
1828                     fprintf(stderr, "illegal vlc code in ESC2 level=%d\n", level);
1829                 else if((i>62 && i<192) || i>192+63)
1830                     fprintf(stderr, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1831 #endif
1832                 }
1833             } else {
1834                 /* first escape */
1835 #if MIN_CACHE_BITS < 22
1836                 LAST_SKIP_BITS(re, &s->gb, 1);
1837                 UPDATE_CACHE(re, &s->gb);
1838 #else
1839                 SKIP_BITS(re, &s->gb, 1);
1840 #endif
1841                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2);
1842                 i+= run;
1843                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1844                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1845                 LAST_SKIP_BITS(re, &s->gb, 1);
1846 #ifdef ERROR_DETAILS
1847                 if(run==66)
1848                     fprintf(stderr, "illegal vlc code in ESC1 level=%d\n", level);
1849                 else if((i>62 && i<192) || i>192+63)
1850                     fprintf(stderr, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1851 #endif
1852             }
1853         } else {
1854             i+= run;
1855             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1856             LAST_SKIP_BITS(re, &s->gb, 1);
1857 #ifdef ERROR_DETAILS
1858                 if(run==66)
1859                     fprintf(stderr, "illegal vlc code level=%d\n", level);
1860                 else if((i>62 && i<192) || i>192+63)
1861                     fprintf(stderr, "run overflow i=%d run=%d level=%d\n", i, run, level);
1862 #endif
1863         }
1864         if (i > 62){
1865             i-= 192;
1866             if(i&(~63)){
1867                 const int left= s->gb.size*8 - get_bits_count(&s->gb);
1868                 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1869                     fprintf(stderr, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1870                     break;
1871                 }else{
1872                     fprintf(stderr, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1873                     return -1;
1874                 }
1875             }
1876
1877             block[scan_table[i]] = level;
1878             break;
1879         }
1880
1881         block[scan_table[i]] = level;
1882     }
1883     CLOSE_READER(re, &s->gb);
1884   }
1885  not_coded:
1886     if (s->mb_intra) {
1887         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1888         if (s->ac_pred) {
1889             i = 63; /* XXX: not optimal */
1890         }
1891     }
1892     if(s->msmpeg4_version==4 && i>0) i=63; //FIXME/XXX optimize
1893     s->block_last_index[n] = i;
1894
1895     return 0;
1896 }
1897
1898 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1899 {
1900     int level, pred;
1901
1902     if(s->msmpeg4_version<=2){
1903         if (n < 4) {
1904             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1905         } else {
1906             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1907         }
1908         if (level < 0)
1909             return -1;
1910         level-=256;
1911     }else{  //FIXME optimize use unified tables & index
1912         if (n < 4) {
1913             level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1914         } else {
1915             level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1916         }
1917         if (level < 0){
1918             fprintf(stderr, "illegal dc vlc\n");
1919             return -1;
1920         }
1921
1922         if (level == DC_MAX) {
1923             level = get_bits(&s->gb, 8);
1924             if (get_bits1(&s->gb))
1925                 level = -level;
1926         } else if (level != 0) {
1927             if (get_bits1(&s->gb))
1928                 level = -level;
1929         }
1930     }
1931
1932     if(s->msmpeg4_version==1){
1933         INT32 *dc_val;
1934         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1935         level += pred;
1936
1937         /* update predictor */
1938         *dc_val= level;
1939     }else{
1940         UINT16 *dc_val;
1941         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1942         level += pred;
1943
1944         /* update predictor */
1945         if (n < 4) {
1946             *dc_val = level * s->y_dc_scale;
1947         } else {
1948             *dc_val = level * s->c_dc_scale;
1949         }
1950     }
1951
1952     return level;
1953 }
1954
1955 static int msmpeg4_decode_motion(MpegEncContext * s,
1956                                  int *mx_ptr, int *my_ptr)
1957 {
1958     MVTable *mv;
1959     int code, mx, my;
1960
1961     mv = &mv_tables[s->mv_table_index];
1962
1963     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1964     if (code < 0){
1965         fprintf(stderr, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1966         return -1;
1967     }
1968     if (code == mv->n) {
1969 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1970         mx = get_bits(&s->gb, 6);
1971         my = get_bits(&s->gb, 6);
1972     } else {
1973         mx = mv->table_mvx[code];
1974         my = mv->table_mvy[code];
1975     }
1976
1977     mx += *mx_ptr - 32;
1978     my += *my_ptr - 32;
1979     /* WARNING : they do not do exactly modulo encoding */
1980     if (mx <= -64)
1981         mx += 64;
1982     else if (mx >= 64)
1983         mx -= 64;
1984
1985     if (my <= -64)
1986         my += 64;
1987     else if (my >= 64)
1988         my -= 64;
1989     *mx_ptr = mx;
1990     *my_ptr = my;
1991     return 0;
1992 }