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 = 3 //XXX: ??
 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 /** The VC1 Context
 213  * @fixme Change size wherever another size is more efficient
 214  * Many members are only used for Advanced Profile
 215  */
 216 typedef struct VC1Context{
 217     MpegEncContext s;
 218
 219     int bits;
 220
 221     /** Simple/Main Profile sequence header */
 222     //@{
 223     int res_sm;           ///< reserved, 2b
 224     int res_x8;           ///< reserved
 225     int multires;         ///< frame-level RESPIC syntax element present
 226     int res_fasttx;       ///< reserved, always 1
 227     int res_transtab;     ///< reserved, always 0
 228     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
 229                           ///< at frame level
 230     int res_rtm_flag;     ///< reserved, set to 1
 231     int reserved;         ///< reserved
 232     //@}
 233
 234     /** Advanced Profile */
 235     //@{
 236     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
 237     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
 238     int postprocflag;     ///< Per-frame processing suggestion flag present
 239     int broadcast;        ///< TFF/RFF present
 240     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
 241     int tfcntrflag;       ///< TFCNTR present
 242     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
 243     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
 244     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
 245     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
 246     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
 247     int hrd_param_flag;   ///< Presence of Hypothetical Reference
 248                           ///< Decoder parameters
 249     //@}
 250
 251     /** Sequence header data for all Profiles
 252      * TODO: choose between ints, uint8_ts and monobit flags
 253      */
 254     //@{
 255     int profile;          ///< 2bits, Profile
 256     int frmrtq_postproc;  ///< 3bits,
 257     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
 258     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
 259     int extended_mv;      ///< Ext MV in P/B (not in Simple)
 260     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
 261     int vstransform;      ///< variable-size [48]x[48] transform type + info
 262     int overlap;          ///< overlapped transforms in use
 263     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
 264     int finterpflag;      ///< INTERPFRM present
 265     //@}
 266
 267     /** Frame decoding info for all profiles */
 268     //@{
 269     uint8_t mv_mode;      ///< MV coding monde
 270     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
 271     int k_x;              ///< Number of bits for MVs (depends on MV range)
 272     int k_y;              ///< Number of bits for MVs (depends on MV range)
 273     int range_x, range_y; ///< MV range
 274     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
 275     /** pquant parameters */
 276     //@{
 277     uint8_t dquantfrm;
 278     uint8_t dqprofile;
 279     uint8_t dqsbedge;
 280     uint8_t dqbilevel;
 281     //@}
 282     /** AC coding set indexes
 283      * @see 8.1.1.10, p(1)10
 284      */
 285     //@{
 286     int c_ac_table_index; ///< Chroma index from ACFRM element
 287     int y_ac_table_index; ///< Luma index from AC2FRM element
 288     //@}
 289     int ttfrm;            ///< Transform type info present at frame level
 290     uint8_t ttmbf;        ///< Transform type flag
 291     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
 292     int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
 293     int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
 294     int pqindex;          ///< raw pqindex used in coding set selection
 295     int a_avail, c_avail;
 296     uint8_t *mb_type_base, *mb_type[3];
 297
 298
 299     /** Luma compensation parameters */
 300     //@{
 301     uint8_t lumscale;
 302     uint8_t lumshift;
 303     //@}
 304     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
 305     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
 306     uint8_t respic;       ///< Frame-level flag for resized images
 307     int buffer_fullness;  ///< HRD info
 308     /** Ranges:
 309      * -# 0 -> [-64n 63.f] x [-32, 31.f]
 310      * -# 1 -> [-128, 127.f] x [-64, 63.f]
 311      * -# 2 -> [-512, 511.f] x [-128, 127.f]
 312      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
 313      */
 314     uint8_t mvrange;
 315     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
 316     VLC *cbpcy_vlc;               ///< CBPCY VLC table
 317     int tt_index;                 ///< Index for Transform Type tables
 318     uint8_t* mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
 319 //    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
 320     int mv_type_is_raw;           ///< mv type mb plane is not coded
 321     int skip_is_raw;              ///< skip mb plane is not coded
 322     uint8_t luty[256], lutuv[256]; // lookup tables used for intensity compensation
 323
 324     /** Frame decoding info for S/M profiles only */
 325     //@{
 326     uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
 327     uint8_t interpfrm;
 328     //@}
 329
 330     /** Frame decoding info for Advanced profile */
 331     //@{
 332     uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
 333     uint8_t numpanscanwin;
 334     uint8_t tfcntr;
 335     uint8_t rptfrm, tff, rff;
 336     uint16_t topleftx;
 337     uint16_t toplefty;
 338     uint16_t bottomrightx;
 339     uint16_t bottomrighty;
 340     uint8_t uvsamp;
 341     uint8_t postproc;
 342     int hrd_num_leaky_buckets;
 343     uint8_t bit_rate_exponent;
 344     uint8_t buffer_size_exponent;
 345 //    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
 346 //    BitPlane over_flags_plane;    ///< Overflags bitplane
 347     uint8_t condover;
 348     uint16_t *hrd_rate, *hrd_buffer;
 349     uint8_t *hrd_fullness;
 350     uint8_t range_mapy_flag;
 351     uint8_t range_mapuv_flag;
 352     uint8_t range_mapy;
 353     uint8_t range_mapuv;
 354     //@}
 355 } VC1Context;
 356
 357 /**
 358  * Get unary code of limited length
 359  * @fixme FIXME Slow and ugly
 360  * @param gb GetBitContext
 361  * @param[in] stop The bitstop value (unary code of 1's or 0's)
 362  * @param[in] len Maximum length
 363  * @return Unary length/index
 364  */
 365 static int get_prefix(GetBitContext *gb, int stop, int len)
 366 {
 367 #if 1
 368     int i;
 369
 370     for(i = 0; i < len && get_bits1(gb) != stop; i++);
 371     return i;
 372 /*  int i = 0, tmp = !stop;
 373
 374   while (i != len && tmp != stop)
 375   {
 376     tmp = get_bits(gb, 1);
 377     i++;
 378   }
 379   if (i == len && tmp != stop) return len+1;
 380   return i;*/
 381 #else
 382   unsigned int buf;
 383   int log;
 384
 385   OPEN_READER(re, gb);
 386   UPDATE_CACHE(re, gb);
 387   buf=GET_CACHE(re, gb); //Still not sure
 388   if (stop) buf = ~buf;
 389
 390   log= av_log2(-buf); //FIXME: -?
 391   if (log < limit){
 392     LAST_SKIP_BITS(re, gb, log+1);
 393     CLOSE_READER(re, gb);
 394     return log;
 395   }
 396
 397   LAST_SKIP_BITS(re, gb, limit);
 398   CLOSE_READER(re, gb);
 399   return limit;
 400 #endif
 401 }
 402
 403 static inline int decode210(GetBitContext *gb){
 404     int n;
 405     n = get_bits1(gb);
 406     if (n == 1)
 407         return 0;
 408     else
 409         return 2 - get_bits1(gb);
 410 }
 411
 412 /**
 413  * Init VC-1 specific tables and VC1Context members
 414  * @param v The VC1Context to initialize
 415  * @return Status
 416  */
 417 static int vc1_init_common(VC1Context *v)
 418 {
 419     static int done = 0;
 420     int i = 0;
 421
 422     v->hrd_rate = v->hrd_buffer = NULL;
 423
 424     /* VLC tables */
 425     if(!done)
 426     {
 427         done = 1;
 428         init_vlc(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,
 429                  vc1_bfraction_bits, 1, 1,
 430                  vc1_bfraction_codes, 1, 1, 1);
 431         init_vlc(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,
 432                  vc1_norm2_bits, 1, 1,
 433                  vc1_norm2_codes, 1, 1, 1);
 434         init_vlc(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,
 435                  vc1_norm6_bits, 1, 1,
 436                  vc1_norm6_codes, 2, 2, 1);
 437         init_vlc(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,
 438                  vc1_imode_bits, 1, 1,
 439                  vc1_imode_codes, 1, 1, 1);
 440         for (i=0; i<3; i++)
 441         {
 442             init_vlc(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,
 443                      vc1_ttmb_bits[i], 1, 1,
 444                      vc1_ttmb_codes[i], 2, 2, 1);
 445             init_vlc(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,
 446                      vc1_ttblk_bits[i], 1, 1,
 447                      vc1_ttblk_codes[i], 1, 1, 1);
 448             init_vlc(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,
 449                      vc1_subblkpat_bits[i], 1, 1,
 450                      vc1_subblkpat_codes[i], 1, 1, 1);
 451         }
 452         for(i=0; i<4; i++)
 453         {
 454             init_vlc(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,
 455                      vc1_4mv_block_pattern_bits[i], 1, 1,
 456                      vc1_4mv_block_pattern_codes[i], 1, 1, 1);
 457             init_vlc(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,
 458                      vc1_cbpcy_p_bits[i], 1, 1,
 459                      vc1_cbpcy_p_codes[i], 2, 2, 1);
 460             init_vlc(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,
 461                      vc1_mv_diff_bits[i], 1, 1,
 462                      vc1_mv_diff_codes[i], 2, 2, 1);
 463         }
 464         for(i=0; i<8; i++)
 465             init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
 466                      &vc1_ac_tables[i][0][1], 8, 4,
 467                      &vc1_ac_tables[i][0][0], 8, 4, 1);
 468         init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64,
 469                  &ff_msmp4_mb_i_table[0][1], 4, 2,
 470                  &ff_msmp4_mb_i_table[0][0], 4, 2, 1);
 471     }
 472
 473     /* Other defaults */
 474     v->pq = -1;
 475     v->mvrange = 0; /* 7.1.1.18, p80 */
 476
 477     return 0;
 478 }
 479
 480 /***********************************************************************/
 481 /**
 482  * @defgroup bitplane VC9 Bitplane decoding
 483  * @see 8.7, p56
 484  * @{
 485  */
 486
 487 /** @addtogroup bitplane
 488  * Imode types
 489  * @{
 490  */
 491 enum Imode {
 492     IMODE_RAW,
 493     IMODE_NORM2,
 494     IMODE_DIFF2,
 495     IMODE_NORM6,
 496     IMODE_DIFF6,
 497     IMODE_ROWSKIP,
 498     IMODE_COLSKIP
 499 };
 500 /** @} */ //imode defines
 501
 502 /** Decode rows by checking if they are skipped
 503  * @param plane Buffer to store decoded bits
 504  * @param[in] width Width of this buffer
 505  * @param[in] height Height of this buffer
 506  * @param[in] stride of this buffer
 507  */
 508 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 509     int x, y;
 510
 511     for (y=0; y<height; y++){
 512         if (!get_bits(gb, 1)) //rowskip
 513             memset(plane, 0, width);
 514         else
 515             for (x=0; x<width; x++)
 516                 plane[x] = get_bits(gb, 1);
 517         plane += stride;
 518     }
 519 }
 520
 521 /** Decode columns 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  * @fixme FIXME: Optimize
 527  */
 528 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 529     int x, y;
 530
 531     for (x=0; x<width; x++){
 532         if (!get_bits(gb, 1)) //colskip
 533             for (y=0; y<height; y++)
 534                 plane[y*stride] = 0;
 535         else
 536             for (y=0; y<height; y++)
 537                 plane[y*stride] = get_bits(gb, 1);
 538         plane ++;
 539     }
 540 }
 541
 542 /** Decode a bitplane's bits
 543  * @param bp Bitplane where to store the decode bits
 544  * @param v VC-1 context for bit reading and logging
 545  * @return Status
 546  * @fixme FIXME: Optimize
 547  * @todo TODO: Decide if a struct is needed
 548  */
 549 static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)
 550 {
 551     GetBitContext *gb = &v->s.gb;
 552
 553     int imode, x, y, code, offset;
 554     uint8_t invert, *planep = data;
 555     int width, height, stride;
 556
 557     width = v->s.mb_width;
 558     height = v->s.mb_height;
 559     stride = v->s.mb_stride;
 560     invert = get_bits(gb, 1);
 561     imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
 562
 563     *raw_flag = 0;
 564     switch (imode)
 565     {
 566     case IMODE_RAW:
 567         //Data is actually read in the MB layer (same for all tests == "raw")
 568         *raw_flag = 1; //invert ignored
 569         return invert;
 570     case IMODE_DIFF2:
 571     case IMODE_NORM2:
 572         if ((height * width) & 1)
 573         {
 574             *planep++ = get_bits(gb, 1);
 575             offset = 1;
 576         }
 577         else offset = 0;
 578         // decode bitplane as one long line
 579         for (y = offset; y < height * width; y += 2) {
 580             code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
 581             *planep++ = code & 1;
 582             offset++;
 583             if(offset == width) {
 584                 offset = 0;
 585                 planep += stride - width;
 586             }
 587             *planep++ = code >> 1;
 588             offset++;
 589             if(offset == width) {
 590                 offset = 0;
 591                 planep += stride - width;
 592             }
 593         }
 594         break;
 595     case IMODE_DIFF6:
 596     case IMODE_NORM6:
 597         if(!(height % 3) && (width % 3)) { // use 2x3 decoding
 598             for(y = 0; y < height; y+= 3) {
 599                 for(x = width & 1; x < width; x += 2) {
 600                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 601                     if(code < 0){
 602                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 603                         return -1;
 604                     }
 605                     planep[x + 0] = (code >> 0) & 1;
 606                     planep[x + 1] = (code >> 1) & 1;
 607                     planep[x + 0 + stride] = (code >> 2) & 1;
 608                     planep[x + 1 + stride] = (code >> 3) & 1;
 609                     planep[x + 0 + stride * 2] = (code >> 4) & 1;
 610                     planep[x + 1 + stride * 2] = (code >> 5) & 1;
 611                 }
 612                 planep += stride * 3;
 613             }
 614             if(width & 1) decode_colskip(data, 1, height, stride, &v->s.gb);
 615         } else { // 3x2
 616             planep += (height & 1) * stride;
 617             for(y = height & 1; y < height; y += 2) {
 618                 for(x = width % 3; x < width; x += 3) {
 619                     code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);
 620                     if(code < 0){
 621                         av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
 622                         return -1;
 623                     }
 624                     planep[x + 0] = (code >> 0) & 1;
 625                     planep[x + 1] = (code >> 1) & 1;
 626                     planep[x + 2] = (code >> 2) & 1;
 627                     planep[x + 0 + stride] = (code >> 3) & 1;
 628                     planep[x + 1 + stride] = (code >> 4) & 1;
 629                     planep[x + 2 + stride] = (code >> 5) & 1;
 630                 }
 631                 planep += stride * 2;
 632             }
 633             x = width % 3;
 634             if(x) decode_colskip(data  ,             x, height    , stride, &v->s.gb);
 635             if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);
 636         }
 637         break;
 638     case IMODE_ROWSKIP:
 639         decode_rowskip(data, width, height, stride, &v->s.gb);
 640         break;
 641     case IMODE_COLSKIP:
 642         decode_colskip(data, width, height, stride, &v->s.gb);
 643         break;
 644     default: break;
 645     }
 646
 647     /* Applying diff operator */
 648     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
 649     {
 650         planep = data;
 651         planep[0] ^= invert;
 652         for (x=1; x<width; x++)
 653             planep[x] ^= planep[x-1];
 654         for (y=1; y<height; y++)
 655         {
 656             planep += stride;
 657             planep[0] ^= planep[-stride];
 658             for (x=1; x<width; x++)
 659             {
 660                 if (planep[x-1] != planep[x-stride]) planep[x] ^= invert;
 661                 else                                 planep[x] ^= planep[x-1];
 662             }
 663         }
 664     }
 665     else if (invert)
 666     {
 667         planep = data;
 668         for (x=0; x<stride*height; x++) planep[x] = !planep[x]; //FIXME stride
 669     }
 670     return (imode<<1) + invert;
 671 }
 672
 673 /** @} */ //Bitplane group
 674
 675 /***********************************************************************/
 676 /** VOP Dquant decoding
 677  * @param v VC-1 Context
 678  */
 679 static int vop_dquant_decoding(VC1Context *v)
 680 {
 681     GetBitContext *gb = &v->s.gb;
 682     int pqdiff;
 683
 684     //variable size
 685     if (v->dquant == 2)
 686     {
 687         pqdiff = get_bits(gb, 3);
 688         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
 689         else v->altpq = v->pq + pqdiff + 1;
 690     }
 691     else
 692     {
 693         v->dquantfrm = get_bits(gb, 1);
 694         if ( v->dquantfrm )
 695         {
 696             v->dqprofile = get_bits(gb, 2);
 697             switch (v->dqprofile)
 698             {
 699             case DQPROFILE_SINGLE_EDGE:
 700             case DQPROFILE_DOUBLE_EDGES:
 701                 v->dqsbedge = get_bits(gb, 2);
 702                 break;
 703             case DQPROFILE_ALL_MBS:
 704                 v->dqbilevel = get_bits(gb, 1);
 705             default: break; //Forbidden ?
 706             }
 707             if (v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
 708             {
 709                 pqdiff = get_bits(gb, 3);
 710                 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
 711                 else v->altpq = v->pq + pqdiff + 1;
 712             }
 713         }
 714     }
 715     return 0;
 716 }
 717
 718
 719 /** Do inverse transform
 720  */
 721 static void vc1_inv_trans(DCTELEM block[64], int M, int N)
 722 {
 723     int i;
 724     register int t1,t2,t3,t4,t5,t6,t7,t8;
 725     DCTELEM *src, *dst;
 726
 727     src = block;
 728     dst = block;
 729     if(M==4){
 730         for(i = 0; i < N; i++){
 731             t1 = 17 * (src[0] + src[2]);
 732             t2 = 17 * (src[0] - src[2]);
 733             t3 = 22 * src[1];
 734             t4 = 22 * src[3];
 735             t5 = 10 * src[1];
 736             t6 = 10 * src[3];
 737
 738             dst[0] = (t1 + t3 + t6 + 4) >> 3;
 739             dst[1] = (t2 - t4 + t5 + 4) >> 3;
 740             dst[2] = (t2 + t4 - t5 + 4) >> 3;
 741             dst[3] = (t1 - t3 - t6 + 4) >> 3;
 742
 743             src += 8;
 744             dst += 8;
 745         }
 746     }else{
 747         for(i = 0; i < N; i++){
 748             t1 = 12 * (src[0] + src[4]);
 749             t2 = 12 * (src[0] - src[4]);
 750             t3 = 16 * src[2] +  6 * src[6];
 751             t4 =  6 * src[2] - 16 * src[6];
 752
 753             t5 = t1 + t3;
 754             t6 = t2 + t4;
 755             t7 = t2 - t4;
 756             t8 = t1 - t3;
 757
 758             t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
 759             t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
 760             t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
 761             t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
 762
 763             dst[0] = (t5 + t1 + 4) >> 3;
 764             dst[1] = (t6 + t2 + 4) >> 3;
 765             dst[2] = (t7 + t3 + 4) >> 3;
 766             dst[3] = (t8 + t4 + 4) >> 3;
 767             dst[4] = (t8 - t4 + 4) >> 3;
 768             dst[5] = (t7 - t3 + 4) >> 3;
 769             dst[6] = (t6 - t2 + 4) >> 3;
 770             dst[7] = (t5 - t1 + 4) >> 3;
 771
 772             src += 8;
 773             dst += 8;
 774         }
 775     }
 776
 777     src = block;
 778     dst = block;
 779     if(N==4){
 780         for(i = 0; i < M; i++){
 781             t1 = 17 * (src[ 0] + src[16]);
 782             t2 = 17 * (src[ 0] - src[16]);
 783             t3 = 22 * src[ 8];
 784             t4 = 22 * src[24];
 785             t5 = 10 * src[ 8];
 786             t6 = 10 * src[24];
 787
 788             dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
 789             dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
 790             dst[16] = (t2 + t4 - t5 + 64) >> 7;
 791             dst[24] = (t1 - t3 - t6 + 64) >> 7;
 792
 793             src ++;
 794             dst ++;
 795         }
 796     }else{
 797         for(i = 0; i < M; i++){
 798             t1 = 12 * (src[ 0] + src[32]);
 799             t2 = 12 * (src[ 0] - src[32]);
 800             t3 = 16 * src[16] +  6 * src[48];
 801             t4 =  6 * src[16] - 16 * src[48];
 802
 803             t5 = t1 + t3;
 804             t6 = t2 + t4;
 805             t7 = t2 - t4;
 806             t8 = t1 - t3;
 807
 808             t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
 809             t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
 810             t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
 811             t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
 812
 813             dst[ 0] = (t5 + t1 + 64) >> 7;
 814             dst[ 8] = (t6 + t2 + 64) >> 7;
 815             dst[16] = (t7 + t3 + 64) >> 7;
 816             dst[24] = (t8 + t4 + 64) >> 7;
 817             dst[32] = (t8 - t4 + 64 + 1) >> 7;
 818             dst[40] = (t7 - t3 + 64 + 1) >> 7;
 819             dst[48] = (t6 - t2 + 64 + 1) >> 7;
 820             dst[56] = (t5 - t1 + 64 + 1) >> 7;
 821
 822             src++;
 823             dst++;
 824         }
 825     }
 826 }
 827
 828 /** Apply overlap transform to vertical edge
 829  * @todo optimize
 830  * @todo move to DSPContext
 831  */
 832 static void vc1_v_overlap(uint8_t* src, int stride)
 833 {
 834     int i;
 835     int a, b, c, d;
 836     for(i = 0; i < 8; i++) {
 837         a = src[-2*stride];
 838         b = src[-stride];
 839         c = src[0];
 840         d = src[stride];
 841
 842         src[-2*stride] = clip_uint8((7*a + d + 3) >> 3);
 843         src[-stride] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
 844         src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
 845         src[stride] = clip_uint8((a + 7*d + 3) >> 3);
 846         src++;
 847     }
 848 }
 849
 850 /** Apply overlap transform to horizontal edge
 851  * @todo optimize
 852  * @todo move to DSPContext
 853  */
 854 static void vc1_h_overlap(uint8_t* src, int stride)
 855 {
 856     int i;
 857     int a, b, c, d;
 858     for(i = 0; i < 8; i++) {
 859         a = src[-2];
 860         b = src[-1];
 861         c = src[0];
 862         d = src[1];
 863
 864         src[-2] = clip_uint8((7*a + d + 3) >> 3);
 865         src[-1] = clip_uint8((-a + 7*b + c + d + 3) >> 3);
 866         src[0] = clip_uint8((a + b + 7*c - d + 3) >> 3);
 867         src[1] = clip_uint8((a + 7*d + 3) >> 3);
 868         src += stride;
 869     }
 870 }
 871
 872 /** Put block onto picture
 873  * @todo move to DSPContext
 874  */
 875 static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
 876 {
 877     uint8_t *Y;
 878     int ys, us, vs;
 879     DSPContext *dsp = &v->s.dsp;
 880
 881     ys = v->s.current_picture.linesize[0];
 882     us = v->s.current_picture.linesize[1];
 883     vs = v->s.current_picture.linesize[2];
 884     Y = v->s.dest[0];
 885
 886     dsp->put_pixels_clamped(block[0], Y, ys);
 887     dsp->put_pixels_clamped(block[1], Y + 8, ys);
 888     Y += ys * 8;
 889     dsp->put_pixels_clamped(block[2], Y, ys);
 890     dsp->put_pixels_clamped(block[3], Y + 8, ys);
 891
 892     dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
 893     dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
 894 }
 895
 896 /* clip motion vector as specified in 8.3.6.5 */
 897 #define CLIP_RANGE(mv, src, lim, bs)      \
 898     if(mv < -bs) mv = -bs - src * bs; \
 899     if(mv > lim) mv = lim - src * bs;
 900
 901 /** Do motion compensation over 1 macroblock
 902  * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
 903  */
 904 static void vc1_mc_1mv(VC1Context *v)
 905 {
 906     MpegEncContext *s = &v->s;
 907     DSPContext *dsp = &v->s.dsp;
 908     uint8_t *srcY, *srcU, *srcV;
 909     int dxy, uvdxy, mx, my, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
 910
 911     if(!v->s.last_picture.data[0])return;
 912
 913     mx = s->mv[0][0][0];
 914     my = s->mv[0][0][1];
 915     uvmx = (mx + ((mx & 3) == 3)) >> 1;
 916     uvmy = (my + ((my & 3) == 3)) >> 1;
 917     srcY = s->last_picture.data[0];
 918     srcU = s->last_picture.data[1];
 919     srcV = s->last_picture.data[2];
 920
 921     src_x = s->mb_x * 16 + (mx >> 2);
 922     src_y = s->mb_y * 16 + (my >> 2);
 923     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
 924     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
 925
 926     CLIP_RANGE(  src_x, s->mb_x, s->mb_width  * 16, 16);
 927     CLIP_RANGE(  src_y, s->mb_y, s->mb_height * 16, 16);
 928     CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
 929     CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
 930
 931     srcY += src_y * s->linesize + src_x;
 932     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
 933     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
 934
 935     if((v->mv_mode == MV_PMODE_INTENSITY_COMP)
 936        || (unsigned)src_x > s->h_edge_pos - (mx&3) - 16
 937        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
 938         uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
 939
 940         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
 941                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);
 942         srcY = s->edge_emu_buffer;
 943         ff_emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8+1, 8+1,
 944                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 945         ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
 946                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
 947         srcU = uvbuf;
 948         srcV = uvbuf + 16;
 949         /* if we deal with intensity compensation we need to scale source blocks */
 950         if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
 951             int i, j;
 952             uint8_t *src, *src2;
 953
 954             src = srcY;
 955             for(j = 0; j < 17; j++) {
 956                 for(i = 0; i < 17; i++) src[i] = v->luty[src[i]];
 957                 src += s->linesize;
 958             }
 959             src = srcU; src2 = srcV;
 960             for(j = 0; j < 9; j++) {
 961                 for(i = 0; i < 9; i++) {
 962                     src[i] = v->lutuv[src[i]];
 963                     src2[i] = v->lutuv[src2[i]];
 964                 }
 965                 src += s->uvlinesize;
 966                 src2 += s->uvlinesize;
 967             }
 968         }
 969     }
 970
 971     if(v->fastuvmc) {
 972         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
 973         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
 974     }
 975
 976     if(!s->quarter_sample) { // hpel mc
 977         mx >>= 1;
 978         my >>= 1;
 979         dxy = ((my & 1) << 1) | (mx & 1);
 980
 981         dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
 982     } else {
 983         dxy = ((my & 3) << 2) | (mx & 3);
 984
 985         dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
 986     }
 987     uvmx >>= 1;
 988     uvmy >>= 1;
 989     uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
 990     dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
 991     dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
 992 //    dsp->put_mspel_pixels_tab[uvdxy](s->dest[1], srcU, s->uvlinesize);
 993 //    dsp->put_mspel_pixels_tab[uvdxy](s->dest[2], srcV, s->uvlinesize);
 994 }
 995
 996 /** Do motion compensation for 4-MV macroblock - luminance block
 997  */
 998 static void vc1_mc_4mv_luma(VC1Context *v, int n)
 999 {
1000     MpegEncContext *s = &v->s;
1001     DSPContext *dsp = &v->s.dsp;
1002     uint8_t *srcY;
1003     int dxy, mx, my, src_x, src_y;
1004     int off;
1005
1006     if(!v->s.last_picture.data[0])return;
1007     mx = s->mv[0][n][0];
1008     my = s->mv[0][n][1];
1009     srcY = s->last_picture.data[0];
1010
1011     off = s->linesize * 4 * (n&2) + (n&1) * 8;
1012
1013     src_x = s->mb_x * 16 + (n&1) * 8 + (mx >> 2);
1014     src_y = s->mb_y * 16 + (n&2) * 4 + (my >> 2);
1015
1016     CLIP_RANGE(src_x, s->mb_x, s->mb_width  * 16, 16);
1017     CLIP_RANGE(src_y, s->mb_y, s->mb_height * 16, 16);
1018
1019     srcY += src_y * s->linesize + src_x;
1020
1021     if((unsigned)src_x > s->h_edge_pos - (mx&3) - 16
1022        || (unsigned)src_y > s->v_edge_pos - (my&3) - 16){
1023         ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
1024                             src_x, src_y, s->h_edge_pos, s->v_edge_pos);
1025         srcY = s->edge_emu_buffer;
1026     }
1027
1028     if(!s->quarter_sample) { // hpel mc
1029         mx >>= 1;
1030         my >>= 1;
1031         dxy = ((my & 1) << 1) | (mx & 1);
1032
1033         dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
1034     } else {
1035         dxy = ((my & 3) << 2) | (mx & 3);
1036
1037         dsp->put_no_rnd_qpel_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize);
1038     }
1039 }
1040
1041 static inline int median4(int a, int b, int c, int d)
1042 {
1043     if(a < b) {
1044         if(c < d) return (FFMIN(b, d) + FFMAX(a, c)) / 2;
1045         else      return (FFMIN(b, c) + FFMAX(a, d)) / 2;
1046     } else {
1047         if(c < d) return (FFMIN(a, d) + FFMAX(b, c)) / 2;
1048         else      return (FFMIN(a, c) + FFMAX(b, d)) / 2;
1049     }
1050 }
1051
1052
1053 /** Do motion compensation for 4-MV macroblock - both chroma blocks
1054  */
1055 static void vc1_mc_4mv_chroma(VC1Context *v)
1056 {
1057     MpegEncContext *s = &v->s;
1058     DSPContext *dsp = &v->s.dsp;
1059     uint8_t *srcU, *srcV;
1060     int uvdxy, uvmx, uvmy, uvsrc_x, uvsrc_y;
1061     int i, idx, tx = 0, ty = 0;
1062     int mvx[4], mvy[4], intra[4];
1063     static const int count[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
1064
1065     if(!v->s.last_picture.data[0])return;
1066
1067     for(i = 0; i < 4; i++) {
1068         mvx[i] = s->mv[0][i][0];
1069         mvy[i] = s->mv[0][i][1];
1070         intra[i] = v->mb_type[0][s->block_index[i]];
1071     }
1072
1073     /* calculate chroma MV vector from four luma MVs */
1074     idx = (intra[3] << 3) | (intra[2] << 2) | (intra[1] << 1) | intra[0];
1075     if(!idx) { // all blocks are inter
1076         tx = median4(mvx[0], mvx[1], mvx[2], mvx[3]);
1077         ty = median4(mvy[0], mvy[1], mvy[2], mvy[3]);
1078     } else if(count[idx] == 1) { // 3 inter blocks
1079         switch(idx) {
1080         case 0x1:
1081             tx = mid_pred(mvx[1], mvx[2], mvx[3]);
1082             ty = mid_pred(mvy[1], mvy[2], mvy[3]);
1083             break;
1084         case 0x2:
1085             tx = mid_pred(mvx[0], mvx[2], mvx[3]);
1086             ty = mid_pred(mvy[0], mvy[2], mvy[3]);
1087             break;
1088         case 0x4:
1089             tx = mid_pred(mvx[0], mvx[1], mvx[3]);
1090             ty = mid_pred(mvy[0], mvy[1], mvy[3]);
1091             break;
1092         case 0x8:
1093             tx = mid_pred(mvx[0], mvx[1], mvx[2]);
1094             ty = mid_pred(mvy[0], mvy[1], mvy[2]);
1095             break;
1096         }
1097     } else if(count[idx] == 2) {
1098         int t1 = 0, t2 = 0;
1099         for(i=0; i<3;i++) if(!intra[i]) {t1 = i; break;}
1100         for(i= t1+1; i<4; i++)if(!intra[i]) {t2 = i; break;}
1101         tx = (mvx[t1] + mvx[t2]) / 2;
1102         ty = (mvy[t1] + mvy[t2]) / 2;
1103     } else
1104         return; //no need to do MC for inter blocks
1105
1106     uvmx = (tx + ((tx&3) == 3)) >> 1;
1107     uvmy = (ty + ((ty&3) == 3)) >> 1;
1108
1109     uvsrc_x = s->mb_x * 8 + (uvmx >> 2);
1110     uvsrc_y = s->mb_y * 8 + (uvmy >> 2);
1111
1112     CLIP_RANGE(uvsrc_x, s->mb_x, s->mb_width  *  8,  8);
1113     CLIP_RANGE(uvsrc_y, s->mb_y, s->mb_height *  8,  8);
1114     srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
1115     srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
1116     if((unsigned)uvsrc_x > (s->h_edge_pos >> 1) - ((uvmx >> 1)&1) - 8
1117        || (unsigned)uvsrc_y > (s->v_edge_pos >> 1) - ((uvmy >> 1)&1) - 8){
1118         ff_emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize, 8+1, 8+1,
1119                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1120         ff_emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize, 8+1, 8+1,
1121                             uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
1122         srcU = s->edge_emu_buffer;
1123         srcV = s->edge_emu_buffer + 16;
1124     }
1125
1126     if(v->fastuvmc) {
1127         uvmx = uvmx + ((uvmx<0)?(uvmx&1):-(uvmx&1));
1128         uvmy = uvmy + ((uvmy<0)?(uvmy&1):-(uvmy&1));
1129     }
1130
1131     uvmx >>= 1;
1132     uvmy >>= 1;
1133     uvdxy = ((uvmy & 1) << 1) | (uvmx & 1);
1134     dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
1135     dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
1136 }
1137
1138 /**
1139  * Decode Simple/Main Profiles sequence header
1140  * @see Figure 7-8, p16-17
1141  * @param avctx Codec context
1142  * @param gb GetBit context initialized from Codec context extra_data
1143  * @return Status
1144  */
1145 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
1146 {
1147     VC1Context *v = avctx->priv_data;
1148
1149     av_log(avctx, AV_LOG_INFO, "Header: %0X\n", show_bits(gb, 32));
1150     v->profile = get_bits(gb, 2);
1151     if (v->profile == 2)
1152     {
1153         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
1154         return -1;
1155     }
1156
1157     if (v->profile == PROFILE_ADVANCED)
1158     {
1159         v->level = get_bits(gb, 3);
1160         if(v->level >= 5)
1161         {
1162             av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
1163         }
1164         v->chromaformat = get_bits(gb, 2);
1165         if (v->chromaformat != 1)
1166         {
1167             av_log(avctx, AV_LOG_ERROR,
1168                    "Only 4:2:0 chroma format supported\n");
1169             return -1;
1170         }
1171     }
1172     else
1173     {
1174         v->res_sm = get_bits(gb, 2); //reserved
1175         if (v->res_sm)
1176         {
1177             av_log(avctx, AV_LOG_ERROR,
1178                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
1179             return -1;
1180         }
1181     }
1182
1183     // (fps-2)/4 (->30)
1184     v->frmrtq_postproc = get_bits(gb, 3); //common
1185     // (bitrate-32kbps)/64kbps
1186     v->bitrtq_postproc = get_bits(gb, 5); //common
1187     v->s.loop_filter = get_bits(gb, 1); //common
1188     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
1189     {
1190         av_log(avctx, AV_LOG_ERROR,
1191                "LOOPFILTER shell not be enabled in simple profile\n");
1192     }
1193
1194     if (v->profile < PROFILE_ADVANCED)
1195     {
1196         v->res_x8 = get_bits(gb, 1); //reserved
1197         if (v->res_x8)
1198         {
1199             av_log(avctx, AV_LOG_ERROR,
1200                    "1 for reserved RES_X8 is forbidden\n");
1201             //return -1;
1202         }
1203         v->multires = get_bits(gb, 1);
1204         v->res_fasttx = get_bits(gb, 1);
1205         if (!v->res_fasttx)
1206         {
1207             av_log(avctx, AV_LOG_ERROR,
1208                    "0 for reserved RES_FASTTX is forbidden\n");
1209             //return -1;
1210         }
1211     }
1212
1213     v->fastuvmc =  get_bits(gb, 1); //common
1214     if (!v->profile && !v->fastuvmc)
1215     {
1216         av_log(avctx, AV_LOG_ERROR,
1217                "FASTUVMC unavailable in Simple Profile\n");
1218         return -1;
1219     }
1220     v->extended_mv =  get_bits(gb, 1); //common
1221     if (!v->profile && v->extended_mv)
1222     {
1223         av_log(avctx, AV_LOG_ERROR,
1224                "Extended MVs unavailable in Simple Profile\n");
1225         return -1;
1226     }
1227     v->dquant =  get_bits(gb, 2); //common
1228     v->vstransform =  get_bits(gb, 1); //common
1229
1230     if (v->profile < PROFILE_ADVANCED)
1231     {
1232         v->res_transtab = get_bits(gb, 1);
1233         if (v->res_transtab)
1234         {
1235             av_log(avctx, AV_LOG_ERROR,
1236                    "1 for reserved RES_TRANSTAB is forbidden\n");
1237             return -1;
1238         }
1239     }
1240
1241     v->overlap = get_bits(gb, 1); //common
1242
1243     if (v->profile < PROFILE_ADVANCED)
1244     {
1245         v->s.resync_marker = get_bits(gb, 1);
1246         v->rangered = get_bits(gb, 1);
1247         if (v->rangered && v->profile == PROFILE_SIMPLE)
1248         {
1249             av_log(avctx, AV_LOG_INFO,
1250                    "RANGERED should be set to 0 in simple profile\n");
1251         }
1252     }
1253
1254     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
1255     v->quantizer_mode = get_bits(gb, 2); //common
1256
1257     if (v->profile < PROFILE_ADVANCED)
1258     {
1259         v->finterpflag = get_bits(gb, 1); //common
1260         v->res_rtm_flag = get_bits(gb, 1); //reserved
1261         if (!v->res_rtm_flag)
1262         {
1263             av_log(avctx, AV_LOG_ERROR,
1264                    "0 for reserved RES_RTM_FLAG is forbidden\n");
1265             //return -1;
1266         }
1267         av_log(avctx, AV_LOG_DEBUG,
1268                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
1269                "LoopFilter=%i, MultiRes=%i, FastUVMC=%i, Extended MV=%i\n"
1270                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
1271                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
1272                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
1273                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
1274                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
1275                v->dquant, v->quantizer_mode, avctx->max_b_frames
1276                );
1277         return 0;
1278     }
1279     return -1;
1280 }
1281
1282
1283 static int vc1_parse_frame_header(VC1Context *v, GetBitContext* gb)
1284 {
1285     int pqindex, lowquant, status;
1286
1287     if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
1288     skip_bits(gb, 2); //framecnt unused
1289     v->rangeredfrm = 0;
1290     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1291     v->s.pict_type = get_bits(gb, 1);
1292     if (v->s.avctx->max_b_frames) {
1293         if (!v->s.pict_type) {
1294             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1295             else v->s.pict_type = B_TYPE;
1296         } else v->s.pict_type = P_TYPE;
1297     } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
1298
1299     if(v->s.pict_type == I_TYPE)
1300         get_bits(gb, 7); // skip buffer fullness
1301
1302     /* Quantizer stuff */
1303     pqindex = get_bits(gb, 5);
1304     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1305         v->pq = pquant_table[0][pqindex];
1306     else
1307         v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1308
1309     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1310         v->pquantizer = pqindex < 9;
1311     if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
1312         v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
1313     v->pqindex = pqindex;
1314     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1315     else v->halfpq = 0;
1316     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1317         v->pquantizer = get_bits(gb, 1);
1318     v->dquantfrm = 0;
1319     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1320     v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
1321     v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
1322     v->range_x = 1 << (v->k_x - 1);
1323     v->range_y = 1 << (v->k_y - 1);
1324     if (v->profile == PROFILE_ADVANCED)
1325     {
1326         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1327     }
1328     else
1329         if (v->multires && v->s.pict_type != B_TYPE) v->respic = get_bits(gb, 2);
1330
1331 //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
1332 //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
1333
1334     //TODO: complete parsing for P/B/BI frames
1335     switch(v->s.pict_type) {
1336     case P_TYPE:
1337         if (v->pq < 5) v->tt_index = 0;
1338         else if(v->pq < 13) v->tt_index = 1;
1339         else v->tt_index = 2;
1340
1341         lowquant = (v->pq > 12) ? 0 : 1;
1342         v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1343         if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1344         {
1345             int scale, shift, i;
1346             v->mv_mode2 = mv_pmode_table2[lowquant][get_prefix(gb, 1, 3)];
1347             v->lumscale = get_bits(gb, 6);
1348             v->lumshift = get_bits(gb, 6);
1349             /* fill lookup tables for intensity compensation */
1350             if(!v->lumscale) {
1351                 scale = -64;
1352                 shift = (255 - v->lumshift * 2) << 6;
1353                 if(v->lumshift > 31)
1354                     shift += 128 << 6;
1355             } else {
1356                 scale = v->lumscale + 32;
1357                 if(v->lumshift > 31)
1358                     shift = (v->lumshift - 64) << 6;
1359                 else
1360                     shift = v->lumshift << 6;
1361             }
1362             for(i = 0; i < 256; i++) {
1363                 v->luty[i] = clip_uint8((scale * i + shift + 32) >> 6);
1364                 v->lutuv[i] = clip_uint8((scale * (i - 128) + 128*64 + 32) >> 6);
1365             }
1366         }
1367         if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
1368             v->s.quarter_sample = 0;
1369         else if(v->mv_mode == MV_PMODE_INTENSITY_COMP) {
1370             if(v->mv_mode2 == MV_PMODE_1MV_HPEL || v->mv_mode2 == MV_PMODE_1MV_HPEL_BILIN)
1371                 v->s.quarter_sample = 0;
1372             else
1373                 v->s.quarter_sample = 1;
1374         } else
1375             v->s.quarter_sample = 1;
1376
1377         if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1378                  v->mv_mode2 == MV_PMODE_MIXED_MV)
1379                 || v->mv_mode == MV_PMODE_MIXED_MV)
1380         {
1381             status = bitplane_decoding(v->mv_type_mb_plane, &v->mv_type_is_raw, v);
1382             if (status < 0) return -1;
1383             av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1384                    "Imode: %i, Invert: %i\n", status>>1, status&1);
1385         } else {
1386             v->mv_type_is_raw = 0;
1387             memset(v->mv_type_mb_plane, 0, v->s.mb_stride * v->s.mb_height);
1388         }
1389         status = bitplane_decoding(v->s.mbskip_table, &v->skip_is_raw, v);
1390         if (status < 0) return -1;
1391         av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1392                "Imode: %i, Invert: %i\n", status>>1, status&1);
1393
1394         /* Hopefully this is correct for P frames */
1395         v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables
1396         v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];
1397
1398         if (v->dquant)
1399         {
1400             av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
1401             vop_dquant_decoding(v);
1402         }
1403
1404         v->ttfrm = 0; //FIXME Is that so ?
1405         if (v->vstransform)
1406         {
1407             v->ttmbf = get_bits(gb, 1);
1408             if (v->ttmbf)
1409             {
1410                 v->ttfrm = ttfrm_to_tt[get_bits(gb, 2)];
1411             }
1412         }
1413         break;
1414     case B_TYPE:
1415         break;
1416     }
1417
1418     /* AC Syntax */
1419     v->c_ac_table_index = decode012(gb);
1420     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1421     {
1422         v->y_ac_table_index = decode012(gb);
1423     }
1424     /* DC Syntax */
1425     v->s.dc_table_index = get_bits(gb, 1);
1426
1427     return 0;
1428 }
1429
1430 /***********************************************************************/
1431 /**
1432  * @defgroup block VC-1 Block-level functions
1433  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1434  * @todo TODO: Integrate to MpegEncContext facilities
1435  * @{
1436  */
1437
1438 /**
1439  * @def GET_MQUANT
1440  * @brief Get macroblock-level quantizer scale
1441  * @warning XXX: qdiff to the frame quant, not previous quant ?
1442  * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1443  */
1444 #define GET_MQUANT()                                           \
1445   if (v->dquantfrm)                                            \
1446   {                                                            \
1447     int edges = 0;                                             \
1448     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1449     {                                                          \
1450       if (v->dqbilevel)                                        \
1451       {                                                        \
1452         mquant = (get_bits(gb, 1)) ? v->altpq : v->pq;         \
1453       }                                                        \
1454       else                                                     \
1455       {                                                        \
1456         mqdiff = get_bits(gb, 3);                              \
1457         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1458         else mquant = get_bits(gb, 5);                         \
1459       }                                                        \
1460     }                                                          \
1461     if(v->dqprofile == DQPROFILE_SINGLE_EDGE)                  \
1462         edges = 1 << v->dqsbedge;                              \
1463     else if(v->dqprofile == DQPROFILE_DOUBLE_EDGES)            \
1464         edges = (3 << v->dqsbedge) % 15;                       \
1465     else if(v->dqprofile == DQPROFILE_FOUR_EDGES)              \
1466         edges = 15;                                            \
1467     if((edges&1) && !s->mb_x)                                  \
1468         mquant = v->altpq;                                     \
1469     if((edges&2) && s->first_slice_line)                       \
1470         mquant = v->altpq;                                     \
1471     if((edges&4) && s->mb_x == (s->mb_width - 1))              \
1472         mquant = v->altpq;                                     \
1473     if((edges&8) && s->mb_y == (s->mb_height - 1))             \
1474         mquant = v->altpq;                                     \
1475   }
1476
1477 /**
1478  * @def GET_MVDATA(_dmv_x, _dmv_y)
1479  * @brief Get MV differentials
1480  * @see MVDATA decoding from 8.3.5.2, p(1)20
1481  * @param _dmv_x Horizontal differential for decoded MV
1482  * @param _dmv_y Vertical differential for decoded MV
1483  * @todo TODO: Use MpegEncContext arrays to store them
1484  */
1485 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1486   index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
1487                        VC1_MV_DIFF_VLC_BITS, 2);                    \
1488   if (index > 36)                                                   \
1489   {                                                                 \
1490     mb_has_coeffs = 1;                                              \
1491     index -= 37;                                                    \
1492   }                                                                 \
1493   else mb_has_coeffs = 0;                                           \
1494   s->mb_intra = 0;                                                  \
1495   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1496   else if (index == 35)                                             \
1497   {                                                                 \
1498     _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample);          \
1499     _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample);          \
1500   }                                                                 \
1501   else if (index == 36)                                             \
1502   {                                                                 \
1503     _dmv_x = 0;                                                     \
1504     _dmv_y = 0;                                                     \
1505     s->mb_intra = 1;                                                \
1506   }                                                                 \
1507   else                                                              \
1508   {                                                                 \
1509     index1 = index%6;                                               \
1510     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1511     else                                   val = 0;                 \
1512     if(size_table[index1] - val > 0)                                \
1513         val = get_bits(gb, size_table[index1] - val);               \
1514     else                                   val = 0;                 \
1515     sign = 0 - (val&1);                                             \
1516     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1517                                                                     \
1518     index1 = index/6;                                               \
1519     if (!s->quarter_sample && index1 == 5) val = 1;                 \
1520     else                                   val = 0;                 \
1521     if(size_table[index1] - val > 0)                                \
1522         val = get_bits(gb, size_table[index1] - val);               \
1523     else                                   val = 0;                 \
1524     sign = 0 - (val&1);                                             \
1525     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1526   }
1527
1528 /** Predict and set motion vector
1529  */
1530 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)
1531 {
1532     int xy, wrap, off = 0;
1533     int16_t *A, *B, *C;
1534     int px, py;
1535     int sum;
1536
1537     /* scale MV difference to be quad-pel */
1538     dmv_x <<= 1 - s->quarter_sample;
1539     dmv_y <<= 1 - s->quarter_sample;
1540
1541     wrap = s->b8_stride;
1542     xy = s->block_index[n];
1543
1544     if(s->mb_intra){
1545         s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = 0;
1546         s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = 0;
1547         if(mv1) { /* duplicate motion data for 1-MV block */
1548             s->current_picture.motion_val[0][xy + 1][0] = 0;
1549             s->current_picture.motion_val[0][xy + 1][1] = 0;
1550             s->current_picture.motion_val[0][xy + wrap][0] = 0;
1551             s->current_picture.motion_val[0][xy + wrap][1] = 0;
1552             s->current_picture.motion_val[0][xy + wrap + 1][0] = 0;
1553             s->current_picture.motion_val[0][xy + wrap + 1][1] = 0;
1554         }
1555         return;
1556     }
1557
1558     C = s->current_picture.motion_val[0][xy - 1];
1559     A = s->current_picture.motion_val[0][xy - wrap];
1560     if(mv1)
1561         off = (s->mb_x == (s->mb_width - 1)) ? -1 : 2;
1562     else {
1563         //in 4-MV mode different blocks have different B predictor position
1564         switch(n){
1565         case 0:
1566             off = (s->mb_x > 0) ? -1 : 1;
1567             break;
1568         case 1:
1569             off = (s->mb_x == (s->mb_width - 1)) ? -1 : 1;
1570             break;
1571         case 2:
1572             off = 1;
1573             break;
1574         case 3:
1575             off = -1;
1576         }
1577     }
1578     B = s->current_picture.motion_val[0][xy - wrap + off];
1579
1580     if(!s->first_slice_line || (n==2 || n==3)) { // predictor A is not out of bounds
1581         if(s->mb_width == 1) {
1582             px = A[0];
1583             py = A[1];
1584         } else {
1585             px = mid_pred(A[0], B[0], C[0]);
1586             py = mid_pred(A[1], B[1], C[1]);
1587         }
1588     } else if(s->mb_x || (n==1 || n==3)) { // predictor C is not out of bounds
1589         px = C[0];
1590         py = C[1];
1591     } else {
1592         px = py = 0;
1593     }
1594     /* Pullback MV as specified in 8.3.5.3.4 */
1595     {
1596         int qx, qy, X, Y;
1597         qx = (s->mb_x << 6) + ((n==1 || n==3) ? 32 : 0);
1598         qy = (s->mb_y << 6) + ((n==2 || n==3) ? 32 : 0);
1599         X = (s->mb_width << 6) - 4;
1600         Y = (s->mb_height << 6) - 4;
1601         if(mv1) {
1602             if(qx + px < -60) px = -60 - qx;
1603             if(qy + py < -60) py = -60 - qy;
1604         } else {
1605             if(qx + px < -28) px = -28 - qx;
1606             if(qy + py < -28) py = -28 - qy;
1607         }
1608         if(qx + px > X) px = X - qx;
1609         if(qy + py > Y) py = Y - qy;
1610     }
1611     /* Calculate hybrid prediction as specified in 8.3.5.3.5 */
1612     if((!s->first_slice_line || (n==2 || n==3)) && (s->mb_x || (n==1 || n==3))) {
1613         if(is_intra[xy - wrap])
1614             sum = ABS(px) + ABS(py);
1615         else
1616             sum = ABS(px - A[0]) + ABS(py - A[1]);
1617         if(sum > 32) {
1618             if(get_bits1(&s->gb)) {
1619                 px = A[0];
1620                 py = A[1];
1621             } else {
1622                 px = C[0];
1623                 py = C[1];
1624             }
1625         } else {
1626             if(is_intra[xy - 1])
1627                 sum = ABS(px) + ABS(py);
1628             else
1629                 sum = ABS(px - C[0]) + ABS(py - C[1]);
1630             if(sum > 32) {
1631                 if(get_bits1(&s->gb)) {
1632                     px = A[0];
1633                     py = A[1];
1634                 } else {
1635                     px = C[0];
1636                     py = C[1];
1637                 }
1638             }
1639         }
1640     }
1641     /* store MV using signed modulus of MV range defined in 4.11 */
1642     s->mv[0][n][0] = s->current_picture.motion_val[0][xy][0] = ((px + dmv_x + r_x) & ((r_x << 1) - 1)) - r_x;
1643     s->mv[0][n][1] = s->current_picture.motion_val[0][xy][1] = ((py + dmv_y + r_y) & ((r_y << 1) - 1)) - r_y;
1644     if(mv1) { /* duplicate motion data for 1-MV block */
1645         s->current_picture.motion_val[0][xy + 1][0] = s->current_picture.motion_val[0][xy][0];
1646         s->current_picture.motion_val[0][xy + 1][1] = s->current_picture.motion_val[0][xy][1];
1647         s->current_picture.motion_val[0][xy + wrap][0] = s->current_picture.motion_val[0][xy][0];
1648         s->current_picture.motion_val[0][xy + wrap][1] = s->current_picture.motion_val[0][xy][1];
1649         s->current_picture.motion_val[0][xy + wrap + 1][0] = s->current_picture.motion_val[0][xy][0];
1650         s->current_picture.motion_val[0][xy + wrap + 1][1] = s->current_picture.motion_val[0][xy][1];
1651     }
1652 }
1653
1654 /** Get predicted DC value for I-frames only
1655  * prediction dir: left=0, top=1
1656  * @param s MpegEncContext
1657  * @param[in] n block index in the current MB
1658  * @param dc_val_ptr Pointer to DC predictor
1659  * @param dir_ptr Prediction direction for use in AC prediction
1660  */
1661 static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1662                               int16_t **dc_val_ptr, int *dir_ptr)
1663 {
1664     int a, b, c, wrap, pred, scale;
1665     int16_t *dc_val;
1666     static const uint16_t dcpred[32] = {
1667     -1, 1024,  512,  341,  256,  205,  171,  146,  128,
1668          114,  102,   93,   85,   79,   73,   68,   64,
1669           60,   57,   54,   51,   49,   47,   45,   43,
1670           41,   39,   38,   37,   35,   34,   33
1671     };
1672
1673     /* find prediction - wmv3_dc_scale always used here in fact */
1674     if (n < 4)     scale = s->y_dc_scale;
1675     else           scale = s->c_dc_scale;
1676
1677     wrap = s->block_wrap[n];
1678     dc_val= s->dc_val[0] + s->block_index[n];
1679
1680     /* B A
1681      * C X
1682      */
1683     c = dc_val[ - 1];
1684     b = dc_val[ - 1 - wrap];
1685     a = dc_val[ - wrap];
1686
1687     if (pq < 9 || !overlap)
1688     {
1689         /* Set outer values */
1690         if (s->first_slice_line && (n!=2 && n!=3)) b=a=dcpred[scale];
1691         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=dcpred[scale];
1692     }
1693     else
1694     {
1695         /* Set outer values */
1696         if (s->first_slice_line && (n!=2 && n!=3)) b=a=0;
1697         if (s->mb_x == 0 && (n!=1 && n!=3)) b=c=0;
1698     }
1699
1700     if (abs(a - b) <= abs(b - c)) {
1701         pred = c;
1702         *dir_ptr = 1;//left
1703     } else {
1704         pred = a;
1705         *dir_ptr = 0;//top
1706     }
1707
1708     /* update predictor */
1709     *dc_val_ptr = &dc_val[0];
1710     return pred;
1711 }
1712
1713
1714 /** Get predicted DC value
1715  * prediction dir: left=0, top=1
1716  * @param s MpegEncContext
1717  * @param[in] n block index in the current MB
1718  * @param dc_val_ptr Pointer to DC predictor
1719  * @param dir_ptr Prediction direction for use in AC prediction
1720  */
1721 static inline int vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n,
1722                               int a_avail, int c_avail,
1723                               int16_t **dc_val_ptr, int *dir_ptr)
1724 {
1725     int a, b, c, wrap, pred, scale;
1726     int16_t *dc_val;
1727     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
1728     int q1, q2 = 0;
1729
1730     /* find prediction - wmv3_dc_scale always used here in fact */
1731     if (n < 4)     scale = s->y_dc_scale;
1732     else           scale = s->c_dc_scale;
1733
1734     wrap = s->block_wrap[n];
1735     dc_val= s->dc_val[0] + s->block_index[n];
1736
1737     /* B A
1738      * C X
1739      */
1740     c = dc_val[ - 1];
1741     b = dc_val[ - 1 - wrap];
1742     a = dc_val[ - wrap];
1743
1744     if(a_avail && c_avail) {
1745         if(abs(a - b) <= abs(b - c)) {
1746             pred = c;
1747             *dir_ptr = 1;//left
1748             q2 = s->current_picture.qscale_table[mb_pos - 1];
1749         } else {
1750             pred = a;
1751             *dir_ptr = 0;//top
1752             q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1753         }
1754     } else if(a_avail) {
1755         pred = a;
1756         *dir_ptr = 0;//top
1757         q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
1758     } else if(c_avail) {
1759         pred = c;
1760         *dir_ptr = 1;//left
1761         q2 = s->current_picture.qscale_table[mb_pos - 1];
1762     } else {
1763         pred = 0;
1764         *dir_ptr = 1;//left
1765     }
1766
1767     /* scale coeffs if needed */
1768     q1 = s->current_picture.qscale_table[mb_pos];
1769     if(n && n<4) q2=q1;
1770
1771     if(q2 && q1!=q2) {
1772         pred = (pred * s->y_dc_scale_table[q2] * vc1_dqscale[s->y_dc_scale_table[q1] - 1] + 0x20000) >> 18;
1773     }
1774
1775     /* update predictor */
1776     *dc_val_ptr = &dc_val[0];
1777     return pred;
1778 }
1779
1780
1781 /**
1782  * @defgroup std_mb VC1 Macroblock-level functions in Simple/Main Profiles
1783  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1784  * @todo TODO: Integrate to MpegEncContext facilities
1785  * @{
1786  */
1787
1788 static inline int vc1_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1789 {
1790     int xy, wrap, pred, a, b, c;
1791
1792     xy = s->block_index[n];
1793     wrap = s->b8_stride;
1794
1795     /* B C
1796      * A X
1797      */
1798     a = s->coded_block[xy - 1       ];
1799     b = s->coded_block[xy - 1 - wrap];
1800     c = s->coded_block[xy     - wrap];
1801
1802     if (b == c) {
1803         pred = a;
1804     } else {
1805         pred = c;
1806     }
1807
1808     /* store value */
1809     *coded_block_ptr = &s->coded_block[xy];
1810
1811     return pred;
1812 }
1813
1814 /**
1815  * Decode one AC coefficient
1816  * @param v The VC1 context
1817  * @param last Last coefficient
1818  * @param skip How much zero coefficients to skip
1819  * @param value Decoded AC coefficient value
1820  * @see 8.1.3.4
1821  */
1822 static void vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, int *value, int codingset)
1823 {
1824     GetBitContext *gb = &v->s.gb;
1825     int index, escape, run = 0, level = 0, lst = 0;
1826
1827     index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1828     if (index != vc1_ac_sizes[codingset] - 1) {
1829         run = vc1_index_decode_table[codingset][index][0];
1830         level = vc1_index_decode_table[codingset][index][1];
1831         lst = index >= vc1_last_decode_table[codingset];
1832         if(get_bits(gb, 1))
1833             level = -level;
1834     } else {
1835         escape = decode210(gb);
1836         if (escape != 2) {
1837             index = get_vlc2(gb, vc1_ac_coeff_table[codingset].table, AC_VLC_BITS, 3);
1838             run = vc1_index_decode_table[codingset][index][0];
1839             level = vc1_index_decode_table[codingset][index][1];
1840             lst = index >= vc1_last_decode_table[codingset];
1841             if(escape == 0) {
1842                 if(lst)
1843                     level += vc1_last_delta_level_table[codingset][run];
1844                 else
1845                     level += vc1_delta_level_table[codingset][run];
1846             } else {
1847                 if(lst)
1848                     run += vc1_last_delta_run_table[codingset][level] + 1;
1849                 else
1850                     run += vc1_delta_run_table[codingset][level] + 1;
1851             }
1852             if(get_bits(gb, 1))
1853                 level = -level;
1854         } else {
1855             int sign;
1856             lst = get_bits(gb, 1);
1857             if(v->s.esc3_level_length == 0) {
1858                 if(v->pq < 8 || v->dquantfrm) { // table 59
1859                     v->s.esc3_level_length = get_bits(gb, 3);
1860                     if(!v->s.esc3_level_length)
1861                         v->s.esc3_level_length = get_bits(gb, 2) + 8;
1862                 } else { //table 60
1863                     v->s.esc3_level_length = get_prefix(gb, 1, 6) + 2;
1864                 }
1865                 v->s.esc3_run_length = 3 + get_bits(gb, 2);
1866             }
1867             run = get_bits(gb, v->s.esc3_run_length);
1868             sign = get_bits(gb, 1);
1869             level = get_bits(gb, v->s.esc3_level_length);
1870             if(sign)
1871                 level = -level;
1872         }
1873     }
1874
1875     *last = lst;
1876     *skip = run;
1877     *value = level;
1878 }
1879
1880 /** Decode intra block in intra frames - should be faster than decode_intra_block
1881  * @param v VC1Context
1882  * @param block block to decode
1883  * @param coded are AC coeffs present or not
1884  * @param codingset set of VLC to decode data
1885  */
1886 static int vc1_decode_i_block(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset)
1887 {
1888     GetBitContext *gb = &v->s.gb;
1889     MpegEncContext *s = &v->s;
1890     int dc_pred_dir = 0; /* Direction of the DC prediction used */
1891     int run_diff, i;
1892     int16_t *dc_val;
1893     int16_t *ac_val, *ac_val2;
1894     int dcdiff;
1895
1896     /* Get DC differential */
1897     if (n < 4) {
1898         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1899     } else {
1900         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1901     }
1902     if (dcdiff < 0){
1903         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1904         return -1;
1905     }
1906     if (dcdiff)
1907     {
1908         if (dcdiff == 119 /* ESC index value */)
1909         {
1910             /* TODO: Optimize */
1911             if (v->pq == 1) dcdiff = get_bits(gb, 10);
1912             else if (v->pq == 2) dcdiff = get_bits(gb, 9);
1913             else dcdiff = get_bits(gb, 8);
1914         }
1915         else
1916         {
1917             if (v->pq == 1)
1918                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1919             else if (v->pq == 2)
1920                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1921         }
1922         if (get_bits(gb, 1))
1923             dcdiff = -dcdiff;
1924     }
1925
1926     /* Prediction */
1927     dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir);
1928     *dc_val = dcdiff;
1929
1930     /* Store the quantized DC coeff, used for prediction */
1931     if (n < 4) {
1932         block[0] = dcdiff * s->y_dc_scale;
1933     } else {
1934         block[0] = dcdiff * s->c_dc_scale;
1935     }
1936     /* Skip ? */
1937     run_diff = 0;
1938     i = 0;
1939     if (!coded) {
1940         goto not_coded;
1941     }
1942
1943     //AC Decoding
1944     i = 1;
1945
1946     {
1947         int last = 0, skip, value;
1948         const int8_t *zz_table;
1949         int scale;
1950         int k;
1951
1952         scale = v->pq * 2 + v->halfpq;
1953
1954         if(v->s.ac_pred) {
1955             if(!dc_pred_dir)
1956                 zz_table = vc1_horizontal_zz;
1957             else
1958                 zz_table = vc1_vertical_zz;
1959         } else
1960             zz_table = vc1_normal_zz;
1961
1962         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1963         ac_val2 = ac_val;
1964         if(dc_pred_dir) //left
1965             ac_val -= 16;
1966         else //top
1967             ac_val -= 16 * s->block_wrap[n];
1968
1969         while (!last) {
1970             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
1971             i += skip;
1972             if(i > 63)
1973                 break;
1974             block[zz_table[i++]] = value;
1975         }
1976
1977         /* apply AC prediction if needed */
1978         if(s->ac_pred) {
1979             if(dc_pred_dir) { //left
1980                 for(k = 1; k < 8; k++)
1981                     block[k << 3] += ac_val[k];
1982             } else { //top
1983                 for(k = 1; k < 8; k++)
1984                     block[k] += ac_val[k + 8];
1985             }
1986         }
1987         /* save AC coeffs for further prediction */
1988         for(k = 1; k < 8; k++) {
1989             ac_val2[k] = block[k << 3];
1990             ac_val2[k + 8] = block[k];
1991         }
1992
1993         /* scale AC coeffs */
1994         for(k = 1; k < 64; k++)
1995             if(block[k]) {
1996                 block[k] *= scale;
1997                 if(!v->pquantizer)
1998                     block[k] += (block[k] < 0) ? -v->pq : v->pq;
1999             }
2000
2001         if(s->ac_pred) i = 63;
2002     }
2003
2004 not_coded:
2005     if(!coded) {
2006         int k, scale;
2007         ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2008         ac_val2 = ac_val;
2009
2010         scale = v->pq * 2 + v->halfpq;
2011         memset(ac_val2, 0, 16 * 2);
2012         if(dc_pred_dir) {//left
2013             ac_val -= 16;
2014             if(s->ac_pred)
2015                 memcpy(ac_val2, ac_val, 8 * 2);
2016         } else {//top
2017             ac_val -= 16 * s->block_wrap[n];
2018             if(s->ac_pred)
2019                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2020         }
2021
2022         /* apply AC prediction if needed */
2023         if(s->ac_pred) {
2024             if(dc_pred_dir) { //left
2025                 for(k = 1; k < 8; k++) {
2026                     block[k << 3] = ac_val[k] * scale;
2027                     if(!v->pquantizer)
2028                         block[k << 3] += (block[k << 3] < 0) ? -v->pq : v->pq;
2029                 }
2030             } else { //top
2031                 for(k = 1; k < 8; k++) {
2032                     block[k] = ac_val[k + 8] * scale;
2033                     if(!v->pquantizer)
2034                         block[k] += (block[k] < 0) ? -v->pq : v->pq;
2035                 }
2036             }
2037             i = 63;
2038         }
2039     }
2040     s->block_last_index[n] = i;
2041
2042     return 0;
2043 }
2044
2045 /** Decode intra block in inter frames - more generic version than vc1_decode_i_block
2046  * @param v VC1Context
2047  * @param block block to decode
2048  * @param coded are AC coeffs present or not
2049  * @param mquant block quantizer
2050  * @param codingset set of VLC to decode data
2051  */
2052 static int vc1_decode_intra_block(VC1Context *v, DCTELEM block[64], int n, int coded, int mquant, int codingset)
2053 {
2054     GetBitContext *gb = &v->s.gb;
2055     MpegEncContext *s = &v->s;
2056     int dc_pred_dir = 0; /* Direction of the DC prediction used */
2057     int run_diff, i;
2058     int16_t *dc_val;
2059     int16_t *ac_val, *ac_val2;
2060     int dcdiff;
2061     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2062     int a_avail = v->a_avail, c_avail = v->c_avail;
2063     int use_pred = s->ac_pred;
2064     int scale;
2065     int q1, q2 = 0;
2066
2067     /* XXX: Guard against dumb values of mquant */
2068     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
2069
2070     /* Set DC scale - y and c use the same */
2071     s->y_dc_scale = s->y_dc_scale_table[mquant];
2072     s->c_dc_scale = s->c_dc_scale_table[mquant];
2073
2074     /* Get DC differential */
2075     if (n < 4) {
2076         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2077     } else {
2078         dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
2079     }
2080     if (dcdiff < 0){
2081         av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
2082         return -1;
2083     }
2084     if (dcdiff)
2085     {
2086         if (dcdiff == 119 /* ESC index value */)
2087         {
2088             /* TODO: Optimize */
2089             if (mquant == 1) dcdiff = get_bits(gb, 10);
2090             else if (mquant == 2) dcdiff = get_bits(gb, 9);
2091             else dcdiff = get_bits(gb, 8);
2092         }
2093         else
2094         {
2095             if (mquant == 1)
2096                 dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
2097             else if (mquant == 2)
2098                 dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
2099         }
2100         if (get_bits(gb, 1))
2101             dcdiff = -dcdiff;
2102     }
2103
2104     /* Prediction */
2105     dcdiff += vc1_pred_dc(&v->s, v->overlap, mquant, n, a_avail, c_avail, &dc_val, &dc_pred_dir);
2106     *dc_val = dcdiff;
2107
2108     /* Store the quantized DC coeff, used for prediction */
2109
2110     if (n < 4) {
2111         block[0] = dcdiff * s->y_dc_scale;
2112     } else {
2113         block[0] = dcdiff * s->c_dc_scale;
2114     }
2115     /* Skip ? */
2116     run_diff = 0;
2117     i = 0;
2118
2119     //AC Decoding
2120     i = 1;
2121
2122     /* check if AC is needed at all and adjust direction if needed */
2123     if(!a_avail) dc_pred_dir = 1;
2124     if(!c_avail) dc_pred_dir = 0;
2125     if(!a_avail && !c_avail) use_pred = 0;
2126     ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
2127     ac_val2 = ac_val;
2128
2129     scale = mquant * 2;
2130
2131     if(dc_pred_dir) //left
2132         ac_val -= 16;
2133     else //top
2134         ac_val -= 16 * s->block_wrap[n];
2135
2136     q1 = s->current_picture.qscale_table[mb_pos];
2137     if(dc_pred_dir && c_avail) q2 = s->current_picture.qscale_table[mb_pos - 1];
2138     if(!dc_pred_dir && a_avail) q2 = s->current_picture.qscale_table[mb_pos - s->mb_stride];
2139     if(n && n<4) q2 = q1;
2140
2141     if(coded) {
2142         int last = 0, skip, value;
2143         const int8_t *zz_table;
2144         int k;
2145
2146         zz_table = vc1_simple_progressive_8x8_zz;
2147
2148         while (!last) {
2149             vc1_decode_ac_coeff(v, &last, &skip, &value, codingset);
2150             i += skip;
2151             if(i > 63)
2152                 break;
2153             block[zz_table[i++]] = value;
2154         }
2155
2156         /* apply AC prediction if needed */
2157         if(use_pred) {
2158             /* scale predictors if needed*/
2159             if(q2 && q1!=q2) {
2160                 q1 = q1 * 2 - 1;
2161                 q2 = q2 * 2 - 1;
2162
2163                 if(dc_pred_dir) { //left
2164                     for(k = 1; k < 8; k++)
2165                         block[k << 3] += (ac_val[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2166                 } else { //top
2167                     for(k = 1; k < 8; k++)
2168                         block[k] += (ac_val[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2169                 }
2170             } else {
2171                 if(dc_pred_dir) { //left
2172                     for(k = 1; k < 8; k++)
2173                         block[k << 3] += ac_val[k];
2174                 } else { //top
2175                     for(k = 1; k < 8; k++)
2176                         block[k] += ac_val[k + 8];
2177                 }
2178             }
2179         }
2180         /* save AC coeffs for further prediction */
2181         for(k = 1; k < 8; k++) {
2182             ac_val2[k] = block[k << 3];
2183             ac_val2[k + 8] = block[k];
2184         }
2185
2186         /* scale AC coeffs */
2187         for(k = 1; k < 64; k++)
2188             if(block[k]) {
2189                 block[k] *= scale;
2190                 if(!v->pquantizer)
2191                     block[k] += (block[k] < 0) ? -mquant : mquant;
2192             }
2193
2194         if(use_pred) i = 63;
2195     } else { // no AC coeffs
2196         int k;
2197
2198         memset(ac_val2, 0, 16 * 2);
2199         if(dc_pred_dir) {//left
2200             if(use_pred) {
2201                 memcpy(ac_val2, ac_val, 8 * 2);
2202                 if(q2 && q1!=q2) {
2203                     q1 = q1 * 2 - 1;
2204                     q2 = q2 * 2 - 1;
2205                     for(k = 1; k < 8; k++)
2206                         ac_val2[k] = (ac_val2[k] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2207                 }
2208             }
2209         } else {//top
2210             if(use_pred) {
2211                 memcpy(ac_val2 + 8, ac_val + 8, 8 * 2);
2212                 if(q2 && q1!=q2) {
2213                     q1 = q1 * 2 - 1;
2214                     q2 = q2 * 2 - 1;
2215                     for(k = 1; k < 8; k++)
2216                         ac_val2[k + 8] = (ac_val2[k + 8] * q2 * vc1_dqscale[q1 - 1] + 0x20000) >> 18;
2217                 }
2218             }
2219         }
2220
2221         /* apply AC prediction if needed */
2222         if(use_pred) {
2223             if(dc_pred_dir) { //left
2224                 for(k = 1; k < 8; k++) {
2225                     block[k << 3] = ac_val2[k] * scale;
2226                     if(!v->pquantizer)
2227                         block[k << 3] += (block[k << 3] < 0) ? -mquant : mquant;
2228                 }
2229             } else { //top
2230                 for(k = 1; k < 8; k++) {
2231                     block[k] = ac_val2[k + 8] * scale;
2232                     if(!v->pquantizer)
2233                         block[k] += (block[k] < 0) ? -mquant : mquant;
2234                 }
2235             }
2236             i = 63;
2237         }
2238     }
2239     s->block_last_index[n] = i;
2240
2241     return 0;
2242 }
2243
2244 /** Decode P block
2245  */
2246 static int vc1_decode_p_block(VC1Context *v, DCTELEM block[64], int n, int mquant, int ttmb, int first_block)
2247 {
2248     MpegEncContext *s = &v->s;
2249     GetBitContext *gb = &s->gb;
2250     int i, j;
2251     int subblkpat = 0;
2252     int scale, off, idx, last, skip, value;
2253     int ttblk = ttmb & 7;
2254
2255     if(ttmb == -1) {
2256         ttblk = ttblk_to_tt[v->tt_index][get_vlc2(gb, vc1_ttblk_vlc[v->tt_index].table, VC1_TTBLK_VLC_BITS, 1)];
2257     }
2258     if(ttblk == TT_4X4) {
2259         subblkpat = ~(get_vlc2(gb, vc1_subblkpat_vlc[v->tt_index].table, VC1_SUBBLKPAT_VLC_BITS, 1) + 1);
2260     }
2261     if((ttblk != TT_8X8 && ttblk != TT_4X4) && (v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block))) {
2262         subblkpat = decode012(gb);
2263         if(subblkpat) subblkpat ^= 3; //swap decoded pattern bits
2264         if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) ttblk = TT_8X4;
2265         if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) ttblk = TT_4X8;
2266     }
2267     scale = 2 * mquant;
2268
2269     // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT
2270     if(ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) {
2271         subblkpat = 2 - (ttblk == TT_8X4_TOP);
2272         ttblk = TT_8X4;
2273     }
2274     if(ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) {
2275         subblkpat = 2 - (ttblk == TT_4X8_LEFT);
2276         ttblk = TT_4X8;
2277     }
2278     switch(ttblk) {
2279     case TT_8X8:
2280         i = 0;
2281         last = 0;
2282         while (!last) {
2283             vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2284             i += skip;
2285             if(i > 63)
2286                 break;
2287             idx = vc1_simple_progressive_8x8_zz[i++];
2288             block[idx] = value * scale;
2289         }
2290         vc1_inv_trans(block, 8, 8);
2291         break;
2292     case TT_4X4:
2293         for(j = 0; j < 4; j++) {
2294             last = subblkpat & (1 << (3 - j));
2295             i = 0;
2296             off = (j & 1) * 4 + (j & 2) * 16;
2297             while (!last) {
2298                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2299                 i += skip;
2300                 if(i > 15)
2301                     break;
2302                 idx = vc1_simple_progressive_4x4_zz[i++];
2303                 block[idx + off] = value * scale;
2304             }
2305             if(!(subblkpat & (1 << (3 - j))))
2306                 vc1_inv_trans(block + off, 4, 4);
2307         }
2308         break;
2309     case TT_8X4:
2310         for(j = 0; j < 2; j++) {
2311             last = subblkpat & (1 << (1 - j));
2312             i = 0;
2313             off = j * 32;
2314             while (!last) {
2315                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2316                 i += skip;
2317                 if(i > 31)
2318                     break;
2319                 idx = vc1_simple_progressive_8x4_zz[i++];
2320                 block[idx + off] = value * scale;
2321             }
2322             if(!(subblkpat & (1 << (1 - j))))
2323                 vc1_inv_trans(block + off, 8, 4);
2324         }
2325         break;
2326     case TT_4X8:
2327         for(j = 0; j < 2; j++) {
2328             last = subblkpat & (1 << (1 - j));
2329             i = 0;
2330             off = j * 4;
2331             while (!last) {
2332                 vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2);
2333                 i += skip;
2334                 if(i > 31)
2335                     break;
2336                 idx = vc1_simple_progressive_4x8_zz[i++];
2337                 block[idx + off] = value * scale;
2338             }
2339             if(!(subblkpat & (1 << (1 - j))))
2340                 vc1_inv_trans(block + off, 4, 8);
2341         }
2342         break;
2343     }
2344     return 0;
2345 }
2346
2347
2348 /** Decode one P-frame MB (in Simple/Main profile)
2349  * @todo TODO: Extend to AP
2350  * @fixme FIXME: DC value for inter blocks not set
2351  */
2352 static int vc1_decode_p_mb(VC1Context *v, DCTELEM block[6][64])
2353 {
2354     MpegEncContext *s = &v->s;
2355     GetBitContext *gb = &s->gb;
2356     int i, j;
2357     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
2358     int cbp; /* cbp decoding stuff */
2359     int mqdiff, mquant; /* MB quantization */
2360     int ttmb = v->ttfrm; /* MB Transform type */
2361     int status;
2362
2363     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2364       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2365     int mb_has_coeffs = 1; /* last_flag */
2366     int dmv_x, dmv_y; /* Differential MV components */
2367     int index, index1; /* LUT indices */
2368     int val, sign; /* temp values */
2369     int first_block = 1;
2370     int dst_idx, off;
2371     int skipped, fourmv;
2372
2373     mquant = v->pq; /* Loosy initialization */
2374
2375     if (v->mv_type_is_raw)
2376         fourmv = get_bits1(gb);
2377     else
2378         fourmv = v->mv_type_mb_plane[mb_pos];
2379     if (v->skip_is_raw)
2380         skipped = get_bits1(gb);
2381     else
2382         skipped = v->s.mbskip_table[mb_pos];
2383
2384     s->dsp.clear_blocks(s->block[0]);
2385
2386     if (!fourmv) /* 1MV mode */
2387     {
2388         if (!skipped)
2389         {
2390             GET_MVDATA(dmv_x, dmv_y);
2391
2392             s->current_picture.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16;
2393             vc1_pred_mv(s, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type[0]);
2394
2395             /* FIXME Set DC val for inter block ? */
2396             if (s->mb_intra && !mb_has_coeffs)
2397             {
2398                 GET_MQUANT();
2399                 s->ac_pred = get_bits(gb, 1);
2400                 cbp = 0;
2401             }
2402             else if (mb_has_coeffs)
2403             {
2404                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2405                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2406                 GET_MQUANT();
2407             }
2408             else
2409             {
2410                 mquant = v->pq;
2411                 cbp = 0;
2412             }
2413             s->current_picture.qscale_table[mb_pos] = mquant;
2414
2415             if (!v->ttmbf && !s->mb_intra && mb_has_coeffs)
2416                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table,
2417                                 VC1_TTMB_VLC_BITS, 2);
2418             if(!s->mb_intra) vc1_mc_1mv(v);
2419             dst_idx = 0;
2420             for (i=0; i<6; i++)
2421             {
2422                 s->dc_val[0][s->block_index[i]] = 0;
2423                 dst_idx += i >> 2;
2424                 val = ((cbp >> (5 - i)) & 1);
2425                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2426                 v->mb_type[0][s->block_index[i]] = s->mb_intra;
2427                 if(s->mb_intra) {
2428                     /* check if prediction blocks A and C are available */
2429                     v->a_avail = v->c_avail = 0;
2430                     if(i == 2 || i == 3 || !s->first_slice_line)
2431                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2432                     if(i == 1 || i == 3 || s->mb_x)
2433                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2434
2435                     vc1_decode_intra_block(v, block[i], i, val, mquant, (i&4)?v->codingset2:v->codingset);
2436                     vc1_inv_trans(block[i], 8, 8);
2437                     for(j = 0; j < 64; j++) block[i][j] += 128;
2438                     s->dsp.put_pixels_clamped(block[i], s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2439                     /* TODO: proper loop filtering */
2440                     if(v->pq >= 9 && v->overlap) {
2441                         if(v->a_avail)
2442                             vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2443                         if(v->c_avail)
2444                             vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2445                     }
2446                 } else if(val) {
2447                     vc1_decode_p_block(v, block[i], i, mquant, ttmb, first_block);
2448                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
2449                     first_block = 0;
2450                     s->dsp.add_pixels_clamped(block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2451                 }
2452             }
2453         }
2454         else //Skipped
2455         {
2456             s->mb_intra = 0;
2457             for(i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
2458             s->current_picture.mb_type[mb_pos] = MB_TYPE_SKIP;
2459             s->current_picture.qscale_table[mb_pos] = 0;
2460             vc1_pred_mv(s, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type[0]);
2461             vc1_mc_1mv(v);
2462             return 0;
2463         }
2464     } //1MV mode
2465     else //4MV mode
2466     {
2467         if (!skipped /* unskipped MB */)
2468         {
2469             int intra_count = 0, coded_inter = 0;
2470             int is_intra[6], is_coded[6];
2471             /* Get CBPCY */
2472             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC1_CBPCY_P_VLC_BITS, 2);
2473             for (i=0; i<6; i++)
2474             {
2475                 val = ((cbp >> (5 - i)) & 1);
2476                 s->dc_val[0][s->block_index[i]] = 0;
2477                 s->mb_intra = 0;
2478                 if(i < 4) {
2479                     dmv_x = dmv_y = 0;
2480                     s->mb_intra = 0;
2481                     mb_has_coeffs = 0;
2482                     if(val) {
2483                         GET_MVDATA(dmv_x, dmv_y);
2484                     }
2485                     vc1_pred_mv(s, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type[0]);
2486                     if(!s->mb_intra) vc1_mc_4mv_luma(v, i);
2487                     intra_count += s->mb_intra;
2488                     is_intra[i] = s->mb_intra;
2489                     is_coded[i] = mb_has_coeffs;
2490                 }
2491                 if(i&4){
2492                     is_intra[i] = (intra_count >= 3);
2493                     is_coded[i] = val;
2494                 }
2495                 if(i == 4) vc1_mc_4mv_chroma(v);
2496                 v->mb_type[0][s->block_index[i]] = is_intra[i];
2497                 if(!coded_inter) coded_inter = !is_intra[i] & is_coded[i];
2498             }
2499             // if there are no coded blocks then don't do anything more
2500             if(!intra_count && !coded_inter) return 0;
2501             dst_idx = 0;
2502             GET_MQUANT();
2503             s->current_picture.qscale_table[mb_pos] = mquant;
2504             /* test if block is intra and has pred */
2505             {
2506                 int intrapred = 0;
2507                 for(i=0; i<6; i++)
2508                     if(is_intra[i]) {
2509                         if(((!s->first_slice_line || (i==2 || i==3)) && v->mb_type[0][s->block_index[i] - s->block_wrap[i]])
2510                             || ((s->mb_x || (i==1 || i==3)) && v->mb_type[0][s->block_index[i] - 1])) {
2511                             intrapred = 1;
2512                             break;
2513                         }
2514                     }
2515                 if(intrapred)s->ac_pred = get_bits(gb, 1);
2516                 else s->ac_pred = 0;
2517             }
2518             if (!v->ttmbf && coded_inter)
2519                 ttmb = get_vlc2(gb, vc1_ttmb_vlc[v->tt_index].table, VC1_TTMB_VLC_BITS, 12);
2520             for (i=0; i<6; i++)
2521             {
2522                 dst_idx += i >> 2;
2523                 off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize);
2524                 s->mb_intra = is_intra[i];
2525                 if (is_intra[i]) {
2526                     /* check if prediction blocks A and C are available */
2527                     v->a_avail = v->c_avail = 0;
2528                     if(i == 2 || i == 3 || !s->first_slice_line)
2529                         v->a_avail = v->mb_type[0][s->block_index[i] - s->block_wrap[i]];
2530                     if(i == 1 || i == 3 || s->mb_x)
2531                         v->c_avail = v->mb_type[0][s->block_index[i] - 1];
2532
2533                     vc1_decode_intra_block(v, s->block[i], i, is_coded[i], mquant, (i&4)?v->codingset2:v->codingset);
2534                     vc1_inv_trans(block[i], 8, 8);
2535                     for(j = 0; j < 64; j++) block[i][j] += 128;
2536                     s->dsp.put_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2537                     /* TODO: proper loop filtering */
2538                     if(v->pq >= 9 && v->overlap) {
2539                         if(v->a_avail)
2540                             vc1_v_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2541                         if(v->c_avail)
2542                             vc1_h_overlap(s->dest[dst_idx] + off, s->linesize >> ((i & 4) >> 2));
2543                     }
2544                 } else if(is_coded[i]) {
2545                     status = vc1_decode_p_block(v, s->block[i], i, mquant, ttmb, first_block);
2546                     if(!v->ttmbf && ttmb < 8) ttmb = -1;
2547                     first_block = 0;
2548                     s->dsp.add_pixels_clamped(s->block[i], s->dest[dst_idx] + off, (i&4)?s->uvlinesize:s->linesize);
2549                 }
2550             }
2551             return status;
2552         }
2553         else //Skipped MB
2554         {
2555             s->mb_intra = 0;
2556             for (i=0; i<6; i++) v->mb_type[0][s->block_index[i]] = 0;
2557             for (i=0; i<4; i++)
2558             {
2559                 vc1_pred_mv(s, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type[0]);
2560                 vc1_mc_4mv_luma(v, i);
2561             }
2562             vc1_mc_4mv_chroma(v);
2563             s->current_picture.qscale_table[mb_pos] = 0;
2564             return 0;
2565         }
2566     }
2567
2568     /* Should never happen */
2569     return -1;
2570 }
2571
2572 /** Decode blocks of I-frame
2573  */
2574 static void vc1_decode_i_blocks(VC1Context *v)
2575 {
2576     int k, j;
2577     MpegEncContext *s = &v->s;
2578     int cbp, val;
2579     uint8_t *coded_val;
2580     int mb_pos;
2581
2582     /* select codingmode used for VLC tables selection */
2583     switch(v->y_ac_table_index){
2584     case 0:
2585         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2586         break;
2587     case 1:
2588         v->codingset = CS_HIGH_MOT_INTRA;
2589         break;
2590     case 2:
2591         v->codingset = CS_MID_RATE_INTRA;
2592         break;
2593     }
2594
2595     switch(v->c_ac_table_index){
2596     case 0:
2597         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2598         break;
2599     case 1:
2600         v->codingset2 = CS_HIGH_MOT_INTER;
2601         break;
2602     case 2:
2603         v->codingset2 = CS_MID_RATE_INTER;
2604         break;
2605     }
2606
2607     /* Set DC scale - y and c use the same */
2608     s->y_dc_scale = s->y_dc_scale_table[v->pq];
2609     s->c_dc_scale = s->c_dc_scale_table[v->pq];
2610
2611     //do frame decode
2612     s->mb_x = s->mb_y = 0;
2613     s->mb_intra = 1;
2614     s->first_slice_line = 1;
2615     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2616     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2617         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2618             ff_init_block_index(s);
2619             ff_update_block_index(s);
2620             s->dsp.clear_blocks(s->block[0]);
2621             mb_pos = s->mb_x + s->mb_y * s->mb_width;
2622             s->current_picture.mb_type[mb_pos] = MB_TYPE_INTRA;
2623             s->current_picture.qscale_table[mb_pos] = v->pq;
2624
2625             // do actual MB decoding and displaying
2626             cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
2627             v->s.ac_pred = get_bits(&v->s.gb, 1);
2628
2629             for(k = 0; k < 6; k++) {
2630                 val = ((cbp >> (5 - k)) & 1);
2631
2632                 if (k < 4) {
2633                     int pred = vc1_coded_block_pred(&v->s, k, &coded_val);
2634                     val = val ^ pred;
2635                     *coded_val = val;
2636                 }
2637                 cbp |= val << (5 - k);
2638
2639                 vc1_decode_i_block(v, s->block[k], k, val, (k<4)? v->codingset : v->codingset2);
2640
2641                 vc1_inv_trans(s->block[k], 8, 8);
2642                 if(v->pq >= 9 && v->overlap) {
2643                     for(j = 0; j < 64; j++) s->block[k][j] += 128;
2644                 }
2645             }
2646
2647             vc1_put_block(v, s->block);
2648             if(v->pq >= 9 && v->overlap) { /* XXX: do proper overlapping insted of loop filter */
2649                 if(!s->first_slice_line) {
2650                     vc1_v_overlap(s->dest[0], s->linesize);
2651                     vc1_v_overlap(s->dest[0] + 8, s->linesize);
2652                     vc1_v_overlap(s->dest[1], s->uvlinesize);
2653                     vc1_v_overlap(s->dest[2], s->uvlinesize);
2654                 }
2655                 vc1_v_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2656                 vc1_v_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2657                 if(s->mb_x) {
2658                     vc1_h_overlap(s->dest[0], s->linesize);
2659                     vc1_h_overlap(s->dest[0] + 8 * s->linesize, s->linesize);
2660                     vc1_h_overlap(s->dest[1], s->uvlinesize);
2661                     vc1_h_overlap(s->dest[2], s->uvlinesize);
2662                 }
2663                 vc1_h_overlap(s->dest[0] + 8, s->linesize);
2664                 vc1_h_overlap(s->dest[0] + 8 * s->linesize + 8, s->linesize);
2665             }
2666
2667             if(get_bits_count(&s->gb) > v->bits) {
2668                 av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", get_bits_count(&s->gb), v->bits);
2669                 return;
2670             }
2671         }
2672         ff_draw_horiz_band(s, s->mb_y * 16, 16);
2673         s->first_slice_line = 0;
2674     }
2675 }
2676
2677 static void vc1_decode_p_blocks(VC1Context *v)
2678 {
2679     MpegEncContext *s = &v->s;
2680
2681     /* select codingmode used for VLC tables selection */
2682     switch(v->c_ac_table_index){
2683     case 0:
2684         v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
2685         break;
2686     case 1:
2687         v->codingset = CS_HIGH_MOT_INTRA;
2688         break;
2689     case 2:
2690         v->codingset = CS_MID_RATE_INTRA;
2691         break;
2692     }
2693
2694     switch(v->c_ac_table_index){
2695     case 0:
2696         v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER;
2697         break;
2698     case 1:
2699         v->codingset2 = CS_HIGH_MOT_INTER;
2700         break;
2701     case 2:
2702         v->codingset2 = CS_MID_RATE_INTER;
2703         break;
2704     }
2705
2706     ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, (AC_END|DC_END|MV_END));
2707     s->first_slice_line = 1;
2708     for(s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
2709         for(s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
2710             ff_init_block_index(s);
2711             ff_update_block_index(s);
2712             s->dsp.clear_blocks(s->block[0]);
2713
2714             vc1_decode_p_mb(v, s->block);
2715             if(get_bits_count(&s->gb) > v->bits || get_bits_count(&s->gb) < 0) {
2716                 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);
2717                 return;
2718             }
2719         }
2720         ff_draw_horiz_band(s, s->mb_y * 16, 16);
2721         s->first_slice_line = 0;
2722     }
2723 }
2724
2725 static void vc1_decode_blocks(VC1Context *v)
2726 {
2727
2728     v->s.esc3_level_length = 0;
2729
2730     switch(v->s.pict_type) {
2731     case I_TYPE:
2732         vc1_decode_i_blocks(v);
2733         break;
2734     case P_TYPE:
2735         vc1_decode_p_blocks(v);
2736         break;
2737     }
2738 }
2739
2740
2741 /** Initialize a VC1/WMV3 decoder
2742  * @todo TODO: Handle VC-1 IDUs (Transport level?)
2743  * @todo TODO: Decypher remaining bits in extra_data
2744  */
2745 static int vc1_decode_init(AVCodecContext *avctx)
2746 {
2747     VC1Context *v = avctx->priv_data;
2748     MpegEncContext *s = &v->s;
2749     GetBitContext gb;
2750
2751     if (!avctx->extradata_size || !avctx->extradata) return -1;
2752     avctx->pix_fmt = PIX_FMT_YUV420P;
2753     v->s.avctx = avctx;
2754     avctx->flags |= CODEC_FLAG_EMU_EDGE;
2755     v->s.flags |= CODEC_FLAG_EMU_EDGE;
2756
2757     if(ff_h263_decode_init(avctx) < 0)
2758         return -1;
2759     if (vc1_init_common(v) < 0) return -1;
2760
2761     av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2762     av_log(avctx, AV_LOG_INFO, "If you see a picture, don't believe your eyes.\n");
2763
2764     avctx->coded_width = avctx->width;
2765     avctx->coded_height = avctx->height;
2766     if (avctx->codec_id == CODEC_ID_WMV3)
2767     {
2768         int count = 0;
2769
2770         // looks like WMV3 has a sequence header stored in the extradata
2771         // advanced sequence header may be before the first frame
2772         // the last byte of the extradata is a version number, 1 for the
2773         // samples we can decode
2774
2775         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2776
2777         if (decode_sequence_header(avctx, &gb) < 0)
2778           return -1;
2779
2780         count = avctx->extradata_size*8 - get_bits_count(&gb);
2781         if (count>0)
2782         {
2783             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2784                    count, get_bits(&gb, count));
2785         }
2786         else if (count < 0)
2787         {
2788             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2789         }
2790     }
2791     avctx->has_b_frames= !!(avctx->max_b_frames);
2792
2793     s->mb_width = (avctx->coded_width+15)>>4;
2794     s->mb_height = (avctx->coded_height+15)>>4;
2795
2796     /* Allocate mb bitplanes */
2797     v->mv_type_mb_plane = av_malloc(s->mb_stride * s->mb_height);
2798
2799     /* allocate block type info in that way so it could be used with s->block_index[] */
2800     v->mb_type_base = av_malloc(s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride * (s->mb_height + 1) * 2);
2801     v->mb_type[0] = v->mb_type_base + s->b8_stride + 1;
2802     v->mb_type[1] = v->mb_type_base + s->b8_stride * (s->mb_height * 2 + 1) + s->mb_stride + 1;
2803     v->mb_type[2] = v->mb_type[1] + s->mb_stride * (s->mb_height + 1);
2804
2805     /* Init coded blocks info */
2806     if (v->profile == PROFILE_ADVANCED)
2807     {
2808 //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2809 //            return -1;
2810 //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2811 //            return -1;
2812     }
2813
2814     return 0;
2815 }
2816
2817
2818 /** Decode a VC1/WMV3 frame
2819  * @todo TODO: Handle VC-1 IDUs (Transport level?)
2820  * @warning Initial try at using MpegEncContext stuff
2821  */
2822 static int vc1_decode_frame(AVCodecContext *avctx,
2823                             void *data, int *data_size,
2824                             uint8_t *buf, int buf_size)
2825 {
2826     VC1Context *v = avctx->priv_data;
2827     MpegEncContext *s = &v->s;
2828     AVFrame *pict = data;
2829
2830     /* no supplementary picture */
2831     if (buf_size == 0) {
2832         /* special case for last picture */
2833         if (s->low_delay==0 && s->next_picture_ptr) {
2834             *pict= *(AVFrame*)s->next_picture_ptr;
2835             s->next_picture_ptr= NULL;
2836
2837             *data_size = sizeof(AVFrame);
2838         }
2839
2840         return 0;
2841     }
2842
2843     //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2844     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2845         int i= ff_find_unused_picture(s, 0);
2846         s->current_picture_ptr= &s->picture[i];
2847     }
2848
2849     avctx->has_b_frames= !s->low_delay;
2850
2851     init_get_bits(&s->gb, buf, buf_size*8);
2852     // do parse frame header
2853     if(vc1_parse_frame_header(v, &s->gb) == -1)
2854         return -1;
2855
2856     if(s->pict_type != I_TYPE && s->pict_type != P_TYPE)return -1;
2857
2858     // for hurry_up==5
2859     s->current_picture.pict_type= s->pict_type;
2860     s->current_picture.key_frame= s->pict_type == I_TYPE;
2861
2862     /* skip B-frames if we don't have reference frames */
2863     if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable)) return -1;//buf_size;
2864     /* skip b frames if we are in a hurry */
2865     if(avctx->hurry_up && s->pict_type==B_TYPE) return -1;//buf_size;
2866     if(   (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
2867        || (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
2868        ||  avctx->skip_frame >= AVDISCARD_ALL)
2869         return buf_size;
2870     /* skip everything if we are in a hurry>=5 */
2871     if(avctx->hurry_up>=5) return -1;//buf_size;
2872
2873     if(s->next_p_frame_damaged){
2874         if(s->pict_type==B_TYPE)
2875             return buf_size;
2876         else
2877             s->next_p_frame_damaged=0;
2878     }
2879
2880     if(MPV_frame_start(s, avctx) < 0)
2881         return -1;
2882
2883     ff_er_frame_start(s);
2884
2885     v->bits = buf_size * 8;
2886     vc1_decode_blocks(v);
2887 //av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), buf_size*8);
2888 //  if(get_bits_count(&s->gb) > buf_size * 8)
2889 //      return -1;
2890     ff_er_frame_end(s);
2891
2892     MPV_frame_end(s);
2893
2894 assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2895 assert(s->current_picture.pict_type == s->pict_type);
2896     if (s->pict_type == B_TYPE || s->low_delay) {
2897         *pict= *(AVFrame*)s->current_picture_ptr;
2898     } else if (s->last_picture_ptr != NULL) {
2899         *pict= *(AVFrame*)s->last_picture_ptr;
2900     }
2901
2902     if(s->last_picture_ptr || s->low_delay){
2903         *data_size = sizeof(AVFrame);
2904         ff_print_debug_info(s, pict);
2905     }
2906
2907     /* Return the Picture timestamp as the frame number */
2908     /* we substract 1 because it is added on utils.c    */
2909     avctx->frame_number = s->picture_number - 1;
2910
2911     return buf_size;
2912 }
2913
2914
2915 /** Close a VC1/WMV3 decoder
2916  * @warning Initial try at using MpegEncContext stuff
2917  */
2918 static int vc1_decode_end(AVCodecContext *avctx)
2919 {
2920     VC1Context *v = avctx->priv_data;
2921
2922     av_freep(&v->hrd_rate);
2923     av_freep(&v->hrd_buffer);
2924     MPV_common_end(&v->s);
2925     av_freep(&v->mv_type_mb_plane);
2926     av_freep(&v->mb_type_base);
2927     return 0;
2928 }
2929
2930
2931 AVCodec vc1_decoder = {
2932     "vc1",
2933     CODEC_TYPE_VIDEO,
2934     CODEC_ID_VC1,
2935     sizeof(VC1Context),
2936     vc1_decode_init,
2937     NULL,
2938     vc1_decode_end,
2939     vc1_decode_frame,
2940     CODEC_CAP_DELAY,
2941     NULL
2942 };
2943
2944 AVCodec wmv3_decoder = {
2945     "wmv3",
2946     CODEC_TYPE_VIDEO,
2947     CODEC_ID_WMV3,
2948     sizeof(VC1Context),
2949     vc1_decode_init,
2950     NULL,
2951     vc1_decode_end,
2952     vc1_decode_frame,
2953     CODEC_CAP_DELAY,
2954     NULL
2955 };