Merge "WIP: removing predictor buffer usage from decoder" into experimental

3 files changed, 93 insertions, 79 deletions

diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c
index 5d605bac9..6013591f4 100644
--- a/vp9/decoder/vp9_decodframe.c
+++ b/vp9/decoder/vp9_decodframe.c
@@ -226,24 +226,28 @@ static void skip_recon_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
 static void decode_16x16(VP9D_COMP *pbi, MACROBLOCKD *xd,
                          BOOL_DECODER* const bc) {
   const TX_TYPE tx_type = get_tx_type_16x16(xd, 0);
+
   if (tx_type != DCT_DCT) {
     vp9_dequant_iht_add_16x16_c(tx_type, xd->plane[0].qcoeff,
-                                xd->block[0].dequant, xd->predictor,
-                                xd->dst.y_buffer, 16, xd->dst.y_stride,
-                                xd->plane[0].eobs[0]);
+                                xd->block[0].dequant, xd->dst.y_buffer,
+                                xd->dst.y_buffer, xd->dst.y_stride,
+                                xd->dst.y_stride, xd->plane[0].eobs[0]);
   } else {
     vp9_dequant_idct_add_16x16(xd->plane[0].qcoeff, xd->block[0].dequant,
-                               xd->predictor, xd->dst.y_buffer,
-                               16, xd->dst.y_stride, xd->plane[0].eobs[0]);
+                               xd->dst.y_buffer, xd->dst.y_buffer,
+                               xd->dst.y_stride, xd->dst.y_stride,
+                               xd->plane[0].eobs[0]);
   }
 
   vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
-                           xd->predictor + 16 * 16, xd->dst.u_buffer, 8,
-                           xd->dst.uv_stride, xd->plane[1].eobs[0]);
+                           xd->dst.u_buffer, xd->dst.u_buffer,
+                           xd->dst.uv_stride, xd->dst.uv_stride,
+                           xd->plane[1].eobs[0]);
 
   vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[20].dequant,
-                           xd->predictor + 16 * 16 + 64, xd->dst.v_buffer, 8,
-                           xd->dst.uv_stride, xd->plane[2].eobs[0]);
+                           xd->dst.v_buffer, xd->dst.v_buffer,
+                           xd->dst.uv_stride, xd->dst.uv_stride,
+                           xd->plane[2].eobs[0]);
 }
 
 static void decode_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
@@ -259,27 +263,27 @@ static void decode_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
       int idx = (ib & 0x02) ? (ib + 2) : ib;
       int16_t *q  = BLOCK_OFFSET(xd->plane[0].qcoeff, idx, 16);
       int16_t *dq = xd->block[0].dequant;
-      uint8_t *pre = xd->block[ib].predictor;
       uint8_t *dst = *(xd->block[ib].base_dst) + xd->block[ib].dst;
       int stride = xd->dst.y_stride;
-      BLOCKD *b = &xd->block[ib];
       if (mode == I8X8_PRED) {
+        BLOCKD *b = &xd->block[ib];
         int i8x8mode = b->bmi.as_mode.first;
-        vp9_intra8x8_predict(xd, b, i8x8mode, b->predictor);
+        vp9_intra8x8_predict(xd, b, i8x8mode, dst, stride);
       }
       tx_type = get_tx_type_8x8(xd, ib);
       if (tx_type != DCT_DCT) {
-        vp9_dequant_iht_add_8x8_c(tx_type, q, dq, pre, dst, 16, stride,
+        vp9_dequant_iht_add_8x8_c(tx_type, q, dq, dst, dst, stride, stride,
                                   xd->plane[0].eobs[idx]);
       } else {
-        vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride,
+        vp9_dequant_idct_add_8x8_c(q, dq, dst, dst, stride, stride,
                                    xd->plane[0].eobs[idx]);
       }
     }
   } else {
     vp9_dequant_idct_add_y_block_8x8(xd->plane[0].qcoeff,
                                      xd->block[0].dequant,
-                                     xd->predictor,
+                                     xd->dst.y_buffer,
+                                     xd->dst.y_stride,
                                      xd->dst.y_buffer,
                                      xd->dst.y_stride,
                                      xd);
@@ -294,34 +298,38 @@ static void decode_8x8(VP9D_COMP *pbi, MACROBLOCKD *xd,
       int i8x8mode = b->bmi.as_mode.first;
 
       b = &xd->block[16 + i];
-      vp9_intra_uv4x4_predict(xd, b, i8x8mode, b->predictor);
+      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
+                              b->dst_stride);
       xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
-                   b->dequant, b->predictor,
-                   *(b->base_dst) + b->dst, 8, b->dst_stride,
+                   b->dequant, *(b->base_dst) + b->dst,
+                   *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                    xd->plane[1].eobs[i]);
 
       b = &xd->block[20 + i];
