PeerStreamer

ifneq ($(CONFIG_VC1_DECODER)$(CONFIG_WMV3_DECODER),)

    OBJS+= vc1.o

#ifdef CONFIG_VC1_DECODER

    register_avcodec(&vc1_decoder);

#endif //CONFIG_VC1_DECODER

    CODEC_ID_VC1,

extern AVCodec vc1_decoder;

/* vc1 externs */

#if defined(CONFIG_WMV3_DECODER)||defined(CONFIG_VC1_DECODER)

        //FIXME + TODO VC1 decode mb

/*

 * VC-1 and WMV3 decoder

 * Copyright (c) 2005 Anonymous

 * Copyright (c) 2005 Alex Beregszaszi

 * Copyright (c) 2005 Michael Niedermayer

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 *

 */

/**

 * @file vc1.c

 * VC-1 and WMV3 decoder

 *

 * TODO: most AP stuff, optimize, most of MB layer, transform, filtering and motion compensation, etc

 * TODO: use MPV_ !!

 */

#include "common.h"

#include "dsputil.h"

#include "avcodec.h"

#include "mpegvideo.h"

#include "vc1data.h"

#undef NDEBUG

#include <assert.h>

extern const uint32_t ff_table0_dc_lum[120][2], ff_table1_dc_lum[120][2];

extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];

extern VLC ff_msmp4_dc_luma_vlc[2], ff_msmp4_dc_chroma_vlc[2];

#define MB_INTRA_VLC_BITS 9

extern VLC ff_msmp4_mb_i_vlc;

#define DC_VLC_BITS 9

static const uint16_t table_mb_intra[64][2];

/* Some inhibiting stuff */

#define HAS_ADVANCED_PROFILE   0

#define TRACE                  1

#if TRACE

#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \

                   codes, codes_wrap, codes_size, use_static)          \

  if (init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,     \

               codes, codes_wrap, codes_size, use_static) < 0)         \

  {                                                                    \

    av_log(v->s.avctx, AV_LOG_ERROR, "Error for " # vlc " (%i)\n", i);   \

    return -1;                                                         \

  }

#else

#  define INIT_VLC(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, \

                   codes, codes_wrap, codes_size, use_static)          \

  init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size,         \

           codes, codes_wrap, codes_size, use_static)

#endif

/** Available Profiles */

//@{

#define PROFILE_SIMPLE   0

#define PROFILE_MAIN     1

#define PROFILE_COMPLEX  2 ///< TODO: WMV9 specific

#define PROFILE_ADVANCED 3

//@}

/** Sequence quantizer mode */

//@{

#define QUANT_FRAME_IMPLICIT   0 ///< Implicitly specified at frame level

#define QUANT_FRAME_EXPLICIT   1 ///< Explicitly specified at frame level

#define QUANT_NON_UNIFORM      2 ///< Non-uniform quant used for all frames

#define QUANT_UNIFORM          3 ///< Uniform quant used for all frames

//@}

/** Where quant can be changed */

//@{

#define DQPROFILE_FOUR_EDGES   0

#define DQPROFILE_DOUBLE_EDGES 1

#define DQPROFILE_SINGLE_EDGE  2

#define DQPROFILE_ALL_MBS      3

//@}

/** @name Where quant can be changed

 */

//@{

#define DQPROFILE_FOUR_EDGES   0

#define DQSINGLE_BEDGE_LEFT   0

#define DQSINGLE_BEDGE_TOP    1

#define DQSINGLE_BEDGE_RIGHT  2

#define DQSINGLE_BEDGE_BOTTOM 3

//@}

/** Which pair of edges is quantized with ALTPQUANT */

//@{

#define DQDOUBLE_BEDGE_TOPLEFT     0

#define DQDOUBLE_BEDGE_TOPRIGHT    1

#define DQDOUBLE_BEDGE_BOTTOMRIGHT 2

#define DQDOUBLE_BEDGE_BOTTOMLEFT  3

//@}

/** MV modes for P frames */

//@{

#define MV_PMODE_1MV_HPEL_BILIN   0

#define MV_PMODE_1MV              1

#define MV_PMODE_1MV_HPEL         2

#define MV_PMODE_MIXED_MV         3

#define MV_PMODE_INTENSITY_COMP   4

//@}

/** @name MV types for B frames */

//@{

#define BMV_TYPE_BACKWARD          0

#define BMV_TYPE_BACKWARD          0

#define BMV_TYPE_FORWARD           1

#define BMV_TYPE_INTERPOLATED      3

//@}

/** MV P mode - the 5th element is only used for mode 1 */

static const uint8_t mv_pmode_table[2][5] = {

  { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_MIXED_MV, MV_PMODE_INTENSITY_COMP },

  { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_INTENSITY_COMP }

};

/** One more frame type */

#define BI_TYPE 7

static const int fps_nr[5] = { 24, 25, 30, 50, 60 },

  fps_dr[2] = { 1000, 1001 };

static const uint8_t pquant_table[3][32] = {

  {  /* Implicit quantizer */

     0,  1,  2,  3,  4,  5,  6,  7,  8,  6,  7,  8,  9, 10, 11, 12,

    13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 29, 31

  },

  {  /* Explicit quantizer, pquantizer uniform */

     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,

    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31

  },

  {  /* Explicit quantizer, pquantizer non-uniform */

     0,  1,  1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13,

    14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29, 31

  }

};

/** @name VC-1 VLC tables and defines

 *  @todo TODO move this into the context

 */

//@{

#define VC1_BFRACTION_VLC_BITS 7

static VLC vc1_bfraction_vlc;

#define VC1_IMODE_VLC_BITS 4

static VLC vc1_imode_vlc;

#define VC1_NORM2_VLC_BITS 3

static VLC vc1_norm2_vlc;

#define VC1_NORM6_VLC_BITS 9

static VLC vc1_norm6_vlc;

/* Could be optimized, one table only needs 8 bits */

#define VC1_TTMB_VLC_BITS 9 //12

static VLC vc1_ttmb_vlc[3];

#define VC1_MV_DIFF_VLC_BITS 9 //15

static VLC vc1_mv_diff_vlc[4];

#define VC1_CBPCY_P_VLC_BITS 9 //14

