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  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  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 void ff_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 it is 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 void ff_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 void ff_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     ff_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                 ff_code012(&s->pb, s->rl_chroma_table_index);
 351                 ff_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                 ff_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 literally */
 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             ff_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             ff_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, extquant;
 786     int extrabits = 0;
 787
 788     if(s->msmpeg4_version==1){
 789         int32_t *dc_val;
 790         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 791
 792         /* update predictor */
 793         *dc_val= level;
 794     }else{
 795         int16_t *dc_val;
 796         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 797
 798         /* update predictor */
 799         if (n < 4) {
 800             *dc_val = level * s->y_dc_scale;
 801         } else {
 802             *dc_val = level * s->c_dc_scale;
 803         }
 804     }
 805
 806     /* do the prediction */
 807     level -= pred;
 808
 809     if(s->msmpeg4_version<=2){
 810         if (n < 4) {
 811             put_bits(&s->pb,
 812                      v2_dc_lum_table[level+256][1],
 813                      v2_dc_lum_table[level+256][0]);
 814         }else{
 815             put_bits(&s->pb,
 816                      v2_dc_chroma_table[level+256][1],
 817                      v2_dc_chroma_table[level+256][0]);
 818         }
 819     }else{
 820         sign = 0;
 821         if (level < 0) {
 822             level = -level;
 823             sign = 1;
 824         }
 825         code = level;
 826         if (code > DC_MAX)
 827             code = DC_MAX;
 828         else if( s->msmpeg4_version>=6 ) {
 829             if( s->qscale == 1 ) {
 830                 extquant = (level + 3) & 0x3;
 831                 code  = ((level+3)>>2);
 832             } else if( s->qscale == 2 ) {
 833                 extquant = (level + 1) & 0x1;
 834                 code  = ((level+1)>>1);
 835             }
 836         }
 837
 838         if (s->dc_table_index == 0) {
 839             if (n < 4) {
 840                 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]);
 841             } else {
 842                 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]);
 843             }
 844         } else {
 845             if (n < 4) {
 846                 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]);
 847             } else {
 848                 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]);
 849             }
 850         }
 851
 852         if(s->msmpeg4_version>=6 && s->qscale<=2)
 853             extrabits = 3 - s->qscale;
 854
 855         if (code == DC_MAX)
 856             put_bits(&s->pb, 8 + extrabits, level);
 857         else if(extrabits > 0)//== VC1 && s->qscale<=2
 858             put_bits(&s->pb, extrabits, extquant);
 859
 860         if (level != 0) {
 861             put_bits(&s->pb, 1, sign);
 862         }
 863     }
 864 }
 865
 866 /* Encoding of a block. Very similar to MPEG4 except for a different
 867    escape coding (same as H263) and more vlc tables.
 868  */
 869 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n)
 870 {
 871     int level, run, last, i, j, last_index;
 872     int last_non_zero, sign, slevel;
 873     int code, run_diff, dc_pred_dir;
 874     const RLTable *rl;
 875     const uint8_t *scantable;
 876
 877     if (s->mb_intra) {
 878         msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir);
 879         i = 1;
 880         if (n < 4) {
 881             rl = &rl_table[s->rl_table_index];
 882         } else {
 883             rl = &rl_table[3 + s->rl_chroma_table_index];
 884         }
 885         run_diff = s->msmpeg4_version>=4;
 886         scantable= s->intra_scantable.permutated;
 887     } else {
 888         i = 0;
 889         rl = &rl_table[3 + s->rl_table_index];
 890         if(s->msmpeg4_version<=2)
 891             run_diff = 0;
 892         else
 893             run_diff = 1;
 894         scantable= s->inter_scantable.permutated;
 895     }
 896
 897     /* recalculate block_last_index for M$ wmv1 */
 898     if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){
 899         for(last_index=63; last_index>=0; last_index--){
 900             if(block[scantable[last_index]]) break;
 901         }
 902         s->block_last_index[n]= last_index;
 903     }else
 904         last_index = s->block_last_index[n];
 905     /* AC coefs */
 906     last_non_zero = i - 1;
 907     for (; i <= last_index; i++) {
 908         j = scantable[i];
 909         level = block[j];
 910         if (level) {
 911             run = i - last_non_zero - 1;
 912             last = (i == last_index);
 913             sign = 0;
 914             slevel = level;
 915             if (level < 0) {
 916                 sign = 1;
 917                 level = -level;
 918             }
 919
 920             if(level<=MAX_LEVEL && run<=MAX_RUN){
 921                 s->ac_stats[s->mb_intra][n>3][level][run][last]++;
 922             }
 923 #if 0
 924 else
 925     s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like
 926 #endif
 927             code = get_rl_index(rl, last, run, level);
 928             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 929             if (code == rl->n) {
 930                 int level1, run1;
 931
 932                 level1 = level - rl->max_level[last][run];
 933                 if (level1 < 1)
 934                     goto esc2;
 935                 code = get_rl_index(rl, last, run, level1);
 936                 if (code == rl->n) {
 937                 esc2:
 938                     put_bits(&s->pb, 1, 0);
 939                     if (level > MAX_LEVEL)
 940                         goto esc3;
 941                     run1 = run - rl->max_run[last][level] - run_diff;
 942                     if (run1 < 0)
 943                         goto esc3;
 944                     code = get_rl_index(rl, last, run1+1, level);
 945                     if (s->msmpeg4_version == 4 && code == rl->n)
 946                         goto esc3;
 947                     code = get_rl_index(rl, last, run1, level);
 948                     if (code == rl->n) {
 949                     esc3:
 950                         /* third escape */
 951                         put_bits(&s->pb, 1, 0);
 952                         put_bits(&s->pb, 1, last);
 953                         if(s->msmpeg4_version>=4){
 954                             if(s->esc3_level_length==0){
 955                                 s->esc3_level_length=8;
 956                                 s->esc3_run_length= 6;
 957                                 //ESCLVLSZ + ESCRUNSZ
 958                                 if(s->qscale<8)
 959                                     put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3);
 960                                 else
 961                                     put_bits(&s->pb, 8, 3);
 962                             }
 963                             put_bits(&s->pb, s->esc3_run_length, run);
 964                             put_bits(&s->pb, 1, sign);
 965                             put_bits(&s->pb, s->esc3_level_length, level);
 966                         }else{
 967                             put_bits(&s->pb, 6, run);
 968                             put_bits(&s->pb, 8, slevel & 0xff);
 969                         }
 970                     } else {
 971                         /* second escape */
 972                         put_bits(&s->pb, 1, 1);
 973                         put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 974                         put_bits(&s->pb, 1, sign);
 975                     }
 976                 } else {
 977                     /* first escape */
 978                     put_bits(&s->pb, 1, 1);
 979                     put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
 980                     put_bits(&s->pb, 1, sign);
 981                 }
 982             } else {
 983                 put_bits(&s->pb, 1, sign);
 984             }
 985             last_non_zero = i;
 986         }
 987     }
 988 }
 989
 990 /****************************************/
 991 /* decoding stuff */
 992
 993 static VLC mb_non_intra_vlc[4];
 994 static VLC v2_dc_lum_vlc;
 995 static VLC v2_dc_chroma_vlc;
 996 static VLC cbpy_vlc;
 997 static VLC v2_intra_cbpc_vlc;
 998 static VLC v2_mb_type_vlc;
 999 static VLC v2_mv_vlc;