-      vp9_intra_uv4x4_predict(xd, b, i8x8mode, b->predictor);
+      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
+                              b->dst_stride);
       xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
-                   b->dequant, b->predictor,
-                   *(b->base_dst) + b->dst, 8, b->dst_stride,
+                   b->dequant, *(b->base_dst) + b->dst,
+                   *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                    xd->plane[2].eobs[i]);
     }
   } else if (mode == SPLITMV) {
     xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16, xd->dst.u_buffer,
+         xd->dst.u_buffer, xd->dst.uv_stride, xd->dst.u_buffer,
          xd->dst.uv_stride, xd->plane[1].eobs);
     xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16 + 64, xd->dst.v_buffer,
+         xd->dst.v_buffer, xd->dst.uv_stride, xd->dst.v_buffer,
          xd->dst.uv_stride, xd->plane[2].eobs);
   } else {
     vp9_dequant_idct_add_8x8(xd->plane[1].qcoeff, xd->block[16].dequant,
-                             xd->predictor + 16 * 16, xd->dst.u_buffer, 8,
-                             xd->dst.uv_stride, xd->plane[1].eobs[0]);
+                             xd->dst.u_buffer, xd->dst.u_buffer,
+                             xd->dst.uv_stride, xd->dst.uv_stride,
+                             xd->plane[1].eobs[0]);
 
     vp9_dequant_idct_add_8x8(xd->plane[2].qcoeff, xd->block[16].dequant,
-                             xd->predictor + 16 * 16 + 64, xd->dst.v_buffer, 8,
-                             xd->dst.uv_stride, xd->plane[2].eobs[0]);
+                             xd->dst.v_buffer, xd->dst.v_buffer,
+                             xd->dst.uv_stride, xd->dst.uv_stride,
+                             xd->plane[2].eobs[0]);
   }
 }
 
@@ -337,35 +345,38 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
       int j;
       BLOCKD *b = &xd->block[ib];
       int i8x8mode = b->bmi.as_mode.first;
-      vp9_intra8x8_predict(xd, b, i8x8mode, b->predictor);
+      vp9_intra8x8_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
+                           b->dst_stride);
       for (j = 0; j < 4; j++) {
         b = &xd->block[ib + iblock[j]];
         tx_type = get_tx_type_4x4(xd, ib + iblock[j]);
         if (tx_type != DCT_DCT) {
           vp9_dequant_iht_add_c(tx_type,
               BLOCK_OFFSET(xd->plane[0].qcoeff, ib + iblock[j], 16),
-                                    b->dequant, b->predictor,
-                                    *(b->base_dst) + b->dst, 16,
+                                    b->dequant, *(b->base_dst) + b->dst,
+                                    *(b->base_dst) + b->dst, b->dst_stride,
                                     b->dst_stride,
                                     xd->plane[0].eobs[ib + iblock[j]]);
         } else {
           xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, ib + iblock[j], 16),
-                       b->dequant, b->predictor,
-                       *(b->base_dst) + b->dst, 16, b->dst_stride,
+                       b->dequant, *(b->base_dst) + b->dst,
+                       *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                        xd->plane[0].eobs[ib + iblock[j]]);
         }
       }
       b = &xd->block[16 + i];
-      vp9_intra_uv4x4_predict(xd, b, i8x8mode, b->predictor);
+      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
+                              b->dst_stride);
       xd->itxm_add(BLOCK_OFFSET(xd->plane[1].qcoeff, i, 16),
-                   b->dequant, b->predictor,
-                   *(b->base_dst) + b->dst, 8, b->dst_stride,
+                   b->dequant, *(b->base_dst) + b->dst,
+                   *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                    xd->plane[1].eobs[i]);
       b = &xd->block[20 + i];
