/libavcodec/vc1.c - Diff - PeerStreamer - Redmine

Revision be3492ec libavcodec/vc1.c

     /*
      * VC-1 and WMV3 decoder
      * Copyright (c) 2005 Anonymous
      * Copyright (c) 2005 Alex Beregszaszi
      * Copyright (c) 2005 Michael Niedermayer
      * Copyright (c) 2006 Konstantin Shishkov
      * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
+     *
      * This library is free software; you can redistribute it and/or
      * modify it under the terms of the GNU Lesser General Public
-...
      * @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"
     #include "vc1acdata.h"
     #undef NDEBUG
     #include <assert.h>
-...
     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;
     extern const uint16_t ff_msmp4_mb_i_table[64][2];
     #define DC_VLC_BITS 9
     #define AC_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
     enum Profile {
         PROFILE_SIMPLE,
         PROFILE_MAIN,
         PROFILE_COMPLEX, ///< TODO: WMV9 specific
         PROFILE_ADVANCED
     };
     //@}
     /** 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
     enum QuantMode {
         QUANT_FRAME_IMPLICIT,    ///< Implicitly specified at frame level
         QUANT_FRAME_EXPLICIT,    ///< Explicitly specified at frame level
         QUANT_NON_UNIFORM,       ///< Non-uniform quant used for all frames
         QUANT_UNIFORM            ///< 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
     enum DQProfile {
         DQPROFILE_FOUR_EDGES,
         DQPROFILE_DOUBLE_EDGES,
         DQPROFILE_SINGLE_EDGE,
         DQPROFILE_ALL_MBS
     };
     //@}
     /** @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
     enum DQSingleEdge {
         DQSINGLE_BEDGE_LEFT,
         DQSINGLE_BEDGE_TOP,
         DQSINGLE_BEDGE_RIGHT,
         DQSINGLE_BEDGE_BOTTOM
     };
     //@}
     /** 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
     enum DQDoubleEdge {
         DQDOUBLE_BEDGE_TOPLEFT,
         DQDOUBLE_BEDGE_TOPRIGHT,
         DQDOUBLE_BEDGE_BOTTOMRIGHT,
         DQDOUBLE_BEDGE_BOTTOMLEFT
     };
     //@}
     /** 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
     enum MVModes {
         MV_PMODE_1MV_HPEL_BILIN,
         MV_PMODE_1MV,
         MV_PMODE_1MV_HPEL,
         MV_PMODE_MIXED_MV,
         MV_PMODE_INTENSITY_COMP
     };
     //@}
     /** @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
     enum BMVTypes {
         BMV_TYPE_BACKWARD,
         BMV_TYPE_FORWARD,
         BMV_TYPE_INTERPOLATED = 3 //XXX: ??
     };
     //@}
     /** @name Block types for P/B frames */
     //@{
     enum TransformTypes {
         TT_8X8,
         TT_8X4_BOTTOM,
         TT_8X4_TOP,
         TT_8X4, //Both halves
         TT_4X8_RIGHT,
         TT_4X8_LEFT,
         TT_4X8, //Both halves
         TT_4X4
     };
     //@}
     /** Table for conversion between TTBLK and TTMB */
     static const int ttblk_to_tt[3][8] = {
       { TT_8X4, TT_4X8, TT_8X8, TT_4X4, TT_8X4_TOP, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT },
       { TT_8X8, TT_4X8_RIGHT, TT_4X8_LEFT, TT_4X4, TT_8X4, TT_4X8, TT_8X4_BOTTOM, TT_8X4_TOP },
       { TT_8X8, TT_4X8, TT_4X4, TT_8X4_BOTTOM, TT_4X8_RIGHT, TT_4X8_LEFT, TT_8X4, TT_8X4_TOP }
     };
     /** 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 }
       { MV_PMODE_1MV_HPEL_BILIN, MV_PMODE_1MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_MIXED_MV },
       { MV_PMODE_1MV, MV_PMODE_MIXED_MV, MV_PMODE_1MV_HPEL, MV_PMODE_INTENSITY_COMP, MV_PMODE_1MV_HPEL_BILIN }
     };
     /** One more frame type */