1000 static VLC v1_intra_cbpc_vlc;
1001 static VLC v1_inter_cbpc_vlc;
1002 static VLC inter_intra_vlc;
1003
1004 /* This table is practically identical to the one from h263
1005  * except that it is inverted. */
1006 static void init_h263_dc_for_msmpeg4(void)
1007 {
1008         int level, uni_code, uni_len;
1009
1010         for(level=-256; level<256; level++){
1011             int size, v, l;
1012             /* find number of bits */
1013             size = 0;
1014             v = abs(level);
1015             while (v) {
1016                 v >>= 1;
1017                     size++;
1018             }
1019
1020             if (level < 0)
1021                 l= (-level) ^ ((1 << size) - 1);
1022             else
1023                 l= level;
1024
1025             /* luminance h263 */
1026             uni_code= DCtab_lum[size][0];
1027             uni_len = DCtab_lum[size][1];
1028             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1029
1030             if (size > 0) {
1031                 uni_code<<=size; uni_code|=l;
1032                 uni_len+=size;
1033                 if (size > 8){
1034                     uni_code<<=1; uni_code|=1;
1035                     uni_len++;
1036                 }
1037             }
1038             v2_dc_lum_table[level+256][0]= uni_code;
1039             v2_dc_lum_table[level+256][1]= uni_len;
1040
1041             /* chrominance h263 */
1042             uni_code= DCtab_chrom[size][0];
1043             uni_len = DCtab_chrom[size][1];
1044             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
1045
1046             if (size > 0) {
1047                 uni_code<<=size; uni_code|=l;
1048                 uni_len+=size;
1049                 if (size > 8){
1050                     uni_code<<=1; uni_code|=1;
1051                     uni_len++;
1052                 }
1053             }
1054             v2_dc_chroma_table[level+256][0]= uni_code;
1055             v2_dc_chroma_table[level+256][1]= uni_len;
1056
1057         }
1058 }
1059
1060 /* init all vlc decoding tables */
1061 int ff_msmpeg4_decode_init(MpegEncContext *s)
1062 {
1063     static int done = 0;
1064     int i;
1065     MVTable *mv;
1066
1067     common_init(s);
1068
1069     if (!done) {
1070         done = 1;
1071
1072         for(i=0;i<NB_RL_TABLES;i++) {
1073             init_rl(&rl_table[i], static_rl_table_store[i]);
1074             init_vlc_rl(&rl_table[i], 1);
1075         }
1076         for(i=0;i<2;i++) {
1077             mv = &mv_tables[i];
1078             init_vlc(&mv->vlc, MV_VLC_BITS, mv->n + 1,
1079                      mv->table_mv_bits, 1, 1,
1080                      mv->table_mv_code, 2, 2, 1);
1081         }
1082
1083         init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
1084                  &ff_table0_dc_lum[0][1], 8, 4,
1085                  &ff_table0_dc_lum[0][0], 8, 4, 1);
1086         init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
1087                  &ff_table0_dc_chroma[0][1], 8, 4,
1088                  &ff_table0_dc_chroma[0][0], 8, 4, 1);
1089         init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
1090                  &ff_table1_dc_lum[0][1], 8, 4,
1091                  &ff_table1_dc_lum[0][0], 8, 4, 1);
1092         init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
1093                  &ff_table1_dc_chroma[0][1], 8, 4,
1094                  &ff_table1_dc_chroma[0][0], 8, 4, 1);
1095
1096         init_vlc(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
1097                  &v2_dc_lum_table[0][1], 8, 4,
1098                  &v2_dc_lum_table[0][0], 8, 4, 1);
1099         init_vlc(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
1100                  &v2_dc_chroma_table[0][1], 8, 4,
1101                  &v2_dc_chroma_table[0][0], 8, 4, 1);
1102
1103         init_vlc(&cbpy_vlc, CBPY_VLC_BITS, 16,
1104                  &cbpy_tab[0][1], 2, 1,
1105                  &cbpy_tab[0][0], 2, 1, 1);
1106         init_vlc(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
1107                  &v2_intra_cbpc[0][1], 2, 1,
1108                  &v2_intra_cbpc[0][0], 2, 1, 1);
1109         init_vlc(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
1110                  &v2_mb_type[0][1], 2, 1,
1111                  &v2_mb_type[0][0], 2, 1, 1);
1112         init_vlc(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
1113                  &mvtab[0][1], 2, 1,
1114                  &mvtab[0][0], 2, 1, 1);
1115
1116         for(i=0; i<4; i++){
1117             init_vlc(&mb_non_intra_vlc[i], MB_NON_INTRA_VLC_BITS, 128,
1118                      &wmv2_inter_table[i][0][1], 8, 4,
1119                      &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?
1120         }
1121
1122         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
1123                  &ff_msmp4_mb_i_table[0][1], 4, 2,
1124                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
1125
1126         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8,
1127                  intra_MCBPC_bits, 1, 1,
1128                  intra_MCBPC_code, 1, 1, 1);
1129         init_vlc(&v1_inter_cbpc_vlc, V1_INTER_CBPC_VLC_BITS, 25,
1130                  inter_MCBPC_bits, 1, 1,
1131                  inter_MCBPC_code, 1, 1, 1);
1132
1133         init_vlc(&inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
1134                  &table_inter_intra[0][1], 2, 1,
1135                  &table_inter_intra[0][0], 2, 1, 1);
1136     }
1137
1138     switch(s->msmpeg4_version){
1139     case 1:
1140     case 2:
1141         s->decode_mb= msmpeg4v12_decode_mb;
1142         break;
1143     case 3:
1144     case 4:
1145         s->decode_mb= msmpeg4v34_decode_mb;
1146         break;
1147     case 5:
1148         s->decode_mb= wmv2_decode_mb;
1149     case 6:
1150         //FIXME + TODO VC1 decode mb
1151         break;
1152     }
1153
1154     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
1155
1156     return 0;
1157 }
1158
1159 int msmpeg4_decode_picture_header(MpegEncContext * s)
1160 {
1161     int code;
1162
1163 #if 0
1164 {
1165 int i;
1166 for(i=0; i<s->gb.size_in_bits; i++)
1167     av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb));
1168 //    get_bits1(&s->gb);
1169 av_log(s->avctx, AV_LOG_DEBUG, "END\n");
1170 return -1;
1171 }
1172 #endif
1173
1174     if(s->msmpeg4_version==1){
1175         int start_code, num;
1176         start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16);
1177         if(start_code!=0x00000100){
1178             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
1179             return -1;
1180         }
1181
1182         num= get_bits(&s->gb, 5); // frame number */
1183     }
1184
1185     s->pict_type = get_bits(&s->gb, 2) + 1;
1186     if (s->pict_type != I_TYPE &&
1187         s->pict_type != P_TYPE){
1188         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
1189         return -1;
1190     }
1191 #if 0
1192 {
1193     static int had_i=0;
1194     if(s->pict_type == I_TYPE) had_i=1;
1195     if(!had_i) return -1;
1196 }
1197 #endif
1198     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
1199     if(s->qscale==0){
1200         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
1201         return -1;
1202     }
1203
1204     if (s->pict_type == I_TYPE) {
1205         code = get_bits(&s->gb, 5);
1206         if(s->msmpeg4_version==1){
1207             if(code==0 || code>s->mb_height){
1208                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
1209                 return -1;
1210             }
1211
1212             s->slice_height = code;
1213         }else{
1214             /* 0x17: one slice, 0x18: two slices, ... */
1215             if (code < 0x17){
1216                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
1217                 return -1;
1218             }
1219
1220             s->slice_height = s->mb_height / (code - 0x16);
1221         }
1222
1223         switch(s->msmpeg4_version){
1224         case 1:
1225         case 2:
1226             s->rl_chroma_table_index = 2;
1227             s->rl_table_index = 2;
1228
1229             s->dc_table_index = 0; //not used
1230             break;
1231         case 3:
1232             s->rl_chroma_table_index = decode012(&s->gb);
1233             s->rl_table_index = decode012(&s->gb);
1234
1235             s->dc_table_index = get_bits1(&s->gb);
1236             break;
1237         case 4:
1238             msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
1239
1240             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1241             else                           s->per_mb_rl_table= 0;
1242
1243             if(!s->per_mb_rl_table){
1244                 s->rl_chroma_table_index = decode012(&s->gb);
1245                 s->rl_table_index = decode012(&s->gb);
1246             }
1247
1248             s->dc_table_index = get_bits1(&s->gb);
1249             s->inter_intra_pred= 0;
1250             break;
1251         }
1252         s->no_rounding = 1;
1253         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1254             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
1255                 s->qscale,
1256                 s->rl_chroma_table_index,
1257                 s->rl_table_index,
1258                 s->dc_table_index,
1259                 s->per_mb_rl_table,
1260                 s->slice_height);
1261     } else {
1262         switch(s->msmpeg4_version){
1263         case 1:
1264         case 2:
1265             if(s->msmpeg4_version==1)
1266                 s->use_skip_mb_code = 1;
1267             else
1268                 s->use_skip_mb_code = get_bits1(&s->gb);
1269             s->rl_table_index = 2;
1270             s->rl_chroma_table_index = s->rl_table_index;
1271             s->dc_table_index = 0; //not used
1272             s->mv_table_index = 0;
1273             break;
1274         case 3:
1275             s->use_skip_mb_code = get_bits1(&s->gb);
1276             s->rl_table_index = decode012(&s->gb);
1277             s->rl_chroma_table_index = s->rl_table_index;
1278
1279             s->dc_table_index = get_bits1(&s->gb);
1280
1281             s->mv_table_index = get_bits1(&s->gb);
1282             break;
1283         case 4:
1284             s->use_skip_mb_code = get_bits1(&s->gb);
1285
1286             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
1287             else                           s->per_mb_rl_table= 0;
1288
1289             if(!s->per_mb_rl_table){
1290                 s->rl_table_index = decode012(&s->gb);
1291                 s->rl_chroma_table_index = s->rl_table_index;
1292             }
1293
1294             s->dc_table_index = get_bits1(&s->gb);
1295
1296             s->mv_table_index = get_bits1(&s->gb);
1297             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
1298             break;
1299         }
1300
1301         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
1302             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
1303                 s->use_skip_mb_code,
1304                 s->rl_table_index,
1305                 s->rl_chroma_table_index,
1306                 s->dc_table_index,
1307                 s->mv_table_index,
1308                 s->per_mb_rl_table,
1309                 s->qscale);
1310
1311         if(s->flipflop_rounding){
1312             s->no_rounding ^= 1;
1313         }else{
1314             s->no_rounding = 0;
1315         }
1316     }
1317 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height);
1318
1319     s->esc3_level_length= 0;
1320     s->esc3_run_length= 0;
1321
1322 #ifdef DEBUG
1323     av_log(s->avctx, AV_LOG_DEBUG, "*****frame %d:\n", frame_count++);
1324 #endif
1325     return 0;
1326 }
1327
1328 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
1329 {
1330     int left= buf_size*8 - get_bits_count(&s->gb);
1331     int length= s->msmpeg4_version>=3 ? 17 : 16;
1332     /* the alt_bitstream reader could read over the end so we need to check it */
1333     if(left>=length && left<length+8)
1334     {
1335         int fps;
1336
1337         fps= get_bits(&s->gb, 5);
1338         s->bit_rate= get_bits(&s->gb, 11)*1024;
1339         if(s->msmpeg4_version>=3)
1340             s->flipflop_rounding= get_bits1(&s->gb);
1341         else
1342             s->flipflop_rounding= 0;
1343
1344 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1345     }
1346     else if(left<length+8)
1347     {
1348         s->flipflop_rounding= 0;
1349         if(s->msmpeg4_version != 2)
1350             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1351     }
1352     else
1353     {
1354         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1355     }
1356
1357     return 0;
1358 }
1359
1360 static inline void msmpeg4_memsetw(short *tab, int val, int n)
1361 {
1362     int i;
1363     for(i=0;i<n;i++)
1364         tab[i] = val;
1365 }
1366
1367 #ifdef CONFIG_ENCODERS
1368 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val)
1369 {
1370     int range, bit_size, sign, code, bits;
1371
1372     if (val == 0) {
1373         /* zero vector */
1374         code = 0;
1375         put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
1376     } else {
1377         bit_size = s->f_code - 1;
1378         range = 1 << bit_size;
1379         if (val <= -64)
1380             val += 64;
1381         else if (val >= 64)
1382             val -= 64;
1383
1384         if (val >= 0) {
1385             sign = 0;
1386         } else {
1387             val = -val;
1388             sign = 1;
1389         }
1390         val--;
1391         code = (val >> bit_size) + 1;
1392         bits = val & (range - 1);
1393
1394         put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
1395         if (bit_size > 0) {
1396             put_bits(&s->pb, bit_size, bits);
1397         }
1398     }
1399 }
1400 #endif
1401
1402 /* This is identical to h263 except that its range is multiplied by 2. */
1403 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
1404 {
1405     int code, val, sign, shift;
1406
1407     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
1408 //     printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
1409     if (code < 0)
1410         return 0xffff;
1411
1412     if (code == 0)
1413         return pred;
1414     sign = get_bits1(&s->gb);
1415     shift = f_code - 1;
1416     val = code;
1417     if (shift) {
1418         val = (val - 1) << shift;
1419         val |= get_bits(&s->gb, shift);
1420         val++;
1421     }
1422     if (sign)
1423         val = -val;
1424
1425     val += pred;
1426     if (val <= -64)
1427         val += 64;
1428     else if (val >= 64)
1429         val -= 64;
1430
1431     return val;
1432 }
1433
1434 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1435 {
1436     int cbp, code, i;
1437
1438     if (s->pict_type == P_TYPE) {
1439         if (s->use_skip_mb_code) {
1440             if (get_bits1(&s->gb)) {
1441                 /* skip mb */
1442                 s->mb_intra = 0;
1443                 for(i=0;i<6;i++)
1444                     s->block_last_index[i] = -1;
1445                 s->mv_dir = MV_DIR_FORWARD;
1446                 s->mv_type = MV_TYPE_16X16;
1447                 s->mv[0][0][0] = 0;
1448                 s->mv[0][0][1] = 0;
1449                 s->mb_skipped = 1;
1450                 return 0;
1451             }
1452         }
1453
1454         if(s->msmpeg4_version==2)
1455             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
1456         else
1457             code = get_vlc2(&s->gb, v1_inter_cbpc_vlc.table, V1_INTER_CBPC_VLC_BITS, 3);
1458         if(code<0 || code>7){
1459             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
1460             return -1;
1461         }
1462
1463         s->mb_intra = code >>2;
1464
1465         cbp = code & 0x3;
1466     } else {
1467         s->mb_intra = 1;
1468         if(s->msmpeg4_version==2)
1469             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
1470         else
1471             cbp= get_vlc2(&s->gb, v1_intra_cbpc_vlc.table, V1_INTRA_CBPC_VLC_BITS, 1);
1472         if(cbp<0 || cbp>3){
1473             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1474             return -1;
1475         }
1476     }
1477
1478     if (!s->mb_intra) {
1479         int mx, my, cbpy;
1480
1481         cbpy= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1);
1482         if(cbpy<0){
1483             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
1484             return -1;
1485         }
1486
1487         cbp|= cbpy<<2;
1488         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
1489
1490         h263_pred_motion(s, 0, 0, &mx, &my);
1491         mx= msmpeg4v2_decode_motion(s, mx, 1);
1492         my= msmpeg4v2_decode_motion(s, my, 1);
1493
1494         s->mv_dir = MV_DIR_FORWARD;
1495         s->mv_type = MV_TYPE_16X16;
1496         s->mv[0][0][0] = mx;
1497         s->mv[0][0][1] = my;
1498     } else {
1499         if(s->msmpeg4_version==2){
1500             s->ac_pred = get_bits1(&s->gb);
1501             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1502         } else{
1503             s->ac_pred = 0;
1504             cbp|= get_vlc2(&s->gb, cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
1505             if(s->pict_type==P_TYPE) cbp^=0x3C;
1506         }
1507     }
1508
1509     s->dsp.clear_blocks(s->block[0]);
1510     for (i = 0; i < 6; i++) {
1511         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1512         {
1513              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1514              return -1;
1515         }
1516     }
1517     return 0;
1518 }
1519
1520 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
1521 {
1522     int cbp, code, i;
1523     uint8_t *coded_val;
1524     uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ];
1525
1526     if (s->pict_type == P_TYPE) {
1527         if (s->use_skip_mb_code) {
1528             if (get_bits1(&s->gb)) {
1529                 /* skip mb */
1530                 s->mb_intra = 0;
1531                 for(i=0;i<6;i++)
1532                     s->block_last_index[i] = -1;
1533                 s->mv_dir = MV_DIR_FORWARD;
1534                 s->mv_type = MV_TYPE_16X16;
1535                 s->mv[0][0][0] = 0;
1536                 s->mv[0][0][1] = 0;
1537                 s->mb_skipped = 1;
1538                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
1539
1540                 return 0;
1541             }
1542         }
1543
1544         code = get_vlc2(&s->gb, mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
1545         if (code < 0)
1546             return -1;
1547         //s->mb_intra = (code & 0x40) ? 0 : 1;
1548         s->mb_intra = (~code & 0x40) >> 6;
1549
1550         cbp = code & 0x3f;
1551     } else {
1552         s->mb_intra = 1;
1553         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1554         if (code < 0)
1555             return -1;
1556         /* predict coded block pattern */
1557         cbp = 0;
1558         for(i=0;i<6;i++) {
1559             int val = ((code >> (5 - i)) & 1);
1560             if (i < 4) {
1561                 int pred = coded_block_pred(s, i, &coded_val);
1562                 val = val ^ pred;
1563                 *coded_val = val;
1564             }
1565             cbp |= val << (5 - i);
1566         }
1567     }
1568
1569     if (!s->mb_intra) {
1570         int mx, my;
1571 //printf("P at %d %d\n", s->mb_x, s->mb_y);
1572         if(s->per_mb_rl_table && cbp){
1573             s->rl_table_index = decode012(&s->gb);
1574             s->rl_chroma_table_index = s->rl_table_index;
1575         }
1576         h263_pred_motion(s, 0, 0, &mx, &my);
1577         if (msmpeg4_decode_motion(s, &mx, &my) < 0)
1578             return -1;
1579         s->mv_dir = MV_DIR_FORWARD;
1580         s->mv_type = MV_TYPE_16X16;
1581         s->mv[0][0][0] = mx;
1582         s->mv[0][0][1] = my;
1583         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
1584     } else {
1585 //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));
1586         s->ac_pred = get_bits1(&s->gb);
1587         *mb_type_ptr = MB_TYPE_INTRA;
1588         if(s->inter_intra_pred){
1589             s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
1590 //            printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
1591         }
1592         if(s->per_mb_rl_table && cbp){
1593             s->rl_table_index = decode012(&s->gb);
1594             s->rl_chroma_table_index = s->rl_table_index;
1595         }
1596     }
1597
1598     s->dsp.clear_blocks(s->block[0]);
1599     for (i = 0; i < 6; i++) {
1600         if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
1601         {
1602             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
1603             return -1;
1604         }
1605     }
1606
1607     return 0;
1608 }
1609 //#define ERROR_DETAILS
1610 static inline int msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1611                               int n, int coded, const uint8_t *scan_table)
1612 {
1613     int level, i, last, run, run_diff;
1614     int dc_pred_dir;
1615     RLTable *rl;
1616     RL_VLC_ELEM *rl_vlc;
1617     int qmul, qadd;
1618
1619     if (s->mb_intra) {
1620         qmul=1;
1621         qadd=0;
1622
1623         /* DC coef */
1624         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1625
1626         if (level < 0){
1627             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1628             if(s->inter_intra_pred) level=0;
1629             else                    return -1;
1630         }
1631         if (n < 4) {
1632             rl = &rl_table[s->rl_table_index];
1633             if(level > 256*s->y_dc_scale){
1634                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1635                 if(!s->inter_intra_pred) return -1;
1636             }
1637         } else {
1638             rl = &rl_table[3 + s->rl_chroma_table_index];
1639             if(level > 256*s->c_dc_scale){
1640                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1641                 if(!s->inter_intra_pred) return -1;
1642             }
1643         }
1644         block[0] = level;
1645
1646         run_diff = s->msmpeg4_version >= 4;
1647         i = 0;
1648         if (!coded) {
1649             goto not_coded;
1650         }
1651         if (s->ac_pred) {
1652             if (dc_pred_dir == 0)
1653                 scan_table = s->intra_v_scantable.permutated; /* left */
1654             else
1655                 scan_table = s->intra_h_scantable.permutated; /* top */
1656         } else {
1657             scan_table = s->intra_scantable.permutated;
1658         }
1659         rl_vlc= rl->rl_vlc[0];
1660     } else {
1661         qmul = s->qscale << 1;
1662         qadd = (s->qscale - 1) | 1;
1663         i = -1;
1664         rl = &rl_table[3 + s->rl_table_index];
1665
1666         if(s->msmpeg4_version==2)
1667             run_diff = 0;
1668         else
1669             run_diff = 1;
1670
1671         if (!coded) {
1672             s->block_last_index[n] = i;
1673             return 0;
1674         }
1675         if(!scan_table)
1676             scan_table = s->inter_scantable.permutated;
1677         rl_vlc= rl->rl_vlc[s->qscale];
1678     }
1679   {
1680     OPEN_READER(re, &s->gb);
1681     for(;;) {
1682         UPDATE_CACHE(re, &s->gb);
1683         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1684         if (level==0) {
1685             int cache;
1686             cache= GET_CACHE(re, &s->gb);
1687             /* escape */
1688             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1689                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1690                     /* third escape */
1691                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1692                     UPDATE_CACHE(re, &s->gb);
1693                     if(s->msmpeg4_version<=3){
1694                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1695                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1696                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1697                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1698                     }else{
1699                         int sign;
1700                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1701                         if(!s->esc3_level_length){
1702                             int ll;
1703                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1704                             if(s->qscale<8){
1705                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1706                                 if(ll==0){
1707                                     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");
1708                                     SKIP_BITS(re, &s->gb, 1);
1709                                     ll=8;
1710                                 }
1711                             }else{
1712                                 ll=2;
1713                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1714                                     ll++;
1715                                     SKIP_BITS(re, &s->gb, 1);
1716                                 }
1717                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1718                             }
1719
1720                             s->esc3_level_length= ll;
1721                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1722 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1723                             UPDATE_CACHE(re, &s->gb);
1724                         }
1725                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1726                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1727
1728                         sign=  SHOW_UBITS(re, &s->gb, 1);
1729                         SKIP_BITS(re, &s->gb, 1);
1730
1731                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1732                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1733                         if(sign) level= -level;
1734                     }
1735 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1736 #if 0 // waste of time / this will detect very few errors
1737                     {
1738                         const int abs_level= FFABS(level);
1739                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1740                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1741                             if(abs_level <= rl->max_level[last][run]){
1742                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1743                                 return DECODING_AC_LOST;
1744                             }
1745                             if(abs_level <= rl->max_level[last][run]*2){
1746                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1747                                 return DECODING_AC_LOST;
1748                             }
1749                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1750                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1751                                 return DECODING_AC_LOST;
1752                             }
1753                         }
1754                     }
1755 #endif
1756                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1757                     if (level>0) level= level * qmul + qadd;
1758                     else         level= level * qmul - qadd;
1759 #if 0 // waste of time too :(
1760                     if(level>2048 || level<-2048){
1761                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1762                         return DECODING_AC_LOST;
1763                     }
1764 #endif
1765                     i+= run + 1;
1766                     if(last) i+=192;
1767 #ifdef ERROR_DETAILS
1768                 if(run==66)
1769                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1770                 else if((i>62 && i<192) || i>192+63)
1771                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1772 #endif
1773                 } else {
1774                     /* second escape */
1775 #if MIN_CACHE_BITS < 23
1776                     LAST_SKIP_BITS(re, &s->gb, 2);
1777                     UPDATE_CACHE(re, &s->gb);
1778 #else
1779                     SKIP_BITS(re, &s->gb, 2);
1780 #endif
1781                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1782                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1783                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1784                     LAST_SKIP_BITS(re, &s->gb, 1);
1785 #ifdef ERROR_DETAILS
1786                 if(run==66)
1787                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1788                 else if((i>62 && i<192) || i>192+63)
1789                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1790 #endif
1791                 }
1792             } else {
1793                 /* first escape */
1794 #if MIN_CACHE_BITS < 22
1795                 LAST_SKIP_BITS(re, &s->gb, 1);
1796                 UPDATE_CACHE(re, &s->gb);
1797 #else
1798                 SKIP_BITS(re, &s->gb, 1);
1799 #endif
1800                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1801                 i+= run;
1802                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1803                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1804                 LAST_SKIP_BITS(re, &s->gb, 1);
1805 #ifdef ERROR_DETAILS
1806                 if(run==66)
1807                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1808                 else if((i>62 && i<192) || i>192+63)
1809                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1810 #endif
1811             }
1812         } else {
1813             i+= run;
1814             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1815             LAST_SKIP_BITS(re, &s->gb, 1);
1816 #ifdef ERROR_DETAILS
1817                 if(run==66)
1818                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1819                 else if((i>62 && i<192) || i>192+63)
1820                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1821 #endif
1822         }
1823         if (i > 62){
1824             i-= 192;
1825             if(i&(~63)){
1826                 const int left= s->gb.size_in_bits - get_bits_count(&s->gb);
1827                 if(((i+192 == 64 && level/qmul==-1) || s->error_resilience<=1) && left>=0){
1828                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1829                     break;
1830                 }else{
1831                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1832                     return -1;
1833                 }
1834             }
1835
1836             block[scan_table[i]] = level;
1837             break;
1838         }
1839
1840         block[scan_table[i]] = level;
1841     }
1842     CLOSE_READER(re, &s->gb);
1843   }
1844  not_coded:
1845     if (s->mb_intra) {
1846         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1847         if (s->ac_pred) {
1848             i = 63; /* XXX: not optimal */
1849         }
1850     }
1851     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1852     s->block_last_index[n] = i;
1853
1854     return 0;
1855 }
1856
1857 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1858 {
1859     int level, pred;
1860
1861     if(s->msmpeg4_version<=2){
1862         if (n < 4) {
1863             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1864         } else {
1865             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1866         }
1867         if (level < 0)
1868             return -1;
1869         level-=256;
1870     }else{  //FIXME optimize use unified tables & index
1871         if (n < 4) {
1872             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1873         } else {
1874             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1875         }
1876         if (level < 0){
1877             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1878             return -1;
1879         }
1880
1881         if (level == DC_MAX) {
1882             level = get_bits(&s->gb, 8);
1883             if (get_bits1(&s->gb))
1884                 level = -level;
1885         } else if (level != 0) {
1886             if (get_bits1(&s->gb))
1887                 level = -level;
1888         }
1889     }
1890
1891     if(s->msmpeg4_version==1){
1892         int32_t *dc_val;
1893         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1894         level += pred;
1895
1896         /* update predictor */
1897         *dc_val= level;
1898     }else{
1899         int16_t *dc_val;
1900         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1901         level += pred;
1902
1903         /* update predictor */
1904         if (n < 4) {
1905             *dc_val = level * s->y_dc_scale;
1906         } else {
1907             *dc_val = level * s->c_dc_scale;
1908         }
1909     }
1910
1911     return level;
1912 }
1913
1914 static int msmpeg4_decode_motion(MpegEncContext * s,
1915                                  int *mx_ptr, int *my_ptr)
1916 {
1917     MVTable *mv;
1918     int code, mx, my;
1919
1920     mv = &mv_tables[s->mv_table_index];
1921
1922     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1923     if (code < 0){
1924         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1925         return -1;
1926     }
1927     if (code == mv->n) {
1928 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1929         mx = get_bits(&s->gb, 6);
1930         my = get_bits(&s->gb, 6);
1931     } else {
1932         mx = mv->table_mvx[code];
1933         my = mv->table_mvy[code];
1934     }
1935
1936     mx += *mx_ptr - 32;
1937     my += *my_ptr - 32;
1938     /* WARNING : they do not do exactly modulo encoding */
1939     if (mx <= -64)
1940         mx += 64;
1941     else if (mx >= 64)
1942         mx -= 64;
1943
1944     if (my <= -64)
1945         my += 64;
1946     else if (my >= 64)
1947         my -= 64;
1948     *mx_ptr = mx;
1949     *my_ptr = my;
1950     return 0;
1951 }
1952
1953 /* cleanest way to support it
1954  * there is too much shared between versions so that we cant have 1 file per version & 1 common
1955  * as allmost everything would be in the common file
1956  */
1957 #include "wmv2.c"