Improve bitmask construction
(1). At decoder, store is_coding_block_border correctly if
block size > 64x64.
(2). Correctly use unit64_t for skip and is_coding_block_border at
bitmask construction to avoid int overflow.
(3). Fix a bug when storing bitmask at decoder, block size error.
if decoder stores bitmask at max depth - 1, do not call store bitmask
at max depth.
Change-Id: I84799602355cc5d338c29e30b5ecfd9ac3892bc2
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 537d8df..6de130d 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -1463,8 +1463,8 @@
const int is_uv = plane > 0;
TX_SIZE tx_size = TX_16X16, prev_tx_size = TX_16X16;
uint8_t level, prev_level = 1;
- int skip, prev_skip = 0;
- int is_coding_block_border;
+ uint64_t skip, prev_skip = 0;
+ uint64_t is_coding_block_border;
for (int r = 0; (r << MI_SIZE_LOG2) < plane_ptr->dst.height; r += row_step) {
const int mi_row = r << subsampling_y;
@@ -1534,8 +1534,8 @@
const int is_uv = plane > 0;
TX_SIZE tx_size = TX_16X16, prev_tx_size = TX_16X16;
uint8_t level, prev_level = 1;
- int skip, prev_skip = 0;
- int is_coding_block_border;
+ uint64_t skip, prev_skip = 0;
+ uint64_t is_coding_block_border;
for (int c = 0; (c << MI_SIZE_LOG2) < plane_ptr->dst.width; c += col_step) {
const int mi_col = c << subsampling_x;
@@ -2219,6 +2219,92 @@
}
}
+void av1_filter_block_plane_vert_test(const AV1_COMMON *const cm,
+ const MACROBLOCKD *const xd,
+ const int plane,
+ const MACROBLOCKD_PLANE *const plane_ptr,
+ const uint32_t mi_row,
+ const uint32_t mi_col) {
+ const int row_step = MI_SIZE >> MI_SIZE_LOG2;
+ const uint32_t scale_horz = plane_ptr->subsampling_x;
+ const uint32_t scale_vert = plane_ptr->subsampling_y;
+ uint8_t *const dst_ptr = plane_ptr->dst.buf;
+ const int dst_stride = plane_ptr->dst.stride;
+ const int y_range = cm->mi_rows >> scale_vert;
+ const int x_range = cm->mi_cols >> scale_horz;
+ for (int y = 0; y < y_range; y += row_step) {
+ uint8_t *p = dst_ptr + y * MI_SIZE * dst_stride;
+ for (int x = 0; x < x_range;) {
+ // inner loop always filter vertical edges in a MI block. If MI size
+ // is 8x8, it will filter the vertical edge aligned with a 8x8 block.
+ // If 4x4 trasnform is used, it will then filter the internal edge
+ // aligned with a 4x4 block
+ const uint32_t curr_x = ((mi_col * MI_SIZE) >> scale_horz) + x * MI_SIZE;
+ const uint32_t curr_y = ((mi_row * MI_SIZE) >> scale_vert) + y * MI_SIZE;
+ uint32_t advance_units;
+ TX_SIZE tx_size;
+ AV1_DEBLOCKING_PARAMETERS params;
+ memset(¶ms, 0, sizeof(params));
+
+ tx_size =
+ set_lpf_parameters(¶ms, ((ptrdiff_t)1 << scale_horz), cm, xd,
+ VERT_EDGE, curr_x, curr_y, plane, plane_ptr);
+ if (tx_size == TX_INVALID) {
+ params.filter_length = 0;
+ tx_size = TX_4X4;
+ }
+
+ // advance the destination pointer
+ advance_units = tx_size_wide_unit[tx_size];
+ x += advance_units;
+ p += advance_units * MI_SIZE;
+ }
+ }
+}
+
+void av1_filter_block_plane_horz_test(const AV1_COMMON *const cm,
+ const MACROBLOCKD *const xd,
+ const int plane,
+ const MACROBLOCKD_PLANE *const plane_ptr,
+ const uint32_t mi_row,
+ const uint32_t mi_col) {
+ const int col_step = MI_SIZE >> MI_SIZE_LOG2;
+ const uint32_t scale_horz = plane_ptr->subsampling_x;
+ const uint32_t scale_vert = plane_ptr->subsampling_y;
+ uint8_t *const dst_ptr = plane_ptr->dst.buf;
+ const int dst_stride = plane_ptr->dst.stride;
+ const int y_range = cm->mi_rows >> scale_vert;
+ const int x_range = cm->mi_cols >> scale_horz;
+ for (int x = 0; x < x_range; x += col_step) {
+ uint8_t *p = dst_ptr + x * MI_SIZE;
+ for (int y = 0; y < y_range;) {
+ // inner loop always filter vertical edges in a MI block. If MI size
+ // is 8x8, it will first filter the vertical edge aligned with a 8x8
+ // block. If 4x4 trasnform is used, it will then filter the internal
+ // edge aligned with a 4x4 block
+ const uint32_t curr_x = ((mi_col * MI_SIZE) >> scale_horz) + x * MI_SIZE;
+ const uint32_t curr_y = ((mi_row * MI_SIZE) >> scale_vert) + y * MI_SIZE;
+ uint32_t advance_units;
+ TX_SIZE tx_size;
+ AV1_DEBLOCKING_PARAMETERS params;
+ memset(¶ms, 0, sizeof(params));
+
+ tx_size =
+ set_lpf_parameters(¶ms, (cm->mi_stride << scale_vert), cm, xd,
+ HORZ_EDGE, curr_x, curr_y, plane, plane_ptr);
+ if (tx_size == TX_INVALID) {
+ params.filter_length = 0;
+ tx_size = TX_4X4;
+ }
+
+ // advance the destination pointer
+ advance_units = tx_size_high_unit[tx_size];
+ y += advance_units;
+ p += advance_units * dst_stride * MI_SIZE;
+ }
+ }
+}
+
static void loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer, AV1_COMMON *cm,
MACROBLOCKD *xd, int start, int stop,
#if LOOP_FILTER_BITMASK
@@ -2233,6 +2319,7 @@
#if LOOP_FILTER_BITMASK
if (is_decoding) {
+ cm->is_decoding = is_decoding;
for (plane = plane_start; plane < plane_end; plane++) {
if (plane == 0 && !(cm->lf.filter_level[0]) && !(cm->lf.filter_level[1]))
break;
@@ -2243,6 +2330,10 @@
av1_setup_dst_planes(pd, cm->seq_params.sb_size, frame_buffer, 0, 0,
plane, plane + 1);
+
+ av1_filter_block_plane_vert_test(cm, xd, plane, &pd[plane], 0, 0);
+ av1_filter_block_plane_horz_test(cm, xd, plane, &pd[plane], 0, 0);
+
av1_build_bitmask_vert_info(cm, &pd[plane], plane);
av1_build_bitmask_horz_info(cm, &pd[plane], plane);
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index ff011c8..224e59e 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -551,6 +551,7 @@
int64_t txcoeff_cost_count;
#endif
const cfg_options_t *options;
+ int is_decoding;
} AV1_COMMON;
// TODO(hkuang): Don't need to lock the whole pool after implementing atomic
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 81cd879..cb49284 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1242,6 +1242,7 @@
TX_SIZE tx_size, int depth,
#if LOOP_FILTER_BITMASK
AV1_COMMON *cm, int mi_row, int mi_col,
+ int store_bitmask,
#endif
int blk_row, int blk_col, aom_reader *r) {
FRAME_CONTEXT *ec_ctx = xd->tile_ctx;
@@ -1288,15 +1289,18 @@
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, sub_txs, tx_size);
#if LOOP_FILTER_BITMASK
- store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, BLOCK_8X8,
- TX_4X4, mbmi);
+ if (store_bitmask) {
+ store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
+ txsize_to_bsize[tx_size], TX_4X4, mbmi);
+ }
#endif
return;
}
#if LOOP_FILTER_BITMASK
- if (depth + 1 == MAX_VARTX_DEPTH) {
+ if (depth + 1 == MAX_VARTX_DEPTH && store_bitmask) {
store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
txsize_to_bsize[tx_size], sub_txs, mbmi);
+ store_bitmask = 0;
}
#endif
@@ -1307,7 +1311,7 @@
int offsetc = blk_col + col;
read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1,
#if LOOP_FILTER_BITMASK
- cm, mi_row, mi_col,
+ cm, mi_row, mi_col, store_bitmask,
#endif
offsetr, offsetc, r);
}
@@ -1324,8 +1328,10 @@
txfm_partition_update(xd->above_txfm_context + blk_col,
xd->left_txfm_context + blk_row, tx_size, tx_size);
#if LOOP_FILTER_BITMASK
- store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
- txsize_to_bsize[tx_size], tx_size, mbmi);
+ if (store_bitmask) {
+ store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col,
+ txsize_to_bsize[tx_size], tx_size, mbmi);
+ }
#endif
}
}
@@ -1505,7 +1511,9 @@
}
static void store_bitmask_other_info(AV1_COMMON *cm, int mi_row, int mi_col,
- BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) {
+ BLOCK_SIZE bsize, MB_MODE_INFO *mbmi,
+ int is_horz_coding_block_border,
+ int is_vert_coding_block_border) {
int index;
int shift;
int row;
@@ -1513,14 +1521,19 @@
const int row_start = mi_row % MI_SIZE_64X64;
const int col_start = mi_col % MI_SIZE_64X64;
shift = get_index_shift(col_start, row_start, &index);
- const uint64_t top_edge_mask =
- ((uint64_t)1 << (shift + mi_size_wide[bsize])) - ((uint64_t)1 << shift);
- lfm->is_horz_border.bits[index] |= top_edge_mask;
- const int is_vert_border = mask_id_table_vert_border[bsize];
- const int vert_shift = block_size_high[bsize] <= 8 ? shift : col_start;
- for (int i = 0; i + index < 4; ++i) {
- lfm->is_vert_border.bits[i + index] |=
- (left_mask_univariant_reordered[is_vert_border].bits[i] << vert_shift);
+ if (is_horz_coding_block_border) {
+ const uint64_t top_edge_mask =
+ ((uint64_t)1 << (shift + mi_size_wide[bsize])) - ((uint64_t)1 << shift);
+ lfm->is_horz_border.bits[index] |= top_edge_mask;
+ }
+ if (is_vert_coding_block_border) {
+ const int is_vert_border = mask_id_table_vert_border[bsize];
+ const int vert_shift = block_size_high[bsize] <= 8 ? shift : col_start;
+ for (int i = 0; i + index < 4; ++i) {
+ lfm->is_vert_border.bits[i + index] |=
+ (left_mask_univariant_reordered[is_vert_border].bits[i]
+ << vert_shift);
+ }
}
const int is_skip = mbmi->skip && is_inter_block(mbmi);
if (is_skip) {
@@ -1574,7 +1587,7 @@
for (int idx = 0; idx < width; idx += bw)
read_tx_size_vartx(xd, mbmi, max_tx_size, 0,
#if LOOP_FILTER_BITMASK
- cm, mi_row, mi_col,
+ cm, mi_row, mi_col, 1,
#endif
idy, idx, r);
} else {
@@ -1602,12 +1615,12 @@
const int w = mi_size_wide[bsize];
const int h = mi_size_high[bsize];
if (w <= mi_size_wide[BLOCK_64X64] && h <= mi_size_high[BLOCK_64X64]) {
- store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi);
+ store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi, 1, 1);
} else {
for (int row = 0; row < h; row += mi_size_high[BLOCK_64X64]) {
for (int col = 0; col < w; col += mi_size_wide[BLOCK_64X64]) {
store_bitmask_other_info(cm, mi_row + row, mi_col + col, BLOCK_64X64,
- mbmi);
+ mbmi, row == 0, col == 0);
}
}
}
