libavcodec/vc1.c

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