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

   1 /*
   2  * MSMPEG4 backend for encoder and decoder
   3  * Copyright (c) 2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * MSMPEG4 backend for encoder and decoder
  28  */
  29
  30 #include "avcodec.h"
  31 #include "dsputil.h"
  32 #include "mpegvideo.h"
  33 #include "msmpeg4.h"
  34 #include "libavutil/x86/asm.h"
  35 #include "h263.h"
  36 #include "mpeg4video.h"
  37 #include "msmpeg4data.h"
  38 #include "vc1data.h"
  39
  40 /*
  41  * You can also call this codec : MPEG4 with a twist !
  42  *
  43  * TODO:
  44  *        - (encoding) select best mv table (two choices)
  45  *        - (encoding) select best vlc/dc table
  46  */
  47 //#define DEBUG
  48
  49 #define DC_VLC_BITS 9
  50 #define V2_INTRA_CBPC_VLC_BITS 3
  51 #define V2_MB_TYPE_VLC_BITS 7
  52 #define MV_VLC_BITS 9
  53 #define V2_MV_VLC_BITS 9
  54 #define TEX_VLC_BITS 9
  55
  56 #define DEFAULT_INTER_INDEX 3
  57
  58 /* This table is practically identical to the one from h263
  59  * except that it is inverted. */
  60 static av_cold void init_h263_dc_for_msmpeg4(void)
  61 {
  62         int level, uni_code, uni_len;
  63
  64         if(ff_v2_dc_chroma_table[255 + 256][1])
  65             return;
  66
  67         for(level=-256; level<256; level++){
  68             int size, v, l;
  69             /* find number of bits */
  70             size = 0;
  71             v = abs(level);
  72             while (v) {
  73                 v >>= 1;
  74                     size++;
  75             }
  76
  77             if (level < 0)
  78                 l= (-level) ^ ((1 << size) - 1);
  79             else
  80                 l= level;
  81
  82             /* luminance h263 */
  83             uni_code= ff_mpeg4_DCtab_lum[size][0];
  84             uni_len = ff_mpeg4_DCtab_lum[size][1];
  85             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
  86
  87             if (size > 0) {
  88                 uni_code<<=size; uni_code|=l;
  89                 uni_len+=size;
  90                 if (size > 8){
  91                     uni_code<<=1; uni_code|=1;
  92                     uni_len++;
  93                 }
  94             }
  95             ff_v2_dc_lum_table[level + 256][0] = uni_code;
  96             ff_v2_dc_lum_table[level + 256][1] = uni_len;
  97
  98             /* chrominance h263 */
  99             uni_code= ff_mpeg4_DCtab_chrom[size][0];
 100             uni_len = ff_mpeg4_DCtab_chrom[size][1];
 101             uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility
 102
 103             if (size > 0) {
 104                 uni_code<<=size; uni_code|=l;
 105                 uni_len+=size;
 106                 if (size > 8){
 107                     uni_code<<=1; uni_code|=1;
 108                     uni_len++;
 109                 }
 110             }
 111             ff_v2_dc_chroma_table[level + 256][0] = uni_code;
 112             ff_v2_dc_chroma_table[level + 256][1] = uni_len;
 113
 114         }
 115 }
 116
 117 av_cold void ff_msmpeg4_common_init(MpegEncContext *s)
 118 {
 119     switch(s->msmpeg4_version){
 120     case 1:
 121     case 2:
 122         s->y_dc_scale_table=
 123         s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 124         break;
 125     case 3:
 126         if(s->workaround_bugs){
 127             s->y_dc_scale_table= ff_old_ff_y_dc_scale_table;
 128             s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
 129         } else{
 130             s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table;
 131             s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
 132         }
 133         break;
 134     case 4:
 135     case 5:
 136         s->y_dc_scale_table= ff_wmv1_y_dc_scale_table;
 137         s->c_dc_scale_table= ff_wmv1_c_dc_scale_table;
 138         break;
 139 #if CONFIG_VC1_DECODER
 140     case 6:
 141         s->y_dc_scale_table= ff_wmv3_dc_scale_table;
 142         s->c_dc_scale_table= ff_wmv3_dc_scale_table;
 143         break;
 144 #endif
 145
 146     }
 147
 148
 149     if(s->msmpeg4_version>=4){
 150         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_wmv1_scantable[1]);
 151         ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_wmv1_scantable[2]);
 152         ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_wmv1_scantable[3]);
 153         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_wmv1_scantable[0]);
 154     }
 155     //Note the default tables are set in common_init in mpegvideo.c
 156
 157     init_h263_dc_for_msmpeg4();
 158 }
 159
 160 /* predict coded block */
 161 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
 162 {
 163     int xy, wrap, pred, a, b, c;
 164
 165     xy = s->block_index[n];
 166     wrap = s->b8_stride;
 167
 168     /* B C
 169      * A X
 170      */
 171     a = s->coded_block[xy - 1       ];
 172     b = s->coded_block[xy - 1 - wrap];
 173     c = s->coded_block[xy     - wrap];
 174
 175     if (b == c) {
 176         pred = a;
 177     } else {
 178         pred = c;
 179     }
 180
 181     /* store value */
 182     *coded_block_ptr = &s->coded_block[xy];
 183
 184     return pred;
 185 }
 186
 187 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
 188                                     int32_t **dc_val_ptr)
 189 {
 190     int i;
 191
 192     if (n < 4) {
 193         i= 0;
 194     } else {
 195         i= n-3;
 196     }
 197
 198     *dc_val_ptr= &s->last_dc[i];
 199     return s->last_dc[i];
 200 }
 201
 202 static int get_dc(uint8_t *src, int stride, int scale)
 203 {
 204     int y;
 205     int sum=0;
 206     for(y=0; y<8; y++){
 207         int x;
 208         for(x=0; x<8; x++){
 209             sum+=src[x + y*stride];
 210         }
 211     }
 212     return FASTDIV((sum + (scale>>1)), scale);
 213 }
 214
 215 /* dir = 0: left, dir = 1: top prediction */
 216 int ff_msmpeg4_pred_dc(MpegEncContext *s, int n,
 217                        int16_t **dc_val_ptr, int *dir_ptr)
 218 {
 219     int a, b, c, wrap, pred, scale;
 220     int16_t *dc_val;
 221
 222     /* find prediction */
 223     if (n < 4) {
 224         scale = s->y_dc_scale;
 225     } else {
 226         scale = s->c_dc_scale;
 227     }
 228
 229     wrap = s->block_wrap[n];
 230     dc_val= s->dc_val[0] + s->block_index[n];
 231
 232     /* B C
 233      * A X
 234      */
 235     a = dc_val[ - 1];
 236     b = dc_val[ - 1 - wrap];
 237     c = dc_val[ - wrap];
 238
 239     if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){
 240         b=c=1024;
 241     }
 242
 243     /* XXX: the following solution consumes divisions, but it does not
 244        necessitate to modify mpegvideo.c. The problem comes from the
 245        fact they decided to store the quantized DC (which would lead
 246        to problems if Q could vary !) */
 247 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE
 248     __asm__ volatile(
 249         "movl %3, %%eax         \n\t"
 250         "shrl $1, %%eax         \n\t"
 251         "addl %%eax, %2         \n\t"
 252         "addl %%eax, %1         \n\t"
 253         "addl %0, %%eax         \n\t"
 254         "mull %4                \n\t"
 255         "movl %%edx, %0         \n\t"
 256         "movl %1, %%eax         \n\t"
 257         "mull %4                \n\t"
 258         "movl %%edx, %1         \n\t"
 259         "movl %2, %%eax         \n\t"
 260         "mull %4                \n\t"
 261         "movl %%edx, %2         \n\t"
 262         : "+b" (a), "+c" (b), "+D" (c)
 263         : "g" (scale), "S" (ff_inverse[scale])
 264         : "%eax", "%edx"
 265     );
 266 #else
 267     /* #elif ARCH_ALPHA */
 268     /* Divisions are extremely costly on Alpha; optimize the most
 269        common case. But they are costly everywhere...
 270      */
 271     if (scale == 8) {
 272         a = (a + (8 >> 1)) / 8;
 273         b = (b + (8 >> 1)) / 8;
 274         c = (c + (8 >> 1)) / 8;
 275     } else {
 276         a = FASTDIV((a + (scale >> 1)), scale);
 277         b = FASTDIV((b + (scale >> 1)), scale);
 278         c = FASTDIV((c + (scale >> 1)), scale);
 279     }
 280 #endif
 281     /* XXX: WARNING: they did not choose the same test as MPEG4. This
 282        is very important ! */
 283     if(s->msmpeg4_version>3){
 284         if(s->inter_intra_pred){
 285             uint8_t *dest;
 286             int wrap;
 287
 288             if(n==1){
 289                 pred=a;
 290                 *dir_ptr = 0;
 291             }else if(n==2){
 292                 pred=c;
 293                 *dir_ptr = 1;
 294             }else if(n==3){
 295                 if (abs(a - b) < abs(b - c)) {
 296                     pred = c;
 297                     *dir_ptr = 1;
 298                 } else {
 299                     pred = a;
 300                     *dir_ptr = 0;
 301                 }
 302             }else{
 303                 if(n<4){
 304                     wrap= s->linesize;
 305                     dest= s->current_picture.f.data[0] + (((n >> 1) + 2*s->mb_y) * 8*  wrap ) + ((n & 1) + 2*s->mb_x) * 8;
 306                 }else{
 307                     wrap= s->uvlinesize;
 308                     dest= s->current_picture.f.data[n - 3] + (s->mb_y * 8 * wrap) + s->mb_x * 8;
 309                 }
 310                 if(s->mb_x==0) a= (1024 + (scale>>1))/scale;
 311                 else           a= get_dc(dest-8, wrap, scale*8);
 312                 if(s->mb_y==0) c= (1024 + (scale>>1))/scale;
 313                 else           c= get_dc(dest-8*wrap, wrap, scale*8);
 314
 315                 if (s->h263_aic_dir==0) {
 316                     pred= a;
 317                     *dir_ptr = 0;
 318                 }else if (s->h263_aic_dir==1) {
 319                     if(n==0){
 320                         pred= c;
 321                         *dir_ptr = 1;
 322                     }else{
 323                         pred= a;
 324                         *dir_ptr = 0;
 325                     }
 326                 }else if (s->h263_aic_dir==2) {
 327                     if(n==0){
 328                         pred= a;
 329                         *dir_ptr = 0;
 330                     }else{
 331                         pred= c;
 332                         *dir_ptr = 1;
 333                     }
 334                 } else {
 335                     pred= c;
 336                     *dir_ptr = 1;
 337                 }
 338             }
 339         }else{
 340             if (abs(a - b) < abs(b - c)) {
 341                 pred = c;
 342                 *dir_ptr = 1;
 343             } else {
 344                 pred = a;
 345                 *dir_ptr = 0;
 346             }
 347         }
 348     }else{
 349         if (abs(a - b) <= abs(b - c)) {
 350             pred = c;
 351             *dir_ptr = 1;
 352         } else {
 353             pred = a;
 354             *dir_ptr = 0;
 355         }
 356     }
 357
 358     /* update predictor */
 359     *dc_val_ptr = &dc_val[0];
 360     return pred;
 361 }
 362
 363 /****************************************/
 364 /* decoding stuff */
 365
 366 VLC ff_mb_non_intra_vlc[4];
 367 static VLC v2_dc_lum_vlc;
 368 static VLC v2_dc_chroma_vlc;
 369 static VLC v2_intra_cbpc_vlc;
 370 static VLC v2_mb_type_vlc;
 371 static VLC v2_mv_vlc;
 372 VLC ff_inter_intra_vlc;
 373
 374 /* This is identical to h263 except that its range is multiplied by 2. */
 375 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
 376 {
 377     int code, val, sign, shift;
 378
 379     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
 380     av_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
 381     if (code < 0)
 382         return 0xffff;
 383
 384     if (code == 0)
 385         return pred;
 386     sign = get_bits1(&s->gb);
 387     shift = f_code - 1;
 388     val = code;
 389     if (shift) {
 390         val = (val - 1) << shift;
 391         val |= get_bits(&s->gb, shift);
 392         val++;
 393     }
 394     if (sign)
 395         val = -val;
 396
 397     val += pred;
 398     if (val <= -64)
 399         val += 64;
 400     else if (val >= 64)
 401         val -= 64;
 402
 403     return val;
 404 }
 405
 406 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 407 {
 408     int cbp, code, i;
 409     uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
 410
 411     if (s->pict_type == AV_PICTURE_TYPE_P) {
 412         if (s->use_skip_mb_code) {
 413             if (get_bits1(&s->gb)) {
 414                 /* skip mb */
 415                 s->mb_intra = 0;
 416                 for(i=0;i<6;i++)
 417                     s->block_last_index[i] = -1;
 418                 s->mv_dir = MV_DIR_FORWARD;
 419                 s->mv_type = MV_TYPE_16X16;
 420                 s->mv[0][0][0] = 0;
 421                 s->mv[0][0][1] = 0;
 422                 s->mb_skipped = 1;
 423                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 424                 return 0;
 425             }
 426         }
 427
 428         if(s->msmpeg4_version==2)
 429             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
 430         else
 431             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 432         if(code<0 || code>7){
 433             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
 434             return -1;
 435         }
 436
 437         s->mb_intra = code >>2;
 438
 439         cbp = code & 0x3;
 440     } else {
 441         s->mb_intra = 1;
 442         if(s->msmpeg4_version==2)
 443             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
 444         else
 445             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
 446         if(cbp<0 || cbp>3){
 447             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 448             return -1;
 449         }
 450     }
 451
 452     if (!s->mb_intra) {
 453         int mx, my, cbpy;
 454
 455         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 456         if(cbpy<0){
 457             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 458             return -1;
 459         }
 460
 461         cbp|= cbpy<<2;
 462         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
 463
 464         ff_h263_pred_motion(s, 0, 0, &mx, &my);
 465         mx= msmpeg4v2_decode_motion(s, mx, 1);
 466         my= msmpeg4v2_decode_motion(s, my, 1);
 467
 468         s->mv_dir = MV_DIR_FORWARD;
 469         s->mv_type = MV_TYPE_16X16;
 470         s->mv[0][0][0] = mx;
 471         s->mv[0][0][1] = my;
 472         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 473     } else {
 474         if(s->msmpeg4_version==2){
 475             s->ac_pred = get_bits1(&s->gb);
 476             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 477         } else{
 478             s->ac_pred = 0;
 479             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 480             if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
 481         }
 482         *mb_type_ptr = MB_TYPE_INTRA;
 483     }
 484
 485     s->dsp.clear_blocks(s->block[0]);
 486     for (i = 0; i < 6; i++) {
 487         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 488         {
 489              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 490              return -1;
 491         }
 492     }
 493     return 0;
 494 }
 495
 496 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
 497 {
 498     int cbp, code, i;
 499     uint8_t *coded_val;
 500     uint32_t * const mb_type_ptr = &s->current_picture.f.mb_type[s->mb_x + s->mb_y*s->mb_stride];
 501
 502     if (s->pict_type == AV_PICTURE_TYPE_P) {
 503         if (s->use_skip_mb_code) {
 504             if (get_bits1(&s->gb)) {
 505                 /* skip mb */
 506                 s->mb_intra = 0;
 507                 for(i=0;i<6;i++)
 508                     s->block_last_index[i] = -1;
 509                 s->mv_dir = MV_DIR_FORWARD;
 510                 s->mv_type = MV_TYPE_16X16;
 511                 s->mv[0][0][0] = 0;
 512                 s->mv[0][0][1] = 0;
 513                 s->mb_skipped = 1;
 514                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 515
 516                 return 0;
 517             }
 518         }
 519
 520         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
 521         if (code < 0)
 522             return -1;
 523         //s->mb_intra = (code & 0x40) ? 0 : 1;
 524         s->mb_intra = (~code & 0x40) >> 6;
 525
 526         cbp = code & 0x3f;
 527     } else {
 528         s->mb_intra = 1;
 529         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
 530         if (code < 0)
 531             return -1;
 532         /* predict coded block pattern */
 533         cbp = 0;
 534         for(i=0;i<6;i++) {
 535             int val = ((code >> (5 - i)) & 1);
 536             if (i < 4) {
 537                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
 538                 val = val ^ pred;
 539                 *coded_val = val;
 540             }
 541             cbp |= val << (5 - i);
 542         }
 543     }
 544
 545     if (!s->mb_intra) {
 546         int mx, my;
 547         if(s->per_mb_rl_table && cbp){
 548             s->rl_table_index = decode012(&s->gb);
 549             s->rl_chroma_table_index = s->rl_table_index;
 550         }
 551         ff_h263_pred_motion(s, 0, 0, &mx, &my);
 552         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
 553             return -1;
 554         s->mv_dir = MV_DIR_FORWARD;
 555         s->mv_type = MV_TYPE_16X16;
 556         s->mv[0][0][0] = mx;
 557         s->mv[0][0][1] = my;
 558         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 559     } else {
 560         av_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
 561                 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
 562                 show_bits(&s->gb, 24));
 563         s->ac_pred = get_bits1(&s->gb);
 564         *mb_type_ptr = MB_TYPE_INTRA;
 565         if(s->inter_intra_pred){
 566             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
 567             av_dlog(s, "%d%d %d %d/",
 568                     s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
 569         }
 570         if(s->per_mb_rl_table && cbp){
 571             s->rl_table_index = decode012(&s->gb);
 572             s->rl_chroma_table_index = s->rl_table_index;
 573         }
 574     }
 575
 576     s->dsp.clear_blocks(s->block[0]);
 577     for (i = 0; i < 6; i++) {
 578         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 579         {
 580             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 581             return -1;
 582         }
 583     }
 584
 585     return 0;
 586 }
 587
 588 /* init all vlc decoding tables */
 589 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
 590 {
 591     MpegEncContext *s = avctx->priv_data;
 592     static volatile int done = 0;
 593     int i;
 594     MVTable *mv;
 595
 596     if(avctx->width<=0 || avctx->height<=0) {
 597         av_log(avctx, AV_LOG_ERROR, "invalid dimensions\n");
 598         return -1;
 599     }
 600
 601     if (ff_h263_decode_init(avctx) < 0)
 602         return -1;
 603
 604     ff_msmpeg4_common_init(s);
 605
 606     if (!done) {
 607         for(i=0;i<NB_RL_TABLES;i++) {
 608             ff_init_rl(&ff_rl_table[i], ff_static_rl_table_store[i]);
 609         }
 610         INIT_VLC_RL(ff_rl_table[0], 642);
 611         INIT_VLC_RL(ff_rl_table[1], 1104);
 612         INIT_VLC_RL(ff_rl_table[2], 554);
 613         INIT_VLC_RL(ff_rl_table[3], 940);
 614         INIT_VLC_RL(ff_rl_table[4], 962);
 615         INIT_VLC_RL(ff_rl_table[5], 554);
 616
 617         mv = &ff_mv_tables[0];
 618         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
 619                     mv->table_mv_bits, 1, 1,
 620                     mv->table_mv_code, 2, 2, 3714);
 621         mv = &ff_mv_tables[1];
 622         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
 623                     mv->table_mv_bits, 1, 1,
 624                     mv->table_mv_code, 2, 2, 2694);
 625
 626         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
 627                  &ff_table0_dc_lum[0][1], 8, 4,
 628                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
 629         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
 630                  &ff_table0_dc_chroma[0][1], 8, 4,
 631                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
 632         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
 633                  &ff_table1_dc_lum[0][1], 8, 4,
 634                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
 635         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
 636                  &ff_table1_dc_chroma[0][1], 8, 4,
 637                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
 638
 639         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
 640                  &ff_v2_dc_lum_table[0][1], 8, 4,
 641                  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
 642         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
 643                  &ff_v2_dc_chroma_table[0][1], 8, 4,
 644                  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
 645
 646         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
 647                  &ff_v2_intra_cbpc[0][1], 2, 1,
 648                  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
 649         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
 650                  &ff_v2_mb_type[0][1], 2, 1,
 651                  &ff_v2_mb_type[0][0], 2, 1, 128);
 652         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
 653                  &ff_mvtab[0][1], 2, 1,
 654                  &ff_mvtab[0][0], 2, 1, 538);
 655
 656         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
 657                      &ff_wmv2_inter_table[0][0][1], 8, 4,
 658                      &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
 659         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
 660                      &ff_wmv2_inter_table[1][0][1], 8, 4,
 661                      &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
 662         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
 663                      &ff_wmv2_inter_table[2][0][1], 8, 4,
 664                      &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
 665         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
 666                      &ff_wmv2_inter_table[3][0][1], 8, 4,
 667                      &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
 668
 669         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 670                  &ff_msmp4_mb_i_table[0][1], 4, 2,
 671                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
 672
 673         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
 674                  &ff_table_inter_intra[0][1], 2, 1,
 675                  &ff_table_inter_intra[0][0], 2, 1, 8);
 676         done = 1;
 677     }
 678
 679     switch(s->msmpeg4_version){
 680     case 1:
 681     case 2:
 682         s->decode_mb= msmpeg4v12_decode_mb;
 683         break;
 684     case 3:
 685     case 4:
 686         s->decode_mb= msmpeg4v34_decode_mb;
 687         break;
 688     case 5:
 689         if (CONFIG_WMV2_DECODER)
 690             s->decode_mb= ff_wmv2_decode_mb;
 691     case 6:
 692         //FIXME + TODO VC1 decode mb
 693         break;
 694     }
 695
 696     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
 697
 698     return 0;
 699 }
 700
 701 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
 702 {
 703     int code;
 704
 705     if(s->msmpeg4_version==1){
 706         int start_code = get_bits_long(&s->gb, 32);
 707         if(start_code!=0x00000100){
 708             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
 709             return -1;
 710         }
 711
 712         skip_bits(&s->gb, 5); // frame number */
 713     }
 714
 715     s->pict_type = get_bits(&s->gb, 2) + 1;
 716     if (s->pict_type != AV_PICTURE_TYPE_I &&
 717         s->pict_type != AV_PICTURE_TYPE_P){
 718         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
 719         return -1;
 720     }
 721 #if 0
 722 {
 723     static int had_i=0;
 724     if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
 725     if(!had_i) return -1;
 726 }
 727 #endif
 728     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
 729     if(s->qscale==0){
 730         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
 731         return -1;
 732     }
 733
 734     if (s->pict_type == AV_PICTURE_TYPE_I) {
 735         code = get_bits(&s->gb, 5);
 736         if(s->msmpeg4_version==1){
 737             if(code==0 || code>s->mb_height){
 738                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
 739                 return -1;
 740             }
 741
 742             s->slice_height = code;
 743         }else{
 744             /* 0x17: one slice, 0x18: two slices, ... */
 745             if (code < 0x17){
 746                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
 747                 return -1;
 748             }
 749
 750             s->slice_height = s->mb_height / (code - 0x16);
 751         }
 752
 753         switch(s->msmpeg4_version){
 754         case 1:
 755         case 2:
 756             s->rl_chroma_table_index = 2;
 757             s->rl_table_index = 2;
 758
 759             s->dc_table_index = 0; //not used
 760             break;
 761         case 3:
 762             s->rl_chroma_table_index = decode012(&s->gb);
 763             s->rl_table_index = decode012(&s->gb);
 764
 765             s->dc_table_index = get_bits1(&s->gb);
 766             break;
 767         case 4:
 768             ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
 769
 770             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 771             else                           s->per_mb_rl_table= 0;
 772
 773             if(!s->per_mb_rl_table){
 774                 s->rl_chroma_table_index = decode012(&s->gb);
 775                 s->rl_table_index = decode012(&s->gb);
 776             }
 777
 778             s->dc_table_index = get_bits1(&s->gb);
 779             s->inter_intra_pred= 0;
 780             break;
 781         }
 782         s->no_rounding = 1;
 783         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 784             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
 785                 s->qscale,
 786                 s->rl_chroma_table_index,
 787                 s->rl_table_index,
 788                 s->dc_table_index,
 789                 s->per_mb_rl_table,
 790                 s->slice_height);
 791     } else {
 792         switch(s->msmpeg4_version){
 793         case 1:
 794         case 2:
 795             if(s->msmpeg4_version==1)
 796                 s->use_skip_mb_code = 1;
 797             else
 798                 s->use_skip_mb_code = get_bits1(&s->gb);
 799             s->rl_table_index = 2;
 800             s->rl_chroma_table_index = s->rl_table_index;
 801             s->dc_table_index = 0; //not used
 802             s->mv_table_index = 0;
 803             break;
 804         case 3:
 805             s->use_skip_mb_code = get_bits1(&s->gb);
 806             s->rl_table_index = decode012(&s->gb);
 807             s->rl_chroma_table_index = s->rl_table_index;
 808
 809             s->dc_table_index = get_bits1(&s->gb);
 810
 811             s->mv_table_index = get_bits1(&s->gb);
 812             break;
 813         case 4:
 814             s->use_skip_mb_code = get_bits1(&s->gb);
 815
 816             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 817             else                           s->per_mb_rl_table= 0;
 818
 819             if(!s->per_mb_rl_table){
 820                 s->rl_table_index = decode012(&s->gb);
 821                 s->rl_chroma_table_index = s->rl_table_index;
 822             }
 823
 824             s->dc_table_index = get_bits1(&s->gb);
 825
 826             s->mv_table_index = get_bits1(&s->gb);
 827             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
 828             break;
 829         }
 830
 831         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 832             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
 833                 s->use_skip_mb_code,
 834                 s->rl_table_index,
 835                 s->rl_chroma_table_index,
 836                 s->dc_table_index,
 837                 s->mv_table_index,
 838                 s->per_mb_rl_table,
 839                 s->qscale);
 840
 841         if(s->flipflop_rounding){
 842             s->no_rounding ^= 1;
 843         }else{
 844             s->no_rounding = 0;
 845         }
 846     }
 847     av_dlog(s->avctx, "%d %d %d %d %d\n", s->pict_type, s->bit_rate,
 848             s->inter_intra_pred, s->width, s->height);
 849
 850     s->esc3_level_length= 0;
 851     s->esc3_run_length= 0;
 852
 853     return 0;
 854 }
 855
 856 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
 857 {
 858     int left= buf_size*8 - get_bits_count(&s->gb);
 859     int length= s->msmpeg4_version>=3 ? 17 : 16;
 860     /* the alt_bitstream reader could read over the end so we need to check it */
 861     if(left>=length && left<length+8)
 862     {
 863         skip_bits(&s->gb, 5); /* fps */
 864         s->bit_rate= get_bits(&s->gb, 11)*1024;
 865         if(s->msmpeg4_version>=3)
 866             s->flipflop_rounding= get_bits1(&s->gb);
 867         else
 868             s->flipflop_rounding= 0;
 869     }
 870     else if(left<length+8)
 871     {
 872         s->flipflop_rounding= 0;
 873         if(s->msmpeg4_version != 2)
 874             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
 875     }
 876     else
 877     {
 878         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
 879     }
 880
 881     return 0;
 882 }
 883
 884 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
 885 {
 886     int level, pred;
 887
 888     if(s->msmpeg4_version<=2){
 889         if (n < 4) {
 890             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
 891         } else {
 892             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
 893         }
 894         if (level < 0)
 895             return -1;
 896         level-=256;
 897     }else{  //FIXME optimize use unified tables & index
 898         if (n < 4) {
 899             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 900         } else {
 901             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 902         }
 903         if (level < 0){
 904             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 905             return -1;
 906         }
 907
 908         if (level == DC_MAX) {
 909             level = get_bits(&s->gb, 8);
 910             if (get_bits1(&s->gb))
 911                 level = -level;
 912         } else if (level != 0) {
 913             if (get_bits1(&s->gb))
 914                 level = -level;
 915         }
 916     }
 917
 918     if(s->msmpeg4_version==1){
 919         int32_t *dc_val;
 920         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 921         level += pred;
 922
 923         /* update predictor */
 924         *dc_val= level;
 925     }else{
 926         int16_t *dc_val;
 927         pred   = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 928         level += pred;
 929
 930         /* update predictor */
 931         if (n < 4) {
 932             *dc_val = level * s->y_dc_scale;
 933         } else {
 934             *dc_val = level * s->c_dc_scale;
 935         }
 936     }
 937
 938     return level;
 939 }
 940
 941 //#define ERROR_DETAILS
 942 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
 943                               int n, int coded, const uint8_t *scan_table)
 944 {
 945     int level, i, last, run, run_diff;
 946     int av_uninit(dc_pred_dir);
 947     RLTable *rl;
 948     RL_VLC_ELEM *rl_vlc;
 949     int qmul, qadd;
 950
 951     if (s->mb_intra) {
 952         qmul=1;
 953         qadd=0;
 954
 955         /* DC coef */
 956         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
 957
 958         if (level < 0){
 959             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
 960             if(s->inter_intra_pred) level=0;
 961             else                    return -1;
 962         }
 963         if (n < 4) {
 964             rl = &ff_rl_table[s->rl_table_index];
 965             if(level > 256*s->y_dc_scale){
 966                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
 967                 if(!s->inter_intra_pred) return -1;
 968             }
 969         } else {
 970             rl = &ff_rl_table[3 + s->rl_chroma_table_index];
 971             if(level > 256*s->c_dc_scale){
 972                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
 973                 if(!s->inter_intra_pred) return -1;
 974             }
 975         }
 976         block[0] = level;
 977
 978         run_diff = s->msmpeg4_version >= 4;
 979         i = 0;
 980         if (!coded) {
 981             goto not_coded;
 982         }
 983         if (s->ac_pred) {
 984             if (dc_pred_dir == 0)
 985                 scan_table = s->intra_v_scantable.permutated; /* left */
 986             else
 987                 scan_table = s->intra_h_scantable.permutated; /* top */
 988         } else {
 989             scan_table = s->intra_scantable.permutated;
 990         }
 991         rl_vlc= rl->rl_vlc[0];
 992     } else {
 993         qmul = s->qscale << 1;
 994         qadd = (s->qscale - 1) | 1;
 995         i = -1;
 996         rl = &ff_rl_table[3 + s->rl_table_index];
 997
 998         if(s->msmpeg4_version==2)
 999             run_diff = 0;
1000         else
1001             run_diff = 1;
1002
1003         if (!coded) {
1004             s->block_last_index[n] = i;
1005             return 0;
1006         }
1007         if(!scan_table)
1008             scan_table = s->inter_scantable.permutated;
1009         rl_vlc= rl->rl_vlc[s->qscale];
1010     }
1011   {
1012     OPEN_READER(re, &s->gb);
1013     for(;;) {
1014         UPDATE_CACHE(re, &s->gb);
1015         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
1016         if (level==0) {
1017             int cache;
1018             cache= GET_CACHE(re, &s->gb);
1019             /* escape */
1020             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
1021                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
1022                     /* third escape */
1023                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
1024                     UPDATE_CACHE(re, &s->gb);
1025                     if(s->msmpeg4_version<=3){
1026                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
1027                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
1028                         level= SHOW_SBITS(re, &s->gb, 8);
1029                         SKIP_COUNTER(re, &s->gb, 1+6+8);
1030                     }else{
1031                         int sign;
1032                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1033                         if(!s->esc3_level_length){
1034                             int ll;
1035                             av_dlog(s->avctx, "ESC-3 %X at %d %d\n",
1036                                     show_bits(&s->gb, 24), s->mb_x, s->mb_y);
1037                             if(s->qscale<8){
1038                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
1039                                 if(ll==0){
1040                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
1041                                 }
1042                             }else{
1043                                 ll=2;
1044                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
1045                                     ll++;
1046                                     SKIP_BITS(re, &s->gb, 1);
1047                                 }
1048                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
1049                             }
1050
1051                             s->esc3_level_length= ll;
1052                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
1053                             UPDATE_CACHE(re, &s->gb);
1054                         }
1055                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
1056                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
1057
1058                         sign=  SHOW_UBITS(re, &s->gb, 1);
1059                         SKIP_BITS(re, &s->gb, 1);
1060
1061                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
1062                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
1063                         if(sign) level= -level;
1064                     }
1065
1066 #if 0 // waste of time / this will detect very few errors
1067                     {
1068                         const int abs_level= FFABS(level);
1069                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
1070                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
1071                             if(abs_level <= rl->max_level[last][run]){
1072                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
1073                                 return DECODING_AC_LOST;
1074                             }
1075                             if(abs_level <= rl->max_level[last][run]*2){
1076                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
1077                                 return DECODING_AC_LOST;
1078                             }
1079                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
1080                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
1081                                 return DECODING_AC_LOST;
1082                             }
1083                         }
1084                     }
1085 #endif
1086                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
1087                     if (level>0) level= level * qmul + qadd;
1088                     else         level= level * qmul - qadd;
1089 #if 0 // waste of time too :(
1090                     if(level>2048 || level<-2048){
1091                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
1092                         return DECODING_AC_LOST;
1093                     }
1094 #endif
1095                     i+= run + 1;
1096                     if(last) i+=192;
1097 #ifdef ERROR_DETAILS
1098                 if(run==66)
1099                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
1100                 else if((i>62 && i<192) || i>192+63)
1101                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
1102 #endif
1103                 } else {
1104                     /* second escape */
1105                     SKIP_BITS(re, &s->gb, 2);
1106                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1107                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
1108                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1109                     LAST_SKIP_BITS(re, &s->gb, 1);
1110 #ifdef ERROR_DETAILS
1111                 if(run==66)
1112                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
1113                 else if((i>62 && i<192) || i>192+63)
1114                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
1115 #endif
1116                 }
1117             } else {
1118                 /* first escape */
1119                 SKIP_BITS(re, &s->gb, 1);
1120                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
1121                 i+= run;
1122                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
1123                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1124                 LAST_SKIP_BITS(re, &s->gb, 1);
1125 #ifdef ERROR_DETAILS
1126                 if(run==66)
1127                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
1128                 else if((i>62 && i<192) || i>192+63)
1129                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
1130 #endif
1131             }
1132         } else {
1133             i+= run;
1134             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
1135             LAST_SKIP_BITS(re, &s->gb, 1);
1136 #ifdef ERROR_DETAILS
1137                 if(run==66)
1138                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
1139                 else if((i>62 && i<192) || i>192+63)
1140                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
1141 #endif
1142         }
1143         if (i > 62){
1144             i-= 192;
1145             if(i&(~63)){
1146                 const int left= get_bits_left(&s->gb);
1147                 if(((i+192 == 64 && level/qmul==-1) || !(s->err_recognition&(AV_EF_BITSTREAM|AV_EF_COMPLIANT))) && left>=0){
1148                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
1149                     break;
1150                 }else{
1151                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
1152                     return -1;
1153                 }
1154             }
1155
1156             block[scan_table[i]] = level;
1157             break;
1158         }
1159
1160         block[scan_table[i]] = level;
1161     }
1162     CLOSE_READER(re, &s->gb);
1163   }
1164  not_coded:
1165     if (s->mb_intra) {
1166         ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
1167         if (s->ac_pred) {
1168             i = 63; /* XXX: not optimal */
1169         }
1170     }
1171     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
1172     s->block_last_index[n] = i;
1173
1174     return 0;
1175 }
1176
1177 int ff_msmpeg4_decode_motion(MpegEncContext * s,
1178                                  int *mx_ptr, int *my_ptr)
1179 {
1180     MVTable *mv;
1181     int code, mx, my;
1182
1183     mv = &ff_mv_tables[s->mv_table_index];
1184
1185     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
1186     if (code < 0){
1187         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
1188         return -1;
1189     }
1190     if (code == mv->n) {
1191         mx = get_bits(&s->gb, 6);
1192         my = get_bits(&s->gb, 6);
1193     } else {
1194         mx = mv->table_mvx[code];
1195         my = mv->table_mvy[code];
1196     }
1197
1198     mx += *mx_ptr - 32;
1199     my += *my_ptr - 32;
1200     /* WARNING : they do not do exactly modulo encoding */
1201     if (mx <= -64)
1202         mx += 64;
1203     else if (mx >= 64)
1204         mx -= 64;
1205
1206     if (my <= -64)
1207         my += 64;
1208     else if (my >= 64)
1209         my -= 64;
1210     *mx_ptr = mx;
1211     *my_ptr = my;
1212     return 0;
1213 }
1214
1215 AVCodec ff_msmpeg4v1_decoder = {
1216     .name           = "msmpeg4v1",
1217     .type           = AVMEDIA_TYPE_VIDEO,
1218     .id             = AV_CODEC_ID_MSMPEG4V1,
1219     .priv_data_size = sizeof(MpegEncContext),
1220     .init           = ff_msmpeg4_decode_init,
1221     .close          = ff_h263_decode_end,
1222     .decode         = ff_h263_decode_frame,
1223     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1224     .max_lowres     = 3,
1225     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
1226     .pix_fmts       = ff_pixfmt_list_420,
1227 };
1228
1229 AVCodec ff_msmpeg4v2_decoder = {
1230     .name           = "msmpeg4v2",
1231     .type           = AVMEDIA_TYPE_VIDEO,
1232     .id             = AV_CODEC_ID_MSMPEG4V2,
1233     .priv_data_size = sizeof(MpegEncContext),
1234     .init           = ff_msmpeg4_decode_init,
1235     .close          = ff_h263_decode_end,
1236     .decode         = ff_h263_decode_frame,
1237     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1238     .max_lowres     = 3,
1239     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
1240     .pix_fmts       = ff_pixfmt_list_420,
1241 };
1242
1243 AVCodec ff_msmpeg4v3_decoder = {
1244     .name           = "msmpeg4",
1245     .type           = AVMEDIA_TYPE_VIDEO,
1246     .id             = AV_CODEC_ID_MSMPEG4V3,
1247     .priv_data_size = sizeof(MpegEncContext),
1248     .init           = ff_msmpeg4_decode_init,
1249     .close          = ff_h263_decode_end,
1250     .decode         = ff_h263_decode_frame,
1251     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1252     .max_lowres     = 3,
1253     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
1254     .pix_fmts       = ff_pixfmt_list_420,
1255 };
1256
1257 AVCodec ff_wmv1_decoder = {
1258     .name           = "wmv1",
1259     .type           = AVMEDIA_TYPE_VIDEO,
1260     .id             = AV_CODEC_ID_WMV1,
1261     .priv_data_size = sizeof(MpegEncContext),
1262     .init           = ff_msmpeg4_decode_init,
1263     .close          = ff_h263_decode_end,
1264     .decode         = ff_h263_decode_frame,
1265     .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
1266     .max_lowres     = 3,
1267     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
1268     .pix_fmts       = ff_pixfmt_list_420,
1269 };