static VLC vc1_cbpcy_p_vlc[4];

#define VC1_4MV_BLOCK_PATTERN_VLC_BITS 6

static VLC vc1_4mv_block_pattern_vlc[4];

#define VC1_TTBLK_VLC_BITS 5

static VLC vc1_ttblk_vlc[3];

#define VC1_SUBBLKPAT_VLC_BITS 6

static VLC vc1_subblkpat_vlc[3];

//@}

/** Bitplane struct

 * We mainly need data and is_raw, so this struct could be avoided

 * to save a level of indirection; feel free to modify

 * @fixme For now, stride=width

 * @warning Data are bits, either 1 or 0

 */

typedef struct BitPlane {

    uint8_t *data;      ///< Data buffer

    int width;          ///< Width of the buffer

    int stride;         ///< Stride of the buffer

    int height;         ///< Plane height

    uint8_t is_raw;     ///< Bit values must be read at MB level

} BitPlane;

/** The VC1 Context

 * @fixme Change size wherever another size is more efficient

 * Many members are only used for Advanced Profile

 */

typedef struct VC1Context{

    MpegEncContext s;

    /** Simple/Main Profile sequence header */

    //@{

    int res_sm;           ///< reserved, 2b

    int res_x8;           ///< reserved

    int multires;         ///< frame-level RESPIC syntax element present

    int res_fasttx;       ///< reserved, always 1

    int res_transtab;     ///< reserved, always 0

    int rangered;         ///< RANGEREDFRM (range reduction) syntax element present

                          ///< at frame level

    int res_rtm_flag;     ///< reserved, set to 1

    int reserved;         ///< reserved

    //@}

#if HAS_ADVANCED_PROFILE

    /** Advanced Profile */

    //@{

    int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer

    int chromaformat;     ///< 2bits, 2=4:2:0, only defined

    int postprocflag;     ///< Per-frame processing suggestion flag present

    int broadcast;        ///< TFF/RFF present

    int interlace;        ///< Progressive/interlaced (RPTFTM syntax element)

    int tfcntrflag;       ///< TFCNTR present

    int panscanflag;      ///< NUMPANSCANWIN, TOPLEFT{X,Y}, BOTRIGHT{X,Y} present

    int extended_dmv;     ///< Additional extended dmv range at P/B frame-level

    int color_prim;       ///< 8bits, chroma coordinates of the color primaries

    int transfer_char;    ///< 8bits, Opto-electronic transfer characteristics

    int matrix_coef;      ///< 8bits, Color primaries->YCbCr transform matrix

    int hrd_param_flag;   ///< Presence of Hypothetical Reference

                          ///< Decoder parameters

    //@}

#endif

    /** Sequence header data for all Profiles

     * TODO: choose between ints, uint8_ts and monobit flags

     */

    //@{

    int profile;          ///< 2bits, Profile

    int frmrtq_postproc;  ///< 3bits,

    int bitrtq_postproc;  ///< 5bits, quantized framerate-based postprocessing strength

    int fastuvmc;         ///< Rounding of qpel vector to hpel ? (not in Simple)

    int extended_mv;      ///< Ext MV in P/B (not in Simple)

    int dquant;           ///< How qscale varies with MBs, 2bits (not in Simple)

    int vstransform;      ///< variable-size [48]x[48] transform type + info

    int overlap;          ///< overlapped transforms in use

    int quantizer_mode;   ///< 2bits, quantizer mode used for sequence, see QUANT_*

    int finterpflag;      ///< INTERPFRM present

    //@}

    /** Frame decoding info for all profiles */

    //@{

    uint8_t mv_mode;      ///< MV coding monde

    uint8_t mv_mode2;     ///< Secondary MV coding mode (B frames)

    int k_x;              ///< Number of bits for MVs (depends on MV range)

    int k_y;              ///< Number of bits for MVs (depends on MV range)

    uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale

    /** pquant parameters */

    //@{

    uint8_t dquantfrm;

    uint8_t dqprofile;

    uint8_t dqsbedge;

    uint8_t dqbilevel;

    //@}

    /** AC coding set indexes

     * @see 8.1.1.10, p(1)10

     */

    //@{

    int c_ac_table_index; ///< Chroma index from ACFRM element

    int y_ac_table_index; ///< Luma index from AC2FRM element

    //@}

    int ttfrm;            ///< Transform type info present at frame level

    uint8_t ttmbf;        ///< Transform type flag

    int ttmb;             ///< Transform type

    uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform

    /** Luma compensation parameters */

    //@{

    uint8_t lumscale;

    uint8_t lumshift;

    //@}

    int16_t bfraction;    ///< Relative position % anchors=> how to scale MVs

    uint8_t halfpq;       ///< Uniform quant over image and qp+.5

    uint8_t respic;       ///< Frame-level flag for resized images

    int buffer_fullness;  ///< HRD info

    /** Ranges:

     * -# 0 -> [-64n 63.f] x [-32, 31.f]

     * -# 1 -> [-128, 127.f] x [-64, 63.f]

     * -# 2 -> [-512, 511.f] x [-128, 127.f]

     * -# 3 -> [-1024, 1023.f] x [-256, 255.f]

     */

    uint8_t mvrange;

    uint8_t pquantizer;           ///< Uniform (over sequence) quantizer in use

    uint8_t *previous_line_cbpcy; ///< To use for predicted CBPCY

    VLC *cbpcy_vlc;               ///< CBPCY VLC table

    int tt_index;                 ///< Index for Transform Type tables

    BitPlane mv_type_mb_plane;    ///< bitplane for mv_type == (4MV)

    BitPlane skip_mb_plane;       ///< bitplane for skipped MBs

    BitPlane direct_mb_plane;     ///< bitplane for "direct" MBs

    /** Frame decoding info for S/M profiles only */

    //@{

    uint8_t rangeredfrm; ///< out_sample = CLIP((in_sample-128)*2+128)

    uint8_t interpfrm;

    //@}

#if HAS_ADVANCED_PROFILE

    /** Frame decoding info for Advanced profile */

    //@{

    uint8_t fcm; ///< 0->Progressive, 2->Frame-Interlace, 3->Field-Interlace

    uint8_t numpanscanwin;

    uint8_t tfcntr;

    uint8_t rptfrm, tff, rff;

    uint16_t topleftx;

    uint16_t toplefty;

    uint16_t bottomrightx;

    uint16_t bottomrighty;

    uint8_t uvsamp;

    uint8_t postproc;

    int hrd_num_leaky_buckets;

    uint8_t bit_rate_exponent;

    uint8_t buffer_size_exponent;

    BitPlane ac_pred_plane;       ///< AC prediction flags bitplane

    BitPlane over_flags_plane;    ///< Overflags bitplane

    uint8_t condover;

    uint16_t *hrd_rate, *hrd_buffer;

    uint8_t *hrd_fullness;

    uint8_t range_mapy_flag;

    uint8_t range_mapuv_flag;

    uint8_t range_mapy;

    uint8_t range_mapuv;

    //@}

#endif

} VC1Context;

