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