From cc6dc0b7d9ded31b23523b251c074704f5fe6fd4 Mon Sep 17 00:00:00 2001 From: Yunqing Wang Date: Mon, 6 Jul 2015 10:03:23 -0700 Subject: [PATCH] Nextgen branch cleanup: remove nonrd code Code cleanup. Change-Id: I4d8d7fa2fc61a58b819c9a18bf25cda53e3fd88c --- vp9/encoder/vp9_aq_cyclicrefresh.c | 7 - vp9/encoder/vp9_encodeframe.c | 691 +--------------------- vp9/encoder/vp9_encoder.c | 4 +- vp9/encoder/vp9_pickmode.c | 903 ----------------------------- vp9/encoder/vp9_pickmode.h | 30 - vp9/encoder/vp9_ratectrl.c | 10 +- vp9/encoder/vp9_rd.c | 65 +-- vp9/encoder/vp9_speed_features.c | 2 - vp9/encoder/vp9_speed_features.h | 3 - vp9/vp9cx.mk | 2 - 10 files changed, 34 insertions(+), 1683 deletions(-) delete mode 100644 vp9/encoder/vp9_pickmode.c delete mode 100644 vp9/encoder/vp9_pickmode.h diff --git a/vp9/encoder/vp9_aq_cyclicrefresh.c b/vp9/encoder/vp9_aq_cyclicrefresh.c index 514ff7a52..190683137 100644 --- a/vp9/encoder/vp9_aq_cyclicrefresh.c +++ b/vp9/encoder/vp9_aq_cyclicrefresh.c @@ -211,13 +211,6 @@ void vp9_cyclic_refresh_setup(VP9_COMP *const cpi) { cr->thresh_rate_sb = (rc->sb64_target_rate * 256) >> 2; // Distortion threshold, quadratic in Q, scale factor to be adjusted. cr->thresh_dist_sb = 8 * (int)(q * q); - if (cpi->sf.use_nonrd_pick_mode) { - // May want to be more conservative with thresholds in non-rd mode for now - // as rate/distortion are derived from model based on prediction residual. - cr->thresh_rate_sb = (rc->sb64_target_rate * 256) >> 3; - cr->thresh_dist_sb = 4 * (int)(q * q); - } - cr->num_seg_blocks = 0; // Set up segmentation. // Clear down the segment map. diff --git a/vp9/encoder/vp9_encodeframe.c b/vp9/encoder/vp9_encodeframe.c index 653dbee75..5ab18872e 100644 --- a/vp9/encoder/vp9_encodeframe.c +++ b/vp9/encoder/vp9_encodeframe.c @@ -46,7 +46,6 @@ #include "vp9/encoder/vp9_encodemb.h" #include "vp9/encoder/vp9_encodemv.h" #include "vp9/encoder/vp9_extend.h" -#include "vp9/encoder/vp9_pickmode.h" #include "vp9/encoder/vp9_rd.h" #include "vp9/encoder/vp9_rdopt.h" #include "vp9/encoder/vp9_segmentation.h" @@ -235,20 +234,6 @@ static BLOCK_SIZE get_rd_var_based_fixed_partition(VP9_COMP *cpi, return BLOCK_8X8; } -static BLOCK_SIZE get_nonrd_var_based_fixed_partition(VP9_COMP *cpi, - int mi_row, - int mi_col) { - unsigned int var = get_sby_perpixel_diff_variance(cpi, &cpi->mb.plane[0].src, - mi_row, mi_col, - BLOCK_64X64); - if (var < 4) - return BLOCK_64X64; - else if (var < 10) - return BLOCK_32X32; - else - return BLOCK_16X16; -} - // Lighter version of set_offsets that only sets the mode info // pointers. static INLINE void set_modeinfo_offsets(VP9_COMMON *const cm, @@ -4297,32 +4282,6 @@ static TX_MODE select_tx_mode(const VP9_COMP *cpi) { return cpi->common.tx_mode; } -static void nonrd_pick_sb_modes(VP9_COMP *cpi, const TileInfo *const tile, - int mi_row, int mi_col, RD_COST *rd_cost, - BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { - VP9_COMMON *const cm = &cpi->common; - MACROBLOCK *const x = &cpi->mb; - MACROBLOCKD *const xd = &x->e_mbd; - MB_MODE_INFO *mbmi; - set_offsets(cpi, tile, mi_row, mi_col, bsize); - mbmi = &xd->mi[0].src_mi->mbmi; - mbmi->sb_type = bsize; - - if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled) - if (mbmi->segment_id && x->in_static_area) - x->rdmult = vp9_cyclic_refresh_get_rdmult(cpi->cyclic_refresh); - - if (vp9_segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) - set_mode_info_seg_skip(cm, x, rd_cost, bsize); - else - vp9_pick_inter_mode(cpi, x, tile, mi_row, mi_col, rd_cost, bsize, ctx); - - duplicate_mode_info_in_sb(cm, xd, mi_row, mi_col, bsize); - - if (rd_cost->rate == INT_MAX) - vp9_rd_cost_reset(rd_cost); -} - static void fill_mode_info_sb(VP9_COMMON *cm, MACROBLOCK *x, int mi_row, int mi_col, BLOCK_SIZE bsize, BLOCK_SIZE subsize, @@ -4381,632 +4340,6 @@ static void fill_mode_info_sb(VP9_COMMON *cm, MACROBLOCK *x, } } -static void nonrd_initialize_pick_mode_context(PICK_MODE_CONTEXT *pick_mode_ctx, - MACROBLOCK *const x) { - MACROBLOCKD *const xd = &x->e_mbd; - pick_mode_ctx->mic.mbmi = xd->mi[0].src_mi->mbmi; - pick_mode_ctx->skip_txfm[0] = x->skip_txfm[0]; - pick_mode_ctx->skip = x->skip; -} - -static void nonrd_increment_rate_distortion(RD_COST *rd_cost, - RD_COST *increment) { - if (increment->rate != INT_MAX && increment->dist != INT64_MAX && - rd_cost->rate != INT_MAX && rd_cost->dist != INT64_MAX) { - rd_cost->rate += increment->rate; - rd_cost->dist += increment->dist; - } -} - -static void nonrd_pick_partition(VP9_COMP *cpi, const TileInfo *const tile, - TOKENEXTRA **tp, int mi_row, - int mi_col, BLOCK_SIZE bsize, RD_COST *rd_cost, - int do_recon, int64_t best_rd, - PC_TREE *pc_tree) { - const SPEED_FEATURES *const sf = &cpi->sf; - const VP9EncoderConfig *const oxcf = &cpi->oxcf; - VP9_COMMON *const cm = &cpi->common; - MACROBLOCK *const x = &cpi->mb; - MACROBLOCKD *const xd = &x->e_mbd; - const int ms = num_8x8_blocks_wide_lookup[bsize] / 2; - TOKENEXTRA *tp_orig = *tp; - PICK_MODE_CONTEXT *ctx = &pc_tree->none; - int i; - BLOCK_SIZE subsize = bsize; - RD_COST this_rdc, sum_rdc, best_rdc; - int do_split = bsize >= BLOCK_8X8; - int do_rect = 1; - // Override skipping rectangular partition operations for edge blocks - const int force_horz_split = (mi_row + ms >= cm->mi_rows); - const int force_vert_split = (mi_col + ms >= cm->mi_cols); - const int xss = x->e_mbd.plane[1].subsampling_x; - const int yss = x->e_mbd.plane[1].subsampling_y; - - int partition_none_allowed = !force_horz_split && !force_vert_split; - int partition_horz_allowed = !force_vert_split && yss <= xss && - bsize >= BLOCK_8X8; - int partition_vert_allowed = !force_horz_split && xss <= yss && - bsize >= BLOCK_8X8; - (void) *tp_orig; - - assert(num_8x8_blocks_wide_lookup[bsize] == - num_8x8_blocks_high_lookup[bsize]); - - vp9_rd_cost_init(&sum_rdc); - vp9_rd_cost_reset(&best_rdc); - best_rdc.rdcost = best_rd; - - // Determine partition types in search according to the speed features. - // The threshold set here has to be of square block size. - if (sf->auto_min_max_partition_size) { - partition_none_allowed &= (bsize <= sf->max_partition_size && - bsize >= sf->min_partition_size); - partition_horz_allowed &= ((bsize <= sf->max_partition_size && - bsize > sf->min_partition_size) || - force_horz_split); - partition_vert_allowed &= ((bsize <= sf->max_partition_size && - bsize > sf->min_partition_size) || - force_vert_split); - do_split &= bsize > sf->min_partition_size; - } - if (sf->use_square_partition_only) { - partition_horz_allowed &= force_horz_split; - partition_vert_allowed &= force_vert_split; - } - - // PARTITION_NONE - if (partition_none_allowed) { - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, - &this_rdc, bsize, ctx); - nonrd_initialize_pick_mode_context(ctx, x); - ctx->pred_pixel_ready = 0; - - if (this_rdc.rate != INT_MAX) { - int pl = partition_plane_context(xd, mi_row, mi_col, bsize); - this_rdc.rate += cpi->partition_cost[pl][PARTITION_NONE]; - this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - this_rdc.rate, this_rdc.dist); - if (this_rdc.rdcost < best_rdc.rdcost) { - int64_t dist_breakout_thr = sf->partition_search_breakout_dist_thr; - int64_t rate_breakout_thr = sf->partition_search_breakout_rate_thr; - - dist_breakout_thr >>= 8 - (b_width_log2_lookup[bsize] + - b_height_log2_lookup[bsize]); - - rate_breakout_thr *= num_pels_log2_lookup[bsize]; - - best_rdc = this_rdc; - if (bsize >= BLOCK_8X8) - pc_tree->partitioning = PARTITION_NONE; - - if (!x->e_mbd.lossless && - this_rdc.rate < rate_breakout_thr && - this_rdc.dist < dist_breakout_thr) { - do_split = 0; - do_rect = 0; - } - } - } - } - - // store estimated motion vector - store_pred_mv(x, ctx); - - // PARTITION_SPLIT - if (do_split) { - int pl = partition_plane_context(xd, mi_row, mi_col, bsize); - sum_rdc.rate += cpi->partition_cost[pl][PARTITION_SPLIT]; - sum_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, sum_rdc.rate, sum_rdc.dist); - subsize = get_subsize(bsize, PARTITION_SPLIT); - for (i = 0; i < 4 && sum_rdc.rdcost < best_rdc.rdcost; ++i) { - const int x_idx = (i & 1) * ms; - const int y_idx = (i >> 1) * ms; - - if (mi_row + y_idx >= cm->mi_rows || mi_col + x_idx >= cm->mi_cols) - continue; - load_pred_mv(x, ctx); - nonrd_pick_partition(cpi, tile, tp, mi_row + y_idx, mi_col + x_idx, - subsize, &this_rdc, 0, - best_rdc.rdcost - sum_rdc.rdcost, pc_tree->split[i]); - - if (this_rdc.rate == INT_MAX) { - vp9_rd_cost_reset(&sum_rdc); - } else { - nonrd_increment_rate_distortion(&sum_rdc, &this_rdc); - sum_rdc.rdcost += this_rdc.rdcost; - } - } - - if (sum_rdc.rdcost < best_rdc.rdcost) { - best_rdc = sum_rdc; - pc_tree->partitioning = PARTITION_SPLIT; - } else { - // skip rectangular partition test when larger block size - // gives better rd cost - if (sf->less_rectangular_check) - do_rect &= !partition_none_allowed; - } - } - - // PARTITION_HORZ - if (partition_horz_allowed && do_rect) { - subsize = get_subsize(bsize, PARTITION_HORZ); - if (sf->adaptive_motion_search) - load_pred_mv(x, ctx); - - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, &sum_rdc, subsize, - &pc_tree->horizontal[0]); - - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[0], x); - pc_tree->horizontal[0].pred_pixel_ready = 0; - - if (sum_rdc.rdcost < best_rdc.rdcost && mi_row + ms < cm->mi_rows) { - load_pred_mv(x, ctx); - nonrd_pick_sb_modes(cpi, tile, mi_row + ms, mi_col, &this_rdc, subsize, - &pc_tree->horizontal[1]); - - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[1], x); - pc_tree->horizontal[1].pred_pixel_ready = 0; - - if (this_rdc.rate == INT_MAX) { - vp9_rd_cost_reset(&sum_rdc); - } else { - int pl = partition_plane_context(xd, mi_row, mi_col, bsize); - this_rdc.rate += cpi->partition_cost[pl][PARTITION_HORZ]; - nonrd_increment_rate_distortion(&sum_rdc, &this_rdc); - sum_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - sum_rdc.rate, sum_rdc.dist); - } - } - - if (sum_rdc.rdcost < best_rdc.rdcost) { - best_rdc = sum_rdc; - pc_tree->partitioning = PARTITION_HORZ; - } - } - - // PARTITION_VERT - if (partition_vert_allowed && do_rect) { - subsize = get_subsize(bsize, PARTITION_VERT); - - if (sf->adaptive_motion_search) - load_pred_mv(x, ctx); - - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, &sum_rdc, subsize, - &pc_tree->vertical[0]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[0], x); - pc_tree->vertical[0].pred_pixel_ready = 0; - - if (sum_rdc.rdcost < best_rdc.rdcost && mi_col + ms < cm->mi_cols) { - load_pred_mv(x, ctx); - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col + ms, &this_rdc, subsize, - &pc_tree->vertical[1]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[1], x); - pc_tree->vertical[1].pred_pixel_ready = 0; - - if (this_rdc.rate == INT_MAX) { - vp9_rd_cost_reset(&sum_rdc); - } else { - int pl = partition_plane_context(xd, mi_row, mi_col, bsize); - sum_rdc.rate += cpi->partition_cost[pl][PARTITION_VERT]; - nonrd_increment_rate_distortion(&sum_rdc, &this_rdc); - sum_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - sum_rdc.rate, sum_rdc.dist); - } - } - - if (sum_rdc.rdcost < best_rdc.rdcost) { - best_rdc = sum_rdc; - pc_tree->partitioning = PARTITION_VERT; - } - } - - *rd_cost = best_rdc; - - if (best_rdc.rate == INT_MAX) { - vp9_rd_cost_reset(rd_cost); - return; - } - - // update mode info array - subsize = get_subsize(bsize, pc_tree->partitioning); - fill_mode_info_sb(cm, x, mi_row, mi_col, bsize, subsize, - pc_tree); - - if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX && do_recon) { - int output_enabled = (bsize == BLOCK_64X64); - - // Check the projected output rate for this SB against it's target - // and and if necessary apply a Q delta using segmentation to get - // closer to the target. - if ((oxcf->aq_mode == COMPLEXITY_AQ) && cm->seg.update_map) { - vp9_select_in_frame_q_segment(cpi, mi_row, mi_col, output_enabled, - best_rdc.rate); - } - - if (oxcf->aq_mode == CYCLIC_REFRESH_AQ) - vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh, - best_rdc.rate, best_rdc.dist); - - encode_sb_rt(cpi, tile, tp, mi_row, mi_col, output_enabled, bsize, pc_tree); - } - - if (bsize == BLOCK_64X64) { - assert(tp_orig < *tp); - assert(best_rdc.rate < INT_MAX); - assert(best_rdc.dist < INT64_MAX); - } else { - assert(tp_orig == *tp); - } -} - - - -static void nonrd_select_partition(VP9_COMP *cpi, - const TileInfo *const tile, - MODE_INFO *mi, - TOKENEXTRA **tp, - int mi_row, int mi_col, - BLOCK_SIZE bsize, int output_enabled, - RD_COST *rd_cost, PC_TREE *pc_tree) { - VP9_COMMON *const cm = &cpi->common; - MACROBLOCK *const x = &cpi->mb; - const int bsl = b_width_log2_lookup[bsize], hbs = (1 << bsl) / 4; - const int mis = cm->mi_stride; - PARTITION_TYPE partition; - BLOCK_SIZE subsize; - RD_COST this_rdc; - - vp9_rd_cost_reset(&this_rdc); - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) - return; - - subsize = (bsize >= BLOCK_8X8) ? mi[0].src_mi->mbmi.sb_type : BLOCK_4X4; - partition = partition_lookup[bsl][subsize]; - - if (bsize == BLOCK_32X32 && partition != PARTITION_NONE && - subsize >= BLOCK_16X16) { - cpi->sf.max_partition_size = BLOCK_32X32; - cpi->sf.min_partition_size = BLOCK_8X8; - nonrd_pick_partition(cpi, tile, tp, mi_row, mi_col, bsize, - rd_cost, 0, INT64_MAX, pc_tree); - } else if (bsize == BLOCK_16X16 && partition != PARTITION_NONE) { - cpi->sf.max_partition_size = BLOCK_16X16; - cpi->sf.min_partition_size = BLOCK_8X8; - nonrd_pick_partition(cpi, tile, tp, mi_row, mi_col, bsize, - rd_cost, 0, INT64_MAX, pc_tree); - } else { - switch (partition) { - case PARTITION_NONE: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->none); - nonrd_initialize_pick_mode_context(&pc_tree->none, x); - pc_tree->none.pred_pixel_ready = 1; - break; - case PARTITION_VERT: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->vertical[0]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[0], x); - pc_tree->vertical[0].pred_pixel_ready = 1; - if (mi_col + hbs < cm->mi_cols) { - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col + hbs, - &this_rdc, subsize, &pc_tree->vertical[1]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[1], x); - pc_tree->vertical[1].pred_pixel_ready = 1; - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - } - break; - case PARTITION_HORZ: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->horizontal[0]); - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[0], x); - pc_tree->horizontal[0].pred_pixel_ready = 1; - if (mi_row + hbs < cm->mi_rows) { - nonrd_pick_sb_modes(cpi, tile, mi_row + hbs, mi_col, - &this_rdc, subsize, &pc_tree->horizontal[0]); - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[1], x); - pc_tree->horizontal[1].pred_pixel_ready = 1; - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - } - break; - case PARTITION_SPLIT: - subsize = get_subsize(bsize, PARTITION_SPLIT); - nonrd_select_partition(cpi, tile, mi, tp, mi_row, mi_col, - subsize, output_enabled, rd_cost, - pc_tree->split[0]); - nonrd_select_partition(cpi, tile, mi + hbs, tp, - mi_row, mi_col + hbs, subsize, output_enabled, - &this_rdc, pc_tree->split[1]); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - nonrd_select_partition(cpi, tile, mi + hbs * mis, tp, - mi_row + hbs, mi_col, subsize, output_enabled, - &this_rdc, pc_tree->split[2]); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - nonrd_select_partition(cpi, tile, mi + hbs * mis + hbs, tp, - mi_row + hbs, mi_col + hbs, subsize, - output_enabled, &this_rdc, pc_tree->split[3]); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - break; - default: - assert(0 && "Invalid partition type."); - break; - } - } - - if (bsize == BLOCK_64X64 && output_enabled) { - if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) - vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh, - rd_cost->rate, rd_cost->dist); - encode_sb_rt(cpi, tile, tp, mi_row, mi_col, 1, bsize, pc_tree); - } -} - -static void nonrd_use_partition(VP9_COMP *cpi, - const TileInfo *const tile, - MODE_INFO *mi, - TOKENEXTRA **tp, - int mi_row, int mi_col, - BLOCK_SIZE bsize, int output_enabled, - RD_COST *rd_cost, PC_TREE *pc_tree) { - VP9_COMMON *const cm = &cpi->common; - MACROBLOCK *const x = &cpi->mb; - const int bsl = b_width_log2_lookup[bsize], hbs = (1 << bsl) / 4; - const int mis = cm->mi_stride; - PARTITION_TYPE partition; - BLOCK_SIZE subsize; - RD_COST this_rdc; - - vp9_rd_cost_reset(&this_rdc); - if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols) - return; - - subsize = (bsize >= BLOCK_8X8) ? mi[0].src_mi->mbmi.sb_type : BLOCK_4X4; - partition = partition_lookup[bsl][subsize]; - - switch (partition) { - case PARTITION_NONE: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->none); - nonrd_initialize_pick_mode_context(&pc_tree->none, x); - break; - case PARTITION_VERT: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->vertical[0]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[0], x); - if (mi_col + hbs < cm->mi_cols) { - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col + hbs, - &this_rdc, subsize, &pc_tree->vertical[1]); - nonrd_initialize_pick_mode_context(&pc_tree->vertical[1], x); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - } - break; - case PARTITION_HORZ: - nonrd_pick_sb_modes(cpi, tile, mi_row, mi_col, rd_cost, - subsize, &pc_tree->horizontal[0]); - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[0], x); - if (mi_row + hbs < cm->mi_rows) { - nonrd_pick_sb_modes(cpi, tile, mi_row + hbs, mi_col, - &this_rdc, subsize, &pc_tree->horizontal[0]); - nonrd_initialize_pick_mode_context(&pc_tree->horizontal[1], x); - - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - } - break; - case PARTITION_SPLIT: - subsize = get_subsize(bsize, PARTITION_SPLIT); - nonrd_use_partition(cpi, tile, mi, tp, mi_row, mi_col, - subsize, output_enabled, rd_cost, - pc_tree->split[0]); - nonrd_use_partition(cpi, tile, mi + hbs, tp, - mi_row, mi_col + hbs, subsize, output_enabled, - &this_rdc, pc_tree->split[1]); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - nonrd_use_partition(cpi, tile, mi + hbs * mis, tp, - mi_row + hbs, mi_col, subsize, output_enabled, - &this_rdc, pc_tree->split[2]); - - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - nonrd_use_partition(cpi, tile, mi + hbs * mis + hbs, tp, - mi_row + hbs, mi_col + hbs, subsize, output_enabled, - &this_rdc, pc_tree->split[3]); - nonrd_increment_rate_distortion(rd_cost, &this_rdc); - break; - default: - assert(0 && "Invalid partition type."); - break; - } - - if (bsize == BLOCK_64X64 && output_enabled) { - if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ) - vp9_cyclic_refresh_set_rate_and_dist_sb(cpi->cyclic_refresh, - rd_cost->rate, rd_cost->dist); - encode_sb_rt(cpi, tile, tp, mi_row, mi_col, 1, bsize, pc_tree); - } -} - -static void encode_nonrd_sb_row(VP9_COMP *cpi, const TileInfo *const tile, - int mi_row, TOKENEXTRA **tp) { - SPEED_FEATURES *const sf = &cpi->sf; - VP9_COMMON *const cm = &cpi->common; - MACROBLOCK *const x = &cpi->mb; - MACROBLOCKD *const xd = &x->e_mbd; - int mi_col; - - // Initialize the left context for the new SB row - vpx_memset(&xd->left_context, 0, sizeof(xd->left_context)); - vpx_memset(xd->left_seg_context, 0, sizeof(xd->left_seg_context)); - - // Code each SB in the row - for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end; - mi_col += MI_BLOCK_SIZE) { - RD_COST dummy_rdc; - const int idx_str = cm->mi_stride * mi_row + mi_col; - MODE_INFO *mi = cm->mi + idx_str; - BLOCK_SIZE bsize; - x->in_static_area = 0; - x->source_variance = UINT_MAX; - vp9_zero(x->pred_mv); - vp9_rd_cost_init(&dummy_rdc); - - // Set the partition type of the 64X64 block - switch (sf->partition_search_type) { - case VAR_BASED_PARTITION: - choose_partitioning(cpi, tile, mi_row, mi_col); - nonrd_use_partition(cpi, tile, mi, tp, mi_row, mi_col, BLOCK_64X64, - 1, &dummy_rdc, cpi->pc_root); - break; - case SOURCE_VAR_BASED_PARTITION: - set_source_var_based_partition(cpi, tile, mi, mi_row, mi_col); - nonrd_use_partition(cpi, tile, mi, tp, mi_row, mi_col, BLOCK_64X64, - 1, &dummy_rdc, cpi->pc_root); - break; - case FIXED_PARTITION: - bsize = sf->partition_search_type == FIXED_PARTITION ? - sf->always_this_block_size : - get_nonrd_var_based_fixed_partition(cpi, mi_row, mi_col); - set_fixed_partitioning(cpi, tile, mi, mi_row, mi_col, bsize); - nonrd_use_partition(cpi, tile, mi, tp, mi_row, mi_col, BLOCK_64X64, - 1, &dummy_rdc, cpi->pc_root); - break; - case REFERENCE_PARTITION: - set_offsets(cpi, tile, mi_row, mi_col, BLOCK_64X64); - x->in_static_area = is_background(cpi, tile, mi_row, mi_col); - - if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ && cm->seg.enabled && - xd->mi[0].src_mi->mbmi.segment_id && x->in_static_area) { - auto_partition_range(cpi, tile, mi_row, mi_col, - &sf->min_partition_size, - &sf->max_partition_size); - nonrd_pick_partition(cpi, tile, tp, mi_row, mi_col, BLOCK_64X64, - &dummy_rdc, 1, - INT64_MAX, cpi->pc_root); - } else { - choose_partitioning(cpi, tile, mi_row, mi_col); - nonrd_select_partition(cpi, tile, mi, tp, mi_row, mi_col, BLOCK_64X64, - 1, &dummy_rdc, cpi->pc_root); - } - - break; - default: - assert(0); - break; - } - } -} -// end RTC play code - -static int set_var_thresh_from_histogram(VP9_COMP *cpi) { - const SPEED_FEATURES *const sf = &cpi->sf; - const VP9_COMMON *const cm = &cpi->common; - - const uint8_t *src = cpi->Source->y_buffer; - const uint8_t *last_src = cpi->Last_Source->y_buffer; - const int src_stride = cpi->Source->y_stride; - const int last_stride = cpi->Last_Source->y_stride; - - // Pick cutoff threshold - const int cutoff = (MIN(cm->width, cm->height) >= 720) ? - (cm->MBs * VAR_HIST_LARGE_CUT_OFF / 100) : - (cm->MBs * VAR_HIST_SMALL_CUT_OFF / 100); - DECLARE_ALIGNED_ARRAY(16, int, hist, VAR_HIST_BINS); - diff *var16 = cpi->source_diff_var; - - int sum = 0; - int i, j; - - vpx_memset(hist, 0, VAR_HIST_BINS * sizeof(hist[0])); - - for (i = 0; i < cm->mb_rows; i++) { - for (j = 0; j < cm->mb_cols; j++) { -#if CONFIG_VP9_HIGHBITDEPTH - if (cm->use_highbitdepth) { - switch (cm->bit_depth) { - case VPX_BITS_8: - vp9_highbd_get16x16var(src, src_stride, last_src, last_stride, - &var16->sse, &var16->sum); - break; - case VPX_BITS_10: - vp9_highbd_10_get16x16var(src, src_stride, last_src, last_stride, - &var16->sse, &var16->sum); - break; - case VPX_BITS_12: - vp9_highbd_12_get16x16var(src, src_stride, last_src, last_stride, - &var16->sse, &var16->sum); - break; - default: - assert(0 && "cm->bit_depth should be VPX_BITS_8, VPX_BITS_10" - " or VPX_BITS_12"); - return -1; - } - } else { - vp9_get16x16var(src, src_stride, last_src, last_stride, - &var16->sse, &var16->sum); - } -#else - vp9_get16x16var(src, src_stride, last_src, last_stride, - &var16->sse, &var16->sum); -#endif // CONFIG_VP9_HIGHBITDEPTH - var16->var = var16->sse - - (((uint32_t)var16->sum * var16->sum) >> 8); - - if (var16->var >= VAR_HIST_MAX_BG_VAR) - hist[VAR_HIST_BINS - 1]++; - else - hist[var16->var / VAR_HIST_FACTOR]++; - - src += 16; - last_src += 16; - var16++; - } - - src = src - cm->mb_cols * 16 + 16 * src_stride; - last_src = last_src - cm->mb_cols * 16 + 16 * last_stride; - } - - cpi->source_var_thresh = 0; - - if (hist[VAR_HIST_BINS - 1] < cutoff) { - for (i = 0; i < VAR_HIST_BINS - 1; i++) { - sum += hist[i]; - - if (sum > cutoff) { - cpi->source_var_thresh = (i + 1) * VAR_HIST_FACTOR; - return 0; - } - } - } - - return sf->search_type_check_frequency; -} - -static void source_var_based_partition_search_method(VP9_COMP *cpi) { - VP9_COMMON *const cm = &cpi->common; - SPEED_FEATURES *const sf = &cpi->sf; - - if (cm->frame_type == KEY_FRAME) { - // For key frame, use SEARCH_PARTITION. - sf->partition_search_type = SEARCH_PARTITION; - } else if (cm->intra_only) { - sf->partition_search_type = FIXED_PARTITION; - } else { - if (cm->last_width != cm->width || cm->last_height != cm->height) { - if (cpi->source_diff_var) - vpx_free(cpi->source_diff_var); - - CHECK_MEM_ERROR(cm, cpi->source_diff_var, - vpx_calloc(cm->MBs, sizeof(diff))); - } - - if (!cpi->frames_till_next_var_check) - cpi->frames_till_next_var_check = set_var_thresh_from_histogram(cpi); - - if (cpi->frames_till_next_var_check > 0) { - sf->partition_search_type = FIXED_PARTITION; - cpi->frames_till_next_var_check--; - } - } -} - static int get_skip_encode_frame(const VP9_COMMON *cm) { unsigned int intra_count = 0, inter_count = 0; int j; @@ -5063,9 +4396,6 @@ static void encode_tiles(VP9_COMP *cpi) { for (mi_row = ptile->mi_row_start; mi_row < ptile->mi_row_end; mi_row += MI_BLOCK_SIZE) { - if (cpi->sf.use_nonrd_pick_mode && !frame_is_intra_only(cm)) - encode_nonrd_sb_row(cpi, ptile, mi_row, &tok[tile_row][tile_col]); - else encode_rd_sb_row(cpi, ptile, mi_row, &tok[tile_row][tile_col]); } cpi->tok_count[tile_row][tile_col] = @@ -5298,25 +4628,6 @@ static void encode_frame_internal(VP9_COMP *cpi) { x->quant_fp = cpi->sf.use_quant_fp; vp9_zero(x->skip_txfm); - if (sf->use_nonrd_pick_mode) { - // Initialize internal buffer pointers for rtc coding, where non-RD - // mode decision is used and hence no buffer pointer swap needed. - int i; - struct macroblock_plane *const p = x->plane; - struct macroblockd_plane *const pd = xd->plane; - PICK_MODE_CONTEXT *ctx = &cpi->pc_root->none; - - for (i = 0; i < MAX_MB_PLANE; ++i) { - p[i].coeff = ctx->coeff_pbuf[i][0]; - p[i].qcoeff = ctx->qcoeff_pbuf[i][0]; - pd[i].dqcoeff = ctx->dqcoeff_pbuf[i][0]; - p[i].eobs = ctx->eobs_pbuf[i][0]; - } - vp9_zero(x->zcoeff_blk); - - if (sf->partition_search_type == SOURCE_VAR_BASED_PARTITION) - source_var_based_partition_search_method(cpi); - } { struct vpx_usec_timer emr_timer; @@ -5662,7 +4973,7 @@ static void encode_superblock(VP9_COMP *cpi, TOKENEXTRA **t, int output_enabled, cpi->oxcf.aq_mode != CYCLIC_REFRESH_AQ && cpi->sf.allow_skip_recode; - if (!x->skip_recode && !cpi->sf.use_nonrd_pick_mode) + if (!x->skip_recode) vpx_memset(x->skip_txfm, 0, sizeof(x->skip_txfm)); x->skip_optimize = ctx->is_coded; diff --git a/vp9/encoder/vp9_encoder.c b/vp9/encoder/vp9_encoder.c index e08fe715f..cc2cf7137 100644 --- a/vp9/encoder/vp9_encoder.c +++ b/vp9/encoder/vp9_encoder.c @@ -2938,8 +2938,8 @@ static void encode_with_recode_loop(VP9_COMP *cpi, // to recode. if (cpi->sf.recode_loop >= ALLOW_RECODE_KFARFGF) { save_coding_context(cpi); - if (!cpi->sf.use_nonrd_pick_mode) - vp9_pack_bitstream(cpi, dest, size); + + vp9_pack_bitstream(cpi, dest, size); rc->projected_frame_size = (int)(*size) << 3; restore_coding_context(cpi); diff --git a/vp9/encoder/vp9_pickmode.c b/vp9/encoder/vp9_pickmode.c deleted file mode 100644 index c0cff3f44..000000000 --- a/vp9/encoder/vp9_pickmode.c +++ /dev/null @@ -1,903 +0,0 @@ -/* - * Copyright (c) 2014 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#include -#include -#include -#include - -#include "./vp9_rtcd.h" - -#include "vpx_mem/vpx_mem.h" - -#include "vp9/common/vp9_blockd.h" -#include "vp9/common/vp9_common.h" -#include "vp9/common/vp9_mvref_common.h" -#include "vp9/common/vp9_reconinter.h" -#include "vp9/common/vp9_reconintra.h" - -#include "vp9/encoder/vp9_encoder.h" -#include "vp9/encoder/vp9_pickmode.h" -#include "vp9/encoder/vp9_ratectrl.h" -#include "vp9/encoder/vp9_rd.h" - -typedef struct { - uint8_t *data; - int stride; - int in_use; -} PRED_BUFFER; - -static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCKD *xd, - const TileInfo *const tile, - MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, - int_mv *mv_ref_list, - int mi_row, int mi_col) { - const int *ref_sign_bias = cm->ref_frame_sign_bias; - int i, refmv_count = 0; - - const POSITION *const mv_ref_search = mv_ref_blocks[mi->mbmi.sb_type]; - - int different_ref_found = 0; - int context_counter = 0; - int const_motion = 0; - - // Blank the reference vector list - vpx_memset(mv_ref_list, 0, sizeof(*mv_ref_list) * MAX_MV_REF_CANDIDATES); - - // The nearest 2 blocks are treated differently - // if the size < 8x8 we get the mv from the bmi substructure, - // and we also need to keep a mode count. - for (i = 0; i < 2; ++i) { - const POSITION *const mv_ref = &mv_ref_search[i]; - if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { - const MODE_INFO *const candidate_mi = xd->mi[mv_ref->col + mv_ref->row * - xd->mi_stride].src_mi; - const MB_MODE_INFO *const candidate = &candidate_mi->mbmi; - // Keep counts for entropy encoding. - context_counter += mode_2_counter[candidate->mode]; - different_ref_found = 1; - - if (candidate->ref_frame[0] == ref_frame) - ADD_MV_REF_LIST(get_sub_block_mv(candidate_mi, 0, mv_ref->col, -1)); - } - } - - const_motion = 1; - - // Check the rest of the neighbors in much the same way - // as before except we don't need to keep track of sub blocks or - // mode counts. - for (; i < MVREF_NEIGHBOURS && !refmv_count; ++i) { - const POSITION *const mv_ref = &mv_ref_search[i]; - if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { - const MB_MODE_INFO *const candidate = &xd->mi[mv_ref->col + mv_ref->row * - xd->mi_stride].src_mi->mbmi; - different_ref_found = 1; - - if (candidate->ref_frame[0] == ref_frame) - ADD_MV_REF_LIST(candidate->mv[0]); - } - } - - // Since we couldn't find 2 mvs from the same reference frame - // go back through the neighbors and find motion vectors from - // different reference frames. - if (different_ref_found && !refmv_count) { - for (i = 0; i < MVREF_NEIGHBOURS; ++i) { - const POSITION *mv_ref = &mv_ref_search[i]; - if (is_inside(tile, mi_col, mi_row, cm->mi_rows, mv_ref)) { - const MB_MODE_INFO *const candidate = &xd->mi[mv_ref->col + mv_ref->row - * xd->mi_stride].src_mi->mbmi; - - // If the candidate is INTRA we don't want to consider its mv. - IF_DIFF_REF_FRAME_ADD_MV(candidate); - } - } - } - - Done: - - mi->mbmi.mode_context[ref_frame] = counter_to_context[context_counter]; - - // Clamp vectors - for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) - clamp_mv_ref(&mv_ref_list[i].as_mv, xd); - - return const_motion; -} - -static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x, - BLOCK_SIZE bsize, int mi_row, int mi_col, - int_mv *tmp_mv, int *rate_mv, - int64_t best_rd_sofar) { - MACROBLOCKD *xd = &x->e_mbd; - MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi; - struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0, 0, 0, 0}}; - const int step_param = cpi->sf.mv.fullpel_search_step_param; - const int sadpb = x->sadperbit16; - MV mvp_full; - const int ref = mbmi->ref_frame[0]; - const MV ref_mv = mbmi->ref_mvs[ref][0].as_mv; - int dis; - int rate_mode; - const int tmp_col_min = x->mv_col_min; - const int tmp_col_max = x->mv_col_max; - const int tmp_row_min = x->mv_row_min; - const int tmp_row_max = x->mv_row_max; - int rv = 0; - int cost_list[5]; - const YV12_BUFFER_CONFIG *scaled_ref_frame = vp9_get_scaled_ref_frame(cpi, - ref); - if (cpi->common.show_frame && - (x->pred_mv_sad[ref] >> 3) > x->pred_mv_sad[LAST_FRAME]) - return rv; - - if (scaled_ref_frame) { - int i; - // Swap out the reference frame for a version that's been scaled to - // match the resolution of the current frame, allowing the existing - // motion search code to be used without additional modifications. - for (i = 0; i < MAX_MB_PLANE; i++) - backup_yv12[i] = xd->plane[i].pre[0]; - vp9_setup_pre_planes(xd, 0, scaled_ref_frame, mi_row, mi_col, NULL); - } - vp9_set_mv_search_range(x, &ref_mv); - - assert(x->mv_best_ref_index[ref] <= 2); - if (x->mv_best_ref_index[ref] < 2) - mvp_full = mbmi->ref_mvs[ref][x->mv_best_ref_index[ref]].as_mv; - else - mvp_full = x->pred_mv[ref]; - - mvp_full.col >>= 3; - mvp_full.row >>= 3; - - vp9_full_pixel_search(cpi, x, bsize, &mvp_full, step_param, sadpb, - cond_cost_list(cpi, cost_list), - &ref_mv, &tmp_mv->as_mv, INT_MAX, 0); - - x->mv_col_min = tmp_col_min; - x->mv_col_max = tmp_col_max; - x->mv_row_min = tmp_row_min; - x->mv_row_max = tmp_row_max; - - // calculate the bit cost on motion vector - mvp_full.row = tmp_mv->as_mv.row * 8; - mvp_full.col = tmp_mv->as_mv.col * 8; - - *rate_mv = vp9_mv_bit_cost(&mvp_full, &ref_mv, - x->nmvjointcost, x->mvcost, MV_COST_WEIGHT); -#if CONFIG_NEW_INTER - if (has_second_ref(mbmi)) - rate_mode = cpi->inter_compound_mode_cost[mbmi->mode_context[ref]] - [INTER_COMPOUND_OFFSET(NEW_NEWMV)]; - else -#endif // CONFIG_NEW_INTER - rate_mode = cpi->inter_mode_cost[mbmi->mode_context[ref]] - [INTER_OFFSET(NEWMV)]; - rv = !(RDCOST(x->rdmult, x->rddiv, (*rate_mv + rate_mode), 0) > - best_rd_sofar); - - if (rv) { - cpi->find_fractional_mv_step(x, &tmp_mv->as_mv, &ref_mv, - cpi->common.allow_high_precision_mv, - x->errorperbit, - &cpi->fn_ptr[bsize], - cpi->sf.mv.subpel_force_stop, - cpi->sf.mv.subpel_iters_per_step, - cond_cost_list(cpi, cost_list), - x->nmvjointcost, x->mvcost, - &dis, &x->pred_sse[ref], NULL, 0, 0); - x->pred_mv[ref] = tmp_mv->as_mv; - } - - if (scaled_ref_frame) { - int i; - for (i = 0; i < MAX_MB_PLANE; i++) - xd->plane[i].pre[0] = backup_yv12[i]; - } - return rv; -} - - -static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize, - MACROBLOCK *x, MACROBLOCKD *xd, - int *out_rate_sum, int64_t *out_dist_sum, - unsigned int *var_y, unsigned int *sse_y) { - // Note our transform coeffs are 8 times an orthogonal transform. - // Hence quantizer step is also 8 times. To get effective quantizer - // we need to divide by 8 before sending to modeling function. - unsigned int sse; - int rate; - int64_t dist; - struct macroblock_plane *const p = &x->plane[0]; - struct macroblockd_plane *const pd = &xd->plane[0]; - const uint32_t dc_quant = pd->dequant[0]; - const uint32_t ac_quant = pd->dequant[1]; - unsigned int var = cpi->fn_ptr[bsize].vf(p->src.buf, p->src.stride, - pd->dst.buf, pd->dst.stride, &sse); - *var_y = var; - *sse_y = sse; - - if (sse < dc_quant * dc_quant >> 6) - x->skip_txfm[0] = 1; - else if (var < ac_quant * ac_quant >> 6) - x->skip_txfm[0] = 2; - else - x->skip_txfm[0] = 0; - - if (cpi->common.tx_mode == TX_MODE_SELECT) { - if (sse > (var << 2)) - xd->mi[0].src_mi->mbmi.tx_size = - MIN(max_txsize_lookup[bsize], - tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); - else - xd->mi[0].src_mi->mbmi.tx_size = TX_8X8; - - if (cpi->sf.partition_search_type == VAR_BASED_PARTITION && - xd->mi[0].src_mi->mbmi.tx_size > TX_16X16) - xd->mi[0].src_mi->mbmi.tx_size = TX_16X16; - } else { - xd->mi[0].src_mi->mbmi.tx_size = - MIN(max_txsize_lookup[bsize], - tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); - } - -#if CONFIG_VP9_HIGHBITDEPTH - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - vp9_model_rd_from_var_lapndz(sse - var, 1 << num_pels_log2_lookup[bsize], - dc_quant >> (xd->bd - 5), &rate, &dist); - } else { - vp9_model_rd_from_var_lapndz(sse - var, 1 << num_pels_log2_lookup[bsize], - dc_quant >> 3, &rate, &dist); - } -#else - vp9_model_rd_from_var_lapndz(sse - var, 1 << num_pels_log2_lookup[bsize], - dc_quant >> 3, &rate, &dist); -#endif // CONFIG_VP9_HIGHBITDEPTH - - *out_rate_sum = rate >> 1; - *out_dist_sum = dist << 3; - -#if CONFIG_VP9_HIGHBITDEPTH - if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) { - vp9_model_rd_from_var_lapndz(var, - 1 << num_pels_log2_lookup[bsize], - ac_quant >> (xd->bd - 5), - &rate, - &dist); - } else { - vp9_model_rd_from_var_lapndz(var, - 1 << num_pels_log2_lookup[bsize], - ac_quant >> 3, - &rate, - &dist); - } -#else - vp9_model_rd_from_var_lapndz(var, - 1 << num_pels_log2_lookup[bsize], - ac_quant >> 3, - &rate, - &dist); -#endif // CONFIG_VP9_HIGHBITDEPTH - - *out_rate_sum += rate; - *out_dist_sum += dist << 4; -} - -static int get_pred_buffer(PRED_BUFFER *p, int len) { - int i; - - for (i = 0; i < len; i++) { - if (!p[i].in_use) { - p[i].in_use = 1; - return i; - } - } - return -1; -} - -static void free_pred_buffer(PRED_BUFFER *p) { - if (p != NULL) - p->in_use = 0; -} - -static void encode_breakout_test(VP9_COMP *cpi, MACROBLOCK *x, - BLOCK_SIZE bsize, int mi_row, int mi_col, - MV_REFERENCE_FRAME ref_frame, - PREDICTION_MODE this_mode, - unsigned int var_y, unsigned int sse_y, - struct buf_2d yv12_mb[][MAX_MB_PLANE], - int *rate, int64_t *dist) { - MACROBLOCKD *xd = &x->e_mbd; - MB_MODE_INFO *mbmi = &xd->mi[0].src_mi->mbmi; - - const BLOCK_SIZE uv_size = get_plane_block_size(bsize, &xd->plane[1]); - unsigned int var = var_y, sse = sse_y; - // Skipping threshold for ac. - unsigned int thresh_ac; - // Skipping threshold for dc. - unsigned int thresh_dc; - if (x->encode_breakout > 0) { - // Set a maximum for threshold to avoid big PSNR loss in low bit rate - // case. Use extreme low threshold for static frames to limit - // skipping. - const unsigned int max_thresh = 36000; - // The encode_breakout input - const unsigned int min_thresh = - MIN(((unsigned int)x->encode_breakout << 4), max_thresh); -#if CONFIG_VP9_HIGHBITDEPTH - const int shift = 2 * xd->bd - 16; -#endif - - // Calculate threshold according to dequant value. - thresh_ac = (xd->plane[0].dequant[1] * xd->plane[0].dequant[1]) / 9; -#if CONFIG_VP9_HIGHBITDEPTH - if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) && shift > 0) { - thresh_ac = ROUND_POWER_OF_TWO(thresh_ac, shift); - } -#endif // CONFIG_VP9_HIGHBITDEPTH - thresh_ac = clamp(thresh_ac, min_thresh, max_thresh); - - // Adjust ac threshold according to partition size. - thresh_ac >>= - 8 - (b_width_log2_lookup[bsize] + b_height_log2_lookup[bsize]); - - thresh_dc = (xd->plane[0].dequant[0] * xd->plane[0].dequant[0] >> 6); -#if CONFIG_VP9_HIGHBITDEPTH - if ((xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) && shift > 0) { - thresh_dc = ROUND_POWER_OF_TWO(thresh_dc, shift); - } -#endif // CONFIG_VP9_HIGHBITDEPTH - } else { - thresh_ac = 0; - thresh_dc = 0; - } - - // Y skipping condition checking for ac and dc. - if (var <= thresh_ac && (sse - var) <= thresh_dc) { - unsigned int sse_u, sse_v; - unsigned int var_u, var_v; - - // Skip UV prediction unless breakout is zero (lossless) to save - // computation with low impact on the result - if (x->encode_breakout == 0) { - xd->plane[1].pre[0] = yv12_mb[ref_frame][1]; - xd->plane[2].pre[0] = yv12_mb[ref_frame][2]; - vp9_build_inter_predictors_sbuv(xd, mi_row, mi_col, bsize); - } - - var_u = cpi->fn_ptr[uv_size].vf(x->plane[1].src.buf, - x->plane[1].src.stride, - xd->plane[1].dst.buf, - xd->plane[1].dst.stride, &sse_u); - - // U skipping condition checking - if ((var_u * 4 <= thresh_ac) && (sse_u - var_u <= thresh_dc)) { - var_v = cpi->fn_ptr[uv_size].vf(x->plane[2].src.buf, - x->plane[2].src.stride, - xd->plane[2].dst.buf, - xd->plane[2].dst.stride, &sse_v); - - // V skipping condition checking - if ((var_v * 4 <= thresh_ac) && (sse_v - var_v <= thresh_dc)) { - x->skip = 1; - - // The cost of skip bit needs to be added. -#if CONFIG_NEW_INTER - if (has_second_ref(mbmi)) - *rate = cpi->inter_compound_mode_cost[mbmi->mode_context[ref_frame]] - [INTER_COMPOUND_OFFSET(this_mode)]; - - else -#endif // CONFIG_NEW_INTER - *rate = cpi->inter_mode_cost[mbmi->mode_context[ref_frame]] - [INTER_OFFSET(this_mode)]; - // More on this part of rate - // rate += vp9_cost_bit(vp9_get_skip_prob(cm, xd), 1); - - // Scaling factor for SSE from spatial domain to frequency - // domain is 16. Adjust distortion accordingly. - // TODO(yunqingwang): In this function, only y-plane dist is - // calculated. - *dist = (sse << 4); // + ((sse_u + sse_v) << 4); - - // *disable_skip = 1; - } - } - } -} - -struct estimate_block_intra_args { - VP9_COMP *cpi; - MACROBLOCK *x; - PREDICTION_MODE mode; - int rate; - int64_t dist; -}; - -static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize, - TX_SIZE tx_size, void *arg) { - struct estimate_block_intra_args* const args = arg; - VP9_COMP *const cpi = args->cpi; - MACROBLOCK *const x = args->x; - MACROBLOCKD *const xd = &x->e_mbd; - struct macroblock_plane *const p = &x->plane[0]; - struct macroblockd_plane *const pd = &xd->plane[0]; - const BLOCK_SIZE bsize_tx = txsize_to_bsize[tx_size]; - uint8_t *const src_buf_base = p->src.buf; - uint8_t *const dst_buf_base = pd->dst.buf; - const int src_stride = p->src.stride; - const int dst_stride = pd->dst.stride; - int i, j; - int rate; - int64_t dist; - unsigned int var_y, sse_y; - txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &i, &j); - assert(plane == 0); - (void) plane; - - p->src.buf = &src_buf_base[4 * (j * src_stride + i)]; - pd->dst.buf = &dst_buf_base[4 * (j * dst_stride + i)]; - // Use source buffer as an approximation for the fully reconstructed buffer. - vp9_predict_intra_block(xd, block >> (2 * tx_size), - b_width_log2_lookup[plane_bsize], - tx_size, args->mode, -#if CONFIG_FILTERINTRA - 0, -#endif - p->src.buf, src_stride, - pd->dst.buf, dst_stride, - i, j, 0); - // This procedure assumes zero offset from p->src.buf and pd->dst.buf. - model_rd_for_sb_y(cpi, bsize_tx, x, xd, &rate, &dist, &var_y, &sse_y); - p->src.buf = src_buf_base; - pd->dst.buf = dst_buf_base; - args->rate += rate; - args->dist += dist; -} - -static const THR_MODES mode_idx[MAX_REF_FRAMES - 1][INTER_MODES] = { -#if CONFIG_NEW_INTER - {THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV, THR_NEW2MV}, - {THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG, THR_NEW2G}, - {THR_NEARESTA, THR_NEARA, THR_ZEROA, THR_NEWA, THR_NEW2A}, -#else - {THR_NEARESTMV, THR_NEARMV, THR_ZEROMV, THR_NEWMV}, - {THR_NEARESTG, THR_NEARG, THR_ZEROG, THR_NEWG}, - {THR_NEARESTA, THR_NEARA, THR_ZEROA, THR_NEWA}, -#endif // CONFIG_NEW_INTER -}; - -// TODO(jingning) placeholder for inter-frame non-RD mode decision. -// this needs various further optimizations. to be continued.. -void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, - const TileInfo *const tile, - int mi_row, int mi_col, RD_COST *rd_cost, - BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { - VP9_COMMON *const cm = &cpi->common; - MACROBLOCKD *const xd = &x->e_mbd; - MB_MODE_INFO *const mbmi = &xd->mi[0].src_mi->mbmi; - struct macroblockd_plane *const pd = &xd->plane[0]; - PREDICTION_MODE best_mode = ZEROMV; - MV_REFERENCE_FRAME ref_frame, best_ref_frame = LAST_FRAME; - TX_SIZE best_tx_size = MIN(max_txsize_lookup[bsize], - tx_mode_to_biggest_tx_size[cm->tx_mode]); - INTERP_FILTER best_pred_filter = EIGHTTAP; - int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES]; - struct buf_2d yv12_mb[4][MAX_MB_PLANE]; - static const int flag_list[4] = { 0, VP9_LAST_FLAG, VP9_GOLD_FLAG, - VP9_ALT_FLAG }; - RD_COST this_rdc, best_rdc; - uint8_t skip_txfm = 0; - // var_y and sse_y are saved to be used in skipping checking - unsigned int var_y = UINT_MAX; - unsigned int sse_y = UINT_MAX; - // Reduce the intra cost penalty for small blocks (<=16x16). - const int reduction_fac = - (cpi->sf.partition_search_type == VAR_BASED_PARTITION && - bsize <= BLOCK_16X16) ? 4 : 1; - const int intra_cost_penalty = vp9_get_intra_cost_penalty( - cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth) / reduction_fac; - const int64_t inter_mode_thresh = RDCOST(x->rdmult, x->rddiv, - intra_cost_penalty, 0); - const int intra_mode_cost = 50; - - const int8_t segment_id = mbmi->segment_id; - const int *const rd_threshes = cpi->rd.threshes[segment_id][bsize]; - const int *const rd_thresh_freq_fact = cpi->rd.thresh_freq_fact[bsize]; - INTERP_FILTER filter_ref = cm->interp_filter; - const int bsl = mi_width_log2_lookup[bsize]; - const int pred_filter_search = cm->interp_filter == SWITCHABLE ? - (((mi_row + mi_col) >> bsl) + - get_chessboard_index(cm->current_video_frame)) & 0x1 : 0; - int const_motion[MAX_REF_FRAMES] = { 0 }; - const int bh = num_4x4_blocks_high_lookup[bsize] << 2; - const int bw = num_4x4_blocks_wide_lookup[bsize] << 2; - // For speed 6, the result of interp filter is reused later in actual encoding - // process. - // tmp[3] points to dst buffer, and the other 3 point to allocated buffers. - PRED_BUFFER tmp[4]; - DECLARE_ALIGNED_ARRAY(16, uint8_t, pred_buf, 3 * 64 * 64); -#if CONFIG_VP9_HIGHBITDEPTH - DECLARE_ALIGNED_ARRAY(16, uint16_t, pred_buf_16, 3 * 64 * 64); -#endif - struct buf_2d orig_dst = pd->dst; - PRED_BUFFER *best_pred = NULL; - PRED_BUFFER *this_mode_pred = NULL; - const int pixels_in_block = bh * bw; - - if (cpi->sf.reuse_inter_pred_sby) { - int i; - for (i = 0; i < 3; i++) { -#if CONFIG_VP9_HIGHBITDEPTH - if (cm->use_highbitdepth) - tmp[i].data = CONVERT_TO_BYTEPTR(&pred_buf_16[pixels_in_block * i]); - else - tmp[i].data = &pred_buf[pixels_in_block * i]; -#else - tmp[i].data = &pred_buf[pixels_in_block * i]; -#endif // CONFIG_VP9_HIGHBITDEPTH - tmp[i].stride = bw; - tmp[i].in_use = 0; - } - tmp[3].data = pd->dst.buf; - tmp[3].stride = pd->dst.stride; - tmp[3].in_use = 0; - } - - x->skip_encode = cpi->sf.skip_encode_frame && x->q_index < QIDX_SKIP_THRESH; - x->skip = 0; - - // initialize mode decisions - vp9_rd_cost_reset(&best_rdc); - vp9_rd_cost_reset(&this_rdc); - vp9_rd_cost_reset(rd_cost); - vpx_memset(mbmi, 0, sizeof(MB_MODE_INFO)); - mbmi->sb_type = bsize; - mbmi->ref_frame[0] = NONE; - mbmi->ref_frame[1] = NONE; - mbmi->tx_size = MIN(max_txsize_lookup[bsize], - tx_mode_to_biggest_tx_size[cm->tx_mode]); - mbmi->interp_filter = cm->interp_filter == SWITCHABLE ? - EIGHTTAP : cm->interp_filter; - mbmi->segment_id = segment_id; - - for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { - PREDICTION_MODE this_mode; - x->pred_mv_sad[ref_frame] = INT_MAX; - frame_mv[NEWMV][ref_frame].as_int = INVALID_MV; -#if CONFIG_GLOBAL_MOTION - frame_mv[ZEROMV][ref_frame].as_int = - cm->global_motion[ref_frame][0].mv.as_int; -#else - frame_mv[ZEROMV][ref_frame].as_int = 0; -#endif // CONFIG_GLOBAL_MOTION - - if (xd->up_available) - filter_ref = xd->mi[-xd->mi_stride].src_mi->mbmi.interp_filter; - else if (xd->left_available) - filter_ref = xd->mi[-1].src_mi->mbmi.interp_filter; - - if (cpi->ref_frame_flags & flag_list[ref_frame]) { - const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame); - int_mv *const candidates = mbmi->ref_mvs[ref_frame]; - const struct scale_factors *const sf = &cm->frame_refs[ref_frame - 1].sf; - vp9_setup_pred_block(xd, yv12_mb[ref_frame], yv12, mi_row, mi_col, - sf, sf); - - if (!cm->error_resilient_mode) - vp9_find_mv_refs(cm, xd, tile, xd->mi[0].src_mi, ref_frame, - candidates, mi_row, mi_col); - else - const_motion[ref_frame] = mv_refs_rt(cm, xd, tile, xd->mi[0].src_mi, - ref_frame, candidates, - mi_row, mi_col); - - vp9_find_best_ref_mvs(xd, cm->allow_high_precision_mv, candidates, - &frame_mv[NEARESTMV][ref_frame], - &frame_mv[NEARMV][ref_frame]); - - if (!vp9_is_scaled(sf) && bsize >= BLOCK_8X8) - vp9_mv_pred(cpi, x, yv12_mb[ref_frame][0].buf, yv12->y_stride, - ref_frame, bsize); - } else { - continue; - } - - // Select prediction reference frames. - xd->plane[0].pre[0] = yv12_mb[ref_frame][0]; - - clamp_mv2(&frame_mv[NEARESTMV][ref_frame].as_mv, xd); - clamp_mv2(&frame_mv[NEARMV][ref_frame].as_mv, xd); - - mbmi->ref_frame[0] = ref_frame; - -#if CONFIG_NEW_INTER - for (this_mode = NEARESTMV; this_mode <= NEW_NEWMV; ++this_mode) { -#else - for (this_mode = NEARESTMV; this_mode <= NEWMV; ++this_mode) { -#endif // CONFIG_NEW_INTER - int rate_mv = 0; - int mode_rd_thresh; -#if CONFIG_GLOBAL_MOTION - if (const_motion[ref_frame] && this_mode == NEARMV) -#else // CONFIG_GLOBAL_MOTION -#if CONFIG_NEW_INTER - if (const_motion[ref_frame] && - (this_mode == NEARMV || this_mode == ZEROMV || - this_mode == ZERO_ZEROMV)) -#else - if (const_motion[ref_frame] && - (this_mode == NEARMV || this_mode == ZEROMV)) -#endif // CONFIG_NEW_INTER -#endif // CONFIG_GLOBAL_MOTION - continue; - - if (!(cpi->sf.inter_mode_mask[bsize] & (1 << this_mode))) - continue; -#if CONFIG_NEW_INTER - if (has_second_ref(mbmi)) - mode_rd_thresh = - rd_threshes[mode_idx[ref_frame - LAST_FRAME] - [INTER_COMPOUND_OFFSET(this_mode)]]; - else -#endif // CONFIG_NEW_INTER - mode_rd_thresh = - rd_threshes[mode_idx[ref_frame - LAST_FRAME] - [INTER_OFFSET(this_mode)]]; - if (rd_less_than_thresh(best_rdc.rdcost, mode_rd_thresh, - rd_thresh_freq_fact[this_mode])) - continue; - -#if CONFIG_NEW_INTER - if (this_mode == NEWMV || this_mode == NEW_NEWMV) { -#else - if (this_mode == NEWMV) { -#endif // CONFIG_NEW_INTER - if (cpi->sf.partition_search_type != VAR_BASED_PARTITION && - this_rdc.rdcost < (int64_t)(1 << num_pels_log2_lookup[bsize])) - continue; - if (!combined_motion_search(cpi, x, bsize, mi_row, mi_col, - &frame_mv[NEWMV][ref_frame], - &rate_mv, best_rdc.rdcost)) - continue; - } - -#if CONFIG_NEW_INTER - if (this_mode != NEARESTMV && this_mode != NEAREST_NEARESTMV && -#else - if (this_mode != NEARESTMV && -#endif // CONFIG_NEW_INTER - frame_mv[this_mode][ref_frame].as_int == - frame_mv[NEARESTMV][ref_frame].as_int) - continue; - - mbmi->mode = this_mode; - mbmi->mv[0].as_int = frame_mv[this_mode][ref_frame].as_int; - - // Search for the best prediction filter type, when the resulting - // motion vector is at sub-pixel accuracy level for luma component, i.e., - // the last three bits are all zeros. - if (cpi->sf.reuse_inter_pred_sby) { -#if CONFIG_NEW_INTER - if (this_mode == NEARESTMV || this_mode == NEAREST_NEARESTMV) { -#else - if (this_mode == NEARESTMV) { -#endif // CONFIG_NEW_INTER - this_mode_pred = &tmp[3]; - } else { - this_mode_pred = &tmp[get_pred_buffer(tmp, 3)]; - pd->dst.buf = this_mode_pred->data; - pd->dst.stride = bw; - } - } - -#if CONFIG_NEW_INTER - if ((this_mode == NEWMV || this_mode == NEW_NEWMV || - filter_ref == SWITCHABLE) && -#else - if ((this_mode == NEWMV || filter_ref == SWITCHABLE) && -#endif // CONFIG_NEW_INTER - pred_filter_search && - ((mbmi->mv[0].as_mv.row & 0x07) != 0 || - (mbmi->mv[0].as_mv.col & 0x07) != 0)) { - int pf_rate[3]; - int64_t pf_dist[3]; - unsigned int pf_var[3]; - unsigned int pf_sse[3]; - TX_SIZE pf_tx_size[3]; - int64_t best_cost = INT64_MAX; - INTERP_FILTER best_filter = SWITCHABLE, filter; - PRED_BUFFER *current_pred = this_mode_pred; - - for (filter = EIGHTTAP; filter <= EIGHTTAP_SHARP; ++filter) { - int64_t cost; - mbmi->interp_filter = filter; - vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); - model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rate[filter], - &pf_dist[filter], &pf_var[filter], &pf_sse[filter]); - cost = RDCOST(x->rdmult, x->rddiv, - vp9_get_switchable_rate(cpi) + pf_rate[filter], - pf_dist[filter]); - pf_tx_size[filter] = mbmi->tx_size; - if (cost < best_cost) { - best_filter = filter; - best_cost = cost; - skip_txfm = x->skip_txfm[0]; - - if (cpi->sf.reuse_inter_pred_sby) { - if (this_mode_pred != current_pred) { - free_pred_buffer(this_mode_pred); - this_mode_pred = current_pred; - } - - if (filter < EIGHTTAP_SHARP) { - current_pred = &tmp[get_pred_buffer(tmp, 3)]; - pd->dst.buf = current_pred->data; - pd->dst.stride = bw; - } - } - } - } - - if (cpi->sf.reuse_inter_pred_sby && this_mode_pred != current_pred) - free_pred_buffer(current_pred); - - mbmi->interp_filter = best_filter; - mbmi->tx_size = pf_tx_size[mbmi->interp_filter]; - this_rdc.rate = pf_rate[mbmi->interp_filter]; - this_rdc.dist = pf_dist[mbmi->interp_filter]; - var_y = pf_var[mbmi->interp_filter]; - sse_y = pf_sse[mbmi->interp_filter]; - x->skip_txfm[0] = skip_txfm; - } else { - mbmi->interp_filter = (filter_ref == SWITCHABLE) ? EIGHTTAP: filter_ref; - vp9_build_inter_predictors_sby(xd, mi_row, mi_col, bsize); - model_rd_for_sb_y(cpi, bsize, x, xd, &this_rdc.rate, &this_rdc.dist, - &var_y, &sse_y); - } - - this_rdc.rate += rate_mv; -#if CONFIG_NEW_INTER - if (has_second_ref(mbmi)) - this_rdc.rate += cpi->inter_compound_mode_cost - [mbmi->mode_context[ref_frame]] - [INTER_COMPOUND_OFFSET(this_mode)]; - else -#endif // CONFIG_NEW_INTER - this_rdc.rate += cpi->inter_mode_cost[mbmi->mode_context[ref_frame]] - [INTER_OFFSET(this_mode)]; - this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - this_rdc.rate, this_rdc.dist); - - // Skipping checking: test to see if this block can be reconstructed by - // prediction only. - if (cpi->allow_encode_breakout) { - encode_breakout_test(cpi, x, bsize, mi_row, mi_col, ref_frame, - this_mode, var_y, sse_y, yv12_mb, - &this_rdc.rate, &this_rdc.dist); - if (x->skip) { - this_rdc.rate += rate_mv; - this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - this_rdc.rate, this_rdc.dist); - } - } - -#if CONFIG_VP9_TEMPORAL_DENOISING - if (cpi->oxcf.noise_sensitivity > 0) { - vp9_denoiser_update_frame_stats(mbmi, sse_y, this_mode, ctx); - } -#else - (void)ctx; -#endif - - if (this_rdc.rdcost < best_rdc.rdcost || x->skip) { - best_rdc = this_rdc; - best_mode = this_mode; - best_pred_filter = mbmi->interp_filter; - best_tx_size = mbmi->tx_size; - best_ref_frame = ref_frame; - skip_txfm = x->skip_txfm[0]; - - if (cpi->sf.reuse_inter_pred_sby) { - free_pred_buffer(best_pred); - - best_pred = this_mode_pred; - } - } else { - if (cpi->sf.reuse_inter_pred_sby) - free_pred_buffer(this_mode_pred); - } - - if (x->skip) - break; - } - // If the current reference frame is valid and we found a usable mode, - // we are done. - if (best_rdc.rdcost < INT64_MAX) - break; - } - - // If best prediction is not in dst buf, then copy the prediction block from - // temp buf to dst buf. - if (best_pred != NULL && cpi->sf.reuse_inter_pred_sby && - best_pred->data != orig_dst.buf) { - pd->dst = orig_dst; -#if CONFIG_VP9_HIGHBITDEPTH - if (cm->use_highbitdepth) { - vp9_highbd_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride, - NULL, 0, NULL, 0, bw, bh, xd->bd); - } else { - vp9_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride, - NULL, 0, NULL, 0, bw, bh); - } -#else - vp9_convolve_copy(best_pred->data, bw, pd->dst.buf, pd->dst.stride, NULL, 0, - NULL, 0, bw, bh); -#endif // CONFIG_VP9_HIGHBITDEPTH - } - - mbmi->mode = best_mode; - mbmi->interp_filter = best_pred_filter; - mbmi->tx_size = best_tx_size; - mbmi->ref_frame[0] = best_ref_frame; - mbmi->mv[0].as_int = frame_mv[best_mode][best_ref_frame].as_int; - xd->mi[0].src_mi->bmi[0].as_mv[0].as_int = mbmi->mv[0].as_int; - x->skip_txfm[0] = skip_txfm; - - // Perform intra prediction search, if the best SAD is above a certain - // threshold. - if (!x->skip && best_rdc.rdcost > inter_mode_thresh && - bsize <= cpi->sf.max_intra_bsize) { - PREDICTION_MODE this_mode; - struct estimate_block_intra_args args = { cpi, x, DC_PRED, 0, 0 }; - const TX_SIZE intra_tx_size = - MIN(max_txsize_lookup[bsize], - tx_mode_to_biggest_tx_size[cpi->common.tx_mode]); - - if (cpi->sf.reuse_inter_pred_sby) { - pd->dst.buf = tmp[0].data; - pd->dst.stride = bw; - } - - for (this_mode = DC_PRED; this_mode <= DC_PRED; ++this_mode) { - const TX_SIZE saved_tx_size = mbmi->tx_size; - args.mode = this_mode; - args.rate = 0; - args.dist = 0; - mbmi->tx_size = intra_tx_size; - vp9_foreach_transformed_block_in_plane(xd, bsize, 0, - estimate_block_intra, &args); - mbmi->tx_size = saved_tx_size; - this_rdc.rate = args.rate; - this_rdc.dist = args.dist; - this_rdc.rate += cpi->mbmode_cost[this_mode]; - this_rdc.rate += intra_cost_penalty; - this_rdc.rdcost = RDCOST(x->rdmult, x->rddiv, - this_rdc.rate, this_rdc.dist); - - if (this_rdc.rdcost + intra_mode_cost < best_rdc.rdcost) { - best_rdc = this_rdc; - mbmi->mode = this_mode; - mbmi->tx_size = intra_tx_size; - mbmi->ref_frame[0] = INTRA_FRAME; - mbmi->uv_mode = this_mode; - mbmi->mv[0].as_int = INVALID_MV; - } else { - x->skip_txfm[0] = skip_txfm; - } - } - if (cpi->sf.reuse_inter_pred_sby) - pd->dst = orig_dst; - } - - *rd_cost = best_rdc; -} diff --git a/vp9/encoder/vp9_pickmode.h b/vp9/encoder/vp9_pickmode.h deleted file mode 100644 index 27a319d3c..000000000 --- a/vp9/encoder/vp9_pickmode.h +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (c) 2014 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef VP9_ENCODER_VP9_PICKMODE_H_ -#define VP9_ENCODER_VP9_PICKMODE_H_ - -#include "vp9/encoder/vp9_encoder.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void vp9_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x, - const struct TileInfo *const tile, - int mi_row, int mi_col, RD_COST *rd_cost, - BLOCK_SIZE bsize, - PICK_MODE_CONTEXT *ctx); - -#ifdef __cplusplus -} // extern "C" -#endif - -#endif // VP9_ENCODER_VP9_PICKMODE_H_ diff --git a/vp9/encoder/vp9_ratectrl.c b/vp9/encoder/vp9_ratectrl.c index 65bca669a..ac3fc305a 100644 --- a/vp9/encoder/vp9_ratectrl.c +++ b/vp9/encoder/vp9_ratectrl.c @@ -1082,15 +1082,7 @@ int vp9_rc_pick_q_and_bounds(const VP9_COMP *cpi, } else { q = rc_pick_q_and_bounds_two_pass(cpi, bottom_index, top_index); } - if (cpi->sf.use_nonrd_pick_mode) { - if (cpi->sf.force_frame_boost == 1) - q -= cpi->sf.max_delta_qindex; - - if (q < *bottom_index) - *bottom_index = q; - else if (q > *top_index) - *top_index = q; - } + return q; } diff --git a/vp9/encoder/vp9_rd.c b/vp9/encoder/vp9_rd.c index b89a08bc8..82f858a5e 100644 --- a/vp9/encoder/vp9_rd.c +++ b/vp9/encoder/vp9_rd.c @@ -314,57 +314,52 @@ void vp9_initialize_rd_consts(VP9_COMP *cpi) { set_block_thresholds(cm, rd); - if (!cpi->sf.use_nonrd_pick_mode || cm->frame_type == KEY_FRAME) { - fill_token_costs(x->token_costs, cm->fc.coef_probs); + fill_token_costs(x->token_costs, cm->fc.coef_probs); #if CONFIG_TX_SKIP - if (FOR_SCREEN_CONTENT) - fill_token_costs_pxd(x->token_costs_pxd, cm->fc.coef_probs_pxd); + if (FOR_SCREEN_CONTENT) + fill_token_costs_pxd(x->token_costs_pxd, cm->fc.coef_probs_pxd); #endif // CONFIG_TX_SKIP #if CONFIG_EXT_PARTITION - vp9_cost_tokens(cpi->partition_cost[0], get_partition_probs(cm, 0), - vp9_partition_tree); - for (i = 1; i < PARTITION_CONTEXTS; ++i) - vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i), - vp9_ext_partition_tree); + vp9_cost_tokens(cpi->partition_cost[0], get_partition_probs(cm, 0), + vp9_partition_tree); + for (i = 1; i < PARTITION_CONTEXTS; ++i) + vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i), + vp9_ext_partition_tree); #else - for (i = 0; i < PARTITION_CONTEXTS; ++i) - vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i), - vp9_partition_tree); + for (i = 0; i < PARTITION_CONTEXTS; ++i) + vp9_cost_tokens(cpi->partition_cost[i], get_partition_probs(cm, i), + vp9_partition_tree); #endif - } - if (!cpi->sf.use_nonrd_pick_mode || (cm->current_video_frame & 0x07) == 1 || - cm->frame_type == KEY_FRAME) { - fill_mode_costs(cpi); + fill_mode_costs(cpi); - if (!frame_is_intra_only(cm)) { - vp9_build_nmv_cost_table(x->nmvjointcost, - cm->allow_high_precision_mv ? x->nmvcost_hp - : x->nmvcost, - &cm->fc.nmvc, + if (!frame_is_intra_only(cm)) { + vp9_build_nmv_cost_table(x->nmvjointcost, + cm->allow_high_precision_mv ? x->nmvcost_hp + : x->nmvcost, + &cm->fc.nmvc, #if CONFIG_INTRABC - 1, + 1, #endif // CONFIG_INTRABC - cm->allow_high_precision_mv); + cm->allow_high_precision_mv); - for (i = 0; i < INTER_MODE_CONTEXTS; ++i) - vp9_cost_tokens((int *)cpi->inter_mode_cost[i], - cm->fc.inter_mode_probs[i], vp9_inter_mode_tree); + for (i = 0; i < INTER_MODE_CONTEXTS; ++i) + vp9_cost_tokens((int *)cpi->inter_mode_cost[i], + cm->fc.inter_mode_probs[i], vp9_inter_mode_tree); #if CONFIG_NEW_INTER - for (i = 0; i < INTER_MODE_CONTEXTS; ++i) - vp9_cost_tokens((int *)cpi->inter_compound_mode_cost[i], - cm->fc.inter_compound_mode_probs[i], - vp9_inter_compound_mode_tree); + for (i = 0; i < INTER_MODE_CONTEXTS; ++i) + vp9_cost_tokens((int *)cpi->inter_compound_mode_cost[i], + cm->fc.inter_compound_mode_probs[i], + vp9_inter_compound_mode_tree); #endif // CONFIG_NEW_INTER #if CONFIG_INTRABC - } else { - vp9_build_nmv_cost_table(x->nmvjointcost, - x->ndvcost, - &cm->fc.ndvc, 0, 0); + } else { + vp9_build_nmv_cost_table(x->nmvjointcost, + x->ndvcost, + &cm->fc.ndvc, 0, 0); #endif // CONFIG_INTRABC - } } #if CONFIG_COPY_MODE diff --git a/vp9/encoder/vp9_speed_features.c b/vp9/encoder/vp9_speed_features.c index 2dc496e0e..726459610 100644 --- a/vp9/encoder/vp9_speed_features.c +++ b/vp9/encoder/vp9_speed_features.c @@ -278,7 +278,6 @@ static void set_rt_speed_feature(VP9_COMP *cpi, SPEED_FEATURES *sf, (frames_since_key % (sf->last_partitioning_redo_frequency << 1) == 1); sf->max_delta_qindex = is_keyframe ? 20 : 15; sf->partition_search_type = REFERENCE_PARTITION; - sf->use_nonrd_pick_mode = 1; sf->allow_skip_recode = 0; sf->inter_mode_mask[BLOCK_32X32] = INTER_NEAREST_NEW_ZERO; sf->inter_mode_mask[BLOCK_32X64] = INTER_NEAREST_NEW_ZERO; @@ -397,7 +396,6 @@ void vp9_set_speed_features(VP9_COMP *cpi) { sf->use_fast_coef_costing = 0; sf->mode_skip_start = MAX_MODES; // Mode index at which mode skip mask set sf->schedule_mode_search = 0; - sf->use_nonrd_pick_mode = 0; for (i = 0; i < BLOCK_SIZES; ++i) sf->inter_mode_mask[i] = INTER_ALL; sf->max_intra_bsize = BLOCK_64X64; diff --git a/vp9/encoder/vp9_speed_features.h b/vp9/encoder/vp9_speed_features.h index 502b29e52..2761390ca 100644 --- a/vp9/encoder/vp9_speed_features.h +++ b/vp9/encoder/vp9_speed_features.h @@ -402,9 +402,6 @@ typedef struct SPEED_FEATURES { // by only looking at counts from 1/2 the bands. FAST_COEFF_UPDATE use_fast_coef_updates; - // This flag controls the use of non-RD mode decision. - int use_nonrd_pick_mode; - // A binary mask indicating if NEARESTMV, NEARMV, ZEROMV, NEWMV // modes are used in order from LSB to MSB for each BLOCK_SIZE. int inter_mode_mask[BLOCK_SIZES]; diff --git a/vp9/vp9cx.mk b/vp9/vp9cx.mk index 1993e22d7..8affb1f18 100644 --- a/vp9/vp9cx.mk +++ b/vp9/vp9cx.mk @@ -51,7 +51,6 @@ VP9_CX_SRCS-yes += encoder/vp9_quantize.h VP9_CX_SRCS-yes += encoder/vp9_ratectrl.h VP9_CX_SRCS-yes += encoder/vp9_rd.h VP9_CX_SRCS-yes += encoder/vp9_rdopt.h -VP9_CX_SRCS-yes += encoder/vp9_pickmode.h VP9_CX_SRCS-yes += encoder/vp9_svc_layercontext.h VP9_CX_SRCS-yes += encoder/vp9_tokenize.h VP9_CX_SRCS-yes += encoder/vp9_treewriter.h @@ -64,7 +63,6 @@ VP9_CX_SRCS-yes += encoder/vp9_quantize.c VP9_CX_SRCS-yes += encoder/vp9_ratectrl.c VP9_CX_SRCS-yes += encoder/vp9_rd.c VP9_CX_SRCS-yes += encoder/vp9_rdopt.c -VP9_CX_SRCS-yes += encoder/vp9_pickmode.c VP9_CX_SRCS-yes += encoder/vp9_sad.c VP9_CX_SRCS-yes += encoder/vp9_segmentation.c VP9_CX_SRCS-yes += encoder/vp9_segmentation.h -- 2.49.0