| /* |
| * 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_ports/system_state.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/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/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/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. |
| const uint8_t AV1_VAR_OFFS[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_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 |
| }; |
| /*!\endcond */ |
| |
| unsigned int av1_get_sby_perpixel_variance(const AV1_COMP *cpi, |
| const struct buf_2d *ref, |
| BLOCK_SIZE bs) { |
| unsigned int sse; |
| const unsigned int var = |
| cpi->fn_ptr[bs].vf(ref->buf, ref->stride, AV1_VAR_OFFS, 0, &sse); |
| return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]); |
| } |
| |
| unsigned int av1_high_get_sby_perpixel_variance(const AV1_COMP *cpi, |
| const struct buf_2d *ref, |
| BLOCK_SIZE bs, int bd) { |
| unsigned int var, sse; |
| assert(bd == 8 || bd == 10 || bd == 12); |
| const int off_index = (bd - 8) >> 1; |
| const uint16_t *high_var_offs[3] = { AV1_HIGH_VAR_OFFS_8, |
| AV1_HIGH_VAR_OFFS_10, |
| AV1_HIGH_VAR_OFFS_12 }; |
| var = |
| cpi->fn_ptr[bs].vf(ref->buf, ref->stride, |
| CONVERT_TO_BYTEPTR(high_var_offs[off_index]), 0, &sse); |
| return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]); |
| } |
| |
| static unsigned int get_sby_perpixel_diff_variance(const AV1_COMP *const cpi, |
| const struct buf_2d *ref, |
| int mi_row, int mi_col, |
| BLOCK_SIZE bs) { |
| unsigned int sse, var; |
| uint8_t *last_y; |
| const YV12_BUFFER_CONFIG *last = |
| get_ref_frame_yv12_buf(&cpi->common, LAST_FRAME); |
| |
| assert(last != NULL); |
| last_y = |
| &last->y_buffer[mi_row * MI_SIZE * last->y_stride + mi_col * MI_SIZE]; |
| var = cpi->fn_ptr[bs].vf(ref->buf, ref->stride, last_y, last->y_stride, &sse); |
| return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]); |
| } |
| |
| static BLOCK_SIZE get_rd_var_based_fixed_partition(AV1_COMP *cpi, MACROBLOCK *x, |
| int mi_row, int mi_col) { |
| unsigned int var = get_sby_perpixel_diff_variance( |
| cpi, &x->plane[0].src, mi_row, mi_col, BLOCK_64X64); |
| if (var < 8) |
| return BLOCK_64X64; |
| else if (var < 128) |
| return BLOCK_32X32; |
| else if (var < 2048) |
| return BLOCK_16X16; |
| else |
| return BLOCK_8X8; |
| } |
| |
| 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) { |
| // Set current frame pointer. |
| x->e_mbd.cur_buf = src; |
| |
| // We use AOMMIN(num_planes, MAX_MB_PLANE) instead of num_planes to quiet |
| // the static analysis warnings. |
| for (int i = 0; i < AOMMIN(num_planes, MAX_MB_PLANE); i++) { |
| const int is_uv = i > 0; |
| setup_pred_plane( |
| &x->plane[i].src, bsize, src->buffers[i], src->crop_widths[is_uv], |
| src->crop_heights[is_uv], src->strides[is_uv], mi_row, mi_col, NULL, |
| x->e_mbd.plane[i].subsampling_x, x->e_mbd.plane[i].subsampling_y); |
| } |
| } |
| |
| #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) |
| * |
| * \return No return value but updates macroblock and thread data |
| * related to the q / q delta to be used. |
| */ |
| static AOM_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); |
| |
| int current_qindex = cm->quant_params.base_qindex; |
| 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, sb_size, mi_row, mi_col); |
| } |
| |
| const int delta_q_res = delta_q_info->delta_q_res; |
| // Right now deltaq only works with tpl model. So if tpl is disabled, we set |
| // the current_qindex to base_qindex. |
| if (cpi->oxcf.algo_cfg.enable_tpl_model && |
| cpi->oxcf.q_cfg.deltaq_mode != NO_DELTA_Q) { |
| current_qindex = |
| clamp(current_qindex, delta_q_res, 256 - delta_q_info->delta_q_res); |
| } else { |
| current_qindex = cm->quant_params.base_qindex; |
| } |
| |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int sign_deltaq_index = |
| current_qindex - xd->current_base_qindex >= 0 ? 1 : -1; |
| const int deltaq_deadzone = delta_q_res / 4; |
| const int qmask = ~(delta_q_res - 1); |
| int abs_deltaq_index = abs(current_qindex - xd->current_base_qindex); |
| abs_deltaq_index = (abs_deltaq_index + deltaq_deadzone) & qmask; |
| current_qindex = |
| xd->current_base_qindex + sign_deltaq_index * abs_deltaq_index; |
| current_qindex = AOMMAX(current_qindex, MINQ + 1); |
| assert(current_qindex > 0); |
| |
| 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); |
| |
| // 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 / 2 + 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_grid_base[grid_idx]->delta_lf_from_base = delta_lf; |
| for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { |
| mi_params->mi_grid_base[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->gf_group; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| MACROBLOCK *x = &td->mb; |
| const int frame_idx = cpi->gf_group.index; |
| TplParams *const tpl_data = &cpi->tpl_data; |
| TplDepFrame *tpl_frame = &tpl_data->tpl_frame[frame_idx]; |
| const uint8_t block_mis_log2 = tpl_data->tpl_stats_block_mis_log2; |
| |
| av1_zero(x->tpl_keep_ref_frame); |
| |
| if (tpl_frame->is_valid == 0) return; |
| if (!is_frame_tpl_eligible(gf_group, gf_group->index)) return; |
| if (frame_idx >= MAX_TPL_FRAME_IDX) return; |
| if (cpi->oxcf.q_cfg.aq_mode != NO_AQ) return; |
| |
| const int is_overlay = cpi->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; |
| } |
| |
| 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 AOM_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->gf_group.size > 0, |
| cpi->gf_group.index < cpi->gf_group.size)); |
| const int gf_group_index = cpi->gf_group.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->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 3 |
| #define AVG_CDF_WEIGHT_TOP_RIGHT 1 |
| |
| /*!\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 AOM_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) { |
| AV1_COMMON *const cm = &cpi->common; |
| MACROBLOCK *const x = &td->mb; |
| const SPEED_FEATURES *const sf = &cpi->sf; |
| const TileInfo *const tile_info = &tile_data->tile_info; |
| MB_MODE_INFO **mi = cm->mi_params.mi_grid_base + |
| get_mi_grid_idx(&cm->mi_params, mi_row, mi_col); |
| const BLOCK_SIZE sb_size = cm->seq_params.sb_size; |
| |
| // Grade the temporal variation of the sb, the grade will be used to decide |
| // fast mode search strategy for coding blocks |
| if (sf->rt_sf.source_metrics_sb_nonrd && |
| cpi->svc.number_spatial_layers <= 1 && |
| cm->current_frame.frame_type != KEY_FRAME) { |
| int offset = cpi->source->y_stride * (mi_row << 2) + (mi_col << 2); |
| av1_source_content_sb(cpi, x, offset); |
| } |
| #if CONFIG_RT_ML_PARTITIONING |
| if (sf->part_sf.partition_search_type == ML_BASED_PARTITION) { |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| RD_STATS dummy_rdc; |
| get_estimated_pred(cpi, tile_info, x, mi_row, mi_col); |
| av1_nonrd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, |
| BLOCK_64X64, &dummy_rdc, 1, INT64_MAX, pc_root); |
| av1_free_pc_tree_recursive(pc_root, av1_num_planes(cm), 0, 0); |
| return; |
| } |
| #endif |
| // Set the partition |
| if (sf->part_sf.partition_search_type == FIXED_PARTITION || seg_skip) { |
| // set a fixed-size partition |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); |
| const BLOCK_SIZE bsize = |
| seg_skip ? sb_size : sf->part_sf.fixed_partition_size; |
| av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize); |
| } else if (cpi->partition_search_skippable_frame) { |
| // set a fixed-size partition for which the size is determined by the source |
| // variance |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); |
| const BLOCK_SIZE bsize = |
| get_rd_var_based_fixed_partition(cpi, x, mi_row, mi_col); |
| av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize); |
| } else if (sf->part_sf.partition_search_type == VAR_BASED_PARTITION) { |
| // set a variance-based partition |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); |
| av1_choose_var_based_partitioning(cpi, tile_info, td, x, mi_row, mi_col); |
| } |
| assert(sf->part_sf.partition_search_type == FIXED_PARTITION || seg_skip || |
| cpi->partition_search_skippable_frame || |
| sf->part_sf.partition_search_type == VAR_BASED_PARTITION); |
| set_cb_offsets(td->mb.cb_offset, 0, 0); |
| |
| // Adjust and encode the superblock |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| av1_nonrd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size, |
| pc_root); |
| av1_free_pc_tree_recursive(pc_root, av1_num_planes(cm), 0, 0); |
| } |
| |
| // 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) { |
| const AV1_COMMON *cm = &cpi->common; |
| const TileInfo *tile_info = &tile_data->tile_info; |
| MACROBLOCK *x = &td->mb; |
| |
| 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) { |
| init_simple_motion_search_mvs(sms_root); |
| } |
| |
| #if !CONFIG_REALTIME_ONLY |
| if (has_no_stats_stage(cpi) && cpi->oxcf.mode == REALTIME && |
| cpi->oxcf.gf_cfg.lag_in_frames == 0) { |
| (void)tile_info; |
| (void)mi_row; |
| (void)mi_col; |
| (void)gather_tpl_data; |
| } else { |
| init_ref_frame_space(cpi, td, mi_row, mi_col); |
| x->sb_energy_level = 0; |
| x->part_search_info.cnn_output_valid = 0; |
| if (gather_tpl_data) { |
| if (cm->delta_q_info.delta_q_present_flag) { |
| const int num_planes = av1_num_planes(cm); |
| const BLOCK_SIZE sb_size = cm->seq_params.sb_size; |
| setup_delta_q(cpi, td, x, tile_info, mi_row, mi_col, num_planes); |
| av1_tpl_rdmult_setup_sb(cpi, x, sb_size, mi_row, mi_col); |
| } |
| if (cpi->oxcf.algo_cfg.enable_tpl_model) { |
| adjust_rdmult_tpl_model(cpi, x, mi_row, mi_col); |
| } |
| } |
| } |
| #else |
| (void)tile_info; |
| (void)mi_row; |
| (void)mi_col; |
| (void)gather_tpl_data; |
| #endif |
| |
| // Reset hash state for transform/mode rd hash information |
| reset_hash_records(&x->txfm_search_info, cpi->sf.tx_sf.use_inter_txb_hash); |
| av1_zero(x->picked_ref_frames_mask); |
| av1_invalid_rd_stats(rd_cost); |
| } |
| |
| /*!\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 AOM_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) { |
| AV1_COMMON *const cm = &cpi->common; |
| MACROBLOCK *const x = &td->mb; |
| const SPEED_FEATURES *const sf = &cpi->sf; |
| const TileInfo *const tile_info = &tile_data->tile_info; |
| MB_MODE_INFO **mi = cm->mi_params.mi_grid_base + |
| get_mi_grid_idx(&cm->mi_params, mi_row, mi_col); |
| const BLOCK_SIZE sb_size = cm->seq_params.sb_size; |
| const int num_planes = av1_num_planes(cm); |
| int dummy_rate; |
| int64_t dummy_dist; |
| RD_STATS dummy_rdc; |
| SIMPLE_MOTION_DATA_TREE *const sms_root = td->sms_root; |
| |
| #if CONFIG_REALTIME_ONLY |
| (void)seg_skip; |
| #endif // CONFIG_REALTIME_ONLY |
| |
| init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row, mi_col, |
| 1); |
| |
| // Encode the superblock |
| if (sf->part_sf.partition_search_type == VAR_BASED_PARTITION) { |
| // partition search starting from a variance-based partition |
| av1_set_offsets_without_segment_id(cpi, tile_info, x, mi_row, mi_col, |
| sb_size); |
| av1_choose_var_based_partitioning(cpi, tile_info, td, x, mi_row, mi_col); |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size, |
| &dummy_rate, &dummy_dist, 1, pc_root); |
| av1_free_pc_tree_recursive(pc_root, num_planes, 0, 0); |
| } |
| #if !CONFIG_REALTIME_ONLY |
| else if (sf->part_sf.partition_search_type == FIXED_PARTITION || seg_skip) { |
| // partition search by adjusting a fixed-size partition |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); |
| const BLOCK_SIZE bsize = |
| seg_skip ? sb_size : sf->part_sf.fixed_partition_size; |
| av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize); |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size, |
| &dummy_rate, &dummy_dist, 1, pc_root); |
| av1_free_pc_tree_recursive(pc_root, num_planes, 0, 0); |
| } else if (cpi->partition_search_skippable_frame) { |
| // partition search by adjusting a fixed-size partition for which the size |
| // is determined by the source variance |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, sb_size); |
| const BLOCK_SIZE bsize = |
| get_rd_var_based_fixed_partition(cpi, x, mi_row, mi_col); |
| av1_set_fixed_partitioning(cpi, tile_info, mi, mi_row, mi_col, bsize); |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col, sb_size, |
| &dummy_rate, &dummy_dist, 1, pc_root); |
| av1_free_pc_tree_recursive(pc_root, num_planes, 0, 0); |
| } else { |
| // The most exhaustive recursive partition search |
| SuperBlockEnc *sb_enc = &x->sb_enc; |
| // No stats for overlay frames. Exclude key frame. |
| av1_get_tpl_stats_sb(cpi, sb_size, mi_row, mi_col, sb_enc); |
| |
| // Reset the tree for simple motion search data |
| av1_reset_simple_motion_tree_partition(sms_root, sb_size); |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, rd_pick_partition_time); |
| #endif |
| |
| // Estimate the maximum square partition block size, which will be used |
| // as the starting block size for partitioning the sb |
| set_max_min_partition_size(sb_enc, cpi, x, sf, sb_size, mi_row, mi_col); |
| |
| // The superblock can be searched only once, or twice consecutively for |
| // better quality. Note that the meaning of passes here is different from |
| // the general concept of 1-pass/2-pass encoders. |
| const int num_passes = |
| cpi->oxcf.unit_test_cfg.sb_multipass_unit_test ? 2 : 1; |
| |
| if (num_passes == 1) { |
| PC_TREE *const pc_root = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size, |
| &dummy_rdc, dummy_rdc, pc_root, sms_root, NULL, |
| SB_SINGLE_PASS, NULL); |
| } else { |
| // First pass |
| SB_FIRST_PASS_STATS sb_fp_stats; |
| av1_backup_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col); |
| PC_TREE *const pc_root_p0 = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size, |
| &dummy_rdc, dummy_rdc, pc_root_p0, sms_root, NULL, |
| SB_DRY_PASS, NULL); |
| |
| // Second pass |
| init_encode_rd_sb(cpi, td, tile_data, sms_root, &dummy_rdc, mi_row, |
| mi_col, 0); |
| av1_reset_mbmi(&cm->mi_params, sb_size, mi_row, mi_col); |
| av1_reset_simple_motion_tree_partition(sms_root, sb_size); |
| |
| av1_restore_sb_state(&sb_fp_stats, cpi, td, tile_data, mi_row, mi_col); |
| |
| PC_TREE *const pc_root_p1 = av1_alloc_pc_tree_node(sb_size); |
| av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size, |
| &dummy_rdc, dummy_rdc, pc_root_p1, sms_root, NULL, |
| SB_WET_PASS, NULL); |
| } |
| // Reset to 0 so that it wouldn't be used elsewhere mistakenly. |
| sb_enc->tpl_data_count = 0; |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, rd_pick_partition_time); |
| #endif |
| } |
| #endif // !CONFIG_REALTIME_ONLY |
| |
| // Update the inter rd model |
| // TODO(angiebird): Let inter_mode_rd_model_estimation support multi-tile. |
| if (cpi->sf.inter_sf.inter_mode_rd_model_estimation == 1 && |
| cm->tiles.cols == 1 && cm->tiles.rows == 1) { |
| av1_inter_mode_data_fit(tile_data, x->rdmult); |
| } |
| } |
| |
| /*!\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 AOM_INLINE void encode_sb_row(AV1_COMP *cpi, ThreadData *td, |
| TileDataEnc *tile_data, int mi_row, |
| TokenExtra **tp) { |
| AV1_COMMON *const cm = &cpi->common; |
| const TileInfo *const tile_info = &tile_data->tile_info; |
| MultiThreadInfo *const mt_info = &cpi->mt_info; |
| AV1EncRowMultiThreadInfo *const enc_row_mt = &mt_info->enc_row_mt; |
| AV1EncRowMultiThreadSync *const row_mt_sync = &tile_data->row_mt_sync; |
| bool row_mt_enabled = mt_info->row_mt_enabled; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int sb_cols_in_tile = av1_get_sb_cols_in_tile(cm, tile_data->tile_info); |
| const BLOCK_SIZE sb_size = cm->seq_params.sb_size; |
| const int mib_size = cm->seq_params.mib_size; |
| const int mib_size_log2 = cm->seq_params.mib_size_log2; |
| const int sb_row = (mi_row - tile_info->mi_row_start) >> mib_size_log2; |
| const int use_nonrd_mode = cpi->sf.rt_sf.use_nonrd_pick_mode; |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, encode_sb_row_time); |
| #endif |
| |
| // Initialize the left context for the new SB row |
| av1_zero_left_context(xd); |
| |
| // Reset delta for quantizer and loof filters at the beginning of every tile |
| if (mi_row == tile_info->mi_row_start || row_mt_enabled) { |
| if (cm->delta_q_info.delta_q_present_flag) |
| xd->current_base_qindex = cm->quant_params.base_qindex; |
| if (cm->delta_q_info.delta_lf_present_flag) { |
| av1_reset_loop_filter_delta(xd, av1_num_planes(cm)); |
| } |
| } |
| |
| reset_thresh_freq_fact(x); |
| |
| // Code each SB in the row |
| for (int mi_col = tile_info->mi_col_start, sb_col_in_tile = 0; |
| mi_col < tile_info->mi_col_end; mi_col += mib_size, sb_col_in_tile++) { |
| (*(enc_row_mt->sync_read_ptr))(row_mt_sync, sb_row, sb_col_in_tile); |
| |
| if (tile_data->allow_update_cdf && row_mt_enabled && |
| (tile_info->mi_row_start != mi_row)) { |
| if ((tile_info->mi_col_start == mi_col)) { |
| // restore frame context at the 1st column sb |
| memcpy(xd->tile_ctx, x->row_ctx, sizeof(*xd->tile_ctx)); |
| } else { |
| if (!cpi->sf.rt_sf.use_nonrd_pick_mode || |
| cpi->oxcf.cost_upd_freq.coeff < 2 || |
| cpi->oxcf.cost_upd_freq.mode < 2 || |
| cpi->oxcf.cost_upd_freq.mv < 2) { |
| // update context |
| int wt_left = AVG_CDF_WEIGHT_LEFT; |
| int wt_tr = AVG_CDF_WEIGHT_TOP_RIGHT; |
| if (tile_info->mi_col_end > (mi_col + mib_size)) |
| av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile, |
| wt_left, wt_tr); |
| else |
| av1_avg_cdf_symbols(xd->tile_ctx, x->row_ctx + sb_col_in_tile - 1, |
| wt_left, wt_tr); |
| } |
| } |
| } |
| |
| // Update the rate cost tables for some symbols |
| av1_set_cost_upd_freq(cpi, td, tile_info, mi_row, mi_col); |
| |
| // Reset color coding related parameters |
| x->color_sensitivity[0] = 0; |
| x->color_sensitivity[1] = 0; |
| x->content_state_sb.source_sad = kMedSad; |
| x->content_state_sb.lighting_change = 0; |
| x->content_state_sb.low_sumdiff = 0; |
| |
| xd->cur_frame_force_integer_mv = cm->features.cur_frame_force_integer_mv; |
| x->source_variance = UINT_MAX; |
| td->mb.cb_coef_buff = av1_get_cb_coeff_buffer(cpi, mi_row, mi_col); |
| |
| // Get segment id and skip flag |
| const struct segmentation *const seg = &cm->seg; |
| int seg_skip = 0; |
| if (seg->enabled) { |
| const uint8_t *const map = |
| seg->update_map ? cpi->enc_seg.map : cm->last_frame_seg_map; |
| const int segment_id = |
| map ? get_segment_id(&cm->mi_params, map, sb_size, mi_row, mi_col) |
| : 0; |
| seg_skip = segfeature_active(seg, segment_id, SEG_LVL_SKIP); |
| } |
| |
| // encode the superblock |
| if (use_nonrd_mode) { |
| encode_nonrd_sb(cpi, td, tile_data, tp, mi_row, mi_col, seg_skip); |
| } else { |
| encode_rd_sb(cpi, td, tile_data, tp, mi_row, mi_col, seg_skip); |
| } |
| |
| // Update the top-right context in row_mt coding |
| if (tile_data->allow_update_cdf && row_mt_enabled && |
| (tile_info->mi_row_end > (mi_row + mib_size))) { |
| if (sb_cols_in_tile == 1) |
| memcpy(x->row_ctx, xd->tile_ctx, sizeof(*xd->tile_ctx)); |
| else if (sb_col_in_tile >= 1) |
| memcpy(x->row_ctx + sb_col_in_tile - 1, xd->tile_ctx, |
| sizeof(*xd->tile_ctx)); |
| } |
| (*(enc_row_mt->sync_write_ptr))(row_mt_sync, sb_row, sb_col_in_tile, |
| sb_cols_in_tile); |
| } |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, encode_sb_row_time); |
| #endif |
| } |
| |
| static AOM_INLINE void init_encode_frame_mb_context(AV1_COMP *cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCK *const x = &cpi->td.mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| |
| // Copy data over into macro block data structures. |
| av1_setup_src_planes(x, cpi->source, 0, 0, num_planes, |
| cm->seq_params.sb_size); |
| |
| av1_setup_block_planes(xd, cm->seq_params.subsampling_x, |
| cm->seq_params.subsampling_y, num_planes); |
| } |
| |
| void av1_alloc_tile_data(AV1_COMP *cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int tile_cols = cm->tiles.cols; |
| const int tile_rows = cm->tiles.rows; |
| |
| if (cpi->tile_data != NULL) aom_free(cpi->tile_data); |
| CHECK_MEM_ERROR( |
| cm, cpi->tile_data, |
| aom_memalign(32, tile_cols * tile_rows * sizeof(*cpi->tile_data))); |
| |
| cpi->allocated_tiles = tile_cols * tile_rows; |
| } |
| |
| void av1_init_tile_data(AV1_COMP *cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| const int tile_cols = cm->tiles.cols; |
| const int tile_rows = cm->tiles.rows; |
| int tile_col, tile_row; |
| TokenInfo *const token_info = &cpi->token_info; |
| TokenExtra *pre_tok = token_info->tile_tok[0][0]; |
| TokenList *tplist = token_info->tplist[0][0]; |
| unsigned int tile_tok = 0; |
| int tplist_count = 0; |
| |
| for (tile_row = 0; tile_row < tile_rows; ++tile_row) { |
| for (tile_col = 0; tile_col < tile_cols; ++tile_col) { |
| TileDataEnc *const tile_data = |
| &cpi->tile_data[tile_row * tile_cols + tile_col]; |
| TileInfo *const tile_info = &tile_data->tile_info; |
| av1_tile_init(tile_info, cm, tile_row, tile_col); |
| tile_data->firstpass_top_mv = kZeroMv; |
| |
| if (pre_tok != NULL && tplist != NULL) { |
| token_info->tile_tok[tile_row][tile_col] = pre_tok + tile_tok; |
| pre_tok = token_info->tile_tok[tile_row][tile_col]; |
| tile_tok = allocated_tokens(*tile_info, |
| cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, |
| num_planes); |
| token_info->tplist[tile_row][tile_col] = tplist + tplist_count; |
| tplist = token_info->tplist[tile_row][tile_col]; |
| tplist_count = av1_get_sb_rows_in_tile(cm, tile_data->tile_info); |
| } |
| tile_data->allow_update_cdf = !cm->tiles.large_scale; |
| tile_data->allow_update_cdf = |
| tile_data->allow_update_cdf && !cm->features.disable_cdf_update; |
| tile_data->tctx = *cm->fc; |
| } |
| } |
| } |
| |
| /*!\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) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| const int tile_cols = cm->tiles.cols; |
| TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col]; |
| const TileInfo *const tile_info = &this_tile->tile_info; |
| TokenExtra *tok = NULL; |
| TokenList *const tplist = cpi->token_info.tplist[tile_row][tile_col]; |
| const int sb_row_in_tile = |
| (mi_row - tile_info->mi_row_start) >> cm->seq_params.mib_size_log2; |
| const int tile_mb_cols = |
| (tile_info->mi_col_end - tile_info->mi_col_start + 2) >> 2; |
| const int num_mb_rows_in_sb = |
| ((1 << (cm->seq_params.mib_size_log2 + MI_SIZE_LOG2)) + 8) >> 4; |
| |
| get_start_tok(cpi, tile_row, tile_col, mi_row, &tok, |
| cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, num_planes); |
| tplist[sb_row_in_tile].start = tok; |
| |
| encode_sb_row(cpi, td, this_tile, mi_row, &tok); |
| |
| tplist[sb_row_in_tile].count = |
| (unsigned int)(tok - tplist[sb_row_in_tile].start); |
| |
| assert((unsigned int)(tok - tplist[sb_row_in_tile].start) <= |
| get_token_alloc(num_mb_rows_in_sb, tile_mb_cols, |
| cm->seq_params.mib_size_log2 + MI_SIZE_LOG2, |
| num_planes)); |
| |
| (void)tile_mb_cols; |
| (void)num_mb_rows_in_sb; |
| } |
| |
| /*!\brief Encode a tile |
| * |
| * \ingroup partition_search |
| */ |
| void av1_encode_tile(AV1_COMP *cpi, ThreadData *td, int tile_row, |
| int tile_col) { |
| AV1_COMMON *const cm = &cpi->common; |
| TileDataEnc *const this_tile = |
| &cpi->tile_data[tile_row * cm->tiles.cols + tile_col]; |
| const TileInfo *const tile_info = &this_tile->tile_info; |
| |
| if (!cpi->sf.rt_sf.use_nonrd_pick_mode) av1_inter_mode_data_init(this_tile); |
| |
| av1_zero_above_context(cm, &td->mb.e_mbd, tile_info->mi_col_start, |
| tile_info->mi_col_end, tile_row); |
| av1_init_above_context(&cm->above_contexts, av1_num_planes(cm), tile_row, |
| &td->mb.e_mbd); |
| |
| if (cpi->oxcf.intra_mode_cfg.enable_cfl_intra) |
| cfl_init(&td->mb.e_mbd.cfl, &cm->seq_params); |
| |
| if (td->mb.txfm_search_info.txb_rd_records != NULL) { |
| av1_crc32c_calculator_init( |
| &td->mb.txfm_search_info.txb_rd_records->mb_rd_record.crc_calculator); |
| } |
| |
| for (int mi_row = tile_info->mi_row_start; mi_row < tile_info->mi_row_end; |
| mi_row += cm->seq_params.mib_size) { |
| av1_encode_sb_row(cpi, td, tile_row, tile_col, mi_row); |
| } |
| } |
| |
| /*!\brief Break one frame into tiles and encode the tiles |
| * |
| * \ingroup partition_search |
| * |
| * \param[in] cpi Top-level encoder structure |
| */ |
| static AOM_INLINE void encode_tiles(AV1_COMP *cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int tile_cols = cm->tiles.cols; |
| const int tile_rows = cm->tiles.rows; |
| int tile_col, tile_row; |
| |
| assert(IMPLIES(cpi->tile_data == NULL, |
| cpi->allocated_tiles < tile_cols * tile_rows)); |
| if (cpi->allocated_tiles < tile_cols * tile_rows) av1_alloc_tile_data(cpi); |
| |
| av1_init_tile_data(cpi); |
| if (!cpi->sf.rt_sf.use_nonrd_pick_mode) { |
| cpi->td.mb.txfm_search_info.txb_rd_records = |
| (TxbRdRecords *)aom_malloc(sizeof(TxbRdRecords)); |
| } |
| |
| for (tile_row = 0; tile_row < tile_rows; ++tile_row) { |
| for (tile_col = 0; tile_col < tile_cols; ++tile_col) { |
| TileDataEnc *const this_tile = |
| &cpi->tile_data[tile_row * cm->tiles.cols + tile_col]; |
| cpi->td.intrabc_used = 0; |
| cpi->td.deltaq_used = 0; |
| cpi->td.mb.e_mbd.tile_ctx = &this_tile->tctx; |
| cpi->td.mb.tile_pb_ctx = &this_tile->tctx; |
| av1_encode_tile(cpi, &cpi->td, tile_row, tile_col); |
| cpi->intrabc_used |= cpi->td.intrabc_used; |
| cpi->deltaq_used |= cpi->td.deltaq_used; |
| } |
| } |
| |
| if (cpi->td.mb.txfm_search_info.txb_rd_records) { |
| aom_free(cpi->td.mb.txfm_search_info.txb_rd_records); |
| cpi->td.mb.txfm_search_info.txb_rd_records = NULL; |
| } |
| } |
| |
| // Set the relative distance of a reference frame w.r.t. current frame |
| static AOM_INLINE void set_rel_frame_dist( |
| const AV1_COMMON *const cm, RefFrameDistanceInfo *const ref_frame_dist_info, |
| const int ref_frame_flags) { |
| MV_REFERENCE_FRAME ref_frame; |
| int min_past_dist = INT32_MAX, min_future_dist = INT32_MAX; |
| ref_frame_dist_info->nearest_past_ref = NONE_FRAME; |
| ref_frame_dist_info->nearest_future_ref = NONE_FRAME; |
| for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { |
| ref_frame_dist_info->ref_relative_dist[ref_frame - LAST_FRAME] = 0; |
| if (ref_frame_flags & av1_ref_frame_flag_list[ref_frame]) { |
| int dist = av1_encoder_get_relative_dist( |
| cm->cur_frame->ref_display_order_hint[ref_frame - LAST_FRAME], |
| cm->current_frame.display_order_hint); |
| ref_frame_dist_info->ref_relative_dist[ref_frame - LAST_FRAME] = dist; |
| // Get the nearest ref_frame in the past |
| if (abs(dist) < min_past_dist && dist < 0) { |
| ref_frame_dist_info->nearest_past_ref = ref_frame; |
| min_past_dist = abs(dist); |
| } |
| // Get the nearest ref_frame in the future |
| if (dist < min_future_dist && dist > 0) { |
| ref_frame_dist_info->nearest_future_ref = ref_frame; |
| min_future_dist = dist; |
| } |
| } |
| } |
| } |
| |
| static INLINE int refs_are_one_sided(const AV1_COMMON *cm) { |
| assert(!frame_is_intra_only(cm)); |
| |
| int one_sided_refs = 1; |
| const int cur_display_order_hint = cm->current_frame.display_order_hint; |
| for (int ref = LAST_FRAME; ref <= ALTREF_FRAME; ++ref) { |
| const RefCntBuffer *const buf = get_ref_frame_buf(cm, ref); |
| if (buf == NULL) continue; |
| if (av1_encoder_get_relative_dist(buf->display_order_hint, |
| cur_display_order_hint) > 0) { |
| one_sided_refs = 0; // bwd reference |
| break; |
| } |
| } |
| return one_sided_refs; |
| } |
| |
| static INLINE void get_skip_mode_ref_offsets(const AV1_COMMON *cm, |
| int ref_order_hint[2]) { |
| const SkipModeInfo *const skip_mode_info = &cm->current_frame.skip_mode_info; |
| ref_order_hint[0] = ref_order_hint[1] = 0; |
| if (!skip_mode_info->skip_mode_allowed) return; |
| |
| const RefCntBuffer *const buf_0 = |
| get_ref_frame_buf(cm, LAST_FRAME + skip_mode_info->ref_frame_idx_0); |
| const RefCntBuffer *const buf_1 = |
| get_ref_frame_buf(cm, LAST_FRAME + skip_mode_info->ref_frame_idx_1); |
| assert(buf_0 != NULL && buf_1 != NULL); |
| |
| ref_order_hint[0] = buf_0->order_hint; |
| ref_order_hint[1] = buf_1->order_hint; |
| } |
| |
| static int check_skip_mode_enabled(AV1_COMP *const cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| |
| av1_setup_skip_mode_allowed(cm); |
| if (!cm->current_frame.skip_mode_info.skip_mode_allowed) return 0; |
| |
| // Turn off skip mode if the temporal distances of the reference pair to the |
| // current frame are different by more than 1 frame. |
| const int cur_offset = (int)cm->current_frame.order_hint; |
| int ref_offset[2]; |
| get_skip_mode_ref_offsets(cm, ref_offset); |
| const int cur_to_ref0 = get_relative_dist(&cm->seq_params.order_hint_info, |
| cur_offset, ref_offset[0]); |
| const int cur_to_ref1 = abs(get_relative_dist(&cm->seq_params.order_hint_info, |
| cur_offset, ref_offset[1])); |
| if (abs(cur_to_ref0 - cur_to_ref1) > 1) return 0; |
| |
| // High Latency: Turn off skip mode if all refs are fwd. |
| if (cpi->all_one_sided_refs && cpi->oxcf.gf_cfg.lag_in_frames > 0) return 0; |
| |
| static const int flag_list[REF_FRAMES] = { 0, |
| AOM_LAST_FLAG, |
| AOM_LAST2_FLAG, |
| AOM_LAST3_FLAG, |
| AOM_GOLD_FLAG, |
| AOM_BWD_FLAG, |
| AOM_ALT2_FLAG, |
| AOM_ALT_FLAG }; |
| const int ref_frame[2] = { |
| cm->current_frame.skip_mode_info.ref_frame_idx_0 + LAST_FRAME, |
| cm->current_frame.skip_mode_info.ref_frame_idx_1 + LAST_FRAME |
| }; |
| if (!(cpi->ref_frame_flags & flag_list[ref_frame[0]]) || |
| !(cpi->ref_frame_flags & flag_list[ref_frame[1]])) |
| return 0; |
| |
| return 1; |
| } |
| |
| static AOM_INLINE void set_default_interp_skip_flags( |
| const AV1_COMMON *cm, InterpSearchFlags *interp_search_flags) { |
| const int num_planes = av1_num_planes(cm); |
| interp_search_flags->default_interp_skip_flags = |
| (num_planes == 1) ? INTERP_SKIP_LUMA_EVAL_CHROMA |
| : INTERP_SKIP_LUMA_SKIP_CHROMA; |
| } |
| |
| static AOM_INLINE void setup_prune_ref_frame_mask(AV1_COMP *cpi) { |
| if ((!cpi->oxcf.ref_frm_cfg.enable_onesided_comp || |
| cpi->sf.inter_sf.disable_onesided_comp) && |
| cpi->all_one_sided_refs) { |
| // Disable all compound references |
| cpi->prune_ref_frame_mask = (1 << MODE_CTX_REF_FRAMES) - (1 << REF_FRAMES); |
| } else if (!cpi->sf.rt_sf.use_nonrd_pick_mode && |
| cpi->sf.inter_sf.selective_ref_frame >= 2) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int cur_frame_display_order_hint = |
| cm->current_frame.display_order_hint; |
| unsigned int *ref_display_order_hint = |
| cm->cur_frame->ref_display_order_hint; |
| const int arf2_dist = av1_encoder_get_relative_dist( |
| ref_display_order_hint[ALTREF2_FRAME - LAST_FRAME], |
| cur_frame_display_order_hint); |
| const int bwd_dist = av1_encoder_get_relative_dist( |
| ref_display_order_hint[BWDREF_FRAME - LAST_FRAME], |
| cur_frame_display_order_hint); |
| |
| for (int ref_idx = REF_FRAMES; ref_idx < MODE_CTX_REF_FRAMES; ++ref_idx) { |
| MV_REFERENCE_FRAME rf[2]; |
| av1_set_ref_frame(rf, ref_idx); |
| if (!(cpi->ref_frame_flags & av1_ref_frame_flag_list[rf[0]]) || |
| !(cpi->ref_frame_flags & av1_ref_frame_flag_list[rf[1]])) { |
| continue; |
| } |
| |
| if (!cpi->all_one_sided_refs) { |
| int ref_dist[2]; |
| for (int i = 0; i < 2; ++i) { |
| ref_dist[i] = av1_encoder_get_relative_dist( |
| ref_display_order_hint[rf[i] - LAST_FRAME], |
| cur_frame_display_order_hint); |
| } |
| |
| // One-sided compound is used only when all reference frames are |
| // one-sided. |
| if ((ref_dist[0] > 0) == (ref_dist[1] > 0)) { |
| cpi->prune_ref_frame_mask |= 1 << ref_idx; |
| } |
| } |
| |
| if (cpi->sf.inter_sf.selective_ref_frame >= 4 && |
| (rf[0] == ALTREF2_FRAME || rf[1] == ALTREF2_FRAME) && |
| (cpi->ref_frame_flags & av1_ref_frame_flag_list[BWDREF_FRAME])) { |
| // Check if both ALTREF2_FRAME and BWDREF_FRAME are future references. |
| if (arf2_dist > 0 && bwd_dist > 0 && bwd_dist <= arf2_dist) { |
| // Drop ALTREF2_FRAME as a reference if BWDREF_FRAME is a closer |
| // reference to the current frame than ALTREF2_FRAME |
| cpi->prune_ref_frame_mask |= 1 << ref_idx; |
| } |
| } |
| } |
| } |
| } |
| |
| /*!\brief Encoder setup(only for the current frame), encoding, and recontruction |
| * for a single frame |
| * |
| * \ingroup high_level_algo |
| */ |
| static AOM_INLINE void encode_frame_internal(AV1_COMP *cpi) { |
| ThreadData *const td = &cpi->td; |
| MACROBLOCK *const x = &td->mb; |
| AV1_COMMON *const cm = &cpi->common; |
| CommonModeInfoParams *const mi_params = &cm->mi_params; |
| FeatureFlags *const features = &cm->features; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| RD_COUNTS *const rdc = &cpi->td.rd_counts; |
| FrameProbInfo *const frame_probs = &cpi->frame_probs; |
| IntraBCHashInfo *const intrabc_hash_info = &x->intrabc_hash_info; |
| MultiThreadInfo *const mt_info = &cpi->mt_info; |
| AV1EncRowMultiThreadInfo *const enc_row_mt = &mt_info->enc_row_mt; |
| const AV1EncoderConfig *const oxcf = &cpi->oxcf; |
| const DELTAQ_MODE deltaq_mode = oxcf->q_cfg.deltaq_mode; |
| int i; |
| |
| if (!cpi->sf.rt_sf.use_nonrd_pick_mode) { |
| mi_params->setup_mi(mi_params); |
| } |
| |
| set_mi_offsets(mi_params, xd, 0, 0); |
| |
| av1_zero(*td->counts); |
| av1_zero(rdc->comp_pred_diff); |
| av1_zero(rdc->tx_type_used); |
| av1_zero(rdc->obmc_used); |
| av1_zero(rdc->warped_used); |
| |
| // Reset the flag. |
| cpi->intrabc_used = 0; |
| // Need to disable intrabc when superres is selected |
| if (av1_superres_scaled(cm)) { |
| features->allow_intrabc = 0; |
| } |
| |
| features->allow_intrabc &= (oxcf->kf_cfg.enable_intrabc); |
| |
| if (features->allow_warped_motion && |
| cpi->sf.inter_sf.prune_warped_prob_thresh > 0) { |
| const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group); |
| if (frame_probs->warped_probs[update_type] < |
| cpi->sf.inter_sf.prune_warped_prob_thresh) |
| features->allow_warped_motion = 0; |
| } |
| |
| int hash_table_created = 0; |
| if (!is_stat_generation_stage(cpi) && av1_use_hash_me(cpi) && |
| !cpi->sf.rt_sf.use_nonrd_pick_mode) { |
| // TODO(any): move this outside of the recoding loop to avoid recalculating |
| // the hash table. |
| // add to hash table |
| const int pic_width = cpi->source->y_crop_width; |
| const int pic_height = cpi->source->y_crop_height; |
| uint32_t *block_hash_values[2][2]; |
| int8_t *is_block_same[2][3]; |
| int k, j; |
| |
| for (k = 0; k < 2; k++) { |
| for (j = 0; j < 2; j++) { |
| CHECK_MEM_ERROR(cm, block_hash_values[k][j], |
| aom_malloc(sizeof(uint32_t) * pic_width * pic_height)); |
| } |
| |
| for (j = 0; j < 3; j++) { |
| CHECK_MEM_ERROR(cm, is_block_same[k][j], |
| aom_malloc(sizeof(int8_t) * pic_width * pic_height)); |
| } |
| } |
| |
| av1_hash_table_init(intrabc_hash_info); |
| av1_hash_table_create(&intrabc_hash_info->intrabc_hash_table); |
| hash_table_created = 1; |
| av1_generate_block_2x2_hash_value(intrabc_hash_info, cpi->source, |
| block_hash_values[0], is_block_same[0]); |
| // Hash data generated for screen contents is used for intraBC ME |
| const int min_alloc_size = block_size_wide[mi_params->mi_alloc_bsize]; |
| const int max_sb_size = |
| (1 << (cm->seq_params.mib_size_log2 + MI_SIZE_LOG2)); |
| int src_idx = 0; |
| for (int size = 4; size <= max_sb_size; size *= 2, src_idx = !src_idx) { |
| const int dst_idx = !src_idx; |
| av1_generate_block_hash_value( |
| intrabc_hash_info, cpi->source, size, block_hash_values[src_idx], |
| block_hash_values[dst_idx], is_block_same[src_idx], |
| is_block_same[dst_idx]); |
| if (size >= min_alloc_size) { |
| av1_add_to_hash_map_by_row_with_precal_data( |
| &intrabc_hash_info->intrabc_hash_table, block_hash_values[dst_idx], |
| is_block_same[dst_idx][2], pic_width, pic_height, size); |
| } |
| } |
| |
| for (k = 0; k < 2; k++) { |
| for (j = 0; j < 2; j++) { |
| aom_free(block_hash_values[k][j]); |
| } |
| |
| for (j = 0; j < 3; j++) { |
| aom_free(is_block_same[k][j]); |
| } |
| } |
| } |
| |
| const CommonQuantParams *quant_params = &cm->quant_params; |
| for (i = 0; i < MAX_SEGMENTS; ++i) { |
| const int qindex = |
| cm->seg.enabled ? av1_get_qindex(&cm->seg, i, quant_params->base_qindex) |
| : quant_params->base_qindex; |
| xd->lossless[i] = |
| qindex == 0 && quant_params->y_dc_delta_q == 0 && |
| quant_params->u_dc_delta_q == 0 && quant_params->u_ac_delta_q == 0 && |
| quant_params->v_dc_delta_q == 0 && quant_params->v_ac_delta_q == 0; |
| if (xd->lossless[i]) cpi->enc_seg.has_lossless_segment = 1; |
| xd->qindex[i] = qindex; |
| if (xd->lossless[i]) { |
| cpi->optimize_seg_arr[i] = NO_TRELLIS_OPT; |
| } else { |
| cpi->optimize_seg_arr[i] = cpi->sf.rd_sf.optimize_coefficients; |
| } |
| } |
| features->coded_lossless = is_coded_lossless(cm, xd); |
| features->all_lossless = features->coded_lossless && !av1_superres_scaled(cm); |
| |
| // Fix delta q resolution for the moment |
| cm->delta_q_info.delta_q_res = 0; |
| if (cpi->oxcf.q_cfg.aq_mode != CYCLIC_REFRESH_AQ) { |
| if (deltaq_mode == DELTA_Q_OBJECTIVE) |
| cm->delta_q_info.delta_q_res = DEFAULT_DELTA_Q_RES_OBJECTIVE; |
| else if (deltaq_mode == DELTA_Q_PERCEPTUAL) |
| cm->delta_q_info.delta_q_res = DEFAULT_DELTA_Q_RES_PERCEPTUAL; |
| // Set delta_q_present_flag before it is used for the first time |
| cm->delta_q_info.delta_lf_res = DEFAULT_DELTA_LF_RES; |
| cm->delta_q_info.delta_q_present_flag = deltaq_mode != NO_DELTA_Q; |
| |
| // Turn off cm->delta_q_info.delta_q_present_flag if objective delta_q |
| // is used for ineligible frames. That effectively will turn off row_mt |
| // usage. Note objective delta_q and tpl eligible frames are only altref |
| // frames currently. |
| const GF_GROUP *gf_group = &cpi->gf_group; |
| if (cm->delta_q_info.delta_q_present_flag) { |
| if (deltaq_mode == DELTA_Q_OBJECTIVE && |
| !is_frame_tpl_eligible(gf_group, gf_group->index)) |
| cm->delta_q_info.delta_q_present_flag = 0; |
| } |
| |
| // Reset delta_q_used flag |
| cpi->deltaq_used = 0; |
| |
| cm->delta_q_info.delta_lf_present_flag = |
| cm->delta_q_info.delta_q_present_flag && |
| oxcf->tool_cfg.enable_deltalf_mode; |
| cm->delta_q_info.delta_lf_multi = DEFAULT_DELTA_LF_MULTI; |
| |
| // update delta_q_present_flag and delta_lf_present_flag based on |
| // base_qindex |
| cm->delta_q_info.delta_q_present_flag &= quant_params->base_qindex > 0; |
| cm->delta_q_info.delta_lf_present_flag &= quant_params->base_qindex > 0; |
| } |
| |
| av1_frame_init_quantizer(cpi); |
| |
| init_encode_frame_mb_context(cpi); |
| set_default_interp_skip_flags(cm, &cpi->interp_search_flags); |
| if (cm->prev_frame && cm->prev_frame->seg.enabled) |
| cm->last_frame_seg_map = cm->prev_frame->seg_map; |
| else |
| cm->last_frame_seg_map = NULL; |
| if (features->allow_intrabc || features->coded_lossless) { |
| av1_set_default_ref_deltas(cm->lf.ref_deltas); |
| av1_set_default_mode_deltas(cm->lf.mode_deltas); |
| } else if (cm->prev_frame) { |
| memcpy(cm->lf.ref_deltas, cm->prev_frame->ref_deltas, REF_FRAMES); |
| memcpy(cm->lf.mode_deltas, cm->prev_frame->mode_deltas, MAX_MODE_LF_DELTAS); |
| } |
| memcpy(cm->cur_frame->ref_deltas, cm->lf.ref_deltas, REF_FRAMES); |
| memcpy(cm->cur_frame->mode_deltas, cm->lf.mode_deltas, MAX_MODE_LF_DELTAS); |
| |
| cpi->all_one_sided_refs = |
| frame_is_intra_only(cm) ? 0 : refs_are_one_sided(cm); |
| |
| cpi->prune_ref_frame_mask = 0; |
| // Figure out which ref frames can be skipped at frame level. |
| setup_prune_ref_frame_mask(cpi); |
| |
| x->txfm_search_info.txb_split_count = 0; |
| #if CONFIG_SPEED_STATS |
| x->txfm_search_info.tx_search_count = 0; |
| #endif // CONFIG_SPEED_STATS |
| |
| #if !CONFIG_REALTIME_ONLY |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, av1_compute_global_motion_time); |
| #endif |
| av1_compute_global_motion_facade(cpi); |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, av1_compute_global_motion_time); |
| #endif |
| #endif // !CONFIG_REALTIME_ONLY |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, av1_setup_motion_field_time); |
| #endif |
| if (features->allow_ref_frame_mvs) av1_setup_motion_field(cm); |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, av1_setup_motion_field_time); |
| #endif |
| |
| cm->current_frame.skip_mode_info.skip_mode_flag = |
| check_skip_mode_enabled(cpi); |
| |
| // Initialization of skip mode cost depends on the value of |
| // 'skip_mode_flag'. This initialization happens in the function |
| // av1_fill_mode_rates(), which is in turn called in |
| // av1_initialize_rd_consts(). Thus, av1_initialize_rd_consts() |
| // has to be called after 'skip_mode_flag' is initialized. |
| av1_initialize_rd_consts(cpi); |
| av1_set_sad_per_bit(cpi, &x->sadperbit, quant_params->base_qindex); |
| |
| enc_row_mt->sync_read_ptr = av1_row_mt_sync_read_dummy; |
| enc_row_mt->sync_write_ptr = av1_row_mt_sync_write_dummy; |
| mt_info->row_mt_enabled = 0; |
| |
| if (oxcf->row_mt && (mt_info->num_workers > 1)) { |
| mt_info->row_mt_enabled = 1; |
| enc_row_mt->sync_read_ptr = av1_row_mt_sync_read; |
| enc_row_mt->sync_write_ptr = av1_row_mt_sync_write; |
| av1_encode_tiles_row_mt(cpi); |
| } else { |
| if (AOMMIN(mt_info->num_workers, cm->tiles.cols * cm->tiles.rows) > 1) |
| av1_encode_tiles_mt(cpi); |
| else |
| encode_tiles(cpi); |
| } |
| |
| // If intrabc is allowed but never selected, reset the allow_intrabc flag. |
| if (features->allow_intrabc && !cpi->intrabc_used) { |
| features->allow_intrabc = 0; |
| } |
| if (features->allow_intrabc) { |
| cm->delta_q_info.delta_lf_present_flag = 0; |
| } |
| |
| if (cm->delta_q_info.delta_q_present_flag && cpi->deltaq_used == 0) { |
| cm->delta_q_info.delta_q_present_flag = 0; |
| } |
| |
| // Set the transform size appropriately before bitstream creation |
| const MODE_EVAL_TYPE eval_type = |
| cpi->sf.winner_mode_sf.enable_winner_mode_for_tx_size_srch |
| ? WINNER_MODE_EVAL |
| : DEFAULT_EVAL; |
| const TX_SIZE_SEARCH_METHOD tx_search_type = |
| cpi->winner_mode_params.tx_size_search_methods[eval_type]; |
| assert(oxcf->txfm_cfg.enable_tx64 || tx_search_type != USE_LARGESTALL); |
| features->tx_mode = select_tx_mode(cm, tx_search_type); |
| |
| if (cpi->sf.tx_sf.tx_type_search.prune_tx_type_using_stats) { |
| const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group); |
| |
| for (i = 0; i < TX_SIZES_ALL; i++) { |
| int sum = 0; |
| int j; |
| int left = 1024; |
| |
| for (j = 0; j < TX_TYPES; j++) |
| sum += cpi->td.rd_counts.tx_type_used[i][j]; |
| |
| for (j = TX_TYPES - 1; j >= 0; j--) { |
| const int new_prob = |
| sum ? 1024 * cpi->td.rd_counts.tx_type_used[i][j] / sum |
| : (j ? 0 : 1024); |
| int prob = |
| (frame_probs->tx_type_probs[update_type][i][j] + new_prob) >> 1; |
| left -= prob; |
| if (j == 0) prob += left; |
| frame_probs->tx_type_probs[update_type][i][j] = prob; |
| } |
| } |
| } |
| |
| if (cpi->sf.inter_sf.prune_obmc_prob_thresh > 0 && |
| cpi->sf.inter_sf.prune_obmc_prob_thresh < INT_MAX) { |
| const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group); |
| |
| for (i = 0; i < BLOCK_SIZES_ALL; i++) { |
| int sum = 0; |
| for (int j = 0; j < 2; j++) sum += cpi->td.rd_counts.obmc_used[i][j]; |
| |
| const int new_prob = |
| sum ? 128 * cpi->td.rd_counts.obmc_used[i][1] / sum : 0; |
| frame_probs->obmc_probs[update_type][i] = |
| (frame_probs->obmc_probs[update_type][i] + new_prob) >> 1; |
| } |
| } |
| |
| if (features->allow_warped_motion && |
| cpi->sf.inter_sf.prune_warped_prob_thresh > 0) { |
| const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group); |
| int sum = 0; |
| for (i = 0; i < 2; i++) sum += cpi->td.rd_counts.warped_used[i]; |
| const int new_prob = sum ? 128 * cpi->td.rd_counts.warped_used[1] / sum : 0; |
| frame_probs->warped_probs[update_type] = |
| (frame_probs->warped_probs[update_type] + new_prob) >> 1; |
| } |
| |
| if (cm->current_frame.frame_type != KEY_FRAME && |
| cpi->sf.interp_sf.adaptive_interp_filter_search == 2 && |
| features->interp_filter == SWITCHABLE) { |
| const FRAME_UPDATE_TYPE update_type = get_frame_update_type(&cpi->gf_group); |
| |
| for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; i++) { |
| int sum = 0; |
| int j; |
| int left = 1536; |
| |
| for (j = 0; j < SWITCHABLE_FILTERS; j++) { |
| sum += cpi->td.counts->switchable_interp[i][j]; |
| } |
| |
| for (j = SWITCHABLE_FILTERS - 1; j >= 0; j--) { |
| const int new_prob = |
| sum ? 1536 * cpi->td.counts->switchable_interp[i][j] / sum |
| : (j ? 0 : 1536); |
| int prob = (frame_probs->switchable_interp_probs[update_type][i][j] + |
| new_prob) >> |
| 1; |
| left -= prob; |
| if (j == 0) prob += left; |
| frame_probs->switchable_interp_probs[update_type][i][j] = prob; |
| } |
| } |
| } |
| if (hash_table_created) { |
| av1_hash_table_destroy(&intrabc_hash_info->intrabc_hash_table); |
| } |
| } |
| |
| /*!\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) { |
| AV1_COMMON *const cm = &cpi->common; |
| CurrentFrame *const current_frame = &cm->current_frame; |
| FeatureFlags *const features = &cm->features; |
| const int num_planes = av1_num_planes(cm); |
| // Indicates whether or not to use a default reduced set for ext-tx |
| // rather than the potential full set of 16 transforms |
| features->reduced_tx_set_used = cpi->oxcf.txfm_cfg.reduced_tx_type_set; |
| |
| // Make sure segment_id is no larger than last_active_segid. |
| if (cm->seg.enabled && cm->seg.update_map) { |
| const int mi_rows = cm->mi_params.mi_rows; |
| const int mi_cols = cm->mi_params.mi_cols; |
| const int last_active_segid = cm->seg.last_active_segid; |
| uint8_t *map = cpi->enc_seg.map; |
| for (int mi_row = 0; mi_row < mi_rows; ++mi_row) { |
| for (int mi_col = 0; mi_col < mi_cols; ++mi_col) { |
| map[mi_col] = AOMMIN(map[mi_col], last_active_segid); |
| } |
| map += mi_cols; |
| } |
| } |
| |
| av1_setup_frame_buf_refs(cm); |
| enforce_max_ref_frames(cpi, &cpi->ref_frame_flags, |
| cm->cur_frame->ref_display_order_hint, |
| cm->current_frame.display_order_hint); |
| set_rel_frame_dist(&cpi->common, &cpi->ref_frame_dist_info, |
| cpi->ref_frame_flags); |
| av1_setup_frame_sign_bias(cm); |
| |
| #if CONFIG_MISMATCH_DEBUG |
| mismatch_reset_frame(num_planes); |
| #else |
| (void)num_planes; |
| #endif |
| |
| if (cpi->sf.hl_sf.frame_parameter_update) { |
| RD_COUNTS *const rdc = &cpi->td.rd_counts; |
| |
| if (frame_is_intra_only(cm)) |
| current_frame->reference_mode = SINGLE_REFERENCE; |
| else |
| current_frame->reference_mode = REFERENCE_MODE_SELECT; |
| |
| features->interp_filter = SWITCHABLE; |
| if (cm->tiles.large_scale) features->interp_filter = EIGHTTAP_REGULAR; |
| |
| features->switchable_motion_mode = 1; |
| |
| rdc->compound_ref_used_flag = 0; |
| rdc->skip_mode_used_flag = 0; |
| |
| encode_frame_internal(cpi); |
| |
| if (current_frame->reference_mode == REFERENCE_MODE_SELECT) { |
| // Use a flag that includes 4x4 blocks |
| if (rdc->compound_ref_used_flag == 0) { |
| current_frame->reference_mode = SINGLE_REFERENCE; |
| #if CONFIG_ENTROPY_STATS |
| av1_zero(cpi->td.counts->comp_inter); |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| } |
| // Re-check on the skip mode status as reference mode may have been |
| // changed. |
| SkipModeInfo *const skip_mode_info = ¤t_frame->skip_mode_info; |
| if (frame_is_intra_only(cm) || |
| current_frame->reference_mode == SINGLE_REFERENCE) { |
| skip_mode_info->skip_mode_allowed = 0; |
| skip_mode_info->skip_mode_flag = 0; |
| } |
| if (skip_mode_info->skip_mode_flag && rdc->skip_mode_used_flag == 0) |
| skip_mode_info->skip_mode_flag = 0; |
| |
| if (!cm->tiles.large_scale) { |
| if (features->tx_mode == TX_MODE_SELECT && |
| cpi->td.mb.txfm_search_info.txb_split_count == 0) |
| features->tx_mode = TX_MODE_LARGEST; |
| } |
| } else { |
| encode_frame_internal(cpi); |
| } |
| } |
