| /* |
| * Copyright (c) 2020, Alliance for Open Media. All rights reserved. |
| * |
| * This source code is subject to the terms of the BSD 2 Clause License and |
| * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
| * was not distributed with this source code in the LICENSE file, you can |
| * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
| * Media Patent License 1.0 was not distributed with this source code in the |
| * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
| */ |
| |
| #include <float.h> |
| |
| #include "aom_dsp/txfm_common.h" |
| |
| #include "av1/common/av1_common_int.h" |
| #include "av1/common/blockd.h" |
| #include "av1/common/enums.h" |
| #include "av1/common/reconintra.h" |
| |
| #include "av1/encoder/aq_complexity.h" |
| #include "av1/encoder/aq_variance.h" |
| #include "av1/encoder/context_tree.h" |
| #include "av1/encoder/encoder.h" |
| #include "av1/encoder/encodeframe.h" |
| #include "av1/encoder/encodeframe_utils.h" |
| #include "av1/encoder/encodemv.h" |
| #include "av1/encoder/intra_mode_search_utils.h" |
| #include "av1/encoder/motion_search_facade.h" |
| #include "av1/encoder/nonrd_opt.h" |
| #include "av1/encoder/partition_search.h" |
| #include "av1/encoder/partition_strategy.h" |
| #include "av1/encoder/reconinter_enc.h" |
| #include "av1/encoder/tokenize.h" |
| #include "av1/encoder/var_based_part.h" |
| #include "av1/encoder/av1_ml_partition_models.h" |
| |
| #if CONFIG_TUNE_VMAF |
| #include "av1/encoder/tune_vmaf.h" |
| #endif |
| |
| #define COLLECT_MOTION_SEARCH_FEATURE_SB 0 |
| |
| void av1_reset_part_sf(PARTITION_SPEED_FEATURES *part_sf) { |
| part_sf->partition_search_type = SEARCH_PARTITION; |
| part_sf->less_rectangular_check_level = 0; |
| part_sf->use_square_partition_only_threshold = BLOCK_128X128; |
| part_sf->auto_max_partition_based_on_simple_motion = NOT_IN_USE; |
| part_sf->default_max_partition_size = BLOCK_LARGEST; |
| part_sf->default_min_partition_size = BLOCK_4X4; |
| part_sf->adjust_var_based_rd_partitioning = 0; |
| part_sf->max_intra_bsize = BLOCK_LARGEST; |
| // This setting only takes effect when partition_search_type is set |
| // to FIXED_PARTITION. |
| part_sf->fixed_partition_size = BLOCK_16X16; |
| // Recode loop tolerance %. |
| part_sf->partition_search_breakout_dist_thr = 0; |
| part_sf->partition_search_breakout_rate_thr = 0; |
| part_sf->prune_ext_partition_types_search_level = 0; |
| part_sf->prune_part4_search = 0; |
| part_sf->ml_prune_partition = 0; |
| part_sf->ml_early_term_after_part_split_level = 0; |
| for (int i = 0; i < PARTITION_BLOCK_SIZES; ++i) { |
| part_sf->ml_partition_search_breakout_thresh[i] = |
| -1; // -1 means not enabled. |
| } |
| part_sf->simple_motion_search_prune_agg = SIMPLE_AGG_LVL0; |
| part_sf->simple_motion_search_split = 0; |
| part_sf->simple_motion_search_prune_rect = 0; |
| part_sf->simple_motion_search_early_term_none = 0; |
| part_sf->simple_motion_search_reduce_search_steps = 0; |
| part_sf->intra_cnn_based_part_prune_level = 0; |
| part_sf->ext_partition_eval_thresh = BLOCK_8X8; |
| part_sf->rect_partition_eval_thresh = BLOCK_128X128; |
| part_sf->ext_part_eval_based_on_cur_best = 0; |
| part_sf->prune_ext_part_using_split_info = 0; |
| part_sf->prune_rectangular_split_based_on_qidx = 0; |
| part_sf->early_term_after_none_split = 0; |
| part_sf->ml_predict_breakout_level = 0; |
| part_sf->prune_sub_8x8_partition_level = 0; |
| part_sf->simple_motion_search_rect_split = 0; |
| part_sf->reuse_prev_rd_results_for_part_ab = 0; |
| part_sf->reuse_best_prediction_for_part_ab = 0; |
| part_sf->use_best_rd_for_pruning = 0; |
| part_sf->skip_non_sq_part_based_on_none = 0; |
| } |
| |
| // Reset speed features that works for the baseline encoding, but |
| // blocks the external partition search. |
| void av1_reset_sf_for_ext_part(AV1_COMP *const cpi) { |
| cpi->sf.inter_sf.prune_ref_frame_for_rect_partitions = 0; |
| } |
| |
| #if !CONFIG_REALTIME_ONLY |
| // If input |features| is NULL, write tpl stats to file for each super block. |
| // Otherwise, store tpl stats to |features|. |
| // The tpl stats is computed in the unit of tpl_bsize_1d (16x16). |
| // When writing to text file: |
| // The first row contains super block position, super block size, |
| // tpl unit length, number of units in the super block. |
| // The second row contains the intra prediction cost for each unit. |
| // The third row contains the inter prediction cost for each unit. |
| // The forth row contains the motion compensated dependency cost for each unit. |
| static void collect_tpl_stats_sb(const AV1_COMP *const cpi, |
| const BLOCK_SIZE bsize, const int mi_row, |
| const int mi_col, |
| aom_partition_features_t *features) { |
| const AV1_COMMON *const cm = &cpi->common; |
| GF_GROUP *gf_group = &cpi->ppi->gf_group; |
| if (gf_group->update_type[cpi->gf_frame_index] == INTNL_OVERLAY_UPDATE || |
| gf_group->update_type[cpi->gf_frame_index] == OVERLAY_UPDATE) { |
| return; |
| } |
| |
| TplParams *const tpl_data = &cpi->ppi->tpl_data; |
| TplDepFrame *tpl_frame = &tpl_data->tpl_frame[cpi->gf_frame_index]; |
| TplDepStats *tpl_stats = tpl_frame->tpl_stats_ptr; |
| // If tpl stats is not established, early return |
| if (!tpl_data->ready || gf_group->max_layer_depth_allowed == 0) { |
| if (features != NULL) features->sb_features.tpl_features.available = 0; |
| return; |
| } |
| |
| const int tpl_stride = tpl_frame->stride; |
| const int step = 1 << tpl_data->tpl_stats_block_mis_log2; |
| const int mi_width = |
| AOMMIN(mi_size_wide[bsize], cm->mi_params.mi_cols - mi_col); |
| const int mi_height = |
| AOMMIN(mi_size_high[bsize], cm->mi_params.mi_rows - mi_row); |
| const int col_steps = (mi_width / step) + ((mi_width % step) > 0); |
| const int row_steps = (mi_height / step) + ((mi_height % step) > 0); |
| const int num_blocks = col_steps * row_steps; |
| |
| if (features == NULL) { |
| char filename[256]; |
| snprintf(filename, sizeof(filename), "%s/tpl_feature_sb%d", |
| cpi->oxcf.partition_info_path, cpi->sb_counter); |
| FILE *pfile = fopen(filename, "w"); |
| fprintf(pfile, "%d,%d,%d,%d,%d\n", mi_row, mi_col, bsize, |
| tpl_data->tpl_bsize_1d, num_blocks); |
| int count = 0; |
| for (int row = 0; row < mi_height; row += step) { |
| for (int col = 0; col < mi_width; col += step) { |
| TplDepStats *this_stats = |
| &tpl_stats[av1_tpl_ptr_pos(mi_row + row, mi_col + col, tpl_stride, |
| tpl_data->tpl_stats_block_mis_log2)]; |
| fprintf(pfile, "%.0f", (double)this_stats->intra_cost); |
| if (count < num_blocks - 1) fprintf(pfile, ","); |
| ++count; |
| } |
| } |
| fprintf(pfile, "\n"); |
| count = 0; |
| for (int row = 0; row < mi_height; row += step) { |
| for (int col = 0; col < mi_width; col += step) { |
| TplDepStats *this_stats = |
| &tpl_stats[av1_tpl_ptr_pos(mi_row + row, mi_col + col, tpl_stride, |
| tpl_data->tpl_stats_block_mis_log2)]; |
| fprintf(pfile, "%.0f", (double)this_stats->inter_cost); |
| if (count < num_blocks - 1) fprintf(pfile, ","); |
| ++count; |
| } |
| } |
| fprintf(pfile, "\n"); |
| count = 0; |
| for (int row = 0; row < mi_height; row += step) { |
| for (int col = 0; col < mi_width; col += step) { |
| TplDepStats *this_stats = |
| &tpl_stats[av1_tpl_ptr_pos(mi_row + row, mi_col + col, tpl_stride, |
| tpl_data->tpl_stats_block_mis_log2)]; |
| const int64_t mc_dep_delta = |
| RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate, |
| this_stats->mc_dep_dist); |
| fprintf(pfile, "%.0f", (double)mc_dep_delta); |
| if (count < num_blocks - 1) fprintf(pfile, ","); |
| ++count; |
| } |
| } |
| fclose(pfile); |
| } else { |
| features->sb_features.tpl_features.available = 1; |
| features->sb_features.tpl_features.tpl_unit_length = tpl_data->tpl_bsize_1d; |
| features->sb_features.tpl_features.num_units = num_blocks; |
| int count = 0; |
| for (int row = 0; row < mi_height; row += step) { |
| for (int col = 0; col < mi_width; col += step) { |
| TplDepStats *this_stats = |
| &tpl_stats[av1_tpl_ptr_pos(mi_row + row, mi_col + col, tpl_stride, |
| tpl_data->tpl_stats_block_mis_log2)]; |
| const int64_t mc_dep_delta = |
| RDCOST(tpl_frame->base_rdmult, this_stats->mc_dep_rate, |
| this_stats->mc_dep_dist); |
| features->sb_features.tpl_features.intra_cost[count] = |
| this_stats->intra_cost; |
| features->sb_features.tpl_features.inter_cost[count] = |
| this_stats->inter_cost; |
| features->sb_features.tpl_features.mc_dep_cost[count] = mc_dep_delta; |
| ++count; |
| } |
| } |
| } |
| } |
| #endif // !CONFIG_REALTIME_ONLY |
| |
| static void update_txfm_count(MACROBLOCK *x, MACROBLOCKD *xd, |
| FRAME_COUNTS *counts, TX_SIZE tx_size, int depth, |
| int blk_row, int blk_col, |
| uint8_t allow_update_cdf) { |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| const BLOCK_SIZE bsize = mbmi->bsize; |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| int ctx = txfm_partition_context(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, mbmi->bsize, |
| tx_size); |
| const int txb_size_index = av1_get_txb_size_index(bsize, blk_row, blk_col); |
| const TX_SIZE plane_tx_size = mbmi->inter_tx_size[txb_size_index]; |
| |
| if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; |
| assert(tx_size > TX_4X4); |
| |
| if (depth == MAX_VARTX_DEPTH) { |
| // Don't add to counts in this case |
| mbmi->tx_size = tx_size; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, tx_size, tx_size); |
| return; |
| } |
| |
| if (tx_size == plane_tx_size) { |
| #if CONFIG_ENTROPY_STATS |
| ++counts->txfm_partition[ctx][0]; |
| #endif |
| if (allow_update_cdf) |
| update_cdf(xd->tile_ctx->txfm_partition_cdf[ctx], 0, 2); |
| mbmi->tx_size = tx_size; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, tx_size, tx_size); |
| } else { |
| const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; |
| const int bsw = tx_size_wide_unit[sub_txs]; |
| const int bsh = tx_size_high_unit[sub_txs]; |
| |
| #if CONFIG_ENTROPY_STATS |
| ++counts->txfm_partition[ctx][1]; |
| #endif |
| if (allow_update_cdf) |
| update_cdf(xd->tile_ctx->txfm_partition_cdf[ctx], 1, 2); |
| ++x->txfm_search_info.txb_split_count; |
| |
| if (sub_txs == TX_4X4) { |
| mbmi->inter_tx_size[txb_size_index] = TX_4X4; |
| mbmi->tx_size = TX_4X4; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, TX_4X4, tx_size); |
| return; |
| } |
| |
| for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { |
| for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { |
| int offsetr = row; |
| int offsetc = col; |
| |
| update_txfm_count(x, xd, counts, sub_txs, depth + 1, blk_row + offsetr, |
| blk_col + offsetc, allow_update_cdf); |
| } |
| } |
| } |
| } |
| |
| static void tx_partition_count_update(const AV1_COMMON *const cm, MACROBLOCK *x, |
| BLOCK_SIZE plane_bsize, |
| FRAME_COUNTS *td_counts, |
| uint8_t allow_update_cdf) { |
| MACROBLOCKD *xd = &x->e_mbd; |
| const int mi_width = mi_size_wide[plane_bsize]; |
| const int mi_height = mi_size_high[plane_bsize]; |
| const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0); |
| const int bh = tx_size_high_unit[max_tx_size]; |
| const int bw = tx_size_wide_unit[max_tx_size]; |
| |
| xd->above_txfm_context = |
| cm->above_contexts.txfm[xd->tile.tile_row] + xd->mi_col; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + (xd->mi_row & MAX_MIB_MASK); |
| |
| for (int idy = 0; idy < mi_height; idy += bh) { |
| for (int idx = 0; idx < mi_width; idx += bw) { |
| update_txfm_count(x, xd, td_counts, max_tx_size, 0, idy, idx, |
| allow_update_cdf); |
| } |
| } |
| } |
| |
| static void set_txfm_context(MACROBLOCKD *xd, TX_SIZE tx_size, int blk_row, |
| int blk_col) { |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| const BLOCK_SIZE bsize = mbmi->bsize; |
| const int max_blocks_high = max_block_high(xd, bsize, 0); |
| const int max_blocks_wide = max_block_wide(xd, bsize, 0); |
| const int txb_size_index = av1_get_txb_size_index(bsize, blk_row, blk_col); |
| const TX_SIZE plane_tx_size = mbmi->inter_tx_size[txb_size_index]; |
| |
| if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return; |
| |
| if (tx_size == plane_tx_size) { |
| mbmi->tx_size = tx_size; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, tx_size, tx_size); |
| |
| } else { |
| if (tx_size == TX_8X8) { |
| mbmi->inter_tx_size[txb_size_index] = TX_4X4; |
| mbmi->tx_size = TX_4X4; |
| txfm_partition_update(xd->above_txfm_context + blk_col, |
| xd->left_txfm_context + blk_row, TX_4X4, tx_size); |
| return; |
| } |
| const TX_SIZE sub_txs = sub_tx_size_map[tx_size]; |
| const int bsw = tx_size_wide_unit[sub_txs]; |
| const int bsh = tx_size_high_unit[sub_txs]; |
| const int row_end = |
| AOMMIN(tx_size_high_unit[tx_size], max_blocks_high - blk_row); |
| const int col_end = |
| AOMMIN(tx_size_wide_unit[tx_size], max_blocks_wide - blk_col); |
| for (int row = 0; row < row_end; row += bsh) { |
| const int offsetr = blk_row + row; |
| for (int col = 0; col < col_end; col += bsw) { |
| const int offsetc = blk_col + col; |
| set_txfm_context(xd, sub_txs, offsetr, offsetc); |
| } |
| } |
| } |
| } |
| |
| static void tx_partition_set_contexts(const AV1_COMMON *const cm, |
| MACROBLOCKD *xd, BLOCK_SIZE plane_bsize) { |
| const int mi_width = mi_size_wide[plane_bsize]; |
| const int mi_height = mi_size_high[plane_bsize]; |
| const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0); |
| const int bh = tx_size_high_unit[max_tx_size]; |
| const int bw = tx_size_wide_unit[max_tx_size]; |
| |
| xd->above_txfm_context = |
| cm->above_contexts.txfm[xd->tile.tile_row] + xd->mi_col; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + (xd->mi_row & MAX_MIB_MASK); |
| |
| for (int idy = 0; idy < mi_height; idy += bh) { |
| for (int idx = 0; idx < mi_width; idx += bw) { |
| set_txfm_context(xd, max_tx_size, idy, idx); |
| } |
| } |
| } |
| |
| static void update_zeromv_cnt(const AV1_COMP *const cpi, |
| const MB_MODE_INFO *const mi, int mi_row, |
| int mi_col, BLOCK_SIZE bsize) { |
| if (mi->ref_frame[0] != LAST_FRAME || !is_inter_block(mi) || |
| mi->segment_id > CR_SEGMENT_ID_BOOST2) { |
| return; |
| } |
| const AV1_COMMON *const cm = &cpi->common; |
| const MV mv = mi->mv[0].as_mv; |
| const int bw = mi_size_wide[bsize] >> 1; |
| const int bh = mi_size_high[bsize] >> 1; |
| const int xmis = AOMMIN((cm->mi_params.mi_cols - mi_col) >> 1, bw); |
| const int ymis = AOMMIN((cm->mi_params.mi_rows - mi_row) >> 1, bh); |
| const int block_index = |
| (mi_row >> 1) * (cm->mi_params.mi_cols >> 1) + (mi_col >> 1); |
| for (int y = 0; y < ymis; y++) { |
| for (int x = 0; x < xmis; x++) { |
| // consec_zero_mv is in the scale of 8x8 blocks |
| const int map_offset = block_index + y * (cm->mi_params.mi_cols >> 1) + x; |
| if (abs(mv.row) < 10 && abs(mv.col) < 10) { |
| if (cpi->consec_zero_mv[map_offset] < 255) |
| cpi->consec_zero_mv[map_offset]++; |
| } else { |
| cpi->consec_zero_mv[map_offset] = 0; |
| } |
| } |
| } |
| } |
| |
| static void encode_superblock(const AV1_COMP *const cpi, TileDataEnc *tile_data, |
| ThreadData *td, TokenExtra **t, RUN_TYPE dry_run, |
| BLOCK_SIZE bsize, int *rate) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO **mi_4x4 = xd->mi; |
| MB_MODE_INFO *mbmi = mi_4x4[0]; |
| const int seg_skip = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP); |
| const int mis = cm->mi_params.mi_stride; |
| const int mi_width = mi_size_wide[bsize]; |
| const int mi_height = mi_size_high[bsize]; |
| const int is_inter = is_inter_block(mbmi); |
| |
| // Initialize tx_mode and tx_size_search_method |
| TxfmSearchParams *txfm_params = &x->txfm_search_params; |
| set_tx_size_search_method( |
| cm, &cpi->winner_mode_params, txfm_params, |
| cpi->sf.winner_mode_sf.enable_winner_mode_for_tx_size_srch, 1); |
| |
| const int mi_row = xd->mi_row; |
| const int mi_col = xd->mi_col; |
| if (!is_inter) { |
| xd->cfl.store_y = store_cfl_required(cm, xd); |
| mbmi->skip_txfm = 1; |
| for (int plane = 0; plane < num_planes; ++plane) { |
| av1_encode_intra_block_plane(cpi, x, bsize, plane, dry_run, |
| cpi->optimize_seg_arr[mbmi->segment_id]); |
| } |
| |
| // If there is at least one lossless segment, force the skip for intra |
| // block to be 0, in order to avoid the segment_id to be changed by in |
| // write_segment_id(). |
| if (!cpi->common.seg.segid_preskip && cpi->common.seg.update_map && |
| cpi->enc_seg.has_lossless_segment) |
| mbmi->skip_txfm = 0; |
| |
| xd->cfl.store_y = 0; |
| if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize)) { |
| for (int plane = 0; plane < AOMMIN(2, num_planes); ++plane) { |
| if (mbmi->palette_mode_info.palette_size[plane] > 0) { |
| if (!dry_run) { |
| av1_tokenize_color_map(x, plane, t, bsize, mbmi->tx_size, |
| PALETTE_MAP, tile_data->allow_update_cdf, |
| td->counts); |
| } else if (dry_run == DRY_RUN_COSTCOEFFS) { |
| *rate += |
| av1_cost_color_map(x, plane, bsize, mbmi->tx_size, PALETTE_MAP); |
| } |
| } |
| } |
| } |
| |
| av1_update_intra_mb_txb_context(cpi, td, dry_run, bsize, |
| tile_data->allow_update_cdf); |
| } else { |
| int ref; |
| const int is_compound = has_second_ref(mbmi); |
| |
| set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); |
| for (ref = 0; ref < 1 + is_compound; ++ref) { |
| const YV12_BUFFER_CONFIG *cfg = |
| get_ref_frame_yv12_buf(cm, mbmi->ref_frame[ref]); |
| assert(IMPLIES(!is_intrabc_block(mbmi), cfg)); |
| av1_setup_pre_planes(xd, ref, cfg, mi_row, mi_col, |
| xd->block_ref_scale_factors[ref], num_planes); |
| } |
| // Predicted sample of inter mode (for Luma plane) cannot be reused if |
| // nonrd_check_partition_split speed feature is enabled, Since in such cases |
| // the buffer may not contain the predicted sample of best mode. |
| const int start_plane = |
| (x->reuse_inter_pred && (!cpi->sf.rt_sf.nonrd_check_partition_split) && |
| cm->seq_params->bit_depth == AOM_BITS_8) |
| ? 1 |
| : 0; |
| av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize, |
| start_plane, av1_num_planes(cm) - 1); |
| if (mbmi->motion_mode == OBMC_CAUSAL) { |
| assert(cpi->oxcf.motion_mode_cfg.enable_obmc); |
| av1_build_obmc_inter_predictors_sb(cm, xd); |
| } |
| |
| #if CONFIG_MISMATCH_DEBUG |
| if (dry_run == OUTPUT_ENABLED) { |
| for (int plane = 0; plane < num_planes; ++plane) { |
| const struct macroblockd_plane *pd = &xd->plane[plane]; |
| int pixel_c, pixel_r; |
| mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, |
| pd->subsampling_x, pd->subsampling_y); |
| if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, |
| pd->subsampling_y)) |
| continue; |
| mismatch_record_block_pre(pd->dst.buf, pd->dst.stride, |
| cm->current_frame.order_hint, plane, pixel_c, |
| pixel_r, pd->width, pd->height, |
| xd->cur_buf->flags & YV12_FLAG_HIGHBITDEPTH); |
| } |
| } |
| #else |
| (void)num_planes; |
| #endif |
| |
| av1_encode_sb(cpi, x, bsize, dry_run); |
| av1_tokenize_sb_vartx(cpi, td, dry_run, bsize, rate, |
| tile_data->allow_update_cdf); |
| } |
| |
| if (!dry_run) { |
| if (av1_allow_intrabc(cm) && is_intrabc_block(mbmi)) td->intrabc_used = 1; |
| if (txfm_params->tx_mode_search_type == TX_MODE_SELECT && |
| !xd->lossless[mbmi->segment_id] && mbmi->bsize > BLOCK_4X4 && |
| !(is_inter && (mbmi->skip_txfm || seg_skip))) { |
| if (is_inter) { |
| tx_partition_count_update(cm, x, bsize, td->counts, |
| tile_data->allow_update_cdf); |
| } else { |
| if (mbmi->tx_size != max_txsize_rect_lookup[bsize]) |
| ++x->txfm_search_info.txb_split_count; |
| if (block_signals_txsize(bsize)) { |
| const int tx_size_ctx = get_tx_size_context(xd); |
| const int32_t tx_size_cat = bsize_to_tx_size_cat(bsize); |
| const int depth = tx_size_to_depth(mbmi->tx_size, bsize); |
| const int max_depths = bsize_to_max_depth(bsize); |
| |
| if (tile_data->allow_update_cdf) |
| update_cdf(xd->tile_ctx->tx_size_cdf[tx_size_cat][tx_size_ctx], |
| depth, max_depths + 1); |
| #if CONFIG_ENTROPY_STATS |
| ++td->counts->intra_tx_size[tx_size_cat][tx_size_ctx][depth]; |
| #endif |
| } |
| } |
| assert(IMPLIES(is_rect_tx(mbmi->tx_size), is_rect_tx_allowed(xd, mbmi))); |
| } else { |
| int i, j; |
| TX_SIZE intra_tx_size; |
| // The new intra coding scheme requires no change of transform size |
| if (is_inter) { |
| if (xd->lossless[mbmi->segment_id]) { |
| intra_tx_size = TX_4X4; |
| } else { |
| intra_tx_size = |
| tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type); |
| } |
| } else { |
| intra_tx_size = mbmi->tx_size; |
| } |
| |
| const int cols = AOMMIN(cm->mi_params.mi_cols - mi_col, mi_width); |
| const int rows = AOMMIN(cm->mi_params.mi_rows - mi_row, mi_height); |
| for (j = 0; j < rows; j++) { |
| for (i = 0; i < cols; i++) mi_4x4[mis * j + i]->tx_size = intra_tx_size; |
| } |
| |
| if (intra_tx_size != max_txsize_rect_lookup[bsize]) |
| ++x->txfm_search_info.txb_split_count; |
| } |
| } |
| |
| if (txfm_params->tx_mode_search_type == TX_MODE_SELECT && |
| block_signals_txsize(mbmi->bsize) && is_inter && |
| !(mbmi->skip_txfm || seg_skip) && !xd->lossless[mbmi->segment_id]) { |
| if (dry_run) tx_partition_set_contexts(cm, xd, bsize); |
| } else { |
| TX_SIZE tx_size = mbmi->tx_size; |
| // The new intra coding scheme requires no change of transform size |
| if (is_inter) { |
| if (xd->lossless[mbmi->segment_id]) { |
| tx_size = TX_4X4; |
| } else { |
| tx_size = tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type); |
| } |
| } else { |
| tx_size = (bsize > BLOCK_4X4) ? tx_size : TX_4X4; |
| } |
| mbmi->tx_size = tx_size; |
| set_txfm_ctxs(tx_size, xd->width, xd->height, |
| (mbmi->skip_txfm || seg_skip) && is_inter_block(mbmi), xd); |
| } |
| |
| if (is_inter_block(mbmi) && !xd->is_chroma_ref && is_cfl_allowed(xd)) { |
| cfl_store_block(xd, mbmi->bsize, mbmi->tx_size); |
| } |
| if (!dry_run) { |
| if (cpi->oxcf.pass == AOM_RC_ONE_PASS && cpi->svc.temporal_layer_id == 0 && |
| cpi->sf.rt_sf.use_temporal_noise_estimate && |
| (!cpi->ppi->use_svc || |
| (cpi->ppi->use_svc && |
| !cpi->svc.layer_context[cpi->svc.temporal_layer_id].is_key_frame && |
| cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1))) |
| update_zeromv_cnt(cpi, mbmi, mi_row, mi_col, bsize); |
| } |
| } |
| |
| static void setup_block_rdmult(const AV1_COMP *const cpi, MACROBLOCK *const x, |
| int mi_row, int mi_col, BLOCK_SIZE bsize, |
| AQ_MODE aq_mode, MB_MODE_INFO *mbmi) { |
| x->rdmult = cpi->rd.RDMULT; |
| |
| if (aq_mode != NO_AQ) { |
| assert(mbmi != NULL); |
| if (aq_mode == VARIANCE_AQ) { |
| if (cpi->vaq_refresh) { |
| const int energy = bsize <= BLOCK_16X16 |
| ? x->mb_energy |
| : av1_log_block_var(cpi, x, bsize); |
| mbmi->segment_id = energy; |
| } |
| x->rdmult = set_rdmult(cpi, x, mbmi->segment_id); |
| } else if (aq_mode == COMPLEXITY_AQ) { |
| x->rdmult = set_rdmult(cpi, x, mbmi->segment_id); |
| } else if (aq_mode == CYCLIC_REFRESH_AQ) { |
| // If segment is boosted, use rdmult for that segment. |
| if (cyclic_refresh_segment_id_boosted(mbmi->segment_id)) |
| x->rdmult = av1_cyclic_refresh_get_rdmult(cpi->cyclic_refresh); |
| } |
| } |
| |
| #if !CONFIG_REALTIME_ONLY |
| if (cpi->common.delta_q_info.delta_q_present_flag && |
| !cpi->sf.rt_sf.use_nonrd_pick_mode) { |
| x->rdmult = av1_get_cb_rdmult(cpi, x, bsize, mi_row, mi_col); |
| } |
| #endif // !CONFIG_REALTIME_ONLY |
| |
| if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_SSIM) { |
| av1_set_ssim_rdmult(cpi, &x->errorperbit, bsize, mi_row, mi_col, |
| &x->rdmult); |
| } |
| #if CONFIG_SALIENCY_MAP |
| else if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_SALIENCY_MAP) { |
| av1_set_saliency_map_vmaf_rdmult(cpi, &x->errorperbit, |
| cpi->common.seq_params->sb_size, mi_row, |
| mi_col, &x->rdmult); |
| } |
| #endif |
| #if CONFIG_TUNE_VMAF |
| else if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_WITHOUT_PREPROCESSING || |
| cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_MAX_GAIN || |
| cpi->oxcf.tune_cfg.tuning == AOM_TUNE_VMAF_NEG_MAX_GAIN) { |
| av1_set_vmaf_rdmult(cpi, x, bsize, mi_row, mi_col, &x->rdmult); |
| } |
| #endif |
| #if CONFIG_TUNE_BUTTERAUGLI |
| else if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_BUTTERAUGLI) { |
| av1_set_butteraugli_rdmult(cpi, x, bsize, mi_row, mi_col, &x->rdmult); |
| } |
| #endif |
| if (cpi->oxcf.mode == ALLINTRA) { |
| x->rdmult = (int)(((int64_t)x->rdmult * x->intra_sb_rdmult_modifier) >> 7); |
| } |
| |
| // Check to make sure that the adjustments above have not caused the |
| // rd multiplier to be truncated to 0. |
| x->rdmult = (x->rdmult > 0) ? x->rdmult : 1; |
| } |
| |
| void av1_set_offsets_without_segment_id(const AV1_COMP *const cpi, |
| const TileInfo *const tile, |
| MACROBLOCK *const x, int mi_row, |
| int mi_col, BLOCK_SIZE bsize) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| assert(bsize < BLOCK_SIZES_ALL); |
| const int mi_width = mi_size_wide[bsize]; |
| const int mi_height = mi_size_high[bsize]; |
| |
| set_mode_info_offsets(&cpi->common.mi_params, &cpi->mbmi_ext_info, x, xd, |
| mi_row, mi_col); |
| |
| set_entropy_context(xd, mi_row, mi_col, num_planes); |
| xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); |
| |
| // Set up destination pointers. |
| av1_setup_dst_planes(xd->plane, bsize, &cm->cur_frame->buf, mi_row, mi_col, 0, |
| num_planes); |
| |
| // Set up limit values for MV components. |
| // Mv beyond the range do not produce new/different prediction block. |
| av1_set_mv_limits(&cm->mi_params, &x->mv_limits, mi_row, mi_col, mi_height, |
| mi_width, cpi->oxcf.border_in_pixels); |
| |
| set_plane_n4(xd, mi_width, mi_height, num_planes); |
| |
| // Set up distance of MB to edge of frame in 1/8th pel units. |
| assert(!(mi_col & (mi_width - 1)) && !(mi_row & (mi_height - 1))); |
| set_mi_row_col(xd, tile, mi_row, mi_height, mi_col, mi_width, |
| cm->mi_params.mi_rows, cm->mi_params.mi_cols); |
| |
| // Set up source buffers. |
| av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, bsize); |
| |
| // required by av1_append_sub8x8_mvs_for_idx() and av1_find_best_ref_mvs() |
| xd->tile = *tile; |
| } |
| |
| void av1_set_offsets(const AV1_COMP *const cpi, const TileInfo *const tile, |
| MACROBLOCK *const x, int mi_row, int mi_col, |
| BLOCK_SIZE bsize) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const struct segmentation *const seg = &cm->seg; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *mbmi; |
| |
| av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize); |
| |
| // Setup segment ID. |
| mbmi = xd->mi[0]; |
| mbmi->segment_id = 0; |
| if (seg->enabled) { |
| if (seg->enabled && !cpi->vaq_refresh) { |
| const uint8_t *const map = |
| seg->update_map ? cpi->enc_seg.map : cm->last_frame_seg_map; |
| mbmi->segment_id = |
| map ? get_segment_id(&cm->mi_params, map, bsize, mi_row, mi_col) : 0; |
| } |
| av1_init_plane_quantizers(cpi, x, mbmi->segment_id, 0); |
| } |
| #ifndef NDEBUG |
| x->last_set_offsets_loc.mi_row = mi_row; |
| x->last_set_offsets_loc.mi_col = mi_col; |
| x->last_set_offsets_loc.bsize = bsize; |
| #endif // NDEBUG |
| } |
| |
| /*!\brief Hybrid intra mode search. |
| * |
| * \ingroup intra_mode_search |
| * \callgraph |
| * \callergraph |
| * This is top level function for mode search for intra frames in non-RD |
| * optimized case. Depending on speed feature and block size it calls |
| * either non-RD or RD optimized intra mode search. |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] x Pointer to structure holding all the data for |
| the current macroblock |
| * \param[in] rd_cost Struct to keep track of the RD information |
| * \param[in] bsize Current block size |
| * \param[in] ctx Structure to hold snapshot of coding context |
| during the mode picking process |
| * |
| * \remark Nothing is returned. Instead, the MB_MODE_INFO struct inside x |
| * is modified to store information about the best mode computed |
| * in this function. The rd_cost struct is also updated with the RD stats |
| * corresponding to the best mode found. |
| */ |
| |
| static inline void hybrid_intra_mode_search(AV1_COMP *cpi, MACROBLOCK *const x, |
| RD_STATS *rd_cost, BLOCK_SIZE bsize, |
| PICK_MODE_CONTEXT *ctx) { |
| int use_rdopt = 0; |
| const int hybrid_intra_pickmode = cpi->sf.rt_sf.hybrid_intra_pickmode; |
| // Use rd pick for intra mode search based on block size and variance. |
| if (hybrid_intra_pickmode && bsize < BLOCK_16X16) { |
| unsigned int var_thresh[3] = { 0, 101, 201 }; |
| assert(hybrid_intra_pickmode <= 3); |
| if (x->source_variance >= var_thresh[hybrid_intra_pickmode - 1]) |
| use_rdopt = 1; |
| } |
| |
| if (use_rdopt) |
| av1_rd_pick_intra_mode_sb(cpi, x, rd_cost, bsize, ctx, INT64_MAX); |
| else |
| av1_nonrd_pick_intra_mode(cpi, x, rd_cost, bsize, ctx); |
| } |
| |
| // For real time/allintra row-mt enabled multi-threaded encoding with cost |
| // update frequency set to COST_UPD_TILE/COST_UPD_OFF, tile ctxt is not updated |
| // at superblock level. Thus, it is not required for the encoding of top-right |
| // superblock be complete for updating tile ctxt. However, when encoding a block |
| // whose right edge is also the superblock edge, intra and inter mode evaluation |
| // (ref mv list population) require the encoding of the top-right superblock to |
| // be complete. So, here, we delay the waiting of threads until the need for the |
| // data from the top-right superblock region. |
| static inline void wait_for_top_right_sb(AV1EncRowMultiThreadInfo *enc_row_mt, |
| AV1EncRowMultiThreadSync *row_mt_sync, |
| TileInfo *tile_info, |
| BLOCK_SIZE sb_size, |
| int sb_mi_size_log2, BLOCK_SIZE bsize, |
| int mi_row, int mi_col) { |
| const int sb_size_in_mi = mi_size_wide[sb_size]; |
| const int bw_in_mi = mi_size_wide[bsize]; |
| const int blk_row_in_sb = mi_row & (sb_size_in_mi - 1); |
| const int blk_col_in_sb = mi_col & (sb_size_in_mi - 1); |
| const int top_right_block_in_sb = |
| (blk_row_in_sb == 0) && (blk_col_in_sb + bw_in_mi >= sb_size_in_mi); |
| |
| // Don't wait if the block is the not the top-right block in the superblock. |
| if (!top_right_block_in_sb) return; |
| |
| // Wait for the top-right superblock to finish encoding. |
| const int sb_row_in_tile = |
| (mi_row - tile_info->mi_row_start) >> sb_mi_size_log2; |
| const int sb_col_in_tile = |
| (mi_col - tile_info->mi_col_start) >> sb_mi_size_log2; |
| |
| enc_row_mt->sync_read_ptr(row_mt_sync, sb_row_in_tile, sb_col_in_tile); |
| } |
| |
| /*!\brief Interface for AV1 mode search for an individual coding block |
| * |
| * \ingroup partition_search |
| * \callgraph |
| * \callergraph |
| * Searches prediction modes, transform, and coefficient coding modes for an |
| * individual coding block. This function is the top-level interface that |
| * directs the encoder to the proper mode search function, among these |
| * implemented for inter/intra + rd/non-rd + non-skip segment/skip segment. |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] tile_data Pointer to struct holding adaptive |
| * data/contexts/models for the tile during |
| * encoding |
| * \param[in] x Pointer to structure holding all the data for |
| * the current macroblock |
| * \param[in] mi_row Row coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] mi_col Column coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] rd_cost Pointer to structure holding rate and distortion |
| * stats for the current block |
| * \param[in] partition Partition mode of the parent block |
| * \param[in] bsize Current block size |
| * \param[in] ctx Pointer to structure holding coding contexts and |
| * chosen modes for the current block |
| * \param[in] best_rd Upper bound of rd cost of a valid partition |
| * |
| * \remark Nothing is returned. Instead, the chosen modes and contexts necessary |
| * for reconstruction are stored in ctx, the rate-distortion stats are stored in |
| * rd_cost. If no valid mode leading to rd_cost <= best_rd, the status will be |
| * signalled by an INT64_MAX rd_cost->rdcost. |
| */ |
| static void pick_sb_modes(AV1_COMP *const cpi, TileDataEnc *tile_data, |
| MACROBLOCK *const x, int mi_row, int mi_col, |
| RD_STATS *rd_cost, PARTITION_TYPE partition, |
| BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx, |
| RD_STATS best_rd) { |
| if (cpi->sf.part_sf.use_best_rd_for_pruning && best_rd.rdcost < 0) { |
| ctx->rd_stats.rdcost = INT64_MAX; |
| ctx->rd_stats.skip_txfm = 0; |
| av1_invalid_rd_stats(rd_cost); |
| return; |
| } |
| |
| av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize); |
| |
| if (cpi->sf.part_sf.reuse_prev_rd_results_for_part_ab && |
| ctx->rd_mode_is_ready) { |
| assert(ctx->mic.bsize == bsize); |
| assert(ctx->mic.partition == partition); |
| rd_cost->rate = ctx->rd_stats.rate; |
| rd_cost->dist = ctx->rd_stats.dist; |
| rd_cost->rdcost = ctx->rd_stats.rdcost; |
| return; |
| } |
| |
| AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *mbmi; |
| struct macroblock_plane *const p = x->plane; |
| struct macroblockd_plane *const pd = xd->plane; |
| const AQ_MODE aq_mode = cpi->oxcf.q_cfg.aq_mode; |
| TxfmSearchInfo *txfm_info = &x->txfm_search_info; |
| |
| int i; |
| |
| // This is only needed for real time/allintra row-mt enabled multi-threaded |
| // encoding with cost update frequency set to COST_UPD_TILE/COST_UPD_OFF. |
| wait_for_top_right_sb(&cpi->mt_info.enc_row_mt, &tile_data->row_mt_sync, |
| &tile_data->tile_info, cm->seq_params->sb_size, |
| cm->seq_params->mib_size_log2, bsize, mi_row, mi_col); |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, rd_pick_sb_modes_time); |
| #endif |
| |
| mbmi = xd->mi[0]; |
| mbmi->bsize = bsize; |
| mbmi->partition = partition; |
| |
| #if CONFIG_RD_DEBUG |
| mbmi->mi_row = mi_row; |
| mbmi->mi_col = mi_col; |
| #endif |
| |
| // Sets up the tx_type_map buffer in MACROBLOCKD. |
| xd->tx_type_map = txfm_info->tx_type_map_; |
| xd->tx_type_map_stride = mi_size_wide[bsize]; |
| |
| for (i = 0; i < num_planes; ++i) { |
| p[i].coeff = ctx->coeff[i]; |
| p[i].qcoeff = ctx->qcoeff[i]; |
| p[i].dqcoeff = ctx->dqcoeff[i]; |
| p[i].eobs = ctx->eobs[i]; |
| p[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i]; |
| } |
| |
| for (i = 0; i < 2; ++i) pd[i].color_index_map = ctx->color_index_map[i]; |
| |
| ctx->skippable = 0; |
| // Set to zero to make sure we do not use the previous encoded frame stats |
| mbmi->skip_txfm = 0; |
| // Reset skip mode flag. |
| mbmi->skip_mode = 0; |
| |
| x->source_variance = av1_get_perpixel_variance_facade( |
| cpi, xd, &x->plane[0].src, bsize, AOM_PLANE_Y); |
| |
| // Initialize default mode evaluation params |
| set_mode_eval_params(cpi, x, DEFAULT_EVAL); |
| |
| // Save rdmult before it might be changed, so it can be restored later. |
| const int orig_rdmult = x->rdmult; |
| setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, aq_mode, mbmi); |
| // Set error per bit for current rdmult |
| av1_set_error_per_bit(&x->errorperbit, x->rdmult); |
| av1_rd_cost_update(x->rdmult, &best_rd); |
| |
| // If set best_rd.rdcost to INT64_MAX, the encoder will not use any previous |
| // rdcost information for the following mode search. |
| // Disabling the feature could get some coding gain, with encoder slowdown. |
| if (!cpi->sf.part_sf.use_best_rd_for_pruning) { |
| av1_invalid_rd_stats(&best_rd); |
| } |
| |
| // Find best coding mode & reconstruct the MB so it is available |
| // as a predictor for MBs that follow in the SB |
| if (frame_is_intra_only(cm)) { |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, av1_rd_pick_intra_mode_sb_time); |
| #endif |
| av1_rd_pick_intra_mode_sb(cpi, x, rd_cost, bsize, ctx, best_rd.rdcost); |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, av1_rd_pick_intra_mode_sb_time); |
| #endif |
| } else { |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, av1_rd_pick_inter_mode_sb_time); |
| #endif |
| if (segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { |
| av1_rd_pick_inter_mode_sb_seg_skip(cpi, tile_data, x, mi_row, mi_col, |
| rd_cost, bsize, ctx, best_rd.rdcost); |
| } else { |
| av1_rd_pick_inter_mode(cpi, tile_data, x, rd_cost, bsize, ctx, |
| best_rd.rdcost); |
| } |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, av1_rd_pick_inter_mode_sb_time); |
| #endif |
| } |
| |
| // Examine the resulting rate and for AQ mode 2 make a segment choice. |
| if (rd_cost->rate != INT_MAX && aq_mode == COMPLEXITY_AQ && |
| bsize >= BLOCK_16X16) { |
| av1_caq_select_segment(cpi, x, bsize, mi_row, mi_col, rd_cost->rate); |
| } |
| |
| x->rdmult = orig_rdmult; |
| |
| // TODO(jingning) The rate-distortion optimization flow needs to be |
| // refactored to provide proper exit/return handle. |
| if (rd_cost->rate == INT_MAX) rd_cost->rdcost = INT64_MAX; |
| |
| ctx->rd_stats.rate = rd_cost->rate; |
| ctx->rd_stats.dist = rd_cost->dist; |
| ctx->rd_stats.rdcost = rd_cost->rdcost; |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, rd_pick_sb_modes_time); |
| #endif |
| } |
| |
| static void update_stats(const AV1_COMMON *const cm, ThreadData *td) { |
| MACROBLOCK *x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const MB_MODE_INFO *const mbmi = xd->mi[0]; |
| const MB_MODE_INFO_EXT *const mbmi_ext = &x->mbmi_ext; |
| const CurrentFrame *const current_frame = &cm->current_frame; |
| const BLOCK_SIZE bsize = mbmi->bsize; |
| FRAME_CONTEXT *fc = xd->tile_ctx; |
| const int seg_ref_active = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_REF_FRAME); |
| |
| if (current_frame->skip_mode_info.skip_mode_flag && !seg_ref_active && |
| is_comp_ref_allowed(bsize)) { |
| const int skip_mode_ctx = av1_get_skip_mode_context(xd); |
| #if CONFIG_ENTROPY_STATS |
| td->counts->skip_mode[skip_mode_ctx][mbmi->skip_mode]++; |
| #endif |
| update_cdf(fc->skip_mode_cdfs[skip_mode_ctx], mbmi->skip_mode, 2); |
| } |
| |
| if (!mbmi->skip_mode && !seg_ref_active) { |
| const int skip_ctx = av1_get_skip_txfm_context(xd); |
| #if CONFIG_ENTROPY_STATS |
| td->counts->skip_txfm[skip_ctx][mbmi->skip_txfm]++; |
| #endif |
| update_cdf(fc->skip_txfm_cdfs[skip_ctx], mbmi->skip_txfm, 2); |
| } |
| |
| #if CONFIG_ENTROPY_STATS |
| // delta quant applies to both intra and inter |
| const int super_block_upper_left = |
| ((xd->mi_row & (cm->seq_params->mib_size - 1)) == 0) && |
| ((xd->mi_col & (cm->seq_params->mib_size - 1)) == 0); |
| const DeltaQInfo *const delta_q_info = &cm->delta_q_info; |
| if (delta_q_info->delta_q_present_flag && |
| (bsize != cm->seq_params->sb_size || !mbmi->skip_txfm) && |
| super_block_upper_left) { |
| const int dq = (mbmi->current_qindex - xd->current_base_qindex) / |
| delta_q_info->delta_q_res; |
| const int absdq = abs(dq); |
| for (int i = 0; i < AOMMIN(absdq, DELTA_Q_SMALL); ++i) { |
| td->counts->delta_q[i][1]++; |
| } |
| if (absdq < DELTA_Q_SMALL) td->counts->delta_q[absdq][0]++; |
| if (delta_q_info->delta_lf_present_flag) { |
| if (delta_q_info->delta_lf_multi) { |
| const int frame_lf_count = |
| av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; |
| for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { |
| const int delta_lf = (mbmi->delta_lf[lf_id] - xd->delta_lf[lf_id]) / |
| delta_q_info->delta_lf_res; |
| const int abs_delta_lf = abs(delta_lf); |
| for (int i = 0; i < AOMMIN(abs_delta_lf, DELTA_LF_SMALL); ++i) { |
| td->counts->delta_lf_multi[lf_id][i][1]++; |
| } |
| if (abs_delta_lf < DELTA_LF_SMALL) |
| td->counts->delta_lf_multi[lf_id][abs_delta_lf][0]++; |
| } |
| } else { |
| const int delta_lf = |
| (mbmi->delta_lf_from_base - xd->delta_lf_from_base) / |
| delta_q_info->delta_lf_res; |
| const int abs_delta_lf = abs(delta_lf); |
| for (int i = 0; i < AOMMIN(abs_delta_lf, DELTA_LF_SMALL); ++i) { |
| td->counts->delta_lf[i][1]++; |
| } |
| if (abs_delta_lf < DELTA_LF_SMALL) |
| td->counts->delta_lf[abs_delta_lf][0]++; |
| } |
| } |
| } |
| #endif |
| |
| if (!is_inter_block(mbmi)) { |
| av1_sum_intra_stats(cm, td->counts, xd, mbmi, xd->above_mbmi, xd->left_mbmi, |
| frame_is_intra_only(cm)); |
| } |
| |
| if (av1_allow_intrabc(cm)) { |
| const int is_intrabc = is_intrabc_block(mbmi); |
| update_cdf(fc->intrabc_cdf, is_intrabc, 2); |
| #if CONFIG_ENTROPY_STATS |
| ++td->counts->intrabc[is_intrabc]; |
| #endif // CONFIG_ENTROPY_STATS |
| if (is_intrabc) { |
| const int8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); |
| const int_mv dv_ref = mbmi_ext->ref_mv_stack[ref_frame_type][0].this_mv; |
| av1_update_mv_stats(&mbmi->mv[0].as_mv, &dv_ref.as_mv, &fc->ndvc, |
| MV_SUBPEL_NONE); |
| } |
| } |
| |
| if (frame_is_intra_only(cm) || mbmi->skip_mode) return; |
| |
| FRAME_COUNTS *const counts = td->counts; |
| const int inter_block = is_inter_block(mbmi); |
| |
| if (!seg_ref_active) { |
| #if CONFIG_ENTROPY_STATS |
| counts->intra_inter[av1_get_intra_inter_context(xd)][inter_block]++; |
| #endif |
| update_cdf(fc->intra_inter_cdf[av1_get_intra_inter_context(xd)], |
| inter_block, 2); |
| // If the segment reference feature is enabled we have only a single |
| // reference frame allowed for the segment so exclude it from |
| // the reference frame counts used to work out probabilities. |
| if (inter_block) { |
| const MV_REFERENCE_FRAME ref0 = mbmi->ref_frame[0]; |
| const MV_REFERENCE_FRAME ref1 = mbmi->ref_frame[1]; |
| if (current_frame->reference_mode == REFERENCE_MODE_SELECT) { |
| if (is_comp_ref_allowed(bsize)) { |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_inter[av1_get_reference_mode_context(xd)] |
| [has_second_ref(mbmi)]++; |
| #endif // CONFIG_ENTROPY_STATS |
| update_cdf(av1_get_reference_mode_cdf(xd), has_second_ref(mbmi), 2); |
| } |
| } |
| |
| if (has_second_ref(mbmi)) { |
| const COMP_REFERENCE_TYPE comp_ref_type = has_uni_comp_refs(mbmi) |
| ? UNIDIR_COMP_REFERENCE |
| : BIDIR_COMP_REFERENCE; |
| update_cdf(av1_get_comp_reference_type_cdf(xd), comp_ref_type, |
| COMP_REFERENCE_TYPES); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_ref_type[av1_get_comp_reference_type_context(xd)] |
| [comp_ref_type]++; |
| #endif // CONFIG_ENTROPY_STATS |
| |
| if (comp_ref_type == UNIDIR_COMP_REFERENCE) { |
| const int bit = (ref0 == BWDREF_FRAME); |
| update_cdf(av1_get_pred_cdf_uni_comp_ref_p(xd), bit, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts |
| ->uni_comp_ref[av1_get_pred_context_uni_comp_ref_p(xd)][0][bit]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (!bit) { |
| const int bit1 = (ref1 == LAST3_FRAME || ref1 == GOLDEN_FRAME); |
| update_cdf(av1_get_pred_cdf_uni_comp_ref_p1(xd), bit1, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->uni_comp_ref[av1_get_pred_context_uni_comp_ref_p1(xd)][1] |
| [bit1]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (bit1) { |
| update_cdf(av1_get_pred_cdf_uni_comp_ref_p2(xd), |
| ref1 == GOLDEN_FRAME, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->uni_comp_ref[av1_get_pred_context_uni_comp_ref_p2(xd)][2] |
| [ref1 == GOLDEN_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| } |
| } else { |
| const int bit = (ref0 == GOLDEN_FRAME || ref0 == LAST3_FRAME); |
| update_cdf(av1_get_pred_cdf_comp_ref_p(xd), bit, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_ref[av1_get_pred_context_comp_ref_p(xd)][0][bit]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (!bit) { |
| update_cdf(av1_get_pred_cdf_comp_ref_p1(xd), ref0 == LAST2_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_ref[av1_get_pred_context_comp_ref_p1(xd)][1] |
| [ref0 == LAST2_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } else { |
| update_cdf(av1_get_pred_cdf_comp_ref_p2(xd), ref0 == GOLDEN_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_ref[av1_get_pred_context_comp_ref_p2(xd)][2] |
| [ref0 == GOLDEN_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| update_cdf(av1_get_pred_cdf_comp_bwdref_p(xd), ref1 == ALTREF_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_bwdref[av1_get_pred_context_comp_bwdref_p(xd)][0] |
| [ref1 == ALTREF_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (ref1 != ALTREF_FRAME) { |
| update_cdf(av1_get_pred_cdf_comp_bwdref_p1(xd), |
| ref1 == ALTREF2_FRAME, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->comp_bwdref[av1_get_pred_context_comp_bwdref_p1(xd)][1] |
| [ref1 == ALTREF2_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| } |
| } else { |
| const int bit = (ref0 >= BWDREF_FRAME); |
| update_cdf(av1_get_pred_cdf_single_ref_p1(xd), bit, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p1(xd)][0][bit]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (bit) { |
| assert(ref0 <= ALTREF_FRAME); |
| update_cdf(av1_get_pred_cdf_single_ref_p2(xd), ref0 == ALTREF_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p2(xd)][1] |
| [ref0 == ALTREF_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (ref0 != ALTREF_FRAME) { |
| update_cdf(av1_get_pred_cdf_single_ref_p6(xd), |
| ref0 == ALTREF2_FRAME, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p6(xd)][5] |
| [ref0 == ALTREF2_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| } else { |
| const int bit1 = !(ref0 == LAST2_FRAME || ref0 == LAST_FRAME); |
| update_cdf(av1_get_pred_cdf_single_ref_p3(xd), bit1, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p3(xd)][2][bit1]++; |
| #endif // CONFIG_ENTROPY_STATS |
| if (!bit1) { |
| update_cdf(av1_get_pred_cdf_single_ref_p4(xd), ref0 != LAST_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p4(xd)][3] |
| [ref0 != LAST_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } else { |
| update_cdf(av1_get_pred_cdf_single_ref_p5(xd), ref0 != LAST3_FRAME, |
| 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->single_ref[av1_get_pred_context_single_ref_p5(xd)][4] |
| [ref0 != LAST3_FRAME]++; |
| #endif // CONFIG_ENTROPY_STATS |
| } |
| } |
| } |
| |
| if (cm->seq_params->enable_interintra_compound && |
| is_interintra_allowed(mbmi)) { |
| const int bsize_group = size_group_lookup[bsize]; |
| if (mbmi->ref_frame[1] == INTRA_FRAME) { |
| #if CONFIG_ENTROPY_STATS |
| counts->interintra[bsize_group][1]++; |
| #endif |
| update_cdf(fc->interintra_cdf[bsize_group], 1, 2); |
| #if CONFIG_ENTROPY_STATS |
| counts->interintra_mode[bsize_group][mbmi->interintra_mode]++; |
| #endif |
| update_cdf(fc->interintra_mode_cdf[bsize_group], |
| mbmi->interintra_mode, INTERINTRA_MODES); |
| if (av1_is_wedge_used(bsize)) { |
| #if CONFIG_ENTROPY_STATS |
| counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++; |
| #endif |
| update_cdf(fc->wedge_interintra_cdf[bsize], |
| mbmi->use_wedge_interintra, 2); |
| if (mbmi->use_wedge_interintra) { |
| #if CONFIG_ENTROPY_STATS |
| counts->wedge_idx[bsize][mbmi->interintra_wedge_index]++; |
| #endif |
| update_cdf(fc->wedge_idx_cdf[bsize], mbmi->interintra_wedge_index, |
| 16); |
| } |
| } |
| } else { |
| #if CONFIG_ENTROPY_STATS |
| counts->interintra[bsize_group][0]++; |
| #endif |
| update_cdf(fc->interintra_cdf[bsize_group], 0, 2); |
| } |
| } |
| |
| const MOTION_MODE motion_allowed = |
| cm->features.switchable_motion_mode |
| ? motion_mode_allowed(xd->global_motion, xd, mbmi, |
| cm->features.allow_warped_motion) |
| : SIMPLE_TRANSLATION; |
| if (mbmi->ref_frame[1] != INTRA_FRAME) { |
| if (motion_allowed == WARPED_CAUSAL) { |
| #if CONFIG_ENTROPY_STATS |
| counts->motion_mode[bsize][mbmi->motion_mode]++; |
| #endif |
| update_cdf(fc->motion_mode_cdf[bsize], mbmi->motion_mode, |
| MOTION_MODES); |
| } else if (motion_allowed == OBMC_CAUSAL) { |
| #if CONFIG_ENTROPY_STATS |
| counts->obmc[bsize][mbmi->motion_mode == OBMC_CAUSAL]++; |
| #endif |
| update_cdf(fc->obmc_cdf[bsize], mbmi->motion_mode == OBMC_CAUSAL, 2); |
| } |
| } |
| |
| if (has_second_ref(mbmi)) { |
| assert(current_frame->reference_mode != SINGLE_REFERENCE && |
| is_inter_compound_mode(mbmi->mode) && |
| mbmi->motion_mode == SIMPLE_TRANSLATION); |
| |
| const int masked_compound_used = is_any_masked_compound_used(bsize) && |
| cm->seq_params->enable_masked_compound; |
| if (masked_compound_used) { |
| const int comp_group_idx_ctx = get_comp_group_idx_context(xd); |
| #if CONFIG_ENTROPY_STATS |
| ++counts->comp_group_idx[comp_group_idx_ctx][mbmi->comp_group_idx]; |
| #endif |
| update_cdf(fc->comp_group_idx_cdf[comp_group_idx_ctx], |
| mbmi->comp_group_idx, 2); |
| } |
| |
| if (mbmi->comp_group_idx == 0) { |
| const int comp_index_ctx = get_comp_index_context(cm, xd); |
| #if CONFIG_ENTROPY_STATS |
| ++counts->compound_index[comp_index_ctx][mbmi->compound_idx]; |
| #endif |
| update_cdf(fc->compound_index_cdf[comp_index_ctx], mbmi->compound_idx, |
| 2); |
| } else { |
| assert(masked_compound_used); |
| if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) { |
| #if CONFIG_ENTROPY_STATS |
| ++counts->compound_type[bsize][mbmi->interinter_comp.type - |
| COMPOUND_WEDGE]; |
| #endif |
| update_cdf(fc->compound_type_cdf[bsize], |
| mbmi->interinter_comp.type - COMPOUND_WEDGE, |
| MASKED_COMPOUND_TYPES); |
| } |
| } |
| } |
| if (mbmi->interinter_comp.type == COMPOUND_WEDGE) { |
| if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) { |
| #if CONFIG_ENTROPY_STATS |
| counts->wedge_idx[bsize][mbmi->interinter_comp.wedge_index]++; |
| #endif |
| update_cdf(fc->wedge_idx_cdf[bsize], |
| mbmi->interinter_comp.wedge_index, 16); |
| } |
| } |
| } |
| } |
| |
| if (inter_block && cm->features.interp_filter == SWITCHABLE && |
| av1_is_interp_needed(xd)) { |
| update_filter_type_cdf(xd, mbmi, cm->seq_params->enable_dual_filter); |
| } |
| if (inter_block && |
| !segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP)) { |
| const PREDICTION_MODE mode = mbmi->mode; |
| const int16_t mode_ctx = |
| av1_mode_context_analyzer(mbmi_ext->mode_context, mbmi->ref_frame); |
| if (has_second_ref(mbmi)) { |
| #if CONFIG_ENTROPY_STATS |
| ++counts->inter_compound_mode[mode_ctx][INTER_COMPOUND_OFFSET(mode)]; |
| #endif |
| update_cdf(fc->inter_compound_mode_cdf[mode_ctx], |
| INTER_COMPOUND_OFFSET(mode), INTER_COMPOUND_MODES); |
| } else { |
| av1_update_inter_mode_stats(fc, counts, mode, mode_ctx); |
| } |
| |
| const int new_mv = mbmi->mode == NEWMV || mbmi->mode == NEW_NEWMV; |
| if (new_mv) { |
| const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); |
| for (int idx = 0; idx < 2; ++idx) { |
| if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) { |
| const uint8_t drl_ctx = |
| av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx); |
| update_cdf(fc->drl_cdf[drl_ctx], mbmi->ref_mv_idx != idx, 2); |
| #if CONFIG_ENTROPY_STATS |
| ++counts->drl_mode[drl_ctx][mbmi->ref_mv_idx != idx]; |
| #endif |
| if (mbmi->ref_mv_idx == idx) break; |
| } |
| } |
| } |
| |
| if (have_nearmv_in_inter_mode(mbmi->mode)) { |
| const uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame); |
| for (int idx = 1; idx < 3; ++idx) { |
| if (mbmi_ext->ref_mv_count[ref_frame_type] > idx + 1) { |
| const uint8_t drl_ctx = |
| av1_drl_ctx(mbmi_ext->weight[ref_frame_type], idx); |
| update_cdf(fc->drl_cdf[drl_ctx], mbmi->ref_mv_idx != idx - 1, 2); |
| #if CONFIG_ENTROPY_STATS |
| ++counts->drl_mode[drl_ctx][mbmi->ref_mv_idx != idx - 1]; |
| #endif |
| if (mbmi->ref_mv_idx == idx - 1) break; |
| } |
| } |
| } |
| if (have_newmv_in_inter_mode(mbmi->mode)) { |
| const int allow_hp = cm->features.cur_frame_force_integer_mv |
| ? MV_SUBPEL_NONE |
| : cm->features.allow_high_precision_mv; |
| if (new_mv) { |
| for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) { |
| const int_mv ref_mv = av1_get_ref_mv(x, ref); |
| av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc, |
| allow_hp); |
| } |
| } else if (mbmi->mode == NEAREST_NEWMV || mbmi->mode == NEAR_NEWMV) { |
| const int ref = 1; |
| const int_mv ref_mv = av1_get_ref_mv(x, ref); |
| av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc, |
| allow_hp); |
| } else if (mbmi->mode == NEW_NEARESTMV || mbmi->mode == NEW_NEARMV) { |
| const int ref = 0; |
| const int_mv ref_mv = av1_get_ref_mv(x, ref); |
| av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc, |
| allow_hp); |
| } |
| } |
| } |
| } |
| |
| /*!\brief Reconstructs an individual coding block |
| * |
| * \ingroup partition_search |
| * Reconstructs an individual coding block by applying the chosen modes stored |
| * in ctx, also updates mode counts and entropy models. |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] tile_data Pointer to struct holding adaptive |
| * data/contexts/models for the tile during encoding |
| * \param[in] td Pointer to thread data |
| * \param[in] tp Pointer to the starting token |
| * \param[in] mi_row Row coordinate of the block in a step size of MI_SIZE |
| * \param[in] mi_col Column coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] dry_run A code indicating whether it is part of the final |
| * pass for reconstructing the superblock |
| * \param[in] bsize Current block size |
| * \param[in] partition Partition mode of the parent block |
| * \param[in] ctx Pointer to structure holding coding contexts and the |
| * chosen modes for the current block |
| * \param[in] rate Pointer to the total rate for the current block |
| * |
| * \remark Nothing is returned. Instead, reconstructions (w/o in-loop filters) |
| * will be updated in the pixel buffers in td->mb.e_mbd. Also, the chosen modes |
| * will be stored in the MB_MODE_INFO buffer td->mb.e_mbd.mi[0]. |
| */ |
| static void encode_b(const AV1_COMP *const cpi, TileDataEnc *tile_data, |
| ThreadData *td, TokenExtra **tp, int mi_row, int mi_col, |
| RUN_TYPE dry_run, BLOCK_SIZE bsize, |
| PARTITION_TYPE partition, PICK_MODE_CONTEXT *const ctx, |
| int *rate) { |
| const AV1_COMMON *const cm = &cpi->common; |
| TileInfo *const tile = &tile_data->tile_info; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *xd = &x->e_mbd; |
| const int subsampling_x = cm->seq_params->subsampling_x; |
| const int subsampling_y = cm->seq_params->subsampling_y; |
| |
| av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize); |
| const int origin_mult = x->rdmult; |
| setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL); |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| mbmi->partition = partition; |
| av1_update_state(cpi, td, ctx, mi_row, mi_col, bsize, dry_run); |
| |
| if (!dry_run) { |
| set_cb_offsets(x->mbmi_ext_frame->cb_offset, x->cb_offset[PLANE_TYPE_Y], |
| x->cb_offset[PLANE_TYPE_UV]); |
| assert(x->cb_offset[PLANE_TYPE_Y] < |
| (1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size])); |
| assert(x->cb_offset[PLANE_TYPE_UV] < |
| ((1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]) >> |
| (subsampling_x + subsampling_y))); |
| } |
| |
| encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, rate); |
| |
| if (!dry_run) { |
| update_cb_offsets(x, bsize, subsampling_x, subsampling_y); |
| if (bsize == cpi->common.seq_params->sb_size && mbmi->skip_txfm == 1 && |
| cm->delta_q_info.delta_lf_present_flag) { |
| const int frame_lf_count = |
| av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; |
| for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) |
| mbmi->delta_lf[lf_id] = xd->delta_lf[lf_id]; |
| mbmi->delta_lf_from_base = xd->delta_lf_from_base; |
| } |
| if (has_second_ref(mbmi)) { |
| if (mbmi->compound_idx == 0 || |
| mbmi->interinter_comp.type == COMPOUND_AVERAGE) |
| mbmi->comp_group_idx = 0; |
| else |
| mbmi->comp_group_idx = 1; |
| } |
| |
| // delta quant applies to both intra and inter |
| const int super_block_upper_left = |
| ((mi_row & (cm->seq_params->mib_size - 1)) == 0) && |
| ((mi_col & (cm->seq_params->mib_size - 1)) == 0); |
| const DeltaQInfo *const delta_q_info = &cm->delta_q_info; |
| if (delta_q_info->delta_q_present_flag && |
| (bsize != cm->seq_params->sb_size || !mbmi->skip_txfm) && |
| super_block_upper_left) { |
| xd->current_base_qindex = mbmi->current_qindex; |
| if (delta_q_info->delta_lf_present_flag) { |
| if (delta_q_info->delta_lf_multi) { |
| const int frame_lf_count = |
| av1_num_planes(cm) > 1 ? FRAME_LF_COUNT : FRAME_LF_COUNT - 2; |
| for (int lf_id = 0; lf_id < frame_lf_count; ++lf_id) { |
| xd->delta_lf[lf_id] = mbmi->delta_lf[lf_id]; |
| } |
| } else { |
| xd->delta_lf_from_base = mbmi->delta_lf_from_base; |
| } |
| } |
| } |
| |
| RD_COUNTS *rdc = &td->rd_counts; |
| if (mbmi->skip_mode) { |
| assert(!frame_is_intra_only(cm)); |
| rdc->skip_mode_used_flag = 1; |
| if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) { |
| assert(has_second_ref(mbmi)); |
| rdc->compound_ref_used_flag = 1; |
| } |
| set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); |
| } else { |
| const int seg_ref_active = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_REF_FRAME); |
| if (!seg_ref_active) { |
| // If the segment reference feature is enabled we have only a single |
| // reference frame allowed for the segment so exclude it from |
| // the reference frame counts used to work out probabilities. |
| if (is_inter_block(mbmi)) { |
| av1_collect_neighbors_ref_counts(xd); |
| if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT) { |
| if (has_second_ref(mbmi)) { |
| // This flag is also updated for 4x4 blocks |
| rdc->compound_ref_used_flag = 1; |
| } |
| } |
| set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); |
| } |
| } |
| } |
| |
| if (tile_data->allow_update_cdf) update_stats(&cpi->common, td); |
| |
| // Gather obmc and warped motion count to update the probability. |
| if ((cpi->sf.inter_sf.prune_obmc_prob_thresh > 0 && |
| cpi->sf.inter_sf.prune_obmc_prob_thresh < INT_MAX) || |
| (cm->features.allow_warped_motion && |
| cpi->sf.inter_sf.prune_warped_prob_thresh > 0)) { |
| const int inter_block = is_inter_block(mbmi); |
| const int seg_ref_active = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_REF_FRAME); |
| if (!seg_ref_active && inter_block) { |
| const MOTION_MODE motion_allowed = |
| cm->features.switchable_motion_mode |
| ? motion_mode_allowed(xd->global_motion, xd, mbmi, |
| cm->features.allow_warped_motion) |
| : SIMPLE_TRANSLATION; |
| |
| if (mbmi->ref_frame[1] != INTRA_FRAME) { |
| if (motion_allowed >= OBMC_CAUSAL) { |
| td->rd_counts.obmc_used[bsize][mbmi->motion_mode == OBMC_CAUSAL]++; |
| } |
| if (motion_allowed == WARPED_CAUSAL) { |
| td->rd_counts.warped_used[mbmi->motion_mode == WARPED_CAUSAL]++; |
| } |
| } |
| } |
| } |
| } |
| // TODO(Ravi/Remya): Move this copy function to a better logical place |
| // This function will copy the best mode information from block |
| // level (x->mbmi_ext) to frame level (cpi->mbmi_ext_info.frame_base). This |
| // frame level buffer (cpi->mbmi_ext_info.frame_base) will be used during |
| // bitstream preparation. |
| av1_copy_mbmi_ext_to_mbmi_ext_frame(x->mbmi_ext_frame, &x->mbmi_ext, |
| av1_ref_frame_type(xd->mi[0]->ref_frame)); |
| x->rdmult = origin_mult; |
| } |
| |
| /*!\brief Reconstructs a partition (may contain multiple coding blocks) |
| * |
| * \ingroup partition_search |
| * Reconstructs a sub-partition of the superblock by applying the chosen modes |
| * and partition trees stored in pc_tree. |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] td Pointer to thread data |
| * \param[in] tile_data Pointer to struct holding adaptive |
| * data/contexts/models for the tile during encoding |
| * \param[in] tp Pointer to the starting token |
| * \param[in] mi_row Row coordinate of the block in a step size of MI_SIZE |
| * \param[in] mi_col Column coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] dry_run A code indicating whether it is part of the final |
| * pass for reconstructing the superblock |
| * \param[in] bsize Current block size |
| * \param[in] pc_tree Pointer to the PC_TREE node storing the picked |
| * partitions and mode info for the current block |
| * \param[in] rate Pointer to the total rate for the current block |
| * |
| * \remark Nothing is returned. Instead, reconstructions (w/o in-loop filters) |
| * will be updated in the pixel buffers in td->mb.e_mbd. |
| */ |
| static void encode_sb(const AV1_COMP *const cpi, ThreadData *td, |
| TileDataEnc *tile_data, TokenExtra **tp, int mi_row, |
| int mi_col, RUN_TYPE dry_run, BLOCK_SIZE bsize, |
| PC_TREE *pc_tree, int *rate) { |
| assert(bsize < BLOCK_SIZES_ALL); |
| const AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| assert(bsize < BLOCK_SIZES_ALL); |
| const int hbs = mi_size_wide[bsize] / 2; |
| const int is_partition_root = bsize >= BLOCK_8X8; |
| const int ctx = is_partition_root |
| ? partition_plane_context(xd, mi_row, mi_col, bsize) |
| : -1; |
| const PARTITION_TYPE partition = pc_tree->partitioning; |
| const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition); |
| #if !CONFIG_REALTIME_ONLY |
| int quarter_step = mi_size_wide[bsize] / 4; |
| int i; |
| BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT); |
| #endif |
| |
| if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return; |
| if (subsize == BLOCK_INVALID) return; |
| |
| if (!dry_run && ctx >= 0) { |
| const int has_rows = (mi_row + hbs) < mi_params->mi_rows; |
| const int has_cols = (mi_col + hbs) < mi_params->mi_cols; |
| |
| if (has_rows && has_cols) { |
| #if CONFIG_ENTROPY_STATS |
| td->counts->partition[ctx][partition]++; |
| #endif |
| |
| if (tile_data->allow_update_cdf) { |
| FRAME_CONTEXT *fc = xd->tile_ctx; |
| update_cdf(fc->partition_cdf[ctx], partition, |
| partition_cdf_length(bsize)); |
| } |
| } |
| } |
| |
| switch (partition) { |
| case PARTITION_NONE: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->none, rate); |
| break; |
| case PARTITION_VERT: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->vertical[0], rate); |
| if (mi_col + hbs < mi_params->mi_cols) { |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, subsize, |
| partition, pc_tree->vertical[1], rate); |
| } |
| break; |
| case PARTITION_HORZ: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->horizontal[0], rate); |
| if (mi_row + hbs < mi_params->mi_rows) { |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, subsize, |
| partition, pc_tree->horizontal[1], rate); |
| } |
| break; |
| case PARTITION_SPLIT: |
| encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize, |
| pc_tree->split[0], rate); |
| encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs, dry_run, subsize, |
| pc_tree->split[1], rate); |
| encode_sb(cpi, td, tile_data, tp, mi_row + hbs, mi_col, dry_run, subsize, |
| pc_tree->split[2], rate); |
| encode_sb(cpi, td, tile_data, tp, mi_row + hbs, mi_col + hbs, dry_run, |
| subsize, pc_tree->split[3], rate); |
| break; |
| |
| #if !CONFIG_REALTIME_ONLY |
| case PARTITION_HORZ_A: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, bsize2, |
| partition, pc_tree->horizontala[0], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, bsize2, |
| partition, pc_tree->horizontala[1], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, subsize, |
| partition, pc_tree->horizontala[2], rate); |
| break; |
| case PARTITION_HORZ_B: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->horizontalb[0], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, bsize2, |
| partition, pc_tree->horizontalb[1], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col + hbs, dry_run, |
| bsize2, partition, pc_tree->horizontalb[2], rate); |
| break; |
| case PARTITION_VERT_A: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, bsize2, |
| partition, pc_tree->verticala[0], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col, dry_run, bsize2, |
| partition, pc_tree->verticala[1], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, subsize, |
| partition, pc_tree->verticala[2], rate); |
| |
| break; |
| case PARTITION_VERT_B: |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->verticalb[0], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs, dry_run, bsize2, |
| partition, pc_tree->verticalb[1], rate); |
| encode_b(cpi, tile_data, td, tp, mi_row + hbs, mi_col + hbs, dry_run, |
| bsize2, partition, pc_tree->verticalb[2], rate); |
| break; |
| case PARTITION_HORZ_4: |
| for (i = 0; i < SUB_PARTITIONS_PART4; ++i) { |
| int this_mi_row = mi_row + i * quarter_step; |
| if (i > 0 && this_mi_row >= mi_params->mi_rows) break; |
| |
| encode_b(cpi, tile_data, td, tp, this_mi_row, mi_col, dry_run, subsize, |
| partition, pc_tree->horizontal4[i], rate); |
| } |
| break; |
| case PARTITION_VERT_4: |
| for (i = 0; i < SUB_PARTITIONS_PART4; ++i) { |
| int this_mi_col = mi_col + i * quarter_step; |
| if (i > 0 && this_mi_col >= mi_params->mi_cols) break; |
| encode_b(cpi, tile_data, td, tp, mi_row, this_mi_col, dry_run, subsize, |
| partition, pc_tree->vertical4[i], rate); |
| } |
| break; |
| #endif |
| default: assert(0 && "Invalid partition type."); break; |
| } |
| |
| update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition); |
| } |
| |
| static inline int is_adjust_var_based_part_enabled( |
| AV1_COMMON *const cm, const PARTITION_SPEED_FEATURES *const part_sf, |
| BLOCK_SIZE bsize) { |
| if (part_sf->partition_search_type != VAR_BASED_PARTITION) return 0; |
| if (part_sf->adjust_var_based_rd_partitioning == 0 || |
| part_sf->adjust_var_based_rd_partitioning > 2) |
| return 0; |
| |
| if (bsize <= BLOCK_32X32) return 1; |
| if (part_sf->adjust_var_based_rd_partitioning == 2) { |
| const int is_larger_qindex = cm->quant_params.base_qindex > 190; |
| const int is_360p_or_larger = AOMMIN(cm->width, cm->height) >= 360; |
| return is_360p_or_larger && is_larger_qindex && bsize == BLOCK_64X64; |
| } |
| return 0; |
| } |
| |
| /*!\brief AV1 block partition search (partition estimation and partial search). |
| * |
| * \ingroup partition_search |
| * Encode the block by applying pre-calculated partition patterns that are |
| * represented by coding block sizes stored in the mbmi array. Minor partition |
| * adjustments are tested and applied if they lead to lower rd costs. The |
| * partition types are limited to a basic set: none, horz, vert, and split. |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] td Pointer to thread data |
| * \param[in] tile_data Pointer to struct holding adaptive |
| data/contexts/models for the tile during encoding |
| * \param[in] mib Array representing MB_MODE_INFO pointers for mi |
| blocks starting from the first pixel of the current |
| block |
| * \param[in] tp Pointer to the starting token |
| * \param[in] mi_row Row coordinate of the block in a step size of MI_SIZE |
| * \param[in] mi_col Column coordinate of the block in a step size of |
| MI_SIZE |
| * \param[in] bsize Current block size |
| * \param[in] rate Pointer to the final rate for encoding the current |
| block |
| * \param[in] dist Pointer to the final distortion of the current block |
| * \param[in] do_recon Whether the reconstruction function needs to be run, |
| either for finalizing a superblock or providing |
| reference for future sub-partitions |
| * \param[in] pc_tree Pointer to the PC_TREE node holding the picked |
| partitions and mode info for the current block |
| * |
| * \remark Nothing is returned. The pc_tree struct is modified to store the |
| * picked partition and modes. The rate and dist are also updated with those |
| * corresponding to the best partition found. |
| */ |
| void av1_rd_use_partition(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, |
| MB_MODE_INFO **mib, TokenExtra **tp, int mi_row, |
| int mi_col, BLOCK_SIZE bsize, int *rate, |
| int64_t *dist, int do_recon, PC_TREE *pc_tree) { |
| AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| const int num_planes = av1_num_planes(cm); |
| TileInfo *const tile_info = &tile_data->tile_info; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const ModeCosts *mode_costs = &x->mode_costs; |
| const int bs = mi_size_wide[bsize]; |
| const int hbs = bs / 2; |
| const int pl = (bsize >= BLOCK_8X8) |
| ? partition_plane_context(xd, mi_row, mi_col, bsize) |
| : 0; |
| const PARTITION_TYPE partition = |
| (bsize >= BLOCK_8X8) ? get_partition(cm, mi_row, mi_col, bsize) |
| : PARTITION_NONE; |
| const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition); |
| RD_SEARCH_MACROBLOCK_CONTEXT x_ctx; |
| RD_STATS last_part_rdc, none_rdc, chosen_rdc, invalid_rdc; |
| BLOCK_SIZE bs_type = mib[0]->bsize; |
| int use_partition_none = 0; |
| x->try_merge_partition = 0; |
| |
| if (pc_tree->none == NULL) { |
| pc_tree->none = av1_alloc_pmc(cpi, bsize, &td->shared_coeff_buf); |
| if (!pc_tree->none) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| } |
| PICK_MODE_CONTEXT *ctx_none = pc_tree->none; |
| |
| if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return; |
| |
| assert(mi_size_wide[bsize] == mi_size_high[bsize]); |
| // In rt mode, currently the min partition size is BLOCK_8X8. |
| assert(bsize >= cpi->sf.part_sf.default_min_partition_size); |
| |
| av1_invalid_rd_stats(&last_part_rdc); |
| av1_invalid_rd_stats(&none_rdc); |
| av1_invalid_rd_stats(&chosen_rdc); |
| av1_invalid_rd_stats(&invalid_rdc); |
| |
| pc_tree->partitioning = partition; |
| |
| xd->above_txfm_context = |
| cm->above_contexts.txfm[tile_info->tile_row] + mi_col; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); |
| av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| |
| if (bsize == BLOCK_16X16 && cpi->vaq_refresh) { |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize); |
| x->mb_energy = av1_log_block_var(cpi, x, bsize); |
| } |
| |
| // Save rdmult before it might be changed, so it can be restored later. |
| const int orig_rdmult = x->rdmult; |
| setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL); |
| |
| if (partition != PARTITION_NONE && |
| is_adjust_var_based_part_enabled(cm, &cpi->sf.part_sf, bsize) && |
| (mi_row + hbs < mi_params->mi_rows && |
| mi_col + hbs < mi_params->mi_cols)) { |
| assert(bsize > cpi->sf.part_sf.default_min_partition_size); |
| mib[0]->bsize = bsize; |
| pc_tree->partitioning = PARTITION_NONE; |
| x->try_merge_partition = 1; |
| pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &none_rdc, PARTITION_NONE, |
| bsize, ctx_none, invalid_rdc); |
| |
| if (none_rdc.rate < INT_MAX) { |
| none_rdc.rate += mode_costs->partition_cost[pl][PARTITION_NONE]; |
| none_rdc.rdcost = RDCOST(x->rdmult, none_rdc.rate, none_rdc.dist); |
| } |
| |
| // Try to skip split partition evaluation based on none partition |
| // characteristics. |
| if (none_rdc.rate < INT_MAX && none_rdc.skip_txfm == 1) { |
| use_partition_none = 1; |
| } |
| |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| mib[0]->bsize = bs_type; |
| pc_tree->partitioning = partition; |
| } |
| |
| for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++i) { |
| pc_tree->split[i] = av1_alloc_pc_tree_node(subsize); |
| if (!pc_tree->split[i]) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PC_TREE"); |
| pc_tree->split[i]->index = i; |
| } |
| switch (partition) { |
| case PARTITION_NONE: |
| pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc, |
| PARTITION_NONE, bsize, ctx_none, invalid_rdc); |
| break; |
| case PARTITION_HORZ: |
| if (use_partition_none) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| |
| for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) { |
| pc_tree->horizontal[i] = |
| av1_alloc_pmc(cpi, subsize, &td->shared_coeff_buf); |
| if (!pc_tree->horizontal[i]) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| } |
| pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc, |
| PARTITION_HORZ, subsize, pc_tree->horizontal[0], |
| invalid_rdc); |
| if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 && |
| mi_row + hbs < mi_params->mi_rows) { |
| RD_STATS tmp_rdc; |
| const PICK_MODE_CONTEXT *const ctx_h = pc_tree->horizontal[0]; |
| av1_init_rd_stats(&tmp_rdc); |
| av1_update_state(cpi, td, ctx_h, mi_row, mi_col, subsize, 1); |
| encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize, |
| NULL); |
| pick_sb_modes(cpi, tile_data, x, mi_row + hbs, mi_col, &tmp_rdc, |
| PARTITION_HORZ, subsize, pc_tree->horizontal[1], |
| invalid_rdc); |
| if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| last_part_rdc.rate += tmp_rdc.rate; |
| last_part_rdc.dist += tmp_rdc.dist; |
| last_part_rdc.rdcost += tmp_rdc.rdcost; |
| } |
| break; |
| case PARTITION_VERT: |
| if (use_partition_none) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| |
| for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) { |
| pc_tree->vertical[i] = |
| av1_alloc_pmc(cpi, subsize, &td->shared_coeff_buf); |
| if (!pc_tree->vertical[i]) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| } |
| pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc, |
| PARTITION_VERT, subsize, pc_tree->vertical[0], invalid_rdc); |
| if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 && |
| mi_col + hbs < mi_params->mi_cols) { |
| RD_STATS tmp_rdc; |
| const PICK_MODE_CONTEXT *const ctx_v = pc_tree->vertical[0]; |
| av1_init_rd_stats(&tmp_rdc); |
| av1_update_state(cpi, td, ctx_v, mi_row, mi_col, subsize, 1); |
| encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize, |
| NULL); |
| pick_sb_modes(cpi, tile_data, x, mi_row, mi_col + hbs, &tmp_rdc, |
| PARTITION_VERT, subsize, |
| pc_tree->vertical[bsize > BLOCK_8X8], invalid_rdc); |
| if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| last_part_rdc.rate += tmp_rdc.rate; |
| last_part_rdc.dist += tmp_rdc.dist; |
| last_part_rdc.rdcost += tmp_rdc.rdcost; |
| } |
| break; |
| case PARTITION_SPLIT: |
| if (use_partition_none) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| |
| last_part_rdc.rate = 0; |
| last_part_rdc.dist = 0; |
| last_part_rdc.rdcost = 0; |
| for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) { |
| int x_idx = (i & 1) * hbs; |
| int y_idx = (i >> 1) * hbs; |
| int jj = i >> 1, ii = i & 0x01; |
| RD_STATS tmp_rdc; |
| if ((mi_row + y_idx >= mi_params->mi_rows) || |
| (mi_col + x_idx >= mi_params->mi_cols)) |
| continue; |
| |
| av1_init_rd_stats(&tmp_rdc); |
| av1_rd_use_partition( |
| cpi, td, tile_data, |
| mib + jj * hbs * mi_params->mi_stride + ii * hbs, tp, |
| mi_row + y_idx, mi_col + x_idx, subsize, &tmp_rdc.rate, |
| &tmp_rdc.dist, i != (SUB_PARTITIONS_SPLIT - 1), pc_tree->split[i]); |
| if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) { |
| av1_invalid_rd_stats(&last_part_rdc); |
| break; |
| } |
| last_part_rdc.rate += tmp_rdc.rate; |
| last_part_rdc.dist += tmp_rdc.dist; |
| } |
| break; |
| case PARTITION_VERT_A: |
| case PARTITION_VERT_B: |
| case PARTITION_HORZ_A: |
| case PARTITION_HORZ_B: |
| case PARTITION_HORZ_4: |
| case PARTITION_VERT_4: |
| assert(0 && "Cannot handle extended partition types"); |
| default: assert(0); break; |
| } |
| |
| if (last_part_rdc.rate < INT_MAX) { |
| last_part_rdc.rate += mode_costs->partition_cost[pl][partition]; |
| last_part_rdc.rdcost = |
| RDCOST(x->rdmult, last_part_rdc.rate, last_part_rdc.dist); |
| } |
| |
| if ((cpi->sf.part_sf.partition_search_type == VAR_BASED_PARTITION && |
| cpi->sf.part_sf.adjust_var_based_rd_partitioning > 2) && |
| partition != PARTITION_SPLIT && bsize > BLOCK_8X8 && |
| (mi_row + bs < mi_params->mi_rows || |
| mi_row + hbs == mi_params->mi_rows) && |
| (mi_col + bs < mi_params->mi_cols || |
| mi_col + hbs == mi_params->mi_cols)) { |
| BLOCK_SIZE split_subsize = get_partition_subsize(bsize, PARTITION_SPLIT); |
| chosen_rdc.rate = 0; |
| chosen_rdc.dist = 0; |
| |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| pc_tree->partitioning = PARTITION_SPLIT; |
| |
| // Split partition. |
| for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) { |
| int x_idx = (i & 1) * hbs; |
| int y_idx = (i >> 1) * hbs; |
| RD_STATS tmp_rdc; |
| |
| if ((mi_row + y_idx >= mi_params->mi_rows) || |
| (mi_col + x_idx >= mi_params->mi_cols)) |
| continue; |
| |
| av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| pc_tree->split[i]->partitioning = PARTITION_NONE; |
| if (pc_tree->split[i]->none == NULL) |
| pc_tree->split[i]->none = |
| av1_alloc_pmc(cpi, split_subsize, &td->shared_coeff_buf); |
| if (!pc_tree->split[i]->none) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| pick_sb_modes(cpi, tile_data, x, mi_row + y_idx, mi_col + x_idx, &tmp_rdc, |
| PARTITION_SPLIT, split_subsize, pc_tree->split[i]->none, |
| invalid_rdc); |
| |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| if (tmp_rdc.rate == INT_MAX || tmp_rdc.dist == INT64_MAX) { |
| av1_invalid_rd_stats(&chosen_rdc); |
| break; |
| } |
| |
| chosen_rdc.rate += tmp_rdc.rate; |
| chosen_rdc.dist += tmp_rdc.dist; |
| |
| if (i != SUB_PARTITIONS_SPLIT - 1) |
| encode_sb(cpi, td, tile_data, tp, mi_row + y_idx, mi_col + x_idx, |
| OUTPUT_ENABLED, split_subsize, pc_tree->split[i], NULL); |
| |
| chosen_rdc.rate += mode_costs->partition_cost[pl][PARTITION_NONE]; |
| } |
| if (chosen_rdc.rate < INT_MAX) { |
| chosen_rdc.rate += mode_costs->partition_cost[pl][PARTITION_SPLIT]; |
| chosen_rdc.rdcost = RDCOST(x->rdmult, chosen_rdc.rate, chosen_rdc.dist); |
| } |
| } |
| |
| // If last_part is better set the partitioning to that. |
| if (last_part_rdc.rdcost < chosen_rdc.rdcost) { |
| mib[0]->bsize = bs_type; |
| if (bsize >= BLOCK_8X8) pc_tree->partitioning = partition; |
| |
| chosen_rdc = last_part_rdc; |
| } |
| // If none was better set the partitioning to that. |
| if (none_rdc.rdcost < INT64_MAX && |
| none_rdc.rdcost - (none_rdc.rdcost >> 9) < chosen_rdc.rdcost) { |
| mib[0]->bsize = bsize; |
| if (bsize >= BLOCK_8X8) pc_tree->partitioning = PARTITION_NONE; |
| chosen_rdc = none_rdc; |
| } |
| |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes); |
| |
| // We must have chosen a partitioning and encoding or we'll fail later on. |
| // No other opportunities for success. |
| if (bsize == cm->seq_params->sb_size) |
| assert(chosen_rdc.rate < INT_MAX && chosen_rdc.dist < INT64_MAX); |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, encode_sb_time); |
| #endif |
| if (do_recon) { |
| if (bsize == cm->seq_params->sb_size) { |
| // NOTE: To get estimate for rate due to the tokens, use: |
| // int rate_coeffs = 0; |
| // encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_COSTCOEFFS, |
| // bsize, pc_tree, &rate_coeffs); |
| set_cb_offsets(x->cb_offset, 0, 0); |
| encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, OUTPUT_ENABLED, bsize, |
| pc_tree, NULL); |
| } else { |
| encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize, |
| pc_tree, NULL); |
| } |
| } |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, encode_sb_time); |
| #endif |
| |
| *rate = chosen_rdc.rate; |
| *dist = chosen_rdc.dist; |
| x->rdmult = orig_rdmult; |
| } |
| |
| static void encode_b_nonrd(const AV1_COMP *const cpi, TileDataEnc *tile_data, |
| ThreadData *td, TokenExtra **tp, int mi_row, |
| int mi_col, RUN_TYPE dry_run, BLOCK_SIZE bsize, |
| PARTITION_TYPE partition, |
| PICK_MODE_CONTEXT *const ctx, int *rate) { |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing((AV1_COMP *)cpi, encode_b_nonrd_time); |
| #endif |
| const AV1_COMMON *const cm = &cpi->common; |
| TileInfo *const tile = &tile_data->tile_info; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *xd = &x->e_mbd; |
| av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize); |
| const int origin_mult = x->rdmult; |
| setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL); |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| mbmi->partition = partition; |
| av1_update_state(cpi, td, ctx, mi_row, mi_col, bsize, dry_run); |
| const int subsampling_x = cpi->common.seq_params->subsampling_x; |
| const int subsampling_y = cpi->common.seq_params->subsampling_y; |
| if (!dry_run) { |
| set_cb_offsets(x->mbmi_ext_frame->cb_offset, x->cb_offset[PLANE_TYPE_Y], |
| x->cb_offset[PLANE_TYPE_UV]); |
| assert(x->cb_offset[PLANE_TYPE_Y] < |
| (1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size])); |
| assert(x->cb_offset[PLANE_TYPE_UV] < |
| ((1 << num_pels_log2_lookup[cpi->common.seq_params->sb_size]) >> |
| (subsampling_x + subsampling_y))); |
| } |
| |
| encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, rate); |
| if (!dry_run) { |
| update_cb_offsets(x, bsize, subsampling_x, subsampling_y); |
| if (has_second_ref(mbmi)) { |
| if (mbmi->compound_idx == 0 || |
| mbmi->interinter_comp.type == COMPOUND_AVERAGE) |
| mbmi->comp_group_idx = 0; |
| else |
| mbmi->comp_group_idx = 1; |
| mbmi->compound_idx = 1; |
| } |
| RD_COUNTS *const rdc = &td->rd_counts; |
| if (mbmi->skip_mode) { |
| assert(!frame_is_intra_only(cm)); |
| rdc->skip_mode_used_flag = 1; |
| if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT && |
| has_second_ref(mbmi)) { |
| rdc->compound_ref_used_flag = 1; |
| } |
| set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); |
| } else { |
| const int seg_ref_active = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_REF_FRAME); |
| if (!seg_ref_active) { |
| // If the segment reference feature is enabled we have only a single |
| // reference frame allowed for the segment so exclude it from |
| // the reference frame counts used to work out probabilities. |
| if (is_inter_block(mbmi)) { |
| av1_collect_neighbors_ref_counts(xd); |
| if (cm->current_frame.reference_mode == REFERENCE_MODE_SELECT && |
| has_second_ref(mbmi)) { |
| // This flag is also updated for 4x4 blocks |
| rdc->compound_ref_used_flag = 1; |
| } |
| set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]); |
| } |
| } |
| } |
| if (cpi->oxcf.algo_cfg.loopfilter_control == LOOPFILTER_SELECTIVELY && |
| (mbmi->mode == NEWMV || mbmi->mode < INTRA_MODE_END)) { |
| int32_t blocks = mi_size_high[bsize] * mi_size_wide[bsize]; |
| rdc->newmv_or_intra_blocks += blocks; |
| } |
| if (tile_data->allow_update_cdf) update_stats(&cpi->common, td); |
| } |
| if ((cpi->oxcf.q_cfg.aq_mode == CYCLIC_REFRESH_AQ || |
| cpi->active_map.enabled) && |
| mbmi->skip_txfm && !cpi->rc.rtc_external_ratectrl && cm->seg.enabled) |
| av1_cyclic_reset_segment_skip(cpi, x, mi_row, mi_col, bsize, dry_run); |
| // TODO(Ravi/Remya): Move this copy function to a better logical place |
| // This function will copy the best mode information from block |
| // level (x->mbmi_ext) to frame level (cpi->mbmi_ext_info.frame_base). This |
| // frame level buffer (cpi->mbmi_ext_info.frame_base) will be used during |
| // bitstream preparation. |
| av1_copy_mbmi_ext_to_mbmi_ext_frame(x->mbmi_ext_frame, &x->mbmi_ext, |
| av1_ref_frame_type(xd->mi[0]->ref_frame)); |
| x->rdmult = origin_mult; |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing((AV1_COMP *)cpi, encode_b_nonrd_time); |
| #endif |
| } |
| |
| static int get_force_zeromv_skip_flag_for_blk(const AV1_COMP *cpi, |
| const MACROBLOCK *x, |
| BLOCK_SIZE bsize) { |
| // Force zero MV skip based on SB level decision |
| if (x->force_zeromv_skip_for_sb < 2) return x->force_zeromv_skip_for_sb; |
| |
| // For blocks of size equal to superblock size, the decision would have been |
| // already done at superblock level. Hence zeromv-skip decision is skipped. |
| const AV1_COMMON *const cm = &cpi->common; |
| if (bsize == cm->seq_params->sb_size) return 0; |
| |
| const int num_planes = av1_num_planes(cm); |
| const MACROBLOCKD *const xd = &x->e_mbd; |
| const unsigned int thresh_exit_part_y = |
| cpi->zeromv_skip_thresh_exit_part[bsize]; |
| const unsigned int thresh_exit_part_uv = |
| CALC_CHROMA_THRESH_FOR_ZEROMV_SKIP(thresh_exit_part_y); |
| const unsigned int thresh_exit_part[MAX_MB_PLANE] = { thresh_exit_part_y, |
| thresh_exit_part_uv, |
| thresh_exit_part_uv }; |
| const YV12_BUFFER_CONFIG *const yv12 = get_ref_frame_yv12_buf(cm, LAST_FRAME); |
| const struct scale_factors *const sf = |
| get_ref_scale_factors_const(cm, LAST_FRAME); |
| |
| struct buf_2d yv12_mb[MAX_MB_PLANE]; |
| av1_setup_pred_block(xd, yv12_mb, yv12, sf, sf, num_planes); |
| |
| for (int plane = 0; plane < num_planes; ++plane) { |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const BLOCK_SIZE bs = |
| get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y); |
| const unsigned int plane_sad = cpi->ppi->fn_ptr[bs].sdf( |
| p->src.buf, p->src.stride, yv12_mb[plane].buf, yv12_mb[plane].stride); |
| assert(plane < MAX_MB_PLANE); |
| if (plane_sad >= thresh_exit_part[plane]) return 0; |
| } |
| return 1; |
| } |
| |
| /*!\brief Top level function to pick block mode for non-RD optimized case |
| * |
| * \ingroup partition_search |
| * \callgraph |
| * \callergraph |
| * Searches prediction modes, transform, and coefficient coding modes for an |
| * individual coding block. This function is the top-level function that is |
| * used for non-RD optimized mode search (controlled by |
| * \c cpi->sf.rt_sf.use_nonrd_pick_mode). Depending on frame type it calls |
| * inter/skip/hybrid-intra mode search functions |
| * |
| * \param[in] cpi Top-level encoder structure |
| * \param[in] tile_data Pointer to struct holding adaptive |
| * data/contexts/models for the tile during |
| * encoding |
| * \param[in] x Pointer to structure holding all the data for |
| * the current macroblock |
| * \param[in] mi_row Row coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] mi_col Column coordinate of the block in a step size of |
| * MI_SIZE |
| * \param[in] rd_cost Pointer to structure holding rate and distortion |
| * stats for the current block |
| * \param[in] bsize Current block size |
| * \param[in] ctx Pointer to structure holding coding contexts and |
| * chosen modes for the current block |
| * |
| * \remark Nothing is returned. Instead, the chosen modes and contexts necessary |
| * for reconstruction are stored in ctx, the rate-distortion stats are stored in |
| * rd_cost. If no valid mode leading to rd_cost <= best_rd, the status will be |
| * signalled by an INT64_MAX rd_cost->rdcost. |
| */ |
| static void pick_sb_modes_nonrd(AV1_COMP *const cpi, TileDataEnc *tile_data, |
| MACROBLOCK *const x, int mi_row, int mi_col, |
| RD_STATS *rd_cost, BLOCK_SIZE bsize, |
| PICK_MODE_CONTEXT *ctx) { |
| // For nonrd mode, av1_set_offsets is already called at the superblock level |
| // in encode_nonrd_sb when we determine the partitioning. |
| if (bsize != cpi->common.seq_params->sb_size || |
| cpi->sf.rt_sf.nonrd_check_partition_split == 1) { |
| av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize); |
| } |
| assert(x->last_set_offsets_loc.mi_row == mi_row && |
| x->last_set_offsets_loc.mi_col == mi_col && |
| x->last_set_offsets_loc.bsize == bsize); |
| AV1_COMMON *const cm = &cpi->common; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| MB_MODE_INFO *mbmi = xd->mi[0]; |
| struct macroblock_plane *const p = x->plane; |
| struct macroblockd_plane *const pd = xd->plane; |
| const AQ_MODE aq_mode = cpi->oxcf.q_cfg.aq_mode; |
| TxfmSearchInfo *txfm_info = &x->txfm_search_info; |
| int i; |
| const int seg_skip = |
| segfeature_active(&cm->seg, mbmi->segment_id, SEG_LVL_SKIP); |
| |
| // This is only needed for real time/allintra row-mt enabled multi-threaded |
| // encoding with cost update frequency set to COST_UPD_TILE/COST_UPD_OFF. |
| wait_for_top_right_sb(&cpi->mt_info.enc_row_mt, &tile_data->row_mt_sync, |
| &tile_data->tile_info, cm->seq_params->sb_size, |
| cm->seq_params->mib_size_log2, bsize, mi_row, mi_col); |
| |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, pick_sb_modes_nonrd_time); |
| #endif |
| // Sets up the tx_type_map buffer in MACROBLOCKD. |
| xd->tx_type_map = txfm_info->tx_type_map_; |
| xd->tx_type_map_stride = mi_size_wide[bsize]; |
| for (i = 0; i < num_planes; ++i) { |
| p[i].coeff = ctx->coeff[i]; |
| p[i].qcoeff = ctx->qcoeff[i]; |
| p[i].dqcoeff = ctx->dqcoeff[i]; |
| p[i].eobs = ctx->eobs[i]; |
| p[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i]; |
| } |
| for (i = 0; i < 2; ++i) pd[i].color_index_map = ctx->color_index_map[i]; |
| |
| if (!seg_skip) { |
| x->force_zeromv_skip_for_blk = |
| get_force_zeromv_skip_flag_for_blk(cpi, x, bsize); |
| |
| // Source variance may be already compute at superblock level, so no need |
| // to recompute, unless bsize < sb_size or source_variance is not yet set. |
| if (!x->force_zeromv_skip_for_blk && |
| (x->source_variance == UINT_MAX || bsize < cm->seq_params->sb_size)) |
| x->source_variance = av1_get_perpixel_variance_facade( |
| cpi, xd, &x->plane[0].src, bsize, AOM_PLANE_Y); |
| } |
| |
| // Save rdmult before it might be changed, so it can be restored later. |
| const int orig_rdmult = x->rdmult; |
| setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, aq_mode, mbmi); |
| // Set error per bit for current rdmult |
| av1_set_error_per_bit(&x->errorperbit, x->rdmult); |
| // Find best coding mode & reconstruct the MB so it is available |
| // as a predictor for MBs that follow in the SB |
| if (frame_is_intra_only(cm)) { |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, hybrid_intra_mode_search_time); |
| #endif |
| hybrid_intra_mode_search(cpi, x, rd_cost, bsize, ctx); |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, hybrid_intra_mode_search_time); |
| #endif |
| } else { |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| start_timing(cpi, nonrd_pick_inter_mode_sb_time); |
| #endif |
| if (seg_skip) { |
| x->force_zeromv_skip_for_blk = 1; |
| // TODO(marpan): Consider adding a function for nonrd: |
| // av1_nonrd_pick_inter_mode_sb_seg_skip(), instead of setting |
| // x->force_zeromv_skip flag and entering av1_nonrd_pick_inter_mode_sb(). |
| } |
| av1_nonrd_pick_inter_mode_sb(cpi, tile_data, x, rd_cost, bsize, ctx); |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, nonrd_pick_inter_mode_sb_time); |
| #endif |
| } |
| if (cpi->sf.rt_sf.skip_cdef_sb) { |
| // cdef_strength is initialized to 1 which means skip_cdef, and is updated |
| // here. Check to see is skipping cdef is allowed. Never skip on slide/scene |
| // change, near a key frame, or when color sensitivity is set. Always allow |
| // cdef_skip for seg_skip = 1. |
| const int allow_cdef_skipping = |
| seg_skip || |
| (cpi->rc.frames_since_key > 10 && !cpi->rc.high_source_sad && |
| !(x->color_sensitivity[COLOR_SENS_IDX(AOM_PLANE_U)] || |
| x->color_sensitivity[COLOR_SENS_IDX(AOM_PLANE_V)])); |
| |
| // Find the corresponding 64x64 block. It'll be the 128x128 block if that's |
| // the block size. |
| const int mi_row_sb = mi_row - mi_row % MI_SIZE_64X64; |
| const int mi_col_sb = mi_col - mi_col % MI_SIZE_64X64; |
| MB_MODE_INFO **mi_sb = |
| cm->mi_params.mi_grid_base + |
| get_mi_grid_idx(&cm->mi_params, mi_row_sb, mi_col_sb); |
| const int is_720p_or_larger = AOMMIN(cm->width, cm->height) >= 720; |
| unsigned int thresh_spatial_var = |
| (cpi->oxcf.speed >= 11 && !is_720p_or_larger && |
| cpi->oxcf.tune_cfg.content != AOM_CONTENT_SCREEN) |
| ? 400 |
| : UINT_MAX; |
| // For skip_cdef_sb = 1: do not skip if allow_cdef_skipping is false or |
| // intra or new mv is picked, with possible conidition on spatial variance. |
| // For skip_cdef_sb >= 2: more aggressive mode to always skip unless |
| // allow_cdef_skipping is false and source_variance is non-zero. |
| if (cpi->sf.rt_sf.skip_cdef_sb >= 2) { |
| mi_sb[0]->cdef_strength = |
| mi_sb[0]->cdef_strength && |
| (allow_cdef_skipping || x->source_variance == 0); |
| } else { |
| mi_sb[0]->cdef_strength = |
| mi_sb[0]->cdef_strength && allow_cdef_skipping && |
| !(x->source_variance < thresh_spatial_var && |
| (mbmi->mode < INTRA_MODES || mbmi->mode == NEWMV)); |
| } |
| // Store in the pickmode context. |
| ctx->mic.cdef_strength = mi_sb[0]->cdef_strength; |
| } |
| x->rdmult = orig_rdmult; |
| ctx->rd_stats.rate = rd_cost->rate; |
| ctx->rd_stats.dist = rd_cost->dist; |
| ctx->rd_stats.rdcost = rd_cost->rdcost; |
| #if CONFIG_COLLECT_COMPONENT_TIMING |
| end_timing(cpi, pick_sb_modes_nonrd_time); |
| #endif |
| } |
| |
| static int try_split_partition(AV1_COMP *const cpi, ThreadData *const td, |
| TileDataEnc *const tile_data, |
| TileInfo *const tile_info, TokenExtra **tp, |
| MACROBLOCK *const x, MACROBLOCKD *const xd, |
| const CommonModeInfoParams *const mi_params, |
| const int mi_row, const int mi_col, |
| const BLOCK_SIZE bsize, const int pl, |
| PC_TREE *pc_tree) { |
| AV1_COMMON *const cm = &cpi->common; |
| const ModeCosts *mode_costs = &x->mode_costs; |
| const int hbs = mi_size_wide[bsize] / 2; |
| if (mi_row + mi_size_high[bsize] >= mi_params->mi_rows || |
| mi_col + mi_size_wide[bsize] >= mi_params->mi_cols) |
| return 0; |
| if (bsize <= BLOCK_8X8 || frame_is_intra_only(cm)) return 0; |
| if (x->content_state_sb.source_sad_nonrd <= kLowSad) return 0; |
| |
| // Do not try split partition when the source sad is small, or |
| // the prediction residual is small. |
| const YV12_BUFFER_CONFIG *const yv12 = get_ref_frame_yv12_buf(cm, LAST_FRAME); |
| const struct scale_factors *const sf = |
| get_ref_scale_factors_const(cm, LAST_FRAME); |
| const int num_planes = av1_num_planes(cm); |
| av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, bsize); |
| av1_setup_pre_planes(xd, 0, yv12, mi_row, mi_col, sf, num_planes); |
| int block_sad = 0; |
| for (int plane = 0; plane < num_planes; ++plane) { |
| const struct macroblock_plane *const p = &x->plane[plane]; |
| const struct macroblockd_plane *const pd = &xd->plane[plane]; |
| const BLOCK_SIZE bs = |
| get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y); |
| const unsigned int plane_sad = cpi->ppi->fn_ptr[bs].sdf( |
| p->src.buf, p->src.stride, pd->pre[0].buf, pd->pre[0].stride); |
| block_sad += plane_sad; |
| } |
| const int blk_pix = block_size_wide[bsize] * block_size_high[bsize]; |
| const int block_avg_sad = block_sad / blk_pix; |
| // TODO(chengchen): find a proper threshold. It might change according to |
| // q as well. |
| const int threshold = 25; |
| if (block_avg_sad < threshold) return 0; |
| |
| RD_SEARCH_MACROBLOCK_CONTEXT x_ctx; |
| RD_STATS split_rdc, none_rdc; |
| av1_invalid_rd_stats(&split_rdc); |
| av1_invalid_rd_stats(&none_rdc); |
| av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, 3); |
| xd->above_txfm_context = |
| cm->above_contexts.txfm[tile_info->tile_row] + mi_col; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK); |
| |
| // Calculate rdcost for none partition |
| pc_tree->partitioning = PARTITION_NONE; |
| av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize); |
| if (!pc_tree->none) { |
| pc_tree->none = av1_alloc_pmc(cpi, bsize, &td->shared_coeff_buf); |
| if (!pc_tree->none) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| } else { |
| av1_reset_pmc(pc_tree->none); |
| } |
| pick_sb_modes_nonrd(cpi, tile_data, x, mi_row, mi_col, &none_rdc, bsize, |
| pc_tree->none); |
| none_rdc.rate += mode_costs->partition_cost[pl][PARTITION_NONE]; |
| none_rdc.rdcost = RDCOST(x->rdmult, none_rdc.rate, none_rdc.dist); |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, 3); |
| |
| // Calculate rdcost for split partition |
| pc_tree->partitioning = PARTITION_SPLIT; |
| const BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_SPLIT); |
| av1_init_rd_stats(&split_rdc); |
| split_rdc.rate += mode_costs->partition_cost[pl][PARTITION_SPLIT]; |
| if (subsize >= BLOCK_8X8) { |
| split_rdc.rate += (mode_costs->partition_cost[pl][PARTITION_NONE] * 4); |
| } |
| for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++i) { |
| if (!pc_tree->split[i]) { |
| pc_tree->split[i] = av1_alloc_pc_tree_node(subsize); |
| if (!pc_tree->split[i]) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PC_TREE"); |
| } |
| pc_tree->split[i]->index = i; |
| } |
| for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) { |
| RD_STATS block_rdc; |
| av1_invalid_rd_stats(&block_rdc); |
| int x_idx = (i & 1) * hbs; |
| int y_idx = (i >> 1) * hbs; |
| if ((mi_row + y_idx >= mi_params->mi_rows) || |
| (mi_col + x_idx >= mi_params->mi_cols)) |
| continue; |
| xd->above_txfm_context = |
| cm->above_contexts.txfm[tile_info->tile_row] + mi_col + x_idx; |
| xd->left_txfm_context = |
| xd->left_txfm_context_buffer + ((mi_row + y_idx) & MAX_MIB_MASK); |
| if (!pc_tree->split[i]->none) { |
| pc_tree->split[i]->none = |
| av1_alloc_pmc(cpi, subsize, &td->shared_coeff_buf); |
| if (!pc_tree->split[i]->none) |
| aom_internal_error(xd->error_info, AOM_CODEC_MEM_ERROR, |
| "Failed to allocate PICK_MODE_CONTEXT"); |
| } else { |
| av1_reset_pmc(pc_tree->split[i]->none); |
| } |
| pc_tree->split[i]->partitioning = PARTITION_NONE; |
| pick_sb_modes_nonrd(cpi, tile_data, x, mi_row + y_idx, mi_col + x_idx, |
| &block_rdc, subsize, pc_tree->split[i]->none); |
| split_rdc.rate += block_rdc.rate; |
| split_rdc.dist += block_rdc.dist; |
| av1_rd_cost_update(x->rdmult, &split_rdc); |
| if (none_rdc.rdcost < split_rdc.rdcost) break; |
| if (i != SUB_PARTITIONS_SPLIT - 1) |
| encode_b_nonrd(cpi, tile_data, td, tp, mi_row + y_idx, mi_col + x_idx, 1, |
| subsize, PARTITION_NONE, pc_tree->split[i]->none, NULL); |
| } |
| av1_restore_context(x, &x_ctx, mi_row, mi_col, bsize, 3); |
| split_rdc.rdcost = RDCOST(x->rdmult, split_rdc.rate, split_rdc.dist); |
| const int split = split_rdc.rdcost < none_rdc.rdcost; |
| |
| return split; |
| } |
| |
| // Returns if SPLIT partitions should be evaluated |
| static bool calc_do_split_flag(const AV1_COMP *cpi, const MACROBLOCK *x, |
| const PC_TREE *pc_tree, const RD_STATS *none_rdc, |
| const CommonModeInfoParams *mi_params, |
| int mi_row, int mi_col, int hbs, |
| BLOCK_SIZE bsize, PARTITION_TYPE partition) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const int is_larger_qindex = cm->quant_params.base_qindex > 100; |
| const MACROBLOCKD *const xd = &x->e_mbd; |
| bool do_split = |
| (cpi->sf.rt_sf.nonrd_check_partition_merge_mode == 3) |
| ? (bsize <= BLOCK_32X32 || (is_larger_qindex && bsize <= BLOCK_64X64)) |
| : true; |
| if (cpi->oxcf.tune_cfg.content == AOM_CONTENT_SCREEN || |
| cpi->sf.rt_sf.nonrd_check_partition_merge_mode < 2 || |
| cyclic_refresh_segment_id_boosted(xd->mi[0]->segment_id) || |
| !none_rdc->skip_txfm) |
| return do_split; |
| |
| const int use_model_yrd_large = get_model_rd_flag(cpi, xd, bsize); |
| |
| // When model based skip is not used (i.e.,use_model_yrd_large = 0), skip_txfm |
| // would have been populated based on Hadamard transform and skip_txfm flag is |
| // more reliable. Hence SPLIT evaluation is disabled at all quantizers for 8x8 |
| // and 16x16 blocks. |
| // When model based skip is used (i.e.,use_model_yrd_large = 1), skip_txfm may |
| // not be reliable. Hence SPLIT evaluation is disabled only at lower |
| // quantizers for blocks >= 32x32. |
| if ((!use_model_yrd_large) || (!is_larger_qindex)) return false; |
| |
| // Use residual statistics to decide if SPLIT partition should be evaluated |
| // for 32x32 blocks. The pruning logic is avoided for larger block size to |
| // avoid the visual artifacts |
| if (pc_tree->none->mic.mode == NEWMV && bsize == BLOCK_32X32 && do_split) { |
| const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition); |
| assert(subsize < BLOCK_SIZES_ALL); |
| double min_per_pixel_error = DBL_MAX; |
| double max_per_pixel_error = 0.; |
| int i; |
| for (i = 0; i < SUB_PARTITIONS_SPLIT; i++) { |
| const int x_idx = (i & 1) * hbs; |
| const int y_idx = (i >> 1) * hbs; |
| if ((mi_row + y_idx >= mi_params->mi_rows) || |
|