blob: 0abf1e12cb32f7d1099ada54c4bc3da845ad7166 [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"
#if CONFIG_ADAPTIVE_MVD
#include "av1/common/reconinter.h"
#endif // CONFIG_ADAPTIVE_MVD
#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;
const int is_rect = is_rect_tx(max_tx_size);
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 (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_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;
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, this_size, tx_size);
#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(const AV1_COMMON *const cm, MACROBLOCK *x,
BLOCK_SIZE plane_bsize,
FRAME_COUNTS *td_counts,
uint8_t allow_update_cdf) {
MACROBLOCKD *xd = &x->e_mbd;
const int mi_width = mi_size_wide[plane_bsize];
const int mi_height = mi_size_high[plane_bsize];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0);
const int bh = tx_size_high_unit[max_tx_size];
const int bw = tx_size_wide_unit[max_tx_size];
xd->above_txfm_context =
cm->above_contexts.txfm[xd->tile.tile_row] + xd->mi_col;
xd->left_txfm_context =
xd->left_txfm_context_buffer + (xd->mi_row & MAX_MIB_MASK);
for (int idy = 0; idy < mi_height; idy += bh) {
for (int idx = 0; idx < mi_width; idx += bw) {
update_txfm_count(x, xd, td_counts, max_tx_size, 0, idy, idx,
allow_update_cdf);
}
}
}
static void set_txfm_context(MACROBLOCKD *xd, TX_SIZE tx_size, int blk_row,
int blk_col) {
MB_MODE_INFO *mbmi = xd->mi[0];
const BLOCK_SIZE bsize = mbmi->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);
}
}
}
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);
// 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 CONFIG_CROSS_CHROMA_TX
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]);
#else
av1_encode_intra_block_plane(cpi, x, bsize, plane, dry_run,
cpi->optimize_seg_arr[mbmi->segment_id]);
#endif // CONFIG_CROSS_CHROMA_TX
}
// 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,
cm->current_frame.order_hint, 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 (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(cm, 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_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_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_BVP_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
#endif // CONFIG_REF_MV_BANK && !CONFIG_C043_MVP_IMPROVEMENTS
#if CONFIG_WARP_REF_LIST && !WARP_CU_BANK
if (is_inter) av1_update_warp_param_bank(cm, xd, mbmi);
#endif // CONFIG_WARP_REF_LIST && !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 (dry_run) tx_partition_set_contexts(cm, xd, bsize);
} else {
TX_SIZE tx_size = mbmi->tx_size;
// The new intra coding scheme requires no change of transform size
if (is_inter) {
if (xd->lossless[mbmi->segment_id]) {
tx_size = TX_4X4;
} else {
tx_size = tx_size_from_tx_mode(bsize, txfm_params->tx_mode_search_type);
}
} else {
tx_size = (bsize > BLOCK_4X4) ? tx_size : TX_4X4;
}
mbmi->tx_size = tx_size;
set_txfm_ctxs(tx_size, xd->width, xd->height,
(mbmi->skip_txfm[xd->tree_type == CHROMA_PART] || seg_skip) &&
is_inter_block(mbmi, xd->tree_type),
xd);
}
if (is_inter_block(mbmi, xd->tree_type) && !xd->is_chroma_ref &&
is_cfl_allowed(xd)) {
#if CONFIG_ADAPTIVE_DS_FILTER
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
mbmi->tx_size,
#if DS_FRAME_LEVEL
cm->features.ds_filter_type);
#else
cm->seq_params.enable_cfl_ds_filter);
#endif // DS_FRAME_LEVEL
#else
cfl_store_block(xd, mbmi->sb_type[xd->tree_type == CHROMA_PART],
mbmi->tx_size);
#endif // CONFIG_ADAPTIVE_DS_FILTER
}
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->seq_params.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);
xd->above_txfm_context = cm->above_contexts.txfm[tile->tile_row] + mi_col;
xd->left_txfm_context =
xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
// Set up destination pointers.
av1_setup_dst_planes(xd->plane, &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_C043_MVP_IMPROVEMENTS
const int is_inter = is_inter_block(&ctx->mic, xd->tree_type);
#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_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_BVP_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, &ctx->mic);
#endif // CONFIG_C043_MVP_IMPROVEMENTS
#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];
#if CONFIG_CROSS_CHROMA_TX
xd->cctx_type_map = txfm_info->cctx_type_map_;
xd->cctx_type_map_stride = mi_size_wide[bsize];
#endif // CONFIG_CROSS_CHROMA_TX
for (i = 0; i < num_planes; ++i) {
p[i].coeff = ctx->coeff[i];
p[i].qcoeff = ctx->qcoeff[i];
p[i].dqcoeff = ctx->dqcoeff[i];
p[i].eobs = ctx->eobs[i];
p[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i];
}
for (i = 0; i < 2; ++i) pd[i].color_index_map = ctx->color_index_map[i];
ctx->skippable = 0;
// Set to zero to make sure we do not use the previous encoded frame stats
mbmi->skip_txfm[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_C043_MVP_IMPROVEMENTS
const int is_inter = is_inter_block(mbmi, xd->tree_type);
#if CONFIG_IBC_SR_EXT && !CONFIG_BVP_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_BVP_IMPROVEMENT
av1_update_ref_mv_bank(cm, xd, mbmi);
#endif // CONFIG_C043_MVP_IMPROVEMENTS
#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_WARPMV
assert(IMPLIES(mbmi->mode == WARPMV, 0));
#endif // CONFIG_WARPMV
#if IMPROVED_AMVD
if (mbmi->mode == AMVDNEWMV) max_drl_bits = AOMMIN(max_drl_bits, 1);
#endif // IMPROVED_AMVD
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
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;
}
}
#if CONFIG_BVP_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_BVP_IMPROVEMENT
#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,
#if !CONFIG_WARP_REF_LIST
const MACROBLOCKD *xd,
#endif //! CONFIG_WARP_REF_LIST
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 CONFIG_WARP_REF_LIST
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(mbmi)) {
#endif // CONFIG_WARP_REF_LIST
const WarpedMotionParams *params = &mbmi->wm_params[0];
WarpedMotionParams base_params;
av1_get_warp_base_params(
cm,
#if !CONFIG_WARP_REF_LIST
xd,
#endif //! CONFIG_WARP_REF_LIST
mbmi,
#if !CONFIG_WARP_REF_LIST
mbmi_ext->ref_mv_stack[mbmi->ref_frame[0]],
#endif //! CONFIG_WARP_REF_LIST
&base_params, NULL
#if CONFIG_WARP_REF_LIST
,
mbmi_ext->warp_param_stack[av1_ref_frame_type(mbmi->ref_frame)]
#endif // CONFIG_WARP_REF_LIST
);
// 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);
#if CONFIG_WARP_REF_LIST
}
#endif // CONFIG_WARP_REF_LIST
}
#endif // CONFIG_EXTENDED_WARP_PREDICTION
#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
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));
assert(mbmi->ref_mv_idx < max_drl_bits + 1);
for (int idx = 0; idx < max_drl_bits; ++idx) {
aom_cdf_prob *drl_cdf = fc->skip_drl_cdf[AOMMIN(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
update_cdf(drl_cdf, mbmi->ref_mv_idx != idx, 2);
if (mbmi->ref_mv_idx == idx) break;
}
}
#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
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 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_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);
}
#if CONFIG_ENTROPY_STATS
// delta quant applies to both intra and inter
const int super_block_upper_left =
((xd->mi_row & (cm->seq_params.mib_size - 1)) == 0) &&
((xd->mi_col & (cm->seq_params.mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
(bsize != cm->seq_params.sb_size ||
!mbmi->skip_txfm[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) {
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
#if CONFIG_BVCOST_UPDATE
if (use_intrabc) {
const int_mv ref_mv = mbmi_ext->ref_mv_stack[INTRA_FRAME][0].this_mv;
#if CONFIG_FLEX_MVRES
av1_update_mv_stats(mbmi->mv[0].as_mv, ref_mv.as_mv, &fc->ndvc,
#if CONFIG_ADAPTIVE_MVD
0,
#endif // CONFIG_ADAPTIVE_MVD
MV_PRECISION_ONE_PEL);
}
#else
av1_update_mv_stats(&mbmi->mv[0].as_mv, &ref_mv.as_mv, &fc->ndvc,
#if CONFIG_ADAPTIVE_MVD
0,
#endif // CONFIG_ADAPTIVE_MVD
MV_SUBPEL_NONE);
}
#endif
#endif // CONFIG_BVCOST_UPDATE
#if CONFIG_BVP_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
update_intrabc_drl_idx_stats(MAX_REF_BV_STACK_SIZE, fc, td->counts, mbmi);
}
#endif // CONFIG_BVP_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_DRL_WITH_REF_IDX
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_DRL_WITH_REF_IDX
}
#endif // CONFIG_SKIP_MODE_ENHANCEMENT
if (frame_is_intra_only(cm) || mbmi->skip_mode) return;
FRAME_COUNTS *const counts = td->counts;
const int inter_block = mbmi->ref_frame[0] != INTRA_FRAME;
if (!seg_ref_active) {
#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
// 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 CONFIG_TIP
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
}
#endif // CONFIG_TIP
if (current_frame->reference_mode == REFERENCE_MODE_SELECT
#if CONFIG_TIP
&& !is_tip_ref_frame(ref0)
#endif // CONFIG_TIP
) {
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_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_ALLOW_SAME_REF_COMPOUND
const int bit_type = n_bits == 0 ? -1
: av1_get_compound_ref_bit_type(
&cm->ref_frames_info, ref0, i);
if (n_bits > 0 || i < RANKED_REF0_TO_PRUNE - 1)
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) {
if (i < RANKED_REF0_TO_PRUNE - 1)
counts->comp_ref0[av1_get_ref_pred_context(xd, i, n_refs)][i]
[bit]++;
} else {
counts->comp_ref1[av1_get_ref_pred_context(xd, i, n_refs)][bit_type]
[i - 1][bit]++;
}
#endif // CONFIG_ENTROPY_STATS
n_bits += bit;
#if CONFIG_ALLOW_SAME_REF_COMPOUND
if (i < cm->ref_frames_info.num_same_ref_compound) i -= bit;
#endif // CONFIG_ALLOW_SAME_REF_COMPOUND
}
#if CONFIG_TIP
} else if (!is_tip_ref_frame(ref0)) {
#else
} else {
#endif // CONFIG_TIP
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 (cm->features.enable_bawp &&
av1_allow_bawp(mbmi, xd->mi_row, xd->mi_col)) {
update_cdf(fc->bawp_cdf, mbmi->bawp_flag == 1, 2);
#if CONFIG_ENTROPY_STATS
counts->bawp[mbmi->bawp_flag == 1]++;
#endif // CONFIG_ENTROPY_STATS
}
#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 CONFIG_WARPMV
if (mbmi->mode == WARPMV) {
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
update_cdf(fc->warped_causal_warpmv_cdf[bsize],
motion_mode == WARPED_CAUSAL, 2);
}
}
#endif // CONFIG_WARPMV
bool continue_motion_mode_signaling =
#if CONFIG_WARPMV
(mbmi->mode == WARPMV) ? false :
#endif // CONFIG_WARPMV
true;
#if CONFIG_WARPMV
assert(IMPLIES(mbmi->mode == WARPMV,
mbmi->motion_mode == WARP_DELTA ||
mbmi->motion_mode == WARPED_CAUSAL));
#endif // CONFIG_WARPMV
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_ENTROPY_STATS
counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++;
#endif
update_cdf(fc->wedge_interintra_cdf[bsize],
mbmi->use_wedge_interintra, 2);
if (mbmi->use_wedge_interintra) {
#if CONFIG_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_ENTROPY_STATS
counts->obmc[bsize][motion_mode == OBMC_CAUSAL]++;
#endif
update_cdf(fc->obmc_cdf[bsize], motion_mode == OBMC_CAUSAL, 2);
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_ENTROPY_STATS
counts->warped_causal[bsize][motion_mode == WARPED_CAUSAL]++;
#endif
update_cdf(fc->warped_causal_cdf[bsize], motion_mode == WARPED_CAUSAL,
2);
if (motion_mode == WARPED_CAUSAL) {
continue_motion_mode_signaling = false;
}
}
if (continue_motion_mode_signaling &&
(allowed_motion_modes & (1 << WARP_DELTA))) {
#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);
}
if (motion_mode == WARP_DELTA
#if CONFIG_WARPMV
|| (motion_mode == WARPED_CAUSAL && mbmi->mode == WARPMV)
#endif // CONFIG_WARPMV
) {
update_warp_delta_stats(cm,
#if !CONFIG_WARP_REF_LIST
xd,
#endif //! CONFIG_WARP_REF_LIST
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;
}
#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_ENTROPY_STATS
counts->wedge_interintra[bsize][mbmi->use_wedge_interintra]++;
#endif
update_cdf(fc->wedge_interintra_cdf[bsize],
mbmi->use_wedge_interintra, 2);
if (mbmi->use_wedge_interintra) {
#if CONFIG_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_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_EXTENDED_WARP_PREDICTION
if (has_second_ref(mbmi)
#if CONFIG_OPTFLOW_REFINEMENT
&& mbmi->mode < NEAR_NEARMV_OPTFLOW
#endif // CONFIG_OPTFLOW_REFINEMENT
#if IMPROVED_AMVD && CONFIG_JOINT_MVD
&& !is_joint_amvd_coding_mode(mbmi->mode)
#endif // IMPROVED_AMVD && CONFIG_JOINT_MVD
) {
assert(current_frame->reference_mode != SINGLE_REFERENCE &&
is_inter_compound_mode(mbmi->mode) &&
mbmi->motion_mode == SIMPLE_TRANSLATION);
const int masked_compound_used = is_any_masked_compound_used(bsize) &&
cm->seq_params.enable_masked_compound;
if (masked_compound_used) {
const int comp_group_idx_ctx = get_comp_group_idx_context(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_ENTROPY_STATS
++counts->compound_type[bsize][mbmi->interinter_comp.type -
COMPOUND_WEDGE];
#endif
update_cdf(fc->compound_type_cdf[bsize],
mbmi->interinter_comp.type - COMPOUND_WEDGE,
MASKED_COMPOUND_TYPES);
}
}
}
if (mbmi->interinter_comp.type == COMPOUND_WEDGE) {
if (is_interinter_compound_used(COMPOUND_WEDGE, bsize)) {
#if CONFIG_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 (inter_block && cm->features.interp_filter == SWITCHABLE &&
!is_warp_mode(mbmi->motion_mode) &&
!is_nontrans_global_motion(xd, mbmi)) {
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 &&
is_opfl_refine_allowed(cm, mbmi)) {
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);
}
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 CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
if (is_joint_mvd_coding_mode(mbmi->mode)) {
#if CONFIG_ADAPTIVE_MVD
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
update_cdf(fc->jmvd_scale_mode_cdf, mbmi->jmvd_scale_mode,
JOINT_NEWMV_SCALE_FACTOR_CNT);
#endif // CONFIG_ADAPTIVE_MVD
}
#endif // CONFIG_IMPROVED_JMVD && CONFIG_JOINT_MVD
} else {
av1_update_inter_mode_stats(fc, counts, mode, mode_ctx
#if CONFIG_WARPMV
,
cm, xd, mbmi, bsize
#endif // CONFIG_WARPMV
);
}
const int new_mv = have_newmv_in_each_reference(mbmi->mode);
#if CONFIG_JOINT_MVD
const int jmvd_base_ref_list = is_joint_mvd_coding_mode(mbmi->mode)
? get_joint_mvd_base_ref_list(cm, mbmi)
: 0;
#endif // CONFIG_JOINT_MVD
#if CONFIG_ADAPTIVE_MVD
const int is_adaptive_mvd = enable_adaptive_mvd_resolution(cm, mbmi);
#endif // CONFIG_ADAPTIVE_MVD
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 (have_newmv_in_inter_mode(mbmi->mode) && xd->tree_type != CHROMA_PART) {
#if CONFIG_FLEX_MVRES
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));
#else
const int allow_hp = cm->features.cur_frame_force_integer_mv
? MV_SUBPEL_NONE
: cm->features.allow_high_precision_mv;
#endif
#if CONFIG_FLEX_MVRES
if (is_pb_mv_precision_active(cm, mbmi, bsize)) {
#if CONFIG_ADAPTIVE_MVD
assert(!is_adaptive_mvd);
#endif
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);
}
}
#endif // CONFIG_FLEX_MVRES
if (new_mv) {
for (int ref = 0; ref < 1 + has_second_ref(mbmi); ++ref) {
const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_FLEX_MVRES
av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
pb_mv_precision);
#else
av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
allow_hp);
#endif
}
} 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
#if CONFIG_JOINT_MVD
jmvd_base_ref_list ||
#endif // CONFIG_JOINT_MVD
mbmi->mode == NEAR_NEWMV;
const int_mv ref_mv = av1_get_ref_mv(x, ref);
#if CONFIG_FLEX_MVRES
av1_update_mv_stats(mbmi->mv[ref].as_mv, ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
pb_mv_precision);
#else
av1_update_mv_stats(&mbmi->mv[ref].as_mv, &ref_mv.as_mv, &fc->nmvc,
#if CONFIG_ADAPTIVE_MVD
is_adaptive_mvd,
#endif // CONFIG_ADAPTIVE_MVD
allow_hp);
#endif
}
}
}
}
/*!\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.seq_params.sb_size]));
}
#if CONFIG_PC_WIENER
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_PC_WIENER
}
encode_superblock(cpi, tile_data, td, tp, dry_run, bsize, plane_start,
plane_end, rate);
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.seq_params.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->seq_params.mib_size - 1)) == 0) &&
((mi_col & (cm->seq_params.mib_size - 1)) == 0);
const DeltaQInfo *const delta_q_info = &cm->delta_q_info;
if (delta_q_info->delta_q_present_flag &&
(bsize != cm->seq_params.sb_size ||
!mbmi->skip_txfm[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_DRL_WITH_REF_IDX
assert(has_second_ref(mbmi));
#endif // !CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
rdc->compound_ref_used_flag = 1;
}
set_ref_ptrs(cm, xd, mbmi->ref_frame[0], mbmi->ref_frame[1]);
} else {
const int seg_ref_active = 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) {
#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]++;
}
if (allowed_motion_modes & (1 << WARPED_CAUSAL)) {
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_DRL_WITH_REF_IDX
{
if (mbmi->skip_mode) {
const SkipModeInfo *const skip_mode_info =
&cpi->common.current_frame.skip_mode_info;
MV_REFERENCE_FRAME rf[2];
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_WARP_REF_LIST
,
NULL, 0, NULL
#endif // CONFIG_WARP_REF_LIST
);
// 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_DRL_WITH_REF_IDX
av1_copy_mbmi_ext_to_mbmi_ext_frame(
x->mbmi_ext_frame, x->mbmi_ext,
#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
mbmi->skip_mode,
#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
av1_ref_frame_type(xd->mi[0]->ref_frame));
#if CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
}
#endif // CONFIG_SKIP_MODE_DRL_WITH_REF_IDX
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,
#if !CONFIG_H_PARTITION
PARTITION_TREE const *ptree,
#endif // !CONFIG_H_PARTITION
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) {
const int plane_index = xd->tree_type == CHROMA_PART;
#if CONFIG_EXT_RECUR_PARTITIONS
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
if (is_luma_chroma_share_same_partition(xd->tree_type, ptree_luma, bsize)) {
PARTITION_TYPE derived_partition_mode =
sdp_chroma_part_from_luma(bsize, ptree_luma->partition, ss_x, ss_y);
assert(partition == derived_partition_mode &&
"Chroma partition does not match the derived mode.");
(void)derived_partition_mode;
return;
}
PARTITION_TYPE implied_partition;
const bool is_part_implied = is_partition_implied_at_boundary(
mi_params, xd->tree_type, ss_x, ss_y, mi_row, mi_col, bsize,
chroma_ref_info, &implied_partition);
if (is_part_implied) {
assert(partition == implied_partition &&
"Partition doesn't match the implied partition at boundary.");
return;
}
#endif // CONFIG_EXT_RECUR_PARTITIONS
FRAME_CONTEXT *fc = xd->tile_ctx;
#if CONFIG_EXT_RECUR_PARTITIONS
#if !CONFIG_H_PARTITION
const PARTITION_TYPE parent_partition =
ptree->parent ? ptree->parent->partition : PARTITION_INVALID;
const bool is_middle_block = (parent_partition == PARTITION_HORZ_3 ||
parent_partition == PARTITION_VERT_3) &&
ptree->index == 1;
const bool limit_rect_split = is_middle_block &&
is_bsize_geq(bsize, BLOCK_8X8) &&
is_bsize_geq(BLOCK_64X64, bsize);
#endif // !CONFIG_H_PARTITION
if (is_square_block(bsize)) {
if (disable_ext_part) {
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
const int dir_idx = (parent_partition == PARTITION_HORZ_3) ? 0 : 1;
const int symbol = get_symbol_from_limited_partition_noext(
partition, parent_partition);
if (allow_update_cdf) {
update_cdf(fc->limited_partition_noext_cdf[plane_index][dir_idx][ctx],
symbol, LIMITED_PARTITION_TYPES);
}
} else {
#endif // !CONFIG_H_PARTITION
if (allow_update_cdf) {
update_cdf(fc->partition_noext_cdf[plane_index][ctx], partition,
PARTITION_TYPES);
}
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
} else {
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
const int dir_idx = (parent_partition == PARTITION_HORZ_3) ? 0 : 1;
const int symbol =
get_symbol_from_limited_partition(partition, parent_partition);
#if CONFIG_ENTROPY_STATS
counts->limited_partition[plane_index][dir_idx][ctx][symbol]++;
#endif // CONFIG_ENTROPY_STATS
if (allow_update_cdf) {
update_cdf(fc->limited_partition_cdf[plane_index][dir_idx][ctx],
symbol, limited_partition_cdf_length(bsize));
}
} else {
#endif // !CONFIG_H_PARTITION
#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));
}
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
}
} else { // Rectangular blocks
if (disable_ext_part) {
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
const PARTITION_TYPE_REC p_rec =
get_symbol_from_limited_partition_noext(partition,
parent_partition);
if (allow_update_cdf) {
update_cdf(fc->partition_middle_noext_rec_cdf[ctx], p_rec,
partition_middle_noext_rec_cdf_length(bsize));
}
} else {
#endif // !CONFIG_H_PARTITION
const PARTITION_TYPE_REC p_rec =
get_symbol_from_partition_noext_rec_block(bsize, partition);
if (allow_update_cdf) {
update_cdf(fc->partition_noext_rec_cdf[ctx], p_rec,
partition_noext_rec_cdf_length(bsize));
}
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
} else {
const PARTITION_TYPE_REC p_rec =
get_symbol_from_partition_rec_block(bsize, partition);
#if !CONFIG_H_PARTITION
if (limit_rect_split) {
#if CONFIG_ENTROPY_STATS
counts->partition_middle_rec[ctx][p_rec]++;
#endif // CONFIG_ENTROPY_STATS
if (allow_update_cdf) {
update_cdf(fc->partition_middle_rec_cdf[ctx], p_rec,
partition_middle_rec_cdf_length(bsize));
}
} else {
#endif // !CONFIG_H_PARTITION
#if CONFIG_ENTROPY_STATS
counts->partition_rec[ctx][p_rec]++;
#endif // CONFIG_ENTROPY_STATS
if (allow_update_cdf) {
update_cdf(fc->partition_rec_cdf[ctx], p_rec,
partition_rec_cdf_length(bsize));
}
#if !CONFIG_H_PARTITION
}
#endif // !CONFIG_H_PARTITION
}
}
#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 (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_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,
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_H_PARTITION
const int qbs_w = mi_size_wide[bsize] / 4;
const int qbs_h = mi_size_high[bsize] / 4;
#endif // !CONFIG_H_PARTITION
const int is_partition_root = is_partition_point(bsize);
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;
#else
const BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
#endif // CONFIG_EXT_RECUR_PARTITIONS
if (subsize == BLOCK_INVALID) return;
#if CONFIG_EXT_RECUR_PARTITIONS
assert(partition != PARTITION_SPLIT);
#endif // CONFIG_EXT_RECUR_PARTITIONS
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,
#if !CONFIG_H_PARTITION
ptree,
#endif // !CONFIG_H_PARTITION
ptree_luma, &pc_tree->chroma_ref_info,
#endif // CONFIG_EXT_RECUR_PARTITIONS
partition, mi_row, mi_col, bsize, ctx);
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;
PARTITION_TREE *parent = ptree->parent;
const int ss_x = xd->plane[1].subsampling_x;
const int ss_y = xd->plane[1].subsampling_y;
set_chroma_ref_info(
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);
switch (partition) {
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);
#if CONFIG_H_PARTITION
ptree->sub_tree[3] = av1_alloc_ptree_node(ptree, 3);
#endif // CONFIG_H_PARTITION
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 && 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
#if CONFIG_H_PARTITION
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;
}
#else
case PARTITION_HORZ_3: {
const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_HORZ);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->horizontal3[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_row + qbs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + qbs_h, mi_col, dry_run, bsize3,
pc_tree->horizontal3[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_row + 3 * qbs_h >= cm->mi_params.mi_rows) break;
encode_sb(cpi, td, tile_data, tp, mi_row + 3 * qbs_h, mi_col, dry_run,
subsize, pc_tree->horizontal3[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
break;
}
case PARTITION_VERT_3: {
const BLOCK_SIZE bsize3 = get_partition_subsize(bsize, PARTITION_VERT);
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col, dry_run, subsize,
pc_tree->vertical3[0], sub_tree[0],
track_ptree_luma ? ptree_luma->sub_tree[0] : NULL, rate);
if (mi_col + qbs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + qbs_w, dry_run, bsize3,
pc_tree->vertical3[1], sub_tree[1],
track_ptree_luma ? ptree_luma->sub_tree[1] : NULL, rate);
if (mi_col + 3 * qbs_w >= cm->mi_params.mi_cols) break;
encode_sb(cpi, td, tile_data, tp, mi_row, mi_col + 3 * qbs_w, dry_run,
subsize, pc_tree->vertical3[2], sub_tree[2],
track_ptree_luma ? ptree_luma->sub_tree[2] : NULL, rate);
break;
}
#endif // CONFIG_H_PARTITION
#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(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 PARTITION_TYPE second_partition =
(first_partition == PARTITION_HORZ) ? PARTITION_VERT : PARTITION_HORZ;
const int hbs_w = mi_size_wide[bsize] >> 1;
const int hbs_h = mi_size_high[bsize] >> 1;
const BLOCK_SIZE subsize = subsize_lookup[PARTITION_SPLIT][bsize];
ptree->partition = first_partition;
ptree->sub_tree[0] = av1_alloc_ptree_node(ptree, 0);
ptree->sub_tree[1] = av1_alloc_ptree_node(ptree, 1);
#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->seq_params.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 ssx = cm->cur_frame->buf.subsampling_x;
const bool ssy = cm->cur_frame->buf.subsampling_y;
PARTITION_TYPE implied_partition;
const bool is_part_implied = is_partition_implied_at_boundary(
&cm->mi_params, tree_type, ssx, ssy, mi_row, mi_col, bsize,
&ptree->chroma_ref_info, &implied_partition);
assert(IMPLIES(is_part_implied, ptree->partition == implied_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;
}