-...
     static VLC vc1_ttblk_vlc[3];
     #define VC1_SUBBLKPAT_VLC_BITS 6
     static VLC vc1_subblkpat_vlc[3];
     static VLC vc1_ac_coeff_table[8];
     //@}
     enum CodingSet {
         CS_HIGH_MOT_INTRA = 0,
         CS_HIGH_MOT_INTER,
         CS_LOW_MOT_INTRA,
         CS_LOW_MOT_INTER,
         CS_MID_RATE_INTRA,
         CS_MID_RATE_INTER,
         CS_HIGH_RATE_INTRA,
         CS_HIGH_RATE_INTER
     };
     /** 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
-...
         uint8_t is_raw;     ///< Bit values must be read at MB level
     } BitPlane;
     /** Block data for DC/AC prediction
     */
     typedef struct Block {
         uint16_t dc;
         int16_t hor_ac[7];
         int16_t vert_ac[7];
         int16_t dcstep, step;
     } Block;
     /** 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;
         int bits;
         /** Simple/Main Profile sequence header */
         //@{
         int res_sm;           ///< reserved, 2b
-...
         int reserved;         ///< reserved
         //@}
     #if HAS_ADVANCED_PROFILE
         /** Advanced Profile */
         //@{
         int level;            ///< 3bits, for Advanced/Simple Profile, provided by TS layer
-...
         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
-...
         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)
         int range_x, range_y; ///< MV range
         uint8_t pq, altpq;    ///< Current/alternate frame quantizer scale
         /** pquant parameters */
         //@{
-...
         uint8_t ttmbf;        ///< Transform type flag
         int ttmb;             ///< Transform type
         uint8_t ttblk4x4;     ///< Value of ttblk which indicates a 4x4 transform
         int codingset;        ///< index of current table set from 11.8 to use for luma block decoding
         int codingset2;       ///< index of current table set from 11.8 to use for chroma block decoding
         int pqindex;          ///< raw pqindex used in coding set selection
         /** Luma compensation parameters */
         //@{
         uint8_t lumscale;
-...
         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 range_mapy;
         uint8_t range_mapuv;
         //@}
     #endif
     } VC1Context;
     /**
-...
     static int get_prefix(GetBitContext *gb, int stop, int len)
+    {
     #if 1
       int i = 0, tmp = !stop;
         int i;
         for(i = 0; i < len && get_bits1(gb) != stop; i++);
         return i;
     /*  int i = 0, tmp = !stop;
       while (i != len && tmp != stop)
+      {
-...
         i++;
+      }
       if (i == len && tmp != stop) return len+1;
       return i;
       return i;*/
     #else
       unsigned int buf;
       int log;
-...
     #endif
+    }
     static inline int decode210(GetBitContext *gb){
         int n;
         n = get_bits1(gb);
         if (n == 1)
             return 0;
         else
             return 2 - get_bits1(gb);
+    }
     /**
      * Init VC-1 specific tables and VC1Context members
      * @param v The VC1Context to initialize
-...
         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,
             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,
             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,
             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,
             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,
                 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,
                 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,
                 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,
                 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,
                 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,
                 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);
+            }
             for(i=0; i<8; i++)
                 init_vlc(&vc1_ac_coeff_table[i], AC_VLC_BITS, vc1_ac_sizes[i],
                          &vc1_ac_tables[i][0][1], 8, 4,
                          &vc1_ac_tables[i][0][0], 8, 4, 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);
+        }
         /* Other defaults */
