Add function to fetch chroma block size
This helps reduce code and logic complexity.
Change-Id: I2456e464025e18ccd57a018a1d5f424e7e08ff0b
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index be76d2b..44b9143 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1390,37 +1390,27 @@
const struct macroblockd_plane *const pd = &xd->plane[plane];
const BLOCK_SIZE bsize = mbmi->sb_type;
assert(bsize < BLOCK_SIZES_ALL);
- const BLOCK_SIZE bsizec =
- scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
-
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsizec, pd->subsampling_x, pd->subsampling_y);
-
+ const int ss_x = pd->subsampling_x;
+ const int ss_y = pd->subsampling_y;
+ const BLOCK_SIZE plane_bsize = get_scaled_plane_bsize(bsize, ss_x, ss_y);
+ assert(plane_bsize < BLOCK_SIZES_ALL);
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane);
const int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
const int bkw = tx_size_wide_unit[max_tx_size];
const int bkh = tx_size_high_unit[max_tx_size];
-
const BLOCK_SIZE max_unit_bsize =
- get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y);
- int mu_blocks_wide = block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
- int mu_blocks_high = block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
-
- int blk_row, blk_col;
-
- assert(plane_bsize < BLOCK_SIZES_ALL);
+ get_plane_block_size(BLOCK_64X64, ss_x, ss_y);
const int num_4x4_w = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
const int num_4x4_h = block_size_high[plane_bsize] >> tx_size_high_log2[0];
-
- const int unit_height =
- AOMMIN(mu_blocks_high + (row >> pd->subsampling_y), num_4x4_h);
- const int unit_width =
- AOMMIN(mu_blocks_wide + (col >> pd->subsampling_x), num_4x4_w);
- for (blk_row = row >> pd->subsampling_y; blk_row < unit_height;
- blk_row += bkh) {
- for (blk_col = col >> pd->subsampling_x; blk_col < unit_width;
- blk_col += bkw) {
+ const int mu_blocks_wide =
+ block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
+ const int mu_blocks_high =
+ block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
+ const int unit_height = AOMMIN(mu_blocks_high + (row >> ss_y), num_4x4_h);
+ const int unit_width = AOMMIN(mu_blocks_wide + (col >> ss_x), num_4x4_w);
+ for (int blk_row = row >> ss_y; blk_row < unit_height; blk_row += bkh) {
+ for (int blk_col = col >> ss_x; blk_col < unit_width; blk_col += bkw) {
pack_txb_tokens(w, cm, x, tok, tok_end, xd, mbmi, plane, plane_bsize,
cm->seq_params.bit_depth, *block, blk_row, blk_col,
max_tx_size, token_stats);
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index 9e87527..148906a 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -72,12 +72,10 @@
src_stride, dst, dst_stride);
}
-void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane) {
+void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE plane_bsize, int plane) {
struct macroblock_plane *const p = &x->plane[plane];
const struct macroblockd_plane *const pd = &x->e_mbd.plane[plane];
- assert(bsize < BLOCK_SIZES_ALL);
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+ assert(plane_bsize < BLOCK_SIZES_ALL);
const int bw = block_size_wide[plane_bsize];
const int bh = block_size_high[plane_bsize];
const MACROBLOCKD *xd = &x->e_mbd;
@@ -377,28 +375,22 @@
}
void av1_foreach_transformed_block_in_plane(
- const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
+ const MACROBLOCKD *const xd, BLOCK_SIZE plane_bsize, int plane,
foreach_transformed_block_visitor visit, void *arg) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
// block and transform sizes, in number of 4x4 blocks log 2 ("*_b")
// 4x4=0, 8x8=2, 16x16=4, 32x32=6, 64x64=8
// transform size varies per plane, look it up in a common way.
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
const uint8_t txw_unit = tx_size_wide_unit[tx_size];
const uint8_t txh_unit = tx_size_high_unit[tx_size];
const int step = txw_unit * txh_unit;
- int i = 0, r, c;
// If mb_to_right_edge is < 0 we are in a situation in which
// the current block size extends into the UMV and we won't
// visit the sub blocks that are wholly within the UMV.
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
-
- int blk_row, blk_col;
-
const BLOCK_SIZE max_unit_bsize =
get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y);
int mu_blocks_wide = block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
@@ -408,13 +400,14 @@
// Keep track of the row and column of the blocks we use so that we know
// if we are in the unrestricted motion border.
- for (r = 0; r < max_blocks_high; r += mu_blocks_high) {
+ int i = 0;
+ for (int r = 0; r < max_blocks_high; r += mu_blocks_high) {
const int unit_height = AOMMIN(mu_blocks_high + r, max_blocks_high);
// Skip visiting the sub blocks that are wholly within the UMV.
- for (c = 0; c < max_blocks_wide; c += mu_blocks_wide) {
+ for (int c = 0; c < max_blocks_wide; c += mu_blocks_wide) {
const int unit_width = AOMMIN(mu_blocks_wide + c, max_blocks_wide);
- for (blk_row = r; blk_row < unit_height; blk_row += txh_unit) {
- for (blk_col = c; blk_col < unit_width; blk_col += txw_unit) {
+ for (int blk_row = r; blk_row < unit_height; blk_row += txh_unit) {
+ for (int blk_col = c; blk_col < unit_width; blk_col += txw_unit) {
visit(plane, i, blk_row, blk_col, plane_bsize, tx_size, arg);
i += step;
}
@@ -428,11 +421,13 @@
foreach_transformed_block_visitor visit,
void *arg, const int num_planes) {
for (int plane = 0; plane < num_planes; ++plane) {
- if (!is_chroma_reference(mi_row, mi_col, bsize,
- xd->plane[plane].subsampling_x,
- xd->plane[plane].subsampling_y))
- continue;
- av1_foreach_transformed_block_in_plane(xd, bsize, plane, visit, arg);
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int ss_x = xd->plane[plane].subsampling_x;
+ const int ss_y = xd->plane[plane].subsampling_y;
+ if (!is_chroma_reference(mi_row, mi_col, bsize, ss_x, ss_y)) continue;
+ const BLOCK_SIZE plane_bsize =
+ get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+ av1_foreach_transformed_block_in_plane(xd, plane_bsize, plane, visit, arg);
}
}
@@ -485,12 +480,13 @@
void av1_encode_sb(const struct AV1_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bsize,
int mi_row, int mi_col, RUN_TYPE dry_run) {
- (void)dry_run;
- const AV1_COMMON *const cm = &cpi->common;
- const int num_planes = av1_num_planes(cm);
+ assert(bsize < BLOCK_SIZES_ALL);
MACROBLOCKD *const xd = &x->e_mbd;
- struct optimize_ctx ctx;
MB_MODE_INFO *mbmi = xd->mi[0];
+ mbmi->skip = 1;
+ if (x->skip) return;
+
+ struct optimize_ctx ctx;
struct encode_b_args arg = { cpi,
x,
&ctx,
@@ -498,58 +494,44 @@
NULL,
NULL,
cpi->optimize_seg_arr[mbmi->segment_id] };
- int plane;
+ const AV1_COMMON *const cm = &cpi->common;
+ const int num_planes = av1_num_planes(cm);
- mbmi->skip = 1;
-
- if (x->skip) return;
-
- assert(bsize < BLOCK_SIZES_ALL);
-
- for (plane = 0; plane < num_planes; ++plane) {
- const int subsampling_x = xd->plane[plane].subsampling_x;
- const int subsampling_y = xd->plane[plane].subsampling_y;
+ for (int plane = 0; plane < num_planes; ++plane) {
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int subsampling_x = pd->subsampling_x;
+ const int subsampling_y = pd->subsampling_y;
if (!is_chroma_reference(mi_row, mi_col, bsize, subsampling_x,
subsampling_y))
continue;
- const BLOCK_SIZE bsizec =
- scale_chroma_bsize(bsize, subsampling_x, subsampling_y);
-
- // TODO(jingning): Clean this up.
- const struct macroblockd_plane *const pd = &xd->plane[plane];
const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsizec, pd->subsampling_x, pd->subsampling_y);
+ get_scaled_plane_bsize(bsize, subsampling_x, subsampling_y);
assert(plane_bsize < BLOCK_SIZES_ALL);
const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
const int mi_height = block_size_high[plane_bsize] >> tx_size_high_log2[0];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane);
-
const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size];
const int bw = block_size_wide[txb_size] >> tx_size_wide_log2[0];
const int bh = block_size_high[txb_size] >> tx_size_high_log2[0];
- int idx, idy;
int block = 0;
- int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
- av1_get_entropy_contexts(bsizec, pd, ctx.ta[plane], ctx.tl[plane]);
-
- av1_subtract_plane(x, bsizec, plane);
-
+ const int step =
+ tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
+ av1_get_entropy_contexts(plane_bsize, pd, ctx.ta[plane], ctx.tl[plane]);
+ av1_subtract_plane(x, plane_bsize, plane);
arg.ta = ctx.ta[plane];
arg.tl = ctx.tl[plane];
-
const BLOCK_SIZE max_unit_bsize =
- get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y);
+ get_plane_block_size(BLOCK_64X64, subsampling_x, subsampling_y);
int mu_blocks_wide =
block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
int mu_blocks_high =
block_size_high[max_unit_bsize] >> tx_size_high_log2[0];
-
mu_blocks_wide = AOMMIN(mi_width, mu_blocks_wide);
mu_blocks_high = AOMMIN(mi_height, mu_blocks_high);
- for (idy = 0; idy < mi_height; idy += mu_blocks_high) {
- for (idx = 0; idx < mi_width; idx += mu_blocks_wide) {
+ for (int idy = 0; idy < mi_height; idy += mu_blocks_high) {
+ for (int idx = 0; idx < mi_width; idx += mu_blocks_wide) {
int blk_row, blk_col;
const int unit_height = AOMMIN(mu_blocks_high + idy, mi_height);
const int unit_width = AOMMIN(mu_blocks_wide + idx, mi_width);
@@ -669,24 +651,23 @@
BLOCK_SIZE bsize, int plane,
int enable_optimize_b, int mi_row,
int mi_col) {
+ assert(bsize < BLOCK_SIZES_ALL);
const MACROBLOCKD *const xd = &x->e_mbd;
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int ss_x = pd->subsampling_x;
+ const int ss_y = pd->subsampling_y;
+ if (plane && !is_chroma_reference(mi_row, mi_col, bsize, ss_x, ss_y)) return;
+
ENTROPY_CONTEXT ta[MAX_MIB_SIZE] = { 0 };
ENTROPY_CONTEXT tl[MAX_MIB_SIZE] = { 0 };
- assert(bsize < BLOCK_SIZES_ALL);
-
struct encode_b_args arg = {
cpi, x, NULL, &(xd->mi[0]->skip), ta, tl, enable_optimize_b
};
-
- if (!is_chroma_reference(mi_row, mi_col, bsize,
- xd->plane[plane].subsampling_x,
- xd->plane[plane].subsampling_y))
- return;
-
+ const BLOCK_SIZE plane_bsize =
+ get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
if (enable_optimize_b) {
- const struct macroblockd_plane *const pd = &xd->plane[plane];
- av1_get_entropy_contexts(bsize, pd, ta, tl);
+ av1_get_entropy_contexts(plane_bsize, pd, ta, tl);
}
av1_foreach_transformed_block_in_plane(
- xd, bsize, plane, encode_block_intra_and_set_context, &arg);
+ xd, plane_bsize, plane, encode_block_intra_and_set_context, &arg);
}
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h
index dc9b190..320b5fe 100644
--- a/av1/encoder/encodemb.h
+++ b/av1/encoder/encodemb.h
@@ -49,7 +49,7 @@
int mi_row, int mi_col, RUN_TYPE dry_run);
void av1_foreach_transformed_block_in_plane(
- const MACROBLOCKD *const xd, BLOCK_SIZE bsize, int plane,
+ const MACROBLOCKD *const xd, BLOCK_SIZE plane_bsize, int plane,
foreach_transformed_block_visitor visit, void *arg);
void av1_foreach_transformed_block(const MACROBLOCKD *const xd,
@@ -82,7 +82,7 @@
void av1_subtract_txb(MACROBLOCK *x, int plane, BLOCK_SIZE plane_bsize,
int blk_col, int blk_row, TX_SIZE tx_size);
-void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
+void av1_subtract_plane(MACROBLOCK *x, BLOCK_SIZE plane_bsize, int plane);
static INLINE void av1_set_txb_context(MACROBLOCK *x, int plane, int block,
TX_SIZE tx_size, ENTROPY_CONTEXT *a,
diff --git a/av1/encoder/nonrd_pickmode.c b/av1/encoder/nonrd_pickmode.c
index 614ffdb..a796a84 100644
--- a/av1/encoder/nonrd_pickmode.c
+++ b/av1/encoder/nonrd_pickmode.c
@@ -1948,12 +1948,14 @@
block_yrd(cpi, x, mi_row, mi_col, &this_rdc, &args.skippable, &this_sse,
bsize, mi->tx_size);
// TODO(kyslov@) Need to account for skippable
- if (x->color_sensitivity[0])
+ if (x->color_sensitivity[0]) {
av1_foreach_transformed_block_in_plane(xd, uv_bsize, 1,
estimate_block_intra, &args);
- if (x->color_sensitivity[1])
+ }
+ if (x->color_sensitivity[1]) {
av1_foreach_transformed_block_in_plane(xd, uv_bsize, 2,
estimate_block_intra, &args);
+ }
int mode_cost = 0;
if (av1_is_directional_mode(this_mode) && av1_use_angle_delta(bsize)) {
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index b73543f..949a825 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -989,13 +989,11 @@
memcpy(t_left, left, sizeof(ENTROPY_CONTEXT) * num_4x4_h);
}
-void av1_get_entropy_contexts(BLOCK_SIZE bsize,
+void av1_get_entropy_contexts(BLOCK_SIZE plane_bsize,
const struct macroblockd_plane *pd,
ENTROPY_CONTEXT t_above[MAX_MIB_SIZE],
ENTROPY_CONTEXT t_left[MAX_MIB_SIZE]) {
- assert(bsize < BLOCK_SIZES_ALL);
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
+ assert(plane_bsize < BLOCK_SIZES_ALL);
get_entropy_contexts_plane(plane_bsize, pd, t_above, t_left);
}
diff --git a/av1/encoder/rd.h b/av1/encoder/rd.h
index cc1484f..637cef2 100644
--- a/av1/encoder/rd.h
+++ b/av1/encoder/rd.h
@@ -235,7 +235,7 @@
void av1_set_mvcost(MACROBLOCK *x, int ref, int ref_mv_idx);
-void av1_get_entropy_contexts(BLOCK_SIZE bsize,
+void av1_get_entropy_contexts(BLOCK_SIZE plane_bsize,
const struct macroblockd_plane *pd,
ENTROPY_CONTEXT t_above[MAX_MIB_SIZE],
ENTROPY_CONTEXT t_left[MAX_MIB_SIZE]);
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index a3ce861..8cb7520 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -3774,10 +3774,15 @@
static AOM_INLINE void txfm_rd_in_plane(MACROBLOCK *x, const AV1_COMP *cpi,
RD_STATS *rd_stats, int64_t ref_best_rd,
int64_t this_rd, int plane,
- BLOCK_SIZE bsize, TX_SIZE tx_size,
+ BLOCK_SIZE plane_bsize, TX_SIZE tx_size,
int use_fast_coef_casting,
FAST_TX_SEARCH_MODE ftxs_mode,
int skip_trellis) {
+ if (!cpi->oxcf.enable_tx64 && txsize_sqr_up_map[tx_size] == TX_64X64) {
+ av1_invalid_rd_stats(rd_stats);
+ return;
+ }
+
MACROBLOCKD *const xd = &x->e_mbd;
const struct macroblockd_plane *const pd = &xd->plane[plane];
struct rdcost_block_args args;
@@ -3791,20 +3796,15 @@
args.skip_trellis = skip_trellis;
av1_init_rd_stats(&args.rd_stats);
- if (!cpi->oxcf.enable_tx64 && txsize_sqr_up_map[tx_size] == TX_64X64) {
- av1_invalid_rd_stats(rd_stats);
- return;
- }
-
if (plane == 0) xd->mi[0]->tx_size = tx_size;
- av1_get_entropy_contexts(bsize, pd, args.t_above, args.t_left);
+ av1_get_entropy_contexts(plane_bsize, pd, args.t_above, args.t_left);
if (args.this_rd > args.best_rd) {
args.exit_early = 1;
}
- av1_foreach_transformed_block_in_plane(xd, bsize, plane, block_rd_txfm,
+ av1_foreach_transformed_block_in_plane(xd, plane_bsize, plane, block_rd_txfm,
&args);
MB_MODE_INFO *const mbmi = xd->mi[0];
@@ -5640,28 +5640,27 @@
static int super_block_uvrd(const AV1_COMP *const cpi, MACROBLOCK *x,
RD_STATS *rd_stats, BLOCK_SIZE bsize,
int64_t ref_best_rd) {
+ av1_init_rd_stats(rd_stats);
+ int is_cost_valid = 1;
+ if (ref_best_rd < 0) is_cost_valid = 0;
+ if (x->skip_chroma_rd || !is_cost_valid) return is_cost_valid;
+
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_U];
- const TX_SIZE uv_tx_size = av1_get_tx_size(AOM_PLANE_U, xd);
int plane;
- int is_cost_valid = 1;
const int is_inter = is_inter_block(mbmi);
int64_t this_rd = 0, skip_rd = 0;
- av1_init_rd_stats(rd_stats);
-
- if (ref_best_rd < 0) is_cost_valid = 0;
-
- if (x->skip_chroma_rd) return is_cost_valid;
-
- bsize = scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
+ const BLOCK_SIZE plane_bsize =
+ get_scaled_plane_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
if (is_inter && is_cost_valid) {
for (plane = 1; plane < MAX_MB_PLANE; ++plane)
- av1_subtract_plane(x, bsize, plane);
+ av1_subtract_plane(x, plane_bsize, plane);
}
if (is_cost_valid) {
+ const TX_SIZE uv_tx_size = av1_get_tx_size(AOM_PLANE_U, xd);
for (plane = 1; plane < MAX_MB_PLANE; ++plane) {
RD_STATS pn_rd_stats;
int64_t chroma_ref_best_rd = ref_best_rd;
@@ -5674,7 +5673,7 @@
chroma_ref_best_rd != INT64_MAX)
chroma_ref_best_rd = ref_best_rd - AOMMIN(this_rd, skip_rd);
txfm_rd_in_plane(x, cpi, &pn_rd_stats, chroma_ref_best_rd, 0, plane,
- bsize, uv_tx_size, cpi->sf.use_fast_coef_costing,
+ plane_bsize, uv_tx_size, cpi->sf.use_fast_coef_costing,
FTXS_NONE, 0);
if (pn_rd_stats.rate == INT_MAX) {
is_cost_valid = 0;
@@ -6980,20 +6979,16 @@
TX_SIZE tx_size, int64_t best_rd) {
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
+ const MACROBLOCKD_PLANE *pd = &xd->plane[AOM_PLANE_U];
+ const BLOCK_SIZE plane_bsize =
+ get_plane_block_size(mbmi->sb_type, pd->subsampling_x, pd->subsampling_y);
- const BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_DEBUG
assert(is_cfl_allowed(xd) && cpi->oxcf.enable_cfl_intra);
- const int ssx = xd->plane[AOM_PLANE_U].subsampling_x;
- const int ssy = xd->plane[AOM_PLANE_U].subsampling_y;
- const BLOCK_SIZE plane_bsize = get_plane_block_size(mbmi->sb_type, ssx, ssy);
- (void)plane_bsize;
assert(plane_bsize < BLOCK_SIZES_ALL);
if (!xd->lossless[mbmi->segment_id]) {
assert(block_size_wide[plane_bsize] == tx_size_wide[tx_size]);
assert(block_size_high[plane_bsize] == tx_size_high[tx_size]);
}
-#endif // CONFIG_DEBUG
xd->cfl.use_dc_pred_cache = 1;
const int64_t mode_rd =
@@ -7020,7 +7015,7 @@
if (i == CFL_SIGN_NEG) {
mbmi->cfl_alpha_idx = 0;
mbmi->cfl_alpha_signs = joint_sign;
- txfm_rd_in_plane(x, cpi, &rd_stats, best_rd, 0, plane + 1, bsize,
+ txfm_rd_in_plane(x, cpi, &rd_stats, best_rd, 0, plane + 1, plane_bsize,
tx_size, cpi->sf.use_fast_coef_costing, FTXS_NONE, 0);
if (rd_stats.rate == INT_MAX) break;
}
@@ -7048,9 +7043,9 @@
if (i == 0) {
mbmi->cfl_alpha_idx = (c << CFL_ALPHABET_SIZE_LOG2) + c;
mbmi->cfl_alpha_signs = joint_sign;
- txfm_rd_in_plane(x, cpi, &rd_stats, best_rd, 0, plane + 1, bsize,
- tx_size, cpi->sf.use_fast_coef_costing, FTXS_NONE,
- 0);
+ txfm_rd_in_plane(x, cpi, &rd_stats, best_rd, 0, plane + 1,
+ plane_bsize, tx_size,
+ cpi->sf.use_fast_coef_costing, FTXS_NONE, 0);
if (rd_stats.rate == INT_MAX) break;
}
const int alpha_rate = x->cfl_cost[joint_sign][plane][c];
@@ -10438,7 +10433,7 @@
const int bw = block_size_wide[plane_bsize];
const int bh = block_size_high[plane_bsize];
- av1_subtract_plane(x, bsize, plane);
+ av1_subtract_plane(x, plane_bsize, plane);
int64_t sse = aom_sum_squares_2d_i16(p->src_diff, bw, bw, bh) << 4;
total_sse += sse;
}
diff --git a/av1/encoder/reconinter_enc.c b/av1/encoder/reconinter_enc.c
index e51b9d8..b2aa880 100644
--- a/av1/encoder/reconinter_enc.c
+++ b/av1/encoder/reconinter_enc.c
@@ -73,9 +73,9 @@
// block size
const int b4_w = block_size_wide[bsize] >> ss_x;
const int b4_h = block_size_high[bsize] >> ss_y;
- const BLOCK_SIZE plane_bsize = scale_chroma_bsize(bsize, ss_x, ss_y);
- const int b8_w = block_size_wide[plane_bsize] >> ss_x;
- const int b8_h = block_size_high[plane_bsize] >> ss_y;
+ const BLOCK_SIZE plane_bsize = get_scaled_plane_bsize(bsize, ss_x, ss_y);
+ const int b8_w = block_size_wide[plane_bsize];
+ const int b8_h = block_size_high[plane_bsize];
assert(!is_compound);
int row = row_start;
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 9fdd47b..7389d4d 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -205,29 +205,26 @@
}
for (int plane = 0; plane < num_planes; ++plane) {
- if (!is_chroma_reference(mi_row, mi_col, bsize,
- xd->plane[plane].subsampling_x,
- xd->plane[plane].subsampling_y)) {
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
+ const int ss_x = pd->subsampling_x;
+ const int ss_y = pd->subsampling_y;
+ if (!is_chroma_reference(mi_row, mi_col, bsize, ss_x, ss_y)) {
continue;
}
- const struct macroblockd_plane *const pd = &xd->plane[plane];
- const BLOCK_SIZE bsizec =
- scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(bsizec, pd->subsampling_x, pd->subsampling_y);
+ const BLOCK_SIZE plane_bsize = get_scaled_plane_bsize(bsize, ss_x, ss_y);
assert(plane_bsize < BLOCK_SIZES_ALL);
const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
const int mi_height = block_size_high[plane_bsize] >> tx_size_high_log2[0];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, plane);
const BLOCK_SIZE txb_size = txsize_to_bsize[max_tx_size];
- int bw = block_size_wide[txb_size] >> tx_size_wide_log2[0];
- int bh = block_size_high[txb_size] >> tx_size_high_log2[0];
- int idx, idy;
+ const int bw = block_size_wide[txb_size] >> tx_size_wide_log2[0];
+ const int bh = block_size_high[txb_size] >> tx_size_high_log2[0];
int block = 0;
- int step = tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
+ const int step =
+ tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
const BLOCK_SIZE max_unit_bsize =
- get_plane_block_size(BLOCK_64X64, pd->subsampling_x, pd->subsampling_y);
+ get_plane_block_size(BLOCK_64X64, ss_x, ss_y);
int mu_blocks_wide =
block_size_wide[max_unit_bsize] >> tx_size_wide_log2[0];
int mu_blocks_high =
@@ -236,13 +233,12 @@
mu_blocks_wide = AOMMIN(mi_width, mu_blocks_wide);
mu_blocks_high = AOMMIN(mi_height, mu_blocks_high);
- for (idy = 0; idy < mi_height; idy += mu_blocks_high) {
- for (idx = 0; idx < mi_width; idx += mu_blocks_wide) {
- int blk_row, blk_col;
+ for (int idy = 0; idy < mi_height; idy += mu_blocks_high) {
+ for (int idx = 0; idx < mi_width; idx += mu_blocks_wide) {
const int unit_height = AOMMIN(mu_blocks_high + idy, mi_height);
const int unit_width = AOMMIN(mu_blocks_wide + idx, mi_width);
- for (blk_row = idy; blk_row < unit_height; blk_row += bh) {
- for (blk_col = idx; blk_col < unit_width; blk_col += bw) {
+ for (int blk_row = idy; blk_row < unit_height; blk_row += bh) {
+ for (int blk_col = idx; blk_col < unit_width; blk_col += bw) {
tokenize_vartx(td, dry_run, max_tx_size, plane_bsize, blk_row,
blk_col, block, plane, &arg);
block += step;
