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.f.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.f.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.f.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         skip_bits(&s->gb, 5); /* fps */
1532         s->bit_rate= get_bits(&s->gb, 11)*1024;
1533         if(s->msmpeg4_version>=3)
1534             s->flipflop_rounding= get_bits1(&s->gb);
1535         else
1536             s->flipflop_rounding= 0;
1537
1538 //        printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding);
1539     }
1540     else if(left<length+8)
1541     {
1542         s->flipflop_rounding= 0;
1543         if(s->msmpeg4_version != 2)
1544             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
1545     }
1546     else
1547     {
1548         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
1549     }
1550
1551     return 0;
1552 }
1553
1554 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
1555 {
1556     int level, pred;
1557
1558     if(s->msmpeg4_version<=2){
1559         if (n < 4) {
1560             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
1561         } else {
1562             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
1563         }
1564         if (level < 0)
1565             return -1;
1566         level-=256;
1567     }else{  //FIXME optimize use unified tables & index
1568         if (n < 4) {
1569             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1570         } else {
1571             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1572         }
1573         if (level < 0){
1574             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
1575             return -1;
1576         }
1577
1578         if (level == DC_MAX) {
1579             level = get_bits(&s->gb, 8);
1580             if (get_bits1(&s->gb))
1581                 level = -level;
1582         } else if (level != 0) {
1583             if (get_bits1(&s->gb))
1584                 level = -level;
1585         }
1586     }
1587
1588     if(s->msmpeg4_version==1){
1589         int32_t *dc_val;
1590         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
1591         level += pred;
1592
1593         /* update predictor */
1594         *dc_val= level;
1595     }else{
1596         int16_t *dc_val;
1597         pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
1598         level += pred;
1599
1600         /* update predictor */
1601         if (n < 4) {
1602             *dc_val = level * s->y_dc_scale;
1603         } else {
1604             *dc_val = level * s->c_dc_scale;
1605         }
1606     }
1607
1608     return level;
1609 }
1610
1611 //#define ERROR_DETAILS
1612 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
1613                               int n, int coded, const uint8_t *scan_table)
1614 {
1615     int level, i, last, run, run_diff;
1616     int av_uninit(dc_pred_dir);
1617     RLTable *rl;
1618     RL_VLC_ELEM *rl_vlc;
1619     int qmul, qadd;
1620
1621     if (s->mb_intra) {
1622         qmul=1;
1623         qadd=0;
1624
1625         /* DC coef */
1626         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
1627
1628         if (level < 0){
1629             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
1630             if(s->inter_intra_pred) level=0;
1631             else                    return -1;
1632         }
1633         if (n < 4) {
1634             rl = &rl_table[s->rl_table_index];
1635             if(level > 256*s->y_dc_scale){
1636                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
1637                 if(!s->inter_intra_pred) return -1;
1638             }
1639         } else {
1640             rl = &rl_table[3 + s->rl_chroma_table_index];
1641             if(level > 256*s->c_dc_scale){
1642                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
1643                 if(!s->inter_intra_pred) return -1;
1644             }
1645         }
1646         block[0] = level;
1647
1648         run_diff = s->msmpeg4_version >= 4;
1649         i = 0;
1650         if (!coded) {
1651             goto not_coded;
1652         }
1653         if (s->ac_pred) {
1654             if (dc_pred_dir == 0)
1655                 scan_table = s->intra_v_scantable.permutated; /* left */
1656             else
1657                 scan_table = s->intra_h_scantable.permutated; /* top */
1658         } else {
1659             scan_table = s->intra_scantable.permutated;
1660         }
1661         rl_vlc= rl->rl_vlc[0];
1662     } else {
1663         qmul = s->qscale << 1;
1664         qadd = (s->qscale - 1) | 1;
1665         i = -1;
1666         rl = &rl_table[3 + s->rl_table_index];
1667
1668         if(s->msmpeg4_version==2)
1669             run_diff = 0;
1670         else
1671             run_diff = 1;
1672
1673         if (!coded) {
1674             s->block_last_index[n] = i;
1675             return 0;
1676         }
1677         if(!scan_table)
1678             scan_table = s->inter_scantable.permutated;
1679         rl_vlc= rl->rl_vlc[s->qscale];
1680     }
1681   {
1682     OPEN_READER(re, &s->gb);
1683     for(;;) {
1684         UPDATE_CACHE(re, &s->gb);
1685         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1686         if (level==0) {
1687             int cache;
1688             cache= GET_CACHE(re, &s->gb);
1689             /* escape */
1690             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1691                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1692                     /* third escape */
1693                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1694                     UPDATE_CACHE(re, &s->gb);
1695                     if(s->msmpeg4_version<=3){
1696                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1697                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1698                         level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8);
1699                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1700                     }else{
1701                         int sign;
1702                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1703                         if(!s->esc3_level_length){
1704                             int ll;
1705                             //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1706                             if(s->qscale<8){
1707                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1708                                 if(ll==0){
1709                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1710                                 }
1711                             }else{
1712                                 ll=2;
1713                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1714                                     ll++;
1715                                     SKIP_BITS(re, &s->gb, 1);
1716                                 }
1717                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1718                             }
1719
1720                             s->esc3_level_length= ll;
1721                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1722 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length);
1723                             UPDATE_CACHE(re, &s->gb);
1724                         }
1725                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1726                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1727
1728                         sign=  SHOW_UBITS(re, &s->gb, 1);
1729                         SKIP_BITS(re, &s->gb, 1);
1730
1731                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1732                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1733                         if(sign) level= -level;
1734                     }
1735 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y);
1736 #if 0 // waste of time / this will detect very few errors
1737                     {
1738                         const int abs_level= FFABS(level);
1739                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1740                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1741                             if(abs_level <= rl->max_level[last][run]){
1742                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1743                                 return DECODING_AC_LOST;
1744                             }
1745                             if(abs_level <= rl->max_level[last][run]*2){
1746                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1747                                 return DECODING_AC_LOST;
1748                             }
1749                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1750                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1751                                 return DECODING_AC_LOST;
1752                             }
1753                         }
1754                     }
1755 #endif
1756                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1757                     if (level>0) level= level * qmul + qadd;
1758                     else         level= level * qmul - qadd;
1759 #if 0 // waste of time too :(
1760                     if(level>2048 || level<-2048){
1761                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1762                         return DECODING_AC_LOST;
1763                     }
1764 #endif
1765                     i+= run + 1;
1766                     if(last) i+=192;
1767 #ifdef ERROR_DETAILS
1768                 if(run==66)
1769                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1770                 else if((i>62 && i<192) || i>192+63)
1771                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1772 #endif
1773                 } else {
1774                     /* second escape */
1775                     SKIP_BITS(re, &s->gb, 2);
1776                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1777                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1778                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1779                     LAST_SKIP_BITS(re, &s->gb, 1);
1780 #ifdef ERROR_DETAILS
1781                 if(run==66)
1782                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1783                 else if((i>62 && i<192) || i>192+63)
1784                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1785 #endif
1786                 }
1787             } else {
1788                 /* first escape */
1789                 SKIP_BITS(re, &s->gb, 1);
1790                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1791                 i+= run;
1792                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1793                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1794                 LAST_SKIP_BITS(re, &s->gb, 1);
1795 #ifdef ERROR_DETAILS
1796                 if(run==66)
1797                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1798                 else if((i>62 && i<192) || i>192+63)
1799                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1800 #endif
1801             }
1802         } else {
1803             i+= run;
1804             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1805             LAST_SKIP_BITS(re, &s->gb, 1);
1806 #ifdef ERROR_DETAILS
1807                 if(run==66)
1808                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1809                 else if((i>62 && i<192) || i>192+63)
1810                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1811 #endif
1812         }
1813         if (i > 62){
1814             i-= 192;
1815             if(i&(~63)){
1816                 const int left= get_bits_left(&s->gb);
1817                 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){
1818                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1819                     break;
1820                 }else{
1821                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1822                     return -1;
1823                 }
1824             }
1825
1826             block[scan_table[i]] = level;
1827             break;
1828         }
1829
1830         block[scan_table[i]] = level;
1831     }
1832     CLOSE_READER(re, &s->gb);
1833   }
1834  not_coded:
1835     if (s->mb_intra) {
1836         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1837         if (s->ac_pred) {
1838             i = 63; /* XXX: not optimal */
1839         }
1840     }
1841     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1842     s->block_last_index[n] = i;
1843
1844     return 0;
1845 }
1846
1847 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1848                                  int *mx_ptr, int *my_ptr)
1849 {
1850     MVTable *mv;
1851     int code, mx, my;
1852
1853     mv = &mv_tables[s->mv_table_index];
1854
1855     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1856     if (code < 0){
1857         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1858         return -1;
1859     }
1860     if (code == mv->n) {
1861 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1862         mx = get_bits(&s->gb, 6);
1863         my = get_bits(&s->gb, 6);
1864     } else {
1865         mx = mv->table_mvx[code];
1866         my = mv->table_mvy[code];
1867     }
1868
1869     mx += *mx_ptr - 32;
1870     my += *my_ptr - 32;
1871     /* WARNING : they do not do exactly modulo encoding */
1872     if (mx <= -64)
1873         mx += 64;
1874     else if (mx >= 64)
1875         mx -= 64;
1876
1877     if (my <= -64)
1878         my += 64;
1879     else if (my >= 64)
1880         my -= 64;
1881     *mx_ptr = mx;
1882     *my_ptr = my;
1883     return 0;
1884 }
1885
1886 AVCodec ff_msmpeg4v1_decoder = {
1887     "msmpeg4v1",
1888     AVMEDIA_TYPE_VIDEO,
1889     CODEC_ID_MSMPEG4V1,
1890     sizeof(MpegEncContext),
1891     ff_msmpeg4_decode_init,
1892     NULL,
1893     ff_h263_decode_end,
1894     ff_h263_decode_frame,
1895     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1896     .max_lowres= 3,
1897     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1898     .pix_fmts= ff_pixfmt_list_420,
1899 };
1900
1901 AVCodec ff_msmpeg4v2_decoder = {
1902     "msmpeg4v2",
1903     AVMEDIA_TYPE_VIDEO,
1904     CODEC_ID_MSMPEG4V2,
1905     sizeof(MpegEncContext),
1906     ff_msmpeg4_decode_init,
1907     NULL,
1908     ff_h263_decode_end,
1909     ff_h263_decode_frame,
1910     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1911     .max_lowres= 3,
1912     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1913     .pix_fmts= ff_pixfmt_list_420,
1914 };
1915
1916 AVCodec ff_msmpeg4v3_decoder = {
1917     "msmpeg4",
1918     AVMEDIA_TYPE_VIDEO,
1919     CODEC_ID_MSMPEG4V3,
1920     sizeof(MpegEncContext),
1921     ff_msmpeg4_decode_init,
1922     NULL,
1923     ff_h263_decode_end,
1924     ff_h263_decode_frame,
1925     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1926     .max_lowres= 3,
1927     .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1928     .pix_fmts= ff_pixfmt_list_420,
1929 };
1930
1931 AVCodec ff_wmv1_decoder = {
1932     "wmv1",
1933     AVMEDIA_TYPE_VIDEO,
1934     CODEC_ID_WMV1,
1935     sizeof(MpegEncContext),
1936     ff_msmpeg4_decode_init,
1937     NULL,
1938     ff_h263_decode_end,
1939     ff_h263_decode_frame,
1940     CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1941     .max_lowres= 3,
1942     .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1943     .pix_fmts= ff_pixfmt_list_420,
1944 };