-...
         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
      * @defgroup bitplane VC9 Bitplane decoding
      * @see 8.7, p56
      * @{
      */
     /** @addtogroup bitplane
      * Imode types
      * @{
      */
     enum Imode {
         IMODE_RAW,
         IMODE_NORM2,
         IMODE_DIFF2,
         IMODE_NORM6,
         IMODE_DIFF6,
         IMODE_ROWSKIP,
         IMODE_COLSKIP
     };
     /** @} */ //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 decode_hrd(VC1Context *v, GetBitContext *gb)
     static int alloc_bitplane(BitPlane *bp, int width, int height)
+    {
         int i, num;
         num = 1 + get_bits(gb, 5);
         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;
+    }
         /*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;
     /** 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);
+    }
         /*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;
+        }
     /** 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;
         /*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;
         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;
+        }
         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);
     /** 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 (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;
+            }
         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 ++;
+        }
         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
     /** Decode a bitplane's bits
      * @param bp Bitplane where to store the decode bits
      * @param v VC-1 context for bit reading and logging
      * @return Status
      * @fixme FIXME: Optimize
      * @todo TODO: Decide if a struct is needed
      */
     static int decode_advanced_sequence_header(AVCodecContext *avctx, GetBitContext *gb)
     static int bitplane_decoding(BitPlane *bp, VC1Context *v)
+    {
         VC1Context *v = avctx->priv_data;
         int nr, dr, aspect_ratio;
         GetBitContext *gb = &v->s.gb;
         v->postprocflag = get_bits(gb, 1);
         v->broadcast = get_bits(gb, 1);
         v->interlace = get_bits(gb, 1);
         int imode, x, y, code, offset;
         uint8_t invert, *planep = bp->data;
         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);
         invert = get_bits(gb, 1);
         imode = get_vlc2(gb, vc1_imode_vlc.table, VC1_IMODE_VLC_BITS, 1);
         /* 6.1.7, p21 */
         if (get_bits(gb, 1) /* pic_size_flag */)
         bp->is_raw = 0;
         switch (imode)
+        {
             avctx->coded_width = get_bits(gb, 12) << 1;
             avctx->coded_height = get_bits(gb, 12) << 1;
             if ( get_bits(gb, 1) /* disp_size_flag */)
         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)
+            {
                 avctx->width = get_bits(gb, 14);
                 avctx->height = get_bits(gb, 14);
                 *planep++ = get_bits(gb, 1);
                 offset = 1;
+            }
             /* 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 offset = 0;
             // decode bitplane as one long line
             for (y = offset; y < bp->height * bp->width; y += 2) {
                 code = get_vlc2(gb, vc1_norm2_vlc.table, VC1_NORM2_VLC_BITS, 1);
                 *planep++ = code & 1;
                 offset++;
                 if(offset == bp->width) {
                     offset = 0;
                     planep += bp->stride - bp->width;
+                }
                 else if (aspect_ratio == 0x0E)
+                {
                     av_log(avctx, AV_LOG_DEBUG, "Reserved AR found\n");
                 *planep++ = code >> 1;
                 offset++;
                 if(offset == bp->width) {
                     offset = 0;
                     planep += bp->stride - bp->width;
+                }
                 else
+            }
             break;
         case IMODE_DIFF6:
         case IMODE_NORM6:
             if(!(bp->height % 3) && (bp->width % 3)) { // use 2x3 decoding
                 for(y = 0; y < bp->height; y+= 3) {
                     for(x = bp->width & 1; x < bp->width; x += 2) {
                         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;
+                        }
                         planep[x + 0] = (code >> 0) & 1;
                         planep[x + 1] = (code >> 1) & 1;
                         planep[x + 0 + bp->stride] = (code >> 2) & 1;
                         planep[x + 1 + bp->stride] = (code >> 3) & 1;
                         planep[x + 0 + bp->stride * 2] = (code >> 4) & 1;
                         planep[x + 1 + bp->stride * 2] = (code >> 5) & 1;
+                    }
                     planep += bp->stride * 3;
+                }
                 if(bp->width & 1) decode_colskip(bp->data, 1, bp->height, bp->stride, &v->s.gb);
             } else { // 3x2
                 for(y = bp->height & 1; y < bp->height; y += 2) {
                     for(x = bp->width % 3; x < bp->width; x += 3) {
                         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;
+                        }
                         planep[x + 0] = (code >> 0) & 1;
                         planep[x + 1] = (code >> 1) & 1;
                         planep[x + 2] = (code >> 2) & 1;
                         planep[x + 0 + bp->stride] = (code >> 3) & 1;
                         planep[x + 1 + bp->stride] = (code >> 4) & 1;
                         planep[x + 2 + bp->stride] = (code >> 5) & 1;
+                    }
                     planep += bp->stride * 2;
+                }
                 x = bp->width % 3;
                 if(x) decode_colskip(bp->data  ,             x, bp->height    , bp->stride, &v->s.gb);
                 if(bp->height & 1) decode_rowskip(bp->data+x, bp->width - x, bp->height & 1, 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++)
+                {
                   avctx->sample_aspect_ratio = vc1_pixel_aspect[aspect_ratio];
                     if (planep[x-1] != planep[x-bp->stride]) planep[x] ^= invert;
                     else                                     planep[x] ^= planep[x-1];
+                }
+            }
+        }
         else
         else if (invert)
+        {
             avctx->coded_width = avctx->width;
             avctx->coded_height = avctx->height;
             planep = bp->data;
             for (x=0; x<bp->width*bp->height; x++) planep[x] = !planep[x]; //FIXME stride
+        }
         return (imode<<1) + invert;
+    }
     /** @} */ //Bitplane group
         /* 6.1.8, p23 */
         if ( get_bits(gb, 1) /* framerateflag */)
     /***********************************************************************/
     /** VOP Dquant decoding
      * @param v VC-1 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
+        {
             if ( !get_bits(gb, 1) /* framerateind */)
             v->dquantfrm = get_bits(gb, 1);
             if ( v->dquantfrm )
