Using plane_bsize instead of bsize.

This change set is intermediate. The next one will remove all repetitive
plane_bsize calculations, because it will be passed as argument to
foreach_transformed_block_visitor.

Change-Id: Ifc12e0b330e017c6851a28746b3a5460b9bf7f0b

5 files changed, 90 insertions, 94 deletions

diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 2e65b94ea..cff68218c 100644
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -533,44 +533,39 @@ static INLINE void foreach_predicted_block(
     foreach_predicted_block_in_plane(xd, bsize, plane, visit, arg);
 }
 
-static int raster_block_offset(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize,
-                               int plane, int block, int stride) {
-  const int bw = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
-  const int y = 4 * (block >> bw), x = 4 * (block & ((1 << bw) - 1));
+static int raster_block_offset(BLOCK_SIZE_TYPE plane_bsize,
+                               int raster_block, int stride) {
+  const int bw = b_width_log2(plane_bsize);
+  const int y = 4 * (raster_block >> bw);
+  const int x = 4 * (raster_block & ((1 << bw) - 1));
   return y * stride + x;
 }
-static int16_t* raster_block_offset_int16(MACROBLOCKD *xd,
-                                          BLOCK_SIZE_TYPE bsize,
-                                          int plane, int block, int16_t *base) {
-  const int stride = plane_block_width(bsize, &xd->plane[plane]);
-  return base + raster_block_offset(xd, bsize, plane, block, stride);
+static int16_t* raster_block_offset_int16(BLOCK_SIZE_TYPE plane_bsize,
+                                          int raster_block, int16_t *base) {
+  const int stride = 4 << b_width_log2(plane_bsize);
+  return base + raster_block_offset(plane_bsize, raster_block, stride);
 }
-static uint8_t* raster_block_offset_uint8(MACROBLOCKD *xd,
-                                          BLOCK_SIZE_TYPE bsize,
-                                          int plane, int block,
-                                          uint8_t *base, int stride) {
-  return base + raster_block_offset(xd, bsize, plane, block, stride);
+static uint8_t* raster_block_offset_uint8(BLOCK_SIZE_TYPE plane_bsize,
+                                          int raster_block, uint8_t *base,
+                                          int stride) {
+  return base + raster_block_offset(plane_bsize, raster_block, stride);
 }
 
-static int txfrm_block_to_raster_block(MACROBLOCKD *xd,
-                                       BLOCK_SIZE_TYPE bsize,
-                                       int plane, int block,
-                                       TX_SIZE tx_size) {
-  const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
+static int txfrm_block_to_raster_block(BLOCK_SIZE_TYPE plane_bsize,
+                                       TX_SIZE tx_size, int block) {
+  const int bwl = b_width_log2(plane_bsize);
   const int tx_cols_log2 = bwl - tx_size;
   const int tx_cols = 1 << tx_cols_log2;
   const int raster_mb = block >> (tx_size << 1);
   const int x = (raster_mb & (tx_cols - 1)) << tx_size;
-  const int y = raster_mb >> tx_cols_log2 << tx_size;
+  const int y = (raster_mb >> tx_cols_log2) << tx_size;
   return x + (y << bwl);
 }
 
-static void txfrm_block_to_raster_xy(MACROBLOCKD *xd,
-                                     BLOCK_SIZE_TYPE bsize,
-                                     int plane, int block,
-                                     TX_SIZE tx_size,
+static void txfrm_block_to_raster_xy(BLOCK_SIZE_TYPE plane_bsize,
+                                     TX_SIZE tx_size, int block,
                                      int *x, int *y) {
-  const int bwl = b_width_log2(bsize) - xd->plane[plane].subsampling_x;
+  const int bwl = b_width_log2(plane_bsize);
   const int tx_cols_log2 = bwl - tx_size;
   const int tx_cols = 1 << tx_cols_log2;
   const int raster_mb = block >> (tx_size << 1);
@@ -578,15 +573,14 @@ static void txfrm_block_to_raster_xy(MACROBLOCKD *xd,
   *y = raster_mb >> tx_cols_log2 << tx_size;
 }
 
-static void extend_for_intra(MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
+static void extend_for_intra(MACROBLOCKD* const xd, BLOCK_SIZE_TYPE plane_bsize,
                              int plane, int block, TX_SIZE tx_size) {
   struct macroblockd_plane *const pd = &xd->plane[plane];
   uint8_t *const buf = pd->dst.buf;
   const int stride = pd->dst.stride;
-  const int bw = plane_block_width(bsize, pd);
-  const int bh = plane_block_height(bsize, pd);
+
   int x, y;
-  txfrm_block_to_raster_xy(xd, bsize, plane, block, tx_size, &x, &y);
+  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
   x = x * 4 - 1;
   y = y * 4 - 1;
   // Copy a pixel into the umv if we are in a situation where the block size
@@ -594,6 +588,7 @@ static void extend_for_intra(MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
   // TODO(JBB): Should be able to do the full extend in place so we don't have
   // to do this multiple times.
   if (xd->mb_to_right_edge < 0) {
+    const int bw = 4 << b_width_log2(plane_bsize);
     const int umv_border_start = bw + (xd->mb_to_right_edge >>
                                        (3 + pd->subsampling_x));
 
@@ -603,6 +598,7 @@ static void extend_for_intra(MACROBLOCKD* const xd, BLOCK_SIZE_TYPE bsize,
   }
 
   if (xd->mb_to_bottom_edge < 0) {
+    const int bh = 4 << b_height_log2(plane_bsize);
     const int umv_border_start = bh + (xd->mb_to_bottom_edge >>
                                        (3 + pd->subsampling_y));
     int i;
diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 2cb7fbc0b..bf980096c 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -91,13 +91,13 @@ static void decode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
                          TX_SIZE tx_size, void *arg) {
   MACROBLOCKD* const xd = arg;
   struct macroblockd_plane *const pd = &xd->plane[plane];
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize, pd);
   int16_t* const qcoeff = BLOCK_OFFSET(pd->qcoeff, block);
   const int stride = pd->dst.stride;
   const int eob = pd->eobs[block];
-  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
-                                                       block, tx_size);
-  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
-                                                 raster_block,
+  const int raster_block = txfrm_block_to_raster_block(plane_bsize, tx_size,
+                                                       block);
+  uint8_t* const dst = raster_block_offset_uint8(plane_bsize, raster_block,
                                                  pd->dst.buf, stride);
   switch (tx_size) {
     case TX_4X4: {
@@ -128,14 +128,13 @@ static void decode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
                                TX_SIZE tx_size, void *arg) {
   MACROBLOCKD* const xd = arg;
   struct macroblockd_plane *const pd = &xd->plane[plane];
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize, pd);
   MODE_INFO *const mi = xd->mode_info_context;
-  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
-                                                       block, tx_size);
-  uint8_t* const dst = raster_block_offset_uint8(xd, bsize, plane,
-                                                 raster_block,
+  const int raster_block = txfrm_block_to_raster_block(plane_bsize, tx_size,
+                                                       block);
+  uint8_t* const dst = raster_block_offset_uint8(plane_bsize, raster_block,
                                                  pd->dst.buf, pd->dst.stride);
   int b_mode;
-  int plane_b_size;
   const int tx_ib = raster_block >> tx_size;
   const int mode = (plane == 0) ? mi->mbmi.mode : mi->mbmi.uv_mode;
 
@@ -147,10 +146,9 @@ static void decode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
   }
 
   if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0)
-    extend_for_intra(xd, bsize, plane, block, tx_size);
+    extend_for_intra(xd, plane_bsize, plane, block, tx_size);
 
-  plane_b_size = b_width_log2(bsize) - pd->subsampling_x;
-  vp9_predict_intra_block(xd, tx_ib, plane_b_size, tx_size, b_mode,
+  vp9_predict_intra_block(xd, tx_ib, b_width_log2(plane_bsize), tx_size, b_mode,
                           dst, pd->dst.stride,
                           dst, pd->dst.stride);
 
diff --git a/vp9/encoder/vp9_encodemb.c b/vp9/encoder/vp9_encodemb.c
index 030135222..633c1cc50 100644
--- a/vp9/encoder/vp9_encodemb.c
+++ b/vp9/encoder/vp9_encodemb.c
@@ -146,31 +146,33 @@ static void optimize_b(MACROBLOCK *mb,
                        ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l,
                        TX_SIZE tx_size) {
   MACROBLOCKD *const xd = &mb->e_mbd;
+  struct macroblockd_plane *pd = &xd->plane[plane];
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize, pd);
   const int ref = is_inter_block(&xd->mode_info_context->mbmi);
   vp9_token_state tokens[1025][2];
   unsigned best_index[1025][2];
   const int16_t *coeff_ptr = BLOCK_OFFSET(mb->plane[plane].coeff, block);
   int16_t *qcoeff_ptr;
   int16_t *dqcoeff_ptr;
-  int eob = xd->plane[plane].eobs[block], final_eob, sz = 0;
+  int eob = pd->eobs[block], final_eob, sz = 0;
   const int i0 = 0;
   int rc, x, next, i;
   int64_t rdmult, rddiv, rd_cost0, rd_cost1;
   int rate0, rate1, error0, error1, t0, t1;
   int best, band, pt;
-  PLANE_TYPE type = xd->plane[plane].plane_type;
+  PLANE_TYPE type = pd->plane_type;
   int err_mult = plane_rd_mult[type];
   int default_eob;
   const int16_t *scan, *nb;
   const int mul = 1 + (tx_size == TX_32X32);
   uint8_t token_cache[1024];
-  const int ib = txfrm_block_to_raster_block(xd, bsize, plane, block, tx_size);
-  const int16_t *dequant_ptr = xd->plane[plane].dequant;
+  const int ib = txfrm_block_to_raster_block(plane_bsize, tx_size, block);
+  const int16_t *dequant_ptr = pd->dequant;
   const uint8_t * band_translate;
 
   assert((!type && !plane) || (type && plane));
-  dqcoeff_ptr = BLOCK_OFFSET(xd->plane[plane].dqcoeff, block);
-  qcoeff_ptr = BLOCK_OFFSET(xd->plane[plane].qcoeff, block);
+  dqcoeff_ptr = BLOCK_OFFSET(pd->dqcoeff, block);
+  qcoeff_ptr = BLOCK_OFFSET(pd->qcoeff, block);
   switch (tx_size) {
     default:
     case TX_4X4:
@@ -372,10 +374,12 @@ static void optimize_b(MACROBLOCK *mb,
 void vp9_optimize_b(int plane, int block, BLOCK_SIZE_TYPE bsize,
                     TX_SIZE tx_size, MACROBLOCK *mb, struct optimize_ctx *ctx) {
   MACROBLOCKD *const xd = &mb->e_mbd;
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize,
+                                                           &xd->plane[plane]);
   int x, y;
 
   // find current entropy context
-  txfrm_block_to_raster_xy(xd, bsize, plane, block, tx_size, &x, &y);
+  txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
 
   optimize_b(mb, plane, block, bsize, &ctx->ta[plane][x], &ctx->tl[plane][y],
              tx_size);
@@ -445,7 +449,7 @@ void vp9_optimize_sbuv(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize) {
   foreach_transformed_block_uv(&x->e_mbd, bsize, optimize_block, &arg);
 }
 
-void vp9_xform_quant(int plane, int block, BLOCK_SIZE_TYPE bsize,
+void vp9_xform_quant(int plane, int block, BLOCK_SIZE_TYPE plane_bsize,
                      TX_SIZE tx_size, void *arg) {
   struct encode_b_args* const args = arg;
   MACROBLOCK* const x = args->x;
@@ -457,7 +461,7 @@ void vp9_xform_quant(int plane, int block, BLOCK_SIZE_TYPE bsize,
   int16_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
   const int16_t *scan, *iscan;
   uint16_t *eob = &pd->eobs[block];
-  const int bwl = b_width_log2(bsize) - pd->subsampling_x, bw = 1 << bwl;
+  const int bwl = b_width_log2(plane_bsize), bw = 1 << bwl;
   const int twl = bwl - tx_size, twmask = (1 << twl) - 1;
   int xoff, yoff;
   int16_t *src_diff;
@@ -523,14 +527,15 @@ static void encode_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
   struct encode_b_args *const args = arg;
   MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
-  const int raster_block = txfrm_block_to_raster_block(xd, bsize, plane,
-                                                       block, tx_size);
   struct macroblockd_plane *const pd = &xd->plane[plane];
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize, pd);
+  const int raster_block = txfrm_block_to_raster_block(plane_bsize, tx_size,
+                                                       block);
+
   int16_t *const dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
-  uint8_t *const dst = raster_block_offset_uint8(xd, bsize, plane,
-                                                 raster_block,
+  uint8_t *const dst = raster_block_offset_uint8(plane_bsize, raster_block,
                                                  pd->dst.buf, pd->dst.stride);
-  vp9_xform_quant(plane, block, bsize, tx_size, arg);
+  vp9_xform_quant(plane, block, plane_bsize, tx_size, arg);
 
   if (x->optimize)
     vp9_optimize_b(plane, block, bsize, tx_size, x, args->ctx);
@@ -627,13 +632,14 @@ void vp9_encode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
   MB_MODE_INFO *mbmi = &xd->mode_info_context->mbmi;
   struct macroblock_plane *const p = &x->plane[plane];
   struct macroblockd_plane *const pd = &xd->plane[plane];
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize, pd);
   int16_t *coeff = BLOCK_OFFSET(p->coeff, block);
   int16_t *qcoeff = BLOCK_OFFSET(pd->qcoeff, block);
   int16_t *dqcoeff = BLOCK_OFFSET(pd->dqcoeff, block);
   const int16_t *scan, *iscan;
   TX_TYPE tx_type;
   MB_PREDICTION_MODE mode;
-  const int bwl = b_width_log2(bsize) - pd->subsampling_x, bw = 1 << bwl;
+  const int bwl = b_width_log2(plane_bsize), bw = 1 << bwl;
   const int twl = bwl - tx_size, twmask = (1 << twl) - 1;
   int xoff, yoff;
   uint8_t *src, *dst;
@@ -641,7 +647,7 @@ void vp9_encode_block_intra(int plane, int block, BLOCK_SIZE_TYPE bsize,
   uint16_t *eob = &pd->eobs[block];
 
   if (xd->mb_to_right_edge < 0 || xd->mb_to_bottom_edge < 0) {
-    extend_for_intra(xd, bsize, plane, block, tx_size);
+    extend_for_intra(xd, plane_bsize, plane, block, tx_size);
   }
 
   // if (x->optimize)
diff --git a/vp9/encoder/vp9_encodemb.h b/vp9/encoder/vp9_encodemb.h
index e2428ea26..139e16333 100644
--- a/vp9/encoder/vp9_encodemb.h
+++ b/vp9/encoder/vp9_encodemb.h
@@ -41,7 +41,7 @@ void vp9_encode_sb(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
 void vp9_encode_sby(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
 void vp9_encode_sbuv(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
 
-void vp9_xform_quant(int plane, int block, BLOCK_SIZE_TYPE bsize,
+void vp9_xform_quant(int plane, int block, BLOCK_SIZE_TYPE plane_bsize,
                      TX_SIZE tx_size, void *arg);
 void vp9_xform_quant_sby(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
 void vp9_xform_quant_sbuv(MACROBLOCK *x, BLOCK_SIZE_TYPE bsize);
diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c
index 4db396913..466d3d71e 100644
--- a/vp9/encoder/vp9_rdopt.c
+++ b/vp9/encoder/vp9_rdopt.c
@@ -570,8 +570,7 @@ struct rdcost_block_args {
   const int16_t *scan, *nb;
 };
 
-static void dist_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
-                       TX_SIZE tx_size, void *arg) {
+static void dist_block(int plane, int block, TX_SIZE tx_size, void *arg) {
   const int ss_txfrm_size = tx_size << 1;
   struct rdcost_block_args* args = arg;
   MACROBLOCK* const x = args->x;
@@ -596,16 +595,17 @@ static void dist_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
   }
 }
 
-static void rate_block(int plane, int block, BLOCK_SIZE_TYPE bsize,
+static void rate_block(int plane, int block, BLOCK_SIZE_TYPE plane_bsize,
                        TX_SIZE tx_size, void *arg) {
   struct rdcost_block_args* args = arg;
   MACROBLOCKD *const xd = &args->x->e_mbd;
+  struct macroblockd_plane *const pd = &xd->plane[plane];
+
   int x_idx, y_idx;
-  txfrm_block_to_raster_xy(xd, bsize, plane, block, args->tx_size,
-                           &x_idx, &y_idx);
+  txfrm_block_to_raster_xy(plane_bsize, args->tx_size, block, &x_idx, &y_idx);
 
   args->rate += cost_coeffs(args->x, plane, block,
-                            xd->plane[plane].plane_type, args->t_above + x_idx,
+                            pd->plane_type, args->t_above + x_idx,
                             args->t_left + y_idx, args->tx_size,
                             args->scan, args->nb);
 }
@@ -616,6 +616,8 @@ static void block_yrd_txfm(int plane, int block, BLOCK_SIZE_TYPE bsize,
   MACROBLOCK *const x = args->x;
   MACROBLOCKD *const xd = &x->e_mbd;
   struct encode_b_args encode_args = {x, NULL};
+  const BLOCK_SIZE_TYPE plane_bsize = get_plane_block_size(bsize,
+                                                           &xd->plane[plane]);
   int64_t rd1, rd2, rd;
 
   if (args->skip)
@@ -634,10 +636,10 @@ static void block_yrd_txfm(int plane, int block, BLOCK_SIZE_TYPE bsize,
   if (!is_inter_block(&xd->mode_info_context->mbmi))
     vp9_encode_block_intra(plane, block, bsize, tx_size, &encode_args);
   else
-    vp9_xform_quant(plane, block, bsize, tx_size, &encode_args);
+    vp9_xform_quant(plane, block, plane_bsize, tx_size, &encode_args);
 
-  dist_block(plane, block, bsize, tx_size, args);
-  rate_block(plane, block, bsize, tx_size, args);
+  dist_block(plane, block, tx_size, args);
+  rate_block(plane, block, plane_bsize, tx_size, args);
 }
 
 static void txfm_rd_in_plane(MACROBLOCK *x,
@@ -1025,9 +1027,9 @@ static int64_t rd_pick_intra4x4block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
   struct macroblockd_plane *pd = &xd->plane[0];
   const int src_stride = p->src.stride;
   const int dst_stride = pd->dst.stride;
-  uint8_t *src_init = raster_block_offset_uint8(xd, BLOCK_8X8, 0, ib,
+  uint8_t *src_init = raster_block_offset_uint8(BLOCK_8X8, ib,
                                                 p->src.buf, src_stride);
-  uint8_t *dst_init = raster_block_offset_uint8(xd, BLOCK_8X8, 0, ib,
+  uint8_t *dst_init = raster_block_offset_uint8(BLOCK_8X8, ib,
                                                 pd->dst.buf, dst_stride);
   int16_t *src_diff, *coeff;
 
@@ -1070,8 +1072,7 @@ static int64_t rd_pick_intra4x4block(VP9_COMP *cpi, MACROBLOCK *x, int ib,
 
         block = ib + idy * 2 + idx;
         xd->mode_info_context->bmi[block].as_mode = mode;
-        src_diff = raster_block_offset_int16(xd, BLOCK_8X8, 0, block,
-                                             p->src_diff);
+        src_diff = raster_block_offset_int16(BLOCK_8X8, block, p->src_diff);
         coeff = BLOCK_OFFSET(x->plane[0].coeff, block);
         vp9_predict_intra_block(xd, block, 1,
                                 TX_4X4, mode,
@@ -1502,18 +1503,17 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
   const int height = plane_block_height(bsize, pd);
   int idx, idy;
   const int src_stride = x->plane[0].src.stride;
-  uint8_t* const src = raster_block_offset_uint8(xd, BLOCK_8X8, 0, i,
+  uint8_t* const src = raster_block_offset_uint8(BLOCK_8X8, i,
                                                  x->plane[0].src.buf,
                                                  src_stride);
-  int16_t* src_diff = raster_block_offset_int16(xd, BLOCK_8X8, 0, i,
+  int16_t* src_diff = raster_block_offset_int16(BLOCK_8X8, i,
                                                 x->plane[0].src_diff);
   int16_t* coeff = BLOCK_OFFSET(x->plane[0].coeff, i);
-  uint8_t* const pre = raster_block_offset_uint8(xd, BLOCK_8X8, 0, i,
+  uint8_t* const pre = raster_block_offset_uint8(BLOCK_8X8, i,
                                                  pd->pre[0].buf,
                                                  pd->pre[0].stride);
-  uint8_t* const dst = raster_block_offset_uint8(xd, BLOCK_8X8, 0, i,
-                                                 pd->dst.buf,
-                                                 pd->dst.stride);
+  uint8_t* const dst = raster_block_offset_uint8(BLOCK_8X8, i,
+                                                 pd->dst.buf, pd->dst.stride);
   int64_t thisdistortion = 0, thissse = 0;
   int thisrate = 0;
 
@@ -1525,8 +1525,7 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
 
   if (mi->mbmi.ref_frame[1] > 0) {
     uint8_t* const second_pre =
-    raster_block_offset_uint8(xd, BLOCK_8X8, 0, i,
-                              pd->pre[1].buf, pd->pre[1].stride);
+    raster_block_offset_uint8(BLOCK_8X8, 0, pd->pre[1].buf, pd->pre[1].stride);
     vp9_build_inter_predictor(second_pre, pd->pre[1].stride,
                               dst, pd->dst.stride,
                               &mi->bmi[i].as_mv[1].as_mv,
@@ -1543,7 +1542,7 @@ static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
       int64_t ssz, rd, rd1, rd2;
 
       k += (idy * 2 + idx);
-      src_diff = raster_block_offset_int16(xd, BLOCK_8X8, 0, k,
+      src_diff = raster_block_offset_int16(BLOCK_8X8, k,
                                            x->plane[0].src_diff);
       coeff = BLOCK_OFFSET(x->plane[0].coeff, k);
       x->fwd_txm4x4(src_diff, coeff, 16);
@@ -1606,21 +1605,18 @@ static INLINE int mv_check_bounds(MACROBLOCK *x, int_mv *mv) {
 }
 
 static INLINE void mi_buf_shift(MACROBLOCK *x, int i) {
-  MB_MODE_INFO *mbmi = &x->e_mbd.mode_info_context->mbmi;
-  x->plane[0].src.buf =
-      raster_block_offset_uint8(&x->e_mbd, BLOCK_8X8, 0, i,
-                                x->plane[0].src.buf,
-                                x->plane[0].src.stride);
-  assert(((intptr_t)x->e_mbd.plane[0].pre[0].buf & 0x7) == 0);
-  x->e_mbd.plane[0].pre[0].buf =
-      raster_block_offset_uint8(&x->e_mbd, BLOCK_8X8, 0, i,
-                                x->e_mbd.plane[0].pre[0].buf,
-                                x->e_mbd.plane[0].pre[0].stride);
+  MB_MODE_INFO *const mbmi = &x->e_mbd.mode_info_context->mbmi;
+  struct macroblock_plane *const p = &x->plane[0];
+  struct macroblockd_plane *const pd = &x->e_mbd.plane[0];
+
+  p->src.buf = raster_block_offset_uint8(BLOCK_8X8, i, p->src.buf,
+                                         p->src.stride);
+  assert(((intptr_t)pd->pre[0].buf & 0x7) == 0);
+  pd->pre[0].buf = raster_block_offset_uint8(BLOCK_8X8, i, pd->pre[0].buf,
+                                             pd->pre[0].stride);
   if (mbmi->ref_frame[1])
-    x->e_mbd.plane[0].pre[1].buf =
-        raster_block_offset_uint8(&x->e_mbd, BLOCK_8X8, 0, i,
-                                  x->e_mbd.plane[0].pre[1].buf,
-                                  x->e_mbd.plane[0].pre[1].stride);
+    pd->pre[1].buf = raster_block_offset_uint8(BLOCK_8X8, i, pd->pre[1].buf,
+                                               pd->pre[1].stride);
 }
 
 static INLINE void mi_buf_restore(MACROBLOCK *x, struct buf_2d orig_src,