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