AV1 RT: Remove old nonRD path
Change-Id: I7f84c6937edca289a9a6f2531719dc0db8e2ba30
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index de3c565..e33ed54 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -231,9 +231,9 @@
for (int i = 1; i < INTER_REFS_PER_FRAME; ++i) {
const RefCntBuffer *const this_ref = ref_frames[i];
// If this_ref has appeared before, mark the corresponding ref frame as
- // invalid. For fast_nonrd mode, only disable GOLDEN_FRAME if it's the same
+ // invalid. For nonrd mode, only disable GOLDEN_FRAME if it's the same
// as LAST_FRAME.
- int index = (cpi->sf.use_fast_nonrd_pick_mode &&
+ int index = (cpi->sf.use_nonrd_pick_mode &&
ref_frame_priority_order[i] == GOLDEN_FRAME)
? 1
: i;
@@ -688,8 +688,8 @@
update_arf_stack(ref_map_index, ref_buffer_stack);
stack_push(ref_buffer_stack->gld_stack, &ref_buffer_stack->gld_stack_size,
ref_map_index);
- // For fast nonrd_mode: update LAST as well on GF_UPDATE frame.
- if (cpi->sf.use_fast_nonrd_pick_mode)
+ // For nonrd_mode: update LAST as well on GF_UPDATE frame.
+ if (cpi->sf.use_nonrd_pick_mode)
stack_push(ref_buffer_stack->lst_stack,
&ref_buffer_stack->lst_stack_size, ref_map_index);
break;
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index d4961d4..9650974 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -143,7 +143,7 @@
128 * 16, 128 * 16
};
-enum { PICK_MODE_RD = 0, PICK_MODE_NONRD, PICK_MODE_FAST_NONRD };
+enum { PICK_MODE_RD = 0, PICK_MODE_NONRD };
unsigned int av1_get_sby_perpixel_variance(const AV1_COMP *cpi,
const struct buf_2d *ref,
@@ -818,11 +818,6 @@
av1_nonrd_pick_inter_mode_sb(cpi, tile_data, x, mi_row, mi_col,
rd_cost, bsize, ctx, best_rd.rdcost);
break;
- case PICK_MODE_FAST_NONRD:
- av1_fast_nonrd_pick_inter_mode_sb(cpi, tile_data, x, mi_row, mi_col,
- rd_cost, bsize, ctx,
- best_rd.rdcost);
- break;
default: assert(0 && "Unknown pick mode type.");
}
}
@@ -2145,7 +2140,6 @@
BLOCK_SIZE bsize, PC_TREE *pc_tree) {
AV1_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
- const SPEED_FEATURES *const sf = &cpi->sf;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
// Only square blocks from 8x8 to 128x128 are supported
@@ -2180,24 +2174,20 @@
case PARTITION_NONE:
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &dummy_cost,
PARTITION_NONE, bsize, &pc_tree->none, invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ PICK_MODE_NONRD);
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, 0, bsize, partition,
&pc_tree->none, NULL);
break;
case PARTITION_VERT:
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &dummy_cost,
PARTITION_VERT, subsize, &pc_tree->vertical[0], invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ PICK_MODE_NONRD);
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, 0, subsize,
PARTITION_VERT, &pc_tree->vertical[0], NULL);
if (mi_col + hbs < cm->mi_cols && bsize > BLOCK_8X8) {
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col + hbs, &dummy_cost,
PARTITION_VERT, subsize, &pc_tree->vertical[1],
- invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ invalid_rd, PICK_MODE_NONRD);
encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, 0, subsize,
PARTITION_VERT, &pc_tree->vertical[1], NULL);
}
@@ -2205,18 +2195,14 @@
case PARTITION_HORZ:
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &dummy_cost,
PARTITION_HORZ, subsize, &pc_tree->horizontal[0],
- invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ invalid_rd, PICK_MODE_NONRD);
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, 0, subsize,
PARTITION_HORZ, &pc_tree->horizontal[0], NULL);
if (mi_row + hbs < cm->mi_rows && bsize > BLOCK_8X8) {
pick_sb_modes(cpi, tile_data, x, mi_row + hbs, mi_col, &dummy_cost,
PARTITION_HORZ, subsize, &pc_tree->horizontal[1],
- invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ invalid_rd, PICK_MODE_NONRD);
encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, 0, subsize,
PARTITION_HORZ, &pc_tree->horizontal[1], NULL);
}
@@ -2237,8 +2223,7 @@
pc_tree->partitioning = PARTITION_NONE;
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &none_rdc,
PARTITION_NONE, bsize, &pc_tree->none, invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ PICK_MODE_NONRD);
none_rdc.rate += x->partition_cost[pl][PARTITION_NONE];
none_rdc.rdcost = RDCOST(x->rdmult, none_rdc.rate, none_rdc.dist);
restore_context(x, &x_ctx, mi_row, mi_col, bsize, 3);
@@ -2258,9 +2243,7 @@
pc_tree->split[i]->partitioning = PARTITION_NONE;
pick_sb_modes(cpi, tile_data, x, mi_row + y_idx, mi_col + x_idx,
&block_rdc, PARTITION_NONE, subsize,
- &pc_tree->split[i]->none, invalid_rd,
- sf->use_fast_nonrd_pick_mode ? PICK_MODE_FAST_NONRD
- : PICK_MODE_NONRD);
+ &pc_tree->split[i]->none, invalid_rd, PICK_MODE_NONRD);
split_rdc.rate += block_rdc.rate;
split_rdc.dist += block_rdc.dist;
@@ -4562,7 +4545,7 @@
const TileInfo *const tile_info = &this_tile->tile_info;
int mi_row;
- if (!cpi->sf.use_fast_nonrd_pick_mode) av1_inter_mode_data_init(this_tile);
+ if (!cpi->sf.use_nonrd_pick_mode) av1_inter_mode_data_init(this_tile);
av1_zero_above_context(cm, &td->mb.e_mbd, tile_info->mi_col_start,
tile_info->mi_col_end, tile_row);
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index 99d8ecb..408d9b0 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -1362,11 +1362,11 @@
pd->dst.buf = dst_buf_base;
}
-void av1_fast_nonrd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data,
- MACROBLOCK *x, int mi_row, int mi_col,
- RD_STATS *rd_cost, BLOCK_SIZE bsize,
- PICK_MODE_CONTEXT *ctx,
- int64_t best_rd_so_far) {
+void av1_nonrd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data,
+ MACROBLOCK *x, int mi_row, int mi_col,
+ RD_STATS *rd_cost, BLOCK_SIZE bsize,
+ PICK_MODE_CONTEXT *ctx,
+ int64_t best_rd_so_far) {
AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mi = xd->mi[0];
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index bc4b663..bbd69bb 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -9755,7 +9755,7 @@
const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group);
const int prune_obmc =
cpi->obmc_probs[update_type][bsize] < cpi->sf.prune_obmc_prob_thresh;
- if ((cpi->oxcf.enable_obmc == 0 || cpi->sf.use_fast_nonrd_pick_mode ||
+ if ((cpi->oxcf.enable_obmc == 0 || cpi->sf.use_nonrd_pick_mode ||
prune_obmc) &&
mbmi->motion_mode == OBMC_CAUSAL)
continue;
@@ -12784,44 +12784,6 @@
}
}
-// sf->prune_single_motion_modes_by_simple_trans
-static int analyze_simple_trans_states(const AV1_COMP *cpi, MACROBLOCK *x) {
- (void)cpi;
- int64_t rdcosts[REF_FRAMES] = { INT64_MAX, INT64_MAX, INT64_MAX, INT64_MAX,
- INT64_MAX, INT64_MAX, INT64_MAX, INT64_MAX };
- int skip_ref = 0;
- int64_t min_rd = INT64_MAX;
- for (THR_MODES i = SINGLE_REF_MODE_START; i < SINGLE_REF_MODE_END; ++i) {
- const MODE_DEFINITION *mode_order = &av1_mode_defs[i];
- const MV_REFERENCE_FRAME ref_frame = mode_order->ref_frame[0];
- for (int k = 0; k < MAX_REF_MV_SEARCH; ++k) {
- const int64_t rd = x->simple_rd_state[i][k].rd_stats.rdcost;
- rdcosts[ref_frame] = AOMMIN(rdcosts[ref_frame], rd);
- min_rd = AOMMIN(min_rd, rd);
- }
- }
- int valid_cnt = 0;
- for (int i = 1; i < REF_FRAMES; ++i) {
- if (rdcosts[i] == INT64_MAX) {
- skip_ref |= (1 << i);
- } else {
- valid_cnt++;
- }
- }
- if (valid_cnt < 2) {
- return 0;
- }
- min_rd += (min_rd >> 1);
- if (valid_cnt > 2) {
- for (int i = 1; i < REF_FRAMES; ++i) {
- if (rdcosts[i] > min_rd) {
- skip_ref |= (1 << i);
- }
- }
- }
- return skip_ref;
-}
-
static int compare_int64(const void *a, const void *b) {
int64_t a64 = *((int64_t *)a);
int64_t b64 = *((int64_t *)b);
@@ -13459,566 +13421,6 @@
}
}
-// TODO(kyslov): now this is very similar to set_params_rd_pick_inter_mode
-// (except that doesn't set ALTREF parameters)
-// consider passing a flag to select non-rd path (similar to
-// encode_sb_row)
-static AOM_INLINE void set_params_nonrd_pick_inter_mode(
- const AV1_COMP *cpi, MACROBLOCK *x, HandleInterModeArgs *args,
- BLOCK_SIZE bsize, int mi_row, int mi_col, mode_skip_mask_t *mode_skip_mask,
- int skip_ref_frame_mask, unsigned int ref_costs_single[REF_FRAMES],
- unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES],
- struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE]) {
- const AV1_COMMON *const cm = &cpi->common;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
- unsigned char segment_id = mbmi->segment_id;
-
- if (xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH) {
- int len = sizeof(uint16_t);
- args->above_pred_buf[0] = CONVERT_TO_BYTEPTR(x->above_pred_buf);
- args->above_pred_buf[1] =
- CONVERT_TO_BYTEPTR(x->above_pred_buf + (MAX_SB_SQUARE >> 1) * len);
- args->above_pred_buf[2] =
- CONVERT_TO_BYTEPTR(x->above_pred_buf + MAX_SB_SQUARE * len);
- args->left_pred_buf[0] = CONVERT_TO_BYTEPTR(x->left_pred_buf);
- args->left_pred_buf[1] =
- CONVERT_TO_BYTEPTR(x->left_pred_buf + (MAX_SB_SQUARE >> 1) * len);
- args->left_pred_buf[2] =
- CONVERT_TO_BYTEPTR(x->left_pred_buf + MAX_SB_SQUARE * len);
- } else {
- args->above_pred_buf[0] = x->above_pred_buf;
- args->above_pred_buf[1] = x->above_pred_buf + (MAX_SB_SQUARE >> 1);
- args->above_pred_buf[2] = x->above_pred_buf + MAX_SB_SQUARE;
- args->left_pred_buf[0] = x->left_pred_buf;
- args->left_pred_buf[1] = x->left_pred_buf + (MAX_SB_SQUARE >> 1);
- args->left_pred_buf[2] = x->left_pred_buf + MAX_SB_SQUARE;
- }
-
- av1_collect_neighbors_ref_counts(xd);
-
- estimate_ref_frame_costs(cm, xd, x, segment_id, ref_costs_single,
- ref_costs_comp);
-
- MV_REFERENCE_FRAME ref_frame;
- for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
- x->pred_mv_sad[ref_frame] = INT_MAX;
- x->mbmi_ext->mode_context[ref_frame] = 0;
- mbmi_ext->ref_mv_count[ref_frame] = UINT8_MAX;
- if (cpi->ref_frame_flags & av1_ref_frame_flag_list[ref_frame]) {
- if (mbmi->partition != PARTITION_NONE &&
- mbmi->partition != PARTITION_SPLIT) {
- if (skip_ref_frame_mask & (1 << ref_frame)) {
- int skip = 1;
- for (int r = ALTREF_FRAME + 1; r < MODE_CTX_REF_FRAMES; ++r) {
- if (!(skip_ref_frame_mask & (1 << r))) {
- const MV_REFERENCE_FRAME *rf = ref_frame_map[r - REF_FRAMES];
- if (rf[0] == ref_frame || rf[1] == ref_frame) {
- skip = 0;
- break;
- }
- }
- }
- if (skip) continue;
- }
- }
- assert(get_ref_frame_yv12_buf(cm, ref_frame) != NULL);
- setup_buffer_ref_mvs_inter(cpi, x, ref_frame, bsize, mi_row, mi_col,
- yv12_mb);
- }
- }
-
- av1_count_overlappable_neighbors(cm, xd, mi_row, mi_col);
- init_mode_skip_mask(mode_skip_mask, cpi, x, bsize);
-
- if (cpi->sf.tx_type_search.fast_intra_tx_type_search)
- x->use_default_intra_tx_type = 1;
- else
- x->use_default_intra_tx_type = 0;
-
- if (cpi->sf.tx_type_search.fast_inter_tx_type_search)
- x->use_default_inter_tx_type = 1;
- else
- x->use_default_inter_tx_type = 0;
-}
-
-// TODO(kyslov): now this is very similar to av1_rd_pick_inter_mode_sb except:
-// it only checks non-compound mode and
-// it doesn't check palette mode
-// it doesn't refine tx search
-// this function is likely to be heavily modified with nonrd mode
-// decision
-void av1_nonrd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data,
- MACROBLOCK *x, int mi_row, int mi_col,
- RD_STATS *rd_cost, BLOCK_SIZE bsize,
- PICK_MODE_CONTEXT *ctx,
- int64_t best_rd_so_far) {
- AV1_COMMON *const cm = &cpi->common;
- const int num_planes = av1_num_planes(cm);
- const SPEED_FEATURES *const sf = &cpi->sf;
- MACROBLOCKD *const xd = &x->e_mbd;
- MB_MODE_INFO *const mbmi = xd->mi[0];
- const struct segmentation *const seg = &cm->seg;
- unsigned char segment_id = mbmi->segment_id;
- int i;
- struct buf_2d yv12_mb[REF_FRAMES][MAX_MB_PLANE];
- unsigned int ref_costs_single[REF_FRAMES];
- unsigned int ref_costs_comp[REF_FRAMES][REF_FRAMES];
- int *comp_inter_cost = x->comp_inter_cost[av1_get_reference_mode_context(xd)];
- mode_skip_mask_t mode_skip_mask;
- uint8_t motion_mode_skip_mask = 0; // second pass of single ref modes
-
- InterModeSearchState search_state;
- init_inter_mode_search_state(&search_state, cpi, x, bsize, best_rd_so_far);
- HandleInterModeArgs args = { { NULL },
- { MAX_SB_SIZE, MAX_SB_SIZE, MAX_SB_SIZE },
- { NULL },
- { MAX_SB_SIZE >> 1, MAX_SB_SIZE >> 1,
- MAX_SB_SIZE >> 1 },
- NULL,
- NULL,
- NULL,
- search_state.modelled_rd,
- INT_MAX,
- INT_MAX,
- search_state.simple_rd,
- 0,
- NULL,
- 1,
- NULL,
- { { { { 0 }, { { 0 } }, { 0 }, 0, 0, 0 } } },
- { 0 } };
- for (i = 0; i < REF_FRAMES; ++i) x->pred_sse[i] = INT_MAX;
-
- av1_invalid_rd_stats(rd_cost);
-
- // Ref frames that are selected by square partition blocks.
- int picked_ref_frames_mask = 0;
- if (cpi->sf.prune_ref_frame_for_rect_partitions &&
- mbmi->partition != PARTITION_NONE && mbmi->partition != PARTITION_SPLIT) {
- // Don't enable for vert and horz partition blocks if current frame
- // will be used as bwd or arf2.
- if (!cpi->refresh_bwd_ref_frame || (mbmi->partition != PARTITION_VERT &&
- mbmi->partition != PARTITION_HORZ)) {
- picked_ref_frames_mask = fetch_picked_ref_frames_mask(
- x, bsize, cm->seq_params.mib_size, mi_row, mi_col);
- }
- }
-
- // Skip ref frames that never selected by square blocks.
- const int skip_ref_frame_mask =
- picked_ref_frames_mask ? ~picked_ref_frames_mask : 0;
-
- // init params, set frame modes, speed features
- set_params_nonrd_pick_inter_mode(cpi, x, &args, bsize, mi_row, mi_col,
- &mode_skip_mask, skip_ref_frame_mask,
- ref_costs_single, ref_costs_comp, yv12_mb);
-
- int64_t best_est_rd = INT64_MAX;
- InterModesInfo *inter_modes_info = x->inter_modes_info;
- inter_modes_info->num = 0;
-
- int intra_mode_num = 0;
- int intra_mode_idx_ls[MAX_MODES];
- int reach_first_comp_mode = 0;
-
- // Temporary buffers used by handle_inter_mode().
- uint8_t *const tmp_buf = get_buf_by_bd(xd, x->tmp_obmc_bufs[0]);
-
- for (int midx = 0; midx < MAX_MODES; ++midx) {
- const THR_MODES mode_enum = av1_default_mode_order[midx];
- const MODE_DEFINITION *mode_def = &av1_mode_defs[mode_enum];
- const PREDICTION_MODE this_mode = mode_def->mode;
- const MV_REFERENCE_FRAME *ref_frames = mode_def->ref_frame;
-
- if (inter_mode_compatible_skip(cpi, x, bsize, this_mode, ref_frames))
- continue;
-
- const int ret = inter_mode_search_order_independent_skip(
- cpi, x, &mode_skip_mask, &search_state, skip_ref_frame_mask, this_mode,
- mode_def->ref_frame);
- if (ret == 1) continue;
- args.skip_motion_mode = (ret == 2);
-
- const MV_REFERENCE_FRAME ref_frame = ref_frames[0];
- const MV_REFERENCE_FRAME second_ref_frame = ref_frames[1];
- const int is_single_pred =
- ref_frame > INTRA_FRAME && second_ref_frame == NONE_FRAME;
- const int comp_pred = second_ref_frame > INTRA_FRAME;
-
- if (second_ref_frame != NONE_FRAME) continue;
-
- // When single ref motion search ends:
- // 1st pass: To evaluate single ref RD results and rewind to the beginning;
- // 2nd pass: To continue with compound ref search.
- if (sf->prune_single_motion_modes_by_simple_trans) {
- if (comp_pred && args.single_ref_first_pass) {
- args.single_ref_first_pass = 0;
- // Reach the first comp ref mode
- // Reset midx to start the 2nd pass for single ref motion search
- midx = -1;
- motion_mode_skip_mask = analyze_simple_trans_states(cpi, x);
- continue;
- }
- if (!comp_pred && ref_frame != INTRA_FRAME) { // single ref mode
- if (args.single_ref_first_pass) {
- // clear stats
- for (int k = 0; k < MAX_REF_MV_SEARCH; ++k) {
- x->simple_rd_state[mode_enum][k].rd_stats.rdcost = INT64_MAX;
- x->simple_rd_state[mode_enum][k].early_skipped = 0;
- }
- } else {
- if (motion_mode_skip_mask & (1 << ref_frame)) {
- continue;
- }
- }
- }
- }
-
- // Reach the first compound prediction mode
- if (sf->prune_comp_search_by_single_result > 0 && comp_pred &&
- reach_first_comp_mode == 0) {
- analyze_single_states(cpi, &search_state);
- reach_first_comp_mode = 1;
- }
- int64_t this_rd = INT64_MAX;
- int disable_skip = 0;
- int rate2 = 0;
- int64_t distortion2 = 0;
- int skippable = 0;
- int this_skip2 = 0;
-
- init_mbmi(mbmi, this_mode, ref_frames, cm);
-
- x->skip = 0;
- set_ref_ptrs(cm, xd, ref_frame, second_ref_frame);
-
- if (sf->drop_ref && comp_pred) {
- if (sf_check_is_drop_ref(mode_def, &search_state)) {
- continue;
- }
- }
-
- if (search_state.best_rd < search_state.mode_threshold[mode_enum]) continue;
-
- if (sf->prune_comp_search_by_single_result > 0 && comp_pred) {
- if (compound_skip_by_single_states(cpi, &search_state, this_mode,
- ref_frame, second_ref_frame, x))
- continue;
- }
-
- const int ref_frame_cost = comp_pred
- ? ref_costs_comp[ref_frame][second_ref_frame]
- : ref_costs_single[ref_frame];
- const int compmode_cost =
- is_comp_ref_allowed(mbmi->sb_type) ? comp_inter_cost[comp_pred] : 0;
- const int real_compmode_cost =
- cm->current_frame.reference_mode == REFERENCE_MODE_SELECT
- ? compmode_cost
- : 0;
-
- if (comp_pred) {
- if ((sf->mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA) &&
- search_state.best_mode_index != THR_INVALID &&
- search_state.best_mbmode.ref_frame[0] == INTRA_FRAME)
- continue;
- }
-
- if (ref_frame == INTRA_FRAME) {
- if (!cpi->oxcf.enable_smooth_intra &&
- (mbmi->mode == SMOOTH_PRED || mbmi->mode == SMOOTH_H_PRED ||
- mbmi->mode == SMOOTH_V_PRED))
- continue;
- if (!cpi->oxcf.enable_paeth_intra && mbmi->mode == PAETH_PRED) continue;
- if (sf->adaptive_mode_search > 1)
- if ((x->source_variance << num_pels_log2_lookup[bsize]) >
- search_state.best_pred_sse)
- continue;
- }
-
- // Select prediction reference frames.
- for (i = 0; i < num_planes; i++) {
- xd->plane[i].pre[0] = yv12_mb[ref_frame][i];
- if (comp_pred) xd->plane[i].pre[1] = yv12_mb[second_ref_frame][i];
- }
-
- if (ref_frame == INTRA_FRAME) {
- intra_mode_idx_ls[intra_mode_num++] = mode_enum;
- continue;
- } else {
- mbmi->angle_delta[PLANE_TYPE_Y] = 0;
- mbmi->angle_delta[PLANE_TYPE_UV] = 0;
- mbmi->filter_intra_mode_info.use_filter_intra = 0;
- mbmi->ref_mv_idx = 0;
- int64_t ref_best_rd = search_state.best_rd;
- {
- RD_STATS rd_stats, rd_stats_y, rd_stats_uv;
- av1_init_rd_stats(&rd_stats);
- rd_stats.rate = rate2;
-
- // Point to variables that are maintained between loop iterations
- args.single_newmv = search_state.single_newmv;
- args.single_newmv_rate = search_state.single_newmv_rate;
- args.single_newmv_valid = search_state.single_newmv_valid;
- args.single_comp_cost = real_compmode_cost;
- args.ref_frame_cost = ref_frame_cost;
- if (is_single_pred) {
- args.simple_rd_state = x->simple_rd_state[mode_enum];
- }
- this_rd = handle_inter_mode(
- cpi, tile_data, x, bsize, &rd_stats, &rd_stats_y, &rd_stats_uv,
- &disable_skip, mi_row, mi_col, &args, ref_best_rd, tmp_buf,
- &x->comp_rd_buffer, &best_est_rd, 0, inter_modes_info);
- rate2 = rd_stats.rate;
- skippable = rd_stats.skip;
- distortion2 = rd_stats.dist;
- }
-
- if (sf->prune_comp_search_by_single_result > 0 &&
- is_inter_singleref_mode(this_mode) && args.single_ref_first_pass) {
- collect_single_states(x, &search_state, mbmi);
- }
-
- if (this_rd == INT64_MAX) continue;
-
- this_skip2 = mbmi->skip;
- this_rd = RDCOST(x->rdmult, rate2, distortion2);
- }
-
- // Did this mode help.. i.e. is it the new best mode
- if (this_rd < search_state.best_rd || x->skip) {
- int mode_excluded = 0;
- if (comp_pred) {
- mode_excluded = cm->current_frame.reference_mode == SINGLE_REFERENCE;
- }
- if (!mode_excluded) {
- // Note index of best mode so far
- search_state.best_mode_index = mode_enum;
-
- if (ref_frame == INTRA_FRAME) {
- /* required for left and above block mv */
- mbmi->mv[0].as_int = 0;
- } else {
- search_state.best_pred_sse = x->pred_sse[ref_frame];
- }
-
- rd_cost->rate = rate2;
- rd_cost->dist = distortion2;
- rd_cost->rdcost = this_rd;
- search_state.best_rd = this_rd;
- search_state.best_mbmode = *mbmi;
- search_state.best_skip2 = this_skip2;
- search_state.best_mode_skippable = skippable;
- memcpy(ctx->blk_skip, x->blk_skip,
- sizeof(x->blk_skip[0]) * ctx->num_4x4_blk);
- }
- }
-
- /* keep record of best compound/single-only prediction */
- if (!disable_skip && ref_frame != INTRA_FRAME) {
- int64_t single_rd, hybrid_rd, single_rate, hybrid_rate;
-
- if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) {
- single_rate = rate2 - compmode_cost;
- hybrid_rate = rate2;
- } else {
- single_rate = rate2;
- hybrid_rate = rate2 + compmode_cost;
- }
-
- single_rd = RDCOST(x->rdmult, single_rate, distortion2);
- hybrid_rd = RDCOST(x->rdmult, hybrid_rate, distortion2);
-
- if (!comp_pred) {
- if (single_rd < search_state.best_pred_rd[SINGLE_REFERENCE])
- search_state.best_pred_rd[SINGLE_REFERENCE] = single_rd;
- } else {
- if (single_rd < search_state.best_pred_rd[COMPOUND_REFERENCE])
- search_state.best_pred_rd[COMPOUND_REFERENCE] = single_rd;
- }
- if (hybrid_rd < search_state.best_pred_rd[REFERENCE_MODE_SELECT])
- search_state.best_pred_rd[REFERENCE_MODE_SELECT] = hybrid_rd;
- }
- if (sf->drop_ref && second_ref_frame == NONE_FRAME) {
- // Collect data from single ref mode, and analyze data.
- sf_drop_ref_analyze(&search_state, mode_def, distortion2);
- }
-
- if (x->skip && !comp_pred) break;
- }
-
- inter_modes_info_sort(inter_modes_info, inter_modes_info->rd_idx_pair_arr);
- search_state.best_rd = INT64_MAX;
-
- if (inter_modes_info->num > 0) {
- const int data_idx = inter_modes_info->rd_idx_pair_arr[0].idx;
- *mbmi = inter_modes_info->mbmi_arr[data_idx];
- const int mode_rate = inter_modes_info->mode_rate_arr[data_idx];
-
- x->skip = 0;
- set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
-
- // Select prediction reference frames.
- const int is_comp_pred = mbmi->ref_frame[1] > INTRA_FRAME;
- for (i = 0; i < num_planes; i++) {
- xd->plane[i].pre[0] = yv12_mb[mbmi->ref_frame[0]][i];
- if (is_comp_pred) xd->plane[i].pre[1] = yv12_mb[mbmi->ref_frame[1]][i];
- }
-
- RD_STATS rd_stats;
- RD_STATS rd_stats_y;
- RD_STATS rd_stats_uv;
-
- av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, 0,
- av1_num_planes(cm) - 1);
- if (mbmi->motion_mode == OBMC_CAUSAL)
- av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col);
-
- if (txfm_search(cpi, tile_data, x, bsize, mi_row, mi_col, &rd_stats,
- &rd_stats_y, &rd_stats_uv, mode_rate,
- search_state.best_rd)) {
- if (cpi->sf.inter_mode_rd_model_estimation == 1) {
- const int skip_ctx = av1_get_skip_context(xd);
- inter_mode_data_push(tile_data, mbmi->sb_type, rd_stats.sse,
- rd_stats.dist,
- rd_stats_y.rate + rd_stats_uv.rate +
- x->skip_cost[skip_ctx][mbmi->skip]);
- }
- rd_stats.rdcost = RDCOST(x->rdmult, rd_stats.rate, rd_stats.dist);
-
- if (rd_stats.rdcost < search_state.best_rd) {
- // TODO(chiyotsai@google.com): get_prediction_mode_idx gives incorrect
- // output once we change the mode order. Fix this!
- const THR_MODES mode_enum = get_prediction_mode_idx(
- mbmi->mode, mbmi->ref_frame[0], mbmi->ref_frame[1]);
- const int txfm_search_done = 1;
- update_search_state(&search_state, rd_cost, ctx, &rd_stats, &rd_stats_y,
- &rd_stats_uv, mode_enum, x, txfm_search_done);
- }
- }
- }
-
- for (int j = 0; j < intra_mode_num; ++j) {
- const THR_MODES mode_enum = intra_mode_idx_ls[j];
- const MODE_DEFINITION *mode_def = &av1_mode_defs[mode_enum];
- const PREDICTION_MODE curr_mode = mode_def->mode;
- const MV_REFERENCE_FRAME ref_frame = av1_mode_defs[mode_enum].ref_frame[0];
- assert(av1_mode_defs[mode_enum].ref_frame[1] == NONE_FRAME);
- assert(ref_frame == INTRA_FRAME);
- if (sf->skip_intra_in_interframe && search_state.skip_intra_modes) break;
- if (curr_mode != DC_PRED) {
- // Only search the oblique modes if the best so far is
- // one of the neighboring directional modes
- if ((sf->mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER) &&
- (curr_mode >= D45_PRED && curr_mode <= PAETH_PRED)) {
- if (search_state.best_mode_index != THR_INVALID &&
- search_state.best_mbmode.ref_frame[0] > INTRA_FRAME)
- continue;
- }
- if (sf->mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH) {
- if (conditional_skipintra(curr_mode, search_state.best_intra_mode))
- continue;
- }
- }
- init_mbmi(mbmi, curr_mode, mode_def->ref_frame, cm);
- x->skip = 0;
- set_ref_ptrs(cm, xd, INTRA_FRAME, NONE_FRAME);
-
- // Select prediction reference frames.
- for (i = 0; i < num_planes; i++) {
- xd->plane[i].pre[0] = yv12_mb[ref_frame][i];
- }
-
- RD_STATS intra_rd_stats, intra_rd_stats_y, intra_rd_stats_uv;
-
- const int ref_frame_cost = ref_costs_single[ref_frame];
- intra_rd_stats.rdcost = handle_intra_mode(
- &search_state, cpi, x, bsize, ref_frame_cost, ctx, 0, &intra_rd_stats,
- &intra_rd_stats_y, &intra_rd_stats_uv);
- if (intra_rd_stats.rdcost < search_state.best_rd) {
- const int txfm_search_done = 1;
- update_search_state(&search_state, rd_cost, ctx, &intra_rd_stats,
- &intra_rd_stats_y, &intra_rd_stats_uv, mode_enum, x,
- txfm_search_done);
- }
- }
-
- search_state.best_mbmode.skip_mode = 0;
- if (cm->current_frame.skip_mode_info.skip_mode_flag &&
- !segfeature_active(seg, segment_id, SEG_LVL_REF_FRAME) &&
- is_comp_ref_allowed(bsize)) {
- rd_pick_skip_mode(rd_cost, &search_state, cpi, x, bsize, mi_row, mi_col,
- yv12_mb);
- }
-
- // Make sure that the ref_mv_idx is only nonzero when we're
- // using a mode which can support ref_mv_idx
- if (search_state.best_mbmode.ref_mv_idx != 0 &&
- !(search_state.best_mbmode.mode == NEWMV ||
- search_state.best_mbmode.mode == NEW_NEWMV ||
- have_nearmv_in_inter_mode(search_state.best_mbmode.mode))) {
- search_state.best_mbmode.ref_mv_idx = 0;
- }
-
- if (search_state.best_mode_index == THR_INVALID ||
- search_state.best_rd >= best_rd_so_far) {
- rd_cost->rate = INT_MAX;
- rd_cost->rdcost = INT64_MAX;
- return;
- }
-
- assert((cm->interp_filter == SWITCHABLE) ||
- (cm->interp_filter ==
- search_state.best_mbmode.interp_filters.as_filters.y_filter) ||
- !is_inter_block(&search_state.best_mbmode));
- assert((cm->interp_filter == SWITCHABLE) ||
- (cm->interp_filter ==
- search_state.best_mbmode.interp_filters.as_filters.x_filter) ||
- !is_inter_block(&search_state.best_mbmode));
-
- if (!cpi->rc.is_src_frame_alt_ref)
- av1_update_rd_thresh_fact(cm, x->thresh_freq_fact, sf->adaptive_rd_thresh,
- bsize, search_state.best_mode_index);
-
- // macroblock modes
- *mbmi = search_state.best_mbmode;
- x->skip |= search_state.best_skip2;
-
- // Note: this section is needed since the mode may have been forced to
- // GLOBALMV by the all-zero mode handling of ref-mv.
- if (mbmi->mode == GLOBALMV || mbmi->mode == GLOBAL_GLOBALMV) {
- // Correct the interp filters for GLOBALMV
- if (is_nontrans_global_motion(xd, xd->mi[0])) {
- int_interpfilters filters = av1_broadcast_interp_filter(
- av1_unswitchable_filter(cm->interp_filter));
- assert(mbmi->interp_filters.as_int == filters.as_int);
- (void)filters;
- }
- }
-
- for (i = 0; i < REFERENCE_MODES; ++i) {
- if (search_state.best_pred_rd[i] == INT64_MAX)
- search_state.best_pred_diff[i] = INT_MIN;
- else
- search_state.best_pred_diff[i] =
- search_state.best_rd - search_state.best_pred_rd[i];
- }
-
- x->skip |= search_state.best_mode_skippable;
-
- assert(search_state.best_mode_index != THR_INVALID);
-
-#if CONFIG_INTERNAL_STATS
- store_coding_context(x, ctx, search_state.best_mode_index,
- search_state.best_pred_diff,
- search_state.best_mode_skippable);
-#else
- store_coding_context(x, ctx, search_state.best_pred_diff,
- search_state.best_mode_skippable);
-#endif // CONFIG_INTERNAL_STATS
-}
-
void av1_rd_pick_inter_mode_sb_seg_skip(const AV1_COMP *cpi,
TileDataEnc *tile_data, MACROBLOCK *x,
int mi_row, int mi_col,
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index d24401b..971ce9d 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -123,13 +123,6 @@
struct RD_STATS *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx, int64_t best_rd_so_far);
-void av1_fast_nonrd_pick_inter_mode_sb(struct AV1_COMP *cpi,
- struct TileDataEnc *tile_data,
- struct macroblock *x, int mi_row,
- int mi_col, struct RD_STATS *rd_cost,
- BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
- int64_t best_rd_so_far);
-
void av1_nonrd_pick_inter_mode_sb(struct AV1_COMP *cpi,
struct TileDataEnc *tile_data,
struct macroblock *x, int mi_row, int mi_col,
diff --git a/av1/encoder/speed_features.c b/av1/encoder/speed_features.c
index 4f28f38..7487ddc 100644
--- a/av1/encoder/speed_features.c
+++ b/av1/encoder/speed_features.c
@@ -494,7 +494,6 @@
sf->cb_pred_filter_search = 0;
sf->use_nonrd_pick_mode = 0;
sf->use_real_time_ref_set = 0;
- sf->use_fast_nonrd_pick_mode = 0;
sf->reuse_inter_pred_nonrd = 0;
sf->estimate_motion_for_var_based_partition = 1;
sf->use_comp_ref_nonrd = 1;
@@ -672,7 +671,6 @@
sf->mode_search_skip_flags |= FLAG_SKIP_INTRA_DIRMISMATCH;
sf->tx_size_search_level = 1;
sf->use_nonrd_pick_mode = 1;
- sf->use_fast_nonrd_pick_mode = 1;
sf->use_comp_ref_nonrd = 0;
sf->inter_mode_rd_model_estimation = 2;
sf->cdef_pick_method = CDEF_PICK_FROM_Q;
diff --git a/av1/encoder/speed_features.h b/av1/encoder/speed_features.h
index 84b141a..4f3127a 100644
--- a/av1/encoder/speed_features.h
+++ b/av1/encoder/speed_features.h
@@ -729,10 +729,6 @@
// TODO(any): Find out when we can actually skip tx_search on some modes.
int inter_mode_rd_model_estimation_adaptive;
- // Use very reduced set of inter mode checks and fast non-rd mode cost
- // estimation. Only enabled when use_nonrd_pick_mode is != 0
- int use_fast_nonrd_pick_mode;
-
// Reuse inter prediction in fast non-rd mode.
int reuse_inter_pred_nonrd;
diff --git a/av1/encoder/var_based_part.c b/av1/encoder/var_based_part.c
index 0749f7f..39a8d28 100644
--- a/av1/encoder/var_based_part.c
+++ b/av1/encoder/var_based_part.c
@@ -687,7 +687,7 @@
// For non-SVC GOLDEN is another temporal reference. Check if it should be
// used as reference for partitioning.
if (!cpi->use_svc && (cpi->ref_frame_flags & AOM_GOLD_FLAG) &&
- cpi->sf.use_fast_nonrd_pick_mode) {
+ cpi->sf.use_nonrd_pick_mode) {
yv12_g = get_ref_frame_yv12_buf(cm, GOLDEN_FRAME);
if (yv12_g && yv12_g != yv12) {
av1_setup_pre_planes(xd, 0, yv12_g, mi_row, mi_col,
