Remove experimental flag of chroma_sub8x8
Change-Id: I32c5015bedef07f58413c679b4aaf30651a357b9
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index 611ef74..2976422 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -385,11 +385,9 @@
// 00000000
// 00000000
static const uint64_t left_prediction_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0000000000000001ULL, // BLOCK_2X2,
0x0000000000000001ULL, // BLOCK_2X4,
0x0000000000000001ULL, // BLOCK_4X2,
-#endif
0x0000000000000001ULL, // BLOCK_4X4,
0x0000000000000001ULL, // BLOCK_4X8,
0x0000000000000001ULL, // BLOCK_8X4,
@@ -413,11 +411,9 @@
// 64 bit mask to shift and set for each prediction size.
static const uint64_t above_prediction_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0000000000000001ULL, // BLOCK_2X2
0x0000000000000001ULL, // BLOCK_2X4
0x0000000000000001ULL, // BLOCK_4X2
-#endif
0x0000000000000001ULL, // BLOCK_4X4
0x0000000000000001ULL, // BLOCK_4X8
0x0000000000000001ULL, // BLOCK_8X4
@@ -442,11 +438,9 @@
// each 8x8 block that would be in the top left most block of the given block
// size in the 64x64 block.
static const uint64_t size_mask[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0000000000000001ULL, // BLOCK_2X2
0x0000000000000001ULL, // BLOCK_2X4
0x0000000000000001ULL, // BLOCK_4X2
-#endif
0x0000000000000001ULL, // BLOCK_4X4
0x0000000000000001ULL, // BLOCK_4X8
0x0000000000000001ULL, // BLOCK_8X4
@@ -495,11 +489,9 @@
// 16 bit left mask to shift and set for each uv prediction size.
static const uint16_t left_prediction_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0001, // BLOCK_2X2,
0x0001, // BLOCK_2X4,
0x0001, // BLOCK_4X2,
-#endif
0x0001, // BLOCK_4X4,
0x0001, // BLOCK_4X8,
0x0001, // BLOCK_8X4,
@@ -523,11 +515,9 @@
// 16 bit above mask to shift and set for uv each prediction size.
static const uint16_t above_prediction_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0001, // BLOCK_2X2
0x0001, // BLOCK_2X4
0x0001, // BLOCK_4X2
-#endif
0x0001, // BLOCK_4X4
0x0001, // BLOCK_4X8
0x0001, // BLOCK_8X4
@@ -551,11 +541,9 @@
// 64 bit mask to shift and set for each uv prediction size
static const uint16_t size_mask_uv[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0x0001, // BLOCK_2X2
0x0001, // BLOCK_2X4
0x0001, // BLOCK_4X2
-#endif
0x0001, // BLOCK_4X4
0x0001, // BLOCK_4X8
0x0001, // BLOCK_8X4
@@ -2144,12 +2132,8 @@
(blk_row * mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2) >> 1;
const int tx_col_idx =
(blk_col * mi_size_wide[BLOCK_8X8] << TX_UNIT_WIDE_LOG2) >> 1;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(mbmi->sb_type, plane));
-#else
- const BLOCK_SIZE bsize = get_plane_block_size(mbmi->sb_type, plane);
-#endif
const TX_SIZE mb_tx_size = mbmi->inter_tx_size[tx_row_idx][tx_col_idx];
tx_size = (plane->plane_type == PLANE_TYPE_UV)
? uv_txsize_lookup[bsize][mb_tx_size][0][0]
@@ -2628,11 +2612,9 @@
static const uint32_t av1_prediction_masks[NUM_EDGE_DIRS][BLOCK_SIZES_ALL] = {
// mask for vertical edges filtering
{
-#if CONFIG_CHROMA_SUB8X8
2 - 1, // BLOCK_2X2
2 - 1, // BLOCK_2X4
4 - 1, // BLOCK_4X2
-#endif // CONFIG_CHROMA_SUB8X8
4 - 1, // BLOCK_4X4
4 - 1, // BLOCK_4X8
8 - 1, // BLOCK_8X4
@@ -2664,11 +2646,9 @@
},
// mask for horizontal edges filtering
{
-#if CONFIG_CHROMA_SUB8X8
2 - 1, // BLOCK_2X2
4 - 1, // BLOCK_2X4
2 - 1, // BLOCK_4X2
-#endif // CONFIG_CHROMA_SUB8X8
4 - 1, // BLOCK_4X4
8 - 1, // BLOCK_4X8
4 - 1, // BLOCK_8X4
@@ -2779,13 +2759,8 @@
(blk_row * mi_size_high[BLOCK_8X8] << TX_UNIT_HIGH_LOG2) >> 1;
const int tx_col_idx =
(blk_col * mi_size_wide[BLOCK_8X8] << TX_UNIT_WIDE_LOG2) >> 1;
-
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE bsize =
AOMMAX(BLOCK_4X4, ss_size_lookup[sb_type][scale_horz][scale_vert]);
-#else
- const BLOCK_SIZE bsize = ss_size_lookup[sb_type][scale_horz][scale_vert];
-#endif
const TX_SIZE mb_tx_size = mbmi->inter_tx_size[tx_row_idx][tx_col_idx];
assert(mb_tx_size < TX_SIZES_ALL);
diff --git a/av1/common/blockd.c b/av1/common/blockd.c
index 89a4caf..45a560e 100644
--- a/av1/common/blockd.c
+++ b/av1/common/blockd.c
@@ -128,12 +128,8 @@
// 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);
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
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;
@@ -235,12 +231,8 @@
nplanes = 1 + (MAX_MB_PLANE - 1) * chroma_ref;
for (i = 0; i < nplanes; i++) {
struct macroblockd_plane *const pd = &xd->plane[i];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
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];
memset(pd->above_context, 0, sizeof(ENTROPY_CONTEXT) * txs_wide);
diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 1c50596..64f6e1e 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -31,12 +31,6 @@
extern "C" {
#endif
-#if (CONFIG_CHROMA_SUB8X8)
-#define SUB8X8_COMP_REF 0
-#else
-#define SUB8X8_COMP_REF 1
-#endif
-
#define MAX_MB_PLANE 3
#if CONFIG_COMPOUND_SEGMENT
@@ -72,11 +66,7 @@
static INLINE int is_comp_ref_allowed(BLOCK_SIZE bsize) {
(void)bsize;
-#if SUB8X8_COMP_REF
- return 1;
-#else
return AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8;
-#endif // SUB8X8_COMP_REF
}
static INLINE int is_inter_mode(PREDICTION_MODE mode) {
@@ -611,11 +601,11 @@
#endif // CONFIG_LOOP_RESTORATION
#if CONFIG_CFL
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
#define CFL_SUB8X8_VAL_MI_SIZE (4)
#define CFL_SUB8X8_VAL_MI_SQUARE \
(CFL_SUB8X8_VAL_MI_SIZE * CFL_SUB8X8_VAL_MI_SIZE)
-#endif // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_DEBUG
typedef struct cfl_ctx {
// The CfL prediction buffer is used in two steps:
// 1. Stores Q3 reconstructed luma pixels
@@ -644,12 +634,12 @@
int store_y;
int is_chroma_reference;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
// The prediction used for sub8x8 blocks originates from multiple luma blocks,
// this array is used to validate that cfl_store() is called only once for
// each luma block
uint8_t sub8x8_val[CFL_SUB8X8_VAL_MI_SQUARE];
-#endif // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_DEBUG
} CFL_CTX;
#endif // CONFIG_CFL
@@ -671,10 +661,8 @@
int up_available;
int left_available;
-#if CONFIG_CHROMA_SUB8X8
int chroma_up_available;
int chroma_left_available;
-#endif
const aom_prob (*partition_probs)[PARTITION_TYPES - 1];
@@ -1027,11 +1015,9 @@
#if CONFIG_RECT_TX
static INLINE int is_rect_tx_allowed_bsize(BLOCK_SIZE bsize) {
static const char LUT[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0, // BLOCK_2X2
0, // BLOCK_2X4
0, // BLOCK_4X2
-#endif
0, // BLOCK_4X4
1, // BLOCK_4X8
1, // BLOCK_8X4
@@ -1076,11 +1062,9 @@
#if CONFIG_RECT_TX_EXT
static INLINE int is_quarter_tx_allowed_bsize(BLOCK_SIZE bsize) {
static const char LUT_QTTX[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
0, // BLOCK_2X2
0, // BLOCK_2X4
0, // BLOCK_4X2
-#endif
0, // BLOCK_4X4
0, // BLOCK_4X8
0, // BLOCK_8X4
diff --git a/av1/common/cfl.c b/av1/common/cfl.c
index f9acfcb..e286eb3 100644
--- a/av1/common/cfl.c
+++ b/av1/common/cfl.c
@@ -24,9 +24,9 @@
cfl->subsampling_y = cm->subsampling_y;
cfl->are_parameters_computed = 0;
cfl->store_y = 0;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
cfl_clear_sub8x8_val(cfl);
-#endif // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_DEBUG
}
// Due to frame boundary issues, it is possible that the total area covered by
@@ -169,20 +169,16 @@
int sum_u = 0;
int sum_v = 0;
-// Match behavior of build_intra_predictors_high (reconintra.c) at superblock
-// boundaries:
-// base-1 base-1 base-1 .. base-1 base-1 base-1 base-1 base-1 base-1
-// base+1 A B .. Y Z
-// base+1 C D .. W X
-// base+1 E F .. U V
-// base+1 G H .. S T T T T T
-// ..
+ // Match behavior of build_intra_predictors_high (reconintra.c) at superblock
+ // boundaries:
+ // base-1 base-1 base-1 .. base-1 base-1 base-1 base-1 base-1 base-1
+ // base+1 A B .. Y Z
+ // base+1 C D .. W X
+ // base+1 E F .. U V
+ // base+1 G H .. S T T T T T
+ // ..
-#if CONFIG_CHROMA_SUB8X8
if (xd->chroma_up_available && xd->mb_to_right_edge >= 0) {
-#else
- if (xd->up_available && xd->mb_to_right_edge >= 0) {
-#endif
sum_above_row(xd, width, &sum_u, &sum_v);
} else {
const int base = 128 << (xd->bd - 8);
@@ -190,11 +186,7 @@
sum_v = width * (base - 1);
}
-#if CONFIG_CHROMA_SUB8X8
if (xd->chroma_left_available && xd->mb_to_bottom_edge >= 0) {
-#else
- if (xd->left_available && xd->mb_to_bottom_edge >= 0) {
-#endif
sum_left_col(xd, height, &sum_u, &sum_v);
} else {
const int base = 128 << (xd->bd - 8);
@@ -454,7 +446,6 @@
}
}
-#if CONFIG_CHROMA_SUB8X8
// Adjust the row and column of blocks smaller than 8X8, as chroma-referenced
// and non-chroma-referenced blocks are stored together in the CfL buffer.
static INLINE void sub8x8_adjust_offset(const CFL_CTX *cfl, int *row_out,
@@ -485,7 +476,6 @@
}
}
#endif // CONFIG_DEBUG
-#endif // CONFIG_CHROMA_SUB8X8
void cfl_store_tx(MACROBLOCKD *const xd, int row, int col, TX_SIZE tx_size,
BLOCK_SIZE bsize) {
@@ -494,8 +484,6 @@
uint8_t *dst =
&pd->dst.buf[(row * pd->dst.stride + col) << tx_size_wide_log2[0]];
(void)bsize;
-#if CONFIG_CHROMA_SUB8X8
-
if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
// Only dimensions of size 4 can have an odd offset.
assert(!((col & 1) && tx_size_wide[tx_size] != 4));
@@ -506,7 +494,6 @@
tx_size_wide_unit[tx_size]);
#endif // CONFIG_DEBUG
}
-#endif
cfl_store(cfl, dst, pd->dst.stride, row, col, tx_size_wide[tx_size],
tx_size_high[tx_size], get_bitdepth_data_path_index(xd));
}
@@ -516,7 +503,6 @@
struct macroblockd_plane *const pd = &xd->plane[AOM_PLANE_Y];
int row = 0;
int col = 0;
-#if CONFIG_CHROMA_SUB8X8
bsize = AOMMAX(BLOCK_4X4, bsize);
if (block_size_high[bsize] == 4 || block_size_wide[bsize] == 4) {
sub8x8_adjust_offset(cfl, &row, &col);
@@ -524,7 +510,6 @@
sub8x8_set_val(cfl, row, col, mi_size_high[bsize], mi_size_wide[bsize]);
#endif // CONFIG_DEBUG
}
-#endif // CONFIG_CHROMA_SUB8X8
const int width = max_intra_block_width(xd, bsize, AOM_PLANE_Y, tx_size);
const int height = max_intra_block_height(xd, bsize, AOM_PLANE_Y, tx_size);
cfl_store(cfl, pd->dst.buf, pd->dst.stride, row, col, width, height,
@@ -538,7 +523,6 @@
// Do not call cfl_compute_parameters multiple time on the same values.
assert(cfl->are_parameters_computed == 0);
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize = AOMMAX(
BLOCK_4X4, get_plane_block_size(mbmi->sb_type, &xd->plane[AOM_PLANE_U]));
#if CONFIG_DEBUG
@@ -551,10 +535,6 @@
cfl_clear_sub8x8_val(cfl);
}
#endif // CONFIG_DEBUG
-#else
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(mbmi->sb_type, &xd->plane[AOM_PLANE_U]);
-#endif
// AOM_PLANE_U is used, but both planes will have the same sizes.
cfl->uv_width = max_intra_block_width(xd, plane_bsize, AOM_PLANE_U, tx_size);
cfl->uv_height =
diff --git a/av1/common/common_data.h b/av1/common/common_data.h
index 522ac28..f487bb8 100644
--- a/av1/common/common_data.h
+++ b/av1/common/common_data.h
@@ -28,253 +28,373 @@
// Log 2 conversion lookup tables for block width and height
static const uint8_t b_width_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 0, 0,
0,
-#endif
- 0, 0,
- 1, 1,
- 1, 2,
- 2, 2,
- 3, 3,
- 3, 4,
- 4, IF_EXT_PARTITION(4, 5, 5) 0,
- 2, 1,
- 3, 2,
- 4, IF_EXT_PARTITION(3, 5)
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 3,
+ 3,
+ 3,
+ 4,
+ 4,
+ IF_EXT_PARTITION(4, 5, 5) 0,
+ 2,
+ 1,
+ 3,
+ 2,
+ 4,
+ IF_EXT_PARTITION(3, 5)
};
static const uint8_t b_height_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 0, 0,
0,
-#endif
- 0, 1,
- 0, 1,
- 2, 1,
- 2, 3,
- 2, 3,
- 4, 3,
- 4, IF_EXT_PARTITION(5, 4, 5) 2,
- 0, 3,
- 1, 4,
- 2, IF_EXT_PARTITION(5, 3)
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 2,
+ 1,
+ 2,
+ 3,
+ 2,
+ 3,
+ 4,
+ 3,
+ 4,
+ IF_EXT_PARTITION(5, 4, 5) 2,
+ 0,
+ 3,
+ 1,
+ 4,
+ 2,
+ IF_EXT_PARTITION(5, 3)
};
// Log 2 conversion lookup tables for modeinfo width and height
static const uint8_t mi_width_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 0, 0,
0,
-#endif
- 0, 0,
- 1, 1,
- 1, 2,
- 2, 2,
- 3, 3,
- 3, 4,
- 4, IF_EXT_PARTITION(4, 5, 5) 0,
- 2, 1,
- 3, 2,
- 4, IF_EXT_PARTITION(3, 5)
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 3,
+ 3,
+ 3,
+ 4,
+ 4,
+ IF_EXT_PARTITION(4, 5, 5) 0,
+ 2,
+ 1,
+ 3,
+ 2,
+ 4,
+ IF_EXT_PARTITION(3, 5)
};
static const uint8_t mi_height_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 0, 0,
0,
-#endif
- 0, 1,
- 0, 1,
- 2, 1,
- 2, 3,
- 2, 3,
- 4, 3,
- 4, IF_EXT_PARTITION(5, 4, 5) 2,
- 0, 3,
- 1, 4,
- 2, IF_EXT_PARTITION(5, 3)
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 2,
+ 1,
+ 2,
+ 3,
+ 2,
+ 3,
+ 4,
+ 3,
+ 4,
+ IF_EXT_PARTITION(5, 4, 5) 2,
+ 0,
+ 3,
+ 1,
+ 4,
+ 2,
+ IF_EXT_PARTITION(5, 3)
};
/* clang-format off */
static const uint8_t mi_size_wide[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1, 1,
-#endif
- 1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16,
+ 1, 1, 1, 1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16,
IF_EXT_PARTITION(16, 32, 32) 1, 4, 2, 8, 4, 16, IF_EXT_PARTITION(8, 32)
};
static const uint8_t mi_size_high[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1, 1,
-#endif
- 1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16,
+ 1, 1, 1, 1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16,
IF_EXT_PARTITION(32, 16, 32) 4, 1, 8, 2, 16, 4, IF_EXT_PARTITION(32, 8)
};
/* clang-format on */
// Width/height lookup tables in units of various block sizes
static const uint8_t block_size_wide[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 2, 2,
+ 2,
+ 2,
4,
-#endif
- 4, 4,
- 8, 8,
- 8, 16,
- 16, 16,
- 32, 32,
- 32, 64,
- 64, IF_EXT_PARTITION(64, 128, 128) 4,
- 16, 8,
- 32, 16,
- 64, IF_EXT_PARTITION(32, 128)
+ 4,
+ 4,
+ 8,
+ 8,
+ 8,
+ 16,
+ 16,
+ 16,
+ 32,
+ 32,
+ 32,
+ 64,
+ 64,
+ IF_EXT_PARTITION(64, 128, 128) 4,
+ 16,
+ 8,
+ 32,
+ 16,
+ 64,
+ IF_EXT_PARTITION(32, 128)
};
static const uint8_t block_size_high[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 2, 4,
2,
-#endif
- 4, 8,
- 4, 8,
- 16, 8,
- 16, 32,
- 16, 32,
- 64, 32,
- 64, IF_EXT_PARTITION(128, 64, 128) 16,
- 4, 32,
- 8, 64,
- 16, IF_EXT_PARTITION(128, 32)
+ 4,
+ 2,
+ 4,
+ 8,
+ 4,
+ 8,
+ 16,
+ 8,
+ 16,
+ 32,
+ 16,
+ 32,
+ 64,
+ 32,
+ 64,
+ IF_EXT_PARTITION(128, 64, 128) 16,
+ 4,
+ 32,
+ 8,
+ 64,
+ 16,
+ IF_EXT_PARTITION(128, 32)
};
static const uint8_t num_4x4_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 1,
- 2, 2,
- 2, 4,
- 4, 4,
- 8, 8,
- 8, 16,
- 16, IF_EXT_PARTITION(16, 32, 32) 1,
- 4, 2,
- 8, 4,
- 16, IF_EXT_PARTITION(8, 32)
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 4,
+ 4,
+ 4,
+ 8,
+ 8,
+ 8,
+ 16,
+ 16,
+ IF_EXT_PARTITION(16, 32, 32) 1,
+ 4,
+ 2,
+ 8,
+ 4,
+ 16,
+ IF_EXT_PARTITION(8, 32)
};
static const uint8_t num_4x4_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 2,
- 1, 2,
- 4, 2,
- 4, 8,
- 4, 8,
- 16, 8,
- 16, IF_EXT_PARTITION(32, 16, 32) 4,
- 1, 8,
- 2, 16,
- 4, IF_EXT_PARTITION(32, 8)
+ 1,
+ 1,
+ 1,
+ 2,
+ 1,
+ 2,
+ 4,
+ 2,
+ 4,
+ 8,
+ 4,
+ 8,
+ 16,
+ 8,
+ 16,
+ IF_EXT_PARTITION(32, 16, 32) 4,
+ 1,
+ 8,
+ 2,
+ 16,
+ 4,
+ IF_EXT_PARTITION(32, 8)
};
static const uint8_t num_8x8_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 1,
- 1, 1,
- 1, 2,
- 2, 2,
- 4, 4,
- 4, 8,
- 8, IF_EXT_PARTITION(8, 16, 16) 1,
- 2, 1,
- 4, 2,
- 8, IF_EXT_PARTITION(4, 16)
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 4,
+ 4,
+ 4,
+ 8,
+ 8,
+ IF_EXT_PARTITION(8, 16, 16) 1,
+ 2,
+ 1,
+ 4,
+ 2,
+ 8,
+ IF_EXT_PARTITION(4, 16)
};
static const uint8_t num_8x8_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 1,
- 1, 1,
- 2, 1,
- 2, 4,
- 2, 4,
- 8, 4,
- 8, IF_EXT_PARTITION(16, 8, 16) 2,
- 1, 4,
- 1, 8,
- 2, IF_EXT_PARTITION(16, 4)
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 1,
+ 2,
+ 4,
+ 2,
+ 4,
+ 8,
+ 4,
+ 8,
+ IF_EXT_PARTITION(16, 8, 16) 2,
+ 1,
+ 4,
+ 1,
+ 8,
+ 2,
+ IF_EXT_PARTITION(16, 4)
};
static const uint8_t num_16x16_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 1,
- 1, 1,
- 1, 1,
- 1, 1,
- 2, 2,
- 2, 4,
- 4, IF_EXT_PARTITION(4, 8, 8) 1,
- 1, 1,
- 2, 2,
- 4, IF_EXT_PARTITION(2, 8)
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 4,
+ 4,
+ IF_EXT_PARTITION(4, 8, 8) 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 4,
+ IF_EXT_PARTITION(2, 8)
};
static const uint8_t num_16x16_blocks_high_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 1, 1,
1,
-#endif
- 1, 1,
- 1, 1,
- 1, 1,
- 1, 2,
- 1, 2,
- 4, 2,
- 4, IF_EXT_PARTITION(8, 4, 8) 1,
- 1, 2,
- 1, 4,
- 2, IF_EXT_PARTITION(8, 2)
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 2,
+ 1,
+ 2,
+ 4,
+ 2,
+ 4,
+ IF_EXT_PARTITION(8, 4, 8) 1,
+ 1,
+ 2,
+ 1,
+ 4,
+ 2,
+ IF_EXT_PARTITION(8, 2)
};
// AOMMIN(3, AOMMIN(b_width_log2(bsize), b_height_log2(bsize)))
static const uint8_t size_group_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 0, 0,
0,
-#endif
- 0, 0,
- 0, 1,
- 1, 1,
- 2, 2,
- 2, 3,
- 3, 3,
- 3, IF_EXT_PARTITION(3, 3, 3) 0,
- 0, 1,
- 1, 2,
- 2, IF_EXT_PARTITION(3, 3)
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 2,
+ 2,
+ 2,
+ 3,
+ 3,
+ 3,
+ 3,
+ IF_EXT_PARTITION(3, 3, 3) 0,
+ 0,
+ 1,
+ 1,
+ 2,
+ 2,
+ IF_EXT_PARTITION(3, 3)
};
static const uint8_t num_pels_log2_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 2, 3,
+ 2,
3,
-#endif
- 4, 5,
- 5, 6,
- 7, 7,
- 8, 9,
- 9, 10,
- 11, 11,
- 12, IF_EXT_PARTITION(13, 13, 14) 6,
- 6, 8,
- 8, 10,
- 10, IF_EXT_PARTITION(12, 12)
+ 3,
+ 4,
+ 5,
+ 5,
+ 6,
+ 7,
+ 7,
+ 8,
+ 9,
+ 9,
+ 10,
+ 11,
+ 11,
+ 12,
+ IF_EXT_PARTITION(13, 13, 14) 6,
+ 6,
+ 8,
+ 8,
+ 10,
+ 10,
+ IF_EXT_PARTITION(12, 12)
};
/* clang-format off */
@@ -285,10 +405,8 @@
#endif // CONFIG_EXT_PARTITION_TYPES
{
{ // PARTITION_NONE
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_2X2, BLOCK_2X4, BLOCK_4X2,
-#endif
// 4X4
BLOCK_4X4,
// 4X8, 8X4, 8X8
@@ -312,15 +430,10 @@
BLOCK_32X128, BLOCK_128X32
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_HORZ
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
// 4X4
BLOCK_4X2,
-#else
- // 4X4
- BLOCK_INVALID,
-#endif
// 4X8, 8X4, 8X8
BLOCK_INVALID, BLOCK_INVALID, BLOCK_8X4,
// 8X16, 16X8, 16X16
@@ -342,15 +455,10 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_VERT
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
// 4X4
BLOCK_2X4,
-#else
- // 4X4
- BLOCK_INVALID,
-#endif
// 4X8, 8X4, 8X8
BLOCK_INVALID, BLOCK_INVALID, BLOCK_4X8,
// 8X16, 16X8, 16X16
@@ -372,10 +480,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_SPLIT
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -400,10 +506,8 @@
#endif // CONFIG_EXT_PARTITION
#if CONFIG_EXT_PARTITION_TYPES
}, { // PARTITION_HORZ_A
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -427,10 +531,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_HORZ_B
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -454,10 +556,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_VERT_A
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -481,10 +581,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_VERT_B
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -508,10 +606,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_HORZ_4
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -535,10 +631,8 @@
BLOCK_INVALID, BLOCK_INVALID
#endif // CONFIG_EXT_PARTITION
}, { // PARTITION_VERT_4
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
BLOCK_INVALID, BLOCK_INVALID, BLOCK_INVALID,
-#endif
// 4X4
BLOCK_INVALID,
// 4X8, 8X4, 8X8
@@ -567,9 +661,7 @@
static const TX_SIZE max_txsize_lookup[BLOCK_SIZES_ALL] = {
// 2X2, 2X4, 4X2,
-#if CONFIG_CHROMA_SUB8X8
TX_4X4, TX_4X4, TX_4X4,
-#endif
// 4X4
TX_4X4,
// 4X8, 8X4, 8X8
@@ -608,9 +700,7 @@
#if CONFIG_RECT_TX
static const TX_SIZE max_txsize_rect_lookup[BLOCK_SIZES_ALL] = {
// 2X2, 2X4, 4X2,
-#if CONFIG_CHROMA_SUB8X8
TX_4X4, TX_4X4, TX_4X4,
-#endif // CONFIG_CHROMA_SUB8X8
// 4X4
TX_4X4,
// 4X8, 8X4, 8X8
@@ -659,10 +749,8 @@
#if CONFIG_RECT_TX_EXT
static const TX_SIZE quarter_txsize_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
TX_INVALID, TX_INVALID, TX_INVALID,
-#endif
// 4x4,
TX_INVALID,
// 4x8, 8x4, 8x8,
@@ -712,10 +800,8 @@
// block which may use a rectangular transform, in which case it is
// "(max_txsize_lookup[bsize] + 1) - TX_8X8", invalid for bsize < 8X8
static const int32_t intra_tx_size_cat_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
INT32_MIN, INT32_MIN, INT32_MIN,
-#endif
// 4X4,
INT32_MIN,
// 4X8, 8X4, 8X8,
@@ -757,10 +843,8 @@
#else
// Same as "max_txsize_lookup[bsize] - TX_8X8", invalid for bsize < 8X8
static const int32_t intra_tx_size_cat_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2,
INT32_MIN, INT32_MIN, INT32_MIN,
-#endif
// 4X4
INT32_MIN,
// 4X8, 8X4, 8X8
@@ -1046,20 +1130,14 @@
/* clang-format on */
static const BLOCK_SIZE ss_size_lookup[BLOCK_SIZES_ALL][2][2] = {
-// ss_x == 0 ss_x == 0 ss_x == 1 ss_x == 1
-// ss_y == 0 ss_y == 1 ss_y == 0 ss_y == 1
-#if CONFIG_CHROMA_SUB8X8
+ // ss_x == 0 ss_x == 0 ss_x == 1 ss_x == 1
+ // ss_y == 0 ss_y == 1 ss_y == 0 ss_y == 1
{ { BLOCK_2X2, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
{ { BLOCK_2X4, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
{ { BLOCK_4X2, BLOCK_INVALID }, { BLOCK_INVALID, BLOCK_INVALID } },
{ { BLOCK_4X4, BLOCK_4X2 }, { BLOCK_2X4, BLOCK_2X2 } },
{ { BLOCK_4X8, BLOCK_4X4 }, { BLOCK_INVALID, BLOCK_2X4 } },
{ { BLOCK_8X4, BLOCK_INVALID }, { BLOCK_4X4, BLOCK_4X2 } },
-#else
- { { BLOCK_4X4, BLOCK_4X4 }, { BLOCK_4X4, BLOCK_4X4 } },
- { { BLOCK_4X8, BLOCK_4X4 }, { BLOCK_INVALID, BLOCK_4X4 } },
- { { BLOCK_8X4, BLOCK_INVALID }, { BLOCK_4X4, BLOCK_4X4 } },
-#endif // CONFIG_CHROMA_SUB8X8
{ { BLOCK_8X8, BLOCK_8X4 }, { BLOCK_4X8, BLOCK_4X4 } },
{ { BLOCK_8X16, BLOCK_8X8 }, { BLOCK_INVALID, BLOCK_4X8 } },
{ { BLOCK_16X8, BLOCK_INVALID }, { BLOCK_8X8, BLOCK_8X4 } },
@@ -1088,9 +1166,8 @@
};
static const TX_SIZE uv_txsize_lookup[BLOCK_SIZES_ALL][TX_SIZES_ALL][2][2] = {
-// ss_x == 0 ss_x == 0 ss_x == 1 ss_x == 1
-// ss_y == 0 ss_y == 1 ss_y == 0 ss_y == 1
-#if CONFIG_CHROMA_SUB8X8
+ // ss_x == 0 ss_x == 0 ss_x == 1 ss_x == 1
+ // ss_y == 0 ss_y == 1 ss_y == 0 ss_y == 1
{
// BLOCK_2x2
{ { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -1163,7 +1240,6 @@
{ { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
{ { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
},
-#endif
{
// BLOCK_4X4
{ { TX_4X4, TX_4X4 }, { TX_4X4, TX_4X4 } },
@@ -1747,11 +1823,9 @@
PARTITION_CONTEXT left;
} partition_context_lookup[BLOCK_SIZES_ALL] = {
#if CONFIG_EXT_PARTITION
-#if CONFIG_CHROMA_SUB8X8
{ 31, 31 }, // 2X2 - {0b11111, 0b11111}
{ 31, 31 }, // 2X4 - {0b11111, 0b11111}
{ 31, 31 }, // 4X2 - {0b11111, 0b11111}
-#endif
{ 31, 31 }, // 4X4 - {0b11111, 0b11111}
{ 31, 30 }, // 4X8 - {0b11111, 0b11110}
{ 30, 31 }, // 8X4 - {0b11110, 0b11111}
@@ -1778,11 +1852,9 @@
{ 24, 0 }, // 32X128- {0b11000, 0b00000}
{ 0, 24 }, // 128X32- {0b00000, 0b11000}
#else
-#if CONFIG_CHROMA_SUB8X8
{ 15, 15 }, // 2X2 - {0b1111, 0b1111}
{ 15, 15 }, // 2X4 - {0b1111, 0b1111}
{ 15, 15 }, // 4X2 - {0b1111, 0b1111}
-#endif
{ 15, 15 }, // 4X4 - {0b1111, 0b1111}
{ 15, 14 }, // 4X8 - {0b1111, 0b1110}
{ 14, 15 }, // 8X4 - {0b1110, 0b1111}
@@ -1820,11 +1892,9 @@
#if CONFIG_NCOBMC_ADAPT_WEIGHT
// NCOBMC_ADAPT_INTRPL only supports block size >= BLOCK_8X8 and <= BLOCK_64X64
static const ADAPT_OVERLAP_BLOCK adapt_overlap_block_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_2X2
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_2X4
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_4X2
-#endif
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_4X4
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_4X8
ADAPT_OVERLAP_BLOCK_INVALID, // BLOCK_8X4
@@ -1849,12 +1919,9 @@
};
static const BLOCK_SIZE bsize_2_sqr_bsize[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
- BLOCK_2X2, BLOCK_2X2, BLOCK_2X2,
-#endif
- BLOCK_4X4, BLOCK_4X4, BLOCK_4X4, BLOCK_8X8, BLOCK_8X8,
- BLOCK_8X8, BLOCK_16X16, BLOCK_16X16, BLOCK_16X16, BLOCK_32X32,
- BLOCK_32X32, BLOCK_32X32, BLOCK_64X64,
+ BLOCK_2X2, BLOCK_2X2, BLOCK_2X2, BLOCK_4X4, BLOCK_4X4, BLOCK_4X4,
+ BLOCK_8X8, BLOCK_8X8, BLOCK_8X8, BLOCK_16X16, BLOCK_16X16, BLOCK_16X16,
+ BLOCK_32X32, BLOCK_32X32, BLOCK_32X32, BLOCK_64X64,
#if CONFIG_EXT_PARTITION
BLOCK_64X64, BLOCK_64X64,
#endif
diff --git a/av1/common/entropymode.c b/av1/common/entropymode.c
index 54da782..c324cbb 100644
--- a/av1/common/entropymode.c
+++ b/av1/common/entropymode.c
@@ -890,17 +890,15 @@
#if CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
static const aom_prob
default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 128, 128 }, { 128, 128 }, { 128, 128 },
-#endif
- { 128, 128 }, { 255, 128 }, { 255, 128 }, { 66, 51 }, { 72, 35 },
- { 79, 29 }, { 71, 18 }, { 81, 29 }, { 81, 26 }, { 69, 19 },
- { 104, 1 }, { 99, 1 }, { 75, 1 },
+ { 128, 128 }, { 128, 128 }, { 128, 128 }, { 128, 128 },
+ { 255, 128 }, { 255, 128 }, { 66, 51 }, { 72, 35 },
+ { 79, 29 }, { 71, 18 }, { 81, 29 }, { 81, 26 },
+ { 69, 19 }, { 104, 1 }, { 99, 1 }, { 75, 1 },
#if CONFIG_EXT_PARTITION
{ 255, 1 }, { 255, 1 }, { 255, 1 },
#endif // CONFIG_EXT_PARTITION
- { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 1 },
- { 208, 1 },
+ { 208, 128 }, { 208, 128 }, { 208, 128 }, { 208, 128 },
+ { 208, 1 }, { 208, 1 },
#if CONFIG_EXT_PARTITION
{ 208, 1 }, { 208, 1 }
#endif // CONFIG_EXT_PARTITION
@@ -908,11 +906,8 @@
#elif !CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
static const aom_prob
default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 255 }, { 255 }, { 255 },
-#endif
- { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 216 },
- { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
+ { 255 }, { 255 }, { 255 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 },
+ { 208 }, { 216 }, { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
#if CONFIG_EXT_PARTITION
{ 255 }, { 255 }, { 255 },
#endif // CONFIG_EXT_PARTITION
@@ -924,11 +919,8 @@
#elif CONFIG_COMPOUND_SEGMENT && !CONFIG_WEDGE
static const aom_prob
default_compound_type_probs[BLOCK_SIZES_ALL][COMPOUND_TYPES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 255 }, { 255 }, { 255 },
-#endif
- { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 }, { 216 },
- { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
+ { 255 }, { 255 }, { 255 }, { 208 }, { 208 }, { 208 }, { 208 }, { 208 },
+ { 208 }, { 216 }, { 216 }, { 216 }, { 224 }, { 224 }, { 240 }, { 240 },
#if CONFIG_EXT_PARTITION
{ 255 }, { 255 }, { 255 },
#endif // CONFIG_EXT_PARTITION
@@ -945,11 +937,9 @@
#if CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
static const aom_cdf_prob
default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(32640), AOM_ICDF(32704), AOM_ICDF(32768), 0 },
{ AOM_ICDF(32640), AOM_ICDF(32704), AOM_ICDF(32768), 0 },
@@ -982,11 +972,9 @@
#elif !CONFIG_COMPOUND_SEGMENT && CONFIG_WEDGE
static const aom_cdf_prob
default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 }, // 255
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 },
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 }, // 208
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 },
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 },
@@ -1019,11 +1007,9 @@
#elif CONFIG_COMPOUND_SEGMENT && !CONFIG_WEDGE
static const aom_cdf_prob
default_compound_type_cdf[BLOCK_SIZES_ALL][CDF_SIZE(COMPOUND_TYPES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 }, // 255
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 },
{ AOM_ICDF(32640), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 }, // 208
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 },
{ AOM_ICDF(26624), AOM_ICDF(32768), 0 },
@@ -1084,10 +1070,8 @@
};
static const aom_prob default_wedge_interintra_prob[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 128, 128, 128,
-#endif
- 128, 128, 128, 194, 213, 217, 222, 224, 226, 220, 128, 128, 128,
+ 128, 128, 128, 128, 128, 128, 194, 213,
+ 217, 222, 224, 226, 220, 128, 128, 128,
#if CONFIG_EXT_PARTITION
255, 255, 255,
#endif // CONFIG_EXT_PARTITION
@@ -1100,11 +1084,9 @@
#if CONFIG_NEW_MULTISYMBOL
static const aom_cdf_prob
default_wedge_interintra_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
@@ -1199,11 +1181,9 @@
};
static const aom_prob
default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
{ 255, 255 },
{ 255, 255 },
{ 255, 255 },
-#endif
{ 255, 255 },
{ 255, 255 },
{ 255, 255 },
@@ -1236,11 +1216,9 @@
};
static const aom_cdf_prob
default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
-#endif
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0, 0 },
@@ -1279,11 +1257,8 @@
static const aom_prob
default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 255 }, { 255 }, { 255 },
-#endif
- { 255 }, { 255 }, { 255 }, { 151 }, { 153 }, { 144 }, { 178 },
- { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
+ { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 151 }, { 153 },
+ { 144 }, { 178 }, { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
#if CONFIG_EXT_PARTITION
{ 252 }, { 252 }, { 252 },
#endif // CONFIG_EXT_PARTITION
@@ -1295,11 +1270,9 @@
static const aom_cdf_prob
default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
@@ -1338,11 +1311,8 @@
static const aom_prob
default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 255 }, { 255 }, { 255 },
-#endif
- { 255 }, { 255 }, { 255 }, { 151 }, { 153 }, { 144 }, { 178 },
- { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
+ { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 255 }, { 151 }, { 153 },
+ { 144 }, { 178 }, { 165 }, { 160 }, { 207 }, { 195 }, { 168 }, { 244 },
#if CONFIG_EXT_PARTITION
{ 252 }, { 252 }, { 252 },
#endif // CONFIG_EXT_PARTITION
@@ -1354,11 +1324,9 @@
static const aom_cdf_prob
default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(255 * 128), AOM_ICDF(32768), 0 },
@@ -1397,13 +1365,10 @@
static const aom_prob default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES -
1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 128, 128, 255 }, { 128, 128, 128 }, { 128, 128, 128 },
-#endif
- { 128, 128, 128 }, { 128, 128, 128 }, { 128, 128, 128 }, { 62, 115, 128 },
- { 39, 131, 128 }, { 39, 132, 128 }, { 118, 94, 128 }, { 77, 125, 128 },
- { 100, 121, 128 }, { 190, 66, 128 }, { 207, 102, 128 }, { 197, 100, 128 },
- { 239, 76, 128 },
+ { 128, 128, 255 }, { 128, 128, 128 }, { 128, 128, 128 }, { 128, 128, 128 },
+ { 128, 128, 128 }, { 128, 128, 128 }, { 62, 115, 128 }, { 39, 131, 128 },
+ { 39, 132, 128 }, { 118, 94, 128 }, { 77, 125, 128 }, { 100, 121, 128 },
+ { 190, 66, 128 }, { 207, 102, 128 }, { 197, 100, 128 }, { 239, 76, 128 },
#if CONFIG_EXT_PARTITION
{ 252, 200, 128 }, { 252, 200, 128 }, { 252, 200, 128 },
#endif // CONFIG_EXT_PARTITION
@@ -1411,11 +1376,9 @@
};
static const aom_cdf_prob
default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
@@ -1450,12 +1413,10 @@
static const aom_prob
default_ncobmc_prob[BLOCK_SIZES_ALL][OBMC_FAMILY_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 128, 255 }, { 128, 255 }, { 128, 255 },
-#endif
- { 128, 255 }, { 128, 255 }, { 128, 255 }, { 45, 255 }, { 79, 255 },
- { 75, 255 }, { 130, 255 }, { 141, 255 }, { 144, 255 }, { 208, 255 },
- { 201, 255 }, { 186, 255 }, { 231, 255 },
+ { 128, 255 }, { 128, 255 }, { 128, 255 }, { 128, 255 },
+ { 128, 255 }, { 128, 255 }, { 45, 255 }, { 79, 255 },
+ { 75, 255 }, { 130, 255 }, { 141, 255 }, { 144, 255 },
+ { 208, 255 }, { 201, 255 }, { 186, 255 }, { 231, 255 },
#if CONFIG_EXT_PARTITION
{ 252, 255 }, { 252, 255 }, { 252, 255 },
#endif // CONFIG_EXT_PARTITION
@@ -1464,11 +1425,9 @@
static const aom_cdf_prob
default_ncobmc_cdf[BLOCK_SIZES_ALL][CDF_SIZE(OBMC_FAMILY_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32767), AOM_ICDF(32768), 0 },
@@ -1503,28 +1462,24 @@
static const aom_prob
default_motion_mode_prob[BLOCK_SIZES_ALL][MOTION_MODES - 1] = {
-#if CONFIG_CHROMA_SUB8X8
- { 128, 128 }, { 128, 128 }, { 128, 128 },
-#endif
- { 128, 128 }, { 128, 128 }, { 128, 128 }, { 62, 115 }, { 39, 131 },
- { 39, 132 }, { 118, 94 }, { 77, 125 }, { 100, 121 }, { 190, 66 },
- { 207, 102 }, { 197, 100 }, { 239, 76 },
+ { 128, 128 }, { 128, 128 }, { 128, 128 }, { 128, 128 },
+ { 128, 128 }, { 128, 128 }, { 62, 115 }, { 39, 131 },
+ { 39, 132 }, { 118, 94 }, { 77, 125 }, { 100, 121 },
+ { 190, 66 }, { 207, 102 }, { 197, 100 }, { 239, 76 },
#if CONFIG_EXT_PARTITION
{ 252, 200 }, { 252, 200 }, { 252, 200 },
#endif // CONFIG_EXT_PARTITION
- { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 },
- { 208, 200 },
+ { 208, 200 }, { 208, 200 }, { 208, 200 }, { 208, 200 },
+ { 208, 200 }, { 208, 200 },
#if CONFIG_EXT_PARTITION
{ 252, 200 }, { 252, 200 }
#endif // CONFIG_EXT_PARTITION
};
static const aom_cdf_prob
default_motion_mode_cdf[BLOCK_SIZES_ALL][CDF_SIZE(MOTION_MODES)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
{ AOM_ICDF(16384), AOM_ICDF(24576), AOM_ICDF(32768), 0 },
@@ -1557,10 +1512,7 @@
#endif // CONFIG_NCOBMC_ADAPT_WEIGHT
// Probability for the case that only 1 additional motion mode is allowed
static const aom_prob default_obmc_prob[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 128, 128, 128,
-#endif
- 128, 128, 128, 45, 79, 75, 130, 141, 144, 208, 201, 186, 231,
+ 128, 128, 128, 128, 128, 128, 45, 79, 75, 130, 141, 144, 208, 201, 186, 231,
#if CONFIG_EXT_PARTITION
252, 252, 252,
#endif // CONFIG_EXT_PARTITION
@@ -1572,11 +1524,9 @@
#if CONFIG_NEW_MULTISYMBOL || CONFIG_NCOBMC_ADAPT_WEIGHT
static const aom_cdf_prob default_obmc_cdf[BLOCK_SIZES_ALL][CDF_SIZE(2)] = {
-#if CONFIG_CHROMA_SUB8X8
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
-#endif
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
{ AOM_ICDF(128 * 128), AOM_ICDF(32768), 0 },
diff --git a/av1/common/enums.h b/av1/common/enums.h
index 4c3d908..91f1f16 100644
--- a/av1/common/enums.h
+++ b/av1/common/enums.h
@@ -122,11 +122,9 @@
// type, so that we can save memory when they are used in structs/arrays.
typedef enum ATTRIBUTE_PACKED {
-#if CONFIG_CHROMA_SUB8X8
BLOCK_2X2,
BLOCK_2X4,
BLOCK_4X2,
-#endif
BLOCK_4X4,
BLOCK_4X8,
BLOCK_8X4,
diff --git a/av1/common/obmc.h b/av1/common/obmc.h
index f394049..dbab733 100644
--- a/av1/common/obmc.h
+++ b/av1/common/obmc.h
@@ -36,7 +36,6 @@
MODE_INFO **above_mi = prev_row_mi + above_mi_col;
mi_step = AOMMIN(mi_size_wide[above_mi[0]->mbmi.sb_type],
mi_size_wide[BLOCK_64X64]);
-#if CONFIG_CHROMA_SUB8X8
// If we're considering a block with width 4, it should be treated as
// half of a pair of blocks with chroma information in the second. Move
// above_mi_col back to the start of the pair if needed, set above_mbmi
@@ -47,7 +46,6 @@
above_mi = prev_row_mi + above_mi_col + 1;
mi_step = 2;
}
-#endif // CONFIG_CHROMA_SUB8X8
MB_MODE_INFO *above_mbmi = &above_mi[0]->mbmi;
if (is_neighbor_overlappable(above_mbmi)) {
++nb_count;
@@ -76,13 +74,11 @@
MODE_INFO **left_mi = prev_col_mi + left_mi_row * xd->mi_stride;
mi_step = AOMMIN(mi_size_high[left_mi[0]->mbmi.sb_type],
mi_size_high[BLOCK_64X64]);
-#if CONFIG_CHROMA_SUB8X8
if (mi_step == 1) {
left_mi_row &= ~1;
left_mi = prev_col_mi + (left_mi_row + 1) * xd->mi_stride;
mi_step = 2;
}
-#endif // CONFIG_CHROMA_SUB8X8
MB_MODE_INFO *left_mbmi = &left_mi[0]->mbmi;
if (is_neighbor_overlappable(left_mbmi)) {
++nb_count;
diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index 15db2ab..699c404 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -674,11 +674,11 @@
}
#if CONFIG_CFL
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
static INLINE void cfl_clear_sub8x8_val(CFL_CTX *cfl) {
memset(cfl->sub8x8_val, 0, sizeof(cfl->sub8x8_val));
}
-#endif // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_DEBUG
void cfl_init(CFL_CTX *cfl, AV1_COMMON *cm);
#endif // CONFIG_CFL
@@ -729,14 +729,12 @@
int col_offset = mi_col;
for (i = 0; i < MAX_MB_PLANE; ++i) {
struct macroblockd_plane *const pd = &xd->plane[i];
-#if CONFIG_CHROMA_SUB8X8
// Offset the buffer pointer
const BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
if (pd->subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
row_offset = mi_row - 1;
if (pd->subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
col_offset = mi_col - 1;
-#endif
int above_idx = col_offset << (MI_SIZE_LOG2 - tx_size_wide_log2[0]);
int left_idx = (row_offset & MAX_MIB_MASK)
<< (MI_SIZE_LOG2 - tx_size_high_log2[0]);
@@ -787,14 +785,12 @@
#endif // CONFIG_DEPENDENT_HORZTILES
xd->left_available = (mi_col > tile->mi_col_start);
-#if CONFIG_CHROMA_SUB8X8
xd->chroma_up_available = xd->up_available;
xd->chroma_left_available = xd->left_available;
if (xd->plane[1].subsampling_x && bw < mi_size_wide[BLOCK_8X8])
xd->chroma_left_available = (mi_col - 1) > tile->mi_col_start;
if (xd->plane[1].subsampling_y && bh < mi_size_high[BLOCK_8X8])
xd->chroma_up_available = (mi_row - 1) > tile->mi_row_start;
-#endif
if (xd->up_available) {
xd->above_mi = xd->mi[-xd->mi_stride];
// above_mi may be NULL in encoder's first pass.
@@ -876,22 +872,11 @@
static INLINE int is_chroma_reference(int mi_row, int mi_col, BLOCK_SIZE bsize,
int subsampling_x, int subsampling_y) {
-#if CONFIG_CHROMA_SUB8X8
const int bw = mi_size_wide[bsize];
const int bh = mi_size_high[bsize];
-
int ref_pos = ((mi_row & 0x01) || !(bh & 0x01) || !subsampling_y) &&
((mi_col & 0x01) || !(bw & 0x01) || !subsampling_x);
-
return ref_pos;
-#else
- int ref_pos = !(((mi_row & 0x01) && subsampling_y) ||
- ((mi_col & 0x01) && subsampling_x));
-
- if (AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8) ref_pos = 1;
-
- return ref_pos;
-#endif
}
static INLINE BLOCK_SIZE scale_chroma_bsize(BLOCK_SIZE bsize, int subsampling_x,
diff --git a/av1/common/reconinter.c b/av1/common/reconinter.c
index ac1059d..5eba691 100644
--- a/av1/common/reconinter.c
+++ b/av1/common/reconinter.c
@@ -343,11 +343,9 @@
};
const wedge_params_type wedge_params_lookup[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
{ 0, NULL, NULL, 0, NULL },
{ 0, NULL, NULL, 0, NULL },
{ 0, NULL, NULL, 0, NULL },
-#endif // CONFIG_CHROMA_SUB8X8
{ 0, NULL, NULL, 0, NULL },
{ 0, NULL, NULL, 0, NULL },
{ 0, NULL, NULL, 0, NULL },
@@ -1140,7 +1138,6 @@
(void)block;
(void)cm;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE bsize = mi->mbmi.sb_type;
const int ss_x = pd->subsampling_x;
const int ss_y = pd->subsampling_y;
@@ -1347,9 +1344,6 @@
for (ref = 0; ref < 2; ++ref) pd->pre[ref] = orig_pred_buf[ref];
return;
}
-#else
- (void)cm;
-#endif // CONFIG_CHROMA_SUB8X8
{
struct buf_2d *const dst_buf = &pd->dst;
@@ -1751,9 +1745,7 @@
BLOCK_SIZE bsize_plane =
ss_size_lookup[bsize][pd->subsampling_x][pd->subsampling_y];
-#if CONFIG_CHROMA_SUB8X8
if (bsize_plane < BLOCK_4X4) return 1;
-#endif
switch (bsize_plane) {
#if DISABLE_CHROMA_U8X8_OBMC
case BLOCK_4X4:
@@ -2503,9 +2495,7 @@
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
static int ii_size_scales[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
32, 32, 32,
-#endif
32, 16, 16, 16, 8, 8, 8, 4,
4, 4, 2, 2, 2, 1, 1, 1,
16, 16, 8, 8, 4, 4, 2, 2
@@ -2518,9 +2508,7 @@
2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
};
static int ii_size_scales[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
16, 16, 16,
-#endif
16, 8, 8, 8, 4, 4, 4,
2, 2, 2, 1, 1, 1,
8, 8, 4, 4, 2, 2,
diff --git a/av1/common/reconinter.h b/av1/common/reconinter.h
index d0cd27d..7fbd8c3 100644
--- a/av1/common/reconinter.h
+++ b/av1/common/reconinter.h
@@ -221,11 +221,7 @@
BLOCK_SIZE sb_type) {
(void)sb_type;
switch (type) {
-#if CONFIG_CHROMA_SUB8X8
case COMPOUND_AVERAGE: return sb_type >= BLOCK_4X4;
-#else // CONFIG_CHROMA_SUB8X8
- case COMPOUND_AVERAGE: return 1;
-#endif // CONFIG_CHROMA_SUB8X8
#if CONFIG_WEDGE
case COMPOUND_WEDGE: return wedge_params_lookup[sb_type].bits > 0;
#endif // CONFIG_WEDGE
@@ -239,9 +235,7 @@
static INLINE int is_any_masked_compound_used(BLOCK_SIZE sb_type) {
COMPOUND_TYPE comp_type;
-#if CONFIG_CHROMA_SUB8X8
if (sb_type < BLOCK_4X4) return 0;
-#endif // CONFIG_CHROMA_SUB8X8
for (comp_type = 0; comp_type < COMPOUND_TYPES; comp_type++) {
if (is_masked_compound_type(comp_type) &&
is_interinter_compound_used(comp_type, sb_type))
@@ -410,15 +404,11 @@
int stride, int mi_row, int mi_col,
const struct scale_factors *scale,
int subsampling_x, int subsampling_y) {
-#if CONFIG_CHROMA_SUB8X8
// Offset the buffer pointer
if (subsampling_y && (mi_row & 0x01) && (mi_size_high[bsize] == 1))
mi_row -= 1;
if (subsampling_x && (mi_col & 0x01) && (mi_size_wide[bsize] == 1))
mi_col -= 1;
-#else
- (void)bsize;
-#endif
const int x = (MI_SIZE * mi_col) >> subsampling_x;
const int y = (MI_SIZE * mi_row) >> subsampling_y;
diff --git a/av1/common/reconintra.c b/av1/common/reconintra.c
index a6d8efa..8523c2d 100644
--- a/av1/common/reconintra.c
+++ b/av1/common/reconintra.c
@@ -367,10 +367,8 @@
#if CONFIG_EXT_PARTITION
/* clang-format off */
static const uint16_t *const orders[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2
orders_4x4, orders_4x4, orders_4x4,
-#endif
// 4X4
orders_4x4,
// 4X8, 8X4, 8X8
@@ -394,10 +392,8 @@
#else
/* clang-format off */
static const uint16_t *const orders[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2
orders_8x8, orders_8x8, orders_8x8,
-#endif
// 4X4
orders_8x8,
// 4X8, 8X4, 8X8
@@ -453,10 +449,8 @@
#if CONFIG_EXT_PARTITION
/* clang-format off */
static const uint16_t *const orders_verta[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2
orders_4x4, orders_4x4, orders_4x4,
-#endif
// 4X4
orders_verta_8x8,
// 4X8, 8X4, 8X8
@@ -475,10 +469,8 @@
#else
/* clang-format off */
static const uint16_t *const orders_verta[BLOCK_SIZES] = {
-#if CONFIG_CHROMA_SUB8X8
// 2X2, 2X4, 4X2
orders_verta_8x8, orders_verta_8x8, orders_verta_8x8,
-#endif
// 4X4
orders_verta_8x8,
// 4X8, 8X4, 8X8
@@ -2579,16 +2571,11 @@
BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
const struct macroblockd_plane *const pd = &xd->plane[plane];
const int txw = tx_size_wide_unit[tx_size];
-#if CONFIG_CHROMA_SUB8X8
const int have_top = row_off || (pd->subsampling_y ? xd->chroma_up_available
: xd->up_available);
const int have_left =
col_off ||
(pd->subsampling_x ? xd->chroma_left_available : xd->left_available);
-#else
- const int have_top = row_off || xd->up_available;
- const int have_left = col_off || xd->left_available;
-#endif
const int x = col_off << tx_size_wide_log2[0];
const int y = row_off << tx_size_high_log2[0];
const int mi_row = -xd->mb_to_top_edge >> (3 + MI_SIZE_LOG2);
@@ -2598,13 +2585,8 @@
#if !INTRA_USES_RECT_TRANSFORMS
assert(txwpx == txhpx);
#endif // !INTRA_USES_RECT_TRANSFORMS
-#if !CONFIG_CHROMA_SUB8X8
- const int xr_chr_offset = (pd->subsampling_x && bsize < BLOCK_8X8) ? 2 : 0;
- const int yd_chr_offset = (pd->subsampling_y && bsize < BLOCK_8X8) ? 2 : 0;
-#else
const int xr_chr_offset = 0;
const int yd_chr_offset = 0;
-#endif
// Distance between the right edge of this prediction block to
// the frame right edge
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index be57c15..62a0861 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -257,12 +257,8 @@
static int get_block_idx(const MACROBLOCKD *xd, int plane, int row, int col) {
const int bsize = xd->mi[0]->mbmi.sb_type;
const struct macroblockd_plane *pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
const uint8_t txh_unit = tx_size_high_unit[tx_size];
@@ -612,11 +608,11 @@
set_offsets(cm, xd, bsize, mi_row, mi_col, bw, bh, x_mis, y_mis);
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
CFL_CTX *const cfl = xd->cfl;
cfl->is_chroma_reference = is_chroma_reference(
mi_row, mi_col, bsize, cfl->subsampling_x, cfl->subsampling_y);
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif // CONFIG_CFL
if (cm->delta_q_present_flag) {
int i;
@@ -769,12 +765,8 @@
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
const int stepr = tx_size_high_unit[tx_size];
const int stepc = tx_size_wide_unit[tx_size];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
int row, col;
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
@@ -864,12 +856,8 @@
for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
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 row, col;
@@ -915,7 +903,7 @@
}
}
}
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
if (mbmi->uv_mode != UV_CFL_PRED) {
#if CONFIG_DEBUG
if (cfl->is_chroma_reference) {
@@ -926,7 +914,7 @@
cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
}
}
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif // CONFIG_CFL
#endif // CONFIG_COEF_INTERLEAVE
int reader_corrupted_flag = aom_reader_has_error(r);
diff --git a/av1/decoder/decodetxb.c b/av1/decoder/decodetxb.c
index 33418fc..8e21a7f 100644
--- a/av1/decoder/decodetxb.c
+++ b/av1/decoder/decodetxb.c
@@ -626,12 +626,8 @@
struct macroblockd_plane *pd = &xd->plane[plane];
const BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
TXB_CTX txb_ctx;
get_txb_ctx(plane_bsize, tx_size, plane, pd->above_context + col,
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 58b8fb4..c73f022 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2252,12 +2252,8 @@
}
const struct macroblockd_plane *const pd = &xd->plane[plane];
BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
const int num_4x4_w =
block_size_wide[plane_bsize] >> tx_size_wide_log2[0];
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index cd36fac..597b73d 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -2076,9 +2076,7 @@
/* clang-format off */
static const BLOCK_SIZE min_partition_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
BLOCK_2X2, BLOCK_2X2, BLOCK_2X2, // 2x2, 2x4, 4x2
-#endif
BLOCK_4X4, // 4x4
BLOCK_4X4, BLOCK_4X4, BLOCK_4X4, // 4x8, 8x4, 8x8
BLOCK_4X4, BLOCK_4X4, BLOCK_8X8, // 8x16, 16x8, 16x16
@@ -2095,9 +2093,7 @@
};
static const BLOCK_SIZE max_partition_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
BLOCK_4X4, BLOCK_4X4, BLOCK_4X4, // 2x2, 2x4, 4x2
-#endif
BLOCK_8X8, // 4x4
BLOCK_16X16, BLOCK_16X16, BLOCK_16X16, // 4x8, 8x4, 8x8
BLOCK_32X32, BLOCK_32X32, BLOCK_32X32, // 8x16, 16x8, 16x16
@@ -2115,9 +2111,7 @@
// Next square block size less or equal than current block size.
static const BLOCK_SIZE next_square_size[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
BLOCK_2X2, BLOCK_2X2, BLOCK_2X2, // 2x2, 2x4, 4x2
-#endif
BLOCK_4X4, // 4x4
BLOCK_4X4, BLOCK_4X4, BLOCK_8X8, // 4x8, 8x4, 8x8
BLOCK_8X8, BLOCK_8X8, BLOCK_16X16, // 8x16, 16x8, 16x16
@@ -2505,13 +2499,8 @@
uint8_t *src_uv = x->plane[plane].src.buf;
uint8_t *dst_uv = xd->plane[plane].dst.buf;
unsigned sse;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(BLOCK_8X8, &xd->plane[plane]));
-#else
- const BLOCK_SIZE plane_bsize =
- get_plane_block_size(BLOCK_8X8, &xd->plane[plane]);
-#endif
cpi->fn_ptr[plane_bsize].vf(src_uv, src_stride_uv, dst_uv, dst_stride_uv,
&sse);
dist_8x8_uv += (int64_t)sse << 4;
@@ -2810,11 +2799,11 @@
restore_context(x, &x_ctx, mi_row, mi_col, bsize);
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
if (!x->skip_chroma_rd) {
cfl_clear_sub8x8_val(xd->cfl);
}
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_CFL && CONFIG_DEBUG
}
// store estimated motion vector
@@ -2866,10 +2855,10 @@
}
#endif // CONFIG_DIST_8X8
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
if (!reached_last_index && sum_rdc.rdcost >= best_rdc.rdcost)
cfl_clear_sub8x8_val(xd->cfl);
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_CFL && CONFIG_DEBUG
if (reached_last_index && sum_rdc.rdcost < best_rdc.rdcost) {
sum_rdc.rate += partition_cost[PARTITION_SPLIT];
@@ -2954,9 +2943,9 @@
#endif // CONFIG_DIST_8X8
}
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
cfl_clear_sub8x8_val(xd->cfl);
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_CFL && CONFIG_DEBUG
if (sum_rdc.rdcost < best_rdc.rdcost) {
sum_rdc.rate += partition_cost[PARTITION_HORZ];
sum_rdc.rdcost = RDCOST(x->rdmult, sum_rdc.rate, sum_rdc.dist);
@@ -3034,9 +3023,9 @@
#endif // CONFIG_DIST_8X8
}
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_CFL && CONFIG_DEBUG
cfl_clear_sub8x8_val(xd->cfl);
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_CFL && CONFIG_DEBUG
if (sum_rdc.rdcost < best_rdc.rdcost) {
sum_rdc.rate += partition_cost[PARTITION_VERT];
@@ -4622,13 +4611,13 @@
}
#if CONFIG_CFL
xd->cfl->store_y = 0;
-#if CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#if CONFIG_DEBUG
if (is_chroma_reference(mi_row, mi_col, bsize, xd->cfl->subsampling_x,
xd->cfl->subsampling_y) &&
!xd->cfl->are_parameters_computed) {
cfl_clear_sub8x8_val(xd->cfl);
}
-#endif // CONFIG_CHROMA_SUB8X8 && CONFIG_DEBUG
+#endif // CONFIG_DEBUG
#endif // CONFIG_CFL
if (!dry_run) {
sum_intra_stats(td->counts, xd, mi, xd->above_mi, xd->left_mi,
@@ -4817,7 +4806,7 @@
mbmi->tx_size = tx_size;
set_txfm_ctxs(tx_size, xd->n8_w, xd->n8_h, (mbmi->skip || seg_skip), xd);
}
-#if CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#if CONFIG_CFL
CFL_CTX *const cfl = xd->cfl;
#if CONFIG_DEBUG
if (is_chroma_reference(mi_row, mi_col, bsize, cfl->subsampling_x,
@@ -4831,5 +4820,5 @@
cfl->subsampling_y)) {
cfl_store_block(xd, mbmi->sb_type, mbmi->tx_size);
}
-#endif // CONFIG_CFL && CONFIG_CHROMA_SUB8X8
+#endif // CONFIG_CFL
}
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index 95bae67..105eb92 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -1599,14 +1599,12 @@
aom_highbd_8_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits8,
aom_highbd_sad4x4x8_bits8, aom_highbd_sad4x4x4d_bits8)
-#if CONFIG_CHROMA_SUB8X8
HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_8_variance2x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_8_variance4x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_8_variance2x4, NULL, NULL,
NULL, NULL, NULL)
-#endif
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(BLOCK_128X128, aom_highbd_sad128x128_bits8,
@@ -1918,14 +1916,12 @@
aom_highbd_10_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits10,
aom_highbd_sad4x4x8_bits10, aom_highbd_sad4x4x4d_bits10)
-#if CONFIG_CHROMA_SUB8X8
HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_10_variance2x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_10_variance4x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_10_variance2x4, NULL, NULL,
NULL, NULL, NULL)
-#endif
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(
@@ -2239,14 +2235,12 @@
aom_highbd_12_sub_pixel_avg_variance4x4, aom_highbd_sad4x4x3_bits12,
aom_highbd_sad4x4x8_bits12, aom_highbd_sad4x4x4d_bits12)
-#if CONFIG_CHROMA_SUB8X8
HIGHBD_BFP(BLOCK_2X2, NULL, NULL, aom_highbd_12_variance2x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_4X2, NULL, NULL, aom_highbd_12_variance4x2, NULL, NULL,
NULL, NULL, NULL)
HIGHBD_BFP(BLOCK_2X4, NULL, NULL, aom_highbd_12_variance2x4, NULL, NULL,
NULL, NULL, NULL)
-#endif
#if CONFIG_EXT_PARTITION
HIGHBD_BFP(
@@ -2912,11 +2906,9 @@
aom_sub_pixel_variance4x4, aom_sub_pixel_avg_variance4x4, aom_sad4x4x3,
aom_sad4x4x8, aom_sad4x4x4d)
-#if CONFIG_CHROMA_SUB8X8
BFP(BLOCK_2X2, NULL, NULL, aom_variance2x2, NULL, NULL, NULL, NULL, NULL)
BFP(BLOCK_2X4, NULL, NULL, aom_variance2x4, NULL, NULL, NULL, NULL, NULL)
BFP(BLOCK_4X2, NULL, NULL, aom_variance4x2, NULL, NULL, NULL, NULL, NULL)
-#endif
#if CONFIG_MOTION_VAR
#define OBFP(BT, OSDF, OVF, OSVF) \
diff --git a/av1/encoder/encodetxb.c b/av1/encoder/encodetxb.c
index 059680e..aad2038 100644
--- a/av1/encoder/encodetxb.c
+++ b/av1/encoder/encodetxb.c
@@ -681,13 +681,8 @@
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
BLOCK_SIZE bsize = mbmi->sb_type;
struct macroblockd_plane *pd = &xd->plane[plane];
-
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
const int max_blocks_wide = max_block_wide(xd, plane_bsize, plane);
const int max_blocks_high = max_block_high(xd, plane_bsize, plane);
const TX_SIZE tx_size = av1_get_tx_size(plane, xd);
diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 9da59fd..0753e3d 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -54,10 +54,7 @@
// This table is used to correct for block size.
// The factors here are << 2 (2 = x0.5, 32 = x8 etc).
static const uint8_t rd_thresh_block_size_factor[BLOCK_SIZES_ALL] = {
-#if CONFIG_CHROMA_SUB8X8
- 2, 2, 2,
-#endif
- 2, 3, 3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32,
+ 2, 2, 2, 2, 3, 3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32,
#if CONFIG_EXT_PARTITION
48, 48, 64,
#endif // CONFIG_EXT_PARTITION
@@ -1034,12 +1031,8 @@
const struct macroblockd_plane *pd,
ENTROPY_CONTEXT t_above[2 * MAX_MIB_SIZE],
ENTROPY_CONTEXT t_left[2 * MAX_MIB_SIZE]) {
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
get_entropy_contexts_plane(plane_bsize, tx_size, pd, t_above, t_left);
}
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 8a9e2da..c5a3d8b 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -1505,12 +1505,7 @@
for (plane = plane_from; plane <= plane_to; ++plane) {
struct macroblock_plane *const p = &x->plane[plane];
struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE bs = AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE bs = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
-
unsigned int sse;
int rate;
int64_t dist;
@@ -1727,20 +1722,15 @@
#endif
return cost_coeffs(cm, x, plane, block, tx_size, scan_order, a, l,
use_fast_coef_costing);
-#else // !CONFIG_LV_MAP
+#else // !CONFIG_LV_MAP
(void)scan_order;
(void)use_fast_coef_costing;
const MACROBLOCKD *xd = &x->e_mbd;
const MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
const struct macroblockd_plane *pd = &xd->plane[plane];
const BLOCK_SIZE bsize = mbmi->sb_type;
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif // CONFIG_CHROMA_SUB8X8
-
TXB_CTX txb_ctx;
get_txb_ctx(plane_bsize, tx_size, plane, a, l, &txb_ctx);
return av1_cost_coeffs_txb(cm, x, plane, blk_row, blk_col, block, tx_size,
@@ -2122,11 +2112,7 @@
}
#if CONFIG_CFL
if (plane == AOM_PLANE_Y && xd->cfl->store_y) {
-#if CONFIG_CHROMA_SUB8X8
assert(!is_inter_block(mbmi) || plane_bsize < BLOCK_8X8);
-#else
- assert(!is_inter_block(mbmi));
-#endif // CONFIG_CHROMA_SUB8X8
cfl_store_tx(xd, blk_row, blk_col, tx_size, plane_bsize);
}
#endif // CONFIG_CFL
diff --git a/av1/encoder/tokenize.c b/av1/encoder/tokenize.c
index 072c7f5..e4ea8ef 100644
--- a/av1/encoder/tokenize.c
+++ b/av1/encoder/tokenize.c
@@ -686,12 +686,8 @@
continue;
}
const struct macroblockd_plane *const pd = &xd->plane[plane];
-#if CONFIG_CHROMA_SUB8X8
const BLOCK_SIZE plane_bsize =
AOMMAX(BLOCK_4X4, get_plane_block_size(bsize, pd));
-#else
- const BLOCK_SIZE plane_bsize = get_plane_block_size(bsize, pd);
-#endif
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_wide_log2[0];
const TX_SIZE max_tx_size = get_vartx_max_txsize(
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake
index b75d935..4a8e027 100644
--- a/build/cmake/aom_config_defaults.cmake
+++ b/build/cmake/aom_config_defaults.cmake
@@ -113,7 +113,6 @@
set(CONFIG_CDEF 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_CDEF_SINGLEPASS 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_CFL 0 CACHE NUMBER "AV1 experiment flag.")
-set(CONFIG_CHROMA_SUB8X8 1 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_COEF_INTERLEAVE 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_COLORSPACE_HEADERS 0 CACHE NUMBER "AV1 experiment flag.")
set(CONFIG_COMPOUND_ROUND 0 CACHE NUMBER "AV1 experiment flag.")
diff --git a/configure b/configure
index 7e75870..3a26a4b 100755
--- a/configure
+++ b/configure
@@ -291,7 +291,6 @@
daala_tx16
daala_tx32
daala_tx64
- chroma_sub8x8
frame_size
ext_delta_q
adapt_scan
@@ -503,7 +502,6 @@
# Enable adopted experiments by default
soft_enable adopted_experiments
if enabled adopted_experiments; then
- soft_enable chroma_sub8x8
soft_enable rect_tx
soft_enable global_motion
soft_enable ext_tx
diff --git a/examples/inspect.c b/examples/inspect.c
index 087b943..dafcad8 100644
--- a/examples/inspect.c
+++ b/examples/inspect.c
@@ -141,9 +141,7 @@
ENUM(ALTREF_FRAME), LAST_ENUM };
const map_entry block_size_map[] = {
-#if CONFIG_CHROMA_SUB8X8
ENUM(BLOCK_2X2), ENUM(BLOCK_2X4), ENUM(BLOCK_4X2),
-#endif
ENUM(BLOCK_4X4), ENUM(BLOCK_4X8), ENUM(BLOCK_8X4),
ENUM(BLOCK_8X8), ENUM(BLOCK_8X16), ENUM(BLOCK_16X8),
ENUM(BLOCK_16X16), ENUM(BLOCK_16X32), ENUM(BLOCK_32X16),
