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