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