+            {
                 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)
                 v->dqprofile = get_bits(gb, 2);
                 switch (v->dqprofile)
+                {
                     av_log(avctx, AV_LOG_ERROR, "0 is forbidden for FRAMERATEDR\n");
                     return -1;
                 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 (dr>2)
                 if (!v->dqbilevel || v->dqprofile != DQPROFILE_ALL_MBS)
+                {
                     av_log(avctx, AV_LOG_ERROR,
                            "Reserved FRAMERATEDR %i not handled\n", dr);
                     dr = 2; /* overflow protection */
                     pqdiff = get_bits(gb, 3);
                     if (pqdiff == 7) v->altpq = get_bits(gb, 5);
                     else v->altpq = v->pq + pqdiff + 1;
+                }
                 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);
+            }
+        }
         return 0;
+    }
         /* 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;
     /** Do inverse transform
      */
     static void vc1_inv_trans(DCTELEM block[64], int M, int N)
+    {
         int i;
         register int t1,t2,t3,t4,t5,t6,t7,t8;
         DCTELEM *src, *dst;
         src = block;
         dst = block;
         if(M==4){
             for(i = 0; i < N; i++){
                 t1 = 17 * (src[0] + src[2]);
                 t2 = 17 * (src[0] - src[2]);
                 t3 = 22 * src[1];
                 t4 = 22 * src[3];
                 t5 = 10 * src[1];
                 t6 = 10 * src[3];
                 dst[0] = (t1 + t3 + t6 + 4) >> 3;
                 dst[1] = (t2 - t4 + t5 + 4) >> 3;
                 dst[2] = (t2 + t4 - t5 + 4) >> 3;
                 dst[3] = (t1 - t3 - t6 + 4) >> 3;
                 src += 8;
                 dst += 8;
+            }
             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;
         }else{
             for(i = 0; i < N; i++){
                 t1 = 12 * (src[0] + src[4]);
                 t2 = 12 * (src[0] - src[4]);
                 t3 = 16 * src[2] +  6 * src[6];
                 t4 =  6 * src[2] - 16 * src[6];
                 t5 = t1 + t3;
                 t6 = t2 + t4;
                 t7 = t2 - t4;
                 t8 = t1 - t3;
                 t1 = 16 * src[1] + 15 * src[3] +  9 * src[5] +  4 * src[7];
                 t2 = 15 * src[1] -  4 * src[3] - 16 * src[5] -  9 * src[7];
                 t3 =  9 * src[1] - 16 * src[3] +  4 * src[5] + 15 * src[7];
                 t4 =  4 * src[1] -  9 * src[3] + 15 * src[5] - 16 * src[7];
                 dst[0] = (t5 + t1 + 4) >> 3;
                 dst[1] = (t6 + t2 + 4) >> 3;
                 dst[2] = (t7 + t3 + 4) >> 3;
                 dst[3] = (t8 + t4 + 4) >> 3;
                 dst[4] = (t8 - t4 + 4) >> 3;
                 dst[5] = (t7 - t3 + 4) >> 3;
                 dst[6] = (t6 - t2 + 4) >> 3;
                 dst[7] = (t5 - t1 + 4) >> 3;
                 src += 8;
                 dst += 8;
+            }
+        }
             //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;
         src = block;
         dst = block;
         if(N==4){
             for(i = 0; i < M; i++){
                 t1 = 17 * (src[ 0] + src[16]);
                 t2 = 17 * (src[ 0] - src[16]);
                 t3 = 22 * src[ 8];
                 t4 = 22 * src[24];
                 t5 = 10 * src[ 8];
                 t6 = 10 * src[24];
                 dst[ 0] = (t1 + t3 + t6 + 64) >> 7;
                 dst[ 8] = (t2 - t4 + t5 + 64) >> 7;
                 dst[16] = (t2 + t4 - t5 + 64) >> 7;
                 dst[24] = (t1 - t3 - t6 + 64) >> 7;
                 src ++;
                 dst ++;
+            }
             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;
         }else{
             for(i = 0; i < M; i++){
                 t1 = 12 * (src[ 0] + src[32]);
                 t2 = 12 * (src[ 0] - src[32]);
                 t3 = 16 * src[16] +  6 * src[48];
                 t4 =  6 * src[16] - 16 * src[48];
                 t5 = t1 + t3;
                 t6 = t2 + t4;
                 t7 = t2 - t4;
                 t8 = t1 - t3;
                 t1 = 16 * src[ 8] + 15 * src[24] +  9 * src[40] +  4 * src[56];
                 t2 = 15 * src[ 8] -  4 * src[24] - 16 * src[40] -  9 * src[56];
                 t3 =  9 * src[ 8] - 16 * src[24] +  4 * src[40] + 15 * src[56];
                 t4 =  4 * src[ 8] -  9 * src[24] + 15 * src[40] - 16 * src[56];
                 dst[ 0] = (t5 + t1 + 64) >> 7;
                 dst[ 8] = (t6 + t2 + 64) >> 7;
                 dst[16] = (t7 + t3 + 64) >> 7;
                 dst[24] = (t8 + t4 + 64) >> 7;
                 dst[32] = (t8 - t4 + 64 + 1) >> 7;
                 dst[40] = (t7 - t3 + 64 + 1) >> 7;
                 dst[48] = (t6 - t2 + 64 + 1) >> 7;
                 dst[56] = (t5 - t1 + 64 + 1) >> 7;
                 src++;
                 dst++;
+            }
+        }
+    }
         //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;
     /** Apply overlap transform
      * @todo optimize
      * @todo move to DSPContext
      */
     static void vc1_overlap_block(MpegEncContext *s, DCTELEM block[64], int n, int do_hor, int do_vert)
