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