Bitmask patch 4: Store transform size info for vartx To store tx_size information, instead of advancing by 4x4 step vertically and tx_size step horizontally (for vertical edges, similar to horizontal edges), follow recursion in vartx parsing. Benefit: Suppose the block is 32x32 with transform sizes 16x16, the original traversal needs 8*2(vertical) + 8*2(horizontal) = 32 steps. Now, it needs 4 steps. Change-Id: I0a9154e2943107613b4b2fcda47324aafb3a7c80
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c index d136d09..6258d99 100644 --- a/av1/decoder/decodeframe.c +++ b/av1/decoder/decodeframe.c
@@ -1232,9 +1232,18 @@ set_color_index_map_offset); } +#if LOOP_FILTER_BITMASK +static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col, + BLOCK_SIZE bsize, TX_SIZE tx_size, + MB_MODE_INFO *mbmi); +#endif + static void read_tx_size_vartx(MACROBLOCKD *xd, MB_MODE_INFO *mbmi, - TX_SIZE tx_size, int depth, int blk_row, - int blk_col, aom_reader *r) { + TX_SIZE tx_size, int depth, +#if LOOP_FILTER_BITMASK + AV1_COMMON *cm, int mi_row, int mi_col, +#endif + int blk_row, int blk_col, aom_reader *r) { FRAME_CONTEXT *ec_ctx = xd->tile_ctx; int is_split = 0; const BLOCK_SIZE bsize = mbmi->sb_type; @@ -1278,15 +1287,29 @@ mbmi->tx_size = sub_txs; 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); +#endif return; } +#if LOOP_FILTER_BITMASK + if (depth + 1 == MAX_VARTX_DEPTH) { + store_bitmask_vartx(cm, mi_row + blk_row, mi_col + blk_col, + txsize_to_bsize[tx_size], sub_txs, mbmi); + } +#endif assert(bsw > 0 && bsh > 0); for (int row = 0; row < tx_size_high_unit[tx_size]; row += bsh) { for (int col = 0; col < tx_size_wide_unit[tx_size]; col += bsw) { int offsetr = blk_row + row; int offsetc = blk_col + col; - read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, offsetr, offsetc, r); + read_tx_size_vartx(xd, mbmi, sub_txs, depth + 1, +#if LOOP_FILTER_BITMASK + cm, mi_row, mi_col, +#endif + offsetr, offsetc, r); } } } else { @@ -1300,6 +1323,10 @@ mbmi->tx_size = tx_size; 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); +#endif } } @@ -1338,211 +1365,179 @@ } #if LOOP_FILTER_BITMASK -static void store_bitmask_info(AV1_COMMON *cm, int mi_row, int mi_col, - BLOCK_SIZE bsize, MB_MODE_INFO *mbmi, int type) { +static void store_bitmask_vartx(AV1_COMMON *cm, int mi_row, int mi_col, + BLOCK_SIZE bsize, TX_SIZE tx_size, + MB_MODE_INFO *mbmi) { + LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); + const TX_SIZE tx_size_y_vert = txsize_vert_map[tx_size]; + const TX_SIZE tx_size_y_horz = txsize_horz_map[tx_size]; + const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize( + mbmi->sb_type, cm->seq_params.subsampling_x, + cm->seq_params.subsampling_y)]; + const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize( + mbmi->sb_type, cm->seq_params.subsampling_x, + cm->seq_params.subsampling_y)]; + const int is_square_transform_size = tx_size <= TX_64X64; + int mask_id = 0; + int offset = 0; + const int half_ratio_tx_size_max32 = + (tx_size > TX_64X64) & (tx_size <= TX_32X16); + if (is_square_transform_size) { + switch (tx_size) { + case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break; + case TX_8X8: + mask_id = mask_id_table_tx_8x8[bsize]; + offset = 19; + break; + case TX_16X16: + mask_id = mask_id_table_tx_16x16[bsize]; + offset = 33; + break; + case TX_32X32: + mask_id = mask_id_table_tx_32x32[bsize]; + offset = 42; + break; + case TX_64X64: mask_id = 46; break; + default: assert(!is_square_transform_size); return; + } + mask_id += offset; + } else if (half_ratio_tx_size_max32) { + int tx_size_equal_block_size = bsize == txsize_to_bsize[tx_size]; + mask_id = 47 + 2 * (tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1); + } else if (tx_size == TX_32X64) { + mask_id = 59; + } else if (tx_size == TX_64X32) { + mask_id = 60; + } else { // quarter ratio tx size + mask_id = 61 + (tx_size - TX_4X16); + } + int index = 0; + const int row = mi_row % MI_SIZE_64X64; + const int col = mi_col % MI_SIZE_64X64; + const int shift = get_index_shift(col, row, &index); + const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col; + for (int i = 0; i + index < 4; ++i) { + // y vertical. + lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= + (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); + // y horizontal. + lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |= + (above_mask_univariant_reordered[mask_id].bits[i] << shift); + // u/v vertical. + lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= + (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); + // u/v horizontal. + lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |= + (above_mask_univariant_reordered[mask_id].bits[i] << shift); + } +} + +static void store_bitmask_univariant_tx(AV1_COMMON *cm, int mi_row, int mi_col, + BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) { + // Use a lookup table that provides one bitmask for a given block size and + // a univariant transform size. int index; int shift; int row; int col; - if (type == 0) { - // TODO(chengchen): optimize step - LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); - // vertical direction - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; ++r) { - for (int c = mi_col; c < mi_col + mi_size_wide[bsize];) { - index = 0; - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - const uint64_t mask = ((uint64_t)1 << shift); - // Y plane - const int blk_row = r & (mi_size_high[bsize] - 1); - const int blk_col = c & (mi_size_wide[bsize] - 1); - const TX_SIZE mb_tx_size = mbmi->inter_tx_size[av1_get_txb_size_index( - bsize, blk_row, blk_col)]; - const TX_SIZE tx_size = txsize_horz_map[mb_tx_size]; - lfm->tx_size_ver[0][tx_size].bits[index] |= mask; - // U/V plane - const TX_SIZE tx_size_uv = txsize_horz_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - lfm->tx_size_ver[1][tx_size_uv].bits[index] |= mask; - - c += tx_size_wide_unit[tx_size]; - } + LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); + const TX_SIZE tx_size_y_vert = txsize_vert_map[mbmi->tx_size]; + const TX_SIZE tx_size_y_horz = txsize_horz_map[mbmi->tx_size]; + const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize( + mbmi->sb_type, cm->seq_params.subsampling_x, + cm->seq_params.subsampling_y)]; + const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize( + mbmi->sb_type, cm->seq_params.subsampling_x, + cm->seq_params.subsampling_y)]; + const int is_square_transform_size = mbmi->tx_size <= TX_64X64; + int mask_id = 0; + int offset = 0; + const int half_ratio_tx_size_max32 = + (mbmi->tx_size > TX_64X64) & (mbmi->tx_size <= TX_32X16); + if (is_square_transform_size) { + switch (mbmi->tx_size) { + case TX_4X4: mask_id = mask_id_table_tx_4x4[bsize]; break; + case TX_8X8: + mask_id = mask_id_table_tx_8x8[bsize]; + offset = 19; + break; + case TX_16X16: + mask_id = mask_id_table_tx_16x16[bsize]; + offset = 33; + break; + case TX_32X32: + mask_id = mask_id_table_tx_32x32[bsize]; + offset = 42; + break; + case TX_64X64: mask_id = 46; break; + default: assert(!is_square_transform_size); return; } - // horizontal direction - for (int c = mi_col; c < mi_col + mi_size_wide[bsize]; ++c) { - for (int r = mi_row; r < mi_row + mi_size_high[bsize];) { - index = 0; - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - const uint64_t mask = ((uint64_t)1 << shift); - // Y plane - const int blk_row = r & (mi_size_high[bsize] - 1); - const int blk_col = c & (mi_size_wide[bsize] - 1); - const TX_SIZE mb_tx_size = mbmi->inter_tx_size[av1_get_txb_size_index( - bsize, blk_row, blk_col)]; - const TX_SIZE tx_size = txsize_vert_map[mb_tx_size]; - lfm->tx_size_hor[0][tx_size].bits[index] |= mask; - // U/V plane - const TX_SIZE tx_size_uv = txsize_vert_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - lfm->tx_size_hor[1][tx_size_uv].bits[index] |= mask; - - r += tx_size_high_unit[tx_size]; - } - } - // store other info - 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 uint8_t level_vert_y = get_filter_level(cm, &cm->lf_info, 0, 0, mbmi); - const uint8_t level_horz_y = get_filter_level(cm, &cm->lf_info, 1, 0, mbmi); - const uint8_t level_u = get_filter_level(cm, &cm->lf_info, 0, 1, mbmi); - const uint8_t level_v = get_filter_level(cm, &cm->lf_info, 0, 2, mbmi); - const int is_skip = mbmi->skip && is_inter_block(mbmi); - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; r++) { - index = 0; - row = r % MI_SIZE_64X64; - shift = get_index_shift(col_start, row, &index); - const uint64_t mask = ((uint64_t)1 << shift); - lfm->is_vert_border.bits[index] |= mask; - const uint64_t skip_mask = - ((uint64_t)1 << (shift + mi_size_wide[bsize])) - mask; - if (is_skip) lfm->skip.bits[index] |= skip_mask; - memset(&lfm->lfl_y_ver[row][col_start], level_vert_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_y_hor[row][col_start], level_horz_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_u[row][col_start], level_u, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_v[row][col_start], level_v, - sizeof(uint8_t) * mi_size_wide[bsize]); - } - } else { - // TODO(chengchen): optimize step - LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); - const TX_SIZE tx_size_y_vert = txsize_vert_map[mbmi->tx_size]; - const TX_SIZE tx_size_y_horz = txsize_horz_map[mbmi->tx_size]; - const TX_SIZE tx_size_uv_vert = txsize_vert_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - const TX_SIZE tx_size_uv_horz = txsize_horz_map[av1_get_max_uv_txsize( - mbmi->sb_type, cm->seq_params.subsampling_x, - cm->seq_params.subsampling_y)]; - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; - r += tx_size_high_unit[mbmi->tx_size]) { - for (int c = mi_col; c < mi_col + mi_size_wide[bsize]; - c += tx_size_wide_unit[mbmi->tx_size]) { - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - if (tx_size_y_vert <= TX_8X8) { - lfm->tx_size_ver[0][tx_size_y_horz].bits[index] |= - (left_txform_mask[tx_size_y_vert].bits[0] << shift); - } else if (tx_size_y_vert == TX_16X16) { - lfm->tx_size_ver[0][tx_size_y_horz].bits[index] |= - (left_txform_mask[tx_size_y_vert].bits[0] << col); - } else if (tx_size_y_vert == TX_32X32) { - for (int i = 0; i < 2; ++i) { - lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= - (left_txform_mask[tx_size_y_vert].bits[i] << col); - } - } else { - for (int i = 0; i < 4; ++i) { - lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= - (left_txform_mask[tx_size_y_vert].bits[i] << col); - } - } - } - } - // u/v vertical. - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; - r += tx_size_high_unit[tx_size_uv_vert]) { - for (int c = mi_col; c < mi_col + mi_size_wide[bsize]; - c += tx_size_wide_unit[tx_size_uv_horz]) { - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - if (tx_size_uv_vert <= TX_8X8) { - lfm->tx_size_ver[1][tx_size_uv_horz].bits[index] |= - (left_txform_mask[tx_size_uv_vert].bits[0] << shift); - } else if (tx_size_uv_vert == TX_16X16) { - lfm->tx_size_ver[1][tx_size_uv_horz].bits[index] |= - (left_txform_mask[tx_size_uv_vert].bits[0] << col); - } else if (tx_size_uv_vert == TX_32X32) { - for (int i = 0; i < 2; ++i) { - lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= - (left_txform_mask[tx_size_uv_vert].bits[i] << col); - } - } else { - for (int i = 0; i < 4; ++i) { - lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= - (left_txform_mask[tx_size_uv_vert].bits[i] << col); - } - } - } - } - // horizontal direction + mask_id += offset; + } else if (half_ratio_tx_size_max32) { + int tx_size_equal_block_size = bsize == txsize_to_bsize[mbmi->tx_size]; + mask_id = + 47 + 2 * (mbmi->tx_size - TX_4X8) + (tx_size_equal_block_size ? 0 : 1); + } else if (mbmi->tx_size == TX_32X64) { + mask_id = 59; + } else if (mbmi->tx_size == TX_64X32) { + mask_id = 60; + } else { // quarter ratio tx size + mask_id = 61 + (mbmi->tx_size - TX_4X16); + } + row = mi_row % MI_SIZE_64X64; + col = mi_col % MI_SIZE_64X64; + shift = get_index_shift(col, row, &index); + const int vert_shift = tx_size_y_vert <= TX_8X8 ? shift : col; + for (int i = 0; i + index < 4; ++i) { + // y vertical. + lfm->tx_size_ver[0][tx_size_y_horz].bits[i + index] |= + (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); // y horizontal. - for (int c = mi_col; c < mi_col + mi_size_wide[bsize]; - c += tx_size_wide_unit[mbmi->tx_size]) { - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; - r += tx_size_high_unit[mbmi->tx_size]) { - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - lfm->tx_size_hor[0][tx_size_y_vert].bits[index] |= - (above_txform_mask[0][tx_size_y_horz] << shift); - } - } + lfm->tx_size_hor[0][tx_size_y_vert].bits[i + index] |= + (above_mask_univariant_reordered[mask_id].bits[i] << shift); + // u/v vertical. + lfm->tx_size_ver[1][tx_size_uv_horz].bits[i + index] |= + (left_mask_univariant_reordered[mask_id].bits[i] << vert_shift); // u/v horizontal. - for (int c = mi_col; c < mi_col + mi_size_wide[bsize]; - c += tx_size_wide_unit[tx_size_uv_horz]) { - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; - r += tx_size_high_unit[tx_size_uv_vert]) { - row = r % MI_SIZE_64X64; - col = c % MI_SIZE_64X64; - shift = get_index_shift(col, row, &index); - lfm->tx_size_hor[1][tx_size_uv_vert].bits[index] |= - (above_txform_mask[0][tx_size_uv_horz] << shift); - } - } - // store other info - 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 uint8_t level_vert_y = get_filter_level(cm, &cm->lf_info, 0, 0, mbmi); - const uint8_t level_horz_y = get_filter_level(cm, &cm->lf_info, 1, 0, mbmi); - const uint8_t level_u = get_filter_level(cm, &cm->lf_info, 0, 1, mbmi); - const uint8_t level_v = get_filter_level(cm, &cm->lf_info, 0, 2, mbmi); - const int is_skip = mbmi->skip && is_inter_block(mbmi); - for (int r = mi_row; r < mi_row + mi_size_high[bsize]; r++) { - row = r % MI_SIZE_64X64; - shift = get_index_shift(col_start, row, &index); - const uint64_t mask = ((uint64_t)1 << shift); - lfm->is_vert_border.bits[index] |= mask; - const uint64_t skip_mask = - ((uint64_t)1 << (shift + mi_size_wide[bsize])) - mask; - if (is_skip) lfm->skip.bits[index] |= skip_mask; - memset(&lfm->lfl_y_ver[row][col_start], level_vert_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_y_hor[row][col_start], level_horz_y, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_u[row][col_start], level_u, - sizeof(uint8_t) * mi_size_wide[bsize]); - memset(&lfm->lfl_v[row][col_start], level_v, - sizeof(uint8_t) * mi_size_wide[bsize]); - } + lfm->tx_size_hor[1][tx_size_uv_vert].bits[i + index] |= + (above_mask_univariant_reordered[mask_id].bits[i] << shift); + } +} + +static void store_bitmask_other_info(AV1_COMMON *cm, int mi_row, int mi_col, + BLOCK_SIZE bsize, MB_MODE_INFO *mbmi) { + int index; + int shift; + int row; + LoopFilterMask *lfm = get_loop_filter_mask(cm, mi_row, mi_col); + 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 uint8_t level_vert_y = get_filter_level(cm, &cm->lf_info, 0, 0, mbmi); + const uint8_t level_horz_y = get_filter_level(cm, &cm->lf_info, 1, 0, mbmi); + const uint8_t level_u = get_filter_level(cm, &cm->lf_info, 0, 1, mbmi); + const uint8_t level_v = get_filter_level(cm, &cm->lf_info, 0, 2, mbmi); + const int is_skip = mbmi->skip && is_inter_block(mbmi); + for (int r = mi_row; r < mi_row + mi_size_high[bsize]; r++) { + index = 0; + row = r % MI_SIZE_64X64; + shift = get_index_shift(col_start, row, &index); + const uint64_t mask = ((uint64_t)1 << shift); + lfm->is_vert_border.bits[index] |= mask; + const uint64_t skip_mask = + ((uint64_t)1 << (shift + mi_size_wide[bsize])) - mask; + if (is_skip) lfm->skip.bits[index] |= skip_mask; + memset(&lfm->lfl_y_ver[row][col_start], level_vert_y, + sizeof(uint8_t) * mi_size_wide[bsize]); + memset(&lfm->lfl_y_hor[row][col_start], level_horz_y, + sizeof(uint8_t) * mi_size_wide[bsize]); + memset(&lfm->lfl_u[row][col_start], level_u, + sizeof(uint8_t) * mi_size_wide[bsize]); + memset(&lfm->lfl_v[row][col_start], level_v, + sizeof(uint8_t) * mi_size_wide[bsize]); } } #endif @@ -1570,21 +1565,11 @@ for (int idy = 0; idy < height; idy += bh) for (int idx = 0; idx < width; idx += bw) - read_tx_size_vartx(xd, mbmi, max_tx_size, 0, idy, idx, r); + read_tx_size_vartx(xd, mbmi, max_tx_size, 0, #if LOOP_FILTER_BITMASK - 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_info(cm, mi_row, mi_col, bsize, mbmi, 0); - } 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_info(cm, mi_row + row, mi_col + col, BLOCK_64X64, mbmi, - 0); - } - } - } + cm, mi_row, mi_col, #endif + idy, idx, r); } else { mbmi->tx_size = read_tx_size(cm, xd, inter_block_tx, !mbmi->skip, r); if (inter_block_tx) @@ -1595,17 +1580,20 @@ 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_info(cm, mi_row, mi_col, bsize, mbmi, 1); + store_bitmask_univariant_tx(cm, mi_row, mi_col, bsize, mbmi); } 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_info(cm, mi_row + row, mi_col + col, BLOCK_64X64, mbmi, - 1); + store_bitmask_univariant_tx(cm, mi_row + row, mi_col + col, + BLOCK_64X64, mbmi); } } } #endif } +#if LOOP_FILTER_BITMASK + store_bitmask_other_info(cm, mi_row, mi_col, bsize, mbmi); +#endif if (cm->delta_q_present_flag) { for (int i = 0; i < MAX_SEGMENTS; i++) {