@@ -85,6 +85,11 @@ int ff_h263_decode_init(AVCodecContext *avctx)

         s->h263_pred = 1;

         s->msmpeg4_version=5;

         break;

+    case CODEC_ID_WMV3:

+        s->h263_msmpeg4 = 1;

+        s->h263_pred = 1;

+        s->msmpeg4_version=6;

+        break;

     case CODEC_ID_H263I:

         break;

     case CODEC_ID_FLV1:

@@ -75,6 +75,8 @@ static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);

 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);

 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]);

+/* vc9 externs */

+extern uint8_t wmv3_dc_scale_table[32];

 #ifdef DEBUG

 int intra_count = 0;

@@ -175,6 +177,11 @@ static void common_init(MpegEncContext * s)

         s->y_dc_scale_table= wmv1_y_dc_scale_table;

         s->c_dc_scale_table= wmv1_c_dc_scale_table;

         break;

+    case 6:

+        s->y_dc_scale_table= wmv3_dc_scale_table;

+        s->c_dc_scale_table= wmv3_dc_scale_table;

+        break;

+

     }

@@ -629,7 +636,7 @@ void msmpeg4_encode_mb(MpegEncContext * s,

             if (s->pict_type == I_TYPE) {

                 set_stat(ST_INTRA_MB);

                 put_bits(&s->pb, 

-                         table_mb_intra[coded_cbp][1], table_mb_intra[coded_cbp][0]);

+                         ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);

             } else {

                 if (s->use_skip_mb_code)

                     put_bits(&s->pb, 1, 0);	/* mb coded */

@@ -1030,9 +1037,9 @@ else

 /* decoding stuff */

 static VLC mb_non_intra_vlc[4];

-static VLC mb_intra_vlc;

-static VLC dc_lum_vlc[2];

-static VLC dc_chroma_vlc[2];

+VLC ff_msmp4_mb_i_vlc;

+VLC ff_msmp4_dc_luma_vlc[2];

+VLC ff_msmp4_dc_chroma_vlc[2];

 static VLC v2_dc_lum_vlc;

 static VLC v2_dc_chroma_vlc;

 static VLC cbpy_vlc;

@@ -1121,16 +1128,16 @@ int ff_msmpeg4_decode_init(MpegEncContext *s)

                      mv->table_mv_code, 2, 2, 1);

         }

-        init_vlc(&dc_lum_vlc[0], DC_VLC_BITS, 120, 

+        init_vlc(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, 

                  &ff_table0_dc_lum[0][1], 8, 4,

                  &ff_table0_dc_lum[0][0], 8, 4, 1);

-        init_vlc(&dc_chroma_vlc[0], DC_VLC_BITS, 120, 

+        init_vlc(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, 

                  &ff_table0_dc_chroma[0][1], 8, 4,

                  &ff_table0_dc_chroma[0][0], 8, 4, 1);

-        init_vlc(&dc_lum_vlc[1], DC_VLC_BITS, 120, 

+        init_vlc(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, 

                  &ff_table1_dc_lum[0][1], 8, 4,

                  &ff_table1_dc_lum[0][0], 8, 4, 1);

-        init_vlc(&dc_chroma_vlc[1], DC_VLC_BITS, 120, 

+        init_vlc(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, 

                  &ff_table1_dc_chroma[0][1], 8, 4,

                  &ff_table1_dc_chroma[0][0], 8, 4, 1);

@@ -1160,9 +1167,9 @@ int ff_msmpeg4_decode_init(MpegEncContext *s)

                      &wmv2_inter_table[i][0][0], 8, 4, 1); //FIXME name?

         }

-        init_vlc(&mb_intra_vlc, MB_INTRA_VLC_BITS, 64, 

-                 &table_mb_intra[0][1], 4, 2,

-                 &table_mb_intra[0][0], 4, 2, 1);

+        init_vlc(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, 

+                 &ff_msmp4_mb_i_table[0][1], 4, 2,

+                 &ff_msmp4_mb_i_table[0][0], 4, 2, 1);

         init_vlc(&v1_intra_cbpc_vlc, V1_INTRA_CBPC_VLC_BITS, 8, 

                  intra_MCBPC_bits, 1, 1,

@@ -1187,6 +1194,8 @@ int ff_msmpeg4_decode_init(MpegEncContext *s)

         break;

     case 5:

         s->decode_mb= wmv2_decode_mb;

+    case 6:

+        //FIXME + TODO VC9 decode mb

         break;

     }

@@ -1588,7 +1597,7 @@ static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64])

     } else {

         set_stat(ST_INTRA_MB);

         s->mb_intra = 1;

-        code = get_vlc2(&s->gb, mb_intra_vlc.table, MB_INTRA_VLC_BITS, 2);

+        code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);

         if (code < 0)

             return -1;

         /* predict coded block pattern */

