/* * 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 <limits.h> #include <math.h> #include <stdio.h> #include "config/aom_config.h" #include "config/aom_dsp_rtcd.h" #include "aom_dsp/aom_dsp_common.h" #include "aom_mem/aom_mem.h" #include "aom_ports/mem.h" #include "av1/common/av1_common_int.h" #include "av1/common/common.h" #include "av1/common/filter.h" #include "av1/common/mvref_common.h" #include "av1/common/reconinter.h" #include "av1/encoder/encoder.h" #include "av1/encoder/encodemv.h" #include "av1/encoder/mcomp.h" #include "av1/encoder/rdopt.h" #include "av1/encoder/reconinter_enc.h" static inline void init_mv_cost_params(MV_COST_PARAMS *mv_cost_params, const MvCosts *mv_costs, const MV *ref_mv, int errorperbit, int sadperbit) { … } static inline void init_ms_buffers(MSBuffers *ms_buffers, const MACROBLOCK *x) { … } void av1_init_obmc_buffer(OBMCBuffer *obmc_buffer) { … } void av1_make_default_fullpel_ms_params( FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const struct AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv, FULLPEL_MV start_mv, const search_site_config search_sites[NUM_DISTINCT_SEARCH_METHODS], SEARCH_METHODS search_method, int fine_search_interval) { … } void av1_set_ms_to_intra_mode(FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const IntraBCMVCosts *dv_costs) { … } void av1_make_default_subpel_ms_params(SUBPEL_MOTION_SEARCH_PARAMS *ms_params, const struct AV1_COMP *cpi, const MACROBLOCK *x, BLOCK_SIZE bsize, const MV *ref_mv, const int *cost_list) { … } void av1_set_mv_search_range(FullMvLimits *mv_limits, const MV *mv) { … } int av1_init_search_range(int size) { … } // ============================================================================ // Cost of motion vectors // ============================================================================ // TODO(any): Adaptively adjust the regularization strength based on image size // and motion activity instead of using hard-coded values. It seems like we // roughly half the lambda for each increase in resolution // These are multiplier used to perform regularization in motion compensation // when x->mv_cost_type is set to MV_COST_L1. // LOWRES #define SSE_LAMBDA_LOWRES … #define SAD_LAMBDA_LOWRES … // MIDRES #define SSE_LAMBDA_MIDRES … #define SAD_LAMBDA_MIDRES … // HDRES #define SSE_LAMBDA_HDRES … #define SAD_LAMBDA_HDRES … // Returns the rate of encoding the current motion vector based on the // joint_cost and comp_cost. joint_costs covers the cost of transmitting // JOINT_MV, and comp_cost covers the cost of transmitting the actual motion // vector. static inline int mv_cost(const MV *mv, const int *joint_cost, const int *const comp_cost[2]) { … } #define CONVERT_TO_CONST_MVCOST(ptr) … // Returns the cost of encoding the motion vector diff := *mv - *ref. The cost // is defined as the rate required to encode diff * weight, rounded to the // nearest 2 ** 7. // This is NOT used during motion compensation. int av1_mv_bit_cost(const MV *mv, const MV *ref_mv, const int *mvjcost, int *const mvcost[2], int weight) { … } // Returns the cost of using the current mv during the motion search. This is // used when var is used as the error metric. #define PIXEL_TRANSFORM_ERROR_SCALE … static inline int mv_err_cost(const MV *mv, const MV *ref_mv, const int *mvjcost, const int *const mvcost[2], int error_per_bit, MV_COST_TYPE mv_cost_type) { … } static inline int mv_err_cost_(const MV *mv, const MV_COST_PARAMS *mv_cost_params) { … } // Returns the cost of using the current mv during the motion search. This is // only used during full pixel motion search when sad is used as the error // metric static inline int mvsad_err_cost(const FULLPEL_MV *mv, const FULLPEL_MV *ref_mv, const int *mvjcost, const int *const mvcost[2], int sad_per_bit, MV_COST_TYPE mv_cost_type) { … } static inline int mvsad_err_cost_(const FULLPEL_MV *mv, const MV_COST_PARAMS *mv_cost_params) { … } // ============================================================================= // Fullpixel Motion Search: Translational // ============================================================================= #define MAX_PATTERN_SCALES … #define MAX_PATTERN_CANDIDATES … #define PATTERN_CANDIDATES_REF … // Search site initialization for DIAMOND / CLAMPED_DIAMOND search methods. // level = 0: DIAMOND, level = 1: CLAMPED_DIAMOND. static void init_dsmotion_compensation(search_site_config *cfg, int stride, int level) { … } void av1_init_motion_fpf(search_site_config *cfg, int stride) { … } // Search site initialization for NSTEP / NSTEP_8PT search methods. // level = 0: NSTEP, level = 1: NSTEP_8PT. static void init_motion_compensation_nstep(search_site_config *cfg, int stride, int level) { … } // Search site initialization for BIGDIA / FAST_BIGDIA / FAST_DIAMOND // search methods. static void init_motion_compensation_bigdia(search_site_config *cfg, int stride, int level) { … } // Search site initialization for SQUARE search method. static void init_motion_compensation_square(search_site_config *cfg, int stride, int level) { … } // Search site initialization for HEX / FAST_HEX search methods. static void init_motion_compensation_hex(search_site_config *cfg, int stride, int level) { … } const av1_init_search_site_config av1_init_motion_compensation[NUM_DISTINCT_SEARCH_METHODS] = …; // Checks whether the mv is within range of the mv_limits static inline int check_bounds(const FullMvLimits *mv_limits, int row, int col, int range) { … } static inline int get_mvpred_var_cost( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv, FULLPEL_MV_STATS *mv_stats) { … } static inline int get_mvpred_sad(const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const struct buf_2d *const src, const uint8_t *const ref_address, const int ref_stride) { … } static inline int get_mvpred_compound_var_cost( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv, FULLPEL_MV_STATS *mv_stats) { … } static inline int get_mvpred_compound_sad( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const struct buf_2d *const src, const uint8_t *const ref_address, const int ref_stride) { … } // Calculates and returns a sad+mvcost list around an integer best pel during // fullpixel motion search. The resulting list can be used to speed up subpel // motion search later. #define USE_SAD_COSTLIST … // calc_int_cost_list uses var to populate the costlist, which is more accurate // than sad but slightly slower. static AOM_FORCE_INLINE void calc_int_cost_list( const FULLPEL_MV best_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, int *cost_list) { … } // calc_int_sad_list uses sad to populate the costlist, which is less accurate // than var but faster. static AOM_FORCE_INLINE void calc_int_sad_list( const FULLPEL_MV best_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, int *cost_list, int costlist_has_sad) { … } // Computes motion vector cost and adds to the sad cost. // Then updates the best sad and motion vectors. // Inputs: // this_sad: the sad to be evaluated. // mv: the current motion vector. // mv_cost_params: a structure containing information to compute mv cost. // best_sad: the current best sad. // raw_best_sad (optional): the current best sad without calculating mv cost. // best_mv: the current best motion vector. // second_best_mv (optional): the second best motion vector up to now. // Modifies: // best_sad, raw_best_sad, best_mv, second_best_mv // If the current sad is lower than the current best sad. // Returns: // Whether the input sad (mv) is better than the current best. static inline int update_mvs_and_sad(const unsigned int this_sad, const FULLPEL_MV *mv, const MV_COST_PARAMS *mv_cost_params, unsigned int *best_sad, unsigned int *raw_best_sad, FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) { … } // Calculate sad4 and update the bestmv information // in FAST_DIAMOND search method. static inline void calc_sad4_update_bestmv( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const MV_COST_PARAMS *mv_cost_params, FULLPEL_MV *best_mv, const FULLPEL_MV center_mv, const uint8_t *center_address, unsigned int *bestsad, unsigned int *raw_bestsad, int search_step, int *best_site, int cand_start, int *cost_list) { … } static inline void calc_sad3_update_bestmv( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const MV_COST_PARAMS *mv_cost_params, FULLPEL_MV *best_mv, FULLPEL_MV center_mv, const uint8_t *center_address, unsigned int *bestsad, unsigned int *raw_bestsad, int search_step, int *best_site, const int *chkpts_indices, int *cost_list) { … } // Calculate sad and update the bestmv information // in FAST_DIAMOND search method. static inline void calc_sad_update_bestmv( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const MV_COST_PARAMS *mv_cost_params, FULLPEL_MV *best_mv, const FULLPEL_MV center_mv, const uint8_t *center_address, unsigned int *bestsad, unsigned int *raw_bestsad, int search_step, int *best_site, const int num_candidates, int cand_start, int *cost_list) { … } static inline void calc_sad_update_bestmv_with_indices( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const MV_COST_PARAMS *mv_cost_params, FULLPEL_MV *best_mv, const FULLPEL_MV center_mv, const uint8_t *center_address, unsigned int *bestsad, unsigned int *raw_bestsad, int search_step, int *best_site, const int num_candidates, const int *chkpts_indices, int *cost_list) { … } // Generic pattern search function that searches over multiple scales. // Each scale can have a different number of candidates and shape of // candidates as indicated in the num_candidates and candidates arrays // passed into this function static int pattern_search(FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } // For the following foo_search, the input arguments are: // start_mv: where we are starting our motion search // ms_params: a collection of motion search parameters // search_step: how many steps to skip in our motion search. For example, // a value 3 suggests that 3 search steps have already taken place prior to // this function call, so we jump directly to step 4 of the search process // do_init_search: if on, do an initial search of all possible scales around the // start_mv, and then pick the best scale. // cond_list: used to hold the cost around the best full mv so we can use it to // speed up subpel search later. // best_mv: the best mv found in the motion search static int hex_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int bigdia_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int square_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int fast_hex_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int vfast_dia_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int fast_dia_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int fast_bigdia_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, const int do_init_search, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats) { … } static int diamond_search_sad(FULLPEL_MV start_mv, unsigned int start_mv_sad, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int search_step, int *num00, FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) { … } static inline unsigned int get_start_mvpred_sad_cost( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, FULLPEL_MV start_mv) { … } static int full_pixel_diamond(FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int step_param, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats, FULLPEL_MV *second_best_mv) { … } // Exhaustive motion search around a given centre position with a given // step size. static int exhaustive_mesh_search(FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int range, const int step, FULLPEL_MV *best_mv, FULLPEL_MV *second_best_mv) { … } // Runs an limited range exhaustive mesh search using a pattern set // according to the encode speed profile. static int full_pixel_exhaustive(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const struct MESH_PATTERN *const mesh_patterns, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *mv_stats, FULLPEL_MV *second_best_mv) { … } // This function is called when we do joint motion search in comp_inter_inter // mode, or when searching for one component of an ext-inter compound mode. int av1_refining_search_8p_c(const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV start_mv, FULLPEL_MV *best_mv) { … } int av1_full_pixel_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int step_param, int *cost_list, FULLPEL_MV *best_mv, FULLPEL_MV_STATS *best_mv_stats, FULLPEL_MV *second_best_mv) { … } int av1_intrabc_hash_search(const AV1_COMP *cpi, const MACROBLOCKD *xd, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, IntraBCHashInfo *intrabc_hash_info, FULLPEL_MV *best_mv) { … } int av1_vector_match(const int16_t *ref, const int16_t *src, int bwl, int search_size, int full_search, int *sad) { … } // A special fast version of motion search used in rt mode. // The search window along columns and row is given by: // +/- me_search_size_col/row. unsigned int av1_int_pro_motion_estimation(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int mi_row, int mi_col, const MV *ref_mv, unsigned int *y_sad_zero, int me_search_size_col, int me_search_size_row) { … } // ============================================================================= // Fullpixel Motion Search: OBMC // ============================================================================= static inline int get_obmc_mvpred_var( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV *this_mv) { … } static int obmc_refining_search_sad( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, FULLPEL_MV *best_mv) { … } static int obmc_diamond_search_sad( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, FULLPEL_MV start_mv, FULLPEL_MV *best_mv, int search_step, int *num00) { … } static int obmc_full_pixel_diamond( const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const FULLPEL_MV start_mv, int step_param, FULLPEL_MV *best_mv) { … } int av1_obmc_full_pixel_search(const FULLPEL_MV start_mv, const FULLPEL_MOTION_SEARCH_PARAMS *ms_params, const int step_param, FULLPEL_MV *best_mv) { … } // ============================================================================= // Subpixel Motion Search: Translational // ============================================================================= #define INIT_SUBPEL_STEP_SIZE … /* * To avoid the penalty for crossing cache-line read, preload the reference * area in a small buffer, which is aligned to make sure there won't be crossing * cache-line read while reading from this buffer. This reduced the cpu * cycles spent on reading ref data in sub-pixel filter functions. * TODO: Currently, since sub-pixel search range here is -3 ~ 3, copy 22 rows x * 32 cols area that is enough for 16x16 macroblock. Later, for SPLITMV, we * could reduce the area. */ // Returns the subpel offset used by various subpel variance functions [m]sv[a]f static inline int get_subpel_part(int x) { … } // Gets the address of the ref buffer at subpel location (r, c), rounded to the // nearest fullpel precision toward - \infty static inline const uint8_t *get_buf_from_mv(const struct buf_2d *buf, const MV mv) { … } // Estimates the variance of prediction residue using bilinear filter for fast // search. static inline int estimated_pref_error( const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, unsigned int *sse) { … } // Calculates the variance of prediction residue. static int upsampled_pref_error(MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, unsigned int *sse) { … } // Estimates whether this_mv is better than best_mv. This function incorporates // both prediction error and residue into account. It is suffixed "fast" because // it uses bilinear filter to estimate the prediction. static inline unsigned int check_better_fast( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *this_mv, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int *has_better_mv, int is_scaled) { … } // Checks whether this_mv is better than best_mv. This function incorporates // both prediction error and residue into account. static AOM_FORCE_INLINE unsigned int check_better( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *this_mv, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int *is_better) { … } static inline MV get_best_diag_step(int step_size, unsigned int left_cost, unsigned int right_cost, unsigned int up_cost, unsigned int down_cost) { … } // Searches the four cardinal direction for a better mv, then follows up with a // search in the best quadrant. This uses bilinear filter to speed up the // calculation. static AOM_FORCE_INLINE MV first_level_check_fast( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV this_mv, MV *best_mv, int hstep, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int is_scaled) { … } // Performs a following up search after first_level_check_fast is called. This // performs two extra chess pattern searches in the best quadrant. static AOM_FORCE_INLINE void second_level_check_fast( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV this_mv, const MV diag_step, MV *best_mv, int hstep, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int is_scaled) { … } // Combines first level check and second level check when applicable. This first // searches the four cardinal directions, and perform several // diagonal/chess-pattern searches in the best quadrant. static AOM_FORCE_INLINE void two_level_checks_fast( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV this_mv, MV *best_mv, int hstep, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int iters, int is_scaled) { … } static AOM_FORCE_INLINE MV first_level_check(MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV this_mv, MV *best_mv, const int hstep, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion) { … } // A newer version of second level check that gives better quality. // TODO([email protected]): evaluate this on subpel_search_types different // from av1_find_best_sub_pixel_tree static AOM_FORCE_INLINE void second_level_check_v2( MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV this_mv, MV diag_step, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int is_scaled) { … } // Gets the error at the beginning when the mv has fullpel precision static unsigned int setup_center_error( const MACROBLOCKD *xd, const MV *bestmv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *sse1, int *distortion) { … } // Gets the error at the beginning when the mv has fullpel precision static unsigned int upsampled_setup_center_error( MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV *bestmv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *sse1, int *distortion) { … } static inline int divide_and_round(int n, int d) { … } static inline int is_cost_list_wellbehaved(const int *cost_list) { … } // Returns surface minima estimate at given precision in 1/2^n bits. // Assume a model for the cost surface: S = A(x - x0)^2 + B(y - y0)^2 + C // For a given set of costs S0, S1, S2, S3, S4 at points // (y, x) = (0, 0), (0, -1), (1, 0), (0, 1) and (-1, 0) respectively, // the solution for the location of the minima (x0, y0) is given by: // x0 = 1/2 (S1 - S3)/(S1 + S3 - 2*S0), // y0 = 1/2 (S4 - S2)/(S4 + S2 - 2*S0). // The code below is an integerized version of that. static inline void get_cost_surf_min(const int *cost_list, int *ir, int *ic, int bits) { … } // Checks the list of mvs searched in the last iteration and see if we are // repeating it. If so, return 1. Otherwise we update the last_mv_search_list // with current_mv and return 0. static inline int check_repeated_mv_and_update(int_mv *last_mv_search_list, const MV current_mv, int iter) { … } static inline int setup_center_error_facade( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *bestmv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *sse1, int *distortion, int is_scaled) { … } int av1_find_best_sub_pixel_tree_pruned_more( MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } int av1_find_best_sub_pixel_tree_pruned( MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } int av1_find_best_sub_pixel_tree(MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } // Note(yunqingwang): The following 2 functions are only used in the motion // vector unit test, which return extreme motion vectors allowed by the MV // limits. // Returns the maximum MV. int av1_return_max_sub_pixel_mv(MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } // Returns the minimum MV. int av1_return_min_sub_pixel_mv(MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } #if !CONFIG_REALTIME_ONLY // Computes the cost of the current predictor by going through the whole // av1_enc_build_inter_predictor pipeline. This is mainly used by warped mv // during motion_mode_rd. We are going through the whole // av1_enc_build_inter_predictor because we might have changed the interpolation // filter, etc before motion_mode_rd is called. static inline unsigned int compute_motion_cost( MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, BLOCK_SIZE bsize, const MV *this_mv) { unsigned int mse; unsigned int sse; const int mi_row = xd->mi_row; const int mi_col = xd->mi_col; av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, AOM_PLANE_Y, AOM_PLANE_Y); const SUBPEL_SEARCH_VAR_PARAMS *var_params = &ms_params->var_params; const MSBuffers *ms_buffers = &var_params->ms_buffers; const uint8_t *const src = ms_buffers->src->buf; const int src_stride = ms_buffers->src->stride; const uint8_t *const dst = xd->plane[0].dst.buf; const int dst_stride = xd->plane[0].dst.stride; const aom_variance_fn_ptr_t *vfp = ms_params->var_params.vfp; mse = vfp->vf(dst, dst_stride, src, src_stride, &sse); mse += mv_err_cost_(this_mv, &ms_params->mv_cost_params); return mse; } // Refines MV in a small range // Macros to build bitmasks which help us avoid redundant computations // // To explain the idea here, imagine that on the first iteration of the // loop below, we step rightwards. Then, on the second iteration, the neighbors // to consider are: // . . . // 0 1 . // . . . // Where 0 is the initial search point, 1 is the best candidate found in the // first iteration, and the dots are the other neighbors of point 1. // // Naively, we would now need to scan all 8 neighbors of point 1 (point 0 and // the seven points marked with dots), and compare them to see where to move // next. However, we already evaluated 5 of those 8 neighbors in the last // iteration, and decided that they are worse than point 1. So we don't need // to re-consider these points. We only really need to consider the three // points which are adjacent to point 1 but *not* to point 0. // // As the algorithm goes on, there are other ways that redundant evaluations // can happen, if the search path curls back around on itself. // // To avoid all possible redundancies, we'd have to build a set containing // every point we have already checked, and this would be quite expensive. // // So instead, we apply a 95%-effective solution with a much lower overhead: // we prune out the points which were considered during the previous // iteration, but we don't worry about any prior iteration. This can be done // as follows: // // We build a static table, called neighbor_mask, which answers the question // "if we moved in direction X last time, which neighbors are new, and which // were scanned last iteration?" // Then we can query this table to quickly determine which points we need to // evaluate, and which we can skip. // // To query the table, the logic is simply: // neighbor_mask[i] & (1 << j) == "if we moved in direction i last iteration, // do we need to scan neighbor j this iteration?" #define NEIGHBOR_MASK_DIA … #define NEIGHBOR_MASK_SQR … static const warp_search_config warp_search_info[WARP_SEARCH_METHODS] = { // WARP_SEARCH_DIAMOND { .num_neighbors = 4, .neighbors = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 } }, .neighbor_mask = { // If we stepped left last time, consider all points except right NEIGHBOR_MASK_DIA(1, 1, 0, 1), // If we stepped down last time, consider all points except up NEIGHBOR_MASK_DIA(1, 1, 1, 0), // Stepped right last time NEIGHBOR_MASK_DIA(0, 1, 1, 1), // Stepped up last time NEIGHBOR_MASK_DIA(1, 0, 1, 1), }, }, // WARP_SEARCH_SQUARE { .num_neighbors = 8, .neighbors = { { 0, -1 }, { 1, 0 }, { 0, 1 }, { -1, 0 }, { 1, -1 }, { 1, 1 }, { -1, -1 }, { -1, 1 } }, .neighbor_mask = { // If we stepped left last time, then we only need to consider 3 points: // left, down+left, up+left NEIGHBOR_MASK_SQR(1, 0, 0, 0, 1, 0, 1, 0), // If we stepped down last time, then we only need to consider 3 points: // down, down+left, down+right NEIGHBOR_MASK_SQR(0, 1, 0, 0, 1, 1, 0, 0), // Stepped right last time NEIGHBOR_MASK_SQR(0, 0, 1, 0, 0, 1, 0, 1), // Stepped up last time NEIGHBOR_MASK_SQR(0, 0, 0, 1, 0, 0, 1, 1), // If we stepped down+left last time, then we need to consider 5 points: // left, down, down+left, down+right, up+left NEIGHBOR_MASK_SQR(1, 1, 0, 0, 1, 1, 1, 0), // Stepped down+right last time NEIGHBOR_MASK_SQR(0, 1, 1, 0, 1, 1, 0, 1), // Stepped up+left last time NEIGHBOR_MASK_SQR(1, 0, 0, 1, 1, 0, 1, 1), // Stepped up+right last time NEIGHBOR_MASK_SQR(0, 0, 1, 1, 0, 1, 1, 1), }, }, }; unsigned int av1_refine_warped_mv(MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, BLOCK_SIZE bsize, const int *pts0, const int *pts_inref0, int total_samples, WARP_SEARCH_METHOD search_method, int num_iterations) { MB_MODE_INFO *mbmi = xd->mi[0]; const MV *neighbors = warp_search_info[search_method].neighbors; const int num_neighbors = warp_search_info[search_method].num_neighbors; const uint8_t *neighbor_mask = warp_search_info[search_method].neighbor_mask; MV *best_mv = &mbmi->mv[0].as_mv; WarpedMotionParams best_wm_params = mbmi->wm_params; int best_num_proj_ref = mbmi->num_proj_ref; unsigned int bestmse; const SubpelMvLimits *mv_limits = &ms_params->mv_limits; const int mv_shift = ms_params->allow_hp ? 0 : 1; // Calculate the center position's error assert(av1_is_subpelmv_in_range(mv_limits, *best_mv)); bestmse = compute_motion_cost(xd, cm, ms_params, bsize, best_mv); // MV search int pts[SAMPLES_ARRAY_SIZE], pts_inref[SAMPLES_ARRAY_SIZE]; const int mi_row = xd->mi_row; const int mi_col = xd->mi_col; // First step always scans all neighbors uint8_t valid_neighbors = UINT8_MAX; for (int ite = 0; ite < num_iterations; ++ite) { int best_idx = -1; for (int idx = 0; idx < num_neighbors; ++idx) { if ((valid_neighbors & (1 << idx)) == 0) { continue; } unsigned int thismse; MV this_mv = { best_mv->row + neighbors[idx].row * (1 << mv_shift), best_mv->col + neighbors[idx].col * (1 << mv_shift) }; if (av1_is_subpelmv_in_range(mv_limits, this_mv)) { memcpy(pts, pts0, total_samples * 2 * sizeof(*pts0)); memcpy(pts_inref, pts_inref0, total_samples * 2 * sizeof(*pts_inref0)); if (total_samples > 1) { mbmi->num_proj_ref = av1_selectSamples(&this_mv, pts, pts_inref, total_samples, bsize); } if (!av1_find_projection(mbmi->num_proj_ref, pts, pts_inref, bsize, this_mv.row, this_mv.col, &mbmi->wm_params, mi_row, mi_col)) { thismse = compute_motion_cost(xd, cm, ms_params, bsize, &this_mv); if (thismse < bestmse) { best_idx = idx; best_wm_params = mbmi->wm_params; best_num_proj_ref = mbmi->num_proj_ref; bestmse = thismse; } } } } if (best_idx == -1) break; if (best_idx >= 0) { best_mv->row += neighbors[best_idx].row * (1 << mv_shift); best_mv->col += neighbors[best_idx].col * (1 << mv_shift); valid_neighbors = neighbor_mask[best_idx]; } } mbmi->wm_params = best_wm_params; mbmi->num_proj_ref = best_num_proj_ref; return bestmse; } #endif // !CONFIG_REALTIME_ONLY // ============================================================================= // Subpixel Motion Search: OBMC // ============================================================================= // Estimates the variance of prediction residue static inline int estimate_obmc_pref_error( const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, unsigned int *sse) { … } // Calculates the variance of prediction residue static int upsampled_obmc_pref_error(MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, unsigned int *sse) { … } static unsigned int setup_obmc_center_error( const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *sse1, int *distortion) { … } static unsigned int upsampled_setup_obmc_center_error( MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV *this_mv, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *sse1, int *distortion) { … } // Estimates the variance of prediction residue // TODO([email protected]): the cost does does not match the cost in // mv_cost_. Investigate this later. static inline int estimate_obmc_mvcost(const MV *this_mv, const MV_COST_PARAMS *mv_cost_params) { … } // Estimates whether this_mv is better than best_mv. This function incorporates // both prediction error and residue into account. static inline unsigned int obmc_check_better_fast( const MV *this_mv, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int *has_better_mv) { … } // Estimates whether this_mv is better than best_mv. This function incorporates // both prediction error and residue into account. static inline unsigned int obmc_check_better( MACROBLOCKD *xd, const AV1_COMMON *cm, const MV *this_mv, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion, int *has_better_mv) { … } static AOM_FORCE_INLINE MV obmc_first_level_check( MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV this_mv, MV *best_mv, const int hstep, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion) { … } // A newer version of second level check for obmc that gives better quality. static AOM_FORCE_INLINE void obmc_second_level_check_v2( MACROBLOCKD *xd, const AV1_COMMON *const cm, const MV this_mv, MV diag_step, MV *best_mv, const SubpelMvLimits *mv_limits, const SUBPEL_SEARCH_VAR_PARAMS *var_params, const MV_COST_PARAMS *mv_cost_params, unsigned int *besterr, unsigned int *sse1, int *distortion) { … } int av1_find_best_obmc_sub_pixel_tree_up( MACROBLOCKD *xd, const AV1_COMMON *const cm, const SUBPEL_MOTION_SEARCH_PARAMS *ms_params, MV start_mv, const FULLPEL_MV_STATS *start_mv_stats, MV *bestmv, int *distortion, unsigned int *sse1, int_mv *last_mv_search_list) { … } // ============================================================================= // Public cost function: mv_cost + pred error // ============================================================================= int av1_get_mvpred_sse(const MV_COST_PARAMS *mv_cost_params, const FULLPEL_MV best_mv, const aom_variance_fn_ptr_t *vfp, const struct buf_2d *src, const struct buf_2d *pre) { … }
Codebase Browser
chromium