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

   1 /*
   2  * MSMPEG4 backend for encoder and decoder
   3  * Copyright (c) 2001 Fabrice Bellard
   4  * Copyright (c) 2002-2013 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 #include "avcodec.h"
  26 #include "internal.h"
  27 #include "mpegutils.h"
  28 #include "mpegvideo.h"
  29 #include "msmpeg4.h"
  30 #include "libavutil/imgutils.h"
  31 #include "libavutil/x86/asm.h"
  32 #include "h263.h"
  33 #include "mpeg4video.h"
  34 #include "msmpeg4data.h"
  35 #include "vc1data.h"
  36 #include "wmv2.h"
  37
  38 #define DC_VLC_BITS 9
  39 #define V2_INTRA_CBPC_VLC_BITS 3
  40 #define V2_MB_TYPE_VLC_BITS 7
  41 #define MV_VLC_BITS 9
  42 #define V2_MV_VLC_BITS 9
  43 #define TEX_VLC_BITS 9
  44
  45 #define DEFAULT_INTER_INDEX 3
  46
  47 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n,
  48                                     int32_t **dc_val_ptr)
  49 {
  50     int i;
  51
  52     if (n < 4) {
  53         i= 0;
  54     } else {
  55         i= n-3;
  56     }
  57
  58     *dc_val_ptr= &s->last_dc[i];
  59     return s->last_dc[i];
  60 }
  61
  62 /****************************************/
  63 /* decoding stuff */
  64
  65 VLC ff_mb_non_intra_vlc[4];
  66 static VLC v2_dc_lum_vlc;
  67 static VLC v2_dc_chroma_vlc;
  68 static VLC v2_intra_cbpc_vlc;
  69 static VLC v2_mb_type_vlc;
  70 static VLC v2_mv_vlc;
  71 VLC ff_inter_intra_vlc;
  72
  73 /* This is identical to h263 except that its range is multiplied by 2. */
  74 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code)
  75 {
  76     int code, val, sign, shift;
  77
  78     code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2);
  79     ff_dlog(s, "MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred);
  80     if (code < 0)
  81         return 0xffff;
  82
  83     if (code == 0)
  84         return pred;
  85     sign = get_bits1(&s->gb);
  86     shift = f_code - 1;
  87     val = code;
  88     if (shift) {
  89         val = (val - 1) << shift;
  90         val |= get_bits(&s->gb, shift);
  91         val++;
  92     }
  93     if (sign)
  94         val = -val;
  95
  96     val += pred;
  97     if (val <= -64)
  98         val += 64;
  99     else if (val >= 64)
 100         val -= 64;
 101
 102     return val;
 103 }
 104
 105 static int msmpeg4v12_decode_mb(MpegEncContext *s, int16_t block[6][64])
 106 {
 107     int cbp, code, i;
 108     uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
 109
 110     if (s->pict_type == AV_PICTURE_TYPE_P) {
 111         if (s->use_skip_mb_code) {
 112             if (get_bits1(&s->gb)) {
 113                 /* skip mb */
 114                 s->mb_intra = 0;
 115                 for(i=0;i<6;i++)
 116                     s->block_last_index[i] = -1;
 117                 s->mv_dir = MV_DIR_FORWARD;
 118                 s->mv_type = MV_TYPE_16X16;
 119                 s->mv[0][0][0] = 0;
 120                 s->mv[0][0][1] = 0;
 121                 s->mb_skipped = 1;
 122                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 123                 return 0;
 124             }
 125         }
 126
 127         if(s->msmpeg4_version==2)
 128             code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1);
 129         else
 130             code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2);
 131         if(code<0 || code>7){
 132             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y);
 133             return -1;
 134         }
 135
 136         s->mb_intra = code >>2;
 137
 138         cbp = code & 0x3;
 139     } else {
 140         s->mb_intra = 1;
 141         if(s->msmpeg4_version==2)
 142             cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1);
 143         else
 144             cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1);
 145         if(cbp<0 || cbp>3){
 146             av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 147             return -1;
 148         }
 149     }
 150
 151     if (!s->mb_intra) {
 152         int mx, my, cbpy;
 153
 154         cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1);
 155         if(cbpy<0){
 156             av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y);
 157             return -1;
 158         }
 159
 160         cbp|= cbpy<<2;
 161         if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C;
 162
 163         ff_h263_pred_motion(s, 0, 0, &mx, &my);
 164         mx= msmpeg4v2_decode_motion(s, mx, 1);
 165         my= msmpeg4v2_decode_motion(s, my, 1);
 166
 167         s->mv_dir = MV_DIR_FORWARD;
 168         s->mv_type = MV_TYPE_16X16;
 169         s->mv[0][0][0] = mx;
 170         s->mv[0][0][1] = my;
 171         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 172     } else {
 173         if(s->msmpeg4_version==2){
 174             s->ac_pred = get_bits1(&s->gb);
 175             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 176         } else{
 177             s->ac_pred = 0;
 178             cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors
 179             if(s->pict_type==AV_PICTURE_TYPE_P) cbp^=0x3C;
 180         }
 181         *mb_type_ptr = MB_TYPE_INTRA;
 182     }
 183
 184     s->bdsp.clear_blocks(s->block[0]);
 185     for (i = 0; i < 6; i++) {
 186         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 187         {
 188              av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 189              return -1;
 190         }
 191     }
 192     return 0;
 193 }
 194
 195 static int msmpeg4v34_decode_mb(MpegEncContext *s, int16_t block[6][64])
 196 {
 197     int cbp, code, i;
 198     uint8_t *coded_val;
 199     uint32_t * const mb_type_ptr = &s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride];
 200
 201     if (s->pict_type == AV_PICTURE_TYPE_P) {
 202         if (s->use_skip_mb_code) {
 203             if (get_bits1(&s->gb)) {
 204                 /* skip mb */
 205                 s->mb_intra = 0;
 206                 for(i=0;i<6;i++)
 207                     s->block_last_index[i] = -1;
 208                 s->mv_dir = MV_DIR_FORWARD;
 209                 s->mv_type = MV_TYPE_16X16;
 210                 s->mv[0][0][0] = 0;
 211                 s->mv[0][0][1] = 0;
 212                 s->mb_skipped = 1;
 213                 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
 214
 215                 return 0;
 216             }
 217         }
 218
 219         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3);
 220         if (code < 0)
 221             return -1;
 222         //s->mb_intra = (code & 0x40) ? 0 : 1;
 223         s->mb_intra = (~code & 0x40) >> 6;
 224
 225         cbp = code & 0x3f;
 226     } else {
 227         s->mb_intra = 1;
 228         code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
 229         if (code < 0)
 230             return -1;
 231         /* predict coded block pattern */
 232         cbp = 0;
 233         for(i=0;i<6;i++) {
 234             int val = ((code >> (5 - i)) & 1);
 235             if (i < 4) {
 236                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
 237                 val = val ^ pred;
 238                 *coded_val = val;
 239             }
 240             cbp |= val << (5 - i);
 241         }
 242     }
 243
 244     if (!s->mb_intra) {
 245         int mx, my;
 246         if(s->per_mb_rl_table && cbp){
 247             s->rl_table_index = decode012(&s->gb);
 248             s->rl_chroma_table_index = s->rl_table_index;
 249         }
 250         ff_h263_pred_motion(s, 0, 0, &mx, &my);
 251         if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0)
 252             return -1;
 253         s->mv_dir = MV_DIR_FORWARD;
 254         s->mv_type = MV_TYPE_16X16;
 255         s->mv[0][0][0] = mx;
 256         s->mv[0][0][1] = my;
 257         *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16;
 258     } else {
 259         ff_dlog(s, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
 260                 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
 261                 show_bits(&s->gb, 24));
 262         s->ac_pred = get_bits1(&s->gb);
 263         *mb_type_ptr = MB_TYPE_INTRA;
 264         if(s->inter_intra_pred){
 265             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
 266             ff_dlog(s, "%d%d %d %d/",
 267                     s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
 268         }
 269         if(s->per_mb_rl_table && cbp){
 270             s->rl_table_index = decode012(&s->gb);
 271             s->rl_chroma_table_index = s->rl_table_index;
 272         }
 273     }
 274
 275     s->bdsp.clear_blocks(s->block[0]);
 276     for (i = 0; i < 6; i++) {
 277         if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
 278         {
 279             av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
 280             return -1;
 281         }
 282     }
 283
 284     return 0;
 285 }
 286
 287 /* init all vlc decoding tables */
 288 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx)
 289 {
 290     MpegEncContext *s = avctx->priv_data;
 291     static volatile int done = 0;
 292     int i, ret;
 293     MVTable *mv;
 294
 295     if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
 296         return ret;
 297
 298     if (ff_h263_decode_init(avctx) < 0)
 299         return -1;
 300
 301     ff_msmpeg4_common_init(s);
 302
 303     if (!done) {
 304         for(i=0;i<NB_RL_TABLES;i++) {
 305             ff_rl_init(&ff_rl_table[i], ff_static_rl_table_store[i]);
 306         }
 307         INIT_VLC_RL(ff_rl_table[0], 642);
 308         INIT_VLC_RL(ff_rl_table[1], 1104);
 309         INIT_VLC_RL(ff_rl_table[2], 554);
 310         INIT_VLC_RL(ff_rl_table[3], 940);
 311         INIT_VLC_RL(ff_rl_table[4], 962);
 312         INIT_VLC_RL(ff_rl_table[5], 554);
 313
 314         mv = &ff_mv_tables[0];
 315         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
 316                     mv->table_mv_bits, 1, 1,
 317                     mv->table_mv_code, 2, 2, 3714);
 318         mv = &ff_mv_tables[1];
 319         INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1,
 320                     mv->table_mv_bits, 1, 1,
 321                     mv->table_mv_code, 2, 2, 2694);
 322
 323         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120,
 324                  &ff_table0_dc_lum[0][1], 8, 4,
 325                  &ff_table0_dc_lum[0][0], 8, 4, 1158);
 326         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120,
 327                  &ff_table0_dc_chroma[0][1], 8, 4,
 328                  &ff_table0_dc_chroma[0][0], 8, 4, 1118);
 329         INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120,
 330                  &ff_table1_dc_lum[0][1], 8, 4,
 331                  &ff_table1_dc_lum[0][0], 8, 4, 1476);
 332         INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120,
 333                  &ff_table1_dc_chroma[0][1], 8, 4,
 334                  &ff_table1_dc_chroma[0][0], 8, 4, 1216);
 335
 336         INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512,
 337                  &ff_v2_dc_lum_table[0][1], 8, 4,
 338                  &ff_v2_dc_lum_table[0][0], 8, 4, 1472);
 339         INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512,
 340                  &ff_v2_dc_chroma_table[0][1], 8, 4,
 341                  &ff_v2_dc_chroma_table[0][0], 8, 4, 1506);
 342
 343         INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4,
 344                  &ff_v2_intra_cbpc[0][1], 2, 1,
 345                  &ff_v2_intra_cbpc[0][0], 2, 1, 8);
 346         INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8,
 347                  &ff_v2_mb_type[0][1], 2, 1,
 348                  &ff_v2_mb_type[0][0], 2, 1, 128);
 349         INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33,
 350                  &ff_mvtab[0][1], 2, 1,
 351                  &ff_mvtab[0][0], 2, 1, 538);
 352
 353         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128,
 354                      &ff_wmv2_inter_table[0][0][1], 8, 4,
 355                      &ff_wmv2_inter_table[0][0][0], 8, 4, 1636);
 356         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128,
 357                      &ff_wmv2_inter_table[1][0][1], 8, 4,
 358                      &ff_wmv2_inter_table[1][0][0], 8, 4, 2648);
 359         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128,
 360                      &ff_wmv2_inter_table[2][0][1], 8, 4,
 361                      &ff_wmv2_inter_table[2][0][0], 8, 4, 1532);
 362         INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128,
 363                      &ff_wmv2_inter_table[3][0][1], 8, 4,
 364                      &ff_wmv2_inter_table[3][0][0], 8, 4, 2488);
 365
 366         INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 367                  &ff_msmp4_mb_i_table[0][1], 4, 2,
 368                  &ff_msmp4_mb_i_table[0][0], 4, 2, 536);
 369
 370         INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4,
 371                  &ff_table_inter_intra[0][1], 2, 1,
 372                  &ff_table_inter_intra[0][0], 2, 1, 8);
 373         done = 1;
 374     }
 375
 376     switch(s->msmpeg4_version){
 377     case 1:
 378     case 2:
 379         s->decode_mb= msmpeg4v12_decode_mb;
 380         break;
 381     case 3:
 382     case 4:
 383         s->decode_mb= msmpeg4v34_decode_mb;
 384         break;
 385     case 5:
 386         if (CONFIG_WMV2_DECODER)
 387             s->decode_mb= ff_wmv2_decode_mb;
 388     case 6:
 389         //FIXME + TODO VC1 decode mb
 390         break;
 391     }
 392
 393     s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe
 394
 395     return 0;
 396 }
 397
 398 int ff_msmpeg4_decode_picture_header(MpegEncContext * s)
 399 {
 400     int code;
 401
 402     if(s->msmpeg4_version==1){
 403         int start_code = get_bits_long(&s->gb, 32);
 404         if(start_code!=0x00000100){
 405             av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n");
 406             return -1;
 407         }
 408
 409         skip_bits(&s->gb, 5); // frame number */
 410     }
 411
 412     s->pict_type = get_bits(&s->gb, 2) + 1;
 413     if (s->pict_type != AV_PICTURE_TYPE_I &&
 414         s->pict_type != AV_PICTURE_TYPE_P){
 415         av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n");
 416         return -1;
 417     }
 418 #if 0
 419 {
 420     static int had_i=0;
 421     if(s->pict_type == AV_PICTURE_TYPE_I) had_i=1;
 422     if(!had_i) return -1;
 423 }
 424 #endif
 425     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
 426     if(s->qscale==0){
 427         av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n");
 428         return -1;
 429     }
 430
 431     if (s->pict_type == AV_PICTURE_TYPE_I) {
 432         code = get_bits(&s->gb, 5);
 433         if(s->msmpeg4_version==1){
 434             if(code==0 || code>s->mb_height){
 435                 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code);
 436                 return -1;
 437             }
 438
 439             s->slice_height = code;
 440         }else{
 441             /* 0x17: one slice, 0x18: two slices, ... */
 442             if (code < 0x17){
 443                 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code);
 444                 return -1;
 445             }
 446
 447             s->slice_height = s->mb_height / (code - 0x16);
 448         }
 449
 450         switch(s->msmpeg4_version){
 451         case 1:
 452         case 2:
 453             s->rl_chroma_table_index = 2;
 454             s->rl_table_index = 2;
 455
 456             s->dc_table_index = 0; //not used
 457             break;
 458         case 3:
 459             s->rl_chroma_table_index = decode012(&s->gb);
 460             s->rl_table_index = decode012(&s->gb);
 461
 462             s->dc_table_index = get_bits1(&s->gb);
 463             break;
 464         case 4:
 465             ff_msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8);
 466
 467             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 468             else                           s->per_mb_rl_table= 0;
 469
 470             if(!s->per_mb_rl_table){
 471                 s->rl_chroma_table_index = decode012(&s->gb);
 472                 s->rl_table_index = decode012(&s->gb);
 473             }
 474
 475             s->dc_table_index = get_bits1(&s->gb);
 476             s->inter_intra_pred= 0;
 477             break;
 478         }
 479         s->no_rounding = 1;
 480         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 481             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d   \n",
 482                 s->qscale,
 483                 s->rl_chroma_table_index,
 484                 s->rl_table_index,
 485                 s->dc_table_index,
 486                 s->per_mb_rl_table,
 487                 s->slice_height);
 488     } else {
 489         switch(s->msmpeg4_version){
 490         case 1:
 491         case 2:
 492             if(s->msmpeg4_version==1)
 493                 s->use_skip_mb_code = 1;
 494             else
 495                 s->use_skip_mb_code = get_bits1(&s->gb);
 496             s->rl_table_index = 2;
 497             s->rl_chroma_table_index = s->rl_table_index;
 498             s->dc_table_index = 0; //not used
 499             s->mv_table_index = 0;
 500             break;
 501         case 3:
 502             s->use_skip_mb_code = get_bits1(&s->gb);
 503             s->rl_table_index = decode012(&s->gb);
 504             s->rl_chroma_table_index = s->rl_table_index;
 505
 506             s->dc_table_index = get_bits1(&s->gb);
 507
 508             s->mv_table_index = get_bits1(&s->gb);
 509             break;
 510         case 4:
 511             s->use_skip_mb_code = get_bits1(&s->gb);
 512
 513             if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb);
 514             else                           s->per_mb_rl_table= 0;
 515
 516             if(!s->per_mb_rl_table){
 517                 s->rl_table_index = decode012(&s->gb);
 518                 s->rl_chroma_table_index = s->rl_table_index;
 519             }
 520
 521             s->dc_table_index = get_bits1(&s->gb);
 522
 523             s->mv_table_index = get_bits1(&s->gb);
 524             s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
 525             break;
 526         }
 527
 528         if(s->avctx->debug&FF_DEBUG_PICT_INFO)
 529             av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d   \n",
 530                 s->use_skip_mb_code,
 531                 s->rl_table_index,
 532                 s->rl_chroma_table_index,
 533                 s->dc_table_index,
 534                 s->mv_table_index,
 535                 s->per_mb_rl_table,
 536                 s->qscale);
 537
 538         if(s->flipflop_rounding){
 539             s->no_rounding ^= 1;
 540         }else{
 541             s->no_rounding = 0;
 542         }
 543     }
 544     ff_dlog(s->avctx, "%d %"PRId64" %d %d %d\n", s->pict_type, s->bit_rate,
 545             s->inter_intra_pred, s->width, s->height);
 546
 547     s->esc3_level_length= 0;
 548     s->esc3_run_length= 0;
 549
 550     return 0;
 551 }
 552
 553 int ff_msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size)
 554 {
 555     int left= buf_size*8 - get_bits_count(&s->gb);
 556     int length= s->msmpeg4_version>=3 ? 17 : 16;
 557     /* the alt_bitstream reader could read over the end so we need to check it */
 558     if(left>=length && left<length+8)
 559     {
 560         skip_bits(&s->gb, 5); /* fps */
 561         s->bit_rate= get_bits(&s->gb, 11)*1024;
 562         if(s->msmpeg4_version>=3)
 563             s->flipflop_rounding= get_bits1(&s->gb);
 564         else
 565             s->flipflop_rounding= 0;
 566     }
 567     else if(left<length+8)
 568     {
 569         s->flipflop_rounding= 0;
 570         if(s->msmpeg4_version != 2)
 571             av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left);
 572     }
 573     else
 574     {
 575         av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n");
 576     }
 577
 578     return 0;
 579 }
 580
 581 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
 582 {
 583     int level, pred;
 584
 585     if(s->msmpeg4_version<=2){
 586         if (n < 4) {
 587             level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3);
 588         } else {
 589             level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3);
 590         }
 591         if (level < 0) {
 592             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 593             *dir_ptr = 0;
 594             return -1;
 595         }
 596         level-=256;
 597     }else{  //FIXME optimize use unified tables & index
 598         if (n < 4) {
 599             level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 600         } else {
 601             level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
 602         }
 603         if (level < 0){
 604             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");
 605             *dir_ptr = 0;
 606             return -1;
 607         }
 608
 609         if (level == DC_MAX) {
 610             level = get_bits(&s->gb, 8);
 611             if (get_bits1(&s->gb))
 612                 level = -level;
 613         } else if (level != 0) {
 614             if (get_bits1(&s->gb))
 615                 level = -level;
 616         }
 617     }
 618
 619     if(s->msmpeg4_version==1){
 620         int32_t *dc_val;
 621         pred = msmpeg4v1_pred_dc(s, n, &dc_val);
 622         level += pred;
 623
 624         /* update predictor */
 625         *dc_val= level;
 626     }else{
 627         int16_t *dc_val;
 628         pred   = ff_msmpeg4_pred_dc(s, n, &dc_val, dir_ptr);
 629         level += pred;
 630
 631         /* update predictor */
 632         if (n < 4) {
 633             *dc_val = level * s->y_dc_scale;
 634         } else {
 635             *dc_val = level * s->c_dc_scale;
 636         }
 637     }
 638
 639     return level;
 640 }
 641
 642 //#define ERROR_DETAILS
 643 int ff_msmpeg4_decode_block(MpegEncContext * s, int16_t * block,
 644                               int n, int coded, const uint8_t *scan_table)
 645 {
 646     int level, i, last, run, run_diff;
 647     int av_uninit(dc_pred_dir);
 648     RLTable *rl;
 649     RL_VLC_ELEM *rl_vlc;
 650     int qmul, qadd;
 651
 652     if (s->mb_intra) {
 653         qmul=1;
 654         qadd=0;
 655
 656         /* DC coef */
 657         level = msmpeg4_decode_dc(s, n, &dc_pred_dir);
 658
 659         if (level < 0){
 660             av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale);
 661             if(s->inter_intra_pred) level=0;
 662         }
 663         if (n < 4) {
 664             rl = &ff_rl_table[s->rl_table_index];
 665             if(level > 256*s->y_dc_scale){
 666                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale);
 667                 if(!s->inter_intra_pred) return -1;
 668             }
 669         } else {
 670             rl = &ff_rl_table[3 + s->rl_chroma_table_index];
 671             if(level > 256*s->c_dc_scale){
 672                 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale);
 673                 if(!s->inter_intra_pred) return -1;
 674             }
 675         }
 676         block[0] = level;
 677
 678         run_diff = s->msmpeg4_version >= 4;
 679         i = 0;
 680         if (!coded) {
 681             goto not_coded;
 682         }
 683         if (s->ac_pred) {
 684             if (dc_pred_dir == 0)
 685                 scan_table = s->intra_v_scantable.permutated; /* left */
 686             else
 687                 scan_table = s->intra_h_scantable.permutated; /* top */
 688         } else {
 689             scan_table = s->intra_scantable.permutated;
 690         }
 691         rl_vlc= rl->rl_vlc[0];
 692     } else {
 693         qmul = s->qscale << 1;
 694         qadd = (s->qscale - 1) | 1;
 695         i = -1;
 696         rl = &ff_rl_table[3 + s->rl_table_index];
 697
 698         if(s->msmpeg4_version==2)
 699             run_diff = 0;
 700         else
 701             run_diff = 1;
 702
 703         if (!coded) {
 704             s->block_last_index[n] = i;
 705             return 0;
 706         }
 707         if(!scan_table)
 708             scan_table = s->inter_scantable.permutated;
 709         rl_vlc= rl->rl_vlc[s->qscale];
 710     }
 711   {
 712     OPEN_READER(re, &s->gb);
 713     for(;;) {
 714         UPDATE_CACHE(re, &s->gb);
 715         GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0);
 716         if (level==0) {
 717             int cache;
 718             cache= GET_CACHE(re, &s->gb);
 719             /* escape */
 720             if (s->msmpeg4_version==1 || (cache&0x80000000)==0) {
 721                 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) {
 722                     /* third escape */
 723                     if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2);
 724                     UPDATE_CACHE(re, &s->gb);
 725                     if(s->msmpeg4_version<=3){
 726                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1);
 727                         run=   SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6);
 728                         level= SHOW_SBITS(re, &s->gb, 8);
 729                         SKIP_COUNTER(re, &s->gb, 1+6+8);
 730                     }else{
 731                         int sign;
 732                         last=  SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
 733                         if(!s->esc3_level_length){
 734                             int ll;
 735                             ff_dlog(s->avctx, "ESC-3 %X at %d %d\n",
 736                                     show_bits(&s->gb, 24), s->mb_x, s->mb_y);
 737                             if(s->qscale<8){
 738                                 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3);
 739                                 if(ll==0){
 740                                     ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1);
 741                                 }
 742                             }else{
 743                                 ll=2;
 744                                 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){
 745                                     ll++;
 746                                     SKIP_BITS(re, &s->gb, 1);
 747                                 }
 748                                 if(ll<8) SKIP_BITS(re, &s->gb, 1);
 749                             }
 750
 751                             s->esc3_level_length= ll;
 752                             s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2);
 753                             UPDATE_CACHE(re, &s->gb);
 754                         }
 755                         run=   SHOW_UBITS(re, &s->gb, s->esc3_run_length);
 756                         SKIP_BITS(re, &s->gb, s->esc3_run_length);
 757
 758                         sign=  SHOW_UBITS(re, &s->gb, 1);
 759                         SKIP_BITS(re, &s->gb, 1);
 760
 761                         level= SHOW_UBITS(re, &s->gb, s->esc3_level_length);
 762                         SKIP_BITS(re, &s->gb, s->esc3_level_length);
 763                         if(sign) level= -level;
 764                     }
 765
 766 #if 0 // waste of time / this will detect very few errors
 767                     {
 768                         const int abs_level= FFABS(level);
 769                         const int run1= run - rl->max_run[last][abs_level] - run_diff;
 770                         if(abs_level<=MAX_LEVEL && run<=MAX_RUN){
 771                             if(abs_level <= rl->max_level[last][run]){
 772                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n");
 773                                 return DECODING_AC_LOST;
 774                             }
 775                             if(abs_level <= rl->max_level[last][run]*2){
 776                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n");
 777                                 return DECODING_AC_LOST;
 778                             }
 779                             if(run1>=0 && abs_level <= rl->max_level[last][run1]){
 780                                 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n");
 781                                 return DECODING_AC_LOST;
 782                             }
 783                         }
 784                     }
 785 #endif
 786                     //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ;
 787                     if (level>0) level= level * qmul + qadd;
 788                     else         level= level * qmul - qadd;
 789 #if 0 // waste of time too :(
 790                     if(level>2048 || level<-2048){
 791                         av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n");
 792                         return DECODING_AC_LOST;
 793                     }
 794 #endif
 795                     i+= run + 1;
 796                     if(last) i+=192;
 797 #ifdef ERROR_DETAILS
 798                 if(run==66)
 799                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level);
 800                 else if((i>62 && i<192) || i>192+63)
 801                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level);
 802 #endif
 803                 } else {
 804                     /* second escape */
 805                     SKIP_BITS(re, &s->gb, 2);
 806                     GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 807                     i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing
 808                     level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 809                     LAST_SKIP_BITS(re, &s->gb, 1);
 810 #ifdef ERROR_DETAILS
 811                 if(run==66)
 812                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level);
 813                 else if((i>62 && i<192) || i>192+63)
 814                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level);
 815 #endif
 816                 }
 817             } else {
 818                 /* first escape */
 819                 SKIP_BITS(re, &s->gb, 1);
 820                 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1);
 821                 i+= run;
 822                 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing
 823                 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 824                 LAST_SKIP_BITS(re, &s->gb, 1);
 825 #ifdef ERROR_DETAILS
 826                 if(run==66)
 827                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level);
 828                 else if((i>62 && i<192) || i>192+63)
 829                     av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level);
 830 #endif
 831             }
 832         } else {
 833             i+= run;
 834             level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1);
 835             LAST_SKIP_BITS(re, &s->gb, 1);
 836 #ifdef ERROR_DETAILS
 837                 if(run==66)
 838                     av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level);
 839                 else if((i>62 && i<192) || i>192+63)
 840                     av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level);
 841 #endif
 842         }
 843         if (i > 62){
 844             i-= 192;
 845             if(i&(~63)){
 846                 const int left= get_bits_left(&s->gb);
 847                 if (((i + 192 == 64 && level / qmul == -1) ||
 848                      !(s->avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT))) &&
 849                     left >= 0) {
 850                     av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y);
 851                     i = 63;
 852                     break;
 853                 }else{
 854                     av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y);
 855                     return -1;
 856                 }
 857             }
 858
 859             block[scan_table[i]] = level;
 860             break;
 861         }
 862
 863         block[scan_table[i]] = level;
 864     }
 865     CLOSE_READER(re, &s->gb);
 866   }
 867  not_coded:
 868     if (s->mb_intra) {
 869         ff_mpeg4_pred_ac(s, block, n, dc_pred_dir);
 870         if (s->ac_pred) {
 871             i = 63; /* XXX: not optimal */
 872         }
 873     }
 874     if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize
 875     s->block_last_index[n] = i;
 876
 877     return 0;
 878 }
 879
 880 int ff_msmpeg4_decode_motion(MpegEncContext * s,
 881                                  int *mx_ptr, int *my_ptr)
 882 {
 883     MVTable *mv;
 884     int code, mx, my;
 885
 886     mv = &ff_mv_tables[s->mv_table_index];
 887
 888     code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2);
 889     if (code < 0){
 890         av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y);
 891         return -1;
 892     }
 893     if (code == mv->n) {
 894         mx = get_bits(&s->gb, 6);
 895         my = get_bits(&s->gb, 6);
 896     } else {
 897         mx = mv->table_mvx[code];
 898         my = mv->table_mvy[code];
 899     }
 900
 901     mx += *mx_ptr - 32;
 902     my += *my_ptr - 32;
 903     /* WARNING : they do not do exactly modulo encoding */
 904     if (mx <= -64)
 905         mx += 64;
 906     else if (mx >= 64)
 907         mx -= 64;
 908
 909     if (my <= -64)
 910         my += 64;
 911     else if (my >= 64)
 912         my -= 64;
 913     *mx_ptr = mx;
 914     *my_ptr = my;
 915     return 0;
 916 }
 917
 918 AVCodec ff_msmpeg4v1_decoder = {
 919     .name           = "msmpeg4v1",
 920     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
 921     .type           = AVMEDIA_TYPE_VIDEO,
 922     .id             = AV_CODEC_ID_MSMPEG4V1,
 923     .priv_data_size = sizeof(MpegEncContext),
 924     .init           = ff_msmpeg4_decode_init,
 925     .close          = ff_h263_decode_end,
 926     .decode         = ff_h263_decode_frame,
 927     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
 928     .max_lowres     = 3,
 929     .pix_fmts       = (const enum AVPixelFormat[]) {
 930         AV_PIX_FMT_YUV420P,
 931         AV_PIX_FMT_NONE
 932     },
 933 };
 934
 935 AVCodec ff_msmpeg4v2_decoder = {
 936     .name           = "msmpeg4v2",
 937     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
 938     .type           = AVMEDIA_TYPE_VIDEO,
 939     .id             = AV_CODEC_ID_MSMPEG4V2,
 940     .priv_data_size = sizeof(MpegEncContext),
 941     .init           = ff_msmpeg4_decode_init,
 942     .close          = ff_h263_decode_end,
 943     .decode         = ff_h263_decode_frame,
 944     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
 945     .max_lowres     = 3,
 946     .pix_fmts       = (const enum AVPixelFormat[]) {
 947         AV_PIX_FMT_YUV420P,
 948         AV_PIX_FMT_NONE
 949     },
 950 };
 951
 952 AVCodec ff_msmpeg4v3_decoder = {
 953     .name           = "msmpeg4",
 954     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
 955     .type           = AVMEDIA_TYPE_VIDEO,
 956     .id             = AV_CODEC_ID_MSMPEG4V3,
 957     .priv_data_size = sizeof(MpegEncContext),
 958     .init           = ff_msmpeg4_decode_init,
 959     .close          = ff_h263_decode_end,
 960     .decode         = ff_h263_decode_frame,
 961     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
 962     .max_lowres     = 3,
 963     .pix_fmts       = (const enum AVPixelFormat[]) {
 964         AV_PIX_FMT_YUV420P,
 965         AV_PIX_FMT_NONE
 966     },
 967 };
 968
 969 AVCodec ff_wmv1_decoder = {
 970     .name           = "wmv1",
 971     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
 972     .type           = AVMEDIA_TYPE_VIDEO,
 973     .id             = AV_CODEC_ID_WMV1,
 974     .priv_data_size = sizeof(MpegEncContext),
 975     .init           = ff_msmpeg4_decode_init,
 976     .close          = ff_h263_decode_end,
 977     .decode         = ff_h263_decode_frame,
 978     .capabilities   = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1,
 979     .max_lowres     = 3,
 980     .pix_fmts       = (const enum AVPixelFormat[]) {
 981         AV_PIX_FMT_YUV420P,
 982         AV_PIX_FMT_NONE
 983     },
 984 };