/* * Copyright (c) 2019, 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. */ #ifndef AOM_AV1_ENCODER_TPL_MODEL_H_ #define AOM_AV1_ENCODER_TPL_MODEL_H_ #ifdef __cplusplus extern "C" { #endif /*!\cond */ struct AV1_PRIMARY; struct AV1_COMP; struct AV1_SEQ_CODING_TOOLS; struct EncodeFrameParams; struct EncodeFrameInput; struct GF_GROUP; struct ThreadData; struct TPL_INFO; #include "config/aom_config.h" #include "aom_scale/yv12config.h" #include "aom_util/aom_pthread.h" #include "av1/common/mv.h" #include "av1/common/scale.h" #include "av1/encoder/block.h" #include "av1/encoder/lookahead.h" #include "av1/encoder/ratectrl.h" static inline BLOCK_SIZE convert_length_to_bsize(int length) { … } AV1TplRowMultiThreadSync; AV1TplRowMultiThreadInfo; // TODO(jingning): This needs to be cleaned up next. // TPL stats buffers are prepared for every frame in the GOP, // including (internal) overlays and (internal) arfs. // In addition, frames in the lookahead that are outside of the GOP // are also used. // Thus it should use // (gop_length) + (# overlays) + (MAX_LAG_BUFFERS - gop_len) = // MAX_LAG_BUFFERS + (# overlays) // 2 * MAX_LAG_BUFFERS is therefore a safe estimate. // TODO(bohanli): test setting it to 1.5 * MAX_LAG_BUFFER #define MAX_TPL_FRAME_IDX … // The first REF_FRAMES + 1 buffers are reserved. // tpl_data->tpl_frame starts after REF_FRAMES + 1 #define MAX_LENGTH_TPL_FRAME_STATS … #define TPL_DEP_COST_SCALE_LOG2 … #define TPL_EPSILON … TplTxfmStats; TplBuffers; TplDepStats; TplDepFrame; /*!\endcond */ /*! * \brief Params related to temporal dependency model. */ TplParams; #if CONFIG_BITRATE_ACCURACY || CONFIG_RATECTRL_LOG #define VBR_RC_INFO_MAX_FRAMES … #endif // CONFIG_BITRATE_ACCURACY || CONFIG_RATECTRL_LOG #if CONFIG_BITRATE_ACCURACY /*! * \brief This structure stores information needed for bitrate accuracy * experiment. */ typedef struct { int ready; double total_bit_budget; // The total bit budget of the entire video int show_frame_count; // Number of show frames in the entire video int gop_showframe_count; // The number of show frames in the current gop double gop_bit_budget; // The bitbudget for the current gop double scale_factors[FRAME_UPDATE_TYPES]; // Scale factors to improve the // budget estimation double mv_scale_factors[FRAME_UPDATE_TYPES]; // Scale factors to improve // MV entropy estimation // === Below this line are GOP related data that will be updated per GOP === int base_q_index; // Stores the base q index. int q_index_list_ready; int q_index_list[VBR_RC_INFO_MAX_FRAMES]; // q indices for the current // GOP // Array to store qstep_ratio for each frame in a GOP double qstep_ratio_list[VBR_RC_INFO_MAX_FRAMES]; #if CONFIG_THREE_PASS TplTxfmStats txfm_stats_list[VBR_RC_INFO_MAX_FRAMES]; FRAME_UPDATE_TYPE update_type_list[VBR_RC_INFO_MAX_FRAMES]; int gop_start_idx_list[VBR_RC_INFO_MAX_FRAMES]; int gop_length_list[VBR_RC_INFO_MAX_FRAMES]; int cur_gop_idx; int total_frame_count; int gop_count; #endif // CONFIG_THREE_PASS } VBR_RATECTRL_INFO; static inline void vbr_rc_reset_gop_data(VBR_RATECTRL_INFO *vbr_rc_info) { vbr_rc_info->q_index_list_ready = 0; av1_zero(vbr_rc_info->q_index_list); } void av1_vbr_rc_init(VBR_RATECTRL_INFO *vbr_rc_info, double total_bit_budget, int show_frame_count); int av1_vbr_rc_frame_coding_idx(const VBR_RATECTRL_INFO *vbr_rc_info, int gf_frame_index); void av1_vbr_rc_append_tpl_info(VBR_RATECTRL_INFO *vbr_rc_info, const struct TPL_INFO *tpl_info); void av1_vbr_rc_set_gop_bit_budget(VBR_RATECTRL_INFO *vbr_rc_info, int gop_showframe_count); void av1_vbr_rc_compute_q_indices(int base_q_index, int frame_count, const double *qstep_ratio_list, aom_bit_depth_t bit_depth, int *q_index_list); /*!\brief Update q_index_list in vbr_rc_info based on tpl stats * * \param[out] vbr_rc_info Rate control info for BITRATE_ACCURACY * experiment * \param[in] tpl_data TPL struct * \param[in] gf_group GOP struct * \param[in] bit_depth bit depth */ void av1_vbr_rc_update_q_index_list(VBR_RATECTRL_INFO *vbr_rc_info, const TplParams *tpl_data, const struct GF_GROUP *gf_group, aom_bit_depth_t bit_depth); /* *!\brief Compute the number of bits needed to encode a GOP * * \param[in] base_q_index base layer q_index * \param[in] bit_depth bit depth * \param[in] update_type_scale_factors array of scale factors for each * update_type * \param[in] frame_count size of update_type_list, * qstep_ratio_list stats_list, * q_index_list and * estimated_bitrate_byframe * \param[in] update_type_list array of update_type, one per frame * \param[in] qstep_ratio_list array of qstep_ratio, one per frame * \param[in] stats_list array of transform stats, one per * frame * \param[out] q_index_list array of q_index, one per frame * \param[out] estimated_bitrate_byframe array to keep track of frame * bitrate * * \return The estimated GOP bitrate. * */ double av1_vbr_rc_info_estimate_gop_bitrate( int base_q_index, aom_bit_depth_t bit_depth, const double *update_type_scale_factors, int frame_count, const FRAME_UPDATE_TYPE *update_type_list, const double *qstep_ratio_list, const TplTxfmStats *stats_list, int *q_index_list, double *estimated_bitrate_byframe); /*!\brief Estimate the optimal base q index for a GOP. * * This function uses a binary search to find base layer q index to * achieve the specified bit budget. * * \param[in] bit_budget target bit budget * \param[in] bit_depth bit depth * \param[in] update_type_scale_factors array of scale factors for each * update_type * \param[in] frame_count size of update_type_list, qstep_ratio_list * stats_list, q_index_list and * estimated_bitrate_byframe * \param[in] update_type_list array of update_type, one per frame * \param[in] qstep_ratio_list array of qstep_ratio, one per frame * \param[in] stats_list array of transform stats, one per frame * \param[out] q_index_list array of q_index, one per frame * \param[out] estimated_bitrate_byframe Array to keep track of frame * bitrate * * \return Returns the optimal base q index to use. */ int av1_vbr_rc_info_estimate_base_q( double bit_budget, aom_bit_depth_t bit_depth, const double *update_type_scale_factors, int frame_count, const FRAME_UPDATE_TYPE *update_type_list, const double *qstep_ratio_list, const TplTxfmStats *stats_list, int *q_index_list, double *estimated_bitrate_byframe); #endif // CONFIG_BITRATE_ACCURACY #if CONFIG_RD_COMMAND typedef enum { RD_OPTION_NONE, RD_OPTION_SET_Q, RD_OPTION_SET_Q_RDMULT } RD_OPTION; typedef struct RD_COMMAND { RD_OPTION option_ls[MAX_LENGTH_TPL_FRAME_STATS]; int q_index_ls[MAX_LENGTH_TPL_FRAME_STATS]; int rdmult_ls[MAX_LENGTH_TPL_FRAME_STATS]; int frame_count; int frame_index; } RD_COMMAND; void av1_read_rd_command(const char *filepath, RD_COMMAND *rd_command); #endif // CONFIG_RD_COMMAND /*!\brief Allocate buffers used by tpl model * * \param[in] Top-level encode/decode structure * \param[in] lag_in_frames number of lookahead frames * * \param[out] tpl_data tpl data structure */ void av1_setup_tpl_buffers(struct AV1_PRIMARY *const ppi, CommonModeInfoParams *const mi_params, int width, int height, int byte_alignment, int lag_in_frames); static inline void tpl_dealloc_temp_buffers(TplBuffers *tpl_tmp_buffers) { … } static inline bool tpl_alloc_temp_buffers(TplBuffers *tpl_tmp_buffers, uint8_t tpl_bsize_1d) { … } /*!\brief Implements temporal dependency modelling for a GOP (GF/ARF * group) and selects between 16 and 32 frame GOP structure. * *\ingroup tpl_modelling * * \param[in] cpi Top - level encoder instance structure * \param[in] gop_eval Flag if it is in the GOP length decision stage * \param[in] frame_params Per frame encoding parameters * * \return Indicates whether or not we should use a longer GOP length. */ int av1_tpl_setup_stats(struct AV1_COMP *cpi, int gop_eval, const struct EncodeFrameParams *const frame_params); /*!\cond */ void av1_tpl_preload_rc_estimate( struct AV1_COMP *cpi, const struct EncodeFrameParams *const frame_params); int av1_tpl_ptr_pos(int mi_row, int mi_col, int stride, uint8_t right_shift); void av1_init_tpl_stats(TplParams *const tpl_data); int av1_tpl_stats_ready(const TplParams *tpl_data, int gf_frame_index); void av1_tpl_rdmult_setup(struct AV1_COMP *cpi); void av1_tpl_rdmult_setup_sb(struct AV1_COMP *cpi, MACROBLOCK *const x, BLOCK_SIZE sb_size, int mi_row, int mi_col); void av1_mc_flow_dispenser_row(struct AV1_COMP *cpi, TplTxfmStats *tpl_txfm_stats, TplBuffers *tpl_tmp_buffers, MACROBLOCK *x, int mi_row, BLOCK_SIZE bsize, TX_SIZE tx_size); /*!\brief Compute the entropy of an exponential probability distribution * function (pdf) subjected to uniform quantization. * * pdf(x) = b*exp(-b*x) * *\ingroup tpl_modelling * * \param[in] q_step quantizer step size * \param[in] b parameter of exponential distribution * * \return entropy cost */ double av1_exponential_entropy(double q_step, double b); /*!\brief Compute the entropy of a Laplace probability distribution * function (pdf) subjected to non-uniform quantization. * * pdf(x) = 0.5*b*exp(-0.5*b*|x|) * *\ingroup tpl_modelling * * \param[in] q_step quantizer step size for non-zero bins * \param[in] b parameter of Laplace distribution * \param[in] zero_bin_ratio zero bin's size is zero_bin_ratio * q_step * * \return entropy cost */ double av1_laplace_entropy(double q_step, double b, double zero_bin_ratio); /*!\brief Compute the frame rate using transform block stats * * Assume each position i in the transform block is of Laplace distribution * with mean absolute deviation abs_coeff_mean[i] * * Then we can use av1_laplace_entropy() to compute the expected frame * rate. * *\ingroup tpl_modelling * * \param[in] q_index quantizer index * \param[in] block_count number of transform blocks * \param[in] abs_coeff_mean array of mean absolute deviation * \param[in] coeff_num number of coefficients per transform block * * \return expected frame rate */ double av1_laplace_estimate_frame_rate(int q_index, int block_count, const double *abs_coeff_mean, int coeff_num); /* *!\brief Init TplTxfmStats * * \param[in] tpl_txfm_stats a structure for storing transform stats * */ void av1_init_tpl_txfm_stats(TplTxfmStats *tpl_txfm_stats); #if CONFIG_BITRATE_ACCURACY /* *!\brief Accumulate TplTxfmStats * * \param[in] sub_stats a structure for storing sub transform stats * \param[out] accumulated_stats a structure for storing accumulated *transform stats * */ void av1_accumulate_tpl_txfm_stats(const TplTxfmStats *sub_stats, TplTxfmStats *accumulated_stats); /* *!\brief Record a transform block into TplTxfmStats * * \param[in] tpl_txfm_stats A structure for storing transform stats * \param[out] coeff An array of transform coefficients. Its size * should equal to tpl_txfm_stats.coeff_num. * */ void av1_record_tpl_txfm_block(TplTxfmStats *tpl_txfm_stats, const tran_low_t *coeff); /* *!\brief Update abs_coeff_mean and ready of txfm_stats * If txfm_block_count > 0, this function will use abs_coeff_sum and * txfm_block_count to compute abs_coeff_mean. Moreover, reday flag * will be set to one. * * \param[in] txfm_stats A structure for storing transform stats */ void av1_tpl_txfm_stats_update_abs_coeff_mean(TplTxfmStats *txfm_stats); #endif // CONFIG_BITRATE_ACCURACY /*!\brief Estimate coefficient entropy using Laplace dsitribution * *\ingroup tpl_modelling * * This function is equivalent to -log2(laplace_prob()), where laplace_prob() *is defined in tpl_model_test.cc * * \param[in] q_step quantizer step size without any scaling * \param[in] b mean absolute deviation of Laplace *distribution \param[in] zero_bin_ratio zero bin's size is zero_bin_ratio ** q_step \param[in] qcoeff quantized coefficient * * \return estimated coefficient entropy * */ double av1_estimate_coeff_entropy(double q_step, double b, double zero_bin_ratio, int qcoeff); // TODO(angiebird): Add doxygen description here. int64_t av1_delta_rate_cost(int64_t delta_rate, int64_t recrf_dist, int64_t srcrf_dist, int pix_num); /*!\brief Compute the overlap area between two blocks with the same size * *\ingroup tpl_modelling * * If there is no overlap, this function should return zero. * * \param[in] row_a row position of the first block * \param[in] col_a column position of the first block * \param[in] row_b row position of the second block * \param[in] col_b column position of the second block * \param[in] width width shared by the two blocks * \param[in] height height shared by the two blocks * * \return overlap area of the two blocks */ int av1_get_overlap_area(int row_a, int col_a, int row_b, int col_b, int width, int height); /*!\brief Get current frame's q_index from tpl stats and leaf_qindex * * \param[in] tpl_data TPL struct * \param[in] gf_frame_index current frame index in the GOP * \param[in] leaf_qindex q index of leaf frame * \param[in] bit_depth bit depth * * \return q_index */ int av1_tpl_get_q_index(const TplParams *tpl_data, int gf_frame_index, int leaf_qindex, aom_bit_depth_t bit_depth); /*!\brief Compute the frame importance from TPL stats * * \param[in] tpl_data TPL struct * \param[in] gf_frame_index current frame index in the GOP * * \return frame_importance */ double av1_tpl_get_frame_importance(const TplParams *tpl_data, int gf_frame_index); /*!\brief Compute the ratio between arf q step and the leaf q step based on * TPL stats * * \param[in] tpl_data TPL struct * \param[in] gf_frame_index current frame index in the GOP * \param[in] leaf_qindex q index of leaf frame * \param[in] bit_depth bit depth * * \return qstep_ratio */ double av1_tpl_get_qstep_ratio(const TplParams *tpl_data, int gf_frame_index); /*!\brief Find a q index whose step size is near qstep_ratio * leaf_qstep * * \param[in] leaf_qindex q index of leaf frame * \param[in] qstep_ratio step ratio between target q index and * leaf q index \param[in] bit_depth bit depth * * \return q_index */ int av1_get_q_index_from_qstep_ratio(int leaf_qindex, double qstep_ratio, aom_bit_depth_t bit_depth); /*!\brief Improve the motion vector estimation by taking neighbors into * account. * * Use the upper and left neighbor block as the reference MVs. * Compute the minimum difference between current MV and reference MV. * * \param[in] tpl_frame Tpl frame struct * \param[in] row Current row * \param[in] col Current column * \param[in] step Step parameter for av1_tpl_ptr_pos * \param[in] tpl_stride Stride parameter for av1_tpl_ptr_pos * \param[in] right_shift Right shift parameter for * av1_tpl_ptr_pos */ int_mv av1_compute_mv_difference(const TplDepFrame *tpl_frame, int row, int col, int step, int tpl_stride, int right_shift); /*!\brief Compute the entropy of motion vectors for a single frame. * * \param[in] tpl_frame TPL frame struct * \param[in] right_shift right shift value for step * * \return Bits used by the motion vectors for one frame. */ double av1_tpl_compute_frame_mv_entropy(const TplDepFrame *tpl_frame, uint8_t right_shift); #if CONFIG_RATECTRL_LOG typedef struct { int coding_frame_count; int base_q_index; // Encode decision int q_index_list[VBR_RC_INFO_MAX_FRAMES]; double qstep_ratio_list[VBR_RC_INFO_MAX_FRAMES]; FRAME_UPDATE_TYPE update_type_list[VBR_RC_INFO_MAX_FRAMES]; // Frame stats TplTxfmStats txfm_stats_list[VBR_RC_INFO_MAX_FRAMES]; // Estimated encode results double est_coeff_rate_list[VBR_RC_INFO_MAX_FRAMES]; // Actual encode results double act_rate_list[VBR_RC_INFO_MAX_FRAMES]; double act_coeff_rate_list[VBR_RC_INFO_MAX_FRAMES]; } RATECTRL_LOG; static inline void rc_log_init(RATECTRL_LOG *rc_log) { av1_zero(*rc_log); } static inline void rc_log_frame_stats(RATECTRL_LOG *rc_log, int coding_index, const TplTxfmStats *txfm_stats) { rc_log->txfm_stats_list[coding_index] = *txfm_stats; } static inline void rc_log_frame_encode_param(RATECTRL_LOG *rc_log, int coding_index, double qstep_ratio, int q_index, FRAME_UPDATE_TYPE update_type) { rc_log->qstep_ratio_list[coding_index] = qstep_ratio; rc_log->q_index_list[coding_index] = q_index; rc_log->update_type_list[coding_index] = update_type; const TplTxfmStats *txfm_stats = &rc_log->txfm_stats_list[coding_index]; rc_log->est_coeff_rate_list[coding_index] = 0; if (txfm_stats->ready) { rc_log->est_coeff_rate_list[coding_index] = av1_laplace_estimate_frame_rate( q_index, txfm_stats->txfm_block_count, txfm_stats->abs_coeff_mean, txfm_stats->coeff_num); } } static inline void rc_log_frame_entropy(RATECTRL_LOG *rc_log, int coding_index, double act_rate, double act_coeff_rate) { rc_log->act_rate_list[coding_index] = act_rate; rc_log->act_coeff_rate_list[coding_index] = act_coeff_rate; } static inline void rc_log_record_chunk_info(RATECTRL_LOG *rc_log, int base_q_index, int coding_frame_count) { rc_log->base_q_index = base_q_index; rc_log->coding_frame_count = coding_frame_count; } static inline void rc_log_show(const RATECTRL_LOG *rc_log) { printf("= chunk 1\n"); printf("coding_frame_count %d base_q_index %d\n", rc_log->coding_frame_count, rc_log->base_q_index); printf("= frame %d\n", rc_log->coding_frame_count); for (int coding_idx = 0; coding_idx < rc_log->coding_frame_count; coding_idx++) { printf( "coding_idx %d update_type %d q %d qstep_ratio %f est_coeff_rate %f " "act_coeff_rate %f act_rate %f\n", coding_idx, rc_log->update_type_list[coding_idx], rc_log->q_index_list[coding_idx], rc_log->qstep_ratio_list[coding_idx], rc_log->est_coeff_rate_list[coding_idx], rc_log->act_coeff_rate_list[coding_idx], rc_log->act_rate_list[coding_idx]); } } #endif // CONFIG_RATECTRL_LOG /*!\endcond */ #ifdef __cplusplus } // extern "C" #endif #endif // AOM_AV1_ENCODER_TPL_MODEL_H_
Codebase Browser
chromium