Move diff to MACROBLOCKD per-plane data.

Change-Id: Ic27af09e38af8317ac4743241883d577a44f1490

diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h
index 907bef95e291861807541b4ddc4eedfb83844689..265c1f21a5e067691758a57ca837bd196afffb89 100644 (file)
--- a/vp9/common/vp9_blockd.h
+++ b/vp9/common/vp9_blockd.h
@@ -342,6 +342,7 @@ struct mb_plane {
   DECLARE_ALIGNED(16, int16_t,  qcoeff[64 * 64]);
   DECLARE_ALIGNED(16, int16_t,  dqcoeff[64 * 64]);
   DECLARE_ALIGNED(16, uint16_t, eobs[256]);
+  DECLARE_ALIGNED(16, int16_t,  diff[64 * 64]);
   PLANE_TYPE plane_type;
   int subsampling_x;
   int subsampling_y;
@@ -355,7 +356,6 @@ struct mb_plane {
   BLOCK_OFFSET((x)->plane[2].field, ((i) - 20), 16))
 
 typedef struct macroblockd {
-  DECLARE_ALIGNED(16, int16_t,  diff[64*64+32*32*2]);      /* from idct diff */
 #if CONFIG_CODE_NONZEROCOUNT
   DECLARE_ALIGNED(16, uint16_t, nzcs[256+64*2]);
 #endif

diff --git a/vp9/common/vp9_invtrans.c b/vp9/common/vp9_invtrans.c
index 3b11fa9cbbe564ad321557663f6a1349e7d29d07..0673fd81a227523b3b4d3f28396a8659ed82e13c 100644 (file)
--- a/vp9/common/vp9_invtrans.c
+++ b/vp9/common/vp9_invtrans.c
@@ -38,10 +38,10 @@ void vp9_inverse_transform_sby_32x32(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
 
   for (n = 0; n < bw * bh; n++) {
     const int x_idx = n & (bw - 1), y_idx = n >> bwl;
+    const int offset = x_idx * 32 + y_idx * 32 * stride;
 
     vp9_short_idct32x32(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 1024),
-                        xd->diff + x_idx * 32 + y_idx * 32 * stride,
-                        stride * 2);
+                        xd->plane[0].diff + offset, stride * 2);
   }
 }
 
@@ -55,15 +55,14 @@ void vp9_inverse_transform_sby_16x16(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
     const int x_idx = n & (bw - 1), y_idx = n >> bwl;
     const TX_TYPE tx_type = get_tx_type_16x16(xd,
                                               (y_idx * bstride + x_idx) * 4);
+    const int offset = x_idx * 16 + y_idx * 16 * stride;
 
     if (tx_type == DCT_DCT) {
       vp9_inverse_transform_b_16x16(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 256),
-                                    xd->diff + x_idx * 16 + y_idx * stride * 16,
-                                    stride * 2);
+                                    xd->plane[0].diff + offset, stride * 2);
     } else {
       vp9_short_iht16x16(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 256),
-                         xd->diff + x_idx * 16 + y_idx * stride * 16,
-                         stride, tx_type);
+                         xd->plane[0].diff + offset, stride, tx_type);
     }
   }
 }
@@ -77,15 +76,14 @@ void vp9_inverse_transform_sby_8x8(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   for (n = 0; n < bw * bh; n++) {
     const int x_idx = n & (bw - 1), y_idx = n >> bwl;
     const TX_TYPE tx_type = get_tx_type_8x8(xd, (y_idx * bstride + x_idx) * 2);
+    const int offset = x_idx * 8 + y_idx * 8 * stride;
 
     if (tx_type == DCT_DCT) {
       vp9_inverse_transform_b_8x8(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 64),
-                                  xd->diff + x_idx * 8 + y_idx * stride * 8,
-                                  stride * 2);
+                                  xd->plane[0].diff + offset, stride * 2);
     } else {
       vp9_short_iht8x8(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 64),
-                       xd->diff + x_idx * 8 + y_idx * stride * 8,
-                       stride, tx_type);
+                       xd->plane[0].diff + offset, stride, tx_type);
     }
   }
 }
