From: Scott LaVarnway Date: Wed, 30 Mar 2016 11:47:39 +0000 (-0700) Subject: VP9: Eliminate up_available and left_available X-Git-Tag: v1.6.0~267^2 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=ba962a5f370d85a5fb8abf8aa67c7d5fb416f01c;p=libvpx VP9: Eliminate up_available and left_available Use above_mi and left_mi instead. Change-Id: I0b50e232c31d11da30aa2fb6f91a695aaf725e0c --- diff --git a/vp9/common/vp9_blockd.h b/vp9/common/vp9_blockd.h index ae2f66a4a..3ff86b432 100644 --- a/vp9/common/vp9_blockd.h +++ b/vp9/common/vp9_blockd.h @@ -158,9 +158,6 @@ typedef struct macroblockd { MODE_INFO *left_mi; MODE_INFO *above_mi; - int up_available; - int left_available; - const vpx_prob (*partition_probs)[PARTITION_TYPES - 1]; /* Distance of MB away from frame edges */ diff --git a/vp9/common/vp9_onyxc_int.h b/vp9/common/vp9_onyxc_int.h index fd674cbc6..3fd935e62 100644 --- a/vp9/common/vp9_onyxc_int.h +++ b/vp9/common/vp9_onyxc_int.h @@ -404,20 +404,8 @@ static INLINE void set_mi_row_col(MACROBLOCKD *xd, const TileInfo *const tile, xd->mb_to_right_edge = ((mi_cols - bw - mi_col) * MI_SIZE) * 8; // Are edges available for intra prediction? - xd->up_available = (mi_row != 0); - xd->left_available = (mi_col > tile->mi_col_start); - // TODO(slavarnway): eliminate up/left available ??? - if (xd->up_available) { - xd->above_mi = xd->mi[-xd->mi_stride]; - } else { - xd->above_mi = NULL; - } - - if (xd->left_available) { - xd->left_mi = xd->mi[-1]; - } else { - xd->left_mi = NULL; - } + xd->above_mi = (mi_row != 0) ? xd->mi[-xd->mi_stride] : NULL; + xd->left_mi = (mi_col > tile->mi_col_start) ? xd->mi[-1] : NULL; } static INLINE void update_partition_context(MACROBLOCKD *xd, diff --git a/vp9/common/vp9_pred_common.c b/vp9/common/vp9_pred_common.c index c201890a8..92dc85ad4 100644 --- a/vp9/common/vp9_pred_common.c +++ b/vp9/common/vp9_pred_common.c @@ -20,10 +20,10 @@ int vp9_get_pred_context_switchable_interp(const MACROBLOCKD *xd) { // left of the entries corresponding to real macroblocks. // The prediction flags in these dummy entries are initialized to 0. const MODE_INFO *const left_mi = xd->left_mi; - const int left_type = xd->left_available && is_inter_block(left_mi) ? + const int left_type = left_mi && is_inter_block(left_mi) ? left_mi->interp_filter : SWITCHABLE_FILTERS; const MODE_INFO *const above_mi = xd->above_mi; - const int above_type = xd->up_available && is_inter_block(above_mi) ? + const int above_type = above_mi && is_inter_block(above_mi) ? above_mi->interp_filter : SWITCHABLE_FILTERS; if (left_type == above_type) @@ -46,8 +46,8 @@ int vp9_get_pred_context_switchable_interp(const MACROBLOCKD *xd) { int vp9_get_intra_inter_context(const MACROBLOCKD *xd) { const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int has_above = xd->up_available; - const int has_left = xd->left_available; + const int has_above = !!above_mi; + const int has_left = !!left_mi; if (has_above && has_left) { // both edges available const int above_intra = !is_inter_block(above_mi); @@ -66,8 +66,8 @@ int vp9_get_reference_mode_context(const VP9_COMMON *cm, int ctx; const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int has_above = xd->up_available; - const int has_left = xd->left_available; + const int has_above = !!above_mi; + const int has_left = !!left_mi; // Note: // The mode info data structure has a one element border above and to the // left of the entries corresponding to real macroblocks. @@ -109,8 +109,8 @@ int vp9_get_pred_context_comp_ref_p(const VP9_COMMON *cm, int pred_context; const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int above_in_image = xd->up_available; - const int left_in_image = xd->left_available; + const int above_in_image = !!above_mi; + const int left_in_image = !!left_mi; // Note: // The mode info data structure has a one element border above and to the @@ -190,8 +190,8 @@ int vp9_get_pred_context_single_ref_p1(const MACROBLOCKD *xd) { int pred_context; const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int has_above = xd->up_available; - const int has_left = xd->left_available; + const int has_above = !!above_mi; + const int has_left = !!left_mi; // Note: // The mode info data structure has a one element border above and to the // left of the entries corresponding to real macroblocks. @@ -256,8 +256,8 @@ int vp9_get_pred_context_single_ref_p2(const MACROBLOCKD *xd) { int pred_context; const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int has_above = xd->up_available; - const int has_left = xd->left_available; + const int has_above = !!above_mi; + const int has_left = !!left_mi; // Note: // The mode info data structure has a one element border above and to the diff --git a/vp9/common/vp9_pred_common.h b/vp9/common/vp9_pred_common.h index 254cb8b74..494286226 100644 --- a/vp9/common/vp9_pred_common.h +++ b/vp9/common/vp9_pred_common.h @@ -113,8 +113,8 @@ static INLINE int get_tx_size_context(const MACROBLOCKD *xd) { const int max_tx_size = max_txsize_lookup[xd->mi[0]->sb_type]; const MODE_INFO *const above_mi = xd->above_mi; const MODE_INFO *const left_mi = xd->left_mi; - const int has_above = xd->up_available; - const int has_left = xd->left_available; + const int has_above = !!above_mi; + const int has_left = !!left_mi; int above_ctx = (has_above && !above_mi->skip) ? (int)above_mi->tx_size : max_tx_size; int left_ctx = (has_left && !left_mi->skip) ? (int)left_mi->tx_size diff --git a/vp9/common/vp9_reconintra.c b/vp9/common/vp9_reconintra.c index 13a95ae8f..c4d91c825 100644 --- a/vp9/common/vp9_reconintra.c +++ b/vp9/common/vp9_reconintra.c @@ -425,8 +425,8 @@ void vp9_predict_intra_block(const MACROBLOCKD *xd, int bwl_in, int aoff, int loff, int plane) { const int bw = (1 << bwl_in); const int txw = (1 << tx_size); - const int have_top = loff || xd->up_available; - const int have_left = aoff || xd->left_available; + const int have_top = loff || (xd->above_mi != NULL); + const int have_left = aoff || (xd->left_mi != NULL); const int have_right = (aoff + txw) < bw; const int x = aoff * 4; const int y = loff * 4; diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c index 40b332ac8..41b94bf2b 100644 --- a/vp9/encoder/vp9_encodeframe.c +++ b/vp9/encoder/vp9_encodeframe.c @@ -1228,10 +1228,10 @@ static void set_mode_info_seg_skip(MACROBLOCK *x, TX_MODE tx_mode, MODE_INFO *const mi = xd->mi[0]; INTERP_FILTER filter_ref; - if (xd->up_available) - filter_ref = xd->mi[-xd->mi_stride]->interp_filter; - else if (xd->left_available) - filter_ref = xd->mi[-1]->interp_filter; + if (xd->above_mi) + filter_ref = xd->above_mi->interp_filter; + else if (xd->left_mi) + filter_ref = xd->left_mi->interp_filter; else filter_ref = EIGHTTAP; @@ -2266,8 +2266,8 @@ static void rd_auto_partition_range(VP9_COMP *cpi, const TileInfo *const tile, BLOCK_SIZE *max_block_size) { VP9_COMMON *const cm = &cpi->common; MODE_INFO **mi = xd->mi; - const int left_in_image = xd->left_available && mi[-1]; - const int above_in_image = xd->up_available && mi[-xd->mi_stride]; + const int left_in_image = !!xd->left_mi; + const int above_in_image = !!xd->above_mi; const int row8x8_remaining = tile->mi_row_end - mi_row; const int col8x8_remaining = tile->mi_col_end - mi_col; int bh, bw; @@ -2362,7 +2362,7 @@ static void set_partition_range(VP9_COMMON *cm, MACROBLOCKD *xd, } } - if (xd->left_available) { + if (xd->left_mi) { for (idy = 0; idy < mi_height; ++idy) { mi = xd->mi[idy * cm->mi_stride - 1]; bs = mi ? mi->sb_type : bsize; @@ -2371,7 +2371,7 @@ static void set_partition_range(VP9_COMMON *cm, MACROBLOCKD *xd, } } - if (xd->up_available) { + if (xd->above_mi) { for (idx = 0; idx < mi_width; ++idx) { mi = xd->mi[idx - cm->mi_stride]; bs = mi ? mi->sb_type : bsize; diff --git a/vp9/encoder/vp9_firstpass.c b/vp9/encoder/vp9_firstpass.c index 10fd6c02c..3ad175eb2 100644 --- a/vp9/encoder/vp9_firstpass.c +++ b/vp9/encoder/vp9_firstpass.c @@ -563,6 +563,7 @@ void vp9_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) { double intra_factor; double brightness_factor; BufferPool *const pool = cm->buffer_pool; + MODE_INFO mi_above, mi_left; // First pass code requires valid last and new frame buffers. assert(new_yv12 != NULL); @@ -695,6 +696,12 @@ void vp9_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) { mb_row << 1, num_8x8_blocks_high_lookup[bsize], mb_col << 1, num_8x8_blocks_wide_lookup[bsize], cm->mi_rows, cm->mi_cols); + // Are edges available for intra prediction? + // Since the firstpass does not populate the mi_grid_visible, + // above_mi/left_mi must be overwritten with a nonzero value when edges + // are available. Required by vp9_predict_intra_block(). + xd->above_mi = (mb_row != 0) ? &mi_above : NULL; + xd->left_mi = (mb_col > tile.mi_col_start) ? &mi_left : NULL; // Do intra 16x16 prediction. x->skip_encode = 0; diff --git a/vp9/encoder/vp9_mbgraph.c b/vp9/encoder/vp9_mbgraph.c index 7ce86b45d..3ae5b21a9 100644 --- a/vp9/encoder/vp9_mbgraph.c +++ b/vp9/encoder/vp9_mbgraph.c @@ -243,13 +243,16 @@ static void update_mbgraph_frame_stats(VP9_COMP *cpi, int mb_y_offset = 0, arf_y_offset = 0, gld_y_offset = 0; MV gld_top_mv = {0, 0}; MODE_INFO mi_local; + MODE_INFO mi_above, mi_left; vp9_zero(mi_local); // Set up limit values for motion vectors to prevent them extending outside // the UMV borders. x->mv_row_min = -BORDER_MV_PIXELS_B16; x->mv_row_max = (cm->mb_rows - 1) * 8 + BORDER_MV_PIXELS_B16; - xd->up_available = 0; + // Signal to vp9_predict_intra_block() that above is not available + xd->above_mi = NULL; + xd->plane[0].dst.stride = buf->y_stride; xd->plane[0].pre[0].stride = buf->y_stride; xd->plane[1].dst.stride = buf->uv_stride; @@ -268,7 +271,8 @@ static void update_mbgraph_frame_stats(VP9_COMP *cpi, // the UMV borders. x->mv_col_min = -BORDER_MV_PIXELS_B16; x->mv_col_max = (cm->mb_cols - 1) * 8 + BORDER_MV_PIXELS_B16; - xd->left_available = 0; + // Signal to vp9_predict_intra_block() that left is not available + xd->left_mi = NULL; for (mb_col = 0; mb_col < cm->mb_cols; mb_col++) { MBGRAPH_MB_STATS *mb_stats = &stats->mb_stats[offset + mb_col]; @@ -280,14 +284,19 @@ static void update_mbgraph_frame_stats(VP9_COMP *cpi, if (mb_col == 0) { gld_top_mv = gld_left_mv; } - xd->left_available = 1; + // Signal to vp9_predict_intra_block() that left is available + xd->left_mi = &mi_left; + mb_y_in_offset += 16; gld_y_in_offset += 16; arf_y_in_offset += 16; x->mv_col_min -= 16; x->mv_col_max -= 16; } - xd->up_available = 1; + + // Signal to vp9_predict_intra_block() that above is available + xd->above_mi = &mi_above; + mb_y_offset += buf->y_stride * 16; gld_y_offset += golden_ref->y_stride * 16; if (alt_ref) diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c index 8b2e98549..2057dca3a 100644 --- a/vp9/encoder/vp9_pickmode.c +++ b/vp9/encoder/vp9_pickmode.c @@ -1017,8 +1017,8 @@ void vp9_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost, tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); MODE_INFO *const mic = xd->mi[0]; int *bmode_costs; - const MODE_INFO *above_mi = xd->mi[-xd->mi_stride]; - const MODE_INFO *left_mi = xd->left_available ? xd->mi[-1] : NULL; + const MODE_INFO *above_mi = xd->above_mi; + const MODE_INFO *left_mi = xd->left_mi; const PREDICTION_MODE A = vp9_above_block_mode(mic, above_mi, 0); const PREDICTION_MODE L = vp9_left_block_mode(mic, left_mi, 0); bmode_costs = cpi->y_mode_costs[A][L]; @@ -1242,10 +1242,10 @@ void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; x->skip = 0; - if (xd->up_available) - filter_ref = xd->mi[-xd->mi_stride]->interp_filter; - else if (xd->left_available) - filter_ref = xd->mi[-1]->interp_filter; + if (xd->above_mi) + filter_ref = xd->above_mi->interp_filter; + else if (xd->left_mi) + filter_ref = xd->left_mi->interp_filter; else filter_ref = cm->interp_filter; diff --git a/vp9/encoder/vp9_rdopt.c b/vp9/encoder/vp9_rdopt.c index 508c59663..a30418286 100644 --- a/vp9/encoder/vp9_rdopt.c +++ b/vp9/encoder/vp9_rdopt.c @@ -2460,10 +2460,10 @@ static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, if (pred_filter_search) { INTERP_FILTER af = SWITCHABLE, lf = SWITCHABLE; - if (xd->up_available) - af = xd->mi[-xd->mi_stride]->interp_filter; - if (xd->left_available) - lf = xd->mi[-1]->interp_filter; + if (xd->above_mi) + af = xd->above_mi->interp_filter; + if (xd->left_mi) + lf = xd->left_mi->interp_filter; if ((this_mode != NEWMV) || (af == lf)) best_filter = af;