git.sesse.net Git - ffmpeg/blob - libavcodec/msmpeg4.c

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