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