-      vp9_intra_uv4x4_predict(xd, b, i8x8mode, b->predictor);
+      vp9_intra_uv4x4_predict(xd, b, i8x8mode, *(b->base_dst) + b->dst,
+                              b->dst_stride);
       xd->itxm_add(BLOCK_OFFSET(xd->plane[2].qcoeff, i, 16),
-                   b->dequant, b->predictor,
-                   *(b->base_dst) + b->dst, 8, b->dst_stride,
+                   b->dequant, *(b->base_dst) + b->dst,
+                   *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                    xd->plane[2].eobs[i]);
     }
   } else if (mode == B_PRED) {
@@ -378,18 +389,19 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
       if (!xd->mode_info_context->mbmi.mb_skip_coeff)
         vp9_decode_coefs_4x4(pbi, xd, bc, PLANE_TYPE_Y_WITH_DC, i);
 #endif
-      vp9_intra4x4_predict(xd, b, b_mode, b->predictor);
+      vp9_intra4x4_predict(xd, b, b_mode, *(b->base_dst) + b->dst,
+                           b->dst_stride);
       tx_type = get_tx_type_4x4(xd, i);
       if (tx_type != DCT_DCT) {
         vp9_dequant_iht_add_c(tx_type,
                               BLOCK_OFFSET(xd->plane[0].qcoeff, i, 16),
-                              b->dequant, b->predictor,
-                              *(b->base_dst) + b->dst, 16, b->dst_stride,
-                               xd->plane[0].eobs[i]);
+                              b->dequant, *(b->base_dst) + b->dst,
+                              *(b->base_dst) + b->dst, b->dst_stride,
+                              b->dst_stride, xd->plane[0].eobs[i]);
       } else {
         xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, i, 16),
-                     b->dequant, b->predictor,
-                     *(b->base_dst) + b->dst, 16, b->dst_stride,
+                     b->dequant, *(b->base_dst) + b->dst,
+                     *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                      xd->plane[0].eobs[i]);
       }
     }
@@ -397,25 +409,25 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
     if (!xd->mode_info_context->mbmi.mb_skip_coeff)
       vp9_decode_mb_tokens_4x4_uv(pbi, xd, bc);
 #endif
-    vp9_build_intra_predictors_mbuv(xd);
+    vp9_build_intra_predictors_mbuv_s(xd);
     xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16, xd->dst.u_buffer,
+         xd->dst.u_buffer, xd->dst.uv_stride, xd->dst.u_buffer,
          xd->dst.uv_stride, xd->plane[1].eobs);
     xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16 + 64, xd->dst.v_buffer,
+         xd->dst.v_buffer, xd->dst.uv_stride, xd->dst.v_buffer,
          xd->dst.uv_stride, xd->plane[2].eobs);
   } else if (mode == SPLITMV || get_tx_type_4x4(xd, 0) == DCT_DCT) {
     xd->itxm_add_y_block(xd->plane[0].qcoeff,
                           xd->block[0].dequant,
-                          xd->predictor,
+                          xd->dst.y_buffer, xd->dst.y_stride,
                           xd->dst.y_buffer,
                           xd->dst.y_stride,
                           xd);
     xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16, xd->dst.u_buffer,
+         xd->dst.u_buffer, xd->dst.uv_stride, xd->dst.u_buffer,
          xd->dst.uv_stride, xd->plane[1].eobs);
     xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
