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

   1 /*
   2  * VC-9 and WMV3 decoder
   3  * Copyright (c) 2005 Anonymous
   4  * Copyright (c) 2005 Alex Beregszaszi
   5  * Copyright (c) 2005 Michael Niedermayer
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  *
  21  */
  22
  23 /**
  24  * @file vc9.c
  25  * VC-9 and WMV3 decoder
  26  *
  27  * TODO: most AP stuff, optimize, most of MB layer, transform, filtering and motion compensation, etc
  28  * TODO: use MPV_ !!
  29  */
  30 #include "common.h"
  31 #include "dsputil.h"
  32 #include "avcodec.h"
  33 #include "mpegvideo.h"
  34 #include "vc9data.h"
  35
  36 #undef NDEBUG
  37 #include <assert.h>
  38
  39 extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];
  40 extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];
  41 extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];
  42 #define MB_INTRA_VLC_BITS 9
  43 extern VLC ff_msmp4_mb_i_vlc;
  44 #define DC_VLC_BITS 9
  45 static const uint16_t table_mb_intra[64][2];
  46
  47 /* Some inhibiting stuff */
  48 #define HAS_ADVANCED_PROFILE   0
  49 #define TRACE                  1
  50
  51 #if TRACE
  52 #  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
  53                    codes, codes_wrap, codes_size, use_static)          \
  54   if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,     \
  55                codes, codes_wrap, codes_size, use_static) < 0)         \
  56   {                                                                    \
  57     av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i);   \
  58     return -1;                                                         \
  59   }
  60 #else
  61 #  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \
  62                    codes, codes_wrap, codes_size, use_static)          \
  63   init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,         \
  64            codes, codes_wrap, codes_size, use_static)
  65 #endif
  66
  67 /** Available Profiles */
  68 //@{
  69 #define PROFILE_SIMPLE   0
  70 #define PROFILE_MAIN     1
  71 #define PROFILE_COMPLEX  2 ///< TODO: WMV9 specific
  72 #define PROFILE_ADVANCED 3
  73 //@}
  74
  75 /** Sequence quantizer mode */
  76 //@{
  77 #define QUANT_FRAME_IMPLICIT   0 ///< Implicitly specified at frame level
  78 #define QUANT_FRAME_EXPLICIT   1 ///< Explicitly specified at frame level
  79 #define QUANT_NON_UNIFORM      2 ///< Non-uniform quant used for all frames
  80 #define QUANT_UNIFORM          3 ///< Uniform quant used for all frames
  81 //@}
  82
  83 /** Where quant can be changed */
  84 //@{
  85 #define DQPROFILE_FOUR_EDGES   0
  86 #define DQPROFILE_DOUBLE_EDGES 1
  87 #define DQPROFILE_SINGLE_EDGE  2
  88 #define DQPROFILE_ALL_MBS      3
  89 //@}
  90
  91 /** @name Where quant can be changed
  92  */
  93 //@{
  94 #define DQPROFILE_FOUR_EDGES   0
  95 #define DQSINGLE_BEDGE_LEFT   0
  96 #define DQSINGLE_BEDGE_TOP    1
  97 #define DQSINGLE_BEDGE_RIGHT  2
  98 #define DQSINGLE_BEDGE_BOTTOM 3
  99 //@}
 100
 101 /** Which pair of edges is quantized with ALTPQUANT */
 102 //@{
 103 #define DQDOUBLE_BEDGE_TOPLEFT     0
 104 #define DQDOUBLE_BEDGE_TOPRIGHT    1
 105 #define DQDOUBLE_BEDGE_BOTTOMRIGHT 2
 106 #define DQDOUBLE_BEDGE_BOTTOMLEFT  3
 107 //@}
 108
 109 /** MV modes for P frames */
 110 //@{
 111 #define MV_PMODE_1MV_HPEL_BILIN   0
 112 #define MV_PMODE_1MV              1
 113 #define MV_PMODE_1MV_HPEL         2
 114 #define MV_PMODE_MIXED_MV         3
 115 #define MV_PMODE_INTENSITY_COMP   4
 116 //@}
 117
 118 /** @name MV types for B frames */
 119 //@{
 120 #define BMV_TYPE_BACKWARD          0
 121 #define BMV_TYPE_BACKWARD          0
 122 #define BMV_TYPE_FORWARD           1
 123 #define BMV_TYPE_INTERPOLATED      3
 124 //@}
 125
 126 /** MV P mode - the 5th element is only used for mode 1 */
 127 static const uint8_t mv_pmode_table[2][5] = {
 128   { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },
 129   { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }
 130 };
 131
 132 /** One more frame type */
 133 #define BI_TYPE 7
 134
 135 static const int fps_nr[5] = { 24, 25, 30, 50, 60 },
 136   fps_dr[2] = { 1000, 1001 };
 137 static const uint8_t pquant_table[3][32] = {
 138   {  /* Implicit quantizer */
 139      0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,
 140     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31
 141   },
 142   {  /* Explicit quantizer, pquantizer uniform */
 143      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
 144     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
 145   },
 146   {  /* Explicit quantizer, pquantizer non-uniform */
 147      0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,
 148     14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31
 149   }
 150 };
 151
 152 /** @name VC-9 VLC tables and defines
 153  *  @todo TODO move this into the context
 154  */
 155 //@{
 156 #define VC9_BFRACTION_VLC_BITS 7
 157 static VLC vc9_bfraction_vlc;
 158 #define VC9_IMODE_VLC_BITS 4
 159 static VLC vc9_imode_vlc;
 160 #define VC9_NORM2_VLC_BITS 3
 161 static VLC vc9_norm2_vlc;
 162 #define VC9_NORM6_VLC_BITS 9
 163 static VLC vc9_norm6_vlc;
 164 /* Could be optimized, one table only needs 8 bits */
 165 #define VC9_TTMB_VLC_BITS 9 //12
 166 static VLC vc9_ttmb_vlc[3];
 167 #define VC9_MV_DIFF_VLC_BITS 9 //15
 168 static VLC vc9_mv_diff_vlc[4];
 169 #define VC9_CBPCY_P_VLC_BITS 9 //14
 170 static VLC vc9_cbpcy_p_vlc[4];
 171 #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6
 172 static VLC vc9_4mv_block_pattern_vlc[4];
 173 #define VC9_TTBLK_VLC_BITS 5
 174 static VLC vc9_ttblk_vlc[3];
 175 #define VC9_SUBBLKPAT_VLC_BITS 6
 176 static VLC vc9_subblkpat_vlc[3];
 177 //@}
 178
 179 /** Bitplane struct
 180  * We mainly need data and is_raw, so this struct could be avoided
 181  * to save a level of indirection; feel free to modify
 182  * @fixme For now, stride=width
 183  * @warning Data are bits, either 1 or 0
 184  */
 185 typedef struct BitPlane {
 186     uint8_t *data;      ///< Data buffer
 187     int width;          ///< Width of the buffer
 188     int stride;         ///< Stride of the buffer
 189     int height;         ///< Plane height
 190     uint8_t is_raw;     ///< Bit values must be read at MB level
 191 } BitPlane;
 192
 193 /** The VC9 Context
 194  * @fixme Change size wherever another size is more efficient
 195  * Many members are only used for Advanced Profile
 196  */
 197 typedef struct VC9Context{
 198     MpegEncContext s;
 199
 200     /** Simple/Main Profile sequence header */
 201     //@{
 202     int res_sm;           ///< reserved, 2b
 203     int res_x8;           ///< reserved
 204     int multires;         ///< frame-level RESPIC syntax element present
 205     int res_fasttx;       ///< reserved, always 1
 206     int res_transtab;     ///< reserved, always 0
 207     int rangered;         ///< RANGEREDFRM (range reduction) syntax element present
 208                           ///< at frame level
 209     int res_rtm_flag;     ///< reserved, set to 1
 210     int reserved;         ///< reserved
 211     //@}
 212
 213 #if HAS_ADVANCED_PROFILE
 214     /** Advanced Profile */
 215     //@{
 216     int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
 217     int chromaformat;     ///< 2bits, 2=4:2:0, only defined
 218     int postprocflag;     ///< Per-frame processing suggestion flag present
 219     int broadcast;        ///< TFF/RFF present
 220     int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)
 221     int tfcntrflag;       ///< TFCNTR present
 222     int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present
 223     int extended_dmv;     ///< Additional extended dmv range at P/B frame-level
 224     int color_prim;       ///< 8bits, chroma coordinates of the color primaries
 225     int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics
 226     int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix
 227     int hrd_param_flag;   ///< Presence of Hypothetical Reference
 228                           ///< Decoder parameters
 229     //@}
 230 #endif
 231
 232
 233     /** Sequence header data for all Profiles
 234      * TODO: choose between ints, uint8_ts and monobit flags
 235      */
 236     //@{
 237     int profile;          ///< 2bits, Profile
 238     int frmrtq_postproc;  ///< 3bits,
 239     int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength
 240     int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)
 241     int extended_mv;      ///< Ext MV in P/B (not in Simple)
 242     int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)
 243     int vstransform;      ///< variable-size [48]x[48] transform type + info
 244     int overlap;          ///< overlapped transforms in use
 245     int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*
 246     int finterpflag;      ///< INTERPFRM present
 247     //@}
 248
 249     /** Frame decoding info for all profiles */
 250     //@{
 251     uint8_t mv_mode;      ///< MV coding monde
 252     uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)
 253     int k_x;              ///< Number of bits for MVs (depends on MV range)
 254     int k_y;              ///< Number of bits for MVs (depends on MV range)
 255     uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
 256     /** pquant parameters */
 257     //@{
 258     uint8_t dquantfrm;
 259     uint8_t dqprofile;
 260     uint8_t dqsbedge;
 261     uint8_t dqbilevel;
 262     //@}
 263     /** AC coding set indexes
 264      * @see 8.1.1.10, p(1)10
 265      */
 266     //@{
 267     int c_ac_table_index; ///< Chroma index from ACFRM element
 268     int y_ac_table_index; ///< Luma index from AC2FRM element
 269     //@}
 270     int ttfrm;            ///< Transform type info present at frame level
 271     uint8_t ttmbf;        ///< Transform type flag
 272     int ttmb;             ///< Transform type
 273     uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
 274     /** Luma compensation parameters */
 275     //@{
 276     uint8_t lumscale;
 277     uint8_t lumshift;
 278     //@}
 279     int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs
 280     uint8_t halfpq;       ///< Uniform quant over image and qp+.5
 281     uint8_t respic;       ///< Frame-level flag for resized images
 282     int buffer_fullness;  ///< HRD info
 283     /** Ranges:
 284      * -# 0 -> [-64n 63.f] x [-32, 31.f]
 285      * -# 1 -> [-128, 127.f] x [-64, 63.f]
 286      * -# 2 -> [-512, 511.f] x [-128, 127.f]
 287      * -# 3 -> [-1024, 1023.f] x [-256, 255.f]
 288      */
 289     uint8_t mvrange;
 290     uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use
 291     uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY
 292     VLC *cbpcy_vlc;               ///< CBPCY VLC table
 293     int tt_index;                 ///< Index for Transform Type tables
 294     BitPlane mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)
 295     BitPlane skip_mb_plane;       ///< bitplane for skipped MBs
 296     BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs
 297
 298     /** Frame decoding info for S/M profiles only */
 299     //@{
 300     uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)
 301     uint8_t interpfrm;
 302     //@}
 303
 304 #if HAS_ADVANCED_PROFILE
 305     /** Frame decoding info for Advanced profile */
 306     //@{
 307     uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace
 308     uint8_t numpanscanwin;
 309     uint8_t tfcntr;
 310     uint8_t rptfrm, tff, rff;
 311     uint16_t topleftx;
 312     uint16_t toplefty;
 313     uint16_t bottomrightx;
 314     uint16_t bottomrighty;
 315     uint8_t uvsamp;
 316     uint8_t postproc;
 317     int hrd_num_leaky_buckets;
 318     uint8_t bit_rate_exponent;
 319     uint8_t buffer_size_exponent;
 320     BitPlane ac_pred_plane;       ///< AC prediction flags bitplane
 321     BitPlane over_flags_plane;    ///< Overflags bitplane
 322     uint8_t condover;
 323     uint16_t *hrd_rate, *hrd_buffer;
 324     uint8_t *hrd_fullness;
 325     uint8_t range_mapy_flag;
 326     uint8_t range_mapuv_flag;
 327     uint8_t range_mapy;
 328     uint8_t range_mapuv;
 329     //@}
 330 #endif
 331 } VC9Context;
 332
 333 /**
 334  * Get unary code of limited length
 335  * @fixme FIXME Slow and ugly
 336  * @param gb GetBitContext
 337  * @param[in] stop The bitstop value (unary code of 1's or 0's)
 338  * @param[in] len Maximum length
 339  * @return Unary length/index
 340  */
 341 static int get_prefix(GetBitContext *gb, int stop, int len)
 342 {
 343 #if 1
 344   int i = 0, tmp = !stop;
 345
 346   while (i != len && tmp != stop)
 347   {
 348     tmp = get_bits(gb, 1);
 349     i++;
 350   }
 351   if (i == len && tmp != stop) return len+1;
 352   return i;
 353 #else
 354   unsigned int buf;
 355   int log;
 356
 357   OPEN_READER(re, gb);
 358   UPDATE_CACHE(re, gb);
 359   buf=GET_CACHE(re, gb); //Still not sure
 360   if (stop) buf = ~buf;
 361
 362   log= av_log2(-buf); //FIXME: -?
 363   if (log < limit){
 364     LAST_SKIP_BITS(re, gb, log+1);
 365     CLOSE_READER(re, gb);
 366     return log;
 367   }
 368
 369   LAST_SKIP_BITS(re, gb, limit);
 370   CLOSE_READER(re, gb);
 371   return limit;
 372 #endif
 373 }
 374
 375 /**
 376  * Init VC-9 specific tables and VC9Context members
 377  * @param v The VC9Context to initialize
 378  * @return Status
 379  */
 380 static int vc9_init_common(VC9Context *v)
 381 {
 382     static int done = 0;
 383     int i = 0;
 384
 385     /* Set the bit planes */
 386     v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
 387     v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
 388     v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };
 389 #if HAS_ADVANCED_PROFILE
 390     v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };
 391     v->hrd_rate = v->hrd_buffer = NULL;
 392 #endif
 393
 394     /* VLC tables */
 395 #if 0 // spec -> actual tables converter
 396     for(i=0; i<64; i++){
 397         int code= (vc9_norm6_spec[i][1] << vc9_norm6_spec[i][4]) + vc9_norm6_spec[i][3];
 398         av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);
 399         if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
 400     }
 401     for(i=0; i<64; i++){
 402         int code= vc9_norm6_spec[i][2] + vc9_norm6_spec[i][4];
 403         av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);
 404         if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");
 405     }
 406 #endif
 407     if(!done)
 408     {
 409         done = 1;
 410         INIT_VLC(&vc9_bfraction_vlc, VC9_BFRACTION_VLC_BITS, 23,
 411                  vc9_bfraction_bits, 1, 1,
 412                  vc9_bfraction_codes, 1, 1, 1);
 413         INIT_VLC(&vc9_norm2_vlc, VC9_NORM2_VLC_BITS, 4,
 414                  vc9_norm2_bits, 1, 1,
 415                  vc9_norm2_codes, 1, 1, 1);
 416         INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,
 417                  vc9_norm6_bits, 1, 1,
 418                  vc9_norm6_codes, 2, 2, 1);
 419         INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,
 420                  vc9_imode_bits, 1, 1,
 421                  vc9_imode_codes, 1, 1, 1);
 422         for (i=0; i<3; i++)
 423         {
 424             INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,
 425                      vc9_ttmb_bits[i], 1, 1,
 426                      vc9_ttmb_codes[i], 2, 2, 1);
 427             INIT_VLC(&vc9_ttblk_vlc[i], VC9_TTBLK_VLC_BITS, 8,
 428                      vc9_ttblk_bits[i], 1, 1,
 429                      vc9_ttblk_codes[i], 1, 1, 1);
 430             INIT_VLC(&vc9_subblkpat_vlc[i], VC9_SUBBLKPAT_VLC_BITS, 15,
 431                      vc9_subblkpat_bits[i], 1, 1,
 432                      vc9_subblkpat_codes[i], 1, 1, 1);
 433         }
 434         for(i=0; i<4; i++)
 435         {
 436             INIT_VLC(&vc9_4mv_block_pattern_vlc[i], VC9_4MV_BLOCK_PATTERN_VLC_BITS, 16,
 437                      vc9_4mv_block_pattern_bits[i], 1, 1,
 438                      vc9_4mv_block_pattern_codes[i], 1, 1, 1);
 439             INIT_VLC(&vc9_cbpcy_p_vlc[i], VC9_CBPCY_P_VLC_BITS, 64,
 440                      vc9_cbpcy_p_bits[i], 1, 1,
 441                      vc9_cbpcy_p_codes[i], 2, 2, 1);
 442             INIT_VLC(&vc9_mv_diff_vlc[i], VC9_MV_DIFF_VLC_BITS, 73,
 443                      vc9_mv_diff_bits[i], 1, 1,
 444                      vc9_mv_diff_codes[i], 2, 2, 1);
 445         }
 446     }
 447
 448     /* Other defaults */
 449     v->pq = -1;
 450     v->mvrange = 0; /* 7.1.1.18, p80 */
 451
 452     return 0;
 453 }
 454
 455 #if HAS_ADVANCED_PROFILE
 456 /**
 457  * Decode sequence header's Hypothetic Reference Decoder data
 458  * @see 6.2.1, p32
 459  * @param v The VC9Context to initialize
 460  * @param gb A GetBitContext initialized from AVCodecContext extra_data
 461  * @return Status
 462  */
 463 static int decode_hrd(VC9Context *v, GetBitContext *gb)
 464 {
 465     int i, num;
 466
 467     num = 1 + get_bits(gb, 5);
 468
 469     /*hrd rate*/
 470     if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
 471     {
 472         av_freep(&v->hrd_rate);
 473     }
 474     if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));
 475     if (!v->hrd_rate) return -1;
 476
 477     /*hrd buffer*/
 478     if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)
 479     {
 480         av_freep(&v->hrd_buffer);
 481     }
 482     if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));
 483     if (!v->hrd_buffer)
 484     {
 485         av_freep(&v->hrd_rate);
 486         return -1;
 487     }
 488
 489     /*hrd fullness*/
 490     if (v->hrd_fullness || num != v->hrd_num_leaky_buckets)
 491     {
 492         av_freep(&v->hrd_buffer);
 493     }
 494     if (!v->hrd_fullness) v->hrd_fullness = av_malloc(num*sizeof(uint8_t));
 495     if (!v->hrd_fullness)
 496     {
 497         av_freep(&v->hrd_rate);
 498         av_freep(&v->hrd_buffer);
 499         return -1;
 500     }
 501     v->hrd_num_leaky_buckets = num;
 502
 503     //exponent in base-2 for rate
 504     v->bit_rate_exponent = 6 + get_bits(gb, 4);
 505     //exponent in base-2 for buffer_size
 506     v->buffer_size_exponent = 4 + get_bits(gb, 4);
 507
 508     for (i=0; i<num; i++)
 509     {
 510         //mantissae, ordered (if not, use a function ?
 511         v->hrd_rate[i] = 1 + get_bits(gb, 16);
 512         if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])
 513         {
 514             av_log(v->s.avctx, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"
 515                    "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);
 516             return -1;
 517         }
 518         v->hrd_buffer[i] = 1 + get_bits(gb, 16);
 519         if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])
 520         {
 521             av_log(v->s.avctx, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"
 522                    "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);
 523             return -1;
 524         }
 525     }
 526     return 0;
 527 }
 528
 529 /**
 530  * Decode sequence header for Advanced Profile
 531  * @see Table 2, p18
 532  * @see 6.1.7, pp21-27
 533  * @param v The VC9Context to initialize
 534  * @param gb A GetBitContext initialized from AVCodecContext extra_data
 535  * @return Status
 536  */
 537 static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
 538 {
 539     VC9Context *v = avctx->priv_data;
 540     int nr, dr, aspect_ratio;
 541
 542     v->postprocflag = get_bits(gb, 1);
 543     v->broadcast = get_bits(gb, 1);
 544     v->interlace = get_bits(gb, 1);
 545
 546     v->tfcntrflag = get_bits(gb, 1);
 547     v->finterpflag = get_bits(gb, 1); //common
 548     v->panscanflag = get_bits(gb, 1);
 549     v->reserved = get_bits(gb, 1);
 550     if (v->reserved)
 551     {
 552         av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",
 553                v->reserved);
 554         return -1;
 555     }
 556     if (v->extended_mv)
 557         v->extended_dmv = get_bits(gb, 1);
 558
 559     /* 6.1.7, p21 */
 560     if (get_bits(gb, 1) /* pic_size_flag */)
 561     {
 562         avctx->coded_width = get_bits(gb, 12) << 1;
 563         avctx->coded_height = get_bits(gb, 12) << 1;
 564         if ( get_bits(gb, 1) /* disp_size_flag */)
 565         {
 566             avctx->width = get_bits(gb, 14);
 567             avctx->height = get_bits(gb, 14);
 568         }
 569
 570         /* 6.1.7.4, p23 */
 571         if ( get_bits(gb, 1) /* aspect_ratio_flag */)
 572         {
 573             aspect_ratio = get_bits(gb, 4); //SAR
 574             if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED
 575             {
 576                 avctx->sample_aspect_ratio.num = 1 + get_bits(gb, 8);
 577                 avctx->sample_aspect_ratio.den = 1 + get_bits(gb, 8);
 578             }
 579             else if (aspect_ratio == 0x0E)
 580             {
 581                 av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
 582             }
 583             else
 584             {
 585               avctx->sample_aspect_ratio = vc9_pixel_aspect[aspect_ratio];
 586             }
 587         }
 588     }
 589     else
 590     {
 591         avctx->coded_width = avctx->width;
 592         avctx->coded_height = avctx->height;
 593     }
 594
 595     /* 6.1.8, p23 */
 596     if ( get_bits(gb, 1) /* framerateflag */)
 597     {
 598         if ( !get_bits(gb, 1) /* framerateind */)
 599         {
 600             nr = get_bits(gb, 8);
 601             dr = get_bits(gb, 4);
 602             if (nr<1)
 603             {
 604                 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");
 605                 return -1;
 606             }
 607             if (nr>5)
 608             {
 609                 av_log(avctx, AV_LOG_ERROR,
 610                        "Reserved FRAMERATENR %i not handled\n", nr);
 611                 nr = 5; /* overflow protection */
 612             }
 613             if (dr<1)
 614             {
 615                 av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
 616                 return -1;
 617             }
 618             if (dr>2)
 619             {
 620                 av_log(avctx, AV_LOG_ERROR,
 621                        "Reserved FRAMERATEDR %i not handled\n", dr);
 622                 dr = 2; /* overflow protection */
 623             }
 624             avctx->time_base.num = fps_nr[dr - 1];
 625             avctx->time_base.den = fps_nr[nr - 1];
 626         }
 627         else
 628         {
 629             nr = get_bits(gb, 16);
 630             // 0.03125->2048Hz / 0.03125Hz
 631             avctx->time_base.den = 1000000;
 632             avctx->time_base.num = 31250*(1+nr);
 633         }
 634     }
 635
 636     /* 6.1.9, p25 */
 637     if ( get_bits(gb, 1) /* color_format_flag */)
 638     {
 639         //Chromacity coordinates of color primaries
 640         //like ITU-R BT.709-2, BT.470-2, ...
 641         v->color_prim = get_bits(gb, 8);
 642         if (v->color_prim<1)
 643         {
 644             av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is forbidden\n");
 645             return -1;
 646         }
 647         if (v->color_prim == 3 || v->color_prim>6)
 648         {
 649             av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",
 650                    v->color_prim);
 651             return -1;
 652         }
 653
 654         //Opto-electronic transfer characteristics
 655         v->transfer_char = get_bits(gb, 8);
 656         if (v->transfer_char < 1)
 657         {
 658             av_log(avctx, AV_LOG_ERROR, "0 for TRAMSFER_CHAR is forbidden\n");
 659             return -1;
 660         }
 661         if (v->transfer_char == 3 || v->transfer_char>8)
 662         {
 663             av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",
 664                    v->color_prim);
 665             return -1;
 666         }
 667
 668         //Matrix coefficient for primariev->YCbCr
 669         v->matrix_coef = get_bits(gb, 8);
 670         if (v->matrix_coef < 1)
 671         {
 672             av_log(avctx, AV_LOG_ERROR, "0 for MATRIX_COEF is forbidden\n");
 673             return -1;
 674         }
 675         if ((v->matrix_coef > 2 && v->matrix_coef < 6) || v->matrix_coef > 7)
 676         {
 677             av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",
 678                    v->color_prim);
 679             return -1;
 680         }
 681     }
 682
 683     //Hypothetical reference decoder indicator flag
 684     v->hrd_param_flag = get_bits(gb, 1);
 685     if (v->hrd_param_flag)
 686     {
 687       if (decode_hrd(v, gb) < 0) return -1;
 688     }
 689
 690     /*reset scaling ranges, 6.2.2 & 6.2.3, p33*/
 691     v->range_mapy_flag = 0;
 692     v->range_mapuv_flag = 0;
 693
 694     av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");
 695     return -1;
 696 }
 697 #endif
 698
 699 /**
 700  * Decode Simple/Main Profiles sequence header
 701  * @see Figure 7-8, p16-17
 702  * @param avctx Codec context
 703  * @param gb GetBit context initialized from Codec context extra_data
 704  * @return Status
 705  */
 706 static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
 707 {
 708     VC9Context *v = avctx->priv_data;
 709
 710     av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
 711     v->profile = get_bits(gb, 2);
 712     if (v->profile == 2)
 713     {
 714         av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden\n");
 715         return -1;
 716     }
 717
 718 #if HAS_ADVANCED_PROFILE
 719     if (v->profile == PROFILE_ADVANCED)
 720     {
 721         v->level = get_bits(gb, 3);
 722         if(v->level >= 5)
 723         {
 724             av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);
 725         }
 726         v->chromaformat = get_bits(gb, 2);
 727         if (v->chromaformat != 1)
 728         {
 729             av_log(avctx, AV_LOG_ERROR,
 730                    "Only 4:2:0 chroma format supported\n");
 731             return -1;
 732         }
 733     }
 734     else
 735 #endif
 736     {
 737         v->res_sm = get_bits(gb, 2); //reserved
 738         if (v->res_sm)
 739         {
 740             av_log(avctx, AV_LOG_ERROR,
 741                    "Reserved RES_SM=%i is forbidden\n", v->res_sm);
 742             return -1;
 743         }
 744     }
 745
 746     // (fps-2)/4 (->30)
 747     v->frmrtq_postproc = get_bits(gb, 3); //common
 748     // (bitrate-32kbps)/64kbps
 749     v->bitrtq_postproc = get_bits(gb, 5); //common
 750     v->s.loop_filter = get_bits(gb, 1); //common
 751     if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)
 752     {
 753         av_log(avctx, AV_LOG_ERROR,
 754                "LOOPFILTER shell not be enabled in simple profile\n");
 755     }
 756
 757 #if HAS_ADVANCED_PROFILE
 758     if (v->profile < PROFILE_ADVANCED)
 759 #endif
 760     {
 761         v->res_x8 = get_bits(gb, 1); //reserved
 762         if (v->res_x8)
 763         {
 764             av_log(avctx, AV_LOG_ERROR,
 765                    "1 for reserved RES_X8 is forbidden\n");
 766             //return -1;
 767         }
 768         v->multires = get_bits(gb, 1);
 769         v->res_fasttx = get_bits(gb, 1);
 770         if (!v->res_fasttx)
 771         {
 772             av_log(avctx, AV_LOG_ERROR,
 773                    "0 for reserved RES_FASTTX is forbidden\n");
 774             //return -1;
 775         }
 776     }
 777
 778     v->fastuvmc =  get_bits(gb, 1); //common
 779     if (!v->profile && !v->fastuvmc)
 780     {
 781         av_log(avctx, AV_LOG_ERROR,
 782                "FASTUVMC unavailable in Simple Profile\n");
 783         return -1;
 784     }
 785     v->extended_mv =  get_bits(gb, 1); //common
 786     if (!v->profile && v->extended_mv)
 787     {
 788         av_log(avctx, AV_LOG_ERROR,
 789                "Extended MVs unavailable in Simple Profile\n");
 790         return -1;
 791     }
 792     v->dquant =  get_bits(gb, 2); //common
 793     v->vstransform =  get_bits(gb, 1); //common
 794
 795 #if HAS_ADVANCED_PROFILE
 796     if (v->profile < PROFILE_ADVANCED)
 797 #endif
 798     {
 799         v->res_transtab = get_bits(gb, 1);
 800         if (v->res_transtab)
 801         {
 802             av_log(avctx, AV_LOG_ERROR,
 803                    "1 for reserved RES_TRANSTAB is forbidden\n");
 804             return -1;
 805         }
 806     }
 807
 808     v->overlap = get_bits(gb, 1); //common
 809
 810 #if HAS_ADVANCED_PROFILE
 811     if (v->profile < PROFILE_ADVANCED)
 812 #endif
 813     {
 814         v->s.resync_marker = get_bits(gb, 1);
 815         v->rangered = get_bits(gb, 1);
 816         if (v->rangered && v->profile == PROFILE_SIMPLE)
 817         {
 818             av_log(avctx, AV_LOG_DEBUG,
 819                    "RANGERED should be set to 0 in simple profile\n");
 820         }
 821     }
 822
 823     v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common
 824     v->quantizer_mode = get_bits(gb, 2); //common
 825
 826 #if HAS_ADVANCED_PROFILE
 827     if (v->profile < PROFILE_ADVANCED)
 828 #endif
 829     {
 830         v->finterpflag = get_bits(gb, 1); //common
 831         v->res_rtm_flag = get_bits(gb, 1); //reserved
 832         if (!v->res_rtm_flag)
 833         {
 834             av_log(avctx, AV_LOG_ERROR,
 835                    "0 for reserved RES_RTM_FLAG is forbidden\n");
 836             //return -1;
 837         }
 838 #if TRACE
 839         av_log(avctx, AV_LOG_INFO,
 840                "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"
 841                "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"
 842                "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"
 843                "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",
 844                v->profile, v->frmrtq_postproc, v->bitrtq_postproc,
 845                v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,
 846                v->rangered, v->vstransform, v->overlap, v->s.resync_marker,
 847                v->dquant, v->quantizer_mode, avctx->max_b_frames
 848                );
 849         return 0;
 850 #endif
 851     }
 852 #if HAS_ADVANCED_PROFILE
 853     else return decode_advanced_sequence_header(avctx, gb);
 854 #endif
 855 }
 856
 857
 858 #if HAS_ADVANCED_PROFILE
 859 /** Entry point decoding (Advanced Profile)
 860  * @param avctx Codec context
 861  * @param gb GetBit context initialized from avctx->extra_data
 862  * @return Status
 863  */
 864 static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)
 865 {
 866     VC9Context *v = avctx->priv_data;
 867     int i;
 868     if (v->profile != PROFILE_ADVANCED)
 869     {
 870         av_log(avctx, AV_LOG_ERROR,
 871                "Entry point are only defined in Advanced Profile!\n");
 872         return -1; //Only for advanced profile!
 873     }
 874     if (v->hrd_param_flag)
 875     {
 876         //Update buffer fullness
 877         av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");
 878         assert(v->hrd_num_leaky_buckets > 0);
 879         for (i=0; i<v->hrd_num_leaky_buckets; i++)
 880             v->hrd_fullness[i] = get_bits(gb, 8);
 881     }
 882     if ((v->range_mapy_flag = get_bits(gb, 1)))
 883     {
 884         //RANGE_MAPY
 885         av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");
 886         v->range_mapy = get_bits(gb, 3);
 887     }
 888     if ((v->range_mapuv_flag = get_bits(gb, 1)))
 889     {
 890         //RANGE_MAPUV
 891         av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");
 892         v->range_mapuv = get_bits(gb, 3);
 893     }
 894     if (v->panscanflag)
 895     {
 896         //NUMPANSCANWIN
 897         v->numpanscanwin = get_bits(gb, 3);
 898         av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
 899     }
 900     return 0;
 901 }
 902 #endif
 903
 904 /***********************************************************************/
 905 /**
 906  * @defgroup bitplane VC9 Bitplane decoding
 907  * @see 8.7, p56
 908  * @{
 909  */
 910
 911 /** @addtogroup bitplane
 912  * Imode types
 913  * @{
 914  */
 915 #define IMODE_RAW     0
 916 #define IMODE_NORM2   1
 917 #define IMODE_DIFF2   2
 918 #define IMODE_NORM6   3
 919 #define IMODE_DIFF6   4
 920 #define IMODE_ROWSKIP 5
 921 #define IMODE_COLSKIP 6
 922 /** @} */ //imode defines
 923
 924 /** Allocate the buffer from a bitplane, given its dimensions
 925  * @param bp Bitplane which buffer is to allocate
 926  * @param[in] width Width of the buffer
 927  * @param[in] height Height of the buffer
 928  * @return Status
 929  * @todo TODO: Take into account stride
 930  * @todo TODO: Allow use of external buffers ?
 931  */
 932 static int alloc_bitplane(BitPlane *bp, int width, int height)
 933 {
 934     if (!bp || bp->width<0 || bp->height<0) return -1;
 935     bp->data = (uint8_t*)av_malloc(width*height);
 936     if (!bp->data) return -1;
 937     bp->width = bp->stride = width;
 938     bp->height = height;
 939     return 0;
 940 }
 941
 942 /** Free the bitplane's buffer
 943  * @param bp Bitplane which buffer is to free
 944  */
 945 static void free_bitplane(BitPlane *bp)
 946 {
 947     bp->width = bp->stride = bp->height = 0;
 948     if (bp->data) av_freep(&bp->data);
 949 }
 950
 951 /** Decode rows by checking if they are skipped
 952  * @param plane Buffer to store decoded bits
 953  * @param[in] width Width of this buffer
 954  * @param[in] height Height of this buffer
 955  * @param[in] stride of this buffer
 956  */
 957 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 958     int x, y;
 959
 960     for (y=0; y<height; y++){
 961         if (!get_bits(gb, 1)) //rowskip
 962             memset(plane, 0, width);
 963         else
 964             for (x=0; x<width; x++)
 965                 plane[x] = get_bits(gb, 1);
 966         plane += stride;
 967     }
 968 }
 969
 970 /** Decode columns by checking if they are skipped
 971  * @param plane Buffer to store decoded bits
 972  * @param[in] width Width of this buffer
 973  * @param[in] height Height of this buffer
 974  * @param[in] stride of this buffer
 975  * @fixme FIXME: Optimize
 976  */
 977 static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){
 978     int x, y;
 979
 980     for (x=0; x<width; x++){
 981         if (!get_bits(gb, 1)) //colskip
 982             for (y=0; y<height; y++)
 983                 plane[y*stride] = 0;
 984         else
 985             for (y=0; y<height; y++)
 986                 plane[y*stride] = get_bits(gb, 1);
 987         plane ++;
 988     }
 989 }
 990
 991 /** Decode a bitplane's bits
 992  * @param bp Bitplane where to store the decode bits
 993  * @param v VC9 context for bit reading and logging
 994  * @return Status
 995  * @fixme FIXME: Optimize
 996  * @todo TODO: Decide if a struct is needed
 997  */
 998 static int bitplane_decoding(BitPlane *bp, VC9Context *v)
 999 {
1000     GetBitContext *gb = &v->s.gb;
1001
1002     int imode, x, y, code, use_vertical_tile, tile_w, tile_h, offset;
1003     uint8_t invert, *planep = bp->data;
1004
1005     invert = get_bits(gb, 1);
1006     imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);
1007
1008     bp->is_raw = 0;
1009     switch (imode)
1010     {
1011     case IMODE_RAW:
1012         //Data is actually read in the MB layer (same for all tests == "raw")
1013         bp->is_raw = 1; //invert ignored
1014         return invert;
1015     case IMODE_DIFF2:
1016     case IMODE_NORM2:
1017         if ((bp->height*bp->width) & 1)
1018         {
1019             *(++planep) = get_bits(gb, 1);
1020             offset = x = 1;
1021         }
1022         else offset = x = 0;
1023
1024         for (y=0; y<bp->height; y++)
1025         {
1026             for(; x<bp->width; x+=2)
1027             {
1028                 code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
1029                 *(++planep) = code&1; //lsb => left
1030                 *(++planep) = (code>>1)&1; //msb => right
1031             }
1032             planep += bp->stride-bp->width;
1033             if ((bp->width-offset)&1) //Odd number previously processed
1034             {
1035                 code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);
1036                 *planep = code&1;
1037                 planep += bp->stride-bp->width;
1038                 *planep = (code>>1)&1; //msb => right
1039                 offset = x = 1;
1040             }
1041             else
1042             {
1043                 offset = x = 0;
1044                 planep += bp->stride-bp->width;
1045             }
1046         }
1047         break;
1048     case IMODE_DIFF6:
1049     case IMODE_NORM6:
1050         use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;
1051         tile_w= use_vertical_tile ? 2 : 3;
1052         tile_h= use_vertical_tile ? 3 : 2;
1053
1054         for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){
1055             for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){
1056                 code = get_vlc2(gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);
1057                 if(code<0){
1058                     av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");
1059                     return -1;
1060                 }
1061                 //FIXME following is a pure guess and probably wrong
1062                 //FIXME A bitplane (0 | !0), so could the shifts be avoided ?
1063                 planep[x     + 0*bp->stride]= (code>>0)&1;
1064                 planep[x + 1 + 0*bp->stride]= (code>>1)&1;
1065                 //FIXME Does branch prediction help here?
1066                 if(use_vertical_tile){
1067                     planep[x + 0 + 1*bp->stride]= (code>>2)&1;
1068                     planep[x + 1 + 1*bp->stride]= (code>>3)&1;
1069                     planep[x + 0 + 2*bp->stride]= (code>>4)&1;
1070                     planep[x + 1 + 2*bp->stride]= (code>>5)&1;
1071                 }else{
1072                     planep[x + 2 + 0*bp->stride]= (code>>2)&1;
1073                     planep[x + 0 + 1*bp->stride]= (code>>3)&1;
1074                     planep[x + 1 + 1*bp->stride]= (code>>4)&1;
1075                     planep[x + 2 + 1*bp->stride]= (code>>5)&1;
1076                 }
1077             }
1078         }
1079
1080         x=  bp->width % tile_w;
1081         decode_colskip(bp->data  ,             x, bp->height         , bp->stride, &v->s.gb);
1082         decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, &v->s.gb);
1083
1084         break;
1085     case IMODE_ROWSKIP:
1086         decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1087         break;
1088     case IMODE_COLSKIP:
1089         decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);
1090         break;
1091     default: break;
1092     }
1093
1094     /* Applying diff operator */
1095     if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)
1096     {
1097         planep = bp->data;
1098         planep[0] ^= invert;
1099         for (x=1; x<bp->width; x++)
1100             planep[x] ^= planep[x-1];
1101         for (y=1; y<bp->height; y++)
1102         {
1103             planep += bp->stride;
1104             planep[0] ^= planep[-bp->stride];
1105             for (x=1; x<bp->width; x++)
1106             {
1107                 if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
1108                 else                                     planep[x] ^= planep[x-1];
1109             }
1110         }
1111     }
1112     else if (invert)
1113     {
1114         planep = bp->data;
1115         for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
1116     }
1117     return (imode<<1) + invert;
1118 }
1119 /** @} */ //Bitplane group
1120
1121 /***********************************************************************/
1122 /** VOP Dquant decoding
1123  * @param v VC9 Context
1124  */
1125 static int vop_dquant_decoding(VC9Context *v)
1126 {
1127     GetBitContext *gb = &v->s.gb;
1128     int pqdiff;
1129
1130     //variable size
1131     if (v->dquant == 2)
1132     {
1133         pqdiff = get_bits(gb, 3);
1134         if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1135         else v->altpq = v->pq + pqdiff + 1;
1136     }
1137     else
1138     {
1139         v->dquantfrm = get_bits(gb, 1);
1140         if ( v->dquantfrm )
1141         {
1142             v->dqprofile = get_bits(gb, 2);
1143             switch (v->dqprofile)
1144             {
1145             case DQPROFILE_SINGLE_EDGE:
1146             case DQPROFILE_DOUBLE_EDGES:
1147                 v->dqsbedge = get_bits(gb, 2);
1148                 break;
1149             case DQPROFILE_ALL_MBS:
1150                 v->dqbilevel = get_bits(gb, 1);
1151             default: break; //Forbidden ?
1152             }
1153             if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
1154             {
1155                 pqdiff = get_bits(gb, 3);
1156                 if (pqdiff == 7) v->altpq = get_bits(gb, 5);
1157                 else v->altpq = v->pq + pqdiff + 1;
1158             }
1159         }
1160     }
1161     return 0;
1162 }
1163
1164 /***********************************************************************/
1165 /**
1166  * @defgroup all_frame_hdr All VC9 profiles frame header
1167  * @brief Part of the frame header decoding from all profiles
1168  * @warning Only pro/epilog differs between Simple/Main and Advanced => check caller
1169  * @{
1170  */
1171 /** B and BI frame header decoding, primary part
1172  * @see Tables 11+12, p62-65
1173  * @param v VC9 context
1174  * @return Status
1175  * @warning Also handles BI frames
1176  */
1177 static int decode_b_picture_primary_header(VC9Context *v)
1178 {
1179     GetBitContext *gb = &v->s.gb;
1180     int pqindex;
1181
1182     /* Prolog common to all frametypes should be done in caller */
1183     if (v->profile == PROFILE_SIMPLE)
1184     {
1185         av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");
1186         return FRAME_SKIPPED;
1187     }
1188     v->bfraction = vc9_bfraction_lut[get_vlc2(gb, vc9_bfraction_vlc.table,
1189                                               VC9_BFRACTION_VLC_BITS, 2)];
1190     if (v->bfraction < -1)
1191     {
1192         av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");
1193         return FRAME_SKIPPED;
1194     }
1195     else if (!v->bfraction)
1196     {
1197         /* We actually have a BI frame */
1198         v->s.pict_type = BI_TYPE;
1199         v->buffer_fullness = get_bits(gb, 7);
1200     }
1201
1202     /* Read the quantization stuff */
1203     pqindex = get_bits(gb, 5);
1204     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1205         v->pq = pquant_table[0][pqindex];
1206     else
1207     {
1208         v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1209     }
1210     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1211     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1212         v->pquantizer = get_bits(gb, 1);
1213 #if HAS_ADVANCED_PROFILE
1214     if (v->profile == PROFILE_ADVANCED)
1215     {
1216         if (v->postprocflag) v->postproc = get_bits(gb, 2);
1217         if (v->extended_mv == 1 && v->s.pict_type != BI_TYPE)
1218             v->mvrange = get_prefix(gb, 0, 3);
1219     }
1220 #endif
1221     else
1222     {
1223         if (v->extended_mv == 1)
1224             v->mvrange = get_prefix(gb, 0, 3);
1225     }
1226     /* Read the MV mode */
1227     if (v->s.pict_type != BI_TYPE)
1228     {
1229         v->mv_mode = get_bits(gb, 1);
1230         if (v->pq < 13)
1231         {
1232             if (!v->mv_mode)
1233             {
1234                 v->mv_mode = get_bits(gb, 2);
1235                 if (v->mv_mode)
1236                 av_log(v->s.avctx, AV_LOG_ERROR,
1237                        "mv_mode for lowquant B frame was %i\n", v->mv_mode);
1238             }
1239         }
1240         else
1241         {
1242             if (!v->mv_mode)
1243             {
1244                 if (get_bits(gb, 1))
1245                      av_log(v->s.avctx, AV_LOG_ERROR,
1246                             "mv_mode for highquant B frame was %i\n", v->mv_mode);
1247             }
1248             v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping
1249         }
1250     }
1251
1252     return 0;
1253 }
1254
1255 /** B and BI frame header decoding, secondary part
1256  * @see Tables 11+12, p62-65
1257  * @param v VC9 context
1258  * @return Status
1259  * @warning Also handles BI frames
1260  * @warning To call once all MB arrays are allocated
1261  * @todo Support Advanced Profile headers
1262  */
1263 static int decode_b_picture_secondary_header(VC9Context *v)
1264 {
1265     GetBitContext *gb = &v->s.gb;
1266     int status;
1267
1268     status = bitplane_decoding(&v->skip_mb_plane, v);
1269     if (status < 0) return -1;
1270 #if TRACE
1271     if (v->mv_mode == MV_PMODE_MIXED_MV)
1272     {
1273         status = bitplane_decoding(&v->mv_type_mb_plane, v);
1274         if (status < 0)
1275             return -1;
1276 #if TRACE
1277         av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1278                "Imode: %i, Invert: %i\n", status>>1, status&1);
1279 #endif
1280     }
1281
1282     //bitplane
1283     status = bitplane_decoding(&v->direct_mb_plane, v);
1284     if (status < 0) return -1;
1285 #if TRACE
1286     av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "
1287            "Imode: %i, Invert: %i\n", status>>1, status&1);
1288 #endif
1289
1290     av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "
1291            "Imode: %i, Invert: %i\n", status>>1, status&1);
1292 #endif
1293
1294     /* FIXME: what is actually chosen for B frames ? */
1295     v->s.mv_table_index = get_bits(gb, 2); //but using vc9_ tables
1296     v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1297
1298     if (v->dquant)
1299     {
1300         vop_dquant_decoding(v);
1301     }
1302
1303     if (v->vstransform)
1304     {
1305         v->ttmbf = get_bits(gb, 1);
1306         if (v->ttmbf)
1307         {
1308             v->ttfrm = get_bits(gb, 2);
1309             av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1310                    (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1311         }
1312     }
1313     /* Epilog (AC/DC syntax) should be done in caller */
1314     return 0;
1315 }
1316
1317 /** I frame header decoding, primary part
1318  * @see Tables 5+7, p53-54 and 55-57
1319  * @param v VC9 context
1320  * @return Status
1321  * @todo Support Advanced Profile headers
1322  */
1323 static int decode_i_picture_primary_header(VC9Context *v)
1324 {
1325     GetBitContext *gb = &v->s.gb;
1326     int pqindex;
1327
1328     /* Prolog common to all frametypes should be done in caller */
1329     //BF = Buffer Fullness
1330     if (v->profile < PROFILE_ADVANCED && get_bits(gb, 7))
1331     {
1332         av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");
1333     }
1334
1335     /* Quantizer stuff */
1336     pqindex = get_bits(gb, 5);
1337     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1338         v->pq = pquant_table[0][pqindex];
1339     else
1340     {
1341         v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1342     }
1343     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1344     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1345         v->pquantizer = get_bits(gb, 1);
1346     av_log(v->s.avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",
1347            v->pq, v->halfpq);
1348     return 0;
1349 }
1350
1351 /** I frame header decoding, secondary part
1352  * @param v VC9 context
1353  * @return Status
1354  * @warning Not called in A/S/C profiles, it seems
1355  * @todo Support Advanced Profile headers
1356  */
1357 static int decode_i_picture_secondary_header(VC9Context *v)
1358 {
1359 #if HAS_ADVANCED_PROFILE
1360     int status;
1361     if (v->profile == PROFILE_ADVANCED)
1362     {
1363         v->s.ac_pred = get_bits(&v->s.gb, 1);
1364         if (v->postprocflag) v->postproc = get_bits(&v->s.gb, 1);
1365         /* 7.1.1.34 + 8.5.2 */
1366         if (v->overlap && v->pq<9)
1367         {
1368             v->condover = get_bits(&v->s.gb, 1);
1369             if (v->condover)
1370             {
1371                 v->condover = 2+get_bits(&v->s.gb, 1);
1372                 if (v->condover == 3)
1373                 {
1374                     status = bitplane_decoding(&v->over_flags_plane, v);
1375                     if (status < 0) return -1;
1376 #  if TRACE
1377                     av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "
1378                            "Imode: %i, Invert: %i\n", status>>1, status&1);
1379 #  endif
1380                 }
1381             }
1382         }
1383     }
1384 #endif
1385
1386     /* Epilog (AC/DC syntax) should be done in caller */
1387     return 0;
1388 }
1389
1390 /** P frame header decoding, primary part
1391  * @see Tables 5+7, p53-54 and 55-57
1392  * @param v VC9 context
1393  * @todo Support Advanced Profile headers
1394  * @return Status
1395  */
1396 static int decode_p_picture_primary_header(VC9Context *v)
1397 {
1398     /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */
1399     GetBitContext *gb = &v->s.gb;
1400     int lowquant, pqindex;
1401
1402     pqindex = get_bits(gb, 5);
1403     if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
1404         v->pq = pquant_table[0][pqindex];
1405     else
1406     {
1407         v->pq = pquant_table[v->quantizer_mode-1][pqindex];
1408     }
1409     if (pqindex < 9) v->halfpq = get_bits(gb, 1);
1410     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
1411         v->pquantizer = get_bits(gb, 1);
1412     av_log(v->s.avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",
1413            v->pq, v->halfpq);
1414     if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
1415 #if HAS_ADVANCED_PROFILE
1416     if (v->profile == PROFILE_ADVANCED)
1417     {
1418         if (v->postprocflag) v->postproc = get_bits(gb, 1);
1419     }
1420     else
1421 #endif
1422         if (v->multires) v->respic = get_bits(gb, 2);
1423     lowquant = (v->pquantizer>12) ? 0 : 1;
1424     v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];
1425     if (v->mv_mode == MV_PMODE_INTENSITY_COMP)
1426     {
1427         v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];
1428         v->lumscale = get_bits(gb, 6);
1429         v->lumshift = get_bits(gb, 6);
1430     }
1431     return 0;
1432 }
1433
1434 /** P frame header decoding, secondary part
1435  * @see Tables 5+7, p53-54 and 55-57
1436  * @param v VC9 context
1437  * @warning To call once all MB arrays are allocated
1438  * @return Status
1439  */
1440 static int decode_p_picture_secondary_header(VC9Context *v)
1441 {
1442     GetBitContext *gb = &v->s.gb;
1443     int status = 0;
1444     if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
1445          v->mv_mode2 == MV_PMODE_MIXED_MV)
1446         || v->mv_mode == MV_PMODE_MIXED_MV)
1447     {
1448         status = bitplane_decoding(&v->mv_type_mb_plane, v);
1449         if (status < 0) return -1;
1450 #if TRACE
1451         av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
1452                "Imode: %i, Invert: %i\n", status>>1, status&1);
1453 #endif
1454     }
1455
1456     status = bitplane_decoding(&v->skip_mb_plane, v);
1457     if (status < 0) return -1;
1458 #if TRACE
1459     av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
1460            "Imode: %i, Invert: %i\n", status>>1, status&1);
1461 #endif
1462
1463     /* Hopefully this is correct for P frames */
1464     v->s.mv_table_index =get_bits(gb, 2); //but using vc9_ tables
1465     v->cbpcy_vlc = &vc9_cbpcy_p_vlc[get_bits(gb, 2)];
1466
1467     if (v->dquant)
1468     {
1469         av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");
1470         vop_dquant_decoding(v);
1471     }
1472
1473     v->ttfrm = 0; //FIXME Is that so ?
1474     if (v->vstransform)
1475     {
1476         v->ttmbf = get_bits(gb, 1);
1477         if (v->ttmbf)
1478         {
1479             v->ttfrm = get_bits(gb, 2);
1480             av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",
1481                    (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);
1482         }
1483     }
1484     /* Epilog (AC/DC syntax) should be done in caller */
1485     return 0;
1486 }
1487 /** @} */ //End of group all_frm_hdr
1488
1489
1490 /***********************************************************************/
1491 /**
1492  * @defgroup std_frame_hdr VC9 Simple/Main Profiles header decoding
1493  * @brief Part of the frame header decoding belonging to Simple/Main Profiles
1494  * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1495  *          check caller
1496  * @{
1497  */
1498
1499 /** Frame header decoding, first part, in Simple and Main profiles
1500  * @see Tables 5+7, p53-54 and 55-57
1501  * @param v VC9 context
1502  * @todo FIXME: RANGEREDFRM element not read if BI frame from Table6, P54
1503  *              However, 7.1.1.8 says "all frame types, for main profiles"
1504  * @return Status
1505  */
1506 static int standard_decode_picture_primary_header(VC9Context *v)
1507 {
1508     GetBitContext *gb = &v->s.gb;
1509     int status = 0;
1510
1511     if (v->finterpflag) v->interpfrm = get_bits(gb, 1);
1512     skip_bits(gb, 2); //framecnt unused
1513     if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
1514     v->s.pict_type = get_bits(gb, 1);
1515     if (v->s.avctx->max_b_frames)
1516     {
1517         if (!v->s.pict_type)
1518         {
1519             if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
1520             else v->s.pict_type = B_TYPE;
1521         }
1522         else v->s.pict_type = P_TYPE;
1523     }
1524     else v->s.pict_type++;
1525
1526     switch (v->s.pict_type)
1527     {
1528     case I_TYPE: status = decode_i_picture_primary_header(v); break;
1529     case P_TYPE: status = decode_p_picture_primary_header(v); break;
1530     case BI_TYPE: //Same as B
1531     case B_TYPE: status = decode_b_picture_primary_header(v); break;
1532     }
1533
1534     if (status == FRAME_SKIPPED)
1535     {
1536       av_log(v->s.avctx, AV_LOG_INFO, "Skipping frame...\n");
1537       return status;
1538     }
1539     return 0;
1540 }
1541
1542 /** Frame header decoding, secondary part
1543  * @param v VC9 context
1544  * @warning To call once all MB arrays are allocated
1545  * @return Status
1546  */
1547 static int standard_decode_picture_secondary_header(VC9Context *v)
1548 {
1549     GetBitContext *gb = &v->s.gb;
1550     int status = 0;
1551
1552     switch (v->s.pict_type)
1553     {
1554     case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1555     case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1556     case BI_TYPE:
1557     case I_TYPE: break; //Nothing needed as it's done in the epilog
1558     }
1559     if (status < 0) return FRAME_SKIPPED;
1560
1561     /* AC Syntax */
1562     v->c_ac_table_index = decode012(gb);
1563     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1564     {
1565         v->y_ac_table_index = decode012(gb);
1566     }
1567     /* DC Syntax */
1568     v->s.dc_table_index = decode012(gb);
1569
1570     return 0;
1571 }
1572 /** @} */ //End for group std_frame_hdr
1573
1574 #if HAS_ADVANCED_PROFILE
1575 /***********************************************************************/
1576 /**
1577  * @defgroup adv_frame_hdr VC9 Advanced Profile header decoding
1578  * @brief Part of the frame header decoding belonging to Advanced Profiles
1579  * @warning Only pro/epilog differs between Simple/Main and Advanced =>
1580  *          check caller
1581  * @{
1582  */
1583 /** Frame header decoding, primary part
1584  * @param v VC9 context
1585  * @return Status
1586  */
1587 static int advanced_decode_picture_primary_header(VC9Context *v)
1588 {
1589     GetBitContext *gb = &v->s.gb;
1590     static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };
1591     int type;
1592
1593     if (v->interlace)
1594     {
1595         v->fcm = get_bits(gb, 1);
1596         if (v->fcm) v->fcm = 2+get_bits(gb, 1);
1597     }
1598
1599     type = get_prefix(gb, 0, 4);
1600     if (type > 4 || type < 0) return FRAME_SKIPPED;
1601     v->s.pict_type = type_table[type];
1602     av_log(v->s.avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->s.pict_type);
1603
1604     if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);
1605     if (v->broadcast)
1606     {
1607         if (!v->interlace) v->rptfrm = get_bits(gb, 2);
1608         else
1609         {
1610             v->tff = get_bits(gb, 1);
1611             v->rff = get_bits(gb, 1);
1612         }
1613     }
1614
1615     if (v->panscanflag)
1616     {
1617 #if 0
1618         for (i=0; i<v->numpanscanwin; i++)
1619         {
1620             v->topleftx[i] = get_bits(gb, 16);
1621             v->toplefty[i] = get_bits(gb, 16);
1622             v->bottomrightx[i] = get_bits(gb, 16);
1623             v->bottomrighty[i] = get_bits(gb, 16);
1624         }
1625 #else
1626         skip_bits(gb, 16*4*v->numpanscanwin);
1627 #endif
1628     }
1629     v->s.no_rounding = !get_bits(gb, 1);
1630     v->uvsamp = get_bits(gb, 1);
1631     if (v->finterpflag == 1) v->interpfrm = get_bits(gb, 1);
1632
1633     switch(v->s.pict_type)
1634     {
1635     case I_TYPE: if (decode_i_picture_primary_header(v) < 0) return -1;
1636     case P_TYPE: if (decode_p_picture_primary_header(v) < 0) return -1;
1637     case BI_TYPE:
1638     case B_TYPE: if (decode_b_picture_primary_header(v) < 0) return FRAME_SKIPPED;
1639     default: return -1;
1640     }
1641 }
1642
1643 /** Frame header decoding, secondary part
1644  * @param v VC9 context
1645  * @return Status
1646  */
1647 static int advanced_decode_picture_secondary_header(VC9Context *v)
1648 {
1649     GetBitContext *gb = &v->s.gb;
1650     int status = 0;
1651
1652     switch(v->s.pict_type)
1653     {
1654     case P_TYPE: status = decode_p_picture_secondary_header(v); break;
1655     case B_TYPE: status = decode_b_picture_secondary_header(v); break;
1656     case BI_TYPE:
1657     case I_TYPE: status = decode_i_picture_secondary_header(v); break;
1658     }
1659     if (status<0) return FRAME_SKIPPED;
1660
1661     /* AC Syntax */
1662     v->c_ac_table_index = decode012(gb);
1663     if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
1664     {
1665         v->y_ac_table_index = decode012(gb);
1666     }
1667     /* DC Syntax */
1668     v->s.dc_table_index = decode012(gb);
1669
1670     return 0;
1671 }
1672 #endif
1673 /** @} */ //End for adv_frame_hdr
1674
1675 /***********************************************************************/
1676 /**
1677  * @defgroup block VC9 Block-level functions
1678  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1679  * @todo TODO: Integrate to MpegEncContext facilities
1680  * @{
1681  */
1682
1683 /**
1684  * @def GET_MQUANT
1685  * @brief Get macroblock-level quantizer scale
1686  * @warning XXX: qdiff to the frame quant, not previous quant ?
1687  * @fixme XXX: Don't know how to initialize mquant otherwise in last case
1688  */
1689 #define GET_MQUANT()                                           \
1690   if (v->dquantfrm)                                            \
1691   {                                                            \
1692     if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
1693     {                                                          \
1694       if (v->dqbilevel)                                        \
1695       {                                                        \
1696         mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
1697       }                                                        \
1698       else                                                     \
1699       {                                                        \
1700         mqdiff = get_bits(gb, 3);                              \
1701         if (mqdiff != 7) mquant = v->pq + mqdiff;              \
1702         else mquant = get_bits(gb, 5);                         \
1703       }                                                        \
1704     }                                                          \
1705     else mquant = v->pq;                                       \
1706   }
1707
1708 /**
1709  * @def GET_MVDATA(_dmv_x, _dmv_y)
1710  * @brief Get MV differentials
1711  * @see MVDATA decoding from 8.3.5.2, p(1)20
1712  * @param _dmv_x Horizontal differential for decoded MV
1713  * @param _dmv_y Vertical differential for decoded MV
1714  * @todo TODO: Use MpegEncContext arrays to store them
1715  */
1716 #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
1717   index = 1 + get_vlc2(gb, vc9_mv_diff_vlc[s->mv_table_index].table,\
1718                        VC9_MV_DIFF_VLC_BITS, 2);                    \
1719   if (index > 36)                                                   \
1720   {                                                                 \
1721     mb_has_coeffs = 1;                                              \
1722     index -= 37;                                                    \
1723   }                                                                 \
1724   else mb_has_coeffs = 0;                                           \
1725   s->mb_intra = 0;                                                  \
1726   if (!index) { _dmv_x = _dmv_y = 0; }                              \
1727   else if (index == 35)                                             \
1728   {                                                                 \
1729     _dmv_x = get_bits(gb, v->k_x);                                  \
1730     _dmv_y = get_bits(gb, v->k_y);                                  \
1731     s->mb_intra = 1;                                                \
1732   }                                                                 \
1733   else                                                              \
1734   {                                                                 \
1735     index1 = index%6;                                               \
1736     if (s->mspel && index1 == 5) val = 1;                           \
1737     else                         val = 0;                           \
1738     val = get_bits(gb, size_table[index1] - val);                   \
1739     sign = 0 - (val&1);                                             \
1740     _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1741                                                                     \
1742     index1 = index/6;                                               \
1743     if (s->mspel && index1 == 5) val = 1;                           \
1744     else                          val = 0;                          \
1745     val = get_bits(gb, size_table[index1] - val);                   \
1746     sign = 0 - (val&1);                                             \
1747     _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
1748   }
1749
1750 /** Get predicted DC value
1751  * prediction dir: left=0, top=1
1752  * @param s MpegEncContext
1753  * @param[in] n block index in the current MB
1754  * @param dc_val_ptr Pointer to DC predictor
1755  * @param dir_ptr Prediction direction for use in AC prediction
1756  * @todo TODO: Actually do it the VC9 way
1757  * @todo TODO: Handle properly edges
1758  */
1759 static inline int vc9_pred_dc(MpegEncContext *s, int n,
1760                               uint16_t **dc_val_ptr, int *dir_ptr)
1761 {
1762     int a, b, c, wrap, pred, scale;
1763     int16_t *dc_val;
1764     static const uint16_t dcpred[31] = {
1765         1024,  512,  341,  256,  205,  171,  146,  128,
1766          114,  102,   93,   85,   79,   73,   68,   64,
1767           60,   57,   54,   51,   49,   47,   45,   43,
1768           41,   39,   38,   37,   35,   34,   33
1769     };
1770
1771     /* find prediction - wmv3_dc_scale always used here in fact */
1772     if (n < 4)     scale = s->y_dc_scale;
1773     else           scale = s->c_dc_scale;
1774
1775     wrap = s->block_wrap[n];
1776     dc_val= s->dc_val[0] + s->block_index[n];
1777
1778     /* B C
1779      * A X
1780      */
1781     a = dc_val[ - 1];
1782     b = dc_val[ - 1 - wrap];
1783     c = dc_val[ - wrap];
1784
1785     /* XXX: Rule B is used only for I and BI frames in S/M/C profile
1786      *      with overlap filtering off
1787      */
1788     if ((s->pict_type == I_TYPE || s->pict_type == BI_TYPE) &&
1789         1 /* XXX: overlap filtering off */)
1790     {
1791         /* Set outer values */
1792         if (s->first_slice_line && n!=2) b=c=dcpred[scale];
1793         if (s->mb_x == 0) b=a=dcpred[scale];
1794     }
1795     else
1796     {
1797         /* Set outer values */
1798         if (s->first_slice_line && n!=2) b=c=0;
1799         if (s->mb_x == 0) b=a=0;
1800
1801         /* XXX: Rule A needs to know if blocks are inter or intra :/ */
1802         if (0)
1803         {
1804             /* update predictor */
1805             *dc_val_ptr = &dc_val[0];
1806             dir_ptr = 0;
1807             return a;
1808         }
1809     }
1810
1811     if (abs(a - b) <= abs(b - c)) {
1812         pred = c;
1813         *dir_ptr = 1;
1814     } else {
1815         pred = a;
1816         *dir_ptr = 0;
1817     }
1818
1819     /* update predictor */
1820     *dc_val_ptr = &dc_val[0];
1821     return pred;
1822 }
1823
1824 /** Decode one block, inter or intra
1825  * @param v The VC9 context
1826  * @param block 8x8 DCT block
1827  * @param n Block index in the current MB (<4=>luma)
1828  * @param coded If the block is coded
1829  * @param mquant Quantizer step for the current block
1830  * @see Inter TT: Table 21, p73 + p91-85
1831  * @see Intra TT: Table 20, p72 + p(1)05-(1)07
1832  * @todo TODO: Process the blocks
1833  * @todo TODO: Use M$ MPEG-4 cbp prediction
1834  */
1835 static int vc9_decode_block(VC9Context *v, DCTELEM block[64], int n, int coded, int mquant)
1836 {
1837     GetBitContext *gb = &v->s.gb;
1838     MpegEncContext *s = &v->s;
1839     int ttblk; /* Transform Type per Block */
1840     int subblkpat; /* Sub-block Transform Type Pattern */
1841     int dc_pred_dir; /* Direction of the DC prediction used */
1842     int run_diff, i;
1843
1844     /* XXX: Guard against dumb values of mquant */
1845     mquant = (mquant < 1) ? 0 : ( (mquant>31) ? 31 : mquant );
1846
1847     /* Set DC scale - y and c use the same */
1848     s->y_dc_scale = s->y_dc_scale_table[mquant];
1849     s->c_dc_scale = s->c_dc_scale_table[mquant];
1850
1851     if (s->mb_intra)
1852     {
1853         int dcdiff;
1854         uint16_t *dc_val;
1855
1856         /* Get DC differential */
1857         if (n < 4) {
1858             dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1859         } else {
1860             dcdiff = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);
1861         }
1862         if (dcdiff < 0){
1863             av_log(s->avctx, AV_LOG_ERROR, "Illegal DC VLC\n");
1864             return -1;
1865         }
1866         if (dcdiff)
1867         {
1868             if (dcdiff == 119 /* ESC index value */)
1869             {
1870                 /* TODO: Optimize */
1871                 if (mquant == 1) dcdiff = get_bits(gb, 10);
1872                 else if (mquant == 2) dcdiff = get_bits(gb, 9);
1873                 else dcdiff = get_bits(gb, 8);
1874             }
1875             else
1876             {
1877                 if (mquant == 1)
1878                   dcdiff = (dcdiff<<2) + get_bits(gb, 2) - 3;
1879                 else if (mquant == 2)
1880                   dcdiff = (dcdiff<<1) + get_bits(gb, 1) - 1;
1881             }
1882             if (get_bits(gb, 1))
1883               dcdiff = -dcdiff;
1884         }
1885
1886         /* Prediction */
1887         dcdiff += vc9_pred_dc(s, n, &dc_val, &dc_pred_dir);
1888         *dc_val = dcdiff;
1889         /* Store the quantized DC coeff, used for prediction */
1890
1891         if (n < 4) {
1892             block[0] = dcdiff * s->y_dc_scale;
1893         } else {
1894             block[0] = dcdiff * s->c_dc_scale;
1895         }
1896         if (block[0] < 0) {
1897 #if TRACE
1898             //av_log(s->avctx, AV_LOG_ERROR, "DC=%i<0\n", dcdiff);
1899 #endif
1900             //return -1;
1901         }
1902         /* Skip ? */
1903         run_diff = 0;
1904         i = 0;
1905         if (!coded) {
1906             goto not_coded;
1907         }
1908     }
1909     else
1910     {
1911         mquant = v->pq;
1912
1913         /* Get TTBLK */
1914         if (v->ttmb < 8) /* per block */
1915             ttblk = get_vlc2(gb, vc9_ttblk_vlc[v->tt_index].table, VC9_TTBLK_VLC_BITS, 2);
1916         else /* Per frame */
1917           ttblk = 0; //FIXME, depends on ttfrm
1918
1919         /* Get SUBBLKPAT */
1920         if (ttblk == v->ttblk4x4) /* 4x4 transform for that qp value */
1921             subblkpat = 1+get_vlc2(gb, vc9_subblkpat_vlc[v->tt_index].table,
1922                                    VC9_SUBBLKPAT_VLC_BITS, 2);
1923         else /* All others: 8x8, 4x8, 8x4 */
1924             subblkpat = decode012(gb);
1925     }
1926
1927     //TODO AC Decoding
1928     i = 63; //XXX: nothing done yet
1929
1930
1931  not_coded:
1932     if (s->mb_intra) {
1933         mpeg4_pred_ac(s, block, n, dc_pred_dir);
1934         if (s->ac_pred) {
1935             i = 63; /* XXX: not optimal */
1936         }
1937     }
1938     if(i>0) i=63; //FIXME/XXX optimize
1939     s->block_last_index[n] = i;
1940     return 0;
1941 }
1942
1943 /** @} */ //End for group block
1944
1945 /***********************************************************************/
1946 /**
1947  * @defgroup std_mb VC9 Macroblock-level functions in Simple/Main Profiles
1948  * @see 7.1.4, p91 and 8.1.1.7, p(1)04
1949  * @todo TODO: Integrate to MpegEncContext facilities
1950  * @{
1951  */
1952
1953 static inline int vc9_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr)
1954 {
1955     int xy, wrap, pred, a, b, c;
1956
1957     xy = s->block_index[n];
1958     wrap = s->b8_stride;
1959
1960     /* B C
1961      * A X
1962      */
1963     a = s->coded_block[xy - 1       ];
1964     b = s->coded_block[xy - 1 - wrap];
1965     c = s->coded_block[xy     - wrap];
1966
1967     if (b == c) {
1968         pred = a;
1969     } else {
1970         pred = c;
1971     }
1972
1973     /* store value */
1974     *coded_block_ptr = &s->coded_block[xy];
1975
1976     return pred;
1977 }
1978
1979 /** Decode one I-frame MB (in Simple/Main profile)
1980  * @todo TODO: Extend to AP
1981  */
1982 static int vc9_decode_i_mb(VC9Context *v, DCTELEM block[6][64])
1983 {
1984     int i, cbp, val;
1985     uint8_t *coded_val;
1986 //    uint32_t * const mb_type_ptr= &v->s.current_picture.mb_type[ v->s.mb_x + v->s.mb_y*v->s.mb_stride ];
1987
1988     v->s.mb_intra = 1;
1989     cbp = get_vlc2(&v->s.gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
1990     if (cbp < 0) return -1;
1991     v->s.ac_pred = get_bits(&v->s.gb, 1);
1992
1993     for (i=0; i<6; i++)
1994     {
1995         val = ((cbp >> (5 - i)) & 1);
1996         if (i < 4) {
1997             int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
1998             val = val ^ pred;
1999             *coded_val = val;
2000         }
2001         cbp |= val << (5 - i);
2002         if (vc9_decode_block(v, block[i], i, val, v->pq) < 0) //FIXME Should be mquant
2003         {
2004             av_log(v->s.avctx, AV_LOG_ERROR,
2005                    "\nerror while decoding block: %d x %d (%d)\n", v->s.mb_x, v->s.mb_y, i);
2006             return -1;
2007         }
2008     }
2009     return 0;
2010 }
2011
2012 /** Decode one P-frame MB (in Simple/Main profile)
2013  * @todo TODO: Extend to AP
2014  * @fixme FIXME: DC value for inter blocks not set
2015  */
2016 static int vc9_decode_p_mb(VC9Context *v, DCTELEM block[6][64])
2017 {
2018     MpegEncContext *s = &v->s;
2019     GetBitContext *gb = &s->gb;
2020     int i, mb_offset = s->mb_x + s->mb_y*s->mb_width; /* XXX: mb_stride */
2021     int cbp; /* cbp decoding stuff */
2022     int hybrid_pred; /* Prediction types */
2023     int mv_mode_bit = 0;
2024     int mqdiff, mquant; /* MB quantization */
2025     int ttmb; /* MB Transform type */
2026     int status;
2027     uint8_t *coded_val;
2028
2029     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2030       offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2031     int mb_has_coeffs = 1; /* last_flag */
2032     int dmv_x, dmv_y; /* Differential MV components */
2033     int index, index1; /* LUT indices */
2034     int val, sign; /* temp values */
2035
2036     mquant = v->pq; /* Loosy initialization */
2037
2038     if (v->mv_type_mb_plane.is_raw)
2039         v->mv_type_mb_plane.data[mb_offset] = get_bits(gb, 1);
2040     if (v->skip_mb_plane.is_raw)
2041         v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2042     if (!mv_mode_bit) /* 1MV mode */
2043     {
2044         if (!v->skip_mb_plane.data[mb_offset])
2045         {
2046             GET_MVDATA(dmv_x, dmv_y);
2047
2048             /* hybrid mv pred, 8.3.5.3.4 */
2049             if (v->mv_mode == MV_PMODE_1MV ||
2050                 v->mv_mode == MV_PMODE_MIXED_MV)
2051                 hybrid_pred = get_bits(gb, 1);
2052             /* FIXME Set DC val for inter block ? */
2053             if (s->mb_intra && !mb_has_coeffs)
2054             {
2055                 GET_MQUANT();
2056                 s->ac_pred = get_bits(gb, 1);
2057                 /* XXX: how to handle cbp ? */
2058                 cbp = 0;
2059                 for (i=0; i<6; i++)
2060                 {
2061                      s->coded_block[s->block_index[i]] = 0;
2062                      vc9_decode_block(v, block[i], i, 0, mquant);
2063                 }
2064                 return 0;
2065             }
2066             else if (mb_has_coeffs)
2067             {
2068                 if (s->mb_intra) s->ac_pred = get_bits(gb, 1);
2069                 cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
2070                 GET_MQUANT();
2071             }
2072             else
2073             {
2074                 mquant = v->pq;
2075                 /* XXX: how to handle cbp ? */
2076                 /* XXX: how to set values for following predictions ? */
2077                 cbp = 0;
2078             }
2079
2080             if (!v->ttmbf)
2081                 ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2082                                 VC9_TTMB_VLC_BITS, 12);
2083
2084             for (i=0; i<6; i++)
2085             {
2086                 val = ((cbp >> (5 - i)) & 1);
2087                 if (i < 4) {
2088                     int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2089                     val = val ^ pred;
2090                     *coded_val = val;
2091                 }
2092                 vc9_decode_block(v, block[i], i, val, mquant); //FIXME
2093             }
2094         }
2095         else //Skipped
2096         {
2097             /* hybrid mv pred, 8.3.5.3.4 */
2098             if (v->mv_mode == MV_PMODE_1MV ||
2099                 v->mv_mode == MV_PMODE_MIXED_MV)
2100                 hybrid_pred = get_bits(gb, 1);
2101
2102             /* TODO: blah */
2103             return 0;
2104         }
2105     } //1MV mode
2106     else //4MV mode
2107     {
2108         if (!v->skip_mb_plane.data[mb_offset] /* unskipped MB */)
2109         {
2110             /* Get CBPCY */
2111             cbp = get_vlc2(&v->s.gb, v->cbpcy_vlc->table, VC9_CBPCY_P_VLC_BITS, 2);
2112             for (i=0; i<6; i++)
2113             {
2114                 val = ((cbp >> (5 - i)) & 1);
2115                 if (i < 4) {
2116                     int pred = vc9_coded_block_pred(&v->s, i, &coded_val);
2117                     val = val ^ pred;
2118                     *coded_val = val;
2119                 }
2120                 if (i<4 && val)
2121                 {
2122                     GET_MVDATA(dmv_x, dmv_y);
2123                 }
2124                 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2125                     hybrid_pred = get_bits(gb, 1);
2126                 GET_MQUANT();
2127
2128                 if (s->mb_intra /* One of the 4 blocks is intra */ &&
2129                     index /* non-zero pred for that block */)
2130                     s->ac_pred = get_bits(gb, 1);
2131                 if (!v->ttmbf)
2132                     ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2133                                     VC9_TTMB_VLC_BITS, 12);
2134                 status = vc9_decode_block(v, block[i], i, val, mquant);
2135             }
2136             return status;
2137         }
2138         else //Skipped MB
2139         {
2140             /* XXX: Skipped => cbp=0 and mquant doesn't matter ? */
2141             for (i=0; i<4; i++)
2142             {
2143                 if (v->mv_mode == MV_PMODE_MIXED_MV /* Hybrid pred */)
2144                     hybrid_pred = get_bits(gb, 1);
2145                 vc9_decode_block(v, block[i], i, 0, v->pq); //FIXME
2146             }
2147             vc9_decode_block(v, block[4], 4, 0, v->pq); //FIXME
2148             vc9_decode_block(v, block[5], 5, 0, v->pq); //FIXME
2149             /* TODO: blah */
2150             return 0;
2151         }
2152     }
2153
2154     /* Should never happen */
2155     return -1;
2156 }
2157
2158 /** Decode one B-frame MB (in Simple/Main profile)
2159  * @todo TODO: Extend to AP
2160  * @warning XXX: Used for decoding BI MBs
2161  * @fixme FIXME: DC value for inter blocks not set
2162  */
2163 static int vc9_decode_b_mb(VC9Context *v, DCTELEM block[6][64])
2164 {
2165     MpegEncContext *s = &v->s;
2166     GetBitContext *gb = &v->s.gb;
2167     int mb_offset, i /* MB / B postion information */;
2168     int b_mv_type = BMV_TYPE_BACKWARD;
2169     int mquant, mqdiff; /* MB quant stuff */
2170     int ttmb; /* MacroBlock transform type */
2171
2172     static const int size_table[6] = { 0, 2, 3, 4, 5, 8 },
2173         offset_table[6] = { 0, 1, 3, 7, 15, 31 };
2174     int mb_has_coeffs = 1; /* last_flag */
2175     int dmv1_x, dmv1_y, dmv2_x, dmv2_y; /* Differential MV components */
2176     int index, index1; /* LUT indices */
2177     int val, sign; /* MVDATA temp values */
2178
2179     mb_offset = s->mb_width*s->mb_y + s->mb_x; //FIXME: arrays aren't using stride
2180
2181     if (v->direct_mb_plane.is_raw)
2182         v->direct_mb_plane.data[mb_offset] = get_bits(gb, 1);
2183     if (v->skip_mb_plane.is_raw)
2184         v->skip_mb_plane.data[mb_offset] = get_bits(gb, 1);
2185
2186     if (!v->direct_mb_plane.data[mb_offset])
2187     {
2188         if (v->skip_mb_plane.data[mb_offset])
2189         {
2190             b_mv_type = decode012(gb);
2191             if (v->bfraction > 420 /*1/2*/ &&
2192                 b_mv_type < 3) b_mv_type = 1-b_mv_type;
2193         }
2194         else
2195         {
2196             GET_MVDATA(dmv1_x, dmv1_y);
2197             if (!s->mb_intra /* b_mv1 tells not intra */)
2198             {
2199                 b_mv_type = decode012(gb);
2200                 if (v->bfraction > 420 /*1/2*/ &&
2201                     b_mv_type < 3) b_mv_type = 1-b_mv_type;
2202             }
2203         }
2204     }
2205     if (!v->skip_mb_plane.data[mb_offset])
2206     {
2207         if (mb_has_coeffs /* BMV1 == "last" */)
2208         {
2209             GET_MQUANT();
2210             if (s->mb_intra /* intra mb */)
2211                 s->ac_pred = get_bits(gb, 1);
2212         }
2213         else
2214         {
2215             /* if bmv1 tells MVs are interpolated */
2216             if (b_mv_type == BMV_TYPE_INTERPOLATED)
2217             {
2218                 GET_MVDATA(dmv2_x, dmv2_y);
2219                 mquant = v->pq; //FIXME: initialization not necessary ?
2220             }
2221             /* GET_MVDATA has reset some stuff */
2222             if (mb_has_coeffs /* b_mv2 == "last" */)
2223             {
2224                 if (s->mb_intra /* intra_mb */)
2225                     s->ac_pred = get_bits(gb, 1);
2226                 GET_MQUANT();
2227             }
2228         }
2229     }
2230
2231     //End1
2232     if (v->ttmbf)
2233         ttmb = get_vlc2(gb, vc9_ttmb_vlc[v->tt_index].table,
2234                         VC9_TTMB_VLC_BITS, 12);
2235
2236     //End2
2237     for (i=0; i<6; i++)
2238     {
2239         vc9_decode_block(v, block[i], i, 0 /*cbp[i]*/, mquant); //FIXME
2240     }
2241     return 0;
2242 }
2243
2244 /** Decode all MBs for an I frame in Simple/Main profile
2245  * @todo TODO: Move out of the loop the picture type case?
2246                (branch prediction should help there though)
2247  */
2248 static int standard_decode_mbs(VC9Context *v)
2249 {
2250     MpegEncContext *s = &v->s;
2251
2252     /* Set transform type info depending on pq */
2253     if (v->pq < 5)
2254     {
2255         v->tt_index = 0;
2256         v->ttblk4x4 = 3;
2257     }
2258     else if (v->pq < 13)
2259     {
2260         v->tt_index = 1;
2261         v->ttblk4x4 = 3;
2262     }
2263     else
2264     {
2265         v->tt_index = 2;
2266         v->ttblk4x4 = 2;
2267     }
2268
2269     if (s->pict_type != I_TYPE)
2270     {
2271         /* Select proper long MV range */
2272         switch (v->mvrange)
2273         {
2274         case 1: v->k_x = 10; v->k_y = 9; break;
2275         case 2: v->k_x = 12; v->k_y = 10; break;
2276         case 3: v->k_x = 13; v->k_y = 11; break;
2277         default: /*case 0 too */ v->k_x = 9; v->k_y = 8; break;
2278         }
2279
2280         s->mspel = v->mv_mode & 1; //MV_PMODE is HPEL
2281         v->k_x -= s->mspel;
2282         v->k_y -= s->mspel;
2283     }
2284
2285     for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2286     {
2287         for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2288         {
2289             //FIXME Get proper MB DCTELEM
2290             //TODO Move out of the loop
2291             switch (s->pict_type)
2292             {
2293             case I_TYPE: vc9_decode_i_mb(v, s->block); break;
2294             case P_TYPE: vc9_decode_p_mb(v, s->block); break;
2295             case BI_TYPE:
2296             case B_TYPE: vc9_decode_b_mb(v, s->block); break;
2297             }
2298         }
2299         //Add a check for overconsumption ?
2300     }
2301     return 0;
2302 }
2303 /** @} */ //End for group std_mb
2304
2305 #if HAS_ADVANCED_PROFILE
2306 /***********************************************************************/
2307 /**
2308  * @defgroup adv_mb VC9 Macroblock-level functions in Advanced Profile
2309  * @todo TODO: Integrate to MpegEncContext facilities
2310  * @todo TODO: Code P, B and BI
2311  * @{
2312  */
2313 static int advanced_decode_i_mbs(VC9Context *v)
2314 {
2315     MpegEncContext *s = &v->s;
2316     GetBitContext *gb = &v->s.gb;
2317     int mqdiff, mquant, mb_offset = 0, over_flags_mb = 0;
2318
2319     for (s->mb_y=0; s->mb_y<s->mb_height; s->mb_y++)
2320     {
2321         for (s->mb_x=0; s->mb_x<s->mb_width; s->mb_x++)
2322         {
2323             if (v->ac_pred_plane.is_raw)
2324                 s->ac_pred = get_bits(gb, 1);
2325             else
2326                 s->ac_pred = v->ac_pred_plane.data[mb_offset];
2327             if (v->condover == 3 && v->over_flags_plane.is_raw)
2328                 over_flags_mb = get_bits(gb, 1);
2329             GET_MQUANT();
2330
2331             /* TODO: lots */
2332         }
2333         mb_offset++;
2334     }
2335     return 0;
2336 }
2337 /** @} */ //End for group adv_mb
2338 #endif
2339
2340 /** Initialize a VC9/WMV3 decoder
2341  * @todo TODO: Handle VC-9 IDUs (Transport level?)
2342  * @todo TODO: Decypher remaining bits in extra_data
2343  */
2344 static int vc9_decode_init(AVCodecContext *avctx)
2345 {
2346     VC9Context *v = avctx->priv_data;
2347     MpegEncContext *s = &v->s;
2348     GetBitContext gb;
2349
2350     if (!avctx->extradata_size || !avctx->extradata) return -1;
2351     avctx->pix_fmt = PIX_FMT_YUV420P;
2352     v->s.avctx = avctx;
2353
2354     if(ff_h263_decode_init(avctx) < 0)
2355         return -1;
2356     if (vc9_init_common(v) < 0) return -1;
2357
2358     av_log(avctx, AV_LOG_INFO, "This decoder is not supposed to produce picture. Dont report this as a bug!\n");
2359
2360     avctx->coded_width = avctx->width;
2361     avctx->coded_height = avctx->height;
2362     if (avctx->codec_id == CODEC_ID_WMV3)
2363     {
2364         int count = 0;
2365
2366         // looks like WMV3 has a sequence header stored in the extradata
2367         // advanced sequence header may be before the first frame
2368         // the last byte of the extradata is a version number, 1 for the
2369         // samples we can decode
2370
2371         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
2372
2373         if (decode_sequence_header(avctx, &gb) < 0)
2374           return -1;
2375
2376         count = avctx->extradata_size*8 - get_bits_count(&gb);
2377         if (count>0)
2378         {
2379             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
2380                    count, get_bits(&gb, count));
2381         }
2382         else if (count < 0)
2383         {
2384             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
2385         }
2386     }
2387     avctx->has_b_frames= !!(avctx->max_b_frames);
2388
2389     s->mb_width = (avctx->coded_width+15)>>4;
2390     s->mb_height = (avctx->coded_height+15)>>4;
2391
2392     /* Allocate mb bitplanes */
2393     if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2394         return -1;
2395     if (alloc_bitplane(&v->mv_type_mb_plane, s->mb_width, s->mb_height) < 0)
2396         return -1;
2397     if (alloc_bitplane(&v->skip_mb_plane, s->mb_width, s->mb_height) < 0)
2398         return -1;
2399     if (alloc_bitplane(&v->direct_mb_plane, s->mb_width, s->mb_height) < 0)
2400         return -1;
2401
2402     /* For predictors */
2403     v->previous_line_cbpcy = (uint8_t *)av_malloc(s->mb_stride*4);
2404     if (!v->previous_line_cbpcy) return -1;
2405
2406 #if HAS_ADVANCED_PROFILE
2407     if (v->profile == PROFILE_ADVANCED)
2408     {
2409         if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
2410             return -1;
2411         if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
2412             return -1;
2413     }
2414 #endif
2415
2416     return 0;
2417     }
2418
2419 /** Decode a VC9/WMV3 frame
2420  * @todo TODO: Handle VC-9 IDUs (Transport level?)
2421  * @warning Initial try at using MpegEncContext stuff
2422  */
2423 static int vc9_decode_frame(AVCodecContext *avctx,
2424                             void *data, int *data_size,
2425                             uint8_t *buf, int buf_size)
2426 {
2427     VC9Context *v = avctx->priv_data;
2428     MpegEncContext *s = &v->s;
2429     int ret = FRAME_SKIPPED, len;
2430     AVFrame *pict = data;
2431     uint8_t *tmp_buf;
2432     v->s.avctx = avctx;
2433
2434     //buf_size = 0 -> last frame
2435     if (!buf_size) return 0;
2436
2437     len = avpicture_get_size(avctx->pix_fmt, avctx->width,
2438                              avctx->height);
2439     tmp_buf = (uint8_t *)av_mallocz(len);
2440     avpicture_fill((AVPicture *)pict, tmp_buf, avctx->pix_fmt,
2441                    avctx->width, avctx->height);
2442
2443     if (avctx->codec_id == CODEC_ID_VC9)
2444     {
2445 #if 0
2446         // search for IDU's
2447         // FIXME
2448         uint32_t scp = 0;
2449         int scs = 0, i = 0;
2450
2451         while (i < buf_size)
2452         {
2453             for (; i < buf_size && scp != 0x000001; i++)
2454                 scp = ((scp<<8)|buf[i])&0xffffff;
2455
2456             if (scp != 0x000001)
2457                 break; // eof ?
2458
2459             scs = buf[i++];
2460
2461             init_get_bits(gb, buf+i, (buf_size-i)*8);
2462
2463             switch(scs)
2464             {
2465             case 0x0A: //Sequence End Code
2466                 return 0;
2467             case 0x0B: //Slice Start Code
2468                 av_log(avctx, AV_LOG_ERROR, "Slice coding not supported\n");
2469                 return -1;
2470             case 0x0C: //Field start code
2471                 av_log(avctx, AV_LOG_ERROR, "Interlaced coding not supported\n");
2472                 return -1;
2473             case 0x0D: //Frame start code
2474                 break;
2475             case 0x0E: //Entry point Start Code
2476                 if (v->profile < PROFILE_ADVANCED)
2477                     av_log(avctx, AV_LOG_ERROR,
2478                            "Found an entry point in profile %i\n", v->profile);
2479                 advanced_entry_point_process(avctx, gb);
2480                 break;
2481             case 0x0F: //Sequence header Start Code
2482                 decode_sequence_header(avctx, gb);
2483                 break;
2484             default:
2485                 av_log(avctx, AV_LOG_ERROR,
2486                        "Unsupported IDU suffix %lX\n", scs);
2487             }
2488
2489             i += get_bits_count(gb)*8;
2490         }
2491 #else
2492         av_abort();
2493 #endif
2494     }
2495     else
2496         init_get_bits(&v->s.gb, buf, buf_size*8);
2497
2498     s->flags= avctx->flags;
2499     s->flags2= avctx->flags2;
2500
2501     /* no supplementary picture */
2502     if (buf_size == 0) {
2503         /* special case for last picture */
2504         if (s->low_delay==0 && s->next_picture_ptr) {
2505             *pict= *(AVFrame*)s->next_picture_ptr;
2506             s->next_picture_ptr= NULL;
2507
2508             *data_size = sizeof(AVFrame);
2509         }
2510
2511         return 0;
2512     }
2513
2514     //No IDU - we mimic ff_h263_decode_frame
2515     s->bitstream_buffer_size=0;
2516
2517     if (!s->context_initialized) {
2518         if (MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
2519             return -1;
2520     }
2521
2522     //we need to set current_picture_ptr before reading the header, otherwise we cant store anyting im there
2523     if(s->current_picture_ptr==NULL || s->current_picture_ptr->data[0]){
2524         s->current_picture_ptr= &s->picture[ff_find_unused_picture(s, 0)];
2525     }
2526 #if HAS_ADVANCED_PROFILE
2527     if (v->profile == PROFILE_ADVANCED)
2528         ret= advanced_decode_picture_primary_header(v);
2529     else
2530 #endif
2531         ret= standard_decode_picture_primary_header(v);
2532     if (ret == FRAME_SKIPPED) return buf_size;
2533     /* skip if the header was thrashed */
2534     if (ret < 0){
2535         av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
2536         return -1;
2537     }
2538
2539     //No bug workaround yet, no DCT conformance
2540
2541     //WMV9 does have resized images
2542     if (v->profile < PROFILE_ADVANCED && v->multires){
2543         //Parse context stuff in here, don't know how appliable it is
2544     }
2545     //Not sure about context initialization
2546
2547     // for hurry_up==5
2548     s->current_picture.pict_type= s->pict_type;
2549     s->current_picture.key_frame= s->pict_type == I_TYPE;
2550
2551     /* skip b frames if we dont have reference frames */
2552     if(s->last_picture_ptr==NULL && (s->pict_type==B_TYPE || s->dropable))
2553         return buf_size; //FIXME simulating all buffer consumed
2554     /* skip b frames if we are in a hurry */
2555     if(avctx->hurry_up && s->pict_type==B_TYPE)
2556         return buf_size; //FIXME simulating all buffer consumed
2557     /* skip everything if we are in a hurry>=5 */
2558     if(avctx->hurry_up>=5)
2559         return buf_size; //FIXME simulating all buffer consumed
2560
2561     if(s->next_p_frame_damaged){
2562         if(s->pict_type==B_TYPE)
2563             return buf_size; //FIXME simulating all buffer consumed
2564         else
2565             s->next_p_frame_damaged=0;
2566     }
2567
2568     if(MPV_frame_start(s, avctx) < 0)
2569         return -1;
2570
2571     ff_er_frame_start(s);
2572
2573     //wmv9 may or may not have skip bits
2574 #if HAS_ADVANCED_PROFILE
2575     if (v->profile == PROFILE_ADVANCED)
2576         ret= advanced_decode_picture_secondary_header(v);
2577     else
2578 #endif
2579         ret = standard_decode_picture_secondary_header(v);
2580     if (ret<0) return FRAME_SKIPPED; //FIXME Non fatal for now
2581
2582     //We consider the image coded in only one slice
2583 #if HAS_ADVANCED_PROFILE
2584     if (v->profile == PROFILE_ADVANCED)
2585     {
2586         switch(s->pict_type)
2587         {
2588             case I_TYPE: ret = advanced_decode_i_mbs(v); break;
2589             case P_TYPE: ret = decode_p_mbs(v); break;
2590             case B_TYPE:
2591             case BI_TYPE: ret = decode_b_mbs(v); break;
2592             default: ret = FRAME_SKIPPED;
2593         }
2594         if (ret == FRAME_SKIPPED) return buf_size; //We ignore for now failures
2595     }
2596     else
2597 #endif
2598     {
2599         ret = standard_decode_mbs(v);
2600         if (ret == FRAME_SKIPPED) return buf_size;
2601     }
2602
2603     ff_er_frame_end(s);
2604
2605     MPV_frame_end(s);
2606
2607     assert(s->current_picture.pict_type == s->current_picture_ptr->pict_type);
2608     assert(s->current_picture.pict_type == s->pict_type);
2609     if(s->pict_type==B_TYPE || s->low_delay){
2610         *pict= *(AVFrame*)&s->current_picture;
2611         ff_print_debug_info(s, pict);
2612     } else {
2613         *pict= *(AVFrame*)&s->last_picture;
2614         if(pict)
2615             ff_print_debug_info(s, pict);
2616     }
2617
2618     /* Return the Picture timestamp as the frame number */
2619     /* we substract 1 because it is added on utils.c    */
2620     avctx->frame_number = s->picture_number - 1;
2621
2622     /* dont output the last pic after seeking */
2623     if(s->last_picture_ptr || s->low_delay)
2624         *data_size = sizeof(AVFrame);
2625
2626     av_log(avctx, AV_LOG_DEBUG, "Consumed %i/%i bits\n",
2627            get_bits_count(&s->gb), buf_size*8);
2628
2629     /* Fake consumption of all data */
2630     *data_size = len;
2631     return buf_size; //Number of bytes consumed
2632 }
2633
2634 /** Close a VC9/WMV3 decoder
2635  * @warning Initial try at using MpegEncContext stuff
2636  */
2637 static int vc9_decode_end(AVCodecContext *avctx)
2638 {
2639     VC9Context *v = avctx->priv_data;
2640
2641 #if HAS_ADVANCED_PROFILE
2642     av_freep(&v->hrd_rate);
2643     av_freep(&v->hrd_buffer);
2644 #endif
2645     MPV_common_end(&v->s);
2646     free_bitplane(&v->mv_type_mb_plane);
2647     free_bitplane(&v->skip_mb_plane);
2648     free_bitplane(&v->direct_mb_plane);
2649     return 0;
2650 }
2651
2652 AVCodec vc9_decoder = {
2653     "vc9",
2654     CODEC_TYPE_VIDEO,
2655     CODEC_ID_VC9,
2656     sizeof(VC9Context),
2657     vc9_decode_init,
2658     NULL,
2659     vc9_decode_end,
2660     vc9_decode_frame,
2661     CODEC_CAP_DELAY,
2662     NULL
2663 };
2664
2665 AVCodec wmv3_decoder = {
2666     "wmv3",
2667     CODEC_TYPE_VIDEO,
2668     CODEC_ID_WMV3,
2669     sizeof(VC9Context),
2670     vc9_decode_init,
2671     NULL,
2672     vc9_decode_end,
2673     vc9_decode_frame,
2674     CODEC_CAP_DELAY,
2675     NULL
2676 };