/* * 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 <float.h> #include <math.h> #include <stdbool.h> #include <stdio.h> #include "config/aom_config.h" #include "config/aom_dsp_rtcd.h" #include "config/av1_rtcd.h" #include "aom_dsp/aom_dsp_common.h" #include "aom_dsp/binary_codes_writer.h" #include "aom_ports/mem.h" #include "aom_ports/aom_timer.h" #include "aom_util/aom_pthread.h" #if CONFIG_MISMATCH_DEBUG #include "aom_util/debug_util.h" #endif // CONFIG_MISMATCH_DEBUG #include "av1/common/cfl.h" #include "av1/common/common.h" #include "av1/common/common_data.h" #include "av1/common/entropy.h" #include "av1/common/entropymode.h" #include "av1/common/idct.h" #include "av1/common/mv.h" #include "av1/common/mvref_common.h" #include "av1/common/pred_common.h" #include "av1/common/quant_common.h" #include "av1/common/reconintra.h" #include "av1/common/reconinter.h" #include "av1/common/seg_common.h" #include "av1/common/tile_common.h" #include "av1/common/warped_motion.h" #include "av1/encoder/allintra_vis.h" #include "av1/encoder/aq_complexity.h" #include "av1/encoder/aq_cyclicrefresh.h" #include "av1/encoder/aq_variance.h" #include "av1/encoder/global_motion_facade.h" #include "av1/encoder/encodeframe.h" #include "av1/encoder/encodeframe_utils.h" #include "av1/encoder/encodemb.h" #include "av1/encoder/encodemv.h" #include "av1/encoder/encodetxb.h" #include "av1/encoder/ethread.h" #include "av1/encoder/extend.h" #include "av1/encoder/intra_mode_search_utils.h" #include "av1/encoder/ml.h" #include "av1/encoder/motion_search_facade.h" #include "av1/encoder/partition_strategy.h" #if !CONFIG_REALTIME_ONLY #include "av1/encoder/partition_model_weights.h" #endif #include "av1/encoder/partition_search.h" #include "av1/encoder/rd.h" #include "av1/encoder/rdopt.h" #include "av1/encoder/reconinter_enc.h" #include "av1/encoder/segmentation.h" #include "av1/encoder/tokenize.h" #include "av1/encoder/tpl_model.h" #include "av1/encoder/var_based_part.h" #if CONFIG_TUNE_VMAF #include "av1/encoder/tune_vmaf.h" #endif /*!\cond */ // This is used as a reference when computing the source variance for the // purposes of activity masking. // Eventually this should be replaced by custom no-reference routines, // which will be faster. static const uint8_t AV1_VAR_OFFS[MAX_SB_SIZE] = …; #if CONFIG_AV1_HIGHBITDEPTH static const uint16_t AV1_HIGH_VAR_OFFS_8[MAX_SB_SIZE] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128 }; static const uint16_t AV1_HIGH_VAR_OFFS_10[MAX_SB_SIZE] = { 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4, 128 * 4 }; static const uint16_t AV1_HIGH_VAR_OFFS_12[MAX_SB_SIZE] = { 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16, 128 * 16 }; #endif // CONFIG_AV1_HIGHBITDEPTH /*!\endcond */ // For the given bit depth, returns a constant array used to assist the // calculation of source block variance, which will then be used to decide // adaptive quantizers. static const uint8_t *get_var_offs(int use_hbd, int bd) { … } void av1_init_rtc_counters(MACROBLOCK *const x) { … } void av1_accumulate_rtc_counters(AV1_COMP *cpi, const MACROBLOCK *const x) { … } unsigned int av1_get_perpixel_variance(const AV1_COMP *cpi, const MACROBLOCKD *xd, const struct buf_2d *ref, BLOCK_SIZE bsize, int plane, int use_hbd) { … } unsigned int av1_get_perpixel_variance_facade(const AV1_COMP *cpi, const MACROBLOCKD *xd, const struct buf_2d *ref, BLOCK_SIZE bsize, int plane) { … } void av1_setup_src_planes(MACROBLOCK *x, const YV12_BUFFER_CONFIG *src, int mi_row, int mi_col, const int num_planes, BLOCK_SIZE bsize) { … } #if !CONFIG_REALTIME_ONLY /*!\brief Assigns different quantization parameters to each super * block based on its TPL weight. * * \ingroup tpl_modelling * * \param[in] cpi Top level encoder instance structure * \param[in,out] td Thread data structure * \param[in,out] x Macro block level data for this block. * \param[in] tile_info Tile infromation / identification * \param[in] mi_row Block row (in "MI_SIZE" units) index * \param[in] mi_col Block column (in "MI_SIZE" units) index * \param[out] num_planes Number of image planes (e.g. Y,U,V) * * \remark No return value but updates macroblock and thread data * related to the q / q delta to be used. */ static inline void setup_delta_q(AV1_COMP *const cpi, ThreadData *td, MACROBLOCK *const x, const TileInfo *const tile_info, int mi_row, int mi_col, int num_planes) { AV1_COMMON *const cm = &cpi->common; const CommonModeInfoParams *const mi_params = &cm->mi_params; const DeltaQInfo *const delta_q_info = &cm->delta_q_info; assert(delta_q_info->delta_q_present_flag); const BLOCK_SIZE sb_size = cm->seq_params->sb_size; // Delta-q modulation based on variance av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, sb_size); const int delta_q_res = delta_q_info->delta_q_res; int current_qindex = cm->quant_params.base_qindex; if (cpi->use_ducky_encode && cpi->ducky_encode_info.frame_info.qp_mode == DUCKY_ENCODE_FRAME_MODE_QINDEX) { const int sb_row = mi_row >> cm->seq_params->mib_size_log2; const int sb_col = mi_col >> cm->seq_params->mib_size_log2; const int sb_cols = CEIL_POWER_OF_TWO(cm->mi_params.mi_cols, cm->seq_params->mib_size_log2); const int sb_index = sb_row * sb_cols + sb_col; current_qindex = cpi->ducky_encode_info.frame_info.superblock_encode_qindex[sb_index]; } else if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_PERCEPTUAL) { if (DELTA_Q_PERCEPTUAL_MODULATION == 1) { const int block_wavelet_energy_level = av1_block_wavelet_energy_level(cpi, x, sb_size); x->sb_energy_level = block_wavelet_energy_level; current_qindex = av1_compute_q_from_energy_level_deltaq_mode( cpi, block_wavelet_energy_level); } else { const int block_var_level = av1_log_block_var(cpi, x, sb_size); x->sb_energy_level = block_var_level; current_qindex = av1_compute_q_from_energy_level_deltaq_mode(cpi, block_var_level); } } else if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_OBJECTIVE && cpi->oxcf.algo_cfg.enable_tpl_model) { // Setup deltaq based on tpl stats current_qindex = av1_get_q_for_deltaq_objective(cpi, td, NULL, sb_size, mi_row, mi_col); } else if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_PERCEPTUAL_AI) { current_qindex = av1_get_sbq_perceptual_ai(cpi, sb_size, mi_row, mi_col); } else if (cpi->oxcf.q_cfg.deltaq_mode == DELTA_Q_USER_RATING_BASED) { current_qindex = av1_get_sbq_user_rating_based(cpi, mi_row, mi_col); } else if (cpi->oxcf.q_cfg.enable_hdr_deltaq) { current_qindex = av1_get_q_for_hdr(cpi, x, sb_size, mi_row, mi_col); } x->rdmult_cur_qindex = current_qindex; MACROBLOCKD *const xd = &x->e_mbd; const int adjusted_qindex = av1_adjust_q_from_delta_q_res( delta_q_res, xd->current_base_qindex, current_qindex); if (cpi->use_ducky_encode) { assert(adjusted_qindex == current_qindex); } current_qindex = adjusted_qindex; x->delta_qindex = current_qindex - cm->quant_params.base_qindex; x->rdmult_delta_qindex = x->delta_qindex; av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); xd->mi[0]->current_qindex = current_qindex; av1_init_plane_quantizers(cpi, x, xd->mi[0]->segment_id, 0); // keep track of any non-zero delta-q used td->deltaq_used |= (x->delta_qindex != 0); if (cpi->oxcf.tool_cfg.enable_deltalf_mode) { const int delta_lf_res = delta_q_info->delta_lf_res; const int lfmask = ~(delta_lf_res - 1); const int delta_lf_from_base = ((x->delta_qindex / 4 + delta_lf_res / 2) & lfmask); const int8_t delta_lf = (int8_t)clamp(delta_lf_from_base, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); const int frame_lf_count = av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; const int mib_size = cm->seq_params->mib_size; // pre-set the delta lf for loop filter. Note that this value is set // before mi is assigned for each block in current superblock for (int j = 0; j < AOMMIN(mib_size, mi_params->mi_rows - mi_row); j++) { for (int k = 0; k < AOMMIN(mib_size, mi_params->mi_cols - mi_col); k++) { const int grid_idx = get_mi_grid_idx(mi_params, mi_row + j, mi_col + k); mi_params->mi_alloc[grid_idx].delta_lf_from_base = delta_lf; for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { mi_params->mi_alloc[grid_idx].delta_lf[lf_id] = delta_lf; } } } } } static void init_ref_frame_space(AV1_COMP *cpi, ThreadData *td, int mi_row, int mi_col) { const AV1_COMMON *cm = &cpi->common; const GF_GROUP *const gf_group = &cpi->ppi->gf_group; const CommonModeInfoParams *const mi_params = &cm->mi_params; MACROBLOCK *x = &td->mb; const int frame_idx = cpi->gf_frame_index; TplParams *const tpl_data = &cpi->ppi->tpl_data; const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2; av1_zero(x->tpl_keep_ref_frame); if (!av1_tpl_stats_ready(tpl_data, frame_idx)) return; if (!is_frame_tpl_eligible(gf_group, cpi->gf_frame_index)) return; if (cpi->oxcf.q_cfg.aq_mode != NO_AQ) return; const int is_overlay = cpi->ppi->gf_group.update_type[frame_idx] == OVERLAY_UPDATE; if (is_overlay) { memset(x->tpl_keep_ref_frame, 1, sizeof(x->tpl_keep_ref_frame)); return; } TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx]; TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr; const int tpl_stride = tpl_frame->stride; int64_t inter_cost[INTER_REFS_PER_FRAME] = { 0 }; const int step = 1 << block_mis_log2; const BLOCK_SIZE sb_size = cm->seq_params->sb_size; const int mi_row_end = AOMMIN(mi_size_high[sb_size] + mi_row, mi_params->mi_rows); const int mi_cols_sr = av1_pixels_to_mi(cm->superres_upscaled_width); const int mi_col_sr = coded_to_superres_mi(mi_col, cm->superres_scale_denominator); const int mi_col_end_sr = AOMMIN(coded_to_superres_mi(mi_col + mi_size_wide[sb_size], cm->superres_scale_denominator), mi_cols_sr); const int row_step = step; const int col_step_sr = coded_to_superres_mi(step, cm->superres_scale_denominator); for (int row = mi_row; row < mi_row_end; row += row_step) { for (int col = mi_col_sr; col < mi_col_end_sr; col += col_step_sr) { const TplDepStats *this_stats = &tpl_stats[av1_tpl_ptr_pos(row, col, tpl_stride, block_mis_log2)]; int64_t tpl_pred_error[INTER_REFS_PER_FRAME] = { 0 }; // Find the winner ref frame idx for the current block int64_t best_inter_cost = this_stats->pred_error[0]; int best_rf_idx = 0; for (int idx = 1; idx < INTER_REFS_PER_FRAME; ++idx) { if ((this_stats->pred_error[idx] < best_inter_cost) && (this_stats->pred_error[idx] != 0)) { best_inter_cost = this_stats->pred_error[idx]; best_rf_idx = idx; } } // tpl_pred_error is the pred_error reduction of best_ref w.r.t. // LAST_FRAME. tpl_pred_error[best_rf_idx] = this_stats->pred_error[best_rf_idx] - this_stats->pred_error[LAST_FRAME - 1]; for (int rf_idx = 1; rf_idx < INTER_REFS_PER_FRAME; ++rf_idx) inter_cost[rf_idx] += tpl_pred_error[rf_idx]; } } int rank_index[INTER_REFS_PER_FRAME - 1]; for (int idx = 0; idx < INTER_REFS_PER_FRAME - 1; ++idx) { rank_index[idx] = idx + 1; for (int i = idx; i > 0; --i) { if (inter_cost[rank_index[i - 1]] > inter_cost[rank_index[i]]) { const int tmp = rank_index[i - 1]; rank_index[i - 1] = rank_index[i]; rank_index[i] = tmp; } } } x->tpl_keep_ref_frame[INTRA_FRAME] = 1; x->tpl_keep_ref_frame[LAST_FRAME] = 1; int cutoff_ref = 0; for (int idx = 0; idx < INTER_REFS_PER_FRAME - 1; ++idx) { x->tpl_keep_ref_frame[rank_index[idx] + LAST_FRAME] = 1; if (idx > 2) { if (!cutoff_ref) { // If the predictive coding gains are smaller than the previous more // relevant frame over certain amount, discard this frame and all the // frames afterwards. if (llabs(inter_cost[rank_index[idx]]) < llabs(inter_cost[rank_index[idx - 1]]) / 8 || inter_cost[rank_index[idx]] == 0) cutoff_ref = 1; } if (cutoff_ref) x->tpl_keep_ref_frame[rank_index[idx] + LAST_FRAME] = 0; } } } static inline void adjust_rdmult_tpl_model(AV1_COMP *cpi, MACROBLOCK *x, int mi_row, int mi_col) { const BLOCK_SIZE sb_size = cpi->common.seq_params->sb_size; const int orig_rdmult = cpi->rd.RDMULT; assert(IMPLIES(cpi->ppi->gf_group.size > 0, cpi->gf_frame_index < cpi->ppi->gf_group.size)); const int gf_group_index = cpi->gf_frame_index; if (cpi->oxcf.algo_cfg.enable_tpl_model && cpi->oxcf.q_cfg.aq_mode == NO_AQ && cpi->oxcf.q_cfg.deltaq_mode == NO_DELTA_Q && gf_group_index > 0 && cpi->ppi->gf_group.update_type[gf_group_index] == ARF_UPDATE) { const int dr = av1_get_rdmult_delta(cpi, sb_size, mi_row, mi_col, orig_rdmult); x->rdmult = dr; } } #endif // !CONFIG_REALTIME_ONLY #if CONFIG_RT_ML_PARTITIONING // Get a prediction(stored in x->est_pred) for the whole superblock. static void get_estimated_pred(AV1_COMP *cpi, const TileInfo *const tile, MACROBLOCK *x, int mi_row, int mi_col) { AV1_COMMON *const cm = &cpi->common; const int is_key_frame = frame_is_intra_only(cm); MACROBLOCKD *xd = &x->e_mbd; // TODO(kyslov) Extend to 128x128 assert(cm->seq_params->sb_size == BLOCK_64X64); av1_set_offsets(cpi, tile, x, mi_row, mi_col, BLOCK_64X64); if (!is_key_frame) { MB_MODE_INFO *mi = xd->mi[0]; const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_yv12_buf(cm, LAST_FRAME); assert(yv12 != NULL); av1_setup_pre_planes(xd, 0, yv12, mi_row, mi_col, get_ref_scale_factors(cm, LAST_FRAME), 1); mi->ref_frame[0] = LAST_FRAME; mi->ref_frame[1] = NONE; mi->bsize = BLOCK_64X64; mi->mv[0].as_int = 0; mi->interp_filters = av1_broadcast_interp_filter(BILINEAR); set_ref_ptrs(cm, xd, mi->ref_frame[0], mi->ref_frame[1]); xd->plane[0].dst.buf = x->est_pred; xd->plane[0].dst.stride = 64; av1_enc_build_inter_predictor_y(xd, mi_row, mi_col); } else { #if CONFIG_AV1_HIGHBITDEPTH switch (xd->bd) { case 8: memset(x->est_pred, 128, 64 * 64 * sizeof(x->est_pred[0])); break; case 10: memset(x->est_pred, 128 * 4, 64 * 64 * sizeof(x->est_pred[0])); break; case 12: memset(x->est_pred, 128 * 16, 64 * 64 * sizeof(x->est_pred[0])); break; } #else memset(x->est_pred, 128, 64 * 64 * sizeof(x->est_pred[0])); #endif // CONFIG_VP9_HIGHBITDEPTH } } #endif // CONFIG_RT_ML_PARTITIONING #define AVG_CDF_WEIGHT_LEFT … #define AVG_CDF_WEIGHT_TOP_RIGHT … /*!\brief Encode a superblock (minimal RD search involved) * * \ingroup partition_search * Encodes the superblock by a pre-determined partition pattern, only minor * rd-based searches are allowed to adjust the initial pattern. It is only used * by realtime encoding. */ static inline void encode_nonrd_sb(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, TokenExtra **tp, const int mi_row, const int mi_col, const int seg_skip) { … } // This function initializes the stats for encode_rd_sb. static inline void init_encode_rd_sb(AV1_COMP *cpi, ThreadData *td, const TileDataEnc *tile_data, SIMPLE_MOTION_DATA_TREE *sms_root, RD_STATS *rd_cost, int mi_row, int mi_col, int gather_tpl_data) { … } #if !CONFIG_REALTIME_ONLY static void sb_qp_sweep_init_quantizers(AV1_COMP *cpi, ThreadData *td, const TileDataEnc *tile_data, SIMPLE_MOTION_DATA_TREE *sms_tree, RD_STATS *rd_cost, int mi_row, int mi_col, int delta_qp_ofs) { AV1_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &td->mb; const BLOCK_SIZE sb_size = cm->seq_params->sb_size; const TileInfo *tile_info = &tile_data->tile_info; const CommonModeInfoParams *const mi_params = &cm->mi_params; const DeltaQInfo *const delta_q_info = &cm->delta_q_info; assert(delta_q_info->delta_q_present_flag); const int delta_q_res = delta_q_info->delta_q_res; const SPEED_FEATURES *sf = &cpi->sf; const int use_simple_motion_search = (sf->part_sf.simple_motion_search_split || sf->part_sf.simple_motion_search_prune_rect || sf->part_sf.simple_motion_search_early_term_none || sf->part_sf.ml_early_term_after_part_split_level) && !frame_is_intra_only(cm); if (use_simple_motion_search) { av1_init_simple_motion_search_mvs_for_sb(cpi, tile_info, x, sms_tree, mi_row, mi_col); } int current_qindex = x->rdmult_cur_qindex + delta_qp_ofs; MACROBLOCKD *const xd = &x->e_mbd; current_qindex = av1_adjust_q_from_delta_q_res( delta_q_res, xd->current_base_qindex, current_qindex); x->delta_qindex = current_qindex - cm->quant_params.base_qindex; av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); xd->mi[0]->current_qindex = current_qindex; av1_init_plane_quantizers(cpi, x, xd->mi[0]->segment_id, 0); // keep track of any non-zero delta-q used td->deltaq_used |= (x->delta_qindex != 0); if (cpi->oxcf.tool_cfg.enable_deltalf_mode) { const int delta_lf_res = delta_q_info->delta_lf_res; const int lfmask = ~(delta_lf_res - 1); const int delta_lf_from_base = ((x->delta_qindex / 4 + delta_lf_res / 2) & lfmask); const int8_t delta_lf = (int8_t)clamp(delta_lf_from_base, -MAX_LOOP_FILTER, MAX_LOOP_FILTER); const int frame_lf_count = av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; const int mib_size = cm->seq_params->mib_size; // pre-set the delta lf for loop filter. Note that this value is set // before mi is assigned for each block in current superblock for (int j = 0; j < AOMMIN(mib_size, mi_params->mi_rows - mi_row); j++) { for (int k = 0; k < AOMMIN(mib_size, mi_params->mi_cols - mi_col); k++) { const int grid_idx = get_mi_grid_idx(mi_params, mi_row + j, mi_col + k); mi_params->mi_alloc[grid_idx].delta_lf_from_base = delta_lf; for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { mi_params->mi_alloc[grid_idx].delta_lf[lf_id] = delta_lf; } } } } x->reuse_inter_pred = false; x->txfm_search_params.mode_eval_type = DEFAULT_EVAL; reset_mb_rd_record(x->txfm_search_info.mb_rd_record); av1_zero(x->picked_ref_frames_mask); av1_invalid_rd_stats(rd_cost); } static int sb_qp_sweep(AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data, TokenExtra **tp, int mi_row, int mi_col, BLOCK_SIZE bsize, SIMPLE_MOTION_DATA_TREE *sms_tree, SB_FIRST_PASS_STATS *sb_org_stats) { AV1_COMMON *const cm = &cpi->common; MACROBLOCK *const x = &td->mb; RD_STATS rdc_winner, cur_rdc; av1_invalid_rd_stats(&rdc_winner); int best_qindex = td->mb.rdmult_delta_qindex; const int start = cm->current_frame.frame_type == KEY_FRAME ? -20 : -12; const int end = cm->current_frame.frame_type == KEY_FRAME ? 20 : 12; const int step = cm->delta_q_info.delta_q_res; for (int sweep_qp_delta = start; sweep_qp_delta <= end; sweep_qp_delta += step) { sb_qp_sweep_init_quantizers(cpi, td, tile_data, sms_tree, &cur_rdc, mi_row, mi_col, sweep_qp_delta); const int alloc_mi_idx = get_alloc_mi_idx(&cm->mi_params, mi_row, mi_col); const int backup_current_qindex = cm->mi_params.mi_alloc[alloc_mi_idx].current_qindex; av1_reset_mbmi(&cm->mi_params, bsize, mi_row, mi_col); av1_restore_sb_state(sb_org_stats, cpi, td, tile_data, mi_row, mi_col); cm->mi_params.mi_alloc[alloc_mi_idx].current_qindex = backup_current_qindex; td->pc_root = av1_alloc_pc_tree_node(bsize); if (!td->pc_root) aom_internal_error(x->e_mbd.error_info, AOM_CODEC_MEM_ERROR, "Failed to allocate PC_TREE"); av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize, &cur_rdc, cur_rdc, td->pc_root, sms_tree, NULL, SB_DRY_PASS, NULL); if ((rdc_winner.rdcost > cur_rdc.rdcost) || (abs(sweep_qp_delta) < abs(best_qindex - x->rdmult_delta_qindex) && rdc_winner.rdcost == cur_rdc.rdcost)) { rdc_winner = cur_rdc; best_qindex = x->rdmult_delta_qindex + sweep_qp_delta; } } return best_qindex; } #endif //! CONFIG_REALTIME_ONLY /*!\brief Encode a superblock (RD-search-based) * * \ingroup partition_search * Conducts partition search for a superblock, based on rate-distortion costs, * from scratch or adjusting from a pre-calculated partition pattern. */ static inline void encode_rd_sb(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, TokenExtra **tp, const int mi_row, const int mi_col, const int seg_skip) { … } // Check if the cost update of symbols mode, coeff and dv are tile or off. static inline int is_mode_coeff_dv_upd_freq_tile_or_off( const AV1_COMP *const cpi) { … } // When row-mt is enabled and cost update frequencies are set to off/tile, // processing of current SB can start even before processing of top-right SB // is finished. This function checks if it is sufficient to wait for top SB // to finish processing before current SB starts processing. static inline int delay_wait_for_top_right_sb(const AV1_COMP *const cpi) { … } /*!\brief Calculate source SAD at superblock level using 64x64 block source SAD * * \ingroup partition_search * \callgraph * \callergraph */ static inline uint64_t get_sb_source_sad(const AV1_COMP *cpi, int mi_row, int mi_col) { … } /*!\brief Determine whether grading content can be skipped based on sad stat * * \ingroup partition_search * \callgraph * \callergraph */ static inline bool is_calc_src_content_needed(AV1_COMP *cpi, MACROBLOCK *const x, int mi_row, int mi_col) { … } /*!\brief Determine whether grading content is needed based on sf and frame stat * * \ingroup partition_search * \callgraph * \callergraph */ // TODO(any): consolidate sfs to make interface cleaner static inline void grade_source_content_sb(AV1_COMP *cpi, MACROBLOCK *const x, TileDataEnc *tile_data, int mi_row, int mi_col) { … } /*!\brief Encode a superblock row by breaking it into superblocks * * \ingroup partition_search * \callgraph * \callergraph * Do partition and mode search for an sb row: one row of superblocks filling up * the width of the current tile. */ static inline void encode_sb_row(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, int mi_row, TokenExtra **tp) { … } static inline void init_encode_frame_mb_context(AV1_COMP *cpi) { … } void av1_alloc_tile_data(AV1_COMP *cpi) { … } void av1_init_tile_data(AV1_COMP *cpi) { … } // Populate the start palette token info prior to encoding an SB row. static inline void get_token_start(AV1_COMP *cpi, const TileInfo *tile_info, int tile_row, int tile_col, int mi_row, TokenExtra **tp) { … } // Populate the token count after encoding an SB row. static inline void populate_token_count(AV1_COMP *cpi, const TileInfo *tile_info, int tile_row, int tile_col, int mi_row, TokenExtra *tok) { … } /*!\brief Encode a superblock row * * \ingroup partition_search */ void av1_encode_sb_row(AV1_COMP *cpi, ThreadData *td, int tile_row, int tile_col, int mi_row) { … } /*!\brief Encode a tile * * \ingroup partition_search */ void av1_encode_tile(AV1_COMP *cpi, ThreadData *td, int tile_row, int tile_col) { … } /*!\brief Break one frame into tiles and encode the tiles * * \ingroup partition_search * * \param[in] cpi Top-level encoder structure */ static inline void encode_tiles(AV1_COMP *cpi) { … } // Set the relative distance of a reference frame w.r.t. current frame static inline void set_rel_frame_dist( const AV1_COMMON *const cm, RefFrameDistanceInfo *const ref_frame_dist_info, const int ref_frame_flags) { … } static inline int refs_are_one_sided(const AV1_COMMON *cm) { … } static inline void get_skip_mode_ref_offsets(const AV1_COMMON *cm, int ref_order_hint[2]) { … } static int check_skip_mode_enabled(AV1_COMP *const cpi) { … } static inline void set_default_interp_skip_flags( const AV1_COMMON *cm, InterpSearchFlags *interp_search_flags) { … } static inline void setup_prune_ref_frame_mask(AV1_COMP *cpi) { … } static int allow_deltaq_mode(AV1_COMP *cpi) { … } #define FORCE_ZMV_SKIP_128X128_BLK_DIFF … #define FORCE_ZMV_SKIP_MAX_PER_PIXEL_DIFF … // Populates block level thresholds for force zeromv-skip decision static void populate_thresh_to_force_zeromv_skip(AV1_COMP *cpi) { … } static void free_block_hash_buffers(uint32_t *block_hash_values[2][2], int8_t *is_block_same[2][3]) { … } /*!\brief Encoder setup(only for the current frame), encoding, and recontruction * for a single frame * * \ingroup high_level_algo */ static inline void encode_frame_internal(AV1_COMP *cpi) { … } /*!\brief Setup reference frame buffers and encode a frame * * \ingroup high_level_algo * \callgraph * \callergraph * * \param[in] cpi Top-level encoder structure */ void av1_encode_frame(AV1_COMP *cpi) { … }
Codebase Browser
chromium