/**

 * Get unary code of limited length

 * @fixme FIXME Slow and ugly

 * @param gb GetBitContext

 * @param[in] stop The bitstop value (unary code of 1's or 0's)

 * @param[in] len Maximum length

 * @return Unary length/index

 */

static int get_prefix(GetBitContext *gb, int stop, int len)

{

#if 1

  int i = 0, tmp = !stop;

  while (i != len && tmp != stop)

  {

    tmp = get_bits(gb, 1);

    i++;

  }

  if (i == len && tmp != stop) return len+1;

  return i;

#else

  unsigned int buf;

  int log;

  OPEN_READER(re, gb);

  UPDATE_CACHE(re, gb);

  buf=GET_CACHE(re, gb); //Still not sure

  if (stop) buf = ~buf;

  log= av_log2(-buf); //FIXME: -?

  if (log < limit){

    LAST_SKIP_BITS(re, gb, log+1);

    CLOSE_READER(re, gb);

    return log;

  }

  LAST_SKIP_BITS(re, gb, limit);

  CLOSE_READER(re, gb);

  return limit;

#endif

}

/**

 * Init VC-1 specific tables and VC1Context members

 * @param v The VC1Context to initialize

 * @return Status

 */

static int vc1_init_common(VC1Context *v)

{

    static int done = 0;

    int i = 0;

    /* Set the bit planes */

    v->mv_type_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

    v->direct_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

    v->skip_mb_plane = (struct BitPlane) { NULL, 0, 0, 0 };

#if HAS_ADVANCED_PROFILE

    v->ac_pred_plane = v->over_flags_plane = (struct BitPlane) { NULL, 0, 0, 0 };

    v->hrd_rate = v->hrd_buffer = NULL;

#endif

    /* VLC tables */

#if 0 // spec -> actual tables converter

    for(i=0; i<64; i++){

        int code= (vc1_norm6_spec[i][1] << vc1_norm6_spec[i][4]) + vc1_norm6_spec[i][3];

        av_log(NULL, AV_LOG_DEBUG, "0x%03X, ", code);

        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");

    }

    for(i=0; i<64; i++){

        int code= vc1_norm6_spec[i][2] + vc1_norm6_spec[i][4];

        av_log(NULL, AV_LOG_DEBUG, "%2d, ", code);

        if(i%16==15) av_log(NULL, AV_LOG_DEBUG, "\n");

    }

#endif

    if(!done)

    {

        done = 1;

        INIT_VLC(&vc1_bfraction_vlc, VC1_BFRACTION_VLC_BITS, 23,

                 vc1_bfraction_bits, 1, 1,

                 vc1_bfraction_codes, 1, 1, 1);

        INIT_VLC(&vc1_norm2_vlc, VC1_NORM2_VLC_BITS, 4,

                 vc1_norm2_bits, 1, 1,

                 vc1_norm2_codes, 1, 1, 1);

        INIT_VLC(&vc1_norm6_vlc, VC1_NORM6_VLC_BITS, 64,

                 vc1_norm6_bits, 1, 1,

                 vc1_norm6_codes, 2, 2, 1);

        INIT_VLC(&vc1_imode_vlc, VC1_IMODE_VLC_BITS, 7,

                 vc1_imode_bits, 1, 1,

                 vc1_imode_codes, 1, 1, 1);

        for (i=0; i<3; i++)

        {

            INIT_VLC(&vc1_ttmb_vlc[i], VC1_TTMB_VLC_BITS, 16,

                     vc1_ttmb_bits[i], 1, 1,

                     vc1_ttmb_codes[i], 2, 2, 1);

            INIT_VLC(&vc1_ttblk_vlc[i], VC1_TTBLK_VLC_BITS, 8,

                     vc1_ttblk_bits[i], 1, 1,

                     vc1_ttblk_codes[i], 1, 1, 1);

            INIT_VLC(&vc1_subblkpat_vlc[i], VC1_SUBBLKPAT_VLC_BITS, 15,

                     vc1_subblkpat_bits[i], 1, 1,

                     vc1_subblkpat_codes[i], 1, 1, 1);

        }

        for(i=0; i<4; i++)

        {

            INIT_VLC(&vc1_4mv_block_pattern_vlc[i], VC1_4MV_BLOCK_PATTERN_VLC_BITS, 16,

                     vc1_4mv_block_pattern_bits[i], 1, 1,

                     vc1_4mv_block_pattern_codes[i], 1, 1, 1);

            INIT_VLC(&vc1_cbpcy_p_vlc[i], VC1_CBPCY_P_VLC_BITS, 64,

                     vc1_cbpcy_p_bits[i], 1, 1,

                     vc1_cbpcy_p_codes[i], 2, 2, 1);

            INIT_VLC(&vc1_mv_diff_vlc[i], VC1_MV_DIFF_VLC_BITS, 73,

                     vc1_mv_diff_bits[i], 1, 1,

                     vc1_mv_diff_codes[i], 2, 2, 1);

        }

    }

    /* Other defaults */

    v->pq = -1;

    v->mvrange = 0; /* 7.1.1.18, p80 */

    return 0;

}

#if HAS_ADVANCED_PROFILE

/**

 * Decode sequence header's Hypothetic Reference Decoder data

 * @see 6.2.1, p32

 * @param v The VC1Context to initialize

 * @param gb A GetBitContext initialized from AVCodecContext extra_data

 * @return Status

 */