@@ -1911,9 +1920,9 @@ static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)

         level-=256;

     }else{  //FIXME optimize use unified tables & index

         if (n < 4) {

-            level = get_vlc2(&s->gb, dc_lum_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

+            level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

         } else {

-            level = get_vlc2(&s->gb, dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

+            level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3);

         }

         if (level < 0){

             av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n");

@@ -4,7 +4,7 @@

  */

 /* intra picture macro block coded block pattern */

-static const uint16_t table_mb_intra[64][2] = {

+const uint16_t ff_msmp4_mb_i_table[64][2] = {

 { 0x1, 1 },{ 0x17, 6 },{ 0x9, 5 },{ 0x5, 5 },

 { 0x6, 5 },{ 0x47, 9 },{ 0x20, 7 },{ 0x10, 7 },

 { 0x2, 5 },{ 0x7c, 9 },{ 0x3a, 7 },{ 0x1d, 7 },

@@ -32,8 +32,14 @@

 #include "avcodec.h"

 #include "mpegvideo.h"

 #include "vc9data.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   1

@@ -45,7 +51,7 @@ extern const uint32_t ff_table0_dc_chroma[120][2], ff_table1_dc_chroma[120][2];

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

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

   {                                                                    \

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

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

     return -1;                                                         \

   }

 #else

@@ -134,15 +140,10 @@ static VLC vc9_norm6_vlc;

 static VLC vc9_ttmb_vlc[3];

 #define VC9_MV_DIFF_VLC_BITS 9 //15

 static VLC vc9_mv_diff_vlc[4];

-#define VC9_CBPCY_I_VLC_BITS 9 //13

-static VLC vc9_cbpcy_i_vlc;

 #define VC9_CBPCY_P_VLC_BITS 9 //14

 static VLC vc9_cbpcy_p_vlc[4];

 #define VC9_4MV_BLOCK_PATTERN_VLC_BITS 6

 static VLC vc9_4mv_block_pattern_vlc[4];

-#define VC9_DC_VLC_BITS 9

-static VLC vc9_luma_dc_vlc[2];

-static VLC vc9_chroma_dc_vlc[2];

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

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

@@ -155,8 +156,7 @@ typedef struct BitPlane {

 typedef struct VC9Context{

   /* No MpegEnc context, might be good to use it */

-  GetBitContext gb;

-  AVCodecContext *avctx;

+  MpegEncContext s;

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

   /* Sequence Header         */

@@ -167,7 +167,6 @@ typedef struct VC9Context{

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

   int res_fasttx; //always 1

   int res_transtab; //always 0

-  int syncmarker; //Sync markers presents

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

   int res_rtm_flag; //reserved, set to 1

   int reserved; //duh

@@ -196,8 +195,9 @@ typedef struct VC9Context{

     int loopfilter;

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

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

-  int dquant; //Q varies with MBs, 2bits (not in Simple)

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

   int vstransform; //variable-size transform46

+  

   int overlap; //overlapped transforms in use

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

@@ -209,10 +209,8 @@ typedef struct VC9Context{

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

   /* All profiles */

   uint8_t mv_mode, mv_mode2; /* MV coding mode */

-  uint8_t pict_type; /* Picture type, mapped on MPEG types */

   uint8_t pq, altpq; /* Quantizers */

   uint8_t dquantfrm, dqprofile, dqsbedge, dqbilevel; /* pquant parameters */

-  int width_mb, height_mb;

   int tile; /* 3x2 if (width_mb%3) else 2x3 */

   VLC *luma_ac_vlc, *chroma_ac_vlc,

     *luma_dc_vlc, *chroma_dc_vlc; /* transac/dcfrm bits are indexes */

@@ -251,7 +249,6 @@ typedef struct VC9Context{

   uint8_t toplefty;

   uint8_t bottomrightx;

   uint8_t bottomrighty;

-  uint8_t rndctrl;

   uint8_t uvsamp;

   uint8_t postproc;

   int hrd_num_leaky_buckets;

@@ -299,7 +296,7 @@ static int get_prefix(GetBitContext *gb, int stop, int len)

 #endif

 }

-static int init_common(VC9Context *v)

+static int vc9_init_common(VC9Context *v)

 {

     static int done = 0;

     int i;

@@ -339,24 +336,9 @@ static int init_common(VC9Context *v)

         INIT_VLC(&vc9_norm6_vlc, VC9_NORM6_VLC_BITS, 64,

                  vc9_norm6_bits, 1, 1,

                  vc9_norm6_codes, 2, 2, 1);

-        INIT_VLC(&vc9_cbpcy_i_vlc, VC9_CBPCY_I_VLC_BITS, 64,

-                 vc9_cbpcy_i_bits, 1, 1,

-                 vc9_cbpcy_i_codes, 2, 2, 1);

         INIT_VLC(&vc9_imode_vlc, VC9_IMODE_VLC_BITS, 7,

                  vc9_imode_bits, 1, 1,

                  vc9_imode_codes, 1, 1, 1);

-        INIT_VLC(&vc9_luma_dc_vlc[0], VC9_DC_VLC_BITS, 120, 

-                 &ff_table0_dc_lum[0][1], 8, 4,

-                 &ff_table0_dc_lum[0][0], 8, 4, 1);

-        INIT_VLC(&vc9_chroma_dc_vlc[0], VC9_DC_VLC_BITS, 120, 

-                 &ff_table0_dc_chroma[0][1], 8, 4,

-                 &ff_table0_dc_chroma[0][0], 8, 4, 1);

-        INIT_VLC(&vc9_luma_dc_vlc[1], VC9_DC_VLC_BITS, 120, 

-                 &ff_table1_dc_lum[0][1], 8, 4,

-                 &ff_table1_dc_lum[0][0], 8, 4, 1);

-        INIT_VLC(&vc9_chroma_dc_vlc[1], VC9_DC_VLC_BITS, 120, 

-                 &ff_table1_dc_chroma[0][1], 8, 4,

-                 &ff_table1_dc_chroma[0][0], 8, 4, 1);

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

         {

             INIT_VLC(&vc9_ttmb_vlc[i], VC9_TTMB_VLC_BITS, 16,

@@ -676,11 +658,11 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

     if (v->profile <= PROFILE_MAIN)

 #endif

     {

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

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

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

     }

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

+    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

@@ -703,7 +685,7 @@ static int decode_sequence_header(AVCodecContext *avctx, GetBitContext *gb)

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

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

                v->loopfilter, v->multires, v->fastuvmc, v->extended_mv,

-               v->rangered, v->vstransform, v->overlap, v->syncmarker,

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

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

                );

         return 0;

@@ -778,15 +760,22 @@ int alloc_bitplane(BitPlane *bp, int width, int height)

     return 0;

 }

+void free_bitplane(BitPlane *bp)

+{

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

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

+}

+

 static void decode_rowskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){

     int x, y;

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

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

-        if (!get_bits(&v->gb, 1)) //rowskip

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

             memset(plane, 0, width);

         else

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

-                plane[x] = get_bits(&v->gb, 1);

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

         plane += stride;

     }

 }

@@ -794,14 +783,15 @@ static void decode_rowskip(uint8_t* plane, int width, int height, int stride, VC

 //FIXME optimize

 static void decode_colskip(uint8_t* plane, int width, int height, int stride, VC9Context *v){

     int x, y;

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

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

-        if (!get_bits(&v->gb, 1)) //colskip

+        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(&v->gb, 1);

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

         plane ++;

     }

 }

@@ -813,11 +803,13 @@ static void decode_colskip(uint8_t* plane, int width, int height, int stride, VC

 //      later on)

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

 {

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

+

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

     uint8_t invert, *planep = bp->data;

-    invert = get_bits(&v->gb, 1);

-    imode = get_vlc2(&v->gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);

+    invert = get_bits(gb, 1);

+    imode = get_vlc2(gb, vc9_imode_vlc.table, VC9_IMODE_VLC_BITS, 2);

     bp->is_raw = 0;

     switch (imode)

@@ -828,9 +820,9 @@ static int bitplane_decoding(BitPlane *bp, VC9Context *v)

         return invert;

     case IMODE_DIFF2:

     case IMODE_NORM2:

-        if ((bp->height*bp->width) & 1) *(++planep) = get_bits(&v->gb, 1);

+        if ((bp->height*bp->width) & 1) *(++planep) = get_bits(gb, 1);

         for(x=0; x<(bp->height*bp->width)>>1; x++){

-            code = get_vlc2(&v->gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);

+            code = get_vlc2(gb, vc9_norm2_vlc.table, VC9_NORM2_VLC_BITS, 2);

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

             *(++planep) = code&2; //msb => right - bitplane => only !0 matters

             //FIXME width->stride

@@ -844,9 +836,9 @@ static int bitplane_decoding(BitPlane *bp, VC9Context *v)

         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(&v->gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);

+                code = get_vlc2(gb, vc9_norm6_vlc.table, VC9_NORM6_VLC_BITS, 2);

                 if(code<0){

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

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

                     return -1;

                 }

                 //FIXME following is a pure guess and probably wrong

@@ -912,35 +904,36 @@ static int bitplane_decoding(BitPlane *bp, VC9Context *v)

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

 static int vop_dquant_decoding(VC9Context *v)

 {

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

     int pqdiff;

     //variable size

     if (v->dquant == 2)

     {

-        pqdiff = get_bits(&v->gb, 3);

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

+        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(&v->gb, 1);

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

         if ( v->dquantfrm )

         {

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

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

             switch (v->dqprofile)

             {

             case DQPROFILE_SINGLE_EDGE:

             case DQPROFILE_DOUBLE_EDGES:

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

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

                 break;

             case DQPROFILE_ALL_MBS:

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

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

             default: break; //Forbidden ?

             }

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

             {

-                pqdiff = get_bits(&v->gb, 3);

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

+                pqdiff = get_bits(gb, 3);

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

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

             }

         }

@@ -961,38 +954,40 @@ static int decode_bi_picture_header(VC9Context *v)

        - for A Profile, PTYPE already tells so and we can go

          directly there

     */

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

     int pqindex;

     /* Read the quantization stuff */

-    pqindex = get_bits(&v->gb, 5);

+    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(&v->gb, 1);

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

     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

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

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

     /* Read the MV type/mode */

     if (v->extended_mv == 1)

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

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

     /* FIXME: what table are used in that case ? */

     v->mv_diff_vlc = &vc9_mv_diff_vlc[0];

-    v->cbpcy_vlc = &vc9_cbpcy_i_vlc;

+    v->cbpcy_vlc = &ff_msmp4_mb_i_vlc;

-    av_log(v->avctx, AV_LOG_DEBUG, "B frame, QP=%i\n", v->pq);

-    av_log(v->avctx, AV_LOG_ERROR, "BI_TYPE not supported yet\n");

+    av_log(v->s.avctx, AV_LOG_DEBUG, "B frame, QP=%i\n", v->pq);

+    av_log(v->s.avctx, AV_LOG_ERROR, "BI_TYPE not supported yet\n");

     /* Epilog should be done in caller */

     return -1;

 }

 /* Tables 11+12, p62-65 */

-static int decode_b_picture_header(VC9Context *v)

+static int decode_b_picture_primary_header(VC9Context *v)

 {

-  int pqindex, status;

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

+    int pqindex, status;

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

     if (v->profile == PROFILE_SIMPLE)

@@ -1001,7 +996,7 @@ static int decode_b_picture_header(VC9Context *v)

         return FRAME_SKIPED;

     }

-    v->bfraction = vc9_bfraction_lut[get_vlc2(&v->gb, vc9_bfraction_vlc.table,

+    v->bfraction = vc9_bfraction_lut[get_vlc2(gb, vc9_bfraction_vlc.table,

                                               VC9_BFRACTION_VLC_BITS, 2)];

     if (v->bfraction < -1)

     {

@@ -1015,26 +1010,26 @@ static int decode_b_picture_header(VC9Context *v)

     }

     /* Read the quantization stuff */

-    pqindex = get_bits(&v->gb, 5);

+    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(&v->gb, 1);

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

     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

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

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

     /* Read the MV type/mode */

     if (v->extended_mv == 1)

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

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

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

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

     if (v->pq < 13)

     {

         if (!v->mv_mode)

         {

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

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

             if (v->mv_mode)

                 av_log(v, AV_LOG_ERROR,

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

@@ -1044,20 +1039,31 @@ static int decode_b_picture_header(VC9Context *v)

     {

         if (!v->mv_mode)

         {

-            if (get_bits(&v->gb, 1))

+            if (get_bits(gb, 1))

                 av_log(v, 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;

+}

+

+static int decode_b_picture_secondary_header(VC9Context *v)

+{

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

+    int 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->avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "

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

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

 #endif

     }

@@ -1066,20 +1072,17 @@ static int decode_b_picture_header(VC9Context *v)

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

     if (status < 0) return -1;

 #if TRACE

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

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

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

 #endif

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

-    if (status < 0) return -1;

-#if TRACE

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

+    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->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];

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

+    v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(gb, 2)];

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

     if (v->dquant)

     {

         vop_dquant_decoding(v);

@@ -1087,10 +1090,10 @@ static int decode_b_picture_header(VC9Context *v)

     if (v->vstransform)

     {

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

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

         if (v->ttmbf)

         {

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

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

             av_log(v, AV_LOG_INFO, "Transform used: %ix%i\n",

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

         }

@@ -1102,53 +1105,54 @@ static int decode_b_picture_header(VC9Context *v)

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

 static int decode_i_picture_header(VC9Context *v)

 {

-  int pqindex, status = 0, ac_pred;

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

+    int pqindex, status = 0;

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

     //BF = Buffer Fullness

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

+    if (v->profile <= PROFILE_MAIN && get_bits(gb, 7))

     {

         av_log(v, AV_LOG_DEBUG, "I BufferFullness not 0\n");

     }

     /* Quantizer stuff */

-    pqindex = get_bits(&v->gb, 5);

+    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(&v->gb, 1);

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

     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

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

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

+        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);

 #if HAS_ADVANCED_PROFILE

     if (v->profile <= PROFILE_MAIN)

 #endif

     {

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

-        if (v->multires) v->respic = get_bits(&v->gb, 2);

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

+        if (v->multires) v->respic = get_bits(gb, 2);

     }

 #if HAS_ADVANCED_PROFILE

     else

     {

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

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

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

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

         /* 7.1.1.34 + 8.5.2 */

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

         {

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

+            v->condover = get_bits(gb, 1);

             if (v->condover)

             {

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

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

                 if (v->condover == 3)

                 {

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

                     if (status < 0) return -1;

 #if TRACE

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

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

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

 #endif

                 }

@@ -1162,41 +1166,48 @@ static int decode_i_picture_header(VC9Context *v)

 }

 /* Table 9, p58-60 */

-static int decode_p_picture_header(VC9Context *v)

+static int decode_p_picture_primary_header(VC9Context *v)

 {

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

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

     int lowquant, pqindex, status = 0;

-    pqindex = get_bits(&v->gb, 5);

+    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(&v->gb, 1);

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

     if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)

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

-    av_log(v->avctx, AV_LOG_DEBUG, "P Frame: QP=%i (+%i/2)\n",

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

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

            v->pq, v->halfpq);

-    if (v->extended_mv == 1) v->mvrange = get_prefix(&v->gb, 0, 3);

+    if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);

 #if HAS_ADVANCED_PROFILE

     if (v->profile > PROFILE_MAIN)

     {

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

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

     }

     else

 #endif

-        if (v->multires) v->respic = get_bits(&v->gb, 2);

+        if (v->multires) v->respic = get_bits(gb, 2);

     lowquant = (v->pquantizer>12) ? 0 : 1;

-    v->mv_mode = mv_pmode_table[lowquant][get_prefix(&v->gb, 1, 4)];

+    v->mv_mode = mv_pmode_table[lowquant][get_prefix(gb, 1, 4)];

     if (v->mv_mode == MV_PMODE_INTENSITY_COMP)

     {

-        v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(&v->gb, 1, 3)];

-        v->lumscale = get_bits(&v->gb, 6);

-        v->lumshift = get_bits(&v->gb, 6);

+        v->mv_mode2 = mv_pmode_table[lowquant][get_prefix(gb, 1, 3)];

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

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

     }

+    return 0;

+}

+static int decode_p_picture_secondary_header(VC9Context *v)

+{

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

+    int status = 0;

     if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&

          v->mv_mode2 == MV_PMODE_MIXED_MV)

         || v->mv_mode == MV_PMODE_MIXED_MV)

@@ -1204,7 +1215,7 @@ static int decode_p_picture_header(VC9Context *v)

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

         if (status < 0) return -1;

 #if TRACE

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

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

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

 #endif

     }

@@ -1212,27 +1223,27 @@ static int decode_p_picture_header(VC9Context *v)

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

     if (status < 0) return -1;

 #if TRACE

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

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

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

 #endif

     /* Hopefully this is correct for P frames */

-    v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(&v->gb, 2)];

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

+    v->mv_diff_vlc = &vc9_mv_diff_vlc[get_bits(gb, 2)];

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

     if (v->dquant)

     {

-        av_log(v->avctx, AV_LOG_INFO, "VOP DQuant info\n");

+        av_log(v->s.avctx, AV_LOG_INFO, "VOP DQuant info\n");

         vop_dquant_decoding(v);

     }

     if (v->vstransform)

     {

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

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

         if (v->ttmbf)

         {

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

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

+            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);

         }

     }

@@ -1241,27 +1252,28 @@ static int decode_p_picture_header(VC9Context *v)

 }

-static int standard_decode_picture_header(VC9Context *v)

+static int standard_decode_picture_primary_header(VC9Context *v)

 {

-    int status = 0, index;

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

+    int status = 0;

-    if (v->finterpflag) v->interpfrm = get_bits(&v->gb, 1);

-    skip_bits(&v->gb, 2); //framecnt unused

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

-    v->pict_type = get_bits(&v->gb, 1);

-    if (v->avctx->max_b_frames && !v->pict_type)

+    if (v->finterpflag) v->interpfrm = get_bits(gb, 1);

+    skip_bits(gb, 2); //framecnt unused

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

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

+    if (v->s.avctx->max_b_frames && !v->s.pict_type)

     {

-        if (get_bits(&v->gb, 1)) v->pict_type = I_TYPE;

-        else v->pict_type = P_TYPE;

+        if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;

+        else v->s.pict_type = P_TYPE;

     }

-    else v->pict_type++; //P_TYPE

+    else v->s.pict_type++; //P_TYPE

-    switch (v->pict_type)

+    switch (v->s.pict_type)

     {

     case I_TYPE: status = decode_i_picture_header(v); break;

-    case BI_TYPE: status = decode_b_picture_header(v); break;

-    case P_TYPE: status = decode_p_picture_header(v); break;

-    case B_TYPE: status = decode_b_picture_header(v); break;

+    case BI_TYPE: status = decode_bi_picture_header(v); break;

+    case P_TYPE: status = decode_p_picture_primary_header(v); break;

+    case B_TYPE: status = decode_b_picture_primary_header(v); break;

     }

     if (status == FRAME_SKIPED)

@@ -1269,21 +1281,34 @@ static int standard_decode_picture_header(VC9Context *v)

       av_log(v, AV_LOG_INFO, "Skipping frame...\n");

       return status;

     }

+    return 0;

+}

+

+static int standard_decode_picture_secondary_header(VC9Context *v)

+{

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

+    int status = 0, index;

+

+    switch (v->s.pict_type)

+    {

+    case P_TYPE: status = decode_p_picture_secondary_header(v); break;

+    case B_TYPE: status = decode_b_picture_secondary_header(v); break;

+    }

     /* AC Syntax */

-    index = decode012(&v->gb);

+    index = decode012(gb);

     v->luma_ac_vlc = NULL + index; //FIXME Add AC table

     v->chroma_ac_vlc = NULL +  index;

-    if (v->pict_type == I_TYPE || v->pict_type == BI_TYPE)

+    if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)

     {

-        index = decode012(&v->gb);

+        index = decode012(gb);

         v->luma_ac2_vlc = NULL + index; //FIXME Add AC2 table

         v->chroma_ac2_vlc = NULL + index;

     }

     /* DC Syntax */

-    index = decode012(&v->gb);

-    v->luma_dc_vlc = vc9_luma_dc_vlc + index;

-    v->chroma_dc_vlc = vc9_chroma_dc_vlc + index;

+    index = decode012(gb);

+    v->luma_dc_vlc = &ff_msmp4_dc_luma_vlc[index];

+    v->chroma_dc_vlc = &ff_msmp4_dc_chroma_vlc[index];

     return 0;

 }

@@ -1293,30 +1318,31 @@ static int standard_decode_picture_header(VC9Context *v)

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

 /* Advanced Profile picture header decoding specific functions                */

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

-static int advanced_decode_picture_header(VC9Context *v)

+static int advanced_decode_picture_primary_header(VC9Context *v)

 {

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

     static const int type_table[4] = { P_TYPE, B_TYPE, I_TYPE, BI_TYPE };

-    int type, i, index;

+    int type, i;

     if (v->interlace)

     {

-        v->fcm = get_bits(&v->gb, 1);

-        if (v->fcm) v->fcm = 2+get_bits(&v->gb, 1);

+        v->fcm = get_bits(gb, 1);

+        if (v->fcm) v->fcm = 2+get_bits(gb, 1);

     }

-    type = get_prefix(&v->gb, 0, 4);

+    type = get_prefix(gb, 0, 4);

     if (type > 4 || type < 0) return FRAME_SKIPED;

-    v->pict_type = type_table[type];

-    av_log(v->avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->pict_type);

+    v->s.pict_type = type_table[type];

+    av_log(v->s.avctx, AV_LOG_INFO, "AP Frame Type: %i\n", v->s.pict_type);

-    if (v->tfcntrflag) v->tfcntr = get_bits(&v->gb, 8);

+    if (v->tfcntrflag) v->tfcntr = get_bits(gb, 8);

     if (v->broadcast)

     {

-        if (!v->interlace) v->rptfrm = get_bits(&v->gb, 2);

+        if (!v->interlace) v->rptfrm = get_bits(gb, 2);

         else

         {

-            v->tff = get_bits(&v->gb, 1);

-            v->rff = get_bits(&v->gb, 1);

+            v->tff = get_bits(gb, 1);

+            v->rff = get_bits(gb, 1);

         }

     }

@@ -1325,42 +1351,56 @@ static int advanced_decode_picture_header(VC9Context *v)

 #if 0

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

         {

-            v->topleftx[i] = get_bits(&v->gb, 16);

-            v->toplefty[i] = get_bits(&v->gb, 16);

-            v->bottomrightx[i] = get_bits(&v->gb, 16);

-            v->bottomrighty[i] = get_bits(&v->gb, 16);

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

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

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

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

         }

 #else

-        skip_bits(&v->gb, 16*4*v->numpanscanwin);

+        skip_bits(gb, 16*4*v->numpanscanwin);

 #endif

     }

-    v->rndctrl = get_bits(&v->gb, 1);

-    v->uvsamp = get_bits(&v->gb, 1);

-    if (v->finterpflag == 1) v->interpfrm = get_bits(&v->gb, 1);

+    v->s.no_rounding = !get_bits(gb, 1);

+    v->uvsamp = get_bits(gb, 1);

+    if (v->finterpflag == 1) v->interpfrm = get_bits(gb, 1);

-    switch(v->pict_type)

+    switch(v->s.pict_type)

     {

     case I_TYPE: if (decode_i_picture_header(v) < 0) return -1;

-    case P_TYPE: if (decode_p_picture_header(v) < 0) return -1;