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

   1 /*
   2  * VC-1 and WMV3 decoder
   3  * Copyright (c) 2006 Konstantin Shishkov
   4  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  */
  23
  24 /**
  25  * @file vc1.c
  26  * VC-1 and WMV3 decoder
  27  *
  28  */
  29 #include "common.h"
  30 #include "dsputil.h"
  31 #include "avcodec.h"
  32 #include "mpegvideo.h"
  33 #include "vc1data.h"
  34 #include "vc1acdata.h"
  35
  36 #undef NDEBUG
  37 #include <assert.h>
  38
  39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
  40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
  41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
  42 #define MB_INTRA_VLC_BITS 9
  43 extern VLC ff_msmp4_mb_i_vlc;
  44 extern const uint16_t ff_msmp4_mb_i_table[64][2];
  45 #define DC_VLC_BITS 9
  46 #define AC_VLC_BITS 9
  47 static const uint16_t table_mb_intra[64][2];
  48
  49 /** Markers used if VC-1 AP frame data */
  50 //@{
  51 enum VC1Code{
  52     VC1_CODE_RES0       = 0x00000100,
  53     VC1_CODE_ENDOFSEQ   = 0x0000010A,
  54     VC1_CODE_SLICE,
  55     VC1_CODE_FIELD,
  56     VC1_CODE_FRAME,
  57     VC1_CODE_ENTRYPOINT,
  58     VC1_CODE_SEQHDR,
  59 };
  60 //@}
  61
  62 /** Available Profiles */
  63 //@{
  64 enum Profile {
  65     PROFILE_SIMPLE,
  66     PROFILE_MAIN,
  67     PROFILE_COMPLEX, ///< TODO: WMV9 specific
  68     PROFILE_ADVANCED
  69 };
  70 //@}
  71
  72 /** Sequence quantizer mode */
  73 //@{
  74 enum QuantMode {
  75     QUANT_FRAME_IMPLICIT,    ///< Implicitly specified at frame level
  76     QUANT_FRAME_EXPLICIT,    ///< Explicitly specified at frame level
  77     QUANT_NON_UNIFORM,       ///< Non-uniform quant used for all frames
  78     QUANT_UNIFORM            ///< Uniform quant used for all frames
  79 };
  80 //@}
  81
  82 /** Where quant can be changed */
  83 //@{
  84 enum DQProfile {
  85     DQPROFILE_FOUR_EDGES,
  86     DQPROFILE_DOUBLE_EDGES,
  87     DQPROFILE_SINGLE_EDGE,
  88     DQPROFILE_ALL_MBS
  89 };
  90 //@}
  91
  92 /** @name Where quant can be changed
  93  */
  94 //@{
  95 enum DQSingleEdge {
  96     DQSINGLE_BEDGE_LEFT,
  97     DQSINGLE_BEDGE_TOP,
  98     DQSINGLE_BEDGE_RIGHT,
  99     DQSINGLE_BEDGE_BOTTOM
 100 };
 101 //@}
 102
 103 /** Which pair of edges is quantized with ALTPQUANT */
 104 //@{
 105 enum DQDoubleEdge {
 106     DQDOUBLE_BEDGE_TOPLEFT,
 107     DQDOUBLE_BEDGE_TOPRIGHT,
 108     DQDOUBLE_BEDGE_BOTTOMRIGHT,
 109     DQDOUBLE_BEDGE_BOTTOMLEFT
 110 };
 111 //@}
 112
 113 /** MV modes for P frames */
 114 //@{
 115 enum MVModes {
 116     MV_PMODE_1MV_HPEL_BILIN,
 117     MV_PMODE_1MV,
 118     MV_PMODE_1MV_HPEL,
 119     MV_PMODE_MIXED_MV,
 120     MV_PMODE_INTENSITY_COMP
 121 };
 122 //@}
 123
 124 /** @name MV types for B frames */
 125 //@{
 126 enum BMVTypes {
 127     BMV_TYPE_BACKWARD,
 128     BMV_TYPE_FORWARD,
 129     BMV_TYPE_INTERPOLATED
 130 };
 131 //@}
 132
 133 /** @name Block types for P/B frames */
 134 //@{
 135 enum TransformTypes {
 136     TT_8X8,
 137     TT_8X4_BOTTOM,
 138     TT_8X4_TOP,
 139     TT_8X4, //Both halves
 140     TT_4X8_RIGHT,
 141     TT_4X8_LEFT,
 142     TT_4X8, //Both halves
 143     TT_4X4
 144 };
 145 //@}
 146
 147 /** Table for conversion between TTBLK and TTMB */
 148 static const int ttblk_to_tt[3][8] = {
 149   { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
 150   { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
 151   { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
 152 };
 153
 154 static const int ttfrm_to_tt[4] = { TT_8X8, TT_8X4, TT_4X8, TT_4X4 };
 155
 156 /** MV P mode - the 5th element is only used for mode 1 */
 157 static const uint8_t mv_pmode_table[2][5] = {
 158   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
 159   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
 160 };
 161 static const uint8_t mv_pmode_table2[2][4] = {
 162   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV },
 163   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN }
 164 };
 165
 166 /** One more frame type */
 167 #define BI_TYPE 7
 168
 169 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
 170   fps_dr[2] = { 1000, 1001 };
 171 static const uint8_t pquant_table[3][32] = {
 172   {  /* Implicit quantizer */
 173      0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
 174     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
 175   },
 176   {  /* Explicit quantizer, pquantizer uniform */
 177      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 178     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
 179   },
 180   {  /* Explicit quantizer, pquantizer non-uniform */
 181      0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
 182     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
 183   }
 184 };
 185
 186 /** @name VC-1 VLC tables and defines
 187  *  @todo TODO move this into the context
 188  */
 189 //@{
 190 #define VC1_BFRACTION_VLC_BITS 7
 191 static VLC vc1_bfraction_vlc;
 192 #define VC1_IMODE_VLC_BITS 4
 193 static VLC vc1_imode_vlc;
 194 #define VC1_NORM2_VLC_BITS 3
 195 static VLC vc1_norm2_vlc;
 196 #define VC1_NORM6_VLC_BITS 9
 197 static VLC vc1_norm6_vlc;
 198 /* Could be optimized, one table only needs 8 bits */
 199 #define VC1_TTMB_VLC_BITS 9 //12
 200 static VLC vc1_ttmb_vlc[3];
 201 #define VC1_MV_DIFF_VLC_BITS 9 //15
 202 static VLC vc1_mv_diff_vlc[4];
 203 #define VC1_CBPCY_P_VLC_BITS 9 //14
 204 static VLC vc1_cbpcy_p_vlc[4];
 205 #define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6
 206 static VLC vc1_4mv_block_pattern_vlc[4];
 207 #define VC1_TTBLK_VLC_BITS 5
 208 static VLC vc1_ttblk_vlc[3];
 209 #define VC1_SUBBLKPAT_VLC_BITS 6
 210 static VLC vc1_subblkpat_vlc[3];
 211
 212 static VLC vc1_ac_coeff_table[8];
 213 //@}
 214
 215 enum CodingSet {
 216     CS_HIGH_MOT_INTRA = 0,
 217     CS_HIGH_MOT_INTER,
 218     CS_LOW_MOT_INTRA,
 219     CS_LOW_MOT_INTER,
 220     CS_MID_RATE_INTRA,
 221     CS_MID_RATE_INTER,
 222     CS_HIGH_RATE_INTRA,
 223     CS_HIGH_RATE_INTER
 224 };
 225
 226 /** @name Overlap conditions for Advanced Profile */
 227 //@{
 228 enum COTypes {
 229     CONDOVER_NONE = 0,
 230     CONDOVER_ALL,
 231     CONDOVER_SELECT
 232 };
 233 //@}
 234
 235
 236 /** The VC1 Context
 237  * @fixme Change size wherever another size is more efficient
 238  * Many members are only used for Advanced Profile
 239  */
 240 typedef struct VC1Context{
 241     MpegEncContext s;
 242
 243     int bits;
 244
 245     /** Simple/Main Profile sequence header */
 246     //@{
 247     int res_sm;           ///< reserved, 2b
 248     int res_x8;           ///< reserved
 249     int multires;         ///< frame-level RESPIC syntax element present
 250     int res_fasttx;       ///< reserved, always 1
 251     int res_transtab;     ///< reserved, always 0
 252     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
 253                           ///< at frame level
 254     int res_rtm_flag;     ///< reserved, set to 1
 255     int reserved;         ///< reserved
 256     //@}
 257
 258     /** Advanced Profile */
 259     //@{
 260     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
 261     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
 262     int postprocflag;     ///< Per-frame processing suggestion flag present
 263     int broadcast;        ///< TFF/RFF present
 264     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
 265     int tfcntrflag;       ///< TFCNTR present
 266     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
 267     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
 268     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
 269     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
 270     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
 271     int hrd_param_flag;   ///< Presence of Hypothetical Reference
 272                           ///< Decoder parameters
 273     int psf;              ///< Progressive Segmented Frame
 274     //@}
 275
 276     /** Sequence header data for all Profiles
 277      * TODO: choose between ints, uint8_ts and monobit flags
 278      */
 279     //@{
 280     int profile;          ///< 2bits, Profile
 281     int frmrtq_postproc;  ///< 3bits,
 282     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
 283     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
 284     int extended_mv;      ///< Ext MV in P/B (not in Simple)
 285     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
 286     int vstransform;      ///< variable-size [48]x[48] transform type + info
 287     int overlap;          ///< overlapped transforms in use
 288     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
 289     int finterpflag;      ///< INTERPFRM present
 290     //@}
 291
 292     /** Frame decoding info for all profiles */
 293     //@{
 294     uint8_t mv_mode;      ///< MV coding monde
 295     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
 296     int k_x;              ///< Number of bits for MVs (depends on MV range)
 297     int k_y;              ///< Number of bits for MVs (depends on MV range)
 298     int range_x, range_y; ///< MV range
 299     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
 300     /** pquant parameters */
 301     //@{
 302     uint8_t dquantfrm;
 303     uint8_t dqprofile;
 304     uint8_t dqsbedge;
 305     uint8_t dqbilevel;
 306     //@}
 307     /** AC coding set indexes
 308      * @see 8.1.1.10, p(1)10
 309      */
 310     //@{
 311     int c_ac_table_index; ///< Chroma index from ACFRM element
 312     int y_ac_table_index; ///< Luma index from AC2FRM element
 313     //@}
 314     int ttfrm;            ///< Transform type info present at frame level
 315     uint8_t ttmbf;        ///< Transform type flag
 316     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
 317     int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
 318     int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
 319     int pqindex;          ///< raw pqindex used in coding set selection
 320     int a_avail, c_avail;
 321     uint8_t *mb_type_base, *mb_type[3];
 322
 323
 324     /** Luma compensation parameters */
 325     //@{
 326     uint8_t lumscale;
 327     uint8_t lumshift;
 328     //@}
 329     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
 330     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
 331     uint8_t respic;       ///< Frame-level flag for resized images
 332     int buffer_fullness;  ///< HRD info
 333     /** Ranges:
 334      * -# 0 -> [-64n 63.f] x [-32, 31.f]
 335      * -# 1 -> [-128, 127.f] x [-64, 63.f]
 336      * -# 2 -> [-512, 511.f] x [-128, 127.f]
 337      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
 338      */
 339     uint8_t mvrange;
 340     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
 341     VLC *cbpcy_vlc;               ///< CBPCY VLC table
 342     int tt_index;                 ///< Index for Transform Type tables
 343     uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
 344     uint8_t* direct_mb_plane;     ///< bitplane for "direct" MBs
 345     int mv_type_is_raw;           ///< mv type mb plane is not coded
 346     int dmb_is_raw;               ///< direct mb plane is raw
 347     int skip_is_raw;              ///< skip mb plane is not coded
 348     uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
 349     int use_ic;                   ///< use intensity compensation in B-frames
 350     int rnd;                      ///< rounding control
 351
 352     /** Frame decoding info for S/M profiles only */
 353     //@{
 354     uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
 355     uint8_t interpfrm;
 356     //@}
 357
 358     /** Frame decoding info for Advanced profile */
 359     //@{
 360     uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
 361     uint8_t numpanscanwin;
 362     uint8_t tfcntr;
 363     uint8_t rptfrm, tff, rff;
 364     uint16_t topleftx;
 365     uint16_t toplefty;
 366     uint16_t bottomrightx;
 367     uint16_t bottomrighty;
 368     uint8_t uvsamp;
 369     uint8_t postproc;
 370     int hrd_num_leaky_buckets;
 371     uint8_t bit_rate_exponent;
 372     uint8_t buffer_size_exponent;
 373     uint8_t* acpred_plane;       ///< AC prediction flags bitplane
 374     int acpred_is_raw;
 375     uint8_t* over_flags_plane;   ///< Overflags bitplane
 376     int overflg_is_raw;
 377     uint8_t condover;
 378     uint16_t *hrd_rate, *hrd_buffer;
 379     uint8_t *hrd_fullness;
 380     uint8_t range_mapy_flag;
 381     uint8_t range_mapuv_flag;
 382     uint8_t range_mapy;
 383     uint8_t range_mapuv;
 384     //@}
 385
 386     int p_frame_skipped;
 387     int bi_type;
 388 } VC1Context;
 389
 390 /**
 391  * Get unary code of limited length
 392  * @fixme FIXME Slow and ugly
 393  * @param gb GetBitContext
 394  * @param[in] stop The bitstop value (unary code of 1's or 0's)
 395  * @param[in] len Maximum length
 396  * @return Unary length/index
 397  */
 398 static int get_prefix(GetBitContext *gb, int stop, int len)
 399 {
 400 #if 1
 401     int i;
 402
 403     for(i = 0; i < len && get_bits1(gb) != stop; i++);
 404     return i;
 405 /*  int i = 0, tmp = !stop;
 406
 407   while (i != len && tmp != stop)
 408   {
 409     tmp = get_bits(gb, 1);
 410     i++;
 411   }
 412   if (i == len && tmp != stop) return len+1;
 413   return i;*/
 414 #else
 415   unsigned int buf;
 416   int log;
 417
 418   OPEN_READER(re, gb);
 419   UPDATE_CACHE(re, gb);
 420   buf=GET_CACHE(re, gb); //Still not sure
 421   if (stop) buf = ~buf;
 422
 423   log= av_log2(-buf); //FIXME: -?
 424   if (log < limit){
 425     LAST_SKIP_BITS(re, gb, log+1);
 426     CLOSE_READER(re, gb);
 427     return log;
 428   }
 429
 430   LAST_SKIP_BITS(re, gb, limit);
 431   CLOSE_READER(re, gb);
 432   return limit;
 433 #endif
 434 }
 435
 436 static inline int decode210(GetBitContext *gb){
 437     int n;
 438     n = get_bits1(gb);
 439     if (n == 1)
 440         return 0;
 441     else
 442         return 2 - get_bits1(gb);
 443 }
 444
 445 /**
 446  * Init VC-1 specific tables and VC1Context members
 447  * @param v The VC1Context to initialize
 448  * @return Status
 449  */
 450 static int vc1_init_common(VC1Context *v)
 451 {
 452     static int done = 0;
 453     int i = 0;
 454
 455     v->hrd_rate = v->hrd_buffer = NULL;
 456
 457     /* VLC tables */
 458     if(!done)
 459     {
 460         done = 1;
 461         init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
 462                  vc1_bfraction_bits, 1, 1,
 463                  vc1_bfraction_codes, 1, 1, 1);
 464         init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
 465                  vc1_norm2_bits, 1, 1,
 466                  vc1_norm2_codes, 1, 1, 1);
 467         init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
 468                  vc1_norm6_bits, 1, 1,
 469                  vc1_norm6_codes, 2, 2, 1);
 470         init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
 471                  vc1_imode_bits, 1, 1,
 472                  vc1_imode_codes, 1, 1, 1);
 473         for (i=0; i<3; i++)
 474         {
 475             init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
 476                      vc1_ttmb_bits[i], 1, 1,
 477                      vc1_ttmb_codes[i], 2, 2, 1);
 478             init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
 479                      vc1_ttblk_bits[i], 1, 1,
 480                      vc1_ttblk_codes[i], 1, 1, 1);
 481             init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
 482                      vc1_subblkpat_bits[i], 1, 1,
 483                      vc1_subblkpat_codes[i], 1, 1, 1);
 484         }
 485         for(i=0; i<4; i++)
 486         {
 487             init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
 488                      vc1_4mv_block_pattern_bits[i], 1, 1,
 489                      vc1_4mv_block_pattern_codes[i], 1, 1, 1);
 490             init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
 491                      vc1_cbpcy_p_bits[i], 1, 1,
 492                      vc1_cbpcy_p_codes[i], 2, 2, 1);
 493             init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
 494                      vc1_mv_diff_bits[i], 1, 1,
 495                      vc1_mv_diff_codes[i], 2, 2, 1);
 496         }
 497         for(i=0; i<8; i++)
 498             init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
 499                      &vc1_ac_tables[i][0][1], 8, 4,
 500                      &vc1_ac_tables[i][0][0], 8, 4, 1);
 501         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 502                  &ff_msmp4_mb_i_table[0][1], 4, 2,
 503                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
 504     }
 505
 506     /* Other defaults */
 507     v->pq = -1;
 508     v->mvrange = 0; /* 7.1.1.18, p80 */
 509
 510     return 0;
 511 }
 512
 513 /***********************************************************************/
 514 /**
 515  * @defgroup bitplane VC9 Bitplane decoding
 516  * @see 8.7, p56
 517  * @{
 518  */
 519
 520 /** @addtogroup bitplane
 521  * Imode types
 522  * @{
 523  */
 524 enum Imode {
 525     IMODE_RAW,
 526     IMODE_NORM2,
 527     IMODE_DIFF2,
 528     IMODE_NORM6,
 529     IMODE_DIFF6,
 530     IMODE_ROWSKIP,
 531     IMODE_COLSKIP
 532 };
 533 /** @} */ //imode defines
 534
 535 /** Decode rows by checking if they are skipped
 536  * @param plane Buffer to store decoded bits
 537  * @param[in] width Width of this buffer
 538  * @param[in] height Height of this buffer
 539  * @param[in] stride of this buffer
 540  */
 541 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 542     int x, y;
 543
 544     for (y=0; y<height; y++){
 545         if (!get_bits(gb, 1)) //rowskip
 546             memset(plane, 0, width);
 547         else
 548             for (x=0; x<width; x++)
 549                 plane[x] = get_bits(gb, 1);
 550         plane += stride;
 551     }
 552 }
 553
 554 /** Decode columns by checking if they are skipped
 555  * @param plane Buffer to store decoded bits
 556  * @param[in] width Width of this buffer
 557  * @param[in] height Height of this buffer
 558  * @param[in] stride of this buffer
 559  * @fixme FIXME: Optimize
 560  */
 561 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 562     int x, y;
 563
 564     for (x=0; x<width; x++){
 565         if (!get_bits(gb, 1)) //colskip
 566             for (y=0; y<height; y++)
 567                 plane[y*stride] = 0;
 568         else
 569             for (y=0; y<height; y++)
 570                 plane[y*stride] = get_bits(gb, 1);
 571         plane ++;
 572     }
 573 }
 574
 575 /** Decode a bitplane's bits
 576  * @param bp Bitplane where to store the decode bits
 577  * @param v VC-1 context for bit reading and logging
 578  * @return Status
 579  * @fixme FIXME: Optimize
 580  */
 581 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
 582 {
 583     GetBitContext *gb = &v->s.gb;
 584
 585     int imode, x, y, code, offset;
 586     uint8_t invert, *planep = data;
 587     int width, height, stride;
 588
 589     width = v->s.mb_width;
 590     height = v->s.mb_height;
 591     stride = v->s.mb_stride;
 592     invert = get_bits(gb, 1);
 593     imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
 594
 595     *raw_flag = 0;
 596     switch (imode)
 597     {
 598     case IMODE_RAW:
 599         //Data is actually read in the MB layer (same for all tests == "raw")
 600         *raw_flag = 1; //invert ignored
 601         return invert;
 602     case IMODE_DIFF2:
 603     case IMODE_NORM2:
 604         if ((height * width) & 1)
 605         {
 606             *planep++ = get_bits(gb, 1);
 607             offset = 1;
 608         }
 609         else offset = 0;
 610         // decode bitplane as one long line
 611         for (y = offset; y < height * width; y += 2) {
 612             code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
 613             *planep++ = code & 1;
 614             offset++;
 615             if(offset == width) {
 616                 offset = 0;
 617                 planep += stride - width;
 618             }
 619             *planep++ = code >> 1;
 620             offset++;
 621             if(offset == width) {
 622                 offset = 0;
 623                 planep += stride - width;
 624             }
 625         }
 626         break;
 627     case IMODE_DIFF6:
 628     case IMODE_NORM6:
 629         if(!(height % 3) && (width % 3)) { // use 2x3 decoding
 630             for(y = 0; y < height; y+= 3) {
 631                 for(x = width & 1; x < width; x += 2) {
 632                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 633                     if(code < 0){
 634                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 635                         return -1;
 636                     }
 637                     planep[x + 0] = (code >> 0) & 1;
 638                     planep[x + 1] = (code >> 1) & 1;
 639                     planep[x + 0 + stride] = (code >> 2) & 1;
 640                     planep[x + 1 + stride] = (code >> 3) & 1;
 641                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
 642                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
 643                 }
 644                 planep += stride * 3;
 645             }
 646             if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
 647         } else { // 3x2
 648             planep += (height & 1) * stride;
 649             for(y = height & 1; y < height; y += 2) {
 650                 for(x = width % 3; x < width; x += 3) {
 651                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 652                     if(code < 0){
 653                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 654                         return -1;
 655                     }
 656                     planep[x + 0] = (code >> 0) & 1;
 657                     planep[x + 1] = (code >> 1) & 1;
 658                     planep[x + 2] = (code >> 2) & 1;
 659                     planep[x + 0 + stride] = (code >> 3) & 1;
 660                     planep[x + 1 + stride] = (code >> 4) & 1;
 661                     planep[x + 2 + stride] = (code >> 5) & 1;
 662                 }
 663                 planep += stride * 2;
 664             }
 665             x = width % 3;
 666             if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
 667             if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
 668         }
 669         break;
 670     case IMODE_ROWSKIP:
 671         decode_rowskip(data, width, height, stride, &v->s.gb);
 672         break;
 673     case IMODE_COLSKIP:
 674         decode_colskip(data, width, height, stride, &v->s.gb);
 675         break;
 676     default: break;
 677     }
 678
 679     /* Applying diff operator */
 680     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
 681     {
 682         planep = data;
 683         planep[0] ^= invert;
 684         for (x=1; x<width; x++)
 685             planep[x] ^= planep[x-1];
 686         for (y=1; y<height; y++)
 687         {
 688             planep += stride;
 689             planep[0] ^= planep[-stride];
 690             for (x=1; x<width; x++)
 691             {
 692                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
 693                 else                                 planep[x] ^= planep[x-1];
 694             }
 695         }
 696     }
 697     else if (invert)
 698     {
 699         planep = data;
 700         for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
 701     }
 702     return (imode<<1) + invert;
 703 }
 704
 705 /** @} */ //Bitplane group
 706
 707 /***********************************************************************/
 708 /** VOP Dquant decoding
 709  * @param v VC-1 Context
 710  */
 711 static int vop_dquant_decoding(VC1Context *v)
 712 {
 713     GetBitContext *gb = &v->s.gb;
 714     int pqdiff;
 715
 716     //variable size
 717     if (v->dquant == 2)
 718     {
 719         pqdiff = get_bits(gb, 3);
 720         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
 721         else v->altpq = v->pq + pqdiff + 1;
 722     }
 723     else
 724     {
 725         v->dquantfrm = get_bits(gb, 1);
 726         if ( v->dquantfrm )
 727         {
 728             v->dqprofile = get_bits(gb, 2);
 729             switch (v->dqprofile)
 730             {
 731             case DQPROFILE_SINGLE_EDGE:
 732             case DQPROFILE_DOUBLE_EDGES:
 733                 v->dqsbedge = get_bits(gb, 2);
 734                 break;
 735             case DQPROFILE_ALL_MBS:
 736                 v->dqbilevel = get_bits(gb, 1);
 737             default: break; //Forbidden ?
 738             }
 739             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
 740             {
 741                 pqdiff = get_bits(gb, 3);
 742                 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
 743                 else v->altpq = v->pq + pqdiff + 1;
 744             }
 745         }
 746     }
 747     return 0;
 748 }
 749
 750 /** Put block onto picture
 751  */
 752 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
 753 {
 754     uint8_t *Y;
 755     int ys, us, vs;
 756     DSPContext *dsp = &v->s.dsp;
 757
 758     if(v->rangeredfrm) {
 759         int i, j, k;
 760         for(k = 0; k < 6; k++)
 761             for(j = 0; j < 8; j++)
 762                 for(i = 0; i < 8; i++)
 763                     block[k][i + j*8] = ((block[k][i + j*8] - 128) << 1) + 128;
 764
 765     }
 766     ys = v->s.current_picture.linesize[0];
 767     us = v->s.current_picture.linesize[1];
 768     vs = v->s.current_picture.linesize[2];
 769     Y = v->s.dest[0];
 770
 771     dsp->put_pixels_clamped(block[0], Y, ys);
 772     dsp->put_pixels_clamped(block[1], Y + 8, ys);
 773     Y += ys * 8;
 774     dsp->put_pixels_clamped(block[2], Y, ys);
 775     dsp->put_pixels_clamped(block[3], Y + 8, ys);
 776
 777     if(!(v->s.flags & CODEC_FLAG_GRAY)) {
 778         dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
 779         dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
 780     }
 781 }
 782
 783 /** Do motion compensation over 1 macroblock
 784  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
 785  */
 786 static void vc1_mc_1mv(VC1Context *v, int dir)
 787 {
 788     MpegEncContext *s = &v->s;
 789     DSPContext *dsp = &v->s.dsp;
 790     uint8_t *srcY, *srcU, *srcV;
 791     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
 792
 793     if(!v->s.last_picture.data[0])return;
 794
 795     mx = s->mv[dir][0][0];
 796     my = s->mv[dir][0][1];
 797
 798     // store motion vectors for further use in B frames
 799     if(s->pict_type == P_TYPE) {
 800         s->current_picture.motion_val[1][s->block_index[0]][0] = mx;
 801         s->current_picture.motion_val[1][s->block_index[0]][1] = my;
 802     }
 803     uvmx = (mx + ((mx & 3) == 3)) >> 1;
 804     uvmy = (my + ((my & 3) == 3)) >> 1;
 805     if(v->fastuvmc) {
 806         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
 807         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
 808     }
 809     if(!dir) {
 810         srcY = s->last_picture.data[0];
 811         srcU = s->last_picture.data[1];
 812         srcV = s->last_picture.data[2];
 813     } else {
 814         srcY = s->next_picture.data[0];
 815         srcU = s->next_picture.data[1];
 816         srcV = s->next_picture.data[2];
 817     }
 818
 819     src_x = s->mb_x * 16 + (mx >> 2);
 820     src_y = s->mb_y * 16 + (my >> 2);
 821     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
 822     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
 823
 824     src_x   = clip(  src_x, -16, s->mb_width  * 16);
 825     src_y   = clip(  src_y, -16, s->mb_height * 16);
 826     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
 827     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
 828
 829     srcY += src_y * s->linesize + src_x;
 830     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
 831     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
 832
 833     /* for grayscale we should not try to read from unknown area */
 834     if(s->flags & CODEC_FLAG_GRAY) {
 835         srcU = s->edge_emu_buffer + 18 * s->linesize;
 836         srcV = s->edge_emu_buffer + 18 * s->linesize;
 837     }
 838
 839     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
 840        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel*3
 841        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 16 - s->mspel*3){
 842         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
 843
 844         srcY -= s->mspel * (1 + s->linesize);
 845         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
 846                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
 847         srcY = s->edge_emu_buffer;
 848         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
 849                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 850         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
 851                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 852         srcU = uvbuf;
 853         srcV = uvbuf + 16;
 854         /* if we deal with range reduction we need to scale source blocks */
 855         if(v->rangeredfrm) {
 856             int i, j;
 857             uint8_t *src, *src2;
 858
 859             src = srcY;
 860             for(j = 0; j < 17 + s->mspel*2; j++) {
 861                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
 862                 src += s->linesize;
 863             }
 864             src = srcU; src2 = srcV;
 865             for(j = 0; j < 9; j++) {
 866                 for(i = 0; i < 9; i++) {
 867                     src[i] = ((src[i] - 128) >> 1) + 128;
 868                     src2[i] = ((src2[i] - 128) >> 1) + 128;
 869                 }
 870                 src += s->uvlinesize;
 871                 src2 += s->uvlinesize;
 872             }
 873         }
 874         /* if we deal with intensity compensation we need to scale source blocks */
 875         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 876             int i, j;
 877             uint8_t *src, *src2;
 878
 879             src = srcY;
 880             for(j = 0; j < 17 + s->mspel*2; j++) {
 881                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = v->luty[src[i]];
 882                 src += s->linesize;
 883             }
 884             src = srcU; src2 = srcV;
 885             for(j = 0; j < 9; j++) {
 886                 for(i = 0; i < 9; i++) {
 887                     src[i] = v->lutuv[src[i]];
 888                     src2[i] = v->lutuv[src2[i]];
 889                 }
 890                 src += s->uvlinesize;
 891                 src2 += s->uvlinesize;
 892             }
 893         }
 894         srcY += s->mspel * (1 + s->linesize);
 895     }
 896
 897     if(s->mspel) {
 898         dxy = ((my & 3) << 2) | (mx & 3);
 899         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0]    , srcY    , s->linesize, v->rnd);
 900         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8, srcY + 8, s->linesize, v->rnd);
 901         srcY += s->linesize * 8;
 902         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize    , srcY    , s->linesize, v->rnd);
 903         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + 8 * s->linesize + 8, srcY + 8, s->linesize, v->rnd);
 904     } else { // hpel mc - always used for luma
 905         dxy = (my & 2) | ((mx & 2) >> 1);
 906
 907         if(!v->rnd)
 908             dsp->put_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
 909         else
 910             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
 911     }
 912
 913     if(s->flags & CODEC_FLAG_GRAY) return;
 914     /* Chroma MC always uses qpel bilinear */
 915     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
 916     uvmx = (uvmx&3)<<1;
 917     uvmy = (uvmy&3)<<1;
 918     if(!v->rnd){
 919         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 920         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 921     }else{
 922         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
 923         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
 924     }
 925 }
 926
 927 /** Do motion compensation for 4-MV macroblock - luminance block
 928  */
 929 static void vc1_mc_4mv_luma(VC1Context *v, int n)
 930 {
 931     MpegEncContext *s = &v->s;
 932     DSPContext *dsp = &v->s.dsp;
 933     uint8_t *srcY;
 934     int dxy, mx, my, src_x, src_y;
 935     int off;
 936
 937     if(!v->s.last_picture.data[0])return;
 938     mx = s->mv[0][n][0];
 939     my = s->mv[0][n][1];
 940     srcY = s->last_picture.data[0];
 941
 942     off = s->linesize * 4 * (n&2) + (n&1) * 8;
 943
 944     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
 945     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
 946
 947     src_x   = clip(  src_x, -16, s->mb_width  * 16);
 948     src_y   = clip(  src_y, -16, s->mb_height * 16);
 949
 950     srcY += src_y * s->linesize + src_x;
 951
 952     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
 953        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 8 - s->mspel*2
 954        || (unsigned)(src_y - s->mspel) > s->v_edge_pos - (my&3) - 8 - s->mspel*2){
 955         srcY -= s->mspel * (1 + s->linesize);
 956         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 9+s->mspel*2, 9+s->mspel*2,
 957                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
 958         srcY = s->edge_emu_buffer;
 959         /* if we deal with range reduction we need to scale source blocks */
 960         if(v->rangeredfrm) {
 961             int i, j;
 962             uint8_t *src;
 963
 964             src = srcY;
 965             for(j = 0; j < 9 + s->mspel*2; j++) {
 966                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
 967                 src += s->linesize;
 968             }
 969         }
 970         /* if we deal with intensity compensation we need to scale source blocks */
 971         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 972             int i, j;
 973             uint8_t *src;
 974
 975             src = srcY;
 976             for(j = 0; j < 9 + s->mspel*2; j++) {
 977                 for(i = 0; i < 9 + s->mspel*2; i++) src[i] = v->luty[src[i]];
 978                 src += s->linesize;
 979             }
 980         }
 981         srcY += s->mspel * (1 + s->linesize);
 982     }
 983
 984     if(s->mspel) {
 985         dxy = ((my & 3) << 2) | (mx & 3);
 986         dsp->put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize, v->rnd);
 987     } else { // hpel mc - always used for luma
 988         dxy = (my & 2) | ((mx & 2) >> 1);
 989         if(!v->rnd)
 990             dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 991         else
 992             dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
 993     }
 994 }
 995
 996 static inline int median4(int a, int b, int c, int d)
 997 {
 998     if(a < b) {
 999         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1000         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1001     } else {
1002         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1003         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1004     }
1005 }
1006
1007
1008 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1009  */
1010 static void vc1_mc_4mv_chroma(VC1Context *v)
1011 {
1012     MpegEncContext *s = &v->s;
1013     DSPContext *dsp = &v->s.dsp;
1014     uint8_t *srcU, *srcV;
1015     int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1016     int i, idx, tx = 0, ty = 0;
1017     int mvx[4], mvy[4], intra[4];
1018     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1019
1020     if(!v->s.last_picture.data[0])return;
1021     if(s->flags & CODEC_FLAG_GRAY) return;
1022
1023     for(i = 0; i < 4; i++) {
1024         mvx[i] = s->mv[0][i][0];
1025         mvy[i] = s->mv[0][i][1];
1026         intra[i] = v->mb_type[0][s->block_index[i]];
1027     }
1028
1029     /* calculate chroma MV vector from four luma MVs */
1030     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1031     if(!idx) { // all blocks are inter
1032         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1033         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1034     } else if(count[idx] == 1) { // 3 inter blocks
1035         switch(idx) {
1036         case 0x1:
1037             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1038             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1039             break;
1040         case 0x2:
1041             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1042             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1043             break;
1044         case 0x4:
1045             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1046             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1047             break;
1048         case 0x8:
1049             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1050             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1051             break;
1052         }
1053     } else if(count[idx] == 2) {
1054         int t1 = 0, t2 = 0;
1055         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1056         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1057         tx = (mvx[t1] + mvx[t2]) / 2;
1058         ty = (mvy[t1] + mvy[t2]) / 2;
1059     } else
1060         return; //no need to do MC for inter blocks
1061
1062     s->current_picture.motion_val[1][s->block_index[0]][0] = tx;
1063     s->current_picture.motion_val[1][s->block_index[0]][1] = ty;
1064     uvmx = (tx + ((tx&3) == 3)) >> 1;
1065     uvmy = (ty + ((ty&3) == 3)) >> 1;
1066     if(v->fastuvmc) {
1067         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1068         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1069     }
1070
1071     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1072     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1073
1074     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
1075     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
1076     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1077     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1078     if(v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1079        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
1080        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - 9){
1081         ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1082                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1083         ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1084                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1085         srcU = s->edge_emu_buffer;
1086         srcV = s->edge_emu_buffer + 16;
1087
1088         /* if we deal with range reduction we need to scale source blocks */
1089         if(v->rangeredfrm) {
1090             int i, j;
1091             uint8_t *src, *src2;
1092
1093             src = srcU; src2 = srcV;
1094             for(j = 0; j < 9; j++) {
1095                 for(i = 0; i < 9; i++) {
1096                     src[i] = ((src[i] - 128) >> 1) + 128;
1097                     src2[i] = ((src2[i] - 128) >> 1) + 128;
1098                 }
1099                 src += s->uvlinesize;
1100                 src2 += s->uvlinesize;
1101             }
1102         }
1103         /* if we deal with intensity compensation we need to scale source blocks */
1104         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1105             int i, j;
1106             uint8_t *src, *src2;
1107
1108             src = srcU; src2 = srcV;
1109             for(j = 0; j < 9; j++) {
1110                 for(i = 0; i < 9; i++) {
1111                     src[i] = v->lutuv[src[i]];
1112                     src2[i] = v->lutuv[src2[i]];
1113                 }
1114                 src += s->uvlinesize;
1115                 src2 += s->uvlinesize;
1116             }
1117         }
1118     }
1119
1120     /* Chroma MC always uses qpel bilinear */
1121     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
1122     uvmx = (uvmx&3)<<1;
1123     uvmy = (uvmy&3)<<1;
1124     if(!v->rnd){
1125         dsp->put_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1126         dsp->put_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1127     }else{
1128         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
1129         dsp->put_no_rnd_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
1130     }
1131 }
1132
1133 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb);
1134
1135 /**
1136  * Decode Simple/Main Profiles sequence header
1137  * @see Figure 7-8, p16-17
1138  * @param avctx Codec context
1139  * @param gb GetBit context initialized from Codec context extra_data
1140  * @return Status
1141  */
1142 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1143 {
1144     VC1Context *v = avctx->priv_data;
1145
1146     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
1147     v->profile = get_bits(gb, 2);
1148     if (v->profile == 2)
1149     {
1150         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1151         return -1;
1152     }
1153
1154     if (v->profile == PROFILE_ADVANCED)
1155     {
1156         return decode_sequence_header_adv(v, gb);
1157     }
1158     else
1159     {
1160         v->res_sm = get_bits(gb, 2); //reserved
1161         if (v->res_sm)
1162         {
1163             av_log(avctx, AV_LOG_ERROR,
1164                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1165             return -1;
1166         }
1167     }
1168
1169     // (fps-2)/4 (->30)
1170     v->frmrtq_postproc = get_bits(gb, 3); //common
1171     // (bitrate-32kbps)/64kbps
1172     v->bitrtq_postproc = get_bits(gb, 5); //common
1173     v->s.loop_filter = get_bits(gb, 1); //common
1174     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1175     {
1176         av_log(avctx, AV_LOG_ERROR,
1177                "LOOPFILTER shell not be enabled in simple profile\n");
1178     }
1179
1180     v->res_x8 = get_bits(gb, 1); //reserved
1181     if (v->res_x8)
1182     {
1183         av_log(avctx, AV_LOG_ERROR,
1184                "1 for reserved RES_X8 is forbidden\n");
1185         //return -1;
1186     }
1187     v->multires = get_bits(gb, 1);
1188     v->res_fasttx = get_bits(gb, 1);
1189     if (!v->res_fasttx)
1190     {
1191         av_log(avctx, AV_LOG_ERROR,
1192                "0 for reserved RES_FASTTX is forbidden\n");
1193         //return -1;
1194     }
1195
1196     v->fastuvmc =  get_bits(gb, 1); //common
1197     if (!v->profile && !v->fastuvmc)
1198     {
1199         av_log(avctx, AV_LOG_ERROR,
1200                "FASTUVMC unavailable in Simple Profile\n");
1201         return -1;
1202     }
1203     v->extended_mv =  get_bits(gb, 1); //common
1204     if (!v->profile && v->extended_mv)
1205     {
1206         av_log(avctx, AV_LOG_ERROR,
1207                "Extended MVs unavailable in Simple Profile\n");
1208         return -1;
1209     }
1210     v->dquant =  get_bits(gb, 2); //common
1211     v->vstransform =  get_bits(gb, 1); //common
1212
1213     v->res_transtab = get_bits(gb, 1);
1214     if (v->res_transtab)
1215     {
1216         av_log(avctx, AV_LOG_ERROR,
1217                "1 for reserved RES_TRANSTAB is forbidden\n");
1218         return -1;
1219     }
1220
1221     v->overlap = get_bits(gb, 1); //common
1222
1223     v->s.resync_marker = get_bits(gb, 1);
1224     v->rangered = get_bits(gb, 1);
1225     if (v->rangered && v->profile == PROFILE_SIMPLE)
1226     {
1227         av_log(avctx, AV_LOG_INFO,
1228                "RANGERED should be set to 0 in simple profile\n");
1229     }
1230
1231     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1232     v->quantizer_mode = get_bits(gb, 2); //common
1233
1234     v->finterpflag = get_bits(gb, 1); //common
1235     v->res_rtm_flag = get_bits(gb, 1); //reserved
1236     if (!v->res_rtm_flag)
1237     {
1238 //            av_log(avctx, AV_LOG_ERROR,
1239 //                   "0 for reserved RES_RTM_FLAG is forbidden\n");
1240         av_log(avctx, AV_LOG_ERROR,
1241                "Old WMV3 version detected, only I-frames will be decoded\n");
1242         //return -1;
1243     }
1244     av_log(avctx, AV_LOG_DEBUG,
1245                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1246                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1247                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1248                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1249                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1250                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1251                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1252                v->dquant, v->quantizer_mode, avctx->max_b_frames
1253                );
1254     return 0;
1255 }
1256
1257 static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)
1258 {
1259     v->res_rtm_flag = 1;
1260     v->level = get_bits(gb, 3);
1261     if(v->level >= 5)
1262     {
1263         av_log(v->s.avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1264     }
1265     v->chromaformat = get_bits(gb, 2);
1266     if (v->chromaformat != 1)
1267     {
1268         av_log(v->s.avctx, AV_LOG_ERROR,
1269                "Only 4:2:0 chroma format supported\n");
1270         return -1;
1271     }
1272
1273     // (fps-2)/4 (->30)
1274     v->frmrtq_postproc = get_bits(gb, 3); //common
1275     // (bitrate-32kbps)/64kbps
1276     v->bitrtq_postproc = get_bits(gb, 5); //common
1277     v->postprocflag = get_bits(gb, 1); //common
1278
1279     v->s.avctx->coded_width = (get_bits(gb, 12) + 1) << 1;
1280     v->s.avctx->coded_height = (get_bits(gb, 12) + 1) << 1;
1281     v->broadcast = get_bits1(gb);
1282     v->interlace = get_bits1(gb);
1283     if(v->interlace){
1284         av_log(v->s.avctx, AV_LOG_ERROR, "Interlaced mode not supported (yet)\n");
1285         return -1;
1286     }
1287     v->tfcntrflag = get_bits1(gb);
1288     v->finterpflag = get_bits1(gb);
1289     get_bits1(gb); // reserved
1290
1291     av_log(v->s.avctx, AV_LOG_DEBUG,
1292                "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1293                "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"
1294                "TFCTRflag=%i, FINTERPflag=%i\n",
1295                v->level, v->frmrtq_postproc, v->bitrtq_postproc,
1296                v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,
1297                v->tfcntrflag, v->finterpflag
1298                );
1299
1300     v->psf = get_bits1(gb);
1301     if(v->psf) { //PsF, 6.1.13
1302         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");
1303         return -1;
1304     }
1305     if(get_bits1(gb)) { //Display Info - decoding is not affected by it
1306         int w, h, ar = 0;
1307         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
1308         v->s.avctx->width  = v->s.width  = w = get_bits(gb, 14) + 1;
1309         v->s.avctx->height = v->s.height = h = get_bits(gb, 14) + 1;
1310         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
1311         if(get_bits1(gb))
1312             ar = get_bits(gb, 4);
1313         if(ar && ar < 14){
1314             v->s.avctx->sample_aspect_ratio = vc1_pixel_aspect[ar];
1315         }else if(ar == 15){
1316             w = get_bits(gb, 8);
1317             h = get_bits(gb, 8);
1318             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};
1319         }
1320
1321         if(get_bits1(gb)){ //framerate stuff
1322             if(get_bits1(gb)) {
1323                 get_bits(gb, 16);
1324             } else {
1325                 get_bits(gb, 8);
1326                 get_bits(gb, 4);
1327             }
1328         }
1329
1330         if(get_bits1(gb)){
1331             v->color_prim = get_bits(gb, 8);
1332             v->transfer_char = get_bits(gb, 8);
1333             v->matrix_coef = get_bits(gb, 8);
1334         }
1335     }
1336
1337     v->hrd_param_flag = get_bits1(gb);
1338     if(v->hrd_param_flag) {
1339         int i;
1340         v->hrd_num_leaky_buckets = get_bits(gb, 5);
1341         get_bits(gb, 4); //bitrate exponent
1342         get_bits(gb, 4); //buffer size exponent
1343         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1344             get_bits(gb, 16); //hrd_rate[n]
1345             get_bits(gb, 16); //hrd_buffer[n]
1346         }
1347     }
1348     return 0;
1349 }
1350
1351 static int decode_entry_point(AVCodecContext *avctx, GetBitContext *gb)
1352 {
1353     VC1Context *v = avctx->priv_data;
1354     int i, blink, refdist;
1355
1356     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));
1357     blink = get_bits1(gb); // broken link
1358     avctx->max_b_frames = 1 - get_bits1(gb); // 'closed entry' also signalize possible B-frames
1359     v->panscanflag = get_bits1(gb);
1360     refdist = get_bits1(gb); // refdist flag
1361     v->s.loop_filter = get_bits1(gb);
1362     v->fastuvmc = get_bits1(gb);
1363     v->extended_mv = get_bits1(gb);
1364     v->dquant = get_bits(gb, 2);
1365     v->vstransform = get_bits1(gb);
1366     v->overlap = get_bits1(gb);
1367     v->quantizer_mode = get_bits(gb, 2);
1368
1369     if(v->hrd_param_flag){
1370         for(i = 0; i < v->hrd_num_leaky_buckets; i++) {
1371             get_bits(gb, 8); //hrd_full[n]
1372         }
1373     }
1374
1375     if(get_bits1(gb)){
1376         avctx->coded_width = (get_bits(gb, 12)+1)<<1;
1377         avctx->coded_height = (get_bits(gb, 12)+1)<<1;
1378     }
1379     if(v->extended_mv)
1380         v->extended_dmv = get_bits1(gb);
1381     if(get_bits1(gb)) {
1382         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");
1383         skip_bits(gb, 3); // Y range, ignored for now
1384     }
1385     if(get_bits1(gb)) {
1386         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");
1387         skip_bits(gb, 3); // UV range, ignored for now
1388     }
1389
1390     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"
1391         "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"
1392         "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"
1393         "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",
1394         blink, 1 - avctx->max_b_frames, v->panscanflag, refdist, v->s.loop_filter,
1395         v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);
1396
1397     return 0;
1398 }
1399
1400 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1401 {
1402     int pqindex, lowquant, status;
1403
1404     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1405     skip_bits(gb, 2); //framecnt unused
1406     v->rangeredfrm = 0;
1407     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1408     v->s.pict_type = get_bits(gb, 1);
1409     if (v->s.avctx->max_b_frames) {
1410         if (!v->s.pict_type) {
1411             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1412             else v->s.pict_type = B_TYPE;
1413         } else v->s.pict_type = P_TYPE;
1414     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1415
1416     v->bi_type = 0;
1417     if(v->s.pict_type == B_TYPE) {
1418         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1419         v->bfraction = vc1_bfraction_lut[v->bfraction];
1420         if(v->bfraction == 0) {
1421             v->s.pict_type = BI_TYPE;
1422         }
1423     }
1424     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1425         get_bits(gb, 7); // skip buffer fullness
1426
1427     /* calculate RND */
1428     if(v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1429         v->rnd = 1;
1430     if(v->s.pict_type == P_TYPE)
1431         v->rnd ^= 1;
1432
1433     /* Quantizer stuff */
1434     pqindex = get_bits(gb, 5);
1435     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1436         v->pq = pquant_table[0][pqindex];
1437     else
1438         v->pq = pquant_table[1][pqindex];
1439
1440     v->pquantizer = 1;
1441     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1442         v->pquantizer = pqindex < 9;
1443     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1444         v->pquantizer = 0;
1445     v->pqindex = pqindex;
1446     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1447     else v->halfpq = 0;
1448     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1449         v->pquantizer = get_bits(gb, 1);
1450     v->dquantfrm = 0;
1451     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1452     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1453     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1454     v->range_x = 1 << (v->k_x - 1);
1455     v->range_y = 1 << (v->k_y - 1);
1456     if (v->profile == PROFILE_ADVANCED)
1457     {
1458         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1459     }
1460     else
1461         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1462
1463 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1464 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1465
1466     if(v->s.pict_type == I_TYPE || v->s.pict_type == P_TYPE) v->use_ic = 0;
1467
1468     switch(v->s.pict_type) {
1469     case P_TYPE:
1470         if (v->pq < 5) v->tt_index = 0;
1471         else if(v->pq < 13) v->tt_index = 1;
1472         else v->tt_index = 2;
1473
1474         lowquant = (v->pq > 12) ? 0 : 1;
1475         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1476         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1477         {
1478             int scale, shift, i;
1479             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1480             v->lumscale = get_bits(gb, 6);
1481             v->lumshift = get_bits(gb, 6);
1482             v->use_ic = 1;
1483             /* fill lookup tables for intensity compensation */
1484             if(!v->lumscale) {
1485                 scale = -64;
1486                 shift = (255 - v->lumshift * 2) << 6;
1487                 if(v->lumshift > 31)
1488                     shift += 128 << 6;
1489             } else {
1490                 scale = v->lumscale + 32;
1491                 if(v->lumshift > 31)
1492                     shift = (v->lumshift - 64) << 6;
1493                 else
1494                     shift = v->lumshift << 6;
1495             }
1496             for(i = 0; i < 256; i++) {
1497                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1498                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1499             }
1500         }
1501         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1502             v->s.quarter_sample = 0;
1503         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1504             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1505                 v->s.quarter_sample = 0;
1506             else
1507                 v->s.quarter_sample = 1;
1508         } else
1509             v->s.quarter_sample = 1;
1510         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1511
1512         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1513                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1514                 || v->mv_mode == MV_PMODE_MIXED_MV)
1515         {
1516             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1517             if (status < 0) return -1;
1518             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1519                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1520         } else {
1521             v->mv_type_is_raw = 0;
1522             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1523         }
1524         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1525         if (status < 0) return -1;
1526         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1527                "Imode: %i, Invert: %i\n", status>>1, status&1);
1528
1529         /* Hopefully this is correct for P frames */
1530         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1531         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1532
1533         if (v->dquant)
1534         {
1535             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1536             vop_dquant_decoding(v);
1537         }
1538
1539         v->ttfrm = 0; //FIXME Is that so ?
1540         if (v->vstransform)
1541         {
1542             v->ttmbf = get_bits(gb, 1);
1543             if (v->ttmbf)
1544             {
1545                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1546             }
1547         } else {
1548             v->ttmbf = 1;
1549             v->ttfrm = TT_8X8;
1550         }
1551         break;
1552     case B_TYPE:
1553         if (v->pq < 5) v->tt_index = 0;
1554         else if(v->pq < 13) v->tt_index = 1;
1555         else v->tt_index = 2;
1556
1557         lowquant = (v->pq > 12) ? 0 : 1;
1558         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1559         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1560         v->s.mspel = v->s.quarter_sample;
1561
1562         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1563         if (status < 0) return -1;
1564         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1565                "Imode: %i, Invert: %i\n", status>>1, status&1);
1566         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1567         if (status < 0) return -1;
1568         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1569                "Imode: %i, Invert: %i\n", status>>1, status&1);
1570
1571         v->s.mv_table_index = get_bits(gb, 2);
1572         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1573
1574         if (v->dquant)
1575         {
1576             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1577             vop_dquant_decoding(v);
1578         }
1579
1580         v->ttfrm = 0;
1581         if (v->vstransform)
1582         {
1583             v->ttmbf = get_bits(gb, 1);
1584             if (v->ttmbf)
1585             {
1586                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1587             }
1588         } else {
1589             v->ttmbf = 1;
1590             v->ttfrm = TT_8X8;
1591         }
1592         break;
1593     }
1594
1595     /* AC Syntax */
1596     v->c_ac_table_index = decode012(gb);
1597     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1598     {
1599         v->y_ac_table_index = decode012(gb);
1600     }
1601     /* DC Syntax */
1602     v->s.dc_table_index = get_bits(gb, 1);
1603
1604     if(v->s.pict_type == BI_TYPE) {
1605         v->s.pict_type = B_TYPE;
1606         v->bi_type = 1;
1607     }
1608     return 0;
1609 }
1610
1611 static int vc1_parse_frame_header_adv(VC1Context *v, GetBitContext* gb)
1612 {
1613     int fcm;
1614     int pqindex, lowquant;
1615     int status;
1616
1617     v->p_frame_skipped = 0;
1618
1619     if(v->interlace)
1620         fcm = decode012(gb);
1621     switch(get_prefix(gb, 0, 4)) {
1622     case 0:
1623         v->s.pict_type = P_TYPE;
1624         break;
1625     case 1:
1626         v->s.pict_type = B_TYPE;
1627         break;
1628     case 2:
1629         v->s.pict_type = I_TYPE;
1630         break;
1631     case 3:
1632         v->s.pict_type = BI_TYPE;
1633         break;
1634     case 4:
1635         v->s.pict_type = P_TYPE; // skipped pic
1636         v->p_frame_skipped = 1;
1637         return 0;
1638     }
1639     if(v->tfcntrflag)
1640         get_bits(gb, 8);
1641     if(v->broadcast) {
1642         if(!v->interlace || v->panscanflag) {
1643             get_bits(gb, 2);
1644         } else {
1645             get_bits1(gb);
1646             get_bits1(gb);
1647         }
1648     }
1649     if(v->panscanflag) {
1650         //...
1651     }
1652     v->rnd = get_bits1(gb);
1653     if(v->interlace)
1654         v->uvsamp = get_bits1(gb);
1655     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1656     if(v->s.pict_type == B_TYPE) {
1657         v->bfraction = get_vlc2(gb, vc1_bfraction_vlc.table, VC1_BFRACTION_VLC_BITS, 1);
1658         v->bfraction = vc1_bfraction_lut[v->bfraction];
1659         if(v->bfraction == 0) {
1660             v->s.pict_type = BI_TYPE; /* XXX: should not happen here */
1661         }
1662     }
1663     pqindex = get_bits(gb, 5);
1664     v->pqindex = pqindex;
1665     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1666         v->pq = pquant_table[0][pqindex];
1667     else
1668         v->pq = pquant_table[1][pqindex];
1669
1670     v->pquantizer = 1;
1671     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1672         v->pquantizer = pqindex < 9;
1673     if (v->quantizer_mode == QUANT_NON_UNIFORM)
1674         v->pquantizer = 0;
1675     v->pqindex = pqindex;
1676     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1677     else v->halfpq = 0;
1678     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1679         v->pquantizer = get_bits(gb, 1);
1680
1681     switch(v->s.pict_type) {
1682     case I_TYPE:
1683     case BI_TYPE:
1684         status = bitplane_decoding(v->acpred_plane, &v->acpred_is_raw, v);
1685         if (status < 0) return -1;
1686         av_log(v->s.avctx, AV_LOG_DEBUG, "ACPRED plane encoding: "
1687                 "Imode: %i, Invert: %i\n", status>>1, status&1);
1688         v->condover = CONDOVER_NONE;
1689         if(v->overlap && v->pq <= 8) {
1690             v->condover = decode012(gb);
1691             if(v->condover == CONDOVER_SELECT) {
1692                 status = bitplane_decoding(v->over_flags_plane, &v->overflg_is_raw, v);
1693                 if (status < 0) return -1;
1694                 av_log(v->s.avctx, AV_LOG_DEBUG, "CONDOVER plane encoding: "
1695                         "Imode: %i, Invert: %i\n", status>>1, status&1);
1696             }
1697         }
1698         break;
1699     case P_TYPE:
1700         if(v->postprocflag)
1701             v->postproc = get_bits1(gb);
1702         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1703         else v->mvrange = 0;
1704         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1705         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1706         v->range_x = 1 << (v->k_x - 1);
1707         v->range_y = 1 << (v->k_y - 1);
1708
1709         if (v->pq < 5) v->tt_index = 0;
1710         else if(v->pq < 13) v->tt_index = 1;
1711         else v->tt_index = 2;
1712
1713         lowquant = (v->pq > 12) ? 0 : 1;
1714         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1715         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1716         {
1717             int scale, shift, i;
1718             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1719             v->lumscale = get_bits(gb, 6);
1720             v->lumshift = get_bits(gb, 6);
1721             /* fill lookup tables for intensity compensation */
1722             if(!v->lumscale) {
1723                 scale = -64;
1724                 shift = (255 - v->lumshift * 2) << 6;
1725                 if(v->lumshift > 31)
1726                     shift += 128 << 6;
1727             } else {
1728                 scale = v->lumscale + 32;
1729                 if(v->lumshift > 31)
1730                     shift = (v->lumshift - 64) << 6;
1731                 else
1732                     shift = v->lumshift << 6;
1733             }
1734             for(i = 0; i < 256; i++) {
1735                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1736                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1737             }
1738         }
1739         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1740             v->s.quarter_sample = 0;
1741         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1742             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1743                 v->s.quarter_sample = 0;
1744             else
1745                 v->s.quarter_sample = 1;
1746         } else
1747             v->s.quarter_sample = 1;
1748         v->s.mspel = !(v->mv_mode == MV_PMODE_1MV_HPEL_BILIN || (v->mv_mode == MV_PMODE_INTENSITY_COMP && v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN));
1749
1750         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1751                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1752                 || v->mv_mode == MV_PMODE_MIXED_MV)
1753         {
1754             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1755             if (status < 0) return -1;
1756             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1757                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1758         } else {
1759             v->mv_type_is_raw = 0;
1760             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1761         }
1762         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1763         if (status < 0) return -1;
1764         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1765                "Imode: %i, Invert: %i\n", status>>1, status&1);
1766
1767         /* Hopefully this is correct for P frames */
1768         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1769         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1770         if (v->dquant)
1771         {
1772             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1773             vop_dquant_decoding(v);
1774         }
1775
1776         v->ttfrm = 0; //FIXME Is that so ?
1777         if (v->vstransform)
1778         {
1779             v->ttmbf = get_bits(gb, 1);
1780             if (v->ttmbf)
1781             {
1782                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1783             }
1784         } else {
1785             v->ttmbf = 1;
1786             v->ttfrm = TT_8X8;
1787         }
1788         break;
1789     case B_TYPE:
1790         if(v->postprocflag)
1791             v->postproc = get_bits1(gb);
1792         if (v->extended_mv) v->mvrange = get_prefix(gb, 0, 3);
1793         else v->mvrange = 0;
1794         v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1795         v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1796         v->range_x = 1 << (v->k_x - 1);
1797         v->range_y = 1 << (v->k_y - 1);
1798
1799         if (v->pq < 5) v->tt_index = 0;
1800         else if(v->pq < 13) v->tt_index = 1;
1801         else v->tt_index = 2;
1802
1803         lowquant = (v->pq > 12) ? 0 : 1;
1804         v->mv_mode = get_bits1(gb) ? MV_PMODE_1MV : MV_PMODE_1MV_HPEL_BILIN;
1805         v->s.quarter_sample = (v->mv_mode == MV_PMODE_1MV);
1806         v->s.mspel = v->s.quarter_sample;
1807
1808         status = bitplane_decoding(v->direct_mb_plane, &v->dmb_is_raw, v);
1809         if (status < 0) return -1;
1810         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct Type plane encoding: "
1811                "Imode: %i, Invert: %i\n", status>>1, status&1);
1812         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1813         if (status < 0) return -1;
1814         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1815                "Imode: %i, Invert: %i\n", status>>1, status&1);
1816
1817         v->s.mv_table_index = get_bits(gb, 2);
1818         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1819
1820         if (v->dquant)
1821         {
1822             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1823             vop_dquant_decoding(v);
1824         }
1825
1826         v->ttfrm = 0;
1827         if (v->vstransform)
1828         {
1829             v->ttmbf = get_bits(gb, 1);
1830             if (v->ttmbf)
1831             {
1832                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1833             }
1834         } else {
1835             v->ttmbf = 1;
1836             v->ttfrm = TT_8X8;
1837         }
1838         break;
1839     }
1840
1841     /* AC Syntax */
1842     v->c_ac_table_index = decode012(gb);
1843     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1844     {
1845         v->y_ac_table_index = decode012(gb);
1846     }
1847     /* DC Syntax */
1848     v->s.dc_table_index = get_bits(gb, 1);
1849     if ((v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE) && v->dquant) {
1850         av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1851         vop_dquant_decoding(v);
1852     }
1853
1854     v->bi_type = 0;
1855     if(v->s.pict_type == BI_TYPE) {
1856         v->s.pict_type = B_TYPE;
1857         v->bi_type = 1;
1858     }
1859     return 0;
1860 }
1861
1862 /***********************************************************************/
1863 /**
1864  * @defgroup block VC-1 Block-level functions
1865  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1866  * @{
1867  */
1868
1869 /**
1870  * @def GET_MQUANT
1871  * @brief Get macroblock-level quantizer scale
1872  */
1873 #define GET_MQUANT()                                           \
1874   if (v->dquantfrm)                                            \
1875   {                                                            \
1876     int edges = 0;                                             \
1877     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1878     {                                                          \
1879       if (v->dqbilevel)                                        \
1880       {                                                        \
1881         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1882       }                                                        \
1883       else                                                     \
1884       {                                                        \
1885         mqdiff = get_bits(gb, 3);                              \
1886         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1887         else mquant = get_bits(gb, 5);                         \
1888       }                                                        \
1889     }                                                          \
1890     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1891         edges = 1 << v->dqsbedge;                              \
1892     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1893         edges = (3 << v->dqsbedge) % 15;                       \
1894     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1895         edges = 15;                                            \
1896     if((edges&1) && !s->mb_x)                                  \
1897         mquant = v->altpq;                                     \
1898     if((edges&2) && s->first_slice_line)                       \
1899         mquant = v->altpq;                                     \
1900     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1901         mquant = v->altpq;                                     \
1902     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1903         mquant = v->altpq;                                     \
1904   }
1905
1906 /**
1907  * @def GET_MVDATA(_dmv_x, _dmv_y)
1908  * @brief Get MV differentials
1909  * @see MVDATA decoding from 8.3.5.2, p(1)20
1910  * @param _dmv_x Horizontal differential for decoded MV
1911  * @param _dmv_y Vertical differential for decoded MV
1912  */
1913 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1914   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1915                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1916   if (index > 36)                                                   \
1917   {                                                                 \
1918     mb_has_coeffs = 1;                                              \
1919     index -= 37;                                                    \
1920   }                                                                 \
1921   else mb_has_coeffs = 0;                                           \
1922   s->mb_intra = 0;                                                  \
1923   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1924   else if (index == 35)                                             \
1925   {                                                                 \
1926     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1927     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1928   }                                                                 \
1929   else if (index == 36)                                             \
1930   {                                                                 \
1931     _dmv_x = 0;                                                     \
1932     _dmv_y = 0;                                                     \
1933     s->mb_intra = 1;                                                \
1934   }                                                                 \
1935   else                                                              \
1936   {                                                                 \
1937     index1 = index%6;                                               \
1938     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1939     else                                   val = 0;                 \
1940     if(size_table[index1] - val > 0)                                \
1941         val = get_bits(gb, size_table[index1] - val);               \
1942     else                                   val = 0;                 \
1943     sign = 0 - (val&1);                                             \
1944     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1945                                                                     \
1946     index1 = index/6;                                               \
1947     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1948     else                                   val = 0;                 \
1949     if(size_table[index1] - val > 0)                                \
1950         val = get_bits(gb, size_table[index1] - val);               \
1951     else                                   val = 0;                 \
1952     sign = 0 - (val&1);                                             \
1953     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1954   }
1955
1956 /** Predict and set motion vector
1957  */
1958 static inline void vc1_pred_mv(MpegEncContext *s, int n, int dmv_x, int dmv_y, int mv1, int r_x, int r_y, uint8_t* is_intra)
1959 {
1960     int xy, wrap, off = 0;
1961     int16_t *A, *B, *C;
1962     int px, py;
1963     int sum;
1964
1965     /* scale MV difference to be quad-pel */
1966     dmv_x <<= 1 - s->quarter_sample;
1967     dmv_y <<= 1 - s->quarter_sample;
1968
1969     wrap = s->b8_stride;
1970     xy = s->block_index[n];
1971
1972     if(s->mb_intra){
1973         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1974         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1975         if(mv1) { /* duplicate motion data for 1-MV block */
1976             s->current_picture.motion_val[0][xy + 1][0] = 0;
1977             s->current_picture.motion_val[0][xy + 1][1] = 0;
1978             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1979             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1980             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1981             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1982         }
1983         return;
1984     }
1985
1986     C = s->current_picture.motion_val[0][xy - 1];
1987     A = s->current_picture.motion_val[0][xy - wrap];
1988     if(mv1)
1989         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1990     else {
1991         //in 4-MV mode different blocks have different B predictor position
1992         switch(n){
1993         case 0:
1994             off = (s->mb_x > 0) ? -1 : 1;
1995             break;
1996         case 1:
1997             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1998             break;
1999         case 2:
2000             off = 1;
2001             break;
2002         case 3:
2003             off = -1;
2004         }
2005     }
2006     B = s->current_picture.motion_val[0][xy - wrap + off];
2007
2008     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
2009         if(s->mb_width == 1) {
2010             px = A[0];
2011             py = A[1];
2012         } else {
2013             px = mid_pred(A[0], B[0], C[0]);
2014             py = mid_pred(A[1], B[1], C[1]);
2015         }
2016     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
2017         px = C[0];
2018         py = C[1];
2019     } else {
2020         px = py = 0;
2021     }
2022     /* Pullback MV as specified in 8.3.5.3.4 */
2023     {
2024         int qx, qy, X, Y;
2025         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
2026         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
2027         X = (s->mb_width << 6) - 4;
2028         Y = (s->mb_height << 6) - 4;
2029         if(mv1) {
2030             if(qx + px < -60) px = -60 - qx;
2031             if(qy + py < -60) py = -60 - qy;
2032         } else {
2033             if(qx + px < -28) px = -28 - qx;
2034             if(qy + py < -28) py = -28 - qy;
2035         }
2036         if(qx + px > X) px = X - qx;
2037         if(qy + py > Y) py = Y - qy;
2038     }
2039     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2040     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
2041         if(is_intra[xy - wrap])
2042             sum = FFABS(px) + FFABS(py);
2043         else
2044             sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2045         if(sum > 32) {
2046             if(get_bits1(&s->gb)) {
2047                 px = A[0];
2048                 py = A[1];
2049             } else {
2050                 px = C[0];
2051                 py = C[1];
2052             }
2053         } else {
2054             if(is_intra[xy - 1])
2055                 sum = FFABS(px) + FFABS(py);
2056             else
2057                 sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2058             if(sum > 32) {
2059                 if(get_bits1(&s->gb)) {
2060                     px = A[0];
2061                     py = A[1];
2062                 } else {
2063                     px = C[0];
2064                     py = C[1];
2065                 }
2066             }
2067         }
2068     }
2069     /* store MV using signed modulus of MV range defined in 4.11 */
2070     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
2071     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
2072     if(mv1) { /* duplicate motion data for 1-MV block */
2073         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
2074         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
2075         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
2076         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
2077         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
2078         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
2079     }
2080 }
2081
2082 /** Motion compensation for direct or interpolated blocks in B-frames
2083  */
2084 static void vc1_interp_mc(VC1Context *v)
2085 {
2086     MpegEncContext *s = &v->s;
2087     DSPContext *dsp = &v->s.dsp;
2088     uint8_t *srcY, *srcU, *srcV;
2089     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
2090
2091     if(!v->s.next_picture.data[0])return;
2092
2093     mx = s->mv[1][0][0];
2094     my = s->mv[1][0][1];
2095     uvmx = (mx + ((mx & 3) == 3)) >> 1;
2096     uvmy = (my + ((my & 3) == 3)) >> 1;
2097     if(v->fastuvmc) {
2098         uvmx = uvmx + ((uvmx<0)?-(uvmx&1):(uvmx&1));
2099         uvmy = uvmy + ((uvmy<0)?-(uvmy&1):(uvmy&1));
2100     }
2101     srcY = s->next_picture.data[0];
2102     srcU = s->next_picture.data[1];
2103     srcV = s->next_picture.data[2];
2104
2105     src_x = s->mb_x * 16 + (mx >> 2);
2106     src_y = s->mb_y * 16 + (my >> 2);
2107     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
2108     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
2109
2110     src_x   = clip(  src_x, -16, s->mb_width  * 16);
2111     src_y   = clip(  src_y, -16, s->mb_height * 16);
2112     uvsrc_x = clip(uvsrc_x,  -8, s->mb_width  *  8);
2113     uvsrc_y = clip(uvsrc_y,  -8, s->mb_height *  8);
2114
2115     srcY += src_y * s->linesize + src_x;
2116     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
2117     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
2118
2119     /* for grayscale we should not try to read from unknown area */
2120     if(s->flags & CODEC_FLAG_GRAY) {
2121         srcU = s->edge_emu_buffer + 18 * s->linesize;
2122         srcV = s->edge_emu_buffer + 18 * s->linesize;
2123     }
2124
2125     if(v->rangeredfrm
2126        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
2127        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
2128         uint8_t *uvbuf= s->edge_emu_buffer + 19 * s->linesize;
2129
2130         srcY -= s->mspel * (1 + s->linesize);
2131         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17+s->mspel*2, 17+s->mspel*2,
2132                             src_x - s->mspel, src_y - s->mspel, s->h_edge_pos, s->v_edge_pos);
2133         srcY = s->edge_emu_buffer;
2134         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
2135                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2136         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
2137                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
2138         srcU = uvbuf;
2139         srcV = uvbuf + 16;
2140         /* if we deal with range reduction we need to scale source blocks */
2141         if(v->rangeredfrm) {
2142             int i, j;
2143             uint8_t *src, *src2;
2144
2145             src = srcY;
2146             for(j = 0; j < 17 + s->mspel*2; j++) {
2147                 for(i = 0; i < 17 + s->mspel*2; i++) src[i] = ((src[i] - 128) >> 1) + 128;
2148                 src += s->linesize;
2149             }
2150             src = srcU; src2 = srcV;
2151             for(j = 0; j < 9; j++) {
2152                 for(i = 0; i < 9; i++) {
2153                     src[i] = ((src[i] - 128) >> 1) + 128;
2154                     src2[i] = ((src2[i] - 128) >> 1) + 128;
2155                 }
2156                 src += s->uvlinesize;
2157                 src2 += s->uvlinesize;
2158             }
2159         }
2160         srcY += s->mspel * (1 + s->linesize);
2161     }
2162
2163     mx >>= 1;
2164     my >>= 1;
2165     dxy = ((my & 1) << 1) | (mx & 1);
2166
2167     dsp->avg_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
2168
2169     if(s->flags & CODEC_FLAG_GRAY) return;
2170     /* Chroma MC always uses qpel blilinear */
2171     uvdxy = ((uvmy & 3) << 2) | (uvmx & 3);
2172     uvmx = (uvmx&3)<<1;
2173     uvmy = (uvmy&3)<<1;
2174     dsp->avg_h264_chroma_pixels_tab[0](s->dest[1], srcU, s->uvlinesize, 8, uvmx, uvmy);
2175     dsp->avg_h264_chroma_pixels_tab[0](s->dest[2], srcV, s->uvlinesize, 8, uvmx, uvmy);
2176 }
2177
2178 static av_always_inline int scale_mv(int value, int bfrac, int inv, int qs)
2179 {
2180     int n = bfrac;
2181
2182 #if B_FRACTION_DEN==256
2183     if(inv)
2184         n -= 256;
2185     if(!qs)
2186         return 2 * ((value * n + 255) >> 9);
2187     return (value * n + 128) >> 8;
2188 #else
2189     if(inv)
2190         n -= B_FRACTION_DEN;
2191     if(!qs)
2192         return 2 * ((value * n + B_FRACTION_DEN - 1) / (2 * B_FRACTION_DEN));
2193     return (value * n + B_FRACTION_DEN/2) / B_FRACTION_DEN;
2194 #endif
2195 }
2196
2197 /** Reconstruct motion vector for B-frame and do motion compensation
2198  */
2199 static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mode)
2200 {
2201     if(v->use_ic) {
2202         v->mv_mode2 = v->mv_mode;
2203         v->mv_mode = MV_PMODE_INTENSITY_COMP;
2204     }
2205     if(direct) {
2206         vc1_mc_1mv(v, 0);
2207         vc1_interp_mc(v);
2208         if(v->use_ic) v->mv_mode = v->mv_mode2;
2209         return;
2210     }
2211     if(mode == BMV_TYPE_INTERPOLATED) {
2212         vc1_mc_1mv(v, 0);
2213         vc1_interp_mc(v);
2214         if(v->use_ic) v->mv_mode = v->mv_mode2;
2215         return;
2216     }
2217
2218     if(v->use_ic && (mode == BMV_TYPE_BACKWARD)) v->mv_mode = v->mv_mode2;
2219     vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD));
2220     if(v->use_ic) v->mv_mode = v->mv_mode2;
2221 }
2222
2223 static inline void vc1_pred_b_mv(VC1Context *v, int dmv_x[2], int dmv_y[2], int direct, int mvtype)
2224 {
2225     MpegEncContext *s = &v->s;
2226     int xy, wrap, off = 0;
2227     int16_t *A, *B, *C;
2228     int px, py;
2229     int sum;
2230     int r_x, r_y;
2231     const uint8_t *is_intra = v->mb_type[0];
2232
2233     r_x = v->range_x;
2234     r_y = v->range_y;
2235     /* scale MV difference to be quad-pel */
2236     dmv_x[0] <<= 1 - s->quarter_sample;
2237     dmv_y[0] <<= 1 - s->quarter_sample;
2238     dmv_x[1] <<= 1 - s->quarter_sample;
2239     dmv_y[1] <<= 1 - s->quarter_sample;
2240
2241     wrap = s->b8_stride;
2242     xy = s->block_index[0];
2243
2244     if(s->mb_intra) {
2245         s->current_picture.motion_val[0][xy][0] =
2246         s->current_picture.motion_val[0][xy][1] =
2247         s->current_picture.motion_val[1][xy][0] =
2248         s->current_picture.motion_val[1][xy][1] = 0;
2249         return;
2250     }
2251     s->mv[0][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 0, s->quarter_sample);
2252     s->mv[0][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 0, s->quarter_sample);
2253     s->mv[1][0][0] = scale_mv(s->next_picture.motion_val[1][xy][0], v->bfraction, 1, s->quarter_sample);
2254     s->mv[1][0][1] = scale_mv(s->next_picture.motion_val[1][xy][1], v->bfraction, 1, s->quarter_sample);
2255     if(direct) {
2256         s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2257         s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2258         s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2259         s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2260         return;
2261     }
2262
2263     if((mvtype == BMV_TYPE_FORWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2264         C = s->current_picture.motion_val[0][xy - 2];
2265         A = s->current_picture.motion_val[0][xy - wrap*2];
2266         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2267         B = s->current_picture.motion_val[0][xy - wrap*2 + off];
2268
2269         if(!s->first_slice_line) { // predictor A is not out of bounds
2270             if(s->mb_width == 1) {
2271                 px = A[0];
2272                 py = A[1];
2273             } else {
2274                 px = mid_pred(A[0], B[0], C[0]);
2275                 py = mid_pred(A[1], B[1], C[1]);
2276             }
2277         } else if(s->mb_x) { // predictor C is not out of bounds
2278             px = C[0];
2279             py = C[1];
2280         } else {
2281             px = py = 0;
2282         }
2283         /* Pullback MV as specified in 8.3.5.3.4 */
2284         {
2285             int qx, qy, X, Y;
2286             if(v->profile < PROFILE_ADVANCED) {
2287                 qx = (s->mb_x << 5);
2288                 qy = (s->mb_y << 5);
2289                 X = (s->mb_width << 5) - 4;
2290                 Y = (s->mb_height << 5) - 4;
2291                 if(qx + px < -28) px = -28 - qx;
2292                 if(qy + py < -28) py = -28 - qy;
2293                 if(qx + px > X) px = X - qx;
2294                 if(qy + py > Y) py = Y - qy;
2295             } else {
2296                 qx = (s->mb_x << 6);
2297                 qy = (s->mb_y << 6);
2298                 X = (s->mb_width << 6) - 4;
2299                 Y = (s->mb_height << 6) - 4;
2300                 if(qx + px < -60) px = -60 - qx;
2301                 if(qy + py < -60) py = -60 - qy;
2302                 if(qx + px > X) px = X - qx;
2303                 if(qy + py > Y) py = Y - qy;
2304             }
2305         }
2306         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2307         if(0 && !s->first_slice_line && s->mb_x) {
2308             if(is_intra[xy - wrap])
2309                 sum = FFABS(px) + FFABS(py);
2310             else
2311                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2312             if(sum > 32) {
2313                 if(get_bits1(&s->gb)) {
2314                     px = A[0];
2315                     py = A[1];
2316                 } else {
2317                     px = C[0];
2318                     py = C[1];
2319                 }
2320             } else {
2321                 if(is_intra[xy - 2])
2322                     sum = FFABS(px) + FFABS(py);
2323                 else
2324                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2325                 if(sum > 32) {
2326                     if(get_bits1(&s->gb)) {
2327                         px = A[0];
2328                         py = A[1];
2329                     } else {
2330                         px = C[0];
2331                         py = C[1];
2332                     }
2333                 }
2334             }
2335         }
2336         /* store MV using signed modulus of MV range defined in 4.11 */
2337         s->mv[0][0][0] = ((px + dmv_x[0] + r_x) & ((r_x << 1) - 1)) - r_x;
2338         s->mv[0][0][1] = ((py + dmv_y[0] + r_y) & ((r_y << 1) - 1)) - r_y;
2339     }
2340     if((mvtype == BMV_TYPE_BACKWARD) || (mvtype == BMV_TYPE_INTERPOLATED)) {
2341         C = s->current_picture.motion_val[1][xy - 2];
2342         A = s->current_picture.motion_val[1][xy - wrap*2];
2343         off = (s->mb_x == (s->mb_width - 1)) ? -2 : 2;
2344         B = s->current_picture.motion_val[1][xy - wrap*2 + off];
2345
2346         if(!s->first_slice_line) { // predictor A is not out of bounds
2347             if(s->mb_width == 1) {
2348                 px = A[0];
2349                 py = A[1];
2350             } else {
2351                 px = mid_pred(A[0], B[0], C[0]);
2352                 py = mid_pred(A[1], B[1], C[1]);
2353             }
2354         } else if(s->mb_x) { // predictor C is not out of bounds
2355             px = C[0];
2356             py = C[1];
2357         } else {
2358             px = py = 0;
2359         }
2360         /* Pullback MV as specified in 8.3.5.3.4 */
2361         {
2362             int qx, qy, X, Y;
2363             if(v->profile < PROFILE_ADVANCED) {
2364                 qx = (s->mb_x << 5);
2365                 qy = (s->mb_y << 5);
2366                 X = (s->mb_width << 5) - 4;
2367                 Y = (s->mb_height << 5) - 4;
2368                 if(qx + px < -28) px = -28 - qx;
2369                 if(qy + py < -28) py = -28 - qy;
2370                 if(qx + px > X) px = X - qx;
2371                 if(qy + py > Y) py = Y - qy;
2372             } else {
2373                 qx = (s->mb_x << 6);
2374                 qy = (s->mb_y << 6);
2375                 X = (s->mb_width << 6) - 4;
2376                 Y = (s->mb_height << 6) - 4;
2377                 if(qx + px < -60) px = -60 - qx;
2378                 if(qy + py < -60) py = -60 - qy;
2379                 if(qx + px > X) px = X - qx;
2380                 if(qy + py > Y) py = Y - qy;
2381             }
2382         }
2383         /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
2384         if(0 && !s->first_slice_line && s->mb_x) {
2385             if(is_intra[xy - wrap])
2386                 sum = FFABS(px) + FFABS(py);
2387             else
2388                 sum = FFABS(px - A[0]) + FFABS(py - A[1]);
2389             if(sum > 32) {
2390                 if(get_bits1(&s->gb)) {
2391                     px = A[0];
2392                     py = A[1];
2393                 } else {
2394                     px = C[0];
2395                     py = C[1];
2396                 }
2397             } else {
2398                 if(is_intra[xy - 2])
2399                     sum = FFABS(px) + FFABS(py);
2400                 else
2401                     sum = FFABS(px - C[0]) + FFABS(py - C[1]);
2402                 if(sum > 32) {
2403                     if(get_bits1(&s->gb)) {
2404                         px = A[0];
2405                         py = A[1];
2406                     } else {
2407                         px = C[0];
2408                         py = C[1];
2409                     }
2410                 }
2411             }
2412         }
2413         /* store MV using signed modulus of MV range defined in 4.11 */
2414
2415         s->mv[1][0][0] = ((px + dmv_x[1] + r_x) & ((r_x << 1) - 1)) - r_x;
2416         s->mv[1][0][1] = ((py + dmv_y[1] + r_y) & ((r_y << 1) - 1)) - r_y;
2417     }
2418     s->current_picture.motion_val[0][xy][0] = s->mv[0][0][0];
2419     s->current_picture.motion_val[0][xy][1] = s->mv[0][0][1];
2420     s->current_picture.motion_val[1][xy][0] = s->mv[1][0][0];
2421     s->current_picture.motion_val[1][xy][1] = s->mv[1][0][1];
2422 }
2423
2424 /** Get predicted DC value for I-frames only
2425  * prediction dir: left=0, top=1
2426  * @param s MpegEncContext
2427  * @param[in] n block index in the current MB
2428  * @param dc_val_ptr Pointer to DC predictor
2429  * @param dir_ptr Prediction direction for use in AC prediction
2430  */
2431 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2432                               int16_t **dc_val_ptr, int *dir_ptr)
2433 {
2434     int a, b, c, wrap, pred, scale;
2435     int16_t *dc_val;
2436     static const uint16_t dcpred[32] = {
2437     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
2438          114,  102,   93,   85,   79,   73,   68,   64,
2439           60,   57,   54,   51,   49,   47,   45,   43,
2440           41,   39,   38,   37,   35,   34,   33
2441     };
2442
2443     /* find prediction - wmv3_dc_scale always used here in fact */
2444     if (n < 4)     scale = s->y_dc_scale;
2445     else           scale = s->c_dc_scale;
2446
2447     wrap = s->block_wrap[n];
2448     dc_val= s->dc_val[0] + s->block_index[n];
2449
2450     /* B A
2451      * C X
2452      */
2453     c = dc_val[ - 1];
2454     b = dc_val[ - 1 - wrap];
2455     a = dc_val[ - wrap];
2456
2457     if (pq < 9 || !overlap)
2458     {
2459         /* Set outer values */
2460         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
2461         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
2462     }
2463     else
2464     {
2465         /* Set outer values */
2466         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
2467         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
2468     }
2469
2470     if (abs(a - b) <= abs(b - c)) {
2471         pred = c;
2472         *dir_ptr = 1;//left
2473     } else {
2474         pred = a;
2475         *dir_ptr = 0;//top
2476     }
2477
2478     /* update predictor */
2479     *dc_val_ptr = &dc_val[0];
2480     return pred;
2481 }
2482
2483
2484 /** Get predicted DC value
2485  * prediction dir: left=0, top=1
2486  * @param s MpegEncContext
2487  * @param[in] n block index in the current MB
2488  * @param dc_val_ptr Pointer to DC predictor
2489  * @param dir_ptr Prediction direction for use in AC prediction
2490  */
2491 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
2492                               int a_avail, int c_avail,
2493                               int16_t **dc_val_ptr, int *dir_ptr)
2494 {
2495     int a, b, c, wrap, pred, scale;
2496     int16_t *dc_val;
2497     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2498     int q1, q2 = 0;
2499
2500     /* find prediction - wmv3_dc_scale always used here in fact */
2501     if (n < 4)     scale = s->y_dc_scale;
2502     else           scale = s->c_dc_scale;
2503
2504     wrap = s->block_wrap[n];
2505     dc_val= s->dc_val[0] + s->block_index[n];
2506
2507     /* B A
2508      * C X
2509      */
2510     c = dc_val[ - 1];
2511     b = dc_val[ - 1 - wrap];
2512     a = dc_val[ - wrap];
2513     /* scale predictors if needed */
2514     q1 = s->current_picture.qscale_table[mb_pos];
2515     if(c_avail && (n!= 1 && n!=3)) {
2516         q2 = s->current_picture.qscale_table[mb_pos - 1];
2517         if(q2 && q2 != q1)
2518             c = (c * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2519     }
2520     if(a_avail && (n!= 2 && n!=3)) {
2521         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2522         if(q2 && q2 != q1)
2523             a = (a * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2524     }
2525     if(a_avail && c_avail && (n!=3)) {
2526         int off = mb_pos;
2527         if(n != 1) off--;
2528         if(n != 2) off -= s->mb_stride;
2529         q2 = s->current_picture.qscale_table[off];
2530         if(q2 && q2 != q1)
2531             b = (b * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
2532     }
2533
2534     if(a_avail && c_avail) {
2535         if(abs(a - b) <= abs(b - c)) {
2536             pred = c;
2537             *dir_ptr = 1;//left
2538         } else {
2539             pred = a;
2540             *dir_ptr = 0;//top
2541         }
2542     } else if(a_avail) {
2543         pred = a;
2544         *dir_ptr = 0;//top
2545     } else if(c_avail) {
2546         pred = c;
2547         *dir_ptr = 1;//left
2548     } else {
2549         pred = 0;
2550         *dir_ptr = 1;//left
2551     }
2552
2553     /* update predictor */
2554     *dc_val_ptr = &dc_val[0];
2555     return pred;
2556 }
2557
2558
2559 /**
2560  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
2561  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
2562  * @{
2563  */
2564
2565 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
2566 {
2567     int xy, wrap, pred, a, b, c;
2568
2569     xy = s->block_index[n];
2570     wrap = s->b8_stride;
2571
2572     /* B C
2573      * A X
2574      */
2575     a = s->coded_block[xy - 1       ];
2576     b = s->coded_block[xy - 1 - wrap];
2577     c = s->coded_block[xy     - wrap];
2578
2579     if (b == c) {
2580         pred = a;
2581     } else {
2582         pred = c;
2583     }
2584
2585     /* store value */
2586     *coded_block_ptr = &s->coded_block[xy];
2587
2588     return pred;
2589 }
2590
2591 /**
2592  * Decode one AC coefficient
2593  * @param v The VC1 context
2594  * @param last Last coefficient
2595  * @param skip How much zero coefficients to skip
2596  * @param value Decoded AC coefficient value
2597  * @see 8.1.3.4
2598  */
2599 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
2600 {
2601     GetBitContext *gb = &v->s.gb;
2602     int index, escape, run = 0, level = 0, lst = 0;
2603
2604     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2605     if (index != vc1_ac_sizes[codingset] - 1) {
2606         run = vc1_index_decode_table[codingset][index][0];
2607         level = vc1_index_decode_table[codingset][index][1];
2608         lst = index >= vc1_last_decode_table[codingset];
2609         if(get_bits(gb, 1))
2610             level = -level;
2611     } else {
2612         escape = decode210(gb);
2613         if (escape != 2) {
2614             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
2615             run = vc1_index_decode_table[codingset][index][0];
2616             level = vc1_index_decode_table[codingset][index][1];
2617             lst = index >= vc1_last_decode_table[codingset];
2618             if(escape == 0) {
2619                 if(lst)
2620                     level += vc1_last_delta_level_table[codingset][run];
2621                 else
2622                     level += vc1_delta_level_table[codingset][run];
2623             } else {
2624                 if(lst)
2625                     run += vc1_last_delta_run_table[codingset][level] + 1;
2626                 else
2627                     run += vc1_delta_run_table[codingset][level] + 1;
2628             }
2629             if(get_bits(gb, 1))
2630                 level = -level;
2631         } else {
2632             int sign;
2633             lst = get_bits(gb, 1);
2634             if(v->s.esc3_level_length == 0) {
2635                 if(v->pq < 8 || v->dquantfrm) { // table 59
2636                     v->s.esc3_level_length = get_bits(gb, 3);
2637                     if(!v->s.esc3_level_length)
2638                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
2639                 } else { //table 60
2640                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
2641                 }
2642                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
2643             }
2644             run = get_bits(gb, v->s.esc3_run_length);
2645             sign = get_bits(gb, 1);
2646             level = get_bits(gb, v->s.esc3_level_length);
2647             if(sign)
2648                 level = -level;
2649         }
2650     }
2651
2652     *last = lst;
2653     *skip = run;
2654     *value = level;
2655 }
2656
2657 /** Decode intra block in intra frames - should be faster than decode_intra_block
2658  * @param v VC1Context
2659  * @param block block to decode
2660  * @param coded are AC coeffs present or not
2661  * @param codingset set of VLC to decode data
2662  */
2663 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
2664 {
2665     GetBitContext *gb = &v->s.gb;
2666     MpegEncContext *s = &v->s;
2667     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2668     int run_diff, i;
2669     int16_t *dc_val;
2670     int16_t *ac_val, *ac_val2;
2671     int dcdiff;
2672
2673     /* Get DC differential */
2674     if (n < 4) {
2675         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2676     } else {
2677         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2678     }
2679     if (dcdiff < 0){
2680         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2681         return -1;
2682     }
2683     if (dcdiff)
2684     {
2685         if (dcdiff == 119 /* ESC index value */)
2686         {
2687             /* TODO: Optimize */
2688             if (v->pq == 1) dcdiff = get_bits(gb, 10);
2689             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
2690             else dcdiff = get_bits(gb, 8);
2691         }
2692         else
2693         {
2694             if (v->pq == 1)
2695                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2696             else if (v->pq == 2)
2697                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2698         }
2699         if (get_bits(gb, 1))
2700             dcdiff = -dcdiff;
2701     }
2702
2703     /* Prediction */
2704     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
2705     *dc_val = dcdiff;
2706
2707     /* Store the quantized DC coeff, used for prediction */
2708     if (n < 4) {
2709         block[0] = dcdiff * s->y_dc_scale;
2710     } else {
2711         block[0] = dcdiff * s->c_dc_scale;
2712     }
2713     /* Skip ? */
2714     run_diff = 0;
2715     i = 0;
2716     if (!coded) {
2717         goto not_coded;
2718     }
2719
2720     //AC Decoding
2721     i = 1;
2722
2723     {
2724         int last = 0, skip, value;
2725         const int8_t *zz_table;
2726         int scale;
2727         int k;
2728
2729         scale = v->pq * 2 + v->halfpq;
2730
2731         if(v->s.ac_pred) {
2732             if(!dc_pred_dir)
2733                 zz_table = vc1_horizontal_zz;
2734             else
2735                 zz_table = vc1_vertical_zz;
2736         } else
2737             zz_table = vc1_normal_zz;
2738
2739         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2740         ac_val2 = ac_val;
2741         if(dc_pred_dir) //left
2742             ac_val -= 16;
2743         else //top
2744             ac_val -= 16 * s->block_wrap[n];
2745
2746         while (!last) {
2747             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2748             i += skip;
2749             if(i > 63)
2750                 break;
2751             block[zz_table[i++]] = value;
2752         }
2753
2754         /* apply AC prediction if needed */
2755         if(s->ac_pred) {
2756             if(dc_pred_dir) { //left
2757                 for(k = 1; k < 8; k++)
2758                     block[k << 3] += ac_val[k];
2759             } else { //top
2760                 for(k = 1; k < 8; k++)
2761                     block[k] += ac_val[k + 8];
2762             }
2763         }
2764         /* save AC coeffs for further prediction */
2765         for(k = 1; k < 8; k++) {
2766             ac_val2[k] = block[k << 3];
2767             ac_val2[k + 8] = block[k];
2768         }
2769
2770         /* scale AC coeffs */
2771         for(k = 1; k < 64; k++)
2772             if(block[k]) {
2773                 block[k] *= scale;
2774                 if(!v->pquantizer)
2775                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
2776             }
2777
2778         if(s->ac_pred) i = 63;
2779     }
2780
2781 not_coded:
2782     if(!coded) {
2783         int k, scale;
2784         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2785         ac_val2 = ac_val;
2786
2787         scale = v->pq * 2 + v->halfpq;
2788         memset(ac_val2, 0, 16 * 2);
2789         if(dc_pred_dir) {//left
2790             ac_val -= 16;
2791             if(s->ac_pred)
2792                 memcpy(ac_val2, ac_val, 8 * 2);
2793         } else {//top
2794             ac_val -= 16 * s->block_wrap[n];
2795             if(s->ac_pred)
2796                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2797         }
2798
2799         /* apply AC prediction if needed */
2800         if(s->ac_pred) {
2801             if(dc_pred_dir) { //left
2802                 for(k = 1; k < 8; k++) {
2803                     block[k << 3] = ac_val[k] * scale;
2804                     if(!v->pquantizer && block[k << 3])
2805                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2806                 }
2807             } else { //top
2808                 for(k = 1; k < 8; k++) {
2809                     block[k] = ac_val[k + 8] * scale;
2810                     if(!v->pquantizer && block[k])
2811                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2812                 }
2813             }
2814             i = 63;
2815         }
2816     }
2817     s->block_last_index[n] = i;
2818
2819     return 0;
2820 }
2821
2822 /** Decode intra block in intra frames - should be faster than decode_intra_block
2823  * @param v VC1Context
2824  * @param block block to decode
2825  * @param coded are AC coeffs present or not
2826  * @param codingset set of VLC to decode data
2827  */
2828 static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
2829 {
2830     GetBitContext *gb = &v->s.gb;
2831     MpegEncContext *s = &v->s;
2832     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2833     int run_diff, i;
2834     int16_t *dc_val;
2835     int16_t *ac_val, *ac_val2;
2836     int dcdiff;
2837     int a_avail = v->a_avail, c_avail = v->c_avail;
2838     int use_pred = s->ac_pred;
2839     int scale;
2840     int q1, q2 = 0;
2841     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2842
2843     /* Get DC differential */
2844     if (n < 4) {
2845         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2846     } else {
2847         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2848     }
2849     if (dcdiff < 0){
2850         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2851         return -1;
2852     }
2853     if (dcdiff)
2854     {
2855         if (dcdiff == 119 /* ESC index value */)
2856         {
2857             /* TODO: Optimize */
2858             if (mquant == 1) dcdiff = get_bits(gb, 10);
2859             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2860             else dcdiff = get_bits(gb, 8);
2861         }
2862         else
2863         {
2864             if (mquant == 1)
2865                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2866             else if (mquant == 2)
2867                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2868         }
2869         if (get_bits(gb, 1))
2870             dcdiff = -dcdiff;
2871     }
2872
2873     /* Prediction */
2874     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir);
2875     *dc_val = dcdiff;
2876
2877     /* Store the quantized DC coeff, used for prediction */
2878     if (n < 4) {
2879         block[0] = dcdiff * s->y_dc_scale;
2880     } else {
2881         block[0] = dcdiff * s->c_dc_scale;
2882     }
2883     /* Skip ? */
2884     run_diff = 0;
2885     i = 0;
2886
2887     //AC Decoding
2888     i = 1;
2889
2890     /* check if AC is needed at all and adjust direction if needed */
2891     if(!a_avail) dc_pred_dir = 1;
2892     if(!c_avail) dc_pred_dir = 0;
2893     if(!a_avail && !c_avail) use_pred = 0;
2894     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2895     ac_val2 = ac_val;
2896
2897     scale = mquant * 2 + v->halfpq;
2898
2899     if(dc_pred_dir) //left
2900         ac_val -= 16;
2901     else //top
2902         ac_val -= 16 * s->block_wrap[n];
2903
2904     q1 = s->current_picture.qscale_table[mb_pos];
2905     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
2906     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2907     if(n && n<4) q2 = q1;
2908
2909     if(coded) {
2910         int last = 0, skip, value;
2911         const int8_t *zz_table;
2912         int k;
2913
2914         if(v->s.ac_pred) {
2915             if(!dc_pred_dir)
2916                 zz_table = vc1_horizontal_zz;
2917             else
2918                 zz_table = vc1_vertical_zz;
2919         } else
2920             zz_table = vc1_normal_zz;
2921
2922         while (!last) {
2923             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2924             i += skip;
2925             if(i > 63)
2926                 break;
2927             block[zz_table[i++]] = value;
2928         }
2929
2930         /* apply AC prediction if needed */
2931         if(use_pred) {
2932             /* scale predictors if needed*/
2933             if(q2 && q1!=q2) {
2934                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2935                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2936
2937                 if(dc_pred_dir) { //left
2938                     for(k = 1; k < 8; k++)
2939                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2940                 } else { //top
2941                     for(k = 1; k < 8; k++)
2942                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2943                 }
2944             } else {
2945                 if(dc_pred_dir) { //left
2946                     for(k = 1; k < 8; k++)
2947                         block[k << 3] += ac_val[k];
2948                 } else { //top
2949                     for(k = 1; k < 8; k++)
2950                         block[k] += ac_val[k + 8];
2951                 }
2952             }
2953         }
2954         /* save AC coeffs for further prediction */
2955         for(k = 1; k < 8; k++) {
2956             ac_val2[k] = block[k << 3];
2957             ac_val2[k + 8] = block[k];
2958         }
2959
2960         /* scale AC coeffs */
2961         for(k = 1; k < 64; k++)
2962             if(block[k]) {
2963                 block[k] *= scale;
2964                 if(!v->pquantizer)
2965                     block[k] += (block[k] < 0) ? -mquant : mquant;
2966             }
2967
2968         if(use_pred) i = 63;
2969     } else { // no AC coeffs
2970         int k;
2971
2972         memset(ac_val2, 0, 16 * 2);
2973         if(dc_pred_dir) {//left
2974             if(use_pred) {
2975                 memcpy(ac_val2, ac_val, 8 * 2);
2976                 if(q2 && q1!=q2) {
2977                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2978                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2979                     for(k = 1; k < 8; k++)
2980                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2981                 }
2982             }
2983         } else {//top
2984             if(use_pred) {
2985                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2986                 if(q2 && q1!=q2) {
2987                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
2988                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
2989                     for(k = 1; k < 8; k++)
2990                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2991                 }
2992             }
2993         }
2994
2995         /* apply AC prediction if needed */
2996         if(use_pred) {
2997             if(dc_pred_dir) { //left
2998                 for(k = 1; k < 8; k++) {
2999                     block[k << 3] = ac_val2[k] * scale;
3000                     if(!v->pquantizer && block[k << 3])
3001                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3002                 }
3003             } else { //top
3004                 for(k = 1; k < 8; k++) {
3005                     block[k] = ac_val2[k + 8] * scale;
3006                     if(!v->pquantizer && block[k])
3007                         block[k] += (block[k] < 0) ? -mquant : mquant;
3008                 }
3009             }
3010             i = 63;
3011         }
3012     }
3013     s->block_last_index[n] = i;
3014
3015     return 0;
3016 }
3017
3018 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
3019  * @param v VC1Context
3020  * @param block block to decode
3021  * @param coded are AC coeffs present or not
3022  * @param mquant block quantizer
3023  * @param codingset set of VLC to decode data
3024  */
3025 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
3026 {
3027     GetBitContext *gb = &v->s.gb;
3028     MpegEncContext *s = &v->s;
3029     int dc_pred_dir = 0; /* Direction of the DC prediction used */
3030     int run_diff, i;
3031     int16_t *dc_val;
3032     int16_t *ac_val, *ac_val2;
3033     int dcdiff;
3034     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3035     int a_avail = v->a_avail, c_avail = v->c_avail;
3036     int use_pred = s->ac_pred;
3037     int scale;
3038     int q1, q2 = 0;
3039
3040     /* XXX: Guard against dumb values of mquant */
3041     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
3042
3043     /* Set DC scale - y and c use the same */
3044     s->y_dc_scale = s->y_dc_scale_table[mquant];
3045     s->c_dc_scale = s->c_dc_scale_table[mquant];
3046
3047     /* Get DC differential */
3048     if (n < 4) {
3049         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3050     } else {
3051         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
3052     }
3053     if (dcdiff < 0){
3054         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
3055         return -1;
3056     }
3057     if (dcdiff)
3058     {
3059         if (dcdiff == 119 /* ESC index value */)
3060         {
3061             /* TODO: Optimize */
3062             if (mquant == 1) dcdiff = get_bits(gb, 10);
3063             else if (mquant == 2) dcdiff = get_bits(gb, 9);
3064             else dcdiff = get_bits(gb, 8);
3065         }
3066         else
3067         {
3068             if (mquant == 1)
3069                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
3070             else if (mquant == 2)
3071                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
3072         }
3073         if (get_bits(gb, 1))
3074             dcdiff = -dcdiff;
3075     }
3076
3077     /* Prediction */
3078     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
3079     *dc_val = dcdiff;
3080
3081     /* Store the quantized DC coeff, used for prediction */
3082
3083     if (n < 4) {
3084         block[0] = dcdiff * s->y_dc_scale;
3085     } else {
3086         block[0] = dcdiff * s->c_dc_scale;
3087     }
3088     /* Skip ? */
3089     run_diff = 0;
3090     i = 0;
3091
3092     //AC Decoding
3093     i = 1;
3094
3095     /* check if AC is needed at all and adjust direction if needed */
3096     if(!a_avail) dc_pred_dir = 1;
3097     if(!c_avail) dc_pred_dir = 0;
3098     if(!a_avail && !c_avail) use_pred = 0;
3099     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
3100     ac_val2 = ac_val;
3101
3102     scale = mquant * 2 + v->halfpq;
3103
3104     if(dc_pred_dir) //left
3105         ac_val -= 16;
3106     else //top
3107         ac_val -= 16 * s->block_wrap[n];
3108
3109     q1 = s->current_picture.qscale_table[mb_pos];
3110     if(dc_pred_dir && c_avail && mb_pos) q2 = s->current_picture.qscale_table[mb_pos - 1];
3111     if(!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
3112     if(n && n<4) q2 = q1;
3113
3114     if(coded) {
3115         int last = 0, skip, value;
3116         const int8_t *zz_table;
3117         int k;
3118
3119         zz_table = vc1_simple_progressive_8x8_zz;
3120
3121         while (!last) {
3122             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
3123             i += skip;
3124             if(i > 63)
3125                 break;
3126             block[zz_table[i++]] = value;
3127         }
3128
3129         /* apply AC prediction if needed */
3130         if(use_pred) {
3131             /* scale predictors if needed*/
3132             if(q2 && q1!=q2) {
3133                 q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3134                 q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3135
3136                 if(dc_pred_dir) { //left
3137                     for(k = 1; k < 8; k++)
3138                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3139                 } else { //top
3140                     for(k = 1; k < 8; k++)
3141                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3142                 }
3143             } else {
3144                 if(dc_pred_dir) { //left
3145                     for(k = 1; k < 8; k++)
3146                         block[k << 3] += ac_val[k];
3147                 } else { //top
3148                     for(k = 1; k < 8; k++)
3149                         block[k] += ac_val[k + 8];
3150                 }
3151             }
3152         }
3153         /* save AC coeffs for further prediction */
3154         for(k = 1; k < 8; k++) {
3155             ac_val2[k] = block[k << 3];
3156             ac_val2[k + 8] = block[k];
3157         }
3158
3159         /* scale AC coeffs */
3160         for(k = 1; k < 64; k++)
3161             if(block[k]) {
3162                 block[k] *= scale;
3163                 if(!v->pquantizer)
3164                     block[k] += (block[k] < 0) ? -mquant : mquant;
3165             }
3166
3167         if(use_pred) i = 63;
3168     } else { // no AC coeffs
3169         int k;
3170
3171         memset(ac_val2, 0, 16 * 2);
3172         if(dc_pred_dir) {//left
3173             if(use_pred) {
3174                 memcpy(ac_val2, ac_val, 8 * 2);
3175                 if(q2 && q1!=q2) {
3176                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3177                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3178                     for(k = 1; k < 8; k++)
3179                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3180                 }
3181             }
3182         } else {//top
3183             if(use_pred) {
3184                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
3185                 if(q2 && q1!=q2) {
3186                     q1 = q1 * 2 + ((q1 == v->pq) ? v->halfpq : 0) - 1;
3187                     q2 = q2 * 2 + ((q2 == v->pq) ? v->halfpq : 0) - 1;
3188                     for(k = 1; k < 8; k++)
3189                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
3190                 }
3191             }
3192         }
3193
3194         /* apply AC prediction if needed */
3195         if(use_pred) {
3196             if(dc_pred_dir) { //left
3197                 for(k = 1; k < 8; k++) {
3198                     block[k << 3] = ac_val2[k] * scale;
3199                     if(!v->pquantizer && block[k << 3])
3200                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
3201                 }
3202             } else { //top
3203                 for(k = 1; k < 8; k++) {
3204                     block[k] = ac_val2[k + 8] * scale;
3205                     if(!v->pquantizer && block[k])
3206                         block[k] += (block[k] < 0) ? -mquant : mquant;
3207                 }
3208             }
3209             i = 63;
3210         }
3211     }
3212     s->block_last_index[n] = i;
3213
3214     return 0;
3215 }
3216
3217 /** Decode P block
3218  */
3219 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
3220 {
3221     MpegEncContext *s = &v->s;
3222     GetBitContext *gb = &s->gb;
3223     int i, j;
3224     int subblkpat = 0;
3225     int scale, off, idx, last, skip, value;
3226     int ttblk = ttmb & 7;
3227
3228     if(ttmb == -1) {
3229         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
3230     }
3231     if(ttblk == TT_4X4) {
3232         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
3233     }
3234     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
3235         subblkpat = decode012(gb);
3236         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
3237         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
3238         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
3239     }
3240     scale = 2 * mquant + v->halfpq;
3241
3242     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
3243     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
3244         subblkpat = 2 - (ttblk == TT_8X4_TOP);
3245         ttblk = TT_8X4;
3246     }
3247     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
3248         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
3249         ttblk = TT_4X8;
3250     }
3251     switch(ttblk) {
3252     case TT_8X8:
3253         i = 0;
3254         last = 0;
3255         while (!last) {
3256             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3257             i += skip;
3258             if(i > 63)
3259                 break;
3260             idx = vc1_simple_progressive_8x8_zz[i++];
3261             block[idx] = value * scale;
3262             if(!v->pquantizer)
3263                 block[idx] += (block[idx] < 0) ? -mquant : mquant;
3264         }
3265         s->dsp.vc1_inv_trans_8x8(block);
3266         break;
3267     case TT_4X4:
3268         for(j = 0; j < 4; j++) {
3269             last = subblkpat & (1 << (3 - j));
3270             i = 0;
3271             off = (j & 1) * 4 + (j & 2) * 16;
3272             while (!last) {
3273                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3274                 i += skip;
3275                 if(i > 15)
3276                     break;
3277                 idx = vc1_simple_progressive_4x4_zz[i++];
3278                 block[idx + off] = value * scale;
3279                 if(!v->pquantizer)
3280                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3281             }
3282             if(!(subblkpat & (1 << (3 - j))))
3283                 s->dsp.vc1_inv_trans_4x4(block, j);
3284         }
3285         break;
3286     case TT_8X4:
3287         for(j = 0; j < 2; j++) {
3288             last = subblkpat & (1 << (1 - j));
3289             i = 0;
3290             off = j * 32;
3291             while (!last) {
3292                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3293                 i += skip;
3294                 if(i > 31)
3295                     break;
3296                 if(v->profile < PROFILE_ADVANCED)
3297                     idx = vc1_simple_progressive_8x4_zz[i++];
3298                 else
3299                     idx = vc1_adv_progressive_8x4_zz[i++];
3300                 block[idx + off] = value * scale;
3301                 if(!v->pquantizer)
3302                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3303             }
3304             if(!(subblkpat & (1 << (1 - j))))
3305                 s->dsp.vc1_inv_trans_8x4(block, j);
3306         }
3307         break;
3308     case TT_4X8:
3309         for(j = 0; j < 2; j++) {
3310             last = subblkpat & (1 << (1 - j));
3311             i = 0;
3312             off = j * 4;
3313             while (!last) {
3314                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
3315                 i += skip;
3316                 if(i > 31)
3317                     break;
3318                 if(v->profile < PROFILE_ADVANCED)
3319                     idx = vc1_simple_progressive_4x8_zz[i++];
3320                 else
3321                     idx = vc1_adv_progressive_4x8_zz[i++];
3322                 block[idx + off] = value * scale;
3323                 if(!v->pquantizer)
3324                     block[idx + off] += (block[idx + off] < 0) ? -mquant : mquant;
3325             }
3326             if(!(subblkpat & (1 << (1 - j))))
3327                 s->dsp.vc1_inv_trans_4x8(block, j);
3328         }
3329         break;
3330     }
3331     return 0;
3332 }
3333
3334
3335 /** Decode one P-frame MB (in Simple/Main profile)
3336  */
3337 static int vc1_decode_p_mb(VC1Context *v)
3338 {
3339     MpegEncContext *s = &v->s;
3340     GetBitContext *gb = &s->gb;
3341     int i, j;
3342     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3343     int cbp; /* cbp decoding stuff */
3344     int mqdiff, mquant; /* MB quantization */
3345     int ttmb = v->ttfrm; /* MB Transform type */
3346     int status;
3347
3348     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3349       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3350     int mb_has_coeffs = 1; /* last_flag */
3351     int dmv_x, dmv_y; /* Differential MV components */
3352     int index, index1; /* LUT indices */
3353     int val, sign; /* temp values */
3354     int first_block = 1;
3355     int dst_idx, off;
3356     int skipped, fourmv;
3357
3358     mquant = v->pq; /* Loosy initialization */
3359
3360     if (v->mv_type_is_raw)
3361         fourmv = get_bits1(gb);
3362     else
3363         fourmv = v->mv_type_mb_plane[mb_pos];
3364     if (v->skip_is_raw)
3365         skipped = get_bits1(gb);
3366     else
3367         skipped = v->s.mbskip_table[mb_pos];
3368
3369     s->dsp.clear_blocks(s->block[0]);
3370
3371     if (!fourmv) /* 1MV mode */
3372     {
3373         if (!skipped)
3374         {
3375             GET_MVDATA(dmv_x, dmv_y);
3376
3377             if (s->mb_intra) {
3378                 s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3379                 s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3380             }
3381             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
3382             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
3383
3384             /* FIXME Set DC val for inter block ? */
3385             if (s->mb_intra && !mb_has_coeffs)
3386             {
3387                 GET_MQUANT();
3388                 s->ac_pred = get_bits(gb, 1);
3389                 cbp = 0;
3390             }
3391             else if (mb_has_coeffs)
3392             {
3393                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
3394                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3395                 GET_MQUANT();
3396             }
3397             else
3398             {
3399                 mquant = v->pq;
3400                 cbp = 0;
3401             }
3402             s->current_picture.qscale_table[mb_pos] = mquant;
3403
3404             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3405                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
3406                                 VC1_TTMB_VLC_BITS, 2);
3407             if(!s->mb_intra) vc1_mc_1mv(v, 0);
3408             dst_idx = 0;
3409             for (i=0; i<6; i++)
3410             {
3411                 s->dc_val[0][s->block_index[i]] = 0;
3412                 dst_idx += i >> 2;
3413                 val = ((cbp >> (5 - i)) & 1);
3414                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3415                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
3416                 if(s->mb_intra) {
3417                     /* check if prediction blocks A and C are available */
3418                     v->a_avail = v->c_avail = 0;
3419                     if(i == 2 || i == 3 || !s->first_slice_line)
3420                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3421                     if(i == 1 || i == 3 || s->mb_x)
3422                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3423
3424                     vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3425                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3426                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3427                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3428                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3429                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3430                     if(v->pq >= 9 && v->overlap) {
3431                         if(v->c_avail)
3432                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3433                         if(v->a_avail)
3434                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3435                     }
3436                 } else if(val) {
3437                     vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3438                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3439                     first_block = 0;
3440                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3441                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3442                 }
3443             }
3444         }
3445         else //Skipped
3446         {
3447             s->mb_intra = 0;
3448             for(i = 0; i < 6; i++) {
3449                 v->mb_type[0][s->block_index[i]] = 0;
3450                 s->dc_val[0][s->block_index[i]] = 0;
3451             }
3452             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
3453             s->current_picture.qscale_table[mb_pos] = 0;
3454             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
3455             vc1_mc_1mv(v, 0);
3456             return 0;
3457         }
3458     } //1MV mode
3459     else //4MV mode
3460     {
3461         if (!skipped /* unskipped MB */)
3462         {
3463             int intra_count = 0, coded_inter = 0;
3464             int is_intra[6], is_coded[6];
3465             /* Get CBPCY */
3466             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3467             for (i=0; i<6; i++)
3468             {
3469                 val = ((cbp >> (5 - i)) & 1);
3470                 s->dc_val[0][s->block_index[i]] = 0;
3471                 s->mb_intra = 0;
3472                 if(i < 4) {
3473                     dmv_x = dmv_y = 0;
3474                     s->mb_intra = 0;
3475                     mb_has_coeffs = 0;
3476                     if(val) {
3477                         GET_MVDATA(dmv_x, dmv_y);
3478                     }
3479                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
3480                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
3481                     intra_count += s->mb_intra;
3482                     is_intra[i] = s->mb_intra;
3483                     is_coded[i] = mb_has_coeffs;
3484                 }
3485                 if(i&4){
3486                     is_intra[i] = (intra_count >= 3);
3487                     is_coded[i] = val;
3488                 }
3489                 if(i == 4) vc1_mc_4mv_chroma(v);
3490                 v->mb_type[0][s->block_index[i]] = is_intra[i];
3491                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
3492             }
3493             // if there are no coded blocks then don't do anything more
3494             if(!intra_count && !coded_inter) return 0;
3495             dst_idx = 0;
3496             GET_MQUANT();
3497             s->current_picture.qscale_table[mb_pos] = mquant;
3498             /* test if block is intra and has pred */
3499             {
3500                 int intrapred = 0;
3501                 for(i=0; i<6; i++)
3502                     if(is_intra[i]) {
3503                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
3504                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
3505                             intrapred = 1;
3506                             break;
3507                         }
3508                     }
3509                 if(intrapred)s->ac_pred = get_bits(gb, 1);
3510                 else s->ac_pred = 0;
3511             }
3512             if (!v->ttmbf && coded_inter)
3513                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3514             for (i=0; i<6; i++)
3515             {
3516                 dst_idx += i >> 2;
3517                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3518                 s->mb_intra = is_intra[i];
3519                 if (is_intra[i]) {
3520                     /* check if prediction blocks A and C are available */
3521                     v->a_avail = v->c_avail = 0;
3522                     if(i == 2 || i == 3 || !s->first_slice_line)
3523                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3524                     if(i == 1 || i == 3 || s->mb_x)
3525                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3526
3527                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
3528                     if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3529                     s->dsp.vc1_inv_trans_8x8(s->block[i]);
3530                     if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3531                     for(j = 0; j < 64; j++) s->block[i][j] += 128;
3532                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3533                     if(v->pq >= 9 && v->overlap) {
3534                         if(v->c_avail)
3535                             s->dsp.vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3536                         if(v->a_avail)
3537                             s->dsp.vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3538                     }
3539                 } else if(is_coded[i]) {
3540                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3541                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
3542                     first_block = 0;
3543                     if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3544                         s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3545                 }
3546             }
3547             return status;
3548         }
3549         else //Skipped MB
3550         {
3551             s->mb_intra = 0;
3552             s->current_picture.qscale_table[mb_pos] = 0;
3553             for (i=0; i<6; i++) {
3554                 v->mb_type[0][s->block_index[i]] = 0;
3555                 s->dc_val[0][s->block_index[i]] = 0;
3556             }
3557             for (i=0; i<4; i++)
3558             {
3559                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
3560                 vc1_mc_4mv_luma(v, i);
3561             }
3562             vc1_mc_4mv_chroma(v);
3563             s->current_picture.qscale_table[mb_pos] = 0;
3564             return 0;
3565         }
3566     }
3567
3568     /* Should never happen */
3569     return -1;
3570 }
3571
3572 /** Decode one B-frame MB (in Main profile)
3573  */
3574 static void vc1_decode_b_mb(VC1Context *v)
3575 {
3576     MpegEncContext *s = &v->s;
3577     GetBitContext *gb = &s->gb;
3578     int i, j;
3579     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3580     int cbp = 0; /* cbp decoding stuff */
3581     int mqdiff, mquant; /* MB quantization */
3582     int ttmb = v->ttfrm; /* MB Transform type */
3583
3584     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
3585       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
3586     int mb_has_coeffs = 0; /* last_flag */
3587     int index, index1; /* LUT indices */
3588     int val, sign; /* temp values */
3589     int first_block = 1;
3590     int dst_idx, off;
3591     int skipped, direct;
3592     int dmv_x[2], dmv_y[2];
3593     int bmvtype = BMV_TYPE_BACKWARD;
3594
3595     mquant = v->pq; /* Loosy initialization */
3596     s->mb_intra = 0;
3597
3598     if (v->dmb_is_raw)
3599         direct = get_bits1(gb);
3600     else
3601         direct = v->direct_mb_plane[mb_pos];
3602     if (v->skip_is_raw)
3603         skipped = get_bits1(gb);
3604     else
3605         skipped = v->s.mbskip_table[mb_pos];
3606
3607     s->dsp.clear_blocks(s->block[0]);
3608     dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0;
3609     for(i = 0; i < 6; i++) {
3610         v->mb_type[0][s->block_index[i]] = 0;
3611         s->dc_val[0][s->block_index[i]] = 0;
3612     }
3613     s->current_picture.qscale_table[mb_pos] = 0;
3614
3615     if (!direct) {
3616         if (!skipped) {
3617             GET_MVDATA(dmv_x[0], dmv_y[0]);
3618             dmv_x[1] = dmv_x[0];
3619             dmv_y[1] = dmv_y[0];
3620         }
3621         if(skipped || !s->mb_intra) {
3622             bmvtype = decode012(gb);
3623             switch(bmvtype) {
3624             case 0:
3625                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD;
3626                 break;
3627             case 1:
3628                 bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD;
3629                 break;
3630             case 2:
3631                 bmvtype = BMV_TYPE_INTERPOLATED;
3632                 dmv_x[0] = dmv_y[0] = 0;
3633             }
3634         }
3635     }
3636     for(i = 0; i < 6; i++)
3637         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3638
3639     if (skipped) {
3640         if(direct) bmvtype = BMV_TYPE_INTERPOLATED;
3641         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3642         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3643         return;
3644     }
3645     if (direct) {
3646         cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3647         GET_MQUANT();
3648         s->mb_intra = 0;
3649         mb_has_coeffs = 0;
3650         s->current_picture.qscale_table[mb_pos] = mquant;
3651         if(!v->ttmbf)
3652             ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3653         dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0;
3654         vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3655         vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3656     } else {
3657         if(!mb_has_coeffs && !s->mb_intra) {
3658             /* no coded blocks - effectively skipped */
3659             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3660             vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3661             return;
3662         }
3663         if(s->mb_intra && !mb_has_coeffs) {
3664             GET_MQUANT();
3665             s->current_picture.qscale_table[mb_pos] = mquant;
3666             s->ac_pred = get_bits1(gb);
3667             cbp = 0;
3668             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3669         } else {
3670             if(bmvtype == BMV_TYPE_INTERPOLATED) {
3671                 GET_MVDATA(dmv_x[0], dmv_y[0]);
3672                 if(!mb_has_coeffs) {
3673                     /* interpolated skipped block */
3674                     vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3675                     vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3676                     return;
3677                 }
3678             }
3679             vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype);
3680             if(!s->mb_intra) {
3681                 vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype);
3682             }
3683             if(s->mb_intra)
3684                 s->ac_pred = get_bits1(gb);
3685             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
3686             GET_MQUANT();
3687             s->current_picture.qscale_table[mb_pos] = mquant;
3688             if(!v->ttmbf && !s->mb_intra && mb_has_coeffs)
3689                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 2);
3690         }
3691     }
3692     dst_idx = 0;
3693     for (i=0; i<6; i++)
3694     {
3695         s->dc_val[0][s->block_index[i]] = 0;
3696         dst_idx += i >> 2;
3697         val = ((cbp >> (5 - i)) & 1);
3698         off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
3699         v->mb_type[0][s->block_index[i]] = s->mb_intra;
3700         if(s->mb_intra) {
3701             /* check if prediction blocks A and C are available */
3702             v->a_avail = v->c_avail = 0;
3703             if(i == 2 || i == 3 || !s->first_slice_line)
3704                 v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
3705             if(i == 1 || i == 3 || s->mb_x)
3706                 v->c_avail = v->mb_type[0][s->block_index[i] - 1];
3707
3708             vc1_decode_intra_block(v, s->block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
3709             if((i>3) && (s->flags & CODEC_FLAG_GRAY)) continue;
3710             s->dsp.vc1_inv_trans_8x8(s->block[i]);
3711             if(v->rangeredfrm) for(j = 0; j < 64; j++) s->block[i][j] <<= 1;
3712             for(j = 0; j < 64; j++) s->block[i][j] += 128;
3713             s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
3714         } else if(val) {
3715             vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
3716             if(!v->ttmbf && ttmb < 8) ttmb = -1;
3717             first_block = 0;
3718             if((i<4) || !(s->flags & CODEC_FLAG_GRAY))
3719                 s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
3720         }
3721     }
3722 }
3723
3724 /** Decode blocks of I-frame
3725  */
3726 static void vc1_decode_i_blocks(VC1Context *v)
3727 {
3728     int k, j;
3729     MpegEncContext *s = &v->s;
3730     int cbp, val;
3731     uint8_t *coded_val;
3732     int mb_pos;
3733
3734     /* select codingmode used for VLC tables selection */
3735     switch(v->y_ac_table_index){
3736     case 0:
3737         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3738         break;
3739     case 1:
3740         v->codingset = CS_HIGH_MOT_INTRA;
3741         break;
3742     case 2:
3743         v->codingset = CS_MID_RATE_INTRA;
3744         break;
3745     }
3746
3747     switch(v->c_ac_table_index){
3748     case 0:
3749         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3750         break;
3751     case 1:
3752         v->codingset2 = CS_HIGH_MOT_INTER;
3753         break;
3754     case 2:
3755         v->codingset2 = CS_MID_RATE_INTER;
3756         break;
3757     }
3758
3759     /* Set DC scale - y and c use the same */
3760     s->y_dc_scale = s->y_dc_scale_table[v->pq];
3761     s->c_dc_scale = s->c_dc_scale_table[v->pq];
3762
3763     //do frame decode
3764     s->mb_x = s->mb_y = 0;
3765     s->mb_intra = 1;
3766     s->first_slice_line = 1;
3767     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3768     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3769         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3770             ff_init_block_index(s);
3771             ff_update_block_index(s);
3772             s->dsp.clear_blocks(s->block[0]);
3773             mb_pos = s->mb_x + s->mb_y * s->mb_width;
3774             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3775             s->current_picture.qscale_table[mb_pos] = v->pq;
3776             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3777             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3778
3779             // do actual MB decoding and displaying
3780             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3781             v->s.ac_pred = get_bits(&v->s.gb, 1);
3782
3783             for(k = 0; k < 6; k++) {
3784                 val = ((cbp >> (5 - k)) & 1);
3785
3786                 if (k < 4) {
3787                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3788                     val = val ^ pred;
3789                     *coded_val = val;
3790                 }
3791                 cbp |= val << (5 - k);
3792
3793                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
3794
3795                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3796                 if(v->pq >= 9 && v->overlap) {
3797                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
3798                 }
3799             }
3800
3801             vc1_put_block(v, s->block);
3802             if(v->pq >= 9 && v->overlap) {
3803                 if(s->mb_x) {
3804                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3805                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3806                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3807                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3808                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3809                     }
3810                 }
3811                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3812                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3813                 if(!s->first_slice_line) {
3814                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3815                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3816                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3817                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3818                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3819                     }
3820                 }
3821                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3822                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3823             }
3824
3825             if(get_bits_count(&s->gb) > v->bits) {
3826                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3827                 return;
3828             }
3829         }
3830         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3831         s->first_slice_line = 0;
3832     }
3833 }
3834
3835 /** Decode blocks of I-frame for advanced profile
3836  */
3837 static void vc1_decode_i_blocks_adv(VC1Context *v)
3838 {
3839     int k, j;
3840     MpegEncContext *s = &v->s;
3841     int cbp, val;
3842     uint8_t *coded_val;
3843     int mb_pos;
3844     int mquant = v->pq;
3845     int mqdiff;
3846     int overlap;
3847     GetBitContext *gb = &s->gb;
3848
3849     /* select codingmode used for VLC tables selection */
3850     switch(v->y_ac_table_index){
3851     case 0:
3852         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3853         break;
3854     case 1:
3855         v->codingset = CS_HIGH_MOT_INTRA;
3856         break;
3857     case 2:
3858         v->codingset = CS_MID_RATE_INTRA;
3859         break;
3860     }
3861
3862     switch(v->c_ac_table_index){
3863     case 0:
3864         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3865         break;
3866     case 1:
3867         v->codingset2 = CS_HIGH_MOT_INTER;
3868         break;
3869     case 2:
3870         v->codingset2 = CS_MID_RATE_INTER;
3871         break;
3872     }
3873
3874     //do frame decode
3875     s->mb_x = s->mb_y = 0;
3876     s->mb_intra = 1;
3877     s->first_slice_line = 1;
3878     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3879     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3880         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3881             ff_init_block_index(s);
3882             ff_update_block_index(s);
3883             s->dsp.clear_blocks(s->block[0]);
3884             mb_pos = s->mb_x + s->mb_y * s->mb_stride;
3885             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
3886             s->current_picture.motion_val[1][s->block_index[0]][0] = 0;
3887             s->current_picture.motion_val[1][s->block_index[0]][1] = 0;
3888
3889             // do actual MB decoding and displaying
3890             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
3891             if(v->acpred_is_raw)
3892                 v->s.ac_pred = get_bits(&v->s.gb, 1);
3893             else
3894                 v->s.ac_pred = v->acpred_plane[mb_pos];
3895
3896             if(v->condover == CONDOVER_SELECT) {
3897                 if(v->overflg_is_raw)
3898                     overlap = get_bits(&v->s.gb, 1);
3899                 else
3900                     overlap = v->over_flags_plane[mb_pos];
3901             } else
3902                 overlap = (v->condover == CONDOVER_ALL);
3903
3904             GET_MQUANT();
3905
3906             s->current_picture.qscale_table[mb_pos] = mquant;
3907             /* Set DC scale - y and c use the same */
3908             s->y_dc_scale = s->y_dc_scale_table[mquant];
3909             s->c_dc_scale = s->c_dc_scale_table[mquant];
3910
3911             for(k = 0; k < 6; k++) {
3912                 val = ((cbp >> (5 - k)) & 1);
3913
3914                 if (k < 4) {
3915                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
3916                     val = val ^ pred;
3917                     *coded_val = val;
3918                 }
3919                 cbp |= val << (5 - k);
3920
3921                 v->a_avail = !s->first_slice_line || (k==2 || k==3);
3922                 v->c_avail = !!s->mb_x || (k==1 || k==3);
3923
3924                 vc1_decode_i_block_adv(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2, mquant);
3925
3926                 s->dsp.vc1_inv_trans_8x8(s->block[k]);
3927                 for(j = 0; j < 64; j++) s->block[k][j] += 128;
3928             }
3929
3930             vc1_put_block(v, s->block);
3931             if(overlap) {
3932                 if(s->mb_x) {
3933                     s->dsp.vc1_h_overlap(s->dest[0], s->linesize);
3934                     s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3935                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3936                         s->dsp.vc1_h_overlap(s->dest[1], s->uvlinesize);
3937                         s->dsp.vc1_h_overlap(s->dest[2], s->uvlinesize);
3938                     }
3939                 }
3940                 s->dsp.vc1_h_overlap(s->dest[0] + 8, s->linesize);
3941                 s->dsp.vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3942                 if(!s->first_slice_line) {
3943                     s->dsp.vc1_v_overlap(s->dest[0], s->linesize);
3944                     s->dsp.vc1_v_overlap(s->dest[0] + 8, s->linesize);
3945                     if(!(s->flags & CODEC_FLAG_GRAY)) {
3946                         s->dsp.vc1_v_overlap(s->dest[1], s->uvlinesize);
3947                         s->dsp.vc1_v_overlap(s->dest[2], s->uvlinesize);
3948                     }
3949                 }
3950                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
3951                 s->dsp.vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
3952             }
3953
3954             if(get_bits_count(&s->gb) > v->bits) {
3955                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
3956                 return;
3957             }
3958         }
3959         ff_draw_horiz_band(s, s->mb_y * 16, 16);
3960         s->first_slice_line = 0;
3961     }
3962 }
3963
3964 static void vc1_decode_p_blocks(VC1Context *v)
3965 {
3966     MpegEncContext *s = &v->s;
3967
3968     /* select codingmode used for VLC tables selection */
3969     switch(v->c_ac_table_index){
3970     case 0:
3971         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
3972         break;
3973     case 1:
3974         v->codingset = CS_HIGH_MOT_INTRA;
3975         break;
3976     case 2:
3977         v->codingset = CS_MID_RATE_INTRA;
3978         break;
3979     }
3980
3981     switch(v->c_ac_table_index){
3982     case 0:
3983         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
3984         break;
3985     case 1:
3986         v->codingset2 = CS_HIGH_MOT_INTER;
3987         break;
3988     case 2:
3989         v->codingset2 = CS_MID_RATE_INTER;
3990         break;
3991     }
3992
3993     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
3994     s->first_slice_line = 1;
3995     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
3996         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
3997             ff_init_block_index(s);
3998             ff_update_block_index(s);
3999             s->dsp.clear_blocks(s->block[0]);
4000
4001             vc1_decode_p_mb(v);
4002             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4003                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
4004                 return;
4005             }
4006         }
4007         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4008         s->first_slice_line = 0;
4009     }
4010 }
4011
4012 static void vc1_decode_b_blocks(VC1Context *v)
4013 {
4014     MpegEncContext *s = &v->s;
4015
4016     /* select codingmode used for VLC tables selection */
4017     switch(v->c_ac_table_index){
4018     case 0:
4019         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
4020         break;
4021     case 1:
4022         v->codingset = CS_HIGH_MOT_INTRA;
4023         break;
4024     case 2:
4025         v->codingset = CS_MID_RATE_INTRA;
4026         break;
4027     }
4028
4029     switch(v->c_ac_table_index){
4030     case 0:
4031         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
4032         break;
4033     case 1:
4034         v->codingset2 = CS_HIGH_MOT_INTER;
4035         break;
4036     case 2:
4037         v->codingset2 = CS_MID_RATE_INTER;
4038         break;
4039     }
4040
4041     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4042     s->first_slice_line = 1;
4043     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4044         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
4045             ff_init_block_index(s);
4046             ff_update_block_index(s);
4047             s->dsp.clear_blocks(s->block[0]);
4048
4049             vc1_decode_b_mb(v);
4050             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
4051                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", get_bits_count(&s->gb), v->bits,s->mb_x,s->mb_y);
4052                 return;
4053             }
4054         }
4055         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4056         s->first_slice_line = 0;
4057     }
4058 }
4059
4060 static void vc1_decode_skip_blocks(VC1Context *v)
4061 {
4062     MpegEncContext *s = &v->s;
4063
4064     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
4065     s->first_slice_line = 1;
4066     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
4067         s->mb_x = 0;
4068         ff_init_block_index(s);
4069         ff_update_block_index(s);
4070         memcpy(s->dest[0], s->last_picture.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16);
4071         memcpy(s->dest[1], s->last_picture.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4072         memcpy(s->dest[2], s->last_picture.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8);
4073         ff_draw_horiz_band(s, s->mb_y * 16, 16);
4074         s->first_slice_line = 0;
4075     }
4076     s->pict_type = P_TYPE;
4077 }
4078
4079 static void vc1_decode_blocks(VC1Context *v)
4080 {
4081
4082     v->s.esc3_level_length = 0;
4083
4084     switch(v->s.pict_type) {
4085     case I_TYPE:
4086         if(v->profile == PROFILE_ADVANCED)
4087             vc1_decode_i_blocks_adv(v);
4088         else
4089             vc1_decode_i_blocks(v);
4090         break;
4091     case P_TYPE:
4092         if(v->p_frame_skipped)
4093             vc1_decode_skip_blocks(v);
4094         else
4095             vc1_decode_p_blocks(v);
4096         break;
4097     case B_TYPE:
4098         if(v->bi_type){
4099             if(v->profile == PROFILE_ADVANCED)
4100                 vc1_decode_i_blocks_adv(v);
4101             else
4102                 vc1_decode_i_blocks(v);
4103         }else
4104             vc1_decode_b_blocks(v);
4105         break;
4106     }
4107 }
4108
4109 #define IS_MARKER(x) (((x) & ~0xFF) == VC1_CODE_RES0)
4110
4111 /** Find VC-1 marker in buffer
4112  * @return position where next marker starts or end of buffer if no marker found
4113  */
4114 static av_always_inline uint8_t* find_next_marker(uint8_t *src, uint8_t *end)
4115 {
4116     uint32_t mrk = 0xFFFFFFFF;
4117
4118     if(end-src < 4) return end;
4119     while(src < end){
4120         mrk = (mrk << 8) | *src++;
4121         if(IS_MARKER(mrk))
4122             return src-4;
4123     }
4124     return end;
4125 }
4126
4127 static av_always_inline int vc1_unescape_buffer(uint8_t *src, int size, uint8_t *dst)
4128 {
4129     int dsize = 0, i;
4130
4131     if(size < 4){
4132         for(dsize = 0; dsize < size; dsize++) *dst++ = *src++;
4133         return size;
4134     }
4135     for(i = 0; i < size; i++, src++) {
4136         if(src[0] == 3 && i >= 2 && !src[-1] && !src[-2] && i < size-1 && src[1] < 4) {
4137             dst[dsize++] = src[1];
4138             src++;
4139             i++;
4140         } else
4141             dst[dsize++] = *src;
4142     }
4143     return dsize;
4144 }
4145
4146 /** Initialize a VC1/WMV3 decoder
4147  * @todo TODO: Handle VC-1 IDUs (Transport level?)
4148  * @todo TODO: Decypher remaining bits in extra_data
4149  */
4150 static int vc1_decode_init(AVCodecContext *avctx)
4151 {
4152     VC1Context *v = avctx->priv_data;
4153     MpegEncContext *s = &v->s;
4154     GetBitContext gb;
4155
4156     if (!avctx->extradata_size || !avctx->extradata) return -1;
4157     if (!(avctx->flags & CODEC_FLAG_GRAY))
4158         avctx->pix_fmt = PIX_FMT_YUV420P;
4159     else
4160         avctx->pix_fmt = PIX_FMT_GRAY8;
4161     v->s.avctx = avctx;
4162     avctx->flags |= CODEC_FLAG_EMU_EDGE;
4163     v->s.flags |= CODEC_FLAG_EMU_EDGE;
4164
4165     if(ff_h263_decode_init(avctx) < 0)
4166         return -1;
4167     if (vc1_init_common(v) < 0) return -1;
4168
4169     avctx->coded_width = avctx->width;
4170     avctx->coded_height = avctx->height;
4171     if (avctx->codec_id == CODEC_ID_WMV3)
4172     {
4173         int count = 0;
4174
4175         // looks like WMV3 has a sequence header stored in the extradata
4176         // advanced sequence header may be before the first frame
4177         // the last byte of the extradata is a version number, 1 for the
4178         // samples we can decode
4179
4180         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
4181
4182         if (decode_sequence_header(avctx, &gb) < 0)
4183           return -1;
4184
4185         count = avctx->extradata_size*8 - get_bits_count(&gb);
4186         if (count>0)
4187         {
4188             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
4189                    count, get_bits(&gb, count));
4190         }
4191         else if (count < 0)
4192         {
4193             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
4194         }
4195     } else { // VC1/WVC1
4196         uint8_t *start = avctx->extradata, *end = avctx->extradata + avctx->extradata_size;
4197         uint8_t *next; int size, buf2_size;
4198         uint8_t *buf2 = NULL;
4199         int seq_inited = 0, ep_inited = 0;
4200
4201         if(avctx->extradata_size < 16) {
4202             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
4203             return -1;
4204         }
4205
4206         buf2 = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
4207         if(start[0]) start++; // in WVC1 extradata first byte is its size
4208         next = start;
4209         for(; next < end; start = next){
4210             next = find_next_marker(start + 4, end);
4211             size = next - start - 4;
4212             if(size <= 0) continue;
4213             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
4214             init_get_bits(&gb, buf2, buf2_size * 8);
4215             switch(AV_RB32(start)){
4216             case VC1_CODE_SEQHDR:
4217                 if(decode_sequence_header(avctx, &gb) < 0){
4218                     av_free(buf2);
4219                     return -1;
4220                 }
4221                 seq_inited = 1;
4222                 break;
4223             case VC1_CODE_ENTRYPOINT:
4224                 if(decode_entry_point(avctx, &gb) < 0){
4225                     av_free(buf2);
4226                     return -1;
4227                 }
4228                 ep_inited = 1;
4229                 break;
4230             }
4231         }
4232         av_free(buf2);
4233         if(!seq_inited || !ep_inited){
4234             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
4235             return -1;
4236         }
4237     }
4238     avctx->has_b_frames= !!(avctx->max_b_frames);
4239     s->low_delay = !avctx->has_b_frames;
4240
4241     s->mb_width = (avctx->coded_width+15)>>4;
4242     s->mb_height = (avctx->coded_height+15)>>4;
4243
4244     /* Allocate mb bitplanes */
4245     v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4246     v->direct_mb_plane = av_malloc(s->mb_stride * s->mb_height);
4247     v->acpred_plane = av_malloc(s->mb_stride * s->mb_height);
4248     v->over_flags_plane = av_malloc(s->mb_stride * s->mb_height);
4249
4250     /* allocate block type info in that way so it could be used with s->block_index[] */
4251     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
4252     v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
4253     v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
4254     v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
4255
4256     /* Init coded blocks info */
4257     if (v->profile == PROFILE_ADVANCED)
4258     {
4259 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
4260 //            return -1;
4261 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
4262 //            return -1;
4263     }
4264
4265     return 0;
4266 }
4267
4268
4269 /** Decode a VC1/WMV3 frame
4270  * @todo TODO: Handle VC-1 IDUs (Transport level?)
4271  */
4272 static int vc1_decode_frame(AVCodecContext *avctx,
4273                             void *data, int *data_size,
4274                             uint8_t *buf, int buf_size)
4275 {
4276     VC1Context *v = avctx->priv_data;
4277     MpegEncContext *s = &v->s;
4278     AVFrame *pict = data;
4279     uint8_t *buf2 = NULL;
4280
4281     /* no supplementary picture */
4282     if (buf_size == 0) {
4283         /* special case for last picture */
4284         if (s->low_delay==0 && s->next_picture_ptr) {
4285             *pict= *(AVFrame*)s->next_picture_ptr;
4286             s->next_picture_ptr= NULL;
4287
4288             *data_size = sizeof(AVFrame);
4289         }
4290
4291         return 0;
4292     }
4293
4294     //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
4295     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
4296         int i= ff_find_unused_picture(s, 0);
4297         s->current_picture_ptr= &s->picture[i];
4298     }
4299
4300     //for advanced profile we may need to parse and unescape data
4301     if (avctx->codec_id == CODEC_ID_VC1) {
4302         int buf_size2 = 0;
4303         buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
4304
4305         if(IS_MARKER(AV_RB32(buf))){ /* frame starts with marker and needs to be parsed */
4306             uint8_t *dst = buf2, *start, *end, *next;
4307             int size;
4308
4309             next = buf;
4310             for(start = buf, end = buf + buf_size; next < end; start = next){
4311                 next = find_next_marker(start + 4, end);
4312                 size = next - start - 4;
4313                 if(size <= 0) continue;
4314                 switch(AV_RB32(start)){
4315                 case VC1_CODE_FRAME:
4316                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
4317                     break;
4318                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
4319                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
4320                     init_get_bits(&s->gb, buf2, buf_size2*8);
4321                     decode_entry_point(avctx, &s->gb);
4322                     break;
4323                 case VC1_CODE_SLICE:
4324                     av_log(avctx, AV_LOG_ERROR, "Sliced decoding is not implemented (yet)\n");
4325                     av_free(buf2);
4326                     return -1;
4327                 }
4328             }
4329         }else if(v->interlace && ((buf[0] & 0xC0) == 0xC0)){ /* WVC1 interlaced stores both fields divided by marker */
4330             uint8_t *divider;
4331
4332             divider = find_next_marker(buf, buf + buf_size);
4333             if((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD){
4334                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
4335                 return -1;
4336             }
4337
4338             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
4339             // TODO
4340             av_free(buf2);return -1;
4341         }else{
4342             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
4343         }
4344         init_get_bits(&s->gb, buf2, buf_size2*8);
4345     } else
4346         init_get_bits(&s->gb, buf, buf_size*8);
4347     // do parse frame header
4348     if(v->profile < PROFILE_ADVANCED) {
4349         if(vc1_parse_frame_header(v, &s->gb) == -1) {
4350             av_free(buf2);
4351             return -1;
4352         }
4353     } else {
4354         if(vc1_parse_frame_header_adv(v, &s->gb) == -1) {
4355             av_free(buf2);
4356             return -1;
4357         }
4358     }
4359
4360     if(s->pict_type != I_TYPE && !v->res_rtm_flag){
4361         av_free(buf2);
4362         return -1;
4363     }
4364
4365     // for hurry_up==5
4366     s->current_picture.pict_type= s->pict_type;
4367     s->current_picture.key_frame= s->pict_type == I_TYPE;
4368
4369     /* skip B-frames if we don't have reference frames */
4370     if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)){
4371         av_free(buf2);
4372         return -1;//buf_size;
4373     }
4374     /* skip b frames if we are in a hurry */
4375     if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
4376     if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
4377        || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
4378        ||  avctx->skip_frame >= AVDISCARD_ALL) {
4379         av_free(buf2);
4380         return buf_size;
4381     }
4382     /* skip everything if we are in a hurry>=5 */
4383     if(avctx->hurry_up>=5) {
4384         av_free(buf2);
4385         return -1;//buf_size;
4386     }
4387
4388     if(s->next_p_frame_damaged){
4389         if(s->pict_type==B_TYPE)
4390             return buf_size;
4391         else
4392             s->next_p_frame_damaged=0;
4393     }
4394
4395     if(MPV_frame_start(s, avctx) < 0) {
4396         av_free(buf2);
4397         return -1;
4398     }
4399
4400     ff_er_frame_start(s);
4401
4402     v->bits = buf_size * 8;
4403     vc1_decode_blocks(v);
4404 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
4405 //  if(get_bits_count(&s->gb) > buf_size * 8)
4406 //      return -1;
4407     ff_er_frame_end(s);
4408
4409     MPV_frame_end(s);
4410
4411 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
4412 assert(s->current_picture.pict_type == s->pict_type);
4413     if (s->pict_type == B_TYPE || s->low_delay) {
4414         *pict= *(AVFrame*)s->current_picture_ptr;
4415     } else if (s->last_picture_ptr != NULL) {
4416         *pict= *(AVFrame*)s->last_picture_ptr;
4417     }
4418
4419     if(s->last_picture_ptr || s->low_delay){
4420         *data_size = sizeof(AVFrame);
4421         ff_print_debug_info(s, pict);
4422     }
4423
4424     /* Return the Picture timestamp as the frame number */
4425     /* we substract 1 because it is added on utils.c    */
4426     avctx->frame_number = s->picture_number - 1;
4427
4428     av_free(buf2);
4429     return buf_size;
4430 }
4431
4432
4433 /** Close a VC1/WMV3 decoder
4434  * @warning Initial try at using MpegEncContext stuff
4435  */
4436 static int vc1_decode_end(AVCodecContext *avctx)
4437 {
4438     VC1Context *v = avctx->priv_data;
4439
4440     av_freep(&v->hrd_rate);
4441     av_freep(&v->hrd_buffer);
4442     MPV_common_end(&v->s);
4443     av_freep(&v->mv_type_mb_plane);
4444     av_freep(&v->direct_mb_plane);
4445     av_freep(&v->acpred_plane);
4446     av_freep(&v->over_flags_plane);
4447     av_freep(&v->mb_type_base);
4448     return 0;
4449 }
4450
4451
4452 AVCodec vc1_decoder = {
4453     "vc1",
4454     CODEC_TYPE_VIDEO,
4455     CODEC_ID_VC1,
4456     sizeof(VC1Context),
4457     vc1_decode_init,
4458     NULL,
4459     vc1_decode_end,
4460     vc1_decode_frame,
4461     CODEC_CAP_DELAY,
4462     NULL
4463 };
4464
4465 AVCodec wmv3_decoder = {
4466     "wmv3",
4467     CODEC_TYPE_VIDEO,
4468     CODEC_ID_WMV3,
4469     sizeof(VC1Context),
4470     vc1_decode_init,
4471     NULL,
4472     vc1_decode_end,
4473     vc1_decode_frame,
4474     CODEC_CAP_DELAY,
4475     NULL
4476 };
4477
4478 #ifdef CONFIG_VC1_PARSER
4479 /**
4480  * finds the end of the current frame in the bitstream.
4481  * @return the position of the first byte of the next frame, or -1
4482  */
4483 static int vc1_find_frame_end(ParseContext *pc, const uint8_t *buf,
4484                                int buf_size) {
4485     int pic_found, i;
4486     uint32_t state;
4487
4488     pic_found= pc->frame_start_found;
4489     state= pc->state;
4490
4491     i=0;
4492     if(!pic_found){
4493         for(i=0; i<buf_size; i++){
4494             state= (state<<8) | buf[i];
4495             if(state == VC1_CODE_FRAME || state == VC1_CODE_FIELD){
4496                 i++;
4497                 pic_found=1;
4498                 break;
4499             }
4500         }
4501     }
4502
4503     if(pic_found){
4504         /* EOF considered as end of frame */
4505         if (buf_size == 0)
4506             return 0;
4507         for(; i<buf_size; i++){
4508             state= (state<<8) | buf[i];
4509             if(IS_MARKER(state) && state != VC1_CODE_FIELD && state != VC1_CODE_SLICE){
4510                 pc->frame_start_found=0;
4511                 pc->state=-1;
4512                 return i-3;
4513             }
4514         }
4515     }
4516     pc->frame_start_found= pic_found;
4517     pc->state= state;
4518     return END_NOT_FOUND;
4519 }
4520
4521 static int vc1_parse(AVCodecParserContext *s,
4522                            AVCodecContext *avctx,
4523                            uint8_t **poutbuf, int *poutbuf_size,
4524                            const uint8_t *buf, int buf_size)
4525 {
4526     ParseContext *pc = s->priv_data;
4527     int next;
4528
4529     if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
4530         next= buf_size;
4531     }else{
4532         next= vc1_find_frame_end(pc, buf, buf_size);
4533
4534         if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
4535             *poutbuf = NULL;
4536             *poutbuf_size = 0;
4537             return buf_size;
4538         }
4539     }
4540     *poutbuf = (uint8_t *)buf;
4541     *poutbuf_size = buf_size;
4542     return next;
4543 }
4544
4545 int vc1_split(AVCodecContext *avctx,
4546                            const uint8_t *buf, int buf_size)
4547 {
4548     int i;
4549     uint32_t state= -1;
4550
4551     for(i=0; i<buf_size; i++){
4552         state= (state<<8) | buf[i];
4553         if(IS_MARKER(state) && state != VC1_CODE_SEQHDR && state != VC1_CODE_ENTRYPOINT)
4554             return i-3;
4555     }
4556     return 0;
4557 }
4558
4559 AVCodecParser vc1_parser = {
4560     { CODEC_ID_VC1 },
4561     sizeof(ParseContext1),
4562     NULL,
4563     vc1_parse,
4564     ff_parse1_close,
4565     vc1_split,
4566 };
4567 #endif /* CONFIG_VC1_PARSER */