/* * Copyright (c) 2020, 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 "av1/common/av1_common_int.h" #include "av1/common/cfl.h" #include "av1/common/reconintra.h" #include "av1/encoder/intra_mode_search.h" #include "av1/encoder/intra_mode_search_utils.h" #include "av1/encoder/palette.h" #include "av1/encoder/speed_features.h" #include "av1/encoder/tx_search.h" // Even though there are 7 delta angles, this macro is set to 9 to facilitate // the rd threshold check to prune -3 and 3 delta angles. #define SIZE_OF_ANGLE_DELTA_RD_COST_ARRAY … // The order for evaluating delta angles while processing the luma directional // intra modes. Currently, this order of evaluation is applicable only when // speed feature prune_luma_odd_delta_angles_in_intra is enabled. In this case, // even angles are evaluated first in order to facilitate the pruning of odd // delta angles based on the rd costs of the neighboring delta angles. static const int8_t luma_delta_angles_order[2 * MAX_ANGLE_DELTA] = …; /*!\cond */ static const PREDICTION_MODE intra_rd_search_mode_order[INTRA_MODES] = …; static const UV_PREDICTION_MODE uv_rd_search_mode_order[UV_INTRA_MODES] = …; // The bitmask corresponds to the filter intra modes as defined in enums.h // FILTER_INTRA_MODE enumeration type. Setting a bit to 0 in the mask means to // disable the evaluation of corresponding filter intra mode. The table // av1_derived_filter_intra_mode_used_flag is used when speed feature // prune_filter_intra_level is 1. The evaluated filter intra modes are union // of the following: // 1) FILTER_DC_PRED // 2) mode that corresponds to best mode so far of DC_PRED, V_PRED, H_PRED, // D157_PRED and PAETH_PRED. (Eg: FILTER_V_PRED if best mode so far is V_PRED). static const uint8_t av1_derived_filter_intra_mode_used_flag[INTRA_MODES] = …; // The bitmask corresponds to the chroma intra modes as defined in enums.h // UV_PREDICTION_MODE enumeration type. Setting a bit to 0 in the mask means to // disable the evaluation of corresponding chroma intra mode. The table // av1_derived_chroma_intra_mode_used_flag is used when speed feature // prune_chroma_modes_using_luma_winner is enabled. The evaluated chroma // intra modes are union of the following: // 1) UV_DC_PRED // 2) UV_SMOOTH_PRED // 3) UV_CFL_PRED // 4) mode that corresponds to luma intra mode winner (Eg : UV_V_PRED if luma // intra mode winner is V_PRED). static const uint16_t av1_derived_chroma_intra_mode_used_flag[INTRA_MODES] = …; DECLARE_ALIGNED(16, static const uint8_t, all_zeros[MAX_SB_SIZE]) = …; DECLARE_ALIGNED(16, static const uint16_t, highbd_all_zeros[MAX_SB_SIZE]) = …; int av1_calc_normalized_variance(aom_variance_fn_t vf, const uint8_t *const buf, const int stride, const int is_hbd) { … } // Computes average of log(1 + variance) across 4x4 sub-blocks for source and // reconstructed blocks. static void compute_avg_log_variance(const AV1_COMP *const cpi, MACROBLOCK *x, const BLOCK_SIZE bs, double *avg_log_src_variance, double *avg_log_recon_variance) { … } // Returns a factor to be applied to the RD value based on how well the // reconstructed block variance matches the source variance. static double intra_rd_variance_factor(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs) { … } /*!\endcond */ /*!\brief Search for the best filter_intra mode when coding intra frame. * * \ingroup intra_mode_search * \callergraph * This function loops through all filter_intra modes to find the best one. * * \return Returns 1 if a new filter_intra mode is selected; 0 otherwise. */ static int rd_pick_filter_intra_sby(const AV1_COMP *const cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int64_t *distortion, uint8_t *skippable, BLOCK_SIZE bsize, int mode_cost, PREDICTION_MODE best_mode_so_far, int64_t *best_rd, int64_t *best_model_rd, PICK_MODE_CONTEXT *ctx) { … } void av1_count_colors(const uint8_t *src, int stride, int rows, int cols, int *val_count, int *num_colors) { … } void av1_count_colors_highbd(const uint8_t *src8, int stride, int rows, int cols, int bit_depth, int *val_count, int *bin_val_count, int *num_color_bins, int *num_colors) { … } void set_y_mode_and_delta_angle(const int mode_idx, MB_MODE_INFO *const mbmi, int reorder_delta_angle_eval) { … } static inline int get_model_rd_index_for_pruning( const MACROBLOCK *const x, const INTRA_MODE_SPEED_FEATURES *const intra_sf) { … } /*! \brief prune luma intra mode based on the model rd. * \param[in] this_model_rd model rd for current mode. * \param[in] best_model_rd Best model RD seen for this block so * far. * \param[in] top_intra_model_rd Top intra model RD seen for this * block so far. * \param[in] max_model_cnt_allowed The maximum number of top intra * model RD allowed. * \param[in] model_rd_index_for_pruning Index of the candidate used for * pruning based on model rd. */ static int prune_intra_y_mode(int64_t this_model_rd, int64_t *best_model_rd, int64_t top_intra_model_rd[], int max_model_cnt_allowed, int model_rd_index_for_pruning) { … } // Run RD calculation with given chroma intra prediction angle., and return // the RD cost. Update the best mode info. if the RD cost is the best so far. static int64_t pick_intra_angle_routine_sbuv( const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int rate_overhead, int64_t best_rd_in, int *rate, RD_STATS *rd_stats, int *best_angle_delta, int64_t *best_rd) { … } /*!\brief Search for the best angle delta for chroma prediction * * \ingroup intra_mode_search * \callergraph * Given a chroma directional intra prediction mode, this function will try to * estimate the best delta_angle. * * \returns Return if there is a new mode with smaller rdcost than best_rd. */ static int rd_pick_intra_angle_sbuv(const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize, int rate_overhead, int64_t best_rd, int *rate, RD_STATS *rd_stats) { … } #define PLANE_SIGN_TO_JOINT_SIGN(plane, a, b) … static void cfl_idx_to_sign_and_alpha(int cfl_idx, CFL_SIGN_TYPE *cfl_sign, int *cfl_alpha) { … } static int64_t cfl_compute_rd(const AV1_COMP *const cpi, MACROBLOCK *x, int plane, TX_SIZE tx_size, BLOCK_SIZE plane_bsize, int cfl_idx, int fast_mode, RD_STATS *rd_stats) { … } static const int cfl_dir_ls[2] = …; // If cfl_search_range is CFL_MAGS_SIZE, return zero. Otherwise return the index // of the best alpha found using intra_model_rd(). static int cfl_pick_plane_parameter(const AV1_COMP *const cpi, MACROBLOCK *x, int plane, TX_SIZE tx_size, int cfl_search_range) { … } static inline void set_invalid_cfl_parameters(uint8_t *best_cfl_alpha_idx, int8_t *best_cfl_alpha_signs) { … } static void cfl_pick_plane_rd(const AV1_COMP *const cpi, MACROBLOCK *x, int plane, TX_SIZE tx_size, int cfl_search_range, RD_STATS cfl_rd_arr[CFL_MAGS_SIZE], int est_best_cfl_idx) { … } /*!\brief Pick the optimal parameters for Chroma to Luma (CFL) component * * \ingroup intra_mode_search * \callergraph * * This function will use DCT_DCT followed by computing SATD (sum of absolute * transformed differences) to estimate the RD score and find the best possible * CFL parameter. * * Then the function will apply a full RD search near the best possible CFL * parameter to find the best actual CFL parameter. * * Side effect: * We use ths buffers in x->plane[] and xd->plane[] as throw-away buffers for RD * search. * * \param[in] x Encoder prediction block structure. * \param[in] cpi Top-level encoder instance structure. * \param[in] tx_size Transform size. * \param[in] ref_best_rd Reference best RD. * \param[in] cfl_search_range The search range of full RD search near the * estimated best CFL parameter. * * \param[out] best_rd_stats RD stats of the best CFL parameter * \param[out] best_cfl_alpha_idx Best CFL alpha index * \param[out] best_cfl_alpha_signs Best CFL joint signs * */ static int cfl_rd_pick_alpha(MACROBLOCK *const x, const AV1_COMP *const cpi, TX_SIZE tx_size, int64_t ref_best_rd, int cfl_search_range, RD_STATS *best_rd_stats, uint8_t *best_cfl_alpha_idx, int8_t *best_cfl_alpha_signs) { … } static bool should_prune_chroma_smooth_pred_based_on_source_variance( const AV1_COMP *cpi, const MACROBLOCK *x, BLOCK_SIZE bsize) { … } int64_t av1_rd_pick_intra_sbuv_mode(const AV1_COMP *const cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int64_t *distortion, uint8_t *skippable, BLOCK_SIZE bsize, TX_SIZE max_tx_size) { … } // Searches palette mode for luma channel in inter frame. int av1_search_palette_mode(IntraModeSearchState *intra_search_state, const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, unsigned int ref_frame_cost, PICK_MODE_CONTEXT *ctx, RD_STATS *this_rd_cost, int64_t best_rd) { … } void av1_search_palette_mode_luma(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, unsigned int ref_frame_cost, PICK_MODE_CONTEXT *ctx, RD_STATS *this_rd_cost, int64_t best_rd) { … } /*!\brief Get the intra prediction by searching through tx_type and tx_size. * * \ingroup intra_mode_search * \callergraph * Currently this function is only used in the intra frame code path for * winner-mode processing. * * \return Returns whether the current mode is an improvement over best_rd. */ static inline int intra_block_yrd(const AV1_COMP *const cpi, MACROBLOCK *x, BLOCK_SIZE bsize, const int *bmode_costs, int64_t *best_rd, int *rate, int *rate_tokenonly, int64_t *distortion, uint8_t *skippable, MB_MODE_INFO *best_mbmi, PICK_MODE_CONTEXT *ctx) { … } /*!\brief Search for the best filter_intra mode when coding inter frame. * * \ingroup intra_mode_search * \callergraph * This function loops through all filter_intra modes to find the best one. * * \remark Returns nothing, but updates the mbmi and rd_stats. */ static inline void handle_filter_intra_mode(const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, const PICK_MODE_CONTEXT *ctx, RD_STATS *rd_stats_y, int mode_cost, int64_t best_rd, int64_t best_rd_so_far) { … } // Evaluate a given luma intra-mode in inter frames. int av1_handle_intra_y_mode(IntraModeSearchState *intra_search_state, const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, unsigned int ref_frame_cost, const PICK_MODE_CONTEXT *ctx, RD_STATS *rd_stats_y, int64_t best_rd, int *mode_cost_y, int64_t *rd_y, int64_t *best_model_rd, int64_t top_intra_model_rd[]) { … } int av1_search_intra_uv_modes_in_interframe( IntraModeSearchState *intra_search_state, const AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize, RD_STATS *rd_stats, const RD_STATS *rd_stats_y, RD_STATS *rd_stats_uv, int64_t best_rd) { … } // Checks if odd delta angles can be pruned based on rdcosts of even delta // angles of the corresponding directional mode. static inline int prune_luma_odd_delta_angles_using_rd_cost( const MB_MODE_INFO *const mbmi, const int64_t *const intra_modes_rd_cost, int64_t best_rd, int prune_luma_odd_delta_angles_in_intra) { … } // Finds the best non-intrabc mode on an intra frame. int64_t av1_rd_pick_intra_sby_mode(const AV1_COMP *const cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int64_t *distortion, uint8_t *skippable, BLOCK_SIZE bsize, int64_t best_rd, PICK_MODE_CONTEXT *ctx) { … }
Codebase Browser
chromium