+    {
         int i;
         if(do_hor) { //TODO
+        }
         if(do_vert) { //TODO
+        }
         for(i = 0; i < 64; i++)
             block[i] += 128;
+    }
     /** Put block onto picture
      * @todo move to DSPContext
      */
     static void vc1_put_block(VC1Context *v, DCTELEM block[6][64])
+    {
         uint8_t *Y;
         int ys, us, vs;
         DSPContext *dsp = &v->s.dsp;
         ys = v->s.current_picture.linesize[0];
         us = v->s.current_picture.linesize[1];
         vs = v->s.current_picture.linesize[2];
         Y = v->s.dest[0];
         dsp->put_pixels_clamped(block[0], Y, ys);
         dsp->put_pixels_clamped(block[1], Y + 8, ys);
         Y += ys * 8;
         dsp->put_pixels_clamped(block[2], Y, ys);
         dsp->put_pixels_clamped(block[3], Y + 8, ys);
         dsp->put_pixels_clamped(block[4], v->s.dest[1], us);
         dsp->put_pixels_clamped(block[5], v->s.dest[2], vs);
+    }
     /** Do motion compensation over 1 macroblock
      * Mostly adapted hpel_motion and qpel_motion from mpegvideo.c
      */
     static void vc1_mc_1mv(VC1Context *v)