@@ -99,16 +97,15 @@ void vp9_inverse_transform_sby_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   for (n = 0; n < bw * bh; n++) {
     const int x_idx = n & (bw - 1), y_idx = n >> bwl;
     const TX_TYPE tx_type = get_tx_type_4x4(xd, y_idx * bstride + x_idx);
+    const int offset = x_idx * 4 + y_idx * 4 * stride;
 
     if (tx_type == DCT_DCT) {
       vp9_inverse_transform_b_4x4(xd, xd->plane[0].eobs[n],
                                   BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 16),
-                                  xd->diff + x_idx * 4 + y_idx * 4 * stride,
-                                  stride * 2);
+                                  xd->plane[0].diff + offset, stride * 2);
     } else {
       vp9_short_iht4x4(BLOCK_OFFSET(xd->plane[0].dqcoeff, n, 16),
-                       xd->diff + x_idx * 4 + y_idx * 4 * stride,
-                       stride, tx_type);
+                       xd->plane[0].diff + offset, stride, tx_type);
     }
   }
 }
@@ -116,15 +113,12 @@ void vp9_inverse_transform_sby_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
 void vp9_inverse_transform_sbuv_32x32(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   assert(bsize == BLOCK_SIZE_SB64X64);
 
-  vp9_short_idct32x32(xd->plane[1].dqcoeff,
-                      xd->diff + 4096, 64);
-  vp9_short_idct32x32(xd->plane[2].dqcoeff,
-                      xd->diff + 4096 + 1024, 64);
+  vp9_short_idct32x32(xd->plane[1].dqcoeff, xd->plane[1].diff, 64);
+  vp9_short_idct32x32(xd->plane[2].dqcoeff, xd->plane[2].diff, 64);
 }
 
 void vp9_inverse_transform_sbuv_16x16(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
-  const int uoff = (16 * 16) << (bwl + bhl), voff = (uoff * 5) >> 2;
   const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
   const int stride = 16 << (bwl - 1);
   int n;
@@ -134,15 +128,14 @@ void vp9_inverse_transform_sbuv_16x16(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
     const int off = x_idx * 16 + y_idx * stride * 16;
 
     vp9_inverse_transform_b_16x16(BLOCK_OFFSET(xd->plane[1].dqcoeff, n, 256),
-                                  xd->diff + uoff + off, stride * 2);
+                                  xd->plane[1].diff + off, stride * 2);
     vp9_inverse_transform_b_16x16(BLOCK_OFFSET(xd->plane[2].dqcoeff, n, 256),
-                                  xd->diff + voff + off, stride * 2);
+                                  xd->plane[2].diff + off, stride * 2);
   }
 }
 
 void vp9_inverse_transform_sbuv_8x8(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   const int bwl = mb_width_log2(bsize) + 1, bhl = mb_height_log2(bsize) + 1;
-  const int uoff = (8 * 8) << (bwl + bhl), voff = (uoff * 5) >> 2;
   const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
   const int stride = 8 << (bwl - 1);
   int n;
@@ -152,15 +145,14 @@ void vp9_inverse_transform_sbuv_8x8(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
     const int off = x_idx * 8 + y_idx * stride * 8;
 
     vp9_inverse_transform_b_8x8(BLOCK_OFFSET(xd->plane[1].dqcoeff, n, 64),
-                                xd->diff + uoff + off, stride * 2);
+                                xd->plane[1].diff + off, stride * 2);
     vp9_inverse_transform_b_8x8(BLOCK_OFFSET(xd->plane[2].dqcoeff, n, 64),
-                                xd->diff + voff + off, stride * 2);
+                                xd->plane[2].diff + off, stride * 2);
   }
 }
 
 void vp9_inverse_transform_sbuv_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
   const int bwl = mb_width_log2(bsize) + 2, bhl = mb_height_log2(bsize) + 2;
-  const int uoff = (4 * 4) << (bwl + bhl), voff = (uoff * 5) >> 2;
   const int bw = 1 << (bwl - 1), bh = 1 << (bhl - 1);
   const int stride = 4 << (bwl - 1);
   int n;
