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