static int decode_hrd(VC1Context *v, GetBitContext *gb)

{

    int i, num;

    num = 1 + get_bits(gb, 5);

    /*hrd rate*/

    if (v->hrd_rate || num != v->hrd_num_leaky_buckets)

    {

        av_freep(&v->hrd_rate);

    }

    if (!v->hrd_rate) v->hrd_rate = av_malloc(num*sizeof(uint16_t));

    if (!v->hrd_rate) return -1;

    /*hrd buffer*/

    if (v->hrd_buffer || num != v->hrd_num_leaky_buckets)

    {

        av_freep(&v->hrd_buffer);

    }

    if (!v->hrd_buffer) v->hrd_buffer = av_malloc(num*sizeof(uint16_t));

    if (!v->hrd_buffer)

    {

        av_freep(&v->hrd_rate);

        return -1;

    }

    /*hrd fullness*/

    if (v->hrd_fullness || num != v->hrd_num_leaky_buckets)

    {

        av_freep(&v->hrd_buffer);

    }

    if (!v->hrd_fullness) v->hrd_fullness = av_malloc(num*sizeof(uint8_t));

    if (!v->hrd_fullness)

    {

        av_freep(&v->hrd_rate);

        av_freep(&v->hrd_buffer);

        return -1;

    }

    v->hrd_num_leaky_buckets = num;

    //exponent in base-2 for rate

    v->bit_rate_exponent = 6 + get_bits(gb, 4);

    //exponent in base-2 for buffer_size

    v->buffer_size_exponent = 4 + get_bits(gb, 4);

    for (i=0; i<num; i++)

    {

        //mantissae, ordered (if not, use a function ?

        v->hrd_rate[i] = 1 + get_bits(gb, 16);

        if (i && v->hrd_rate[i-1]>=v->hrd_rate[i])

        {

            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Rates aren't strictly increasing:"

                   "%i vs %i\n", v->hrd_rate[i-1], v->hrd_rate[i]);

            return -1;

        }

        v->hrd_buffer[i] = 1 + get_bits(gb, 16);

        if (i && v->hrd_buffer[i-1]<v->hrd_buffer[i])

        {

            av_log(v->s.avctx, AV_LOG_ERROR, "HDR Buffers aren't decreasing:"

                   "%i vs %i\n", v->hrd_buffer[i-1], v->hrd_buffer[i]);

            return -1;

        }

    }

    return 0;

}

/**

 * Decode sequence header for Advanced Profile

 * @see Table 2, p18

 * @see 6.1.7, pp21-27

 * @param v The VC1Context to initialize

 * @param gb A GetBitContext initialized from AVCodecContext extra_data

 * @return Status

 */

static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

{

    VC1Context *v = avctx->priv_data;

    int nr, dr, aspect_ratio;

    v->postprocflag = get_bits(gb, 1);

    v->broadcast = get_bits(gb, 1);

    v->interlace = get_bits(gb, 1);

    v->tfcntrflag = get_bits(gb, 1);

    v->finterpflag = get_bits(gb, 1); //common

    v->panscanflag = get_bits(gb, 1);

    v->reserved = get_bits(gb, 1);

    if (v->reserved)

    {

        av_log(avctx, AV_LOG_ERROR, "RESERVED should be 0 (is %i)\n",

               v->reserved);

        return -1;

    }

    if (v->extended_mv)

        v->extended_dmv = get_bits(gb, 1);

    /* 6.1.7, p21 */

    if (get_bits(gb, 1) /* pic_size_flag */)

    {

        avctx->coded_width = get_bits(gb, 12) << 1;

        avctx->coded_height = get_bits(gb, 12) << 1;

        if ( get_bits(gb, 1) /* disp_size_flag */)

        {

            avctx->width = get_bits(gb, 14);

            avctx->height = get_bits(gb, 14);

        }

        /* 6.1.7.4, p23 */

        if ( get_bits(gb, 1) /* aspect_ratio_flag */)

        {

            aspect_ratio = get_bits(gb, 4); //SAR

            if (aspect_ratio == 0x0F) //FF_ASPECT_EXTENDED

            {

                avctx->sample_aspect_ratio.num = 1 + get_bits(gb, 8);

                avctx->sample_aspect_ratio.den = 1 + get_bits(gb, 8);

            }

            else if (aspect_ratio == 0x0E)

            {

                av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");

            }

            else

            {

              avctx->sample_aspect_ratio = vc1_pixel_aspect[aspect_ratio];

            }

        }

    }

    else

    {

        avctx->coded_width = avctx->width;

        avctx->coded_height = avctx->height;

    }

    /* 6.1.8, p23 */

    if ( get_bits(gb, 1) /* framerateflag */)

    {

        if ( !get_bits(gb, 1) /* framerateind */)

        {

            nr = get_bits(gb, 8);

            dr = get_bits(gb, 4);

            if (nr<1)

            {

                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATENR\n");

                return -1;

            }

            if (nr>5)

            {

                av_log(avctx, AV_LOG_ERROR,

                       "Reserved FRAMERATENR %i not handled\n", nr);

                nr = 5; /* overflow protection */

            }

            if (dr<1)

            {

                av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");

                return -1;

            }

            if (dr>2)

            {

                av_log(avctx, AV_LOG_ERROR,

                       "Reserved FRAMERATEDR %i not handled\n", dr);

                dr = 2; /* overflow protection */

            }

            avctx->time_base.num = fps_nr[dr - 1];

            avctx->time_base.den = fps_nr[nr - 1];

        }

        else

        {

            nr = get_bits(gb, 16);

            // 0.03125->2048Hz / 0.03125Hz

            avctx->time_base.den = 1000000;

            avctx->time_base.num = 31250*(1+nr);

        }

    }

    /* 6.1.9, p25 */

    if ( get_bits(gb, 1) /* color_format_flag */)

    {

        //Chromacity coordinates of color primaries

        //like ITU-R BT.709-2, BT.470-2, ...

        v->color_prim = get_bits(gb, 8);

        if (v->color_prim<1)

        {

            av_log(avctx, AV_LOG_ERROR, "0 for COLOR_PRIM is forbidden\n");

            return -1;

        }

        if (v->color_prim == 3 || v->color_prim>6)

        {

            av_log(avctx, AV_LOG_DEBUG, "Reserved COLOR_PRIM %i found\n",

                   v->color_prim);

            return -1;

        }

        //Opto-electronic transfer characteristics

        v->transfer_char = get_bits(gb, 8);

        if (v->transfer_char < 1)

        {

            av_log(avctx, AV_LOG_ERROR, "0 for TRAMSFER_CHAR is forbidden\n");

            return -1;

        }

        if (v->transfer_char == 3 || v->transfer_char>8)

        {

            av_log(avctx, AV_LOG_DEBUG, "Reserved TRANSFERT_CHAR %i found\n",

                   v->color_prim);

            return -1;

        }

        //Matrix coefficient for primariev->YCbCr

        v->matrix_coef = get_bits(gb, 8);

        if (v->matrix_coef < 1)

        {

            av_log(avctx, AV_LOG_ERROR, "0 for MATRIX_COEF is forbidden\n");

            return -1;

        }

        if ((v->matrix_coef > 2 && v->matrix_coef < 6) || v->matrix_coef > 7)

        {

            av_log(avctx, AV_LOG_DEBUG, "Reserved MATRIX_COEF %i found\n",

                   v->color_prim);

            return -1;

        }

    }

    //Hypothetical reference decoder indicator flag

    v->hrd_param_flag = get_bits(gb, 1);

    if (v->hrd_param_flag)

    {

      if (decode_hrd(v, gb) < 0) return -1;

    }

    /*reset scaling ranges, 6.2.2 & 6.2.3, p33*/

    v->range_mapy_flag = 0;

    v->range_mapuv_flag = 0;

    av_log(avctx, AV_LOG_DEBUG, "Advanced profile not supported yet\n");

    return -1;

}

