g3dvl/vp8: Rename some data fields to match RFC 6386, plus some minor cleanups

Signed-off-by: Emeric Grange <emeric.grange@gmail.com>

12 files changed, 86 insertions, 93 deletions

diff --git a/src/gallium/auxiliary/vl/vp8/alloccommon.c b/src/gallium/auxiliary/vl/vp8/alloccommon.c
index 4709b2159a..b97740050a 100644
--- a/src/gallium/auxiliary/vl/vp8/alloccommon.c
+++ b/src/gallium/auxiliary/vl/vp8/alloccommon.c
@@ -154,21 +154,21 @@ void vp8_initialize_common(VP8_COMMON *common)
     vp8_init_mbmode_probs(common);
     vp8_default_bmode_probs(common->fc.bmode_prob);
 
-    common->mb_no_coeff_skip = 1;
+    common->mb_no_skip_coeff = 1;
     common->no_lpf = 0;
     common->filter_type = NORMAL_LOOPFILTER;
     common->use_bilinear_mc_filter = 0;
     common->full_pixel = 0;
     common->multi_token_partition = ONE_PARTITION;
-    common->clr_type = REG_YUV;
-    common->clamp_type = RECON_CLAMP_REQUIRED;
+    common->color_space = REG_YUV;
+    common->clamping_type = RECON_CLAMP_REQUIRED;
 
     /* Initialise reference frame sign bias structure to defaults */
     memset(common->ref_frame_sign_bias, 0, sizeof(common->ref_frame_sign_bias));
 
     /* Default disable buffer to buffer copying */
-    common->copy_buffer_to_gf = 0;
-    common->copy_buffer_to_arf = 0;
+    common->copy_buffer_to_golden = 0;
+    common->copy_buffer_to_alternate = 0;
 
     /*  */
     vp8_coef_tree_initialize();
diff --git a/src/gallium/auxiliary/vl/vp8/decodeframe.c b/src/gallium/auxiliary/vl/vp8/decodeframe.c
index 56827ff610..1b446938bb 100644
--- a/src/gallium/auxiliary/vl/vp8/decodeframe.c
+++ b/src/gallium/auxiliary/vl/vp8/decodeframe.c
@@ -507,9 +507,9 @@ static void vp8_frame_init(VP8_COMMON *common)
 
         /* All buffers are implicitly updated on key frames. */
         common->refresh_golden_frame = 1;
-        common->refresh_alt_ref_frame = 1;
-        common->copy_buffer_to_gf = 0;
-        common->copy_buffer_to_arf = 0;
+        common->refresh_alternate_frame = 1;
+        common->copy_buffer_to_golden = 0;
+        common->copy_buffer_to_alternate = 0;
 
         /* Note that Golden and Altref modes cannot be used on a key frame so
          * ref_frame_sign_bias[] is undefined and meaningless. */
@@ -520,19 +520,19 @@ static void vp8_frame_init(VP8_COMMON *common)
     {
         if (common->use_bilinear_mc_filter)
         {
-            common->mcomp_filter_type   = BILINEAR;
-            mb->filter_predict4x4   = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear4x4);
-            mb->filter_predict8x4   = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear8x4);
-            mb->filter_predict8x8   = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear8x8);
-            mb->filter_predict16x16 = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear16x16);
+            common->mcomp_filter_type = BILINEAR;
+            mb->filter_predict4x4     = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear4x4);
+            mb->filter_predict8x4     = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear8x4);
+            mb->filter_predict8x8     = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear8x8);
+            mb->filter_predict16x16   = FILTER_INVOKE(RTCD_VTABLE(filter), bilinear16x16);
         }
         else
         {
-            common->mcomp_filter_type   = SIXTAP;
-            mb->filter_predict4x4   = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap4x4);
-            mb->filter_predict8x4   = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap8x4);
-            mb->filter_predict8x8   = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap8x8);
-            mb->filter_predict16x16 = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap16x16);
+            common->mcomp_filter_type = SIXTAP;
+            mb->filter_predict4x4     = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap4x4);
+            mb->filter_predict8x4     = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap8x4);
+            mb->filter_predict8x8     = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap8x8);
+            mb->filter_predict16x16   = FILTER_INVOKE(RTCD_VTABLE(filter), sixtap16x16);
         }
     }
 