-         xd->predictor + 16 * 16 + 64, xd->dst.v_buffer,
+         xd->dst.v_buffer, xd->dst.uv_stride, xd->dst.v_buffer,
          xd->dst.uv_stride, xd->plane[2].eobs);
   } else {
     for (i = 0; i < 16; i++) {
@@ -424,21 +436,21 @@ static void decode_4x4(VP9D_COMP *pbi, MACROBLOCKD *xd,
       if (tx_type != DCT_DCT) {
         vp9_dequant_iht_add_c(tx_type,
                               BLOCK_OFFSET(xd->plane[0].qcoeff, i, 16),
-                              b->dequant, b->predictor,
-                              *(b->base_dst) + b->dst, 16,
+                              b->dequant, *(b->base_dst) + b->dst,
+                              *(b->base_dst) + b->dst, b->dst_stride,
                               b->dst_stride, xd->plane[0].eobs[i]);
       } else {
         xd->itxm_add(BLOCK_OFFSET(xd->plane[0].qcoeff, i, 16),
-                     b->dequant, b->predictor,
-                     *(b->base_dst) + b->dst, 16, b->dst_stride,
+                     b->dequant, *(b->base_dst) + b->dst,
+                     *(b->base_dst) + b->dst, b->dst_stride, b->dst_stride,
                      xd->plane[0].eobs[i]);
       }
     }
     xd->itxm_add_uv_block(xd->plane[1].qcoeff, xd->block[16].dequant,
-                          xd->predictor + 16 * 16, xd->dst.u_buffer,
+                          xd->dst.u_buffer, xd->dst.uv_stride, xd->dst.u_buffer,
                           xd->dst.uv_stride, xd->plane[1].eobs);
     xd->itxm_add_uv_block(xd->plane[2].qcoeff, xd->block[16].dequant,
-                          xd->predictor + 16 * 16 + 64, xd->dst.v_buffer,
+                          xd->dst.v_buffer, xd->dst.uv_stride, xd->dst.v_buffer,
                           xd->dst.uv_stride, xd->plane[2].eobs);
   }
 }
