@@ -62,6 +62,7 @@ easier to use. The changes are:

 - CELT in Ogg demuxing

 - G.723.1 demuxer and decoder

 - libmodplug support (--enable-libmodplug)

+- VC-1 interlaced decoding

 version 0.8:

@@ -3163,6 +3163,7 @@ check_cflags -Wtype-limits

 check_cflags -Wundef

 check_cflags -Wmissing-prototypes

 check_cflags -Wno-pointer-to-int-cast

+check_cflags -Wstrict-prototypes

 enabled extra_warnings && check_cflags -Winline

 # add some linker flags

@@ -60,7 +60,6 @@ static int ptx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,

     avctx->pix_fmt = PIX_FMT_RGB555;

-

     if (buf_end - buf < offset)

         return AVERROR_INVALIDDATA;

     if (offset != 0x2c)

@@ -1544,22 +1544,22 @@ void ff_copy_and_dup(int16_t *target, const int16_t *source, int offset)

 int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)

 {

     int b, i, j;

-    int buffer1[10];

-    int buffer2[10];

+    int buffer1[LPC_ORDER];

+    int buffer2[LPC_ORDER];

     int *bp1 = buffer1;

     int *bp2 = buffer2;

-    for (i=0; i < 10; i++)

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

         buffer2[i] = coefs[i];

-    refl[9] = bp2[9];

+    refl[LPC_ORDER-1] = bp2[LPC_ORDER-1];

-    if ((unsigned) bp2[9] + 0x1000 > 0x1fff) {

+    if ((unsigned) bp2[LPC_ORDER-1] + 0x1000 > 0x1fff) {

         av_log(avctx, AV_LOG_ERROR, "Overflow. Broken sample?\n");

         return 1;

     }

-    for (i=8; i >= 0; i--) {

+    for (i = LPC_ORDER-2; i >= 0; i--) {

         b = 0x1000-((bp2[i+1] * bp2[i+1]) >> 12);

         if (!b)

@@ -1584,12 +1584,12 @@ int ff_eval_refl(int *refl, const int16_t *coefs, AVCodecContext *avctx)

  */

 void ff_eval_coefs(int *coefs, const int *refl)

 {

-    int buffer[10];

+    int buffer[LPC_ORDER];

     int *b1 = buffer;

     int *b2 = coefs;

     int i, j;

-    for (i=0; i < 10; i++) {

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

         b1[i] = refl[i] << 4;

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

@@ -1598,7 +1598,7 @@ void ff_eval_coefs(int *coefs, const int *refl)

         FFSWAP(int *, b1, b2);

     }

-    for (i=0; i < 10; i++)

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

         coefs[i] >>= 4;

 }

@@ -1606,7 +1606,7 @@ void ff_int_to_int16(int16_t *out, const int *inp)

 {

     int i;

-    for (i=0; i < 10; i++)

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

         *out++ = *inp++;

 }

@@ -1629,9 +1629,9 @@ unsigned int ff_rms(const int *data)

 {

     int i;

     unsigned int res = 0x10000;

-    int b = 10;

+    int b = LPC_ORDER;

-    for (i=0; i < 10; i++) {

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

         res = (((0x1000000 - data[i]*data[i]) >> 12) * res) >> 12;

         if (res == 0)

@@ -1648,13 +1648,13 @@ unsigned int ff_rms(const int *data)

 int ff_interp(RA144Context *ractx, int16_t *out, int a, int copyold, int energy)

 {

-    int work[10];

+    int work[LPC_ORDER];

     int b = NBLOCKS - a;

     int i;

     // Interpolate block coefficients from the this frame's forth block and

     // last frame's forth block.

-    for (i=0; i<10; i++)

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

         out[i] = (a * ractx->lpc_coef[0][i] + b * ractx->lpc_coef[1][i])>> 2;

     if (ff_eval_refl(work, out, ractx->avctx)) {

@@ -1690,7 +1690,7 @@ void ff_subblock_synthesis(RA144Context *ractx, const uint16_t *lpc_coefs,

                            int cba_idx, int cb1_idx, int cb2_idx,

                            int gval, int gain)

 {

-    uint16_t buffer_a[40];

+    uint16_t buffer_a[BLOCKSIZE];

     uint16_t *block;

     int m[3];

@@ -1711,10 +1711,10 @@ void ff_subblock_synthesis(RA144Context *ractx, const uint16_t *lpc_coefs,

     ff_add_wav(block, gain, cba_idx, m, cba_idx? buffer_a: NULL,

                ff_cb1_vects[cb1_idx], ff_cb2_vects[cb2_idx]);

-    memcpy(ractx->curr_sblock, ractx->curr_sblock + 40,

-           10*sizeof(*ractx->curr_sblock));

+    memcpy(ractx->curr_sblock, ractx->curr_sblock + BLOCKSIZE,

+           LPC_ORDER*sizeof(*ractx->curr_sblock));

-    if (ff_celp_lp_synthesis_filter(ractx->curr_sblock + 10, lpc_coefs,

-                                    block, BLOCKSIZE, 10, 1, 0, 0xfff))

-        memset(ractx->curr_sblock, 0, 50*sizeof(*ractx->curr_sblock));

+    if (ff_celp_lp_synthesis_filter(ractx->curr_sblock + LPC_ORDER, lpc_coefs,

+                                    block, BLOCKSIZE, LPC_ORDER, 1, 0, 0xfff))

+        memset(ractx->curr_sblock, 0, (LPC_ORDER+BLOCKSIZE)*sizeof(*ractx->curr_sblock));

 }

@@ -59,29 +59,33 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,

 {

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

-    static const uint8_t sizes[10] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};

-    unsigned int refl_rms[4];    // RMS of the reflection coefficients

-    uint16_t block_coefs[4][10]; // LPC coefficients of each sub-block

-    unsigned int lpc_refl[10];   // LPC reflection coefficients of the frame

+    static const uint8_t sizes[LPC_ORDER] = {6, 5, 5, 4, 4, 3, 3, 3, 3, 2};

+    unsigned int refl_rms[NBLOCKS];           // RMS of the reflection coefficients

+    uint16_t block_coefs[NBLOCKS][LPC_ORDER]; // LPC coefficients of each sub-block

+    unsigned int lpc_refl[LPC_ORDER];         // LPC reflection coefficients of the frame

     int i, j;

+    int out_size;

     int16_t *data = vdata;

     unsigned int energy;

     RA144Context *ractx = avctx->priv_data;

     GetBitContext gb;

-    if (*data_size < 2*160)

-        return -1;

+    out_size = NBLOCKS * BLOCKSIZE * av_get_bytes_per_sample(avctx->sample_fmt);

+    if (*data_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");

+        return AVERROR(EINVAL);

+    }

-    if(buf_size < 20) {

+    if(buf_size < FRAMESIZE) {

         av_log(avctx, AV_LOG_ERROR,

                "Frame too small (%d bytes). Truncated file?\n", buf_size);

         *data_size = 0;

         return buf_size;

     }

-    init_get_bits(&gb, buf, 20 * 8);

+    init_get_bits(&gb, buf, FRAMESIZE * 8);

-    for (i=0; i<10; i++)

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

         lpc_refl[i] = ff_lpc_refl_cb[i][get_bits(&gb, sizes[i])];

     ff_eval_coefs(ractx->lpc_coef[0], lpc_refl);

@@ -98,7 +102,7 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,

     ff_int_to_int16(block_coefs[3], ractx->lpc_coef[0]);

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

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

         do_output_subblock(ractx, block_coefs[i], refl_rms[i], &gb);

         for (j=0; j < BLOCKSIZE; j++)

@@ -110,8 +114,8 @@ static int ra144_decode_frame(AVCodecContext * avctx, void *vdata,

     FFSWAP(unsigned int *, ractx->lpc_coef[0], ractx->lpc_coef[1]);

-    *data_size = 2*160;

-    return 20;

+    *data_size = out_size;

+    return FRAMESIZE;

 }

 AVCodec ff_ra_144_decoder = {

@@ -31,6 +31,9 @@

 #define MAX_BACKWARD_FILTER_LEN    40

 #define MAX_BACKWARD_FILTER_NONREC 35

+#define RA288_BLOCK_SIZE        5

+#define RA288_BLOCKS_PER_FRAME 32

+

 typedef struct {

     float sp_lpc[36];      ///< LPC coefficients for speech data (spec: A)

     float gain_lpc[10];    ///< LPC coefficients for gain        (spec: GB)

@@ -165,7 +168,7 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,

     const uint8_t *buf = avpkt->data;

     int buf_size = avpkt->size;

     float *out = data;

-    int i, j;

+    int i, j, out_size;

     RA288Context *ractx = avctx->priv_data;

     GetBitContext gb;

@@ -176,18 +179,22 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,

         return 0;

     }

-    if (*data_size < 32*5*4)

-        return -1;

+    out_size = RA288_BLOCK_SIZE * RA288_BLOCKS_PER_FRAME *

+               av_get_bytes_per_sample(avctx->sample_fmt);

+    if (*data_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "Output buffer is too small\n");

+        return AVERROR(EINVAL);

+    }

     init_get_bits(&gb, buf, avctx->block_align * 8);

-    for (i=0; i < 32; i++) {

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

         float gain = amptable[get_bits(&gb, 3)];

         int cb_coef = get_bits(&gb, 6 + (i&1));

         decode(ractx, gain, cb_coef);

-        for (j=0; j < 5; j++)

+        for (j=0; j < RA288_BLOCK_SIZE; j++)

             *(out++) = ractx->sp_hist[70 + 36 + j];

         if ((i & 7) == 3) {

@@ -199,7 +206,7 @@ static int ra288_decode_frame(AVCodecContext * avctx, void *data,

         }

     }

-    *data_size = (char *)out - (char *)data;

+    *data_size = out_size;

     return avctx->block_align;

 }

@@ -1,5 +1,6 @@

 /*

  * VC-1 and WMV3 decoder common code

+ * Copyright (c) 2011 Mashiat Sarker Shakkhar

  * Copyright (c) 2006-2007 Konstantin Shishkov

  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer

  *

@@ -25,6 +26,7 @@

  * VC-1 and WMV3 decoder common code

  *

  */

+

 #include "internal.h"

 #include "dsputil.h"

 #include "avcodec.h"

@@ -66,14 +68,16 @@ enum Imode {

  * @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){

+static void decode_rowskip(uint8_t* plane, int width, int height, int stride,

+                           GetBitContext *gb)

+{

     int x, y;

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

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

         if (!get_bits1(gb)) //rowskip

             memset(plane, 0, width);

         else

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

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

                 plane[x] = get_bits1(gb);

         plane += stride;

     }

@@ -86,15 +90,17 @@ static void decode_rowskip(uint8_t* plane, int width, int height, int stride, Ge

  * @param[in] stride of this buffer

  * @todo FIXME: Optimize

  */

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

+static void decode_colskip(uint8_t* plane, int width, int height, int stride,

+                           GetBitContext *gb)

+{

     int x, y;

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

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

         if (!get_bits1(gb)) //colskip

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

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

                 plane[y*stride] = 0;

         else

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

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

                 plane[y*stride] = get_bits1(gb);

         plane ++;

     }

@@ -115,76 +121,76 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)

     uint8_t invert, *planep = data;

     int width, height, stride;

-    width = v->s.mb_width;

-    height = v->s.mb_height;

+    width  = v->s.mb_width;

+    height = v->s.mb_height >> v->field_mode;

     stride = v->s.mb_stride;

     invert = get_bits1(gb);

     imode = get_vlc2(gb, ff_vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);

     *raw_flag = 0;

-    switch (imode)

-    {

+    switch (imode) {

     case IMODE_RAW:

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

         *raw_flag = 1; //invert ignored

         return invert;

     case IMODE_DIFF2:

     case IMODE_NORM2:

-        if ((height * width) & 1)

-        {

+        if ((height * width) & 1) {

             *planep++ = get_bits1(gb);

-            offset = 1;

+            offset    = 1;

         }

-        else offset = 0;

+        else

+            offset = 0;

         // decode bitplane as one long line

         for (y = offset; y < height * width; y += 2) {

             code = get_vlc2(gb, ff_vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);

             *planep++ = code & 1;

             offset++;

-            if(offset == width) {

-                offset = 0;

+            if (offset == width) {

+                offset  = 0;

                 planep += stride - width;

             }

             *planep++ = code >> 1;

             offset++;

-            if(offset == width) {

-                offset = 0;

+            if (offset == width) {

+                offset  = 0;

                 planep += stride - width;

             }

         }

         break;

     case IMODE_DIFF6:

     case IMODE_NORM6:

-        if(!(height % 3) && (width % 3)) { // use 2x3 decoding

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

-                for(x = width & 1; x < width; x += 2) {

+        if (!(height % 3) && (width % 3)) { // use 2x3 decoding

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

+                for (x = width & 1; x < width; x += 2) {

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

-                    if(code < 0){

+                    if (code < 0) {

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

                         return -1;

                     }

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

-                    planep[x + 1] = (code >> 1) & 1;

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

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

+                    planep[x + 0]              = (code >> 0) & 1;

+                    planep[x + 1]              = (code >> 1) & 1;

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

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

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

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

                 }

                 planep += stride * 3;

             }

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

+            if (width & 1)

+                decode_colskip(data, 1, height, stride, &v->s.gb);

         } else { // 3x2

             planep += (height & 1) * stride;

-            for(y = height & 1; y < height; y += 2) {

-                for(x = width % 3; x < width; x += 3) {

+            for (y = height & 1; y < height; y += 2) {

+                for (x = width % 3; x < width; x += 3) {

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

-                    if(code < 0){

+                    if (code < 0) {

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

                         return -1;

                     }

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

-                    planep[x + 1] = (code >> 1) & 1;

-                    planep[x + 2] = (code >> 2) & 1;

+                    planep[x + 0]          = (code >> 0) & 1;

+                    planep[x + 1]          = (code >> 1) & 1;

+                    planep[x + 2]          = (code >> 2) & 1;

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

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

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

@@ -192,8 +198,10 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)

                 planep += stride * 2;

             }

             x = width % 3;

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

-            if(height & 1) decode_rowskip(data+x, width - x, 1, stride, &v->s.gb);

+            if (x)

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

+            if (height & 1)

+                decode_rowskip(data + x, width - x,      1, stride, &v->s.gb);

         }

         break;

     case IMODE_ROWSKIP:

@@ -202,33 +210,30 @@ static int bitplane_decoding(uint8_t* data, int *raw_flag, VC1Context *v)

     case IMODE_COLSKIP:

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

         break;

-    default: break;

+    default:

+        break;

     }

     /* Applying diff operator */

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

-    {

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

         planep = data;

         planep[0] ^= invert;

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

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

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

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

-        {

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

             planep += stride;

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

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

-            {

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

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

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

             }

         }

-    }

-    else if (invert)

-    {

+    } else if (invert) {

         planep = data;

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

+        for (x = 0; x < stride * height; x++)

+            planep[x] = !planep[x]; //FIXME stride

     }

-    return (imode<<1) + invert;

+    return (imode << 1) + invert;

 }

 /** @} */ //Bitplane group

@@ -243,35 +248,34 @@ static int vop_dquant_decoding(VC1Context *v)

     int pqdiff;

     //variable size

-    if (v->dquant == 2)

-    {

+    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

-    {

+        if (pqdiff == 7)

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

+        else

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

+    } else {

         v->dquantfrm = get_bits1(gb);

-        if ( v->dquantfrm )

-        {

+        if (v->dquantfrm) {

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

-            switch (v->dqprofile)

-            {

+            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_bits1(gb);

-                if(!v->dqbilevel)

+                if (!v->dqbilevel)

                     v->halfpq = 0;

-            default: break; //Forbidden ?

+            default:

+                break; //Forbidden ?

             }

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

-            {

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

+                if (pqdiff == 7)

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

+                else

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

             }

         }

     }

@@ -291,25 +295,20 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte

 {

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

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

-    if (v->profile == PROFILE_COMPLEX)

-    {

+    if (v->profile == PROFILE_COMPLEX) {

         av_log(avctx, AV_LOG_WARNING, "WMV3 Complex Profile is not fully supported\n");

     }

-    if (v->profile == PROFILE_ADVANCED)

-    {

+    if (v->profile == PROFILE_ADVANCED) {

         v->zz_8x4 = ff_vc1_adv_progressive_8x4_zz;

         v->zz_4x8 = ff_vc1_adv_progressive_4x8_zz;

         return decode_sequence_header_adv(v, gb);

-    }

-    else

-    {

+    } else {

         v->zz_8x4 = wmv2_scantableA;

         v->zz_4x8 = wmv2_scantableB;

         v->res_y411   = get_bits1(gb);

         v->res_sprite = get_bits1(gb);

-        if (v->res_y411)

-        {

+        if (v->res_y411) {

             av_log(avctx, AV_LOG_ERROR,

                    "Old interlaced mode is not supported\n");

             return -1;

@@ -320,48 +319,45 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte

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

     // (bitrate-32kbps)/64kbps

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

-    v->s.loop_filter = get_bits1(gb); //common

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

-    {

+    v->s.loop_filter   = get_bits1(gb); //common

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

         av_log(avctx, AV_LOG_ERROR,

                "LOOPFILTER shall not be enabled in Simple Profile\n");

     }

-    if(v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)

+    if (v->s.avctx->skip_loop_filter >= AVDISCARD_ALL)

         v->s.loop_filter = 0;

-    v->res_x8 = get_bits1(gb); //reserved

-    v->multires = get_bits1(gb);

-    v->res_fasttx = get_bits1(gb);

-    if (!v->res_fasttx)

-    {

-        v->vc1dsp.vc1_inv_trans_8x8 = ff_simple_idct_8;

-        v->vc1dsp.vc1_inv_trans_8x4 = ff_simple_idct84_add;

-        v->vc1dsp.vc1_inv_trans_4x8 = ff_simple_idct48_add;

-        v->vc1dsp.vc1_inv_trans_4x4 = ff_simple_idct44_add;

+    v->res_x8          = get_bits1(gb); //reserved

+    v->multires        = get_bits1(gb);

+    v->res_fasttx      = get_bits1(gb);

+    if (!v->res_fasttx) {

+        v->vc1dsp.vc1_inv_trans_8x8    = ff_simple_idct_8;

+        v->vc1dsp.vc1_inv_trans_8x4    = ff_simple_idct84_add;

+        v->vc1dsp.vc1_inv_trans_4x8    = ff_simple_idct48_add;

+        v->vc1dsp.vc1_inv_trans_4x4    = ff_simple_idct44_add;

         v->vc1dsp.vc1_inv_trans_8x8_dc = ff_simple_idct_add_8;

         v->vc1dsp.vc1_inv_trans_8x4_dc = ff_simple_idct84_add;

         v->vc1dsp.vc1_inv_trans_4x8_dc = ff_simple_idct48_add;

         v->vc1dsp.vc1_inv_trans_4x4_dc = ff_simple_idct44_add;

     }

-    v->fastuvmc =  get_bits1(gb); //common

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

-    {

+    v->fastuvmc        = get_bits1(gb); //common

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

         av_log(avctx, AV_LOG_ERROR,

                "FASTUVMC unavailable in Simple Profile\n");

         return -1;

     }

-    v->extended_mv =  get_bits1(gb); //common

+    v->extended_mv     = get_bits1(gb); //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_bits1(gb); //common

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

+    v->vstransform     = get_bits1(gb); //common

-    v->res_transtab = get_bits1(gb);

+    v->res_transtab    = get_bits1(gb);

     if (v->res_transtab)

     {

         av_log(avctx, AV_LOG_ERROR,

@@ -369,12 +365,11 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte

         return -1;

     }

-    v->overlap = get_bits1(gb); //common

+    v->overlap         = get_bits1(gb); //common

     v->s.resync_marker = get_bits1(gb);

-    v->rangered = get_bits1(gb);

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

-    {

+    v->rangered        = get_bits1(gb);

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

         av_log(avctx, AV_LOG_INFO,

                "RANGERED should be set to 0 in Simple Profile\n");

     }

@@ -399,8 +394,7 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte

     } else {

         v->res_rtm_flag = get_bits1(gb); //reserved

     }

-    if (!v->res_rtm_flag)

-    {

+    if (!v->res_rtm_flag) {

 //            av_log(avctx, AV_LOG_ERROR,

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

         av_log(avctx, AV_LOG_ERROR,

@@ -408,17 +402,17 @@ int vc1_decode_sequence_header(AVCodecContext *avctx, VC1Context *v, GetBitConte

         //return -1;

     }

     //TODO: figure out what they mean (always 0x402F)

-    if(!v->res_fasttx) skip_bits(gb, 16);

+    if (!v->res_fasttx)

+        skip_bits(gb, 16);

     av_log(avctx, AV_LOG_DEBUG,

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

-               "LoopFilter=%i, MultiRes=%i, FastUVMC=%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

-               );

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

+           "LoopFilter=%i, MultiRes=%i, FastUVMC=%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;

 }

@@ -427,59 +421,56 @@ static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)

     int w, h;

     v->res_rtm_flag = 1;

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

-    if(v->level >= 5)

-    {

+    if (v->level >= 5) {

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

     }

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

-    if (v->chromaformat != 1)

-    {

+    if (v->chromaformat != 1) {

         av_log(v->s.avctx, AV_LOG_ERROR,

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

         return -1;

     }

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

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

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

     // (bitrate-32kbps)/64kbps

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

-    v->postprocflag = get_bits1(gb); //common

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

+    v->postprocflag          = get_bits1(gb);   //common

     w = (get_bits(gb, 12) + 1) << 1;

     h = (get_bits(gb, 12) + 1) << 1;

     avcodec_set_dimensions(v->s.avctx, w, h);

-    v->broadcast = get_bits1(gb);

-    v->interlace = get_bits1(gb);

-    v->tfcntrflag = get_bits1(gb);

-    v->finterpflag = get_bits1(gb);

+    v->broadcast             = get_bits1(gb);

+    v->interlace             = get_bits1(gb);

+    v->tfcntrflag            = get_bits1(gb);

+    v->finterpflag           = get_bits1(gb);

     skip_bits1(gb); // reserved

     av_log(v->s.avctx, AV_LOG_DEBUG,

-               "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

-               "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"

-               "TFCTRflag=%i, FINTERPflag=%i\n",

-               v->level, v->frmrtq_postproc, v->bitrtq_postproc,

-               v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,

-               v->tfcntrflag, v->finterpflag

-               );

+           "Advanced Profile level %i:\nfrmrtq_postproc=%i, bitrtq_postproc=%i\n"

+           "LoopFilter=%i, ChromaFormat=%i, Pulldown=%i, Interlace: %i\n"

+           "TFCTRflag=%i, FINTERPflag=%i\n",

+           v->level, v->frmrtq_postproc, v->bitrtq_postproc,

+           v->s.loop_filter, v->chromaformat, v->broadcast, v->interlace,

+           v->tfcntrflag, v->finterpflag);

     v->psf = get_bits1(gb);

-    if(v->psf) { //PsF, 6.1.13

+    if (v->psf) { //PsF, 6.1.13

         av_log(v->s.avctx, AV_LOG_ERROR, "Progressive Segmented Frame mode: not supported (yet)\n");

         return -1;

     }

     v->s.max_b_frames = v->s.avctx->max_b_frames = 7;

-    if(get_bits1(gb)) { //Display Info - decoding is not affected by it

+    if (get_bits1(gb)) { //Display Info - decoding is not affected by it

         int w, h, ar = 0;

         av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");

         w = get_bits(gb, 14) + 1;

         h = get_bits(gb, 14) + 1;

         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);

-        if(get_bits1(gb))

+        if (get_bits1(gb))

             ar = get_bits(gb, 4);

-        if(ar && ar < 14){

+        if (ar && ar < 14) {

             v->s.avctx->sample_aspect_ratio = ff_vc1_pixel_aspect[ar];

-        }else if(ar == 15){

+        } else if (ar == 15) {

             w = get_bits(gb, 8) + 1;

             h = get_bits(gb, 8) + 1;

             v->s.avctx->sample_aspect_ratio = (AVRational){w, h};

@@ -488,43 +479,45 @@ static int decode_sequence_header_adv(VC1Context *v, GetBitContext *gb)

                       &v->s.avctx->sample_aspect_ratio.den,

                       v->s.avctx->height * w,

                       v->s.avctx->width * h,

-                      1<<30);

+                      1 << 30);

         }

-        av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n", v->s.avctx->sample_aspect_ratio.num, v->s.avctx->sample_aspect_ratio.den);

+        av_log(v->s.avctx, AV_LOG_DEBUG, "Aspect: %i:%i\n",

+               v->s.avctx->sample_aspect_ratio.num,

+               v->s.avctx->sample_aspect_ratio.den);

-        if(get_bits1(gb)){ //framerate stuff

-            if(get_bits1(gb)) {

+        if (get_bits1(gb)) { //framerate stuff

+            if (get_bits1(gb)) {

                 v->s.avctx->time_base.num = 32;

                 v->s.avctx->time_base.den = get_bits(gb, 16) + 1;

             } else {

                 int nr, dr;

                 nr = get_bits(gb, 8);

                 dr = get_bits(gb, 4);

-                if(nr && nr < 8 && dr && dr < 3){

+                if (nr && nr < 8 && dr && dr < 3) {

                     v->s.avctx->time_base.num = ff_vc1_fps_dr[dr - 1];

                     v->s.avctx->time_base.den = ff_vc1_fps_nr[nr - 1] * 1000;

                 }

             }

-            if(v->broadcast) { // Pulldown may be present

-                v->s.avctx->time_base.den *= 2;

+            if (v->broadcast) { // Pulldown may be present

+                v->s.avctx->time_base.den  *= 2;

                 v->s.avctx->ticks_per_frame = 2;

             }

         }

-        if(get_bits1(gb)){

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

+        if (get_bits1(gb)) {

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

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

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

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

         }

     }

     v->hrd_param_flag = get_bits1(gb);

-    if(v->hrd_param_flag) {

+    if (v->hrd_param_flag) {

         int i;

         v->hrd_num_leaky_buckets = get_bits(gb, 5);

         skip_bits(gb, 4); //bitrate exponent

         skip_bits(gb, 4); //buffer size exponent

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

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

             skip_bits(gb, 16); //hrd_rate[n]

             skip_bits(gb, 16); //hrd_buffer[n]

         }

@@ -537,20 +530,20 @@ int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *

     int i;

     av_log(avctx, AV_LOG_DEBUG, "Entry point: %08X\n", show_bits_long(gb, 32));

-    v->broken_link = get_bits1(gb);

-    v->closed_entry = get_bits1(gb);

-    v->panscanflag = get_bits1(gb);

-    v->refdist_flag = get_bits1(gb);

-    v->s.loop_filter = get_bits1(gb);

-    v->fastuvmc = get_bits1(gb);

-    v->extended_mv = get_bits1(gb);

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

-    v->vstransform = get_bits1(gb);

-    v->overlap = get_bits1(gb);

+    v->broken_link    = get_bits1(gb);

+    v->closed_entry   = get_bits1(gb);

+    v->panscanflag    = get_bits1(gb);

+    v->refdist_flag   = get_bits1(gb);

+    v->s.loop_filter  = get_bits1(gb);

+    v->fastuvmc       = get_bits1(gb);

+    v->extended_mv    = get_bits1(gb);

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

+    v->vstransform    = get_bits1(gb);

+    v->overlap        = get_bits1(gb);

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

-    if(v->hrd_param_flag){

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

+    if (v->hrd_param_flag) {

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

             skip_bits(gb, 8); //hrd_full[n]

         }

     }

@@ -560,23 +553,23 @@ int vc1_decode_entry_point(AVCodecContext *avctx, VC1Context *v, GetBitContext *

         int h = (get_bits(gb, 12)+1)<<1;

         avcodec_set_dimensions(avctx, w, h);

     }

-    if(v->extended_mv)

+    if (v->extended_mv)

         v->extended_dmv = get_bits1(gb);

-    if((v->range_mapy_flag = get_bits1(gb))) {

+    if ((v->range_mapy_flag = get_bits1(gb))) {

         av_log(avctx, AV_LOG_ERROR, "Luma scaling is not supported, expect wrong picture\n");

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

     }

-    if((v->range_mapuv_flag = get_bits1(gb))) {

+    if ((v->range_mapuv_flag = get_bits1(gb))) {

         av_log(avctx, AV_LOG_ERROR, "Chroma scaling is not supported, expect wrong picture\n");

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

     }

     av_log(avctx, AV_LOG_DEBUG, "Entry point info:\n"

-        "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"

-        "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"

-        "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",

-        v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,

-        v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);

+           "BrokenLink=%i, ClosedEntry=%i, PanscanFlag=%i\n"

+           "RefDist=%i, Postproc=%i, FastUVMC=%i, ExtMV=%i\n"

+           "DQuant=%i, VSTransform=%i, Overlap=%i, Qmode=%i\n",

+           v->broken_link, v->closed_entry, v->panscanflag, v->refdist_flag, v->s.loop_filter,

+           v->fastuvmc, v->extended_mv, v->dquant, v->vstransform, v->overlap, v->quantizer_mode);