#endif

/**

 * Decode Simple/Main Profiles sequence header

 * @see Figure 7-8, p16-17

 * @param avctx Codec context

 * @param gb GetBit context initialized from Codec context extra_data

 * @return Status

 */

static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

{

    VC1Context *v = avctx->priv_data;

    av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));

    v->profile = get_bits(gb, 2);

    if (v->profile == 2)

    {

        av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden\n");

        return -1;

    }

#if HAS_ADVANCED_PROFILE

    if (v->profile == PROFILE_ADVANCED)

    {

        v->level = get_bits(gb, 3);

        if(v->level >= 5)

        {

            av_log(avctx, AV_LOG_ERROR, "Reserved LEVEL %i\n",v->level);

        }

        v->chromaformat = get_bits(gb, 2);

        if (v->chromaformat != 1)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "Only 4:2:0 chroma format supported\n");

            return -1;

        }

    }

    else

#endif

    {

        v->res_sm = get_bits(gb, 2); //reserved

        if (v->res_sm)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "Reserved RES_SM=%i is forbidden\n", v->res_sm);

            return -1;

        }

    }

    // (fps-2)/4 (->30)

    v->frmrtq_postproc = get_bits(gb, 3); //common

    // (bitrate-32kbps)/64kbps

    v->bitrtq_postproc = get_bits(gb, 5); //common

    v->s.loop_filter = get_bits(gb, 1); //common

    if(v->s.loop_filter == 1 && v->profile == PROFILE_SIMPLE)

    {

        av_log(avctx, AV_LOG_ERROR,

               "LOOPFILTER shell not be enabled in simple profile\n");

    }

#if HAS_ADVANCED_PROFILE

    if (v->profile < PROFILE_ADVANCED)

#endif

    {

        v->res_x8 = get_bits(gb, 1); //reserved

        if (v->res_x8)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "1 for reserved RES_X8 is forbidden\n");

            //return -1;

        }

        v->multires = get_bits(gb, 1);

        v->res_fasttx = get_bits(gb, 1);

        if (!v->res_fasttx)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "0 for reserved RES_FASTTX is forbidden\n");

            //return -1;

        }

    }

    v->fastuvmc =  get_bits(gb, 1); //common

    if (!v->profile && !v->fastuvmc)

    {

        av_log(avctx, AV_LOG_ERROR,

               "FASTUVMC unavailable in Simple Profile\n");

        return -1;

    }

    v->extended_mv =  get_bits(gb, 1); //common

    if (!v->profile && v->extended_mv)

    {

        av_log(avctx, AV_LOG_ERROR,

               "Extended MVs unavailable in Simple Profile\n");

        return -1;

    }

    v->dquant =  get_bits(gb, 2); //common

    v->vstransform =  get_bits(gb, 1); //common

#if HAS_ADVANCED_PROFILE

    if (v->profile < PROFILE_ADVANCED)

#endif

    {

        v->res_transtab = get_bits(gb, 1);

        if (v->res_transtab)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "1 for reserved RES_TRANSTAB is forbidden\n");

            return -1;

        }

    }

    v->overlap = get_bits(gb, 1); //common

#if HAS_ADVANCED_PROFILE

    if (v->profile < PROFILE_ADVANCED)

#endif

    {

        v->s.resync_marker = get_bits(gb, 1);

        v->rangered = get_bits(gb, 1);

        if (v->rangered && v->profile == PROFILE_SIMPLE)

        {

            av_log(avctx, AV_LOG_DEBUG,

                   "RANGERED should be set to 0 in simple profile\n");

        }

    }

    v->s.max_b_frames = avctx->max_b_frames = get_bits(gb, 3); //common

    v->quantizer_mode = get_bits(gb, 2); //common

#if HAS_ADVANCED_PROFILE

    if (v->profile < PROFILE_ADVANCED)

#endif

    {

        v->finterpflag = get_bits(gb, 1); //common

        v->res_rtm_flag = get_bits(gb, 1); //reserved

        if (!v->res_rtm_flag)

        {

            av_log(avctx, AV_LOG_ERROR,

                   "0 for reserved RES_RTM_FLAG is forbidden\n");

            //return -1;

        }

#if TRACE

        av_log(avctx, AV_LOG_INFO,

               "Profile %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

               "LoopFilter=%i, MultiRes=%i, FastUVMV=%i, Extended MV=%i\n"

               "Rangered=%i, VSTransform=%i, Overlap=%i, SyncMarker=%i\n"

               "DQuant=%i, Quantizer mode=%i, Max B frames=%i\n",

               v->profile, v->frmrtq_postproc, v->bitrtq_postproc,

               v->s.loop_filter, v->multires, v->fastuvmc, v->extended_mv,

               v->rangered, v->vstransform, v->overlap, v->s.resync_marker,

               v->dquant, v->quantizer_mode, avctx->max_b_frames

               );

        return 0;

#endif

    }

