Google Git
Sign in
aomedia / avm / refs/heads/main / . / av1 / encoder / partition_search.c
blob: 29e3198606ce5b79801352e485e3b46aa4c5154a [file] [log] [blame]
/*
* Copyright (c) 2021, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 3-Clause Clear License
* and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear
* License was not distributed with this source code in the LICENSE file, you
* can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. 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
* aomedia.org/license/patent-license/.
*/
#include "aom/aom_codec.h"
#include "aom_ports/system_state.h"
#include "av1/common/av1_common_int.h"
#include "av1/common/blockd.h"
#include "av1/common/common_data.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/block.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/motion_search_facade.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/common/reconinter.h"
#if CONFIG_EXT_RECUR_PARTITIONS
#include "av1/encoder/erp_tflite.h"
#endif // CONFIG_EXT_RECUR_PARTITIONS
#include "aom_util/debug_util.h"
#if CONFIG_TUNE_VMAF
#include "av1/encoder/tune_vmaf.h"
#endif
#if CONFIG_NEW_TX_PARTITION
static void update_partition_cdfs_and_counts(MACROBLOCKD *xd, int blk_col,
int blk_row, TX_SIZE max_tx_size,
int allow_update_cdf,
FRAME_COUNTS *counts) {
(void)counts;
MB_MODE_INFO *mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->sb_type[xd->tree_type == CHROMA_PART];
const int is_inter = is_inter_block(mbmi, xd->tree_type);
const int txb_size_index =
is_inter ? av1_get_txb_size_index(bsize, blk_row, blk_col) : 0;
#if !CONFIG_TX_PARTITION_CTX
const int is_rect = is_rect_tx(max_tx_size);
#endif // !CONFIG_TX_PARTITION_CTX
const TX_PARTITION_TYPE partition = mbmi->tx_partition_type[txb_size_index];
const int allow_horz = allow_tx_horz_split(max_tx_size);
const int allow_vert = allow_tx_vert_split(max_tx_size);
#if CONFIG_IMPROVEIDTX_CTXS
const int plane_type = xd->tree_type == CHROMA_PART;
const int is_fsc = (xd->mi[0]->fsc_mode[xd->tree_type == CHROMA_PART] &&
plane_type == PLANE_TYPE_Y);
#endif // CONFIG_IMPROVEIDTX_CTXS
#if CONFIG_TX_PARTITION_CTX
const int bsize_group = size_to_tx_part_group_lookup[bsize];
int do_partition = 0;
if (allow_horz || allow_vert) {
do_partition = (partition != TX_PARTITION_NONE);
if (allow_update_cdf) {
aom_cdf_prob *do_partition_cdf =
#if CONFIG_IMPROVEIDTX_CTXS
xd->tile_ctx->txfm_do_partition_cdf[is_fsc][is_inter][bsize_group];
#else
xd->tile_ctx->txfm_do_partition_cdf[is_inter][bsize_group];
#endif // CONFIG_IMPROVEIDTX_CTXS
update_cdf(do_partition_cdf, do_partition, 2);
}
#if CONFIG_ENTROPY_STATS
#if CONFIG_IMPROVEIDTX_CTXS
++counts->txfm_do_partition[is_fsc][is_inter][bsize_group][do_partition];
#else
++counts->txfm_do_partition[is_inter][bsize_group][do_partition];
#endif // CONFIG_IMPROVEIDTX_CTXS
#endif // CONFIG_ENTROPY_STATS
}
if (do_partition) {
if (allow_horz && allow_vert) {
assert(bsize_group > 0);
const TX_PARTITION_TYPE split4_partition =
get_split4_partition(partition);
if (allow_update_cdf) {
aom_cdf_prob *partition_type_cdf =
#if CONFIG_IMPROVEIDTX_CTXS
xd->tile_ctx->txfm_4way_partition_type_cdf[is_fsc][is_inter]
[bsize_group - 1];
#else
xd->tile_ctx
->txfm_4way_partition_type_cdf[is_inter][bsize_group - 1];
#endif // CONFIG_IMPROVEIDTX_CTXS
update_cdf(partition_type_cdf, split4_partition - 1, 3);
}
#if CONFIG_ENTROPY_STATS
#if CONFIG_IMPROVEIDTX_CTXS
++counts->txfm_4way_partition_type[is_fsc][is_inter][bsize_group - 1]
[split4_partition - 1];
#else
++counts->txfm_4way_partition_type[is_inter][bsize_group - 1]
[split4_partition - 1];
#endif // CONFIG_IMPROVEIDTX_CTXS
#endif // CONFIG_ENTROPY_STATS
}
}
#else
if (allow_horz && allow_vert) {
const TX_PARTITION_TYPE split4_partition = get_split4_partition(partition);
const int split4_ctx =
is_inter ? txfm_partition_split4_inter_context(
xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, bsize, max_tx_size)
: get_tx_size_context(xd);
aom_cdf_prob *split4_cdf =
is_inter
? xd->tile_ctx->inter_4way_txfm_partition_cdf[is_rect][split4_ctx]
: xd->tile_ctx->intra_4way_txfm_partition_cdf[is_rect][split4_ctx];
if (allow_update_cdf) {
update_cdf(split4_cdf, split4_partition, 4);
}
#if CONFIG_ENTROPY_STATS
if (is_inter)
++counts
->inter_4way_txfm_partition[is_rect][split4_ctx][split4_partition];
else
++counts
->intra_4way_txfm_partition[is_rect][split4_ctx][split4_partition];
#endif // CONFIG_ENTROPY_STATS
} else if (allow_horz || allow_vert) {
const int has_first_split = partition != TX_PARTITION_NONE;
if (allow_update_cdf) {
aom_cdf_prob *split2_cdf =
is_inter ? xd->tile_ctx->inter_2way_txfm_partition_cdf
: xd->tile_ctx->intra_2way_txfm_partition_cdf;
update_cdf(split2_cdf, has_first_split, 2);
}
#if CONFIG_ENTROPY_STATS
if (is_inter)
++counts->inter_2way_txfm_partition[has_first_split];
else
++counts->intra_2way_txfm_partition[has_first_split];
#endif // CONFIG_ENTROPY_STATS
} else {
assert(!allow_horz && !allow_vert);
assert(partition == PARTITION_NONE);
}
#endif // CONFIG_TX_PARTITION_CTX
}
#endif // CONFIG_NEW_TX_PARTITION
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->sb_type[xd->tree_type == CHROMA_PART];
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);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
assert(tx_size > TX_4X4);
#if CONFIG_NEW_TX_PARTITION
(void)depth;
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
get_tx_partition_sizes(mbmi->tx_partition_type[txb_size_index], tx_size,
sub_txs);
// TODO(sarahparker) This assumes all of the tx sizes in the partition scheme
// are the same size. This will need to be adjusted to deal with the case
// where they can be different.
TX_SIZE this_size = sub_txs[0];
assert(mbmi->inter_tx_size[txb_size_index] == this_size);
if (mbmi->tx_partition_type[txb_size_index] != TX_PARTITION_NONE)
++x->txfm_search_info.txb_split_count;
update_partition_cdfs_and_counts(xd, blk_col, blk_row, tx_size,
allow_update_cdf, counts);
mbmi->tx_size = this_size;
#if !CONFIG_TX_PARTITION_CTX
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, this_size, tx_size);
#endif // !CONFIG_TX_PARTITION_CTX
#else // CONFIG_NEW_TX_PARTITION
int ctx = txfm_partition_context(
xd->above_txfm_context + blk_col, xd->left_txfm_context + blk_row,
mbmi->sb_type[xd->tree_type == CHROMA_PART], tx_size);
const TX_SIZE plane_tx_size = mbmi->inter_tx_size[txb_size_index];
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);
}
}
}
#endif // CONFIG_NEW_TX_PARTITION
}
static void tx_partition_count_update(
#if !CONFIG_TX_PARTITION_CTX
const AV1_COMMON *const cm,
#endif // !CONFIG_TX_PARTITION_CTX
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];
#if !CONFIG_TX_PARTITION_CTX
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);
#endif // !CONFIG_TX_PARTITION_CTX
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);
}
}
}
#if !CONFIG_TX_PARTITION_CTX
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->sb_type[xd->tree_type == CHROMA_PART];
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 CONFIG_NEW_TX_PARTITION
TX_SIZE sub_txs[MAX_TX_PARTITIONS] = { 0 };
const int index = av1_get_txb_size_index(bsize, blk_row, blk_col);
get_tx_partition_sizes(mbmi->tx_partition_type[index], tx_size, sub_txs);
int cur_partition = 0;
int bsw = 0, bsh = 0;
for (int r = 0; r < tx_size_high_unit[tx_size]; r += bsh) {
for (int c = 0; c < tx_size_wide_unit[tx_size]; c += bsw) {
const TX_SIZE sub_tx = sub_txs[cur_partition];
bsw = tx_size_wide_unit[sub_tx];
bsh = tx_size_high_unit[sub_tx];
const int offsetr = blk_row + r;
const int offsetc = blk_col + c;
if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
mbmi->tx_size = sub_tx;
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, sub_tx, sub_tx);
cur_partition++;
}
}
#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];
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) {
const int offsetr = blk_row + row;
const int offsetc = blk_col + col;
if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue;
set_txfm_context(xd, sub_txs, offsetr, offsetc);
}
}
#endif // CONFIG_NEW_TX_PARTITION
}
}
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);
}
}
}
#endif // !CONFIG_TX_PARTITION_CTX
static void encode_superblock(const AV1_COMP *const cpi, TileDataEnc *tile_data,
ThreadData *td, TokenExtra **t, RUN_TYPE dry_run,
BLOCK_SIZE bsize, int plane_start, int plane_end,
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, xd->tree_type);
xd->cfl.use_dc_pred_cache = 0;
xd->cfl.dc_pred_is_cached[0] = 0;
xd->cfl.dc_pred_is_cached[1] = 0;
// 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
#if CONFIG_EXT_RECUR_PARTITIONS
,
x, cpi->sf.tx_sf.use_largest_tx_size_for_small_bsize
#endif // CONFIG_EXT_RECUR_PARTITIONS
);
const int mi_row = xd->mi_row;
const int mi_col = xd->mi_col;
if (!is_inter) {
if (xd->tree_type != LUMA_PART) {
xd->cfl.store_y = store_cfl_required(cm, xd);
}
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] = 1;
for (int plane = plane_start; plane < plane_end; ++plane) {
if (plane == AOM_PLANE_Y || !is_cctx_allowed(cm, xd))
av1_encode_intra_block_plane(cpi, x, bsize, plane, dry_run,
cpi->optimize_seg_arr[mbmi->segment_id]);
else if (plane == AOM_PLANE_U)
av1_encode_intra_block_joint_uv(
cpi, x, bsize, 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[xd->tree_type == CHROMA_PART] = 0;
xd->cfl.store_y = 0;
if (av1_allow_palette(cm->features.allow_screen_content_tools, bsize)) {
for (int plane = plane_start; plane < AOMMIN(2, plane_end); ++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, xd->tree_type), cfg));
av1_setup_pre_planes(xd, ref, cfg, mi_row, mi_col,
xd->block_ref_scale_factors[ref], num_planes,
&mbmi->chroma_ref_info);
}
int start_plane = 0;
#if CONFIG_BAWP
struct macroblockd_plane *p = xd->plane;
const BUFFER_SET orig_dst = {
{ p[0].dst.buf, p[1].dst.buf, p[2].dst.buf },
{ p[0].dst.stride, p[1].dst.stride, p[2].dst.stride },
};
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, &orig_dst, bsize,
#else
av1_enc_build_inter_predictor(cm, xd, mi_row, mi_col, NULL, bsize,
#endif
start_plane, av1_num_planes(cm) - 1);
if (mbmi->motion_mode == OBMC_CAUSAL) {
#if CONFIG_EXTENDED_WARP_PREDICTION
assert(cm->features.enabled_motion_modes & (1 << OBMC_CAUSAL));
#else
assert(cpi->oxcf.motion_mode_cfg.enable_obmc);
#endif
av1_build_obmc_inter_predictors_sb(cm, xd);
}
#if CONFIG_MISMATCH_DEBUG
if (dry_run == OUTPUT_ENABLED) {
for (int plane = plane_start; plane < plane_end; ++plane) {
const struct macroblockd_plane *pd = &xd->plane[plane];
int pixel_c, pixel_r;
if (plane && !xd->is_chroma_ref) continue;
if (plane) {
mi_to_pixel_loc(&pixel_c, &pixel_r,
mbmi->chroma_ref_info.mi_col_chroma_base,
mbmi->chroma_ref_info.mi_row_chroma_base, 0, 0,
pd->subsampling_x, pd->subsampling_y);
} else {
mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0,
pd->subsampling_x, pd->subsampling_y);
}
mismatch_record_block_pre(pd->dst.buf, pd->dst.stride,
#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
cm->current_frame.display_order_hint,
#else
cm->current_frame.order_hint,
#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
plane, pixel_c, pixel_r, pd->width,
pd->height);
}
}
#else
(void)num_planes;
#endif // CONFIG_MISMATCH_DEBUG
av1_encode_sb(cpi, x, bsize, dry_run, plane_start, plane_end);
av1_tokenize_sb_vartx(cpi, td, dry_run, bsize, rate,
tile_data->allow_update_cdf, plane_start, plane_end);
}
if (!dry_run) {
if (av1_allow_intrabc(cm) && is_intrabc_block(mbmi, xd->tree_type))
td->intrabc_used = 1;
#if CONFIG_MORPH_PRED
if (mbmi->morph_pred) {
assert(av1_allow_intrabc(cm));
assert(is_intrabc_block(mbmi, xd->tree_type));
}
#endif // CONFIG_MORPH_PRED
if (txfm_params->tx_mode_search_type == TX_MODE_SELECT &&
!xd->lossless[mbmi->segment_id] &&
mbmi->sb_type[xd->tree_type == CHROMA_PART] > BLOCK_4X4 &&
!(is_inter &&
(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] || seg_skip))) {
if (is_inter) {
tx_partition_count_update(
#if !CONFIG_TX_PARTITION_CTX
cm,
#endif // !CONFIG_TX_PARTITION_CTX
x, bsize, td->counts, tile_data->allow_update_cdf);
} else {
if (mbmi->tx_size != max_txsize_rect_lookup[bsize] &&
xd->tree_type != CHROMA_PART)
++x->txfm_search_info.txb_split_count;
if (block_signals_txsize(bsize) && xd->tree_type != CHROMA_PART) {
#if CONFIG_NEW_TX_PARTITION
const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
update_partition_cdfs_and_counts(
xd, 0, 0, max_tx_size, tile_data->allow_update_cdf, td->counts);
#else // CONFIG_NEW_TX_PARTITION
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
#endif // CONFIG_NEW_TX_PARTITION
}
}
if (xd->tree_type != CHROMA_PART)
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;
}
for (j = 0; j < mi_height; j++)
for (i = 0; i < mi_width; i++)
if (mi_col + i < cm->mi_params.mi_cols &&
mi_row + j < cm->mi_params.mi_rows)
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 !CONFIG_MVP_IMPROVEMENT
#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(mbmi, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
#endif // !CONFIG_MVP_IMPROVEMENT
#if CONFIG_EXTENDED_WARP_PREDICTION && !WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, mbmi);
#endif // CONFIG_EXTENDED_WARP_PREDICTION && !WARP_CU_BANK
}
if (txfm_params->tx_mode_search_type == TX_MODE_SELECT &&
block_signals_txsize(mbmi->sb_type[xd->tree_type == CHROMA_PART]) &&
is_inter &&
!(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] || seg_skip) &&
!xd->lossless[mbmi->segment_id]) {
#if !CONFIG_TX_PARTITION_CTX
if (dry_run) tx_partition_set_contexts(cm, xd, bsize);
#endif // !CONFIG_TX_PARTITION_CTX
} 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;
#if !CONFIG_TX_PARTITION_CTX
set_txfm_ctxs(tx_size, xd->width, xd->height,
(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] || seg_skip) &&
is_inter_block(mbmi, xd->tree_type),
xd);
#endif // !CONFIG_TX_PARTITION_CTX
}
if (is_inter_block(mbmi, xd->tree_type) && !xd->is_chroma_ref &&
is_cfl_allowed(xd)) {
#if CONFIG_IMPROVED_CFL
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
mbmi->tx_size, cm->seq_params.enable_cfl_ds_filter);
#else
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
mbmi->tx_size);
#endif // CONFIG_IMPROVED_CFL
}
if (xd->tree_type == LUMA_PART) {
const CommonModeInfoParams *const mi_params = &cm->mi_params;
for (int y = 0; y < mi_height; y++) {
for (int x_idx = 0; x_idx < mi_width; x_idx++) {
if ((xd->mb_to_right_edge >> (3 + MI_SIZE_LOG2)) + mi_width > x_idx &&
(xd->mb_to_bottom_edge >> (3 + MI_SIZE_LOG2)) + mi_height > y) {
if (y == 0 && x_idx == 0) continue;
const int mi_idx =
get_alloc_mi_idx(mi_params, mi_row + y, mi_col + x_idx);
xd->mi[x_idx + y * mis] = &mi_params->mi_alloc[mi_idx];
xd->mi[x_idx + y * mis]->skip_txfm[PLANE_TYPE_Y] =
xd->mi[0]->skip_txfm[PLANE_TYPE_Y];
}
}
}
}
av1_mark_block_as_coded(xd, bsize, cm->sb_size);
}
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;
MACROBLOCKD *const xd = &x->e_mbd;
if (aq_mode != NO_AQ && xd->tree_type == SHARED_PART) {
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_segment_rdmult(cpi, x, mbmi->segment_id);
} else if (aq_mode == COMPLEXITY_AQ) {
x->rdmult = set_segment_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);
}
}
const AV1_COMMON *const cm = &cpi->common;
if (cm->delta_q_info.delta_q_present_flag) {
x->rdmult =
av1_get_hier_tpl_rdmult(cpi, x, bsize, mi_row, mi_col, x->rdmult);
}
if (cpi->oxcf.tune_cfg.tuning == AOM_TUNE_SSIM) {
av1_set_ssim_rdmult(cpi, &x->mv_costs, bsize, mi_row, mi_col, &x->rdmult);
}
#if CONFIG_TUNE_VMAF
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
}
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 CHROMA_REF_INFO *chroma_ref_info) {
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
#if CONFIG_C071_SUBBLK_WARPMV
,
mi_width, mi_height
#endif // CONFIG_C071_SUBBLK_WARPMV
);
set_entropy_context(xd, mi_row, mi_col, num_planes, chroma_ref_info);
#if !CONFIG_TX_PARTITION_CTX
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);
#endif // !CONFIG_TX_PARTITION_CTX
// Set up destination pointers.
av1_setup_dst_planes(xd->plane, &cm->cur_frame->buf, mi_row, mi_col, 0,
num_planes, chroma_ref_info);
// 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, chroma_ref_info);
// Set up distance of MB to edge of frame in 1/8th pel units.
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(!(mi_col & (mi_width - 1)) && !(mi_row & (mi_height - 1)));
#endif // !CONFIG_EXT_RECUR_PARTITIONS
set_mi_row_col(xd, tile, mi_row, mi_height, mi_col, mi_width,
cm->mi_params.mi_rows, cm->mi_params.mi_cols, chroma_ref_info);
// Set up source buffers.
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes,
chroma_ref_info);
// 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 CHROMA_REF_INFO *chroma_ref_info) {
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,
chroma_ref_info);
// 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);
}
}
/*!\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
*
* 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 (best_rd.rdcost < 0) {
ctx->rd_stats.rdcost = INT64_MAX;
ctx->rd_stats.skip_txfm = 0;
av1_invalid_rd_stats(rd_cost);
return;
}
AV1_COMMON *const cm = &cpi->common;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
int plane_type = (xd->tree_type == CHROMA_PART);
assert(is_bsize_geq(bsize, cpi->common.mi_params.mi_alloc_bsize));
av1_set_offsets(cpi, &tile_data->tile_info, x, mi_row, mi_col, bsize,
&ctx->chroma_ref_info);
if (ctx->rd_mode_is_ready) {
assert(ctx->mic.sb_type[plane_type] == 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;
#if CONFIG_MVP_IMPROVEMENT
const int is_inter = is_inter_block(&ctx->mic, xd->tree_type);
#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(&ctx->mic, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, &ctx->mic);
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, &ctx->mic);
#endif // WARP_CU_BANK
return;
}
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;
#if CONFIG_COLLECT_COMPONENT_TIMING
start_timing(cpi, rd_pick_sb_modes_time);
#endif
aom_clear_system_state();
mbmi = xd->mi[0];
mbmi->sb_type[plane_type] = bsize;
if (xd->tree_type == SHARED_PART) mbmi->sb_type[PLANE_TYPE_UV] = bsize;
mbmi->partition = partition;
mbmi->chroma_ref_info = ctx->chroma_ref_info;
#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];
const BLOCK_SIZE chroma_bsize = get_bsize_base(xd, &ctx->mic, AOM_PLANE_U);
xd->cctx_type_map = txfm_info->cctx_type_map_;
xd->cctx_type_map_stride = mi_size_wide[chroma_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].bobs = ctx->bobs[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[xd->tree_type == CHROMA_PART] = 0;
// Reset skip mode flag.
mbmi->skip_mode = 0;
x->source_variance =
av1_high_get_sby_perpixel_variance(cpi, &x->plane[0].src, bsize, xd->bd);
// 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->mv_costs, x->rdmult);
av1_rd_cost_update(x->rdmult, &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_sb(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
}
#if CONFIG_MVP_IMPROVEMENT
const int is_inter = is_inter_block(mbmi, xd->tree_type);
#if CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
if (cm->seq_params.enable_refmvbank && is_inter &&
!is_intrabc_block(mbmi, xd->tree_type))
#else
if (cm->seq_params.enable_refmvbank && is_inter)
#endif // CONFIG_IBC_SR_EXT && !CONFIG_IBC_BV_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, mbmi);
#endif // WARP_CU_BANK
// 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_drl_index_stats(int max_drl_bits, const int16_t mode_ctx,
FRAME_CONTEXT *fc, FRAME_COUNTS *counts,
const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT *mbmi_ext) {
#if !CONFIG_ENTROPY_STATS
(void)counts;
#endif // !CONFIG_ENTROPY_STATS
assert(have_drl_index(mbmi->mode));
#if CONFIG_EXTENDED_WARP_PREDICTION
assert(IMPLIES(mbmi->mode == WARPMV, 0));
#endif // CONFIG_EXTENDED_WARP_PREDICTION
if (mbmi->mode == AMVDNEWMV) max_drl_bits = AOMMIN(max_drl_bits, 1);
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
#if CONFIG_SEP_COMP_DRL
assert(mbmi->ref_mv_idx[0] < max_drl_bits + 1);
assert(mbmi->ref_mv_idx[1] < max_drl_bits + 1);
for (int ref = 0; ref < 1 + has_second_drl(mbmi); ++ref) {
for (int idx = 0; idx < max_drl_bits; ++idx) {
const uint16_t *weight = has_second_drl(mbmi)
? mbmi_ext->weight[mbmi->ref_frame[ref]]
: mbmi_ext->weight[ref_frame_type];
aom_cdf_prob *drl_cdf = av1_get_drl_cdf(fc, weight, mode_ctx, idx);
#if CONFIG_IMPROVED_SAME_REF_COMPOUND
if (ref && mbmi->ref_frame[0] == mbmi->ref_frame[1] &&
mbmi->mode == NEAR_NEARMV && idx <= mbmi->ref_mv_idx[0])
continue;
#endif // CONFIG_IMPROVED_SAME_REF_COMPOUND
#if CONFIG_ENTROPY_STATS
int drl_ctx = av1_drl_ctx(mode_ctx);
switch (idx) {
case 0:
counts->drl_mode[0][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
break;
case 1:
counts->drl_mode[1][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
break;
default:
counts->drl_mode[2][drl_ctx][mbmi->ref_mv_idx[ref] != idx]++;
break;
}
#endif // CONFIG_ENTROPY_STATS
update_cdf(drl_cdf, mbmi->ref_mv_idx[ref] != idx, 2);
if (mbmi->ref_mv_idx[ref] == idx) break;
}
}
#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf =
av1_get_drl_cdf(fc, mbmi_ext->weight[ref_frame_type], mode_ctx, idx);
#if CONFIG_ENTROPY_STATS
int drl_ctx = av1_drl_ctx(mode_ctx);
switch (idx) {
case 0: counts->drl_mode[0][drl_ctx][mbmi->ref_mv_idx != idx]++; break;
case 1: counts->drl_mode[1][drl_ctx][mbmi->ref_mv_idx != idx]++; break;
default: counts->drl_mode[2][drl_ctx][mbmi->ref_mv_idx != idx]++; break;
}
#endif // CONFIG_ENTROPY_STATS
update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
if (mbmi->ref_mv_idx == idx) break;
}
#endif // CONFIG_SEP_COMP_DRL
}
#if CONFIG_IBC_BV_IMPROVEMENT
static void update_intrabc_drl_idx_stats(int max_ref_bv_num, FRAME_CONTEXT *fc,
FRAME_COUNTS *counts,
const MB_MODE_INFO *mbmi) {
#if !CONFIG_ENTROPY_STATS
(void)counts;
#endif // !CONFIG_ENTROPY_STATS
assert(mbmi->intrabc_drl_idx < max_ref_bv_num);
int bit_cnt = 0;
for (int idx = 0; idx < max_ref_bv_num - 1; ++idx) {
#if CONFIG_ENTROPY_STATS
counts->intrabc_drl_idx[bit_cnt][mbmi->intrabc_drl_idx != idx]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->intrabc_drl_idx_cdf[bit_cnt], mbmi->intrabc_drl_idx != idx,
2);
if (mbmi->intrabc_drl_idx == idx) break;
++bit_cnt;
}
}
#endif // CONFIG_IBC_BV_IMPROVEMENT
// Update the stats for compound weighted prediction
static void update_cwp_idx_stats(FRAME_CONTEXT *fc, FRAME_COUNTS *counts,
const AV1_COMMON *const cm, MACROBLOCKD *xd) {
#if !CONFIG_ENTROPY_STATS
(void)counts;
#endif // !CONFIG_ENTROPY_STATS
const MB_MODE_INFO *mbmi = xd->mi[0];
assert(mbmi->cwp_idx >= CWP_MIN && mbmi->cwp_idx <= CWP_MAX);
int bit_cnt = 0;
const int ctx = 0;
int8_t final_idx = get_cwp_coding_idx(mbmi->cwp_idx, 1, cm, mbmi);
for (int idx = 0; idx < MAX_CWP_NUM - 1; ++idx) {
#if CONFIG_ENTROPY_STATS
counts->cwp_idx[bit_cnt][final_idx != idx]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->cwp_idx_cdf[ctx][bit_cnt], final_idx != idx, 2);
if (final_idx == idx) break;
++bit_cnt;
}
}
#if CONFIG_EXTENDED_WARP_PREDICTION
static void update_warp_delta_param_stats(int index, int value,
#if CONFIG_ENTROPY_STATS
FRAME_COUNTS *counts,
#endif // CONFIG_ENTROPY_STATS
FRAME_CONTEXT *fc) {
assert(2 <= index && index <= 5);
int index_type = (index == 2 || index == 5) ? 0 : 1;
int coded_value = (value / WARP_DELTA_STEP) + WARP_DELTA_CODED_MAX;
assert(0 <= coded_value && coded_value < WARP_DELTA_NUM_SYMBOLS);
update_cdf(fc->warp_delta_param_cdf[index_type], coded_value,
WARP_DELTA_NUM_SYMBOLS);
#if CONFIG_ENTROPY_STATS
counts->warp_delta_param[index_type][coded_value]++;
#endif // CONFIG_ENTROPY_STATS
}
static void update_warp_delta_stats(const AV1_COMMON *cm,
const MB_MODE_INFO *mbmi,
const MB_MODE_INFO_EXT *mbmi_ext,
#if CONFIG_ENTROPY_STATS
FRAME_COUNTS *counts,
#endif // CONFIG_ENTROPY_STATS
FRAME_CONTEXT *fc) {
if (mbmi->max_num_warp_candidates > 1) {
assert(mbmi->warp_ref_idx < mbmi->max_num_warp_candidates);
int max_idx_bits = mbmi->max_num_warp_candidates - 1;
for (int bit_idx = 0; bit_idx < max_idx_bits; ++bit_idx) {
aom_cdf_prob *warp_ref_idx_cdf = av1_get_warp_ref_idx_cdf(fc, bit_idx);
update_cdf(warp_ref_idx_cdf, mbmi->warp_ref_idx != bit_idx, 2);
if (mbmi->warp_ref_idx == bit_idx) break;
}
}
if (allow_warp_parameter_signaling(cm, mbmi)) {
const WarpedMotionParams *params = &mbmi->wm_params[0];
WarpedMotionParams base_params;
av1_get_warp_base_params(
cm, mbmi, &base_params, NULL,
mbmi_ext->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]);
// The RDO stage should not give us a model which is not warpable.
// Such models can still be signalled, but are effectively useless
// as we'll just fall back to translational motion
assert(!params->invalid);
// TODO(rachelbarker): Allow signaling warp type?
update_warp_delta_param_stats(2, params->wmmat[2] - base_params.wmmat[2],
#if CONFIG_ENTROPY_STATS
counts,
#endif // CONFIG_ENTROPY_STATS
fc);
update_warp_delta_param_stats(3, params->wmmat[3] - base_params.wmmat[3],
#if CONFIG_ENTROPY_STATS
counts,
#endif // CONFIG_ENTROPY_STATS
fc);
}
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#if CONFIG_SKIP_MODE_ENHANCEMENT
static void update_skip_drl_index_stats(int max_drl_bits, FRAME_CONTEXT *fc,
FRAME_COUNTS *counts,
const MB_MODE_INFO *mbmi) {
#if !CONFIG_ENTROPY_STATS
(void)counts;
#endif // !CONFIG_ENTROPY_STATS
assert(have_drl_index(mbmi->mode));
#if CONFIG_SEP_COMP_DRL
assert(get_ref_mv_idx(mbmi, 0) < max_drl_bits + 1);
assert(get_ref_mv_idx(mbmi, 1) < max_drl_bits + 1);
#else
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
#endif // CONFIG_SEP_COMP_DRL
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf = fc->skip_drl_cdf[AOMMIN(idx, 2)];
#if CONFIG_SEP_COMP_DRL
update_cdf(drl_cdf, mbmi->ref_mv_idx[0] != idx, 2);
#if CONFIG_ENTROPY_STATS
switch (idx) {
case 0: counts->skip_drl_mode[idx][mbmi->ref_mv_idx[0] != idx]++; break;
case 1: counts->skip_drl_mode[idx][mbmi->ref_mv_idx[0] != idx]++; break;
default: counts->skip_drl_mode[2][mbmi->ref_mv_idx[0] != idx]++; break;
}
#endif // CONFIG_ENTROPY_STATS
if (mbmi->ref_mv_idx[0] == idx) break;
#else
update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
#if CONFIG_ENTROPY_STATS
switch (idx) {
case 0: counts->skip_drl_mode[idx][mbmi->ref_mv_idx != idx]++; break;
case 1: counts->skip_drl_mode[idx][mbmi->ref_mv_idx != idx]++; break;
default: counts->skip_drl_mode[2][mbmi->ref_mv_idx != idx]++; break;
}
#endif // CONFIG_ENTROPY_STATS
if (mbmi->ref_mv_idx == idx) break;
#endif // CONFIG_SEP_COMP_DRL
}
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
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->sb_type[xd->tree_type == CHROMA_PART];
FRAME_CONTEXT *fc = xd->tile_ctx;
const int inter_block = mbmi->ref_frame[0] != INTRA_FRAME;
const int seg_ref_active = 0;
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 CONFIG_SKIP_TXFM_OPT
const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
if (!seg_ref_active) {
if (!mbmi->skip_mode && !frame_is_intra_only(cm)) {
const int intra_inter_ctx = av1_get_intra_inter_context(xd);
#if CONFIG_ENTROPY_STATS
td->counts->intra_inter[intra_inter_ctx][inter_block]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->intra_inter_cdf[intra_inter_ctx], inter_block, 2);
}
if (!inter_block && av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
#if CONFIG_NEW_CONTEXT_MODELING
const int intrabc_ctx = get_intrabc_ctx(xd);
update_cdf(fc->intrabc_cdf[intrabc_ctx], use_intrabc, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->intrabc[intrabc_ctx][use_intrabc];
#endif // CONFIG_ENTROPY_STATS
#else
update_cdf(fc->intrabc_cdf, use_intrabc, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->intrabc[use_intrabc];
#endif // CONFIG_ENTROPY_STATS
#endif // CONFIG_NEW_CONTEXT_MODELING
}
if (inter_block || (!inter_block && use_intrabc)) {
#if !CONFIG_SKIP_MODE_ENHANCEMENT
if (!mbmi->skip_mode) {
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
const int skip_ctx = av1_get_skip_txfm_context(xd);
#if CONFIG_ENTROPY_STATS
td->counts->skip_txfm[skip_ctx]
[mbmi->skip_txfm[xd->tree_type == CHROMA_PART]]++;
#endif
update_cdf(fc->skip_txfm_cdfs[skip_ctx],
mbmi->skip_txfm[xd->tree_type == CHROMA_PART], 2);
#if !CONFIG_SKIP_MODE_ENHANCEMENT
}
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
}
}
#else
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (!seg_ref_active) {
#else
if (!mbmi->skip_mode && !seg_ref_active) {
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
const int skip_ctx = av1_get_skip_txfm_context(xd);
#if CONFIG_ENTROPY_STATS
td->counts
->skip_txfm[skip_ctx][mbmi->skip_txfm[xd->tree_type == CHROMA_PART]]++;
#endif
update_cdf(fc->skip_txfm_cdfs[skip_ctx],
mbmi->skip_txfm[xd->tree_type == CHROMA_PART], 2);
}
#endif // CONFIG_SKIP_TXFM_OPT
#if CONFIG_ENTROPY_STATS
// delta quant applies to both intra and inter
const int super_block_upper_left = ((xd->mi_row & (cm->mib_size - 1)) == 0) &&
((xd->mi_col & (cm->mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
(bsize != cm->sb_size ||
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) &&
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, xd->tree_type)) {
av1_sum_intra_stats(cm, td->counts, xd, mbmi);
}
if (av1_allow_intrabc(cm) && xd->tree_type != CHROMA_PART) {
#if !CONFIG_SKIP_TXFM_OPT
const int use_intrabc = is_intrabc_block(mbmi, xd->tree_type);
#if CONFIG_NEW_CONTEXT_MODELING
const int intrabc_ctx = get_intrabc_ctx(xd);
update_cdf(fc->intrabc_cdf[intrabc_ctx], use_intrabc, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->intrabc[intrabc_ctx][use_intrabc];
#endif // CONFIG_ENTROPY_STATS
#else
update_cdf(fc->intrabc_cdf, use_intrabc, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->intrabc[use_intrabc];
#endif // CONFIG_ENTROPY_STATS
#endif // CONFIG_NEW_CONTEXT_MODELING
#endif // !CONFIG_SKIP_TXFM_OPT
#if CONFIG_IBC_BV_IMPROVEMENT
if (use_intrabc) {
const int_mv ref_mv = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
#if CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
MV mv_diff;
mv_diff.row = mbmi->mv[0].as_mv.row - ref_mv.as_mv.row;
mv_diff.col = mbmi->mv[0].as_mv.col - ref_mv.as_mv.col;
#endif // CONFIG_DERIVED_MVD_SIGN
#if CONFIG_VQ_MVD_CODING
av1_update_mv_stats(&fc->ndvc, mv_diff, MV_PRECISION_ONE_PEL, 0);
#if CONFIG_DERIVED_MVD_SIGN
if (mv_diff.row) {
update_cdf(fc->ndvc.comps[0].sign_cdf, mv_diff.row < 0, 2);
}
if (mv_diff.col) {
update_cdf(fc->ndvc.comps[1].sign_cdf, mv_diff.col < 0, 2);
}
#endif
#else
av1_update_mv_stats(
#if CONFIG_DERIVED_MVD_SIGN
mv_diff, 0,
#else
mbmi->mv[0].as_mv, ref_mv.as_mv,
#endif // CONFIG_DERIVED_MVD_SIGN
&fc->ndvc, 0, MV_PRECISION_ONE_PEL);
#endif // CONFIG_VQ_MVD_CODING
}
#endif // CONFIG_IBC_BV_IMPROVEMENT
#if CONFIG_IBC_BV_IMPROVEMENT
if (use_intrabc) {
update_cdf(fc->intrabc_mode_cdf, mbmi->intrabc_mode, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->intrabc_mode[mbmi->intrabc_mode];
#endif // CONFIG_ENTROPY_STATS
#if CONFIG_IBC_MAX_DRL
update_intrabc_drl_idx_stats(cm->features.max_bvp_drl_bits + 1, fc,
td->counts, mbmi);
#else
update_intrabc_drl_idx_stats(MAX_REF_BV_STACK_SIZE, fc, td->counts, mbmi);
#endif // CONFIG_IBC_MAX_DRL
#if CONFIG_MORPH_PRED
const int morph_pred_ctx = get_morph_pred_ctx(xd);
update_cdf(fc->morph_pred_cdf[morph_pred_ctx], mbmi->morph_pred, 2);
#if CONFIG_ENTROPY_STATS
++td->counts->morph_pred_count[morph_pred_ctx][mbmi->morph_pred];
#endif // CONFIG_ENTROPY_STATS
#endif // CONFIG_MORPH_PRED
}
#endif // CONFIG_IBC_BV_IMPROVEMENT
}
#if CONFIG_SKIP_MODE_ENHANCEMENT
if (mbmi->skip_mode && have_drl_index(mbmi->mode)) {
FRAME_COUNTS *const counts = td->counts;
#if CONFIG_SKIP_MODE_ENHANCEMENT
update_skip_drl_index_stats(cm->features.max_drl_bits, fc, counts, mbmi);
#else
const int16_t mode_ctx_pristine =
av1_mode_context_pristine(mbmi_ext->mode_context, mbmi->ref_frame);
update_drl_index_stats(cm->features.max_drl_bits, mode_ctx_pristine, fc,
counts, mbmi, mbmi_ext);
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_REFINEMV
if (mbmi->skip_mode && switchable_refinemv_flag(cm, mbmi)) {
const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
update_cdf(fc->refinemv_flag_cdf[refinemv_ctx], mbmi->refinemv_flag,
REFINEMV_NUM_MODES);
}
#endif // CONFIG_REFINEMV
if (frame_is_intra_only(cm) || mbmi->skip_mode) return;
FRAME_COUNTS *const counts = td->counts;
if (!seg_ref_active) {
#if !CONFIG_SKIP_TXFM_OPT
#if CONFIG_ENTROPY_STATS && !CONFIG_CONTEXT_DERIVATION
counts->intra_inter[av1_get_intra_inter_context(xd)][inter_block]++;
#endif // CONFIG_ENTROPY_STATS && !CONFIG_CONTEXT_DERIVATION
#if CONFIG_CONTEXT_DERIVATION
const int skip_txfm = mbmi->skip_txfm[xd->tree_type == CHROMA_PART];
#if CONFIG_ENTROPY_STATS
counts->intra_inter[skip_txfm][av1_get_intra_inter_context(xd)]
[inter_block]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->intra_inter_cdf[skip_txfm][av1_get_intra_inter_context(xd)],
inter_block, 2);
#else
update_cdf(fc->intra_inter_cdf[av1_get_intra_inter_context(xd)],
inter_block, 2);
#endif // CONFIG_CONTEXT_DERIVATION
#endif // !CONFIG_SKIP_TXFM_OPT
// 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 (cm->features.tip_frame_mode &&
#if CONFIG_EXT_RECUR_PARTITIONS
is_tip_allowed_bsize(mbmi)) {
#else // CONFIG_EXT_RECUR_PARTITIONS
is_tip_allowed_bsize(bsize)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int tip_ctx = get_tip_ctx(xd);
update_cdf(fc->tip_cdf[tip_ctx], is_tip_ref_frame(ref0), 2);
#if CONFIG_ENTROPY_STATS
++counts->tip_ref[tip_ctx][is_tip_ref_frame(ref0)];
#endif
}
if (current_frame->reference_mode == REFERENCE_MODE_SELECT &&
!is_tip_ref_frame(ref0)) {
if (is_comp_ref_allowed(bsize)) {
#if CONFIG_ENTROPY_STATS
counts->comp_inter[av1_get_reference_mode_context(cm, xd)]
[has_second_ref(mbmi)]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(av1_get_reference_mode_cdf(cm, xd), has_second_ref(mbmi),
2);
}
}
if (has_second_ref(mbmi)) {
const int n_refs = cm->ref_frames_info.num_total_refs;
int n_bits = 0;
#if CONFIG_IMPROVED_SAME_REF_COMPOUND
int may_have_same_ref_comp =
cm->ref_frames_info.num_same_ref_compound > 0;
assert(ref0 < ref1 + may_have_same_ref_comp);
for (int i = 0;
(i < n_refs + n_bits - 2 || may_have_same_ref_comp) && n_bits < 2;
i++) {
const int bit =
((n_bits == 0) && (ref0 == i)) || ((n_bits == 1) && (ref1 == i));
#elif CONFIG_ALLOW_SAME_REF_COMPOUND
assert(ref0 <= ref1);
for (int i = 0; i < n_refs - 1 && n_bits < 2; i++) {
const int bit =
((n_bits == 0) && (ref0 == i)) || ((n_bits == 1) && (ref1 == i));
#else
assert(ref0 < ref1);
for (int i = 0; i < n_refs + n_bits - 2 && n_bits < 2; i++) {
const int bit = ref0 == i || ref1 == i;
#endif // CONFIG_IMPROVED_SAME_REF_COMPOUND
const int bit_type = n_bits == 0 ? -1
: av1_get_compound_ref_bit_type(
&cm->ref_frames_info, ref0, i);
int implicit_ref_bit = n_bits == 0 && i >= RANKED_REF0_TO_PRUNE - 1;
#if CONFIG_IMPROVED_SAME_REF_COMPOUND
implicit_ref_bit |=
n_bits == 0 && i >= n_refs - 2 &&
i + 1 >= cm->ref_frames_info.num_same_ref_compound;
#endif // CONFIG_IMPROVED_SAME_REF_COMPOUND
if (!implicit_ref_bit) {
update_cdf(
av1_get_pred_cdf_compound_ref(xd, i, n_bits, bit_type, n_refs),
bit, 2);
#if CONFIG_ENTROPY_STATS
if (n_bits == 0) {
counts->comp_ref0[av1_get_ref_pred_context(xd, i, n_refs)][i]
[bit]++;
} else {
#if CONFIG_ALLOW_SAME_REF_COMPOUND
counts->comp_ref1[av1_get_ref_pred_context(xd, i, n_refs)]
[bit_type][i][bit]++;
#else
counts->comp_ref1[av1_get_ref_pred_context(xd, i, n_refs)]
[bit_type][i - 1][bit]++;
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
}
#endif // CONFIG_ENTROPY_STATS
}
n_bits += bit;
#if CONFIG_IMPROVED_SAME_REF_COMPOUND
if (i < cm->ref_frames_info.num_same_ref_compound &&
may_have_same_ref_comp) {
may_have_same_ref_comp =
!bit && i + 1 < cm->ref_frames_info.num_same_ref_compound;
i -= bit;
} else {
may_have_same_ref_comp = 0;
}
#elif CONFIG_ALLOW_SAME_REF_COMPOUND
if (i < cm->ref_frames_info.num_same_ref_compound) i -= bit;
#endif // CONFIG_IMPROVED_SAME_REF_COMPOUND
}
} else if (!is_tip_ref_frame(ref0)) {
const int n_refs = cm->ref_frames_info.num_total_refs;
const MV_REFERENCE_FRAME ref0_nrs = mbmi->ref_frame[0];
for (int i = 0; i < n_refs - 1; i++) {
const int bit = ref0_nrs == i;
update_cdf(av1_get_pred_cdf_single_ref(xd, i, n_refs), bit, 2);
#if CONFIG_ENTROPY_STATS
counts->single_ref[av1_get_ref_pred_context(xd, i, n_refs)][i][bit]++;
#endif // CONFIG_ENTROPY_STATS
if (bit) break;
}
}
#if CONFIG_BAWP
#if CONFIG_BAWP_CHROMA
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
#if CONFIG_EXPLICIT_BAWP
update_cdf(fc->bawp_cdf[0], mbmi->bawp_flag[0] > 0, 2);
if (mbmi->bawp_flag[0] > 0 && av1_allow_explicit_bawp(mbmi)) {
const int ctx_index =
(mbmi->mode == NEARMV) ? 0 : (mbmi->mode == AMVDNEWMV ? 1 : 2);
update_cdf(fc->explicit_bawp_cdf[ctx_index], mbmi->bawp_flag[0] > 1,
2);
if (mbmi->bawp_flag[0] > 1) {
update_cdf(fc->explicit_bawp_scale_cdf, mbmi->bawp_flag[0] - 2,
EXPLICIT_BAWP_SCALE_CNT);
}
}
#else
update_cdf(fc->bawp_cdf[0], mbmi->bawp_flag[0] == 1, 2);
#endif // CONFIG_EXPLICIT_BAWP
if (mbmi->bawp_flag[0]) {
update_cdf(fc->bawp_cdf[1], mbmi->bawp_flag[1] == 1, 2);
}
#if CONFIG_ENTROPY_STATS
counts->bawp[mbmi->bawp_flag[0] == 1]++;
#endif // CONFIG_ENTROPY_STATS
}
#else
if (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
#if CONFIG_EXPLICIT_BAWP
update_cdf(fc->bawp_cdf, mbmi->bawp_flag > 0, 2);
if (mbmi->bawp_flag > 0 && av1_allow_explicit_bawp(mbmi)) {
const int ctx_index =
(mbmi->mode == NEARMV) ? 0 : (mbmi->mode == AMVDNEWMV ? 1 : 2);
update_cdf(fc->explicit_bawp_cdf[ctx_index], mbmi->bawp_flag > 1, 2);
if (mbmi->bawp_flag > 1) {
update_cdf(fc->explicit_bawp_scale_cdf, mbmi->bawp_flag - 2,
EXPLICIT_BAWP_SCALE_CNT);
}
}
#else
update_cdf(fc->bawp_cdf, mbmi->bawp_flag == 1, 2);
#endif // CONFIG_EXPLICIT_BAWP
#if CONFIG_ENTROPY_STATS
counts->bawp[mbmi->bawp_flag == 1]++;
#endif // CONFIG_ENTROPY_STATS
}
#endif // CONFIG_BAWP_CHROMA
#endif // CONFIG_BAWP
#if CONFIG_EXTENDED_WARP_PREDICTION
const int allowed_motion_modes = motion_mode_allowed(
cm, xd, mbmi_ext->ref_mv_stack[mbmi->ref_frame[0]], mbmi);
MOTION_MODE motion_mode = mbmi->motion_mode;
if (mbmi->mode == WARPMV) {
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
#if CONFIG_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->warped_causal_warpmv[motion_mode == WARPED_CAUSAL]++;
#endif
update_cdf(fc->warped_causal_warpmv_cdf, motion_mode == WARPED_CAUSAL,
2);
#else
#if CONFIG_ENTROPY_STATS
counts->warped_causal_warpmv[bsize][motion_mode == WARPED_CAUSAL]++;
#endif
update_cdf(fc->warped_causal_warpmv_cdf[bsize],
motion_mode == WARPED_CAUSAL, 2);
#endif // CONFIG_D149_CTX_MODELING_OPT
}
}
bool continue_motion_mode_signaling =
(mbmi->mode == WARPMV) ? false : true;
assert(IMPLIES(mbmi->mode == WARPMV,
mbmi->motion_mode == WARP_DELTA ||
mbmi->motion_mode == WARPED_CAUSAL));
if (continue_motion_mode_signaling &&
(allowed_motion_modes & (1 << INTERINTRA))) {
const int bsize_group = size_group_lookup[bsize];
#if CONFIG_ENTROPY_STATS
counts->interintra[bsize_group][motion_mode == INTERINTRA]++;
#endif
update_cdf(fc->interintra_cdf[bsize_group], motion_mode == INTERINTRA,
2);
if (motion_mode == INTERINTRA) {
#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_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->wedge_interintra[mbmi->use_wedge_interintra]++;
#endif
update_cdf(fc->wedge_interintra_cdf, mbmi->use_wedge_interintra, 2);
#else
#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);
#endif // CONFIG_D149_CTX_MODELING_OPT
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
update_wedge_mode_cdf(fc, bsize, mbmi->interintra_wedge_index
#if CONFIG_ENTROPY_STATS
,
counts
#endif // CONFIG_ENTROPY_STATS
);
#else
#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);
#endif // CONFIG_WEDGE_MOD_EXT
}
}
continue_motion_mode_signaling = false;
}
}
if (continue_motion_mode_signaling &&
(allowed_motion_modes & (1 << OBMC_CAUSAL))) {
#if CONFIG_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->obmc[motion_mode == OBMC_CAUSAL]++;
#endif
update_cdf(fc->obmc_cdf, motion_mode == OBMC_CAUSAL, 2);
#else
#if CONFIG_ENTROPY_STATS
counts->obmc[bsize][motion_mode == OBMC_CAUSAL]++;
#endif
update_cdf(fc->obmc_cdf[bsize], motion_mode == OBMC_CAUSAL, 2);
#endif // CONFIG_D149_CTX_MODELING_OPT
if (motion_mode == OBMC_CAUSAL) {
continue_motion_mode_signaling = false;
}
}
if (continue_motion_mode_signaling &&
allowed_motion_modes & (1 << WARP_EXTEND)) {
const int ctx1 = av1_get_warp_extend_ctx1(xd, mbmi);
const int ctx2 = av1_get_warp_extend_ctx2(xd, mbmi);
#if CONFIG_ENTROPY_STATS
counts->warp_extend[ctx1][ctx2][mbmi->motion_mode == WARP_EXTEND]++;
#endif
update_cdf(fc->warp_extend_cdf[ctx1][ctx2],
mbmi->motion_mode == WARP_EXTEND, 2);
if (motion_mode == WARP_EXTEND) {
continue_motion_mode_signaling = false;
}
}
if (continue_motion_mode_signaling &&
(allowed_motion_modes & (1 << WARPED_CAUSAL))) {
#if CONFIG_D149_CTX_MODELING_OPT && !NO_D149_FOR_WARPED_CAUSAL
#if CONFIG_ENTROPY_STATS
counts->warped_causal[motion_mode == WARPED_CAUSAL]++;
#endif
update_cdf(fc->warped_causal_cdf, motion_mode == WARPED_CAUSAL, 2);
#else
#if CONFIG_ENTROPY_STATS
counts->warped_causal[bsize][motion_mode == WARPED_CAUSAL]++;
#endif
update_cdf(fc->warped_causal_cdf[bsize], motion_mode == WARPED_CAUSAL,
2);
#endif // CONFIG_D149_CTX_MODELING_OPT && !NO_D149_FOR_WARPED_CAUSAL
if (motion_mode == WARPED_CAUSAL) {
continue_motion_mode_signaling = false;
}
}
if (continue_motion_mode_signaling &&
(allowed_motion_modes & (1 << WARP_DELTA))) {
#if CONFIG_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->warp_delta[motion_mode == WARP_DELTA]++;
#endif
update_cdf(fc->warp_delta_cdf, motion_mode == WARP_DELTA, 2);
#else
#if CONFIG_ENTROPY_STATS
counts->warp_delta[bsize][motion_mode == WARP_DELTA]++;
#endif
update_cdf(fc->warp_delta_cdf[bsize], motion_mode == WARP_DELTA, 2);
#endif // CONFIG_D149_CTX_MODELING_OPT
}
if (motion_mode == WARP_DELTA ||
(motion_mode == WARPED_CAUSAL && mbmi->mode == WARPMV)) {
update_warp_delta_stats(cm, mbmi, mbmi_ext,
#if CONFIG_ENTROPY_STATS
counts,
#endif // CONFIG_ENTROPY_STATS
fc);
// The following line is commented out to remove a spurious
// static analysis warning. Uncomment when adding a new motion mode
// continue_motion_mode_signaling = false;
}
if (allow_warpmv_with_mvd_coding(cm, mbmi)) {
#if CONFIG_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->warpmv_with_mvd_flag[mbmi->warpmv_with_mvd_flag]++;
#endif
update_cdf(fc->warpmv_with_mvd_flag_cdf, mbmi->warpmv_with_mvd_flag, 2);
#else
#if CONFIG_ENTROPY_STATS
counts->warpmv_with_mvd_flag[bsize][mbmi->warpmv_with_mvd_flag]++;
#endif
update_cdf(fc->warpmv_with_mvd_flag_cdf[bsize],
mbmi->warpmv_with_mvd_flag, 2);
#endif // CONFIG_D149_CTX_MODELING_OPT
} else {
assert(mbmi->warpmv_with_mvd_flag == 0);
}
#else
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_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->wedge_interintra[mbmi->use_wedge_interintra]++;
#endif
update_cdf(fc->wedge_interintra_cdf, mbmi->use_wedge_interintra, 2);
#else
#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);
#endif // CONFIG_D149_CTX_MODELING_OPT
if (mbmi->use_wedge_interintra) {
#if CONFIG_WEDGE_MOD_EXT
update_wedge_mode_cdf(fc, bsize, mbmi->interintra_wedge_index
#if CONFIG_ENTROPY_STATS
,
counts
#endif // CONFIG_ENTROPY_STATS
);
#else
#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);
#endif // CONFIG_WEDGE_MOD_EXT
}
}
} 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 = motion_mode_allowed(cm, xd, mbmi);
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_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
counts->obmc[mbmi->motion_mode == OBMC_CAUSAL]++;
#endif
update_cdf(fc->obmc_cdf, mbmi->motion_mode == OBMC_CAUSAL, 2);
#else
#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);
#endif // CONFIG_D149_CTX_MODELING_OPT
}
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#if CONFIG_REFINEMV
int is_refinemv_signaled = switchable_refinemv_flag(cm, mbmi);
if (!mbmi->skip_mode && is_refinemv_signaled) {
const int refinemv_ctx = av1_get_refinemv_context(cm, xd, bsize);
update_cdf(fc->refinemv_flag_cdf[refinemv_ctx], mbmi->refinemv_flag,
REFINEMV_NUM_MODES);
}
assert(IMPLIES(mbmi->refinemv_flag && is_refinemv_signaled,
mbmi->comp_group_idx == 0 &&
mbmi->interinter_comp.type == COMPOUND_AVERAGE));
#endif // CONFIG_REFINEMV
if (has_second_ref(mbmi)
#if CONFIG_OPTFLOW_REFINEMENT
&& mbmi->mode < NEAR_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
#if CONFIG_REFINEMV
&& (!mbmi->refinemv_flag || !is_refinemv_signaled)
#endif // CONFIG_REFINEMV
&& !is_joint_amvd_coding_mode(mbmi->mode)) {
#if CONFIG_COMPOUND_WARP_CAUSAL
assert(current_frame->reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
(mbmi->motion_mode == SIMPLE_TRANSLATION ||
is_compound_warp_causal_allowed(mbmi)));
#else
assert(current_frame->reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
mbmi->motion_mode == SIMPLE_TRANSLATION);
#endif // CONFIG_COMPOUND_WARP_CAUSAL
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(cm, 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 == 1) {
assert(masked_compound_used);
if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) {
#if CONFIG_D149_CTX_MODELING_OPT
#if CONFIG_ENTROPY_STATS
++counts
->compound_type[mbmi->interinter_comp.type - COMPOUND_WEDGE];
#endif
update_cdf(fc->compound_type_cdf,
mbmi->interinter_comp.type - COMPOUND_WEDGE,
MASKED_COMPOUND_TYPES);
#else
#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);
#endif // CONFIG_D149_CTX_MODELING_OPT
}
}
}
if (mbmi->interinter_comp.type == COMPOUND_WEDGE) {
if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) {
#if CONFIG_WEDGE_MOD_EXT
update_wedge_mode_cdf(fc, bsize, mbmi->interinter_comp.wedge_index
#if CONFIG_ENTROPY_STATS
,
counts
#endif // CONFIG_ENTROPY_STATS
);
#else
#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);
#endif // CONFIG_WEDGE_MOD_EXT
}
}
if (cm->features.enable_cwp && is_cwp_allowed(mbmi) && !mbmi->skip_mode) {
update_cwp_idx_stats(fc, td->counts, cm, xd);
}
}
}
if (inter_block && cm->features.interp_filter == SWITCHABLE &&
!is_warp_mode(mbmi->motion_mode) && !is_nontrans_global_motion(xd, mbmi)
#if CONFIG_REFINEMV
&& !(mbmi->refinemv_flag || mbmi->mode >= NEAR_NEARMV_OPTFLOW)
#endif // CONFIG_REFINEMV
) {
update_filter_type_cdf(xd, mbmi);
}
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_OPTFLOW_REFINEMENT
if (cm->features.opfl_refine_type == REFINE_SWITCHABLE &&
opfl_allowed_for_cur_refs(cm, mbmi)) {
#if CONFIG_AFFINE_REFINEMENT
const int allow_translational = is_translational_refinement_allowed(
cm, comp_idx_to_opfl_mode[opfl_get_comp_idx(mode)]);
const int allow_affine = is_affine_refinement_allowed(
cm, xd, comp_idx_to_opfl_mode[opfl_get_comp_idx(mode)]);
if (allow_affine || allow_translational) {
#endif // CONFIG_AFFINE_REFINEMENT
const int use_optical_flow = mode >= NEAR_NEARMV_OPTFLOW;
#if CONFIG_ENTROPY_STATS
++counts->use_optflow[mode_ctx][use_optical_flow];
#endif
update_cdf(fc->use_optflow_cdf[mode_ctx], use_optical_flow, 2);
#if CONFIG_AFFINE_REFINEMENT
}
#endif // CONFIG_AFFINE_REFINEMENT
}
const int comp_mode_idx = opfl_get_comp_idx(mode);
#if CONFIG_ENTROPY_STATS
++counts->inter_compound_mode[mode_ctx][comp_mode_idx];
#endif
update_cdf(fc->inter_compound_mode_cdf[mode_ctx], comp_mode_idx,
INTER_COMPOUND_REF_TYPES);
#else
#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);
#endif // CONFIG_OPTFLOW_REFINEMENT
if (is_joint_mvd_coding_mode(mbmi->mode)) {
const int is_joint_amvd_mode = is_joint_amvd_coding_mode(mbmi->mode);
aom_cdf_prob *jmvd_scale_mode_cdf = is_joint_amvd_mode
? fc->jmvd_amvd_scale_mode_cdf
: fc->jmvd_scale_mode_cdf;
const int jmvd_scale_cnt = is_joint_amvd_mode
? JOINT_AMVD_SCALE_FACTOR_CNT
: JOINT_NEWMV_SCALE_FACTOR_CNT;
update_cdf(jmvd_scale_mode_cdf, mbmi->jmvd_scale_mode, jmvd_scale_cnt);
}
} else {
av1_update_inter_mode_stats(fc, counts, mode, mode_ctx
#if CONFIG_EXTENDED_WARP_PREDICTION
,
cm, xd, mbmi, bsize
#endif // CONFIG_EXTENDED_WARP_PREDICTION
);
}
const int new_mv = have_newmv_in_each_reference(mbmi->mode);
const int jmvd_base_ref_list = is_joint_mvd_coding_mode(mbmi->mode)
? get_joint_mvd_base_ref_list(cm, mbmi)
: 0;
const int is_adaptive_mvd = enable_adaptive_mvd_resolution(cm, mbmi);
if (have_drl_index(mbmi->mode)) {
const int16_t mode_ctx_pristine =
av1_mode_context_pristine(mbmi_ext->mode_context, mbmi->ref_frame);
update_drl_index_stats(cm->features.max_drl_bits, mode_ctx_pristine, fc,
counts, mbmi, mbmi_ext);
}
#if CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
MV mv_diff[2] = { kZeroMv, kZeroMv };
#if CONFIG_DERIVED_MVD_SIGN
int num_signaled_mvd = 0;
int start_signaled_mvd_idx = 0;
#endif
#endif // CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
#if CONFIG_EXTENDED_WARP_PREDICTION
if (xd->tree_type != CHROMA_PART && mbmi->mode == WARPMV) {
if (mbmi->warpmv_with_mvd_flag) {
WarpedMotionParams ref_warp_model =
mbmi_ext
->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
[mbmi->warp_ref_idx]
.wm_params;
int_mv ref_mv =
get_mv_from_wrl(xd, &ref_warp_model, mbmi->pb_mv_precision, bsize,
xd->mi_col, xd->mi_row);
assert(is_adaptive_mvd == 0);
#if CONFIG_DERIVED_MVD_SIGN
num_signaled_mvd = 1;
start_signaled_mvd_idx = 0;
#endif
#if CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
get_mvd_from_ref_mv(mbmi->mv[0].as_mv, ref_mv.as_mv, is_adaptive_mvd,
mbmi->pb_mv_precision, &mv_diff[0]);
#endif // CONFIG_DERIVED_MVD_SIGN
#if CONFIG_VQ_MVD_CODING
av1_update_mv_stats(&fc->nmvc, mv_diff[0], mbmi->pb_mv_precision,
is_adaptive_mvd);
#else
av1_update_mv_stats(
#if CONFIG_DERIVED_MVD_SIGN
mv_diff[0], 1,
#else
mbmi->mv[0].as_mv, ref_mv.as_mv,
#endif // CONFIG_DERIVED_MVD_SIGN
&fc->nmvc, is_adaptive_mvd, mbmi->pb_mv_precision);
#endif // CONFIG_VQ_MVD_CODING
}
} else {
#endif // CONFIG_EXTENDED_WARP_PREDICTION
if (have_newmv_in_inter_mode(mbmi->mode) &&
xd->tree_type != CHROMA_PART) {
const int pb_mv_precision = mbmi->pb_mv_precision;
assert(IMPLIES(cm->features.cur_frame_force_integer_mv,
pb_mv_precision == MV_PRECISION_ONE_PEL));
if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
assert(!is_adaptive_mvd);
assert(mbmi->most_probable_pb_mv_precision <= mbmi->max_mv_precision);
const int mpp_flag_context = av1_get_mpp_flag_context(cm, xd);
const int mpp_flag =
(mbmi->pb_mv_precision == mbmi->most_probable_pb_mv_precision);
update_cdf(fc->pb_mv_mpp_flag_cdf[mpp_flag_context], mpp_flag, 2);
if (!mpp_flag) {
const PRECISION_SET *precision_def =
&av1_mv_precision_sets[mbmi->mb_precision_set];
int down = av1_get_pb_mv_precision_index(mbmi);
int nsymbs = precision_def->num_precisions - 1;
const int down_ctx = av1_get_pb_mv_precision_down_context(cm, xd);
update_cdf(
fc->pb_mv_precision_cdf[down_ctx][mbmi->max_mv_precision -
MV_PRECISION_HALF_PEL],
down, nsymbs);
}
}
if (new_mv) {
#if CONFIG_DERIVED_MVD_SIGN
num_signaled_mvd = 1 + has_second_ref(mbmi);
start_signaled_mvd_idx = 0;
#endif // CONFIG_DERIVED_MVD_SIGN
for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
get_mvd_from_ref_mv(mbmi->mv[ref].as_mv, ref_mv.as_mv,
is_adaptive_mvd, pb_mv_precision,
&mv_diff[ref]);
#endif // CONFIG_DERIVED_MVD_SIGN || CONFIG_VQ_MVD_CODING
#if CONFIG_VQ_MVD_CODING
av1_update_mv_stats(&fc->nmvc, mv_diff[ref], pb_mv_precision,
is_adaptive_mvd);
#else
av1_update_mv_stats(
#if CONFIG_DERIVED_MVD_SIGN
mv_diff[ref], 1,
#else
mbmi->mv[ref].as_mv, ref_mv.as_mv,
#endif // CONFIG_DERIVED_MVD_SIGN
&fc->nmvc, is_adaptive_mvd, pb_mv_precision);
#endif // CONFIG_VQ_MVD_CODING
}
} else if (have_nearmv_newmv_in_inter_mode(mbmi->mode)) {
const int ref =
#if CONFIG_OPTFLOW_REFINEMENT
mbmi->mode == NEAR_NEWMV_OPTFLOW ||
#endif // CONFIG_OPTFLOW_REFINEMENT
jmvd_base_ref_list || mbmi->mode == NEAR_NEWMV;
const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_DERIVED_MVD_SIGN
num_signaled_mvd = 1;
start_signaled_mvd_idx = ref;
#endif
#if CONFIG_VQ_MVD_CODING || CONFIG_DERIVED_MVD_SIGN
get_mvd_from_ref_mv(mbmi->mv[ref].as_mv, ref_mv.as_mv,
is_adaptive_mvd, pb_mv_precision, &mv_diff[ref]);
#endif // CONFIG_DERIVED_MVD_SIGN
#if CONFIG_VQ_MVD_CODING
av1_update_mv_stats(&fc->nmvc, mv_diff[ref], pb_mv_precision,
is_adaptive_mvd);
#else
av1_update_mv_stats(
#if CONFIG_DERIVED_MVD_SIGN
mv_diff[ref], 1,
#else
mbmi->mv[ref].as_mv, ref_mv.as_mv,
#endif // CONFIG_DERIVED_MVD_SIGN
&fc->nmvc, is_adaptive_mvd, pb_mv_precision);
#endif // CONFIG_VQ_MVD_CODING
}
}
#if CONFIG_EXTENDED_WARP_PREDICTION
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#if CONFIG_DERIVED_MVD_SIGN
// Update stats of the sign in the second pass
if (num_signaled_mvd > 0) {
int last_ref = -1;
int last_comp = -1;
uint16_t sum_mvd = 0;
int precision_shift = MV_PRECISION_ONE_EIGHTH_PEL - mbmi->pb_mv_precision;
int th_for_num_nonzero = get_derive_sign_nzero_th(mbmi);
uint8_t num_nonzero_mvd_comp = 0;
uint8_t enable_sign_derive = 0;
if (is_mvd_sign_derive_allowed(cm, xd, mbmi)) {
for (int ref = start_signaled_mvd_idx;
ref < start_signaled_mvd_idx + num_signaled_mvd; ++ref) {
assert(ref == 0 || ref == 1);
for (int comp = 0; comp < 2; comp++) {
int this_mvd_comp = comp == 0 ? mv_diff[ref].row : mv_diff[ref].col;
if (this_mvd_comp) {
last_ref = ref;
last_comp = comp;
sum_mvd = sum_mvd + (abs(this_mvd_comp) >> precision_shift);
num_nonzero_mvd_comp++;
}
}
}
if (num_nonzero_mvd_comp >= th_for_num_nonzero) enable_sign_derive = 1;
}
for (int ref = start_signaled_mvd_idx;
ref < start_signaled_mvd_idx + num_signaled_mvd; ++ref) {
assert(ref == 0 || ref == 1);
for (int comp = 0; comp < 2; comp++) {
if (enable_sign_derive && (ref == last_ref && comp == last_comp))
continue;
int this_mvd_comp = comp == 0 ? mv_diff[ref].row : mv_diff[ref].col;
if (this_mvd_comp) {
const int sign = this_mvd_comp < 0;
update_cdf(fc->nmvc.comps[comp].sign_cdf, sign, 2);
}
}
}
}
#endif // CONFIG_DERIVED_MVD_SIGN
}
}
/*!\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.
*
* This function works on planes determined by get_partition_plane_start() and
* get_partition_plane_end() based on xd->tree_type.
*
* \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
*
* 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,
const 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;
av1_set_offsets_without_segment_id(cpi, tile, x, mi_row, mi_col, bsize,
&ctx->chroma_ref_info);
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 num_planes = av1_num_planes(cm);
const int plane_start = (xd->tree_type == CHROMA_PART);
const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes;
if (!dry_run) {
for (int plane = plane_start; plane < plane_end; plane++) {
x->mbmi_ext_frame->cb_offset[plane] = x->cb_offset[plane];
assert(x->cb_offset[plane] <
(1 << num_pels_log2_lookup[cpi->common.sb_size]));
}
#if CONFIG_LR_IMPROVEMENTS
av1_init_txk_skip_array(&cpi->common, mi_row, mi_col, bsize, 0,
xd->tree_type, &mbmi->chroma_ref_info, plane_start,
plane_end);
#endif // CONFIG_LR_IMPROVEMENTS
}
encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, plane_start,
plane_end, rate);
#if CONFIG_REFINED_MVS_IN_TMVP
if (!dry_run && cm->seq_params.order_hint_info.enable_ref_frame_mvs) {
const MB_MODE_INFO *const mi = &ctx->mic;
if (opfl_allowed_for_cur_block(cm, mi)
#if CONFIG_REFINEMV
|| (mi->refinemv_flag && mi->interinter_comp.type == COMPOUND_AVERAGE)
#endif // CONFIG_REFINEMV
) {
const int bw = mi_size_wide[mi->sb_type[xd->tree_type == CHROMA_PART]];
const int bh = mi_size_high[mi->sb_type[xd->tree_type == CHROMA_PART]];
const int x_inside_boundary = AOMMIN(bw, cm->mi_params.mi_cols - mi_col);
const int y_inside_boundary = AOMMIN(bh, cm->mi_params.mi_rows - mi_row);
av1_copy_frame_refined_mvs(cm, xd, mi, mi_row, mi_col, x_inside_boundary,
y_inside_boundary);
}
}
#endif // CONFIG_REFINED_MVS_IN_TMVP
if (!dry_run) {
for (int plane = plane_start; plane < plane_end; ++plane) {
if (plane == 0) {
x->cb_offset[plane] += block_size_wide[bsize] * block_size_high[bsize];
} else if (xd->is_chroma_ref) {
const BLOCK_SIZE bsize_base = mbmi->chroma_ref_info.bsize_base;
x->cb_offset[plane] +=
block_size_wide[bsize_base] * block_size_high[bsize_base];
}
}
if (bsize == cpi->common.sb_size &&
mbmi->skip_txfm[xd->tree_type == CHROMA_PART] == 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->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->mib_size - 1)) == 0) &&
((mi_col & (cm->mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
(bsize != cm->sb_size ||
!mbmi->skip_txfm[xd->tree_type == CHROMA_PART]) &&
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) {
#if !CONFIG_SKIP_MODE_ENHANCEMENT
assert(has_second_ref(mbmi));
#endif // !CONFIG_SKIP_MODE_ENHANCEMENT
#if CONFIG_D072_SKIP_MODE_IMPROVE
if (has_second_ref(mbmi)) {
#endif // CONFIG_D072_SKIP_MODE_IMPROVE
rdc->compound_ref_used_flag = 1;
#if CONFIG_D072_SKIP_MODE_IMPROVE
}
#endif // CONFIG_D072_SKIP_MODE_IMPROVE
}
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
} else {
const int seg_ref_active = 0;
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, xd->tree_type)) {
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.disable_obmc &&
cpi->sf.inter_sf.prune_obmc_prob_thresh > 0) ||
#if CONFIG_EXTENDED_WARP_PREDICTION
cpi->sf.inter_sf.prune_warped_prob_thresh > 0 ||
cpi->sf.inter_sf.prune_warpmv_prob_thresh > 0) {
#else
(cm->features.allow_warped_motion &&
cpi->sf.inter_sf.prune_warped_prob_thresh > 0)) {
#endif // CONFIG_EXTENDED_WARP_PREDICTION
const int inter_block = is_inter_block(mbmi, xd->tree_type);
const int seg_ref_active = 0;
if (!seg_ref_active && inter_block) {
#if CONFIG_EXTENDED_WARP_PREDICTION
const int allowed_motion_modes = motion_mode_allowed(
cm, xd, x->mbmi_ext->ref_mv_stack[mbmi->ref_frame[0]], mbmi);
if (mbmi->motion_mode != INTERINTRA) {
if (allowed_motion_modes & (1 << OBMC_CAUSAL)) {
td->rd_counts.obmc_used[bsize][mbmi->motion_mode == OBMC_CAUSAL]++;
}
int is_warp_allowed = (allowed_motion_modes & (1 << WARPED_CAUSAL)) ||
(allowed_motion_modes & (1 << WARP_DELTA)) ||
(allowed_motion_modes & (1 << WARP_EXTEND));
if (is_warp_allowed) {
td->rd_counts.warped_used[mbmi->motion_mode >= WARPED_CAUSAL]++;
}
// TODO(rachelbarker): Add counts and pruning for WARP_DELTA and
// WARP_EXTEND
}
#else
const MOTION_MODE motion_allowed = motion_mode_allowed(cm, xd, mbmi);
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]++;
}
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
}
}
}
// 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.
if (xd->tree_type != CHROMA_PART)
#if CONFIG_SKIP_MODE_ENHANCEMENT
{
if (mbmi->skip_mode) {
MV_REFERENCE_FRAME rf[2];
const SkipModeInfo *const skip_mode_info =
&cpi->common.current_frame.skip_mode_info;
rf[0] = skip_mode_info->ref_frame_idx_0;
rf[1] = skip_mode_info->ref_frame_idx_1;
MV_REFERENCE_FRAME ref_frame_type = av1_ref_frame_type(rf);
av1_find_mv_refs(&cpi->common, xd, mbmi, ref_frame_type,
x->mbmi_ext->ref_mv_count, xd->ref_mv_stack, xd->weight,
NULL, NULL
#if !CONFIG_C076_INTER_MOD_CTX
,
NULL
#endif //! CONFIG_C076_INTER_MOD_CTX
#if CONFIG_EXTENDED_WARP_PREDICTION
,
NULL, 0, NULL
#endif // CONFIG_EXTENDED_WARP_PREDICTION
);
// TODO(Ravi): Populate mbmi_ext->ref_mv_stack[ref_frame][4] and
// mbmi_ext->weight[ref_frame][4] inside av1_find_mv_refs.
av1_copy_usable_ref_mv_stack_and_weight(xd, x->mbmi_ext, ref_frame_type);
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_copy_mbmi_ext_to_mbmi_ext_frame(
x->mbmi_ext_frame, x->mbmi_ext,
#if CONFIG_SEP_COMP_DRL
mbmi,
#endif // CONFIG_SEP_COMP_DRL
#if CONFIG_SKIP_MODE_ENHANCEMENT
mbmi->skip_mode,
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
av1_ref_frame_type(xd->mi[0]->ref_frame));
#if CONFIG_SKIP_MODE_ENHANCEMENT
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
x->rdmult = origin_mult;
}
static void update_partition_stats(MACROBLOCKD *const xd,
#if CONFIG_ENTROPY_STATS
FRAME_COUNTS *counts,
#endif // CONFIG_ENTROPY_STATS
int allow_update_cdf,
const CommonModeInfoParams *const mi_params,
#if CONFIG_EXT_RECUR_PARTITIONS
int disable_ext_part,
PARTITION_TREE const *ptree_luma,
const CHROMA_REF_INFO *chroma_ref_info,
#endif // CONFIG_EXT_RECUR_PARTITIONS
PARTITION_TYPE partition, const int mi_row,
const int mi_col, BLOCK_SIZE bsize,
const int ctx, BLOCK_SIZE sb_size) {
#if !CONFIG_BLOCK_256
(void)sb_size;
#endif // !CONFIG_BLOCK_256
const TREE_TYPE tree_type = xd->tree_type;
const int plane_index = tree_type == CHROMA_PART;
FRAME_CONTEXT *fc = xd->tile_ctx;
assert(ctx >= 0); // is_partition_point() is true.
#if CONFIG_EXT_RECUR_PARTITIONS
const bool ss_x = xd->plane[1].subsampling_x;
const bool ss_y = xd->plane[1].subsampling_y;
const PARTITION_TYPE derived_partition =
av1_get_normative_forced_partition_type(
mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
#if CONFIG_CB1TO4_SPLIT
BLOCK_INVALID, // as it is a partition point
#endif // CONFIG_CB1TO4_SPLIT
ptree_luma, chroma_ref_info);
if (derived_partition != PARTITION_INVALID) {
assert(partition == derived_partition &&
"Partition does not match normatively derived partition.");
return;
}
const bool do_split = partition != PARTITION_NONE;
if (allow_update_cdf) {
#if CONFIG_ENTROPY_STATS
counts->do_split[plane_index][ctx][do_split]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->do_split_cdf[plane_index][ctx], do_split, 2);
}
if (!do_split) {
return;
}
#if CONFIG_BLOCK_256
const bool do_square_split = partition == PARTITION_SPLIT;
if (is_square_split_eligible(bsize, sb_size)) {
const int square_split_ctx =
square_split_context(xd, mi_row, mi_col, bsize);
#if CONFIG_ENTROPY_STATS
counts->do_square_split[plane_index][square_split_ctx][do_square_split]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->do_square_split_cdf[plane_index][square_split_ctx],
do_square_split, 2);
}
if (do_square_split) {
return;
}
#endif // CONFIG_BLOCK_256
RECT_PART_TYPE rect_type = get_rect_part_type(partition);
if (rect_type_implied_by_bsize(bsize, tree_type) == RECT_INVALID) {
#if CONFIG_ENTROPY_STATS
counts->rect_type[plane_index][ctx][rect_type]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->rect_type_cdf[plane_index][ctx], rect_type, 2);
}
const bool ext_partition_allowed =
!disable_ext_part &&
is_ext_partition_allowed(bsize, rect_type, tree_type);
if (ext_partition_allowed) {
const bool do_ext_partition = (partition >= PARTITION_HORZ_3);
#if CONFIG_ENTROPY_STATS
counts->do_ext_partition[plane_index][rect_type][ctx][do_ext_partition]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(fc->do_ext_partition_cdf[plane_index][rect_type][ctx],
do_ext_partition, 2);
if (do_ext_partition) {
const bool uneven_4way_partition_allowed =
is_uneven_4way_partition_allowed(bsize, rect_type, tree_type);
if (uneven_4way_partition_allowed) {
const bool do_uneven_4way_partition = (partition >= PARTITION_HORZ_4A);
#if CONFIG_ENTROPY_STATS
counts->do_uneven_4way_partition[plane_index][rect_type][ctx]
[do_uneven_4way_partition]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(
fc->do_uneven_4way_partition_cdf[plane_index][rect_type][ctx],
do_uneven_4way_partition, 2);
if (do_uneven_4way_partition) {
const UNEVEN_4WAY_PART_TYPE uneven_4way_type =
(partition == PARTITION_HORZ_4A || partition == PARTITION_VERT_4A)
? UNEVEN_4A
: UNEVEN_4B;
#if CONFIG_ENTROPY_STATS
counts->uneven_4way_partition_type[plane_index][rect_type][ctx]
[uneven_4way_type]++;
#endif // CONFIG_ENTROPY_STATS
update_cdf(
fc->uneven_4way_partition_type_cdf[plane_index][rect_type][ctx],
uneven_4way_type, NUM_UNEVEN_4WAY_PARTS);
}
}
}
}
#else // CONFIG_EXT_RECUR_PARTITIONS
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
const int has_rows = (mi_row + hbs_h) < mi_params->mi_rows;
const int has_cols = (mi_col + hbs_w) < mi_params->mi_cols;
if (has_rows && has_cols) {
int luma_split_flag = 0;
int parent_block_width = block_size_wide[bsize];
if (tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
}
if (luma_split_flag <= 3) {
#if CONFIG_ENTROPY_STATS
counts->partition[plane_index][ctx][partition]++;
#endif // CONFIG_ENTROPY_STATS
if (allow_update_cdf) {
update_cdf(fc->partition_cdf[plane_index][ctx], partition,
partition_cdf_length(bsize));
}
} else {
// if luma blocks uses smaller blocks, then chroma will also split
assert(partition == PARTITION_SPLIT);
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if CONFIG_EXT_RECUR_PARTITIONS
/*!\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] ptree Pointer to the PARTITION_TREE node holding the
* partition info for the current node and all of its
* descendants.
* \param[in] ptree_luma Pointer to the luma partition tree so that the
* encoder to estimate the
* partition type for chroma.
* \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,
const PC_TREE *pc_tree, PARTITION_TREE *ptree,
const PARTITION_TREE *ptree_luma, int *rate) {
#else
/*!\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.
*
* This function works on planes determined by get_partition_plane_start() and
* get_partition_plane_end() based on xd->tree_type.
*
* \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] ptree Pointer to the PARTITION_TREE node holding the
* partition info for the current node and all of its
* descendants.
* \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,
const PC_TREE *pc_tree, PARTITION_TREE *ptree,
int *rate) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
assert(bsize < BLOCK_SIZES_ALL);
const AV1_COMMON *const cm = &cpi->common;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
assert(bsize < BLOCK_SIZES_ALL);
const int hbs_w = mi_size_wide[bsize] / 2;
const int hbs_h = mi_size_high[bsize] / 2;
#if CONFIG_EXT_RECUR_PARTITIONS
const int ebs_w = mi_size_wide[bsize] / 8;
const int ebs_h = mi_size_high[bsize] / 8;
#else
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
#endif // CONFIG_EXT_RECUR_PARTITIONS
PARTITION_TREE *parent = ptree ? ptree->parent : NULL;
const BLOCK_SIZE parent_bsize = parent ? parent->bsize : BLOCK_INVALID;
const int is_partition_root = is_partition_point(bsize
#if CONFIG_CB1TO4_SPLIT
,
parent_bsize
#endif // CONFIG_CB1TO4_SPLIT
);
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_EXT_RECUR_PARTITIONS
const bool disable_ext_part = !cm->seq_params.enable_ext_partitions;
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
if (subsize == BLOCK_INVALID) return;
if (!dry_run && ctx >= 0)
update_partition_stats(xd,
#if CONFIG_ENTROPY_STATS
td->counts,
#endif // CONFIG_ENTROPY_STATS
tile_data->allow_update_cdf, mi_params,
#if CONFIG_EXT_RECUR_PARTITIONS
disable_ext_part, ptree_luma,
&pc_tree->chroma_ref_info,
#endif // CONFIG_EXT_RECUR_PARTITIONS
partition, mi_row, mi_col, bsize, ctx, cm->sb_size);
PARTITION_TREE *sub_tree[4] = { NULL, NULL, NULL, NULL };
#if CONFIG_EXT_RECUR_PARTITIONS
// If two pass partition tree is enable, then store the partition types in
// ptree even if it's dry run.
if (!dry_run || (cpi->sf.part_sf.two_pass_partition_search && ptree)) {
#else
if (!dry_run) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
assert(ptree);
ptree->partition = partition;
ptree->bsize = bsize;
ptree->mi_row = mi_row;
ptree->mi_col = mi_col;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
set_chroma_ref_info(
xd->tree_type, mi_row, mi_col, ptree->index, bsize,
&ptree->chroma_ref_info, parent ? &parent->chroma_ref_info : NULL,
parent_bsize, parent ? parent->partition : PARTITION_NONE, ss_x, ss_y);
switch (partition) {
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_4A:
case PARTITION_HORZ_4B:
case PARTITION_VERT_4A:
case PARTITION_VERT_4B:
#endif // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
break;
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ:
case PARTITION_VERT:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
break;
case PARTITION_HORZ_3:
case PARTITION_VERT_3:
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
default: break;
}
for (int i = 0; i < 4; ++i) sub_tree[i] = ptree->sub_tree[i];
}
#if CONFIG_EXT_RECUR_PARTITIONS
const int track_ptree_luma =
is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize);
if (track_ptree_luma) {
assert(partition ==
sdp_chroma_part_from_luma(bsize, ptree_luma->partition,
cm->seq_params.subsampling_x,
cm->seq_params.subsampling_x));
if (partition != PARTITION_NONE) {
assert(ptree_luma);
assert(ptree_luma->sub_tree);
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
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:
#if CONFIG_EXT_RECUR_PARTITIONS
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->vertical[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_col + hbs_w < cm->mi_params.mi_cols) {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
subsize, pc_tree->vertical[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
}
#else // CONFIG_EXT_RECUR_PARTITIONS
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->vertical[0], rate);
if (mi_col + hbs_w < mi_params->mi_cols) {
encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, dry_run,
subsize, partition, pc_tree->vertical[1], rate);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
case PARTITION_HORZ:
#if CONFIG_EXT_RECUR_PARTITIONS
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->horizontal[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_row + hbs_h < cm->mi_params.mi_rows) {
encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
subsize, pc_tree->horizontal[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
}
#else // CONFIG_EXT_RECUR_PARTITIONS
encode_b(cpi, tile_data, td, tp, mi_row, mi_col, dry_run, subsize,
partition, pc_tree->horizontal[0], rate);
if (mi_row + hbs_h < mi_params->mi_rows) {
encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col, dry_run,
subsize, partition, pc_tree->horizontal[1], rate);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
break;
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ_4A: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->horizontal4a[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
bsize_med, pc_tree->horizontal4a[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_row + 3 * ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + 3 * ebs_h, mi_col, dry_run,
bsize_big, pc_tree->horizontal4a[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
subsize, pc_tree->horizontal4a[3], sub_tree[3],
track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
break;
}
case PARTITION_HORZ_4B: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->horizontal4b[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_row + ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + ebs_h, mi_col, dry_run,
bsize_big, pc_tree->horizontal4b[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_row + 5 * ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + 5 * ebs_h, mi_col, dry_run,
bsize_med, pc_tree->horizontal4b[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
if (mi_row + 7 * ebs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + 7 * ebs_h, mi_col, dry_run,
subsize, pc_tree->horizontal4b[3], sub_tree[3],
track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
break;
}
case PARTITION_VERT_4A: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->vertical4a[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
bsize_med, pc_tree->vertical4a[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_col + 3 * ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 3 * ebs_w, dry_run,
bsize_big, pc_tree->vertical4a[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
subsize, pc_tree->vertical4a[3], sub_tree[3],
track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
break;
}
case PARTITION_VERT_4B: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->vertical4b[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_col + ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + ebs_w, dry_run,
bsize_big, pc_tree->vertical4b[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_col + 5 * ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 5 * ebs_w, dry_run,
bsize_med, pc_tree->vertical4b[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
if (mi_col + 7 * ebs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 7 * ebs_w, dry_run,
subsize, pc_tree->vertical4b[3], sub_tree[3],
track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
break;
}
case PARTITION_HORZ_3:
case PARTITION_VERT_3: {
for (int i = 0; i < 4; ++i) {
const BLOCK_SIZE this_bsize =
get_h_partition_subsize(bsize, i, partition);
const int offset_r = get_h_partition_offset_mi_row(bsize, i, partition);
const int offset_c = get_h_partition_offset_mi_col(bsize, i, partition);
const int this_mi_row = mi_row + offset_r;
const int this_mi_col = mi_col + offset_c;
PC_TREE *this_pc_tree = partition == PARTITION_HORZ_3
? pc_tree->horizontal3[i]
: pc_tree->vertical3[i];
if (partition == PARTITION_HORZ_3) {
if (this_mi_row >= cm->mi_params.mi_rows) break;
} else {
if (this_mi_col >= cm->mi_params.mi_cols) break;
}
encode_sb(cpi, td, tile_data, tp, this_mi_row, this_mi_col, dry_run,
this_bsize, this_pc_tree, sub_tree[i],
track_ptree_luma ? ptree_luma->sub_tree[i] : NULL, rate);
}
break;
}
case PARTITION_SPLIT:
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->split[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
subsize, pc_tree->split[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
subsize, pc_tree->split[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
subsize, pc_tree->split[3], sub_tree[3],
track_ptree_luma ? ptree_luma->sub_tree[3] : NULL, rate);
break;
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->split[0], sub_tree[0], rate);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + hbs_w, dry_run,
subsize, pc_tree->split[1], sub_tree[1], rate);
encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col, dry_run,
subsize, pc_tree->split[2], sub_tree[2], rate);
encode_sb(cpi, td, tile_data, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
subsize, pc_tree->split[3], sub_tree[3], rate);
break;
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_w, dry_run, bsize2,
partition, pc_tree->horizontala[1], rate);
encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, 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_h, mi_col, dry_run, bsize2,
partition, pc_tree->horizontalb[1], rate);
encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col + hbs_w, 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_h, mi_col, dry_run, bsize2,
partition, pc_tree->verticala[1], rate);
encode_b(cpi, tile_data, td, tp, mi_row, mi_col + hbs_w, 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_w, dry_run, bsize2,
partition, pc_tree->verticalb[1], rate);
encode_b(cpi, tile_data, td, tp, mi_row + hbs_h, mi_col + hbs_w, dry_run,
bsize2, partition, pc_tree->verticalb[2], rate);
break;
case PARTITION_HORZ_4:
for (int i = 0; i < SUB_PARTITIONS_PART4; ++i) {
int this_mi_row = mi_row + i * qbs_h;
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 (int i = 0; i < SUB_PARTITIONS_PART4; ++i) {
int this_mi_col = mi_col + i * qbs_w;
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 // CONFIG_EXT_RECUR_PARTITIONS
default: assert(0 && "Invalid partition type."); break;
}
if (ptree) ptree->is_settled = 1;
update_ext_partition_context(xd, mi_row, mi_col, subsize, bsize, partition);
}
#if CONFIG_EXT_RECUR_PARTITIONS
static void build_one_split_tree(AV1_COMMON *const cm, TREE_TYPE tree_type,
int mi_row, int mi_col, BLOCK_SIZE bsize,
BLOCK_SIZE final_bsize,
PARTITION_TREE *ptree) {
assert(block_size_high[bsize] == block_size_wide[bsize]);
if (mi_row >= cm->mi_params.mi_rows || mi_col >= cm->mi_params.mi_cols)
return;
const int ss_x = cm->seq_params.subsampling_x;
const int ss_y = cm->seq_params.subsampling_y;
PARTITION_TREE *parent = ptree->parent;
set_chroma_ref_info(tree_type, mi_row, mi_col, ptree->index, bsize,
&ptree->chroma_ref_info,
parent ? &parent->chroma_ref_info : NULL,
parent ? parent->bsize : BLOCK_INVALID,
parent ? parent->partition : PARTITION_NONE, ss_x, ss_y);
if (bsize == BLOCK_4X4) {
ptree->partition = PARTITION_NONE;
return;
}
const CHROMA_REF_INFO *chroma_ref_info = &ptree->chroma_ref_info;
// Handle boundary for first partition.
PARTITION_TYPE implied_first_partition;
const bool is_first_part_implied = is_partition_implied_at_boundary(
&cm->mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
chroma_ref_info, &implied_first_partition);
if (!is_first_part_implied &&
(block_size_wide[bsize] <= block_size_wide[final_bsize]) &&
(block_size_high[bsize] <= block_size_high[final_bsize])) {
ptree->partition = PARTITION_NONE;
return;
}
// In general, we simulate SPLIT partition as HORZ followed by VERT partition.
// But in case first partition is implied to be VERT, we are forced to use
// VERT followed by HORZ.
PARTITION_TYPE first_partition = PARTITION_INVALID;
if (is_first_part_implied) {
first_partition = implied_first_partition;
} else if (check_is_chroma_size_valid(tree_type, PARTITION_HORZ, bsize,
mi_row, mi_col, ss_x, ss_y,
chroma_ref_info)) {
first_partition = PARTITION_HORZ;
} else if (check_is_chroma_size_valid(tree_type, PARTITION_VERT, bsize,
mi_row, mi_col, ss_x, ss_y,
chroma_ref_info)) {
first_partition = PARTITION_VERT;
}
assert(first_partition != PARTITION_INVALID);
const BLOCK_SIZE subsize = subsize_lookup[PARTITION_SPLIT][bsize];
const int hbs_w = mi_size_wide[bsize] >> 1;
const int hbs_h = mi_size_high[bsize] >> 1;
ptree->partition = first_partition;
if (first_partition == PARTITION_SPLIT) {
ptree->partition = first_partition;
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[2] = av1_alloc_ptree_node(ptree, 2);
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
build_one_split_tree(cm, tree_type, mi_row, mi_col, subsize, final_bsize,
ptree->sub_tree[0]);
build_one_split_tree(cm, tree_type, mi_row, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[1]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col, subsize,
final_bsize, ptree->sub_tree[2]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[3]);
return;
}
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
const PARTITION_TYPE second_partition =
(first_partition == PARTITION_HORZ) ? PARTITION_VERT : PARTITION_HORZ;
#ifndef NDEBUG
// Boundary sanity checks for 2nd partitions.
{
PARTITION_TYPE implied_second_first_partition;
const bool is_second_first_part_implied = is_partition_implied_at_boundary(
&cm->mi_params, tree_type, ss_x, ss_y, mi_row, mi_col,
subsize_lookup[first_partition][bsize],
&ptree->sub_tree[0]->chroma_ref_info, &implied_second_first_partition);
assert(IMPLIES(is_second_first_part_implied,
implied_second_first_partition == second_partition));
}
{
const int mi_row_second_second =
(second_partition == PARTITION_HORZ) ? mi_row + hbs_h : mi_row;
const int mi_col_second_second =
(second_partition == PARTITION_VERT) ? mi_col + hbs_w : mi_col;
PARTITION_TYPE implied_second_second_partition;
const bool is_second_second_part_implied = is_partition_implied_at_boundary(
&cm->mi_params, tree_type, ss_x, ss_y, mi_row_second_second,
mi_col_second_second, subsize_lookup[first_partition][bsize],
&ptree->sub_tree[0]->chroma_ref_info, &implied_second_second_partition);
assert(IMPLIES(is_second_second_part_implied,
implied_second_second_partition == second_partition));
}
#endif // NDEBUG
ptree->sub_tree[0]->partition = second_partition;
ptree->sub_tree[0]->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[0]->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
ptree->sub_tree[1]->partition = second_partition;
ptree->sub_tree[1]->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1]->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
if (first_partition == PARTITION_HORZ) {
assert(second_partition == PARTITION_VERT);
build_one_split_tree(cm, tree_type, mi_row, mi_col, subsize, final_bsize,
ptree->sub_tree[0]->sub_tree[0]);
build_one_split_tree(cm, tree_type, mi_row, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[0]->sub_tree[1]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col, subsize,
final_bsize, ptree->sub_tree[1]->sub_tree[0]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[1]->sub_tree[1]);
} else {
assert(first_partition == PARTITION_VERT);
assert(second_partition == PARTITION_HORZ);
build_one_split_tree(cm, tree_type, mi_row, mi_col, subsize, final_bsize,
ptree->sub_tree[0]->sub_tree[0]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col, subsize,
final_bsize, ptree->sub_tree[0]->sub_tree[1]);
build_one_split_tree(cm, tree_type, mi_row, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[1]->sub_tree[0]);
build_one_split_tree(cm, tree_type, mi_row + hbs_h, mi_col + hbs_w, subsize,
final_bsize, ptree->sub_tree[1]->sub_tree[1]);
}
}
void av1_build_partition_tree_fixed_partitioning(AV1_COMMON *const cm,
TREE_TYPE tree_type,
int mi_row, int mi_col,
BLOCK_SIZE bsize,
PARTITION_TREE *ptree) {
const BLOCK_SIZE sb_size = cm->sb_size;
build_one_split_tree(cm, tree_type, mi_row, mi_col, sb_size, bsize, ptree);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
static PARTITION_TYPE get_preset_partition(const AV1_COMMON *cm,
TREE_TYPE tree_type, int mi_row,
int mi_col, BLOCK_SIZE bsize,
PARTITION_TREE *ptree) {
if (ptree) {
#ifndef NDEBUG
#if CONFIG_EXT_RECUR_PARTITIONS
const bool ss_x = cm->cur_frame->buf.subsampling_x;
const bool ss_y = cm->cur_frame->buf.subsampling_y;
const PARTITION_TYPE derived_partition =
av1_get_normative_forced_partition_type(
&cm->mi_params, tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
#if CONFIG_CB1TO4_SPLIT
ptree->parent ? ptree->parent->bsize : BLOCK_INVALID,
#endif // CONFIG_CB1TO4_SPLIT
/* ptree_luma= */ NULL, &ptree->chroma_ref_info);
assert(IMPLIES(derived_partition != PARTITION_INVALID,
ptree->partition == derived_partition));
#endif // CONFIG_EXT_RECUR_PARTITIONS
#endif // NDEBUG
return ptree->partition;
}
if (bsize >= BLOCK_8X8) {
const int plane_type = (tree_type == CHROMA_PART);
return get_partition(cm, plane_type, mi_row, mi_col, bsize);
}
return PARTITION_NONE;
}
/*!\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] ptree Pointer to the PARTITION_TREE node holding the
pre-calculated partition tree (if any) for the current block
* \param[in] pc_tree Pointer to the PC_TREE node holding the picked
partitions and mode info for the current block
*
* 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, PARTITION_TREE *ptree,
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 int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const ModeCosts *mode_costs = &x->mode_costs;
assert(bsize < BLOCK_SIZES_ALL);
const int bs = mi_size_wide[bsize];
const int hbs = bs / 2;
#if CONFIG_EXT_RECUR_PARTITIONS
const int hbh = mi_size_high[bsize] / 2;
const int hbw = mi_size_wide[bsize] / 2;
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int pl = (bsize >= BLOCK_8X8)
? partition_plane_context(xd, mi_row, mi_col, bsize)
: 0;
const int plane_type = (xd->tree_type == CHROMA_PART);
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end = get_partition_plane_end(xd->tree_type, num_planes);
const PARTITION_TYPE partition =
get_preset_partition(cm, plane_type, mi_row, mi_col, bsize, ptree);
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
RD_SEARCH_MACROBLOCK_CONTEXT x_ctx;
RD_STATS last_part_rdc, invalid_rdc;
if (pc_tree->none == NULL) {
pc_tree->none =
av1_alloc_pmc(cm, xd->tree_type, mi_row, mi_col, bsize, pc_tree,
PARTITION_NONE, 0, ss_x, ss_y, &td->shared_coeff_buf);
}
PICK_MODE_CONTEXT *ctx_none = pc_tree->none;
if (mi_row >= mi_params->mi_rows || mi_col >= mi_params->mi_cols) return;
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(mi_size_wide[bsize] == mi_size_high[bsize]);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
av1_invalid_rd_stats(&last_part_rdc);
av1_invalid_rd_stats(&invalid_rdc);
pc_tree->partitioning = partition;
#if !CONFIG_TX_PARTITION_CTX
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);
#endif // !CONFIG_TX_PARTITION_CTX
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,
&pc_tree->chroma_ref_info);
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 !CONFIG_EXT_RECUR_PARTITIONS
const BLOCK_SIZE split_subsize =
get_partition_subsize(bsize, PARTITION_SPLIT);
for (int i = 0; i < SUB_PARTITIONS_SPLIT; ++i) {
int x_idx = (i & 1) * hbs;
int y_idx = (i >> 1) * hbs;
pc_tree->split[i] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row + y_idx, mi_col + x_idx, split_subsize, pc_tree,
PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
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 CONFIG_EXT_RECUR_PARTITIONS
pc_tree->horizontal[0] =
av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, subsize,
pc_tree, PARTITION_HORZ, 0, 0, ss_x, ss_y);
pc_tree->horizontal[1] =
av1_alloc_pc_tree_node(xd->tree_type, mi_row + hbh, mi_col, subsize,
pc_tree, PARTITION_HORZ, 1, 1, ss_x, ss_y);
av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
&last_part_rdc.rate, &last_part_rdc.dist, 1,
ptree ? ptree->sub_tree[0] : NULL,
pc_tree->horizontal[0]);
#else // CONFIG_EXT_RECUR_PARTITIONS
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
if (pc_tree->horizontal[i] == NULL) {
pc_tree->horizontal[i] = av1_alloc_pmc(
cm, xd->tree_type, mi_row + hbs * i, mi_col, subsize, pc_tree,
PARTITION_HORZ, i, ss_x, ss_y, &td->shared_coeff_buf);
}
}
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
PARTITION_HORZ, subsize, pc_tree->horizontal[0],
invalid_rdc);
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 &&
mi_row + hbs < mi_params->mi_rows) {
RD_STATS tmp_rdc;
av1_init_rd_stats(&tmp_rdc);
#if CONFIG_EXT_RECUR_PARTITIONS
av1_rd_use_partition(
cpi, td, tile_data, mib + hbh * mi_params->mi_stride, tp,
mi_row + hbh, mi_col, subsize, &tmp_rdc.rate, &tmp_rdc.dist, 0,
ptree ? ptree->sub_tree[1] : NULL, pc_tree->horizontal[1]);
#else // CONFIG_EXT_RECUR_PARTITIONS
const PICK_MODE_CONTEXT *const ctx_h = pc_tree->horizontal[0];
av1_update_state(cpi, td, ctx_h, mi_row, mi_col, subsize, 1);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize,
plane_start, plane_end, NULL);
pick_sb_modes(cpi, tile_data, x, mi_row + hbs, mi_col, &tmp_rdc,
PARTITION_HORZ, subsize, pc_tree->horizontal[1],
invalid_rdc);
#endif // CONFIG_EXT_RECUR_PARTITIONS
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 CONFIG_EXT_RECUR_PARTITIONS
pc_tree->vertical[0] =
av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col, subsize,
pc_tree, PARTITION_VERT, 0, 0, ss_x, ss_y);
pc_tree->vertical[1] =
av1_alloc_pc_tree_node(xd->tree_type, mi_row, mi_col + hbw, subsize,
pc_tree, PARTITION_VERT, 1, 1, ss_x, ss_y);
av1_rd_use_partition(cpi, td, tile_data, mib, tp, mi_row, mi_col, subsize,
&last_part_rdc.rate, &last_part_rdc.dist, 1,
ptree ? ptree->sub_tree[0] : NULL,
pc_tree->vertical[0]);
#else // CONFIG_EXT_RECUR_PARTITIONS
for (int i = 0; i < SUB_PARTITIONS_RECT; ++i) {
if (pc_tree->vertical[i] == NULL) {
pc_tree->vertical[i] = av1_alloc_pmc(
cm, xd->tree_type, mi_row, mi_col + hbs * i, subsize, pc_tree,
PARTITION_VERT, i, ss_x, ss_y, &td->shared_coeff_buf);
}
}
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
PARTITION_VERT, subsize, pc_tree->vertical[0], invalid_rdc);
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (last_part_rdc.rate != INT_MAX && bsize >= BLOCK_8X8 &&
mi_col + hbs < mi_params->mi_cols) {
RD_STATS tmp_rdc;
av1_init_rd_stats(&tmp_rdc);
#if CONFIG_EXT_RECUR_PARTITIONS
av1_rd_use_partition(
cpi, td, tile_data, mib + hbw, tp, mi_row, mi_col + hbw, subsize,
&tmp_rdc.rate, &tmp_rdc.dist, 0, ptree ? ptree->sub_tree[1] : NULL,
pc_tree->vertical[1]);
#else // CONFIG_EXT_RECUR_PARTITIONS
const PICK_MODE_CONTEXT *const ctx_v = pc_tree->vertical[0];
av1_update_state(cpi, td, ctx_v, mi_row, mi_col, subsize, 1);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize,
plane_start, plane_end, 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);
#endif // CONFIG_EXT_RECUR_PARTITIONS
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;
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
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;
pc_tree->split[i] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row + y_idx, mi_col + x_idx, subsize, pc_tree,
PARTITION_SPLIT, i, i == 3, ss_x, ss_y);
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),
ptree ? ptree->sub_tree[i] : NULL, 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_HORZ_4A:
case PARTITION_HORZ_4B:
case PARTITION_VERT_4A:
case PARTITION_VERT_4B:
case PARTITION_HORZ_3:
case PARTITION_VERT_3:
#else // CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_SPLIT:
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), NULL,
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:
#endif // CONFIG_EXT_RECUR_PARTITIONS
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[xd->tree_type == CHROMA_PART][pl][partition];
last_part_rdc.rdcost =
RDCOST(x->rdmult, last_part_rdc.rate, last_part_rdc.dist);
}
// If last_part is better set the partitioning to that.
mib[0]->sb_type[plane_type] = bsize;
if (bsize >= BLOCK_8X8) pc_tree->partitioning = partition;
av1_restore_context(cm, 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->sb_size)
assert(last_part_rdc.rate < INT_MAX && last_part_rdc.dist < INT64_MAX);
if (do_recon) {
if (bsize == cm->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);
for (int plane = plane_start; plane < plane_end; plane++) {
x->cb_offset[plane] = 0;
}
av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, OUTPUT_ENABLED, bsize,
pc_tree, xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
#if CONFIG_EXT_RECUR_PARTITIONS
NULL,
#endif // CONFIG_EXT_RECUR_PARTITIONS
NULL);
} else {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
pc_tree, NULL,
#if CONFIG_EXT_RECUR_PARTITIONS
NULL,
#endif // CONFIG_EXT_RECUR_PARTITIONS
NULL);
}
}
*rate = last_part_rdc.rate;
*dist = last_part_rdc.dist;
x->rdmult = orig_rdmult;
}
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
/*! \brief Contains level banks used for rdopt.*/
typedef struct LevelBanksRDO {
#if CONFIG_MVP_IMPROVEMENT
//! The current level bank, used to restore the level bank in MACROBLOCKD.
REF_MV_BANK curr_level_bank;
//! The best level bank from the rdopt process.
REF_MV_BANK best_level_bank;
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
//! The current warp, level bank, used to restore the warp level bank in
//! MACROBLOCKD.
WARP_PARAM_BANK curr_level_warp_bank;
//! The best warp level bank from the rdopt process.
WARP_PARAM_BANK best_level_warp_bank;
#endif // WARP_CU_BANK
} LevelBanksRDO;
static AOM_INLINE void update_best_level_banks(LevelBanksRDO *level_banks,
const MACROBLOCKD *xd) {
#if CONFIG_MVP_IMPROVEMENT
level_banks->best_level_bank = xd->ref_mv_bank;
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
level_banks->best_level_warp_bank = xd->warp_param_bank;
#endif // WARP_CU_BANK
}
static AOM_INLINE void restore_level_banks(MACROBLOCKD *xd,
const LevelBanksRDO *level_banks) {
#if CONFIG_MVP_IMPROVEMENT
xd->ref_mv_bank = level_banks->curr_level_bank;
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
xd->warp_param_bank = level_banks->curr_level_warp_bank;
#endif // WARP_CU_BANK
}
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
#if !CONFIG_EXT_RECUR_PARTITIONS
// Try searching for an encoding for the given subblock. Returns zero if the
// rdcost is already too high (to tell the caller not to bother searching for
// encodings of further subblocks).
static int rd_try_subblock(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, int is_last,
int mi_row, int mi_col, BLOCK_SIZE subsize,
RD_STATS best_rdcost, RD_STATS *sum_rdc,
PARTITION_TYPE partition,
PICK_MODE_CONTEXT *this_ctx) {
MACROBLOCK *const x = &td->mb;
const int orig_mult = x->rdmult;
setup_block_rdmult(cpi, x, mi_row, mi_col, subsize, NO_AQ, NULL);
av1_rd_cost_update(x->rdmult, &best_rdcost);
RD_STATS rdcost_remaining;
av1_rd_stats_subtraction(x->rdmult, &best_rdcost, sum_rdc, &rdcost_remaining);
RD_STATS this_rdc;
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &this_rdc, partition,
subsize, this_ctx, rdcost_remaining);
if (this_rdc.rate == INT_MAX) {
sum_rdc->rdcost = INT64_MAX;
} else {
sum_rdc->rate += this_rdc.rate;
sum_rdc->dist += this_rdc.dist;
av1_rd_cost_update(x->rdmult, sum_rdc);
}
if (sum_rdc->rdcost >= best_rdcost.rdcost) {
x->rdmult = orig_mult;
return 0;
}
MACROBLOCKD *xd = &x->e_mbd;
const AV1_COMMON *const cm = &cpi->common;
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
if (!is_last) {
av1_update_state(cpi, td, this_ctx, mi_row, mi_col, subsize, 1);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL, subsize,
plane_start, plane_end, NULL);
}
x->rdmult = orig_mult;
return 1;
}
// Tests an AB partition, and updates the encoder status, the pick mode
// contexts, the best rdcost, and the best partition.
static bool rd_test_partition3(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp,
PC_TREE *pc_tree, RD_STATS *best_rdc,
PICK_MODE_CONTEXT *ctxs[SUB_PARTITIONS_AB],
int mi_row, int mi_col, BLOCK_SIZE bsize,
PARTITION_TYPE partition,
const BLOCK_SIZE ab_subsize[SUB_PARTITIONS_AB],
const int ab_mi_pos[SUB_PARTITIONS_AB][2]
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const MACROBLOCK *const x = &td->mb;
const MACROBLOCKD *const xd = &x->e_mbd;
const int pl = partition_plane_context(xd, mi_row, mi_col, bsize);
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
sum_rdc.rate =
x->mode_costs.partition_cost[xd->tree_type == CHROMA_PART][pl][partition];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
// Loop over sub-partitions in AB partition type.
for (int i = 0; i < SUB_PARTITIONS_AB; i++) {
assert(ab_subsize[i] != BLOCK_INVALID);
if (!rd_try_subblock(cpi, td, tile_data, tp, i == SUB_PARTITIONS_AB - 1,
ab_mi_pos[i][0], ab_mi_pos[i][1], ab_subsize[i],
*best_rdc, &sum_rdc, partition, ctxs[i]))
return false;
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost >= best_rdc->rdcost) return false;
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
if (sum_rdc.rdcost >= best_rdc->rdcost) return false;
*best_rdc = sum_rdc;
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
pc_tree->partitioning = partition;
return true;
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE PARTITION_TYPE get_forced_partition_type(
const AV1_COMMON *const cm, MACROBLOCK *x, int mi_row, int mi_col,
BLOCK_SIZE bsize,
#if CONFIG_CB1TO4_SPLIT
BLOCK_SIZE parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
const CHROMA_REF_INFO *chroma_ref_info) {
// Partition types forced by bitstream syntax.
const MACROBLOCKD *xd = &x->e_mbd;
const bool ss_x = cm->seq_params.subsampling_x;
const bool ss_y = cm->seq_params.subsampling_y;
const PARTITION_TYPE derived_partition =
av1_get_normative_forced_partition_type(&cm->mi_params, xd->tree_type,
ss_x, ss_y, mi_row, mi_col, bsize,
#if CONFIG_CB1TO4_SPLIT
parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
ptree_luma, chroma_ref_info);
if (derived_partition != PARTITION_INVALID) {
return derived_partition;
}
// Partition types forced by speed_features.
if (template_tree) {
return template_tree->partition;
}
if (should_reuse_mode(x, REUSE_PARTITION_MODE_FLAG)
#if CONFIG_CB1TO4_SPLIT
&& (parent_bsize == BLOCK_INVALID || parent_bsize <= BLOCK_LARGEST)
#endif // CONFIG_CB1TO4_SPLIT
) {
return av1_get_prev_partition(x, mi_row, mi_col, bsize, cm->sb_size);
}
return PARTITION_INVALID;
}
static AOM_INLINE void init_allowed_partitions(
PartitionSearchState *part_search_state, const PartitionCfg *part_cfg,
const CHROMA_REF_INFO *chroma_ref_info, TREE_TYPE tree_type) {
const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const int mi_row = blk_params->mi_row;
const int mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
const bool has_rows = blk_params->has_rows;
const bool has_cols = blk_params->has_cols;
const bool ss_x = part_search_state->ss_x;
const bool ss_y = part_search_state->ss_y;
part_search_state->do_rectangular_split = part_cfg->enable_rect_partitions;
const BLOCK_SIZE horz_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE vert_subsize = get_partition_subsize(bsize, PARTITION_VERT);
const int is_horz_size_valid =
is_partition_valid(bsize, PARTITION_HORZ) &&
check_is_chroma_size_valid(tree_type, PARTITION_HORZ, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info);
const int is_vert_size_valid =
is_partition_valid(bsize, PARTITION_VERT) &&
check_is_chroma_size_valid(tree_type, PARTITION_VERT, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info);
// Initialize allowed partition types for the partition block.
part_search_state->is_block_splittable =
is_partition_point(bsize
#if CONFIG_CB1TO4_SPLIT
,
blk_params->parent_bsize
#endif // CONFIG_CB1TO4_SPLIT
);
part_search_state->partition_none_allowed =
(tree_type == CHROMA_PART && bsize == BLOCK_8X8) ||
(has_rows && has_cols &&
is_bsize_geq(blk_params->bsize, blk_params->min_partition_size));
part_search_state->partition_rect_allowed[HORZ] =
part_search_state->is_block_splittable &&
part_cfg->enable_rect_partitions &&
is_bsize_geq(horz_subsize, blk_params->min_partition_size) &&
is_horz_size_valid;
part_search_state->partition_rect_allowed[VERT] =
part_search_state->is_block_splittable &&
part_cfg->enable_rect_partitions &&
is_bsize_geq(vert_subsize, blk_params->min_partition_size) &&
is_vert_size_valid;
const int ext_partition_allowed = part_search_state->ext_partition_allowed =
part_search_state->is_block_splittable &&
part_cfg->enable_ext_partitions &&
is_ext_partition_allowed_at_bsize(bsize, tree_type);
part_search_state->partition_3_allowed[HORZ] =
ext_partition_allowed &&
get_partition_subsize(bsize, PARTITION_HORZ_3) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_HORZ_3, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_3),
blk_params->min_partition_size)
#if CONFIG_CB1TO4_SPLIT
&& is_bsize_geq(get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_HORZ_3, ss_x, ss_y),
blk_params->has_3_4th_rows)
#endif // CONFIG_CB1TO4_SPLIT
;
part_search_state->partition_3_allowed[VERT] =
ext_partition_allowed &&
get_partition_subsize(bsize, PARTITION_VERT_3) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_VERT_3, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_3),
blk_params->min_partition_size)
#if CONFIG_CB1TO4_SPLIT
&& is_bsize_geq(get_h_partition_subsize(bsize, 1, PARTITION_VERT_3),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_VERT_3, ss_x, ss_y),
blk_params->has_3_4th_cols)
#endif // CONFIG_CB1TO4_SPLIT
;
const int uneven_4way_partition_allowed =
part_search_state->ext_partition_allowed =
part_cfg->enable_ext_partitions &&
is_uneven_4way_partition_allowed_at_bsize(bsize, tree_type);
part_search_state->partition_4a_allowed[HORZ] =
uneven_4way_partition_allowed &&
get_partition_subsize(bsize, PARTITION_HORZ_4A) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_HORZ_4A, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_4A),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_HORZ_4A, ss_x, ss_y),
blk_params->has_7_8th_rows);
part_search_state->partition_4b_allowed[HORZ] =
uneven_4way_partition_allowed &&
get_partition_subsize(bsize, PARTITION_HORZ_4B) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_HORZ_4B, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_HORZ_4B),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_HORZ_4B, ss_x, ss_y),
blk_params->has_7_8th_rows);
part_search_state->partition_4a_allowed[VERT] =
uneven_4way_partition_allowed &&
get_partition_subsize(bsize, PARTITION_VERT_4A) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_VERT_4A, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_4A),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_VERT_4A, ss_x, ss_y),
blk_params->has_7_8th_cols);
part_search_state->partition_4b_allowed[VERT] =
uneven_4way_partition_allowed &&
get_partition_subsize(bsize, PARTITION_VERT_4B) != BLOCK_INVALID &&
check_is_chroma_size_valid(tree_type, PARTITION_VERT_4B, bsize, mi_row,
mi_col, ss_x, ss_y, chroma_ref_info) &&
is_bsize_geq(get_partition_subsize(bsize, PARTITION_VERT_4B),
blk_params->min_partition_size) &&
IMPLIES(have_nz_chroma_ref_offset(bsize, PARTITION_VERT_4B, ss_x, ss_y),
blk_params->has_7_8th_cols);
// Reset the flag indicating whether a partition leading to a rdcost lower
// than the bound best_rdc has been found.
part_search_state->found_best_partition = false;
}
static const int kZeroPartitionCosts[ALL_PARTITION_TYPES];
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Initialize state variables of partition search used in
// av1_rd_pick_partition().
static void init_partition_search_state_params(
MACROBLOCK *x, AV1_COMP *const cpi, PartitionSearchState *part_search_state,
#if CONFIG_EXT_RECUR_PARTITIONS
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, int max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
int mi_row, int mi_col, BLOCK_SIZE bsize) {
MACROBLOCKD *const xd = &x->e_mbd;
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const CommonModeInfoParams *const mi_params = &cpi->common.mi_params;
const TREE_TYPE tree_type = xd->tree_type;
assert(bsize < BLOCK_SIZES_ALL);
// Initialization of block size related parameters.
blk_params->mi_step = mi_size_wide[bsize] / 2;
#if CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_step_h = mi_size_high[bsize] / 2;
blk_params->mi_step_w = mi_size_wide[bsize] / 2;
#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_row = mi_row;
blk_params->mi_col = mi_col;
#if CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_row_edge = mi_row + blk_params->mi_step_h;
blk_params->mi_col_edge = mi_col + blk_params->mi_step_w;
#else // CONFIG_EXT_RECUR_PARTITIONS
blk_params->mi_row_edge = mi_row + blk_params->mi_step;
blk_params->mi_col_edge = mi_col + blk_params->mi_step;
#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->width = block_size_wide[bsize];
#if CONFIG_EXT_RECUR_PARTITIONS
blk_params->min_partition_size = x->sb_enc.min_partition_size;
#else
blk_params->min_partition_size_1d =
block_size_wide[x->sb_enc.min_partition_size];
#endif // CONFIG_EXT_RECUR_PARTITIONS
blk_params->subsize = get_partition_subsize(bsize, PARTITION_SPLIT);
blk_params->split_bsize2 = blk_params->subsize;
#if !CONFIG_EXT_RECUR_PARTITIONS
blk_params->bsize_at_least_8x8 = (bsize >= BLOCK_8X8);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
blk_params->bsize = bsize;
#if CONFIG_CB1TO4_SPLIT
blk_params->parent_bsize =
pc_tree->parent ? pc_tree->parent->block_size : BLOCK_INVALID;
#endif // CONFIG_CB1TO4_SPLIT
// Chroma subsampling.
part_search_state->ss_x = x->e_mbd.plane[1].subsampling_x;
part_search_state->ss_y = x->e_mbd.plane[1].subsampling_y;
// Check if the partition corresponds to edge block.
blk_params->has_rows = (blk_params->mi_row_edge < mi_params->mi_rows);
blk_params->has_cols = (blk_params->mi_col_edge < mi_params->mi_cols);
const int ebw = mi_size_wide[bsize] / 8;
const int ebh = mi_size_high[bsize] / 8;
blk_params->has_7_8th_rows = (mi_row + 7 * ebh < mi_params->mi_rows);
blk_params->has_7_8th_cols = (mi_col + 7 * ebw < mi_params->mi_cols);
#if CONFIG_CB1TO4_SPLIT
blk_params->has_3_4th_rows = (mi_row + 6 * ebh < mi_params->mi_rows);
blk_params->has_3_4th_cols = (mi_col + 6 * ebw < mi_params->mi_cols);
#endif // CONFIG_CB1TO4_SPLIT
// Update intra partitioning related info.
part_search_state->intra_part_info = &x->part_search_info;
// Prepare for segmentation CNN-based partitioning for intra-frame.
if (frame_is_intra_only(cm) && bsize == BLOCK_64X64) {
part_search_state->intra_part_info->quad_tree_idx = 0;
part_search_state->intra_part_info->cnn_output_valid = 0;
}
// Set partition plane context index.
part_search_state->pl_ctx_idx =
#if CONFIG_EXT_RECUR_PARTITIONS
is_partition_point(bsize
#if CONFIG_CB1TO4_SPLIT
,
blk_params->parent_bsize
#endif // CONFIG_CB1TO4_SPLIT
)
#else
blk_params->bsize_at_least_8x8
#endif // CONFIG_EXT_RECUR_PARTITIONS
? partition_plane_context(xd, mi_row, mi_col, bsize)
: 0;
// Partition cost buffer update
ModeCosts *mode_costs = &x->mode_costs;
part_search_state->partition_cost =
mode_costs->partition_cost[tree_type == CHROMA_PART]
[part_search_state->pl_ctx_idx];
#if CONFIG_EXT_RECUR_PARTITIONS
if (av1_get_normative_forced_partition_type(
mi_params, tree_type, part_search_state->ss_x,
part_search_state->ss_y, mi_row, mi_col, bsize,
#if CONFIG_CB1TO4_SPLIT
blk_params->parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
ptree_luma, &pc_tree->chroma_ref_info) != PARTITION_INVALID) {
part_search_state->partition_cost = kZeroPartitionCosts;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Initialize HORZ and VERT win flags as true for all split partitions.
for (int i = 0; i < SUB_PARTITIONS_SPLIT; i++) {
part_search_state->split_part_rect_win[i].rect_part_win[HORZ] = true;
part_search_state->split_part_rect_win[i].rect_part_win[VERT] = true;
}
// Initialize the rd cost.
av1_init_rd_stats(&part_search_state->this_rdc);
// Initialize RD costs for partition types to 0.
part_search_state->none_rd = 0;
av1_zero(part_search_state->split_rd);
av1_zero(part_search_state->rect_part_rd);
// Initialize SPLIT partition to be not ready.
av1_zero(part_search_state->is_split_ctx_is_ready);
// Initialize HORZ and VERT partitions to be not ready.
av1_zero(part_search_state->is_rect_ctx_is_ready);
// Initialize partition search flags to defaults.
part_search_state->terminate_partition_search = 0;
av1_zero(part_search_state->prune_rect_part);
#if CONFIG_EXT_RECUR_PARTITIONS
part_search_state->partition_boundaries = NULL;
part_search_state->prune_partition_none = false;
av1_zero(part_search_state->prune_partition_3);
av1_zero(part_search_state->prune_partition_4a);
av1_zero(part_search_state->prune_partition_4b);
part_search_state->forced_partition = get_forced_partition_type(
cm, x, mi_row, mi_col, bsize,
#if CONFIG_CB1TO4_SPLIT
blk_params->parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
ptree_luma, template_tree, &pc_tree->chroma_ref_info);
init_allowed_partitions(part_search_state, &cpi->oxcf.part_cfg,
&pc_tree->chroma_ref_info, tree_type);
if (max_recursion_depth == 0) {
part_search_state->prune_rect_part[HORZ] =
part_search_state->prune_rect_part[VERT] = true;
part_search_state->prune_partition_3[HORZ] =
part_search_state->prune_partition_3[VERT] = true;
part_search_state->prune_partition_4a[HORZ] =
part_search_state->prune_partition_4a[VERT] = true;
part_search_state->prune_partition_4b[HORZ] =
part_search_state->prune_partition_4b[VERT] = true;
}
#else
part_search_state->do_square_split =
blk_params->bsize_at_least_8x8 &&
(tree_type != CHROMA_PART || bsize > BLOCK_8X8);
part_search_state->do_rectangular_split =
cpi->oxcf.part_cfg.enable_rect_partitions &&
(tree_type != CHROMA_PART || bsize > BLOCK_8X8);
const BLOCK_SIZE horz_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE vert_subsize = get_partition_subsize(bsize, PARTITION_VERT);
const int is_horz_size_valid =
horz_subsize != BLOCK_INVALID &&
get_plane_block_size(horz_subsize, part_search_state->ss_x,
part_search_state->ss_y) != BLOCK_INVALID;
const int is_vert_size_valid =
vert_subsize != BLOCK_INVALID &&
get_plane_block_size(vert_subsize, part_search_state->ss_x,
part_search_state->ss_y) != BLOCK_INVALID;
const bool no_sub_16_chroma_part =
tree_type != CHROMA_PART ||
(block_size_wide[bsize] > 8 && block_size_high[bsize] > 8);
// Initialize allowed partition types for the partition block.
part_search_state->is_block_splittable = is_partition_point(bsize);
part_search_state->partition_none_allowed =
blk_params->has_rows && blk_params->has_cols;
part_search_state->partition_rect_allowed[HORZ] =
blk_params->has_cols && blk_params->bsize_at_least_8x8 &&
no_sub_16_chroma_part && cpi->oxcf.part_cfg.enable_rect_partitions &&
is_horz_size_valid;
part_search_state->partition_rect_allowed[VERT] =
blk_params->has_rows && blk_params->bsize_at_least_8x8 &&
no_sub_16_chroma_part && cpi->oxcf.part_cfg.enable_rect_partitions &&
is_vert_size_valid;
// Reset the flag indicating whether a partition leading to a rdcost lower
// than the bound best_rdc has been found.
part_search_state->found_best_partition = false;
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
#if !CONFIG_EXT_RECUR_PARTITIONS
// Override partition cost buffer for the edge blocks.
static void set_partition_cost_for_edge_blk(
AV1_COMMON const *cm, MACROBLOCKD *const xd,
PartitionSearchState *part_search_state) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
assert(blk_params.bsize_at_least_8x8 && part_search_state->pl_ctx_idx >= 0);
const int plane = xd->tree_type == CHROMA_PART;
const aom_cdf_prob *partition_cdf =
cm->fc->partition_cdf[plane][part_search_state->pl_ctx_idx];
const int max_cost = av1_cost_symbol(0);
for (PARTITION_TYPE i = 0; i < PARTITION_TYPES; ++i)
part_search_state->tmp_partition_cost[i] = max_cost;
if (blk_params.has_cols) {
// At the bottom, the two possibilities are HORZ and SPLIT.
aom_cdf_prob bot_cdf[2];
partition_gather_vert_alike(bot_cdf, partition_cdf, blk_params.bsize);
static const int bot_inv_map[2] = { PARTITION_HORZ, PARTITION_SPLIT };
av1_cost_tokens_from_cdf(part_search_state->tmp_partition_cost, bot_cdf,
bot_inv_map);
} else if (blk_params.has_rows) {
// At the right, the two possibilities are VERT and SPLIT.
aom_cdf_prob rhs_cdf[2];
partition_gather_horz_alike(rhs_cdf, partition_cdf, blk_params.bsize);
static const int rhs_inv_map[2] = { PARTITION_VERT, PARTITION_SPLIT };
av1_cost_tokens_from_cdf(part_search_state->tmp_partition_cost, rhs_cdf,
rhs_inv_map);
} else {
// At the bottom right, we always split.
part_search_state->tmp_partition_cost[PARTITION_SPLIT] = 0;
}
// Override the partition cost buffer.
part_search_state->partition_cost = part_search_state->tmp_partition_cost;
}
// Reset the partition search state flags when
// must_find_valid_partition is equal to 1.
static AOM_INLINE void reset_part_limitations(
AV1_COMP *const cpi, PartitionSearchState *part_search_state) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
part_search_state->do_square_split =
blk_params.bsize_at_least_8x8 &&
(blk_params.width > blk_params.min_partition_size_1d);
part_search_state->partition_none_allowed =
blk_params.has_rows && blk_params.has_cols &&
(blk_params.width >= blk_params.min_partition_size_1d);
// Initialize allowed partition types for the partition block.
part_search_state->partition_rect_allowed[HORZ] =
blk_params.has_cols &&
is_partition_valid(blk_params.bsize, PARTITION_HORZ) &&
get_plane_block_size(
get_partition_subsize(blk_params.bsize, PARTITION_HORZ),
part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID &&
(blk_params.width > blk_params.min_partition_size_1d) &&
cpi->oxcf.part_cfg.enable_rect_partitions;
part_search_state->partition_rect_allowed[VERT] =
blk_params.has_rows &&
is_partition_valid(blk_params.bsize, PARTITION_VERT) &&
get_plane_block_size(
get_partition_subsize(blk_params.bsize, PARTITION_VERT),
part_search_state->ss_x, part_search_state->ss_y) != BLOCK_INVALID &&
(blk_params.width > blk_params.min_partition_size_1d) &&
cpi->oxcf.part_cfg.enable_rect_partitions;
part_search_state->terminate_partition_search = 0;
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
static const int rect_partition_type[NUM_RECT_PARTS] = { PARTITION_HORZ,
PARTITION_VERT };
#if !CONFIG_EXT_RECUR_PARTITIONS
// Rectangular partitions evaluation at sub-block level.
static void rd_pick_rect_partition(AV1_COMP *const cpi, TileDataEnc *tile_data,
MACROBLOCK *x,
PICK_MODE_CONTEXT *cur_partition_ctx,
PartitionSearchState *part_search_state,
RD_STATS *best_rdc, const int idx,
int mi_row, int mi_col, BLOCK_SIZE bsize,
PARTITION_TYPE partition_type) {
// Obtain the remainder from the best rd cost
// for further processing of partition.
RD_STATS best_remain_rdcost;
av1_rd_stats_subtraction(x->rdmult, best_rdc, &part_search_state->sum_rdc,
&best_remain_rdcost);
// Obtain the best mode for the partition sub-block.
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &part_search_state->this_rdc,
partition_type, bsize, cur_partition_ctx, best_remain_rdcost);
av1_rd_cost_update(x->rdmult, &part_search_state->this_rdc);
// Update the partition rd cost with the current sub-block rd.
if (part_search_state->this_rdc.rate == INT_MAX) {
part_search_state->sum_rdc.rdcost = INT64_MAX;
} else {
part_search_state->sum_rdc.rate += part_search_state->this_rdc.rate;
part_search_state->sum_rdc.dist += part_search_state->this_rdc.dist;
av1_rd_cost_update(x->rdmult, &part_search_state->sum_rdc);
}
const RECT_PART_TYPE rect_part =
partition_type == PARTITION_HORZ ? HORZ : VERT;
part_search_state->rect_part_rd[rect_part][idx] =
part_search_state->this_rdc.rdcost;
}
#else
static void rd_pick_rect_partition(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree,
PartitionSearchState *part_search_state, const RD_STATS *best_rdc,
RECT_PART_TYPE rect_type,
const int mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][2],
BLOCK_SIZE bsize, const int is_not_edge_block[NUM_RECT_PARTS],
SB_MULTI_PASS_MODE multi_pass_mode, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, bool *both_blocks_skippable,
int max_recursion_depth) {
const PARTITION_TYPE partition_type = rect_partition_type[rect_type];
RD_STATS *sum_rdc = &part_search_state->sum_rdc;
sum_rdc->rate = part_search_state->partition_cost[partition_type];
sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, 0);
RD_STATS this_rdc;
RD_STATS best_remain_rdcost;
PC_TREE **sub_tree =
(rect_type == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
*both_blocks_skippable = true;
av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
bool partition_found = av1_rd_pick_partition(
cpi, td, tile_data, tp, mi_pos_rect[rect_type][0][0],
mi_pos_rect[rect_type][0][1], bsize, &this_rdc, best_remain_rdcost,
sub_tree[0], get_partition_subtree_const(ptree_luma, 0),
get_partition_subtree_const(template_tree, 0), max_recursion_depth, NULL,
NULL, multi_pass_mode, NULL);
av1_rd_cost_update(x->rdmult, &this_rdc);
if (!partition_found) {
av1_invalid_rd_stats(sum_rdc);
return;
} else {
*both_blocks_skippable &= sub_tree[0]->skippable;
sum_rdc->rate += this_rdc.rate;
sum_rdc->dist += this_rdc.dist;
av1_rd_cost_update(x->rdmult, sum_rdc);
}
part_search_state->rect_part_rd[rect_type][0] = this_rdc.rdcost;
if (sum_rdc->rdcost < best_rdc->rdcost && is_not_edge_block[rect_type]) {
av1_rd_stats_subtraction(x->rdmult, best_rdc, sum_rdc, &best_remain_rdcost);
partition_found = av1_rd_pick_partition(
cpi, td, tile_data, tp, mi_pos_rect[rect_type][1][0],
mi_pos_rect[rect_type][1][1], bsize, &this_rdc, best_remain_rdcost,
sub_tree[1], get_partition_subtree_const(ptree_luma, 1),
get_partition_subtree_const(template_tree, 1), max_recursion_depth,
NULL, NULL, multi_pass_mode, NULL);
av1_rd_cost_update(x->rdmult, &this_rdc);
part_search_state->rect_part_rd[rect_type][1] = this_rdc.rdcost;
if (!partition_found) {
av1_invalid_rd_stats(sum_rdc);
return;
} else {
*both_blocks_skippable &= sub_tree[1]->skippable;
sum_rdc->rate += this_rdc.rate;
sum_rdc->dist += this_rdc.dist;
av1_rd_cost_update(x->rdmult, sum_rdc);
}
}
}
static AOM_INLINE bool is_part_pruned_by_forced_partition(
const PartitionSearchState *part_state, PARTITION_TYPE partition) {
const PARTITION_TYPE forced_partition = part_state->forced_partition;
return forced_partition != PARTITION_INVALID && forced_partition != partition;
}
#endif
typedef int (*active_edge_info)(const AV1_COMP *cpi, int mi_col, int mi_step);
// Checks if HORZ / VERT partition search is allowed.
static AOM_INLINE int is_rect_part_allowed(
const AV1_COMP *cpi, PartitionSearchState *part_search_state,
active_edge_info *active_edge, RECT_PART_TYPE rect_part, const int mi_pos) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
#if CONFIG_EXT_RECUR_PARTITIONS
const int mi_step =
(rect_part == HORZ) ? blk_params.mi_step_h : blk_params.mi_step_w;
#else
const int mi_step = blk_params.mi_step;
#endif // CONFIG_EXT_RECUR_PARTITIONS
const int is_part_allowed =
(!part_search_state->terminate_partition_search &&
part_search_state->partition_rect_allowed[rect_part] &&
!part_search_state->prune_rect_part[rect_part] &&
#if CONFIG_EXT_RECUR_PARTITIONS
is_partition_valid(blk_params.bsize, rect_partition_type[rect_part]) &&
#endif // CONFIG_EXT_RECUR_PARTITIONS
(part_search_state->do_rectangular_split ||
active_edge[rect_part](cpi, mi_pos, mi_step)));
return is_part_allowed;
}
#if CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE void prune_rect_with_none_rd(
PartitionSearchState *part_search_state, BLOCK_SIZE bsize, int q_index,
int rdmult, int64_t part_none_rd, const int *is_not_edge_block) {
for (RECT_PART_TYPE rect = 0; rect < NUM_RECT_PARTS; rect++) {
// Disable pruning on the boundary
if (!is_not_edge_block[rect]) {
continue;
}
const PARTITION_TYPE partition_type = rect_partition_type[rect];
float discount_factor = 1.1f;
const int q_thresh = 180;
if (q_index < q_thresh) {
discount_factor -= 0.025f;
}
if (AOMMAX(block_size_wide[bsize], block_size_high[bsize]) < 16) {
discount_factor -= 0.02f;
}
const int part_rate = part_search_state->partition_cost[partition_type];
const int64_t est_rd = (int64_t)(part_none_rd / discount_factor) +
RDCOST(rdmult, part_rate, 0);
if (est_rd > part_none_rd) {
part_search_state->prune_rect_part[rect] = true;
}
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Rectangular partition types search function.
static void rectangular_partition_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree,
RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
#if CONFIG_EXT_RECUR_PARTITIONS
SB_MULTI_PASS_MODE multi_pass_mode, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, int max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
RD_RECT_PART_WIN_INFO *rect_part_win_info,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
int64_t part_none_rd) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
RD_STATS *sum_rdc = &part_search_state->sum_rdc;
MACROBLOCKD *xd = &x->e_mbd;
const int plane_start = get_partition_plane_start(xd->tree_type);
const int plane_end =
get_partition_plane_end(xd->tree_type, av1_num_planes(cm));
(void)plane_start;
(void)plane_end;
#if CONFIG_EXT_RECUR_PARTITIONS
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
#else // !CONFIG_EXT_RECUR_PARTITIONS
(void)part_none_rd;
#endif // CONFIG_EXT_RECUR_PARTITIONS
// mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][0]: mi_row postion of
// HORZ and VERT partition types.
// mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][1]: mi_col postion of
// HORZ and VERT partition types.
const int mi_pos_rect[NUM_RECT_PARTS][SUB_PARTITIONS_RECT][2] = {
{ { blk_params.mi_row, blk_params.mi_col },
{ blk_params.mi_row_edge, blk_params.mi_col } },
{ { blk_params.mi_row, blk_params.mi_col },
{ blk_params.mi_row, blk_params.mi_col_edge } }
};
// Initialize active edge_type function pointer
// for HOZR and VERT partition types.
active_edge_info active_edge_type[NUM_RECT_PARTS] = { av1_active_h_edge,
av1_active_v_edge };
// Indicates edge blocks for HORZ and VERT partition types.
const int is_not_edge_block[NUM_RECT_PARTS] = { blk_params.has_rows,
blk_params.has_cols };
#if !CONFIG_EXT_RECUR_PARTITIONS
// Initialize pc tree context for HORZ and VERT partition types.
PICK_MODE_CONTEXT **cur_ctx[NUM_RECT_PARTS][SUB_PARTITIONS_RECT] = {
{ &pc_tree->horizontal[0], &pc_tree->horizontal[1] },
{ &pc_tree->vertical[0], &pc_tree->vertical[1] }
};
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
const CommonModeInfoParams *const mi_params = &cpi->common.mi_params;
const BLOCK_SIZE bsize = blk_params.bsize;
const bool is_whole_block_inside =
(blk_params.mi_row + mi_size_high[bsize] < mi_params->mi_rows) &&
(blk_params.mi_col + mi_size_wide[bsize] < mi_params->mi_cols);
const bool try_prune_with_ml =
cpi->sf.part_sf.prune_rect_with_ml && !frame_is_intra_only(cm) &&
part_search_state->forced_partition == PARTITION_INVALID &&
is_whole_block_inside && part_none_rd < INT64_MAX &&
(is_rect_part_allowed(cpi, part_search_state, active_edge_type, HORZ,
mi_pos_rect[HORZ][0][HORZ]) ||
is_rect_part_allowed(cpi, part_search_state, active_edge_type, VERT,
mi_pos_rect[VERT][0][VERT]));
if (try_prune_with_ml && bsize != BLOCK_4X8 && bsize != BLOCK_8X4 &&
is_partition_point(bsize
#if CONFIG_CB1TO4_SPLIT
,
blk_params.parent_bsize
#endif // CONFIG_CB1TO4_SPLIT
)) {
float ml_features[19];
av1_gather_erp_rect_features(ml_features, cpi, x, &tile_data->tile_info,
pc_tree, part_search_state, part_none_rd,
mi_pos_rect);
const bool is_hd = AOMMIN(cm->width, cm->height) >= 1080;
av1_erp_prune_rect(bsize, is_hd, ml_features,
&part_search_state->prune_rect_part[HORZ],
&part_search_state->prune_rect_part[VERT]);
}
if (cpi->sf.part_sf.prune_rect_with_none_rd &&
part_search_state->forced_partition == PARTITION_INVALID &&
!frame_is_intra_only(cm) && part_none_rd < INT64_MAX) {
prune_rect_with_none_rd(part_search_state, bsize, x->qindex, x->rdmult,
part_none_rd, is_not_edge_block);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Loop over rectangular partition types.
for (RECT_PART_TYPE i = HORZ; i < NUM_RECT_PARTS; i++) {
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part_search_state->partition_rect_allowed[i]));
// Check if the HORZ / VERT partition search is to be performed.
if (!is_rect_part_allowed(cpi, part_search_state, active_edge_type, i,
mi_pos_rect[i][0][i]))
continue;
// Sub-partition idx.
const PARTITION_TYPE partition_type = rect_partition_type[i];
blk_params.subsize =
get_partition_subsize(blk_params.bsize, partition_type);
const int part_hv_rate = part_search_state->partition_cost[partition_type];
if (part_hv_rate == INT_MAX ||
RDCOST(x->rdmult, part_hv_rate, 0) >= best_rdc->rdcost) {
continue;
}
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(blk_params.subsize <= BLOCK_LARGEST);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
av1_init_rd_stats(sum_rdc);
#if CONFIG_EXT_RECUR_PARTITIONS
if (is_part_pruned_by_forced_partition(part_search_state, partition_type)) {
continue;
}
PC_TREE **sub_tree = (i == HORZ) ? pc_tree->horizontal : pc_tree->vertical;
assert(sub_tree);
const int num_planes = av1_num_planes(cm);
for (int idx = 0; idx < SUB_PARTITIONS_RECT; idx++) {
if (sub_tree[idx]) {
av1_free_pc_tree_recursive(sub_tree[idx], num_planes, 0, 0);
sub_tree[idx] = NULL;
}
}
sub_tree[0] = av1_alloc_pc_tree_node(
xd->tree_type, mi_pos_rect[i][0][0], mi_pos_rect[i][0][1],
blk_params.subsize, pc_tree, partition_type, 0, 0, ss_x, ss_y);
sub_tree[1] = av1_alloc_pc_tree_node(
xd->tree_type, mi_pos_rect[i][1][0], mi_pos_rect[i][1][1],
blk_params.subsize, pc_tree, partition_type, 1, 1, ss_x, ss_y);
bool both_blocks_skippable = true;
const int track_ptree_luma =
is_luma_chroma_share_same_partition(x->e_mbd.tree_type, ptree_luma,
bsize) &&
partition_type ==
sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
rd_pick_rect_partition(
cpi, td, tile_data, tp, x, pc_tree, part_search_state, best_rdc, i,
mi_pos_rect, blk_params.subsize, is_not_edge_block, multi_pass_mode,
track_ptree_luma ? ptree_luma : NULL, template_tree,
&both_blocks_skippable, max_recursion_depth);
#else
int sub_part_idx = 0;
for (int j = 0; j < SUB_PARTITIONS_RECT; j++) {
assert(cur_ctx[i][j] != NULL);
if (cur_ctx[i][j][0] == NULL) {
cur_ctx[i][j][0] =
av1_alloc_pmc(cm, xd->tree_type, mi_pos_rect[i][j][0],
mi_pos_rect[i][j][1], blk_params.subsize, pc_tree,
partition_type, j, part_search_state->ss_x,
part_search_state->ss_y, &td->shared_coeff_buf);
}
}
sum_rdc->rate = part_search_state->partition_cost[partition_type];
sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, 0);
#if CONFIG_COLLECT_PARTITION_STATS
if (best_rdc.rdcost - sum_rdc->rdcost >= 0) {
partition_attempts[partition_type] += 1;
aom_usec_timer_start(&partition_timer);
partition_timer_on = 1;
}
#endif
// First sub-partition evaluation in HORZ / VERT partition type.
rd_pick_rect_partition(
cpi, tile_data, x, cur_ctx[i][sub_part_idx][0], part_search_state,
best_rdc, 0, mi_pos_rect[i][sub_part_idx][0],
mi_pos_rect[i][sub_part_idx][1], blk_params.subsize, partition_type);
// Start of second sub-partition evaluation.
// Evaluate second sub-partition if the first sub-partition cost
// is less than the best cost and if it is not an edge block.
if (sum_rdc->rdcost < best_rdc->rdcost && is_not_edge_block[i]) {
const MB_MODE_INFO *const mbmi = &cur_ctx[i][sub_part_idx][0]->mic;
const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
// Neither palette mode nor cfl predicted.
if (pmi->palette_size[PLANE_TYPE_Y] == 0 &&
pmi->palette_size[PLANE_TYPE_UV] == 0) {
if (mbmi->uv_mode != UV_CFL_PRED)
part_search_state->is_rect_ctx_is_ready[i] = 1;
}
av1_update_state(cpi, td, cur_ctx[i][sub_part_idx][0], blk_params.mi_row,
blk_params.mi_col, blk_params.subsize, DRY_RUN_NORMAL);
encode_superblock(cpi, tile_data, td, tp, DRY_RUN_NORMAL,
blk_params.subsize, plane_start, plane_end, NULL);
// Second sub-partition evaluation in HORZ / VERT partition type.
sub_part_idx = 1;
rd_pick_rect_partition(
cpi, tile_data, x, cur_ctx[i][sub_part_idx][0], part_search_state,
best_rdc, 1, mi_pos_rect[i][sub_part_idx][0],
mi_pos_rect[i][sub_part_idx][1], blk_params.subsize, partition_type);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_COLLECT_PARTITION_STATS
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
int64_t time = aom_usec_timer_elapsed(&partition_timer);
partition_times[partition_type] += time;
partition_timer_on = 0;
}
#endif
// Update HORZ / VERT best partition.
if (sum_rdc->rdcost < best_rdc->rdcost) {
sum_rdc->rdcost = RDCOST(x->rdmult, sum_rdc->rate, sum_rdc->dist);
if (sum_rdc->rdcost < best_rdc->rdcost) {
#if CONFIG_EXT_RECUR_PARTITIONS
pc_tree->skippable = both_blocks_skippable;
#endif // CONFIG_EXT_RECUR_PARTITIONS
*best_rdc = *sum_rdc;
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = partition_type;
}
} else {
// Update HORZ / VERT win flag.
if (rect_part_win_info != NULL)
rect_part_win_info->rect_part_win[i] = false;
}
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
av1_restore_context(cm, x, x_ctx, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, av1_num_planes(cm));
#if CONFIG_EXT_RECUR_PARTITIONS
if (sum_rdc->rdcost < INT64_MAX && both_blocks_skippable &&
!frame_is_intra_only(cm)) {
const int right_shift =
((2 * (BLOCK_128_MI_SIZE_LOG2)) -
(mi_size_wide_log2[bsize] + mi_size_high_log2[bsize]));
const int64_t dist_breakout_thr =
(right_shift >= 0)
? ((cpi->sf.part_sf.partition_search_breakout_dist_thr / 4) >>
right_shift)
: ((cpi->sf.part_sf.partition_search_breakout_dist_thr / 4)
<< (-right_shift));
const int rate_breakout_thr =
(int64_t)25 * cpi->sf.part_sf.partition_search_breakout_rate_thr *
num_pels_log2_lookup[bsize];
if (sum_rdc->dist < dist_breakout_thr &&
sum_rdc->rate < rate_breakout_thr) {
part_search_state->terminate_partition_search = true;
break;
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
}
#if !CONFIG_EXT_RECUR_PARTITIONS
// AB partition type evaluation.
static void rd_pick_ab_part(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PC_TREE *pc_tree, PICK_MODE_CONTEXT *dst_ctxs[SUB_PARTITIONS_AB],
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
const BLOCK_SIZE ab_subsize[SUB_PARTITIONS_AB],
const int ab_mi_pos[SUB_PARTITIONS_AB][2], const PARTITION_TYPE part_type
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
#if CONFIG_COLLECT_PARTITION_STATS
{
RD_STATS tmp_sum_rdc;
av1_init_rd_stats(&tmp_sum_rdc);
tmp_sum_rdc.rate =
x->partition_cost[part_search_state->pl_ctx_idx][part_type];
tmp_sum_rdc.rdcost = RDCOST(x->rdmult, tmp_sum_rdc.rate, 0);
if (best_rdc->rdcost - tmp_sum_rdc.rdcost >= 0) {
partition_attempts[part_type] += 1;
aom_usec_timer_start(&partition_timer);
partition_timer_on = 1;
}
}
#endif
// Test this partition and update the best partition.
part_search_state->found_best_partition |=
rd_test_partition3(cpi, td, tile_data, tp, pc_tree, best_rdc, dst_ctxs,
mi_row, mi_col, bsize, part_type, ab_subsize, ab_mi_pos
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
#if CONFIG_COLLECT_PARTITION_STATS
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
int64_t time = aom_usec_timer_elapsed(&partition_timer);
partition_times[part_type] += time;
partition_timer_on = 0;
}
#endif
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
}
// Check if AB partitions search is allowed.
static AOM_INLINE int is_ab_part_allowed(
PartitionSearchState *part_search_state,
const int ab_partitions_allowed[NUM_AB_PARTS], const int ab_part_type) {
const int is_horz_ab = (ab_part_type >> 1);
const int is_part_allowed =
(!part_search_state->terminate_partition_search &&
part_search_state->partition_rect_allowed[is_horz_ab] &&
ab_partitions_allowed[ab_part_type]);
return is_part_allowed;
}
// Set mode search context.
static AOM_INLINE void set_mode_search_ctx(
PC_TREE *pc_tree, const int is_ctx_ready[NUM_AB_PARTS][2],
PICK_MODE_CONTEXT **mode_srch_ctx[NUM_AB_PARTS][2]) {
mode_srch_ctx[HORZ_B][0] = &pc_tree->horizontal[0];
mode_srch_ctx[VERT_B][0] = &pc_tree->vertical[0];
if (is_ctx_ready[HORZ_A][0])
mode_srch_ctx[HORZ_A][0] = &pc_tree->split[0]->none;
if (is_ctx_ready[VERT_A][0])
mode_srch_ctx[VERT_A][0] = &pc_tree->split[0]->none;
if (is_ctx_ready[HORZ_A][1])
mode_srch_ctx[HORZ_A][1] = &pc_tree->split[1]->none;
}
// AB Partitions type search.
static void ab_partitions_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PC_TREE *pc_tree, PartitionSearchState *part_search_state,
RD_STATS *best_rdc, RD_RECT_PART_WIN_INFO *rect_part_win_info,
int pb_source_variance, int ext_partition_allowed
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
int ab_partitions_allowed[NUM_AB_PARTS] = { 1, 1, 1, 1 };
// Prune AB partitions
av1_prune_ab_partitions(
cpi, x, pc_tree, bsize, pb_source_variance, best_rdc->rdcost,
part_search_state->rect_part_rd, part_search_state->split_rd,
rect_part_win_info, ext_partition_allowed,
part_search_state->partition_rect_allowed[HORZ],
part_search_state->partition_rect_allowed[VERT],
&ab_partitions_allowed[HORZ_A], &ab_partitions_allowed[HORZ_B],
&ab_partitions_allowed[VERT_A], &ab_partitions_allowed[VERT_B]);
// Flags to indicate whether the mode search is done.
const int is_ctx_ready[NUM_AB_PARTS][2] = {
{ part_search_state->is_split_ctx_is_ready[0],
part_search_state->is_split_ctx_is_ready[1] },
{ part_search_state->is_rect_ctx_is_ready[HORZ], 0 },
{ part_search_state->is_split_ctx_is_ready[0], 0 },
{ part_search_state->is_rect_ctx_is_ready[VERT], 0 }
};
// Current partition context.
PICK_MODE_CONTEXT **cur_part_ctxs[NUM_AB_PARTS] = { pc_tree->horizontala,
pc_tree->horizontalb,
pc_tree->verticala,
pc_tree->verticalb };
// Context of already evaluted partition types.
PICK_MODE_CONTEXT **mode_srch_ctx[NUM_AB_PARTS][2];
// Set context of already evaluted partition types.
set_mode_search_ctx(pc_tree, is_ctx_ready, mode_srch_ctx);
// Array of sub-partition size of AB partition types.
const BLOCK_SIZE ab_subsize[NUM_AB_PARTS][SUB_PARTITIONS_AB] = {
{ blk_params.split_bsize2, blk_params.split_bsize2,
get_partition_subsize(bsize, PARTITION_HORZ_A) },
{ get_partition_subsize(bsize, PARTITION_HORZ_B), blk_params.split_bsize2,
blk_params.split_bsize2 },
{ blk_params.split_bsize2, blk_params.split_bsize2,
get_partition_subsize(bsize, PARTITION_VERT_A) },
{ get_partition_subsize(bsize, PARTITION_VERT_B), blk_params.split_bsize2,
blk_params.split_bsize2 }
};
// Array of mi_row, mi_col positions corresponds to each sub-partition in AB
// partition types.
const int ab_mi_pos[NUM_AB_PARTS][SUB_PARTITIONS_AB][2] = {
{ { mi_row, mi_col },
{ mi_row, blk_params.mi_col_edge },
{ blk_params.mi_row_edge, mi_col } },
{ { mi_row, mi_col },
{ blk_params.mi_row_edge, mi_col },
{ blk_params.mi_row_edge, blk_params.mi_col_edge } },
{ { mi_row, mi_col },
{ blk_params.mi_row_edge, mi_col },
{ mi_row, blk_params.mi_col_edge } },
{ { mi_row, mi_col },
{ mi_row, blk_params.mi_col_edge },
{ blk_params.mi_row_edge, blk_params.mi_col_edge } }
};
// Loop over AB partition types.
for (AB_PART_TYPE ab_part_type = 0; ab_part_type < NUM_AB_PARTS;
ab_part_type++) {
const PARTITION_TYPE part_type = ab_part_type + PARTITION_HORZ_A;
// Check if the AB partition search is to be performed.
if (!is_ab_part_allowed(part_search_state, ab_partitions_allowed,
ab_part_type))
continue;
blk_params.subsize = get_partition_subsize(bsize, part_type);
for (int i = 0; i < SUB_PARTITIONS_AB; i++) {
assert(cur_part_ctxs[ab_part_type] != NULL);
// Set AB partition context.
if (cur_part_ctxs[ab_part_type][i] == NULL)
cur_part_ctxs[ab_part_type][i] = av1_alloc_pmc(
cm, x->e_mbd.tree_type, ab_mi_pos[ab_part_type][i][0],
ab_mi_pos[ab_part_type][i][1], ab_subsize[ab_part_type][i], pc_tree,
part_type, i, part_search_state->ss_x, part_search_state->ss_y,
&td->shared_coeff_buf);
// Set mode as not ready.
cur_part_ctxs[ab_part_type][i]->rd_mode_is_ready = 0;
}
// Copy of mode search results if the ctx is ready.
if (is_ctx_ready[ab_part_type][0]) {
av1_copy_tree_context(cur_part_ctxs[ab_part_type][0],
mode_srch_ctx[ab_part_type][0][0]);
cur_part_ctxs[ab_part_type][0]->mic.partition = part_type;
cur_part_ctxs[ab_part_type][0]->rd_mode_is_ready = 1;
if (is_ctx_ready[ab_part_type][1]) {
av1_copy_tree_context(cur_part_ctxs[ab_part_type][1],
mode_srch_ctx[ab_part_type][1][0]);
cur_part_ctxs[ab_part_type][1]->mic.partition = part_type;
cur_part_ctxs[ab_part_type][1]->rd_mode_is_ready = 1;
}
}
// Evaluation of AB partition type.
rd_pick_ab_part(cpi, td, tile_data, tp, x, x_ctx, pc_tree,
cur_part_ctxs[ab_part_type], part_search_state, best_rdc,
ab_subsize[ab_part_type], ab_mi_pos[ab_part_type], part_type
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
}
// Set mi positions for HORZ4 / VERT4 sub-block partitions.
static void set_mi_pos_partition4(const int inc_step[NUM_PART4_TYPES],
int mi_pos[SUB_PARTITIONS_PART4][2],
const int mi_row, const int mi_col) {
for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; i++) {
mi_pos[i][0] = mi_row + i * inc_step[HORZ4];
mi_pos[i][1] = mi_col + i * inc_step[VERT4];
}
}
// Set context and RD cost for HORZ4 / VERT4 partition types.
static void set_4_part_ctx_and_rdcost(
MACROBLOCK *x, const AV1_COMMON *const cm, ThreadData *td,
PICK_MODE_CONTEXT *cur_part_ctx[SUB_PARTITIONS_PART4],
PartitionSearchState *part_search_state, PARTITION_TYPE partition_type,
BLOCK_SIZE bsize, int mi_pos[SUB_PARTITIONS_PART4][2], PC_TREE *pc_tree) {
// Initialize sum_rdc RD cost structure.
av1_init_rd_stats(&part_search_state->sum_rdc);
const int subsize = get_partition_subsize(bsize, partition_type);
part_search_state->sum_rdc.rate =
part_search_state->partition_cost[partition_type];
part_search_state->sum_rdc.rdcost =
RDCOST(x->rdmult, part_search_state->sum_rdc.rate, 0);
for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; ++i) {
if (cur_part_ctx[i] == NULL)
cur_part_ctx[i] = av1_alloc_pmc(
cm, x->e_mbd.tree_type, mi_pos[i][0], mi_pos[i][1], subsize, pc_tree,
partition_type, i, part_search_state->ss_x, part_search_state->ss_y,
&td->shared_coeff_buf);
}
}
// Partition search of HORZ4 / VERT4 partition types.
static void rd_pick_4partition(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PC_TREE *pc_tree, PICK_MODE_CONTEXT *cur_part_ctx[SUB_PARTITIONS_PART4],
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
const int inc_step[NUM_PART4_TYPES], PARTITION_TYPE partition_type
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
// mi positions needed for HORZ4 and VERT4 partition types.
int mi_pos_check[NUM_PART4_TYPES] = { cm->mi_params.mi_rows,
cm->mi_params.mi_cols };
const PART4_TYPES part4_idx = (partition_type != PARTITION_HORZ_4);
int mi_pos[SUB_PARTITIONS_PART4][2];
blk_params.subsize = get_partition_subsize(blk_params.bsize, partition_type);
// Set mi positions for sub-block sizes.
set_mi_pos_partition4(inc_step, mi_pos, blk_params.mi_row, blk_params.mi_col);
// Set partition context and RD cost.
set_4_part_ctx_and_rdcost(x, cm, td, cur_part_ctx, part_search_state,
partition_type, blk_params.bsize, mi_pos, pc_tree);
#if CONFIG_COLLECT_PARTITION_STATS
if (best_rdc.rdcost - part_search_state->sum_rdc.rdcost >= 0) {
partition_attempts[partition_type] += 1;
aom_usec_timer_start(&partition_timer);
partition_timer_on = 1;
}
#endif
// Loop over sub-block partitions.
for (PART4_TYPES i = 0; i < SUB_PARTITIONS_PART4; ++i) {
if (i > 0 && mi_pos[i][part4_idx] >= mi_pos_check[part4_idx]) break;
// Sub-block evaluation of Horz4 / Vert4 partition type.
cur_part_ctx[i]->rd_mode_is_ready = 0;
if (!rd_try_subblock(
cpi, td, tile_data, tp, (i == SUB_PARTITIONS_PART4 - 1),
mi_pos[i][0], mi_pos[i][1], blk_params.subsize, *best_rdc,
&part_search_state->sum_rdc, partition_type, cur_part_ctx[i])) {
av1_invalid_rd_stats(&part_search_state->sum_rdc);
break;
}
}
// Calculate the total cost and update the best partition.
av1_rd_cost_update(x->rdmult, &part_search_state->sum_rdc);
if (part_search_state->sum_rdc.rdcost < best_rdc->rdcost) {
*best_rdc = part_search_state->sum_rdc;
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = partition_type;
}
#if CONFIG_COLLECT_PARTITION_STATS
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
int64_t time = aom_usec_timer_elapsed(&partition_timer);
partition_times[partition_type] += time;
partition_timer_on = 0;
}
#endif
av1_restore_context(cm, x, x_ctx, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, av1_num_planes(cm));
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
// Prune 4-way partitions based on the number of horz/vert wins
// in the current block and sub-blocks in PARTITION_SPLIT.
static void prune_4_partition_using_split_info(
AV1_COMP *const cpi, MACROBLOCK *x, PartitionSearchState *part_search_state,
int part4_search_allowed[NUM_PART4_TYPES]) {
PART4_TYPES cur_part[NUM_PART4_TYPES] = { HORZ4, VERT4 };
// Count of child blocks in which HORZ or VERT partition has won
int num_child_rect_win[NUM_RECT_PARTS] = { 0, 0 };
// Prune HORZ4/VERT4 partitions based on number of HORZ/VERT winners of
// split partiitons.
// Conservative pruning for high quantizers.
const int num_win_thresh = AOMMIN(3 * (MAXQ - x->qindex) / MAXQ + 1, 3);
for (RECT_PART_TYPE i = HORZ; i < NUM_RECT_PARTS; i++) {
if (!(cpi->sf.part_sf.prune_4_partition_using_split_info &&
part4_search_allowed[cur_part[i]]))
continue;
// Loop over split partitions.
// Get reactnagular partitions winner info of split partitions.
for (int idx = 0; idx < SUB_PARTITIONS_SPLIT; idx++)
num_child_rect_win[i] +=
(part_search_state->split_part_rect_win[idx].rect_part_win[i]) ? 1
: 0;
if (num_child_rect_win[i] < num_win_thresh) {
part4_search_allowed[cur_part[i]] = 0;
}
}
}
// Prune 4-way partition search.
static void prune_4_way_partition_search(
AV1_COMP *const cpi, MACROBLOCK *x, PC_TREE *pc_tree,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
int pb_source_variance, int ext_partition_allowed,
int part4_search_allowed[NUM_PART4_TYPES]) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
PARTITION_TYPE cur_part[NUM_PART4_TYPES] = { PARTITION_HORZ_4,
PARTITION_VERT_4 };
const PartitionCfg *const part_cfg = &cpi->oxcf.part_cfg;
// partition4_allowed is 1 if we can use a PARTITION_HORZ_4 or
// PARTITION_VERT_4 for this block. This is almost the same as
// ext_partition_allowed, except that we don't allow 128x32 or 32x128
// blocks, so we require that bsize is not BLOCK_128X128.
const int partition4_allowed = part_cfg->enable_1to4_partitions &&
ext_partition_allowed &&
bsize != BLOCK_128X128;
for (PART4_TYPES i = HORZ4; i < NUM_PART4_TYPES; i++) {
part4_search_allowed[i] =
partition4_allowed && part_search_state->partition_rect_allowed[i] &&
get_plane_block_size(get_partition_subsize(bsize, cur_part[i]),
part_search_state->ss_x,
part_search_state->ss_y) != BLOCK_INVALID;
}
// Pruning: pruning out 4-way partitions based on the current best
// partition.
if (cpi->sf.part_sf.prune_ext_partition_types_search_level == 2) {
part4_search_allowed[HORZ4] &= (pc_tree->partitioning == PARTITION_HORZ ||
pc_tree->partitioning == PARTITION_HORZ_A ||
pc_tree->partitioning == PARTITION_HORZ_B ||
pc_tree->partitioning == PARTITION_SPLIT ||
pc_tree->partitioning == PARTITION_NONE);
part4_search_allowed[VERT4] &= (pc_tree->partitioning == PARTITION_VERT ||
pc_tree->partitioning == PARTITION_VERT_A ||
pc_tree->partitioning == PARTITION_VERT_B ||
pc_tree->partitioning == PARTITION_SPLIT ||
pc_tree->partitioning == PARTITION_NONE);
}
// Pruning: pruning out some 4-way partitions using a DNN taking rd costs of
// sub-blocks from basic partition types.
if (cpi->sf.part_sf.ml_prune_4_partition && partition4_allowed &&
part_search_state->partition_rect_allowed[HORZ] &&
part_search_state->partition_rect_allowed[VERT]) {
av1_ml_prune_4_partition(
cpi, x, bsize, pc_tree->partitioning, best_rdc->rdcost,
part_search_state->rect_part_rd, part_search_state->split_rd,
&part4_search_allowed[HORZ4], &part4_search_allowed[VERT4],
pb_source_variance, mi_row, mi_col);
}
// Pruning: pruning out 4-way partitions based on the number of horz/vert
// wins in the current block and sub-blocks in PARTITION_SPLIT.
prune_4_partition_using_split_info(cpi, x, part_search_state,
part4_search_allowed);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE allowed flag.
static AOM_INLINE void set_part_none_allowed_flag(
const AV1_COMP *const cpi,
#if CONFIG_EXT_RECUR_PARTITIONS
TREE_TYPE tree_type,
#endif // CONFIG_EXT_RECUR_PARTITIONS
PartitionSearchState *part_search_state) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
#if CONFIG_EXT_RECUR_PARTITIONS
if (tree_type == CHROMA_PART && blk_params.bsize == BLOCK_8X8) {
part_search_state->partition_none_allowed = 1;
return;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
if (is_bsize_geq(blk_params.min_partition_size, blk_params.bsize) &&
blk_params.has_rows && blk_params.has_cols)
#else
if ((blk_params.width <= blk_params.min_partition_size_1d) &&
blk_params.has_rows && blk_params.has_cols)
#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state->partition_none_allowed = 1;
#if !CONFIG_EXT_RECUR_PARTITIONS
if (part_search_state->partition_none_allowed == BLOCK_INVALID) {
part_search_state->partition_none_allowed = 0;
return;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE for screen content.
if (cpi->is_screen_content_type)
part_search_state->partition_none_allowed =
blk_params.has_rows && blk_params.has_cols;
}
// Set params needed for PARTITION_NONE search.
static void set_none_partition_params(const AV1_COMMON *const cm,
ThreadData *td, MACROBLOCK *x,
PC_TREE *pc_tree,
PartitionSearchState *part_search_state,
RD_STATS *best_remain_rdcost,
RD_STATS *best_rdc, int *pt_cost) {
PartitionBlkParams blk_params = part_search_state->part_blk_params;
RD_STATS partition_rdcost;
// Set PARTITION_NONE context.
if (pc_tree->none == NULL)
pc_tree->none = av1_alloc_pmc(
cm, x->e_mbd.tree_type, blk_params.mi_row, blk_params.mi_col,
blk_params.bsize, pc_tree, PARTITION_NONE, 0, part_search_state->ss_x,
part_search_state->ss_y, &td->shared_coeff_buf);
// Set PARTITION_NONE type cost.
if (part_search_state->partition_none_allowed) {
if (part_search_state->is_block_splittable) {
*pt_cost = part_search_state->partition_cost[PARTITION_NONE] < INT_MAX
? part_search_state->partition_cost[PARTITION_NONE]
: 0;
}
// Initialize the RD stats structure.
av1_init_rd_stats(&partition_rdcost);
partition_rdcost.rate = *pt_cost;
av1_rd_cost_update(x->rdmult, &partition_rdcost);
av1_rd_stats_subtraction(x->rdmult, best_rdc, &partition_rdcost,
best_remain_rdcost);
}
}
// Skip other partitions based on PARTITION_NONE rd cost.
static void prune_partitions_after_none(AV1_COMP *const cpi, MACROBLOCK *x,
SIMPLE_MOTION_DATA_TREE *sms_tree,
PICK_MODE_CONTEXT *ctx_none,
PartitionSearchState *part_search_state,
RD_STATS *best_rdc,
unsigned int *pb_source_variance) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
RD_STATS *this_rdc = &part_search_state->this_rdc;
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
#if CONFIG_EXT_RECUR_PARTITIONS
(void)sms_tree;
#endif // !CONFIG_EXT_RECUR_PARTITIONS
if (!frame_is_intra_only(cm) &&
#if CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_rectangular_split &&
#else
(part_search_state->do_square_split ||
part_search_state->do_rectangular_split) &&
#endif
!x->e_mbd.lossless[xd->mi[0]->segment_id] && ctx_none->skippable) {
const int use_ml_based_breakout =
bsize <= cpi->sf.part_sf.use_square_partition_only_threshold &&
#if CONFIG_EXT_RECUR_PARTITIONS
is_square_block(bsize) &&
#endif // CONFIG_EXT_RECUR_PARTITIONS
bsize > BLOCK_4X4 && xd->bd == 8;
if (use_ml_based_breakout) {
if (av1_ml_predict_breakout(cpi, bsize, x, this_rdc,
*pb_source_variance)) {
#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split = 0;
#endif
part_search_state->do_rectangular_split = 0;
}
}
// Adjust dist breakout threshold according to the partition size.
const int right_shift =
((2 * (BLOCK_128_MI_SIZE_LOG2)) -
(mi_size_wide_log2[bsize] + mi_size_high_log2[bsize]));
const int64_t dist_breakout_thr =
(right_shift >= 0)
? (cpi->sf.part_sf.partition_search_breakout_dist_thr >>
right_shift)
: (cpi->sf.part_sf.partition_search_breakout_dist_thr
<< (-right_shift));
const int rate_breakout_thr =
cpi->sf.part_sf.partition_search_breakout_rate_thr *
num_pels_log2_lookup[bsize];
// If all y, u, v transform blocks in this partition are skippable,
// and the dist & rate are within the thresholds, the partition
// search is terminated for current branch of the partition search
// tree. The dist & rate thresholds are set to 0 at speed 0 to
// disable the early termination at that speed.
if (best_rdc->dist < dist_breakout_thr &&
best_rdc->rate < rate_breakout_thr) {
#if !CONFIG_EXT_RECUR_PARTITIONS
part_search_state->do_square_split = 0;
#endif
part_search_state->do_rectangular_split = 0;
}
}
// Early termination: using simple_motion_search features and the
// rate, distortion, and rdcost of PARTITION_NONE, a DNN will make a
// decision on early terminating at PARTITION_NONE.
bool is_early_term_allowed =
cpi->sf.part_sf.simple_motion_search_early_term_none &&
!frame_is_intra_only(cm) && bsize >= BLOCK_16X16 &&
blk_params.mi_row_edge < mi_params->mi_rows &&
blk_params.mi_col_edge < mi_params->mi_cols &&
this_rdc->rdcost < INT64_MAX && this_rdc->rdcost >= 0 &&
this_rdc->rate < INT_MAX && this_rdc->rate >= 0;
#if CONFIG_EXT_RECUR_PARTITIONS
is_early_term_allowed &= part_search_state->do_rectangular_split && sms_tree;
#else
is_early_term_allowed &=
cm->show_frame && (part_search_state->do_square_split ||
part_search_state->do_rectangular_split);
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (is_early_term_allowed) {
av1_simple_motion_search_early_term_none(
cpi, x, sms_tree, blk_params.mi_row, blk_params.mi_col, bsize, this_rdc,
&part_search_state->terminate_partition_search);
}
}
#if !CONFIG_EXT_RECUR_PARTITIONS
// Decide early termination and rectangular partition pruning
// based on PARTITION_NONE and PARTITION_SPLIT costs.
static void prune_partitions_after_split(
AV1_COMP *const cpi, MACROBLOCK *x, SIMPLE_MOTION_DATA_TREE *sms_tree,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
int64_t part_none_rd, int64_t part_split_rd) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
#if CONFIG_EXT_RECUR_PARTITIONS
(void)sms_tree;
(void)part_none_rd;
(void)part_split_rd;
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_EXT_RECUR_PARTITIONS
// Early termination: using the rd costs of PARTITION_NONE and subblocks
// from PARTITION_SPLIT to determine an early breakout.
if (cpi->sf.part_sf.ml_early_term_after_part_split_level &&
!frame_is_intra_only(cm) &&
!part_search_state->terminate_partition_search &&
part_search_state->do_rectangular_split &&
(part_search_state->partition_rect_allowed[HORZ] ||
part_search_state->partition_rect_allowed[VERT])) {
av1_ml_early_term_after_split(
cpi, x, sms_tree, bsize, best_rdc->rdcost, part_none_rd, part_split_rd,
part_search_state->split_rd, mi_row, mi_col,
&part_search_state->terminate_partition_search);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Use the rd costs of PARTITION_NONE and subblocks from PARTITION_SPLIT
// to prune out rectangular partitions in some directions.
if (!cpi->sf.part_sf.ml_early_term_after_part_split_level &&
cpi->sf.part_sf.ml_prune_rect_partition && !frame_is_intra_only(cm) &&
(part_search_state->partition_rect_allowed[HORZ] ||
part_search_state->partition_rect_allowed[VERT]) &&
!(part_search_state->prune_rect_part[HORZ] ||
part_search_state->prune_rect_part[VERT]) &&
!part_search_state->terminate_partition_search) {
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, av1_num_planes(cm),
NULL);
av1_ml_prune_rect_partition(
cpi, x, bsize, best_rdc->rdcost, part_search_state->none_rd,
part_search_state->split_rd, &part_search_state->prune_rect_part[HORZ],
&part_search_state->prune_rect_part[VERT]);
}
}
#endif
// PARTITION_NONE search.
static void none_partition_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data, MACROBLOCK *x,
PC_TREE *pc_tree, SIMPLE_MOTION_DATA_TREE *sms_tree,
RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
unsigned int *pb_source_variance, int64_t *none_rd, int64_t *part_none_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
RD_STATS *this_rdc = &part_search_state->this_rdc;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
#if CONFIG_EXT_RECUR_PARTITIONS
if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_NONE)) {
return;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Set PARTITION_NONE allowed flag.
set_part_none_allowed_flag(cpi,
#if CONFIG_EXT_RECUR_PARTITIONS
x->e_mbd.tree_type,
#endif // CONFIG_EXT_RECUR_PARTITIONS
part_search_state);
if (!part_search_state->partition_none_allowed) {
return;
}
#if CONFIG_EXT_RECUR_PARTITIONS
if (part_search_state->prune_partition_none) {
return;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
int pt_cost = 0;
RD_STATS best_remain_rdcost;
// Set PARTITION_NONE context and cost.
set_none_partition_params(cm, td, x, pc_tree, part_search_state,
&best_remain_rdcost, best_rdc, &pt_cost);
#if CONFIG_COLLECT_PARTITION_STATS
// Timer start for partition None.
if (best_remain_rdcost >= 0) {
partition_attempts[PARTITION_NONE] += 1;
aom_usec_timer_start(&partition_timer);
partition_timer_on = 1;
}
#endif
#if CONFIG_EXT_RECUR_PARTITIONS
SimpleMotionData *sms_data =
av1_get_sms_data_entry(x->sms_bufs, mi_row, mi_col, bsize, cm->sb_size);
av1_set_best_mode_cache(x, sms_data->mode_cache);
#endif // CONFIG_EXT_RECUR_PARTITIONS
// PARTITION_NONE evaluation and cost update.
pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, this_rdc, PARTITION_NONE,
bsize, pc_tree->none, best_remain_rdcost);
#if CONFIG_EXT_RECUR_PARTITIONS
x->inter_mode_cache = NULL;
if (this_rdc->rate != INT_MAX) {
av1_add_mode_search_context_to_cache(sms_data, pc_tree->none);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
av1_rd_cost_update(x->rdmult, this_rdc);
#if CONFIG_COLLECT_PARTITION_STATS
// Timer end for partition None.
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
int64_t time = aom_usec_timer_elapsed(&partition_timer);
partition_times[PARTITION_NONE] += time;
partition_timer_on = 0;
}
#endif
*pb_source_variance = x->source_variance;
if (none_rd) *none_rd = this_rdc->rdcost;
part_search_state->none_rd = this_rdc->rdcost;
#if CONFIG_EXT_RECUR_PARTITIONS
pc_tree->none_rd = *this_rdc;
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (this_rdc->rate != INT_MAX) {
#if CONFIG_EXT_RECUR_PARTITIONS
pc_tree->skippable = pc_tree->none->skippable;
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Record picked ref frame to prune ref frames for other partition types.
if (cpi->sf.inter_sf.prune_ref_frames) {
const int ref_type = av1_ref_frame_type(pc_tree->none->mic.ref_frame);
av1_update_picked_ref_frames_mask(x, ref_type, bsize, cm->mib_size,
mi_row, mi_col);
}
// Calculate the total cost and update the best partition.
if (part_search_state->is_block_splittable) {
this_rdc->rate += pt_cost;
this_rdc->rdcost = RDCOST(x->rdmult, this_rdc->rate, this_rdc->dist);
}
*part_none_rd = this_rdc->rdcost;
if (this_rdc->rdcost < best_rdc->rdcost) {
*best_rdc = *this_rdc;
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
#if !CONFIG_EXT_RECUR_PARTITIONS
if (blk_params.bsize_at_least_8x8) {
pc_tree->partitioning = PARTITION_NONE;
}
#else
pc_tree->partitioning = PARTITION_NONE;
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Disable split and rectangular partition search
// based on PARTITION_NONE cost.
prune_partitions_after_none(cpi, x, sms_tree, pc_tree->none,
part_search_state, best_rdc,
pb_source_variance);
}
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
// PARTITION_SPLIT search.
static void split_partition_search(
AV1_COMP *const cpi, ThreadData *td, TileDataEnc *tile_data,
TokenExtra **tp, MACROBLOCK *x, PC_TREE *pc_tree,
SIMPLE_MOTION_DATA_TREE *sms_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
PartitionSearchState *part_search_state, RD_STATS *best_rdc,
SB_MULTI_PASS_MODE multi_pass_mode, int64_t *part_split_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
LevelBanksRDO *level_banks
#endif // CONFIG_C043_MVP_IMPROVEMENTS
#if CONFIG_EXT_RECUR_PARTITIONS
,
const PARTITION_TREE *ptree_luma, const PARTITION_TREE *template_tree,
int max_recursion_depth
#endif // CONFIG_EXT_RECUR_PARTITIONS
) {
const AV1_COMMON *const cm = &cpi->common;
PartitionBlkParams blk_params = part_search_state->part_blk_params;
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int mi_row = blk_params.mi_row;
const int mi_col = blk_params.mi_col;
const BLOCK_SIZE bsize = blk_params.bsize;
assert(bsize < BLOCK_SIZES_ALL);
RD_STATS sum_rdc = part_search_state->sum_rdc;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, PARTITION_SPLIT);
// Check if partition split is allowed.
#if CONFIG_EXT_RECUR_PARTITIONS
(void)sms_tree;
if (part_search_state->terminate_partition_search ||
!is_square_split_eligible(bsize, cm->sb_size)) {
return;
}
if (part_search_state->forced_partition != PARTITION_INVALID &&
part_search_state->forced_partition != PARTITION_SPLIT) {
return;
}
if (max_recursion_depth < 0) {
return;
}
const int num_planes = av1_num_planes(cm);
PC_TREE **sub_tree = pc_tree->split;
assert(sub_tree);
for (int idx = 0; idx < SUB_PARTITIONS_SPLIT; idx++) {
if (sub_tree[idx]) {
av1_free_pc_tree_recursive(sub_tree[idx], num_planes, 0, 0);
sub_tree[idx] = NULL;
}
}
const MACROBLOCKD *const xd = &x->e_mbd;
const int track_ptree_luma =
is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize);
#else
if (part_search_state->terminate_partition_search ||
!part_search_state->do_square_split)
return;
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Initialization of this partition RD stats.
av1_init_rd_stats(&sum_rdc);
sum_rdc.rate = part_search_state->partition_cost[PARTITION_SPLIT];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
int idx;
#if CONFIG_COLLECT_PARTITION_STATS
if (best_rdc->rdcost - sum_rdc.rdcost >= 0) {
partition_attempts[PARTITION_SPLIT] += 1;
aom_usec_timer_start(&partition_timer);
partition_timer_on = 1;
}
#endif
// Recursive partition search on 4 sub-blocks.
for (idx = 0; idx < SUB_PARTITIONS_SPLIT && sum_rdc.rdcost < best_rdc->rdcost;
++idx) {
const int x_idx = (idx & 1) * blk_params.mi_step;
const int y_idx = (idx >> 1) * blk_params.mi_step;
if (mi_row + y_idx >= mi_params->mi_rows ||
mi_col + x_idx >= mi_params->mi_cols)
continue;
if (pc_tree->split[idx] == NULL) {
pc_tree->split[idx] = av1_alloc_pc_tree_node(
x->e_mbd.tree_type, mi_row + y_idx, mi_col + x_idx, subsize, pc_tree,
PARTITION_SPLIT, idx, idx == 3, part_search_state->ss_x,
part_search_state->ss_y);
}
#if !CONFIG_EXT_RECUR_PARTITIONS
int64_t *p_split_rd = &part_search_state->split_rd[idx];
#endif // !CONFIG_EXT_RECUR_PARTITIONS
RD_STATS best_remain_rdcost;
av1_rd_stats_subtraction(x->rdmult, best_rdc, &sum_rdc,
&best_remain_rdcost);
int curr_quad_tree_idx = 0;
if (frame_is_intra_only(cm) && bsize <= BLOCK_64X64) {
curr_quad_tree_idx = part_search_state->intra_part_info->quad_tree_idx;
part_search_state->intra_part_info->quad_tree_idx =
4 * curr_quad_tree_idx + idx + 1;
}
// Split partition evaluation of corresponding idx.
// If the RD cost exceeds the best cost then do not
// evaluate other split sub-partitions.
#if CONFIG_EXT_RECUR_PARTITIONS
if (!av1_rd_pick_partition(
cpi, td, tile_data, tp, mi_row + y_idx, mi_col + x_idx, subsize,
&part_search_state->this_rdc, best_remain_rdcost, sub_tree[idx],
track_ptree_luma ? ptree_luma->sub_tree[idx] : NULL,
get_partition_subtree_const(template_tree, idx),
max_recursion_depth, NULL, NULL, multi_pass_mode, NULL)) {
break;
}
#else
if (!av1_rd_pick_partition(
cpi, td, tile_data, tp, mi_row + y_idx, mi_col + x_idx, subsize,
&part_search_state->this_rdc, best_remain_rdcost,
pc_tree->split[idx], sms_tree->split[idx], p_split_rd,
multi_pass_mode, &part_search_state->split_part_rect_win[idx])) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (frame_is_intra_only(cm) && bsize <= BLOCK_64X64) {
part_search_state->intra_part_info->quad_tree_idx = curr_quad_tree_idx;
}
sum_rdc.rate += part_search_state->this_rdc.rate;
sum_rdc.dist += part_search_state->this_rdc.dist;
av1_rd_cost_update(x->rdmult, &sum_rdc);
// Set split ctx as ready for use.
if (idx <= 1 && (bsize <= BLOCK_8X8 ||
pc_tree->split[idx]->partitioning == PARTITION_NONE)) {
const MB_MODE_INFO *const mbmi = &pc_tree->split[idx]->none->mic;
const PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
// Neither palette mode nor cfl predicted.
if (pmi->palette_size[0] == 0 && pmi->palette_size[1] == 0) {
if (mbmi->uv_mode != UV_CFL_PRED)
part_search_state->is_split_ctx_is_ready[idx] = 1;
}
}
}
#if CONFIG_COLLECT_PARTITION_STATS
if (partition_timer_on) {
aom_usec_timer_mark(&partition_timer);
int64_t time = aom_usec_timer_elapsed(&partition_timer);
partition_times[PARTITION_SPLIT] += time;
partition_timer_on = 0;
}
#endif
const int reached_last_index = (idx == SUB_PARTITIONS_SPLIT);
// Calculate the total cost and update the best partition.
*part_split_rd = sum_rdc.rdcost;
if (reached_last_index && sum_rdc.rdcost < best_rdc->rdcost) {
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
if (sum_rdc.rdcost < best_rdc->rdcost) {
*best_rdc = sum_rdc;
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_SPLIT;
}
} else if (cpi->sf.part_sf.less_rectangular_check_level > 0) {
#if !CONFIG_EXT_RECUR_PARTITIONS
// Skip rectangular partition test when partition type none gives better
// rd than partition type split.
if (cpi->sf.part_sf.less_rectangular_check_level == 2 || idx <= 2) {
const int partition_none_valid = part_search_state->none_rd > 0;
const int partition_none_better =
part_search_state->none_rd < sum_rdc.rdcost;
part_search_state->do_rectangular_split &=
!(partition_none_valid && partition_none_better);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, av1_num_planes(cm));
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
#if CONFIG_EXT_RECUR_PARTITIONS
/*!\brief Stores some data used by rd_try_subblock_new to do rdopt. */
typedef struct SUBBLOCK_RDO_DATA {
/*!\brief The encoder side partition tree. */
PC_TREE *pc_tree;
/*!\brief The luma partition tree. Used by SDP on chroma planes. */
const PARTITION_TREE *ptree_luma;
/*!\brief A "template" that the function will follow to skip the partition
* selection process. */
const PARTITION_TREE *template_tree;
/*!\brief The row coordinate of current block in units of mi. */
int mi_row;
/*!\brief The col coordinate of current block in units of mi. */
int mi_col;
/*!\brief The block_size of the current block. */
BLOCK_SIZE bsize;
/*!\brief The partition type used to get the current block. */
PARTITION_TYPE partition;
} SUBBLOCK_RDO_DATA;
/*!\brief Whether the current partition node uses horizontal type partitions. */
static AOM_INLINE bool node_uses_horz(const PC_TREE *pc_tree) {
assert(pc_tree);
return pc_tree->partitioning == PARTITION_HORZ ||
pc_tree->partitioning == PARTITION_HORZ_4A ||
pc_tree->partitioning == PARTITION_HORZ_4B ||
pc_tree->partitioning == PARTITION_HORZ_3;
}
/*!\brief Whether the current partition node uses vertical type partitions. */
static AOM_INLINE bool node_uses_vert(const PC_TREE *pc_tree) {
assert(pc_tree);
return pc_tree->partitioning == PARTITION_VERT ||
pc_tree->partitioning == PARTITION_VERT_4A ||
pc_tree->partitioning == PARTITION_VERT_4B ||
pc_tree->partitioning == PARTITION_VERT_3;
}
/*!\brief Try searching for an encoding for the given subblock.
*
* Returns zero if the rdcost is already too high (to tell the caller not to
* bother searching for encodings of further subblocks).
* */
static int rd_try_subblock_new(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp,
SUBBLOCK_RDO_DATA *rdo_data,
RD_STATS best_rdcost, RD_STATS *sum_rdc,
SB_MULTI_PASS_MODE multi_pass_mode,
bool *skippable, int max_recursion_depth) {
MACROBLOCK *const x = &td->mb;
const int orig_mult = x->rdmult;
const int mi_row = rdo_data->mi_row;
const int mi_col = rdo_data->mi_col;
const BLOCK_SIZE bsize = rdo_data->bsize;
setup_block_rdmult(cpi, x, mi_row, mi_col, bsize, NO_AQ, NULL);
av1_rd_cost_update(x->rdmult, &best_rdcost);
RD_STATS rdcost_remaining;
av1_rd_stats_subtraction(x->rdmult, &best_rdcost, sum_rdc, &rdcost_remaining);
RD_STATS this_rdc;
if (!av1_rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, bsize,
&this_rdc, rdcost_remaining, rdo_data->pc_tree,
rdo_data->ptree_luma, rdo_data->template_tree,
max_recursion_depth, NULL, NULL, multi_pass_mode,
NULL)) {
av1_invalid_rd_stats(sum_rdc);
return 0;
}
if (this_rdc.rate == INT_MAX) {
*skippable = false;
sum_rdc->rdcost = INT64_MAX;
} else {
*skippable &= rdo_data->pc_tree->skippable;
sum_rdc->rate += this_rdc.rate;
sum_rdc->dist += this_rdc.dist;
av1_rd_cost_update(x->rdmult, sum_rdc);
}
if (sum_rdc->rdcost >= best_rdcost.rdcost) {
x->rdmult = orig_mult;
return 0;
}
x->rdmult = orig_mult;
return 1;
}
/*!\brief Trace out the partition boundaries using the structure in pc_tree.
*
* The results are stored in partition_boundaries. The array
* partition_boundaries has a stride of MAX_MIB_SIZE, and the units are in mi.
* The actual values stored is a bitmask, with 1 << HORZ means that there is a
* horizontal boundary, and 1 << VERT means that there is a vertical boundary.
* */
static AOM_INLINE void trace_partition_boundary(bool *partition_boundaries,
const PC_TREE *pc_tree,
int mi_row, int mi_col,
BLOCK_SIZE bsize) {
mi_row &= MAX_MIB_MASK;
mi_col &= MAX_MIB_MASK;
const PARTITION_TYPE partition = pc_tree->partitioning;
assert(bsize < BLOCK_SIZES_ALL);
const int mi_width = mi_size_wide[bsize];
const int mi_height = mi_size_high[bsize];
const int ebs_w = mi_size_wide[bsize] / 8;
const int ebs_h = mi_size_high[bsize] / 8;
const BLOCK_SIZE subsize = get_partition_subsize(bsize, partition);
switch (partition) {
case PARTITION_NONE:
for (int col = 0; col < mi_width; col++) {
partition_boundaries[(mi_row + mi_height - 1) * MAX_MIB_SIZE +
(mi_col + col)] |= (1 << HORZ);
}
for (int row = 0; row < mi_height; row++) {
partition_boundaries[(mi_row + row) * MAX_MIB_SIZE + mi_col + mi_width -
1] |= (1 << VERT);
}
break;
case PARTITION_HORZ:
trace_partition_boundary(partition_boundaries, pc_tree->horizontal[0],
mi_row, mi_col,
get_partition_subsize(bsize, PARTITION_HORZ));
trace_partition_boundary(partition_boundaries, pc_tree->horizontal[1],
mi_row + mi_height / 2, mi_col,
get_partition_subsize(bsize, PARTITION_HORZ));
break;
case PARTITION_VERT:
trace_partition_boundary(partition_boundaries, pc_tree->vertical[0],
mi_row, mi_col,
get_partition_subsize(bsize, PARTITION_VERT));
trace_partition_boundary(partition_boundaries, pc_tree->vertical[1],
mi_row, mi_col + mi_width / 2,
get_partition_subsize(bsize, PARTITION_VERT));
break;
case PARTITION_HORZ_3:
trace_partition_boundary(
partition_boundaries, pc_tree->horizontal3[0], mi_row, mi_col,
get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
trace_partition_boundary(
partition_boundaries, pc_tree->horizontal3[1], mi_row + mi_height / 4,
mi_col, get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
trace_partition_boundary(
partition_boundaries, pc_tree->horizontal3[2], mi_row + mi_height / 4,
mi_col + mi_width / 2,
get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3));
trace_partition_boundary(
partition_boundaries, pc_tree->horizontal3[3],
mi_row + 3 * mi_height / 4, mi_col,
get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3));
break;
case PARTITION_VERT_3:
trace_partition_boundary(
partition_boundaries, pc_tree->vertical3[0], mi_row, mi_col,
get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
trace_partition_boundary(
partition_boundaries, pc_tree->vertical3[1], mi_row,
mi_col + mi_width / 4,
get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
trace_partition_boundary(
partition_boundaries, pc_tree->vertical3[2], mi_row + mi_height / 2,
mi_col + mi_width / 4,
get_h_partition_subsize(bsize, 1, PARTITION_VERT_3));
trace_partition_boundary(
partition_boundaries, pc_tree->vertical3[3], mi_row,
mi_col + 3 * mi_width / 4,
get_h_partition_subsize(bsize, 0, PARTITION_VERT_3));
break;
case PARTITION_HORZ_4A: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
assert(bsize_big < BLOCK_SIZES_ALL);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[0],
mi_row, mi_col, subsize);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[1],
mi_row + ebs_h, mi_col, bsize_med);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[2],
mi_row + 3 * ebs_h, mi_col, bsize_big);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4a[3],
mi_row + 7 * ebs_h, mi_col, subsize);
break;
}
case PARTITION_HORZ_4B: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_HORZ);
assert(bsize_big < BLOCK_SIZES_ALL);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_HORZ][bsize_big];
assert(subsize == subsize_lookup[PARTITION_HORZ][bsize_med]);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[0],
mi_row, mi_col, subsize);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[1],
mi_row + ebs_h, mi_col, bsize_big);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[2],
mi_row + 5 * ebs_h, mi_col, bsize_med);
trace_partition_boundary(partition_boundaries, pc_tree->horizontal4b[3],
mi_row + 7 * ebs_h, mi_col, subsize);
break;
}
case PARTITION_VERT_4A: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
assert(bsize_big < BLOCK_SIZES_ALL);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[0],
mi_row, mi_col, subsize);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[1],
mi_row, mi_col + ebs_w, bsize_med);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[2],
mi_row, mi_col + 3 * ebs_w, bsize_big);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4a[3],
mi_row, mi_col + 7 * ebs_w, subsize);
break;
}
case PARTITION_VERT_4B: {
const BLOCK_SIZE bsize_big = get_partition_subsize(bsize, PARTITION_VERT);
assert(bsize_big < BLOCK_SIZES_ALL);
const BLOCK_SIZE bsize_med = subsize_lookup[PARTITION_VERT][bsize_big];
assert(subsize == subsize_lookup[PARTITION_VERT][bsize_med]);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[0],
mi_row, mi_col, subsize);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[1],
mi_row, mi_col + ebs_w, bsize_big);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[2],
mi_row, mi_col + 5 * ebs_w, bsize_med);
trace_partition_boundary(partition_boundaries, pc_tree->vertical4b[3],
mi_row, mi_col + 7 * ebs_w, subsize);
break;
}
default: assert(0 && "Invalid partition type in trace_partition_boundary!");
}
}
/*!\brief Prunes h partitions using the current best partition boundaries.
*
* If the H-shaped partitions don't have any overlap with the current best
* partition boundaries, then they are pruned from the search.
* */
static AOM_INLINE void prune_part_3_with_partition_boundary(
PartitionSearchState *part_search_state, BLOCK_SIZE bsize, int mi_row,
int mi_col, bool can_search_horz, bool can_search_vert) {
const int mi_width = mi_size_wide[bsize];
const int mi_height = mi_size_high[bsize];
const int masked_mi_row = mi_row & MAX_MIB_MASK;
const int masked_mi_col = mi_col & MAX_MIB_MASK;
const bool *partition_boundaries = part_search_state->partition_boundaries;
if (can_search_horz) {
bool keep_horz_3 = false;
for (int col = 0; col < mi_width; col++) {
if (partition_boundaries[(masked_mi_row + mi_height / 4 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_3 = true;
break;
}
}
if (!keep_horz_3) {
for (int col = 0; col < mi_width; col++) {
if (partition_boundaries[(masked_mi_row + 3 * mi_height / 4 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_3 = true;
break;
}
}
}
if (!keep_horz_3) {
for (int row = 0; row < mi_height / 2; row++) {
if (partition_boundaries[(masked_mi_row + mi_height / 4 + row) *
MAX_MIB_SIZE +
masked_mi_col + mi_width / 2 - 1] &
(1 << VERT)) {
keep_horz_3 = true;
break;
}
}
}
part_search_state->prune_partition_3[HORZ] |= !keep_horz_3;
}
if (can_search_vert) {
bool keep_vert_3 = false;
for (int row = 0; row < mi_height; row++) {
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + mi_width / 4 - 1] &
(1 << VERT)) {
keep_vert_3 = true;
break;
}
}
if (!keep_vert_3) {
for (int row = 0; row < mi_height; row++) {
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + 3 * mi_width / 4 - 1] &
(1 << VERT)) {
keep_vert_3 = true;
break;
}
}
}
if (!keep_vert_3) {
for (int col = 0; col < mi_width / 2; col++) {
if (partition_boundaries[(masked_mi_row + mi_height / 2 - 1) *
MAX_MIB_SIZE +
masked_mi_col + mi_width / 4 + col] &
(1 << HORZ)) {
keep_vert_3 = true;
break;
}
}
}
part_search_state->prune_partition_3[VERT] |= !keep_vert_3;
}
}
/*!\brief Prunes 4-way partitions using the current best partition boundaries.
*
* If the 4-way partitions don't have any overlap with the current best
* partition boundaries, then they are pruned from the search.
*/
static AOM_INLINE void prune_part_4_with_partition_boundary(
PartitionSearchState *part_search_state, const bool *partition_boundaries,
BLOCK_SIZE bsize, int mi_row, int mi_col, bool can_search_horz_4a,
bool can_search_horz_4b, bool can_search_vert_4a, bool can_search_vert_4b) {
const int mi_width = mi_size_wide[bsize];
const int mi_height = mi_size_high[bsize];
const int masked_mi_row = mi_row & MAX_MIB_MASK;
const int masked_mi_col = mi_col & MAX_MIB_MASK;
bool keep_horz_4a = false, keep_horz_4b = false;
bool keep_vert_4a = false, keep_vert_4b = false;
if (can_search_horz_4a || can_search_horz_4b) {
for (int col = 0; col < mi_width; col++) {
if (partition_boundaries[(masked_mi_row + mi_height / 8 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_4a = true;
keep_horz_4b = true;
break;
}
if (partition_boundaries[(masked_mi_row + 7 * mi_height / 8 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_4a = true;
keep_horz_4b = true;
break;
}
}
if (can_search_horz_4a && !keep_horz_4a) {
for (int col = 0; col < mi_width; col++) {
if (partition_boundaries[(masked_mi_row + 3 * mi_height / 8 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_4a = true;
break;
}
}
}
if (can_search_horz_4b && !keep_horz_4b) {
for (int col = 0; col < mi_width; col++) {
if (partition_boundaries[(masked_mi_row + 5 * mi_height / 8 - 1) *
MAX_MIB_SIZE +
masked_mi_col + col] &
(1 << HORZ)) {
keep_horz_4b = true;
break;
}
}
}
part_search_state->prune_partition_4a[HORZ] |= !keep_horz_4a;
part_search_state->prune_partition_4b[HORZ] |= !keep_horz_4b;
}
if (can_search_vert_4a || can_search_vert_4b) {
for (int row = 0; row < mi_height; row++) {
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + mi_width / 8 - 1] &
(1 << VERT)) {
keep_vert_4a = true;
keep_vert_4b = true;
break;
}
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + 7 * mi_width / 8 - 1] &
(1 << VERT)) {
keep_vert_4a = true;
keep_vert_4b = true;
break;
}
}
if (can_search_vert_4a && !keep_vert_4a) {
for (int row = 0; row < mi_height; row++) {
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + 3 * mi_width / 8 - 1] &
(1 << VERT)) {
keep_vert_4a = true;
break;
}
}
}
if (can_search_vert_4b && !keep_vert_4b) {
for (int row = 0; row < mi_height; row++) {
if (partition_boundaries[(masked_mi_row + row) * MAX_MIB_SIZE +
masked_mi_col + 5 * mi_width / 8 - 1] &
(1 << VERT)) {
keep_vert_4b = true;
break;
}
}
}
part_search_state->prune_partition_4a[VERT] |= !keep_vert_4a;
part_search_state->prune_partition_4b[VERT] |= !keep_vert_4b;
}
}
// Pruning logic for PARTITION_HORZ_3 and PARTITION_VERT_3.
static AOM_INLINE void prune_ext_partitions_3way(
AV1_COMP *const cpi, PC_TREE *pc_tree,
PartitionSearchState *part_search_state, bool *partition_boundaries) {
const AV1_COMMON *const cm = &cpi->common;
const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
const PARTITION_TYPE forced_partition = part_search_state->forced_partition;
if (part_search_state->forced_partition != PARTITION_INVALID) {
return;
}
// Prune horz 3 with speed features
if (part_search_state->partition_3_allowed[HORZ] &&
!frame_is_intra_only(cm) && forced_partition != PARTITION_HORZ_3) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_3[HORZ] = 1;
}
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but the subtrees did not further
// split in horz
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_horz(pc_tree->horizontal[0]) &&
!node_uses_horz(pc_tree->horizontal[1])) {
part_search_state->prune_partition_3[HORZ] = 1;
}
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_horz(pc_tree->vertical[0]) &&
!node_uses_horz(pc_tree->vertical[1])) {
part_search_state->prune_partition_3[HORZ] = 1;
}
}
}
if (part_search_state->partition_3_allowed[VERT] &&
!frame_is_intra_only(cm) && forced_partition != PARTITION_VERT_3) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_3[VERT] = 1;
}
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but the subtrees did not further
// split in vert
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_vert(pc_tree->vertical[0]) &&
!node_uses_vert(pc_tree->vertical[1])) {
part_search_state->prune_partition_3[VERT] = 1;
}
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_vert(pc_tree->horizontal[0]) &&
!node_uses_vert(pc_tree->horizontal[1])) {
part_search_state->prune_partition_3[VERT] = 1;
}
}
}
const bool can_search_horz = part_search_state->partition_3_allowed[HORZ] &&
!part_search_state->prune_partition_3[HORZ];
const bool can_search_vert = part_search_state->partition_3_allowed[VERT] &&
!part_search_state->prune_partition_3[VERT];
const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col,
bsize = blk_params->bsize;
if (part_sf->prune_part_h_with_partition_boundary &&
(can_search_horz || can_search_vert) &&
part_search_state->found_best_partition) {
if (!part_search_state->partition_boundaries) {
part_search_state->partition_boundaries = partition_boundaries;
trace_partition_boundary(partition_boundaries, pc_tree, mi_row, mi_col,
bsize);
}
prune_part_3_with_partition_boundary(part_search_state, bsize, mi_row,
mi_col, can_search_horz,
can_search_vert);
}
}
// Pruning logic for PARTITION_HORZ_4A/B and PARTITION_VERT_4A/B.
static AOM_INLINE void prune_ext_partitions_4way(
AV1_COMP *const cpi, PC_TREE *pc_tree,
PartitionSearchState *part_search_state, bool *partition_boundaries) {
const AV1_COMMON *const cm = &cpi->common;
const PARTITION_SPEED_FEATURES *part_sf = &cpi->sf.part_sf;
const PARTITION_TYPE forced_partition = part_search_state->forced_partition;
// Prune HORZ 4A with speed features
if (part_search_state->partition_4a_allowed[HORZ] &&
forced_partition != PARTITION_HORZ_4A) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_4a[HORZ] = 1;
}
#if CONFIG_FLEX_PARTITION
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but subtrees did not further split
// in horz
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_horz(pc_tree->horizontal[0]) &&
!node_uses_horz(pc_tree->horizontal[1])) {
part_search_state->prune_partition_4a[HORZ] = 1;
}
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_horz(pc_tree->vertical[0]) &&
!node_uses_horz(pc_tree->vertical[1])) {
part_search_state->prune_partition_4a[HORZ] = 1;
}
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
if (pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_horz(pc_tree->horizontal3[0]) &&
!node_uses_horz(pc_tree->horizontal3[3])) {
// Prune if best partition is horizontal H, but first and last
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4a[HORZ] = 1;
}
if (pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_horz(pc_tree->vertical3[1]) &&
!node_uses_horz(pc_tree->vertical3[2])) {
// Prune if best partition is vertical H, but middle two
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4a[HORZ] = 1;
}
}
#else
if (part_sf->prune_ext_part_with_part_rect &&
pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_horz(pc_tree->horizontal[0]) &&
!node_uses_horz(pc_tree->horizontal[1])) {
// Prune if the best partition is horz but horz did not further split in
// horz
part_search_state->prune_partition_4a[HORZ] = 1;
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_horz(pc_tree->horizontal3[0]) &&
!node_uses_horz(pc_tree->horizontal3[3])) {
// Prune is best partition is horizontal H, but first and last
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4a[HORZ] = 1;
}
#endif // CONFIG_FLEX_PARTITION
if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_VERT &&
part_search_state->partition_rect_allowed[HORZ]) {
part_search_state->prune_partition_4a[HORZ] = 1;
}
}
// Prune HORZ 4B with speed features
if (part_search_state->partition_4b_allowed[HORZ] &&
forced_partition != PARTITION_HORZ_4B) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_4b[HORZ] = 1;
}
#if CONFIG_FLEX_PARTITION
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but subtrees did not further split
// in horz
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_horz(pc_tree->horizontal[0]) &&
!node_uses_horz(pc_tree->horizontal[1])) {
part_search_state->prune_partition_4b[HORZ] = 1;
}
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_horz(pc_tree->vertical[0]) &&
!node_uses_horz(pc_tree->vertical[1])) {
part_search_state->prune_partition_4b[HORZ] = 1;
}
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
if (pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_horz(pc_tree->horizontal3[0]) &&
!node_uses_horz(pc_tree->horizontal3[3])) {
// Prune if best partition is horizontal H, but first and last
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4b[HORZ] = 1;
}
if (pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_horz(pc_tree->vertical3[1]) &&
!node_uses_horz(pc_tree->vertical3[2])) {
// Prune if best partition is vertical H, but middle two
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4b[HORZ] = 1;
}
}
#else
if (part_sf->prune_ext_part_with_part_rect &&
pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_horz(pc_tree->horizontal[0]) &&
!node_uses_horz(pc_tree->horizontal[1])) {
// Prune if the best partition is horz but horz did not further split in
// horz
part_search_state->prune_partition_4b[HORZ] = 1;
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_horz(pc_tree->horizontal3[0]) &&
!node_uses_horz(pc_tree->horizontal3[3])) {
// Prune is best partition is horizontal H, but first and last
// subpartitions did not further split in horizontal direction.
part_search_state->prune_partition_4b[HORZ] = 1;
}
#endif // CONFIG_FLEX_PARTITION
if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_VERT &&
part_search_state->partition_rect_allowed[HORZ]) {
part_search_state->prune_partition_4b[HORZ] = 1;
}
}
// Prune VERT_4A with speed features
if (part_search_state->partition_4a_allowed[VERT] &&
forced_partition != PARTITION_VERT_4A) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_4a[VERT] = 1;
}
#if CONFIG_FLEX_PARTITION
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but subtrees did not further split
// in vert
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_vert(pc_tree->vertical[0]) &&
!node_uses_vert(pc_tree->vertical[1])) {
part_search_state->prune_partition_4a[VERT] = 1;
}
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_vert(pc_tree->horizontal[0]) &&
!node_uses_vert(pc_tree->horizontal[1])) {
part_search_state->prune_partition_4a[VERT] = 1;
}
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
if (pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_vert(pc_tree->vertical3[0]) &&
!node_uses_vert(pc_tree->vertical3[3])) {
// Prune if best partition is vertical H, but first and last
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4a[VERT] = 1;
}
if (pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_vert(pc_tree->horizontal3[1]) &&
!node_uses_vert(pc_tree->horizontal3[2])) {
// Prune if best partition is horizontal H, but middle two
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4a[VERT] = 1;
}
}
#else
if (part_sf->prune_ext_part_with_part_rect &&
pc_tree->partitioning == PARTITION_VERT &&
!node_uses_vert(pc_tree->vertical[0]) &&
!node_uses_vert(pc_tree->vertical[1])) {
// Prune if the best partition is vert but vert did not further split in
// vert
part_search_state->prune_partition_4a[VERT] = 1;
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_vert(pc_tree->vertical3[0]) &&
!node_uses_vert(pc_tree->vertical3[3])) {
// Prune is best partition is vertical H, but first and last
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4a[VERT] = 1;
}
#endif // CONFIG_FLEX_PARTITION
if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_HORZ &&
part_search_state->partition_rect_allowed[VERT]) {
part_search_state->prune_partition_4a[VERT] = 1;
}
}
// Prune VERT_4B with speed features
if (part_search_state->partition_4b_allowed[VERT] &&
forced_partition != PARTITION_VERT_4B) {
if (part_sf->prune_ext_part_with_part_none &&
pc_tree->partitioning == PARTITION_NONE) {
// Prune if the best partition does not split
part_search_state->prune_partition_4b[VERT] = 1;
}
#if CONFIG_FLEX_PARTITION
if (part_sf->prune_ext_part_with_part_rect) {
// Prune if the best partition is rect but subtrees did not further split
// in vert
if (pc_tree->partitioning == PARTITION_VERT &&
!node_uses_vert(pc_tree->vertical[0]) &&
!node_uses_vert(pc_tree->vertical[1])) {
part_search_state->prune_partition_4b[VERT] = 1;
}
if (pc_tree->partitioning == PARTITION_HORZ &&
!node_uses_vert(pc_tree->horizontal[0]) &&
!node_uses_vert(pc_tree->horizontal[1])) {
part_search_state->prune_partition_4b[VERT] = 1;
}
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm)) {
if (pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_vert(pc_tree->vertical3[0]) &&
!node_uses_vert(pc_tree->vertical3[3])) {
// Prune if best partition is vertical H, but first and last
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4b[VERT] = 1;
}
if (pc_tree->partitioning == PARTITION_HORZ_3 &&
!node_uses_vert(pc_tree->horizontal3[1]) &&
!node_uses_vert(pc_tree->horizontal3[2])) {
// Prune if best partition is horizontal H, but middle two
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4b[VERT] = 1;
}
}
#else
if (part_sf->prune_ext_part_with_part_rect &&
pc_tree->partitioning == PARTITION_VERT &&
!node_uses_vert(pc_tree->vertical[0]) &&
!node_uses_vert(pc_tree->vertical[1])) {
// Prune if the best partition is vert but vert did not further split in
// vert
part_search_state->prune_partition_4b[VERT] = 1;
}
if (part_sf->prune_part_4_with_part_3 && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_VERT_3 &&
!node_uses_vert(pc_tree->vertical3[0]) &&
!node_uses_vert(pc_tree->vertical3[3])) {
// Prune is best partition is vertical H, but first and last
// subpartitions did not further split in vertical direction.
part_search_state->prune_partition_4b[VERT] = 1;
}
#endif // CONFIG_FLEX_PARTITION
if (part_sf->prune_part_4_horz_or_vert && !frame_is_intra_only(cm) &&
pc_tree->partitioning == PARTITION_HORZ &&
part_search_state->partition_rect_allowed[VERT]) {
part_search_state->prune_partition_4b[VERT] = 1;
}
}
const bool can_search_horz_4a =
part_search_state->partition_4a_allowed[HORZ] &&
!part_search_state->prune_partition_4a[HORZ];
const bool can_search_horz_4b =
part_search_state->partition_4b_allowed[HORZ] &&
!part_search_state->prune_partition_4b[HORZ];
const bool can_search_vert_4a =
part_search_state->partition_4a_allowed[VERT] &&
!part_search_state->prune_partition_4a[VERT];
const bool can_search_vert_4b =
part_search_state->partition_4b_allowed[VERT] &&
!part_search_state->prune_partition_4b[VERT];
const PartitionBlkParams *blk_params = &part_search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col,
bsize = blk_params->bsize;
if (part_sf->prune_part_4_with_partition_boundary &&
(can_search_horz_4a || can_search_vert_4a || can_search_horz_4b ||
can_search_vert_4b) &&
part_search_state->found_best_partition) {
if (!part_search_state->partition_boundaries ||
pc_tree->partitioning == PARTITION_HORZ_3 ||
pc_tree->partitioning == PARTITION_VERT_3) {
part_search_state->partition_boundaries = partition_boundaries;
trace_partition_boundary(partition_boundaries, pc_tree, mi_row, mi_col,
bsize);
}
prune_part_4_with_partition_boundary(
part_search_state, partition_boundaries, bsize, mi_row, mi_col,
can_search_horz_4a, can_search_horz_4b, can_search_vert_4a,
can_search_vert_4b);
}
}
static INLINE void search_partition_horz_4a(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state,
PARTITION_HORZ_4A) ||
!part_search_state->partition_4a_allowed[HORZ] ||
part_search_state->prune_partition_4a[HORZ]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_rows ||
!is_partition_valid(bsize, PARTITION_HORZ_4A) ||
!(search_state->do_rectangular_split ||
av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
return;
}
const int part_h4a_rate = search_state->partition_cost[PARTITION_HORZ_4A];
if (part_h4a_rate == INT_MAX ||
RDCOST(x->rdmult, part_h4a_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int eighth_step = mi_size_high[bsize] / 8;
sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4A];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_partition_subsize(bsize, PARTITION_HORZ_4A);
const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE med_subsize = subsize_lookup[PARTITION_HORZ][big_subsize];
assert(sml_subsize == subsize_lookup[PARTITION_HORZ][med_subsize]);
const int cum_step_multipliers[4] = { 0, 1, 3, 7 };
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, med_subsize, big_subsize,
sml_subsize };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->horizontal4a[idx]) {
av1_free_pc_tree_recursive(pc_tree->horizontal4a[idx], num_planes, 0, 0);
pc_tree->horizontal4a[idx] = NULL;
}
const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
pc_tree->horizontal4a[idx] = av1_alloc_pc_tree_node(
xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
PARTITION_HORZ_4A, idx, idx == 3, ss_x, ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[i];
if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4a[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
this_mi_row,
mi_col,
subblock_sizes[i],
PARTITION_HORZ_4A };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_HORZ_4A;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
static INLINE void search_partition_horz_4b(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state,
PARTITION_HORZ_4B) ||
!part_search_state->partition_4b_allowed[HORZ] ||
part_search_state->prune_partition_4b[HORZ]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_rows ||
!is_partition_valid(bsize, PARTITION_HORZ_4B) ||
!(search_state->do_rectangular_split ||
av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
return;
}
const int part_h4b_rate = search_state->partition_cost[PARTITION_HORZ_4B];
if (part_h4b_rate == INT_MAX ||
RDCOST(x->rdmult, part_h4b_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int eighth_step = mi_size_high[bsize] / 8;
sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_4B];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_partition_subsize(bsize, PARTITION_HORZ_4B);
const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_HORZ);
const BLOCK_SIZE med_subsize = subsize_lookup[PARTITION_HORZ][big_subsize];
assert(sml_subsize == subsize_lookup[PARTITION_HORZ][med_subsize]);
const int cum_step_multipliers[4] = { 0, 1, 5, 7 };
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, med_subsize,
sml_subsize };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->horizontal4b[idx]) {
av1_free_pc_tree_recursive(pc_tree->horizontal4b[idx], num_planes, 0, 0);
pc_tree->horizontal4b[idx] = NULL;
}
const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[idx];
pc_tree->horizontal4b[idx] = av1_alloc_pc_tree_node(
xd->tree_type, this_mi_row, mi_col, subblock_sizes[idx], pc_tree,
PARTITION_HORZ_4B, idx, idx == 3, ss_x, ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + eighth_step * cum_step_multipliers[i];
if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal4b[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
this_mi_row,
mi_col,
subblock_sizes[i],
PARTITION_HORZ_4B };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_HORZ_4B;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
static INLINE void search_partition_vert_4a(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state,
PARTITION_VERT_4A) ||
!part_search_state->partition_4a_allowed[VERT] ||
part_search_state->prune_partition_4a[VERT]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_cols ||
!is_partition_valid(bsize, PARTITION_VERT_4A) ||
!(search_state->do_rectangular_split ||
av1_active_v_edge(cpi, mi_col, blk_params->mi_step_w))) {
return;
}
const int part_v4a_rate = search_state->partition_cost[PARTITION_VERT_4A];
if (part_v4a_rate == INT_MAX ||
RDCOST(x->rdmult, part_v4a_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int eighth_step = mi_size_wide[bsize] / 8;
sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4A];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_partition_subsize(bsize, PARTITION_VERT_4A);
const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
const BLOCK_SIZE med_subsize = subsize_lookup[PARTITION_VERT][big_subsize];
assert(sml_subsize == subsize_lookup[PARTITION_VERT][med_subsize]);
const int cum_step_multipliers[4] = { 0, 1, 3, 7 };
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, med_subsize, big_subsize,
sml_subsize };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->vertical4a[idx]) {
av1_free_pc_tree_recursive(pc_tree->vertical4a[idx], num_planes, 0, 0);
pc_tree->vertical4a[idx] = NULL;
}
const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
pc_tree->vertical4a[idx] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
PARTITION_VERT_4A, idx, idx == 3, ss_x, ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[i];
if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4a[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
mi_row,
this_mi_col,
subblock_sizes[i],
PARTITION_VERT_4A };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_VERT_4A;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
static INLINE void search_partition_vert_4b(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state,
PARTITION_VERT_4B) ||
!part_search_state->partition_4b_allowed[VERT] ||
part_search_state->prune_partition_4b[VERT]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_cols ||
!is_partition_valid(bsize, PARTITION_VERT_4B) ||
!(search_state->do_rectangular_split ||
av1_active_v_edge(cpi, mi_col, blk_params->mi_step_w))) {
return;
}
const int part_v4b_rate = search_state->partition_cost[PARTITION_VERT_4B];
if (part_v4b_rate == INT_MAX ||
RDCOST(x->rdmult, part_v4b_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int eighth_step = mi_size_wide[bsize] / 8;
sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_4B];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_partition_subsize(bsize, PARTITION_VERT_4B);
const BLOCK_SIZE big_subsize = get_partition_subsize(bsize, PARTITION_VERT);
const BLOCK_SIZE med_subsize = subsize_lookup[PARTITION_VERT][big_subsize];
assert(sml_subsize == subsize_lookup[PARTITION_VERT][med_subsize]);
const int cum_step_multipliers[4] = { 0, 1, 5, 7 };
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, med_subsize,
sml_subsize };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->vertical4b[idx]) {
av1_free_pc_tree_recursive(pc_tree->vertical4b[idx], num_planes, 0, 0);
pc_tree->vertical4b[idx] = NULL;
}
const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[idx];
pc_tree->vertical4b[idx] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row, this_mi_col, subblock_sizes[idx], pc_tree,
PARTITION_VERT_4B, idx, idx == 3, ss_x, ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_col = mi_col + eighth_step * cum_step_multipliers[i];
if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical4b[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
mi_row,
this_mi_col,
subblock_sizes[i],
PARTITION_VERT_4B };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_VERT_4B;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
/*!\brief Performs rdopt on PARTITION_HORZ_3. */
static INLINE void search_partition_horz_3(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_HORZ_3) ||
!part_search_state->partition_3_allowed[HORZ] ||
part_search_state->prune_partition_3[HORZ]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_rows ||
!is_partition_valid(bsize, PARTITION_HORZ_3) ||
!(search_state->do_rectangular_split ||
av1_active_h_edge(cpi, mi_row, blk_params->mi_step_h))) {
return;
}
// TODO(yuec): set default partition modes for the edge directly by ruling out
// h partitions from the syntax if the 2nd middle block is not in the frame.
if (mi_col + (mi_size_wide[bsize] >> 1) >= cm->mi_params.mi_cols) return;
const int part_h3_rate = search_state->partition_cost[PARTITION_HORZ_3];
if (part_h3_rate == INT_MAX ||
RDCOST(x->rdmult, part_h3_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int quarter_step = mi_size_high[bsize] / 4;
sum_rdc.rate = search_state->partition_cost[PARTITION_HORZ_3];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_h_partition_subsize(bsize, 0, PARTITION_HORZ_3);
const BLOCK_SIZE big_subsize =
get_h_partition_subsize(bsize, 1, PARTITION_HORZ_3);
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, big_subsize,
sml_subsize };
const int offset_mr[4] = { 0, quarter_step, quarter_step, 3 * quarter_step };
const int offset_mc[4] = { 0, 0, mi_size_wide[bsize] / 2, 0 };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->horizontal3[idx]) {
av1_free_pc_tree_recursive(pc_tree->horizontal3[idx], num_planes, 0, 0);
pc_tree->horizontal3[idx] = NULL;
}
pc_tree->horizontal3[idx] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
subblock_sizes[idx], pc_tree, PARTITION_HORZ_3, idx, idx == 3, ss_x,
ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + offset_mr[i];
const int this_mi_col = mi_col + offset_mc[i];
if (i > 0 && this_mi_row >= cm->mi_params.mi_rows) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->horizontal3[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
this_mi_row,
this_mi_col,
subblock_sizes[i],
PARTITION_HORZ_3 };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_HORZ_3;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
/*!\brief Performs rdopt on PARTITION_VERT_3. */
static INLINE void search_partition_vert_3(
PartitionSearchState *search_state, AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, RD_STATS *best_rdc,
PC_TREE *pc_tree, const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree, RD_SEARCH_MACROBLOCK_CONTEXT *x_ctx,
const PartitionSearchState *part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
LevelBanksRDO *level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
SB_MULTI_PASS_MODE multi_pass_mode, int max_recursion_depth) {
const AV1_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
const int num_planes = av1_num_planes(cm);
MACROBLOCKD *const xd = &x->e_mbd;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
const PartitionBlkParams *blk_params = &search_state->part_blk_params;
const int mi_row = blk_params->mi_row, mi_col = blk_params->mi_col;
const BLOCK_SIZE bsize = blk_params->bsize;
if (is_part_pruned_by_forced_partition(part_search_state, PARTITION_VERT_3) ||
!part_search_state->partition_3_allowed[VERT] ||
part_search_state->prune_partition_3[VERT]) {
return;
}
if (search_state->terminate_partition_search || !blk_params->has_cols ||
!is_partition_valid(bsize, PARTITION_VERT_3) ||
!(search_state->do_rectangular_split ||
av1_active_v_edge(cpi, mi_col, blk_params->mi_step_w))) {
return;
}
// TODO(yuec): set default partition modes for the edge directly by ruling out
// h partitions from the syntax if the 2nd middle block is not in the frame.
if (mi_row + (mi_size_high[bsize] >> 1) >= cm->mi_params.mi_rows) return;
const int part_v3_rate = search_state->partition_cost[PARTITION_VERT_3];
if (part_v3_rate == INT_MAX ||
RDCOST(x->rdmult, part_v3_rate, 0) >= best_rdc->rdcost) {
return;
}
RD_STATS sum_rdc;
av1_init_rd_stats(&sum_rdc);
const int quarter_step = mi_size_wide[bsize] / 4;
sum_rdc.rate = search_state->partition_cost[PARTITION_VERT_3];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, 0);
const BLOCK_SIZE sml_subsize =
get_h_partition_subsize(bsize, 0, PARTITION_VERT_3);
const BLOCK_SIZE big_subsize =
get_h_partition_subsize(bsize, 1, PARTITION_VERT_3);
const BLOCK_SIZE subblock_sizes[4] = { sml_subsize, big_subsize, big_subsize,
sml_subsize };
const int offset_mr[4] = { 0, 0, mi_size_high[bsize] / 2, 0 };
const int offset_mc[4] = { 0, quarter_step, quarter_step, 3 * quarter_step };
for (int idx = 0; idx < 4; idx++) {
if (pc_tree->vertical3[idx]) {
av1_free_pc_tree_recursive(pc_tree->vertical3[idx], num_planes, 0, 0);
pc_tree->vertical3[idx] = NULL;
}
pc_tree->vertical3[idx] = av1_alloc_pc_tree_node(
xd->tree_type, mi_row + offset_mr[idx], mi_col + offset_mc[idx],
subblock_sizes[idx], pc_tree, PARTITION_VERT_3, idx, idx == 3, ss_x,
ss_y);
}
bool skippable = true;
for (int i = 0; i < 4; ++i) {
const int this_mi_row = mi_row + offset_mr[i];
const int this_mi_col = mi_col + offset_mc[i];
if (i > 0 && this_mi_col >= cm->mi_params.mi_cols) break;
SUBBLOCK_RDO_DATA rdo_data = { pc_tree->vertical3[i],
get_partition_subtree_const(ptree_luma, i),
get_partition_subtree_const(template_tree,
i),
this_mi_row,
this_mi_col,
subblock_sizes[i],
PARTITION_VERT_3 };
if (!rd_try_subblock_new(cpi, td, tile_data, tp, &rdo_data, *best_rdc,
&sum_rdc, multi_pass_mode, &skippable,
max_recursion_depth)) {
av1_invalid_rd_stats(&sum_rdc);
break;
}
}
av1_rd_cost_update(x->rdmult, &sum_rdc);
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
update_best_level_banks(level_banks, &x->e_mbd);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
*best_rdc = sum_rdc;
search_state->found_best_partition = true;
pc_tree->partitioning = PARTITION_VERT_3;
pc_tree->skippable = skippable;
}
av1_restore_context(cm, x, x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
restore_level_banks(&x->e_mbd, level_banks);
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE int get_partition_depth(const PC_TREE *pc_tree,
int curr_depth) {
const PARTITION_TYPE partition = pc_tree->partitioning;
int max_depth = curr_depth;
switch (partition) {
case PARTITION_NONE: break;
case PARTITION_SPLIT:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(max_depth, get_partition_depth(pc_tree->split[idx],
curr_depth + 2));
}
break;
#if CONFIG_EXT_RECUR_PARTITIONS
case PARTITION_HORZ:
for (int idx = 0; idx < 2; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->horizontal[idx], curr_depth + 1));
}
break;
case PARTITION_VERT:
for (int idx = 0; idx < 2; idx++) {
max_depth =
AOMMAX(max_depth,
get_partition_depth(pc_tree->vertical[idx], curr_depth + 1));
}
break;
case PARTITION_HORZ_3:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->horizontal3[idx], curr_depth + 1));
}
break;
case PARTITION_VERT_3:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->vertical3[idx], curr_depth + 1));
}
break;
case PARTITION_HORZ_4A:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->horizontal4a[idx], curr_depth + 1));
}
break;
case PARTITION_HORZ_4B:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->horizontal4b[idx], curr_depth + 1));
}
break;
case PARTITION_VERT_4A:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->vertical4a[idx], curr_depth + 1));
}
break;
case PARTITION_VERT_4B:
for (int idx = 0; idx < 4; idx++) {
max_depth = AOMMAX(
max_depth,
get_partition_depth(pc_tree->vertical4b[idx], curr_depth + 1));
}
break;
default: assert(0); break;
#else
default: break;
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
return max_depth;
}
#if CONFIG_EXT_RECUR_PARTITIONS
static AOM_INLINE bool try_none_after_rect(
const MACROBLOCKD *xd, const CommonModeInfoParams *mi_params,
BLOCK_SIZE bsize,
#if CONFIG_CB1TO4_SPLIT
BLOCK_SIZE parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
int mi_row, int mi_col) {
if (!is_partition_point(bsize
#if CONFIG_CB1TO4_SPLIT
,
parent_bsize
#endif // CONFIG_CB1TO4_SPLIT
)) {
return false;
}
const int tree_idx = av1_get_sdp_idx(xd->tree_type);
// This speed feature is not applicable if either the above or left block is
// unavailable.
if (tree_idx == 0 && !(xd->up_available && xd->left_available)) {
return false;
}
if (tree_idx == 1 &&
!(xd->chroma_up_available && xd->chroma_left_available)) {
return false;
}
// Scan for the maximum and minimum dimension of the above and left blocks.
const int mi_stride = xd->mi_stride;
int min_left_dim_log2 = INT_MAX, min_above_dim_log2 = INT_MAX;
int max_left_dim_log2 = 0, max_above_dim_log2 = 0;
const int mi_height =
AOMMIN(mi_size_high[bsize], mi_params->mi_rows - mi_row);
const int mi_width = AOMMIN(mi_size_wide[bsize], mi_params->mi_cols - mi_col);
for (int row = 0; row < mi_height;) {
const MB_MODE_INFO *mi = xd->mi[row * mi_stride - 1];
const BLOCK_SIZE left_bsize = mi->sb_type[tree_idx];
min_left_dim_log2 =
AOMMIN(min_left_dim_log2, mi_size_high_log2[left_bsize]);
max_left_dim_log2 =
AOMMAX(max_left_dim_log2, mi_size_high_log2[left_bsize]);
const int row_step =
tree_idx == 0
? mi_size_high[left_bsize] - AOMMAX(mi_row - mi->mi_row_start, 0)
: mi_size_high[left_bsize] -
AOMMAX(mi_row - mi->chroma_mi_row_start, 0);
row += row_step;
assert(row_step > 0);
}
for (int col = 0; col < mi_width;) {
const MB_MODE_INFO *mi = xd->mi[-1 * mi_stride + col];
const BLOCK_SIZE above_bsize = mi->sb_type[tree_idx];
min_above_dim_log2 =
AOMMIN(min_above_dim_log2, mi_size_wide_log2[above_bsize]);
max_above_dim_log2 =
AOMMAX(max_above_dim_log2, mi_size_wide_log2[above_bsize]);
const int col_step =
tree_idx == 0
? mi_size_wide[above_bsize] - AOMMAX(mi_col - mi->mi_col_start, 0)
: mi_size_wide[above_bsize] -
AOMMAX(mi_col - mi->chroma_mi_col_start, 0);
col += col_step;
assert(col_step > 0);
}
// Delay the search for partition none if the above width and left height
// are not bigger than the current block dimension AND at least one of the
// dimensions if smaller than the current block by a factor of 4.
if ((mi_size_high_log2[bsize] > max_left_dim_log2 + 1 &&
mi_size_wide_log2[bsize] >= min_above_dim_log2) ||
(mi_size_wide_log2[bsize] > max_above_dim_log2 + 1 &&
mi_size_high_log2[bsize] >= min_left_dim_log2)) {
return true;
}
return false;
}
/*!\brief Prune PARTITION_NONE search if rect partitions split deeper.
*/
static AOM_INLINE void prune_none_with_rect_results(
PartitionSearchState *part_search_state, const PC_TREE *pc_tree) {
if (!part_search_state->found_best_partition) {
return;
}
const PARTITION_TYPE cur_best_partition = pc_tree->partitioning;
PC_TREE *const *tree = NULL;
int num_sub_parts = 0;
if (cur_best_partition == PARTITION_SPLIT) {
tree = pc_tree->split;
num_sub_parts = SUB_PARTITIONS_SPLIT;
} else if (cur_best_partition == PARTITION_HORZ) {
tree = pc_tree->horizontal;
num_sub_parts = NUM_RECT_PARTS;
} else if (cur_best_partition == PARTITION_VERT) {
tree = pc_tree->vertical;
num_sub_parts = NUM_RECT_PARTS;
} else {
assert(0 &&
"Unexpected best partition type in prune_none_with_rect_results.");
}
// Give up on PARTITION_NONE if either of the subtrees decided to split
// further.
for (int idx = 0; idx < num_sub_parts; idx++) {
if (!tree[idx]) {
break;
}
part_search_state->prune_partition_none |=
tree[idx]->partitioning != PARTITION_NONE;
}
}
/*!\brief AV1 block partition search (full search).
*
* \ingroup partition_search
* \callgraph
* Searches for the best partition pattern for a block based on the
* rate-distortion cost, and returns a bool value to indicate whether a valid
* partition pattern is found. The partition can recursively go down to the
* smallest block size.
*
* \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] bsize Current block size
* \param[in] rd_cost Pointer to the final rd cost of the block
* \param[in] best_rdc Upper bound of rd cost of a valid partition
* \param[in] pc_tree Pointer to the PC_TREE node storing the
picked partitions and mode info for the
current block
* \param[in] ptree_luma Pointer to the luma partition tree so that the
* encoder to estimate the partition type for chroma.
* \param[in] template_tree A partial tree that contains the partition
* structure to be used as a template.
* \param[in] max_recursion_depth The maximum level of recursion allowed
* \param[in] sms_tree Pointer to struct holding simple motion
search data for the current block
* \param[in] none_rd Pointer to the rd cost in the case of not
splitting the current block
* \param[in] multi_pass_mode SB_SINGLE_PASS/SB_DRY_PASS/SB_WET_PASS
* \param[in] rect_part_win_info Pointer to struct storing whether horz/vert
* partition outperforms previously tested partitions
*
* \return A bool value is returned indicating if a valid partition is found.
* The pc_tree struct is modified to store the picked partition and modes.
* The rd_cost struct is also updated with the RD stats corresponding to the
* best partition found.
*/
#else
/*!\brief AV1 block partition search (full search).
*
* \ingroup partition_search
* \callgraph
* Searches for the best partition pattern for a block based on the
* rate-distortion cost, and returns a bool value to indicate whether a valid
* partition pattern is found. The partition can recursively go down to the
* smallest block size.
*
* This function works on planes determined by get_partition_plane_start() and
* get_partition_plane_end() based on xd->tree_type.
*
* \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] bsize Current block size
* \param[in] rd_cost Pointer to the final rd cost of the block
* \param[in] best_rdc Upper bound of rd cost of a valid partition
* \param[in] pc_tree Pointer to the PC_TREE node storing the
picked partitions and mode info for the
current block
* \param[in] sms_tree Pointer to struct holding simple motion
search data for the current block
* \param[in] none_rd Pointer to the rd cost in the case of not
splitting the current block
* \param[in] multi_pass_mode SB_SINGLE_PASS/SB_DRY_PASS/SB_WET_PASS
* \param[in] rect_part_win_info Pointer to struct storing whether horz/vert
partition outperforms previously tested partitions
*
* \return A bool value is returned indicating if a valid partition is found.
* The pc_tree struct is modified to store the picked partition and modes.
* The rd_cost struct is also updated with the RD stats corresponding to the
* best partition found.
*/
#endif // CONFIG_EXT_RECUR_PARTITIONS
bool av1_rd_pick_partition(AV1_COMP *const cpi, ThreadData *td,
TileDataEnc *tile_data, TokenExtra **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, RD_STATS *rd_cost,
RD_STATS best_rdc, PC_TREE *pc_tree,
#if CONFIG_EXT_RECUR_PARTITIONS
const PARTITION_TREE *ptree_luma,
const PARTITION_TREE *template_tree,
int max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
SIMPLE_MOTION_DATA_TREE *sms_tree, int64_t *none_rd,
SB_MULTI_PASS_MODE multi_pass_mode,
RD_RECT_PART_WIN_INFO *rect_part_win_info) {
const AV1_COMMON *const cm = &cpi->common;
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;
RD_SEARCH_MACROBLOCK_CONTEXT x_ctx;
const TokenExtra *const tp_orig = *tp;
PartitionSearchState part_search_state;
// Initialization of state variables used in partition search.
init_partition_search_state_params(x, cpi, &part_search_state,
#if CONFIG_EXT_RECUR_PARTITIONS
pc_tree, ptree_luma, template_tree,
max_recursion_depth,
#endif // CONFIG_EXT_RECUR_PARTITIONS
mi_row, mi_col, bsize);
PartitionBlkParams blk_params = part_search_state.part_blk_params;
#if CONFIG_EXT_RECUR_PARTITIONS
if (sms_tree != NULL)
#endif // CONFIG_EXT_RECUR_PARTITIONS
sms_tree->partitioning = PARTITION_NONE;
if (best_rdc.rdcost < 0) {
av1_invalid_rd_stats(rd_cost);
return part_search_state.found_best_partition;
}
#if CONFIG_EXT_RECUR_PARTITIONS
// Check whether there is a counterpart pc_tree node with the same size
// and the same neighboring context at the same location but from a
// different partition path. If yes directly copy the RDO decision made for
// the counterpart.
PC_TREE *counterpart_block = av1_look_for_counterpart_block(pc_tree);
if (counterpart_block
#if CONFIG_CB1TO4_SPLIT
&&
(is_partition_point(bsize, pc_tree->parent ? pc_tree->parent->block_size
: BLOCK_INVALID) ==
is_partition_point(counterpart_block->block_size,
counterpart_block->parent
? counterpart_block->parent->block_size
: BLOCK_INVALID))
#endif // CONFIG_CB1TO4_SPLIT
) {
if (counterpart_block->rd_cost.rate != INT_MAX) {
av1_copy_pc_tree_recursive(xd, cm, pc_tree, counterpart_block,
part_search_state.ss_x, part_search_state.ss_y,
&td->shared_coeff_buf, xd->tree_type,
num_planes);
*rd_cost = pc_tree->rd_cost;
assert(bsize != cm->sb_size);
if (bsize == cm->sb_size) exit(0);
if (!pc_tree->is_last_subblock) {
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
pc_tree, NULL,
#if CONFIG_EXT_RECUR_PARTITIONS
NULL,
#endif // CONFIG_EXT_RECUR_PARTITIONS
NULL);
}
return true;
} else {
av1_invalid_rd_stats(rd_cost);
return false;
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (bsize == cm->sb_size) x->must_find_valid_partition = 0;
// Override skipping rectangular partition operations for edge blocks.
if (none_rd) *none_rd = 0;
(void)*tp_orig;
#if CONFIG_COLLECT_PARTITION_STATS
int partition_decisions[EXT_PARTITION_TYPES] = { 0 };
int partition_attempts[EXT_PARTITION_TYPES] = { 0 };
int64_t partition_times[EXT_PARTITION_TYPES] = { 0 };
struct aom_usec_timer partition_timer = { 0 };
int partition_timer_on = 0;
#if CONFIG_COLLECT_PARTITION_STATS == 2
PartitionStats *part_stats = &cpi->partition_stats;
#endif
#endif
#if !CONFIG_EXT_RECUR_PARTITIONS
// Override partition costs at the edges of the frame in the same
// way as in read_partition (see decodeframe.c).
if (!(blk_params.has_rows && blk_params.has_cols))
set_partition_cost_for_edge_blk(cm, xd, &part_search_state);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Disable rectangular partitions for inner blocks when the current block is
// forced to only use square partitions.
if (is_bsize_gt(bsize, cpi->sf.part_sf.use_square_partition_only_threshold)) {
part_search_state.partition_rect_allowed[HORZ] &= !blk_params.has_rows;
part_search_state.partition_rect_allowed[VERT] &= !blk_params.has_cols;
}
#ifndef NDEBUG
// Nothing should rely on the default value of this array (which is just
// leftover from encoding the previous block. Setting it to fixed pattern
// when debugging.
// bit 0, 1, 2 are blk_skip of each plane
// bit 4, 5, 6 are initialization checking of each plane
memset(x->txfm_search_info.blk_skip, 0x77,
sizeof(x->txfm_search_info.blk_skip));
#endif // NDEBUG
assert(bsize < BLOCK_SIZES_ALL);
#if !CONFIG_EXT_RECUR_PARTITIONS
assert(mi_size_wide[bsize] == mi_size_high[bsize]);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Set buffers and offsets.
av1_set_offsets(cpi, tile_info, x, mi_row, mi_col, bsize,
&pc_tree->chroma_ref_info);
bool search_none_after_split = false;
bool search_none_after_rect = false;
#if CONFIG_EXT_RECUR_PARTITIONS
if (part_search_state.forced_partition == PARTITION_INVALID) {
if (cpi->sf.part_sf.adaptive_partition_search_order) {
search_none_after_rect = try_none_after_rect(xd, &cm->mi_params, bsize,
#if CONFIG_CB1TO4_SPLIT
blk_params.parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
mi_row, mi_col);
}
#if CONFIG_BLOCK_256
// For 256X256, always search the subblocks first.
search_none_after_split |= bsize == BLOCK_256X256;
#endif // CONFIG_BLOCK_256
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// 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);
// Update rd cost of the bound using the current multiplier.
av1_rd_cost_update(x->rdmult, &best_rdc);
if (bsize == BLOCK_16X16 && cpi->vaq_refresh)
x->mb_energy = av1_log_block_var(cpi, x, bsize);
#if !CONFIG_TX_PARTITION_CTX
// Set the context.
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);
#endif // !CONFIG_TX_PARTITION_CTX
av1_save_context(x, &x_ctx, mi_row, mi_col, bsize, num_planes);
#if CONFIG_MVP_IMPROVEMENT
LevelBanksRDO level_banks = {
x->e_mbd.ref_mv_bank, /* curr_level_bank*/
x->e_mbd.ref_mv_bank, /* best_level_bank*/
#if WARP_CU_BANK
x->e_mbd.warp_param_bank, /* curr_level_warp_bank*/
x->e_mbd.warp_param_bank, /* best_level_warp_bank*/
#endif // WARP_CU_BANK
};
#endif // CONFIG_MVP_IMPROVEMENT
#if CONFIG_EXT_RECUR_PARTITIONS
{
SimpleMotionData *sms_data =
av1_get_sms_data_entry(x->sms_bufs, mi_row, mi_col, bsize, cm->sb_size);
sms_tree = sms_data->old_sms;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
int *partition_horz_allowed = &part_search_state.partition_rect_allowed[HORZ];
int *partition_vert_allowed = &part_search_state.partition_rect_allowed[VERT];
#if CONFIG_EXT_RECUR_PARTITIONS
if (part_search_state.forced_partition == PARTITION_INVALID &&
is_bsize_gt(bsize, x->sb_enc.min_partition_size)) {
#endif // CONFIG_EXT_RECUR_PARTITIONS
bool *prune_horz = &part_search_state.prune_rect_part[HORZ];
bool *prune_vert = &part_search_state.prune_rect_part[VERT];
#if CONFIG_EXT_RECUR_PARTITIONS
int do_square_split = true;
int *sqr_split_ptr = &do_square_split;
#else
int *sqr_split_ptr = &part_search_state.do_square_split;
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Pruning: before searching any partition type, using source and simple
// motion search results to prune out unlikely partitions.
av1_prune_partitions_before_search(
cpi, x, mi_row, mi_col, bsize, sms_tree,
&part_search_state.partition_none_allowed, partition_horz_allowed,
partition_vert_allowed, &part_search_state.do_rectangular_split,
sqr_split_ptr, prune_horz, prune_vert, pc_tree);
#if CONFIG_EXT_RECUR_PARTITIONS
part_search_state.forced_partition = get_forced_partition_type(
cm, x, blk_params.mi_row, blk_params.mi_col, blk_params.bsize,
#if CONFIG_CB1TO4_SPLIT
blk_params.parent_bsize,
#endif // CONFIG_CB1TO4_SPLIT
ptree_luma, template_tree, &pc_tree->chroma_ref_info);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// Pruning: eliminating partition types leading to coding block sizes
// outside the min and max bsize limitations set from the encoder.
av1_prune_partitions_by_max_min_bsize(
&x->sb_enc, bsize, blk_params.has_rows && blk_params.has_cols,
&part_search_state.partition_none_allowed, partition_horz_allowed,
#if CONFIG_EXT_RECUR_PARTITIONS
partition_vert_allowed, NULL);
#else
partition_vert_allowed, &part_search_state.do_square_split);
#endif
int luma_split_flag = 0;
#if !CONFIG_EXT_RECUR_PARTITIONS
const CommonModeInfoParams *const mi_params = &cm->mi_params;
const int parent_block_width = block_size_wide[bsize];
if (xd->tree_type == CHROMA_PART && parent_block_width >= SHARED_PART_SIZE) {
luma_split_flag = get_luma_split_flag(bsize, mi_params, mi_row, mi_col);
}
// if luma blocks uses smaller blocks, then chroma will also split
if (luma_split_flag > 3) {
part_search_state.partition_none_allowed = BLOCK_INVALID;
part_search_state.partition_rect_allowed[HORZ] = 0;
part_search_state.partition_rect_allowed[VERT] = 0;
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
// Partition search
BEGIN_PARTITION_SEARCH:
// If a valid partition is required, usually when the first round cannot
// find a valid one under the cost limit after pruning, reset the
// limitations on partition types.
if (x->must_find_valid_partition) {
#if CONFIG_EXT_RECUR_PARTITIONS
init_allowed_partitions(&part_search_state, &cpi->oxcf.part_cfg,
&pc_tree->chroma_ref_info, xd->tree_type);
#else
reset_part_limitations(cpi, &part_search_state);
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
// Partition block source pixel variance.
unsigned int pb_source_variance = UINT_MAX;
// PARTITION_NONE search stage.
int64_t part_none_rd = INT64_MAX;
if (!search_none_after_rect && !search_none_after_split) {
none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
&part_search_state, &best_rdc, &pb_source_variance,
none_rd, &part_none_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
#if CONFIG_EXT_RECUR_PARTITIONS
if (cpi->sf.part_sf.end_part_search_after_consec_failures && x->is_whole_sb &&
!frame_is_intra_only(cm) &&
part_search_state.forced_partition == PARTITION_INVALID &&
pc_tree->parent && pc_tree->parent->parent) {
if (pc_tree->none_rd.rate == INT_MAX &&
pc_tree->parent->none_rd.rate == INT_MAX &&
pc_tree->parent->parent->none_rd.rate == INT_MAX &&
part_search_state.partition_none_allowed &&
best_rdc.rdcost < INT64_MAX) {
part_search_state.terminate_partition_search = 1;
}
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
// PARTITION_SPLIT search stage.
int64_t part_split_rd = INT64_MAX;
split_partition_search(cpi, td, tile_data, tp, x, pc_tree, sms_tree, &x_ctx,
&part_search_state, &best_rdc, multi_pass_mode,
&part_split_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
#if CONFIG_EXT_RECUR_PARTITIONS
,
ptree_luma, template_tree, max_recursion_depth - 1
#endif // CONFIG_EXT_RECUR_PARTITIONS
);
#if !CONFIG_EXT_RECUR_PARTITIONS
// Terminate partition search for child partition,
// when NONE and SPLIT partition rd_costs are INT64_MAX.
if (cpi->sf.part_sf.early_term_after_none_split &&
part_none_rd == INT64_MAX && part_split_rd == INT64_MAX &&
!x->must_find_valid_partition && (bsize != cm->sb_size)) {
part_search_state.terminate_partition_search = 1;
}
// Prune partitions based on PARTITION_NONE and PARTITION_SPLIT.
prune_partitions_after_split(cpi, x, sms_tree, &part_search_state, &best_rdc,
part_none_rd, part_split_rd);
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_BLOCK_256
if (search_none_after_split) {
// Based on split result, decide if we want to further delay the search to
// after rect
assert(pc_tree->partitioning == PARTITION_SPLIT);
for (int idx = 0; idx < 4; idx++) {
const int depth = get_partition_depth(pc_tree->split[idx], 0);
search_none_after_split &= depth == 0;
}
}
if (cpi->sf.part_sf.prune_rect_with_split_depth && !frame_is_intra_only(cm) &&
part_search_state.forced_partition == PARTITION_INVALID &&
pc_tree->split[0] && pc_tree->split[1] && pc_tree->split[2] &&
pc_tree->split[3]) {
int min_depth = INT_MAX, max_depth = 0;
for (int idx = 0; idx < 4; idx++) {
const int depth = get_partition_depth(pc_tree->split[idx], 0);
min_depth = AOMMIN(min_depth, depth);
max_depth = AOMMAX(max_depth, depth);
}
if (min_depth > 4) {
part_search_state.prune_rect_part[HORZ] =
part_search_state.prune_rect_part[VERT] = true;
}
(void)max_depth;
}
if (part_search_state.forced_partition == PARTITION_INVALID &&
search_none_after_split) {
none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
&part_search_state, &best_rdc, &pb_source_variance,
none_rd, &part_none_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
#endif // CONFIG_BLOCK_256
// Rectangular partitions search stage.
rectangular_partition_search(
cpi, td, tile_data, tp, x, pc_tree, &x_ctx, &part_search_state, &best_rdc,
#if CONFIG_EXT_RECUR_PARTITIONS
multi_pass_mode, ptree_luma, template_tree, max_recursion_depth - 1,
#endif // CONFIG_EXT_RECUR_PARTITIONS
rect_part_win_info,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
part_none_rd);
if (pb_source_variance == UINT_MAX) {
av1_setup_src_planes(x, cpi->source, mi_row, mi_col, num_planes, NULL);
pb_source_variance = av1_high_get_sby_perpixel_variance(
cpi, &x->plane[0].src, bsize, xd->bd);
}
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part_search_state.do_rectangular_split));
#if CONFIG_EXT_RECUR_PARTITIONS
if (search_none_after_rect && !search_none_after_split) {
prune_none_with_rect_results(&part_search_state, pc_tree);
none_partition_search(cpi, td, tile_data, x, pc_tree, sms_tree, &x_ctx,
&part_search_state, &best_rdc, &pb_source_variance,
none_rd, &part_none_rd
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_EXT_RECUR_PARTITIONS
const int ext_partition_allowed =
part_search_state.do_rectangular_split &&
bsize > cpi->sf.part_sf.ext_partition_eval_thresh &&
blk_params.has_rows && blk_params.has_cols && ((luma_split_flag <= 3));
// AB partitions search stage.
ab_partitions_search(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
&part_search_state, &best_rdc, rect_part_win_info,
pb_source_variance, ext_partition_allowed
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
// 4-way partitions search stage.
int part4_search_allowed[NUM_PART4_TYPES] = { 1, 1 };
// Disable 4-way partition search flags for width less than twice the
// minimum width.
if (blk_params.width < (blk_params.min_partition_size_1d << 2) ||
(xd->tree_type == CHROMA_PART && bsize <= BLOCK_16X16) ||
(luma_split_flag > 3)) {
part4_search_allowed[HORZ4] = 0;
part4_search_allowed[VERT4] = 0;
} else {
// Prune 4-way partition search.
prune_4_way_partition_search(cpi, x, pc_tree, &part_search_state, &best_rdc,
pb_source_variance, ext_partition_allowed,
part4_search_allowed);
}
// PARTITION_HORZ_4
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part4_search_allowed[HORZ4]));
if (!part_search_state.terminate_partition_search &&
part4_search_allowed[HORZ4] && blk_params.has_rows &&
(part_search_state.do_rectangular_split ||
av1_active_h_edge(cpi, mi_row, blk_params.mi_step))) {
const int inc_step[NUM_PART4_TYPES] = { mi_size_high[blk_params.bsize] / 4,
0 };
// Evaluation of Horz4 partition type.
rd_pick_4partition(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
pc_tree->horizontal4, &part_search_state, &best_rdc,
inc_step, PARTITION_HORZ_4
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
// PARTITION_VERT_4
assert(IMPLIES(!cpi->oxcf.part_cfg.enable_rect_partitions,
!part4_search_allowed[VERT4]));
if (!part_search_state.terminate_partition_search &&
part4_search_allowed[VERT4] && blk_params.has_cols &&
(part_search_state.do_rectangular_split ||
av1_active_v_edge(cpi, mi_col, blk_params.mi_step))) {
const int inc_step[NUM_PART4_TYPES] = { 0, mi_size_wide[blk_params.bsize] /
4 };
// Evaluation of Vert4 partition type.
rd_pick_4partition(cpi, td, tile_data, tp, x, &x_ctx, pc_tree,
pc_tree->vertical4, &part_search_state, &best_rdc,
inc_step, PARTITION_VERT_4
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
,
&level_banks
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
);
}
#endif // !CONFIG_EXT_RECUR_PARTITIONS
#if CONFIG_EXT_RECUR_PARTITIONS
bool partition_boundaries[MAX_MIB_SQUARE] = { 0 };
prune_ext_partitions_3way(cpi, pc_tree, &part_search_state,
partition_boundaries);
const int ext_recur_depth =
AOMMIN(max_recursion_depth - 1, cpi->sf.part_sf.ext_recur_depth);
const bool track_ptree_luma =
is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize);
// PARTITION_HORZ_3
search_partition_horz_3(&part_search_state, cpi, td, tile_data, tp, &best_rdc,
pc_tree, track_ptree_luma ? ptree_luma : NULL,
template_tree, &x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
// PARTITION_VERT_3
search_partition_vert_3(&part_search_state, cpi, td, tile_data, tp, &best_rdc,
pc_tree, track_ptree_luma ? ptree_luma : NULL,
template_tree, &x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
prune_ext_partitions_4way(cpi, pc_tree, &part_search_state,
partition_boundaries);
// PARTITION_HORZ_4A
search_partition_horz_4a(&part_search_state, cpi, td, tile_data, tp,
&best_rdc, pc_tree,
track_ptree_luma ? ptree_luma : NULL, template_tree,
&x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
// PARTITION_HORZ_4B
search_partition_horz_4b(&part_search_state, cpi, td, tile_data, tp,
&best_rdc, pc_tree,
track_ptree_luma ? ptree_luma : NULL, template_tree,
&x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
// PARTITION_VERT_4A
search_partition_vert_4a(&part_search_state, cpi, td, tile_data, tp,
&best_rdc, pc_tree,
track_ptree_luma ? ptree_luma : NULL, template_tree,
&x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
// PARTITION_VERT_4B
search_partition_vert_4b(&part_search_state, cpi, td, tile_data, tp,
&best_rdc, pc_tree,
track_ptree_luma ? ptree_luma : NULL, template_tree,
&x_ctx, &part_search_state,
#if CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
&level_banks,
#endif // CONFIG_MVP_IMPROVEMENT || WARP_CU_BANK
multi_pass_mode, ext_recur_depth);
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (bsize == cm->sb_size && !part_search_state.found_best_partition) {
if (x->must_find_valid_partition) {
aom_internal_error(
&cpi->common.error, AOM_CODEC_ERROR,
"The same superblock is recoded twice. Infinite loop detected?");
}
// Did not find a valid partition, go back and search again, with less
// constraint on which partition types to search.
x->must_find_valid_partition = 1;
#if CONFIG_COLLECT_PARTITION_STATS == 2
part_stats->partition_redo += 1;
#endif
goto BEGIN_PARTITION_SEARCH;
}
#if CONFIG_EXT_RECUR_PARTITIONS && !defined(NDEBUG)
if (template_tree && template_tree->partition != PARTITION_INVALID &&
pc_tree->partitioning != template_tree->partition) {
assert(0);
printf("Mismatch with template at fr: %d, mi: (%d, %d), BLOCK_%dX%d\n",
#if CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
cm->current_frame.display_order_hint,
#else
cm->current_frame.order_hint,
#endif // CONFIG_EXPLICIT_TEMPORAL_DIST_CALC
mi_row, mi_col, block_size_wide[bsize], block_size_high[bsize]);
}
#endif // CONFIG_EXT_RECUR_PARTITIONS && !defined(NDEBUG)
// Store the final rd cost
*rd_cost = best_rdc;
#if CONFIG_MVP_IMPROVEMENT
x->e_mbd.ref_mv_bank = level_banks.best_level_bank;
#endif // CONFIG_MVP_IMPROVEMENT
#if WARP_CU_BANK
x->e_mbd.warp_param_bank = level_banks.best_level_warp_bank;
#endif // WARP_CU_BANK
pc_tree->rd_cost = best_rdc;
if (!part_search_state.found_best_partition) {
av1_invalid_rd_stats(&pc_tree->rd_cost);
} else
#if CONFIG_CB1TO4_SPLIT
if (pc_tree->parent == NULL ||
pc_tree->parent->block_size <= BLOCK_LARGEST)
#endif // CONFIG_CB1TO4_SPLIT
{
#if CONFIG_EXT_RECUR_PARTITIONS
av1_cache_best_partition(x->sms_bufs, mi_row, mi_col, bsize, cm->sb_size,
pc_tree->partitioning);
#endif // CONFIG_EXT_RECUR_PARTITIONS
}
// Also record the best partition in simple motion data tree because it is
// necessary for the related speed features.
#if CONFIG_EXT_RECUR_PARTITIONS
if (sms_tree)
#endif // CONFIG_EXT_RECUR_PARTITIONS
sms_tree->partitioning = pc_tree->partitioning;
if (luma_split_flag > 3) {
assert(pc_tree->partitioning == PARTITION_SPLIT);
}
#if CONFIG_COLLECT_PARTITION_STATS
if (best_rdc.rate < INT_MAX && best_rdc.dist < INT64_MAX) {
partition_decisions[pc_tree->partitioning] += 1;
}
#endif
#if CONFIG_COLLECT_PARTITION_STATS == 1
// If CONFIG_COLLECT_PARTITION_STATS is 1, then print out the stats for each
// prediction block.
FILE *f = fopen("data.csv", "a");
fprintf(f, "%d,%d,%d,", bsize, cm->show_frame, frame_is_intra_only(cm));
for (int idx = 0; idx < EXT_PARTITION_TYPES; idx++) {
fprintf(f, "%d,", partition_decisions[idx]);
}
for (int idx = 0; idx < EXT_PARTITION_TYPES; idx++) {
fprintf(f, "%d,", partition_attempts[idx]);
}
for (int idx = 0; idx < EXT_PARTITION_TYPES; idx++) {
fprintf(f, "%ld,", partition_times[idx]);
}
fprintf(f, "\n");
fclose(f);
#endif
#if CONFIG_COLLECT_PARTITION_STATS == 2
// If CONFIG_COLLECTION_PARTITION_STATS is 2, then we print out the stats
// for the whole clip. So we need to pass the information upstream to the
// encoder.
const int bsize_idx = av1_get_bsize_idx_for_part_stats(bsize);
int *agg_attempts = part_stats->partition_attempts[bsize_idx];
int *agg_decisions = part_stats->partition_decisions[bsize_idx];
int64_t *agg_times = part_stats->partition_times[bsize_idx];
for (int idx = 0; idx < EXT_PARTITION_TYPES; idx++) {
agg_attempts[idx] += partition_attempts[idx];
agg_decisions[idx] += partition_decisions[idx];
agg_times[idx] += partition_times[idx];
}
#endif
// Reset the PC_TREE deallocation flag.
int pc_tree_dealloc = 0;
// If a valid partition is found and reconstruction is required for future
// sub-blocks in the same group.
if (part_search_state.found_best_partition && pc_tree->index != 3) {
if (bsize == cm->sb_size) {
// Encode the superblock.
const int emit_output = multi_pass_mode != SB_DRY_PASS;
const RUN_TYPE run_type = emit_output ? OUTPUT_ENABLED : DRY_RUN_NORMAL;
const int plane_start = (xd->tree_type == CHROMA_PART);
const int plane_end = (xd->tree_type == LUMA_PART) ? 1 : num_planes;
for (int plane = plane_start; plane < plane_end; plane++) {
x->cb_offset[plane] = 0;
}
av1_reset_ptree_in_sbi(xd->sbi, xd->tree_type);
x->cb_offset[xd->tree_type == CHROMA_PART] = 0;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, run_type, bsize,
pc_tree, xd->sbi->ptree_root[av1_get_sdp_idx(xd->tree_type)],
#if CONFIG_EXT_RECUR_PARTITIONS
xd->tree_type == CHROMA_PART ? xd->sbi->ptree_root[0] : NULL,
#endif // CONFIG_EXT_RECUR_PARTITIONS
NULL);
// Dealloc the whole PC_TREE after a superblock is done.
av1_free_pc_tree_recursive(pc_tree, num_planes, 0, 0);
pc_tree_dealloc = 1;
} else {
// Encode the smaller blocks in DRY_RUN mode.
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, DRY_RUN_NORMAL, bsize,
pc_tree, NULL,
#if CONFIG_EXT_RECUR_PARTITIONS
NULL,
#endif // CONFIG_EXT_RECUR_PARTITIONS
NULL);
}
}
int keep_tree = 0;
#if CONFIG_EXT_RECUR_PARTITIONS
keep_tree = should_reuse_mode(x, REUSE_INTER_MODE_IN_INTERFRAME_FLAG |
REUSE_INTRA_MODE_IN_INTERFRAME_FLAG);
#endif // CONFIG_EXT_RECUR_PARTITIONS
// If the tree still exists (non-superblock), dealloc most nodes, only keep
// nodes for the best partition and PARTITION_NONE.
if (!pc_tree_dealloc && !keep_tree) {
av1_free_pc_tree_recursive(pc_tree, num_planes, 1, 1);
}
if (bsize == cm->sb_size) {
assert(best_rdc.rate < INT_MAX);
assert(best_rdc.dist < INT64_MAX);
} else {
assert(tp_orig == *tp);
}
// Restore the rd multiplier.
x->rdmult = orig_rdmult;
return part_search_state.found_best_partition;
}