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