#if HAS_ADVANCED_PROFILE

    else return decode_advanced_sequence_header(avctx, gb);

#endif

}

#if HAS_ADVANCED_PROFILE

/** Entry point decoding (Advanced Profile)

 * @param avctx Codec context

 * @param gb GetBit context initialized from avctx->extra_data

 * @return Status

 */

static int advanced_entry_point_process(AVCodecContext *avctx, GetBitContext *gb)

{

    VC1Context *v = avctx->priv_data;

    int i;

    if (v->profile != PROFILE_ADVANCED)

    {

        av_log(avctx, AV_LOG_ERROR,

               "Entry point are only defined in Advanced Profile!\n");

        return -1; //Only for advanced profile!

    }

    if (v->hrd_param_flag)

    {

        //Update buffer fullness

        av_log(avctx, AV_LOG_DEBUG, "Buffer fullness update\n");

        assert(v->hrd_num_leaky_buckets > 0);

        for (i=0; i<v->hrd_num_leaky_buckets; i++)

            v->hrd_fullness[i] = get_bits(gb, 8);

    }

    if ((v->range_mapy_flag = get_bits(gb, 1)))

    {

        //RANGE_MAPY

        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPY\n");

        v->range_mapy = get_bits(gb, 3);

    }

    if ((v->range_mapuv_flag = get_bits(gb, 1)))

    {

        //RANGE_MAPUV

        av_log(avctx, AV_LOG_DEBUG, "RANGE_MAPUV\n");

        v->range_mapuv = get_bits(gb, 3);

    }

    if (v->panscanflag)

    {

        //NUMPANSCANWIN

        v->numpanscanwin = get_bits(gb, 3);

        av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);

    }

    return 0;

}

#endif

/***********************************************************************/

/**

 * @defgroup bitplane VC1 Bitplane decoding

 * @see 8.7, p56

 * @{

 */

/** @addtogroup bitplane

 * Imode types

 * @{

 */

#define IMODE_RAW     0

#define IMODE_NORM2   1

#define IMODE_DIFF2   2

#define IMODE_NORM6   3

#define IMODE_DIFF6   4

#define IMODE_ROWSKIP 5

#define IMODE_COLSKIP 6

/** @} */ //imode defines

/** Allocate the buffer from a bitplane, given its dimensions

 * @param bp Bitplane which buffer is to allocate

 * @param[in] width Width of the buffer

 * @param[in] height Height of the buffer

 * @return Status

 * @todo TODO: Take into account stride

 * @todo TODO: Allow use of external buffers ?

 */

static int alloc_bitplane(BitPlane *bp, int width, int height)

{

    if (!bp || bp->width<0 || bp->height<0) return -1;

    bp->data = (uint8_t*)av_malloc(width*height);

    if (!bp->data) return -1;

    bp->width = bp->stride = width;

    bp->height = height;

    return 0;

}

/** Free the bitplane's buffer

 * @param bp Bitplane which buffer is to free

 */

static void free_bitplane(BitPlane *bp)

{

    bp->width = bp->stride = bp->height = 0;

    if (bp->data) av_freep(&bp->data);

}

/** Decode rows by checking if they are skipped

 * @param plane Buffer to store decoded bits

 * @param[in] width Width of this buffer

 * @param[in] height Height of this buffer

 * @param[in] stride of this buffer

 */

static void decode_rowskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){

    int x, y;

    for (y=0; y<height; y++){

        if (!get_bits(gb, 1)) //rowskip

            memset(plane, 0, width);

        else

            for (x=0; x<width; x++)

                plane[x] = get_bits(gb, 1);

        plane += stride;

    }

}

/** Decode columns by checking if they are skipped

 * @param plane Buffer to store decoded bits

 * @param[in] width Width of this buffer

 * @param[in] height Height of this buffer

 * @param[in] stride of this buffer

 * @fixme FIXME: Optimize

 */

static void decode_colskip(uint8_t* plane, int width, int height, int stride, GetBitContext *gb){

    int x, y;

    for (x=0; x<width; x++){

        if (!get_bits(gb, 1)) //colskip

            for (y=0; y<height; y++)

                plane[y*stride] = 0;

        else

            for (y=0; y<height; y++)

                plane[y*stride] = get_bits(gb, 1);

        plane ++;

    }

}

/** Decode a bitplane's bits

 * @param bp Bitplane where to store the decode bits

 * @param v VC1 context for bit reading and logging

 * @return Status

 * @fixme FIXME: Optimize

 * @todo TODO: Decide if a struct is needed

 */

static int bitplane_decoding(BitPlane *bp, VC1Context *v)