@@ -807,9 +819,9 @@ static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
   // do prediction
   if (xd->mode_info_context->mbmi.ref_frame == INTRA_FRAME) {
     if (mode != I8X8_PRED) {
-      vp9_build_intra_predictors_mbuv(xd);
+      vp9_build_intra_predictors_mbuv_s(xd);
       if (mode != B_PRED)
-        vp9_build_intra_predictors_mby(xd);
+        vp9_build_intra_predictors_mby_s(xd);
     }
   } else {
 #if 0  // def DEC_DEBUG
@@ -818,7 +830,7 @@ static void decode_mb(VP9D_COMP *pbi, MACROBLOCKD *xd,
            xd->mode_info_context->mbmi.mode, tx_size,
            xd->mode_info_context->mbmi.interp_filter);
 #endif
-    vp9_build_inter_predictors_mb(xd, mb_row, mb_col);
+    vp9_build_inter_predictors_mb_s(xd, mb_row, mb_col);
   }
 
   if (tx_size == TX_16X16) {
diff --git a/vp9/decoder/vp9_dequantize.h b/vp9/decoder/vp9_dequantize.h
index da9e2b72f..8b53dd9cb 100644
--- a/vp9/decoder/vp9_dequantize.h
+++ b/vp9/decoder/vp9_dequantize.h
@@ -33,13 +33,14 @@ void vp9_dequant_dc_idct_add_y_block_lossless_c(int16_t *q,
                                                 const int16_t *dc);
 
 void vp9_dequant_idct_add_y_block_lossless_c(int16_t *q, const int16_t *dq,
-                                             unsigned char *pre,
+                                             unsigned char *pre, int pre_stride,
                                              unsigned char *dst,
                                              int stride,
                                              struct macroblockd *xd);
 
 void vp9_dequant_idct_add_uv_block_lossless_c(int16_t *q, const int16_t *dq,
                                               unsigned char *pre,
+                                              int pre_stride,
                                               unsigned char *dst,
                                               int stride,
                                               uint16_t *eobs);
diff --git a/vp9/decoder/vp9_idct_blk.c b/vp9/decoder/vp9_idct_blk.c
index bcf7dfdb9..0e3560189 100644
--- a/vp9/decoder/vp9_idct_blk.c
+++ b/vp9/decoder/vp9_idct_blk.c
@@ -13,85 +13,86 @@
 #include "vp9/decoder/vp9_dequantize.h"
 
 void vp9_dequant_idct_add_y_block_c(int16_t *q, const int16_t *dq,
-                                    uint8_t *pre,
+                                    uint8_t *pre, int pre_stride,
                                     uint8_t *dst,
                                     int stride, MACROBLOCKD *xd) {
   int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      vp9_dequant_idct_add(q, dq, pre, dst, 16, stride,
+      vp9_dequant_idct_add(q, dq, pre, dst, pre_stride, stride,
                            xd->plane[0].eobs[i * 4  + j]);
       q   += 16;
       pre += 4;
       dst += 4;
     }
 
-    pre += 64 - 16;
+    pre += 4 * pre_stride - 16;
     dst += 4 * stride - 16;
   }
 }
 
 void vp9_dequant_idct_add_uv_block_c(int16_t *q, const int16_t *dq,
-                                     uint8_t *pre, uint8_t *dst,
+                                     uint8_t *pre, int pre_stride, uint8_t *dst,
                                      int stride, uint16_t *eobs) {
   int i, j;
 
   for (i = 0; i < 2; i++) {
     for (j = 0; j < 2; j++) {
-      vp9_dequant_idct_add(q, dq, pre, dst, 8, stride, eobs[i * 2 + j]);
+      vp9_dequant_idct_add(q, dq, pre, dst, pre_stride, stride,
+                           eobs[i * 2 + j]);
       q   += 16;
       pre += 4;
       dst += 4;
     }
 
-    pre  += 32 - 8;
+    pre  += 4 * pre_stride - 8;
     dst += 4 * stride - 8;
   }
 }
 
 void vp9_dequant_idct_add_y_block_8x8_c(int16_t *q, const int16_t *dq,
-                                        uint8_t *pre,
+                                        uint8_t *pre, int pre_stride,
                                         uint8_t *dst,
                                         int stride, MACROBLOCKD *xd) {
   uint8_t *origdest = dst;
   uint8_t *origpred = pre;
 
-  vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, 16, stride,
+  vp9_dequant_idct_add_8x8_c(q, dq, pre, dst, pre_stride, stride,
                              xd->plane[0].eobs[0]);
   vp9_dequant_idct_add_8x8_c(&q[64], dq, origpred + 8,
-                             origdest + 8, 16, stride,
+                             origdest + 8, pre_stride, stride,
                              xd->plane[0].eobs[4]);
-  vp9_dequant_idct_add_8x8_c(&q[128], dq, origpred + 8 * 16,
-                             origdest + 8 * stride, 16, stride,
+  vp9_dequant_idct_add_8x8_c(&q[128], dq, origpred + 8 * pre_stride,
+                             origdest + 8 * stride, pre_stride, stride,
                              xd->plane[0].eobs[8]);
-  vp9_dequant_idct_add_8x8_c(&q[192], dq, origpred + 8 * 16 + 8,
-                             origdest + 8 * stride + 8, 16, stride,
+  vp9_dequant_idct_add_8x8_c(&q[192], dq, origpred + 8 * pre_stride + 8,
+                             origdest + 8 * stride + 8, pre_stride, stride,
                              xd->plane[0].eobs[12]);
 }
 
 void vp9_dequant_idct_add_y_block_lossless_c(int16_t *q, const int16_t *dq,
-                                             uint8_t *pre,
+                                             uint8_t *pre, int pre_stride,
                                              uint8_t *dst,
                                              int stride, MACROBLOCKD *xd) {
   int i, j;
 
   for (i = 0; i < 4; i++) {
     for (j = 0; j < 4; j++) {
-      vp9_dequant_idct_add_lossless_c(q, dq, pre, dst, 16, stride,
+      vp9_dequant_idct_add_lossless_c(q, dq, pre, dst, pre_stride, stride,
                                       xd->plane[0].eobs[i * 4 + j]);
       q   += 16;
       pre += 4;
       dst += 4;
     }
 
-    pre += 64 - 16;
+    pre += 4 * pre_stride - 16;
     dst += 4 * stride - 16;
   }
 }
 
 void vp9_dequant_idct_add_uv_block_lossless_c(int16_t *q, const int16_t *dq,
-                                              uint8_t *pre,
+                                              uint8_t *pre, int pre_stride,
                                               uint8_t *dst,
                                               int stride,
                                               uint16_t *eobs) {
@@ -99,14 +100,14 @@ void vp9_dequant_idct_add_uv_block_lossless_c(int16_t *q, const int16_t *dq,
 
   for (i = 0; i < 2; i++) {
     for (j = 0; j < 2; j++) {
-      vp9_dequant_idct_add_lossless_c(q, dq, pre, dst, 8, stride,
+      vp9_dequant_idct_add_lossless_c(q, dq, pre, dst, pre_stride, stride,
                                       eobs[i * 2 + j]);
       q   += 16;
       pre += 4;
       dst += 4;
     }
 
-    pre += 32 - 8;
+    pre += 4 * pre_stride - 8;
     dst += 4 * stride - 8;
   }
 }