@@ -171,9 +163,9 @@ void vp9_inverse_transform_sbuv_4x4(MACROBLOCKD *xd, BLOCK_SIZE_TYPE bsize) {
 
     vp9_inverse_transform_b_4x4(xd, xd->plane[1].eobs[n],
                                 BLOCK_OFFSET(xd->plane[1].dqcoeff, n, 16),
-                                xd->diff + uoff + off, stride * 2);
+                                xd->plane[1].diff + off, stride * 2);
     vp9_inverse_transform_b_4x4(xd, xd->plane[2].eobs[n],
                                 BLOCK_OFFSET(xd->plane[2].dqcoeff, n, 16),
-                                xd->diff + voff + off, stride * 2);
+                                xd->plane[2].diff + off, stride * 2);
   }
 }

diff --git a/vp9/common/vp9_mbpitch.c b/vp9/common/vp9_mbpitch.c
index 6ed5f27d995ea9fe4fd0da46b3adbb54c8ff76d1..00fe9aa15f970b1acc17ca9c834005858a924084 100644 (file)
--- a/vp9/common/vp9_mbpitch.c
+++ b/vp9/common/vp9_mbpitch.c
@@ -77,23 +77,23 @@ void vp9_setup_block_dptrs(MACROBLOCKD *mb) {
     for (c = 0; c < 4; c++) {
       const int to = r * 4 + c;
       const int from = r * 4 * 16 + c * 4;
-      blockd[to].diff = &mb->diff[from];
+      blockd[to].diff = &mb->plane[0].diff[from];
     }
   }
 
   for (r = 0; r < 2; r++) {
     for (c = 0; c < 2; c++) {
       const int to = 16 + r * 2 + c;
-      const int from = 256 + r * 4 * 8 + c * 4;
-      blockd[to].diff = &mb->diff[from];
+      const int from = r * 4 * 8 + c * 4;
+      blockd[to].diff = &mb->plane[1].diff[from];
     }
   }
 
   for (r = 0; r < 2; r++) {
     for (c = 0; c < 2; c++) {
       const int to = 20 + r * 2 + c;
-      const int from = 320 + r * 4 * 8 + c * 4;
-      blockd[to].diff = &mb->diff[from];
+      const int from = r * 4 * 8 + c * 4;
+      blockd[to].diff = &mb->plane[2].diff[from];
     }
   }
 

diff --git a/vp9/common/vp9_recon.c b/vp9/common/vp9_recon.c
index 121776c69c8534a37689572fa6dd4501b058c1ff..fae35844d54c485ec2697ca9a23b81d4e07cc612 100644 (file)
--- a/vp9/common/vp9_recon.c
+++ b/vp9/common/vp9_recon.c
@@ -55,7 +55,7 @@ void vp9_recon_sby_s_c(MACROBLOCKD *mb, uint8_t *dst,
   const int bw = 16 << mb_width_log2(bsize), bh = 16 << mb_height_log2(bsize);
   int x, y;
   const int stride = mb->block[0].dst_stride;
-  const int16_t *diff = mb->diff;
+  const int16_t *diff = mb->plane[0].diff;
 
   for (y = 0; y < bh; y++) {
     for (x = 0; x < bw; x++)
@@ -69,12 +69,11 @@ void vp9_recon_sby_s_c(MACROBLOCKD *mb, uint8_t *dst,
 void vp9_recon_sbuv_s_c(MACROBLOCKD *mb, uint8_t *u_dst, uint8_t *v_dst,
                         BLOCK_SIZE_TYPE bsize) {
   const int bwl = mb_width_log2(bsize), bhl = mb_height_log2(bsize);
-  const int uoff = (16 * 16) << (bwl + bhl), voff = (uoff * 5) >> 2;
   const int bw = 8 << bwl, bh = 8 << bhl;
   int x, y;
   const int stride = mb->block[16].dst_stride;
-  const int16_t *u_diff = mb->diff + uoff;
-  const int16_t *v_diff = mb->diff + voff;
+  const int16_t *u_diff = mb->plane[1].diff;
+  const int16_t *v_diff = mb->plane[2].diff;
 
   for (y = 0; y < bh; y++) {
     for (x = 0; x < bw; x++) {