Simplify code about block size calculation
Change-Id: I10c89610ed3cfa05e38de07476bfde33f51c042d
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index d29ed4c..9abd58a 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -71,8 +71,8 @@
struct macroblockd_plane *const pd = &xd->plane[i];
const BLOCK_SIZE plane_bsize =
get_plane_block_size(bsize, pd->subsampling_x, pd->subsampling_y);
- const int txs_wide = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
- const int txs_high = block_size_high[plane_bsize] >> tx_size_high_log2[0];
+ const int txs_wide = mi_size_wide[plane_bsize];
+ const int txs_high = mi_size_high[plane_bsize];
memset(pd->above_context, 0, sizeof(ENTROPY_CONTEXT) * txs_wide);
memset(pd->left_context, 0, sizeof(ENTROPY_CONTEXT) * txs_high);
}
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 9b5bad2..85164ae 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -361,9 +361,9 @@
int mi_row, int tx_blk_col, int tx_blk_row,
int subsampling_x, int subsampling_y) {
*pixel_c = ((mi_col >> subsampling_x) << MI_SIZE_LOG2) +
- (tx_blk_col << tx_size_wide_log2[0]);
+ (tx_blk_col << MI_SIZE_LOG2);
*pixel_r = ((mi_row >> subsampling_y) << MI_SIZE_LOG2) +
- (tx_blk_row << tx_size_high_log2[0]);
+ (tx_blk_row << MI_SIZE_LOG2);
}
#endif
@@ -414,8 +414,7 @@
qm_val_t *seg_qmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
} MACROBLOCKD_PLANE;
-#define BLOCK_OFFSET(i) \
- ((i) * (1 << (tx_size_wide_log2[0] + tx_size_high_log2[0])))
+#define BLOCK_OFFSET(i) ((i) << 4)
typedef struct {
DECLARE_ALIGNED(16, InterpKernel, vfilter);
diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index db84ebb..171bfdd 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -327,7 +327,7 @@
int row, int col, TX_SIZE tx_size, int use_hbd) {
const int width = tx_size_wide[tx_size];
const int height = tx_size_high[tx_size];
- const int tx_off_log2 = tx_size_wide_log2[0];
+ const int tx_off_log2 = MI_SIZE_LOG2;
const int sub_x = cfl->subsampling_x;
const int sub_y = cfl->subsampling_y;
const int store_row = row << (tx_off_log2 - sub_y);
@@ -391,8 +391,7 @@
BLOCK_SIZE bsize) {
CFL_CTX *const cfl = &xd->cfl;
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_Y];
- uint8_t *dst =
- &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
// Only dimensions of size 4 can have an odd offset.
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 2e68c0f..52b1052 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -1047,32 +1047,34 @@
int plane) {
assert(bsize < BLOCK_SIZES_ALL);
int max_blocks_wide = block_size_wide[bsize];
- const struct macroblockd_plane *const pd = &xd->plane[plane];
- if (xd->mb_to_right_edge < 0)
+ if (xd->mb_to_right_edge < 0) {
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
max_blocks_wide += xd->mb_to_right_edge >> (3 + pd->subsampling_x);
+ }
// Scale the width in the transform block unit.
- return max_blocks_wide >> tx_size_wide_log2[0];
+ return max_blocks_wide >> MI_SIZE_LOG2;
}
static INLINE int max_block_high(const MACROBLOCKD *xd, BLOCK_SIZE bsize,
int plane) {
int max_blocks_high = block_size_high[bsize];
- const struct macroblockd_plane *const pd = &xd->plane[plane];
- if (xd->mb_to_bottom_edge < 0)
+ if (xd->mb_to_bottom_edge < 0) {
+ const struct macroblockd_plane *const pd = &xd->plane[plane];
max_blocks_high += xd->mb_to_bottom_edge >> (3 + pd->subsampling_y);
+ }
// Scale the height in the transform block unit.
- return max_blocks_high >> tx_size_high_log2[0];
+ return max_blocks_high >> MI_SIZE_LOG2;
}
static INLINE int max_intra_block_width(const MACROBLOCKD *xd,
BLOCK_SIZE plane_bsize, int plane,
TX_SIZE tx_size) {
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane)
- << tx_size_wide_log2[0];
+ << MI_SIZE_LOG2;
return ALIGN_POWER_OF_TWO(max_blocks_wide, tx_size_wide_log2[tx_size]);
}
@@ -1080,7 +1082,7 @@
BLOCK_SIZE plane_bsize, int plane,
TX_SIZE tx_size) {
const int max_blocks_high = max_block_high(xd, plane_bsize, plane)
- << tx_size_high_log2[0];
+ << MI_SIZE_LOG2;
return ALIGN_POWER_OF_TWO(max_blocks_high, tx_size_high_log2[tx_size]);
}
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index 6ee31fe..17dc762 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -198,7 +198,7 @@
int col_off, int ss_x, int ss_y) {
if (!top_available || !right_available) return 0;
- const int bw_unit = block_size_wide[bsize] >> tx_size_wide_log2[0];
+ const int bw_unit = mi_size_wide[bsize];
const int plane_bw_unit = AOMMAX(bw_unit >> ss_x, 1);
const int top_right_count_unit = tx_size_wide_unit[txsz];
@@ -405,7 +405,7 @@
// Bottom-left pixels are in the bottom-left block, which is not available.
return 0;
} else {
- const int bh_unit = block_size_high[bsize] >> tx_size_high_log2[0];
+ const int bh_unit = mi_size_high[bsize];
const int plane_bh_unit = AOMMAX(bh_unit >> ss_y, 1);
const int bottom_left_count_unit = tx_size_high_unit[txsz];
@@ -422,10 +422,9 @@
// and/or bottom-left superblocks. But only the left superblock is
// available, so check if all required pixels fall in that superblock.
if (blk_col_in_sb == 0) {
- const int blk_start_row_off = blk_row_in_sb
- << (bh_in_mi_log2 + MI_SIZE_LOG2 -
- tx_size_wide_log2[0]) >>
- ss_y;
+ const int blk_start_row_off =
+ blk_row_in_sb << (bh_in_mi_log2 + MI_SIZE_LOG2 - MI_SIZE_LOG2) >>
+ ss_y;
const int row_off_in_sb = blk_start_row_off + row_off;
const int sb_height_unit = sb_mi_size >> ss_y;
return row_off_in_sb + bottom_left_count_unit < sb_height_unit;
@@ -1565,8 +1564,8 @@
const MB_MODE_INFO *const mbmi = xd->mi[0];
const int txwpx = tx_size_wide[tx_size];
const int txhpx = tx_size_high[tx_size];
- const int x = col_off << tx_size_wide_log2[0];
- const int y = row_off << tx_size_high_log2[0];
+ const int x = col_off << MI_SIZE_LOG2;
+ const int y = row_off << MI_SIZE_LOG2;
if (use_palette) {
int r, c;
@@ -1662,8 +1661,7 @@
const MB_MODE_INFO *const mbmi = xd->mi[0];
struct macroblockd_plane *const pd = &xd->plane[plane];
const int dst_stride = pd->dst.stride;
- uint8_t *dst =
- &pd->dst.buf[(blk_row * dst_stride + blk_col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
const PREDICTION_MODE mode =
(plane == AOM_PLANE_Y) ? mbmi->mode : get_uv_mode(mbmi->uv_mode);
const int use_palette = mbmi->palette_mode_info.palette_size[plane != 0] > 0;
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 61d4c13..693a9c8 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -228,8 +228,7 @@
// tx_type was read out in av1_read_coeffs_txb.
const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, row, col, tx_size,
cm->reduced_tx_set_used);
- uint8_t *dst =
- &pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(row * pd->dst.stride + col) << MI_SIZE_LOG2];
inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
cm->reduced_tx_set_used);
}
@@ -252,8 +251,7 @@
tx_size, cm->reduced_tx_set_used);
uint8_t *dst =
- &pd->dst
- .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
+ &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];
inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride,
cm->reduced_tx_set_used);
#if CONFIG_MISMATCH_DEBUG
@@ -1171,10 +1169,8 @@
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
const int max_blocks_high = max_block_high(xd, bsize, 0);
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
- 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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
@@ -1223,10 +1219,8 @@
assert(max_unit_bsize ==
get_plane_block_size(BLOCK_64X64, xd->plane[0].subsampling_x,
xd->plane[0].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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
@@ -1435,8 +1429,8 @@
const TX_SIZE max_tx_size = max_txsize_rect_lookup[bsize];
const int bh = tx_size_high_unit[max_tx_size];
const int bw = tx_size_wide_unit[max_tx_size];
- const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
- const int height = block_size_high[bsize] >> tx_size_high_log2[0];
+ const int width = mi_size_wide[bsize];
+ const int height = mi_size_high[bsize];
for (int idy = 0; idy < height; idy += bh)
for (int idx = 0; idx < width; idx += bw)
diff --git a/av1/encoder/av1_fwd_txfm2d.c b/av1/encoder/av1_fwd_txfm2d.c
index 642728a..deae95f 100644
--- a/av1/encoder/av1_fwd_txfm2d.c
+++ b/av1/encoder/av1_fwd_txfm2d.c
@@ -416,8 +416,8 @@
set_flip_cfg(tx_type, cfg);
const TX_TYPE_1D tx_type_1d_col = vtx_tab[tx_type];
const TX_TYPE_1D tx_type_1d_row = htx_tab[tx_type];
- const int txw_idx = tx_size_wide_log2[tx_size] - tx_size_wide_log2[0];
- const int txh_idx = tx_size_high_log2[tx_size] - tx_size_high_log2[0];
+ const int txw_idx = get_txw_idx(tx_size);
+ const int txh_idx = get_txh_idx(tx_size);
cfg->shift = av1_fwd_txfm_shift_ls[tx_size];
cfg->cos_bit_col = av1_fwd_cos_bit_col[txw_idx][txh_idx];
cfg->cos_bit_row = av1_fwd_cos_bit_row[txw_idx][txh_idx];
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 03d492e..59e2e7b 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -1401,12 +1401,10 @@
const int bkh = tx_size_high_unit[max_tx_size];
const BLOCK_SIZE max_unit_bsize =
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 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 num_4x4_w = mi_size_wide[plane_bsize];
+ const int num_4x4_h = mi_size_high[plane_bsize];
+ const int mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ const int mu_blocks_high = mi_size_high[max_unit_bsize];
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) {
@@ -1438,8 +1436,8 @@
int block[MAX_MB_PLANE] = { 0 };
assert(bsize == get_plane_block_size(bsize, xd->plane[0].subsampling_x,
xd->plane[0].subsampling_y));
- const int num_4x4_w = block_size_wide[bsize] >> tx_size_wide_log2[0];
- const int num_4x4_h = block_size_high[bsize] >> tx_size_high_log2[0];
+ const int num_4x4_w = mi_size_wide[bsize];
+ const int num_4x4_h = mi_size_high[bsize];
TOKEN_STATS token_stats;
init_token_stats(&token_stats);
@@ -1447,11 +1445,8 @@
assert(max_unit_bsize == get_plane_block_size(BLOCK_64X64,
xd->plane[0].subsampling_x,
xd->plane[0].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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(num_4x4_w, mu_blocks_wide);
mu_blocks_high = AOMMIN(num_4x4_h, mu_blocks_high);
@@ -1533,8 +1528,8 @@
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, bsize, 0);
const int txbh = tx_size_high_unit[max_tx_size];
const int txbw = tx_size_wide_unit[max_tx_size];
- const int width = block_size_wide[bsize] >> tx_size_wide_log2[0];
- const int height = block_size_high[bsize] >> tx_size_high_log2[0];
+ const int width = mi_size_wide[bsize];
+ const int height = mi_size_high[bsize];
for (int idy = 0; idy < height; idy += txbh) {
for (int idx = 0; idx < width; idx += txbw) {
write_tx_size_vartx(xd, mbmi, max_tx_size, 0, idy, idx, w);
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index a1a5c48..4a02ea1 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -1473,10 +1473,8 @@
const int num_planes) {
MACROBLOCKD *xd = &x->e_mbd;
int p;
- const int num_4x4_blocks_wide =
- block_size_wide[bsize] >> tx_size_wide_log2[0];
- const int num_4x4_blocks_high =
- block_size_high[bsize] >> tx_size_high_log2[0];
+ const int num_4x4_blocks_wide = mi_size_wide[bsize];
+ const int num_4x4_blocks_high = mi_size_high[bsize];
int mi_width = mi_size_wide[bsize];
int mi_height = mi_size_high[bsize];
for (p = 0; p < num_planes; p++) {
@@ -1509,10 +1507,6 @@
const int num_planes) {
const MACROBLOCKD *xd = &x->e_mbd;
int p;
- const int num_4x4_blocks_wide =
- block_size_wide[bsize] >> tx_size_wide_log2[0];
- const int num_4x4_blocks_high =
- block_size_high[bsize] >> tx_size_high_log2[0];
int mi_width = mi_size_wide[bsize];
int mi_height = mi_size_high[bsize];
@@ -1520,14 +1514,12 @@
for (p = 0; p < num_planes; ++p) {
int tx_col = mi_col;
int tx_row = mi_row & MAX_MIB_MASK;
- memcpy(ctx->a + num_4x4_blocks_wide * p,
+ memcpy(ctx->a + mi_width * p,
xd->above_context[p] + (tx_col >> xd->plane[p].subsampling_x),
- (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_wide) >>
- xd->plane[p].subsampling_x);
- memcpy(ctx->l + num_4x4_blocks_high * p,
+ (sizeof(ENTROPY_CONTEXT) * mi_width) >> xd->plane[p].subsampling_x);
+ memcpy(ctx->l + mi_height * p,
xd->left_context[p] + (tx_row >> xd->plane[p].subsampling_y),
- (sizeof(ENTROPY_CONTEXT) * num_4x4_blocks_high) >>
- xd->plane[p].subsampling_y);
+ (sizeof(ENTROPY_CONTEXT) * mi_height) >> xd->plane[p].subsampling_y);
}
memcpy(ctx->sa, xd->above_seg_context + mi_col,
sizeof(*xd->above_seg_context) * mi_width);
@@ -5597,8 +5589,8 @@
const AV1_COMMON *const cm, MACROBLOCK *x, BLOCK_SIZE plane_bsize,
int mi_row, int mi_col, FRAME_COUNTS *td_counts, uint8_t allow_update_cdf) {
MACROBLOCKD *xd = &x->e_mbd;
- 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 int mi_width = mi_size_wide[plane_bsize];
+ const int mi_height = mi_size_high[plane_bsize];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0);
const int bh = tx_size_high_unit[max_tx_size];
const int bw = tx_size_wide_unit[max_tx_size];
@@ -5656,20 +5648,21 @@
MACROBLOCKD *xd,
BLOCK_SIZE plane_bsize,
int mi_row, int mi_col) {
- 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 int mi_width = mi_size_wide[plane_bsize];
+ const int mi_height = mi_size_high[plane_bsize];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 0);
const int bh = tx_size_high_unit[max_tx_size];
const int bw = tx_size_wide_unit[max_tx_size];
- int idx, idy;
xd->above_txfm_context = cm->above_txfm_context[xd->tile.tile_row] + mi_col;
xd->left_txfm_context =
xd->left_txfm_context_buffer + (mi_row & MAX_MIB_MASK);
- for (idy = 0; idy < mi_height; idy += bh)
- for (idx = 0; idx < mi_width; idx += bw)
+ for (int idy = 0; idy < mi_height; idy += bh) {
+ for (int idx = 0; idx < mi_width; idx += bw) {
set_txfm_context(xd, max_tx_size, idy, idx);
+ }
+ }
}
static AOM_INLINE void encode_superblock(const AV1_COMP *const cpi,
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c
index f990c80..2575214 100644
--- a/av1/encoder/encodemb.c
+++ b/av1/encoder/encodemb.c
@@ -62,12 +62,10 @@
const int dst_stride = pd->dst.stride;
const int tx1d_width = tx_size_wide[tx_size];
const int tx1d_height = tx_size_high[tx_size];
- uint8_t *dst =
- &pd->dst.buf[(blk_row * dst_stride + blk_col) << tx_size_wide_log2[0]];
- uint8_t *src =
- &p->src.buf[(blk_row * src_stride + blk_col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
+ uint8_t *src = &p->src.buf[(blk_row * src_stride + blk_col) << MI_SIZE_LOG2];
int16_t *src_diff =
- &p->src_diff[(blk_row * diff_stride + blk_col) << tx_size_wide_log2[0]];
+ &p->src_diff[(blk_row * diff_stride + blk_col) << MI_SIZE_LOG2];
av1_subtract_block(xd, tx1d_height, tx1d_width, src_diff, diff_stride, src,
src_stride, dst, dst_stride);
}
@@ -139,7 +137,7 @@
const int diff_stride = block_size_wide[plane_bsize];
const int src_offset = (blk_row * diff_stride + blk_col);
- const int16_t *src_diff = &p->src_diff[src_offset << tx_size_wide_log2[0]];
+ const int16_t *src_diff = &p->src_diff[src_offset << MI_SIZE_LOG2];
av1_fwd_txfm(src_diff, coeff, diff_stride, txfm_param);
@@ -236,9 +234,8 @@
ENTROPY_CONTEXT *a, *l;
int dummy_rate_cost = 0;
- const int bw = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
- dst = &pd->dst
- .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
+ const int bw = mi_size_wide[plane_bsize];
+ dst = &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];
a = &args->ta[blk_col];
l = &args->tl[blk_row];
@@ -393,8 +390,8 @@
const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
@@ -448,8 +445,7 @@
tran_low_t *const dqcoeff = pd->dqcoeff + BLOCK_OFFSET(block);
uint8_t *dst;
- dst = &pd->dst
- .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]];
+ dst = &pd->dst.buf[(blk_row * pd->dst.stride + blk_col) << MI_SIZE_LOG2];
TxfmParam txfm_param;
QUANT_PARAM quant_param;
@@ -508,12 +504,12 @@
const BLOCK_SIZE plane_bsize =
get_plane_block_size(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 int mi_width = mi_size_wide[plane_bsize];
+ const int mi_height = mi_size_high[plane_bsize];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 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];
+ const int bw = mi_size_wide[txb_size];
+ const int bh = mi_size_high[txb_size];
int block = 0;
const int step =
tx_size_wide_unit[max_tx_size] * tx_size_high_unit[max_tx_size];
@@ -523,10 +519,8 @@
arg.tl = ctx.tl[plane];
const BLOCK_SIZE max_unit_bsize =
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];
+ int mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(mi_width, mu_blocks_wide);
mu_blocks_high = AOMMIN(mi_height, mu_blocks_high);
@@ -574,14 +568,13 @@
PLANE_TYPE plane_type = get_plane_type(plane);
uint16_t *eob = &p->eobs[block];
const int dst_stride = pd->dst.stride;
- uint8_t *dst =
- &pd->dst.buf[(blk_row * dst_stride + blk_col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
int dummy_rate_cost = 0;
av1_predict_intra_block_facade(cm, xd, plane, blk_col, blk_row, tx_size);
TX_TYPE tx_type = DCT_DCT;
- const int bw = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+ const int bw = mi_size_wide[plane_bsize];
if (plane == 0 && is_blk_skip(x, plane, blk_row * bw + blk_col)) {
*eob = 0;
p->txb_entropy_ctx[block] = 0;
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index cf2d64b..78deef5 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -657,8 +657,8 @@
const int max_blocks_wide = max_block_wide(xd, bsize, 0);
const int max_blocks_high = max_block_high(xd, bsize, 0);
const BLOCK_SIZE max_unit_bsize = BLOCK_64X64;
- 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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(max_blocks_wide, mu_blocks_wide);
mu_blocks_high = AOMMIN(max_blocks_high, mu_blocks_high);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 949a825..392189a 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -980,8 +980,8 @@
const struct macroblockd_plane *pd,
ENTROPY_CONTEXT t_above[MAX_MIB_SIZE],
ENTROPY_CONTEXT t_left[MAX_MIB_SIZE]) {
- 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 num_4x4_w = mi_size_wide[plane_bsize];
+ const int num_4x4_h = mi_size_high[plane_bsize];
const ENTROPY_CONTEXT *const above = pd->above_context;
const ENTROPY_CONTEXT *const left = pd->left_context;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 5118fc0..636f6b3 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2190,7 +2190,6 @@
const int txb_height = block_size_high[tx_bsize];
const int txb_width = block_size_wide[tx_bsize];
const struct macroblockd_plane *const pd = &xd->plane[plane];
- const int tx_unit_size = tx_size_wide_log2[0];
// TODO(aconverse@google.com): Investigate using crop_width/height here rather
// than the MI size
@@ -2201,7 +2200,7 @@
const int block_rows =
(xd->mb_to_bottom_edge >> (3 + pd->subsampling_y)) + block_height;
*visible_height =
- clamp(block_rows - (blk_row << tx_unit_size), 0, txb_height);
+ clamp(block_rows - (blk_row << MI_SIZE_LOG2), 0, txb_height);
}
if (height) *height = txb_height;
@@ -2212,7 +2211,7 @@
const int block_cols =
(xd->mb_to_right_edge >> (3 + pd->subsampling_x)) + block_width;
*visible_width =
- clamp(block_cols - (blk_col << tx_unit_size), 0, txb_width);
+ clamp(block_cols - (blk_col << MI_SIZE_LOG2), 0, txb_width);
}
if (width) *width = txb_width;
}
@@ -2266,17 +2265,15 @@
int txb_width = block_size_wide[tx_bsize];
if (x->using_dist_8x8 && plane == 0) {
const int src_stride = x->plane[plane].src.stride;
- const int src_idx = (blk_row * src_stride + blk_col)
- << tx_size_wide_log2[0];
- const int diff_idx = (blk_row * diff_stride + blk_col)
- << tx_size_wide_log2[0];
+ const int src_idx = (blk_row * src_stride + blk_col) << MI_SIZE_LOG2;
+ const int diff_idx = (blk_row * diff_stride + blk_col) << MI_SIZE_LOG2;
const uint8_t *src = &x->plane[plane].src.buf[src_idx];
return dist_8x8_diff(x, src, src_stride, diff + diff_idx, diff_stride,
txb_width, txb_height, visible_cols, visible_rows,
x->qindex);
}
#endif
- diff += ((blk_row * diff_stride + blk_col) << tx_size_wide_log2[0]);
+ diff += ((blk_row * diff_stride + blk_col) << MI_SIZE_LOG2);
uint64_t sse =
aom_sum_squares_2d_i16(diff, diff_stride, visible_cols, visible_rows);
if (block_mse_q8 != NULL) {
@@ -2342,8 +2339,7 @@
const TX_TYPE tx_type = av1_get_tx_type(xd, plane_type, blk_row, blk_col,
tx_size, reduced_tx_set);
const int dst_stride = pd->dst.stride;
- uint8_t *dst =
- &pd->dst.buf[(blk_row * dst_stride + blk_col) << tx_size_wide_log2[0]];
+ uint8_t *dst = &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
av1_inverse_transform_block(xd, dqcoeff, plane, tx_type, tx_size, dst,
dst_stride, eob, reduced_tx_set);
}
@@ -2417,8 +2413,8 @@
const int src_stride = x->plane[plane].src.stride;
const int dst_stride = xd->plane[plane].dst.stride;
// Scale the transform block index to pixel unit.
- const int src_idx = (blk_row * src_stride + blk_col) << tx_size_wide_log2[0];
- const int dst_idx = (blk_row * dst_stride + blk_col) << tx_size_wide_log2[0];
+ const int src_idx = (blk_row * src_stride + blk_col) << MI_SIZE_LOG2;
+ const int dst_idx = (blk_row * dst_stride + blk_col) << MI_SIZE_LOG2;
const uint8_t *src = &x->plane[plane].src.buf[src_idx];
const uint8_t *dst = &xd->plane[plane].dst.buf[dst_idx];
const tran_low_t *dqcoeff = pd->dqcoeff + BLOCK_OFFSET(block);
@@ -2718,10 +2714,10 @@
const int src_stride = p->src.stride;
const uint8_t *const src =
- &p->src.buf[(blk_row * src_stride + blk_col) << tx_size_wide_log2[0]];
+ &p->src.buf[(blk_row * src_stride + blk_col) << MI_SIZE_LOG2];
const int dst_stride = pd->dst.stride;
const uint8_t *const dst =
- &pd->dst.buf[(blk_row * dst_stride + blk_col) << tx_size_wide_log2[0]];
+ &pd->dst.buf[(blk_row * dst_stride + blk_col) << MI_SIZE_LOG2];
unsigned int sse;
cpi->fn_ptr[tx_bsize].vf(src, src_stride, dst, dst_stride, &sse);
const double sse_norm = (double)sse / num_samples;
@@ -2734,7 +2730,7 @@
const int diff_stride = block_size_wide[plane_bsize];
const int16_t *const src_diff =
- &p->src_diff[(blk_row * diff_stride + blk_col) << tx_size_wide_log2[0]];
+ &p->src_diff[(blk_row * diff_stride + blk_col) << MI_SIZE_LOG2];
double sse_norm_arr[4], sad_norm_arr[4];
get_2x2_normalized_sses_and_sads(cpi, tx_bsize, src, src_stride, dst,
@@ -3740,8 +3736,7 @@
av1_set_txb_context(x, plane, block, tx_size, a, l);
const int blk_idx =
- blk_row * (block_size_wide[plane_bsize] >> tx_size_wide_log2[0]) +
- blk_col;
+ blk_row * (block_size_wide[plane_bsize] >> MI_SIZE_LOG2) + blk_col;
if (plane == 0)
set_blk_skip(x, plane, blk_idx, x->plane[plane].eobs[block] == 0);
@@ -3981,7 +3976,7 @@
}
static INLINE int bsize_to_num_blk(BLOCK_SIZE bsize) {
- int num_blk = 1 << (num_pels_log2_lookup[bsize] - 2 * tx_size_wide_log2[0]);
+ int num_blk = 1 << (num_pels_log2_lookup[bsize] - 2 * MI_SIZE_LOG2);
return num_blk;
}
@@ -5844,7 +5839,7 @@
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = xd->mi[0];
struct macroblock_plane *const p = &x->plane[0];
- const int bw = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+ const int bw = mi_size_wide[plane_bsize];
no_split->rd = INT64_MAX;
no_split->txb_entropy_ctx = 0;
@@ -5970,7 +5965,7 @@
const int max_blocks_wide = max_block_wide(xd, plane_bsize, 0);
if (blk_row >= max_blocks_high || blk_col >= max_blocks_wide) return;
- const int bw = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+ const int bw = mi_size_wide[plane_bsize];
MB_MODE_INFO *const mbmi = xd->mi[0];
const int ctx = txfm_partition_context(tx_above + blk_col, tx_left + blk_row,
mbmi->sb_type, tx_size);
@@ -6193,7 +6188,7 @@
rd_stats->zero_rate = zero_blk_rate;
tx_type_rd(cpi, x, tx_size, blk_row, blk_col, 0, block, plane_bsize,
&txb_ctx, rd_stats, ftxs_mode, ref_best_rd, NULL);
- const int mi_width = block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
+ const int mi_width = mi_size_wide[plane_bsize];
if (RDCOST(x->rdmult, rd_stats->rate, rd_stats->dist) >=
RDCOST(x->rdmult, zero_blk_rate, rd_stats->sse) ||
rd_stats->skip == 1) {
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index ade1bc0..df2d04a 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -213,22 +213,20 @@
}
const BLOCK_SIZE plane_bsize = get_plane_block_size(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 int mi_width = mi_size_wide[plane_bsize];
+ const int mi_height = mi_size_high[plane_bsize];
const TX_SIZE max_tx_size = get_vartx_max_txsize(xd, plane_bsize, 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];
+ const int bw = mi_size_wide[txb_size];
+ const int bh = mi_size_high[txb_size];
int block = 0;
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, ss_x, ss_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 mu_blocks_wide = mi_size_wide[max_unit_bsize];
+ int mu_blocks_high = mi_size_high[max_unit_bsize];
mu_blocks_wide = AOMMIN(mi_width, mu_blocks_wide);
mu_blocks_high = AOMMIN(mi_height, mu_blocks_high);
