Add function to fetch chroma block size
This helps reduce code and logic complexity.
Change-Id: I2456e464025e18ccd57a018a1d5f424e7e08ff0b
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 9b5bad2..2e35c67 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -805,6 +805,49 @@
return ss_size_lookup[bsize][subsampling_x][subsampling_y];
}
+// Consider special handling of chroma block size for sub 8X8 partitio blocks.
+static INLINE BLOCK_SIZE get_scaled_plane_bsize(BLOCK_SIZE bsize,
+ int subsampling_x,
+ int subsampling_y) {
+ assert(subsampling_x >= 0 && subsampling_x < 2);
+ assert(subsampling_y >= 0 && subsampling_y < 2);
+
+ if (!subsampling_x && !subsampling_y) return bsize;
+
+ switch (bsize) {
+ case BLOCK_4X4: return BLOCK_4X4;
+ case BLOCK_4X8:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ return BLOCK_4X4;
+ else if (subsampling_x == 1)
+ return BLOCK_4X8;
+ else
+ return BLOCK_4X4;
+ case BLOCK_8X4:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ return BLOCK_4X4;
+ else if (subsampling_x == 1)
+ return BLOCK_4X4;
+ else
+ return BLOCK_8X4;
+ case BLOCK_4X16:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ return BLOCK_4X8;
+ else if (subsampling_x == 1)
+ return BLOCK_4X16;
+ else
+ return BLOCK_4X8;
+ case BLOCK_16X4:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ return BLOCK_8X4;
+ else if (subsampling_x == 1)
+ return BLOCK_8X4;
+ else
+ return BLOCK_16X4;
+ default: return ss_size_lookup[bsize][subsampling_x][subsampling_y];
+ }
+}
+
/*
* Logic to generate the lookup tables:
*
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index fc7a65c..2e68c0f 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -942,57 +942,6 @@
return ref_pos;
}
-static INLINE BLOCK_SIZE scale_chroma_bsize(BLOCK_SIZE bsize, int subsampling_x,
- int subsampling_y) {
- assert(subsampling_x >= 0 && subsampling_x < 2);
- assert(subsampling_y >= 0 && subsampling_y < 2);
- BLOCK_SIZE bs = bsize;
- switch (bsize) {
- case BLOCK_4X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X4;
- else if (subsampling_y == 1)
- bs = BLOCK_4X8;
- break;
- case BLOCK_4X8:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X8;
- else if (subsampling_y == 1)
- bs = BLOCK_4X8;
- break;
- case BLOCK_8X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X8;
- else if (subsampling_x == 1)
- bs = BLOCK_8X4;
- else if (subsampling_y == 1)
- bs = BLOCK_8X8;
- break;
- case BLOCK_4X16:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_8X16;
- else if (subsampling_x == 1)
- bs = BLOCK_8X16;
- else if (subsampling_y == 1)
- bs = BLOCK_4X16;
- break;
- case BLOCK_16X4:
- if (subsampling_x == 1 && subsampling_y == 1)
- bs = BLOCK_16X8;
- else if (subsampling_x == 1)
- bs = BLOCK_16X4;
- else if (subsampling_y == 1)
- bs = BLOCK_16X8;
- break;
- default: break;
- }
- return bs;
-}
-
static INLINE aom_cdf_prob cdf_element_prob(const aom_cdf_prob *cdf,
size_t element) {
assert(cdf != NULL);
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index 0a9f5ee..6ee31fe 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -1506,6 +1506,57 @@
}
}
+static INLINE BLOCK_SIZE scale_chroma_bsize(BLOCK_SIZE bsize, int subsampling_x,
+ int subsampling_y) {
+ assert(subsampling_x >= 0 && subsampling_x < 2);
+ assert(subsampling_y >= 0 && subsampling_y < 2);
+ BLOCK_SIZE bs = bsize;
+ switch (bsize) {
+ case BLOCK_4X4:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ bs = BLOCK_8X8;
+ else if (subsampling_x == 1)
+ bs = BLOCK_8X4;
+ else if (subsampling_y == 1)
+ bs = BLOCK_4X8;
+ break;
+ case BLOCK_4X8:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ bs = BLOCK_8X8;
+ else if (subsampling_x == 1)
+ bs = BLOCK_8X8;
+ else if (subsampling_y == 1)
+ bs = BLOCK_4X8;
+ break;
+ case BLOCK_8X4:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ bs = BLOCK_8X8;
+ else if (subsampling_x == 1)
+ bs = BLOCK_8X4;
+ else if (subsampling_y == 1)
+ bs = BLOCK_8X8;
+ break;
+ case BLOCK_4X16:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ bs = BLOCK_8X16;
+ else if (subsampling_x == 1)
+ bs = BLOCK_8X16;
+ else if (subsampling_y == 1)
+ bs = BLOCK_4X16;
+ break;
+ case BLOCK_16X4:
+ if (subsampling_x == 1 && subsampling_y == 1)
+ bs = BLOCK_16X8;
+ else if (subsampling_x == 1)
+ bs = BLOCK_16X4;
+ else if (subsampling_y == 1)
+ bs = BLOCK_16X8;
+ break;
+ default: break;
+ }
+ return bs;
+}
+
void av1_predict_intra_block(
const AV1_COMMON *cm, const MACROBLOCKD *xd, int wpx, int hpx,
TX_SIZE tx_size, PREDICTION_MODE mode, int angle_delta, int use_palette,
@@ -1541,15 +1592,15 @@
return;
}
- BLOCK_SIZE bsize = mbmi->sb_type;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int txw = tx_size_wide_unit[tx_size];
const int txh = tx_size_high_unit[tx_size];
- const int have_top = row_off || (pd->subsampling_y ? xd->chroma_up_available
- : xd->up_available);
+ const int ss_x = pd->subsampling_x;
+ const int ss_y = pd->subsampling_y;
+ const int have_top =
+ row_off || (ss_y ? xd->chroma_up_available : xd->up_available);
const int have_left =
- col_off ||
- (pd->subsampling_x ? xd->chroma_left_available : xd->left_available);
+ col_off || (ss_x ? xd->chroma_left_available : xd->left_available);
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
const int mi_col = -xd->mb_to_left_edge >> (3 + MI_SIZE_LOG2);
const int xr_chr_offset = 0;
@@ -1557,29 +1608,31 @@
// Distance between the right edge of this prediction block to
// the frame right edge
- const int xr = (xd->mb_to_right_edge >> (3 + pd->subsampling_x)) +
- (wpx - x - txwpx) - xr_chr_offset;
+ const int xr =
+ (xd->mb_to_right_edge >> (3 + ss_x)) + (wpx - x - txwpx) - xr_chr_offset;
// Distance between the bottom edge of this prediction block to
// the frame bottom edge
- const int yd = (xd->mb_to_bottom_edge >> (3 + pd->subsampling_y)) +
- (hpx - y - txhpx) - yd_chr_offset;
+ const int yd =
+ (xd->mb_to_bottom_edge >> (3 + ss_y)) + (hpx - y - txhpx) - yd_chr_offset;
const int right_available =
- mi_col + ((col_off + txw) << pd->subsampling_x) < xd->tile.mi_col_end;
+ mi_col + ((col_off + txw) << ss_x) < xd->tile.mi_col_end;
const int bottom_available =
- (yd > 0) &&
- (mi_row + ((row_off + txh) << pd->subsampling_y) < xd->tile.mi_row_end);
+ (yd > 0) && (mi_row + ((row_off + txh) << ss_y) < xd->tile.mi_row_end);
const PARTITION_TYPE partition = mbmi->partition;
+ BLOCK_SIZE bsize = mbmi->sb_type;
// force 4x4 chroma component block size.
- bsize = scale_chroma_bsize(bsize, pd->subsampling_x, pd->subsampling_y);
+ if (ss_x || ss_y) {
+ bsize = scale_chroma_bsize(bsize, ss_x, ss_y);
+ }
- const int have_top_right = has_top_right(
- cm, bsize, mi_row, mi_col, have_top, right_available, partition, tx_size,
- row_off, col_off, pd->subsampling_x, pd->subsampling_y);
- const int have_bottom_left = has_bottom_left(
- cm, bsize, mi_row, mi_col, bottom_available, have_left, partition,
- tx_size, row_off, col_off, pd->subsampling_x, pd->subsampling_y);
+ const int have_top_right =
+ has_top_right(cm, bsize, mi_row, mi_col, have_top, right_available,
+ partition, tx_size, row_off, col_off, ss_x, ss_y);
+ const int have_bottom_left =
+ has_bottom_left(cm, bsize, mi_row, mi_col, bottom_available, have_left,
+ partition, tx_size, row_off, col_off, ss_x, ss_y);
const int disable_edge_filter = !cm->seq_params.enable_intra_edge_filter;
#if CONFIG_AV1_HIGHBITDEPTH
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 8f8c80a..3bd21c7 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -686,9 +686,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);
const struct buf_2d orig_pred_buf[2] = { pd->pre[0], pd->pre[1] };
@@ -1235,14 +1235,12 @@
for (col = 0; col < max_blocks_wide; col += mu_blocks_wide) {
for (int plane = 0; plane < num_planes; ++plane) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
- if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
- pd->subsampling_y))
+ 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 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);
const TX_SIZE max_tx_size =
get_vartx_max_txsize(xd, plane_bsize, plane);
const int bh_var_tx = tx_size_high_unit[max_tx_size];
@@ -1252,15 +1250,13 @@
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
int blk_row, blk_col;
const int unit_height = ROUND_POWER_OF_TWO(
- AOMMIN(mu_blocks_high + row, max_blocks_high),
- pd->subsampling_y);
+ AOMMIN(mu_blocks_high + row, max_blocks_high), ss_y);
const int unit_width = ROUND_POWER_OF_TWO(
- AOMMIN(mu_blocks_wide + col, max_blocks_wide),
- pd->subsampling_x);
+ AOMMIN(mu_blocks_wide + col, max_blocks_wide), ss_x);
- for (blk_row = row >> pd->subsampling_y; blk_row < unit_height;
+ for (blk_row = row >> ss_y; blk_row < unit_height;
blk_row += bh_var_tx) {
- for (blk_col = col >> pd->subsampling_x; blk_col < unit_width;
+ for (blk_col = col >> ss_x; blk_col < unit_width;
blk_col += bw_var_tx) {
decode_reconstruct_tx(cm, td, r, mbmi, plane, plane_bsize,
blk_row, blk_col, block, max_tx_size,
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;
