Code clean up.

Further cases of inconsistent naming convention.

Change-Id: Id3411ecec6f01a4c889268a00f0c9fd5a92ea143

diff --git a/vp8/common/arm/neon/recon_neon.c b/vp8/common/arm/neon/recon_neon.c
index a4f6016420cdc77eabd57cbc81f57ba007d354df..510c87dbe59bbf39699b6a697b5440da9579475a 100644 (file)
--- a/vp8/common/arm/neon/recon_neon.c
+++ b/vp8/common/arm/neon/recon_neon.c
@@ -15,14 +15,15 @@
 
 extern void vp8_recon16x16mb_neon(unsigned char *pred_ptr, short *diff_ptr, unsigned char *dst_ptr, int ystride, unsigned char *udst_ptr, unsigned char *vdst_ptr);
 
-void vp8_recon_mb_neon(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
-  unsigned char *pred_ptr = &x->predictor[0];
-  short *diff_ptr = &x->diff[0];
-  unsigned char *dst_ptr = x->dst.y_buffer;
-  unsigned char *udst_ptr = x->dst.u_buffer;
-  unsigned char *vdst_ptr = x->dst.v_buffer;
-  int ystride = x->dst.y_stride;
-  /*int uv_stride = x->dst.uv_stride;*/
+void vp8_recon_mb_neon(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd) {
+  unsigned char *pred_ptr = &xd->predictor[0];
+  short *diff_ptr = &xd->diff[0];
+  unsigned char *dst_ptr = xd->dst.y_buffer;
+  unsigned char *udst_ptr = xd->dst.u_buffer;
+  unsigned char *vdst_ptr = xd->dst.v_buffer;
+  int ystride = xd->dst.y_stride;
+  /*int uv_stride = xd->dst.uv_stride;*/
 
-  vp8_recon16x16mb_neon(pred_ptr, diff_ptr, dst_ptr, ystride, udst_ptr, vdst_ptr);
+  vp8_recon16x16mb_neon(pred_ptr, diff_ptr, dst_ptr, ystride,
+                        udst_ptr, vdst_ptr);
 }

diff --git a/vp8/common/arm/reconintra_arm.c b/vp8/common/arm/reconintra_arm.c
index 814cabd20102d8510d951221e5c281e2a8169086..2a49fda899970383fcbc651cec151c4162e4362f 100644 (file)
--- a/vp8/common/arm/reconintra_arm.c
+++ b/vp8/common/arm/reconintra_arm.c
@@ -24,15 +24,16 @@ extern void vp8_build_intra_predictors_mby_neon_func(
   int Up,
   int Left);
 
-void vp8_build_intra_predictors_mby_neon(MACROBLOCKD *x) {
-  unsigned char *y_buffer = x->dst.y_buffer;
-  unsigned char *ypred_ptr = x->predictor;
-  int y_stride = x->dst.y_stride;
-  int mode = x->mode_info_context->mbmi.mode;
-  int Up = x->up_available;
-  int Left = x->left_available;
-
-  vp8_build_intra_predictors_mby_neon_func(y_buffer, ypred_ptr, y_stride, mode, Up, Left);
+void vp8_build_intra_predictors_mby_neon(MACROBLOCKD *xd) {
+  unsigned char *y_buffer = xd->dst.y_buffer;
+  unsigned char *ypred_ptr = xd->predictor;
+  int y_stride = xd->dst.y_stride;
+  int mode = xd->mode_info_context->mbmi.mode;
+  int Up = xd->up_available;
+  int Left = xd->left_available;
+
+  vp8_build_intra_predictors_mby_neon_func(y_buffer, ypred_ptr,
+                                           y_stride, mode, Up, Left);
 }
 #endif
 
@@ -46,15 +47,16 @@ extern void vp8_build_intra_predictors_mby_s_neon_func(
   int Up,
   int Left);
 
-void vp8_build_intra_predictors_mby_s_neon(MACROBLOCKD *x) {
-  unsigned char *y_buffer = x->dst.y_buffer;
-  unsigned char *ypred_ptr = x->predictor;
-  int y_stride = x->dst.y_stride;
-  int mode = x->mode_info_context->mbmi.mode;
-  int Up = x->up_available;
-  int Left = x->left_available;
+void vp8_build_intra_predictors_mby_s_neon(MACROBLOCKD *xd) {
+  unsigned char *y_buffer = xd->dst.y_buffer;
+  unsigned char *ypred_ptr = xd->predictor;
+  int y_stride = xd->dst.y_stride;
+  int mode = xd->mode_info_context->mbmi.mode;
+  int Up = xd->up_available;
+  int Left = xd->left_available;
 
-  vp8_build_intra_predictors_mby_s_neon_func(y_buffer, ypred_ptr, y_stride, mode, Up, Left);
+  vp8_build_intra_predictors_mby_s_neon_func(y_buffer, ypred_ptr,
+                                             y_stride, mode, Up, Left);
 }
 
 #endif

diff --git a/vp8/common/blockd.h b/vp8/common/blockd.h
index e3fcc739378c428a45a633a5f5cecccf92fb6543..1926f20bdf7a4c5829439039e688b442ab2ede61 100644 (file)
--- a/vp8/common/blockd.h
+++ b/vp8/common/blockd.h
@@ -463,8 +463,8 @@ static void txfm_map(BLOCKD *b, B_PREDICTION_MODE bmode) {
 }
 #endif
 
-extern void vp8_build_block_doffsets(MACROBLOCKD *x);
-extern void vp8_setup_block_dptrs(MACROBLOCKD *x);
+extern void vp8_build_block_doffsets(MACROBLOCKD *xd);
+extern void vp8_setup_block_dptrs(MACROBLOCKD *xd);
 
 static void update_blockd_bmi(MACROBLOCKD *xd) {
   int i;

diff --git a/vp8/common/invtrans.c b/vp8/common/invtrans.c
index a99f298b6df321bebdf3265447719108863c3562..1d63f465a4707db1138995683b3071eef84182b3 100644 (file)
--- a/vp8/common/invtrans.c
+++ b/vp8/common/invtrans.c
@@ -13,21 +13,21 @@
 
 
 
-static void recon_dcblock(MACROBLOCKD *x) {
-  BLOCKD *b = &x->block[24];
+static void recon_dcblock(MACROBLOCKD *xd) {
+  BLOCKD *b = &xd->block[24];
   int i;
 
   for (i = 0; i < 16; i++) {
-    x->block[i].dqcoeff[0] = b->diff[i];
+    xd->block[i].dqcoeff[0] = b->diff[i];
   }
 
 }
-static void recon_dcblock_8x8(MACROBLOCKD *x) {
-  BLOCKD *b = &x->block[24]; // for coeff 0, 2, 8, 10
-  x->block[0].dqcoeff[0] = b->diff[0];
-  x->block[4].dqcoeff[0] = b->diff[1];
-  x->block[8].dqcoeff[0] = b->diff[4];
-  x->block[12].dqcoeff[0] = b->diff[8];
+static void recon_dcblock_8x8(MACROBLOCKD *xd) {
+  BLOCKD *b = &xd->block[24]; // for coeff 0, 2, 8, 10
+  xd->block[0].dqcoeff[0] = b->diff[0];
+  xd->block[4].dqcoeff[0] = b->diff[1];
+  xd->block[8].dqcoeff[0] = b->diff[4];
+  xd->block[12].dqcoeff[0] = b->diff[8];
 
 }
 
@@ -45,24 +45,28 @@ void vp8_inverse_transform_b(const vp8_idct_rtcd_vtable_t *rtcd, BLOCKD *b, int
 }
 
 
-void vp8_inverse_transform_mby(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
+void vp8_inverse_transform_mby(const vp8_idct_rtcd_vtable_t *rtcd,
+                               MACROBLOCKD *xd) {
   int i;
+  BLOCKD *blockd = xd->block;
 
   /* do 2nd order transform on the dc block */
-  IDCT_INVOKE(rtcd, iwalsh16)(x->block[24].dqcoeff, x->block[24].diff);
+  IDCT_INVOKE(rtcd, iwalsh16)(blockd[24].dqcoeff, blockd[24].diff);
 
-  recon_dcblock(x);
+  recon_dcblock(xd);
 
   for (i = 0; i < 16; i++) {
-    vp8_inverse_transform_b(rtcd, &x->block[i], 32);
+    vp8_inverse_transform_b(rtcd, &blockd[i], 32);
   }
 
 }
-void vp8_inverse_transform_mbuv(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
+void vp8_inverse_transform_mbuv(const vp8_idct_rtcd_vtable_t *rtcd,
+                                MACROBLOCKD *xd) {
   int i;
+  BLOCKD *blockd = xd->block;
 
   for (i = 16; i < 24; i++) {
-    vp8_inverse_transform_b(rtcd, &x->block[i], 16);
+    vp8_inverse_transform_b(rtcd, &blockd[i], 16);
   }
 
 }

diff --git a/vp8/common/invtrans.h b/vp8/common/invtrans.h
index 877032f88917c505c57e997e6df24d7deafa3423..76258d435dd3bf7d2580e9a0ed4f71a36559ce65 100644 (file)
--- a/vp8/common/invtrans.h
+++ b/vp8/common/invtrans.h
@@ -21,21 +21,21 @@ extern void vp8_inverse_htransform_b(const vp8_idct_rtcd_vtable_t *rtcd, BLOCKD
 #endif
 
 extern void vp8_inverse_transform_b(const vp8_idct_rtcd_vtable_t *rtcd, BLOCKD *b, int pitch);
-extern void vp8_inverse_transform_mb(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mby(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mbuv(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
+extern void vp8_inverse_transform_mb(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mby(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mbuv(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
 
 extern void vp8_inverse_transform_b_8x8(const vp8_idct_rtcd_vtable_t *rtcd, short *input_dqcoeff, short *output_coeff, int pitch);
-extern void vp8_inverse_transform_mb_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mby_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mbuv_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
+extern void vp8_inverse_transform_mb_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mby_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mbuv_8x8(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
 
 #if CONFIG_TX16X16
 extern void vp8_inverse_transform_b_16x16(const vp8_idct_rtcd_vtable_t *rtcd,
                                           short *input_dqcoeff, short *output_coeff,
                                           int pitch);
-extern void vp8_inverse_transform_mb_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mby_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
-extern void vp8_inverse_transform_mbuv_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
+extern void vp8_inverse_transform_mb_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mby_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
+extern void vp8_inverse_transform_mbuv_16x16(const vp8_idct_rtcd_vtable_t *rtcd, MACROBLOCKD *xd);
 #endif
 #endif

diff --git a/vp8/common/recon.c b/vp8/common/recon.c
index 943faeef29731dc0fd85018ae4c7d87421e772e4..8fc320863b85e2d375a63e699558aa11c1a97c0c 100644 (file)
--- a/vp8/common/recon.c
+++ b/vp8/common/recon.c
@@ -124,36 +124,36 @@ void vp8_recon2b_c
   }
 }
 
-void vp8_recon_mby_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
+void vp8_recon_mby_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd) {
 #if ARCH_ARM
-  BLOCKD *b = &x->block[0];
+  BLOCKD *b = &xd->block[0];
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
 
-  /*b = &x->block[4];*/
+  /*b = &xd->block[4];*/
   b += 4;
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
 
-  /*b = &x->block[8];*/
+  /*b = &xd->block[8];*/
   b += 4;
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
 
-  /*b = &x->block[12];*/
+  /*b = &xd->block[12];*/
   b += 4;
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
 #else
   int i;
 
   for (i = 0; i < 16; i += 4) {
-    BLOCKD *b = &x->block[i];
+    BLOCKD *b = &xd->block[i];
 
     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
 #endif
 }
 
-void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
+void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *xd) {
 #if ARCH_ARM
-  BLOCKD *b = &x->block[0];
+  BLOCKD *b = &xd->block[0];
 
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   b += 4;
@@ -164,7 +164,7 @@ void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
   RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   b += 4;
 
-  /*b = &x->block[16];*/
+  /*b = &xd->block[16];*/
 
   RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   b++;
@@ -180,13 +180,13 @@ void vp8_recon_mb_c(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x) {
   int i;
 
   for (i = 0; i < 16; i += 4) {
-    BLOCKD *b = &x->block[i];
+    BLOCKD *b = &xd->block[i];
 
     RECON_INVOKE(rtcd, recon4)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }
 
   for (i = 16; i < 24; i += 2) {
-    BLOCKD *b = &x->block[i];
+    BLOCKD *b = &xd->block[i];
 
     RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
   }

diff --git a/vp8/common/recon.h b/vp8/common/recon.h
index 665fec3c4cf5b34a734fc291203ac75d447ea284..2626a218dddefb52966b4b1af7d015edc89ee8c9 100644 (file)
--- a/vp8/common/recon.h
+++ b/vp8/common/recon.h
@@ -21,10 +21,10 @@
   void sym(unsigned char *pred, short *diff, unsigned char *dst, int pitch)
 
 #define prototype_recon_macroblock(sym) \
-  void sym(const struct vp8_recon_rtcd_vtable *rtcd, MACROBLOCKD *x)
+  void sym(const struct vp8_recon_rtcd_vtable *rtcd, MACROBLOCKD *xd)
 
 #define prototype_build_intra_predictors(sym) \
-  void sym(MACROBLOCKD *x)
+  void sym(MACROBLOCKD *xd)
 
 #define prototype_intra4x4_predict(sym) \
   void sym(BLOCKD *x, int b_mode, unsigned char *predictor)
@@ -244,5 +244,6 @@ typedef struct vp8_recon_rtcd_vtable {
 #define RECON_INVOKE(ctx,fn) vp8_recon_##fn
 #endif
 
-void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x);
+void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd,
+                          MACROBLOCKD *xd);
 #endif

diff --git a/vp8/common/reconinter.c b/vp8/common/reconinter.c
index fd3a0022b6452620e2e80df7dc92ab8deb0bae5a..0d82db78475b566cb7cf54c3185cf0a3c653e0e6 100644 (file)
--- a/vp8/common/reconinter.c
+++ b/vp8/common/reconinter.c
@@ -295,7 +295,7 @@ void vp8_build_2nd_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf
   }
 }
 
-static void build_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
+static void build_inter_predictors4b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
   unsigned char *ptr_base;
   unsigned char *ptr;
   unsigned char *pred_ptr = d->predictor;
@@ -303,12 +303,15 @@ static void build_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
 
   ptr_base = *(d->base_pre);
   mv.as_int = d->bmi.as_mv.first.as_int;
-  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride + (mv.as_mv.col >> 3);
+  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
+        (mv.as_mv.col >> 3);
 
   if (mv.as_mv.row & 7 || mv.as_mv.col & 7) {
-    x->subpixel_predict8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1, (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
+    xd->subpixel_predict8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
+                            (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    RECON_INVOKE(&x->rtcd->recon, copy8x8)(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x8)
+      (ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 
@@ -318,7 +321,8 @@ static void build_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
  * come from an earlier call to build_inter_predictors_4b()) with the
  * predictor of the second reference frame / motion vector.
  */
-static void build_2nd_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
+static void build_2nd_inter_predictors4b(MACROBLOCKD *xd,
+                                         BLOCKD *d, int pitch) {
   unsigned char *ptr_base;
   unsigned char *ptr;
   unsigned char *pred_ptr = d->predictor;
@@ -326,16 +330,19 @@ static void build_2nd_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
 
   ptr_base = *(d->base_second_pre);
   mv.as_int = d->bmi.as_mv.second.as_int;
-  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride + (mv.as_mv.col >> 3);
+  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
+        (mv.as_mv.col >> 3);
 
   if (mv.as_mv.row & 7 || mv.as_mv.col & 7) {
-    x->subpixel_predict_avg8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1, (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
+    xd->subpixel_predict_avg8x8(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
+                               (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    RECON_INVOKE(&x->rtcd->recon, avg8x8)(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, avg8x8)
+                (ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 
-static void build_inter_predictors2b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
+static void build_inter_predictors2b(MACROBLOCKD *xd, BLOCKD *d, int pitch) {
   unsigned char *ptr_base;
   unsigned char *ptr;
   unsigned char *pred_ptr = d->predictor;
@@ -343,12 +350,14 @@ static void build_inter_predictors2b(MACROBLOCKD *x, BLOCKD *d, int pitch) {
 
   ptr_base = *(d->base_pre);
   mv.as_int = d->bmi.as_mv.first.as_int;
-  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride + (mv.as_mv.col >> 3);
+  ptr = ptr_base + d->pre + (mv.as_mv.row >> 3) * d->pre_stride +
+        (mv.as_mv.col >> 3);
 
   if (mv.as_mv.row & 7 || mv.as_mv.col & 7) {
-    x->subpixel_predict8x4(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1, (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
+    xd->subpixel_predict8x4(ptr, d->pre_stride, (mv.as_mv.col & 7) << 1,
+                           (mv.as_mv.row & 7) << 1, pred_ptr, pitch);
   } else {
-    RECON_INVOKE(&x->rtcd->recon, copy8x4)(ptr, d->pre_stride, pred_ptr, pitch);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x4)(ptr, d->pre_stride, pred_ptr, pitch);
   }
 }
 

diff --git a/vp8/common/reconinter.h b/vp8/common/reconinter.h
index 2340ccd9db5fc061579707fd8e17c50dda6bdd19..48d95fff261bf2e0740e0853ba6925ffd65d29ca 100644 (file)
--- a/vp8/common/reconinter.h
+++ b/vp8/common/reconinter.h
@@ -16,40 +16,44 @@
 #include "onyxc_int.h"
 #endif
 
-extern void vp8_build_1st_inter16x16_predictors_mby(MACROBLOCKD *x,
+extern void vp8_build_1st_inter16x16_predictors_mby(MACROBLOCKD *xd,
                                                     unsigned char *dst_y,
                                                     int dst_ystride);
-extern void vp8_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *x,
+extern void vp8_build_1st_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
                                                      unsigned char *dst_u,
                                                      unsigned char *dst_v,
                                                      int dst_uvstride);
-extern void vp8_build_1st_inter16x16_predictors_mb(MACROBLOCKD *x,
+extern void vp8_build_1st_inter16x16_predictors_mb(MACROBLOCKD *xd,
                                                    unsigned char *dst_y,
                                                    unsigned char *dst_u,
                                                    unsigned char *dst_v,
                                                    int dst_ystride,
                                                    int dst_uvstride);
 
-extern void vp8_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *x,
+extern void vp8_build_2nd_inter16x16_predictors_mby(MACROBLOCKD *xd,
                                                     unsigned char *dst_y,
                                                     int dst_ystride);
-extern void vp8_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *x,
+extern void vp8_build_2nd_inter16x16_predictors_mbuv(MACROBLOCKD *xd,
                                                      unsigned char *dst_u,
                                                      unsigned char *dst_v,
                                                      int dst_uvstride);
-extern void vp8_build_2nd_inter16x16_predictors_mb(MACROBLOCKD *x,
+extern void vp8_build_2nd_inter16x16_predictors_mb(MACROBLOCKD *xd,
                                                    unsigned char *dst_y,
                                                    unsigned char *dst_u,
                                                    unsigned char *dst_v,
                                                    int dst_ystride,
                                                    int dst_uvstride);
 
-extern void vp8_build_inter_predictors_mb(MACROBLOCKD *x);
+extern void vp8_build_inter_predictors_mb(MACROBLOCKD *xd);
 
-extern void vp8_build_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf);
-extern void vp8_build_2nd_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf);
+extern void vp8_build_inter_predictors_b(BLOCKD *d, int pitch,
+                                         vp8_subpix_fn_t sppf);
+extern void vp8_build_2nd_inter_predictors_b(BLOCKD *d, int pitch,
+                                             vp8_subpix_fn_t sppf);
 
-extern void vp8_build_inter4x4_predictors_mbuv(MACROBLOCKD *x);
-extern void vp8_setup_interp_filters(MACROBLOCKD *x, INTERPOLATIONFILTERTYPE filter, VP8_COMMON *cm);
+extern void vp8_build_inter4x4_predictors_mbuv(MACROBLOCKD *xd);
+extern void vp8_setup_interp_filters(MACROBLOCKD *xd,
+                                     INTERPOLATIONFILTERTYPE filter,
+                                     VP8_COMMON *cm);
 
 #endif

diff --git a/vp8/common/reconintra.c b/vp8/common/reconintra.c
index 8cbbcf2b6d2d308d8a3917f06fa820e1bd370df0..96bebc5be2ff8365b0addb3e05618466a9344184 100644 (file)
--- a/vp8/common/reconintra.c
+++ b/vp8/common/reconintra.c
@@ -14,8 +14,8 @@
 #include "reconintra.h"
 #include "vpx_mem/vpx_mem.h"
 
-/* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
- * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
+/* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *xd)
+ * and vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *xd).
  */
 
 void d27_predictor(unsigned char *ypred_ptr, int y_stride, int n,

diff --git a/vp8/common/reconintra.h b/vp8/common/reconintra.h
index 13143438661eb40f29fabc90d5c4503c5468e8bc..6276340db1d95c8f5fde997d43d7d6feb1500a46 100644 (file)
--- a/vp8/common/reconintra.h
+++ b/vp8/common/reconintra.h
@@ -26,6 +26,6 @@ void d27_predictor(unsigned char *ypred_ptr, int y_stride, int n,
 void d64_predictor(unsigned char *ypred_ptr, int y_stride, int n,
                    unsigned char *yabove_row, unsigned char *yleft_col);
 
-extern void init_intra_left_above_pixels(MACROBLOCKD *x);
+extern void init_intra_left_above_pixels(MACROBLOCKD *xd);
 
 #endif

diff --git a/vp8/common/reconintra4x4.c b/vp8/common/reconintra4x4.c
index c7da1c5582c237472b4820a7666ac61cdace782a..69faab09d656aa1bf6f340bbb9337990e2be8fc1 100644 (file)
--- a/vp8/common/reconintra4x4.c
+++ b/vp8/common/reconintra4x4.c
@@ -296,13 +296,17 @@ void vp8_comp_intra4x4_predict(BLOCKD *x,
 /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
  * to the right prediction have filled in pixels to use.
  */
-void vp8_intra_prediction_down_copy(MACROBLOCKD *x) {
-  unsigned char *above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
+void vp8_intra_prediction_down_copy(MACROBLOCKD *xd) {
+  unsigned char *above_right = *(xd->block[0].base_dst) + xd->block[0].dst -
+                               xd->block[0].dst_stride + 16;
 
   unsigned int *src_ptr = (unsigned int *)above_right;
-  unsigned int *dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
-  unsigned int *dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
-  unsigned int *dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);
+  unsigned int *dst_ptr0 =
+    (unsigned int *)(above_right + 4 * xd->block[0].dst_stride);
+  unsigned int *dst_ptr1 =
+    (unsigned int *)(above_right + 8 * xd->block[0].dst_stride);
+  unsigned int *dst_ptr2 =
+    (unsigned int *)(above_right + 12 * xd->block[0].dst_stride);
 
   *dst_ptr0 = *src_ptr;
   *dst_ptr1 = *src_ptr;

diff --git a/vp8/common/reconintra4x4.h b/vp8/common/reconintra4x4.h
index 6ac2b71376dc21a1e96f81ba3c32882c2d9f55c9..a8cdea47c9ec9b3a9a3ed829796aa50f0a189207 100644 (file)
--- a/vp8/common/reconintra4x4.h
+++ b/vp8/common/reconintra4x4.h
@@ -12,6 +12,6 @@
 #ifndef __INC_RECONINTRA4x4_H
 #define __INC_RECONINTRA4x4_H
 
-extern void vp8_intra_prediction_down_copy(MACROBLOCKD *x);
+extern void vp8_intra_prediction_down_copy(MACROBLOCKD *xd);
 
 #endif

diff --git a/vp8/common/x86/recon_wrapper_sse2.c b/vp8/common/x86/recon_wrapper_sse2.c
index 57ba3fc7e17b6d4f9d75e2c9a32370ec1f24def7..e304d055b27c6345dd3ff488ae198bcc521ed544 100644 (file)
--- a/vp8/common/x86/recon_wrapper_sse2.c
+++ b/vp8/common/x86/recon_wrapper_sse2.c
@@ -28,15 +28,15 @@ extern build_intra_predictors_mbuv_prototype(vp8_intra_pred_uv_ve_mmx);
 extern build_intra_predictors_mbuv_prototype(vp8_intra_pred_uv_tm_sse2);
 extern build_intra_predictors_mbuv_prototype(vp8_intra_pred_uv_tm_ssse3);
 
-static void vp8_build_intra_predictors_mbuv_x86(MACROBLOCKD *x,
+static void vp8_build_intra_predictors_mbuv_x86(MACROBLOCKD *xd,
                                                 unsigned char *dst_u,
                                                 unsigned char *dst_v,
                                                 int dst_stride,
                                                 build_intra_predictors_mbuv_fn_t tm_func,
                                                 build_intra_predictors_mbuv_fn_t ho_func) {
-  int mode = x->mode_info_context->mbmi.uv_mode;
+  int mode = xd->mode_info_context->mbmi.uv_mode;
   build_intra_predictors_mbuv_fn_t fn;
-  int src_stride = x->dst.uv_stride;
+  int src_stride = xd->dst.uv_stride;
 
   switch (mode) {
     case  V_PRED:
@@ -49,15 +49,15 @@ static void vp8_build_intra_predictors_mbuv_x86(MACROBLOCKD *x,
       fn = tm_func;
       break;
     case DC_PRED:
-      if (x->up_available) {
-        if (x->left_available) {
+      if (xd->up_available) {
+        if (xd->left_available) {
           fn = vp8_intra_pred_uv_dc_mmx2;
           break;
         } else {
           fn = vp8_intra_pred_uv_dctop_mmx2;
           break;
         }
-      } else if (x->left_available) {
+      } else if (xd->left_available) {
         fn = vp8_intra_pred_uv_dcleft_mmx2;
         break;
       } else {
@@ -69,34 +69,34 @@ static void vp8_build_intra_predictors_mbuv_x86(MACROBLOCKD *x,
       return;
   }
 
-  fn(dst_u, dst_stride, x->dst.u_buffer, src_stride);
-  fn(dst_v, dst_stride, x->dst.v_buffer, src_stride);
+  fn(dst_u, dst_stride, xd->dst.u_buffer, src_stride);
+  fn(dst_v, dst_stride, xd->dst.v_buffer, src_stride);
 }
 
-void vp8_build_intra_predictors_mbuv_sse2(MACROBLOCKD *x) {
-  vp8_build_intra_predictors_mbuv_x86(x, &x->predictor[256],
-                                      &x->predictor[320], 8,
+void vp8_build_intra_predictors_mbuv_sse2(MACROBLOCKD *xd) {
+  vp8_build_intra_predictors_mbuv_x86(xd, &xd->predictor[256],
+                                      &xd->predictor[320], 8,
                                       vp8_intra_pred_uv_tm_sse2,
                                       vp8_intra_pred_uv_ho_mmx2);
 }
 
-void vp8_build_intra_predictors_mbuv_ssse3(MACROBLOCKD *x) {
-  vp8_build_intra_predictors_mbuv_x86(x, &x->predictor[256],
-                                      &x->predictor[320], 8,
+void vp8_build_intra_predictors_mbuv_ssse3(MACROBLOCKD *xd) {
+  vp8_build_intra_predictors_mbuv_x86(xd, &xd->predictor[256],
+                                      &xd->predictor[320], 8,
                                       vp8_intra_pred_uv_tm_ssse3,
                                       vp8_intra_pred_uv_ho_ssse3);
 }
 
-void vp8_build_intra_predictors_mbuv_s_sse2(MACROBLOCKD *x) {
-  vp8_build_intra_predictors_mbuv_x86(x, x->dst.u_buffer,
-                                      x->dst.v_buffer, x->dst.uv_stride,
+void vp8_build_intra_predictors_mbuv_s_sse2(MACROBLOCKD *xd) {
+  vp8_build_intra_predictors_mbuv_x86(xd, xd->dst.u_buffer,
+                                      xd->dst.v_buffer, xd->dst.uv_stride,
                                       vp8_intra_pred_uv_tm_sse2,
                                       vp8_intra_pred_uv_ho_mmx2);
 }
 
-void vp8_build_intra_predictors_mbuv_s_ssse3(MACROBLOCKD *x) {
-  vp8_build_intra_predictors_mbuv_x86(x, x->dst.u_buffer,
-                                      x->dst.v_buffer, x->dst.uv_stride,
+void vp8_build_intra_predictors_mbuv_s_ssse3(MACROBLOCKD *xd) {
+  vp8_build_intra_predictors_mbuv_x86(xd, xd->dst.u_buffer,
+                                      xd->dst.v_buffer, xd->dst.uv_stride,
                                       vp8_intra_pred_uv_tm_ssse3,
                                       vp8_intra_pred_uv_ho_ssse3);
 }

diff --git a/vp8/decoder/decodemv.c b/vp8/decoder/decodemv.c
index 46ef3fecd39fbc703d64d21dca08fd52b50640cf..94826ef6c6941760c45ab5ede76d50f76faecd7a 100644 (file)
--- a/vp8/decoder/decodemv.c
+++ b/vp8/decoder/decodemv.c
@@ -61,14 +61,17 @@ static int vp8_read_uv_mode(vp8_reader *bc, const vp8_prob *p) {
 
 // This function reads the current macro block's segnent id from the bitstream
 // It should only be called if a segment map update is indicated.
-static void vp8_read_mb_segid(vp8_reader *r, MB_MODE_INFO *mi, MACROBLOCKD *x) {
+static void vp8_read_mb_segid(vp8_reader *r, MB_MODE_INFO *mi,
+                              MACROBLOCKD *xd) {
   /* Is segmentation enabled */
-  if (x->segmentation_enabled && x->update_mb_segmentation_map) {
+  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
     /* If so then read the segment id. */
-    if (vp8_read(r, x->mb_segment_tree_probs[0]))
-      mi->segment_id = (unsigned char)(2 + vp8_read(r, x->mb_segment_tree_probs[2]));
+    if (vp8_read(r, xd->mb_segment_tree_probs[0]))
+      mi->segment_id =
+        (unsigned char)(2 + vp8_read(r, xd->mb_segment_tree_probs[2]));
     else
-      mi->segment_id = (unsigned char)(vp8_read(r, x->mb_segment_tree_probs[1]));
+      mi->segment_id =
+        (unsigned char)(vp8_read(r, xd->mb_segment_tree_probs[1]));
   }
 }
 

diff --git a/vp8/decoder/detokenize.h b/vp8/decoder/detokenize.h
index 05550cec724a15ea16cee3cd7e8df477a217ff2f..918706f6576ca4d5461fa0f10253e8edabb0b650 100644 (file)
--- a/vp8/decoder/detokenize.h
+++ b/vp8/decoder/detokenize.h
@@ -14,7 +14,7 @@
 
 #include "onyxd_int.h"
 
-void vp8_reset_mb_tokens_context(MACROBLOCKD *x);
+void vp8_reset_mb_tokens_context(MACROBLOCKD *xd);
 int vp8_decode_mb_tokens(VP8D_COMP *, MACROBLOCKD *);
 int vp8_decode_mb_tokens_8x8(VP8D_COMP *, MACROBLOCKD *);
 #if CONFIG_TX16X16

diff --git a/vp8/decoder/reconintra_mt.c b/vp8/decoder/reconintra_mt.c
index da6816d568d1ea92293aef346fb04a8f103cd120..f447cb189d2226696d688017d9d85ac18d8ce919 100644 (file)
--- a/vp8/decoder/reconintra_mt.c
+++ b/vp8/decoder/reconintra_mt.c
@@ -15,33 +15,34 @@
 #include "vpx_mem/vpx_mem.h"
 #include "onyxd_int.h"
 
-/* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
- * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
+/* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *xd)
+ * and vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *xd).
  */
 
-void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col) {
-  unsigned char *yabove_row;    /* = x->dst.y_buffer - x->dst.y_stride; */
+void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *xd,
+                                      int mb_row, int mb_col) {
+  unsigned char *yabove_row;    /* = xd->dst.y_buffer - xd->dst.y_stride; */
   unsigned char *yleft_col;
   unsigned char yleft_buf[16];
   unsigned char ytop_left;      /* = yabove_row[-1]; */
-  unsigned char *ypred_ptr = x->predictor;
+  unsigned char *ypred_ptr = xd->predictor;
   int r, c, i;
 
   if (pbi->common.filter_level) {
     yabove_row = pbi->mt_yabove_row[mb_row] + mb_col * 16 + 32;
     yleft_col = pbi->mt_yleft_col[mb_row];
   } else {
-    yabove_row = x->dst.y_buffer - x->dst.y_stride;
+    yabove_row = xd->dst.y_buffer - xd->dst.y_stride;
 
     for (i = 0; i < 16; i++)
-      yleft_buf[i] = x->dst.y_buffer [i * x->dst.y_stride - 1];
+      yleft_buf[i] = xd->dst.y_buffer [i * xd->dst.y_stride - 1];
     yleft_col = yleft_buf;
   }
 
   ytop_left = yabove_row[-1];
 
   /* for Y */
-  switch (x->mode_info_context->mbmi.mode) {
+  switch (xd->mode_info_context->mbmi.mode) {
     case DC_PRED: {
       int expected_dc;
       int i;
@@ -49,14 +50,14 @@ void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row
       int average = 0;
 
 
-      if (x->up_available || x->left_available) {
-        if (x->up_available) {
+      if (xd->up_available || xd->left_available) {
+        if (xd->up_available) {
           for (i = 0; i < 16; i++) {
             average += yabove_row[i];
           }
         }
 
-        if (x->left_available) {
+        if (xd->left_available) {
 
           for (i = 0; i < 16; i++) {
             average += yleft_col[i];
@@ -66,7 +67,7 @@ void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row
 
 
 
-        shift = 3 + x->up_available + x->left_available;
+        shift = 3 + xd->up_available + xd->left_available;
         expected_dc = (average + (1 << (shift - 1))) >> shift;
       } else {
         expected_dc = 128;
@@ -128,32 +129,33 @@ void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row
   }
 }
 
-void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col) {
-  unsigned char *yabove_row;    /* = x->dst.y_buffer - x->dst.y_stride; */
+void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *xd,
+                                        int mb_row, int mb_col) {
+  unsigned char *yabove_row;    /* = xd->dst.y_buffer - xd->dst.y_stride; */
   unsigned char *yleft_col;
   unsigned char yleft_buf[16];
   unsigned char ytop_left;      /* = yabove_row[-1]; */
-  unsigned char *ypred_ptr = x->predictor;
+  unsigned char *ypred_ptr = xd->predictor;
   int r, c, i;
 
-  int y_stride = x->dst.y_stride;
-  ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
+  int y_stride = xd->dst.y_stride;
+  ypred_ptr = xd->dst.y_buffer; /*xd->predictor;*/
 
   if (pbi->common.filter_level) {
     yabove_row = pbi->mt_yabove_row[mb_row] + mb_col * 16 + 32;
     yleft_col = pbi->mt_yleft_col[mb_row];
   } else {
-    yabove_row = x->dst.y_buffer - x->dst.y_stride;
+    yabove_row = xd->dst.y_buffer - xd->dst.y_stride;
 
     for (i = 0; i < 16; i++)
-      yleft_buf[i] = x->dst.y_buffer [i * x->dst.y_stride - 1];
+      yleft_buf[i] = xd->dst.y_buffer [i * xd->dst.y_stride - 1];
     yleft_col = yleft_buf;
   }
 
   ytop_left = yabove_row[-1];
 
   /* for Y */
-  switch (x->mode_info_context->mbmi.mode) {
+  switch (xd->mode_info_context->mbmi.mode) {
     case DC_PRED: {
       int expected_dc;
       int i;
@@ -161,14 +163,14 @@ void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_r
       int average = 0;
 
 
-      if (x->up_available || x->left_available) {
-        if (x->up_available) {
+      if (xd->up_available || xd->left_available) {
+        if (xd->up_available) {
           for (i = 0; i < 16; i++) {
             average += yabove_row[i];
           }
         }
 
-        if (x->left_available) {
+        if (xd->left_available) {
 
           for (i = 0; i < 16; i++) {
             average += yleft_col[i];
@@ -178,7 +180,7 @@ void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_r
 
 
 
-        shift = 3 + x->up_available + x->left_available;
+        shift = 3 + xd->up_available + xd->left_available;
         expected_dc = (average + (1 << (shift - 1))) >> shift;
       } else {
         expected_dc = 128;
@@ -244,17 +246,18 @@ void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_r
   }
 }
 
-void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col) {
-  unsigned char *uabove_row;   /* = x->dst.u_buffer - x->dst.uv_stride; */
+void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *xd,
+                                       int mb_row, int mb_col) {
+  unsigned char *uabove_row;   /* = xd->dst.u_buffer - xd->dst.uv_stride; */
   unsigned char *uleft_col;    /*[16];*/
   unsigned char uleft_buf[8];
   unsigned char utop_left;     /* = uabove_row[-1]; */
-  unsigned char *vabove_row;   /* = x->dst.v_buffer - x->dst.uv_stride; */
+  unsigned char *vabove_row;   /* = xd->dst.v_buffer - xd->dst.uv_stride; */
   unsigned char *vleft_col;    /*[20];*/
   unsigned char vleft_buf[8];
   unsigned char vtop_left;     /* = vabove_row[-1]; */
-  unsigned char *upred_ptr = &x->predictor[256];
-  unsigned char *vpred_ptr = &x->predictor[320];
+  unsigned char *upred_ptr = &xd->predictor[256];
+  unsigned char *vpred_ptr = &xd->predictor[320];
   int i, j;
 
   if (pbi->common.filter_level) {
@@ -263,12 +266,12 @@ void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_ro
     uleft_col = pbi->mt_uleft_col[mb_row];
     vleft_col = pbi->mt_vleft_col[mb_row];
   } else {
-    uabove_row = x->dst.u_buffer - x->dst.uv_stride;
-    vabove_row = x->dst.v_buffer - x->dst.uv_stride;
+    uabove_row = xd->dst.u_buffer - xd->dst.uv_stride;
+    vabove_row = xd->dst.v_buffer - xd->dst.uv_stride;
 
     for (i = 0; i < 8; i++) {
-      uleft_buf[i] = x->dst.u_buffer [i * x->dst.uv_stride - 1];
-      vleft_buf[i] = x->dst.v_buffer [i * x->dst.uv_stride - 1];
+      uleft_buf[i] = xd->dst.u_buffer [i * xd->dst.uv_stride - 1];
+      vleft_buf[i] = xd->dst.v_buffer [i * xd->dst.uv_stride - 1];
     }
     uleft_col = uleft_buf;
     vleft_col = vleft_buf;
@@ -276,7 +279,7 @@ void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_ro
   utop_left = uabove_row[-1];
   vtop_left = vabove_row[-1];
 
-  switch (x->mode_info_context->mbmi.uv_mode) {
+  switch (xd->mode_info_context->mbmi.uv_mode) {
     case DC_PRED: {
       int expected_udc;
       int expected_vdc;
@@ -285,25 +288,25 @@ void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_ro
       int Uaverage = 0;
       int Vaverage = 0;
 
-      if (x->up_available) {
+      if (xd->up_available) {
         for (i = 0; i < 8; i++) {
           Uaverage += uabove_row[i];
           Vaverage += vabove_row[i];
         }
       }
 
-      if (x->left_available) {
+      if (xd->left_available) {
         for (i = 0; i < 8; i++) {
           Uaverage += uleft_col[i];
           Vaverage += vleft_col[i];
         }
       }
 
-      if (!x->up_available && !x->left_available) {
+      if (!xd->up_available && !xd->left_available) {
         expected_udc = 128;
         expected_vdc = 128;
       } else {
-        shift = 2 + x->up_available + x->left_available;
+        shift = 2 + xd->up_available + xd->left_available;
         expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
         expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
       }
@@ -380,18 +383,19 @@ void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_ro
   }
 }
 
-void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col) {
-  unsigned char *uabove_row;  /* = x->dst.u_buffer - x->dst.uv_stride; */
+void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *xd,
+                                         int mb_row, int mb_col) {
+  unsigned char *uabove_row;  /* = xd->dst.u_buffer - xd->dst.uv_stride; */
   unsigned char *uleft_col;   /*[16];*/
   unsigned char uleft_buf[8];
   unsigned char utop_left;    /* = uabove_row[-1]; */
-  unsigned char *vabove_row;  /* = x->dst.v_buffer - x->dst.uv_stride; */
+  unsigned char *vabove_row;  /* = xd->dst.v_buffer - xd->dst.uv_stride; */
   unsigned char *vleft_col;   /*[20];*/
   unsigned char vleft_buf[8];
   unsigned char vtop_left;    /* = vabove_row[-1]; */
-  unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
-  unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
-  int uv_stride = x->dst.uv_stride;
+  unsigned char *upred_ptr = xd->dst.u_buffer; /*&xd->predictor[256];*/
+  unsigned char *vpred_ptr = xd->dst.v_buffer; /*&xd->predictor[320];*/
+  int uv_stride = xd->dst.uv_stride;
   int i, j;
 
   if (pbi->common.filter_level) {
@@ -400,12 +404,12 @@ void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_
     uleft_col = pbi->mt_uleft_col[mb_row];
     vleft_col = pbi->mt_vleft_col[mb_row];
   } else {
-    uabove_row = x->dst.u_buffer - x->dst.uv_stride;
-    vabove_row = x->dst.v_buffer - x->dst.uv_stride;
+    uabove_row = xd->dst.u_buffer - xd->dst.uv_stride;
+    vabove_row = xd->dst.v_buffer - xd->dst.uv_stride;
 
     for (i = 0; i < 8; i++) {
-      uleft_buf[i] = x->dst.u_buffer [i * x->dst.uv_stride - 1];
-      vleft_buf[i] = x->dst.v_buffer [i * x->dst.uv_stride - 1];
+      uleft_buf[i] = xd->dst.u_buffer [i * xd->dst.uv_stride - 1];
+      vleft_buf[i] = xd->dst.v_buffer [i * xd->dst.uv_stride - 1];
     }
     uleft_col = uleft_buf;
     vleft_col = vleft_buf;
@@ -413,7 +417,7 @@ void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_
   utop_left = uabove_row[-1];
   vtop_left = vabove_row[-1];
 
-  switch (x->mode_info_context->mbmi.uv_mode) {
+  switch (xd->mode_info_context->mbmi.uv_mode) {
     case DC_PRED: {
       int expected_udc;
       int expected_vdc;
@@ -422,25 +426,25 @@ void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_
       int Uaverage = 0;
       int Vaverage = 0;
 
-      if (x->up_available) {
+      if (xd->up_available) {
         for (i = 0; i < 8; i++) {
           Uaverage += uabove_row[i];
           Vaverage += vabove_row[i];
         }
       }
 
-      if (x->left_available) {
+      if (xd->left_available) {
         for (i = 0; i < 8; i++) {
           Uaverage += uleft_col[i];
           Vaverage += vleft_col[i];
         }
       }
 
-      if (!x->up_available && !x->left_available) {
+      if (!xd->up_available && !xd->left_available) {
         expected_udc = 128;
         expected_vdc = 128;
       } else {
-        shift = 2 + x->up_available + x->left_available;
+        shift = 2 + xd->up_available + xd->left_available;
         expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
         expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
       }
@@ -531,26 +535,26 @@ void vp8mt_predict_intra4x4(VP8D_COMP *pbi,
                             int num) {
   int i, r, c;
 
-  unsigned char *Above;   /* = *(x->base_dst) + x->dst - x->dst_stride; */
+  unsigned char *Above;   /* = *(xd->base_dst) + xd->dst - xd->dst_stride; */
   unsigned char Left[4];
   unsigned char top_left; /* = Above[-1]; */
 
-  BLOCKD *x = &xd->block[num];
+  BLOCKD *blockd = &xd->block[num];
 
   /*Caution: For some b_mode, it needs 8 pixels (4 above + 4 above-right).*/
   if (num < 4 && pbi->common.filter_level)
     Above = pbi->mt_yabove_row[mb_row] + mb_col * 16 + num * 4 + 32;
   else
-    Above = *(x->base_dst) + x->dst - x->dst_stride;
+    Above = *(blockd->base_dst) + blockd->dst - blockd->dst_stride;
 
   if (num % 4 == 0 && pbi->common.filter_level) {
     for (i = 0; i < 4; i++)
       Left[i] = pbi->mt_yleft_col[mb_row][num + i];
   } else {
-    Left[0] = (*(x->base_dst))[x->dst - 1];
-    Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
-    Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
-    Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
+    Left[0] = (*(blockd->base_dst))[blockd->dst - 1];
+    Left[1] = (*(blockd->base_dst))[blockd->dst - 1 + blockd->dst_stride];
+    Left[2] = (*(blockd->base_dst))[blockd->dst - 1 + 2 * blockd->dst_stride];
+    Left[3] = (*(blockd->base_dst))[blockd->dst - 1 + 3 * blockd->dst_stride];
   }
 
   if ((num == 4 || num == 8 || num == 12) && pbi->common.filter_level)
@@ -808,8 +812,11 @@ void vp8mt_predict_intra4x4(VP8D_COMP *pbi,
 /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
  * to the right prediction have filled in pixels to use.
  */
-void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col) {
-  unsigned char *above_right;   /* = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16; */
+void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *xd,
+                                      int mb_row, int mb_col) {
+  unsigned char *above_right;   // = *(xd->block[0].base_dst) +
+                                //     xd->block[0].dst -
+                                //     xd->block[0].dst_stride + 16; */
   unsigned int *src_ptr;
   unsigned int *dst_ptr0;
   unsigned int *dst_ptr1;
@@ -818,15 +825,19 @@ void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row
   if (pbi->common.filter_level)
     above_right = pbi->mt_yabove_row[mb_row] + mb_col * 16 + 32 + 16;
   else
-    above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
+    above_right = *(xd->block[0].base_dst) + xd->block[0].dst -
+                  xd->block[0].dst_stride + 16;
 
   src_ptr = (unsigned int *)above_right;
-  /*dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
-  dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
-  dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);*/
-  dst_ptr0 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 3 * x->block[0].dst_stride);
-  dst_ptr1 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 7 * x->block[0].dst_stride);
-  dst_ptr2 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 11 * x->block[0].dst_stride);
+  /*dst_ptr0 = (unsigned int *)(above_right + 4 * xd->block[0].dst_stride);
+  dst_ptr1 = (unsigned int *)(above_right + 8 * xd->block[0].dst_stride);
+  dst_ptr2 = (unsigned int *)(above_right + 12 * xd->block[0].dst_stride);*/
+  dst_ptr0 = (unsigned int *)(*(xd->block[0].base_dst) + xd->block[0].dst +
+                              16 + 3 * xd->block[0].dst_stride);
+  dst_ptr1 = (unsigned int *)(*(xd->block[0].base_dst) + xd->block[0].dst +
+                              16 + 7 * xd->block[0].dst_stride);
+  dst_ptr2 = (unsigned int *)(*(xd->block[0].base_dst) + xd->block[0].dst +
+                              16 + 11 * xd->block[0].dst_stride);
   *dst_ptr0 = *src_ptr;
   *dst_ptr1 = *src_ptr;
   *dst_ptr2 = *src_ptr;

diff --git a/vp8/encoder/bitstream.c b/vp8/encoder/bitstream.c
index 6a08eb8ba3055c1e440235fe1d2f7bcc3c7fe1e9..76aed7e2d908af7a5f0866b542ca498ce506c2eb 100644 (file)
--- a/vp8/encoder/bitstream.c
+++ b/vp8/encoder/bitstream.c
@@ -138,7 +138,7 @@ static void update_mode(
 }
 
 static void update_mbintra_mode_probs(VP8_COMP *cpi) {
-  VP8_COMMON *const x = & cpi->common;
+  VP8_COMMON *const cm = & cpi->common;
 
   vp8_writer *const w = & cpi->bc;
 
@@ -148,7 +148,7 @@ static void update_mbintra_mode_probs(VP8_COMP *cpi) {
 
     update_mode(
       w, VP8_YMODES, vp8_ymode_encodings, vp8_ymode_tree,
-      Pnew, x->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
+      Pnew, cm->fc.ymode_prob, bct, (unsigned int *)cpi->ymode_count
     );
   }
 }
@@ -569,31 +569,31 @@ static void write_mv_hp
 // This function writes the current macro block's segnment id to the bitstream
 // It should only be called if a segment map update is indicated.
 static void write_mb_segid(vp8_writer *w,
-                           const MB_MODE_INFO *mi, const MACROBLOCKD *x) {
+                           const MB_MODE_INFO *mi, const MACROBLOCKD *xd) {
   // Encode the MB segment id.
-  if (x->segmentation_enabled && x->update_mb_segmentation_map) {
+  if (xd->segmentation_enabled && xd->update_mb_segmentation_map) {
     switch (mi->segment_id) {
       case 0:
-        vp8_write(w, 0, x->mb_segment_tree_probs[0]);
-        vp8_write(w, 0, x->mb_segment_tree_probs[1]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[0]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[1]);
         break;
       case 1:
-        vp8_write(w, 0, x->mb_segment_tree_probs[0]);
-        vp8_write(w, 1, x->mb_segment_tree_probs[1]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[0]);
+        vp8_write(w, 1, xd->mb_segment_tree_probs[1]);
         break;
       case 2:
-        vp8_write(w, 1, x->mb_segment_tree_probs[0]);
-        vp8_write(w, 0, x->mb_segment_tree_probs[2]);
+        vp8_write(w, 1, xd->mb_segment_tree_probs[0]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[2]);
         break;
       case 3:
-        vp8_write(w, 1, x->mb_segment_tree_probs[0]);
-        vp8_write(w, 1, x->mb_segment_tree_probs[2]);
+        vp8_write(w, 1, xd->mb_segment_tree_probs[0]);
+        vp8_write(w, 1, xd->mb_segment_tree_probs[2]);
         break;
 
         // TRAP.. This should not happen
       default:
-        vp8_write(w, 0, x->mb_segment_tree_probs[0]);
-        vp8_write(w, 0, x->mb_segment_tree_probs[1]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[0]);
+        vp8_write(w, 0, xd->mb_segment_tree_probs[1]);
         break;
     }
   }

diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index d3e0e4535d00ec3041810463f1547bc6b774aca5..e58c852a7b5288591efb6f9b38d19b3398327478 100644 (file)
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -47,7 +47,7 @@ int enc_debug = 0;
 int mb_row_debug, mb_col_debug;
 #endif
 
-extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x,
+extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
                          TOKENEXTRA **t, int dry_run);
 
 extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
@@ -1471,7 +1471,7 @@ void vp8cx_encode_intra_macro_block(VP8_COMP *cpi,
 extern int cnt_pm;
 #endif
 
-extern void vp8_fix_contexts(MACROBLOCKD *x);
+extern void vp8_fix_contexts(MACROBLOCKD *xd);
 
 void vp8cx_encode_inter_macroblock (VP8_COMP *cpi, MACROBLOCK *x,
                                     TOKENEXTRA **t, int recon_yoffset,

diff --git a/vp8/encoder/encodeintra.c b/vp8/encoder/encodeintra.c
index 70ef55a1b7786ebf96eb50c01a70a1b1edd7a852..053639b9d8c817fc9ebe2d709a57e0f5f37488ea 100644 (file)
--- a/vp8/encoder/encodeintra.c
+++ b/vp8/encoder/encodeintra.c
@@ -113,9 +113,9 @@ void vp8_encode_intra4x4mby(const VP8_ENCODER_RTCD *rtcd, MACROBLOCK *mb) {
   int i;
 
 #if 0
-  MACROBLOCKD *x = &mb->e_mbd;
+  MACROBLOCKD *xd = &mb->e_mbd;
   // Intra modes requiring top-right MB reconstructed data have been disabled
-  vp8_intra_prediction_down_copy(x);
+  vp8_intra_prediction_down_copy(xd);
 #endif
 
   for (i = 0; i < 16; i++)

diff --git a/vp8/encoder/encodemb.c b/vp8/encoder/encodemb.c
index d137603d1427bc9e58845a73299888fc21faad79..e03b47e2ced1c2b42fef23f32146c0be3d91d020 100644 (file)
--- a/vp8/encoder/encodemb.c
+++ b/vp8/encoder/encodemb.c
@@ -607,11 +607,11 @@ fall between -65 and +65.
 **************************************************************************/
 #define SUM_2ND_COEFF_THRESH 65
 
-static void check_reset_2nd_coeffs(MACROBLOCKD *x, int type,
+static void check_reset_2nd_coeffs(MACROBLOCKD *xd, int type,
                                    ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l) {
   int sum = 0;
   int i;
-  BLOCKD *bd = &x->block[24];
+  BLOCKD *bd = &xd->block[24];
   if (bd->dequant[0] >= SUM_2ND_COEFF_THRESH
       && bd->dequant[1] >= SUM_2ND_COEFF_THRESH)
     return;
@@ -634,10 +634,10 @@ static void check_reset_2nd_coeffs(MACROBLOCKD *x, int type,
   }
 }
 #define SUM_2ND_COEFF_THRESH_8X8 32
-static void check_reset_8x8_2nd_coeffs(MACROBLOCKD *x, int type,
+static void check_reset_8x8_2nd_coeffs(MACROBLOCKD *xd, int type,
                                        ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l) {
   int sum = 0;
-  BLOCKD *bd = &x->block[24];
+  BLOCKD *bd = &xd->block[24];
   int coef;
 
   coef = bd->dqcoeff[0];

diff --git a/vp8/encoder/temporal_filter.c b/vp8/encoder/temporal_filter.c
index 0e86a0ca42c0b56e5797c9fc96b254e61a2a0db3..035eebb986f68bc104dbd809d002c702351d9558 100644 (file)
--- a/vp8/encoder/temporal_filter.c
+++ b/vp8/encoder/temporal_filter.c
@@ -39,7 +39,7 @@
 
 static void vp8_temporal_filter_predictors_mb_c
 (
-  MACROBLOCKD *x,
+  MACROBLOCKD *xd,
   unsigned char *y_mb_ptr,
   unsigned char *u_mb_ptr,
   unsigned char *v_mb_ptr,
@@ -56,10 +56,10 @@ static void vp8_temporal_filter_predictors_mb_c
   yptr = y_mb_ptr + (mv_row >> 3) * stride + (mv_col >> 3);
 
   if ((mv_row | mv_col) & 7) {
-    x->subpixel_predict16x16(yptr, stride,
+    xd->subpixel_predict16x16(yptr, stride,
                              (mv_col & 7) << 1, (mv_row & 7) << 1, &pred[0], 16);
   } else {
-    RECON_INVOKE(&x->rtcd->recon, copy16x16)(yptr, stride, &pred[0], 16);
+    RECON_INVOKE(&xd->rtcd->recon, copy16x16)(yptr, stride, &pred[0], 16);
   }
 
   // U & V
@@ -73,14 +73,14 @@ static void vp8_temporal_filter_predictors_mb_c
   vptr = v_mb_ptr + offset;
 
   if ((omv_row | omv_col) & 15) {
-    x->subpixel_predict8x8(uptr, stride,
+    xd->subpixel_predict8x8(uptr, stride,
                            (omv_col & 15), (omv_row & 15), &pred[256], 8);
-    x->subpixel_predict8x8(vptr, stride,
+    xd->subpixel_predict8x8(vptr, stride,
                            (omv_col & 15), (omv_row & 15), &pred[320], 8);
   }
   else {
-    RECON_INVOKE(&x->rtcd->recon, copy8x8)(uptr, stride, &pred[256], 8);
-    RECON_INVOKE(&x->rtcd->recon, copy8x8)(vptr, stride, &pred[320], 8);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x8)(uptr, stride, &pred[256], 8);
+    RECON_INVOKE(&xd->rtcd->recon, copy8x8)(vptr, stride, &pred[320], 8);
   }
 }
 void vp8_temporal_filter_apply_c

diff --git a/vp8/encoder/tokenize.c b/vp8/encoder/tokenize.c
index 9b848f3d5835e6f12ae25b493676bfe19d7bc911..5072b19672efb55cff04332ecefe10c361bdb69e 100644 (file)
--- a/vp8/encoder/tokenize.c
+++ b/vp8/encoder/tokenize.c
@@ -39,14 +39,14 @@ extern unsigned int tree_update_hist_16x16[BLOCK_TYPES_16X16][COEF_BANDS]
 #endif
 #endif
 void vp8_stuff_mb(VP8_COMP *cpi,
-                  MACROBLOCKD *x, TOKENEXTRA **t, int dry_run);
+                  MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
 void vp8_stuff_mb_8x8(VP8_COMP *cpi,
-                      MACROBLOCKD *x, TOKENEXTRA **t, int dry_run);
+                      MACROBLOCKD *xd, TOKENEXTRA **t, int dry_run);
 #if CONFIG_TX16X16
-void vp8_stuff_mb_16x16(VP8_COMP *cpi, MACROBLOCKD *x,
+void vp8_stuff_mb_16x16(VP8_COMP *cpi, MACROBLOCKD *xd,
                         TOKENEXTRA **t, int dry_run);
 #endif
-void vp8_fix_contexts(MACROBLOCKD *x);
+void vp8_fix_contexts(MACROBLOCKD *xd);
 
 static TOKENVALUE dct_value_tokens[DCT_MAX_VALUE * 2];
 const TOKENVALUE *vp8_dct_value_tokens_ptr;
@@ -717,100 +717,100 @@ static void tokenize1st_order_b
 }
 
 
-int mby_is_skippable(MACROBLOCKD *x, int has_y2_block) {
+int mby_is_skippable(MACROBLOCKD *xd, int has_y2_block) {
   int skip = 1;
   int i = 0;
 
   if (has_y2_block) {
     for (i = 0; i < 16; i++)
-      skip &= (x->block[i].eob < 2);
-    skip &= (!x->block[24].eob);
+      skip &= (xd->block[i].eob < 2);
+    skip &= (!xd->block[24].eob);
   } else {
     for (i = 0; i < 16; i++)
-      skip &= (!x->block[i].eob);
+      skip &= (!xd->block[i].eob);
   }
   return skip;
 }
 
-int mbuv_is_skippable(MACROBLOCKD *x) {
+int mbuv_is_skippable(MACROBLOCKD *xd) {
   int skip = 1;
   int i;
 
   for (i = 16; i < 24; i++)
-    skip &= (!x->block[i].eob);
+    skip &= (!xd->block[i].eob);
   return skip;
 }
 
-int mb_is_skippable(MACROBLOCKD *x, int has_y2_block) {
-  return (mby_is_skippable(x, has_y2_block) &
-          mbuv_is_skippable(x));
+int mb_is_skippable(MACROBLOCKD *xd, int has_y2_block) {
+  return (mby_is_skippable(xd, has_y2_block) &
+          mbuv_is_skippable(xd));
 }
 
-int mby_is_skippable_8x8(MACROBLOCKD *x) {
+int mby_is_skippable_8x8(MACROBLOCKD *xd) {
   int skip = 1;
   int i = 0;
 
   for (i = 0; i < 16; i += 4)
-    skip &= (x->block[i].eob < 2);
-  skip &= (!x->block[24].eob);
+    skip &= (xd->block[i].eob < 2);
+  skip &= (!xd->block[24].eob);
   return skip;
 }
 
-int mbuv_is_skippable_8x8(MACROBLOCKD *x) {
-  return (!x->block[16].eob) & (!x->block[20].eob);
+int mbuv_is_skippable_8x8(MACROBLOCKD *xd) {
+  return (!xd->block[16].eob) & (!xd->block[20].eob);
 }
 
-int mb_is_skippable_8x8(MACROBLOCKD *x) {
-  return (mby_is_skippable_8x8(x) & mbuv_is_skippable_8x8(x));
+int mb_is_skippable_8x8(MACROBLOCKD *xd) {
+  return (mby_is_skippable_8x8(xd) & mbuv_is_skippable_8x8(xd));
 }
 
 #if CONFIG_TX16X16
-int mby_is_skippable_16x16(MACROBLOCKD *x) {
+int mby_is_skippable_16x16(MACROBLOCKD *xd) {
   int skip = 1;
-  //skip &= (x->block[0].eob < 2); // I think this should be commented? No second order == DC must be coded
-  //skip &= (x->block[0].eob < 1);
-  //skip &= (!x->block[24].eob);
-  skip &= !x->block[0].eob;
+  //skip &= (xd->block[0].eob < 2); // I think this should be commented? No second order == DC must be coded
+  //skip &= (xd->block[0].eob < 1);
+  //skip &= (!xd->block[24].eob);
+  skip &= !xd->block[0].eob;
   return skip;
 }
 
-int mb_is_skippable_16x16(MACROBLOCKD *x) {
+int mb_is_skippable_16x16(MACROBLOCKD *xd) {
   return (mby_is_skippable_16x16(x) & mbuv_is_skippable_8x8(x));
 }
 #endif
 
 void vp8_tokenize_mb(VP8_COMP *cpi,
-                     MACROBLOCKD *x,
+                     MACROBLOCKD *xd,
                      TOKENEXTRA **t,
                      int dry_run) {
   int plane_type;
   int has_y2_block;
   int b;
-  int tx_type = x->mode_info_context->mbmi.txfm_size;
-  int mb_skip_context = get_pred_context(&cpi->common, x, PRED_MBSKIP);
+  int tx_type = xd->mode_info_context->mbmi.txfm_size;
+  int mb_skip_context = get_pred_context(&cpi->common, xd, PRED_MBSKIP);
   TOKENEXTRA *t_backup = *t;
 
   // If the MB is going to be skipped because of a segment level flag
   // exclude this from the skip count stats used to calculate the
   // transmitted skip probability;
   int skip_inc;
-  int segment_id = x->mode_info_context->mbmi.segment_id;
+  int segment_id = xd->mode_info_context->mbmi.segment_id;
 
 #if CONFIG_HYBRIDTRANSFORM
     int QIndex = cpi->mb.q_index;
     int active_ht = (QIndex < ACTIVE_HT) &&
-                    (x->mode_info_context->mbmi.mode == B_PRED);
+                    (xd->mode_info_context->mbmi.mode == B_PRED);
 #endif
 
-  if (!segfeature_active(x, segment_id, SEG_LVL_EOB) ||
-      (get_segdata(x, segment_id, SEG_LVL_EOB) != 0)) {
+  if (!segfeature_active(xd, segment_id, SEG_LVL_EOB) ||
+      (get_segdata(xd, segment_id, SEG_LVL_EOB) != 0)) {
     skip_inc = 1;
   } else
     skip_inc = 0;
 
-  has_y2_block = (x->mode_info_context->mbmi.mode != B_PRED
-                  && x->mode_info_context->mbmi.mode != I8X8_PRED
-                  && x->mode_info_context->mbmi.mode != SPLITMV);
+  has_y2_block = (xd->mode_info_context->mbmi.mode != B_PRED
+                  && xd->mode_info_context->mbmi.mode != I8X8_PRED
+                  && xd->mode_info_context->mbmi.mode != SPLITMV);
 #if CONFIG_TX16X16
   if (tx_type == TX_16X16) has_y2_block = 0; // Because of inter frames
 #endif
@@ -818,18 +818,18 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   switch (tx_type) {
 #if CONFIG_TX16X16
     case TX_16X16:
-      x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(x);
+      xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_16x16(x);
       break;
 #endif
     case TX_8X8:
-      x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_8x8(x);
+      xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable_8x8(xd);
       break;
     default:
-      x->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(x, has_y2_block);
+      xd->mode_info_context->mbmi.mb_skip_coeff = mb_is_skippable(xd, has_y2_block);
       break;
   }
 
-  if (x->mode_info_context->mbmi.mb_skip_coeff) {
+  if (xd->mode_info_context->mbmi.mb_skip_coeff) {
     if (!dry_run)
       cpi->skip_true_count[mb_skip_context] += skip_inc;
     if (!cpi->common.mb_no_coeff_skip) {
@@ -839,11 +839,11 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
       else
 #endif
       if (tx_type == TX_8X8)
-        vp8_stuff_mb_8x8(cpi, x, t, dry_run);
+        vp8_stuff_mb_8x8(cpi, xd, t, dry_run);
       else
-        vp8_stuff_mb(cpi, x, t, dry_run);
+        vp8_stuff_mb(cpi, xd, t, dry_run);
     } else {
-      vp8_fix_contexts(x);
+      vp8_fix_contexts(xd);
     }
     if (dry_run)
       *t = t_backup;
@@ -856,31 +856,31 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   plane_type = 3;
   if (has_y2_block) {
     if (tx_type == TX_8X8) {
-      ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
-      ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
-      tokenize2nd_order_b_8x8(x,
-                              x->block + 24, t, 1, x->frame_type,
+      ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
+      ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
+      tokenize2nd_order_b_8x8(xd,
+                              xd->block + 24, t, 1, xd->frame_type,
                               A + vp8_block2above_8x8[24],
                               L + vp8_block2left_8x8[24],
                               cpi, dry_run);
     } else
-      tokenize2nd_order_b(x, t, cpi, dry_run);
+      tokenize2nd_order_b(xd, t, cpi, dry_run);
 
     plane_type = 0;
   }
 
 #if CONFIG_TX16X16
   if (tx_type == TX_16X16) {
-    ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)x->above_context;
-    ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)x->left_context;
-    tokenize1st_order_b_16x16(x, x->block, t, 3,
-                              x->frame_type, A, L, cpi, dry_run);
+    ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context;
+    ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context;
+    tokenize1st_order_b_16x16(xd, xd->block, t, 3,
+                              xd->frame_type, A, L, cpi, dry_run);
     for (b = 1; b < 16; b++) {
       *(A + vp8_block2above[b]) = *(A);
       *(L + vp8_block2left[b] ) = *(L);
     }
     for (b = 16; b < 24; b += 4) {
-      tokenize1st_order_b_8x8(x, x->block + b, t, 2, x->frame_type,
+      tokenize1st_order_b_8x8(xd, xd->block + b, t, 2, xd->frame_type,
           A + vp8_block2above_8x8[b], L + vp8_block2left_8x8[b], cpi, dry_run);
       *(A + vp8_block2above_8x8[b]+1) = *(A + vp8_block2above_8x8[b]);
       *(L + vp8_block2left_8x8[b]+1 ) = *(L + vp8_block2left_8x8[b]);
@@ -891,11 +891,11 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   else
 #endif
   if (tx_type == TX_8X8) {
-    ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
-    ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
+    ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
+    ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
     for (b = 0; b < 16; b += 4) {
-      tokenize1st_order_b_8x8(x,
-                              x->block + b, t, plane_type, x->frame_type,
+      tokenize1st_order_b_8x8(xd,
+                              xd->block + b, t, plane_type, xd->frame_type,
                               A + vp8_block2above_8x8[b],
                               L + vp8_block2left_8x8[b],
                               cpi, dry_run);
@@ -903,8 +903,8 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
       *(L + vp8_block2left_8x8[b] + 1)  = *(L + vp8_block2left_8x8[b]);
     }
     for (b = 16; b < 24; b += 4) {
-      tokenize1st_order_b_8x8(x,
-                              x->block + b, t, 2, x->frame_type,
+      tokenize1st_order_b_8x8(xd,
+                              xd->block + b, t, 2, xd->frame_type,
                               A + vp8_block2above_8x8[b],
                               L + vp8_block2left_8x8[b],
                               cpi, dry_run);
@@ -914,34 +914,34 @@ void vp8_tokenize_mb(VP8_COMP *cpi,
   } else {
 #if CONFIG_HYBRIDTRANSFORM
     if(active_ht) {
-      tokenize1st_order_ht(x, t, plane_type, cpi, dry_run);
+      tokenize1st_order_ht(xd, t, plane_type, cpi, dry_run);
     } else {
 
 #if CONFIG_HYBRIDTRANSFORM8X8
-      if (x->mode_info_context->mbmi.mode == I8X8_PRED) {
-        ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
-        ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
+      if (xd->mode_info_context->mbmi.mode == I8X8_PRED) {
+        ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
+        ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
         for (b = 0; b < 16; b += 4) {
-          tokenize1st_order_b_8x8(x,
-                                  x->block + b, t, PLANE_TYPE_Y_WITH_DC,
-                                  x->frame_type,
+          tokenize1st_order_b_8x8(xd,
+                                  xd->block + b, t, PLANE_TYPE_Y_WITH_DC,
+                                  xd->frame_type,
                                   A + vp8_block2above_8x8[b],
                                   L + vp8_block2left_8x8[b],
                                   cpi, dry_run);
           *(A + vp8_block2above_8x8[b] + 1) = *(A + vp8_block2above_8x8[b]);
           *(L + vp8_block2left_8x8[b] + 1)  = *(L + vp8_block2left_8x8[b]);
         }
-        tokenize1st_order_chroma(x, t, PLANE_TYPE_UV, cpi, dry_run);
+        tokenize1st_order_chroma(xd, t, PLANE_TYPE_UV, cpi, dry_run);
       } else {
-        tokenize1st_order_b(x, t, plane_type, cpi, dry_run);
+        tokenize1st_order_b(xd, t, plane_type, cpi, dry_run);
       }
 #else
-      tokenize1st_order_b(x, t, plane_type, cpi, dry_run);
+      tokenize1st_order_b(xd, t, plane_type, cpi, dry_run);
 #endif
 
     }
 #else
-    tokenize1st_order_b(x, t, plane_type, cpi, dry_run);
+    tokenize1st_order_b(xd, t, plane_type, cpi, dry_run);
 #endif
   }
   if (dry_run)
@@ -1304,22 +1304,22 @@ void stuff1st_order_buv_8x8
 }
 
 void vp8_stuff_mb_8x8(VP8_COMP *cpi,
-                      MACROBLOCKD *x,
+                      MACROBLOCKD *xd,
                       TOKENEXTRA **t,
                       int dry_run) {
-  ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
-  ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
+  ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
+  ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
   int plane_type;
   int b;
   TOKENEXTRA *t_backup = *t;
 
-  stuff2nd_order_b_8x8(x->block + 24, t, 1, x->frame_type,
+  stuff2nd_order_b_8x8(xd->block + 24, t, 1, xd->frame_type,
                        A + vp8_block2above_8x8[24],
                        L + vp8_block2left_8x8[24], cpi, dry_run);
   plane_type = 0;
 
   for (b = 0; b < 16; b += 4) {
-    stuff1st_order_b_8x8(x->block + b, t, plane_type, x->frame_type,
+    stuff1st_order_b_8x8(xd->block + b, t, plane_type, xd->frame_type,
                          A + vp8_block2above_8x8[b],
                          L + vp8_block2left_8x8[b],
                          cpi, dry_run);
@@ -1328,7 +1328,7 @@ void vp8_stuff_mb_8x8(VP8_COMP *cpi,
   }
 
   for (b = 16; b < 24; b += 4) {
-    stuff1st_order_buv_8x8(x->block + b, t, 2, x->frame_type,
+    stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
                            A + vp8_block2above[b],
                            L + vp8_block2left[b],
                            cpi, dry_run);
@@ -1367,21 +1367,21 @@ void stuff1st_order_b_16x16(const BLOCKD *const b,
 }
 
 void vp8_stuff_mb_16x16(VP8_COMP *cpi,
-                        MACROBLOCKD *x,
+                        MACROBLOCKD *xd,
                         TOKENEXTRA **t,
                         int dry_run) {
-  ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)x->above_context;
-  ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)x->left_context;
+  ENTROPY_CONTEXT * A = (ENTROPY_CONTEXT *)xd->above_context;
+  ENTROPY_CONTEXT * L = (ENTROPY_CONTEXT *)xd->left_context;
   int b, i;
   TOKENEXTRA *t_backup = *t;
 
-  stuff1st_order_b_16x16(x->block, t, x->frame_type, A, L, cpi, dry_run);
+  stuff1st_order_b_16x16(xd->block, t, xd->frame_type, A, L, cpi, dry_run);
   for (i = 1; i < 16; i++) {
     *(A + vp8_block2above[i]) = *(A);
     *(L +  vp8_block2left[i]) = *(L);
   }
   for (b = 16; b < 24; b += 4) {
-    stuff1st_order_buv_8x8(x->block + b, t, 2, x->frame_type,
+    stuff1st_order_buv_8x8(xd->block + b, t, 2, xd->frame_type,
         A + vp8_block2above[b],
         L + vp8_block2left[b],
         cpi, dry_run);
@@ -1462,10 +1462,10 @@ void stuff1st_order_buv
   *a = *l = pt;
 }
 
-void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x,
+void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *xd,
                   TOKENEXTRA **t, int dry_run) {
-  ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)x->above_context;
-  ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)x->left_context;
+  ENTROPY_CONTEXT *A = (ENTROPY_CONTEXT *)xd->above_context;
+  ENTROPY_CONTEXT *L = (ENTROPY_CONTEXT *)xd->left_context;
   int plane_type;
   int b;
   TOKENEXTRA *t_backup = *t;
@@ -1491,19 +1491,19 @@ void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x,
   if (dry_run)
     *t = t_backup;
 }
-void vp8_fix_contexts(MACROBLOCKD *x) {
+void vp8_fix_contexts(MACROBLOCKD *xd) {
   /* Clear entropy contexts for Y2 blocks */
-  if ((x->mode_info_context->mbmi.mode != B_PRED
-      && x->mode_info_context->mbmi.mode != I8X8_PRED
-      && x->mode_info_context->mbmi.mode != SPLITMV)
+  if ((xd->mode_info_context->mbmi.mode != B_PRED
+      && xd->mode_info_context->mbmi.mode != I8X8_PRED
+      && xd->mode_info_context->mbmi.mode != SPLITMV)
 #if CONFIG_TX16X16
-      || x->mode_info_context->mbmi.txfm_size == TX_16X16
+      || xd->mode_info_context->mbmi.txfm_size == TX_16X16
 #endif
       ) {
-    vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
-    vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
+    vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
+    vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES));
   } else {
-    vpx_memset(x->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
-    vpx_memset(x->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
+    vpx_memset(xd->above_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
+    vpx_memset(xd->left_context, 0, sizeof(ENTROPY_CONTEXT_PLANES) - 1);
   }
 }

diff --git a/vp8/encoder/tokenize.h b/vp8/encoder/tokenize.h
index baff4c2b0065c91390856010ab500275ef8b4fb0..ca5d4972267e1592d8178e4125a8fa2c2eeb9c3f 100644 (file)
--- a/vp8/encoder/tokenize.h
+++ b/vp8/encoder/tokenize.h
@@ -31,22 +31,25 @@ typedef struct {
 
 int rd_cost_mby(MACROBLOCKD *);
 
-extern int mby_is_skippable(MACROBLOCKD *x, int has_y2_block);
-extern int mbuv_is_skippable(MACROBLOCKD *x);
-extern int mb_is_skippable(MACROBLOCKD *x, int has_y2_block);
-extern int mby_is_skippable_8x8(MACROBLOCKD *x);
-extern int mbuv_is_skippable_8x8(MACROBLOCKD *x);
-extern int mb_is_skippable_8x8(MACROBLOCKD *x);
-extern int mb_is_skippable_16x16(MACROBLOCKD *x);
+extern int mby_is_skippable(MACROBLOCKD *xd, int has_y2_block);
+extern int mbuv_is_skippable(MACROBLOCKD *xd);
+extern int mb_is_skippable(MACROBLOCKD *xd, int has_y2_block);
+extern int mby_is_skippable_8x8(MACROBLOCKD *xd);
+extern int mbuv_is_skippable_8x8(MACROBLOCKD *xd);
+extern int mb_is_skippable_8x8(MACROBLOCKD *xd);
+extern int mb_is_skippable_16x16(MACROBLOCKD *xd);
 
 #ifdef ENTROPY_STATS
 void init_context_counters();
 void print_context_counters();
 
-extern INT64 context_counters[BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
-extern INT64 context_counters_8x8[BLOCK_TYPES_8X8] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+extern INT64 context_counters[BLOCK_TYPES][COEF_BANDS]
+                             [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
+extern INT64 context_counters_8x8[BLOCK_TYPES_8X8][COEF_BANDS]
+                                 [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
 #if CONFIG_TX16X16
-extern INT64 context_counters_16x16[BLOCK_TYPES_16X16] [COEF_BANDS] [PREV_COEF_CONTEXTS] [MAX_ENTROPY_TOKENS];
+extern INT64 context_counters_16x16[BLOCK_TYPES_16X16][COEF_BANDS]
+                                   [PREV_COEF_CONTEXTS][MAX_ENTROPY_TOKENS];
 #endif
 #endif