+    {
         MpegEncContext *s = &v->s;
         DSPContext *dsp = &v->s.dsp;
         uint8_t *srcY, *srcU, *srcV;
         int dxy, mx, my, src_x, src_y;
         int width = s->mb_width * 16, height = s->mb_height * 16;
         if(!v->s.last_picture.data[0])return;
         mx = s->mv[0][0][0] >> s->mspel;
         my = s->mv[0][0][1] >> s->mspel;
         srcY = s->last_picture.data[0];
         srcU = s->last_picture.data[1];
         srcV = s->last_picture.data[2];
         if(s->mspel) { // hpel mc
             dxy = ((my & 1) << 1) | (mx & 1);
             src_x = s->mb_x * 16 + (mx >> 1);
             src_y = s->mb_y * 16 + (my >> 1);
     /*        src_x = clip(src_x, -16, width); //FIXME unneeded for emu?
             if (src_x == width)
                 dxy &= ~1;
             src_y = clip(src_y, -16, height);
             if (src_y == height)
                 dxy &= ~2;*/
             srcY += src_y * s->linesize + src_x;
             srcU += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
             srcV += (src_y >> 1) * s->uvlinesize + (src_x >> 1);
             if((unsigned)src_x > s->h_edge_pos - (mx&1) - 16
                || (unsigned)src_y > s->v_edge_pos - (my&1) - 16){
                 uint8_t *uvbuf= s->edge_emu_buffer + 18 * s->linesize;
                 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 16+1, 16+1,
                                  src_x, src_y, s->h_edge_pos, s->v_edge_pos);
                 srcY = s->edge_emu_buffer;
                 ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 8+1, 8+1,
                                  src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
                 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8+1, 8+1,
                                  src_x >> 1, src_y >> 1, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
                 srcU = uvbuf;
                 srcV = uvbuf + 16;
+            }
             dsp->put_no_rnd_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize, 16);
             dsp->put_no_rnd_pixels_tab[1][0](s->dest[1], srcU, s->uvlinesize, 8);
             dsp->put_no_rnd_pixels_tab[1][0](s->dest[2], srcV, s->uvlinesize, 8);
         } else {
             int motion_x = mx, motion_y = my, uvdxy, uvsrc_x, uvsrc_y;
             dxy = ((motion_y & 3) << 2) | (motion_x & 3);
             src_x = s->mb_x * 16 + (mx >> 2);
             src_y = s->mb_y * 16 + (my >> 2);
             mx= motion_x/2;
             my= motion_y/2;
             mx= (mx>>1)|(mx&1);
             my= (my>>1)|(my&1);
             uvdxy= (mx&1) | ((my&1)<<1);
             mx>>=1;
             my>>=1;
             uvsrc_x = s->mb_x * 8 + mx;
             uvsrc_y = s->mb_y * 8 + my;
             srcY = s->last_picture.data[0] +   src_y *   s->linesize +   src_x;
             srcU = s->last_picture.data[1] + uvsrc_y * s->uvlinesize + uvsrc_x;
             srcV = s->last_picture.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
             if(   (unsigned)src_x > s->h_edge_pos - (motion_x&3) - 16
                   || (unsigned)src_y > s->v_edge_pos - (motion_y&3) - 16  ){
                 uint8_t *uvbuf= s->edge_emu_buffer + 18*s->linesize;
                 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, 17, 17,
                                     src_x, src_y, s->h_edge_pos, s->v_edge_pos);
                 srcY = s->edge_emu_buffer;
                 ff_emulated_edge_mc(uvbuf, srcU, s->uvlinesize, 9, 9,
                                         uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
                 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 9, 9,
                                         uvsrc_x, uvsrc_y, s->h_edge_pos>>1, s->v_edge_pos>>1);
                 srcU = uvbuf;
                 srcV = uvbuf + 16;
+            }
             dsp->put_no_rnd_qpel_pixels_tab[0][dxy](s->dest[0], srcY, s->linesize);
             dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[1], srcU, s->uvlinesize, 8);
             dsp->put_no_rnd_pixels_tab[1][uvdxy](s->dest[2], srcV, s->uvlinesize, 8);