{

    GetBitContext *gb = &v->s.gb;

    int imode, x, y, code, use_vertical_tile, tile_w, tile_h, offset;

    uint8_t invert, *planep = bp->data;

    invert = get_bits(gb, 1);

    imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 2);

    bp->is_raw = 0;

    switch (imode)

    {

    case IMODE_RAW:

        //Data is actually read in the MB layer (same for all tests == "raw")

        bp->is_raw = 1; //invert ignored

        return invert;

    case IMODE_DIFF2:

    case IMODE_NORM2:

        if ((bp->height*bp->width) & 1)

        {

            *(++planep) = get_bits(gb, 1);

            offset = x = 1;

        }

        else offset = x = 0;

        for (y=0; y<bp->height; y++)

        {

            for(; x<bp->width; x+=2)

            {

                code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 2);

                *(++planep) = code&1; //lsb => left

                *(++planep) = (code>>1)&1; //msb => right

            }

            planep += bp->stride-bp->width;

            if ((bp->width-offset)&1) //Odd number previously processed

            {

                code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 2);

                *planep = code&1;

                planep += bp->stride-bp->width;

                *planep = (code>>1)&1; //msb => right

                offset = x = 1;

            }

            else

            {

                offset = x = 0;

                planep += bp->stride-bp->width;

            }

        }

        break;

    case IMODE_DIFF6:

    case IMODE_NORM6:

        use_vertical_tile=  bp->height%3==0 &&  bp->width%3!=0;

        tile_w= use_vertical_tile ? 2 : 3;

        tile_h= use_vertical_tile ? 3 : 2;

        for(y=  bp->height%tile_h; y< bp->height; y+=tile_h){

            for(x=  bp->width%tile_w; x< bp->width; x+=tile_w){

                code = get_vlc2(gb, vc1_norm6_vlc.table, VC1_NORM6_VLC_BITS, 2);

                if(code<0){

                    av_log(v->s.avctx, AV_LOG_DEBUG, "invalid NORM-6 VLC\n");

                    return -1;

                }

                //FIXME following is a pure guess and probably wrong

                //FIXME A bitplane (0 | !0), so could the shifts be avoided ?

                planep[x     + 0*bp->stride]= (code>>0)&1;

                planep[x + 1 + 0*bp->stride]= (code>>1)&1;

                //FIXME Does branch prediction help here?

                if(use_vertical_tile){

                    planep[x + 0 + 1*bp->stride]= (code>>2)&1;

                    planep[x + 1 + 1*bp->stride]= (code>>3)&1;

                    planep[x + 0 + 2*bp->stride]= (code>>4)&1;

                    planep[x + 1 + 2*bp->stride]= (code>>5)&1;

                }else{

                    planep[x + 2 + 0*bp->stride]= (code>>2)&1;

                    planep[x + 0 + 1*bp->stride]= (code>>3)&1;

                    planep[x + 1 + 1*bp->stride]= (code>>4)&1;

                    planep[x + 2 + 1*bp->stride]= (code>>5)&1;

                }

            }

        }

        x=  bp->width % tile_w;

        decode_colskip(bp->data  ,             x, bp->height         , bp->stride, &v->s.gb);

        decode_rowskip(bp->data+x, bp->width - x, bp->height % tile_h, bp->stride, &v->s.gb);

        break;

    case IMODE_ROWSKIP:

        decode_rowskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);

        break;

    case IMODE_COLSKIP:

        decode_colskip(bp->data, bp->width, bp->height, bp->stride, &v->s.gb);

        break;

    default: break;

    }

    /* Applying diff operator */

    if (imode == IMODE_DIFF2 || imode == IMODE_DIFF6)

    {

        planep = bp->data;

        planep[0] ^= invert;

        for (x=1; x<bp->width; x++)

            planep[x] ^= planep[x-1];

        for (y=1; y<bp->height; y++)

        {

            planep += bp->stride;

            planep[0] ^= planep[-bp->stride];

            for (x=1; x<bp->width; x++)

            {

                if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;

                else                                     planep[x] ^= planep[x-1];

            }

        }

    }

    else if (invert)

    {

        planep = bp->data;

        for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride

    }

    return (imode<<1) + invert;

}

/** @} */ //Bitplane group

/***********************************************************************/

/** VOP Dquant decoding

 * @param v VC1 Context

 */

static int vop_dquant_decoding(VC1Context *v)

{

    GetBitContext *gb = &v->s.gb;

    int pqdiff;

    //variable size

    if (v->dquant == 2)

    {

        pqdiff = get_bits(gb, 3);

        if (pqdiff == 7) v->altpq = get_bits(gb, 5);

        else v->altpq = v->pq + pqdiff + 1;

    }

    else

    {

        v->dquantfrm = get_bits(gb, 1);

        if ( v->dquantfrm )

        {

            v->dqprofile = get_bits(gb, 2);

            switch (v->dqprofile)

            {

            case DQPROFILE_SINGLE_EDGE:

            case DQPROFILE_DOUBLE_EDGES:

                v->dqsbedge = get_bits(gb, 2);

                break;

            case DQPROFILE_ALL_MBS:

                v->dqbilevel = get_bits(gb, 1);

            default: break; //Forbidden ?

            }

            if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)

            {

                pqdiff = get_bits(gb, 3);

                if (pqdiff == 7) v->altpq = get_bits(gb, 5);

                else v->altpq = v->pq + pqdiff + 1;

            }

        }

    }

    return 0;

}

/***********************************************************************/

/**

 * @defgroup all_frame_hdr All VC1 profiles frame header

 * @brief Part of the frame header decoding from all profiles

 * @warning Only pro/epilog differs between Simple/Main and Advanced => check caller

 * @{

 */

/** B and BI frame header decoding, primary part

 * @see Tables 11+12, p62-65

 * @param v VC1 context

 * @return Status

 * @warning Also handles BI frames

 */

static int decode_b_picture_primary_header(VC1Context *v)

{

    GetBitContext *gb = &v->s.gb;

    int pqindex;

    /* Prolog common to all frametypes should be done in caller */

    if (v->profile == PROFILE_SIMPLE)

    {

        av_log(v->s.avctx, AV_LOG_ERROR, "Found a B frame while in Simple Profile!\n");

        return FRAME_SKIPPED;

    }

    v->bfraction = vc1_bfraction_lut[get_vlc2(gb, vc1_bfraction_vlc.table,

                                              VC1_BFRACTION_VLC_BITS, 2)];

    if (v->bfraction < -1)

    {

        av_log(v->s.avctx, AV_LOG_ERROR, "Invalid BFRaction\n");

        return FRAME_SKIPPED;

    }

    else if (!v->bfraction)

    {

        /* We actually have a BI frame */

        v->s.pict_type = BI_TYPE;

        v->buffer_fullness = get_bits(gb, 7);

    }

    /* Read the quantization stuff */

    pqindex = get_bits(gb, 5);

    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

        v->pq = pquant_table[0][pqindex];

    else

    {

        v->pq = pquant_table[v->quantizer_mode-1][pqindex];

    }

    if (pqindex < 9) v->halfpq = get_bits(gb, 1);

    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

        v->pquantizer = get_bits(gb, 1);

#if HAS_ADVANCED_PROFILE

    if (v->profile == PROFILE_ADVANCED)

    {

        if (v->postprocflag) v->postproc = get_bits(gb, 2);

        if (v->extended_mv == 1 && v->s.pict_type != BI_TYPE)

            v->mvrange = get_prefix(gb, 0, 3);

    }

#endif

    else

    {

        if (v->extended_mv == 1)

            v->mvrange = get_prefix(gb, 0, 3);

    }

    /* Read the MV mode */

    if (v->s.pict_type != BI_TYPE)

    {

        v->mv_mode = get_bits(gb, 1);

        if (v->pq < 13)

        {

            if (!v->mv_mode)

            {

                v->mv_mode = get_bits(gb, 2);

                if (v->mv_mode)

                av_log(v->s.avctx, AV_LOG_ERROR,

                       "mv_mode for lowquant B frame was %i\n", v->mv_mode);

            }

        }

        else

        {

            if (!v->mv_mode)

            {

                if (get_bits(gb, 1))

                     av_log(v->s.avctx, AV_LOG_ERROR,

                            "mv_mode for highquant B frame was %i\n", v->mv_mode);

            }

            v->mv_mode = 1-v->mv_mode; //To match (pq < 13) mapping

        }

    }

    return 0;

}

