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