+        }
+    }
     #endif
     /**
      * Decode Simple/Main Profiles sequence header
-...
+    {
         VC1Context *v = avctx->priv_data;
         av_log(avctx, AV_LOG_DEBUG, "Header: %0X\n", show_bits(gb, 32));
         av_log(avctx, AV_LOG_INFO, "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");
             av_log(avctx, AV_LOG_ERROR, "Profile value 2 is forbidden (and WMV3 Complex Profile is unsupported)\n");
             return -1;
+        }
     #if HAS_ADVANCED_PROFILE
         if (v->profile == PROFILE_ADVANCED)
+        {
             v->level = get_bits(gb, 3);
-...
+            }
+        }
         else
     #endif
+        {
             v->res_sm = get_bits(gb, 2); //reserved
             if (v->res_sm)
-...
                    "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)
-...
         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)
-...
         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,
                 av_log(avctx, AV_LOG_INFO,
                        "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
-...
                        "0 for reserved RES_RTM_FLAG is forbidden\n");
                 //return -1;
+            }
     #if TRACE
             av_log(avctx, AV_LOG_INFO,
             av_log(avctx, AV_LOG_DEBUG,
                    "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"
-...
                    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
         return -1;
+    }
     #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)
     static int vc1_parse_frame_header(VC1Context *v, 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);
         int pqindex, lowquant, status;
         if(v->finterpflag) v->interpfrm = get_bits(gb, 1);
         skip_bits(gb, 2); //framecnt unused
         v->rangeredfrm = 0;
         if (v->rangered) v->rangeredfrm = get_bits(gb, 1);
         v->s.pict_type = get_bits(gb, 1);
         if (v->s.avctx->max_b_frames) {
             if (!v->s.pict_type) {
                 if (get_bits(gb, 1)) v->s.pict_type = I_TYPE;
                 else v->s.pict_type = B_TYPE;
             } else v->s.pict_type = P_TYPE;
         } else v->s.pict_type = v->s.pict_type ? P_TYPE : I_TYPE;
         if(v->s.pict_type == I_TYPE)
             get_bits(gb, 7); // skip buffer fullness
         /* 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 (v->quantizer_mode == QUANT_FRAME_IMPLICIT)
             v->pquantizer = pqindex < 9;
         if (v->quantizer_mode == QUANT_UNIFORM || v->quantizer_mode == QUANT_NON_UNIFORM)
             v->pquantizer = v->quantizer_mode == QUANT_UNIFORM;
         v->pqindex = pqindex;
         if (pqindex < 9) v->halfpq = get_bits(gb, 1);
         else v->halfpq = 0;
         if (v->quantizer_mode == QUANT_FRAME_EXPLICIT)
             v->pquantizer = get_bits(gb, 1);
         v->dquantfrm = 0;
     //av_log(v->s.avctx, AV_LOG_INFO, "%c Frame: QP=[%i]%i (+%i/2) %i\n",
     //        (v->s.pict_type == P_TYPE) ? 'P' : ((v->s.pict_type == I_TYPE) ? 'I' : 'B'), pqindex, v->pq, v->halfpq, v->rangeredfrm);
         //TODO: complete parsing for P/B/BI frames
         switch(v->s.pict_type) {
         case P_TYPE:
             if (v->pq < 5) v->tt_index = 0;
             else if(v->pq < 13) v->tt_index = 1;
             else v->tt_index = 2;
             if (v->extended_mv == 1) v->mvrange = get_prefix(gb, 0, 3);
             v->k_x = v->mvrange + 9 + (v->mvrange >> 1); //k_x can be 9 10 12 13
             v->k_y = v->mvrange + 8; //k_y can be 8 9 10 11
             v->range_x = 1 << (v->k_x - 1);
             v->range_y = 1 << (v->k_y - 1);
             if (v->profile == PROFILE_ADVANCED)
+            {
                 if (v->postprocflag) v->postproc = get_bits(gb, 1);
+            }
             else
                 if (v->multires) v->respic = get_bits(gb, 2);
             lowquant = (v->pq > 12) ? 0 : 1;
             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(gb, 1, 3)];
                 v->lumscale = get_bits(gb, 6);
                 v->lumshift = get_bits(gb, 6);
+            }
             if(v->mv_mode == MV_PMODE_1MV_HPEL || v->mv_mode == MV_PMODE_1MV_HPEL_BILIN)
                 v->s.mspel = 1;
             else
                 v->s.mspel = 0;
     if(v->mv_mode != MV_PMODE_1MV && v->mv_mode != MV_PMODE_1MV_HPEL && v->mv_mode != MV_PMODE_1MV_HPEL_BILIN) {
         av_log(v->s.avctx, AV_LOG_ERROR, "Only 1MV P-frames are supported by now\n");
         return -1;
+    }
             if ((v->mv_mode == MV_PMODE_INTENSITY_COMP &&
                      v->mv_mode2 == MV_PMODE_MIXED_MV)
                     || v->mv_mode == MV_PMODE_MIXED_MV)
+            {
                 status = bitplane_decoding(&v->mv_type_mb_plane, v);
                 if (status < 0) return -1;
                 av_log(v->s.avctx, AV_LOG_DEBUG, "MB MV Type plane encoding: "
                        "Imode: %i, Invert: %i\n", status>>1, status&1);
+            }
             status = bitplane_decoding(&v->skip_mb_plane, v);
             if (status < 0) return -1;
             av_log(v->s.avctx, AV_LOG_DEBUG, "MB Skip plane encoding: "
                    "Imode: %i, Invert: %i\n", status>>1, status&1);
             /* Hopefully this is correct for P 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)
+            {
                 av_log(v->s.avctx, AV_LOG_DEBUG, "VOP DQuant info\n");
                 vop_dquant_decoding(v);
+            }
             v->ttfrm = 0; //FIXME Is that so ?
             if (v->vstransform)
+            {
                 v->ttmbf = get_bits(gb, 1);
                 if (v->ttmbf)
+                {
                     v->ttfrm = get_bits(gb, 2);
+                }
+            }
             break;
         case B_TYPE:
             break;
+        }
         if (v->panscanflag)
         /* AC Syntax */
         v->c_ac_table_index = decode012(gb);
         if (v->s.pict_type == I_TYPE || v->s.pict_type == BI_TYPE)