@@ -578,9 +578,9 @@ int vp8_frame_decode(VP8_COMMON *common, struct pipe_vp8_picture_desc *frame_hea
         }
 
         common->width = frame_header->width;
-        common->horiz_scale = frame_header->horizontal_scale;
+        common->horizontal_scale = frame_header->horizontal_scale;
         common->height = frame_header->height;
-        common->vert_scale = frame_header->vertical_scale;
+        common->vertical_scale = frame_header->vertical_scale;
     }
 
     vp8_frame_init(common);
@@ -593,8 +593,8 @@ int vp8_frame_decode(VP8_COMMON *common, struct pipe_vp8_picture_desc *frame_hea
 
     if (common->frame_type == KEY_FRAME)
     {
-        common->clr_type   = (YUV_TYPE)vp8_read_bit(bd);
-        common->clamp_type = (CLAMP_TYPE)vp8_read_bit(bd);
+        common->color_space   = (YUV_TYPE)vp8_read_bit(bd);
+        common->clamping_type = (CLAMP_TYPE)vp8_read_bit(bd);
     }
 
     /* Is segmentation enabled */
@@ -718,17 +718,17 @@ int vp8_frame_decode(VP8_COMMON *common, struct pipe_vp8_picture_desc *frame_hea
     {
         /* Should the GF or ARF be updated from the current frame. */
         common->refresh_golden_frame = vp8_read_bit(bd);
-        common->refresh_alt_ref_frame = vp8_read_bit(bd);
+        common->refresh_alternate_frame = vp8_read_bit(bd);
 
         /* Buffer to buffer copy flags. */
-        common->copy_buffer_to_gf = 0;
-        common->copy_buffer_to_arf = 0;
+        common->copy_buffer_to_golden = 0;
+        common->copy_buffer_to_alternate = 0;
 
         if (!common->refresh_golden_frame)
-            common->copy_buffer_to_gf = vp8_read_literal(bd, 2);
+            common->copy_buffer_to_golden = vp8_read_literal(bd, 2);
 
-        if (!common->refresh_alt_ref_frame)
-            common->copy_buffer_to_arf = vp8_read_literal(bd, 2);
+        if (!common->refresh_alternate_frame)
+            common->copy_buffer_to_alternate = vp8_read_literal(bd, 2);
 
         common->ref_frame_sign_bias[GOLDEN_FRAME] = vp8_read_bit(bd);
         common->ref_frame_sign_bias[ALTREF_FRAME] = vp8_read_bit(bd);
@@ -770,7 +770,7 @@ int vp8_frame_decode(VP8_COMMON *common, struct pipe_vp8_picture_desc *frame_hea
     memset(mb->qcoeff, 0, sizeof(mb->qcoeff));
 
     /* Read the mb_no_coeff_skip flag */
-    common->mb_no_coeff_skip = vp8_read_bit(bd);
+    common->mb_no_skip_coeff = vp8_read_bit(bd);
 
     vp8_decode_mode_mvs(common);
 
@@ -810,7 +810,7 @@ int vp8_frame_decode(VP8_COMMON *common, struct pipe_vp8_picture_desc *frame_hea
     /* If this was a kf or Gf note the Q used */
     if (common->frame_type == KEY_FRAME ||
         common->refresh_golden_frame ||
-        common->refresh_alt_ref_frame)
+        common->refresh_alternate_frame)
     {
         common->last_kf_gf_q = common->base_qindex;
     }
diff --git a/src/gallium/auxiliary/vl/vp8/decodemv.c b/src/gallium/auxiliary/vl/vp8/decodemv.c
index 688099b3b6..2b5a04ae69 100644
--- a/src/gallium/auxiliary/vl/vp8/decodemv.c
+++ b/src/gallium/auxiliary/vl/vp8/decodemv.c
@@ -159,7 +159,7 @@ static void vp8_kfread_modes(VP8_COMMON *common, MODE_INFO *mi, int mb_row, int
         vp8_read_mb_features(bd, &mi->mbmi, &common->mb);
 
     /* Read the macroblock coeff skip flag if this feature is in use, else default to 0 */
-    if (common->mb_no_coeff_skip)
+    if (common->mb_no_skip_coeff)
         mi->mbmi.mb_skip_coeff = vp8_read(bd, common->prob_skip_false);
     else
         mi->mbmi.mb_skip_coeff = 0;
@@ -300,7 +300,7 @@ static void mb_mode_mv_init(VP8_COMMON *common)
     MV_CONTEXT *const mvc = common->fc.mvc;
 
     common->prob_skip_false = 0;
-    if (common->mb_no_coeff_skip)
+    if (common->mb_no_skip_coeff)
         common->prob_skip_false = (vp8_prob)vp8_read_literal(bd, 8);
 
     if (common->frame_type != KEY_FRAME)
@@ -368,7 +368,7 @@ static void read_mb_modes_mv(VP8_COMMON *common,
         vp8_read_mb_features(bd, mbmi, &common->mb);
 
     /* Read the macroblock coeff skip flag if this feature is in use, else default to 0 */
-    if (common->mb_no_coeff_skip)
+    if (common->mb_no_skip_coeff)
         mbmi->mb_skip_coeff = vp8_read(bd, common->prob_skip_false);
     else
         mbmi->mb_skip_coeff = 0;
diff --git a/src/gallium/auxiliary/vl/vp8/dequantize.c b/src/gallium/auxiliary/vl/vp8/dequantize.c
index 77b5266185..be31261300 100644
--- a/src/gallium/auxiliary/vl/vp8/dequantize.c
+++ b/src/gallium/auxiliary/vl/vp8/dequantize.c
@@ -28,10 +28,9 @@ void vp8_dequant_b_c(BLOCKD *d)
 void vp8_dequant_idct_add_c(short *input, short *dq, unsigned char *pred,
                             unsigned char *dest, int pitch, int stride)
 {
+    int i, r, c;
     short output[16];
     short *diff_ptr = output;
-    int r, c;
-    int i;
 
     for (i = 0; i < 16; i++)
     {
@@ -68,10 +67,9 @@ void vp8_dequant_dc_idct_add_c(short *input, short *dq, unsigned char *pred,
                                unsigned char *dest, int pitch, int stride,
                                int dc)
 {
-    int i;
+    int i, r, c;
     short output[16];
     short *diff_ptr = output;
-    int r, c;
 
     input[0] = (short)dc;
 
diff --git a/src/gallium/auxiliary/vl/vp8/dequantize_common.c b/src/gallium/auxiliary/vl/vp8/dequantize_common.c
index 384cab66a6..c16cfc35cc 100644
--- a/src/gallium/auxiliary/vl/vp8/dequantize_common.c
+++ b/src/gallium/auxiliary/vl/vp8/dequantize_common.c
@@ -137,8 +137,7 @@ static int vp8_ac_uv_quant(int QIndex, int Delta)
 
 void vp8_initialize_dequantizer(VP8_COMMON *common)
 {
-    int i;
-    int Q;
+    int Q, i;
 
     for (Q = 0; Q < QINDEX_RANGE; Q++)
     {
diff --git a/src/gallium/auxiliary/vl/vp8/detokenize.c b/src/gallium/auxiliary/vl/vp8/detokenize.c
index 4187c4fae1..990fd9d9f8 100644
--- a/src/gallium/auxiliary/vl/vp8/detokenize.c
+++ b/src/gallium/auxiliary/vl/vp8/detokenize.c
@@ -210,7 +210,7 @@ int vp8_decode_mb_tokens(VP8_COMMON *common, MACROBLOCKD *mb)
     register unsigned int shift;
     uint32_t split;
     VP8_BD_VALUE bigsplit;
-    int16_t *qcoeff_ptr = &mb->qcoeff[0];
+    int16_t *qcoeff_ptr = &mb->qcoeff[0]; // tokens for this block
 
     int type = 3;
     int stop = 16;
@@ -218,7 +218,7 @@ int vp8_decode_mb_tokens(VP8_COMMON *common, MACROBLOCKD *mb)
     int16_t c;
     int16_t v;
     const vp8_prob *Prob;
-    const vp8_prob *coef_probs;
+    const vp8_prob *coef_probs; // probabilities for this block type
 
     if (mb->mode_info_context->mbmi.mode != B_PRED &&
         mb->mode_info_context->mbmi.mode != SPLITMV)
diff --git a/src/gallium/auxiliary/vl/vp8/reconinter.c b/src/gallium/auxiliary/vl/vp8/reconinter.c
index b1a71814c1..c0d34e5343 100644
--- a/src/gallium/auxiliary/vl/vp8/reconinter.c
+++ b/src/gallium/auxiliary/vl/vp8/reconinter.c
@@ -11,7 +11,6 @@
 
 #include "recon_dispatch.h"
 #include "filter_dispatch.h"
-#include "blockd.h"
 #include "reconinter.h"
 #include "vp8_mem.h"
 
@@ -122,15 +121,15 @@ void vp8_build_inter_predictors_b(BLOCKD *d, int pitch, vp8_filter_fn_t sppf)
         for (r = 0; r < 4; r++)
         {
 #ifdef MUST_BE_ALIGNED
-            pred_ptr[0]  = ptr[0];
-            pred_ptr[1]  = ptr[1];
-            pred_ptr[2]  = ptr[2];
-            pred_ptr[3]  = ptr[3];
+            pred_ptr[0] = ptr[0];
+            pred_ptr[1] = ptr[1];
+            pred_ptr[2] = ptr[2];
+            pred_ptr[3] = ptr[3];
 #else
             *(int *)pred_ptr = *(int *)ptr;
 #endif /* MUST_BE_ALIGNED */
-            pred_ptr    += pitch;
-            ptr         += d->pre_stride;
+            pred_ptr += pitch;
+            ptr      += d->pre_stride;
         }
     }
 }
@@ -299,7 +298,7 @@ void vp8_build_uvmvs(MACROBLOCKD *mb, int fullpixel)
                 if (fullpixel)
                     mb->block[uoffset].bmi.mv.as_mv.row = (temp / 8) & 0xfffffff8;
 
-                temp = mb->block[yoffset  ].bmi.mv.as_mv.col
+                temp = mb->block[yoffset].bmi.mv.as_mv.col
                        + mb->block[yoffset+1].bmi.mv.as_mv.col
                        + mb->block[yoffset+4].bmi.mv.as_mv.col
                        + mb->block[yoffset+5].bmi.mv.as_mv.col;
diff --git a/src/gallium/auxiliary/vl/vp8/reconinter.h b/src/gallium/auxiliary/vl/vp8/reconinter.h
index f9fbecb621..fe6e2ba5c0 100644
--- a/src/gallium/auxiliary/vl/vp8/reconinter.h
+++ b/src/gallium/auxiliary/vl/vp8/reconinter.h
@@ -12,6 +12,8 @@
 #ifndef RECONINTER_H
 #define RECONINTER_H
 
+#include "blockd.h"
+
 extern void vp8_build_inter_predictors_mb(MACROBLOCKD *mb);
 
 extern void vp8_build_inter16x16_predictors_mb(MACROBLOCKD *mb,
diff --git a/src/gallium/auxiliary/vl/vp8/treereader.c b/src/gallium/auxiliary/vl/vp8/treereader.c
index 256e1d7a20..e4e8979a41 100644
--- a/src/gallium/auxiliary/vl/vp8/treereader.c
+++ b/src/gallium/auxiliary/vl/vp8/treereader.c
@@ -19,7 +19,7 @@
  */
 int vp8dx_start_decode(BOOL_DECODER *bd,
                        const unsigned char *data,
-                       unsigned int data_size)
+                       const unsigned int data_size)
 {
     bd->user_buffer_end = data + data_size;
     bd->user_buffer     = data;
@@ -30,22 +30,20 @@ int vp8dx_start_decode(BOOL_DECODER *bd,
     if (data_size && !data)
         return 1;
 
-    /* Populate the buffer */
     vp8dx_bool_decoder_fill(bd);
 
     return 0;
 }
 
+/**
+ * Populate the buffer.
+ */
 void vp8dx_bool_decoder_fill(BOOL_DECODER *bd)
 {
-    const unsigned char *bufptr;
-    const unsigned char *bufend;
-    VP8_BD_VALUE value;
-    int count;
-    bufend = bd->user_buffer_end;
-    bufptr = bd->user_buffer;
-    value = bd->value;
-    count = bd->count;
+    const unsigned char *bufptr = bd->user_buffer;
+    const unsigned char *bufend = bd->user_buffer_end;
+    VP8_BD_VALUE value = bd->value;
+    int count = bd->count;
 
     VP8DX_BOOL_DECODER_FILL(count, value, bufptr, bufend);
 
@@ -58,13 +56,11 @@ int vp8dx_decode_bool(BOOL_DECODER *bd, int probability)
 {
     unsigned int bit = 0;
     VP8_BD_VALUE value;
-    unsigned int split;
+    unsigned int split = 1 + (((bd->range - 1) * probability) >> 8);
     VP8_BD_VALUE bigsplit;
     int count;
     unsigned int range;
 
-    split = 1 + (((bd->range - 1) * probability) >> 8);
-
     if (bd->count < 0)
         vp8dx_bool_decoder_fill(bd);
 
diff --git a/src/gallium/auxiliary/vl/vp8/treereader.h b/src/gallium/auxiliary/vl/vp8/treereader.h
index 4594b0bd3c..5c813a1f42 100644
--- a/src/gallium/auxiliary/vl/vp8/treereader.h
+++ b/src/gallium/auxiliary/vl/vp8/treereader.h
@@ -41,7 +41,8 @@ typedef struct
 
 DECLARE_ALIGNED(16, extern const unsigned char, vp8_norm[256]);
 
-int vp8dx_start_decode(BOOL_DECODER *bd, const unsigned char *data, unsigned int data_size);
+int vp8dx_start_decode(BOOL_DECODER *bd, const unsigned char *data,
+                       const unsigned int data_size);
 
 void vp8dx_bool_decoder_fill(BOOL_DECODER *bd);
 
diff --git a/src/gallium/auxiliary/vl/vp8/vp8_decoder.c b/src/gallium/auxiliary/vl/vp8/vp8_decoder.c
index aeb3e8d4e7..51a180e574 100644
--- a/src/gallium/auxiliary/vl/vp8/vp8_decoder.c
+++ b/src/gallium/auxiliary/vl/vp8/vp8_decoder.c
@@ -53,13 +53,13 @@ static int swap_frame_buffers(VP8_COMMON *common)
      * new, last, or golden/alt ref frame. If it is updated using the newly
      * decoded frame it is a refresh. An update using the last or golden/alt
      * ref frame is a copy. */
-    if (common->copy_buffer_to_arf)
+    if (common->copy_buffer_to_alternate)
     {
         int new_fb = 0;
 
-        if (common->copy_buffer_to_arf == 1)
+        if (common->copy_buffer_to_alternate == 1)
             new_fb = common->lst_fb_idx;
-        else if (common->copy_buffer_to_arf == 2)
+        else if (common->copy_buffer_to_alternate == 2)
             new_fb = common->gld_fb_idx;
         else
             err = -1;
@@ -67,13 +67,13 @@ static int swap_frame_buffers(VP8_COMMON *common)
         ref_cnt_fb(common->fb_idx_ref_cnt, &common->alt_fb_idx, new_fb);
     }
 
-    if (common->copy_buffer_to_gf)
+    if (common->copy_buffer_to_golden)
     {
         int new_fb = 0;
 
-        if (common->copy_buffer_to_gf == 1)
+        if (common->copy_buffer_to_golden == 1)
             new_fb = common->lst_fb_idx;
-        else if (common->copy_buffer_to_gf == 2)
+        else if (common->copy_buffer_to_golden == 2)
             new_fb = common->alt_fb_idx;
         else
             err = -1;
@@ -84,7 +84,7 @@ static int swap_frame_buffers(VP8_COMMON *common)
     if (common->refresh_golden_frame)
         ref_cnt_fb(common->fb_idx_ref_cnt, &common->gld_fb_idx, common->new_fb_idx);
 
-    if (common->refresh_alt_ref_frame)
+    if (common->refresh_alternate_frame)
         ref_cnt_fb(common->fb_idx_ref_cnt, &common->alt_fb_idx, common->new_fb_idx);
 
     if (common->refresh_last_frame)
@@ -208,8 +208,7 @@ int vp8_decoder_start(VP8_COMMON *common,
 /**
  * Return a decoded VP8 frame in a YV12 framebuffer.
  */
-int vp8_decoder_getframe(VP8_COMMON *common,
-                         YV12_BUFFER_CONFIG *sd)
+int vp8_decoder_getframe(VP8_COMMON *common, YV12_BUFFER_CONFIG *sd)
 {
     int ret = -1;
 
@@ -220,7 +219,7 @@ int vp8_decoder_getframe(VP8_COMMON *common,
     if (common->frame_to_show)
     {
         *sd = *common->frame_to_show;
-        sd->clrtype = common->clr_type;
+        sd->clrtype = common->color_space;
         sd->y_width = common->width;
         sd->y_height = common->height;
         sd->uv_height = common->height / 2;
diff --git a/src/gallium/auxiliary/vl/vp8/vp8_decoder.h b/src/gallium/auxiliary/vl/vp8/vp8_decoder.h
index f7f1add6f7..7043e2f1e5 100644
--- a/src/gallium/auxiliary/vl/vp8/vp8_decoder.h
+++ b/src/gallium/auxiliary/vl/vp8/vp8_decoder.h
@@ -83,47 +83,48 @@ typedef struct VP8Common
 {
     struct vpx_internal_error_info error;
 
-    /* Bitstream data */
+    /* Bitstream buffer */
     const unsigned char *data;
     unsigned int         data_size;
 
-    /* Boolean decoder */
+    /* Boolean decoders */
     BOOL_DECODER *mbd;
     BOOL_DECODER bd, bd2;
 
-    /* Header content */
+    /* Frame header content */
     FRAME_TYPE frame_type;
     int version;
     int show_frame;
 
+    int horizontal_scale;
     int width;
+    int vertical_scale;
     int height;
-    int horiz_scale;
-    int vert_scale;
 
-    YUV_TYPE clr_type;
-    CLAMP_TYPE clamp_type;
-
-    INTERPOLATIONFILTER_TYPE mcomp_filter_type;
-    LOOPFILTER_TYPE filter_type;
+    YUV_TYPE color_space;
+    CLAMP_TYPE clamping_type;
 
+    INTERPOLATIONFILTER_TYPE mcomp_filter_type;  /**< Motion compensation filter type. Not from the bitstream. */
+    LOOPFILTER_TYPE filter_type;                 /**< Loop filter type */
     int filter_level;
-    int last_sharpness_level;
     int sharpness_level;
 
-    int refresh_last_frame;    /**< Two state 0 = NO, 1 = YES */
-    int refresh_golden_frame;  /**< Two state 0 = NO, 1 = YES */
-    int refresh_alt_ref_frame; /**< Two state 0 = NO, 1 = YES */
-    int refresh_entropy_probs; /**< Two state 0 = NO, 1 = YES */
+    int refresh_last_frame;       /**< Two state 0 = NO, 1 = YES */
+    int refresh_golden_frame;     /**< Two state 0 = NO, 1 = YES */
+    int refresh_alternate_frame;  /**< Two state 0 = NO, 1 = YES */
+    int refresh_entropy_probs;    /**< Two state 0 = NO, 1 = YES */
+
+    int copy_buffer_to_golden;    /**< 0 = none, 1 = LAST to GOLDEN, 2 = ALTERNATE to GOLDEN */
+    int copy_buffer_to_alternate; /**< 0 = none, 1 = LAST to ALTERNATE, 2 = GOLDEN to ALTERNATE */
 
+    int mb_no_skip_coeff;
 
-    /* Profile settings */
-    int mb_no_coeff_skip;
+    /* Profile/Level settings */
     int no_lpf;
     int use_bilinear_mc_filter;
     int full_pixel;
 
-    /* Quantization */
+    /* Quantization parameters */
     DECLARE_ALIGNED(16, short, Y1dequant[QINDEX_RANGE][16]);
     DECLARE_ALIGNED(16, short, Y2dequant[QINDEX_RANGE][16]);
     DECLARE_ALIGNED(16, short, UVdequant[QINDEX_RANGE][16]);
@@ -157,8 +158,6 @@ typedef struct VP8Common
     MODE_INFO *mip; /**< Base of allocated array */
     MODE_INFO *mi;  /**< Corresponds to upper left visible macroblock */
 
-    int copy_buffer_to_gf;     /**< 0 none, 1 Last to GF, 2 ARF to GF */
-    int copy_buffer_to_arf;    /**< 0 none, 1 Last to ARF, 2 GF to ARF */
 
     int ref_frame_sign_bias[MAX_REF_FRAMES]; /**< Two state 0, 1 */