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

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