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