libavcodec/vc1.c

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