+        {
             //NUMPANSCANWIN
             v->numpanscanwin = get_bits(gb, 3);
             av_log(avctx, AV_LOG_DEBUG, "NUMPANSCANWIN: %u\n", v->numpanscanwin);
             v->y_ac_table_index = decode012(gb);
+        }
         /* DC Syntax */
         v->s.dc_table_index = get_bits(gb, 1);
         return 0;
+    }
     #endif
     /***********************************************************************/
     /**
      * @defgroup bitplane VC1 Bitplane decoding
      * @see 8.7, p56
      * @defgroup block VC-1 Block-level functions
      * @see 7.1.4, p91 and 8.1.1.7, p(1)04
      * @todo TODO: Integrate to MpegEncContext facilities
      * @{
      */
     /** @addtogroup bitplane
      * Imode types
      * @{
     /**
      * @def GET_MQUANT
      * @brief Get macroblock-level quantizer scale
      * @warning XXX: qdiff to the frame quant, not previous quant ?
      * @fixme XXX: Don't know how to initialize mquant otherwise in last case
      */
     #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
     #define GET_MQUANT()                                           \
       if (v->dquantfrm)                                            \
       {                                                            \
         if (v->dqprofile == DQPROFILE_ALL_MBS)                     \
         {                                                          \
           if (v->dqbilevel)                                        \
           {                                                        \
             mquant = (get_bits(gb, 1)) ? v->pq : v->altpq;         \
           }                                                        \
           else                                                     \
           {                                                        \
             mqdiff = get_bits(gb, 3);                              \
             if (mqdiff != 7) mquant = v->pq + mqdiff;              \
             else mquant = get_bits(gb, 5);                         \
           }                                                        \
         }                                                          \
         else mquant = v->pq;                                       \
+      }
     /** 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 ?
     /**
      * @def GET_MVDATA(_dmv_x, _dmv_y)
      * @brief Get MV differentials
      * @see MVDATA decoding from 8.3.5.2, p(1)20
      * @param _dmv_x Horizontal differential for decoded MV
      * @param _dmv_y Vertical differential for decoded MV
      * @todo TODO: Use MpegEncContext arrays to store them
      */
     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;
+    }
     #define GET_MVDATA(_dmv_x, _dmv_y)                                  \
       index = 1 + get_vlc2(gb, vc1_mv_diff_vlc[s->mv_table_index].table,\
                            VC1_MV_DIFF_VLC_BITS, 2);                    \
       if (index > 36)                                                   \
       {                                                                 \
         mb_has_coeffs = 1;                                              \
         index -= 37;                                                    \
       }                                                                 \
       else mb_has_coeffs = 0;                                           \
       s->mb_intra = 0;                                                  \
       if (!index) { _dmv_x = _dmv_y = 0; }                              \
       else if (index == 35)                                             \
       {                                                                 \
         _dmv_x = get_bits(gb, v->k_x - s->mspel);                       \
         _dmv_y = get_bits(gb, v->k_y - s->mspel);                       \
       }                                                                 \
       else if (index == 36)                                             \
       {                                                                 \
         _dmv_x = 0;                                                     \
         _dmv_y = 0;                                                     \
         s->mb_intra = 1;                                                \
       }                                                                 \
       else                                                              \
       {                                                                 \
         index1 = index%6;                                               \
         if (s->mspel && index1 == 5) val = 1;                           \
         else                         val = 0;                           \
         val = get_bits(gb, size_table[index1] - val);                   \
         sign = 0 - (val&1);                                             \
         _dmv_x = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
+                                                                        \
         index1 = index/6;                                               \
         if (s->mspel && index1 == 5) val = 1;                           \
         else                          val = 0;                          \
         val = get_bits(gb, size_table[index1] - val);                   \
         sign = 0 - (val&1);                                             \
         _dmv_y = (sign ^ ((val>>1) + offset_table[index1])) - sign;     \
+      }
     /** Free the bitplane's buffer
      * @param bp Bitplane which buffer is to free
     /** Predict and set motion vector
      */
     static void free_bitplane(BitPlane *bp)
     static inline void vc1_pred_mv(MpegEncContext *s, int dmv_x, int dmv_y, int mv1, int r_x, int r_y)
+    {
         bp->width = bp->stride = bp->height = 0;
         if (bp->data) av_freep(&bp->data);

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff