Move mode costs that can be updated inside a frame to MACROBLOCK
It is a refactoring patch, which aims to make the code ready for
implementation of in-frame mode cost update in RDO.
Also add mode cost update per sb row, but it won't affect coding
results because cdf update in RDO is not there.
Mode cost arrays are moved to MACROBLOCK because in multi-thread
coding, threads share the same AV1_COMP.
This patch does not have impact on coding results.
Change-Id: I2e8f7d7d066b23ebfbfc998269023781f359a6ff
diff --git a/av1/encoder/block.h b/av1/encoder/block.h
index cbe4675..869c472 100644
--- a/av1/encoder/block.h
+++ b/av1/encoder/block.h
@@ -149,15 +149,6 @@
uint8_t *above_pred_buf;
uint8_t *left_pred_buf;
#endif // CONFIG_MOTION_VAR
-#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
- int motion_mode_cost[BLOCK_SIZES_ALL][MOTION_MODES];
-#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
- int motion_mode_cost1[BLOCK_SIZES_ALL][2];
-#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
-#if CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
- int ncobmc_mode_cost[ADAPT_OVERLAP_BLOCKS][MAX_NCOBMC_MODES];
-#endif // CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
-#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
#if CONFIG_PALETTE
PALETTE_BUFFER *palette_buffer;
@@ -181,6 +172,68 @@
// note that token_costs is the cost when eob node is skipped
av1_coeff_cost token_costs[TX_SIZES];
+ // mode costs
+ int mbmode_cost[BLOCK_SIZE_GROUPS][INTRA_MODES];
+ int newmv_mode_cost[NEWMV_MODE_CONTEXTS][2];
+ int zeromv_mode_cost[ZEROMV_MODE_CONTEXTS][2];
+ int refmv_mode_cost[REFMV_MODE_CONTEXTS][2];
+ int drl_mode_cost0[DRL_MODE_CONTEXTS][2];
+
+#if CONFIG_EXT_INTER
+ int inter_compound_mode_cost[INTER_MODE_CONTEXTS][INTER_COMPOUND_MODES];
+#if CONFIG_COMPOUND_SINGLEREF
+ int inter_singleref_comp_mode_cost[INTER_MODE_CONTEXTS]
+ [INTER_SINGLEREF_COMP_MODES];
+#endif // CONFIG_COMPOUND_SINGLEREF
+#if CONFIG_INTERINTRA
+ int interintra_mode_cost[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
+#endif // CONFIG_INTERINTRA
+#endif // CONFIG_EXT_INTER
+#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
+ int motion_mode_cost[BLOCK_SIZES_ALL][MOTION_MODES];
+#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
+ int motion_mode_cost1[BLOCK_SIZES_ALL][2];
+#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
+#if CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
+ int ncobmc_mode_cost[ADAPT_OVERLAP_BLOCKS][MAX_NCOBMC_MODES];
+#endif // CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
+#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
+ int intra_uv_mode_cost[INTRA_MODES][UV_INTRA_MODES];
+ int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
+ int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
+#if CONFIG_EXT_PARTITION_TYPES
+ int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
+ [EXT_PARTITION_TYPES];
+#else
+ int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
+ [PARTITION_TYPES];
+#endif // CONFIG_EXT_PARTITION_TYPES
+#if CONFIG_PALETTE
+ int palette_y_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
+ int palette_uv_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
+ int palette_y_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
+ [PALETTE_COLORS];
+ int palette_uv_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
+ [PALETTE_COLORS];
+#endif // CONFIG_PALETTE
+ int tx_size_cost[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES];
+#if CONFIG_EXT_TX
+ int inter_tx_type_costs[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
+ int intra_tx_type_costs[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
+ [TX_TYPES];
+#else
+ int intra_tx_type_costs[EXT_TX_SIZES][TX_TYPES][TX_TYPES];
+ int inter_tx_type_costs[EXT_TX_SIZES][TX_TYPES];
+#endif // CONFIG_EXT_TX
+#if CONFIG_EXT_INTRA
+#if CONFIG_INTRA_INTERP
+ int intra_filter_cost[INTRA_FILTERS + 1][INTRA_FILTERS];
+#endif // CONFIG_INTRA_INTERP
+#endif // CONFIG_EXT_INTRA
+#if CONFIG_LOOP_RESTORATION
+ int switchable_restore_cost[RESTORE_SWITCHABLE_TYPES];
+#endif // CONFIG_LOOP_RESTORATION
+
int optimize;
// Used to store sub partition's choices.
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index edfb132..acda2e9 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -2474,10 +2474,10 @@
bsize, ctx_none, INT64_MAX);
if (none_rdc.rate < INT_MAX) {
- none_rdc.rate += cpi->partition_cost[pl][PARTITION_NONE];
+ none_rdc.rate += x->partition_cost[pl][PARTITION_NONE];
none_rdc.rdcost = RDCOST(x->rdmult, none_rdc.rate, none_rdc.dist);
#if CONFIG_SUPERTX
- none_rate_nocoef += cpi->partition_cost[pl][PARTITION_NONE];
+ none_rate_nocoef += x->partition_cost[pl][PARTITION_NONE];
#endif
}
@@ -2653,11 +2653,11 @@
}
if (last_part_rdc.rate < INT_MAX) {
- last_part_rdc.rate += cpi->partition_cost[pl][partition];
+ last_part_rdc.rate += x->partition_cost[pl][partition];
last_part_rdc.rdcost =
RDCOST(x->rdmult, last_part_rdc.rate, last_part_rdc.dist);
#if CONFIG_SUPERTX
- last_part_rate_nocoef += cpi->partition_cost[pl][partition];
+ last_part_rate_nocoef += x->partition_cost[pl][partition];
#endif
}
@@ -2732,16 +2732,16 @@
encode_sb(cpi, td, tile_info, tp, mi_row + y_idx, mi_col + x_idx,
OUTPUT_ENABLED, split_subsize, pc_tree->split[i], NULL);
- chosen_rdc.rate += cpi->partition_cost[pl][PARTITION_NONE];
+ chosen_rdc.rate += x->partition_cost[pl][PARTITION_NONE];
#if CONFIG_SUPERTX
- chosen_rate_nocoef += cpi->partition_cost[pl][PARTITION_SPLIT];
+ chosen_rate_nocoef += x->partition_cost[pl][PARTITION_SPLIT];
#endif
}
if (chosen_rdc.rate < INT_MAX) {
- chosen_rdc.rate += cpi->partition_cost[pl][PARTITION_SPLIT];
+ chosen_rdc.rate += x->partition_cost[pl][PARTITION_SPLIT];
chosen_rdc.rdcost = RDCOST(x->rdmult, chosen_rdc.rate, chosen_rdc.dist);
#if CONFIG_SUPERTX
- chosen_rate_nocoef += cpi->partition_cost[pl][PARTITION_NONE];
+ chosen_rate_nocoef += x->partition_cost[pl][PARTITION_NONE];
#endif
}
}
@@ -3267,10 +3267,10 @@
has_rows, has_cols,
#endif
bsize);
- sum_rdc.rate += cpi->partition_cost[pl][partition];
+ sum_rdc.rate += x->partition_cost[pl][partition];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
#if CONFIG_SUPERTX
- sum_rate_nocoef += cpi->partition_cost[pl][partition];
+ sum_rate_nocoef += x->partition_cost[pl][partition];
#endif
if (sum_rdc.rdcost < best_rdc->rdcost) {
#if CONFIG_SUPERTX
@@ -3333,7 +3333,7 @@
#endif
bsize);
#endif // CONFIG_CB4X4
- const int *partition_cost = cpi->partition_cost[pl];
+ const int *partition_cost = x->partition_cost[pl];
#if CONFIG_SUPERTX
int this_rate_nocoef, sum_rate_nocoef = 0, best_rate_nocoef = INT_MAX;
int abort_flag;
@@ -4481,6 +4481,7 @@
// Initialize the left context for the new SB row
av1_zero_left_context(xd);
+ av1_fill_mode_rates(cm, x, xd->tile_ctx);
#if CONFIG_DELTA_Q
// Reset delta for every tile
@@ -6004,7 +6005,7 @@
if (bsize >= BLOCK_8X8 && !dry_run) {
for (plane = 0; plane <= 1; ++plane) {
if (mbmi->palette_mode_info.palette_size[plane] > 0)
- av1_tokenize_palette_sb(cpi, td, plane, t, dry_run, bsize, rate);
+ av1_tokenize_palette_sb(td, plane, t, dry_run, bsize, rate);
}
}
#endif // CONFIG_PALETTE
@@ -7258,12 +7259,12 @@
!xd->lossless[xd->mi[0]->mbmi.segment_id] && this_rate != INT_MAX) {
if (ext_tx_set > 0)
this_rate +=
- cpi->inter_tx_type_costs[ext_tx_set][mbmi->tx_size][mbmi->tx_type];
+ x->inter_tx_type_costs[ext_tx_set][mbmi->tx_size][mbmi->tx_type];
}
#else
if (tx_size < TX_32X32 && !xd->lossless[xd->mi[0]->mbmi.segment_id] &&
this_rate != INT_MAX) {
- this_rate += cpi->inter_tx_type_costs[tx_size][mbmi->tx_type];
+ this_rate += x->inter_tx_type_costs[tx_size][mbmi->tx_type];
}
#endif // CONFIG_EXT_TX
*tmp_rate = rate_uv + this_rate;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 9b98975..c3730f3 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -441,6 +441,11 @@
CODING_CONTEXT coding_context;
+#if CONFIG_GLOBAL_MOTION
+ int gmtype_cost[TRANS_TYPES];
+ int gmparams_cost[TOTAL_REFS_PER_FRAME];
+#endif // CONFIG_GLOBAL_MOTION
+
int nmv_costs[NMV_CONTEXTS][2][MV_VALS];
int nmv_costs_hp[NMV_CONTEXTS][2][MV_VALS];
@@ -538,73 +543,6 @@
search_site_config ss_cfg;
- int mbmode_cost[BLOCK_SIZE_GROUPS][INTRA_MODES];
- int newmv_mode_cost[NEWMV_MODE_CONTEXTS][2];
- int zeromv_mode_cost[ZEROMV_MODE_CONTEXTS][2];
- int refmv_mode_cost[REFMV_MODE_CONTEXTS][2];
- int drl_mode_cost0[DRL_MODE_CONTEXTS][2];
-
- unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
-#if CONFIG_EXT_INTER
- unsigned int inter_compound_mode_cost[INTER_MODE_CONTEXTS]
- [INTER_COMPOUND_MODES];
-#if CONFIG_COMPOUND_SINGLEREF
- unsigned int inter_singleref_comp_mode_cost[INTER_MODE_CONTEXTS]
- [INTER_SINGLEREF_COMP_MODES];
-#endif // CONFIG_COMPOUND_SINGLEREF
-#if CONFIG_INTERINTRA
- unsigned int interintra_mode_cost[BLOCK_SIZE_GROUPS][INTERINTRA_MODES];
-#endif // CONFIG_INTERINTRA
-#endif // CONFIG_EXT_INTER
-#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
- int motion_mode_cost[BLOCK_SIZES_ALL][MOTION_MODES];
-#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
- int motion_mode_cost1[BLOCK_SIZES_ALL][2];
-#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
-#if CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
- int ncobmc_mode_cost[ADAPT_OVERLAP_BLOCKS][MAX_NCOBMC_MODES];
-#endif // CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
-#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
- int intra_uv_mode_cost[INTRA_MODES][UV_INTRA_MODES];
- int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
- int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
-#if CONFIG_EXT_PARTITION_TYPES
- int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
- [EXT_PARTITION_TYPES];
-#else
- int partition_cost[PARTITION_CONTEXTS + CONFIG_UNPOISON_PARTITION_CTX]
- [PARTITION_TYPES];
-#endif
-#if CONFIG_PALETTE
- int palette_y_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
- int palette_uv_size_cost[PALETTE_BLOCK_SIZES][PALETTE_SIZES];
- int palette_y_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
- [PALETTE_COLORS];
- int palette_uv_color_cost[PALETTE_SIZES][PALETTE_COLOR_INDEX_CONTEXTS]
- [PALETTE_COLORS];
-#endif // CONFIG_PALETTE
- int tx_size_cost[TX_SIZES - 1][TX_SIZE_CONTEXTS][TX_SIZES];
-#if CONFIG_EXT_TX
- int inter_tx_type_costs[EXT_TX_SETS_INTER][EXT_TX_SIZES][TX_TYPES];
- int intra_tx_type_costs[EXT_TX_SETS_INTRA][EXT_TX_SIZES][INTRA_MODES]
- [TX_TYPES];
-#else
- int intra_tx_type_costs[EXT_TX_SIZES][TX_TYPES][TX_TYPES];
- int inter_tx_type_costs[EXT_TX_SIZES][TX_TYPES];
-#endif // CONFIG_EXT_TX
-#if CONFIG_EXT_INTRA
-#if CONFIG_INTRA_INTERP
- int intra_filter_cost[INTRA_FILTERS + 1][INTRA_FILTERS];
-#endif // CONFIG_INTRA_INTERP
-#endif // CONFIG_EXT_INTRA
-#if CONFIG_LOOP_RESTORATION
- int switchable_restore_cost[RESTORE_SWITCHABLE_TYPES];
-#endif // CONFIG_LOOP_RESTORATION
-#if CONFIG_GLOBAL_MOTION
- int gmtype_cost[TRANS_TYPES];
- int gmparams_cost[TOTAL_REFS_PER_FRAME];
-#endif // CONFIG_GLOBAL_MOTION
-
int multi_arf_allowed;
int multi_arf_enabled;
int multi_arf_last_grp_enabled;
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 3aa4c18..4547e15 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -325,7 +325,7 @@
cost = av1_cost_bit(xd->fc->txb_skip[txs_ctx][txb_skip_ctx], 0);
#if CONFIG_TXK_SEL
- cost += av1_tx_type_cost(cpi, xd, mbmi->sb_type, plane, tx_size, tx_type);
+ cost += av1_tx_type_cost(cm, x, xd, mbmi->sb_type, plane, tx_size, tx_type);
#endif
for (c = 0; c < eob; ++c) {
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index fec6837..8863942 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -1196,7 +1196,7 @@
cost_switchable = RDCOST_DBL(x->rdmult, bits >> 4, 0);
for (tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
double best_cost =
- RDCOST_DBL(x->rdmult, (cpi->switchable_restore_cost[RESTORE_NONE] >> 4),
+ RDCOST_DBL(x->rdmult, (x->switchable_restore_cost[RESTORE_NONE] >> 4),
tile_cost[RESTORE_NONE][tile_idx]);
rsi->restoration_type[tile_idx] = RESTORE_NONE;
for (r = 1; r < RESTORE_SWITCHABLE_TYPES; r++) {
@@ -1211,7 +1211,7 @@
tilebits +=
count_sgrproj_bits(&rsi->sgrproj_info[tile_idx], &ref_sgrproj_info);
tilebits <<= AV1_PROB_COST_SHIFT;
- tilebits += cpi->switchable_restore_cost[r];
+ tilebits += x->switchable_restore_cost[r];
double cost =
RDCOST_DBL(x->rdmult, tilebits >> 4, tile_cost[r][tile_idx]);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 32f164b..2260877 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -61,17 +61,54 @@
4, 4, 8, 8
};
-static void fill_mode_costs(AV1_COMP *cpi) {
- const FRAME_CONTEXT *const fc = cpi->common.fc;
+void av1_fill_mode_rates(AV1_COMMON *const cm, MACROBLOCK *x,
+ FRAME_CONTEXT *fc) {
int i, j;
+ if (cm->frame_type == KEY_FRAME) {
+#if CONFIG_EXT_PARTITION_TYPES
+ for (i = 0; i < PARTITION_PLOFFSET; ++i)
+ av1_cost_tokens(x->partition_cost[i], fc->partition_prob[i],
+ av1_partition_tree);
+ for (; i < PARTITION_CONTEXTS_PRIMARY; ++i)
+ av1_cost_tokens(x->partition_cost[i], fc->partition_prob[i],
+ av1_ext_partition_tree);
+#else
+ for (i = 0; i < PARTITION_CONTEXTS_PRIMARY; ++i)
+ av1_cost_tokens(x->partition_cost[i], fc->partition_prob[i],
+ av1_partition_tree);
+#endif // CONFIG_EXT_PARTITION_TYPES
+#if CONFIG_UNPOISON_PARTITION_CTX
+ for (; i < PARTITION_CONTEXTS_PRIMARY + PARTITION_BLOCK_SIZES; ++i) {
+ aom_prob p = fc->partition_prob[i][PARTITION_VERT];
+ assert(p > 0);
+ x->partition_cost[i][PARTITION_NONE] = INT_MAX;
+ x->partition_cost[i][PARTITION_HORZ] = INT_MAX;
+ x->partition_cost[i][PARTITION_VERT] = av1_cost_bit(p, 0);
+ x->partition_cost[i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
+ }
+ for (; i < PARTITION_CONTEXTS_PRIMARY + 2 * PARTITION_BLOCK_SIZES; ++i) {
+ aom_prob p = fc->partition_prob[i][PARTITION_HORZ];
+ assert(p > 0);
+ x->partition_cost[i][PARTITION_NONE] = INT_MAX;
+ x->partition_cost[i][PARTITION_HORZ] = av1_cost_bit(p, 0);
+ x->partition_cost[i][PARTITION_VERT] = INT_MAX;
+ x->partition_cost[i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
+ }
+ x->partition_cost[PARTITION_CONTEXTS][PARTITION_NONE] = INT_MAX;
+ x->partition_cost[PARTITION_CONTEXTS][PARTITION_HORZ] = INT_MAX;
+ x->partition_cost[PARTITION_CONTEXTS][PARTITION_VERT] = INT_MAX;
+ x->partition_cost[PARTITION_CONTEXTS][PARTITION_SPLIT] = 0;
+#endif // CONFIG_UNPOISON_PARTITION_CTX
+ }
+
for (i = 0; i < INTRA_MODES; ++i)
for (j = 0; j < INTRA_MODES; ++j)
- av1_cost_tokens_from_cdf(cpi->y_mode_costs[i][j], av1_kf_y_mode_cdf[i][j],
+ av1_cost_tokens_from_cdf(x->y_mode_costs[i][j], av1_kf_y_mode_cdf[i][j],
av1_intra_mode_inv);
for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
- av1_cost_tokens_from_cdf(cpi->mbmode_cost[i], fc->y_mode_cdf[i],
+ av1_cost_tokens_from_cdf(x->mbmode_cost[i], fc->y_mode_cdf[i],
av1_intra_mode_inv);
const int *uv_mode_inv_map =
#if CONFIG_CFL
@@ -81,26 +118,26 @@
av1_intra_mode_inv;
#endif
for (i = 0; i < INTRA_MODES; ++i)
- av1_cost_tokens_from_cdf(cpi->intra_uv_mode_cost[i], fc->uv_mode_cdf[i],
+ av1_cost_tokens_from_cdf(x->intra_uv_mode_cost[i], fc->uv_mode_cdf[i],
uv_mode_inv_map);
for (i = 0; i < SWITCHABLE_FILTER_CONTEXTS; ++i)
- av1_cost_tokens(cpi->switchable_interp_costs[i],
+ av1_cost_tokens(x->switchable_interp_costs[i],
fc->switchable_interp_prob[i], av1_switchable_interp_tree);
#if CONFIG_PALETTE
for (i = 0; i < PALETTE_BLOCK_SIZES; ++i) {
- av1_cost_tokens_from_cdf(cpi->palette_y_size_cost[i],
+ av1_cost_tokens_from_cdf(x->palette_y_size_cost[i],
fc->palette_y_size_cdf[i], NULL);
- av1_cost_tokens_from_cdf(cpi->palette_uv_size_cost[i],
+ av1_cost_tokens_from_cdf(x->palette_uv_size_cost[i],
fc->palette_uv_size_cdf[i], NULL);
}
for (i = 0; i < PALETTE_SIZES; ++i) {
for (j = 0; j < PALETTE_COLOR_INDEX_CONTEXTS; ++j) {
- av1_cost_tokens_from_cdf(cpi->palette_y_color_cost[i][j],
+ av1_cost_tokens_from_cdf(x->palette_y_color_cost[i][j],
fc->palette_y_color_index_cdf[i][j], NULL);
- av1_cost_tokens_from_cdf(cpi->palette_uv_color_cost[i][j],
+ av1_cost_tokens_from_cdf(x->palette_uv_color_cost[i][j],
fc->palette_uv_color_index_cdf[i][j], NULL);
}
}
@@ -108,7 +145,7 @@
for (i = 0; i < MAX_TX_DEPTH; ++i)
for (j = 0; j < TX_SIZE_CONTEXTS; ++j)
- av1_cost_tokens(cpi->tx_size_cost[i][j], fc->tx_size_probs[i][j],
+ av1_cost_tokens(x->tx_size_cost[i][j], fc->tx_size_probs[i][j],
av1_tx_size_tree[i]);
#if CONFIG_EXT_TX
@@ -116,14 +153,14 @@
int s;
for (s = 1; s < EXT_TX_SETS_INTER; ++s) {
if (use_inter_ext_tx_for_txsize[s][i]) {
- av1_cost_tokens(cpi->inter_tx_type_costs[s][i],
+ av1_cost_tokens(x->inter_tx_type_costs[s][i],
fc->inter_ext_tx_prob[s][i], av1_ext_tx_inter_tree[s]);
}
}
for (s = 1; s < EXT_TX_SETS_INTRA; ++s) {
if (use_intra_ext_tx_for_txsize[s][i]) {
for (j = 0; j < INTRA_MODES; ++j)
- av1_cost_tokens(cpi->intra_tx_type_costs[s][i][j],
+ av1_cost_tokens(x->intra_tx_type_costs[s][i][j],
fc->intra_ext_tx_prob[s][i][j],
av1_ext_tx_intra_tree[s]);
}
@@ -132,30 +169,82 @@
#else
for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
for (j = 0; j < TX_TYPES; ++j)
- av1_cost_tokens(cpi->intra_tx_type_costs[i][j],
- fc->intra_ext_tx_prob[i][j], av1_ext_tx_tree);
+ av1_cost_tokens(x->intra_tx_type_costs[i][j], fc->intra_ext_tx_prob[i][j],
+ av1_ext_tx_tree);
}
for (i = TX_4X4; i < EXT_TX_SIZES; ++i) {
- av1_cost_tokens(cpi->inter_tx_type_costs[i], fc->inter_ext_tx_prob[i],
+ av1_cost_tokens(x->inter_tx_type_costs[i], fc->inter_ext_tx_prob[i],
av1_ext_tx_tree);
}
#endif // CONFIG_EXT_TX
#if CONFIG_EXT_INTRA
#if CONFIG_INTRA_INTERP
for (i = 0; i < INTRA_FILTERS + 1; ++i)
- av1_cost_tokens(cpi->intra_filter_cost[i], fc->intra_filter_probs[i],
+ av1_cost_tokens(x->intra_filter_cost[i], fc->intra_filter_probs[i],
av1_intra_filter_tree);
#endif // CONFIG_INTRA_INTERP
#endif // CONFIG_EXT_INTRA
#if CONFIG_LOOP_RESTORATION
- av1_cost_tokens(cpi->switchable_restore_cost, fc->switchable_restore_prob,
+ av1_cost_tokens(x->switchable_restore_cost, fc->switchable_restore_prob,
av1_switchable_restore_tree);
#endif // CONFIG_LOOP_RESTORATION
-#if CONFIG_GLOBAL_MOTION
- for (i = 0; i < TRANS_TYPES; ++i)
- cpi->gmtype_cost[i] = (1 + (i > 0 ? GLOBAL_TYPE_BITS : 0))
- << AV1_PROB_COST_SHIFT;
-#endif // CONFIG_GLOBAL_MOTION
+
+ if (!frame_is_intra_only(cm)) {
+ for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) {
+ x->newmv_mode_cost[i][0] = av1_cost_bit(fc->newmv_prob[i], 0);
+ x->newmv_mode_cost[i][1] = av1_cost_bit(fc->newmv_prob[i], 1);
+ }
+
+ for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) {
+ x->zeromv_mode_cost[i][0] = av1_cost_bit(fc->zeromv_prob[i], 0);
+ x->zeromv_mode_cost[i][1] = av1_cost_bit(fc->zeromv_prob[i], 1);
+ }
+
+ for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) {
+ x->refmv_mode_cost[i][0] = av1_cost_bit(fc->refmv_prob[i], 0);
+ x->refmv_mode_cost[i][1] = av1_cost_bit(fc->refmv_prob[i], 1);
+ }
+
+ for (i = 0; i < DRL_MODE_CONTEXTS; ++i) {
+ x->drl_mode_cost0[i][0] = av1_cost_bit(fc->drl_prob[i], 0);
+ x->drl_mode_cost0[i][1] = av1_cost_bit(fc->drl_prob[i], 1);
+ }
+#if CONFIG_EXT_INTER
+ for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
+ av1_cost_tokens(x->inter_compound_mode_cost[i],
+ fc->inter_compound_mode_probs[i],
+ av1_inter_compound_mode_tree);
+#if CONFIG_COMPOUND_SINGLEREF
+ for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
+ av1_cost_tokens(x->inter_singleref_comp_mode_cost[i],
+ fc->inter_singleref_comp_mode_probs[i],
+ av1_inter_singleref_comp_mode_tree);
+#endif // CONFIG_COMPOUND_SINGLEREF
+#if CONFIG_INTERINTRA
+ for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
+ av1_cost_tokens(x->interintra_mode_cost[i], fc->interintra_mode_prob[i],
+ av1_interintra_mode_tree);
+#endif // CONFIG_INTERINTRA
+#endif // CONFIG_EXT_INTER
+#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
+ for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
+ av1_cost_tokens(x->motion_mode_cost[i], fc->motion_mode_prob[i],
+ av1_motion_mode_tree);
+ }
+#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
+ for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
+ x->motion_mode_cost1[i][0] = av1_cost_bit(fc->obmc_prob[i], 0);
+ x->motion_mode_cost1[i][1] = av1_cost_bit(fc->obmc_prob[i], 1);
+ }
+#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
+#if CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
+ for (i = ADAPT_OVERLAP_BLOCK_8X8; i < ADAPT_OVERLAP_BLOCKS; ++i) {
+ av1_cost_tokens(x->ncobmc_mode_cost[i], fc->ncobmc_mode_prob[i],
+ av1_ncobmc_mode_tree);
+ }
+#endif // CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
+#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
+ }
}
void av1_fill_token_costs(av1_coeff_cost *c,
@@ -384,103 +473,11 @@
if (cpi->oxcf.pass != 1) {
av1_fill_token_costs(x->token_costs, cm->fc->coef_probs);
-
- if (cm->frame_type == KEY_FRAME) {
-#if CONFIG_EXT_PARTITION_TYPES
- for (i = 0; i < PARTITION_PLOFFSET; ++i)
- av1_cost_tokens(cpi->partition_cost[i], cm->fc->partition_prob[i],
- av1_partition_tree);
- for (; i < PARTITION_CONTEXTS_PRIMARY; ++i)
- av1_cost_tokens(cpi->partition_cost[i], cm->fc->partition_prob[i],
- av1_ext_partition_tree);
-#else
- for (i = 0; i < PARTITION_CONTEXTS_PRIMARY; ++i)
- av1_cost_tokens(cpi->partition_cost[i], cm->fc->partition_prob[i],
- av1_partition_tree);
-#endif // CONFIG_EXT_PARTITION_TYPES
-#if CONFIG_UNPOISON_PARTITION_CTX
- for (; i < PARTITION_CONTEXTS_PRIMARY + PARTITION_BLOCK_SIZES; ++i) {
- aom_prob p = cm->fc->partition_prob[i][PARTITION_VERT];
- assert(p > 0);
- cpi->partition_cost[i][PARTITION_NONE] = INT_MAX;
- cpi->partition_cost[i][PARTITION_HORZ] = INT_MAX;
- cpi->partition_cost[i][PARTITION_VERT] = av1_cost_bit(p, 0);
- cpi->partition_cost[i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
- }
- for (; i < PARTITION_CONTEXTS_PRIMARY + 2 * PARTITION_BLOCK_SIZES; ++i) {
- aom_prob p = cm->fc->partition_prob[i][PARTITION_HORZ];
- assert(p > 0);
- cpi->partition_cost[i][PARTITION_NONE] = INT_MAX;
- cpi->partition_cost[i][PARTITION_HORZ] = av1_cost_bit(p, 0);
- cpi->partition_cost[i][PARTITION_VERT] = INT_MAX;
- cpi->partition_cost[i][PARTITION_SPLIT] = av1_cost_bit(p, 1);
- }
- cpi->partition_cost[PARTITION_CONTEXTS][PARTITION_NONE] = INT_MAX;
- cpi->partition_cost[PARTITION_CONTEXTS][PARTITION_HORZ] = INT_MAX;
- cpi->partition_cost[PARTITION_CONTEXTS][PARTITION_VERT] = INT_MAX;
- cpi->partition_cost[PARTITION_CONTEXTS][PARTITION_SPLIT] = 0;
-#endif // CONFIG_UNPOISON_PARTITION_CTX
- }
-
- fill_mode_costs(cpi);
-
- if (!frame_is_intra_only(cm)) {
- for (i = 0; i < NEWMV_MODE_CONTEXTS; ++i) {
- cpi->newmv_mode_cost[i][0] = av1_cost_bit(cm->fc->newmv_prob[i], 0);
- cpi->newmv_mode_cost[i][1] = av1_cost_bit(cm->fc->newmv_prob[i], 1);
- }
-
- for (i = 0; i < ZEROMV_MODE_CONTEXTS; ++i) {
- cpi->zeromv_mode_cost[i][0] = av1_cost_bit(cm->fc->zeromv_prob[i], 0);
- cpi->zeromv_mode_cost[i][1] = av1_cost_bit(cm->fc->zeromv_prob[i], 1);
- }
-
- for (i = 0; i < REFMV_MODE_CONTEXTS; ++i) {
- cpi->refmv_mode_cost[i][0] = av1_cost_bit(cm->fc->refmv_prob[i], 0);
- cpi->refmv_mode_cost[i][1] = av1_cost_bit(cm->fc->refmv_prob[i], 1);
- }
-
- for (i = 0; i < DRL_MODE_CONTEXTS; ++i) {
- cpi->drl_mode_cost0[i][0] = av1_cost_bit(cm->fc->drl_prob[i], 0);
- cpi->drl_mode_cost0[i][1] = av1_cost_bit(cm->fc->drl_prob[i], 1);
- }
-#if CONFIG_EXT_INTER
- for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
- av1_cost_tokens((int *)cpi->inter_compound_mode_cost[i],
- cm->fc->inter_compound_mode_probs[i],
- av1_inter_compound_mode_tree);
-#if CONFIG_COMPOUND_SINGLEREF
- for (i = 0; i < INTER_MODE_CONTEXTS; ++i)
- av1_cost_tokens((int *)cpi->inter_singleref_comp_mode_cost[i],
- cm->fc->inter_singleref_comp_mode_probs[i],
- av1_inter_singleref_comp_mode_tree);
-#endif // CONFIG_COMPOUND_SINGLEREF
-#if CONFIG_INTERINTRA
- for (i = 0; i < BLOCK_SIZE_GROUPS; ++i)
- av1_cost_tokens((int *)cpi->interintra_mode_cost[i],
- cm->fc->interintra_mode_prob[i],
- av1_interintra_mode_tree);
-#endif // CONFIG_INTERINTRA
-#endif // CONFIG_EXT_INTER
-#if CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
- for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
- av1_cost_tokens_from_cdf(cpi->motion_mode_cost[i],
- cm->fc->motion_mode_cdf[i], NULL);
- }
-#if CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
- for (i = BLOCK_8X8; i < BLOCK_SIZES_ALL; i++) {
- cpi->motion_mode_cost1[i][0] = av1_cost_bit(cm->fc->obmc_prob[i], 0);
- cpi->motion_mode_cost1[i][1] = av1_cost_bit(cm->fc->obmc_prob[i], 1);
- }
-#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
-#if CONFIG_MOTION_VAR && CONFIG_NCOBMC_ADAPT_WEIGHT
- for (i = ADAPT_OVERLAP_BLOCK_8X8; i < ADAPT_OVERLAP_BLOCKS; ++i) {
- av1_cost_tokens((int *)cpi->ncobmc_mode_cost[i],
- cm->fc->ncobmc_mode_prob[i], av1_ncobmc_mode_tree);
- }
-#endif
-#endif // CONFIG_MOTION_VAR || CONFIG_WARPED_MOTION
- }
+#if CONFIG_GLOBAL_MOTION
+ for (i = 0; i < TRANS_TYPES; ++i)
+ cpi->gmtype_cost[i] = (1 + (i > 0 ? GLOBAL_TYPE_BITS : 0))
+ << AV1_PROB_COST_SHIFT;
+#endif // CONFIG_GLOBAL_MOTION
}
}
@@ -915,8 +912,8 @@
}
#if CONFIG_DUAL_FILTER
-int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
- const AV1_COMMON *const cm = &cpi->common;
+int av1_get_switchable_rate(const AV1_COMMON *const cm, MACROBLOCK *x,
+ const MACROBLOCKD *xd) {
if (cm->interp_filter == SWITCHABLE) {
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
int inter_filter_cost = 0;
@@ -928,7 +925,7 @@
has_subpel_mv_component(xd->mi[0], xd, dir + 2))) {
const int ctx = av1_get_pred_context_switchable_interp(xd, dir);
inter_filter_cost +=
- cpi->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
+ x->switchable_interp_costs[ctx][mbmi->interp_filter[dir]];
}
}
return SWITCHABLE_INTERP_RATE_FACTOR * inter_filter_cost;
@@ -937,13 +934,13 @@
}
}
#else
-int av1_get_switchable_rate(const AV1_COMP *cpi, const MACROBLOCKD *xd) {
- const AV1_COMMON *const cm = &cpi->common;
+int av1_get_switchable_rate(const AV1_COMMON *const cm, MACROBLOCK *x,
+ const MACROBLOCKD *xd) {
if (cm->interp_filter == SWITCHABLE) {
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
const int ctx = av1_get_pred_context_switchable_interp(xd);
return SWITCHABLE_INTERP_RATE_FACTOR *
- cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
+ x->switchable_interp_costs[ctx][mbmi->interp_filter];
}
return 0;
}
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index 531d684..07f0dfc 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -557,7 +557,8 @@
void av1_model_rd_from_var_lapndz(int64_t var, unsigned int n,
unsigned int qstep, int *rate, int64_t *dist);
-int av1_get_switchable_rate(const struct AV1_COMP *cpi, const MACROBLOCKD *xd);
+int av1_get_switchable_rate(const AV1_COMMON *const cm, MACROBLOCK *x,
+ const MACROBLOCKD *xd);
int av1_raster_block_offset(BLOCK_SIZE plane_bsize, int raster_block,
int stride);
@@ -612,6 +613,9 @@
int av1_get_intra_cost_penalty(int qindex, int qdelta,
aom_bit_depth_t bit_depth);
+void av1_fill_mode_rates(AV1_COMMON *const cm, MACROBLOCK *x,
+ FRAME_CONTEXT *fc);
+
#ifdef __cplusplus
} // extern "C"
#endif
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index e846ae6..5c8dc4e 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2198,7 +2198,7 @@
const TX_SIZE coded_tx_size = txsize_sqr_up_map[tx_size];
const int depth = tx_size_to_depth(coded_tx_size);
const int tx_size_ctx = get_tx_size_context(xd);
- int r_tx_size = cpi->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
+ int r_tx_size = x->tx_size_cost[tx_size_cat][tx_size_ctx][depth];
#if CONFIG_RECT_TX_EXT && (CONFIG_EXT_TX || CONFIG_VAR_TX)
if (is_quarter_tx_allowed(xd, mbmi, is_inter) && tx_size != coded_tx_size)
r_tx_size += av1_cost_bit(cm->fc->quarter_tx_size_prob,
@@ -2211,9 +2211,9 @@
}
// #TODO(angiebird): use this function whenever it's possible
-int av1_tx_type_cost(const AV1_COMP *cpi, const MACROBLOCKD *xd,
- BLOCK_SIZE bsize, int plane, TX_SIZE tx_size,
- TX_TYPE tx_type) {
+int av1_tx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
+ const MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane,
+ TX_SIZE tx_size, TX_TYPE tx_type) {
if (plane > 0) return 0;
#if CONFIG_VAR_TX
@@ -2223,31 +2223,31 @@
const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
const int is_inter = is_inter_block(mbmi);
#if CONFIG_EXT_TX
- const AV1_COMMON *cm = &cpi->common;
if (get_ext_tx_types(tx_size, bsize, is_inter, cm->reduced_tx_set_used) > 1 &&
!xd->lossless[xd->mi[0]->mbmi.segment_id]) {
const int ext_tx_set =
get_ext_tx_set(tx_size, bsize, is_inter, cm->reduced_tx_set_used);
if (is_inter) {
if (ext_tx_set > 0)
- return cpi
+ return x
->inter_tx_type_costs[ext_tx_set][txsize_sqr_map[tx_size]][tx_type];
} else {
if (ext_tx_set > 0 && ALLOW_INTRA_EXT_TX)
- return cpi->intra_tx_type_costs[ext_tx_set][txsize_sqr_map[tx_size]]
- [mbmi->mode][tx_type];
+ return x->intra_tx_type_costs[ext_tx_set][txsize_sqr_map[tx_size]]
+ [mbmi->mode][tx_type];
}
}
#else
(void)bsize;
+ (void)cm;
if (tx_size < TX_32X32 && !xd->lossless[xd->mi[0]->mbmi.segment_id] &&
!FIXED_TX_TYPE) {
if (is_inter) {
- return cpi->inter_tx_type_costs[tx_size][tx_type];
+ return x->inter_tx_type_costs[tx_size][tx_type];
} else {
- return cpi->intra_tx_type_costs[tx_size]
- [intra_mode_to_tx_type_context[mbmi->mode]]
- [tx_type];
+ return x->intra_tx_type_costs[tx_size]
+ [intra_mode_to_tx_type_context[mbmi->mode]]
+ [tx_type];
}
}
#endif // CONFIG_EXT_TX
@@ -2286,7 +2286,7 @@
if (rd_stats->rate == INT_MAX) return INT64_MAX;
#if !CONFIG_TXK_SEL
int plane = 0;
- rd_stats->rate += av1_tx_type_cost(cpi, xd, bs, plane, tx_size, tx_type);
+ rd_stats->rate += av1_tx_type_cost(cm, x, xd, bs, plane, tx_size, tx_type);
#endif
if (rd_stats->skip) {
@@ -2449,7 +2449,7 @@
od_encode_rollback(&x->daala_enc, &pre_buf);
#endif // CONFIG_PVQ
if (this_rd_stats.rate == INT_MAX) continue;
- av1_tx_type_cost(cpi, xd, bs, plane, mbmi->tx_size, tx_type);
+ av1_tx_type_cost(cm, x, xd, bs, plane, mbmi->tx_size, tx_type);
if (this_rd_stats.skip)
this_rd = RDCOST(x->rdmult, s1, this_rd_stats.sse);
@@ -2492,7 +2492,7 @@
mbmi->tx_size, cpi->sf.use_fast_coef_costing);
if (this_rd_stats.rate == INT_MAX) continue;
- av1_tx_type_cost(cpi, xd, bs, plane, mbmi->tx_size, tx_type);
+ av1_tx_type_cost(cm, x, xd, bs, plane, mbmi->tx_size, tx_type);
if (is_inter) {
if (cpi->sf.tx_type_search.prune_mode > NO_PRUNE &&
!do_tx_type_search(tx_type, prune))
@@ -3006,7 +3006,7 @@
block_height);
palette_mode_cost =
dc_mode_cost +
- cpi->palette_y_size_cost[bsize - BLOCK_8X8][k - PALETTE_MIN_SIZE] +
+ x->palette_y_size_cost[bsize - BLOCK_8X8][k - PALETTE_MIN_SIZE] +
write_uniform_cost(k, color_map[0]) +
av1_cost_bit(
av1_default_palette_y_mode_prob[bsize - BLOCK_8X8][palette_ctx],
@@ -3022,8 +3022,8 @@
const int color_ctx = av1_get_palette_color_index_context(
color_map, block_width, i, j, k, color_order, &color_idx);
assert(color_idx >= 0 && color_idx < k);
- palette_mode_cost += cpi->palette_y_color_cost[k - PALETTE_MIN_SIZE]
- [color_ctx][color_idx];
+ palette_mode_cost += x->palette_y_color_cost[k - PALETTE_MIN_SIZE]
+ [color_ctx][color_idx];
}
}
this_model_rd = intra_model_yrd(cpi, x, bsize, palette_mode_cost);
@@ -3552,7 +3552,7 @@
int64_t total_distortion = 0;
int tot_rate_y = 0;
int64_t total_rd = 0;
- const int *bmode_costs = cpi->mbmode_cost[0];
+ const int *bmode_costs = mb->mbmode_cost[0];
const int is_lossless = xd->lossless[mbmi->segment_id];
#if CONFIG_EXT_TX && CONFIG_RECT_TX
const TX_SIZE tx_size = is_lossless ? TX_4X4 : max_txsize_rect_lookup[bsize];
@@ -3591,7 +3591,7 @@
const PREDICTION_MODE L =
av1_left_block_mode(mic, left_mi, pred_block_idx);
- bmode_costs = cpi->y_mode_costs[A][L];
+ bmode_costs = mb->y_mode_costs[A][L];
}
this_rd = rd_pick_intra_sub_8x8_y_subblock_mode(
cpi, mb, idy, idx, &best_mode, bmode_costs,
@@ -3642,14 +3642,14 @@
1) {
const int eset =
get_ext_tx_set(tx_size, bsize, 0, cpi->common.reduced_tx_set_used);
- rate_tx_type = cpi->intra_tx_type_costs[eset][txsize_sqr_map[tx_size]]
- [mbmi->mode][mbmi->tx_type];
+ rate_tx_type = mb->intra_tx_type_costs[eset][txsize_sqr_map[tx_size]]
+ [mbmi->mode][mbmi->tx_type];
}
#else
rate_tx_type =
- cpi->intra_tx_type_costs[txsize_sqr_map[tx_size]]
- [intra_mode_to_tx_type_context[mbmi->mode]]
- [mbmi->tx_type];
+ mb->intra_tx_type_costs[txsize_sqr_map[tx_size]]
+ [intra_mode_to_tx_type_context[mbmi->mode]]
+ [mbmi->tx_type];
#endif // CONFIG_EXT_TX
assert(mbmi->tx_size == tx_size);
cost += rate_tx_type;
@@ -3818,7 +3818,7 @@
this_rd = calc_rd_given_intra_angle(
cpi, x, bsize,
#if CONFIG_INTRA_INTERP
- mode_cost + cpi->intra_filter_cost[intra_filter_ctx][filter],
+ mode_cost + x->intra_filter_cost[intra_filter_ctx][filter],
#else
mode_cost,
#endif // CONFIG_INTRA_INTERP
@@ -3859,7 +3859,7 @@
calc_rd_given_intra_angle(
cpi, x, bsize,
#if CONFIG_INTRA_INTERP
- mode_cost + cpi->intra_filter_cost[intra_filter_ctx][filter],
+ mode_cost + x->intra_filter_cost[intra_filter_ctx][filter],
#else
mode_cost,
#endif // CONFIG_INTRA_INTERP
@@ -3884,8 +3884,8 @@
mic->mbmi.intra_filter = filter;
this_rd = calc_rd_given_intra_angle(
cpi, x, bsize,
- mode_cost + cpi->intra_filter_cost[intra_filter_ctx][filter],
- best_rd, best_angle_delta, MAX_ANGLE_DELTA, rate, rd_stats,
+ mode_cost + x->intra_filter_cost[intra_filter_ctx][filter], best_rd,
+ best_angle_delta, MAX_ANGLE_DELTA, rate, rd_stats,
&best_angle_delta, &best_tx_size, &best_tx_type, &best_filter,
&best_rd, best_model_rd);
}
@@ -4093,7 +4093,7 @@
od_encode_checkpoint(&x->daala_enc, &pre_buf);
od_encode_checkpoint(&x->daala_enc, &post_buf);
#endif // CONFIG_PVQ
- bmode_costs = cpi->y_mode_costs[A][L];
+ bmode_costs = x->y_mode_costs[A][L];
#if CONFIG_EXT_INTRA
mbmi->angle_delta[0] = 0;
@@ -4193,8 +4193,7 @@
const int p_angle =
mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP;
if (av1_is_intra_filter_switchable(p_angle))
- this_rate +=
- cpi->intra_filter_cost[intra_filter_ctx][mbmi->intra_filter];
+ this_rate += x->intra_filter_cost[intra_filter_ctx][mbmi->intra_filter];
#endif // CONFIG_INTRA_INTERP
if (av1_use_angle_delta(bsize)) {
this_rate += write_uniform_cost(2 * MAX_ANGLE_DELTA + 1,
@@ -5017,14 +5016,13 @@
if (is_inter) {
if (ext_tx_set > 0)
rd_stats->rate +=
- cpi->inter_tx_type_costs[ext_tx_set]
- [txsize_sqr_map[mbmi->min_tx_size]]
- [mbmi->tx_type];
+ x->inter_tx_type_costs[ext_tx_set]
+ [txsize_sqr_map[mbmi->min_tx_size]]
+ [mbmi->tx_type];
} else {
if (ext_tx_set > 0 && ALLOW_INTRA_EXT_TX)
- rd_stats->rate +=
- cpi->intra_tx_type_costs[ext_tx_set][mbmi->min_tx_size][mbmi->mode]
- [mbmi->tx_type];
+ rd_stats->rate += x->intra_tx_type_costs[ext_tx_set][mbmi->min_tx_size]
+ [mbmi->mode][mbmi->tx_type];
}
}
#else
@@ -5435,7 +5433,7 @@
if (tokenonly_rd_stats.rate == INT_MAX) continue;
this_rate =
tokenonly_rd_stats.rate + dc_mode_cost +
- cpi->palette_uv_size_cost[bsize - BLOCK_8X8][n - PALETTE_MIN_SIZE] +
+ x->palette_uv_size_cost[bsize - BLOCK_8X8][n - PALETTE_MIN_SIZE] +
write_uniform_cost(n, color_map[0]) +
av1_cost_bit(
av1_default_palette_uv_mode_prob[pmi->palette_size[0] > 0], 1);
@@ -5450,8 +5448,8 @@
const int color_ctx = av1_get_palette_color_index_context(
color_map, plane_block_width, i, j, n, color_order, &color_idx);
assert(color_idx >= 0 && color_idx < n);
- this_rate += cpi->palette_uv_color_cost[n - PALETTE_MIN_SIZE]
- [color_ctx][color_idx];
+ this_rate += x->palette_uv_color_cost[n - PALETTE_MIN_SIZE][color_ctx]
+ [color_idx];
}
}
@@ -5505,7 +5503,7 @@
this_rate = tokenonly_rd_stats.rate +
av1_cost_bit(cpi->common.fc->filter_intra_probs[1], 1) +
- cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode] +
+ x->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode] +
write_uniform_cost(FILTER_INTRA_MODES, mode);
this_rd = RDCOST(x->rdmult, this_rate, tokenonly_rd_stats.dist);
if (this_rd < *best_rd) {
@@ -5840,7 +5838,7 @@
#if CONFIG_EXT_INTRA
mbmi->angle_delta[1] = 0;
if (is_directional_mode && av1_use_angle_delta(mbmi->sb_type)) {
- const int rate_overhead = cpi->intra_uv_mode_cost[mbmi->mode][mode] +
+ const int rate_overhead = x->intra_uv_mode_cost[mbmi->mode][mode] +
write_uniform_cost(2 * MAX_ANGLE_DELTA + 1, 0);
if (!rd_pick_intra_angle_sbuv(cpi, x, bsize, rate_overhead, best_rd,
&this_rate, &tokenonly_rd_stats))
@@ -5857,7 +5855,7 @@
}
#endif // CONFIG_EXT_INTRA
this_rate =
- tokenonly_rd_stats.rate + cpi->intra_uv_mode_cost[mbmi->mode][mode];
+ tokenonly_rd_stats.rate + x->intra_uv_mode_cost[mbmi->mode][mode];
#if CONFIG_CFL
if (mode == UV_CFL_PRED) {
@@ -5900,7 +5898,7 @@
if (cpi->common.allow_screen_content_tools && mbmi->sb_type >= BLOCK_8X8) {
uint8_t *best_palette_color_map = x->palette_buffer->best_palette_color_map;
rd_pick_palette_intra_sbuv(cpi, x,
- cpi->intra_uv_mode_cost[mbmi->mode][UV_DC_PRED],
+ x->intra_uv_mode_cost[mbmi->mode][UV_DC_PRED],
best_palette_color_map, &best_mbmi, &best_rd,
rate, rate_tokenonly, distortion, skippable);
}
@@ -5954,17 +5952,16 @@
*mode_uv = x->e_mbd.mi[0]->mbmi.uv_mode;
}
-static int cost_mv_ref(const AV1_COMP *const cpi, PREDICTION_MODE mode,
+static int cost_mv_ref(const MACROBLOCK *const x, PREDICTION_MODE mode,
int16_t mode_context) {
#if CONFIG_EXT_INTER
if (is_inter_compound_mode(mode)) {
- return cpi
+ return x
->inter_compound_mode_cost[mode_context][INTER_COMPOUND_OFFSET(mode)];
#if CONFIG_COMPOUND_SINGLEREF
} else if (is_inter_singleref_comp_mode(mode)) {
- return cpi
- ->inter_singleref_comp_mode_cost[mode_context]
- [INTER_SINGLEREF_COMP_OFFSET(mode)];
+ return x->inter_singleref_comp_mode_cost[mode_context]
+ [INTER_SINGLEREF_COMP_OFFSET(mode)];
#endif // CONFIG_COMPOUND_SINGLEREF
}
#endif
@@ -5976,26 +5973,26 @@
assert(is_inter_mode(mode));
if (mode == NEWMV) {
- mode_cost = cpi->newmv_mode_cost[mode_ctx][0];
+ mode_cost = x->newmv_mode_cost[mode_ctx][0];
return mode_cost;
} else {
- mode_cost = cpi->newmv_mode_cost[mode_ctx][1];
+ mode_cost = x->newmv_mode_cost[mode_ctx][1];
mode_ctx = (mode_context >> ZEROMV_OFFSET) & ZEROMV_CTX_MASK;
if (is_all_zero_mv) return mode_cost;
if (mode == ZEROMV) {
- mode_cost += cpi->zeromv_mode_cost[mode_ctx][0];
+ mode_cost += x->zeromv_mode_cost[mode_ctx][0];
return mode_cost;
} else {
- mode_cost += cpi->zeromv_mode_cost[mode_ctx][1];
+ mode_cost += x->zeromv_mode_cost[mode_ctx][1];
mode_ctx = (mode_context >> REFMV_OFFSET) & REFMV_CTX_MASK;
if (mode_context & (1 << SKIP_NEARESTMV_OFFSET)) mode_ctx = 6;
if (mode_context & (1 << SKIP_NEARMV_OFFSET)) mode_ctx = 7;
if (mode_context & (1 << SKIP_NEARESTMV_SUB8X8_OFFSET)) mode_ctx = 8;
- mode_cost += cpi->refmv_mode_cost[mode_ctx][mode != NEARESTMV];
+ mode_cost += x->refmv_mode_cost[mode_ctx][mode != NEARESTMV];
return mode_cost;
}
}
@@ -6073,7 +6070,8 @@
// Check if NEARESTMV/NEARMV/ZEROMV is the cheapest way encode zero motion.
// TODO(aconverse): Find out if this is still productive then clean up or remove
static int check_best_zero_mv(
- const AV1_COMP *const cpi, const int16_t mode_context[TOTAL_REFS_PER_FRAME],
+ const AV1_COMP *const cpi, const MACROBLOCK *const x,
+ const int16_t mode_context[TOTAL_REFS_PER_FRAME],
#if CONFIG_EXT_INTER
const int16_t compound_mode_context[TOTAL_REFS_PER_FRAME],
#endif // CONFIG_EXT_INTER
@@ -6111,9 +6109,9 @@
frame_mv[this_mode][ref_frames[1]].as_int == zeromv[1].as_int)) {
int16_t rfc =
av1_mode_context_analyzer(mode_context, ref_frames, bsize, block);
- int c1 = cost_mv_ref(cpi, NEARMV, rfc);
- int c2 = cost_mv_ref(cpi, NEARESTMV, rfc);
- int c3 = cost_mv_ref(cpi, ZEROMV, rfc);
+ int c1 = cost_mv_ref(x, NEARMV, rfc);
+ int c2 = cost_mv_ref(x, NEARESTMV, rfc);
+ int c3 = cost_mv_ref(x, ZEROMV, rfc);
if (this_mode == NEARMV) {
if (c1 > c3) return 0;
@@ -6140,9 +6138,9 @@
frame_mv[this_mode][ref_frames[0]].as_int == zeromv[0].as_int &&
frame_mv[this_mode][ref_frames[1]].as_int == zeromv[1].as_int) {
int16_t rfc = compound_mode_context[ref_frames[0]];
- int c2 = cost_mv_ref(cpi, NEAREST_NEARESTMV, rfc);
- int c3 = cost_mv_ref(cpi, ZERO_ZEROMV, rfc);
- int c5 = cost_mv_ref(cpi, NEAR_NEARMV, rfc);
+ int c2 = cost_mv_ref(x, NEAREST_NEARESTMV, rfc);
+ int c3 = cost_mv_ref(x, ZERO_ZEROMV, rfc);
+ int c5 = cost_mv_ref(x, NEAR_NEARMV, rfc);
if (this_mode == NEAREST_NEARESTMV) {
if (c2 > c3) return 0;
@@ -8190,7 +8188,7 @@
set_default_interp_filters(mbmi, assign_filter);
- *switchable_rate = av1_get_switchable_rate(cpi, xd);
+ *switchable_rate = av1_get_switchable_rate(cm, x, xd);
av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, orig_dst, bsize);
model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate, &tmp_dist,
skip_txfm_sb, skip_sse_sb);
@@ -8226,7 +8224,7 @@
#else
mbmi->interp_filter = (InterpFilter)i;
#endif // CONFIG_DUAL_FILTER
- tmp_rs = av1_get_switchable_rate(cpi, xd);
+ tmp_rs = av1_get_switchable_rate(cm, x, xd);
av1_build_inter_predictors_sb(cm, xd, mi_row, mi_col, orig_dst, bsize);
model_rd_for_sb(cpi, bsize, x, xd, 0, MAX_MB_PLANE - 1, &tmp_rate,
&tmp_dist, &tmp_skip_sb, &tmp_skip_sse);
@@ -8234,7 +8232,7 @@
if (tmp_rd < *rd) {
*rd = tmp_rd;
- *switchable_rate = av1_get_switchable_rate(cpi, xd);
+ *switchable_rate = av1_get_switchable_rate(cm, x, xd);
#if CONFIG_DUAL_FILTER
av1_copy(best_filter, mbmi->interp_filter);
#else
@@ -8547,7 +8545,7 @@
rd_stats->rate += x->motion_mode_cost[bsize][mbmi->motion_mode];
#if CONFIG_WARPED_MOTION && CONFIG_MOTION_VAR
else
- rd_stats->rate += cpi->motion_mode_cost1[bsize][mbmi->motion_mode];
+ rd_stats->rate += x->motion_mode_cost1[bsize][mbmi->motion_mode];
#endif // CONFIG_WARPED_MOTION && CONFIG_MOTION_VAR
}
#if CONFIG_WARPED_MOTION
@@ -8772,8 +8770,8 @@
#endif // ONFIG_WEDGE || CONFIG_COMPOUND_SEGMENT
int_mv single_newmv[TOTAL_REFS_PER_FRAME];
#if CONFIG_INTERINTRA
- const unsigned int *const interintra_mode_cost =
- cpi->interintra_mode_cost[size_group_lookup[bsize]];
+ const int *const interintra_mode_cost =
+ x->interintra_mode_cost[size_group_lookup[bsize]];
#endif // CONFIG_INTERINTRA
const int is_comp_interintra_pred = (mbmi->ref_frame[1] == INTRA_FRAME);
uint8_t ref_frame_type = av1_ref_frame_type(mbmi->ref_frame);
@@ -9020,16 +9018,15 @@
if (discount_newmv_test(cpi, this_mode, frame_mv[refs[0]], mode_mv,
refs[0])) {
#if CONFIG_EXT_INTER
- rd_stats->rate +=
- AOMMIN(cost_mv_ref(cpi, this_mode, mode_ctx),
- cost_mv_ref(cpi, is_comp_pred ? NEAREST_NEARESTMV : NEARESTMV,
- mode_ctx));
+ rd_stats->rate += AOMMIN(
+ cost_mv_ref(x, this_mode, mode_ctx),
+ cost_mv_ref(x, is_comp_pred ? NEAREST_NEARESTMV : NEARESTMV, mode_ctx));
#else
- rd_stats->rate += AOMMIN(cost_mv_ref(cpi, this_mode, mode_ctx),
- cost_mv_ref(cpi, NEARESTMV, mode_ctx));
+ rd_stats->rate += AOMMIN(cost_mv_ref(x, this_mode, mode_ctx),
+ cost_mv_ref(x, NEARESTMV, mode_ctx));
#endif // CONFIG_EXT_INTER
} else {
- rd_stats->rate += cost_mv_ref(cpi, this_mode, mode_ctx);
+ rd_stats->rate += cost_mv_ref(x, this_mode, mode_ctx);
}
if (RDCOST(x->rdmult, rd_stats->rate, 0) > ref_best_rd &&
@@ -9867,7 +9864,7 @@
#endif // CONFIG_PALETTE
int rate2 = 0, rate_y = INT_MAX, skippable = 0, rate_uv, rate_dummy, i;
int dc_mode_index;
- const int *const intra_mode_cost = cpi->mbmode_cost[size_group_lookup[bsize]];
+ const int *const intra_mode_cost = x->mbmode_cost[size_group_lookup[bsize]];
int64_t distortion2 = 0, distortion_y = 0, this_rd = *best_rd;
int64_t distortion_uv, model_rd = INT64_MAX;
TX_SIZE uv_tx;
@@ -9930,7 +9927,7 @@
}
rate2 = rate_y + intra_mode_cost[mbmi->mode] + rate_uv +
- cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
+ x->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
#if CONFIG_PALETTE
if (cpi->common.allow_screen_content_tools && mbmi->mode == DC_PRED &&
bsize >= BLOCK_8X8)
@@ -10104,7 +10101,7 @@
#endif // CONFIG_FILTER_INTRA
const int intra_cost_penalty = av1_get_intra_cost_penalty(
cm->base_qindex, cm->y_dc_delta_q, cm->bit_depth);
- const int *const intra_mode_cost = cpi->mbmode_cost[size_group_lookup[bsize]];
+ const int *const intra_mode_cost = x->mbmode_cost[size_group_lookup[bsize]];
int best_skip2 = 0;
uint16_t ref_frame_skip_mask[2] = { 0 };
uint32_t mode_skip_mask[TOTAL_REFS_PER_FRAME] = { 0 };
@@ -10642,7 +10639,7 @@
} else {
#endif // CONFIG_GLOBAL_MOTION
const MV_REFERENCE_FRAME ref_frames[2] = { ref_frame, second_ref_frame };
- if (!check_best_zero_mv(cpi, mbmi_ext->mode_context,
+ if (!check_best_zero_mv(cpi, x, mbmi_ext->mode_context,
#if CONFIG_EXT_INTER
mbmi_ext->compound_mode_context,
#endif // CONFIG_EXT_INTER
@@ -10783,10 +10780,10 @@
#if CONFIG_CB4X4
rate2 = rate_y + intra_mode_cost[mbmi->mode];
if (!x->skip_chroma_rd)
- rate2 += rate_uv + cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
+ rate2 += rate_uv + x->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
#else
rate2 = rate_y + intra_mode_cost[mbmi->mode] + rate_uv +
- cpi->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
+ x->intra_uv_mode_cost[mbmi->mode][mbmi->uv_mode];
#endif // CONFIG_CB4X4
#if CONFIG_PALETTE
@@ -10810,7 +10807,7 @@
const int p_angle =
mode_to_angle_map[mbmi->mode] + mbmi->angle_delta[0] * ANGLE_STEP;
if (av1_is_intra_filter_switchable(p_angle))
- rate2 += cpi->intra_filter_cost[intra_filter_ctx][mbmi->intra_filter];
+ rate2 += x->intra_filter_cost[intra_filter_ctx][mbmi->intra_filter];
#endif // CONFIG_INTRA_INTERP
if (av1_use_angle_delta(bsize)) {
rate2 += write_uniform_cost(2 * MAX_ANGLE_DELTA + 1,
@@ -11035,7 +11032,7 @@
backup_fmv[0] = frame_mv[NEWMV][ref_frame];
if (comp_pred) backup_fmv[1] = frame_mv[NEWMV][second_ref_frame];
- rate2 += (rate2 < INT_MAX ? cpi->drl_mode_cost0[drl_ctx][0] : 0);
+ rate2 += (rate2 < INT_MAX ? x->drl_mode_cost0[drl_ctx][0] : 0);
if (this_rd < INT64_MAX) {
if (RDCOST(x->rdmult, rate_y + rate_uv, distortion2) <
@@ -11196,7 +11193,7 @@
drl1_ctx = av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type],
i + idx_offset);
tmp_rd_stats.rate +=
- (tmp_rd_stats.rate < INT_MAX ? cpi->drl_mode_cost0[drl1_ctx][1]
+ (tmp_rd_stats.rate < INT_MAX ? x->drl_mode_cost0[drl1_ctx][1]
: 0);
}
@@ -11207,7 +11204,7 @@
av1_drl_ctx(mbmi_ext->ref_mv_stack[ref_frame_type],
mbmi->ref_mv_idx + idx_offset);
tmp_rd_stats.rate +=
- (tmp_rd_stats.rate < INT_MAX ? cpi->drl_mode_cost0[drl1_ctx][0]
+ (tmp_rd_stats.rate < INT_MAX ? x->drl_mode_cost0[drl1_ctx][0]
: 0);
}
@@ -11431,8 +11428,7 @@
if (motion_allowed == WARPED_CAUSAL)
*returnrate_nocoef -= x->motion_mode_cost[bsize][mbmi->motion_mode];
else if (motion_allowed == OBMC_CAUSAL)
- *returnrate_nocoef -=
- cpi->motion_mode_cost1[bsize][mbmi->motion_mode];
+ *returnrate_nocoef -= x->motion_mode_cost1[bsize][mbmi->motion_mode];
#else
*returnrate_nocoef -= x->motion_mode_cost[bsize][mbmi->motion_mode];
#endif // CONFIG_MOTION_VAR && CONFIG_WARPED_MOTION
@@ -12121,7 +12117,7 @@
#else
mbmi->interp_filter = i;
#endif // CONFIG_DUAL_FILTER
- rs = av1_get_switchable_rate(cpi, xd);
+ rs = av1_get_switchable_rate(cm, x, xd);
if (rs < best_rs) {
best_rs = rs;
#if CONFIG_DUAL_FILTER
@@ -12139,7 +12135,7 @@
#else
mbmi->interp_filter = best_filter;
#endif // CONFIG_DUAL_FILTER
- rate2 += av1_get_switchable_rate(cpi, xd);
+ rate2 += av1_get_switchable_rate(cm, x, xd);
if (cm->reference_mode == REFERENCE_MODE_SELECT)
rate2 += av1_cost_bit(comp_mode_p, comp_pred);
diff --git a/av1/encoder/rdopt.h b/av1/encoder/rdopt.h
index 43a6a37..83c3fb8 100644
--- a/av1/encoder/rdopt.h
+++ b/av1/encoder/rdopt.h
@@ -142,8 +142,8 @@
} // extern "C"
#endif
-int av1_tx_type_cost(const AV1_COMP *cpi, const MACROBLOCKD *xd,
- BLOCK_SIZE bsize, int plane, TX_SIZE tx_size,
- TX_TYPE tx_type);
+int av1_tx_type_cost(const AV1_COMMON *cm, const MACROBLOCK *x,
+ const MACROBLOCKD *xd, BLOCK_SIZE bsize, int plane,
+ TX_SIZE tx_size, TX_TYPE tx_type);
#endif // AV1_ENCODER_RDOPT_H_
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index b9db891..fdf6bf9 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -319,8 +319,7 @@
#endif // !CONFIG_PVQ || CONFIG_VAR_TX
#if CONFIG_PALETTE
-void av1_tokenize_palette_sb(const AV1_COMP *cpi,
- const struct ThreadData *const td, int plane,
+void av1_tokenize_palette_sb(const struct ThreadData *const td, int plane,
TOKENEXTRA **t, RUN_TYPE dry_run, BLOCK_SIZE bsize,
int *rate) {
assert(plane == 0 || plane == 1);
@@ -360,8 +359,8 @@
color_map, plane_block_width, i, j, n, color_order, &color_new_idx);
assert(color_new_idx >= 0 && color_new_idx < n);
if (calc_rate) {
- this_rate += cpi->palette_y_color_cost[n - PALETTE_MIN_SIZE][color_ctx]
- [color_new_idx];
+ this_rate += x->palette_y_color_cost[n - PALETTE_MIN_SIZE][color_ctx]
+ [color_new_idx];
}
(*t)->token = color_new_idx;
(*t)->palette_cdf = palette_cdf[n - PALETTE_MIN_SIZE][color_ctx];
diff --git a/av1/encoder/tokenize.h b/av1/encoder/tokenize.h
index 73f0305..54efacb 100644
--- a/av1/encoder/tokenize.h
+++ b/av1/encoder/tokenize.h
@@ -78,8 +78,7 @@
int mi_col, BLOCK_SIZE bsize, int *rate);
#endif
#if CONFIG_PALETTE
-void av1_tokenize_palette_sb(const struct AV1_COMP *cpi,
- const struct ThreadData *const td, int plane,
+void av1_tokenize_palette_sb(const struct ThreadData *const td, int plane,
TOKENEXTRA **t, RUN_TYPE dry_run, BLOCK_SIZE bsize,
int *rate);
#endif // CONFIG_PALETTE
