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

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