/* * Copyright (c) 2016, Alliance for Open Media. All rights reserved. * * This source code is subject to the terms of the BSD 2 Clause License and * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License * was not distributed with this source code in the LICENSE file, you can * obtain it at www.aomedia.org/license/software. If the Alliance for Open * Media Patent License 1.0 was not distributed with this source code in the * PATENTS file, you can obtain it at www.aomedia.org/license/patent. */ #include <assert.h> #include <limits.h> #include <math.h> #include <stdio.h> #include "av1/common/reconinter.h" #include "av1/common/reconintra.h" #include "av1/encoder/encodemv.h" #include "av1/encoder/intra_mode_search.h" #include "av1/encoder/model_rd.h" #include "av1/encoder/motion_search_facade.h" #include "av1/encoder/nonrd_opt.h" #include "av1/encoder/palette.h" #include "av1/encoder/reconinter_enc.h" #include "av1/encoder/var_based_part.h" static inline int early_term_inter_search_with_sse(int early_term_idx, BLOCK_SIZE bsize, int64_t this_sse, int64_t best_sse, PREDICTION_MODE this_mode) { … } static inline void init_best_pickmode(BEST_PICKMODE *bp) { … } // Copy best inter mode parameters to best_pickmode static inline void update_search_state_nonrd( InterModeSearchStateNonrd *search_state, MB_MODE_INFO *const mi, TxfmSearchInfo *txfm_info, RD_STATS *nonskip_rdc, PICK_MODE_CONTEXT *ctx, PREDICTION_MODE this_best_mode, const int64_t sse_y) { … } static inline int subpel_select(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int_mv *mv, MV ref_mv, FULLPEL_MV start_mv, bool fullpel_performed_well) { … } static bool use_aggressive_subpel_search_method(MACROBLOCK *x, bool use_adaptive_subpel_search, bool fullpel_performed_well) { … } /*!\brief Runs Motion Estimation for a specific block and specific ref frame. * * \ingroup nonrd_mode_search * \callgraph * \callergraph * Finds the best Motion Vector by running Motion Estimation for a specific * block and a specific reference frame. Exits early if RDCost of Full Pel part * exceeds best RD Cost fund so far * \param[in] cpi Top-level encoder structure * \param[in] x Pointer to structure holding all the * data for the current macroblock * \param[in] bsize Current block size * \param[in] tmp_mv Pointer to best found New MV * \param[in] rate_mv Pointer to Rate of the best new MV * \param[in] best_rd_sofar RD Cost of the best mode found so far * \param[in] use_base_mv Flag, indicating that tmp_mv holds * specific MV to start the search with * * \return Returns 0 if ME was terminated after Full Pel Search because too * high RD Cost. Otherwise returns 1. Best New MV is placed into \c tmp_mv. * Rate estimation for this vector is placed to \c rate_mv */ static int combined_motion_search(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int_mv *tmp_mv, int *rate_mv, int64_t best_rd_sofar, int use_base_mv) { … } /*!\brief Searches for the best New Motion Vector. * * \ingroup nonrd_mode_search * \callgraph * \callergraph * Finds the best Motion Vector by doing Motion Estimation. Uses reduced * complexity ME for non-LAST frames or calls \c combined_motion_search * for LAST reference frame * \param[in] cpi Top-level encoder structure * \param[in] x Pointer to structure holding all the * data for the current macroblock * \param[in] frame_mv Array that holds MVs for all modes * and ref frames * \param[in] ref_frame Reference frame for which to find * the best New MVs * \param[in] gf_temporal_ref Flag, indicating temporal reference * for GOLDEN frame * \param[in] bsize Current block size * \param[in] mi_row Row index in 4x4 units * \param[in] mi_col Column index in 4x4 units * \param[in] rate_mv Pointer to Rate of the best new MV * \param[in] best_rdc Pointer to the RD Cost for the best * mode found so far * * \return Returns -1 if the search was not done, otherwise returns 0. * Best New MV is placed into \c frame_mv array, Rate estimation for this * vector is placed to \c rate_mv */ static int search_new_mv(AV1_COMP *cpi, MACROBLOCK *x, int_mv frame_mv[][REF_FRAMES], MV_REFERENCE_FRAME ref_frame, int gf_temporal_ref, BLOCK_SIZE bsize, int mi_row, int mi_col, int *rate_mv, RD_STATS *best_rdc) { … } static void estimate_single_ref_frame_costs(const AV1_COMMON *cm, const MACROBLOCKD *xd, const ModeCosts *mode_costs, int segment_id, BLOCK_SIZE bsize, unsigned int *ref_costs_single) { … } static inline void set_force_skip_flag(const AV1_COMP *const cpi, MACROBLOCK *const x, unsigned int sse, int *force_skip) { … } #define CAP_TX_SIZE_FOR_BSIZE_GT32(tx_mode_search_type, bsize) … #define TX_SIZE_FOR_BSIZE_GT32 … static TX_SIZE calculate_tx_size(const AV1_COMP *const cpi, BLOCK_SIZE bsize, MACROBLOCK *const x, unsigned int var, unsigned int sse, int *force_skip) { … } static void block_variance(const uint8_t *src, int src_stride, const uint8_t *ref, int ref_stride, int w, int h, unsigned int *sse, int *sum, int block_size, uint32_t *sse8x8, int *sum8x8, uint32_t *var8x8) { … } static void block_variance_16x16_dual(const uint8_t *src, int src_stride, const uint8_t *ref, int ref_stride, int w, int h, unsigned int *sse, int *sum, int block_size, uint32_t *sse16x16, uint32_t *var16x16) { … } static void calculate_variance(int bw, int bh, TX_SIZE tx_size, unsigned int *sse_i, int *sum_i, unsigned int *var_o, unsigned int *sse_o, int *sum_o) { … } // Adjust the ac_thr according to speed, width, height and normalized sum static int ac_thr_factor(int speed, int width, int height, int norm_sum) { … } // Sets early_term flag based on chroma planes prediction static inline void set_early_term_based_on_uv_plane( AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, MACROBLOCKD *xd, int mi_row, int mi_col, int *early_term, int num_blk, const unsigned int *sse_tx, const unsigned int *var_tx, int sum, unsigned int var, unsigned int sse) { … } static inline void calc_rate_dist_block_param(AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *rd_stats, int calculate_rd, int *early_term, BLOCK_SIZE bsize, unsigned int sse) { … } static void model_skip_for_sb_y_large_64(AV1_COMP *cpi, BLOCK_SIZE bsize, int mi_row, int mi_col, MACROBLOCK *x, MACROBLOCKD *xd, RD_STATS *rd_stats, int *early_term, int calculate_rd, int64_t best_sse, unsigned int *var_output, unsigned int var_prune_threshold) { … } static void model_skip_for_sb_y_large(AV1_COMP *cpi, BLOCK_SIZE bsize, int mi_row, int mi_col, MACROBLOCK *x, MACROBLOCKD *xd, RD_STATS *rd_stats, int *early_term, int calculate_rd, int64_t best_sse, unsigned int *var_output, unsigned int var_prune_threshold) { … } static void model_rd_for_sb_y(const AV1_COMP *const cpi, BLOCK_SIZE bsize, MACROBLOCK *x, MACROBLOCKD *xd, RD_STATS *rd_stats, unsigned int *var_out, int calculate_rd, int *early_term) { … } static inline int get_drl_cost(PREDICTION_MODE this_mode, int ref_mv_idx, const MB_MODE_INFO_EXT *mbmi_ext, const int (*const drl_mode_cost0)[2], int8_t ref_frame_type) { … } static int cost_mv_ref(const ModeCosts *const mode_costs, PREDICTION_MODE mode, int16_t mode_context) { … } static void newmv_diff_bias(MACROBLOCKD *xd, PREDICTION_MODE this_mode, RD_STATS *this_rdc, BLOCK_SIZE bsize, int mv_row, int mv_col, int speed, uint32_t spatial_variance, CONTENT_STATE_SB content_state_sb) { … } static inline void update_thresh_freq_fact(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, MV_REFERENCE_FRAME ref_frame, THR_MODES best_mode_idx, PREDICTION_MODE mode) { … } #if CONFIG_AV1_TEMPORAL_DENOISING static void av1_pickmode_ctx_den_update( AV1_PICKMODE_CTX_DEN *ctx_den, int64_t zero_last_cost_orig, unsigned int ref_frame_cost[REF_FRAMES], int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES], int reuse_inter_pred, BEST_PICKMODE *bp) { … } static void recheck_zeromv_after_denoising( AV1_COMP *cpi, MB_MODE_INFO *const mi, MACROBLOCK *x, MACROBLOCKD *const xd, AV1_DENOISER_DECISION decision, AV1_PICKMODE_CTX_DEN *ctx_den, struct buf_2d yv12_mb[4][MAX_MB_PLANE], RD_STATS *best_rdc, BEST_PICKMODE *best_pickmode, BLOCK_SIZE bsize, int mi_row, int mi_col) { … } #endif // CONFIG_AV1_TEMPORAL_DENOISING /*!\brief Searches for the best interpolation filter * * \ingroup nonrd_mode_search * \callgraph * \callergraph * Iterates through subset of possible interpolation filters (EIGHTTAP_REGULAR, * EIGTHTAP_SMOOTH, MULTITAP_SHARP, depending on FILTER_SEARCH_SIZE) and selects * the one that gives lowest RD cost. RD cost is calculated using curvfit model. * Support for dual filters (different filters in the x & y directions) is * allowed if sf.interp_sf.disable_dual_filter = 0. * * \param[in] cpi Top-level encoder structure * \param[in] x Pointer to structure holding all the * data for the current macroblock * \param[in] this_rdc Pointer to calculated RD Cost * \param[in] inter_pred_params_sr Pointer to structure holding parameters of inter prediction for single reference * \param[in] mi_row Row index in 4x4 units * \param[in] mi_col Column index in 4x4 units * \param[in] tmp_buffer Pointer to a temporary buffer for * prediction re-use * \param[in] bsize Current block size * \param[in] reuse_inter_pred Flag, indicating prediction re-use * \param[out] this_mode_pred Pointer to store prediction buffer * for prediction re-use * \param[out] this_early_term Flag, indicating that transform can be * skipped * \param[out] var The residue variance of the current * predictor. * \param[in] use_model_yrd_large Flag, indicating special logic to handle * large blocks * \param[in] best_sse Best sse so far. * \param[in] is_single_pred Flag, indicating single mode. * * \remark Nothing is returned. Instead, calculated RD cost is placed to * \c this_rdc and best filter is placed to \c mi->interp_filters. In case * \c reuse_inter_pred flag is set, this function also outputs * \c this_mode_pred. Also \c this_early_temp is set if transform can be * skipped */ static void search_filter_ref(AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *this_rdc, InterPredParams *inter_pred_params_sr, int mi_row, int mi_col, PRED_BUFFER *tmp_buffer, BLOCK_SIZE bsize, int reuse_inter_pred, PRED_BUFFER **this_mode_pred, int *this_early_term, unsigned int *var, int use_model_yrd_large, int64_t best_sse, int is_single_pred) { … } #if !CONFIG_REALTIME_ONLY static inline int is_warped_mode_allowed(const AV1_COMP *cpi, MACROBLOCK *const x, const MB_MODE_INFO *mbmi) { const FeatureFlags *const features = &cpi->common.features; const MACROBLOCKD *xd = &x->e_mbd; if (cpi->sf.inter_sf.extra_prune_warped) return 0; if (has_second_ref(mbmi)) return 0; MOTION_MODE last_motion_mode_allowed = SIMPLE_TRANSLATION; if (features->switchable_motion_mode) { // Determine which motion modes to search if more than SIMPLE_TRANSLATION // is allowed. last_motion_mode_allowed = motion_mode_allowed( xd->global_motion, xd, mbmi, features->allow_warped_motion); } if (last_motion_mode_allowed == WARPED_CAUSAL) { return 1; } return 0; } static void calc_num_proj_ref(AV1_COMP *cpi, MACROBLOCK *x, MB_MODE_INFO *mi) { AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &x->e_mbd; const FeatureFlags *const features = &cm->features; mi->num_proj_ref = 1; WARP_SAMPLE_INFO *const warp_sample_info = &x->warp_sample_info[mi->ref_frame[0]]; int *pts0 = warp_sample_info->pts; int *pts_inref0 = warp_sample_info->pts_inref; MOTION_MODE last_motion_mode_allowed = SIMPLE_TRANSLATION; if (features->switchable_motion_mode) { // Determine which motion modes to search if more than SIMPLE_TRANSLATION // is allowed. last_motion_mode_allowed = motion_mode_allowed( xd->global_motion, xd, mi, features->allow_warped_motion); } if (last_motion_mode_allowed == WARPED_CAUSAL) { if (warp_sample_info->num < 0) { warp_sample_info->num = av1_findSamples(cm, xd, pts0, pts_inref0); } mi->num_proj_ref = warp_sample_info->num; } } static void search_motion_mode(AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *this_rdc, int mi_row, int mi_col, BLOCK_SIZE bsize, int *this_early_term, int use_model_yrd_large, int *rate_mv, int64_t best_sse) { AV1_COMMON *const cm = &cpi->common; MACROBLOCKD *const xd = &x->e_mbd; const FeatureFlags *const features = &cm->features; MB_MODE_INFO *const mi = xd->mi[0]; RD_STATS pf_rd_stats[MOTION_MODE_SEARCH_SIZE] = { 0 }; int best_skip = 0; int best_early_term = 0; int64_t best_cost = INT64_MAX; int best_mode_index = -1; const int interp_filter = features->interp_filter; const MOTION_MODE motion_modes[MOTION_MODE_SEARCH_SIZE] = { SIMPLE_TRANSLATION, WARPED_CAUSAL }; int mode_search_size = is_warped_mode_allowed(cpi, x, mi) ? 2 : 1; WARP_SAMPLE_INFO *const warp_sample_info = &x->warp_sample_info[mi->ref_frame[0]]; int *pts0 = warp_sample_info->pts; int *pts_inref0 = warp_sample_info->pts_inref; const int total_samples = mi->num_proj_ref; if (total_samples == 0) { // Do not search WARPED_CAUSAL if there are no samples to use to determine // warped parameters. mode_search_size = 1; } const MB_MODE_INFO base_mbmi = *mi; MB_MODE_INFO best_mbmi; for (int mode_index = 0; mode_index < mode_search_size; ++mode_index) { int64_t cost = INT64_MAX; MOTION_MODE motion_mode = motion_modes[mode_index]; *mi = base_mbmi; mi->motion_mode = motion_mode; if (motion_mode == SIMPLE_TRANSLATION) { mi->interp_filters = av1_broadcast_interp_filter(EIGHTTAP_REGULAR); av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, AOM_PLANE_Y, AOM_PLANE_Y); if (use_model_yrd_large) model_skip_for_sb_y_large(cpi, bsize, mi_row, mi_col, x, xd, &pf_rd_stats[mode_index], this_early_term, 1, best_sse, NULL, UINT_MAX); else model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rd_stats[mode_index], NULL, 1, NULL); pf_rd_stats[mode_index].rate += av1_get_switchable_rate(x, xd, cm->features.interp_filter, cm->seq_params->enable_dual_filter); cost = RDCOST(x->rdmult, pf_rd_stats[mode_index].rate, pf_rd_stats[mode_index].dist); } else if (motion_mode == WARPED_CAUSAL) { int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE]; const ModeCosts *mode_costs = &x->mode_costs; mi->wm_params.wmtype = DEFAULT_WMTYPE; mi->interp_filters = av1_broadcast_interp_filter(av1_unswitchable_filter(interp_filter)); memcpy(pts, pts0, total_samples * 2 * sizeof(*pts0)); memcpy(pts_inref, pts_inref0, total_samples * 2 * sizeof(*pts_inref0)); // Select the samples according to motion vector difference if (mi->num_proj_ref > 1) { mi->num_proj_ref = av1_selectSamples(&mi->mv[0].as_mv, pts, pts_inref, mi->num_proj_ref, bsize); } // Compute the warped motion parameters with a least squares fit // using the collected samples if (!av1_find_projection(mi->num_proj_ref, pts, pts_inref, bsize, mi->mv[0].as_mv.row, mi->mv[0].as_mv.col, &mi->wm_params, mi_row, mi_col)) { if (mi->mode == NEWMV) { const int_mv mv0 = mi->mv[0]; const WarpedMotionParams wm_params0 = mi->wm_params; const int num_proj_ref0 = mi->num_proj_ref; const int_mv ref_mv = av1_get_ref_mv(x, 0); SUBPEL_MOTION_SEARCH_PARAMS ms_params; av1_make_default_subpel_ms_params(&ms_params, cpi, x, bsize, &ref_mv.as_mv, NULL); // Refine MV in a small range. av1_refine_warped_mv(xd, cm, &ms_params, bsize, pts0, pts_inref0, total_samples, cpi->sf.mv_sf.warp_search_method, cpi->sf.mv_sf.warp_search_iters); if (mi->mv[0].as_int == ref_mv.as_int) { continue; } if (mv0.as_int != mi->mv[0].as_int) { // Keep the refined MV and WM parameters. int tmp_rate_mv = av1_mv_bit_cost( &mi->mv[0].as_mv, &ref_mv.as_mv, x->mv_costs->nmv_joint_cost, x->mv_costs->mv_cost_stack, MV_COST_WEIGHT); *rate_mv = tmp_rate_mv; } else { // Restore the old MV and WM parameters. mi->mv[0] = mv0; mi->wm_params = wm_params0; mi->num_proj_ref = num_proj_ref0; } } // Build the warped predictor av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, AOM_PLANE_Y, av1_num_planes(cm) - 1); if (use_model_yrd_large) model_skip_for_sb_y_large(cpi, bsize, mi_row, mi_col, x, xd, &pf_rd_stats[mode_index], this_early_term, 1, best_sse, NULL, UINT_MAX); else model_rd_for_sb_y(cpi, bsize, x, xd, &pf_rd_stats[mode_index], NULL, 1, NULL); pf_rd_stats[mode_index].rate += mode_costs->motion_mode_cost[bsize][mi->motion_mode]; cost = RDCOST(x->rdmult, pf_rd_stats[mode_index].rate, pf_rd_stats[mode_index].dist); } else { cost = INT64_MAX; } } if (cost < best_cost) { best_mode_index = mode_index; best_cost = cost; best_skip = pf_rd_stats[mode_index].skip_txfm; best_early_term = *this_early_term; best_mbmi = *mi; } } assert(best_mode_index >= 0 && best_mode_index < FILTER_SEARCH_SIZE); *mi = best_mbmi; this_rdc->rate = pf_rd_stats[best_mode_index].rate; this_rdc->dist = pf_rd_stats[best_mode_index].dist; this_rdc->sse = pf_rd_stats[best_mode_index].sse; this_rdc->skip_txfm = (best_skip || best_early_term); *this_early_term = best_early_term; if (best_mode_index < FILTER_SEARCH_SIZE - 1) { av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, AOM_PLANE_Y, AOM_PLANE_Y); } } #endif // !CONFIG_REALTIME_ONLY #define COLLECT_NON_SQR_STAT … #if COLLECT_NONRD_PICK_MODE_STAT static inline void print_stage_time(const char *stage_name, int64_t stage_time, int64_t total_time) { printf(" %s: %ld (%f%%)\n", stage_name, stage_time, 100 * stage_time / (float)total_time); } static void print_time(const mode_search_stat_nonrd *const ms_stat, BLOCK_SIZE bsize, int mi_rows, int mi_cols, int mi_row, int mi_col) { if ((mi_row + mi_size_high[bsize] >= mi_rows) && (mi_col + mi_size_wide[bsize] >= mi_cols)) { int64_t total_time = 0l; int32_t total_blocks = 0; for (BLOCK_SIZE bs = 0; bs < BLOCK_SIZES; bs++) { total_time += ms_stat->total_block_times[bs]; total_blocks += ms_stat->num_blocks[bs]; } printf("\n"); for (BLOCK_SIZE bs = 0; bs < BLOCK_SIZES; bs++) { if (ms_stat->num_blocks[bs] == 0) { continue; } if (!COLLECT_NON_SQR_STAT && block_size_wide[bs] != block_size_high[bs]) { continue; } printf("BLOCK_%dX%d Num %d, Time: %ld (%f%%), Avg_time %f:\n", block_size_wide[bs], block_size_high[bs], ms_stat->num_blocks[bs], ms_stat->total_block_times[bs], 100 * ms_stat->total_block_times[bs] / (float)total_time, (float)ms_stat->total_block_times[bs] / ms_stat->num_blocks[bs]); for (int j = 0; j < MB_MODE_COUNT; j++) { if (ms_stat->nonskipped_search_times[bs][j] == 0) { continue; } int64_t total_mode_time = ms_stat->nonskipped_search_times[bs][j]; printf(" Mode %d, %d/%d tps %f\n", j, ms_stat->num_nonskipped_searches[bs][j], ms_stat->num_searches[bs][j], ms_stat->num_nonskipped_searches[bs][j] > 0 ? (float)ms_stat->nonskipped_search_times[bs][j] / ms_stat->num_nonskipped_searches[bs][j] : 0l); if (j >= INTER_MODE_START) { total_mode_time = ms_stat->ms_time[bs][j] + ms_stat->ifs_time[bs][j] + ms_stat->model_rd_time[bs][j] + ms_stat->txfm_time[bs][j]; print_stage_time("Motion Search Time", ms_stat->ms_time[bs][j], total_time); print_stage_time("Filter Search Time", ms_stat->ifs_time[bs][j], total_time); print_stage_time("Model RD Time", ms_stat->model_rd_time[bs][j], total_time); print_stage_time("Tranfm Search Time", ms_stat->txfm_time[bs][j], total_time); } print_stage_time("Total Mode Time", total_mode_time, total_time); } printf("\n"); } printf("Total time = %ld. Total blocks = %d\n", total_time, total_blocks); } } #endif // COLLECT_NONRD_PICK_MODE_STAT static bool should_prune_intra_modes_using_neighbors( const MACROBLOCKD *xd, bool enable_intra_mode_pruning_using_neighbors, PREDICTION_MODE this_mode, PREDICTION_MODE above_mode, PREDICTION_MODE left_mode) { … } void av1_nonrd_pick_intra_mode(AV1_COMP *cpi, MACROBLOCK *x, RD_STATS *rd_cost, BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { … } static inline int is_same_gf_and_last_scale(AV1_COMMON *cm) { … } static inline void get_ref_frame_use_mask(AV1_COMP *cpi, MACROBLOCK *x, MB_MODE_INFO *mi, int mi_row, int mi_col, BLOCK_SIZE bsize, int gf_temporal_ref, int use_ref_frame[], int *force_skip_low_temp_var) { … } static inline int is_filter_search_enabled_blk(AV1_COMP *cpi, MACROBLOCK *x, int mi_row, int mi_col, BLOCK_SIZE bsize, int segment_id, int cb_pred_filter_search, InterpFilter *filt_select) { … } static inline int skip_mode_by_threshold(PREDICTION_MODE mode, MV_REFERENCE_FRAME ref_frame, int_mv mv, int frames_since_golden, const int *const rd_threshes, const int *const rd_thresh_freq_fact, int64_t best_cost, int best_skip, int extra_shift) { … } static inline int skip_mode_by_low_temp( PREDICTION_MODE mode, MV_REFERENCE_FRAME ref_frame, BLOCK_SIZE bsize, CONTENT_STATE_SB content_state_sb, int_mv mv, int force_skip_low_temp_var) { … } static inline int skip_mode_by_bsize_and_ref_frame( PREDICTION_MODE mode, MV_REFERENCE_FRAME ref_frame, BLOCK_SIZE bsize, int extra_prune, unsigned int sse_zeromv_norm, int more_prune, int skip_nearmv) { … } static void set_block_source_sad(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, struct buf_2d *yv12_mb) { … } static void set_color_sensitivity(AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int y_sad, unsigned int source_variance, struct buf_2d yv12_mb[MAX_MB_PLANE]) { … } static void setup_compound_prediction(const AV1_COMMON *cm, MACROBLOCK *x, struct buf_2d yv12_mb[8][MAX_MB_PLANE], const int *use_ref_frame_mask, const MV_REFERENCE_FRAME *rf, int *ref_mv_idx) { … } static void set_compound_mode(MACROBLOCK *x, MV_REFERENCE_FRAME ref_frame, MV_REFERENCE_FRAME ref_frame2, int ref_mv_idx, int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES], PREDICTION_MODE this_mode) { … } // Prune compound mode if the single mode variance is lower than a fixed // percentage of the median value. static bool skip_comp_based_on_var( const unsigned int (*single_vars)[REF_FRAMES], BLOCK_SIZE bsize) { … } static AOM_FORCE_INLINE void fill_single_inter_mode_costs( int (*single_inter_mode_costs)[REF_FRAMES], int num_inter_modes, const REF_MODE *reference_mode_set, const ModeCosts *mode_costs, const int16_t *mode_context) { … } static inline bool is_globalmv_better( PREDICTION_MODE this_mode, MV_REFERENCE_FRAME ref_frame, int rate_mv, const ModeCosts *mode_costs, const int (*single_inter_mode_costs)[REF_FRAMES], const MB_MODE_INFO_EXT *mbmi_ext) { … } // Set up the mv/ref_frames etc based on the comp_index. Returns 1 if it // succeeds, 0 if it fails. static inline int setup_compound_params_from_comp_idx( const AV1_COMP *cpi, MACROBLOCK *x, struct buf_2d yv12_mb[8][MAX_MB_PLANE], PREDICTION_MODE *this_mode, MV_REFERENCE_FRAME *ref_frame, MV_REFERENCE_FRAME *ref_frame2, int_mv frame_mv[MB_MODE_COUNT][REF_FRAMES], const int *use_ref_frame_mask, int comp_index, bool comp_use_zero_zeromv_only, MV_REFERENCE_FRAME *last_comp_ref_frame, BLOCK_SIZE bsize) { … } static inline bool previous_mode_performed_poorly( PREDICTION_MODE mode, MV_REFERENCE_FRAME ref_frame, const unsigned int (*vars)[REF_FRAMES], const int64_t (*uv_dist)[REF_FRAMES]) { … } static inline bool prune_compoundmode_with_singlemode_var( PREDICTION_MODE compound_mode, MV_REFERENCE_FRAME ref_frame, MV_REFERENCE_FRAME ref_frame2, const int_mv (*frame_mv)[REF_FRAMES], const uint8_t (*mode_checked)[REF_FRAMES], const unsigned int (*vars)[REF_FRAMES], const int64_t (*uv_dist)[REF_FRAMES]) { … } // Function to setup parameters used for inter mode evaluation in non-rd. static AOM_FORCE_INLINE void set_params_nonrd_pick_inter_mode( AV1_COMP *cpi, MACROBLOCK *x, InterModeSearchStateNonrd *search_state, RD_STATS *rd_cost, int *force_skip_low_temp_var, int mi_row, int mi_col, int gf_temporal_ref, unsigned char segment_id, BLOCK_SIZE bsize #if CONFIG_AV1_TEMPORAL_DENOISING , PICK_MODE_CONTEXT *ctx, int denoise_svc_pickmode #endif ) { … } // Function to check the inter mode can be skipped based on mode statistics and // speed features settings. static AOM_FORCE_INLINE bool skip_inter_mode_nonrd( AV1_COMP *cpi, MACROBLOCK *x, InterModeSearchStateNonrd *search_state, int64_t *thresh_sad_pred, int *force_mv_inter_layer, int *is_single_pred, PREDICTION_MODE *this_mode, MV_REFERENCE_FRAME *last_comp_ref_frame, MV_REFERENCE_FRAME *ref_frame, MV_REFERENCE_FRAME *ref_frame2, int idx, int_mv svc_mv, int force_skip_low_temp_var, unsigned int sse_zeromv_norm, int num_inter_modes, unsigned char segment_id, BLOCK_SIZE bsize, bool comp_use_zero_zeromv_only, bool check_globalmv) { … } // Function to perform inter mode evaluation for non-rd static AOM_FORCE_INLINE bool handle_inter_mode_nonrd( AV1_COMP *cpi, MACROBLOCK *x, InterModeSearchStateNonrd *search_state, PICK_MODE_CONTEXT *ctx, PRED_BUFFER **this_mode_pred, PRED_BUFFER *tmp_buffer, InterPredParams inter_pred_params_sr, int *best_early_term, unsigned int *sse_zeromv_norm, bool *check_globalmv, #if CONFIG_AV1_TEMPORAL_DENOISING int64_t *zero_last_cost_orig, int denoise_svc_pickmode, #endif int idx, int force_mv_inter_layer, int is_single_pred, int gf_temporal_ref, int use_model_yrd_large, int filter_search_enabled_blk, BLOCK_SIZE bsize, PREDICTION_MODE this_mode, InterpFilter filt_select, int cb_pred_filter_search, int reuse_inter_pred, int *sb_me_has_been_tested) { … } // Function to perform screen content mode evaluation for non-rd static AOM_FORCE_INLINE void handle_screen_content_mode_nonrd( AV1_COMP *cpi, MACROBLOCK *x, InterModeSearchStateNonrd *search_state, PRED_BUFFER *this_mode_pred, PICK_MODE_CONTEXT *ctx, PRED_BUFFER *tmp_buffer, struct buf_2d *orig_dst, int skip_idtx_palette, int try_palette, BLOCK_SIZE bsize, int reuse_inter_pred, int mi_col, int mi_row) { … } static inline bool enable_palette(AV1_COMP *cpi, bool is_mode_intra, BLOCK_SIZE bsize, unsigned int source_variance, int force_zeromv_skip, int skip_idtx_palette, int force_palette_test) { … } /*!\brief AV1 inter mode selection based on Non-RD optimized model. * * \ingroup nonrd_mode_search * \callgraph * Top level function for Non-RD optimized inter mode selection. * This finction will loop over subset of inter modes and select the best one * based on calculated modelled RD cost. While making decisions which modes to * check, this function applies heuristics based on previously checked modes, * block residual variance, block size, and other factors to prune certain * modes and reference frames. Currently only single reference frame modes * are checked. Additional heuristics are applied to decide if intra modes * need to be checked. * * * \param[in] cpi Top-level encoder structure * \param[in] tile_data Pointer to struct holding adaptive data/contexts/models for the tile during encoding * \param[in] x Pointer to structure holding all the data for the current macroblock * \param[in] rd_cost Struct to keep track of the RD information * \param[in] bsize Current block size * \param[in] ctx Structure to hold snapshot of coding context during the mode picking process * * \remark Nothing is returned. Instead, the MB_MODE_INFO struct inside x * is modified to store information about the best mode computed * in this function. The rd_cost struct is also updated with the RD stats * corresponding to the best mode found. */ void av1_nonrd_pick_inter_mode_sb(AV1_COMP *cpi, TileDataEnc *tile_data, MACROBLOCK *x, RD_STATS *rd_cost, BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) { … }
Codebase Browser
chromium