add new control flags for coding tools
add some extra command line parameters to enable / disable few
coding tools, including min/max partition size, ab partition
type, 1:4/4:1 partition type, flip/identity transform, one sided
compound.
also fix a bug in which previous smooth/paeth intra control is
only applied to luma plane, but not chroma plane.
Change-Id: I2112b5615f6367c1dac3b05565e7d666f50ef32e
diff --git a/aom/aomcx.h b/aom/aomcx.h
index fb79583..b00d6d2 100644
--- a/aom/aomcx.h
+++ b/aom/aomcx.h
@@ -728,6 +728,38 @@
*/
AV1E_SET_ENABLE_RECT_PARTITIONS,
+ /*!\brief Codec control function to enable/disable AB partitions.
+ *
+ * This will enable or disable usage of AB partitions. The default
+ * value is 1.
+ *
+ */
+ AV1E_SET_ENABLE_AB_PARTITIONS,
+
+ /*!\brief Codec control function to enable/disable 1:4 and 4:1 partitions.
+ *
+ * This will enable or disable usage of 1:4 and 4:1 partitions. The default
+ * value is 1.
+ *
+ */
+ AV1E_SET_ENABLE_1TO4_PARTITIONS,
+
+ /*!\brief Codec control function to set min partition size.
+ *
+ * This will set min partition size. The default value is 4.
+ * valid values are [4, 8, 16, 32, 64, 128]
+ *
+ */
+ AV1E_SET_MIN_PARTITION_SIZE,
+
+ /*!\brief Codec control function to set max partition size.
+ *
+ * This will set max partition size. The default value is 128.
+ * valid values are [4, 8, 16, 32, 64, 128]
+ *
+ */
+ AV1E_SET_MAX_PARTITION_SIZE,
+
/*!\brief Codec control function to turn on / off intra edge filter
* at sequence level.
*
@@ -757,6 +789,17 @@
*/
AV1E_SET_ENABLE_TX64,
+ /*!\brief Codec control function to turn on / off flip and identity
+ * transforms.
+ *
+ * This will enable or disable usage of flip and identity transform
+ * typess in any direction. The default value is 1. Including:
+ * FLIPADST_DCT, DCT_FLIPADST, FLIPADST_FLIPADST, ADST_FLIPADST,
+ * FLIPADST_ADST, IDTX, V_DCT, H_DCT, V_ADST, H_ADST, V_FLIPADST,
+ * H_FLIPADST
+ */
+ AV1E_SET_ENABLE_FLIP_IDTX,
+
/*!\brief Codec control function to turn on / off dist-wtd compound mode
* at sequence level.
*
@@ -803,6 +846,15 @@
*/
AV1E_SET_ENABLE_MASKED_COMP,
+ /*!\brief Codec control function to turn on / off one sided compound usage
+ * for a sequence.
+ *
+ * This will enable or disable usage of one sided compound
+ * modes. The default value is 1.
+ *
+ */
+ AV1E_SET_ENABLE_ONESIDED_COMP,
+
/*!\brief Codec control function to turn on / off interintra compound
* for a sequence.
*
@@ -1232,6 +1284,18 @@
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_RECT_PARTITIONS, int)
#define AOM_CTRL_AV1E_SET_ENABLE_RECT_PARTITIONS
+AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_AB_PARTITIONS, int)
+#define AOM_CTRL_AV1E_SET_ENABLE_AB_PARTITIONS
+
+AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_1TO4_PARTITIONS, int)
+#define AOM_CTRL_AV1E_SET_ENABLE_1TO4_PARTITIONS
+
+AOM_CTRL_USE_TYPE(AV1E_SET_MIN_PARTITION_SIZE, int)
+#define AOM_CTRL_AV1E_SET_MIN_PARTITION_SIZE
+
+AOM_CTRL_USE_TYPE(AV1E_SET_MAX_PARTITION_SIZE, int)
+#define AOM_CTRL_AV1E_SET_MAX_PARTITION_SIZE
+
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_INTRA_EDGE_FILTER, int)
#define AOM_CTRL_AV1E_SET_ENABLE_INTRA_EDGE_FILTER
@@ -1241,6 +1305,9 @@
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_TX64, int)
#define AOM_CTRL_AV1E_SET_ENABLE_TX64
+AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_FLIP_IDTX, int)
+#define AOM_CTRL_AV1E_SET_ENABLE_FLIP_IDTX
+
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_DIST_WTD_COMP, int)
#define AOM_CTRL_AV1E_SET_ENABLE_DIST_WTD_COMP
@@ -1256,6 +1323,9 @@
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_MASKED_COMP, int)
#define AOM_CTRL_AV1E_SET_ENABLE_MASKED_COMP
+AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_ONESIDED_COMP, int)
+#define AOM_CTRL_AV1E_SET_ENABLE_ONESIDED_COMP
+
AOM_CTRL_USE_TYPE(AV1E_SET_ENABLE_INTERINTRA_COMP, int)
#define AOM_CTRL_AV1E_SET_ENABLE_INTERINTRA_COMP
diff --git a/apps/aomenc.c b/apps/aomenc.c
index 00b398f..e2fee2f 100644
--- a/apps/aomenc.c
+++ b/apps/aomenc.c
@@ -440,6 +440,21 @@
ARG_DEF(NULL, "enable-rect-partitions", 1,
"Enable rectangular partitions "
"(0: false, 1: true (default))");
+static const arg_def_t enable_ab_partitions =
+ ARG_DEF(NULL, "enable-ab-partitions", 1,
+ "Enable ab partitions (0: false, 1: true (default))");
+static const arg_def_t enable_1to4_partitions =
+ ARG_DEF(NULL, "enable-1to4-partitions", 1,
+ "Enable 1:4 and 4:1 partitions "
+ "(0: false, 1: true (default))");
+static const arg_def_t min_partition_size =
+ ARG_DEF(NULL, "min-partition-size", 4,
+ "Set min partition size "
+ "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128)");
+static const arg_def_t max_partition_size =
+ ARG_DEF(NULL, "max-partition-size", 128,
+ "Set max partition size "
+ "(4:4x4, 8:8x8, 16:16x16, 32:32x32, 64:64x64, 128:128x128)");
static const arg_def_t enable_dual_filter =
ARG_DEF(NULL, "enable-dual-filter", 1,
"Enable dual filter "
@@ -455,6 +470,12 @@
static const arg_def_t enable_tx64 =
ARG_DEF(NULL, "enable-tx64", 1,
"Enable 64-pt transform (0: false, 1: true (default))");
+static const arg_def_t enable_flip_idtx =
+ ARG_DEF(NULL, "enable-flip-idtx", 1,
+ "Enable extended transform type (0: false, 1: true (default)) "
+ "including FLIPADST_DCT, DCT_FLIPADST, FLIPADST_FLIPADST, "
+ "ADST_FLIPADST, FLIPADST_ADST, IDTX, V_DCT, H_DCT, V_ADST, "
+ "H_ADST, V_FLIPADST, H_FLIPADST");
static const arg_def_t enable_dist_wtd_comp =
ARG_DEF(NULL, "enable-dist-wtd-comp", 1,
"Enable distance-weighted compound "
@@ -463,6 +484,10 @@
ARG_DEF(NULL, "enable-masked-comp", 1,
"Enable masked (wedge/diff-wtd) compound "
"(0: false, 1: true (default))");
+static const arg_def_t enable_onesided_comp =
+ ARG_DEF(NULL, "enable-onesided-comp", 1,
+ "Enable one sided compound "
+ "(0: false, 1: true (default))");
static const arg_def_t enable_interintra_comp =
ARG_DEF(NULL, "enable-interintra-comp", 1,
"Enable interintra compound "
@@ -764,12 +789,18 @@
&enable_cdef,
&enable_restoration,
&enable_rect_partitions,
+ &enable_ab_partitions,
+ &enable_1to4_partitions,
+ &min_partition_size,
+ &max_partition_size,
&enable_dual_filter,
&enable_intra_edge_filter,
&enable_order_hint,
&enable_tx64,
+ &enable_flip_idtx,
&enable_dist_wtd_comp,
&enable_masked_comp,
+ &enable_onesided_comp,
&enable_interintra_comp,
&enable_smooth_interintra,
&enable_diff_wtd_comp,
@@ -856,12 +887,18 @@
AV1E_SET_ENABLE_CDEF,
AV1E_SET_ENABLE_RESTORATION,
AV1E_SET_ENABLE_RECT_PARTITIONS,
+ AV1E_SET_ENABLE_AB_PARTITIONS,
+ AV1E_SET_ENABLE_1TO4_PARTITIONS,
+ AV1E_SET_MIN_PARTITION_SIZE,
+ AV1E_SET_MAX_PARTITION_SIZE,
AV1E_SET_ENABLE_DUAL_FILTER,
AV1E_SET_ENABLE_INTRA_EDGE_FILTER,
AV1E_SET_ENABLE_ORDER_HINT,
AV1E_SET_ENABLE_TX64,
+ AV1E_SET_ENABLE_FLIP_IDTX,
AV1E_SET_ENABLE_DIST_WTD_COMP,
AV1E_SET_ENABLE_MASKED_COMP,
+ AV1E_SET_ENABLE_ONESIDED_COMP,
AV1E_SET_ENABLE_INTERINTRA_COMP,
AV1E_SET_ENABLE_SMOOTH_INTERINTRA,
AV1E_SET_ENABLE_DIFF_WTD_COMP,
diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index a453588..d765242 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -92,15 +92,21 @@
unsigned int motion_vector_unit_test;
unsigned int cdf_update_mode;
int enable_rect_partitions; // enable rectangular partitions for sequence
+ int enable_ab_partitions; // enable AB partitions for sequence
+ int enable_1to4_partitions; // enable 1:4 and 4:1 partitions for sequence
+ int min_partition_size; // min partition size [4,8,16,32,64,128]
+ int max_partition_size; // max partition size [4,8,16,32,64,128]
int enable_intra_edge_filter; // enable intra-edge filter for sequence
int enable_order_hint; // enable order hint for sequence
int enable_tx64; // enable 64-pt transform usage for sequence
+ int enable_flip_idtx; // enable flip and identity transform types
int enable_dist_wtd_comp; // enable dist wtd compound for sequence
int max_reference_frames; // maximum number of references per frame
int enable_reduced_reference_set; // enable reduced set of references
int enable_ref_frame_mvs; // sequence level
int allow_ref_frame_mvs; // frame level
int enable_masked_comp; // enable masked compound for sequence
+ int enable_onesided_comp; // enable one sided compound for sequence
int enable_interintra_comp; // enable interintra compound for sequence
int enable_smooth_interintra; // enable smooth interintra mode usage
int enable_diff_wtd_comp; // enable diff-wtd compound usage
@@ -198,15 +204,21 @@
0, // motion_vector_unit_test
1, // CDF update mode
1, // enable rectangular partitions
+ 1, // enable ab shape partitions
+ 1, // enable 1:4 and 4:1 partitions
+ 4, // min_partition_size
+ 128, // max_partition_size
1, // enable intra edge filter
1, // frame order hint
1, // enable 64-pt transform usage
+ 1, // enable flip and identity transform
1, // dist-wtd compound
7, // max_reference_frames
0, // enable_reduced_reference_set
1, // enable_ref_frame_mvs sequence level
1, // allow ref_frame_mvs frame level
1, // enable masked compound at sequence level
+ 1, // enable one sided compound at sequence level
1, // enable interintra compound at sequence level
1, // enable smooth interintra mode
1, // enable difference-weighted compound
@@ -454,6 +466,10 @@
RANGE_CHECK(extra_cfg, coeff_cost_upd_freq, 0, 2);
RANGE_CHECK(extra_cfg, mode_cost_upd_freq, 0, 2);
+ RANGE_CHECK(extra_cfg, min_partition_size, 4, 128);
+ RANGE_CHECK(extra_cfg, max_partition_size, 4, 128);
+ RANGE_CHECK_HI(extra_cfg, min_partition_size, extra_cfg->max_partition_size);
+
for (int i = 0; i < MAX_NUM_OPERATING_POINTS; ++i) {
if (!is_valid_seq_level_idx(extra_cfg->target_seq_level_idx[i]))
ERROR("Target sequence level index is invalid");
@@ -745,14 +761,20 @@
oxcf->full_still_picture_hdr = cfg->full_still_picture_hdr;
oxcf->enable_dual_filter = extra_cfg->enable_dual_filter;
oxcf->enable_rect_partitions = extra_cfg->enable_rect_partitions;
+ oxcf->enable_ab_partitions = extra_cfg->enable_ab_partitions;
+ oxcf->enable_1to4_partitions = extra_cfg->enable_1to4_partitions;
+ oxcf->min_partition_size = extra_cfg->min_partition_size;
+ oxcf->max_partition_size = extra_cfg->max_partition_size;
oxcf->enable_intra_edge_filter = extra_cfg->enable_intra_edge_filter;
oxcf->enable_tx64 = extra_cfg->enable_tx64;
+ oxcf->enable_flip_idtx = extra_cfg->enable_flip_idtx;
oxcf->enable_order_hint = extra_cfg->enable_order_hint;
oxcf->enable_dist_wtd_comp =
extra_cfg->enable_dist_wtd_comp & extra_cfg->enable_order_hint;
oxcf->max_reference_frames = extra_cfg->max_reference_frames;
oxcf->enable_reduced_reference_set = extra_cfg->enable_reduced_reference_set;
oxcf->enable_masked_comp = extra_cfg->enable_masked_comp;
+ oxcf->enable_onesided_comp = extra_cfg->enable_onesided_comp;
oxcf->enable_diff_wtd_comp =
extra_cfg->enable_masked_comp & extra_cfg->enable_diff_wtd_comp;
oxcf->enable_interinter_wedge =
@@ -1124,6 +1146,35 @@
return update_extra_cfg(ctx, &extra_cfg);
}
+static aom_codec_err_t ctrl_set_enable_ab_partitions(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.enable_ab_partitions = CAST(AV1E_SET_ENABLE_AB_PARTITIONS, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
+static aom_codec_err_t ctrl_set_enable_1to4_partitions(
+ aom_codec_alg_priv_t *ctx, va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.enable_1to4_partitions =
+ CAST(AV1E_SET_ENABLE_1TO4_PARTITIONS, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
+static aom_codec_err_t ctrl_set_min_partition_size(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.min_partition_size = CAST(AV1E_SET_MIN_PARTITION_SIZE, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
+static aom_codec_err_t ctrl_set_max_partition_size(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.max_partition_size = CAST(AV1E_SET_MAX_PARTITION_SIZE, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
static aom_codec_err_t ctrl_set_enable_intra_edge_filter(
aom_codec_alg_priv_t *ctx, va_list args) {
struct av1_extracfg extra_cfg = ctx->extra_cfg;
@@ -1146,6 +1197,13 @@
return update_extra_cfg(ctx, &extra_cfg);
}
+static aom_codec_err_t ctrl_set_enable_flip_idtx(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.enable_flip_idtx = CAST(AV1E_SET_ENABLE_FLIP_IDTX, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
static aom_codec_err_t ctrl_set_enable_dist_wtd_comp(aom_codec_alg_priv_t *ctx,
va_list args) {
struct av1_extracfg extra_cfg = ctx->extra_cfg;
@@ -1189,6 +1247,13 @@
return update_extra_cfg(ctx, &extra_cfg);
}
+static aom_codec_err_t ctrl_set_enable_onesided_comp(aom_codec_alg_priv_t *ctx,
+ va_list args) {
+ struct av1_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.enable_onesided_comp = CAST(AV1E_SET_ENABLE_ONESIDED_COMP, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
static aom_codec_err_t ctrl_set_enable_interintra_comp(
aom_codec_alg_priv_t *ctx, va_list args) {
struct av1_extracfg extra_cfg = ctx->extra_cfg;
@@ -2105,16 +2170,22 @@
{ AV1E_SET_ERROR_RESILIENT_MODE, ctrl_set_error_resilient_mode },
{ AV1E_SET_S_FRAME_MODE, ctrl_set_s_frame_mode },
{ AV1E_SET_ENABLE_RECT_PARTITIONS, ctrl_set_enable_rect_partitions },
+ { AV1E_SET_ENABLE_AB_PARTITIONS, ctrl_set_enable_ab_partitions },
+ { AV1E_SET_ENABLE_1TO4_PARTITIONS, ctrl_set_enable_1to4_partitions },
+ { AV1E_SET_MIN_PARTITION_SIZE, ctrl_set_min_partition_size },
+ { AV1E_SET_MAX_PARTITION_SIZE, ctrl_set_max_partition_size },
{ AV1E_SET_ENABLE_DUAL_FILTER, ctrl_set_enable_dual_filter },
{ AV1E_SET_ENABLE_INTRA_EDGE_FILTER, ctrl_set_enable_intra_edge_filter },
{ AV1E_SET_ENABLE_ORDER_HINT, ctrl_set_enable_order_hint },
{ AV1E_SET_ENABLE_TX64, ctrl_set_enable_tx64 },
+ { AV1E_SET_ENABLE_FLIP_IDTX, ctrl_set_enable_flip_idtx },
{ AV1E_SET_ENABLE_DIST_WTD_COMP, ctrl_set_enable_dist_wtd_comp },
{ AV1E_SET_MAX_REFERENCE_FRAMES, ctrl_set_max_reference_frames },
{ AV1E_SET_REDUCED_REFERENCE_SET, ctrl_set_enable_reduced_reference_set },
{ AV1E_SET_ENABLE_REF_FRAME_MVS, ctrl_set_enable_ref_frame_mvs },
{ AV1E_SET_ALLOW_REF_FRAME_MVS, ctrl_set_allow_ref_frame_mvs },
{ AV1E_SET_ENABLE_MASKED_COMP, ctrl_set_enable_masked_comp },
+ { AV1E_SET_ENABLE_ONESIDED_COMP, ctrl_set_enable_onesided_comp },
{ AV1E_SET_ENABLE_INTERINTRA_COMP, ctrl_set_enable_interintra_comp },
{ AV1E_SET_ENABLE_SMOOTH_INTERINTRA, ctrl_set_enable_smooth_interintra },
{ AV1E_SET_ENABLE_DIFF_WTD_COMP, ctrl_set_enable_diff_wtd_comp },
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 2bff420..aa21fb6 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -3961,16 +3961,6 @@
int vert_ctx_is_ready = 0;
BLOCK_SIZE bsize2 = get_partition_subsize(bsize, PARTITION_SPLIT);
- // Max and min square partition levels are defined as the partition nodes that
- // the recursive function rd_pick_partition() can reach. To implement this:
- // only PARTITION_SPLIT is NOT allowed if the current node equals min_sq_part,
- // only PARTITION_SPLIT is allowed if the current node exceeds max_sq_part.
- assert(block_size_wide[min_sq_part] == block_size_high[min_sq_part]);
- assert(block_size_wide[max_sq_part] == block_size_high[max_sq_part]);
- assert(min_sq_part <= max_sq_part);
- int is_eq_min_sq_part = bsize == min_sq_part;
- int is_gt_max_sq_part = bsize > max_sq_part;
-
if (best_rd < 0) {
pc_tree->none.rdcost = INT64_MAX;
pc_tree->none.skip = 0;
@@ -4147,8 +4137,42 @@
&simple_motion_features_are_valid);
}
+ // Max and min square partition levels are defined as the partition nodes that
+ // the recursive function rd_pick_partition() can reach. To implement this:
+ // only PARTITION_NONE is allowed if the current node equals min_sq_part,
+ // only PARTITION_SPLIT is allowed if the current node exceeds max_sq_part.
+ assert(block_size_wide[min_sq_part] == block_size_high[min_sq_part]);
+ assert(block_size_wide[max_sq_part] == block_size_high[max_sq_part]);
+ assert(min_sq_part <= max_sq_part);
+ assert(block_size_wide[bsize] == block_size_high[bsize]);
+ const int max_partition_size = block_size_wide[max_sq_part];
+ const int min_partition_size = block_size_wide[min_sq_part];
+ const int blksize = block_size_wide[bsize];
+ assert(min_partition_size <= max_partition_size);
+ const int is_le_min_sq_part = blksize <= min_partition_size;
+ const int is_gt_max_sq_part = blksize > max_partition_size;
+ if (is_gt_max_sq_part) {
+ // If current block size is larger than max, only allow split.
+ partition_none_allowed = 0;
+ partition_horz_allowed = 0;
+ partition_vert_allowed = 0;
+ do_square_split = 1;
+ } else if (is_le_min_sq_part) {
+ // If current block size is less or equal to min, only allow none if valid
+ // block large enough; only allow split otherwise.
+ partition_horz_allowed = 0;
+ partition_vert_allowed = 0;
+ // only disable square split when current block is not at the picture
+ // boundary. otherwise, inherit the square split flag from previous logic
+ if (has_rows && has_cols) do_square_split = 0;
+ partition_none_allowed = !do_square_split;
+ }
+ do_square_split &= partition_cost[PARTITION_SPLIT] != INT_MAX;
+
BEGIN_PARTITION_SEARCH:
if (x->must_find_valid_partition) {
+ do_square_split =
+ bsize_at_least_8x8 && partition_cost[PARTITION_SPLIT] != INT_MAX;
partition_none_allowed = has_rows && has_cols;
partition_horz_allowed = has_cols && yss <= xss && bsize_at_least_8x8 &&
cpi->oxcf.enable_rect_partitions;
@@ -4175,7 +4199,7 @@
#endif
// PARTITION_NONE
- if (is_eq_min_sq_part) partition_none_allowed = 1;
+ if (is_le_min_sq_part && has_rows && has_cols) partition_none_allowed = 1;
if (!terminate_partition_search && partition_none_allowed &&
!is_gt_max_sq_part) {
int pt_cost = 0;
@@ -4279,7 +4303,6 @@
if (cpi->sf.adaptive_motion_search) store_pred_mv(x, ctx_none);
// PARTITION_SPLIT
- if (is_eq_min_sq_part) do_square_split = 0;
if ((!terminate_partition_search && do_square_split) || is_gt_max_sq_part) {
av1_init_rd_stats(&sum_rdc);
subsize = get_partition_subsize(bsize, PARTITION_SPLIT);
@@ -4571,8 +4594,10 @@
// The standard AB partitions are allowed whenever ext-partition-types are
// allowed
- int horzab_partition_allowed = ext_partition_allowed;
- int vertab_partition_allowed = ext_partition_allowed;
+ int horzab_partition_allowed =
+ ext_partition_allowed & cpi->oxcf.enable_ab_partitions;
+ int vertab_partition_allowed =
+ ext_partition_allowed & cpi->oxcf.enable_ab_partitions;
#if CONFIG_DIST_8X8
if (x->using_dist_8x8) {
@@ -4658,6 +4683,11 @@
&verta_partition_allowed, &vertb_partition_allowed);
}
+ horza_partition_allowed &= cpi->oxcf.enable_ab_partitions;
+ horzb_partition_allowed &= cpi->oxcf.enable_ab_partitions;
+ verta_partition_allowed &= cpi->oxcf.enable_ab_partitions;
+ vertb_partition_allowed &= cpi->oxcf.enable_ab_partitions;
+
// PARTITION_HORZ_A
if (!terminate_partition_search && partition_horz_allowed &&
horza_partition_allowed && !is_gt_max_sq_part) {
@@ -4832,8 +4862,10 @@
// PARTITION_VERT_4 for this block. This is almost the same as
// ext_partition_allowed, except that we don't allow 128x32 or 32x128
// blocks, so we require that bsize is not BLOCK_128X128.
- const int partition4_allowed =
- ext_partition_allowed && bsize != BLOCK_128X128;
+ const int partition4_allowed = cpi->oxcf.enable_1to4_partitions &&
+ ext_partition_allowed &&
+ bsize != BLOCK_128X128;
+
int partition_horz4_allowed = partition4_allowed && partition_horz_allowed;
int partition_vert4_allowed = partition4_allowed && partition_vert_allowed;
if (cpi->sf.prune_ext_partition_types_search_level == 2) {
@@ -4865,6 +4897,11 @@
}
#endif
+ if (blksize < (min_partition_size << 2)) {
+ partition_horz4_allowed = 0;
+ partition_vert4_allowed = 0;
+ }
+
// PARTITION_HORZ_4
assert(IMPLIES(!cpi->oxcf.enable_rect_partitions, !partition_horz4_allowed));
if (!terminate_partition_search && partition_horz4_allowed && has_rows &&
@@ -5628,16 +5665,41 @@
#if CONFIG_COLLECT_COMPONENT_TIMING
start_timing(cpi, rd_pick_partition_time);
#endif
- BLOCK_SIZE max_sq_size = sb_size;
+ BLOCK_SIZE max_sq_size = BLOCK_128X128;
+ switch (cpi->oxcf.max_partition_size) {
+ case 4: max_sq_size = BLOCK_4X4; break;
+ case 8: max_sq_size = BLOCK_8X8; break;
+ case 16: max_sq_size = BLOCK_16X16; break;
+ case 32: max_sq_size = BLOCK_32X32; break;
+ case 64: max_sq_size = BLOCK_64X64; break;
+ case 128: max_sq_size = BLOCK_128X128; break;
+ default: assert(0); break;
+ }
+ max_sq_size = AOMMIN(max_sq_size, sb_size);
+
+ BLOCK_SIZE min_sq_size = BLOCK_4X4;
+ switch (cpi->oxcf.min_partition_size) {
+ case 4: min_sq_size = BLOCK_4X4; break;
+ case 8: min_sq_size = BLOCK_8X8; break;
+ case 16: min_sq_size = BLOCK_16X16; break;
+ case 32: min_sq_size = BLOCK_32X32; break;
+ case 64: min_sq_size = BLOCK_64X64; break;
+ case 128: min_sq_size = BLOCK_128X128; break;
+ default: assert(0); break;
+ }
+
if (use_auto_max_partition(cpi, sb_size, mi_row, mi_col)) {
float features[FEATURE_SIZE_MAX_MIN_PART_PRED] = { 0.0f };
get_max_min_partition_features(cpi, x, mi_row, mi_col, features);
- max_sq_size = AOMMIN(predict_max_partition(features), sb_size);
+ max_sq_size = AOMMIN(predict_max_partition(features), max_sq_size);
}
+
+ min_sq_size = AOMMIN(min_sq_size, max_sq_size);
+
rd_pick_partition(cpi, td, tile_data, tp, mi_row, mi_col, sb_size,
- max_sq_size, BLOCK_4X4, &dummy_rdc, INT64_MAX, pc_root,
- NULL);
+ max_sq_size, min_sq_size, &dummy_rdc, INT64_MAX,
+ pc_root, NULL);
#if CONFIG_COLLECT_COMPONENT_TIMING
end_timing(cpi, rd_pick_partition_time);
#endif
@@ -6093,6 +6155,8 @@
cm->allow_intrabc = 0;
}
+ cm->allow_intrabc &= (cpi->oxcf.enable_intrabc);
+
if (cpi->oxcf.pass != 1 && av1_use_hash_me(cm)) {
// add to hash table
const int pic_width = cpi->source->y_crop_width;
diff --git a/av1/encoder/encoder.h b/av1/encoder/encoder.h
index 8b64998..537fdef 100644
--- a/av1/encoder/encoder.h
+++ b/av1/encoder/encoder.h
@@ -350,8 +350,13 @@
unsigned int motion_vector_unit_test;
const cfg_options_t *cfg;
int enable_rect_partitions;
+ int enable_ab_partitions;
+ int enable_1to4_partitions;
+ int min_partition_size;
+ int max_partition_size;
int enable_intra_edge_filter;
int enable_tx64;
+ int enable_flip_idtx;
int enable_order_hint;
int enable_dist_wtd_comp;
int enable_ref_frame_mvs;
@@ -359,6 +364,7 @@
int enable_reduced_reference_set;
unsigned int allow_ref_frame_mvs;
int enable_masked_comp;
+ int enable_onesided_comp;
int enable_interintra_comp;
int enable_smooth_interintra;
int enable_diff_wtd_comp;
diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index b9229bb..4c3413b 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -3190,6 +3190,13 @@
}
}
}
+
+ if (cpi->oxcf.enable_flip_idtx == 0) {
+ for (TX_TYPE tx_type = FLIPADST_DCT; tx_type <= H_FLIPADST; ++tx_type) {
+ allowed_tx_mask &= ~(1 << tx_type);
+ }
+ }
+
// Need to have at least one transform type allowed.
if (allowed_tx_mask == 0) {
txk_start = txk_end = (plane ? uv_tx_type : DCT_DCT);
@@ -6436,6 +6443,11 @@
if (!(cpi->sf.intra_uv_mode_mask[txsize_sqr_up_map[max_tx_size]] &
(1 << mode)))
continue;
+ if (!cpi->oxcf.enable_smooth_intra && mode >= UV_SMOOTH_PRED &&
+ mode <= UV_SMOOTH_H_PRED)
+ continue;
+
+ if (!cpi->oxcf.enable_paeth_intra && mode == UV_PAETH_PRED) continue;
mbmi->uv_mode = mode;
int cfl_alpha_rate = 0;
@@ -10870,6 +10882,10 @@
return;
}
+ if (!cpi->oxcf.enable_onesided_comp && cpi->all_one_sided_refs) {
+ return;
+ }
+
mbmi->mode = this_mode;
mbmi->uv_mode = UV_DC_PRED;
mbmi->ref_frame[0] = ref_frame;
@@ -11944,6 +11960,16 @@
if (skip_motion_mode) {
return 2;
}
+
+ if (!cpi->oxcf.enable_global_motion &&
+ (this_mode == GLOBALMV || this_mode == GLOBAL_GLOBALMV)) {
+ return 1;
+ }
+
+ if (!cpi->oxcf.enable_onesided_comp && comp_pred && cpi->all_one_sided_refs) {
+ return 1;
+ }
+
return 0;
}
@@ -11979,6 +12005,7 @@
assert(mbmi->ref_frame[0] == INTRA_FRAME);
PALETTE_MODE_INFO *const pmi = &mbmi->palette_mode_info;
const int try_palette =
+ cpi->oxcf.enable_palette &&
av1_allow_palette(cm->allow_screen_content_tools, mbmi->sb_type);
const int *const intra_mode_cost = x->mbmode_cost[size_group_lookup[bsize]];
const int intra_cost_penalty = av1_get_intra_cost_penalty(
