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,