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

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