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