/** B and BI frame header decoding, secondary part

 * @see Tables 11+12, p62-65

 * @param v VC1 context

 * @return Status

 * @warning Also handles BI frames

 * @warning To call once all MB arrays are allocated

 * @todo Support Advanced Profile headers

 */

static int decode_b_picture_secondary_header(VC1Context *v)

{

    GetBitContext *gb = &v->s.gb;

    int status;

    status = bitplane_decoding(&v->skip_mb_plane, v);

    if (status < 0) return -1;

#if TRACE

    if (v->mv_mode == MV_PMODE_MIXED_MV)

    {

        status = bitplane_decoding(&v->mv_type_mb_plane, v);

        if (status < 0)

            return -1;

#if TRACE

        av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

               "Imode: %i, Invert: %i\n", status>>1, status&1);

#endif

    }

    //bitplane

    status = bitplane_decoding(&v->direct_mb_plane, v);

    if (status < 0) return -1;

#if TRACE

    av_log(v->s.avctx, AV_LOG_DEBUG, "MB Direct plane encoding: "

           "Imode: %i, Invert: %i\n", status>>1, status&1);

#endif

    av_log(v->s.avctx, AV_LOG_DEBUG, "Skip MB plane encoding: "

           "Imode: %i, Invert: %i\n", status>>1, status&1);

#endif

    /* FIXME: what is actually chosen for B frames ? */

    v->s.mv_table_index = get_bits(gb, 2); //but using vc1_ tables

    v->cbpcy_vlc = &vc1_cbpcy_p_vlc[get_bits(gb, 2)];

    if (v->dquant)

    {

        vop_dquant_decoding(v);

    }

    if (v->vstransform)

    {

        v->ttmbf = get_bits(gb, 1);

        if (v->ttmbf)

        {

            v->ttfrm = get_bits(gb, 2);

            av_log(v->s.avctx, AV_LOG_INFO, "Transform used: %ix%i\n",

                   (v->ttfrm & 2) ? 4 : 8, (v->ttfrm & 1) ? 4 : 8);

        }

    }

    /* Epilog (AC/DC syntax) should be done in caller */

    return 0;

}

/** I frame header decoding, primary part

 * @see Tables 5+7, p53-54 and 55-57

 * @param v VC1 context

 * @return Status

 * @todo Support Advanced Profile headers

 */

static int decode_i_picture_primary_header(VC1Context *v)

{

    GetBitContext *gb = &v->s.gb;

    int pqindex;

    /* Prolog common to all frametypes should be done in caller */

    //BF = Buffer Fullness

    if (v->profile < PROFILE_ADVANCED && get_bits(gb, 7))

    {

        av_log(v->s.avctx, AV_LOG_DEBUG, "I BufferFullness not 0\n");

    }

    /* Quantizer stuff */

    pqindex = get_bits(gb, 5);

    if (v->quantizer_mode == QUANT_FRAME_IMPLICIT)

        v->pq = pquant_table[0][pqindex];

    else

    {

        v->pq = pquant_table[v->quantizer_mode-1][pqindex];

    }

    if (pqindex < 9) v->halfpq = get_bits(gb, 1);

    if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

        v->pquantizer = get_bits(gb, 1);

    av_log(v->s.avctx, AV_LOG_DEBUG, "I frame: QP=%i (+%i/2)\n",

           v->pq, v->halfpq);

    return 0;

}

/** I frame header decoding, secondary part

 * @param v VC1 context

 * @return Status

 * @warning Not called in A/S/C profiles, it seems

 * @todo Support Advanced Profile headers

 */

static int decode_i_picture_secondary_header(VC1Context *v)

{

#if HAS_ADVANCED_PROFILE

    int status;

    if (v->profile == PROFILE_ADVANCED)

    {

        v->s.ac_pred = get_bits(&v->s.gb, 1);

        if (v->postprocflag) v->postproc = get_bits(&v->s.gb, 1);

        /* 7.1.1.34 + 8.5.2 */

        if (v->overlap && v->pq<9)

        {

            v->condover = get_bits(&v->s.gb, 1);

            if (v->condover)

            {

                v->condover = 2+get_bits(&v->s.gb, 1);

                if (v->condover == 3)

                {

                    status = bitplane_decoding(&v->over_flags_plane, v);

                    if (status < 0) return -1;

#  if TRACE

                    av_log(v->s.avctx, AV_LOG_DEBUG, "Overflags plane encoding: "

                           "Imode: %i, Invert: %i\n", status>>1, status&1);

#  endif

                }

            }

        }

    }

#endif

    /* Epilog (AC/DC syntax) should be done in caller */

    return 0;

}

/** P frame header decoding, primary part

 * @see Tables 5+7, p53-54 and 55-57

 * @param v VC1 context

 * @todo Support Advanced Profile headers

 * @return Status

 */

static int decode_p_picture_primary_header(VC1Context *v)

{

    /* INTERFRM, FRMCNT, RANGEREDFRM read in caller */

    GetBitContext *gb = &v->s.gb;

    int lowquant, pqindex;

    pqindex = get_bits(gb, 5);