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