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

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